VVC/JEM代码学习15：xCheckRDCostAffineMerge2Nx2N

Affine模式是JEM中新加的，属于帧间预测，与FRUC,merge,inter形成竞争关系。

#if COM16_C1016_AFFINE

Void TEncCu::xCheckRDCostAffineMerge2Nx2N( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU )
{
  assert( rpcTempCU->getSlice()->getSliceType() != I_SLICE );
  if ( getFastDeltaQp() )
  {
    return;
  }


  TComMvField cAffineMvField[2][3];
  UChar uhInterDirNeighbours[1] = {0};
  Int numValidMergeCand = 0;
  const Bool bTransquantBypassFlag = rpcTempCU->getCUTransquantBypass(0);


  UChar uhDepth = rpcTempCU->getDepth( 0 );
#if JVET_C0024_QTBT
  if (rpcBestCU->getWidth(0) * rpcBestCU->getHeight(0) < 64)//只对大于等于8*8的块执行affine merge;
  {
    return;
  }
  UInt uiWIdx = g_aucConvertToBit[rpcBestCU->getWidth(0)];
  UInt uiHIdx = g_aucConvertToBit[rpcBestCU->getHeight(0)];
#else
  rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth );
#endif
  //得到仿射Merge候选;
  rpcTempCU->getAffineMergeCandidates( 0, 0, cAffineMvField, uhInterDirNeighbours, numValidMergeCand );
  if ( numValidMergeCand == -1 )//如果merge候选个数为-1，则退出，不执行Affine merge
  {
    return;
  }
  Int mergeCandBuffer[1] = {0};


  UInt iteration;
  if ( rpcTempCU->isLosslessCoded(0))//无损编码迭代次数为1，否则为2;
  {
    iteration = 1;
  }
  else
  {
    iteration = 2;
  }
  ///至少迭代一次，如果没有残差，则不会进行第二次迭代//
  for ( UInt uiNoResidual = 0; uiNoResidual < iteration; ++uiNoResidual )
  {//遍历所有有效的Merge候选;
    for ( UInt uiMergeCand = 0; uiMergeCand < numValidMergeCand; ++uiMergeCand )//numValidMergeCand=1;
    {//第一次迭代uiNoResidual=0，if条件一定成立，会执行里面的内容;
	 //第二次迭代中，如果在第一次迭代时，没有残差，则mergeCandBuffer[uiMergeCand]=1 ，此时不满足if条件，不进入下面的步骤;
      if ( !( uiNoResidual==1 && mergeCandBuffer[uiMergeCand]==1 ) )
      {
        // set MC parameters,设置运动补偿参数;
        rpcTempCU->setPredModeSubParts( MODE_INTER, 0, uhDepth );//设置预测模式为帧间;
        rpcTempCU->setCUTransquantBypassSubParts( bTransquantBypassFlag, 0, uhDepth );//设置TransquantBypassFlag;
        rpcTempCU->setChromaQpAdjSubParts( bTransquantBypassFlag ? 0 : m_cuChromaQpOffsetIdxPlus1, 0, uhDepth );//设置色度QP调整
#if !JVET_C0024_QTBT
        rpcTempCU->setPartSizeSubParts( SIZE_2Nx2N, 0, uhDepth );
#endif
        rpcTempCU->setAffineFlagSubParts( true, 0, 0, uhDepth );//设置Affine flag为true;
        rpcTempCU->setMergeFlagSubParts( true, 0, 0, uhDepth );//设置merge flag为true;
        rpcTempCU->setMergeIndexSubParts( uiMergeCand, 0, 0, uhDepth );//设置mergeidx 设置为0；
        rpcTempCU->setInterDirSubParts( uhInterDirNeighbours[uiMergeCand], 0, 0, uhDepth );//将帧间模式设置为uhInterDirNeighbours[uiMergeCand]
        rpcTempCU->setAllAffineMvField( 0, 0, cAffineMvField[0 + 2*uiMergeCand], REF_PIC_LIST_0, 0 );//设置affine mvf;
        rpcTempCU->setAllAffineMvField( 0, 0, cAffineMvField[1 + 2*uiMergeCand], REF_PIC_LIST_1, 0 );


#if COM16_C806_OBMC
        rpcTempCU->setOBMCFlagSubParts( true, 0, uhDepth );//设置OBMC Flag为true
#endif


        // do MC,做运动补偿
#if JVET_C0024_QTBT
        m_pcPredSearch->motionCompensation ( rpcTempCU, m_pppcPredYuvTemp[uiWIdx][uiHIdx] );


#if COM16_C806_OBMC//进行重叠块运动补偿;
        m_pcPredSearch->subBlockOBMC( rpcTempCU, 0, m_pppcPredYuvTemp[uiWIdx][uiHIdx], m_pppcTmpYuv1[uiWIdx][uiHIdx], m_pppcTmpYuv2[uiWIdx][uiHIdx] );
#endif
        // estimate residual and encode everything,估计残差和编码所有数据
        m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
                                                   m_pppcOrigYuv    [uiWIdx][uiHIdx],
                                                   m_pppcPredYuvTemp[uiWIdx][uiHIdx],
                                                   m_pppcResiYuvTemp[uiWIdx][uiHIdx],
                                                   m_pppcResiYuvBest[uiWIdx][uiHIdx],
                                                   m_pppcRecoYuvTemp[uiWIdx][uiHIdx],
                                                   (uiNoResidual != 0) 
#if COM16_C806_EMT
                                                   , rpcBestCU->getTotalCost()
#endif
          );
#else
        m_pcPredSearch->motionCompensation ( rpcTempCU, m_ppcPredYuvTemp[uhDepth] );


#if COM16_C806_OBMC
        m_pcPredSearch->subBlockOBMC( rpcTempCU, 0, m_ppcPredYuvTemp[uhDepth], m_ppcTmpYuv1[uhDepth], m_ppcTmpYuv2[uhDepth] );
#endif
        // estimate residual and encode everything
        m_pcPredSearch->encodeResAndCalcRdInterCU( rpcTempCU,
                                                   m_ppcOrigYuv    [uhDepth],
                                                   m_ppcPredYuvTemp[uhDepth],
                                                   m_ppcResiYuvTemp[uhDepth],
                                                   m_ppcResiYuvBest[uhDepth],
                                                   m_ppcRecoYuvTemp[uhDepth],
                                                   (uiNoResidual != 0) 
#if COM16_C806_EMT
                                                   , rpcBestCU->getTotalCost()
#endif
          );
#endif
        if ( uiNoResidual == 0 && rpcTempCU->getQtRootCbf(0) == 0 )
        { //如果是第一次迭代，且cbf为0时（即无残差时），令mergeCandBuffer[uiMergeCnad]=1;
          // If no residual when allowing for one, then set mark to not try case where residual is forced to 0
          mergeCandBuffer[uiMergeCand] = 1;
        }


        rpcTempCU->setSkipFlagSubParts( rpcTempCU->getQtRootCbf(0) == 0, 0, uhDepth );//如果当前CU的cbf为0时，设置Skip Flag为true,否则为false
        Int orgQP = rpcTempCU->getQP( 0 );
        xCheckDQP( rpcTempCU );
        xCheckBestMode(rpcBestCU, rpcTempCU, uhDepth);
        rpcTempCU->initEstData( uhDepth, orgQP, bTransquantBypassFlag );//比较完TempCU和BestCU，就将TempCU重新初始化
      }
    }//遍历merge候选结束/
  }///迭代结束///
}
#endif

//得到Affine的merge候选预测模式
Void TComDataCU::getAffineMergeCandidates( UInt uiAbsPartIdx, UInt uiPUIdx, TComMvField (*pcMvFieldNeighbours)[3], UChar* puhInterDirNeighbours, Int& numValidMergeCand, Int mrgCandIdx )
{
  TComMvField affineMvField[2][3];//2是表示有两个双向预测,3是表示3种运动矢量场？？？
  UInt uiAbsPartAddr = m_absZIdxInCtu + uiAbsPartIdx;

  TComDataCU *pcTempCU = NULL;
  Bool bAvailable = false;
  UInt uiPartIdx = 0;
  //初始化运动场
  for ( Int mvNum = 0; mvNum < 3; mvNum++ )
  {
    pcMvFieldNeighbours[0][mvNum].setMvField( TComMv(0,0), -1 );
    pcMvFieldNeighbours[1][mvNum].setMvField( TComMv(0,0), -1 );
  }

  // Get Part Index in LCU，得到CU在LCU的索引
  UInt uiPartIdxLT, uiPartIdxRT, uiPartIdxLB;
  deriveLeftRightTopIdxGeneral( uiAbsPartIdx, uiPUIdx, uiPartIdxLT, uiPartIdxRT );//推导左上part和右上part的索引
  deriveLeftBottomIdxGeneral  ( uiAbsPartIdx, uiPUIdx, uiPartIdxLB );//推导左下part的索引
  //当一个CU应用AF_MERGE模式时，从有效的相邻重建块中得到第一个用仿射模式的编码块。候选块的选择顺序是从左，上，右上，左下到左上
  // left
  pcTempCU = getPULeft( uiPartIdx, uiPartIdxLB );
  bAvailable = pcTempCU && pcTempCU->isAffine( uiPartIdx );//左边CU是否是Affine模式

  // above
  if ( !bAvailable )//如果左边不是，则查看上边的CU
  {
    pcTempCU = getPUAbove( uiPartIdx, uiPartIdxRT );
    bAvailable = pcTempCU && pcTempCU->isAffine( uiPartIdx );
  }

  // aboveRight
  if ( !bAvailable )//上边不是，则查看右上CU
  {
    pcTempCU = getPUAboveRight( uiPartIdx, uiPartIdxRT );
    bAvailable = pcTempCU && pcTempCU->isAffine( uiPartIdx );
  }

  // leftBottom
  if ( !bAvailable )//右上不是，则查看左下CU
  {
    pcTempCU = getPUBelowLeft( uiPartIdx, uiPartIdxLB );
    bAvailable = pcTempCU && pcTempCU->isAffine( uiPartIdx );
  }

  // aboveLeft
  if ( !bAvailable )//左下不是，则查看左上CU
  {
    pcTempCU = getPUAboveLeft( uiPartIdx, uiAbsPartAddr );
    bAvailable = pcTempCU && pcTempCU->isAffine( uiPartIdx );
  }

  if ( !bAvailable )//如果5个相邻块都不是仿射模式，则有效的merge候选个数为0，退出;
  {
    numValidMergeCand = -1;
    return;
  }
  else//否则，有效的merge候选个数为1;
  {
    assert( pcTempCU );
    numValidMergeCand = 1;
  }

  Int width = pcTempCU->getWidth(uiPartIdx);
  Int height = pcTempCU->getHeight(uiPartIdx);
#if !JVET_C0024_QTBT
  Int depth  = pcTempCU->getDepth(uiPartIdx);
  Int numPart = pcTempCU->getPic()->getNumPartitionsInCtu() >> ( depth << 1 );
#endif
  Int iPartW = width / getPic()->getMinCUWidth();
  Int iPartH = height / getPic()->getMinCUHeight();

#if JVET_C0024_QTBT
  Int iBlkY = g_auiZscanToRaster[uiPartIdx]/(getPic()->getNumPartInCtuWidth()*iPartH);
  Int iBlkX = (g_auiZscanToRaster[uiPartIdx]%getPic()->getNumPartInCtuWidth())/iPartW;
  Int aboveLeftIdx = g_auiRasterToZscan[iBlkY * getPic()->getNumPartInCtuWidth() * iPartH + iBlkX * iPartW];
#else
  Int aboveLeftIdx = uiPartIdx - ( uiPartIdx % numPart );
#endif
  Int aboveRightIdx = g_auiRasterToZscan[ g_auiZscanToRaster[aboveLeftIdx] + iPartW - 1 ];
  Int bottomLeftIdx = g_auiRasterToZscan[ g_auiZscanToRaster[aboveLeftIdx] + ( iPartH - 1 ) * getPic()->getNumPartInCtuWidth() ];

  // list0
  affineMvField[0][0].setMvField( pcTempCU->getCUMvField(REF_PIC_LIST_0)->getMv( aboveLeftIdx ),  pcTempCU->getCUMvField(REF_PIC_LIST_0)->getRefIdx( aboveLeftIdx ) );
  affineMvField[0][1].setMvField( pcTempCU->getCUMvField(REF_PIC_LIST_0)->getMv( aboveRightIdx ), pcTempCU->getCUMvField(REF_PIC_LIST_0)->getRefIdx( aboveRightIdx ) );
  affineMvField[0][2].setMvField( pcTempCU->getCUMvField(REF_PIC_LIST_0)->getMv( bottomLeftIdx ), pcTempCU->getCUMvField(REF_PIC_LIST_0)->getRefIdx( bottomLeftIdx ) );

  // list1
  affineMvField[1][0].setMvField( pcTempCU->getCUMvField(REF_PIC_LIST_1)->getMv( aboveLeftIdx ),  pcTempCU->getCUMvField(REF_PIC_LIST_1)->getRefIdx( aboveLeftIdx ) );
  affineMvField[1][1].setMvField( pcTempCU->getCUMvField(REF_PIC_LIST_1)->getMv( aboveRightIdx ), pcTempCU->getCUMvField(REF_PIC_LIST_1)->getRefIdx( aboveRightIdx ) );
  affineMvField[1][2].setMvField( pcTempCU->getCUMvField(REF_PIC_LIST_1)->getMv( bottomLeftIdx ), pcTempCU->getCUMvField(REF_PIC_LIST_1)->getRefIdx( bottomLeftIdx ) );

  Int pixelOrgX    = g_auiRasterToPelX[ g_auiZscanToRaster[ aboveLeftIdx ] ] + pcTempCU->getCUPelX();
  Int pixelCurrX   = getCUPelX();
  Int pixelOrgY    = g_auiRasterToPelY[ g_auiZscanToRaster[ aboveLeftIdx ] ] + pcTempCU->getCUPelY();
  Int pixelCurrY   = getCUPelY();
  //计算运动矢量场;
  //vx0,vx1,vx2,vy0,vy1,vy2表示G1001里等式15？？？
  Int vx0 = Int( affineMvField[0][0].getHor() + 1.0 * ( affineMvField[0][2].getHor() - affineMvField[0][0].getHor() ) * ( pixelCurrY - pixelOrgY ) / height
    + 1.0 * ( affineMvField[0][1].getHor() - affineMvField[0][0].getHor() ) * ( pixelCurrX - pixelOrgX ) / width );
  Int vy0 = Int( affineMvField[0][0].getVer() + 1.0 * ( affineMvField[0][2].getVer() - affineMvField[0][0].getVer() ) * ( pixelCurrY - pixelOrgY ) / height
    + 1.0 * ( affineMvField[0][1].getVer() - affineMvField[0][0].getVer() ) * ( pixelCurrX - pixelOrgX ) / width );
  pcMvFieldNeighbours[0][0].setMvField( TComMv(vx0, vy0), affineMvField[0][0].getRefIdx() );
  if ( getSlice()->isInterB() )//如果是B_SLICE，则还要计算另一个方向的运动矢量场;
  {
    vx0 = Int( affineMvField[1][0].getHor() + 1.0 * ( affineMvField[1][2].getHor() - affineMvField[1][0].getHor() ) * ( pixelCurrY - pixelOrgY ) / height 
      + 1.0 * ( affineMvField[1][1].getHor() - affineMvField[1][0].getHor() ) * ( pixelCurrX - pixelOrgX ) / width );
    vy0 = Int( affineMvField[1][0].getVer() + 1.0 * ( affineMvField[1][2].getVer() - affineMvField[1][0].getVer() ) * ( pixelCurrY - pixelOrgY ) / height 
      + 1.0 * ( affineMvField[1][1].getVer() - affineMvField[1][0].getVer() ) * ( pixelCurrX - pixelOrgX ) / width );
    pcMvFieldNeighbours[1][0].setMvField( TComMv(vx0, vy0), affineMvField[1][0].getRefIdx() );
  }

  Int vx1 = Int( 1.0 * ( affineMvField[0][1].getHor() - affineMvField[0][0].getHor() ) * getWidth(0) / width + pcMvFieldNeighbours[0][0].getHor() );
  Int vy1 = Int( 1.0 * ( affineMvField[0][1].getVer() - affineMvField[0][0].getVer() ) * getWidth(0) / width + pcMvFieldNeighbours[0][0].getVer() );
  pcMvFieldNeighbours[0][1].setMvField( TComMv(vx1, vy1), affineMvField[0][0].getRefIdx() );
  if ( getSlice()->isInterB() )//如果是B_SLICE，则还要计算另一个方向的运动矢量场;
  {
    vx1 = Int( 1.0 * ( affineMvField[1][1].getHor() - affineMvField[1][0].getHor() ) * getWidth(0) / width + pcMvFieldNeighbours[1][0].getHor() );
    vy1 = Int( 1.0 * ( affineMvField[1][1].getVer() - affineMvField[1][0].getVer() ) * getWidth(0) / width + pcMvFieldNeighbours[1][0].getVer() );
    pcMvFieldNeighbours[1][1].setMvField( TComMv(vx1, vy1), affineMvField[1][0].getRefIdx() );
  }

  Int vx2 = Int( 1.0 * ( affineMvField[0][2].getHor() - affineMvField[0][0].getHor() ) * getHeight(0) / height + pcMvFieldNeighbours[0][0].getHor() );
  Int vy2 = Int( 1.0 * ( affineMvField[0][2].getVer() - affineMvField[0][0].getVer() ) * getHeight(0) / height + pcMvFieldNeighbours[0][0].getVer() );
  pcMvFieldNeighbours[0][2].setMvField( TComMv(vx2, vy2), affineMvField[0][0].getRefIdx() );
  if ( getSlice()->isInterB() )//如果是B_SLICE，则还要计算另一个方向的运动矢量场;
  {
    vx2 = Int( 1.0 * ( affineMvField[1][2].getHor() - affineMvField[1][0].getHor() ) * getHeight(0) / height + pcMvFieldNeighbours[1][0].getHor() );
    vy2 = Int( 1.0 * ( affineMvField[1][2].getVer() - affineMvField[1][0].getVer() ) * getHeight(0) / height + pcMvFieldNeighbours[1][0].getVer() );
    pcMvFieldNeighbours[1][2].setMvField( TComMv(vx2, vy2), affineMvField[1][0].getRefIdx() );
  }

  puhInterDirNeighbours[0] = pcTempCU->getInterDir( uiPartIdx );
  return;
}