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

最新推荐文章于 2020-04-08 21:24:49 发布
最新推荐文章于 2020-04-08 21:24:49 发布
阅读量556 收藏
点赞数
分类专栏： HEVC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010289908/article/details/48858553
版权


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


u010289908
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
HEVC代码学习9：getInterMergeCandidates函数
慢慢积累
05-08 1804
今天需要统计Merge的候选列表信息，来看下getInterMergeCandidates函数，用于建立merge候选列表。 其主要工作流程： 1.建立空间列表，如果达到最大候选数，退出。 2.空间列表不能填满候选列表，建立时域列表补足，如果达到最大候选数，退出。 3.空间+时域列表不能填满候选列表，建立组合列表补足，如果达到最大候选数，退出。 4.若依然为填满，则使用零MV补足。//!
HEVC帧间预测之一——TComDataCU::getInterMergeCandidates函数分析
HEVC_CJL的专栏
03-12 1万+
从今天开始，正式转入到帧间预测方向。由于帧间预测涉及到的方面广且复杂，所以我的理解出现错误的情况可能会更多，请大家以辩证的眼光来看待我的帖子，有问题欢迎大家批评指正。   大家都知道xCompressCU是实际进行预测编码的函数，故很容易就能锁定帧间预测的一个大致范围，在研究了帧内预测的基础上，相信很快就能在该函数中找到与帧间预测相关的函数：xCheckRDCostInter，xCheckRD
H.266/VVC代码学习笔记13：VTM6.0中的getInterMergeCandidates（）函数
Peter_Red_Boy的博客
09-16 1312
getInterMergeCandidates（）函数是帧间预测技术中一个非常重要的函数，它是Merge列表的构造函数，所有的Merge模式都要先构造一个Merge候选列表，然后根据不同的模式在此regularMerge列表的基础上去延伸出相对应的Merge列表，就比如MMVD的Merge列表需要在常规Merge列表的基础上去选择两个初始MV，然后构造MMVDMerge。 普通Merge列表的构造...
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.空域...
HEVC帧间预测
热门推荐
慢慢积累
01-12 1万+
经过一个月奋斗，终于7门考试考完了，继续来学习HEVC。 之前由于并没有用到帧间预测的东西，没有对帧间预测进行学习，现在来具体学习一下。帧间预测是利用视频时间域的相关性，使用邻近已编码图像像素预测当前图像的像素，以达到有效去除视频时域冗余的目的。目前主要采用基于块的运动补偿技术，原理是为当前图像的每个像素块在之前已编码图像中寻找一个最佳匹配块，即运动估计。用于预测的图像称为参考图像，参考块到当前像
voidc:编程语言无效
03-07
然而，“voidc: 编程语言无效”这一标题似乎暗示了一个问题，即“voidc”可能并非一种有效的或被广泛认可的编程语言。在讨论这个主题时，我们将主要聚焦于C++，因为这是提供的标签之一，同时也会对比其他常见编程...
void.cljc：关于无效和缺少信息
02-01
在Clojure编程语言中，`void`是一个特殊形式，它主要用作函数调用的返回值，以确保函数不返回任何具体值。标题"void.cljc：关于无效和缺少信息"提示我们，这个讨论可能围绕着`void`的使用、其在处理无返回值或者信息...
OpenCV实现帧间差分法详解
08-19
OpenCV实现帧间差分法详解 OpenCV实现帧间差分法是一种常用的目标检测算法，通过检测相邻两帧图像之间的差异，来提取运动目标信息。在本文中，我们将详细介绍OpenCV实现帧间差分法的原理、实现方法和优缺点。 一、...
Typecho-Theme-VOID::monkey: 猴子打字机原理的产物
05-30
Typecho Theme VOID 3.5.1 :pencil: 一款简洁优雅的 Typecho 主题 作为计算机术语时，VOID 的意思是「无类型」。 特性 介绍文章：。 响应式设计 ...我建立了一个示例页面，在这里你可以看到 VOID 对
商城代码javascript:void(0);
05-06
商城代码javascript:void(0);
【转载】HEVC帧间预测之一——TComDataCU::getInterMergeCandidates函数分析
HEVC_heiyue的专栏
12-23 541
转载自 从今天开始，正式转入到帧间预测方向。由于帧间预测涉及到的方面广且复杂，所以我的理解出现错误的情况可能会更多，请大家以辩证的眼光来看待我的帖子，有问题欢迎大家批评指正。   大家都知道xCompressCU是实际进行预测编码的函数，故很容易就能锁定帧间预测的一个大致范围，在研究了帧内预测的基础上，相信很快就能在该函数中找到与帧间预测相关的函数：xCheckRDCostI
Void TComPicYuv::create
xhyan523的博客
03-26 260
Void TComPicYuv::create ( const Int picWidth, ///&lt; picture width const Int picHeight, ///&lt; picture height const...
帧内、帧间预测编码效率比较
慢慢积累
08-22 1万+
在之前的各种文献中都看到过这样的结论：帧间预测的编码增益要高于帧内预测。可是从来没看过详细解释，今天来总结一下。首先来看原理： 帧内预测——基于同一帧内已编码块预测，构造预测块，计算与当前块的残差，对残差、预测模式等信息进行编码。其主要去除的是空域冗余。 帧间预测——基于一个或多个已编码帧预测，构造预测块，计算与当前块的残差，对残差、预测模式、运动矢量、参考图像索引等信息进行编码。其主要去除的是
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...
关于HM/JEM Merge Candidates
Coding
12-08 840
TComDataCU::getInterMergeCandidates函数用于得到Merge模式的候选列表。Merge模式的候选列表最多为5个，且默认为5个： software-manual可以设置参数：MaxNumMergeCand 5 Specifies the maximum number of merge candidates to use. CommonDef.h中的最大值：stati
分析HM代码,首先必须把class TComDataCU完全搞明白!
飞翔 视频直播系统
11-29 1万+
分析HM代码,首先必须把class TComDataCU完全搞明白! 为了找到合适的模式或者合适的分割, 基本上都是采用两个TComDataCU来操作, TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU. 相当于两个指针对应两个乒乓buffer,  m_ppcBestCU[uiDepth], m_ppcTempCU[uiDepth], 当然每一个ui
HEVC中的Merge Mode——x265代码getInterMergeCandidates（）函数解析
qq_40102403的博客
11-13 1296
HEVC中的mv预测技术主要分为两种：AMVP mode 和Merge mode，这里就主要来聊聊Merge mode。 由于很多时候当前的编码CU与相邻已经完成编码的CU具有相同的mv，因此从相邻的若干个PU中获取最佳的mv就是Merge mode要做的主要事情： 通过搜索相邻PU的motion information（包括reference index和mv）是否可用，可得时加入MergeC...
VTM3.0代码阅读：getInterMergeCandidates函数
矛盾统一
12-26 257
xCheckRDCostMerge2Nx2N函数中调用getInterMergeCandidates获取merge候选，存储于mrgCtx。 MergeCtx类用来表示merge候选列表，其中存储merge候选列表中的各种信息： class MergeCtx { //... public: MvField mvFieldNeighbours [ MRG_MAX_NUM_CANDS...
浅谈HEVC中的CTU CU PU TU
u010289908的专栏
04-29 9166
CTU CU PU TU
代码解析void KeyBoard::ReleaseInstance()
最新发布
07-13
void KeyBoard::ReleaseInstance() 是一个函数的定义，它属于名为 KeyBoard 的类的成员函数。这函数可能用于释放 KeyBoard 类的单例实例。 函数定义的格式通常是： 返回类型 类名::函数名() { // 函数体 } 在这...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值