VVC/JEM代码学习24：xRecurIntraChromaCodingQT（）

最新推荐文章于 2021-12-12 17:34:10 发布
最新推荐文章于 2021-12-12 17:34:10 发布
阅读量508 收藏
点赞数
分类专栏： H.266/VVC JEM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxy19931018/article/details/80044324
版权
H.266/VVC 同时被 2 个专栏收录
50 篇文章 65 订阅
订阅专栏
JEM
26 篇文章 2 订阅
订阅专栏

在执行色度分量的预测时，对色度分量的11种候选模式都调用一次xRecurIntraChromaCodingQT函数，在里面完成预测，求残差，变换量化和重建，并返回失真。

Void
TEncSearch::xRecurIntraChromaCodingQT(TComYuv*    pcOrgYuv,
                                      TComYuv*    pcPredYuv,
                                      TComYuv*    pcResiYuv,
#if COM16_C806_LARGE_CTU
                                      Pel*        resiLuma[NUMBER_OF_STORED_RESIDUAL_TYPES],
#else
                                      Pel         resiLuma[NUMBER_OF_STORED_RESIDUAL_TYPES][MAX_CU_SIZE * MAX_CU_SIZE],
#endif
                                      Distortion& ruiDist,
                                      TComTU&     rTu
                                      DEBUG_STRING_FN_DECLARE(sDebug))
{
  TComDataCU         *pcCU                  = rTu.getCU();
  const UInt          uiTrDepth             = rTu.GetTransformDepthRel();//一定为0；
#if JVET_C0024_QTBT
  assert(rTu.GetAbsPartIdxTU()==0 && uiTrDepth==0);
  UInt uiWIdx = g_aucConvertToBit[pcCU->getWidth(0)];
  UInt uiHIdx = g_aucConvertToBit[pcCU->getHeight(0)];
#else
  const UInt          uiAbsPartIdx          = rTu.GetAbsPartIdxTU();
#endif
  const ChromaFormat  format                = rTu.GetChromaFormat();
#if !JVET_C0024_QTBT
  UInt                uiTrMode              = pcCU->getTransformIdx( uiAbsPartIdx );
#endif
  const UInt          numberValidComponents = getNumberValidComponents(format);

#if JVET_C0024_QTBT
  assert(uiTrDepth==0);
#else
  if(  uiTrMode == uiTrDepth )
  {
#endif
    if (!rTu.ProcessChannelSection(CHANNEL_TYPE_CHROMA))
    {
      return;
    }

#if !JVET_C0024_QTBT
    const UInt uiFullDepth = rTu.GetTransformDepthTotal();
#endif

    Bool checkTransformSkip = pcCU->getSlice()->getPPS()->getUseTransformSkip();
#if JVET_C0024_QTBT
    checkTransformSkip &= TUCompRectHasAssociatedTransformSkipFlag(pcCU->getSlice()->isIntra(), rTu.getRect(COMPONENT_Cb), pcCU->getSlice()->getPPS()->getPpsRangeExtension().getLog2MaxTransformSkipBlockSize());
#else
    checkTransformSkip &= TUCompRectHasAssociatedTransformSkipFlag(rTu.getRect(COMPONENT_Cb), pcCU->getSlice()->getPPS()->getPpsRangeExtension().getLog2MaxTransformSkipBlockSize());
#endif

    if ( m_pcEncCfg->getUseTransformSkipFast() )
    {
#if JVET_C0024_QTBT//只有亮度分量使用跳过变换时才允许色度分量使用
      checkTransformSkip &= TUCompRectHasAssociatedTransformSkipFlag(pcCU->getSlice()->isIntra(), rTu.getRect(COMPONENT_Y), pcCU->getSlice()->getPPS()->getPpsRangeExtension().getLog2MaxTransformSkipBlockSize());
#else
      checkTransformSkip &= TUCompRectHasAssociatedTransformSkipFlag(rTu.getRect(COMPONENT_Y), pcCU->getSlice()->getPPS()->getPpsRangeExtension().getLog2MaxTransformSkipBlockSize());

      if (checkTransformSkip)
      {
        Int nbLumaSkip = 0;
        const UInt maxAbsPartIdxSub=uiAbsPartIdx + (rTu.ProcessingAllQuadrants(COMPONENT_Cb)?1:4);
        for(UInt absPartIdxSub = uiAbsPartIdx; absPartIdxSub < maxAbsPartIdxSub; absPartIdxSub ++)
        {
          nbLumaSkip += pcCU->getTransformSkip(absPartIdxSub, COMPONENT_Y);
        }
        checkTransformSkip &= (nbLumaSkip > 0);
      }
#endif
    }

//循环两次，第一次是Cb分量，第二次是Cr分量
    for (UInt ch=COMPONENT_Cb; ch<numberValidComponents; ch++)
    {
      const ComponentID compID = ComponentID(ch);
      DEBUG_STRING_NEW(sDebugBestMode)

      //use RDO to decide whether Cr/Cb takes TS
#if JVET_C0024_QTBT
      m_pcRDGoOnSbacCoder->store( m_ppppcRDSbacCoder[uiWIdx][uiHIdx][CI_QT_TRAFO_ROOT] );
      const Bool splitIntoSubTUs = false;//是否分割成子TU，默认false
#else
      m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[uiFullDepth][CI_QT_TRAFO_ROOT] );

      const Bool splitIntoSubTUs = rTu.getRect(compID).width != rTu.getRect(compID).height;
#endif
	  //初始化TUIterator;
      TComTURecurse TUIterator(rTu, false, (splitIntoSubTUs ? TComTU::VERTICAL_SPLIT : TComTU::DONT_SPLIT), true, compID);

#if !JVET_C0024_QTBT
      const UInt partIdxesPerSubTU = TUIterator.GetAbsPartIdxNumParts(compID);
#endif

      do
      {
        const UInt subTUAbsPartIdx   = TUIterator.GetAbsPartIdxTU(compID);
		//初始化失真，代价，等等参数
        Double     dSingleCost               = MAX_DOUBLE;
        Int        bestModeId                = 0;
        Distortion singleDistC               = 0;
        UInt       singleCbfC                = 0;
        Distortion singleDistCTmp            = 0;
        Double     singleCostTmp             = 0;
        UInt       singleCbfCTmp             = 0;
        Char       bestCrossCPredictionAlpha = 0;
        Int        bestTransformSkipMode     = 0;
#if JVET_E0062_MULTI_DMS
#if JVET_E0077_ENHANCED_LM
        const Bool checkCrossComponentPrediction = (!IsLMMode(pcCU->getIntraDir(CHANNEL_TYPE_CHROMA, subTUAbsPartIdx)))
            &&  pcCU->getSlice()->getPPS()->getPpsRangeExtension().getCrossComponentPredictionEnabledFlag()
            && (pcCU->getCbf(subTUAbsPartIdx,  COMPONENT_Y, uiTrDepth) != 0);//如果色度模式不是LM模式且允许使用CCP且Y分量的cbf不为0，则checkCrossComponentPrediction为true;
#else
        const Bool checkCrossComponentPrediction = (pcCU->getIntraDir(CHANNEL_TYPE_CHROMA, subTUAbsPartIdx) != LM_CHROMA_IDX)
                                                   &&  pcCU->getSlice()->getPPS()->getPpsRangeExtension().getCrossComponentPredictionEnabledFlag()
                                                   && (pcCU->getCbf(subTUAbsPartIdx,  COMPONENT_Y, uiTrDepth) != 0);
#endif
#else
        const Bool checkCrossComponentPrediction =    (pcCU->getIntraDir(CHANNEL_TYPE_CHROMA, subTUAbsPartIdx) == DM_CHROMA_IDX)
                                                   &&  pcCU->getSlice()->getPPS()->getPpsRangeExtension().getCrossComponentPredictionEnabledFlag()
                                                   && (pcCU->getCbf(subTUAbsPartIdx,  COMPONENT_Y, uiTrDepth) != 0);
#endif
        const Int  crossCPredictionModesToTest = checkCrossComponentPrediction ? 2 : 1;//checkCrossComponentPrediction为true，则为2，否则为1
        const Int  transformSkipModesToTest    = checkTransformSkip            ? 2 : 1;//checkTransformSkip为true，则为2，否则为1
        const Int  totalModesToTest            = crossCPredictionModesToTest * transformSkipModesToTest;//总的测试次数
              Int  currModeId                  = 0;
              Int  default0Save1Load2          = 0;

        for(Int transformSkipModeId = 0; transformSkipModeId < transformSkipModesToTest; transformSkipModeId++)//选取最优的transformSkip模式
        {
          for(Int crossCPredictionModeId = 0; crossCPredictionModeId < crossCPredictionModesToTest; crossCPredictionModeId++)//选取最优的CCP模式
          {
#if JVET_C0024_QTBT
            pcCU->setCrossComponentPredictionAlphaPartRange(0, compID, subTUAbsPartIdx, 0);//将CrossComponentPredictionAlpha设置为0；
            pcCU->setTransformSkipPartRange( transformSkipModeId, compID, subTUAbsPartIdx, 0 );//将TransformSkip设置为transformSkipModeId
#else
            pcCU->setCrossComponentPredictionAlphaPartRange(0, compID, subTUAbsPartIdx, partIdxesPerSubTU);
            DEBUG_STRING_NEW(sDebugMode)
            pcCU->setTransformSkipPartRange( transformSkipModeId, compID, subTUAbsPartIdx, partIdxesPerSubTU );
#endif
            currModeId++;

            const Bool isOneMode  = (totalModesToTest == 1);//判断总的测试模式是否为1;
            const Bool isLastMode = (currModeId == totalModesToTest); // currModeId is indexed from 1，判断当前模式是否为最后一个模式;

            if (isOneMode)//如果只有一个模式，则执行正常的预测步骤;
            {
              default0Save1Load2 = 0;
            }
            else if (!isOneMode && (transformSkipModeId == 0) && (crossCPredictionModeId == 0))
            {//如果不只有1个模式且是第一遍循环，则保存此第一个模式的预测
              default0Save1Load2 = 1; //save prediction on first mode
            }
            else//不只有1个模式且不是第一遍循环，在后面的模式上加载预测;
            {
              default0Save1Load2 = 2; //load it on subsequent modes
            }

            singleDistCTmp = 0;

#if COM16_C983_RSAF
#if JVET_C0024_QTBT
            pcCU->setLumaIntraFilter(0, false);
            pcCU->setLumaIntraFilterHidden(0, true);
#else
            pcCU->setLumaIntraFilter(uiAbsPartIdx, false);
            pcCU->setLumaIntraFilterHidden(uiAbsPartIdx, true);
#endif
#endif      //对当前CU的色度信息进行一系列的编码工作，如求残差，变换，量化，反量化，反变换，重建等工作;
            xIntraCodingTUBlock( pcOrgYuv, pcPredYuv, pcResiYuv, resiLuma, (crossCPredictionModeId != 0), singleDistCTmp, compID, TUIterator DEBUG_STRING_PASS_INTO(sDebugMode), default0Save1Load2);//倒数第5个参数指示是否使用CCP，0时为false,1时为true;

            singleCbfCTmp = pcCU->getCbf( subTUAbsPartIdx, compID, uiTrDepth);

            if (  ((crossCPredictionModeId == 1) && (pcCU->getCrossComponentPredictionAlpha(subTUAbsPartIdx, compID) == 0))
               || ((transformSkipModeId    == 1) && (singleCbfCTmp == 0))) //In order not to code TS flag when cbf is zero, the case for TS with cbf being zero is forbidden.
            {
              singleCostTmp = MAX_DOUBLE;
            }
            else if (!isOneMode)
            {
              UInt bitsTmp = xGetIntraBitsQTChroma( TUIterator, compID, false );//计算所需的比特数;
              singleCostTmp  = m_pcRdCost->calcRdCost( bitsTmp, singleDistCTmp);//计算率失真代价;
            }

            if(singleCostTmp < dSingleCost)
            {
              DEBUG_STRING_SWAP(sDebugBestMode, sDebugMode)
              dSingleCost               = singleCostTmp;
              singleDistC               = singleDistCTmp;
              bestCrossCPredictionAlpha = (crossCPredictionModeId != 0) ? pcCU->getCrossComponentPredictionAlpha(subTUAbsPartIdx, compID) : 0;
              bestTransformSkipMode     = transformSkipModeId;
              bestModeId                = currModeId;
              singleCbfC                = singleCbfCTmp;

              if (!isOneMode && !isLastMode)//不只有一种模式且不是最后一个模式
              {
#if COM16_C806_LMCHROMA
                xStoreIntraResultQT(compID, TUIterator, pcResiYuv);//保存最优的结果
#else
                xStoreIntraResultQT(compID, TUIterator);
#endif
#if JVET_C0024_QTBT
                m_pcRDGoOnSbacCoder->store( m_ppppcRDSbacCoder[ uiWIdx][uiHIdx ][ CI_TEMP_BEST ] );
#else
                m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_TEMP_BEST ] );
#endif
              }
            }

            if (!isOneMode && !isLastMode)//不只有一种模式且不是最后一个模式
            {
#if JVET_C0024_QTBT
              m_pcRDGoOnSbacCoder->load ( m_ppppcRDSbacCoder[ uiWIdx][uiHIdx ][ CI_QT_TRAFO_ROOT ] );
#else
              m_pcRDGoOnSbacCoder->load ( m_pppcRDSbacCoder[ uiFullDepth ][ CI_QT_TRAFO_ROOT ] );
#endif
            }
          }//crossCPreditionModelToTest遍历结束,最多两次，最少一次;
        }//transformSkipModesToTest遍历结束，最多两次，最少一次;

        if(bestModeId < totalModesToTest)//最优的模式索引小于测试模式的总数
        {
#if COM16_C806_LMCHROMA
          xLoadIntraResultQT(compID, TUIterator, pcResiYuv);
#else
          xLoadIntraResultQT(compID, TUIterator);
#endif
#if JVET_C0024_QTBT
          pcCU->setCbfPartRange( singleCbfC, compID, subTUAbsPartIdx, 0 );
          m_pcRDGoOnSbacCoder->load( m_ppppcRDSbacCoder[ uiWIdx][uiHIdx ][ CI_TEMP_BEST ] );
#else
          pcCU->setCbfPartRange( singleCbfC << uiTrDepth, compID, subTUAbsPartIdx, partIdxesPerSubTU );

          m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[ uiFullDepth ][ CI_TEMP_BEST ] );
#endif
        }

        DEBUG_STRING_APPEND(sDebug, sDebugBestMode)
#if JVET_C0024_QTBT
        pcCU ->setTransformSkipPartRange                ( bestTransformSkipMode,     compID, subTUAbsPartIdx, 0 );//将TransformSkip设置为bestTransformSkipMode
        pcCU ->setCrossComponentPredictionAlphaPartRange( bestCrossCPredictionAlpha, compID, subTUAbsPartIdx, 0 );//将CrossComponentPrediction设置为bestCrossCPredictionAlpha
#else
        pcCU ->setTransformSkipPartRange                ( bestTransformSkipMode,     compID, subTUAbsPartIdx, partIdxesPerSubTU );
        pcCU ->setCrossComponentPredictionAlphaPartRange( bestCrossCPredictionAlpha, compID, subTUAbsPartIdx, partIdxesPerSubTU );
#endif
        ruiDist += singleDistC;//累加Cb和Cr的失真
      } while (TUIterator.nextSection(rTu));//nextSection，如果不继续划分则返回false，否则返回true;

#if !JVET_C0024_QTBT
      if (splitIntoSubTUs)
      {
        offsetSubTUCBFs(rTu, compID);
      }
#endif
    }
	两个色度分量循环结束
#if !JVET_C0024_QTBT
  }
  else
  {
    UInt    uiSplitCbf[MAX_NUM_COMPONENT] = {0,0,0};

    TComTURecurse tuRecurseChild(rTu, false);
    const UInt uiTrDepthChild   = tuRecurseChild.GetTransformDepthRel();
    do
    {
      DEBUG_STRING_NEW(sChild)

      xRecurIntraChromaCodingQT( pcOrgYuv, pcPredYuv, pcResiYuv, resiLuma, ruiDist, tuRecurseChild DEBUG_STRING_PASS_INTO(sChild) );

      DEBUG_STRING_APPEND(sDebug, sChild)
      const UInt uiAbsPartIdxSub=tuRecurseChild.GetAbsPartIdxTU();

      for(UInt ch=COMPONENT_Cb; ch<numberValidComponents; ch++)
      {
        uiSplitCbf[ch] |= pcCU->getCbf( uiAbsPartIdxSub, ComponentID(ch), uiTrDepthChild );
      }
    } while ( tuRecurseChild.nextSection(rTu) );


    UInt uiPartsDiv = rTu.GetAbsPartIdxNumParts();
    for(UInt ch=COMPONENT_Cb; ch<numberValidComponents; ch++)
    {
      if (uiSplitCbf[ch])
      {
        const UInt flag=1<<uiTrDepth;
        ComponentID compID=ComponentID(ch);
        UChar *pBase=pcCU->getCbf( compID );
        for( UInt uiOffs = 0; uiOffs < uiPartsDiv; uiOffs++ )
        {
          pBase[ uiAbsPartIdx + uiOffs ] |= flag;
        }
      }
    }
  }
#endif  //#if !JVET_C0024_QTBT
}

小小柴
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
VTM1.0代码阅读：xRecurIntraChromaCodingQT函数
矛盾统一
12-26 250
xRecurIntraChromaCodingQT在estIntraPredChromaQT函数中被调用，用来计算每个帧内色度预测模式时的cost。 xRecurIntraChromaCodingQT函数通过调用xIntraCodingTUBlock函数，对每个色度预测模式进行预测变换量化反量化反变换之后，获得到resi和pred像素，继而得到reco像素，就可计算失真和cost。 xRecurI...
H.266/VVC代码学习：xRecurIntraChromaCodingQT函数
BigDream123的博客
02-12 721
xRecurIntraChromaCodingQT函数主要是由上层函数estIntraPredChromaQT函数调用，利用传来的预测模式进行预测计算残差信号，接着遍历所有可用的变换模式，对残差信号进行变换、量化、重建等，从而可以求出相应的RD Cost。 注意：这里色度编码模式分为Cb Cr单独编码和JointCbCr（即CbCr联合编码）两种，并且都对这两种编码模式进行了变换模式的遍历。 ...
H.266/VVC代码学习8：xRecurIntraChromaCodingQT函数
时间有泪
03-18 1417
对色度模式列表中的模式都调用一次，进行当前PU的色度分量的一系列编码工作，并求得失真 #if JVET_M0102_INTRA_SUBPARTITIONS ChromaCbfs IntraSearch::xRecurIntraChromaCodingQT( CodingStructure &amp;cs, Partitioner&amp; partitioner, const double bes...
H.266/VVC代码学习笔记11：VTM5.0中的xRecurIntraChromaCodingQT（）函数
Peter_Red_Boy的博客
07-26 853
今天抽空讲一下目前VTM5.0中的编码端的xRecurIntraChromaCodingQT（）函数的代码细节，该函数是帧内色度预测编码的第二入口函数，里面有所有的帧内色度预测模式的底层的实现细节，根据所传递进来的模式号，对应特定的预测模式进行预测编码。 该函数的主要流程如下： 一、 一些初始化操作，定义一些缓存空间及变量（在代码里有详细备注） 二、 通过getFinalIntraMode（）函数...
VTM3.0代码阅读：xRecurIntraChromaCodingQT函数
矛盾统一
12-27 190
xRecurIntraChromaCodingQT在estIntraPredChromaQT函数中被调用，用来计算每个帧内色度预测模式时的cost。 流程： 首先判断tu是否需要划分，若tu划分时，对每个划分出的小tu递归调用本函数，计算每个小tu的在chromaIntra模式下的最优的cost，最后求和； 如果tu不划分，分别对Cb和Cr通道进行处理。对于每个通道，是/否TS模式+是/否跨组件预...
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 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 ...
VVC H.266 4K 60FPS 测试片源
03-13
Format/String : VVC Format/Info : Versatile Video Coding CodecID : vvc1 CodecID/Info : Versatile Video Coding Duration/String : 10 秒 0 毫秒 BitRate/String : 10.0 Mb/s BitRate_Maximum/String : ...
HEVC/VVC学习
wjqwzzzz的博客
09-23 331
HEVC学习 备注几个牛人博客，方便后续学习。 1：nb_vol_1： https://blog.csdn.net/NB_vol_1/category_6179825.html 2：杨杨子江的博客 https://blog.csdn.net/qq_32642107/article/list/9 3：岳麓吹雪 https://blog.csdn.net/lin453701006 ...
VVC学习：各类链接
H_dusk的博客
02-15 1094
VVC-各类链接 VVC官网：https://jvet.hhi.fraunhofer.de/ VTM下载地址：https://vcgit.hhi.fraunhofer.de/jvet/VVCSoftware_VTM
VVC学习日记
weixin_42655087的博客
12-12 583
整个周末都在实现师姐布置的一个任务：CTU的划分与可视化。 师姐说网上有很多代码资料，可以直接copy别人的代码，主要是要看CTU划分在框架中的位置。 天真的我开始寻找资料，但是只有一篇是符合的： 跟着做到最后，发现两个关键函数和别人的完全不同，而且自己也不太懂要怎么修改，所以陷入绝望。本人就是菜狗啊~ 再次感慨，视频编码好难呀! 但是也不是没有收获对吧，至少学会了 go to definition&go todeclaration是吧！ 现在想到两个解决办法： 1、去下载和作者同...
【VVC学习记录】写在前面
Ronater的博客
03-26 447
从265过来的，学习H.266/VVC有一段时间了，学习路线从demo的运行，VTM性能的测试开始。由于configure文件与265类似，所以，性能测试、代码的debug等都可以顺利过渡。另一方面，觉得每天盲目的看代码和草稿，看过的东西很容易忘记，故记录下来方便以后翻阅。 ...
【VVC学习记录—01】VVC的main函数
Ronater的博客
03-26 939
基于VVC编码框架，首先是encoder的main函数，main函数主要功能如下： 1. 为编码做准备，包括输出硬件信息、计算编码每帧图像所需时间等等，输出的编码信息如图1所示； 2. 创建和销毁编码器类； 3. 解析配置文件； 4. 调用编码器（encoder函数下章介绍）。 图1 VTM1.1测试结果示例 ...
H.266/VVC代码学习：色度预测estIntraPredChromaQT函数
BigDream123的博客
02-12 2286
VVC中色度预测一共有八种模式，分别为PLANAR，VER， HOR，DC，LM_CHROMA，MDLM_L，MDLM_T，DM_CHROMA，其中LM_CHROMA，MDLM_L和MDLM_T分别表示CCLM模式，DM_CHROMA为从亮度分量获取到的模式。 VTM中色度预测最佳模式的选择是通过estIntraPredChromaQT函数进行的，其主要流程如下： 初始化色度模式列表，利用ge...
VVC/JEM代码学习1：estIntraPredChromaQT函数
小小柴的博客
01-15 755
       现在好像关于JEM的博客还很少，正好自己学习JEM，就把自己学习到的一点东西记录下来。省的学了就忘，先给自己定个目标，一天至少一篇吧。今天学习了色度帧内预测，先记录一下。estIntraPredChromaQT函数的主要功能是进行色度分量的帧内预测，在11种备选的预测模式中根据RD cost选择cost最小的一种模式作为最优预测模式。11种备选模式中，前6种是属于CCLM预测，用重建...
x265中codeIntraLumaQT()分析
小金牛来了
09-12 995
x265中codeIntraLumaQT()分析
Search::codeIntraLumaQT()
workspace
05-16 427
/* 通过 对当前PU进行计算残差+变换+量化+反量化+反变换+重建帧 得到严格意义上的distortion(sse)开销 对当前CU进行完整的bits编码，则到严格意义的bits开销 基于distortion和bits来得到rdcost 基于来得到当前TU的最优split模式(即TU split tree)，及其distortion、bits、rdcost、energy 过程： 1.载入CUdata、depth等信息 2.判断mightNotSplit？mightSplit？ 3.

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值