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

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) 2018-2026, Fraunhofer-Gesellschaft zur Förderung der angewandten Forschung e.V. & The VVdeC 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 "InterPrediction.h"

#include "Buffer.h"

#include "UnitTools.h"

#include "CommonLib/TimeProfiler.h"

#include <memory.h>

#include <algorithm>

#include <cmath>

namespace vvdec

{

template<bool bi>

void applyPROFCore( Pel* dst, ptrdiff_t dstStride, const Pel* src, const Pel* gradX, const Pel* gradY, const int* dMvX, const int* dMvY, int shiftNum, Pel offset, const ClpRng& clpRng )

{

  static constexpr ptrdiff_t srcStride = 6;

  static constexpr int width = 4;

  static constexpr int height = 4;

  int idx = 0;

  const int dILimit = 1 << std::max<int>(clpRng.bd + 1, 13);

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

  {

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

    {

      int32_t dI = dMvX[idx] * gradX[w] + dMvY[idx] * gradY[w];

      dI = Clip3(-dILimit, dILimit - 1, dI);

      dst[w] = src[w] + dI;

      if (!bi)

      {

        dst[w] = (dst[w] + offset) >> shiftNum;

        dst[w] = ClipPel(dst[w], clpRng);

      }

      idx++;

    }

    gradX += 4;

    gradY += 4;

    dst += dstStride;

    src += srcStride;

  }

}

Unexecuted instantiation: void vvdec::applyPROFCore<false>(short*, long, short const*, short const*, short const*, int const*, int const*, int, short, vvdec::ClpRngTemplate<short> const&)

Unexecuted instantiation: void vvdec::applyPROFCore<true>(short*, long, short const*, short const*, short const*, int const*, int const*, int, short, vvdec::ClpRngTemplate<short> const&)

static inline int rightShiftMSB(int numer, int denom)

{

  int     d;

  int msbIdx = 0;

  for (msbIdx = 0; msbIdx<32; msbIdx++)

  {

    if (denom < ((int)1 << msbIdx))

    {

      break;

    }

  }

  int shiftIdx = msbIdx - 1;

  d = (numer >> shiftIdx);

  return d;

}

static inline void addBIOAvg4(const Pel* src0, ptrdiff_t src0Stride, const Pel* src1, ptrdiff_t src1Stride, Pel *dst, ptrdiff_t dstStride, const Pel *gradX0, const Pel *gradX1, const Pel *gradY0, const Pel*gradY1, ptrdiff_t gradStride, int width, int height, int tmpx, int tmpy, int shift, int offset, const ClpRng& clpRng)

{

  int b = 0;

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

  {

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

    {

      b = tmpx * (gradX0[x] - gradX1[x]) + tmpy * (gradY0[x] - gradY1[x]);

      dst[x] = ClipPel((int16_t)rightShift((src0[x] + src1[x] + b + offset), shift), clpRng);

      b = tmpx * (gradX0[x + 1] - gradX1[x + 1]) + tmpy * (gradY0[x + 1] - gradY1[x + 1]);

      dst[x + 1] = ClipPel((int16_t)rightShift((src0[x + 1] + src1[x + 1] + b + offset), shift), clpRng);

      b = tmpx * (gradX0[x + 2] - gradX1[x + 2]) + tmpy * (gradY0[x + 2] - gradY1[x + 2]);

      dst[x + 2] = ClipPel((int16_t)rightShift((src0[x + 2] + src1[x + 2] + b + offset), shift), clpRng);

      b = tmpx * (gradX0[x + 3] - gradX1[x + 3]) + tmpy * (gradY0[x + 3] - gradY1[x + 3]);

      dst[x + 3] = ClipPel((int16_t)rightShift((src0[x + 3] + src1[x + 3] + b + offset), shift), clpRng);

    }

    dst += dstStride;       src0 += src0Stride;     src1 += src1Stride;

    gradX0 += gradStride; gradX1 += gradStride; gradY0 += gradStride; gradY1 += gradStride;

  }

}

void calcBIOSums(const Pel* srcY0Tmp, const Pel* srcY1Tmp, const Pel* gradX0, const Pel* gradX1, const Pel* gradY0, const Pel* gradY1, int xu, int yu, const int src0Stride, const int src1Stride, const int widthG, const int bitDepth, int* sumAbsGX, int* sumAbsGY, int* sumDIX, int* sumDIY, int* sumSignGY_GX)

{

  int shift4 = 4;

  int shift5 = 1;

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

  {

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

    {

      int tmpGX = (gradX0[x] + gradX1[x]) >> shift5;

      int tmpGY = (gradY0[x] + gradY1[x]) >> shift5;

      int tmpDI = (int)((srcY1Tmp[x] >> shift4) - (srcY0Tmp[x] >> shift4));

      *sumAbsGX += (tmpGX < 0 ? -tmpGX : tmpGX);

      *sumAbsGY += (tmpGY < 0 ? -tmpGY : tmpGY);

      *sumDIX += (tmpGX < 0 ? -tmpDI : (tmpGX == 0 ? 0 : tmpDI));

      *sumDIY += (tmpGY < 0 ? -tmpDI : (tmpGY == 0 ? 0 : tmpDI));

      *sumSignGY_GX += (tmpGY < 0 ? -tmpGX : (tmpGY == 0 ? 0 : tmpGX));

    }

    srcY1Tmp += src1Stride;

    srcY0Tmp += src0Stride;

    gradX0 += widthG;

    gradX1 += widthG;

    gradY0 += widthG;

    gradY1 += widthG;

  }

}

static void BiOptFlowCore(const Pel* srcY0,const Pel* srcY1,const Pel* gradX0,const Pel* gradX1,const Pel* gradY0,const Pel* gradY1,const int width,const int height,Pel* dstY,const ptrdiff_t dstStride,const int shiftNum,const int  offset,const int  limit, const ClpRng& clpRng, const int bitDepth)

{

  int           widthG  = width      + BIO_ALIGN_SIZE;

  int           stridePredMC = width + BIO_ALIGN_SIZE;

  int           offsetPos = widthG*BIO_EXTEND_SIZE + BIO_EXTEND_SIZE;

  int xUnit = (width >> 2);

  int yUnit = (height >> 2);

  const Pel*    srcY0Temp;

  const Pel*    srcY1Temp;

  int OffPos;

  Pel *dstY0;

  for (int yu = 0; yu < yUnit; yu++)

  {

    for (int xu = 0; xu < xUnit; xu++)

    {

      OffPos=offsetPos + ((yu*widthG + xu) << 2);

      {

        int tmpx = 0, tmpy = 0;

        int sumAbsGX = 0, sumAbsGY = 0, sumDIX = 0, sumDIY = 0;

        int sumSignGY_GX = 0;

        const Pel* pGradX0Tmp = gradX0 + (xu << 2) + (yu << 2) * widthG;

        const Pel* pGradX1Tmp = gradX1 + (xu << 2) + (yu << 2) * widthG;

        const Pel* pGradY0Tmp = gradY0 + (xu << 2) + (yu << 2) * widthG;

        const Pel* pGradY1Tmp = gradY1 + (xu << 2) + (yu << 2) * widthG;

        const Pel* SrcY1Tmp = srcY1 + (xu << 2) + (yu << 2) * stridePredMC;

        const Pel* SrcY0Tmp = srcY0 + (xu << 2) + (yu << 2) * stridePredMC;

        calcBIOSums(SrcY0Tmp, SrcY1Tmp, pGradX0Tmp, pGradX1Tmp, pGradY0Tmp, pGradY1Tmp, xu, yu, stridePredMC, stridePredMC, widthG, bitDepth, &sumAbsGX, &sumAbsGY, &sumDIX, &sumDIY, &sumSignGY_GX);

        tmpx = (sumAbsGX == 0 ? 0 : rightShiftMSB(sumDIX *4, sumAbsGX));

        tmpx = Clip3(-limit, limit, tmpx);

        int     mainsGxGy = sumSignGY_GX >> 12;

        int     secsGxGy = sumSignGY_GX & ((1 << 12) - 1);

        int     tmpData = tmpx * mainsGxGy;

        tmpData = ((tmpData *(1<< 12)) + tmpx*secsGxGy) >> 1;

        tmpy = (sumAbsGY == 0 ? 0 : rightShiftMSB(((sumDIY *4) - tmpData), sumAbsGY));

        tmpy = Clip3(-limit, limit, tmpy);

        srcY0Temp = srcY0 + (stridePredMC + 1) + ((yu*stridePredMC + xu) << 2);

        srcY1Temp = srcY1 + (stridePredMC + 1) + ((yu*stridePredMC + xu) << 2);

        dstY0 = dstY + ((yu*dstStride + xu) << 2);

        addBIOAvg4(srcY0Temp, stridePredMC, srcY1Temp, stridePredMC, dstY0, dstStride, gradX0 + OffPos, gradX1 + OffPos, gradY0 + OffPos, gradY1 + OffPos, widthG, (1 << 2), (1 << 2), (int)tmpx, (int)tmpy, shiftNum, offset, clpRng);

      }

    }  // xu

  }  // yu

}

template<bool PAD = true>

void gradFilterCore(Pel* pSrc, ptrdiff_t srcStride, int width, int height, ptrdiff_t gradStride, Pel* gradX, Pel* gradY, const int bitDepth)

{

  Pel* srcTmp   = PAD ? pSrc  + srcStride  + 1 : pSrc;

  Pel* gradXTmp = PAD ? gradX + gradStride + 1 : gradX;

  Pel* gradYTmp = PAD ? gradY + gradStride + 1 : gradY;

  int  shift1 = 6;

  const int widthInside  = PAD ? width  - 2 * BIO_EXTEND_SIZE : width;

  const int heightInside = PAD ? height - 2 * BIO_EXTEND_SIZE : height;

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

  {

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

    {

      gradYTmp[x] = ( srcTmp[x + srcStride] >> shift1 ) - ( srcTmp[x - srcStride] >> shift1 );

      gradXTmp[x] = ( srcTmp[x + 1] >> shift1 ) - ( srcTmp[x - 1] >> shift1 );

    }

    gradXTmp += gradStride;

    gradYTmp += gradStride;

    srcTmp += srcStride;

  }

  if (PAD)

  {

    gradXTmp = gradX + gradStride + 1;

    gradYTmp = gradY + gradStride + 1;

    srcTmp   = pSrc  + srcStride  + 1;

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

    {

      gradXTmp[-1] = gradXTmp[0];

      gradXTmp[width - 2 * BIO_EXTEND_SIZE] = gradXTmp[width - 2 * BIO_EXTEND_SIZE - 1];

      gradXTmp += gradStride;

      gradYTmp[-1] = gradYTmp[0];

      gradYTmp[width - 2 * BIO_EXTEND_SIZE] = gradYTmp[width - 2 * BIO_EXTEND_SIZE - 1];

      gradYTmp += gradStride;

      srcTmp[-1] = srcTmp[0];

      srcTmp[width - 2 * BIO_EXTEND_SIZE] = srcTmp[width - 2 * BIO_EXTEND_SIZE - 1];

      srcTmp += srcStride;

    }

    gradXTmp = gradX + gradStride;

    gradYTmp = gradY + gradStride;

    srcTmp   = pSrc  + srcStride;

    ::memcpy(gradXTmp - gradStride, gradXTmp, sizeof(Pel)*(width));

    ::memcpy(gradXTmp + (height - 2 * BIO_EXTEND_SIZE)*gradStride, gradXTmp + (height - 2 * BIO_EXTEND_SIZE - 1)*gradStride, sizeof(Pel)*(width));

    ::memcpy(gradYTmp - gradStride, gradYTmp, sizeof(Pel)*(width));

    ::memcpy(gradYTmp + (height - 2 * BIO_EXTEND_SIZE)*gradStride, gradYTmp + (height - 2 * BIO_EXTEND_SIZE - 1)*gradStride, sizeof(Pel)*(width));

    ::memcpy(srcTmp   - srcStride , srcTmp, sizeof(Pel)*(width));

    ::memcpy(srcTmp   + (height - 2 * BIO_EXTEND_SIZE)*srcStride , srcTmp   + (height - 2 * BIO_EXTEND_SIZE - 1)*srcStride , sizeof(Pel)*(width));

  }

}

Unexecuted instantiation: void vvdec::gradFilterCore<true>(short*, long, int, int, long, short*, short*, int)

Unexecuted instantiation: void vvdec::gradFilterCore<false>(short*, long, int, int, long, short*, short*, int)

void PaddBIOCore(const Pel* refPel,Pel* dstPel,unsigned width,const int shift)

{

#define LFTSHFT( y, shift ) y * ( 1 << shift )   // simplification because shift is never < 0

  for( int w = 0; w < width + 2 * BIO_EXTEND_SIZE; w++ )

  {

    Pel val   = LFTSHFT( refPel[w], shift );

    dstPel[w] = val - (Pel)IF_INTERNAL_OFFS;

  }

}

template<int padSize>

void paddingCore(Pel *ptr, ptrdiff_t stride, int width, int height)

{

  /*left and right padding*/

  Pel *ptrTemp1 = ptr;

  Pel *ptrTemp2 = ptr + (width - 1);

  ptrdiff_t offset = 0;

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

  {

    offset = stride * i;

    for (int j = 1; j <= padSize; j++)

    {

      *(ptrTemp1 - j + offset) = *(ptrTemp1 + offset);

      *(ptrTemp2 + j + offset) = *(ptrTemp2 + offset);

    }

  }

  /*Top and Bottom padding*/

  int numBytes = (width + padSize + padSize) * sizeof(Pel);

  ptrTemp1 = (ptr - padSize);

  ptrTemp2 = (ptr + (stride * (height - 1)) - padSize);

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

  {

    memcpy(ptrTemp1 - (i * stride), (ptrTemp1), numBytes);

    memcpy(ptrTemp2 + (i * stride), (ptrTemp2), numBytes);

  }

}

Unexecuted instantiation: void vvdec::paddingCore<2>(short*, long, int, int)

Unexecuted instantiation: void vvdec::paddingCore<1>(short*, long, int, int)

template<int padSize>

void prefetchPadCore( const Pel* src, const ptrdiff_t srcStride, Pel* dst, const ptrdiff_t dstStride, int width, int height )

{

  g_pelBufOP.copyBuffer( ( const char* ) src, srcStride * sizeof( Pel ), ( char* ) dst, dstStride * sizeof( Pel ), width * sizeof( Pel ), height );

  paddingCore<padSize>( dst, dstStride, width, height );

}

Unexecuted instantiation: void vvdec::prefetchPadCore<2>(short const*, long, short*, long, int, int)

Unexecuted instantiation: void vvdec::prefetchPadCore<1>(short const*, long, short*, long, int, int)

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

// Constructor / destructor / initialize

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

InterPrediction::InterPrediction()

  : BioGradFilter ( gradFilterCore )

  , profGradFilter( gradFilterCore<false> )

  , BiOptFlow     ( BiOptFlowCore )

  , roundIntVector( nullptr )

{

  clipMv = clipMvInPic;

  m_currChromaFormat = NUM_CHROMA_FORMAT;

  memset( m_gradX0,               0x00, sizeof( m_gradX0             ) );

  memset( m_gradY0,               0x00, sizeof( m_gradY0             ) );

  memset( m_gradX1,               0x00, sizeof( m_gradX1             ) );

  memset( m_gradY1,               0x00, sizeof( m_gradY1             ) );

  memset( m_bdofBlock,            0x00, sizeof( m_bdofBlock          ) );

  memset( m_acYuvPred,            0x00, sizeof( m_acYuvPred          ) );

  memset( m_tmpBlock,             0x00, sizeof( m_tmpBlock           ) );

  memset( m_cRefSamplesDMVRL0,    0x00, sizeof( m_cRefSamplesDMVRL0  ) );

  memset( m_cRefSamplesDMVRL1,    0x00, sizeof( m_cRefSamplesDMVRL1  ) );

  memset( m_cYuvPredTempDMVRL0,   0x00, sizeof( m_cYuvPredTempDMVRL0 ) );

  memset( m_cYuvPredTempDMVRL1,   0x00, sizeof( m_cYuvPredTempDMVRL1 ) );

  memset( m_SADsArray,            0x00, sizeof( m_SADsArray          ) );

}

InterPrediction::~InterPrediction()

{

  destroy();

}

void InterPrediction::destroy()

{

}

void InterPrediction::init( RdCost* pcRdCost, ChromaFormat chromaFormatIDC, const int ctuSize, bool enableOpt )

{

  m_pcRdCost = pcRdCost;

  // if it has been initialised before, but the chroma format has changed, release the memory and start again.

  if( m_currChromaFormat != chromaFormatIDC )

  {

    destroy();

    m_currChromaFormat = NUM_CHROMA_FORMAT;

  }

  if( m_currChromaFormat == NUM_CHROMA_FORMAT ) // check if first is null (in which case, nothing initialised yet)

  {

    VALGRIND_MEMCLEAR( m_bdofBlock );

    VALGRIND_MEMCLEAR( m_tmpBlock  );

    m_iRefListIdx = -1;

    VALGRIND_MEMCLEAR( m_gradX0 );

    VALGRIND_MEMCLEAR( m_gradY0 );

    VALGRIND_MEMCLEAR( m_gradX1 );

    VALGRIND_MEMCLEAR( m_gradY1 );

    m_if.initInterpolationFilter( true );

    applyPROF[0] = applyPROFCore<0>;

    applyPROF[1] = applyPROFCore<1>;

    PaddBIO      = PaddBIOCore;

    prefetchPad[0] = prefetchPadCore<2>; // luma

    prefetchPad[1] = prefetchPadCore<2>; // chroma for 444 and 422

    prefetchPad[2] = prefetchPadCore<1>; // chroma for 420

    if( enableOpt )

    {

#if ENABLE_SIMD_OPT_INTER && defined( TARGET_SIMD_X86 )

      initInterPredictionX86();

#endif

#if ENABLE_SIMD_OPT_INTER && defined( TARGET_SIMD_ARM )

      initInterPredictionARM();

#endif

    }

  }

  m_currChromaFormat = chromaFormatIDC;

}

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

// Public member functions

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

bool InterPrediction::xCheckIdenticalMotion( const CodingUnit &cu )

{

  const Slice &slice = *cu.slice;

  if( slice.isInterB() && !cu.pps->getWPBiPred() )

  {

    if( cu.refIdx[0] >= 0 && cu.refIdx[1] >= 0 )

    {

      int RefPOCL0 = slice.getRefPOC( REF_PIC_LIST_0, cu.refIdx[0] );

      int RefPOCL1 = slice.getRefPOC( REF_PIC_LIST_1, cu.refIdx[1] );

      if( RefPOCL0 == RefPOCL1 )

      {

        if( !cu.affineFlag() )

        {

          if( cu.mv[0][0] == cu.mv[1][0] )

          {

            return true;

          }

        }

        else

        {

          if( cu.mv[0][0] == cu.mv[1][0] && cu.mv[0][1] == cu.mv[1][1] && ( cu.affineType() == AFFINEMODEL_4PARAM || cu.mv[0][2] == cu.mv[1][2] ) )

          {

            return true;

          }

        }

      }

    }

  }

  return false;

}

void InterPrediction::xSubPuMC( CodingUnit& cu, PelUnitBuf& predBuf )

{

  // compute the location of the current PU

  const Position puPos    = cu.lumaPos();

  const Size puSize       = cu.lumaSize();

  const int numPartLine   = std::max<SizeType>( puSize.width  >> ATMVP_SUB_BLOCK_SIZE, 1u );

  const int numPartCol    = std::max<SizeType>( puSize.height >> ATMVP_SUB_BLOCK_SIZE, 1u );

  const int puHeight      = numPartCol  == 1 ? puSize.height : 1 << ATMVP_SUB_BLOCK_SIZE;

  const int puWidth       = numPartLine == 1 ? puSize.width  : 1 << ATMVP_SUB_BLOCK_SIZE;

  CodingUnit      subCu;

  CodingUnit& subPu = subCu;

  subCu.cs           = cu.cs;

  subCu.slice        = cu.slice;

  subCu.pps          = cu.pps;

  subCu.sps          = cu.sps;

  subCu.setChType    ( cu.chType() );

  subCu.setPredMode  ( cu.predMode() );

  subCu.UnitArea::operator=( cu );

  subPu.setMergeType ( MRG_TYPE_DEFAULT_N );

  subPu.setAffineFlag( false );

  subPu.setGeoFlag   ( false );

  subPu.setBcwIdx    ( cu.BcwIdx() );

  subPu.setImv       ( cu.imv() );

  subPu.setSmvdMode  ( cu.smvdMode() );

  // join sub-pus containing the same motion

  bool verMC    = puSize.height > puSize.width;

  int  fstStart = ( !verMC ? puPos.y : puPos.x );

  int  secStart = ( !verMC ? puPos.x : puPos.y );

  int  fstEnd   = ( !verMC ? puPos.y + puSize.height : puPos.x + puSize.width  );

  int  secEnd   = ( !verMC ? puPos.x + puSize.width  : puPos.y + puSize.height );

  int  fstStep  = ( !verMC ? puHeight : puWidth  );

  int  secStep  = ( !verMC ? puWidth  : puHeight );

#if RPR_FIX

  bool scaled = cu.slice->getRefPic( REF_PIC_LIST_0, 0 )->isRefScaled( cu.pps ) || ( cu.slice->getSliceType() == B_SLICE ? cu.slice->getRefPic( REF_PIC_LIST_1, 0 )->isRefScaled( cu.pps ) : false );

#endif

  m_subPuMC = true;

  for( int fstDim = fstStart; fstDim < fstEnd; fstDim += fstStep )

  {

    for( int secDim = secStart; secDim < secEnd; secDim += secStep )

    {

      int x = !verMC ? secDim : fstDim;

      int y = !verMC ? fstDim : secDim;

      const MotionInfo &curMi = cu.getMotionInfo( Position{ x, y } );

      int length = secStep;

      int later   = secDim + secStep;

      while( later < secEnd )

      {

        const MotionInfo &laterMi = !verMC ? cu.getMotionInfo( Position{ later, fstDim } ) : cu.getMotionInfo( Position{ fstDim, later } );

#if RPR_FIX

        if( !scaled && laterMi == curMi )

#else

        if( laterMi == curMi )

#endif

        {

          length += secStep;

        }

        else

        {

          break;

        }

        later += secStep;

      }

      int dx = !verMC ? length : puWidth;

      int dy = !verMC ? puHeight : length;

      subPu = curMi;

      if( !verMC && ( dx & 15 ) && dx > 16 )

      {

        int dxPart = dx & ~15;

        new ( &static_cast< UnitArea& >( subPu ) ) UnitArea( cu.chromaFormat, Area( x, y, dxPart, dy ) );

        PelUnitBuf subPredBuf = predBuf.subBuf( UnitAreaRelative( cu, subPu ) );

        motionCompensation( subPu, subPredBuf );

        x  += dxPart;

        dx -= dxPart;

      }

      else if( verMC && ( dy & 15 ) && dy > 16 )

      {

        int dyPart = dy & ~15;

        new ( &static_cast< UnitArea& >( subPu ) ) UnitArea( cu.chromaFormat, Area( x, y, dx, dyPart ) );

        PelUnitBuf subPredBuf = predBuf.subBuf( UnitAreaRelative( cu, subPu ) );

        motionCompensation( subPu, subPredBuf );

        y  += dyPart;

        dy -= dyPart;

      }

      new ( &static_cast< UnitArea& >( subPu ) ) UnitArea( cu.chromaFormat, Area( x, y, dx, dy ) );

      PelUnitBuf subPredBuf = predBuf.subBuf( UnitAreaRelative( cu, subPu ) );

      motionCompensation( subPu, subPredBuf );

      secDim = later - secStep;

    }

  }

  m_subPuMC = false;

}

void InterPrediction::xSubPuBio(CodingUnit& cu, PelUnitBuf& predBuf )

{

  // compute the location of the current PU

  const Position puPos = cu.lumaPos();

  const Size puSize    = cu.lumaSize();

  CodingUnit      subCu;

  CodingUnit& subPu = subCu;

  subCu.cs           = cu.cs;

  subCu.slice        = cu.slice;

  subCu.pps          = cu.pps;

  subCu.sps          = cu.sps;

  subCu.setChType    ( cu.chType() );

  subCu.setPredMode  ( cu.predMode() );

  subPu.setMergeType ( cu.mergeType() );

  subPu.setMmvdFlag  ( cu.mmvdFlag() );

  subPu.setMergeFlag ( cu.mergeFlag() );

  subPu.setCiipFlag  ( cu.ciipFlag() );

  subPu.setGeoFlag   ( cu.geoFlag() );

//  subPu.mvRefine = cu.mvRefine;

  subPu.setAffineFlag( cu.affineFlag() );

  subPu.refIdx[0]    = cu.refIdx[0];

  subPu.refIdx[1]    = cu.refIdx[1];

  subPu.setBcwIdx    ( cu.BcwIdx() );

  subPu.setImv       ( cu.imv() );

  subPu.setSmvdMode  ( cu.smvdMode() );

  const int  subPuHeight = std::min<int>( MAX_BDOF_APPLICATION_REGION, puSize.height );

  const int  subPuWidth  = std::min<int>( MAX_BDOF_APPLICATION_REGION, puSize.width );

  const int  csy = getChannelTypeScaleY( CH_C, cu.chromaFormat );

  const int  csx = getChannelTypeScaleX( CH_C, cu.chromaFormat );

  const int  subPuHeightC = subPuHeight >> csy;

  const int  subPuWidthC  = subPuWidth  >> csx;

  PelUnitBuf pcMbBuf1( cu.chromaFormat, PelBuf( m_acYuvPred[0], subPuWidth, subPuHeight ), PelBuf( m_acYuvPred[1], subPuWidthC, subPuHeightC ), PelBuf( m_acYuvPred[2], subPuWidthC, subPuHeightC ) );

  PelUnitBuf subPredBuf = predBuf.subBuf( UnitAreaRelative( cu, UnitArea( cu.chromaFormat, Area( 0, 0, subPuWidth, subPuHeight ) ) ) );

  for( int y = puPos.y, dy = 0; y < puPos.y + puSize.height; y += subPuHeight, dy += subPuHeight )

  {

    for( int x = puPos.x, dx = 0; x < puPos.x + puSize.width; x += subPuWidth, dx += subPuWidth )

    {

      const MotionInfo &curMi = cu.getMotionInfo( Position{ x, y } );

      new ( &static_cast< UnitArea& >( subPu ) ) UnitArea( cu.chromaFormat, Area( x, y, subPuWidth, subPuHeight ) );

      subPu = curMi;

      subPredBuf  .bufs[0].buf = GET_OFFSET( predBuf.bufs[0].buf, predBuf.bufs[0].stride, dx,        dy );

      if( isChromaEnabled( cu.chromaFormat ) )

      {

        subPredBuf.bufs[1].buf = GET_OFFSET( predBuf.bufs[1].buf, predBuf.bufs[1].stride, dx >> csx, dy >> csy );

        subPredBuf.bufs[2].buf = GET_OFFSET( predBuf.bufs[2].buf, predBuf.bufs[2].stride, dx >> csx, dy >> csy );

      }

      CHECKD( cu.refIdx[0] < 0 || cu.refIdx[1] < 0, "Bi-prediction required for BDOF!" );

      PelUnitBuf& pcMbBuf0 = subPredBuf;

      m_iRefListIdx = REF_PIC_LIST_0;

      xPredInterUni( subPu, REF_PIC_LIST_0, pcMbBuf0, true, true, true, true );

      m_iRefListIdx = REF_PIC_LIST_1;

      xPredInterUni( subPu, REF_PIC_LIST_1, pcMbBuf1, true, true, true, true );

      xWeightedAverage( subPu, pcMbBuf0, pcMbBuf1, subPredBuf, cu.sps->getBitDepths(), cu.slice->clpRngs(), true );

    }

  }

}

void InterPrediction::xPredInterUni( const CodingUnit &cu, const RefPicList &eRefPicList, PelUnitBuf &pcYuvPred, const bool &bi, const bool &bioApplied, const bool luma, const bool chroma )

{

  const SPS &    sps     = *cu.sps;

  const int      iRefIdx = cu.refIdx[eRefPicList];

  const bool     isIBC   = CU::isIBC( cu );

  const Picture *refPic  = isIBC ? cu.slice->getPic() : cu.slice->getRefPic( eRefPicList, iRefIdx );

        bool     affine  = cu.affineFlag();

  Mv             mv[3];

  const bool scaled       = refPic ? refPic->isRefScaled( cu.pps ) : false;

  const auto scalingRatio = cu.slice->getScalingRatio( eRefPicList, iRefIdx );

  CHECKD( !CU::isIBC( cu ) && cu.lwidth() == 4 && cu.lheight() == 4, "invalid 4x4 inter blocks" );

  if( affine )

  {

    CHECK( iRefIdx < 0, "iRefIdx incorrect." );

    mv[0] = cu.mv[eRefPicList][0];

    mv[1] = cu.mv[eRefPicList][1];

    mv[2] = cu.mv[eRefPicList][2];

  }

  else

  {

    mv[0] = cu.mv[eRefPicList][0];

    CHECK( !refPic, "xPredInterUni missing ref pic" );

    if( !isIBC && !scaled )

    {

      clipMv( mv[0], m_currCuArea.lumaPos(), m_currCuArea.lumaSize(), sps, *cu.pps );

    }

  }

  const bool wrapRef = !isIBC && cu.sps->getUseWrapAround() && wrapClipMv( mv[0], cu.lumaPos(), cu.lumaSize(), *cu.sps, *cu.pps );

  for( uint32_t comp = COMPONENT_Y; comp < pcYuvPred.bufs.size(); comp++ )

  {

    const ComponentID compID = ComponentID( comp );

    if( compID == COMPONENT_Y && !luma   ) continue;

    if( compID != COMPONENT_Y && !chroma ) continue;

    if( affine )

    {

      CHECK( bioApplied, "BIO is not allowed with affine" );

      m_iRefListIdx = eRefPicList;

      xPredAffineBlk( compID, cu, refPic, eRefPicList, pcYuvPred, bi, cu.slice->clpRng( compID ), cu.slice->getScalingRatio( eRefPicList, iRefIdx ) );

    }

    else

    {

      if( !isIBC && scaled )

      {

        xPredInterBlkRPR( scalingRatio, *cu.pps, compID, cu.chromaFormat, refPic, mv[0], cu.blocks[compID], pcYuvPred.bufs[compID].width, pcYuvPred.bufs[compID].height, pcYuvPred.bufs[compID].buf, pcYuvPred.bufs[compID].stride, bi, wrapRef, cu.slice->clpRng( compID ), 0, cu.imv() == IMV_HPEL );

        CHECKD( bioApplied, "BDOF should be disabled with RPR" );

      }

      else

      {

        xPredInterBlk<false, false>( compID, cu, refPic, mv[0], pcYuvPred.bufs[compID], bi, cu.slice->clpRng( compID ), bioApplied, isIBC, wrapRef );

      }

    }

  }

}

void InterPrediction::xPredInterBi( CodingUnit& cu, PelUnitBuf &pcYuvPred )

{

  const Slice &slice = *cu.slice;

  const PPS   &pps   = *cu.pps;

  PelUnitBuf& pcMbBuf0 = pcYuvPred;

  PelUnitBuf  pcMbBuf1 = isChromaEnabled( cu.chromaFormat ) ? PelUnitBuf( cu.chromaFormat, PelBuf( m_acYuvPred[0], pcYuvPred.Y() ), PelBuf( m_acYuvPred[1], pcYuvPred.Cb() ), PelBuf( m_acYuvPred[2], pcYuvPred.Cr() ) ) : PelUnitBuf( cu.chromaFormat, PelBuf( m_acYuvPred[0], pcYuvPred.Y() ) );

  const bool isBiPred = cu.refIdx[0] >= 0 && cu.refIdx[1] >= 0;

  if( isBiPred )

  {

    m_iRefListIdx = REF_PIC_LIST_0;

    xPredInterUni( cu, REF_PIC_LIST_0, pcMbBuf0, true, false, true, true );

    m_iRefListIdx = REF_PIC_LIST_1;

    xPredInterUni( cu, REF_PIC_LIST_1, pcMbBuf1, true, false, true, true );

  }

  else

  {

    m_iRefListIdx = cu.refIdx[0] >= 0 ? REF_PIC_LIST_0 : REF_PIC_LIST_1;

    if( !cu.geoFlag() && ( ( pps.getUseWP() && slice.getSliceType() == P_SLICE ) || ( pps.getWPBiPred() && slice.getSliceType() == B_SLICE ) ) )

    {

      xPredInterUni( cu, RefPicList( m_iRefListIdx ), pcMbBuf0, true, false, true, true );

    }

    else

    {

      xPredInterUni( cu, RefPicList( m_iRefListIdx ), pcYuvPred, cu.geoFlag(), false, true, true );

    }

  }

#ifndef NDEBUG

  for( uint32_t refList = 0; refList < NUM_REF_PIC_LIST_01; refList++ )

  {

    if( cu.refIdx[refList] < 0 )

    {

      continue;

    }

    RefPicList eRefPicList = refList ? REF_PIC_LIST_1 : REF_PIC_LIST_0;

    CHECKD( CU::isIBC( cu ) && eRefPicList != REF_PIC_LIST_0, "Invalid interdir for ibc mode" );

    CHECKD( CU::isIBC( cu ) && cu.refIdx[refList] != MAX_NUM_REF, "Invalid reference index for ibc mode" );

    CHECKD( CU::isInter( cu ) && cu.refIdx[refList] >= slice.getNumRefIdx( eRefPicList ), "Invalid reference index" );

  }

#endif

  if( !cu.geoFlag() )

  {

    if( pps.getWPBiPred() && slice.getSliceType() == B_SLICE && cu.BcwIdx() == BCW_DEFAULT )

    {

      xWeightedPredictionBi( cu, pcMbBuf0, isBiPred ? pcMbBuf1 : pcMbBuf0, pcYuvPred );

    }

    else if( pps.getUseWP() && slice.getSliceType() == P_SLICE )

    {

      xWeightedPredictionUni( cu, pcMbBuf0, REF_PIC_LIST_0, pcYuvPred, -1 );

    }

    else if( isBiPred )

    {

      xWeightedAverage( cu, pcMbBuf0, pcMbBuf1, pcYuvPred, slice.getSPS()->getBitDepths(), slice.clpRngs(), false );

    }

  }

}

template<bool altSrc, bool altSize>

void InterPrediction::xPredInterBlk( const ComponentID&    compID,

                                     const CodingUnit& cu,

                                     const Picture*        refPic,

                                     Mv                    mv,

                                     PelBuf&               dstPic,

                                     bool                  bi,

                                     const ClpRng&         clpRng,

                                     bool                  bioApplied,

                                     bool                  isIBC,

                                     bool                  wrapRef,

                                     SizeType              dmvrWidth,

                                     SizeType              dmvrHeight,

                                     bool                  bilinearMC,

                                     Pel*                  srcPadBuf,

                                     ptrdiff_t             srcPadStride )

{

  CHECK( srcPadBuf == NULL && altSrc, "wrong" );

  const ChromaFormat  chFmt = cu.chromaFormat;

  const bool          rndRes = !bi;

  const int shiftHor = MV_FRACTIONAL_BITS_INTERNAL + getComponentScaleX(compID, chFmt);

  const int shiftVer = MV_FRACTIONAL_BITS_INTERNAL + getComponentScaleY(compID, chFmt);

  const bool useAltHpelIf = cu.imv() == IMV_HPEL;

  const int xFrac     = !isIBC ? mv.hor & ( ( 1 << shiftHor ) - 1 ) : 0;

  const int yFrac     = !isIBC ? mv.ver & ( ( 1 << shiftVer ) - 1 ) : 0;

  const Pel* refPtr    = nullptr;

  ptrdiff_t  refStride = 0;

  if( cu.pps->getNumSubPics() > 1 && cu.pps->getSubPicFromCU( cu ).getTreatedAsPicFlag() )

  {

    const int subPicIdx = cu.pps->getSubPicFromCU( cu ).getSubPicIdx();

    refPtr              = altSrc ? srcPadBuf    : refPic->getSubPicBufPtr   ( subPicIdx, compID, wrapRef );

    refStride           = altSrc ? srcPadStride : refPic->getSubPicBufStride( subPicIdx, compID, wrapRef );

  }

  else

  {

    refPtr    = altSrc ? srcPadBuf    : refPic->getRecoBufPtr   ( compID, wrapRef );

    refStride = altSrc ? srcPadStride : refPic->getRecoBufStride( compID, wrapRef );

  }

  if( !altSrc )

  {

    OFFSET( refPtr, refStride, cu.blocks[compID].x + ( mv.hor >> shiftHor ), cu.blocks[compID].y + ( mv.ver >> shiftVer ) );

  }

  unsigned width, height;

  if( altSize )

  {

    width  = dmvrWidth;

    height = dmvrHeight;

  }

  else

  {

    width  = dstPic.width;

    height = dstPic.height;

  }

  Pel* dstBuf;

  ptrdiff_t dstStride;

  if( bioApplied && compID == COMPONENT_Y )

  {

    // change MC output

    dstStride = width + BIO_ALIGN_SIZE;

    dstBuf    = m_bdofBlock[m_iRefListIdx] + 2 * dstStride + 1;

  }

  else

  {

    dstBuf    = dstPic.buf;

    dstStride = dstPic.stride;

  }

  if( yFrac == 0 )

  {

    m_if.filterHor( compID, refPtr, refStride, dstBuf, dstStride, width, height, xFrac, rndRes, chFmt, clpRng, bilinearMC ? 1 : 0, useAltHpelIf );

  }

  else if( xFrac == 0 )

  {

    m_if.filterVer( compID, refPtr, refStride, dstBuf, dstStride, width, height, yFrac, true, rndRes, chFmt, clpRng, bilinearMC ? 1 : 0, useAltHpelIf );

  }

  else if( bilinearMC )

  {

    m_if.filterN2_2D( compID, refPtr, refStride, dstBuf, dstStride, width, height, xFrac, yFrac, chFmt, clpRng );

  }

  else if( width == 4 && height == 4 )

  {

    m_if.filter4x4( compID, refPtr, refStride, dstBuf, dstStride, 4, 4, xFrac, yFrac, rndRes, chFmt, clpRng );

  }

  else if( width == 16 )

  {

    m_if.filter16xH( compID, refPtr, refStride, dstBuf, dstStride, 16, height, xFrac, yFrac, rndRes, chFmt, clpRng, useAltHpelIf );

  }

  else if( width == 8 )

  {

    m_if.filter8xH( compID, refPtr, refStride, dstBuf, dstStride, 8, height, xFrac, yFrac, rndRes, chFmt, clpRng, useAltHpelIf );

  }

  else

  {

    Pel *tmpBuf = m_tmpBlock;

    ptrdiff_t tmpStride = dmvrWidth ? dmvrWidth : width;

    int vFilterSize = bilinearMC ? NTAPS_BILINEAR : isLuma( compID ) ? NTAPS_LUMA : NTAPS_CHROMA;

    m_if.filterHor( compID, GET_OFFSETY( refPtr, refStride, -( ( vFilterSize >> 1 ) - 1 ) ), refStride, tmpBuf, tmpStride, width, height + vFilterSize - 1, xFrac, false,         chFmt, clpRng, bilinearMC ? 1 : 0, useAltHpelIf );