VTM3.0代码阅读：getInterMergeCandidates函数

最新推荐文章于 2021-05-25 09:19:34 发布
最新推荐文章于 2021-05-25 09:19:34 发布
阅读量257 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gq0323/article/details/103721363
版权

xCheckRDCostMerge2Nx2N函数中调用getInterMergeCandidates获取merge候选，存储于mrgCtx。
MergeCtx类用来表示merge候选列表，其中存储merge候选列表中的各种信息：

class MergeCtx
{
	//...
public:
  MvField       mvFieldNeighbours [ MRG_MAX_NUM_CANDS << 1 ]; // double length for mv of both lists	双向mv，所以列表长为7*2，存储merge候选的mv和refIdx
  #if JVET_L0646_GBI
  uint8_t       GBiIdx            [ MRG_MAX_NUM_CANDS      ];
#endif
  unsigned char interDirNeighbours[ MRG_MAX_NUM_CANDS      ];	//merge候选的帧间方向
  MergeType     mrgTypeNeighbours [ MRG_MAX_NUM_CANDS      ];	//merge候选的merge模式
  int           numValidMergeCand;								//merge候选数目
  bool          hasMergedCandList;								//是否存在merge候选列表

  Void setMergeInfo( PredictionUnit& pu, int candIdx );
};

merge列表构成流程：
merge列表初始化；
获取空域的merge候选信息，顺序依次为pu的左、上、右上、左下，如果不足4个，再加入左上；
获取时域的merge候选信息，位置为当前pu的右下位置和中心位置；
添加HMVP；
添加组合平均mvp；
用0补全merge候选列表。

getInterMergeCandidates函数和L1002文档描述构建merge列表的方法是一样的
相比于VTM1.0，其中添加了HMVP和成对平均mvp
过程当中也穿插了GBI、CPR和MMVD的一些东西
注意一下对CPR_Merge候选的处理

void PU::getInterMergeCandidates( const PredictionUnit &pu, MergeCtx& mrgCtx,
#if JVET_L0054_MMVD
                                 int mmvdList,
#endif
                                 const int& mrgCandIdx )
{
  const CodingStructure &cs  = *pu.cs;
  const Slice &slice         = *pu.cs->slice;
  const uint32_t maxNumMergeCand = slice.getMaxNumMergeCand();		//最大merge候选数目为7
  const bool canFastExit     = pu.cs->pps->getLog2ParallelMergeLevelMinus2() == 0;

  for (uint32_t ui = 0; ui < maxNumMergeCand; ++ui)	//merge候选列表的初始化
  {
#if !JVET_L0090_PAIR_AVG
    isCandInter[ui] = false;
#endif
#if JVET_L0646_GBI
    mrgCtx.GBiIdx[ui] = GBI_DEFAULT;
#endif
    mrgCtx.interDirNeighbours[ui] = 0;
    mrgCtx.mrgTypeNeighbours [ui] = MRG_TYPE_DEFAULT_N;
    mrgCtx.mvFieldNeighbours[(ui << 1)    ].refIdx = NOT_VALID;
    mrgCtx.mvFieldNeighbours[(ui << 1) + 1].refIdx = NOT_VALID;
  }

  mrgCtx.numValidMergeCand = maxNumMergeCand;		//numValidMergeCand=7
  // compute the location of the current PU

  int cnt = 0;


#if JVET_L0293_CPR && JVET_L0054_MMVD
  int mrgCandIdxCPR = mrgCandIdx;
#endif
#if JVET_L0293_CPR && !JVET_L0369_SUBBLOCK_MERGE
  int cntCPR = 0;
#endif

  const Position posLT = pu.Y().topLeft();
  const Position posRT = pu.Y().topRight();
  const Position posLB = pu.Y().bottomLeft();		//当前pu的左上、右上、左下坐标

  MotionInfo miAbove, miLeft, miAboveLeft, miAboveRight, miBelowLeft;

  //left
  const PredictionUnit* puLeft = cs.getPURestricted( posLB.offset( -1, 0 ), pu, pu.chType );	//获取当前pu左侧的pu

  const bool isAvailableA1 = puLeft && isDiffMER( pu, *puLeft ) && pu.cu != puLeft->cu && CU::isInter( *puLeft->cu );	//获取的左侧pu的运动信息是否可用

  if( isAvailableA1 )		//如果左侧pu的运动信息可用，则加入merge候选列表中
  {
    miLeft = puLeft->getMotionInfo( posLB.offset(-1, 0) );		//左侧pu的运动信息

#if !JVET_L0090_PAIR_AVG
    isCandInter[cnt] = true;
#endif

    // get Inter Dir
    mrgCtx.interDirNeighbours[cnt] = miLeft.interDir;		//运动信息加入merge候选列表
#if JVET_L0646_GBI
    mrgCtx.GBiIdx[cnt] = (mrgCtx.interDirNeighbours[cnt] == 3) ? puLeft->cu->GBiIdx : GBI_DEFAULT;
#endif
    // get Mv from Left
#if JVET_L0293_CPR
    if (puLeft->cu->cpr)
    {
      mrgCtx.mrgTypeNeighbours[cnt] = MRG_TYPE_CPR;		//如果相邻pu为CPR模式，那么加入merge列表时记录一下
#if !JVET_L0369_SUBBLOCK_MERGE
      cntCPR++;

#endif
#if JVET_L0293_CPR && JVET_L0054_MMVD
      if (mmvdList != 0 && mrgCandIdx != -1)
        mrgCandIdxCPR++;
#endif
    }
#endif
    mrgCtx.mvFieldNeighbours[cnt << 1].setMvField(miLeft.mv[0], miLeft.refIdx[0]);	//运动信息加入merge候选列表

    if (slice.isInterB())
    {
      mrgCtx.mvFieldNeighbours[(cnt << 1) + 1].setMvField(miLeft.mv[1], miLeft.refIdx[1]);
    }
#if JVET_L0293_CPR && JVET_L0054_MMVD
    if (mrgCandIdxCPR == cnt && canFastExit)
#else
    if( mrgCandIdx == cnt && canFastExit )
#endif
    {
      return;
    }

    cnt++;
  }

  // early termination
  if (cnt == maxNumMergeCand)	//若merge候选列表已满，return
  {
    return;
  }


  // above					//上侧的pu运动信息，处理方法与上面相同
  const PredictionUnit *puAbove = cs.getPURestricted( posRT.offset( 0, -1 ), pu, pu.chType );

  bool isAvailableB1 = puAbove && isDiffMER( pu, *puAbove ) && pu.cu != puAbove->cu && CU::isInter( *puAbove->cu );

  if( isAvailableB1 )
  {
    miAbove = puAbove->getMotionInfo( posRT.offset( 0, -1 ) );

    if( !isAvailableA1 || ( miAbove != miLeft ) )
    {
#if !JVET_L0090_PAIR_AVG
      isCandInter[cnt] = true;
#endif

      // get Inter Dir
      mrgCtx.interDirNeighbours[cnt] = miAbove.interDir;
      // get Mv from Above
#if JVET_L0646_GBI
      mrgCtx.GBiIdx[cnt] = (mrgCtx.interDirNeighbours[cnt] == 3) ? puAbove->cu->GBiIdx : GBI_DEFAULT;
#endif
#if JVET_L0293_CPR
      if (puAbove->cu->cpr)
      {
        mrgCtx.mrgTypeNeighbours[cnt] = MRG_TYPE_CPR;
#if !JVET_L0369_SUBBLOCK_MERGE
        cntCPR++;

#endif
#if JVET_L0293_CPR && JVET_L0054_MMVD
        if (mmvdList != 0 && mrgCandIdx != -1)
          mrgCandIdxCPR++;
#endif
      }
#endif
	    mrgCtx.mvFieldNeighbours[cnt << 1].setMvField( miAbove.mv[0], miAbove.refIdx[0] );

      if( slice.isInterB() )
      {
        mrgCtx.mvFieldNeighbours[( cnt << 1 ) + 1].setMvField( miAbove.mv[1], miAbove.refIdx[1] );
      }
#if JVET_L0293_CPR && JVET_L0054_MMVD
      if (mrgCandIdxCPR == cnt && canFastExit)
#else
      if( mrgCandIdx == cnt && canFastExit )
#endif
      {
        return;
      }

      cnt++;
    }
  }

  // early termination
  if( cnt == maxNumMergeCand )
  {
    return;
  }

  // above right				//右上侧pu运动信息，处理方法与上面相同
  const PredictionUnit *puAboveRight = cs.getPURestricted( posRT.offset( 1, -1 ), pu, pu.chType );

  bool isAvailableB0 = puAboveRight && isDiffMER( pu, *puAboveRight ) && CU::isInter( *puAboveRight->cu );

  if( isAvailableB0 )
  {
    miAboveRight = puAboveRight->getMotionInfo( posRT.offset( 1, -1 ) );

#if HM_JEM_MERGE_CANDS
    if( ( !isAvailableB1 || ( miAbove != miAboveRight ) ) && ( !isAvailableA1 || ( miLeft != miAboveRight ) ) )
#else
    if( !isAvailableB1 || ( miAbove != miAboveRight ) )
#endif
    {
#if !JVET_L0090_PAIR_AVG
      isCandInter[cnt] = true;
#endif

      // get Inter Dir
      mrgCtx.interDirNeighbours[cnt] = miAboveRight.interDir;
      // get Mv from Above-right
#if JVET_L0646_GBI
      mrgCtx.GBiIdx[cnt] = (mrgCtx.interDirNeighbours[cnt] == 3) ? puAboveRight->cu->GBiIdx : GBI_DEFAULT;
#endif
#if JVET_L0293_CPR
      if (puAboveRight->cu->cpr)
      {
        mrgCtx.mrgTypeNeighbours[cnt] = MRG_TYPE_CPR;
#if !JVET_L0369_SUBBLOCK_MERGE
        cntCPR++;

#endif
#if JVET_L0293_CPR && JVET_L0054_MMVD
        if (mmvdList != 0 && mrgCandIdx != -1)
          mrgCandIdxCPR++;
#endif
      }
#endif
	    mrgCtx.mvFieldNeighbours[cnt << 1].setMvField( miAboveRight.mv[0], miAboveRight.refIdx[0] );

      if( slice.isInterB() )
      {
        mrgCtx.mvFieldNeighbours[( cnt << 1 ) + 1].setMvField( miAboveRight.mv[1], miAboveRight.refIdx[1] );
      }

#if JVET_L0293_CPR && JVET_L0054_MMVD
      if (mrgCandIdxCPR == cnt && canFastExit)
#else
      if( mrgCandIdx == cnt && canFastExit )
#endif
      {
        return;
      }

      cnt++;
    }
  }
  // early termination
  if( cnt == maxNumMergeCand )
  {
    return;
  }

  //left bottom					//左下侧pu运动信息，处理方法与上面相同
  const PredictionUnit *puLeftBottom = cs.getPURestricted( posLB.offset( -1, 1 ), pu, pu.chType );

  bool isAvailableA0 = puLeftBottom && isDiffMER( pu, *puLeftBottom ) && CU::isInter( *puLeftBottom->cu );

  if( isAvailableA0 )
  {
    miBelowLeft = puLeftBottom->getMotionInfo( posLB.offset( -1, 1 ) );

#if HM_JEM_MERGE_CANDS
    if( ( !isAvailableA1 || ( miBelowLeft != miLeft ) ) && ( !isAvailableB1 || ( miBelowLeft != miAbove ) ) && ( !isAvailableB0 || ( miBelowLeft != miAboveRight ) ) )
#else
    if( !isAvailableA1 || ( miBelowLeft != miLeft ) )
#endif
    {
#if !JVET_L0090_PAIR_AVG
      isCandInter[cnt] = true;
#endif

      // get Inter Dir
      mrgCtx.interDirNeighbours[cnt] = miBelowLeft.interDir;
#if JVET_L0646_GBI
      mrgCtx.GBiIdx[cnt] = (mrgCtx.interDirNeighbours[cnt] == 3) ? puLeftBottom->cu->GBiIdx : GBI_DEFAULT;
#endif
      // get Mv from Bottom-Left
#if JVET_L0293_CPR
      if (puLeftBottom->cu->cpr)
      {
        mrgCtx.mrgTypeNeighbours[cnt] = MRG_TYPE_CPR;
#if !JVET_L0369_SUBBLOCK_MERGE
        cntCPR++;

#endif
#if JVET_L0293_CPR && JVET_L0054_MMVD
        if (mmvdList != 0 && mrgCandIdx != -1)
          mrgCandIdxCPR++;
#endif
      }
#endif
      mrgCtx.mvFieldNeighbours[cnt << 1].setMvField( miBelowLeft.mv[0], miBelowLeft.refIdx[0] );

      if( slice.isInterB() )
      {
        mrgCtx.mvFieldNeighbours[( cnt << 1 ) + 1].setMvField( miBelowLeft.mv[1], miBelowLeft.refIdx[1] );
      }

#if JVET_L0293_CPR && JVET_L0054_MMVD
      if (mrgCandIdxCPR == cnt && canFastExit)
#else
      if( mrgCandIdx == cnt && canFastExit )
#endif
      {
        return;
      }

      cnt++;
    }
  }
  // early termination
  if( cnt == maxNumMergeCand )
  {
    return;
  }

  // above left
#if JVET_L0369_SUBBLOCK_MERGE
  if ( cnt < 4 )				//如果4个位置没有获得满4个运动信息，那么merge候选列表加入左上侧pu的运动信息
#else
  if( cnt < ( enableSubPuMvp ? 6 : 4 ) )
#endif
  {
    const PredictionUnit *puAboveLeft = cs.getPURestricted( posLT.offset( -1, -1 ), pu, pu.chType );

    bool isAvailableB2 = puAboveLeft && isDiffMER( pu, *puAboveLeft ) && CU::isInter( *puAboveLeft->cu );

    if( isAvailableB2 )
    {
      miAboveLeft = puAboveLeft->getMotionInfo( posLT.offset( -1, -1 ) );

#if HM_JEM_MERGE_CANDS
      if( ( !isAvailableA1 || ( miLeft != miAboveLeft ) ) && ( !isAvailableB1 || ( miAbove != miAboveLeft ) ) && ( !isAvailableA0 || ( miBelowLeft != miAboveLeft ) ) && ( !isAvailableB0 || ( miAboveRight != miAboveLeft ) ) )
#else
      if( ( !isAvailableA1 || ( miLeft != miAboveLeft ) ) && ( !isAvailableB1 || ( miAbove != miAboveLeft ) ) )
#endif
      {
#if !JVET_L0090_PAIR_AVG
        isCandInter[cnt] = true;
#endif

        // get Inter Dir
        mrgCtx.interDirNeighbours[cnt] = miAboveLeft.interDir;
#if JVET_L0646_GBI
        mrgCtx.GBiIdx[cnt] = (mrgCtx.interDirNeighbours[cnt] == 3) ? puAboveLeft->cu->GBiIdx : GBI_DEFAULT;
#endif
        // get Mv from Above-Left
#if JVET_L0293_CPR
        if (puAboveLeft->cu->cpr)
        {
          mrgCtx.mrgTypeNeighbours[cnt] = MRG_TYPE_CPR;
#if !JVET_L0369_SUBBLOCK_MERGE
          cntCPR++;

#endif
#if JVET_L0293_CPR && JVET_L0054_MMVD
          if (mmvdList != 0 && mrgCandIdx != -1)
            mrgCandIdxCPR++;
#endif
        }
#endif
        mrgCtx.mvFieldNeighbours[cnt << 1].setMvField( miAboveLeft.mv[0], miAboveLeft.refIdx[0] );

        if( slice.isInterB() )
        {
          mrgCtx.mvFieldNeighbours[( cnt << 1 ) + 1].setMvField( miAboveLeft.mv[1], miAboveLeft.refIdx[1] );
        }

#if JVET_L0293_CPR && JVET_L0054_MMVD
        if (mrgCandIdxCPR == cnt && canFastExit)
#else
        if( mrgCandIdx == cnt && canFastExit )
#endif
        {
          return;
        }

        cnt++;
      }
    }
  }
  // early termination
  if (cnt == maxNumMergeCand)
  {
    return;
  }

  if (slice.getEnableTMVPFlag())			//merge候选列表加入时域候选TMVP
  {
    //>> MTK colocated-RightBottom
    // offset the pos to be sure to "point" to the same position the uiAbsPartIdx would've pointed to
    Position posRB = pu.Y().bottomRight().offset(-3, -3);

    const PreCalcValues& pcv = *cs.pcv;

    Position posC0;
    Position posC1 = pu.Y().center();
    bool C0Avail = false;

    if (((posRB.x + pcv.minCUWidth) < pcv.lumaWidth) && ((posRB.y + pcv.minCUHeight) < pcv.lumaHeight))
    {
      {
        Position posInCtu( posRB.x & pcv.maxCUWidthMask, posRB.y & pcv.maxCUHeightMask );

        if( ( posInCtu.x + 4 < pcv.maxCUWidth ) &&           // is not at the last column of CTU
            ( posInCtu.y + 4 < pcv.maxCUHeight ) )           // is not at the last row    of CTU
        {
          posC0 = posRB.offset( 4, 4 );
          C0Avail = true;
        }
        else if( posInCtu.x + 4 < pcv.maxCUWidth )           // is not at the last column of CTU But is last row of CTU
        {
          posC0 = posRB.offset( 4, 4 );
          // in the reference the CTU address is not set - thus probably resulting in no using this C0 possibility
        }
        else if( posInCtu.y + 4 < pcv.maxCUHeight )          // is not at the last row of CTU But is last column of CTU
        {
          posC0 = posRB.offset( 4, 4 );
          C0Avail = true;
        }
        else //is the right bottom corner of CTU
        {
          posC0 = posRB.offset( 4, 4 );
          // same as for last column but not last row
        }
      }
    }

    Mv        cColMv;
    int       iRefIdx     = 0;
    int       dir         = 0;
    unsigned  uiArrayAddr = cnt;		//getColocatedMVP获取posC0和posC1位置的时域MV，存入cColMv，L0前向mv
    bool      bExistMV    = ( C0Avail && getColocatedMVP(pu, REF_PIC_LIST_0, posC0, cColMv, iRefIdx ) )
                                      || getColocatedMVP(pu, REF_PIC_LIST_0, posC1, cColMv, iRefIdx );

    if (bExistMV)
    {
      dir     |= 1;
      mrgCtx.mvFieldNeighbours[2 * uiArrayAddr].setMvField(cColMv, iRefIdx);
    }

    if (slice.isInterB())
    {
      bExistMV = ( C0Avail && getColocatedMVP(pu, REF_PIC_LIST_1, posC0, cColMv, iRefIdx ) )	//B帧的反向mv
                           || getColocatedMVP(pu, REF_PIC_LIST_1, posC1, cColMv, iRefIdx );
      if (bExistMV)
      {
        dir     |= 2;
        mrgCtx.mvFieldNeighbours[2 * uiArrayAddr + 1].setMvField(cColMv, iRefIdx);
      }
    }

    if( dir != 0 )			//dir不为0，即获得到了TMVP
    {
      bool addTMvp = true;

      if( addTMvp )			//TMVP运动信息加入到merge列表中
      {
        mrgCtx.interDirNeighbours[uiArrayAddr] = dir;
#if !JVET_L0090_PAIR_AVG
        isCandInter              [uiArrayAddr] = true;
#endif
#if JVET_L0646_GBI
        mrgCtx.GBiIdx[uiArrayAddr] = GBI_DEFAULT;
#endif
#if JVET_L0293_CPR && JVET_L0054_MMVD
        if (mrgCandIdxCPR == cnt && canFastExit)
#else
        if( mrgCandIdx == cnt && canFastExit )
#endif
        {
          return;
        }

        cnt++;
      }
    }
  }

  // early termination
  if (cnt == maxNumMergeCand)
  {
    return;
  }

#if JVET_L0266_HMVP						//HMVP   同一行ctu已编码cu的mvp
  int maxNumMergeCandMin1 = maxNumMergeCand - 1;
  if (cnt != maxNumMergeCandMin1)		//HMVP最多补到MAX-1
  {
#if JVET_L0369_SUBBLOCK_MERGE
    bool isAvailableSubPu = false;
    unsigned subPuMvpPos = 0;
#endif
#if JVET_L0090_PAIR_AVG
    bool bFound = addMergeHMVPCand(slice, mrgCtx, canFastExit
#if JVET_L0293_CPR && JVET_L0054_MMVD
      , (mmvdList != 0 && mrgCandIdx != -1) ? (const int) mrgCandIdxCPR : mrgCandIdx
#else
      , mrgCandIdx
#endif
      , maxNumMergeCandMin1, cnt, cnt, isAvailableSubPu, subPuMvpPos
#if JVET_L0293_CPR && JVET_L0054_MMVD
      , mmvdList
#endif
    );
#else
    bool bFound = addMergeHMVPCand(slice, mrgCtx, isCandInter, canFastExit
#if JVET_L0293_CPR
      , (mmvdList != 0 && mrgCandIdx != -1) ? (const int)mrgCandIdxCPR : mrgCandIdx
#else
      , mrgCandIdx
#endif
      , maxNumMergeCandMin1, cnt, cnt, isAvailableSubPu, subPuMvpPos
#if JVET_L0293_CPR && JVET_L0054_MMVD
      , mmvdList
#endif
    );
#endif
    if (bFound)
    {
      return;
    }
  }
#endif

#if JVET_L0090_PAIR_AVG				//平均MVP
  // pairwise-average candidates	//PAIR_AVG的处理过程和L1002文档中所写一样
  {
    const int cutoff = std::min( cnt, 4 );
    const int end = cutoff * (cutoff - 1) / 2;
    constexpr int PRIORITY_LIST0[] = { 0, 0, 1, 0, 1, 2 };		//预定义的平均MVP对
    constexpr int PRIORITY_LIST1[] = { 1, 2, 2, 3, 3, 3 };

    for( int idx = 0; idx < end && cnt != maxNumMergeCand; idx++ )
    {
      const int i = PRIORITY_LIST0[idx];
      const int j = PRIORITY_LIST1[idx];

      mrgCtx.mvFieldNeighbours[cnt * 2].setMvField( Mv( 0, 0 ), NOT_VALID );
      mrgCtx.mvFieldNeighbours[cnt * 2 + 1].setMvField( Mv( 0, 0 ), NOT_VALID );
      // calculate average MV for L0 and L1 seperately
      unsigned char interDir = 0;
#if JVET_L0293_CPR

      // skip when one is BV and one is MV
      if (mrgCtx.mrgTypeNeighbours[i] != mrgCtx.mrgTypeNeighbours[j] && pu.cs->sps->getSpsNext().getCPRMode())
      {
        continue;
      }
#endif
      for( int refListId = 0; refListId < (slice.isInterB() ? 2 : 1); refListId++ )
      {
        const short refIdxI = mrgCtx.mvFieldNeighbours[i * 2 + refListId].refIdx;
        const short refIdxJ = mrgCtx.mvFieldNeighbours[j * 2 + refListId].refIdx;

        // both MVs are invalid, skip
        if( (refIdxI == NOT_VALID) && (refIdxJ == NOT_VALID) )
        {
          continue;
        }

        interDir += 1 << refListId;
        // both MVs are valid, average these two MVs
        if( (refIdxI != NOT_VALID) && (refIdxJ != NOT_VALID) )		//均可用时取平均加入merge列表
        {
          const Mv& MvI = mrgCtx.mvFieldNeighbours[i * 2 + refListId].mv;
          const Mv& MvJ = mrgCtx.mvFieldNeighbours[j * 2 + refListId].mv;

          // average two MVs
          Mv avgMv = MvI;
#if !REMOVE_MV_ADAPT_PREC
          if( pu.cs->sps->getSpsNext().getUseHighPrecMv() )
          {
            avgMv.setHighPrec();
          }
#endif
          avgMv += MvJ;
          avgMv.setHor( avgMv.getHor() / 2 );
          avgMv.setVer( avgMv.getVer() / 2 );
#if JVET_L0293_CPR

          if (mrgCtx.mrgTypeNeighbours[i] == MRG_TYPE_CPR && mrgCtx.mrgTypeNeighbours[j] == MRG_TYPE_CPR && pu.cs->sps->getSpsNext().getCPRMode())
          {
             mrgCtx.mrgTypeNeighbours[cnt] = MRG_TYPE_CPR;
             avgMv.setHor((avgMv.getHor() / 16) << 4);
             avgMv.setVer((avgMv.getVer() / 16) << 4);
          }
#endif

          mrgCtx.mvFieldNeighbours[cnt * 2 + refListId].setMvField( avgMv, refIdxI );
        }
        // only one MV is valid, take the only one MV
        else if( refIdxI != NOT_VALID )
        {
          Mv singleMv = mrgCtx.mvFieldNeighbours[i * 2 + refListId].mv;
#if !REMOVE_MV_ADAPT_PREC
          if( pu.cs->sps->getSpsNext().getUseHighPrecMv() )
          {
            singleMv.setHighPrec();
          }
#endif
          mrgCtx.mvFieldNeighbours[cnt * 2 + refListId].setMvField( singleMv, refIdxI );
        }
        else if( refIdxJ != NOT_VALID )
        {
          Mv singleMv = mrgCtx.mvFieldNeighbours[j * 2 + refListId].mv;
#if !REMOVE_MV_ADAPT_PREC
          if( pu.cs->sps->getSpsNext().getUseHighPrecMv() )
          {
            singleMv.setHighPrec();
          }
#endif
          mrgCtx.mvFieldNeighbours[cnt * 2 + refListId].setMvField( singleMv, refIdxJ );
        }
      }

      mrgCtx.interDirNeighbours[cnt] = interDir;
      if( interDir > 0 )
      {
        cnt++;
      }
    }

    // early termination
    if( cnt == maxNumMergeCand )
    {
      return;
    }
  }
#endif

  uint32_t uiArrayAddr = cnt;

  int iNumRefIdx = slice.isInterB() ? std::min(slice.getNumRefIdx(REF_PIC_LIST_0), slice.getNumRefIdx(REF_PIC_LIST_1)) : slice.getNumRefIdx(REF_PIC_LIST_0);

  int r = 0;
  int refcnt = 0;
  while (uiArrayAddr < maxNumMergeCand)				//补0
  {
#if !JVET_L0090_PAIR_AVG
    isCandInter               [uiArrayAddr     ] = true;
#endif
    mrgCtx.interDirNeighbours [uiArrayAddr     ] = 1;
#if JVET_L0646_GBI
    mrgCtx.GBiIdx             [uiArrayAddr     ] = GBI_DEFAULT;
#endif
    mrgCtx.mvFieldNeighbours  [uiArrayAddr << 1].setMvField(Mv(0, 0), r);

    if (slice.isInterB())
    {
      mrgCtx.interDirNeighbours [ uiArrayAddr          ] = 3;
      mrgCtx.mvFieldNeighbours  [(uiArrayAddr << 1) + 1].setMvField(Mv(0, 0), r);
    }

#if JVET_L0293_CPR
    if ( mrgCtx.interDirNeighbours[uiArrayAddr] == 1 && pu.cs->slice->getRefPic(REF_PIC_LIST_0, mrgCtx.mvFieldNeighbours[uiArrayAddr << 1].refIdx)->getPOC() == pu.cs->slice->getPOC())
    {
      mrgCtx.mrgTypeNeighbours[uiArrayAddr] = MRG_TYPE_CPR;
    }
#endif

    uiArrayAddr++;

    if (refcnt == iNumRefIdx - 1)
    {
      r = 0;
    }
    else
    {
      ++r;
      ++refcnt;
    }
  }
  mrgCtx.numValidMergeCand = uiArrayAddr;
}
矛盾统一
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HEVC代码学习9：getInterMergeCandidates函数
慢慢积累
05-08 1804
今天需要统计Merge的候选列表信息，来看下getInterMergeCandidates函数，用于建立merge候选列表。 其主要工作流程： 1.建立空间列表，如果达到最大候选数，退出。 2.空间列表不能填满候选列表，建立时域列表补足，如果达到最大候选数，退出。 3.空间+时域列表不能填满候选列表，建立组合列表补足，如果达到最大候选数，退出。 4.若依然为填满，则使用零MV补足。//!
HTM-16.2代码（13）——getInterMergeCandidates
Eyrane的博客
12-28 655
getInterMergeCandidates是Merge技术候选列表的实现。空域：选取的顺序为A1-&gt;B1-&gt;B0-&gt;A0-&gt;(B2)。其中，B2只有在A1，B1，B0，A0中有一个不存在或者帧内预测的情况才可使用。时域：一般情况下首先考虑的是H位置，当H位置不存在或者编码模式使用的是帧内编码模式或者超出了CTU的边界时，选择C3位置。 //! Cons...
H.266/VVC代码学习笔记13：VTM6.0中的getInterMergeCandidates（）函数
Peter_Red_Boy的博客
09-16 1310
getInterMergeCandidates（）函数是帧间预测技术中一个非常重要的函数，它是Merge列表的构造函数，所有的Merge模式都要先构造一个Merge候选列表，然后根据不同的模式在此regularMerge列表的基础上去延伸出相对应的Merge列表，就比如MMVD的Merge列表需要在常规Merge列表的基础上去选择两个初始MV，然后构造MMVDMerge。 普通Merge列表的构造...
HEVC中的Merge Mode——x265代码getInterMergeCandidates（）函数解析
qq_40102403的博客
11-13 1295
HEVC中的mv预测技术主要分为两种：AMVP mode 和Merge mode，这里就主要来聊聊Merge mode。 由于很多时候当前的编码CU与相邻已经完成编码的CU具有相同的mv，因此从相邻的若干个PU中获取最佳的mv就是Merge mode要做的主要事情： 通过搜索相邻PU的motion information（包括reference index和mv）是否可用，可得时加入MergeC...
CUData::getInterMergeCandidates()/getNeighbourMV()
workspace
04-08 366
CUData::getInterMergeCandidates()构造当前PU的merge备选集 空间merge备选集 必要，5选4，B2替补 时间merge备选集 可选，2选1，C3替补 /* Construct list of merging candidates, returns count 构造merge备选集列表，返回备选集个数 备选集方案： 1.空域...
VTM3.0代码阅读：getAffineMergeCand函数
矛盾统一
12-27 417
xCheckRDCostAffineMerge2Nx2N函数中调用getAffineMergeCand来获取AffineMerge候选列表。 AffineMerge候选列表的类： class AffineMergeCtx //AffineMerge候选列表的类 { //... public: MvField mvFieldNeighbours[AFFINE_MRG_MAX_NU...
VTM3.0代码阅读：getIntraMPMs函数
矛盾统一
12-27 219
getIntraMPMs在estIntraPredLumaQT函数中被调用，用来获取MPM候选模式，MPM模式存储在mpm中。 流程大致为：获取左侧和上侧的pu帧内预测模式，然后按照left和above模式的情况，给mpm列表赋值。 MPM列表长度为6。由于宏JVET_L0165_6MPM开启，所以删掉了一些无用的代码。 int PU::getIntraMPMs( const Prediction...
foundryvtt-vtm-20th:吸血鬼化妆舞会20周年纪念版
04-29
在“VTM-20th”模组中，JavaScript代码可能包括了对《吸血鬼：化妆舞会》独特规则的模拟，比如血统、能力、以及复杂的社会结构。通过自定义事件和函数，开发者能够精确地模拟游戏机制，确保游戏体验与实体桌面游戏...
vtm-template:项目重构2.0
05-15
【vtm-template:项目重构2.0】是一个关于软件开发中的项目重构的实践案例，主要聚焦于使用JavaScript语言进行的代码优化与结构改进。在软件开发过程中，重构是为了提高代码的可读性、可维护性和整体性能，而不会改变...
VTM_TER:提交初始
05-10
如果"VTM TER"项目使用了OpenCV，那么它可能包含了将这些高级功能集成到移动应用中的示例代码。 JavaFX则是一个用于创建桌面和基于浏览器的应用的富客户端平台，它包含了一些图形和媒体处理功能，对于创建用户界面...
VTM代码算法文档 下载于官网
10-10
\n\n在2020年10月7日至16日的20次会议上，通过电话会议，JVET发布了VVC工作草案11和VVC测试模型11（VTM11）的算法描述和编码方法。VTM11是一个用于验证和优化VVC编码性能的实验性编码工具，它包含了最新的编码技术，...
H. 266 VTM参考实现代码
08-12
《深入探索H.266 VTM参考实现代码》 H.266，也称为Versatile Video Coding（VVC），是国际电信联盟（ITU-T）视频编码专家组（VCEG）与ISO/IEC动态图像专家组（MPEG）联合制定的新一代视频编码标准。作为H.264/AVC和...
VTM1.0代码阅读：getInterMergeCandidates函数
矛盾统一
12-26 223
xCheckRDCostMerge2Nx2N函数中调用getInterMergeCandidates获取merge候选，存储于mrgCtx。 MergeCtx类用来表示merge候选列表，其中存储merge候选列表中的各种信息： class MergeCtx { public: MergeCtx() : numValidMergeCand( 0 ), hasMergedCandList( fa...
VTM10.0代码学习5：coding_unit()&cu_pred_data()
hjhyxq2014的博客
11-09 1133
此系列是为了记录自己学习VTM10.0的过程和锻炼表达能力，主要是从解码端进行入手。由于本人水平有限，出现的错误恳请大家指正，欢迎与大家一起交流进步。 上一篇博客(VTM10.0代码学习4)讲述了将语法元素的处理从CTU级划分到CU级，并在其2.5节提到coding_unit()这个函数。我原本以为能用一篇博客讲述完coding_unit()，但实际需要两篇，错估了自己的能力(真不想承认啊,这是我太过年轻而犯下的错)。CU级语法元素处理的主要部分可以分为预测模式的参数和变换残差，本篇博客先讲述codi.
VTM1.0代码阅读：xDeriveCUMV函数
矛盾统一
12-26 348
coding_unit函数中的pred_data()获取cu的预测参数数据，xDeriveCUMV则根据pred_data()获取的预测参数数据，计算得到运动信息mv。 pred_data()对于skip模式，只解码了一个merge_idx；对于merge模式，解码了merge_flag和merge_idx；对于inter_ME模式，解码了对应预测方向的refIdx、mvd、mvpIdx。 xDe...
HEVC帧间预测之一——TComDataCU::getInterMergeCandidates函数分析
热门推荐
HEVC_CJL的专栏
03-12 1万+
从今天开始，正式转入到帧间预测方向。由于帧间预测涉及到的方面广且复杂，所以我的理解出现错误的情况可能会更多，请大家以辩证的眼光来看待我的帖子，有问题欢迎大家批评指正。   大家都知道xCompressCU是实际进行预测编码的函数，故很容易就能锁定帧间预测的一个大致范围，在研究了帧内预测的基础上，相信很快就能在该函数中找到与帧间预测相关的函数：xCheckRDCostInter，xCheckRD
VTM3.0代码阅读：解码端coding_unit函数
矛盾统一
12-27 436
coding_unit函数解码一个cu的预测模式、预测数据、残差数据等信息。 其实，编码端的coding_unit是如何编码的，解码端的coding_unit按照相同的顺序如何解码就行。 函数return一个bool值，表示当前cu是否是这一帧的最后一个cu。 由于VTM3.0中加入了很多的编码工具，所以相较于VTM1，coding_unit函数会对更多的模式的信息进行解码. 对于帧内pu的几种模...
H.266/VVC帧间预测技术学习:高级运动矢量预测(Advanced Motion Vector Prediction, AMVP)
BigDream123的博客
05-25 3246
高级运动矢量预测模式(Advanced Motion Vector Prediction，AMVP) AMVP模式是H.265/HEVC中提出的新的MV预测技术，H.266/VVC仍采用了该技术，并在HEVC的基础上进行了改进。AMVP利用空域和时域的运动矢量的相关性，为当前PU建立了候选预测MV列表，编码端从其中选出最优的预测MVP，并对MVP进行差分编码（即通过运动搜索获得真正的MV，将运动矢量差进行编码（MV-MVP））；解码端通过建立相同的列表，仅需要预测MVP在列表中的索引和运动向量残差MVD即
励志2024龙年筑梦前行共创未来PPT模板，适用于工作计划，工作总结
最新发布
07-15
【作品名称】：励志2024龙年筑梦前行共创未来PPT模板，适用于工作计划，工作总结 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
PolycomVTM配套视频解决方案.pptx
01-23
PolycomVTM配套视频解决方案.pptx

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值