帧间预测（一）Void TComDataCU ::getInterMergeCandidates

最新推荐文章于 2020-05-03 01:11:19 发布
最新推荐文章于 2020-05-03 01:11:19 发布
阅读量618 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： HEVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u010289908/article/details/48858553
本文深入探讨了视频处理领域的关键算法和技术，包括图像色彩空间、编解码算法、视频容器和FFmpeg应用，旨在提高视频处理效率和质量。


对应Merge模式的建立

/** Constructs a list of merging candidates
 * \param uiAbsPartIdx
 * \param uiPUIdx
 * \param uiDepth
 * \param pcMvFieldNeighbours
 * \param puhInterDirNeighbours
 * \param numValidMergeCand
 */
Void TComDataCU ::getInterMergeCandidates( UInt uiAbsPartIdx, UInt uiPUIdx , TComMvField* pcMvFieldNeighbours, UChar * puhInterDirNeighbours, Int& numValidMergeCand , Int mrgCandIdx )
{
  UInt uiAbsPartAddr = m_absZIdxInCtu + uiAbsPartIdx;
  Bool abCandIsInter[ MRG_MAX_NUM_CANDS ];
  for( UInt ui = 0; ui < getSlice()->getMaxNumMergeCand(); ++ui ) //!< m_maxNumMergeCand=5
  {
    abCandIsInter[ui] = false;
    pcMvFieldNeighbours[ ( ui << 1 )     ].setRefIdx( NOT_VALID);
    pcMvFieldNeighbours[ ( ui << 1 ) + 1 ].setRefIdx( NOT_VALID);
  }
  numValidMergeCand = getSlice()->getMaxNumMergeCand();
  // compute the location of the current PU
  Int xP, yP, nPSW, nPSH;
  this->getPartPosition( uiPUIdx, xP, yP, nPSW, nPSH);//uiPUIdx为分割索引号，加入采取NxN模式，则为4块，此时取值0,1,2,3

  Int iCount = 0;

  UInt uiPartIdxLT, uiPartIdxRT, uiPartIdxLB;
  PartSize cCurPS = getPartitionSize( uiAbsPartIdx );
  deriveLeftRightTopIdxGeneral( uiAbsPartIdx, uiPUIdx , uiPartIdxLT, uiPartIdxRT );//获得此时PU的左顶方和右顶方的Z值
  deriveLeftBottomIdxGeneral( uiAbsPartIdx, uiPUIdx , uiPartIdxLB );

  //left
  UInt uiLeftPartIdx = 0;
  TComDataCU* pcCULeft = 0;
  pcCULeft = getPULeft( uiLeftPartIdx, uiPartIdxLB ); //uiLeftPartIdx为左边的PU地址

  Bool isAvailableA1 = pcCULeft &&
                       pcCULeft->isDiffMER(xP -1, yP+nPSH-1, xP, yP) &&
                       !( uiPUIdx == 1 && (cCurPS == SIZE_Nx2N || cCurPS == SIZE_nLx2N || cCurPS == SIZE_nRx2N) ) &&
                       pcCULeft->isInter( uiLeftPartIdx ) ;

  if ( isAvailableA1 )
  {
    abCandIsInter[iCount] = true;
    // get Inter Dir
    puhInterDirNeighbours[iCount] = pcCULeft->getInterDir( uiLeftPartIdx ); //L0,L1,Bi
    // get Mv from Left
    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] );//获得左侧A1的参考帧MV与参考帧索引

    }
    if ( mrgCandIdx == iCount )
    {
      return;
    }
    iCount ++;
  }

  // early termination
  if (iCount == getSlice()->getMaxNumMergeCand())
  {
    return;
  }
  // above
  UInt uiAbovePartIdx = 0;
  TComDataCU* pcCUAbove = 0;
  pcCUAbove = getPUAbove( uiAbovePartIdx, uiPartIdxRT );

  Bool isAvailableB1 = pcCUAbove &&
                       pcCUAbove->isDiffMER(xP+nPSW-1, yP-1, xP, yP) &&
                       !( uiPUIdx == 1 && (cCurPS == SIZE_2NxN || cCurPS == SIZE_2NxnU || cCurPS == SIZE_2NxnD) ) &&
                       pcCUAbove->isInter( uiAbovePartIdx );

  if ( isAvailableB1 && (!isAvailableA1 || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCUAbove, uiAbovePartIdx ) ) )
  {
    abCandIsInter[iCount] = true;
    // get Inter Dir
    puhInterDirNeighbours[iCount] = pcCUAbove->getInterDir( uiAbovePartIdx );
    // get Mv from Left
    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;
  pcCUAboveRight = getPUAboveRight( uiAboveRightPartIdx, uiPartIdxRT );

  Bool isAvailableB0 = pcCUAboveRight &&
                       pcCUAboveRight->isDiffMER(xP+nPSW, yP-1, xP, yP) &&
                       pcCUAboveRight->isInter( uiAboveRightPartIdx );

  if ( isAvailableB0 && ( !isAvailableB1 || !pcCUAbove->hasEqualMotion( uiAbovePartIdx, pcCUAboveRight, uiAboveRightPartIdx ) ) )
  {
    abCandIsInter[iCount] = true;
    // get Inter Dir
    puhInterDirNeighbours[iCount] = pcCUAboveRight->getInterDir( uiAboveRightPartIdx );
    // get Mv from Left
    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 );

  Bool isAvailableA0 = pcCULeftBottom &&
                       pcCULeftBottom->isDiffMER(xP-1, yP+nPSH, xP, yP) &&
                       pcCULeftBottom->isInter( uiLeftBottomPartIdx ) ;

  if ( isAvailableA0 && ( !isAvailableA1 || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCULeftBottom, uiLeftBottomPartIdx ) ) )
  {
    abCandIsInter[iCount] = true;
    // get Inter Dir
    puhInterDirNeighbours[iCount] = pcCULeftBottom->getInterDir( uiLeftBottomPartIdx );
    // get Mv from Left
    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;
    pcCUAboveLeft = getPUAboveLeft( uiAboveLeftPartIdx, uiAbsPartAddr );

    Bool isAvailableB2 = pcCUAboveLeft &&
                         pcCUAboveLeft->isDiffMER(xP-1, yP-1, xP, yP) &&
                         pcCUAboveLeft->isInter( uiAboveLeftPartIdx );

    if ( isAvailableB2 && ( !isAvailableA1 || !pcCULeft->hasEqualMotion( uiLeftPartIdx, pcCUAboveLeft, uiAboveLeftPartIdx ) )
        && ( !isAvailableB1 || !pcCUAbove->hasEqualMotion( uiAbovePartIdx, pcCUAboveLeft, uiAboveLeftPartIdx ) ) )
    {
      abCandIsInter[iCount] = true;
      // get Inter Dir
      puhInterDirNeighbours[iCount] = pcCUAboveLeft->getInterDir( uiAboveLeftPartIdx );
      // get Mv from Left
      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())
  {
    return;
  }

  if ( getSlice()->getEnableTMVPFlag() ) //时域候选列表的建立
  {
    //>> MTK colocated-RightBottom
    UInt uiPartIdxRB;

    deriveRightBottomIdx( uiPUIdx, uiPartIdxRB );

    UInt uiAbsPartIdxTmp = g_auiZscanToRaster[uiPartIdxRB];
    const UInt numPartInCtuWidth  = m_pcPic->getNumPartInCtuWidth();
    const UInt numPartInCtuHeight = m_pcPic->getNumPartInCtuHeight();

    TComMv cColMv;
    Int iRefIdx;
    Int ctuRsAddr = -1;

    if (   ( ( m_pcPic->getCtu(m_ctuRsAddr)->getCUPelX() + g_auiRasterToPelX[uiAbsPartIdxTmp] + m_pcPic->getMinCUWidth () ) < m_pcSlice->getSPS()->getPicWidthInLumaSamples () )  // image boundary check
        && ( ( m_pcPic->getCtu(m_ctuRsAddr)->getCUPelY() + g_auiRasterToPelY[uiAbsPartIdxTmp] + m_pcPic->getMinCUHeight() ) < m_pcSlice->getSPS()->getPicHeightInLumaSamples() ) )
    {
      if ( ( uiAbsPartIdxTmp % numPartInCtuWidth < numPartInCtuWidth - 1 ) &&           // is not at the last column of CTU
        ( uiAbsPartIdxTmp / numPartInCtuWidth < numPartInCtuHeight - 1 ) )              // is not at the last row    of CTU
      {
        uiAbsPartAddr = g_auiRasterToZscan[ uiAbsPartIdxTmp + numPartInCtuWidth + 1 ]; //获得同位PU的Z地址
        ctuRsAddr = getCtuRsAddr(); //获得同位PU所在的CTU的首地址
      }
      else if ( uiAbsPartIdxTmp % numPartInCtuWidth < numPartInCtuWidth - 1 )           // is not at the last column of CTU But is last row of CTU
      {
        uiAbsPartAddr = g_auiRasterToZscan[ (uiAbsPartIdxTmp + numPartInCtuWidth + 1) % m_pcPic->getNumPartitionsInCtu() ];
      }
      else if ( uiAbsPartIdxTmp / numPartInCtuWidth < numPartInCtuHeight - 1 )          // is not at the last row of CTU But is last column of CTU
      {
        uiAbsPartAddr = g_auiRasterToZscan[ uiAbsPartIdxTmp + 1 ];
        ctuRsAddr = getCtuRsAddr() + 1;
      }
      else //is the right bottom corner of CTU
      {
        uiAbsPartAddr = 0;
      }
    }

    iRefIdx = 0;

    Bool bExistMV = false;
    UInt uiPartIdxCenter;
    Int dir = 0;
    UInt uiArrayAddr = iCount;
    xDeriveCenterIdx( uiPUIdx, uiPartIdxCenter );
    bExistMV = ctuRsAddr >= 0 && xGetColMVP( REF_PIC_LIST_0, ctuRsAddr, uiAbsPartAddr, cColMv, iRefIdx );
                cout<<iRefIdx<<endl;
    if( bExistMV == false )
    {
      bExistMV = xGetColMVP( REF_PIC_LIST_0, getCtuRsAddr(), uiPartIdxCenter,  cColMv, iRefIdx );
    }
    if( bExistMV )
    {
      dir |= 1;
      pcMvFieldNeighbours[ 2 * uiArrayAddr ].setMvField( cColMv, iRefIdx );
    }

    if ( getSlice()->isInterB() )
    {
      bExistMV = ctuRsAddr >= 0 && xGetColMVP( REF_PIC_LIST_1, ctuRsAddr, uiAbsPartAddr, cColMv, iRefIdx);
      if( bExistMV == false )
      {
        bExistMV = xGetColMVP( REF_PIC_LIST_1, getCtuRsAddr(), uiPartIdxCenter, cColMv, iRefIdx );
      }
      if( bExistMV )
      {
        dir |= 2;
        pcMvFieldNeighbours[ 2 * uiArrayAddr + 1 ].setMvField( cColMv, iRefIdx );
      }
    }

    if (dir != 0)
    {
      puhInterDirNeighbours[uiArrayAddr] = dir;
      abCandIsInter[uiArrayAddr] = true;

      if ( mrgCandIdx == iCount )
      {
        return;
      }
      iCount++;
    }
  }
  // early termination
  if (iCount == getSlice()->getMaxNumMergeCand())
  {
    return;
  }

  UInt uiArrayAddr = iCount;
  UInt uiCutoff = uiArrayAddr;
//建立组合列表
  if ( getSlice()->isInterB() )
  {
    static const UInt NUM_PRIORITY_LIST=12;
    static const UInt uiPriorityList0[NUM_PRIORITY_LIST] = {0 , 1, 0, 2, 1, 2, 0, 3, 1, 3, 2, 3};
    static const UInt uiPriorityList1[NUM_PRIORITY_LIST] = {1 , 0, 2, 0, 2, 1, 3, 0, 3, 1, 3, 2};

    for (Int idx=0; idx<uiCutoff*(uiCutoff-1) && uiArrayAddr!= getSlice()->getMaxNumMergeCand(); idx++)
    {
      assert(idx<NUM_PRIORITY_LIST);
      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;
  }

  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;
}







/**
 * \param eRefPicList
 * \param uiCUAddr
 * \param uiPartUnitIdx
 * \param riRefIdx
 * \returns Bool
 */
Bool TComDataCU ::xGetColMVP( RefPicList eRefPicList, Int ctuRsAddr, Int uiPartUnitIdx , TComMv& rcMv, Int & riRefIdx ) //得到同位pu的运动向量
{
  UInt uiAbsPartAddr = uiPartUnitIdx;

  RefPicList  eColRefPicList;
  Int iColPOC, iColRefPOC, iCurrPOC, iCurrRefPOC, iScale;
  TComMv cColMv;

  // use coldir.
  TComPic *pColPic = getSlice()->getRefPic( RefPicList(getSlice()->isInterB() ? 1-getSlice()->getColFromL0Flag() : 0), getSlice()->getColRefIdx());//得到同位参考帧
  TComDataCU *pColCtu = pColPic->getCtu( ctuRsAddr );
  if(pColCtu->getPic()==0||pColCtu->getPartitionSize( uiPartUnitIdx)==NUMBER_OF_PART_SIZES )
  {
    return false;
  }
  iCurrPOC = m_pcSlice->getPOC();
  iColPOC = pColCtu->getSlice()->getPOC();

  if (!pColCtu->isInter(uiAbsPartAddr))
  {
    return false;
  }

  eColRefPicList = getSlice()->getCheckLDC() ? eRefPicList : RefPicList (getSlice()->getColFromL0Flag());

  Int iColRefIdx = pColCtu->getCUMvField( RefPicList(eColRefPicList))->getRefIdx(uiAbsPartAddr);

  if (iColRefIdx < 0 )
  {
    eColRefPicList = RefPicList(1 - eColRefPicList);
    iColRefIdx = pColCtu->getCUMvField( RefPicList(eColRefPicList))->getRefIdx(uiAbsPartAddr);

    if (iColRefIdx < 0 )
    {
      return false;
    }
  }

  // Scale the vector.
  iColRefPOC = pColCtu->getSlice()->getRefPOC(eColRefPicList, iColRefIdx);
  cColMv = pColCtu->getCUMvField(eColRefPicList)->getMv(uiAbsPartAddr);

  iCurrRefPOC = m_pcSlice->getRefPic( eRefPicList, riRefIdx )->getPOC();

  Bool bIsCurrRefLongTerm = m_pcSlice->getRefPic( eRefPicList, riRefIdx )->getIsLongTerm();
  Bool bIsColRefLongTerm = pColCtu->getSlice()->getIsUsedAsLongTerm(eColRefPicList, iColRefIdx);

  if ( bIsCurrRefLongTerm != bIsColRefLongTerm )
  {
    return false;
  }

  if ( bIsCurrRefLongTerm || bIsColRefLongTerm )
  {
    rcMv = cColMv;
  }
  else
  {
    iScale = xGetDistScaleFactor(iCurrPOC, iCurrRefPOC, iColPOC, iColRefPOC);
    if ( iScale == 4096 )
    {
      rcMv = cColMv;
    }
    else
    {
      rcMv = cColMv.scaleMv( iScale ); //获得MV的的时域向量
    }
  }

  return true;
}


HEVC代码学习9：getInterMergeCandidates函数
慢慢积累
05-08 1916
今天需要统计Merge的候选列表信息，来看下getInterMergeCandidates函数，用于建立merge候选列表。 其主要工作流程： 1.建立空间列表，如果达到最大候选数，退出。 2.空间列表不能填满候选列表，建立时域列表补足，如果达到最大候选数，退出。 3.空间+时域列表不能填满候选列表，建立组合列表补足，如果达到最大候选数，退出。 4.若依然为填满，则使用零MV补足。//!
HEVC帧间预测之一——TComDataCU::getInterMergeCandidates函数分析
HEVC_CJL的专栏
03-12 1万+
从今天开始，正式转入到帧间预测方向。由于帧间预测涉及到的方面广且复杂，所以我的理解出现错误的情况可能会更多，请大家以辩证的眼光来看待我的帖子，有问题欢迎大家批评指正。   大家都知道xCompressCU是实际进行预测编码的函数，故很容易就能锁定帧间预测的一个大致范围，在研究了帧内预测的基础上，相信很快就能在该函数中找到与帧间预测相关的函数：xCheckRDCostInter，xCheckRD
VTM3.0代码阅读：getInterMergeCandidates函数
矛盾统一
12-26 318
xCheckRDCostMerge2Nx2N函数中调用getInterMergeCandidates获取merge候选，存储于mrgCtx。 MergeCtx类用来表示merge候选列表，其中存储merge候选列表中的各种信息： class MergeCtx { //... public: MvField mvFieldNeighbours [ MRG_MAX_NUM_CANDS...
HTM-16.2代码（13）——getInterMergeCandidates
Eyrane的博客
12-28 734
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 474
CUData::getInterMergeCandidates()构造当前PU的merge备选集 空间merge备选集 必要，5选4，B2替补 时间merge备选集 可选，2选1，C3替补 /* Construct list of merging candidates, returns count 构造merge备选集列表，返回备选集个数 备选集方案： 1.空域...
HM代码阅读：帧内预测（一）
Coding
04-26 3216
本文的代码均是TEncSearch::estIntraPredLumaQT函数或被它调用的函数中的代码。在TEncSearch::estIntraPredLumaQT函数中，首先确定RMD（Rough Mode Decision）候选。RMD的候选模式的个数由以下两个数组确定：const UChar g_aucIntraModeNumFast_UseMPM[MAX_CU_DEPTH] = { 3
HEVC帧间预测之四——运动估计（一）
HEVC_CJL的专栏
03-17 1万+
其实HM的运动估计这部分与H.264相比基本没有变化，如果看过JMVC运动估计的代码，会发现xTZSearch的结构几乎就是一样的。所以，严格来讲，这部分的东西没有什么太多新鲜的东西，相信以前研究过TZSearch的人看这部分代码会很轻松。先看运动估计的主调函数： //!< 运动估计 Void TEncSearch::xMotionEstimation( TComDataCU* pcCU, T
HEVC学习（三） —— 帧内预测系列之一
热门推荐
HEVC_CJL的专栏
11-12 3万+
今天开始进入实质性内容的讨论，主要是从代码实现的角度比较深入地研究帧内预测算法。由于帧内预测涉及到的函数的数量相对于编解码器复杂部分来说少，但事实上大大小小也牵涉到了十几二十个函数（没具体统计过，只是大概估算了下），想要一下子讨论完比较困难，所以打算在接下来的若干篇文章里逐步地尽可能详尽地分析每一个较为重要的函数。今天所要讨论的是fillReferenceSamples这个函数，它主要功能是在真正
H.266代码学习：xCheckRDCostIntra函数
慢慢积累
05-22 2394
今天来看帧内预测的入口函数xCheckRDCostIntra。JEM整体代码框架和HM是相同的，帧内预测代码框架可参考 HEVC代码学习37：帧内预测代码整体学习。 xCheckRDCostIntra在xCompressCU中被调用，进行帧内预测。 JEM与HM主要区别： 这一部分，相对HM没有什么重大改动。 流程如下： 主要流程可以分为5个部分： 1.初始化，设置子块信息。 2....
HEVC帧间预测之七——运动估计（四）
HEVC_CJL的专栏
03-18 1万+
有了前面几篇的铺垫，本文就可以把整像素部分的运动估计给结束掉了。到目前为止，只剩下xTZSearch这个函数没分析了，在开始这个函数的代码解释之前，让我们共同来理一下TZSearch的基本流程： 1. 搜索预测得到的mv所指向的点：中值预测mv，当前PU的左，上及右上PU的mv，还有零运动矢量（0,0） 2. 在步骤1中找到匹配误差最小的点作为接下来搜索的起始点 3. 步长从1开始，以2的指
H.266/VVC代码学习笔记13：VTM6.0中的getInterMergeCandidates（）函数
Peter_Red_Boy的博客
09-16 1457
getInterMergeCandidates（）函数是帧间预测技术中一个非常重要的函数，它是Merge列表的构造函数，所有的Merge模式都要先构造一个Merge候选列表，然后根据不同的模式在此regularMerge列表的基础上去延伸出相对应的Merge列表，就比如MMVD的Merge列表需要在常规Merge列表的基础上去选择两个初始MV，然后构造MMVDMerge。 普通Merge列表的构造...
VTM1.0代码阅读：getInterMergeCandidates函数
矛盾统一
12-26 370
xCheckRDCostMerge2Nx2N函数中调用getInterMergeCandidates获取merge候选，存储于mrgCtx。 MergeCtx类用来表示merge候选列表，其中存储merge候选列表中的各种信息： class MergeCtx { public: MergeCtx() : numValidMergeCand( 0 ), hasMergedCandList( fa...
HEVC中的Merge Mode——x265代码getInterMergeCandidates（）函数解析
qq_40102403的博客
11-13 1516
HEVC中的mv预测技术主要分为两种：AMVP mode 和Merge mode，这里就主要来聊聊Merge mode。 由于很多时候当前的编码CU与相邻已经完成编码的CU具有相同的mv，因此从相邻的若干个PU中获取最佳的mv就是Merge mode要做的主要事情： 通过搜索相邻PU的motion information（包括reference index和mv）是否可用，可得时加入MergeC...
【转载】HEVC帧间预测之一——TComDataCU::getInterMergeCandidates函数分析
HEVC_heiyue的专栏
12-23 610
转载自 从今天开始，正式转入到帧间预测方向。由于帧间预测涉及到的方面广且复杂，所以我的理解出现错误的情况可能会更多，请大家以辩证的眼光来看待我的帖子，有问题欢迎大家批评指正。   大家都知道xCompressCU是实际进行预测编码的函数，故很容易就能锁定帧间预测的一个大致范围，在研究了帧内预测的基础上，相信很快就能在该函数中找到与帧间预测相关的函数：xCheckRDCostI
关于HM/JEM Merge Candidates
Coding
12-08 933
TComDataCU::getInterMergeCandidates函数用于得到Merge模式的候选列表。Merge模式的候选列表最多为5个，且默认为5个： software-manual可以设置参数：MaxNumMergeCand 5 Specifies the maximum number of merge candidates to use. CommonDef.h中的最大值：stati
deriveLeftRightTopIdxGeneral函数
zgqsdfx的专栏
05-03 390
此函数用于输出当前CU左上角和右上角在当前CTU中的位置，位置是以4x4的块为单位的。 下图是博客作者hevc_cjl所贴出来的： m_absZIdxInCtu表示CU在当前CTU中的位置，uiAbsPartIdx表示当前PU划分所处的位置，都是基于4x4块的，如8x4 PU的第0个划分的uiAbsPartIdx= 0，第一个划分的uiAbsPartIdx= 2。 V...
HEVC：deriveLeftRightTopIdxGeneral（）代码注释
Moomin的博客
04-08 435
Void TComDataCU::deriveLeftRightTopIdxGeneral ( UInt uiAbsPartIdx, UInt uiPartIdx, UInt&amp; ruiPartIdxLT, UInt&amp; ruiPartIdxRT ) const {//uiAbsPartIdx:当前CU中4x4小块Idx，一般为0；uiPartIdx：CU对称划分和非对称划分中PU P...
Void TComPicYuv::create
xhyan523的博客
03-26 330
Void TComPicYuv::create ( const Int picWidth, ///&lt; picture width const Int picHeight, ///&lt; picture height const...
HEVC帧间预测
慢慢积累
01-12 1万+
经过一个月奋斗，终于7门考试考完了，继续来学习HEVC。 之前由于并没有用到帧间预测的东西，没有对帧间预测进行学习，现在来具体学习一下。帧间预测是利用视频时间域的相关性，使用邻近已编码图像像素预测当前图像的像素，以达到有效去除视频时域冗余的目的。目前主要采用基于块的运动补偿技术，原理是为当前图像的每个像素块在之前已编码图像中寻找一个最佳匹配块，即运动估计。用于预测的图像称为参考图像，参考块到当前像
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值