HEVC帧间预测之一——TComDataCU::getInterMergeCandidates函数分析

最新推荐文章于 2024-02-28 18:21:03 发布
原创 最新推荐文章于 2024-02-28 18:21:03 发布 · 置顶 · 1.1w 阅读 · 13 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#HEVC #帧间预测 #merge #getInterMergeCandida
本文聚焦于HEVC编码中的帧间预测，特别是merge模式。通过分析xCheckRDCostMerge2Nx2N函数中的getInterMergeCandidates函数，探讨了该函数在创建merge list过程中的作用，为理解HEVC帧间预测提供关键洞察。

从今天开始，正式转入到帧间预测方向。由于帧间预测涉及到的方面广且复杂，所以我的理解出现错误的情况可能会更多，请大家以辩证的眼光来看待我的帖子，有问题欢迎大家批评指正。

 

大家都知道xCompressCU是实际进行预测编码的函数，故很容易就能锁定帧间预测的一个大致范围，在研究了帧内预测的基础上，相信很快就能在该函数中找到与帧间预测相关的函数：xCheckRDCostInter，xCheckRDCostMerge2Nx2N。前者进行除了merge模式以外的所有帧间预测，后者则是针对merge模式的。由于merge模式相对于H.264来说是个新事物，我们考虑先从研究它入手。

 

进入到xCheckRDCostMerge2Nx2N函数后，开头有一个比较重要的函数getInterMergeCandidates，它的功能是创建一个merge list，在该模式中是个很重要的函数，故我们先讨论它。下面按照惯例，给出我对这个函数的注释：

 

Void TComDataCU::getInterMergeCandidates( UInt uiAbsPartIdx, UInt uiPUIdx, TComMvField* pcMvFieldNeighbours, UChar* puhInterDirNeighbours, Int& numValidMergeCand, Int mrgCandIdx )
{
  UInt uiAbsPartAddr = m_uiAbsIdxInLCU + uiAbsPartIdx; //!< 当前CU的ZScan地址
  UInt uiIdx = 1;
  Bool abCandIsInter[ MRG_MAX_NUM_CANDS ];
  for( UInt ui = 0; ui < getSlice()->getMaxNumMergeCand(); ++ui ) //!< m_maxNumMergeCand = 5
  {
    abCandIsInter[ui] = false;
  }
  numValidMergeCand = getSlice()->getMaxNumMergeCand(); //!< 5
  // compute the location of the current PU
  Int xP, yP, nPSW, nPSH;
  this->getPartPosition(uiPUIdx, xP, yP, nPSW, nPSH); //!< 获得当前PU的地址和大小

  Int iCount = 0; //!< 统计Merge candidate的个数

  UInt uiPartIdxLT, uiPartIdxRT, uiPartIdxLB;
  PartSize cCurPS = getPartitionSize( uiAbsPartIdx ); //!< CU的分割模式
  deriveLeftRightTopIdxGeneral( uiAbsPartIdx, uiPUIdx, uiPartIdxLT, uiPartIdxRT ); //!< 左上部，右上部
  deriveLeftBottomIdxGeneral  ( uiAbsPartIdx, uiPUIdx, uiPartIdxLB ); //!< 左下部

  //left
  UInt uiLeftPartIdx = 0;
  TComDataCU* pcCULeft = 0;
  pcCULeft = getPULeft( uiLeftPartIdx, uiPartIdxLB, true, false );
#if MERGE_CLEANUP_AND_K0197 //!< 在有多个PU在一个CU中的时候，去除第二个PU对A1和B1的依赖性
  Bool isAvailableA1 = pcCULeft &&
  pcCULeft->isDiffMER(xP -1, yP+nPSH-1, xP, yP) && //!< 当前PU和它的相邻PU不在同一个ME区域
  !( uiPUIdx == 1 && (cCurPS == SIZE_Nx2N || cCurPS == SIZE_nLx2N || cCurPS == SIZE_nRx2N) ) &&
  !pcCULeft->isIntra( uiLeftPartIdx ) ;
  if ( isAvailableA1 )
#else
  if (pcCULeft)
  {
    if (!pcCULeft->isDiffMER(xP -1, yP+nPSH-1, xP, yP))
    {
      pcCULeft = NULL;
    }
  }
  PartSize partSize = getPartitionSize( uiAbsPartIdx );
  if (!(uiPUIdx == 1 && (partSize == SIZE_Nx2N || partSize == SIZE_nLx2N || partSize == SIZE_nRx2N)))
  {
  if ( pcCULeft && !pcCULeft->isIntra( uiLeftPartIdx ) )
#endif
  {
    abCandIsInter[iCount] = true;
    // get Inter Dir
    puhInterDirNeighbours[iCount] = pcCULeft->getInterDir( uiLeftPartIdx ); //!< inter dir分L0，L1，Bi
    // get Mv from Left，将pcCULeft的MV存放到pcMvFieldNeighbours中
    pcCULeft->getMvField( pcCULeft, uiLeftPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
    if ( getSlice()->isInterB() )
    {
      pcCULeft->getMvField( pcCULeft, uiLeftPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
    }
    if ( mrgCandIdx == iCount )
    {
      return;
    }
    iCount ++;
  }
#if !MERGE_CLEANUP_AND_K0197
  }
#endif
  
  // early termination
  if (iCount == getSlice()->getMaxNumMergeCand()) 
  {
    return;
  }
  // above
  UInt uiAbovePartIdx = 0;
  TComDataCU* pcCUAbove = 0;
#if LINEBUF_CLEANUP
  pcCUAbove = getPUAbove( uiAbovePartIdx, uiPartIdxRT, true, false );
#else
  pcCUAbove = getPUAbove( uiAbovePartIdx, uiPartIdxRT, true, false, true );
#endif
#if MERGE_CLEANUP_AND_K0197 //!< 
  Bool isAvailableB1 = pcCUAbove &&
  pcCUAbove->isDiffMER(xP+nPSW-1, yP-1, xP, yP) &&
  !( uiPUIdx == 1 && (cCurPS == SIZE_2NxN || cCurPS == SIZE_2NxnU || cCurPS == SIZE_2NxnD) ) &&
  !pcCUAbove->isIntra( uiAbovePartIdx );
  if ( isAvailableB1 && (!isAvailableA1 || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCUAbove, uiAbovePartIdx ) ) )
#else//!< 如果A1可用，则检查A1和B1的MV是否相同，否则不需要检查
  if (pcCUAbove)
  {
    if (!pcCUAbove->isDiffMER(xP+nPSW-1, yP-1, xP, yP))
    {
      pcCUAbove = NULL;
    }
  }
  if ( pcCUAbove && !pcCUAbove->isIntra( uiAbovePartIdx ) 
    && !(uiPUIdx == 1 && (cCurPS == SIZE_2NxN || cCurPS == SIZE_2NxnU || cCurPS == SIZE_2NxnD))
    && ( !pcCULeft || pcCULeft->isIntra( uiLeftPartIdx ) || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCUAbove, uiAbovePartIdx ) ) )
#endif
  {
    abCandIsInter[iCount] = true;
    // get Inter Dir
    puhInterDirNeighbours[iCount] = pcCUAbove->getInterDir( uiAbovePartIdx );
    // get Mv from Above
    pcCUAbove->getMvField( pcCUAbove, uiAbovePartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
    if ( getSlice()->isInterB() )
    {
      pcCUAbove->getMvField( pcCUAbove, uiAbovePartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
    }
    if ( mrgCandIdx == iCount )
    {
      return;
    }
    iCount ++;
  }
  // early termination
  if (iCount == getSlice()->getMaxNumMergeCand()) 
  {
    return;
  }

  // above right
  UInt uiAboveRightPartIdx = 0;
  TComDataCU* pcCUAboveRight = 0;
#if LINEBUF_CLEANUP
  pcCUAboveRight = getPUAboveRight( uiAboveRightPartIdx, uiPartIdxRT, true, false );
#else
  pcCUAboveRight = getPUAboveRight( uiAboveRightPartIdx, uiPartIdxRT, true, false, true );
#endif
#if MERGE_CLEANUP_AND_K0197
  Bool isAvailableB0 = pcCUAboveRight &&
  pcCUAboveRight->isDiffMER(xP+nPSW, yP-1, xP, yP) &&
  !pcCUAboveRight->isIntra( uiAboveRightPartIdx );
  if ( isAvailableB0 && ( !isAvailableB1 || !pcCUAbove->hasEqualMotion( uiAbovePartIdx, pcCUAboveRight, uiAboveRightPartIdx ) ) )
#else//!< 如果B1可用，则检查B1和B0的MV是否相同，否则不需要检查
  if (pcCUAboveRight)
  {
    if (!pcCUAboveRight->isDiffMER(xP+nPSW, yP-1, xP, yP))
    {
      pcCUAboveRight = NULL;
    }
  }
  if ( pcCUAboveRight && !pcCUAboveRight->isIntra( uiAboveRightPartIdx ) && ( !pcCUAbove || pcCUAbove->isIntra( uiAbovePartIdx ) || !pcCUAbove->hasEqualMotion( uiAbovePartIdx, pcCUAboveRight, uiAboveRightPartIdx ) ) )
#endif
  {
    abCandIsInter[iCount] = true;
    // get Inter Dir
    puhInterDirNeighbours[iCount] = pcCUAboveRight->getInterDir( uiAboveRightPartIdx );
    // get Mv from AboveRight
    pcCUAboveRight->getMvField( pcCUAboveRight, uiAboveRightPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
    if ( getSlice()->isInterB() )
    {
      pcCUAboveRight->getMvField( pcCUAboveRight, uiAboveRightPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
    }
    if ( mrgCandIdx == iCount )
    {
      return;
    }
    iCount ++;
  }
  // early termination
  if (iCount == getSlice()->getMaxNumMergeCand()) 
  {
    return;
  }

  //left bottom
  UInt uiLeftBottomPartIdx = 0;
  TComDataCU* pcCULeftBottom = 0;
  pcCULeftBottom = this->getPUBelowLeft( uiLeftBottomPartIdx, uiPartIdxLB, true, false );
#if MERGE_CLEANUP_AND_K0197
  Bool isAvailableA0 = pcCULeftBottom &&
  pcCULeftBottom->isDiffMER(xP-1, yP+nPSH, xP, yP) &&
  !pcCULeftBottom->isIntra( uiLeftBottomPartIdx ) ;
  if ( isAvailableA0 && ( !isAvailableA1 || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCULeftBottom, uiLeftBottomPartIdx ) ) )
#else//!< 如果A1可用，则检查A1和A0的MV是否相同，否则不需要检查
  if (pcCULeftBottom)
  {
    if (!pcCULeftBottom->isDiffMER(xP-1, yP+nPSH, xP, yP))
    {
      pcCULeftBottom = NULL;
    }
  }
  if ( pcCULeftBottom && !pcCULeftBottom->isIntra( uiLeftBottomPartIdx ) && ( !pcCULeft || pcCULeft->isIntra( uiLeftPartIdx ) || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCULeftBottom, uiLeftBottomPartIdx ) ) )
#endif
  {
    abCandIsInter[iCount] = true;
    // get Inter Dir
    puhInterDirNeighbours[iCount] = pcCULeftBottom->getInterDir( uiLeftBottomPartIdx );
    // get Mv from LeftBottom
    pcCULeftBottom->getMvField( pcCULeftBottom, uiLeftBottomPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
    if ( getSlice()->isInterB() )
    {
      pcCULeftBottom->getMvField( pcCULeftBottom, uiLeftBottomPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
    }
    if ( mrgCandIdx == iCount )
    {
      return;
    }
    iCount ++;
  }
  // early termination
  if (iCount == getSlice()->getMaxNumMergeCand()) 
  {
    return;
  }
  // above left 
  if( iCount < 4 )
  {
    UInt uiAboveLeftPartIdx = 0;
    TComDataCU* pcCUAboveLeft = 0;
#if LINEBUF_CLEANUP
    pcCUAboveLeft = getPUAboveLeft( uiAboveLeftPartIdx, uiAbsPartAddr, true, false );
#else
    pcCUAboveLeft = getPUAboveLeft( uiAboveLeftPartIdx, uiAbsPartAddr, true, false, true );
#endif
#if MERGE_CLEANUP_AND_K0197
    Bool isAvailableB2 = pcCUAboveLeft &&
    pcCUAboveLeft->isDiffMER(xP-1, yP-1, xP, yP) &&
    !pcCUAboveLeft->isIntra( uiAboveLeftPartIdx );
    if ( isAvailableB2 && ( !isAvailableA1 || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCUAboveLeft, uiAboveLeftPartIdx ) )
        && ( !isAvailableB1 || !pcCUAbove->hasEqualMotion( uiAbovePartIdx, pcCUAboveLeft, uiAboveLeftPartIdx ) ) )
#else//!< 分别将B2与A1、B1的mv进行比较
    if (pcCUAboveLeft)
    {
      if (!pcCUAboveLeft->isDiffMER(xP-1, yP-1, xP, yP))
      {
        pcCUAboveLeft = NULL;
      }
    }
    if( pcCUAboveLeft && !pcCUAboveLeft->isIntra( uiAboveLeftPartIdx )
     && ( !pcCULeft || pcCULeft->isIntra( uiLeftPartIdx ) || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCUAboveLeft, uiAboveLeftPartIdx ) )
     && ( !pcCUAbove || pcCUAbove->isIntra( uiAbovePartIdx ) || !pcCUAbove->hasEqualMotion( uiAbovePartIdx, pcCUAboveLeft, uiAboveLeftPartIdx ) )
     )
#endif
    {
      abCandIsInter[iCount] = true;
      // get Inter Dir
      puhInterDirNeighbours[iCount] = pcCUAboveLeft->getInterDir( uiAboveLeftPartIdx );
      // get Mv from AboveLeft
      pcCUAboveLeft->getMvField( pcCUAboveLeft, uiAboveLeftPartIdx, REF_PIC_LIST_0, pcMvFieldNeighbours[iCount<<1] );
      if ( getSlice()->isInterB() )
      {
        pcCUAboveLeft->getMvField( pcCUAboveLeft, uiAboveLeftPartIdx, REF_PIC_LIST_1, pcMvFieldNeighbours[(iCount<<1)+1] );
      }
      if ( mrgCandIdx == iCount )
      {
        return;
      }
      iCount ++;
    }
  }
  // early termination
  if (iCount == getSlice()->getMaxNumMergeCand()) //!< 如果可用的merge candidates达到预设的最大值（5），则提前退出
  {
    return;
  }
  if ( getSlice()->getEnableTMVPFlag()) //!< default is 1
  {
    //>> MTK colocated-RightBottom
    UInt uiPartIdxRB;
    Int uiLCUIdx = getAddr();

    deriveRightBottomIdx( uiPUIdx, uiPartIdxRB ); //!< 当前PU的右下部的地址

    UInt uiAbsPartIdxTmp = g_auiZscanToRaster[uiPartIdxRB];
    UInt uiNumPartInCUWidth = m_pcPic->getNumPartInWidth(); //!< CU以partition为单位的宽度

    TComMv cColMv;
    Int iRefIdx;

    if      ( ( m_pcPic->getCU(m_uiCUAddr)->getCUPelX() + g_auiRasterToPelX[uiAbsPartIdxTmp] + m_pcPic->getMinCUWidth() ) >= m_pcSlice->getSPS()->getPicWidthInLumaSamples() )  // image boundary check
    {
      uiLCUIdx = -1;
    }//!< 横坐标超出图像边界
    else if ( ( m_pcPic->getCU(m_uiCUAddr)->getCUPelY() + g_auiRasterToPelY[uiAbsPartIdxTmp] + m_pcPic->getMinCUHeight() ) >= m_pcSlice->getSPS()->getPicHeightInLumaSamples() )
    {
      uiLCUIdx = -1;
    }//!< 纵坐标超出图像边界
    else
    {
      if ( ( uiAbsPartIdxTmp % uiNumPartInCUWidth < uiNumPartInCUWidth - 1 ) &&           // is not at the last column of LCU 
        ( uiAbsPartIdxTmp / uiNumPartInCUWidth < m_pcPic->getNumPartInHeight() - 1 ) ) // is not at the last row    of LCU
      {//!< 不在LCU的最后一列且不在LCU的最后一行，SIZE_NxN的第1个PU
        uiAbsPartAddr = g_auiRasterToZscan[ uiAbsPartIdxTmp + uiNumPartInCUWidth + 1 ]; //!< 下一行+1
        uiLCUIdx = getAddr(); //!< 与当前PU属于相同的CU
      }
      else if ( uiAbsPartIdxTmp % uiNumPartInCUWidth < uiNumPartInCUWidth - 1 )           // is not at the last column of LCU But is last row of LCU
      {//!< 不在LCU的最后一列但在LCU的最后一行，SIZE_Nx2N的第1个PU，SIZE_NxN的第3个PU，SIZE_nLx2N的第1个PU，SIZE_nRx2N的第1个PU
        uiAbsPartAddr = g_auiRasterToZscan[ (uiAbsPartIdxTmp + uiNumPartInCUWidth + 1) % m_pcPic->getNumPartInCU() ];
        uiLCUIdx = -1 ; 
      }
      else if ( uiAbsPartIdxTmp / uiNumPartInCUWidth < m_pcPic->getNumPartInHeight() - 1 ) // is not at the last row of LCU But is last column of LCU
      {//!< 不在LCU的最后一行但在LCU的最后一列，SIZE_2NxN的第1个PU，SIZE_NxN的第2个PU，SIZE_2NxnU的第1个PU，SIZE_2NxnD的第1个PU
        uiAbsPartAddr = g_auiRasterToZscan[ uiAbsPartIdxTmp + 1 ];
        uiLCUIdx = getAddr() + 1;
      }
      else //is the right bottom corner of LCU，SIZE_2Nx2N                       
      {
        uiAbsPartAddr = 0;
        uiLCUIdx = -1 ; 
      }
    }
    iRefIdx = 0;

    Bool bExistMV = false;
    UInt uiPartIdxCenter;
    UInt uiCurLCUIdx = getAddr();
    xDeriveCenterIdx( uiPUIdx, uiPartIdxCenter ); //!< 根据uiPUIdx计算PU的中心地址uiPartIdxCenter
	//! 获取colocated CU的mv，并经scaled过的。
    bExistMV = uiLCUIdx >= 0 && xGetColMVP( REF_PIC_LIST_0, uiLCUIdx, uiAbsPartAddr, cColMv, iRefIdx );
    if( bExistMV == false )
    {
      bExistMV = xGetColMVP( REF_PIC_LIST_0, uiCurLCUIdx, uiPartIdxCenter,  cColMv, iRefIdx );
    }
    if( bExistMV )
    {
      UInt uiArrayAddr = iCount;
      abCandIsInter[uiArrayAddr] = true;
      pcMvFieldNeighbours[uiArrayAddr << 1].setMvField( cColMv, iRefIdx );

      if ( getSlice()->isInterB() )
      {       
        iRefIdx = 0;
        bExistMV = uiLCUIdx >= 0 && xGetColMVP( REF_PIC_LIST_1, uiLCUIdx, uiAbsPartAddr, cColMv, iRefIdx);
        if( bExistMV == false )
        {
          bExistMV = xGetColMVP( REF_PIC_LIST_1, uiCurLCUIdx, uiPartIdxCenter,  cColMv, iRefIdx );
        }
        if( bExistMV )
        {
          pcMvFieldNeighbours[ ( uiArrayAddr << 1 ) + 1 ].setMvField( cColMv, iRefIdx );
          puhInterDirNeighbours[uiArrayAddr] = 3; //!< Bi
        }
        else
        {
          puhInterDirNeighbours[uiArrayAddr] = 1; //!< L0
        }
      }
      else
      {
        puhInterDirNeighbours[uiArrayAddr] = 1; //!< L0
      }
      if ( mrgCandIdx == iCount )
      {
        return;
      }
      iCount++;
    }
    uiIdx++;

  }
  // early termination
  if (iCount == getSlice()->getMaxNumMergeCand()) 
  {
    return;
  }
  UInt uiArrayAddr = iCount;
  UInt uiCutoff = uiArrayAddr;
    
  if ( getSlice()->isInterB())
  {//! 参考draft Table 8-6 ---- Specification of l0CandIdx and l1CandIdx
    UInt uiPriorityList0[12] = {0 , 1, 0, 2, 1, 2, 0, 3, 1, 3, 2, 3};
    UInt uiPriorityList1[12] = {1 , 0, 2, 0, 2, 1, 3, 0, 3, 1, 3, 2};

    for (Int idx=0; idx<uiCutoff*(uiCutoff-1) && uiArrayAddr!= getSlice()->getMaxNumMergeCand(); idx++)
    {
      Int i = uiPriorityList0[idx]; Int j = uiPriorityList1[idx];
      if (abCandIsInter[i] && abCandIsInter[j]&& (puhInterDirNeighbours[i]&0x1)&&(puhInterDirNeighbours[j]&0x2))
      {
        abCandIsInter[uiArrayAddr] = true;
        puhInterDirNeighbours[uiArrayAddr] = 3;

        // get Mv from cand[i] and cand[j]
        pcMvFieldNeighbours[uiArrayAddr << 1].setMvField(pcMvFieldNeighbours[i<<1].getMv(), pcMvFieldNeighbours[i<<1].getRefIdx());
        pcMvFieldNeighbours[( uiArrayAddr << 1 ) + 1].setMvField(pcMvFieldNeighbours[(j<<1)+1].getMv(), pcMvFieldNeighbours[(j<<1)+1].getRefIdx());

        Int iRefPOCL0 = m_pcSlice->getRefPOC( REF_PIC_LIST_0, pcMvFieldNeighbours[(uiArrayAddr<<1)].getRefIdx() );
        Int iRefPOCL1 = m_pcSlice->getRefPOC( REF_PIC_LIST_1, pcMvFieldNeighbours[(uiArrayAddr<<1)+1].getRefIdx() );
        if (iRefPOCL0 == iRefPOCL1 && pcMvFieldNeighbours[(uiArrayAddr<<1)].getMv() == pcMvFieldNeighbours[(uiArrayAddr<<1)+1].getMv())
        {
          abCandIsInter[uiArrayAddr] = false;
        }
        else
        {
          uiArrayAddr++;
        }
      }
    }
  }
  // early termination
  if (uiArrayAddr == getSlice()->getMaxNumMergeCand()) 
  {
    return;
  }
  //! 当可用的merge candidates数目仍小于预设值时，将余量均设置为零运动矢量
  Int iNumRefIdx = (getSlice()->isInterB()) ? min(m_pcSlice->getNumRefIdx(REF_PIC_LIST_0), m_pcSlice->getNumRefIdx(REF_PIC_LIST_1)) : m_pcSlice->getNumRefIdx(REF_PIC_LIST_0);
  Int r = 0;
  Int refcnt = 0;
  while (uiArrayAddr < getSlice()->getMaxNumMergeCand())
  {
    abCandIsInter[uiArrayAddr] = true;
    puhInterDirNeighbours[uiArrayAddr] = 1;
    pcMvFieldNeighbours[uiArrayAddr << 1].setMvField( TComMv(0, 0), r); //!< 设置为零运动矢量

    if ( getSlice()->isInterB() )
    {
      puhInterDirNeighbours[uiArrayAddr] = 3;
      pcMvFieldNeighbours[(uiArrayAddr << 1) + 1].setMvField(TComMv(0, 0), r);
    }
    uiArrayAddr++;
    if ( refcnt == iNumRefIdx - 1 ) //!< 达到参考帧列表的参考帧数
    {
      r = 0;
    }
    else
    {
      ++r;
      ++refcnt;
    }
  }

  numValidMergeCand = uiArrayAddr;
}


HEVC代码学习9：getInterMergeCandidates函数
慢慢积累
05-08 2117
今天需要统计Merge的候选列表信息，来看下getInterMergeCandidates函数，用于建立merge候选列表。 其主要工作流程： 1.建立空间列表，如果达到最大候选数，退出。 2.空间列表不能填满候选列表，建立时域列表补足，如果达到最大候选数，退出。 3.空间+时域列表不能填满候选列表，建立组合列表补足，如果达到最大候选数，退出。 4.若依然为填满，则使用零MV补足。//!
deriveLeftRightTopIdxGeneral函数
zgqsdfx的专栏
05-03 424
此函数用于输出当前CU左上角和右上角在当前CTU中的位置，位置是以4x4的块为单位的。 下图是博客作者hevc_cjl所贴出来的： m_absZIdxInCtu表示CU在当前CTU中的位置，uiAbsPartIdx表示当前PU划分所处的位置，都是基于4x4块的，如8x4 PU的第0个划分的uiAbsPartIdx= 0，第一个划分的uiAbsPartIdx= 2。 V...
HTM-16.2代码（13）——getInterMergeCandidates
Eyrane的博客
12-28 786
getInterMergeCandidates是Merge技术候选列表的实现。空域：选取的顺序为A1-&gt;B1-&gt;B0-&gt;A0-&gt;(B2)。其中，B2只有在A1，B1，B0，A0中有一个不存在或者帧内预测的情况才可使用。时域：一般情况下首先考虑的是H位置，当H位置不存在或者编码模式使用的是帧内编码模式或者超出了CTU的边界时，选择C3位置。 //! Cons...
CUData::getInterMergeCandidates()/getNeighbourMV()
workspace
04-08 530
CUData::getInterMergeCandidates()构造当前PU的merge备选集 空间merge备选集 必要，5选4，B2替补 时间merge备选集 可选，2选1，C3替补 /* Construct list of merging candidates, returns count 构造merge备选集列表，返回备选集个数 备选集方案： 1.空域...
H.266/VVC代码学习笔记13：VTM6.0中的getInterMergeCandidates（）函数
Peter_Red_Boy的博客
09-16 1556
getInterMergeCandidates（）函数是帧间预测技术中一个非常重要的函数，它是Merge列表的构造函数，所有的Merge模式都要先构造一个Merge候选列表，然后根据不同的模式在此regularMerge列表的基础上去延伸出相对应的Merge列表，就比如MMVD的Merge列表需要在常规Merge列表的基础上去选择两个初始MV，然后构造MMVDMerge。 普通Merge列表的构造...
【转载】HEVC帧间预测之一——TComDataCU::getInterMergeCandidates函数分析
HEVC_heiyue的专栏
12-23 666
转载自 从今天开始，正式转入到帧间预测方向。由于帧间预测涉及到的方面广且复杂，所以我的理解出现错误的情况可能会更多，请大家以辩证的眼光来看待我的帖子，有问题欢迎大家批评指正。   大家都知道xCompressCU是实际进行预测编码的函数，故很容易就能锁定帧间预测的一个大致范围，在研究了帧内预测的基础上，相信很快就能在该函数中找到与帧间预测相关的函数：xCheckRDCostI
HEVC代码学习：帧间预测——MVP过程中MV的获取、传递及存储
zzz_zzz12138的博客
07-10 2489
作为一个视频编码小白，最近开始着手啃HEVC帧间预测的代码，想用博客记录一下自己的学习过程，也想与大家分享、交流一下。 HEVC代码的学习主要是参考两位大神岳麓吹雪、NB_vol_1的博客以及HM参考软件。 两位大神的关于HEVC帧间部分的博客如下： HEVC代码学习 HM编码器代码阅读(33)——帧间预测的总结 而HM软件的安装配置可参考HEVC代码：HM使用+码流分析教程 应接下来研究的需要（想将自己用其他方式获取的MV直接喂入HEVC），先对HEVC帧间预测部分MV的获取、传递和存储方式进行总结，摸清
HEVC中的Merge Mode——x265代码getInterMergeCandidates（）函数解析
qq_40102403的博客
11-13 1647
HEVC中的mv预测技术主要分为两种：AMVP mode 和Merge mode，这里就主要来聊聊Merge mode。 由于很多时候当前的编码CU与相邻已经完成编码的CU具有相同的mv，因此从相邻的若干个PU中获取最佳的mv就是Merge mode要做的主要事情： 通过搜索相邻PU的motion information（包括reference index和mv）是否可用，可得时加入MergeC...
HEVC：deriveLeftRightTopIdxGeneral（）代码注释
Moomin的博客
04-08 459
Void TComDataCU::deriveLeftRightTopIdxGeneral ( UInt uiAbsPartIdx, UInt uiPartIdx, UInt&amp; ruiPartIdxLT, UInt&amp; ruiPartIdxRT ) const {//uiAbsPartIdx:当前CU中4x4小块Idx，一般为0；uiPartIdx：CU对称划分和非对称划分中PU P...
帧间预测（一）Void TComDataCU ::getInterMergeCandidates
u010289908的专栏
10-02 649
对应Merge模式的建立 /** Constructs a list of merging candidates  * \param uiAbsPartIdx  * \param uiPUIdx  * \param uiDepth  * \param pcMvFieldNeighbours  * \param puhInterDirNeighbours  * \param n
HM编码器代码阅读(17)——帧间预测之merge模式（一）Merge模式的介绍以及相关函数
NB_vol_1的专栏
04-15 8271
入口函数：TEncCu::xCheckRDCostMerge2Nx2N 主要流程： （1）获取可用merge候选MV数量以及merge候选MV （2）判断是否为无损模式，如果是无损模式，那么下面的for循环只需迭代一次，如果不是武勋模式，那么下面的for循环要迭代两次 （3）一个for循环，遍历所有的merge模式候选者      1）设置相关参数      2）调用motionCom
VTM3.0代码阅读：getInterMergeCandidates函数
矛盾统一
12-26 392
xCheckRDCostMerge2Nx2N函数中调用getInterMergeCandidates获取merge候选，存储于mrgCtx。 MergeCtx类用来表示merge候选列表，其中存储merge候选列表中的各种信息： class MergeCtx { //... public: MvField mvFieldNeighbours [ MRG_MAX_NUM_CANDS...
VTM1.0代码阅读：getInterMergeCandidates函数
矛盾统一
12-26 436
xCheckRDCostMerge2Nx2N函数中调用getInterMergeCandidates获取merge候选，存储于mrgCtx。 MergeCtx类用来表示merge候选列表，其中存储merge候选列表中的各种信息： class MergeCtx { public: MergeCtx() : numValidMergeCand( 0 ), hasMergedCandList( fa...
【视频编码\VVC】帧间预测编码基础知识
weixin_43799497的博客
02-28 3075
利用时间相关性，使用邻近已编码图像像素值预测当前图像的像素值，能够有效去除时域冗余。目前的视频编码标准中，帧间预测都采用了基于块的运动补偿技术。当前图像的每个像素块在之前已编码图像中寻找一个最佳匹配块的过程。用于预测的图像最佳匹配块到当前块的位移当前块与参考块的像素差值根据MV得到的参考块作为当前当前块预测值的过程只能使用帧内预测编码技术可以使用帧间预测编码技术可以选择使用前向预测、后向预测或双向预测。一个宏块拥有2个MV。去除相邻块运动矢量之间的相关性。MV不一定是像素的整数倍MV预测（MVP）
VVC帧间预测（一）扩展的merge模式
热门推荐
Dillon2015的博客
12-25 5万+
VVC在HEVC的基础上增加了很多新的帧间预测工具，在VTM5里新增的帧间预测工具如下： Extended merge prediction Merge mode with MVD (MMVD) AMVP mode with symmetric MVD signalling Affine motion compensated prediction Su...
HEVC学习（五） —— 帧内预测系列之三
HEVC_CJL的专栏
11-14 2万+
今天主要介绍帧内预测一个很重要的函数initAdiPattern，它的主要功能有三个，（1）检测当前PU的相邻样点包括左上、上、右上、左、左下邻域样点值的可用性，或者说检查这些点是否存在；（2）参考样点的替换过程，主要实现的是JCTVC-J1003即draft 8.4.4.2.2的内容，主要由函数fillReferenceSamples来完成，这个在之前的文章已经讨论过了；（3）相邻样点即参考样点
HEVC帧间预测
fantasy_ARM9的博客
12-20 715
这种模式下，如果解码端按照相同的方式建立候选列表，则只需要传输最优项在列表中的索引即可，大大节省了编码比特数。AMVP模式也需要构建MV候选列表，与合并模式的区别在于，AMVP的候选列表仅包含2个候选项，并且候选项只有空域和时域两种类型，并且从列表中选取的最优项并不直接作为当前块的MV，而是作为预测运动矢量MVP并进行差分编码，也就是对这运动矢量餐叉MVD进行编码，AMVP模式下，解码端按照相同的方式建立候选列表，则仅仅需要传输MVD与最优项在列表中的索引即可。
帧间预测-候选列表建立代码解析
m0_37579288的博客
02-05 898
(转载请注明出处) 候选列表的建立包括两部分，一个是Merge模式，一个是AMVP模式，因为这部分代码中涉及到了较多其他模块的参数，对新手读起来可能不容易理解，我尽力把我作为一个新手的理解过程表述出来，当然代码我看了好几遍才看懂，没办法，经验是个很重要的东西，没人带路，不走几遍哪来的经验。 先熟悉一下代码结构： 定位代码： atrl+F查找encmain.cpp里的入口，从外到里的调用
merge和AMVP
Eyrane的博客
02-26 5047
1.merge和AMVP 2.意义 3.代码 1.merge和AMVP 空域和时域相邻块的mv有一定的相关性，HEVC在mv预测方面提出merge和AMVP技术。merge和AMVP技术通过空域和时域已编码块构建候选mv列表，选取最优的一个当作当前PU的预测mv。merge不存在MVD，AMVP存在MVD，且候选列表的构建方式和长度均不同。skip是merge的一种特殊模式，区...
HEVC 高级运动向量预测技术（AMVP）
linpengbin的专栏
08-26 8768
代码版本： VTHEVCDec 函数： fillMvpCand() 时间： 2015/8/26 作者： 林彬   高级运动向量预测技术（AMVP）利用空间、时间上运动向量的相关性，分别建立空域候选列表以及时域候选列表，再从候选列表中选取最终的MVP。   1、空域候选列表的建立        空域候选列表需要从上图5个参考块中选出两个候选MV。分别是a0，a1中选出一个
评论 21
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值