VVC/JEM代码学习6：xCompressCU（）

最新推荐文章于 2023-10-13 18:44:43 发布
置顶 最新推荐文章于 2023-10-13 18:44:43 发布
阅读量2.4k 收藏 9
点赞数 2
分类专栏： JEM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxy19931018/article/details/79085603
版权

      xCompressCU是一个递归函数，对于每一个CU，该函数都会被调用，主要是计算当前CU编码之后代价，然后再计算当前CU的每一个子CU编码后的代价，和当前CU的编码代价相比较，用来决定是否对当前CU进行分割。这个函数太复杂啦，继续慢慢学习吧。

Void TEncCu::xCompressCU( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, const UInt uiDepth, UInt uiWidth, UInt uiHeight, UInt uiBTSplitMode DEBUG_STRING_FN_DECLARE(sDebug_), UInt uiSplitConstrain )

#else
Void TEncCu::xCompressCU( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, const UInt uiDepth DEBUG_STRING_FN_DECLARE(sDebug_), PartSize eParentPartSize )
#endif
#else
Void TEncCu::xCompressCU( TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU, const UInt uiDepth )
#endif
{
//每个深度的预测用的都是temp，预测完后跟best比较并交换。best保留作为当前深度的预测数据，
//而temp再次初始化。在下一深度的子CU预测中用的是subtemp，每预测完一个子CU，就跟subbest比较交换，
//再把subbest的数据复制到已经初始化的temp的相应位置。当temp获取完子CU的subbest的数据后,
//就代表了整个下一深度的数据，这时再与代表当前深度数据的best比较交换;


#if JVET_C0024_BT_RMV_REDUNDANT
  rpcBestCU->setSplitConstrain( uiSplitConstrain );
  rpcTempCU->setSplitConstrain( uiSplitConstrain );


  Bool bQTreeValid = false;
#endif
  TComPic* pcPic = rpcBestCU->getPic();
  DEBUG_STRING_NEW(sDebug)
  const TComPPS &pps=*(rpcTempCU->getSlice()->getPPS());
  const TComSPS &sps=*(rpcTempCU->getSlice()->getSPS());


#if JVET_C0024_QTBT
  // These are only used if getFastDeltaQp() is true,32;
  const UInt fastDeltaQPCuMaxSize    = Clip3(sps.getMinQTSize(rpcBestCU->getSlice()->getSliceType(), rpcBestCU->getTextType())
    , sps.getCTUSize(), 32u);
#else
  // These are only used if getFastDeltaQp() is true
  const UInt fastDeltaQPCuMaxSize    = Clip3(sps.getMaxCUHeight()>>sps.getLog2DiffMaxMinCodingBlockSize(), sps.getMaxCUHeight(), 32u);
#endif


  // get Original YUV data from picture
#if JVET_C0024_QTBT
  UInt uiWidthIdx = g_aucConvertToBit[rpcTempCU->getWidth(0)];//=5;
  UInt uiHeightIdx = g_aucConvertToBit[rpcTempCU->getHeight(0)];//=5;
  //从图像中复制原始YUV数据;
  m_pppcOrigYuv[uiWidthIdx][uiHeightIdx]->copyFromPicYuv( pcPic->getPicYuvOrg(), rpcBestCU->getCtuRsAddr(), rpcBestCU->getZorderIdxInCtu() );


  UInt uiPelXInCTU = rpcBestCU->getCUPelX() - rpcBestCU->getPic()->getCtu(rpcBestCU->getCtuRsAddr())->getCUPelX();
  UInt uiPelYInCTU = rpcBestCU->getCUPelY() - rpcBestCU->getPic()->getCtu(rpcBestCU->getCtuRsAddr())->getCUPelY();
  rpcBestCU->getPic()->setCodedBlkInCTU(false, uiPelXInCTU>> MIN_CU_LOG2, uiPelYInCTU>> MIN_CU_LOG2, uiWidth>> MIN_CU_LOG2, uiHeight>> MIN_CU_LOG2 );  
#else
  m_ppcOrigYuv[uiDepth]->copyFromPicYuv( pcPic->getPicYuvOrg(), rpcBestCU->getCtuRsAddr(), rpcBestCU->getZorderIdxInCtu() );
#endif


  // variable for Cbf fast mode PU decision
#if !JVET_C0024_QTBT
  Bool    doNotBlockPu = true;
#endif
  Bool    earlyDetectionSkipMode = false;
  //获取当前最优CU的范围;
  const UInt uiLPelX   = rpcBestCU->getCUPelX();//左边的像素，0;
  const UInt uiRPelX   = uiLPelX + rpcBestCU->getWidth(0)  - 1;//最右边的像素，127;
  const UInt uiTPelY   = rpcBestCU->getCUPelY();//上边的像素，0;
  const UInt uiBPelY   = uiTPelY + rpcBestCU->getHeight(0) - 1;//最下边的像素，127;
#if !JVET_C0024_QTBT
  const UInt uiWidth   = rpcBestCU->getWidth(0);
#endif
#if JVET_C0024_DELTA_QP_FIX
  UInt uiQTWidth = sps.getCTUSize()>>uiDepth;//四叉树的宽度，128;
  UInt uiQTHeight = sps.getCTUSize()>>uiDepth;//四叉树的高度，128;
  UInt uiBTDepth = g_aucConvertToBit[uiQTWidth]-g_aucConvertToBit[uiWidth] + g_aucConvertToBit[uiQTHeight]-g_aucConvertToBit[uiHeight];//二叉树深度;
  const UInt uiQTBTDepth = (uiDepth<<1) + uiBTDepth;//QTBT的深度是四叉树的深度加二叉树的深度;
  const UInt uiMaxDQPDepthQTBT = pps.getMaxCuDQPDepth() << 1;
#endif


#if JVET_D0077_SAVE_LOAD_ENC_INFO
  Bool bUseSaveLoad = m_pcEncCfg->getUseSaveLoadEncInfo() && uiWidthIdx > 0 && uiHeightIdx > 0;
  Bool bUseSaveLoadSplitDecision = bUseSaveLoad && m_pcEncCfg->getUseSaveLoadSplitDecision();
#if COM16_C1046_PDPC_INTRA && !JVET_G0104_PLANAR_PDPC
  ChannelType eChannelType = rpcBestCU->getTextType();
#endif
  UInt uiZorderIdx = rpcBestCU->getZorderIdxInCtu();//当前最优CU在CTU中以Z扫描顺序的索引;
#endif

 Int iBaseQP = xComputeQP( rpcBestCU, uiDepth );//计算QP,量化步长;
  Int iMinQP;
  Int iMaxQP;
  Bool isAddLowestQP = false;

#if COM16_C806_EMT
  Double dBestInterCost = MAX_DOUBLE;
  Bool   bEarlySkipIntra = false;
#if !JVET_C0024_QTBT
  Bool   bAllIntra = (m_pcEncCfg->getIntraPeriod()==1);
  Double dIntra2Nx2NCost = MAX_DOUBLE;
#endif
#if !JVET_C0024_QTBT
  Double dIntraNxNCost = MAX_DOUBLE;
#endif
#endif

#if JVET_C0024_DELTA_QP_FIX
  const Char lastCodedQP = rpcBestCU->getCodedQP(); 
#endif

#if JVET_E0076_MULTI_PEL_MVD
  m_dBestMvDPelCost[0] = m_dBestMvDPelCost[1] = m_dBestMvDPelCost[2] = MAX_DOUBLE/2;
#endif
  const UInt numberValidComponents = rpcBestCU->getPic()->getNumberValidComponents();//3;
#if VCEG_AZ08_INTER_KLT
  g_bEnableCheck = false;
#endif
  /设置最大的QP和最小的QP/
#if JVET_C0024_DELTA_QP_FIX
  if( uiQTBTDepth <= uiMaxDQPDepthQTBT )
#else
  if( uiDepth <= pps.getMaxCuDQPDepth() )
#endif
  {
    Int idQP = m_pcEncCfg->getMaxDeltaQP();
    iMinQP = Clip3( -sps.getQpBDOffset(CHANNEL_TYPE_LUMA), MAX_QP, iBaseQP-idQP );
    iMaxQP = Clip3( -sps.getQpBDOffset(CHANNEL_TYPE_LUMA), MAX_QP, iBaseQP+idQP );
#if JVET_C0024_DELTA_QP_FIX
    if( pps.getUseDQP() )
    {
      UInt uiCurrPartIdxInCtu = rpcBestCU->getZorderIdxInCtu();
      rpcBestCU->setQuPartIdx( uiCurrPartIdxInCtu );
      rpcTempCU->setQuPartIdx( uiCurrPartIdxInCtu );
      rpcBestCU->setQuLastCodedQP( lastCodedQP );
      rpcTempCU->setQuLastCodedQP( lastCodedQP );
    }
#endif
  }
  else
  {
    iMinQP = rpcTempCU->getQP(0);
    iMaxQP = rpcTempCU->getQP(0);
  }
#if WCG_LUMA_DQP_CM_SCALE
  Int targetQP = iBaseQP;
  if (m_pcEncCfg->getUseLumaDeltaQp() )
  {
    if (uiQTBTDepth <= uiMaxDQPDepthQTBT)
    {
      m_LumaQPOffset = calculateLumaDQP(rpcTempCU, 0, m_pppcOrigYuv[uiWidthIdx][uiHeightIdx]);  // keep using the same m_QP_LUMA_OFFSET in the same LCU
    }
    targetQP = Clip3(-sps.getQpBDOffset(CHANNEL_TYPE_LUMA), MAX_QP, iBaseQP - m_LumaQPOffset);  // targetQP is used for control lambda,32;
    iMinQP = targetQP;
    iMaxQP = iMinQP;   // make it same as MinQP to force encode choose the modified QP
  }  

#endif
  if ( m_pcEncCfg->getUseRateCtrl() )
  {
    iMinQP = m_pcRateCtrl->getRCQP();
    iMaxQP = m_pcRateCtrl->getRCQP();
  }

  // transquant-bypass (TQB) processing loop variable initialisation ---
  
  const Int lowestQP = iMinQP; // For TQB, use this QP which is the lowest non TQB QP tested (rather than QP'=0) - that way delta QPs are smaller, and TQB can be tested at all CU levels.

  if ( (pps.getTransquantBypassEnableFlag()) )
  {
    isAddLowestQP = true; // mark that the first iteration is to cost TQB mode.
    iMinQP = iMinQP - 1;  // increase loop variable range by 1, to allow testing of TQB mode along with other QPs
    if ( m_pcEncCfg->getCUTransquantBypassFlagForceValue() )
    {
      iMaxQP = iMinQP;
    }
  }

#if VCEG_AZ06_IC
  Bool bICEnabled = rpcTempCU->getSlice()->getApplyIC();
#if JVET_C0024_QTBT
#if VCEG_AZ06_IC_SPEEDUP
 if (uiWidth * uiHeight <= 32 )
  {
    bICEnabled = false;
  }
#endif
#endif
#endif

  TComSlice * pcSlice = rpcTempCU->getPic()->getSlice(rpcTempCU->getPic()->getCurrSliceIdx());

#if COM16_C806_LARGE_CTU
#if JVET_C0024_QTBT//ucMaxDepth=4;
  UChar ucMinDepth = 0 , ucMaxDepth = g_aucConvertToBit[pcSlice->getSPS()->getCTUSize()] 
  - g_aucConvertToBit[pcSlice->getSPS()->getMinQTSize(pcSlice->getSliceType(), rpcTempCU->getTextType())];
#else
  UChar ucMinDepth = 0 , ucMaxDepth = ( UChar )pcSlice->getSPS()->getLog2DiffMaxMinCodingBlockSize();
#endif
  if( m_pcEncCfg->getUseFastLCTU() )//enable fast method for large CTU;
  {
    rpcTempCU->getMaxMinCUDepth( ucMinDepth , ucMaxDepth , rpcTempCU->getZorderIdxInCtu() );
  }
#endif

#if JVET_C0024_QTBT
  Bool bBoundary = !( uiRPelX < sps.getPicWidthInLumaSamples() && uiBPelY < sps.getPicHeightInLumaSamples() );//判断当前CU是否在图像边界;
#else
  const Bool bBoundary = !( uiRPelX < sps.getPicWidthInLumaSamples() && uiBPelY < sps.getPicHeightInLumaSamples() );
#endif
#if JVET_C0024_QTBT
  Bool bForceQT = uiWidth > MAX_TU_SIZE;
  if( bForceQT )
  {
    assert(uiWidth == uiHeight);
  }
#endif
#if JVET_D0077_SAVE_LOAD_ENC_INFO
  UChar saveLoadTag = m_pcPredSearch->getSaveLoadTag( uiZorderIdx, uiWidthIdx, uiHeightIdx );
  UChar saveLoadSplit = ( (bUseSaveLoadSplitDecision && saveLoadTag == LOAD_ENC_INFO) ? m_pcPredSearch->getSaveLoadSplit(uiWidthIdx, uiHeightIdx) : 0 );
  Double dCostTempBest = MAX_DOUBLE;//最优的临时代价;
  Double dNonSplitCost = MAX_DOUBLE;//不分割的代价;
  Double dHorSplitCost = MAX_DOUBLE;//水平分割的代价;
  Double dVerSplitCost = MAX_DOUBLE;//垂直分割的代价;
#endif
  if (!bBoundary
#if COM16_C806_LARGE_CTU
  && ucMinDepth <= uiDepth
#endif
#if JVET_C0024_QTBT
  && !bForceQT
#endif
#if JVET_D0077_SAVE_LOAD_ENC_INFO
  && !(saveLoadSplit & 0x01)
#endif
  )
  {
#if JVET_D0077_FAST_EXT
  Bool bPrevSameBlockIsIntra = rpcBestCU->getPic()->getIntra(rpcBestCU->getZorderIdxInCtu(), uiWidth, uiHeight);
  Bool bPrevSameBlockIsSkip = rpcBestCU->getPic()->getSkiped(rpcBestCU->getZorderIdxInCtu(), uiWidth, uiHeight);
#endif
  //从最小的QP到最大的QP遍历每一个QP，对每一个QP执行下面的操作（目的是选出最优的QP）/
  for (Int iQP = iMinQP; iQP <= iMaxQP; iQP++)
  {
  const Bool bIsLosslessMode = isAddLowestQP && (iQP == iMinQP);

  if (bIsLosslessMode)//判断是否为无损模式，若是无损，则QP设置为最低值;
  {
  iQP = lowestQP;
  }
#if WCG_LUMA_DQP_CM_SCALE
  if (m_pcEncCfg->getUseLumaDeltaQp() && (uiQTBTDepth <= uiMaxDQPDepthQTBT))
  {
  getSliceEncoder()->updateLambda(pcSlice, targetQP);
  }
#endif

  m_cuChromaQpOffsetIdxPlus1 = 0;
  if (pcSlice->getUseChromaQpAdj())
  {
  /* Pre-estimation of chroma QP based on input block activity may be performed
   * here, using for example m_ppcOrigYuv[uiDepth] */
   /* To exercise the current code, the index used for adjustment is based on
* block position
*/
#if JVET_C0024_QTBT
Int lgMinCuSize = g_aucConvertToBit[sps.getMinQTSize(pcSlice->getSliceType(), rpcBestCU->getTextType())] + MIN_CU_LOG2 +
  std::max<Int>(0, g_aucConvertToBit[sps.getCTUSize()] - g_aucConvertToBit[sps.getMinQTSize(pcSlice->getSliceType(), rpcBestCU->getTextType())] - Int(pps.getPpsRangeExtension().getDiffCuChromaQpOffsetDepth()));
#else
  Int lgMinCuSize = sps.getLog2MinCodingBlockSize() +
  std::max<Int>(0, sps.getLog2DiffMaxMinCodingBlockSize() - Int(pps.getPpsRangeExtension().getDiffCuChromaQpOffsetDepth()));
#endif
  m_cuChromaQpOffsetIdxPlus1 = ((uiLPelX >> lgMinCuSize) + (uiTPelY >> lgMinCuSize)) % (pps.getPpsRangeExtension().getChromaQpOffsetListLen() + 1);
  }
  //初始化当前CU的数据;
  rpcTempCU->initEstData(uiDepth, iQP, bIsLosslessMode);

#if VCEG_AZ07_IMV && !JVET_C0024_QTBT
  m_setInterCand.clear();
  for (Int n = 0; n < NUMBER_OF_PART_SIZES; n++)
  {
#if JVET_C0024_QTBT
  m_pppcTempCUIMVCache[n][uiWidthIdx][uiHeightIdx]->initEstData(uiDepth, iQP, bIsLosslessMode);
#else
  m_ppcTempCUIMVCache[n][uiDepth]->initEstData(uiDepth, iQP, bIsLosslessMode);
#endif
  }
#endif
  /帧间模式选择//
// do inter modes, SKIP and 2Nx2N
  if (rpcBestCU->getSlice()->getSliceType() != I_SLICE)//不是I_SLICE,即不进行帧内预测;
  {
#if JVET_D0077_SAVE_LOAD_ENC_INFO
#if VCEG_AZ07_FRUC_MERGE
  Bool bFastSkipFruc = (saveLoadTag == LOAD_ENC_INFO && 0 == m_pcPredSearch->getSaveLoadFrucMode(uiWidthIdx, uiHeightIdx));
#endif
#if VCEG_AZ07_IMV
  Bool bFastSkipIMV = (saveLoadTag == LOAD_ENC_INFO && (!m_pcPredSearch->getSaveLoadIMVFlag(uiWidthIdx, uiHeightIdx) || m_pcPredSearch->getSaveLoadMergeFlag(uiWidthIdx, uiHeightIdx)));
#endif
  Bool bFastSkipInter = (saveLoadTag == LOAD_ENC_INFO && m_pcPredSearch->getSaveLoadMergeFlag(uiWidthIdx, uiHeightIdx));
#if COM16_C1016_AFFINE
  Bool bFastSkipAffine = (saveLoadTag == LOAD_ENC_INFO && !m_pcPredSearch->getSaveLoadAffineFlag(uiWidthIdx, uiHeightIdx));
#endif
#endif
#if VCEG_AZ06_IC
  for (UInt uiICId = 0; uiICId < (bICEnabled ? 2 : 1); uiICId++)
  {
  Bool bICFlag = uiICId ? true : false;
#endif
  // 2Nx2N
  if (m_pcEncCfg->getUseEarlySkipDetection()) //使用earlyDetectionSkipMode;
  {
#if VCEG_AZ06_IC
  rpcTempCU->setICFlagSubParts(bICFlag, 0, uiDepth);
#endif    比较已有最佳模式与2N*2N Inter算出的TempRDcost的大小;
xCheckRDCostInter(rpcBestCU, rpcTempCU, SIZE_2Nx2N DEBUG_STRING_PASS_INTO(sDebug));
 rpcTempCU->initEstData(uiDepth, iQP, bIsLosslessMode);//by Competition for inter_2Nx2N
  }
  // SKIP
#if VCEG_AZ06_IC
  if (!bICFlag)
  {
#endif
#if COM16_C1016_AFFINE
#if JVET_D0077_FAST_EXT
  if (rpcTempCU->getSlice()->getSPS()->getUseAffine() && !bPrevSameBlockIsIntra
#if JVET_D0077_SAVE_LOAD_ENC_INFO
  && !bFastSkipAffine
#endif
  )
#else
  if (rpcTempCU->getSlice()->getSPS()->getUseAffine())
#endif
  {//比较已有最佳模式与AffineMerge2Nx2N算出的tempRDcost的大小;
  xCheckRDCostAffineMerge2Nx2N(rpcBestCU, rpcTempCU);//H.266新加的技术;
  rpcTempCU->initEstData(uiDepth, iQP, bIsLosslessMode);
  }
#endif
  //比较已有最佳模式与Merge2N*2N算出的TempRdcost大小;
  xCheckRDCostMerge2Nx2N(rpcBestCU, rpcTempCU DEBUG_STRING_PASS_INTO(sDebug), &earlyDetectionSkipMode);//by Merge for inter_2Nx2N
  rpcTempCU->initEstData(uiDepth, iQP, bIsLosslessMode);
#if VCEG_AZ06_IC
  }
#endif

#if VCEG_AZ07_FRUC_MERGE
#if JVET_D0077_FAST_EXT
  if (rpcTempCU->getSlice()->getSPS()->getUseFRUCMgrMode() && !bPrevSameBlockIsIntra
#if JVET_D0077_SAVE_LOAD_ENC_INFO
  && !bFastSkipFruc
#endif
  )
#else
  if (rpcTempCU->getSlice()->getSPS()->getUseFRUCMgrMode())
#endif
  {
#if VCEG_AZ06_IC
  rpcTempCU->setICFlagSubParts(bICFlag, 0, uiDepth);
#endif    //比较已有最佳模式与Merge2N*2NFRUC的TempRDcost的大小;
  xCheckRDCostMerge2Nx2NFRUC(rpcBestCU, rpcTempCU, &earlyDetectionSkipMode);//也是H.266里新加的;
  rpcTempCU->initEstData(uiDepth, iQP, bIsLosslessMode);
  }
#endif

#if JVET_C0024_QTBT
#if JVET_D0077_FAST_EXT
  if (!m_pcEncCfg->getUseEarlySkipDetection() && !bPrevSameBlockIsSkip && !bPrevSameBlockIsIntra
#if JVET_D0077_SAVE_LOAD_ENC_INFO
  && !bFastSkipInter
#i
最低0.47元/天 解锁文章
小小柴
关注
专栏目录
BMS/VTM代码学习：xCompressCU
慢慢积累
09-26 3792
找工作基本结束，收心回来看266了，从xCompressCU开始吧。在初学者阶段写过HEVC代码学习11：xCompressCU函数，当时实际看的一知半解，作为参考吧。 BMS/VTM中xCompressCU代码精简了很多，看起来容易多了，主要流程为： 1.初始化：设置可用模式、上下文模型等。 2.尝试帧间、帧内各种可用预测模式，当遍历完所有可用模式后，调用xCheckModeSplit进行划分，...
xcompressCU
Moz_z的专栏
10-03 1585
// ==================================================================================================================== // Protected member functions // ===============================================
H.266/VVC代码学习：xCompressCU函数
BigDream123的博客
08-02 2661
xCompressCU函数是用来进行CU划分（递归调用自身）以及模式选择。 首先调用m_modeCtrl->initCULevel函数初始化模式选择列表，由堆栈控制，将当前CU可以划分的模式（四叉划分、二叉划分和三叉划分）、编码模式（帧内、帧间Merge、帧间inter等） 之后，遍历模式列表，将待测试的模式出栈，根据模式调用不同的函数，所有待测试的模式如下所示： enum EncTestModeType { ETM_HASH_INTER, ETM_MERGE_SKIP, ETM_
HTM-16.2代码（3）——xCompressCU
Eyrane的博客
12-30 597
（1）所有LCU都是通过调用compressCtu（主要为xCompressCU）来实现其CU/PU划分；然后通过其结果再调用 TEncCu::encodeCtu函数来实现对所有CUs进行压缩编码. （2）xCompressCU是一个递归函数。将当前CU划分为4个子CU，计算失真，根据失真大小判断是否划分。...
VVC/JEM代码学习：xCompressCU
小小柴的博客
01-17 1336
        今天上午又看到一篇挺好的关于xCompressCU函数的总结文，不过是关于HM的，所以我就基于此文写一个JEM的吧。原文地址https://www.2cto.com/kf/201604/499329.html。       先来个文字版的简洁说明(写在下面的步骤不一定会执行，是需要经过条件判断的，其中还有很多步骤没写出来)，代码记录在下一篇吧。xCompressCU（） { （...
VVC/JEM（一）：VVC参考软件
Moomin的博客
05-14 4560
以Meeting J之后更新的参考软件为例 进入https://mailman.rwth-aachen.de/mailman/listinfo/jvet进行注册 http://phenix.it-sudparis.eu/jvet/下载J1002文件（Algorithm description for Versatile Video Coding and Test Model 1 (VTM 1)...
VVC/JEM代码学习13 : SAOProcess
小小柴的博客
03-29 1454
在compressSlice和encodeSlice之间，还有两个主要的处理函数，一个是SAOProcess，一个是ALFProcess(ALF是JEM中新加的)；也就是说，当前帧完成重构后要对重构图像进行样点自适应补偿和自适应环路滤波，最后才进行真正的熵编码。        样点自适应补偿的原理是由于量化导致高频信息的丢失从而在解码图像上产生振铃效应，为此，样点自适应补偿技术从像素域入手，对重构...
VVC/JEM代码学习14:loopFilterPic
小小柴的博客
03-30 966
在代码学习13中，记录了SAO技术的详细过程，其实在执行SAO之前，要先对重建图像进行去方块滤波；去方块滤波和样点自适应补偿合并称为环路滤波。今天就记录一下去方块滤波的详细过程。   去方块滤波的原理：由于在编码时各个块的变换量化相互独立，对不同的块使用了不同的量化参数，导致每个块引入的量化误差大小不一致，导致相邻块边界的不连续性。此外，运动补偿预测过程中，相邻块的预测值可能来自不同图像的不同位置...
vvc
03-22
Vaeryn虚拟计算机 一个用于模拟通用计算机体系结构的爱好项目。 项目布局 仿照 。 .vvb文件 Vaeryn虚拟字节码文件（ *.vvb ）是VCC程序源代码。其中包含一个编译器，它将.vvb文件编译为可以在.vvb上执行的格式的二进制文件。 有关.vvb文件的一些示例，请参见 。 sample制作目标演示了.vvb文件的编译以及随后的执行。
VVC代码学习1：xCompressCU函数
Everglow_zbz的博客
09-14 2050
一、函数简述 xCompressCU这个函数通过递归的调用自己来完成对整个CTU的划分和每个CU的模式选择。与HEVC中该函数不同的是，VVC中加入了很多新的模式，比如帧间Affine模式，帧内IBC模式等。 亮度块最大允许尺寸为128×128，并且划分方式采用多类型树结构，CU可以进行四叉划分，水平二叉划分，垂直二叉划分，水平三叉划分，垂直三叉划分。最优划分模式的确定在xCheckModeSpl...
HEVC代码学习11：xCompressCU函数
慢慢积累
05-17 6191
今天接着之前进行了全局最小CU分块，来看进行CU分块的xCompressCU函数。 xCompressCU主要作用是完成块划分，确定最优预测模式。主要可以分为： 1.帧间预测xCheckRDCostInter、xCheckRDCostMerge2Nx2N 2.帧内预测xCheckRDCostIntra 3.PCM模式xCheckIntraPCM 这里PCM模式是一种无损编码模式，该模式下
H.266/VVC-VTM代码学习20-CU层进行RDO函数xCompressCU
liaojq2020的博客
04-16 2103
H.266/VVC专栏传送 上一篇：H.266/VVC-VTM代码学习19-CU层确定测试模式函数initCULevel 下一篇：持续创作中… 目录H.266/VVC专栏传送前言一、函数作用二、函数详解 前言 VTM是H.266/VVC视频编码标准的参考软件，研究VTM代码给研究人员解释了VVC编码标准的详细标准规范与细节。 本文是笔者对VTM代码的一点学习记录，成文于笔者刚开始接触VVC期间，期间很多概念和理论框架还很不成熟，若文中存在错误欢迎批评指正，也欢迎广大视频编码学习者沟通交流、共同进步。 VTM
VVC代码阅读（2）compressGOP函数（2）
dfhg54的博客
04-09 1045
注意：本次代码运用的是encoder_intra_vtm的设置，所以GOP_size 只有一帧 // store sub-picture numbers, sizes, and locations with a picture pcSlice->getPic()->subPictures.clear(); for( int subPicIdx = 0; subPicIdx < pcPic->cs->pps->getNumSubPics(); .
VVC视频编码笔记
最新发布
qq_42691604的博客
10-13 957
在VVC中划分模式一共有六种，不划分（NS）、四叉树划分（QT）、二叉树水平划分（BTH）、二叉树垂直划分（BTV）、三叉树水平划分（TTH）和三叉树垂直划分（TTV）。
HEVC 中主要LCU分析函数xCompressCU说明
飞翔 视频直播系统
11-29 9708
所有LCU都是通过调用xCompressCU来实现其CU/PU划分. 然后通过其结果再调用 TEncCu::xencodeCU 函数来实现对所有CUs进行压缩编码.   xCompressCU大体可分为一下三块. Void TEncCu::xCompressCU() { //第一块 for (Int iQP=iMinQP; iQP<=iMaxQP; iQP+
VVC系列（三）xCompressCTU、xCompressCU和xCheckModeSplit解析
weixin_43721070的博客
10-30 1211
判断是否需要执行IBC模式（帧内块复制技术，屏幕内容编码的一种技术，参考区域不局限在相邻像素行，而是可以利用当前帧所有已编码区域，预测待编码CU）该函数的主要部分是一个do-while循环，遍历子CU的区域，和x265相同的是，也会比较当前累计的cost和最优cost，用来进行提前终止。判断是否开启了 CTU Dual Tree技术，如果开启，需要对色度分量进行一次预测。维护需要测试的mode，通过一个do-while循环，尝试各种划分模式。用来存储当前compress区域各种模式下的数据，
H.266/VVC代码学习13：VTM4.0中的CU层操作（compressCtu 、 xCompressCU）
时间有泪
03-22 5659
从H.266/VVC代码学习3：VTM4.0中的CTU层操作（encodeCtus）我们了解到了视频最基本的操作块为CTU，现在我们进一步学习CU层的操作。有两个十分重要的函数： 1 compressCtu: 是对encodeCtu中拿到的单个ctu进行操作，是进行CU划分预测等处理的入口。内部一共会调用两次 xCompressCU ，一次是对亮度进行处理，一次是对色度进行处理。可见compre...
H.266/VVC 视频编码标准详解
"该文档是关于最新的视频编码标准H.266（也称为VVC，Video Coding Standard）的中文版。文档详细介绍了H.266标准的基础知识，包括编码结构、帧内预测和帧间预测技术，以及变换编码和量化等核心概念。" 在H.266（VVC...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值