/* -----------------------------------------------------------------------------

The copyright in this software is being made available under the Clear BSD

License, included below. No patent rights, trademark rights and/or 

other Intellectual Property Rights other than the copyrights concerning 

the Software are granted under this license.

The Clear BSD License

Copyright (c) 2019-2026, Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V. & The VVenC Authors.

All rights reserved.

Redistribution and use in source and binary forms, with or without modification,

are permitted (subject to the limitations in the disclaimer below) provided that

the following conditions are met:

     * Redistributions of source code must retain the above copyright notice,

     this list of conditions and the following disclaimer.

     * Redistributions in binary form must reproduce the above copyright

     notice, this list of conditions and the following disclaimer in the

     documentation and/or other materials provided with the distribution.

     * Neither the name of the copyright holder nor the names of its

     contributors may be used to endorse or promote products derived from this

     software without specific prior written permission.

NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY

THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND

CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A

PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR

CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR

BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER

IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

POSSIBILITY OF SUCH DAMAGE.

------------------------------------------------------------------------------------------- */

/** \file     Prediction.cpp

    \brief    prediction class

*/

#include "IntraPrediction.h"

#include "Unit.h"

#include "UnitTools.h"

#include "Rom.h"

#include "InterpolationFilter.h"

#include "dtrace_next.h"

#include <memory.h>

//! \ingroup CommonLib

//! \{

namespace vvenc {

// ====================================================================================================================

// Tables

// ====================================================================================================================

const uint8_t IntraPrediction::m_aucIntraFilter[MAX_INTRA_FILTER_DEPTHS] =

{

  24, //   1xn

  24, //   2xn

  24, //   4xn

  14, //   8xn

  2,  //  16xn

  0,  //  32xn

  0,  //  64xn

  0   // 128xn

};

//NOTE: Bit-Limit - 24-bit source

void xPredIntraPlanar_Core( PelBuf& pDst, const CPelBuf& pSrc )

{

  const uint32_t width  = pDst.width;

  const uint32_t height = pDst.height;

  const uint32_t log2W  = Log2(width);

  const uint32_t log2H  = Log2(height);

  int leftColumn[MAX_TB_SIZEY + 1], topRow[MAX_TB_SIZEY + 1], bottomRow[MAX_TB_SIZEY], rightColumn[MAX_TB_SIZEY];

  const uint32_t offset = 1 << (log2W + log2H);

  // Get left and above reference column and row

  for( int k = 0; k < width + 1; k++ )

  {

    topRow[k] = pSrc.at( k + 1, 0 );

  }

  for( int k = 0; k < height + 1; k++ )

  {

    leftColumn[k] = pSrc.at( k + 1, 1 );

  }

  // Prepare intermediate variables used in interpolation

  int bottomLeft = leftColumn[height];

  int topRight = topRow[width];

  // with some optimizations gcc-8 gives spurious "-Wmaybe-uninitialized" warnings here (says leftColumn or topRow would be uninitialized here)

  GCC_WARNING_DISABLE_maybe_uninitialized

  for( int k = 0; k < width; k++ )

  {

    bottomRow[k] = bottomLeft - topRow[k];

    topRow[k]    = topRow[k] << log2H;

  }

  for( int k = 0; k < height; k++ )

  {

    rightColumn[k] = topRight - leftColumn[k];

    leftColumn[k]  = leftColumn[k] << log2W;

  }

  GCC_WARNING_RESET

  const uint32_t finalShift = 1 + log2W + log2H;

  const uint32_t stride     = pDst.stride;

  Pel*       pred       = pDst.buf;

  for( int y = 0; y < height; y++, pred += stride )

  {

    int horPred = leftColumn[y];

    for( int x = 0; x < width; x++ )

    {

      horPred += rightColumn[y];

      topRow[x] += bottomRow[x];

      int vertPred = topRow[x];

      pred[x]      = ( ( horPred << log2H ) + ( vertPred << log2W ) + offset ) >> finalShift;

    }

  }

}

void  IntraPredSampleFilter_Core(PelBuf& dstBuf, const CPelBuf& pSrc)

{

  const int iWidth  = dstBuf.width;

  const int iHeight = dstBuf.height;

  const int scale = ((Log2(iWidth*iHeight) - 2) >> 2);

  CHECK(scale < 0 || scale > 31, "PDPC: scale < 0 || scale > 31");

  for (int y = 0; y < iHeight; y++)

  {

    const int wT   = 32 >> std::min(31, ((y << 1) >> scale));

    const Pel left = pSrc.at(y + 1, 1);

    for (int x = 0; x < iWidth; x++)

    {

      const int wL    = 32 >> std::min(31, ((x << 1) >> scale));

      const Pel top   = pSrc.at(x + 1, 0);

      const Pel val   = dstBuf.at(x, y);

      dstBuf.at(x, y) = val + ((wL * (left - val) + wT * (top - val) + 32) >> 6);

    }

  }

}

void IntraHorVerPDPC_Core(Pel* pDsty,const int dstStride,Pel* refSide,const int width,const int height,int scale,const Pel* refMain, const ClpRng& clpRng)

{

  const Pel topLeft = refMain[0];

  for( int y = 0; y < height; y++ )

  {

    memcpy(pDsty,&refMain[1],width*sizeof(Pel));

    const Pel left    = refSide[1 + y];

    for (int x = 0; x < std::min(3 << scale, width); x++)

    {

      const int wL  = 32 >> (2 * x >> scale);

      const Pel val = pDsty[x];

      pDsty[x]      = ClipPel(val + ((wL * (left - topLeft) + 32) >> 6), clpRng);

    }

    pDsty += dstStride;

  }

}

void IntraAnglePDPC_Core(Pel* pDsty,const int dstStride,Pel* refSide,const int width,const int height,int scale,int invAngle)

{

  for (int y = 0; y<height; y++, pDsty += dstStride)

  {

    int       invAngleSum = 256;

    for (int x = 0; x < std::min(3 << scale, width); x++)

    {

      invAngleSum += invAngle;

      int wL   = 32 >> (2 * x >> scale);

      Pel left = refSide[y + (invAngleSum >> 9) + 1];

      pDsty[x] = pDsty[x] + ((wL * (left - pDsty[x]) + 32) >> 6);

    }

  }

}

void IntraPredAngleLuma_Core(Pel* pDstBuf,const ptrdiff_t dstStride,Pel* refMain,int width,int height,int deltaPos,int intraPredAngle,const TFilterCoeff *ff_unused,const bool useCubicFilter,const ClpRng& clpRng)

{

  for (int y = 0; y<height; y++ )

  {

    const int deltaInt   = deltaPos >> 5;

    const int deltaFract = deltaPos & ( 32 - 1 );

    const TFilterCoeff      intraSmoothingFilter[4] = {TFilterCoeff(16 - (deltaFract >> 1)), TFilterCoeff(32 - (deltaFract >> 1)), TFilterCoeff(16 + (deltaFract >> 1)), TFilterCoeff(deltaFract >> 1)};

    const TFilterCoeff *f = useCubicFilter ? InterpolationFilter::getChromaFilterTable(deltaFract) : intraSmoothingFilter;

    Pel p[4];

    int refMainIndex = deltaInt + 1;

 //   const TFilterCoeff *f = &ff[deltaFract << 2];

    for( int x = 0; x < width; x++, refMainIndex++ )

    {

      p[0] = refMain[refMainIndex - 1];

      p[1] = refMain[refMainIndex    ];

      p[2] = refMain[refMainIndex + 1];

      p[3] = refMain[refMainIndex + 2];

      pDstBuf[y*dstStride + x] = static_cast<Pel>((static_cast<int>(f[0] * p[0]) + static_cast<int>(f[1] * p[1]) + static_cast<int>(f[2] * p[2]) + static_cast<int>(f[3] * p[3]) + 32) >> 6);

      if( useCubicFilter ) // only cubic filter has negative coefficients and requires clipping

      {

        pDstBuf[y*dstStride + x] = ClipPel( pDstBuf[y*dstStride + x], clpRng );

      }

    }

    deltaPos += intraPredAngle;

  }

}

void IntraPredAngleChroma_Core(Pel* pDstBuf,const ptrdiff_t dstStride,int16_t* pBorder,int width,int height,int deltaPos,int intraPredAngle)

{

  for (int y = 0; y<height; y++)

  {

    const int deltaInt   = deltaPos >> 5;

    const int deltaFract = deltaPos & (32 - 1);

    // Do linear filtering

    const Pel* pRM = pBorder + deltaInt + 1;

    int lastRefMainPel = *pRM++;

    for( int x = 0; x < width; pRM++, x++ )

    {

      int thisRefMainPel = *pRM;

      pDstBuf[x + 0] = ( Pel ) ( ( ( 32 - deltaFract )*lastRefMainPel + deltaFract*thisRefMainPel + 16 ) >> 5 );

      lastRefMainPel = thisRefMainPel;

    }

    deltaPos += intraPredAngle;

    pDstBuf += dstStride;

  }

}

// ====================================================================================================================

// Constructor / destructor / initialize

// ====================================================================================================================

static void IntraFilterRefSamples_Core( const Pel* src, Pel* dst, const int length )

{

  for( int i = 1; i < length; i++ )

  {

    dst[i] = ( src[i - 1] + 2 * src[i] + src[i + 1] + 2 ) >> 2;

  }

}

static void LMLumaDownsample420_Core( const Pel* src, const ptrdiff_t srcStride, Pel* dst, const ptrdiff_t dstStride, const int width, const int height, const bool leftAvailable )

{

  for( int y = 0; y < height; y++, src += 2 * srcStride, dst += dstStride )

  {

    for( int i = 0; i < width; i++ )

    {

      const int left = ( i == 0 && !leftAvailable ) ? 0 : 1;

      int s = 4;

      s += src[2 * i] * 2;

      s += src[2 * i + 1];

      s += src[2 * i - left];

      s += src[2 * i + srcStride] * 2;

      s += src[2 * i + 1 + srcStride];

      s += src[2 * i + srcStride - left];

      dst[i] = s >> 3;

    }

  }

}

IntraPrediction::IntraPrediction( bool enableOpt )

:  m_pMdlmTemp( nullptr )

,  m_currChromaFormat( NUM_CHROMA_FORMAT )

{

  IntraPredAngleLuma    = IntraPredAngleLuma_Core;

  IntraPredAngleChroma  = IntraPredAngleChroma_Core;

  IntraAnglePDPC        = IntraAnglePDPC_Core;

  IntraHorVerPDPC       = IntraHorVerPDPC_Core;

  IntraPredSampleFilter = IntraPredSampleFilter_Core;

  xPredIntraPlanar      = xPredIntraPlanar_Core;

  LMLumaDownsample420   = LMLumaDownsample420_Core;

  IntraFilterRefSamples = IntraFilterRefSamples_Core;

#if ENABLE_SIMD_OPT_INTRAPRED

  if( enableOpt )

  {

#if defined( TARGET_SIMD_X86 )

    initIntraPredictionX86();

#endif

#if defined( TARGET_SIMD_ARM )

    initIntraPredictionARM();

#endif

  }

#endif // ENABLE_SIMD_OPT_INTRAPRED

}

IntraPrediction::~IntraPrediction()

{

  destroy();

}

void IntraPrediction::destroy()

{

  delete[] m_pMdlmTemp;

  m_pMdlmTemp = nullptr;

}

void IntraPrediction::init(ChromaFormat chromaFormatIDC, const unsigned bitDepthY)

{

  m_currChromaFormat = chromaFormatIDC;

  if (m_pMdlmTemp == nullptr)

  {

    m_pMdlmTemp = new Pel[(2 * MAX_TB_SIZEY + 1)*(2 * MAX_TB_SIZEY + 1)];//MDLM will use top-above and left-below samples.

  }

}

// ====================================================================================================================

// Public member functions

// ====================================================================================================================

// Function for calculating DC value of the reference samples used in Intra prediction

//NOTE: Bit-Limit - 25-bit source

Pel IntraPrediction::xGetPredValDc( const CPelBuf& pSrc, const Size& dstSize )

{

  CHECK( dstSize.width == 0 || dstSize.height == 0, "Empty area provided" );

  int idx, sum = 0;

  Pel dcVal;

  const int width  = dstSize.width;

  const int height = dstSize.height;

  const auto denom     = (width == height) ? (width << 1) : std::max(width,height);

  const auto divShift  = Log2(denom);

  const auto divOffset = (denom >> 1);

  const int off = m_ipaParam.multiRefIndex + 1;

  if ( width >= height )

  {

    for( idx = 0; idx < width; idx++ )

    {

      sum += pSrc.at( off + idx, 0);

    }

  }

  if ( width <= height )

  {

    for( idx = 0; idx < height; idx++ )

    {

      sum += pSrc.at( off + idx, 1);

    }

  }

  dcVal = (sum + divOffset) >> divShift;

  return dcVal;

}

int IntraPrediction::getWideAngle( int width, int height, int predMode )

{

  if ( predMode > DC_IDX && predMode <= VDIA_IDX )

  {

    int modeShift[] = { 0, 6, 10, 12, 14, 15 };

    int deltaSize = abs(Log2(width) - Log2(height));

    if (width > height && predMode < 2 + modeShift[deltaSize])

    {

      predMode += (VDIA_IDX - 1);

    }

    else if (height > width && predMode > VDIA_IDX - modeShift[deltaSize])

    {

      predMode -= (VDIA_IDX - 1);

    }

  }

  return predMode;

}

void IntraPrediction::predIntraAng( const ComponentID compId, PelBuf& piPred, const CodingUnit& cu)

{

  const ComponentID    compID       = compId;

  const ChannelType    channelType  = toChannelType( compID );

  const uint32_t       uiDirMode = cu.bdpcmM[channelType] ? BDPCM_IDX : CU::getFinalIntraMode(cu, channelType);

  CHECK( Log2(piPred.width) > 7, "Size not allowed" );

//  const int multiRefIdx = m_ipaParam.multiRefIndex;

  const int srcStride  = m_refBufferStride[compID];

  const int srcHStride = 2;

  const CPelBuf& srcBuf = CPelBuf(getPredictorPtr(compID), srcStride, srcHStride);

  const ClpRng& clpRng(cu.cs->slice->clpRngs[compID]);

  switch (uiDirMode)

  {

    case(PLANAR_IDX): xPredIntraPlanar(piPred, srcBuf); break;

    case(DC_IDX):     xPredIntraDc    ( piPred, srcBuf ); break;

    case(BDPCM_IDX):  xPredIntraBDPCM ( piPred, srcBuf, cu.bdpcmM[channelType], clpRng); break;

    default:          xPredIntraAng   ( piPred, srcBuf, channelType, clpRng); break;

  }

  if (m_ipaParam.applyPDPC)

  {

    if (uiDirMode == PLANAR_IDX || uiDirMode == DC_IDX)

    {

      IntraPredSampleFilter(piPred, srcBuf);

    }

  }

}

void IntraPrediction::predIntraChromaLM(const ComponentID compID, PelBuf& piPred, const CodingUnit& cu, const CompArea& chromaArea, int intraDir)

{

  CHECK( piPred.width > MAX_TB_SIZEY || piPred.height > MAX_TB_SIZEY, "not enough memory");

  const int iLumaStride = 2 * MAX_TB_SIZEY + 1;

  PelBuf Temp = PelBuf(m_pMdlmTemp + iLumaStride + 1, iLumaStride, Size(chromaArea));

  int a, b, iShift;

  xGetLMParameters(cu, compID, chromaArea, a, b, iShift); // th shift result is unsigned

  ////// final prediction

  piPred.copyFrom(Temp);

  piPred.linearTransform(a, iShift, b, true, cu.cs->slice->clpRngs[compID]);

}

/** Function for deriving planar intra prediction. This function derives the prediction samples for planar mode (intra coding).

 */

void IntraPrediction::xPredIntraDc( PelBuf& pDst, const CPelBuf& pSrc )

{

  const Pel dcval = xGetPredValDc( pSrc, pDst );

  pDst.fill( dcval );

}

// Function for initialization of intra prediction parameters

void IntraPrediction::initPredIntraParams(const CodingUnit& cu, const CompArea area, const SPS& sps)

{

  const ComponentID compId = area.compID;

  const ChannelType chType = toChannelType(compId);

  const bool        useISP = NOT_INTRA_SUBPARTITIONS != cu.ispMode && isLuma( chType );

  const Size   cuSize    = Size( cu.blocks[compId].width, cu.blocks[compId].height );

  const Size   puSize    = Size( area.width, area.height );

  const Size&  blockSize = useISP ? cuSize : puSize;

  const int      dirMode = CU::getFinalIntraMode(cu, chType);

  const int     predMode = getWideAngle( blockSize.width, blockSize.height, dirMode );

  m_ipaParam.isModeVer            = predMode >= DIA_IDX;

  m_ipaParam.multiRefIndex        = isLuma (chType) ? cu.multiRefIdx : 0 ;

  m_ipaParam.refFilterFlag        = false;

  m_ipaParam.interpolationFlag    = false;

  m_ipaParam.applyPDPC            = (puSize.width >= MIN_TB_SIZEY && puSize.height >= MIN_TB_SIZEY) && m_ipaParam.multiRefIndex == 0;

  const int    intraPredAngleMode = (m_ipaParam.isModeVer) ? predMode - VER_IDX : -(predMode - HOR_IDX);

  int absAng = 0;

  if (dirMode > DC_IDX && dirMode < NUM_LUMA_MODE) // intraPredAngle for directional modes

  {

    static const int angTable[32]    = { 0,    1,    2,    3,    4,    6,     8,   10,   12,   14,   16,   18,   20,   23,   26,   29,   32,   35,   39,  45,  51,  57,  64,  73,  86, 102, 128, 171, 256, 341, 512, 1024 };

    static const int invAngTable[32] = {

      0,   16384, 8192, 5461, 4096, 2731, 2048, 1638, 1365, 1170, 1024, 910, 819, 712, 630, 565,

      512, 468,   420,  364,  321,  287,  256,  224,  191,  161,  128,  96,  64,  48,  32,  16

    };   // (512 * 32) / Angle

    const int     absAngMode         = abs(intraPredAngleMode);

    const int     signAng            = intraPredAngleMode < 0 ? -1 : 1;

                  absAng             = angTable  [absAngMode];

    m_ipaParam.absInvAngle           = invAngTable[absAngMode];

    m_ipaParam.intraPredAngle        = signAng * absAng;

    if (intraPredAngleMode < 0)

    {

      m_ipaParam.applyPDPC = false;

    }

    else if (intraPredAngleMode > 0)

    {

      const int sideSize = m_ipaParam.isModeVer ? puSize.height : puSize.width;

      const int maxScale = 2;

      m_ipaParam.angularScale = std::min(maxScale, floorLog2(sideSize) - (floorLog2(3 * m_ipaParam.absInvAngle - 2) - 8));

      m_ipaParam.applyPDPC &= m_ipaParam.angularScale >= 0;

    }

  }

  // high level conditions and DC intra prediction

  if( !isLuma( chType )

    || useISP

    || CU::isMIP( cu, chType ) //th remove this

    || m_ipaParam.multiRefIndex

    || DC_IDX == dirMode

    )

  {

  }

  else if (cu.bdpcmM[chType])

  {

    m_ipaParam.refFilterFlag = false;

  }

  else if (dirMode == PLANAR_IDX) // Planar intra prediction

  {

    m_ipaParam.refFilterFlag = puSize.width * puSize.height > 32 ? true : false;

  }

  else if (!useISP)// HOR, VER and angular modes (MDIS)

  {

    bool filterFlag = false;

    {

      const int diff = std::min<int>( abs( predMode - HOR_IDX ), abs( predMode - VER_IDX ) );

      const int log2Size = (Log2(puSize.width * puSize.height) >> 1);

      CHECK( log2Size >= MAX_INTRA_FILTER_DEPTHS, "Size not supported" );

      filterFlag = (diff > m_aucIntraFilter[log2Size]);

    }

    // Selelection of either ([1 2 1] / 4 ) refrence filter OR Gaussian 4-tap interpolation filter

    if (filterFlag)

    {

      const bool isRefFilter       =  isIntegerSlope(absAng);

      CHECK( puSize.width * puSize.height <= 32, "DCT-IF interpolation filter is always used for 4x4, 4x8, and 8x4 luma CB" );

      m_ipaParam.refFilterFlag     =  isRefFilter;

      m_ipaParam.interpolationFlag = !isRefFilter;

    }

  }

}

}   // namespace vvenc

#ifdef TARGET_SIMD_X86

#include "x86/CommonDefX86.h"

#endif

namespace vvenc {

/** Function for deriving the simplified angular intra predictions.

*

* This function derives the prediction samples for the angular mode based on the prediction direction indicated by

* the prediction mode index. The prediction direction is given by the displacement of the bottom row of the block and

* the reference row above the block in the case of vertical prediction or displacement of the rightmost column

* of the block and reference column left from the block in the case of the horizontal prediction. The displacement

* is signalled at 1/32 pixel accuracy. When projection of the predicted pixel falls inbetween reference samples,

* the predicted value for the pixel is linearly interpolated from the reference samples. All reference samples are taken

* from the extended main reference.

*/

//NOTE: Bit-Limit - 25-bit source

void IntraPrediction::xPredIntraAng( PelBuf& pDst, const CPelBuf& pSrc, const ChannelType channelType, const ClpRng& clpRng)

{

  int width =int(pDst.width);

  int height=int(pDst.height);

  const bool bIsModeVer     = m_ipaParam.isModeVer;

  const int  multiRefIdx    = m_ipaParam.multiRefIndex;

  const int  intraPredAngle = m_ipaParam.intraPredAngle;

  const int  absInvAngle    = m_ipaParam.absInvAngle;

  Pel* refMain;

  Pel* refSide;

  Pel  refAbove[2 * MAX_CU_SIZE + 3 + 33 * MAX_REF_LINE_IDX];

  Pel  refLeft [2 * MAX_CU_SIZE + 3 + 33 * MAX_REF_LINE_IDX];

  // Initialize the Main and Left reference array.

  if (intraPredAngle < 0)

  {

    memcpy(&refAbove[height],pSrc.buf,(width + 2 + multiRefIdx)*sizeof(Pel));

    for (int y = 0; y <= height + 1 + multiRefIdx; y++)

    {

      refLeft[y + width] = pSrc.at(y, 1);

    }

    refMain = bIsModeVer ? refAbove + height : refLeft + width;

    refSide = bIsModeVer ? refLeft + width : refAbove + height;

    // Extend the Main reference to the left.

    int sizeSide = bIsModeVer ? height : width;

    for (int k = -sizeSide; k <= -1; k++)

    {

      refMain[k] = refSide[std::min((-k * absInvAngle + 256) >> 9, sizeSide)];

    }

  }

  else

  {

    memcpy(&refAbove[0], pSrc.buf, ((m_topRefLength)+multiRefIdx + 1) * sizeof(Pel));

    for (int y = 0; y <= m_leftRefLength + multiRefIdx; y++)

    {

      refLeft[y] = pSrc.at(y, 1);

    }

    refMain = bIsModeVer ? refAbove : refLeft;

    refSide = bIsModeVer ? refLeft : refAbove;

    // Extend main reference to right using replication

    const int log2Ratio = Log2(width) - Log2(height);

    const int s         = std::max<int>(0, bIsModeVer ? log2Ratio : -log2Ratio);

    const int maxIndex  = (multiRefIdx << s) + 2;

    const int refLength = bIsModeVer ? m_topRefLength : m_leftRefLength;

    const Pel val       = refMain[refLength + multiRefIdx];

    for (int z = 1; z <= maxIndex; z++)

    {

      refMain[refLength + multiRefIdx + z] = val;

    }

  }

  // swap width/height if we are doing a horizontal mode:

  if (!bIsModeVer)

  {

    std::swap(width, height);

  }

  Pel tempArray[MAX_CU_SIZE*MAX_CU_SIZE];

  const int dstStride = bIsModeVer ? pDst.stride : MAX_CU_SIZE;

  Pel* pDstBuf = bIsModeVer ? pDst.buf : tempArray;

  // compensate for line offset in reference line buffers

  refMain += multiRefIdx;

  refSide += multiRefIdx;

  Pel* pDsty = pDstBuf;

  if( intraPredAngle == 0 )  // pure vertical or pure horizontal

  {

    if (m_ipaParam.applyPDPC)

    {

      const int scale   = (Log2(width * height) - 2) >> 2;

      IntraHorVerPDPC(pDsty,dstStride,refSide,width,height,scale,refMain,clpRng);

    }

    else

    {

      for( int y = 0; y < height; y++ )

      {

        memcpy(pDsty,&refMain[1],width*sizeof(Pel));

        pDsty += dstStride;

      }

    }

  }

  else

  {

    if( !isIntegerSlope( abs( intraPredAngle ) ) )

    {

      int deltaPos = intraPredAngle * ( 1 + multiRefIdx );

      if( isLuma( channelType ) )

      {

        if( width <= 2 )

        {

          for( int y = 0, deltaPos = intraPredAngle * ( 1 + multiRefIdx );

               y < height;

               y++, deltaPos += intraPredAngle, pDsty += dstStride )

          {

            const int deltaInt   = deltaPos >> 5;

            const int deltaFract = deltaPos & 31;

            if( !isIntegerSlope( abs( intraPredAngle ) ) )

            {

              const bool useCubicFilter = !m_ipaParam.interpolationFlag;

              const TFilterCoeff intraSmoothingFilter[4] = { TFilterCoeff( 16 - ( deltaFract >> 1 ) ),

                                                             TFilterCoeff( 32 - ( deltaFract >> 1 ) ),

                                                             TFilterCoeff( 16 + ( deltaFract >> 1 ) ),

                                                             TFilterCoeff(      ( deltaFract >> 1 ) ) };

              const TFilterCoeff* const f =

                ( useCubicFilter ) ? InterpolationFilter::getChromaFilterTable( deltaFract ) : intraSmoothingFilter;

              for( int x = 0; x < width; x++ )

              {

                Pel p[4];

                p[0] = refMain[deltaInt + x + 0];

                p[1] = refMain[deltaInt + x + 1];

                p[2] = refMain[deltaInt + x + 2];

                p[3] = refMain[deltaInt + x + 3];

                Pel val = ( f[0] * p[0] + f[1] * p[1] + f[2] * p[2] + f[3] * p[3] + 32 ) >> 6;

                pDsty[x] = ClipPel( val, clpRng );   // always clip even though not always needed

              }

            }

          }

        }

        else

        {

          IntraPredAngleLuma(pDstBuf, dstStride, refMain, width, height, deltaPos, intraPredAngle, nullptr, !m_ipaParam.interpolationFlag, clpRng);

        }

      }

      else

      {

        IntraPredAngleChroma(pDstBuf,dstStride,refMain,width,height,deltaPos,intraPredAngle);

      }

    }

    else

    {

      for (int y = 0, deltaPos = intraPredAngle * (1 + multiRefIdx); y<height; y++, deltaPos += intraPredAngle, pDsty += dstStride)

      {

        const int deltaInt   = deltaPos >> 5;

        // Just copy the integer samples

        memcpy(pDsty,refMain  + deltaInt + 1,width*sizeof(Pel));

      }

    }

    if (m_ipaParam.applyPDPC)

    {

      pDsty = pDstBuf;

      IntraAnglePDPC(pDsty,dstStride,refSide,width,height,m_ipaParam.angularScale,absInvAngle);

    }

  } // else

  // Flip the block if this is the horizontal mode

  if( !bIsModeVer )

  {

    pDst.transposedFrom( CPelBuf( pDstBuf, dstStride, width, height) );

  }

}

void IntraPrediction::xPredIntraBDPCM(PelBuf& pDst, const CPelBuf& pSrc, const uint32_t dirMode, const ClpRng& clpRng)

{

  const int wdt = pDst.width;

  const int hgt = pDst.height;

  const int strideP = pDst.stride;

  const int strideS = pSrc.stride;

  CHECK(!(dirMode == 1 || dirMode == 2), "Incorrect BDPCM mode parameter.");

  Pel* pred = &pDst.buf[0];

  if (dirMode == 1)

  {

    Pel  val;

    for (int y = 0; y < hgt; y++)

    {

      val = pSrc.buf[(y + 1) + strideS];

      for (int x = 0; x < wdt; x++)

      {

        pred[x] = val;

      }

      pred += strideP;

    }

  }

  else

  {

    for (int y = 0; y < hgt; y++)

    {

      for (int x = 0; x < wdt; x++)

      {

        pred[x] = pSrc.buf[x + 1];

      }

      pred += strideP;

    }

  }

}

inline bool isAboveLeftAvailable  ( const CodingUnit &cu, const ChannelType& chType, const Position& posLT );

inline int  isAboveAvailable      ( const CodingUnit &cu, const ChannelType& chType, const Position& posLT, const uint32_t numUnits, const uint32_t unitWidth, bool *validFlags );

inline int  isLeftAvailable       ( const CodingUnit &cu, const ChannelType& chType, const Position& posLT, const uint32_t numUnits, const uint32_t unitWidth, bool *validFlags );

inline int  isAboveRightAvailable ( const CodingUnit &cu, const ChannelType& chType, const Position& posRT, const uint32_t numUnits, const uint32_t unitHeight, bool *validFlags );

inline int  isBelowLeftAvailable  ( const CodingUnit &cu, const ChannelType& chType, const Position& posLB, const uint32_t numUnits, const uint32_t unitHeight, bool *validFlags );

void IntraPrediction::initIntraPatternChType(const CodingUnit &cu, const CompArea& area, const bool forceRefFilterFlag)

{

  const CodingStructure& cs   = *cu.cs;

  if (!forceRefFilterFlag)

  {

    initPredIntraParams(cu, area, *cs.sps);

  }

  Pel *refBufUnfiltered = m_refBuffer[area.compID][PRED_BUF_UNFILTERED];

  Pel *refBufFiltered   = m_refBuffer[area.compID][PRED_BUF_FILTERED];

  setReferenceArrayLengths(area);

  // ----- Step 1: unfiltered reference samples -----

  xFillReferenceSamples( cs.picture->getRecoBuf( area ), refBufUnfiltered, area, cu );

  // ----- Step 2: filtered reference samples -----

  if( m_ipaParam.refFilterFlag || forceRefFilterFlag )

  {

    xFilterReferenceSamples( refBufUnfiltered, refBufFiltered, area, *cs.sps, cu.multiRefIdx );

  }

}

void IntraPrediction::reset()

{

  m_lastCh = MAX_NUM_CH;

  m_lastArea = Area(0,0,0,0);

}

void IntraPrediction::xFillReferenceSamples( const CPelBuf& recoBuf, Pel* refBufUnfiltered, const CompArea& area, const CodingUnit &cu )

{

  const ChannelType      chType = toChannelType( area.compID );

  const CodingStructure &cs     = *cu.cs;

  const SPS             &sps    = *cs.sps;

  const PreCalcValues   &pcv    = *cs.pcv;

  const int multiRefIdx         = (area.compID == COMP_Y) ? cu.multiRefIdx : 0;

  const int  tuWidth            = area.width;

  const int  tuHeight           = area.height;

  const int  predSize           = m_topRefLength;

  const int  predHSize          = m_leftRefLength;

  const int predStride = predSize + 1 + multiRefIdx;

  m_refBufferStride[area.compID] = predStride;

  const int  unitWidth          = tuWidth  <= 2 && cu.ispMode && isLuma(area.compID) ? tuWidth  : pcv.minCUSize >> getComponentScaleX(area.compID, sps.chromaFormatIdc);

  const int  unitHeight         = tuHeight <= 2 && cu.ispMode && isLuma(area.compID) ? tuHeight : pcv.minCUSize >> getComponentScaleY(area.compID, sps.chromaFormatIdc);

  const int  totalAboveUnits    = (predSize + (unitWidth - 1)) / unitWidth;

  const int  totalLeftUnits     = (predHSize + (unitHeight - 1)) / unitHeight;

  const int  totalUnits         = totalAboveUnits + totalLeftUnits + 1; //+1 for top-left

  if( m_lastArea != area || m_lastCh != chType )

  {

    m_lastCh = chType;

    m_lastArea = area;

    const int  numAboveUnits      = std::max<int>( tuWidth / unitWidth, 1 );

    const int  numLeftUnits       = std::max<int>( tuHeight / unitHeight, 1 );

    const int  numAboveRightUnits = totalAboveUnits - numAboveUnits;

    const int  numLeftBelowUnits  = totalLeftUnits - numLeftUnits;

    CHECK( numAboveUnits <= 0 || numLeftUnits <= 0 || numAboveRightUnits <= 0 || numLeftBelowUnits <= 0, "Size not supported" );

    // ----- Step 1: analyze neighborhood -----

    const Position posLT          = area;

    const Position posRT          = area.topRight();

    const Position posLB          = area.bottomLeft();

    m_numIntraNeighbor = 0;

    memset( m_neighborFlags, 0, totalUnits );

    m_neighborFlags[totalLeftUnits] = isAboveLeftAvailable( cu, chType, posLT );

    m_numIntraNeighbor += m_neighborFlags[totalLeftUnits] ? 1 : 0;

    m_numIntraNeighbor += isAboveAvailable     ( cu, chType, posLT, numAboveUnits,      unitWidth,  (m_neighborFlags + totalLeftUnits + 1) );

    m_numIntraNeighbor += isAboveRightAvailable( cu, chType, posRT, numAboveRightUnits, unitWidth,  (m_neighborFlags + totalLeftUnits + 1 + numAboveUnits) );

    m_numIntraNeighbor += isLeftAvailable      ( cu, chType, posLT, numLeftUnits,       unitHeight, (m_neighborFlags + totalLeftUnits - 1) );

    m_numIntraNeighbor += isBelowLeftAvailable ( cu, chType, posLB, numLeftBelowUnits,  unitHeight, (m_neighborFlags + totalLeftUnits - 1 - numLeftUnits) );

  }

  // ----- Step 2: fill reference samples (depending on neighborhood) -----

  const Pel*  srcBuf    = recoBuf.buf;

  const int   srcStride = recoBuf.stride;

        Pel*  ptrDst    = refBufUnfiltered;

  const Pel*  ptrSrc;

  const Pel   valueDC   = 1 << (sps.bitDepths[ chType ] - 1);

  if( m_numIntraNeighbor == 0 )

  {

    // Fill border with DC value

    for (int j = 0; j <= predSize + multiRefIdx; j++) { ptrDst[j] = valueDC; }

    for (int i = 0; i <= predHSize + multiRefIdx; i++) { ptrDst[i+predStride] = valueDC; }

  }

  else if( m_numIntraNeighbor == totalUnits )

  {

    // Fill top-left border and top and top right with rec. samples

    ptrSrc = srcBuf - (1 + multiRefIdx) * srcStride - (1 + multiRefIdx);

    for (int j = 0; j <= predSize + multiRefIdx; j++) { ptrDst[j] = ptrSrc[j]; }

    for (int i = 0; i <= predHSize + multiRefIdx; i++)

    {

      ptrDst[i + predStride] = ptrSrc[i * srcStride];

    }

  }

  else // reference samples are partially available

  {

    // Fill top-left sample(s) if available

    ptrSrc = srcBuf - (1 + multiRefIdx) * srcStride - (1 + multiRefIdx);

    ptrDst = refBufUnfiltered;

    if (m_neighborFlags[totalLeftUnits])

    {

      ptrDst[0] = ptrSrc[0];

      ptrDst[predStride] = ptrSrc[0];

      for (int i = 1; i <= multiRefIdx; i++)

      {

        ptrDst[i] = ptrSrc[i];

        ptrDst[i + predStride] = ptrSrc[i * srcStride];

      }

    }

    // Fill left & below-left samples if available (downwards)

    ptrSrc += (1 + multiRefIdx) * srcStride;

    ptrDst += (1 + multiRefIdx) + predStride;

    for (int unitIdx = totalLeftUnits - 1; unitIdx > 0; unitIdx--)

    {

      if (m_neighborFlags[unitIdx])

      {

        for (int i = 0; i < unitHeight; i++)

        {

          ptrDst[i] = ptrSrc[i*srcStride];

        }

      }

      ptrSrc += unitHeight * srcStride;

      ptrDst += unitHeight;

    }

    // Fill last below-left sample(s)

    if (m_neighborFlags[0])

    {

      int lastSample = (predHSize % unitHeight == 0) ? unitHeight : predHSize % unitHeight;

      for (int i = 0; i < lastSample; i++)

      {

        ptrDst[i] = ptrSrc[i*srcStride];

      }

    }

    // Fill above & above-right samples if available (left-to-right)

    ptrSrc = srcBuf - srcStride * (1 + multiRefIdx);

    ptrDst = refBufUnfiltered + 1 + multiRefIdx;

    for (int unitIdx = totalLeftUnits + 1; unitIdx < totalUnits - 1; unitIdx++)

    {

      if (m_neighborFlags[unitIdx])

      {

        memcpy(ptrDst,ptrSrc,unitWidth*sizeof(Pel));

      }

      ptrSrc += unitWidth;

      ptrDst += unitWidth;

    }

    // Fill last above-right sample(s)

    if (m_neighborFlags[totalUnits - 1])

    {

      int lastSample = (predSize % unitWidth == 0) ? unitWidth : predSize % unitWidth;

      memcpy(ptrDst,ptrSrc,lastSample*sizeof(Pel));

    }

    // pad from first available down to the last below-left

    ptrDst = refBufUnfiltered;

    int lastAvailUnit = 0;

    if (!m_neighborFlags[0])

    {

      int firstAvailUnit = 1;

      while (firstAvailUnit < totalUnits && !m_neighborFlags[firstAvailUnit])

      {

        firstAvailUnit++;

      }

      // first available sample

      int firstAvailRow = -1;

      int firstAvailCol = 0;

      if (firstAvailUnit < totalLeftUnits)

      {

        firstAvailRow = (totalLeftUnits - firstAvailUnit) * unitHeight + multiRefIdx;

      }

      else if (firstAvailUnit == totalLeftUnits)

      {

        firstAvailRow = multiRefIdx;

      }

      else

      {

        firstAvailCol = (firstAvailUnit - totalLeftUnits - 1) * unitWidth + 1 + multiRefIdx;

      }

      const Pel firstAvailSample = ptrDst[firstAvailRow < 0 ? firstAvailCol : firstAvailRow + predStride];

      // last sample below-left (n.a.)

      int lastRow = predHSize + multiRefIdx;

      // fill left column

      for (int i = lastRow; i > firstAvailRow; i--)

      {

        ptrDst[i + predStride] = firstAvailSample;

      }

      // fill top row

      if (firstAvailCol > 0)

      {

        for (int j = 0; j < firstAvailCol; j++)

        {

          ptrDst[j] = firstAvailSample;

        }

      }

      lastAvailUnit = firstAvailUnit;

    }

    // pad all other reference samples.

    int currUnit = lastAvailUnit + 1;

    while (currUnit < totalUnits)

    {

      if (!m_neighborFlags[currUnit]) // samples not available

      {

        // last available sample

        int lastAvailRow = -1;

        int lastAvailCol = 0;

        if (lastAvailUnit < totalLeftUnits)

        {

          lastAvailRow = (totalLeftUnits - lastAvailUnit - 1) * unitHeight + multiRefIdx + 1;

        }

        else if (lastAvailUnit == totalLeftUnits)

        {

          lastAvailCol = multiRefIdx;

        }

        else

        {

          lastAvailCol = (lastAvailUnit - totalLeftUnits) * unitWidth + multiRefIdx;

        }

        const Pel lastAvailSample = ptrDst[lastAvailRow < 0 ? lastAvailCol : lastAvailRow + predStride];

        // fill current unit with last available sample

        if (currUnit < totalLeftUnits)

        {

          for (int i = lastAvailRow - 1; i >= lastAvailRow - unitHeight; i--)

          {

            ptrDst[i + predStride] = lastAvailSample;

          }

        }

        else if (currUnit == totalLeftUnits)

        {

          for (int i = 0; i < multiRefIdx + 1; i++)

          {

            ptrDst[i + predStride] = lastAvailSample;

          }

          for (int j = 0; j < multiRefIdx + 1; j++)

          {

            ptrDst[j] = lastAvailSample;

          }

        }

        else

        {

          int numSamplesInUnit = (currUnit == totalUnits - 1) ? ((predSize % unitWidth == 0) ? unitWidth : predSize % unitWidth) : unitWidth;

          for (int j = lastAvailCol + 1; j <= lastAvailCol + numSamplesInUnit; j++)

          {

            ptrDst[j] = lastAvailSample;

          }

        }

      }

      lastAvailUnit = currUnit;

      currUnit++;

    }

  }

}

void IntraPrediction::xFilterReferenceSamples( const Pel* refBufUnfiltered, Pel* refBufFiltered, const CompArea& area, const SPS &sps

  , int multiRefIdx