VVC/JEM代码学习10：xEncodeCU

最新推荐文章于 2020-04-07 12:00:54 发布
最新推荐文章于 2020-04-07 12:00:54 发布
阅读量502 收藏 1
点赞数
分类专栏： H.266/VVC JEM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxy19931018/article/details/79461128
版权
H.266/VVC 同时被 2 个专栏收录
50 篇文章 66 订阅
订阅专栏
JEM
26 篇文章 2 订阅
订阅专栏 
#if JVET_C0024_QTBT
Void TEncCu::xEncodeCU( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiWidth, UInt uiHeight, UInt uiSplitConstrain )
#else
Void TEncCu::xEncodeCU( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth )
#endif
{
#if JVET_C0024_BT_RMV_REDUNDANT
  pcCU->setSplitConstrain( uiSplitConstrain );
  Bool bQTreeValid = false;//bQTreeValid不用于知道四叉树的划分，而只用于赋值给bBTVerRmvEnable用于帧间二叉树划分的限制;
#endif

        TComPic   *const pcPic   = pcCU->getPic();
        TComSlice *const pcSlice = pcCU->getSlice();
  const TComSPS   &sps =*(pcSlice->getSPS());
  const TComPPS   &pps =*(pcSlice->getPPS());

#if !JVET_C0024_QTBT
  const UInt maxCUWidth  = sps.getMaxCUWidth();
  const UInt maxCUHeight = sps.getMaxCUHeight();

        Bool bBoundary = false;
#endif//当前CU的左上角和右下角的坐标;
        UInt uiLPelX   = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
#if JVET_C0024_QTBT
  const UInt uiRPelX   = uiLPelX + uiWidth  - 1;
#else
  const UInt uiRPelX   = uiLPelX + (maxCUWidth>>uiDepth)  - 1;
#endif
        UInt uiTPelY   = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
#if JVET_C0024_QTBT
  const UInt uiBPelY   = uiTPelY + uiHeight - 1;
#else
  const UInt uiBPelY   = uiTPelY + (maxCUHeight>>uiDepth) - 1;
#endif


#if JVET_C0024_QTBT
  Bool bForceQT = uiWidth > MAX_TU_SIZE;
  if( bForceQT )
  {
    assert(uiWidth == uiHeight);
  }
  UInt uiCTUSize = pcCU->getSlice()->getSPS()->getCTUSize();
#if JVET_C0024_DELTA_QP_FIX
  UInt uiQTWidth = uiCTUSize>>uiDepth;
  UInt uiQTHeight = uiCTUSize>>uiDepth;
  const UInt uiQTBTDepth = (uiDepth<<1) + (g_aucConvertToBit[uiQTWidth]-g_aucConvertToBit[uiWidth] + g_aucConvertToBit[uiQTHeight]-g_aucConvertToBit[uiHeight]);
  const UInt uiMaxDQPDepthQTBT = pps.getMaxCuDQPDepth() << 1;
#endif
  if (uiCTUSize>>uiDepth == uiWidth && uiWidth==uiHeight)//判断是否是正方形;
  {
#endif
  if( ( uiRPelX < sps.getPicWidthInLumaSamples() ) && ( uiBPelY < sps.getPicHeightInLumaSamples() ) )//没到达边缘
  {
#if JVET_C0024_QTBT
    if( bForceQT )//强迫四叉树划分
    {
      assert(uiDepth < pcCU->getDepth( uiAbsPartIdx ) ); 
    }
    else//不强迫四叉树划分
#endif
    m_pcEntropyCoder->encodeSplitFlag( pcCU, uiAbsPartIdx, uiDepth );//编码四叉树的划分标记;
  }
  else//是边缘，则不编码四叉树划分标记
  {
#if JVET_C0024_QTBT
    assert(uiDepth < pcCU->getDepth( uiAbsPartIdx ) );
#else
    bBoundary = true;
#endif
  }

#if JVET_C0024_BT_RMV_REDUNDANT
  bQTreeValid = true;
  UInt uiMinQTSize = sps.getMinQTSize(pcCU->getSlice()->getSliceType(), pcCU->getTextType());
  if ((uiCTUSize>>uiDepth) <= uiMinQTSize)//如果此时方块大小小于等于最小的四叉树大小，则不进行四叉树划分;
  {
    bQTreeValid = false;
  }
#endif

#if JVET_C0024_QTBT
  if( uiDepth < pcCU->getDepth( uiAbsPartIdx ) )//如果还没达到最大深度，用深度来判断是否进行了划分;
#else
  if( ( ( uiDepth < pcCU->getDepth( uiAbsPartIdx ) ) && ( uiDepth < sps.getLog2DiffMaxMinCodingBlockSize() ) ) || bBoundary )
#endif
  {//getNumPartitionsInCtu()函数返回一个CTU中包含4*4小块的个数;
    UInt uiQNumParts = ( pcPic->getNumPartitionsInCtu() >> (uiDepth<<1) )>>2;//最小的分区是4x4大小的块，这里计算出以该4x4块为单位的分割数，这么做便于计算当前CU的Zorder坐标
#if JVET_C0024_DELTA_QP_FIX
    if( uiQTBTDepth == uiMaxDQPDepthQTBT && pps.getUseDQP())
#else
    if( uiDepth == pps.getMaxCuDQPDepth() && pps.getUseDQP())
#endif
    {
      setdQPFlag(true);
#if JVET_C0024_DELTA_QP_FIX
      pcCU->setQuPartIdx( uiAbsPartIdx );
      pcCU->setQuLastCodedQP( pcCU->getCodedQP() );
#endif
    }

    if( uiDepth == pps.getPpsRangeExtension().getDiffCuChromaQpOffsetDepth() && pcSlice->getUseChromaQpAdj())
    {
      setCodeChromaQpAdjFlag(true);
    }

    for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 4; uiPartUnitIdx++, uiAbsPartIdx+=uiQNumParts )//如果进行了四叉树划分，则递归调用4次xEncodeCU;
    {
      uiLPelX   = pcCU->getCUPelX() + g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ];
      uiTPelY   = pcCU->getCUPelY() + g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ];
      if( ( uiLPelX < sps.getPicWidthInLumaSamples() ) && ( uiTPelY < sps.getPicHeightInLumaSamples() ) )//没达到图像边界
      {
#if JVET_C0024_QTBT
        xEncodeCU( pcCU, uiAbsPartIdx, uiDepth+1, uiWidth>>1, uiHeight>>1 );//深度加1，宽和高减半
#else
        xEncodeCU( pcCU, uiAbsPartIdx, uiDepth+1 );
#endif
      }
#if JVET_C0024_QTBT
      else//到达边界，则累加编码面积;
      {
        pcCU->getPic()->addCodedAreaInCTU(uiWidth*uiHeight>>2);
      }
#endif
    }
    return;
  }

#if JVET_C0024_QTBT
  }
#if JVET_C0024_BT_RMV_REDUNDANT
  Bool bBTHorRmvEnable = false;
  Bool bBTVerRmvEnable = false;
  if (pcCU->getSlice()->getSliceType() != I_SLICE)//不是I SLICE才能进行remove  redundant???
  {
    bBTHorRmvEnable = true;
    bBTVerRmvEnable = bQTreeValid;
  }
#endif
#if JVET_C0024_SPS_MAX_BT_DEPTH
  UInt uiMaxBTD = pcSlice->isIntra() ? (isLuma(pcCU->getTextType())?sps.getMaxBTDepthISliceL():sps.getMaxBTDepthISliceC()): sps.getMaxBTDepth();
#else
  UInt uiMaxBTD = pcCU->getSlice()->isIntra() ? (isLuma(pcCU->getTextType())?MAX_BT_DEPTH:MAX_BT_DEPTH_C): MAX_BT_DEPTH_INTER;
#endif
#if JVET_C0024_SPS_MAX_BT_SIZE
  UInt uiMaxBTSize = pcSlice->isIntra() ? (isLuma(pcCU->getTextType())?sps.getMaxBTSizeISliceL():sps.getMaxBTSizeISliceC()): sps.getMaxBTSize();
#else
  UInt uiMaxBTSize = isLuma(pcCU->getTextType()) ? pcCU->getSlice()->getMaxBTSize(): MAX_BT_SIZE_C;
#endif
  UInt uiMinBTSize = pcCU->getSlice()->isIntra() ? (isLuma(pcCU->getTextType())?MIN_BT_SIZE:MIN_BT_SIZE_C): MIN_BT_SIZE_INTER;
  UInt uiBTDepth = pcCU->getBTDepth(uiAbsPartIdx, uiWidth, uiHeight);//二叉树的深度是从四叉树叶节点开始算的

  if ( (uiHeight>uiMinBTSize || uiWidth>uiMinBTSize) 
    && uiWidth<=uiMaxBTSize && uiHeight<=uiMaxBTSize && uiBTDepth<uiMaxBTD) //判断是否进行了二叉树划分
  {
#if JVET_C0024_BT_RMV_REDUNDANT
    uiSplitConstrain = 0;
#endif
    m_pcEntropyCoder->encodeBTSplitMode(pcCU, uiAbsPartIdx, uiWidth, uiHeight);//编码二叉树划分标记;
    if (pcCU->getBTSplitModeForBTDepth(uiAbsPartIdx, uiBTDepth)==1)//水平二叉树划分;
    {
#if JVET_C0024_DELTA_QP_FIX
      if( uiQTBTDepth == uiMaxDQPDepthQTBT && pps.getUseDQP())
      {
        setdQPFlag(true);
#if JVET_C0024_DELTA_QP_FIX
        pcCU->setQuPartIdx( uiAbsPartIdx );
        pcCU->setQuLastCodedQP( pcCU->getCodedQP() );
#endif
      }
#endif
      for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 2; uiPartUnitIdx++ )//递归调用两次xEncodeCU;
      {
        if (uiPartUnitIdx==1)
        {
          uiAbsPartIdx = g_auiRasterToZscan[g_auiZscanToRaster[uiAbsPartIdx] 
          + (uiHeight>>1)/pcCU->getPic()->getMinCUHeight()*pcCU->getPic()->getNumPartInCtuWidth()];
        }
#if JVET_C0024_BT_RMV_REDUNDANT
        xEncodeCU( pcCU, uiAbsPartIdx, uiDepth, uiWidth, uiHeight>>1, uiSplitConstrain );//高度减半，uiDepth不变，应该这个指的是四叉树的深度
        if (pcCU->getBTSplitModeForBTDepth(uiAbsPartIdx, uiBTDepth+1) == 2 && bBTHorRmvEnable && uiPartUnitIdx==0)//如果当前层是水平划分，下一层是上边垂直个划分
        {
          uiSplitConstrain = 2;//则限制下一层进行垂直划分（即防止通过二叉树划分出来一个四叉树）
        }
#else
        xEncodeCU( pcCU, uiAbsPartIdx, uiDepth, uiWidth, uiHeight>>1 );
#endif
      }
      return;
    }
    else if (pcCU->getBTSplitModeForBTDepth(uiAbsPartIdx, uiBTDepth)==2)//垂直二叉树划分;
    {
#if JVET_C0024_DELTA_QP_FIX
      if( uiQTBTDepth == uiMaxDQPDepthQTBT && pps.getUseDQP())
      {
        setdQPFlag(true);
#if JVET_C0024_DELTA_QP_FIX
        pcCU->setQuPartIdx( uiAbsPartIdx );
        pcCU->setQuLastCodedQP( pcCU->getCodedQP() );
#endif
      }
#endif
      for ( UInt uiPartUnitIdx = 0; uiPartUnitIdx < 2; uiPartUnitIdx++ )//递归调用两次xEncodeCU;
      {
        if (uiPartUnitIdx==1)
        {
          uiAbsPartIdx = g_auiRasterToZscan[g_auiZscanToRaster[uiAbsPartIdx] 
          + (uiWidth>>1)/pcCU->getPic()->getMinCUWidth()];
        }
#if JVET_C0024_BT_RMV_REDUNDANT
        xEncodeCU( pcCU, uiAbsPartIdx, uiDepth, uiWidth>>1, uiHeight, uiSplitConstrain );//宽度减半，uiDepth也不变
        if (pcCU->getBTSplitModeForBTDepth(uiAbsPartIdx, uiBTDepth+1) == 1 && bBTVerRmvEnable && uiPartUnitIdx==0)//如果当前层是垂直划分，且下一层的左边是水平划分，
        {
          uiSplitConstrain = 1;//则限制右边水平划分（即防止通过二叉树划分出来一个四叉树）;
        }
#else
        xEncodeCU( pcCU, uiAbsPartIdx, uiDepth, uiWidth>>1, uiHeight );
#endif
      }
      return;
    }
  }

  pcCU->getPic()->addCodedAreaInCTU(uiWidth*uiHeight);
  UInt uiBlkX = g_auiRasterToPelX[ g_auiZscanToRaster[uiAbsPartIdx] ] >> MIN_CU_LOG2;
  UInt uiBlkY = g_auiRasterToPelY[ g_auiZscanToRaster[uiAbsPartIdx] ] >> MIN_CU_LOG2;
  pcCU->getPic()->setCodedBlkInCTU(true, uiBlkX, uiBlkY, uiWidth>> MIN_CU_LOG2, uiHeight>> MIN_CU_LOG2);

#endif

#if JVET_C0024_AMAX_BT
  if (!pcCU->getSlice()->isIntra())//不是I帧
  {
    g_uiBlkSize[pcCU->getSlice()->getDepth()] += uiWidth*uiHeight;
    g_uiNumBlk[pcCU->getSlice()->getDepth()]++;
  }
#endif
#if JVET_C0024_DELTA_QP_FIX
  if( uiQTBTDepth <= uiMaxDQPDepthQTBT && pps.getUseDQP())
#else
  if( uiDepth <= pps.getMaxCuDQPDepth() && pps.getUseDQP())
#endif
  {
    setdQPFlag(true);
#if JVET_C0024_DELTA_QP_FIX
    pcCU->setQuPartIdx( uiAbsPartIdx );
    pcCU->setQuLastCodedQP( pcCU->getCodedQP() );
#endif
  }

  if( uiDepth <= pps.getPpsRangeExtension().getDiffCuChromaQpOffsetDepth() && pcSlice->getUseChromaQpAdj())
  {
    setCodeChromaQpAdjFlag(true);
  }

  if (pps.getTransquantBypassEnableFlag())
  {
    m_pcEntropyCoder->encodeCUTransquantBypassFlag( pcCU, uiAbsPartIdx );//编码CU的变换量化旁路标记;
  }

  if( !pcSlice->isIntra() )//不是I帧;
  {
    m_pcEntropyCoder->encodeSkipFlag( pcCU, uiAbsPartIdx );//编码skip标记，只有帧间有skip;
  }

  if( pcCU->isSkipped( uiAbsPartIdx ) )//如果是skip模式;
  {
#if VCEG_AZ07_FRUC_MERGE
    m_pcEntropyCoder->encodeFRUCMgrMode( pcCU , uiAbsPartIdx , 0 );//编码FRUCmerge模式;
    if( !pcCU->getFRUCMgrMode( uiAbsPartIdx ) )//如果不是FRUC merge模式，因为FRUC merge，Affine merge和merge是竞争关系;
#endif
#if COM16_C1016_AFFINE
    {
      if ( pcCU->isAffineMrgFlagCoded(uiAbsPartIdx, 0) )
      {
        m_pcEntropyCoder->encodeAffineFlag( pcCU, uiAbsPartIdx, 0 );//编码仿射标记;
      }

      if ( !pcCU->isAffine(uiAbsPartIdx) )//如果不是仿射;
      {
        m_pcEntropyCoder->encodeMergeIndex( pcCU, uiAbsPartIdx );//编码MERGE索引;
      }
    }
#else
    m_pcEntropyCoder->encodeMergeIndex( pcCU, uiAbsPartIdx );
#endif
#if VCEG_AZ06_IC
    m_pcEntropyCoder->encodeICFlag  ( pcCU, uiAbsPartIdx );//编码局部亮度补偿标记;
#endif
#if !JVET_C0024_QTBT
    finishCU(pcCU,uiAbsPartIdx);
#endif
#if JVET_C0024_DELTA_QP_FIX
    if( pps.getUseDQP() )
    { 
      pcCU->setCodedQP( pcCU->getQP(uiAbsPartIdx) );
    }
#endif
    return;
  }

  m_pcEntropyCoder->encodePredMode( pcCU, uiAbsPartIdx );//编码预测模式
#if JVET_C0024_QTBT
  if (isLuma(pcCU->getTextType()))
  {
#endif
#if VCEG_AZ05_INTRA_MPI
  m_pcEntropyCoder->encodeMPIIdx(pcCU, uiAbsPartIdx);
#endif   
#if COM16_C1046_PDPC_INTRA && !JVET_G0104_PLANAR_PDPC
  m_pcEntropyCoder->encodePDPCIdx(pcCU, uiAbsPartIdx);
#endif  
#if JVET_C0024_QTBT
  }
#else
  m_pcEntropyCoder->encodePartSize( pcCU, uiAbsPartIdx, uiDepth );
#endif

#if JVET_C0024_QTBT
  if (pcCU->isIntra( uiAbsPartIdx ) )//如果是帧内预测
#else
  if (pcCU->isIntra( uiAbsPartIdx ) && pcCU->getPartitionSize( uiAbsPartIdx ) == SIZE_2Nx2N )
#endif
  {
    m_pcEntropyCoder->encodeIPCMInfo( pcCU, uiAbsPartIdx );//编码PCM信息，所以PCM属于帧内;

    if(pcCU->getIPCMFlag(uiAbsPartIdx))
    {
#if !JVET_C0024_QTBT
      // Encode slice finish
      finishCU(pcCU,uiAbsPartIdx);
#endif
#if JVET_C0024_DELTA_QP_FIX
      if( pps.getUseDQP() )
      { 
        pcCU->setCodedQP( pcCU->getQP(uiAbsPartIdx) );
      }
#endif
      return;
    }
  }

  // prediction Info ( Intra : direction mode, Inter : Mv, reference idx )
  m_pcEntropyCoder->encodePredInfo( pcCU, uiAbsPartIdx );//编码预测信息（帧内：预测方向，帧间：MV和参考帧索引）;
#if COM16_C806_OBMC
  m_pcEntropyCoder->encodeOBMCFlag( pcCU, uiAbsPartIdx );//编码重叠块运动补偿标记;
#endif
#if VCEG_AZ06_IC
  m_pcEntropyCoder->encodeICFlag  ( pcCU, uiAbsPartIdx );//编码局部光照补偿标记;
#endif
  // Encode Coefficients
  Bool bCodeDQP = getdQPFlag();
  Bool codeChromaQpAdj = getCodeChromaQpAdjFlag();
#if  VCEG_AZ05_ROT_TR  || VCEG_AZ05_INTRA_MPI || COM16_C1044_NSST || COM16_C1046_PDPC_INTRA
  Int bNonZeroCoeff = false;
#endif
#if JVET_C0045_C0053_NO_NSST_FOR_TS
  Int iNonZeroCoeffNonTs;
#endif
  m_pcEntropyCoder->encodeCoeff( pcCU, uiAbsPartIdx, uiDepth, bCodeDQP, codeChromaQpAdj
#if VCEG_AZ05_ROT_TR  || VCEG_AZ05_INTRA_MPI || COM16_C1044_NSST || COM16_C1046_PDPC_INTRA
    , bNonZeroCoeff
#endif
#if JVET_C0045_C0053_NO_NSST_FOR_TS
    , iNonZeroCoeffNonTs
#endif
    );//编码残差系数;
  setCodeChromaQpAdjFlag( codeChromaQpAdj );
  setdQPFlag( bCodeDQP );
#if JVET_C0024_DELTA_QP_FIX
  if( pps.getUseDQP() )
  { 
    pcCU->setCodedQP( pcCU->getQP(uiAbsPartIdx) );
  }
#endif

#if !JVET_C0024_QTBT
  // --- write terminating bit ---
  finishCU(pcCU,uiAbsPartIdx);
#endif
}


VVCSoftware-VTM-VTM-20.0 H.266/VVC 参考软件
04-27
VVCSoftware-VTM-VTM-20.0 H.266/VVC 参考软件是视频编码领域的一项重要工具，它基于最新的视频编码标准——Versatile Video Coding（VVC），也被称为H.266。这个软件包的发布是为了支持开发者、研究人员以及业界...
H.266/VVC代码学习13：VTM4.0中的CU层操作（compressCtu 、 xCompressCU）
时间有泪
03-22 5707
从H.266/VVC代码学习3：VTM4.0中的CTU层操作（encodeCtus）我们了解到了视频最基本的操作块为CTU，现在我们进一步学习CU层的操作。有两个十分重要的函数： 1 compressCtu: 是对encodeCtu中拿到的单个ctu进行操作，是进行CU划分预测等处理的入口。内部一共会调用两次 xCompressCU ，一次是对亮度进行处理，一次是对色度进行处理。可见compre...
HEVC代码学习35：xEncodeCU函数
慢慢积累
12-01 2789
xEncodeCU是由encodeCtu调用，其作用是从CTU开始迭代对每个CU进行编码。注意，xEncodeCU是在最优分块已经划分完成后进行编码时使用的，在xCompressCU中没有使用。 xEncodeCU会调用以下函数来完成各部分的编码： encodeSplitFlag编码块是否划分 encodeSkipFlag编码是否是skip模式 encodeMergeIndex如果是ski...
H.266代码学习：xEncodeCU函数
慢慢积累
03-29 1229
之前在HEVC代码学习35：xEncodeCU函数中介绍过xEncodeCU函数，今天来看JEM中的xEncodeCU，其中难点在于QTBT编码结构。 HM中使用compressCtu对每个CTU进行划分并预测，然后使用encodeCtu对每个CTU进行编码。JEM中也是如此，会在xEncodeCU，迭代完成CU各种信息的编码。所以在这里，当前的CTU已经进行了划分和预测，如果要看CU的划分和预...
HEVC函数入门（14）——建议先看：整个编码流程以及相关的函数
不是他人太努力，只是自己努力不够罢了
07-30 3273
这篇文章本来要放在前面的，但是我看到的晚，然后发现很有用，就转载一下吧。 转自：http://blog.csdn.net/nb_vol_1/article/details/51144828该作者也是转载，但是没有找到原地址。在此表示对这篇文章作者的感谢。 整个流程可以从compressGOP函数开始着手： 1、compressGOP对一整个图像组（GOP）进行编码，主要是遍历GOP中每
VVC/JEM代码学习6：xCompressCU（）
小小柴的博客
01-17 2507
      xCompressCU是一个递归函数，对于每一个CU，该函数都会被调用，主要是计算当前CU编码之后代价，然后再计算当前CU的每一个子CU编码后的代价，和当前CU的编码代价相比较，用来决定是否对当前CU进行分割。这个函数太复杂啦，继续慢慢学习吧。Void TEncCu::xCompressCU( TComDataCU*&amp; rpcBestCU, TComDataCU*&amp; r...
视频编解码VVC/H266 version1文档
07-21
视频编解码H266（也称为VVC，即Versatile Video Coding）是新一代的视频压缩标准。它是ITU-T（国际电信联盟-电信标准部门）和ISO/IEC（国际标准化组织/国际电工委员会）共同组成的联合视频组（JCT-VC）制定的。H266/...
H.266 JEM参考代码实现
08-12
1. **块划分策略**：JEM引入了更细粒度的块划分方式，包括方形和非方形的划分模式，使得编码器能够更好地适应图像内容的变化，提高压缩性能。 2. **深度多模式运动估计**：除了传统的块匹配方法，JEM还采用了深度...
VVC H.266 360P 60FPS测试片源
最新发布
03-13
Format/String : VVC Format/Info : Versatile Video Coding CodecID : vvc1 CodecID/Info : Versatile Video Coding Duration/String : 10s 0ms BitRate/String : 507 Kbps BitRate_Maximum/String : 692 ...
H266/VVC码流解析器
10-22
Eleard官方的码流解析器
【HEVC学习与研究】30、解码Coding Unit数据
Workshop of Wenjie.Yin
06-10 3614
一个CU结构可以认为是实际编码过程中的
HEVC学习（十二） —— CU的最终划分
热门推荐
HEVC_CJL的专栏
12-09 2万+
相信会有不少人对如何确定CU最终的划分有所困惑（包括我在内，刚开始接触时也不知道该怎么做），我觉得很大的一个原因就是CU是递归划分的，这就导致在寻找确定最佳分割位置时比较困难。   其实，解决问题的办法说难也不难，关键在于思路的转换，既然对于xCompressCU中是如何保存划分模式的觉得难以理解，何不跳出这个小圈子寻找新的方法呢？   我们可以从解码器的角度来考虑，因为最终编码后的码流是
xCompressCU&&xEncodeCU&&main
Ant for life.
08-08 1957
1.xCompressCU Control Flow Graph 2.xEncodeCU Butterfly Graph 3.main Butterfly Graph 4.main Cluster Call Graph
HEVC中CTU递归代码分析
xietingcandice的专栏
12-24 3516
CU递归的算法，那么就是xDecodeCU这个函数里面 首先对其中一些比较难以理解的部分进行相应的整理 UInt uiCurNumParts    = pcPic->getNumPartitionsInCtu() >> (uiDepth pcPic->getNumPartitionsInCtu() 获得的数据就是LCU中也就是根节点中CTU对应的按照最小TU进行划分得到的数量，后
HEVC代码学习39：decodeCtu和xDecodeCU函数
慢慢积累
05-11 1424
在之前 HEVC代码学习38：decompressSlice函数 学习中提到，解码slice会遍历所有CTU，调用decodeCtu和decompressCtu解码每一个CTU。下面就来学习一下decodeCtu和xDecodeCU函数。 decodeCtu 该函数是解码CTU的入口函数，有两个输入参数：待解码的CTU和一个标识是否是slice最后一个CTU的flag。代码很短，其中调用x...
H.266/VVC代码学习3：VTM4.0中的CTU层操作（encodeCtus）
时间有泪
02-23 4109
由于要研究比特数的相关内容，本周阅读了encodeCtus。学习笔记如下： void EncSlice::encodeCtus( Picture* pcPic, const bool bCompressEntireSlice, const bool bFastDeltaQP, uint32_t startCtuTsAddr, uint32_t boundingCtuTsAddr, EncLib* ...
H.266/VVC代码学习61：VTM中deblocking源码阅读
时间有泪
04-07 1595
/* The copyright in this software is being made available under the BSD * License, included below. This software may be subject to other third party * and contributor rights, including patent rights...
H266/VVC视频编码源代码发布
对于希望学习VVC标准，或者将其集成到产品中的开发者来说，这份源代码是了解和实现VVC编码技术的理想起点。对于学术界来说，源代码的开放性还意味着可以进行深入的研究和创新，推动视频编码技术的发展。
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值