VVC学习之五——帧内预测：xRecurIntraCodingLumaQT()

最新推荐文章于 2021-03-30 11:39:41 发布
最新推荐文章于 2021-03-30 11:39:41 发布
阅读量868 收藏 3
点赞数 1
分类专栏： VVC/H.266学习日记 文章标签： RQT MTS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012038173/article/details/90345859
版权

之前我们说道，VTM帧内预测在对RMD和MPM构建的候选列表进行full RDO的时候，会调用xRecurIntraCodingLumaQT()进行信号完整预测、变换和量化，选择变换核，设置cbf，计算完整率失真代价。

xRecurIntraCodingLumaQT()要点如下：

  • 确定tu是否需要继续划分
    – 如果划分（isp），递归调用自身
  • 确定变换模式候选集
  • 遍历变换模式，调用xIntraCodingTUBlock()计算残差并进行变换量化，反变换，反量化，计算重建信号
void IntraSearch::xRecurIntraCodingLumaQT( CodingStructure &cs, Partitioner &partitioner, const double bestCostSoFar, const int subTuIdx, const PartSplit ispType )
{
        int   subTuCounter = subTuIdx; // tu idx （if isp， otherwise equal to -1）
  const UnitArea &currArea = partitioner.currArea();
  const CodingUnit     &cu = *cs.getCU( currArea.lumaPos(), partitioner.chType );
        bool  earlySkipISP = false; // if early skip isp

  uint32_t currDepth       = partitioner.currTrDepth;
  const PPS &pps           = *cs.pps;
  const bool keepResi      = pps.getPpsRangeExtension().getCrossComponentPredictionEnabledFlag() || KEEP_PRED_AND_RESI_SIGNALS; // 默认为0， for 4:2：0
  bool bCheckFull          = true; // pu不可继续划分
  bool bCheckSplit         = false; // pu继续划分
  bCheckFull               = !partitioner.canSplit( TU_MAX_TR_SPLIT, cs ); // always false here
  bCheckSplit              = partitioner.canSplit( TU_MAX_TR_SPLIT, cs );  // always true here

#if JVET_M0102_INTRA_SUBPARTITIONS
  if( cu.ispMode )
  {
    bCheckSplit = partitioner.canSplit( ispType, cs ); // if isp, update bchecksplit 
    bCheckFull = !bCheckSplit;
  }
#endif
  uint32_t    numSig           = 0;

  double     dSingleCost                        = MAX_DOUBLE; // 最优rdcost
  Distortion uiSingleDistLuma                   = 0; // 最优distortion
  uint64_t   singleFracBits                     = 0; // 最优bits
  int        bestModeId[MAX_NUM_COMPONENT]      = { 0, 0, 0 }; // 记录最优tu模式

  const TempCtx ctxStart  ( m_CtxCache, m_CABACEstimator->getCtx() ); // 获取上下文信息
  TempCtx       ctxBest   ( m_CtxCache );

  CodingStructure *csSplit = nullptr;
  CodingStructure *csFull  = nullptr;

  if( bCheckSplit ) // 根据pu划分类型，更新csSplit 或 csFull
  {
    csSplit = &cs;
  }
  else if( bCheckFull )
  {
    csFull = &cs;
  }

  if( bCheckFull )
  {
    csFull->cost = 0.0;
	// add tu and initial
    TransformUnit &tu = csFull->addTU( CS::getArea( *csFull, currArea, partitioner.chType ), partitioner.chType );
    tu.depth = currDepth;

    const bool tsAllowed  = TU::isTSAllowed ( tu, COMPONENT_Y ); // if transform skip allowed 是否进行TS模式
    const bool mtsAllowed = TU::isMTSAllowed( tu, COMPONENT_Y ); // 是否进行mts模式选择 is mts alled -> not isp and not sub-block transform(sbt only for inter blocks)
    uint8_t nNumTransformCands = 1 + ( tsAllowed ? 1 : 0 ) + ( mtsAllowed ? 4 : 0 ); // DCT + TS + 4 MTS = 6 tests，总变换模式候选
    std::vector<TrMode> trModes; // typedef std::pair<int, bool> TrMode; 存放变换模式候选
    trModes.push_back( TrMode( 0, true ) ); // DCT2 默认添加
    if( tsAllowed ) 
    {
      trModes.push_back( TrMode( 1, true ) );
    }
    if( mtsAllowed )
    {
      for( int i = 2; i < 6; i++ )
      {
        trModes.push_back( TrMode( i, true) );
      }
    }

    CHECK( !tu.Y().valid(), "Invalid TU" );

    CodingStructure &saveCS = *m_pSaveCS[0];

    TransformUnit *tmpTU = nullptr;

    Distortion singleDistTmpLuma = 0;
    uint64_t     singleTmpFracBits = 0;
    double     singleCostTmp     = 0;
    int        firstCheckId      = 0;  // 第一次标志位

#if JVET_M0464_UNI_MTS
    int       lastCheckId        = trModes[nNumTransformCands-1].first; // 最后一个tu模式
    bool isNotOnlyOneMode        = nNumTransformCands != 1;  // 是否只能进行DCT II
#else
    //we add the EMT candidates to the loop. TransformSkip will still be the last one to be checked (when modeId == lastCheckId) as long as checkTransformSkip is true
    int        lastCheckId       = numTransformIndexCands - ( firstCheckId + 1 ) + ( int ) checkTransformSkip;
    bool isNotOnlyOneMode        = lastCheckId != firstCheckId && !checkInitTrDepthTransformSkipWinner;
#endif

    if( isNotOnlyOneMode ) // 如果不止dctII一个变换核，保存临时数据
    {
      saveCS.pcv     = cs.pcv;
      saveCS.picture = cs.picture;
      saveCS.area.repositionTo(cs.area);
      saveCS.clearTUs();
      tmpTU = &saveCS.addTU(currArea, partitioner.chType);
    }

#if JVET_M0464_UNI_MTS
    bool    cbfDCT2  = true; // 
#else
    bool cbfBestMode = false;
#endif

    for( int modeId = firstCheckId; modeId < nNumTransformCands; modeId++ )  // 遍历所有tu模式
    {
      // 如果dct2的cbf==0或者TS为亮度最优tu模式，则终止变换核选择
      if( !cbfDCT2 || ( m_pcEncCfg->getUseTransformSkipFast() && bestModeId[COMPONENT_Y] == 1 ) ) 
      {
        break;
      }
      if( !trModes[modeId].second ) // 如果当前tu模式关闭，跳到下一个模式
      {
        continue;
      }
      tu.mtsIdx = trModes[modeId].first; // 更新当前tu变换核
	  // 不是dct2，且不止一个模式时，更新上下文信息
      if ((modeId != firstCheckId) && isNotOnlyOneMode)
      {
        m_CABACEstimator->getCtx() = ctxStart;
      }

      int default0Save1Load2 = 0;
      singleDistTmpLuma = 0;

#if JVET_M0464_UNI_MTS
      if( modeId == firstCheckId && nNumTransformCands > 1 )  // 第一次循环（DCT2），且不止一个tu模式时，更新default0Save1Load2 为 1
#else
      if (modeId == firstCheckId && modeId != lastCheckId && !checkInitTrDepthTransformSkipWinner )
#endif
      {
        default0Save1Load2 = 1;
      }
      else if (modeId != firstCheckId)// 不是（DCT2）更新default0Save1Load2 为 2
      {
        default0Save1Load2 = 2;
      }
#if JVET_M0102_INTRA_SUBPARTITIONS
      if( cu.ispMode ) // isp预测模式，default0Save1Load2置0
      {
        default0Save1Load2 = 0;
      }
#endif

      if( nNumTransformCands > 1 ) // 如果不止一个tu模式，在第一次信号预测，并对残差进行变换量化后，记录最后一个有效的tu模式索引
      {
        // 对预测信号计算残差，并进行变换量化，计算distortion
        // dct2时，更新tu模式候选的有效标志？
        xIntraCodingTUBlock( tu, COMPONENT_Y, false, singleDistTmpLuma, default0Save1Load2, &numSig, modeId == 0 ? &trModes : nullptr, true );
        if( modeId == 0 ) // 记录
        {
          for( int i = 0; i < nNumTransformCands; i++ )
          {
            if( trModes[i].second )
            {
              lastCheckId = trModes[i].first;
            }
          }
        }
      }
      else
      {
       // 只有DCT2，进行预测变换量化
        xIntraCodingTUBlock( tu, COMPONENT_Y, false, singleDistTmpLuma, default0Save1Load2, &numSig );
      }

      //----- determine rate and r-d cost ----- 计算率失真代价
#if JVET_M0464_UNI_MTS
      if( ( trModes[modeId].first != 0 && !TU::getCbfAtDepth( tu, COMPONENT_Y, currDepth ) ) )
#else
      //the condition (transformIndex != DCT2_EMT) seems to be irrelevant, since DCT2_EMT=7 and the highest value of transformIndex is 4
      if( ( modeId == lastCheckId && checkTransformSkip && !TU::getCbfAtDepth( tu, COMPONENT_Y, currDepth ) ) )
#endif
      {
        //In order not to code TS flag when cbf is zero, the case for TS with cbf being zero is forbidden.
        // 为了保证在cbf不为0时，不对TS标志进行编码，当cbf为0时，禁止TS，将代价设为最大
        singleCostTmp = MAX_DOUBLE;
      }
      else
      {
#if JVET_M0102_INTRA_SUBPARTITIONS
        if( cu.ispMode && m_pcRdCost->calcRdCost( csFull->fracBits, csFull->dist + singleDistTmpLuma ) > bestCostSoFar )
        {  // 如果是ISP模式，且进行到当前这个tu时，RDCost已经比之前最优的RDCost大，终止ISP模式
          earlySkipISP = true;
        }
        else
        { // 计算bits（模式头信息，变换量化后的系数，cbf）
          singleTmpFracBits = xGetIntraFracBitsQT( *csFull, partitioner, true, false, subTuCounter, ispType );
        }
#else
        singleTmpFracBits = xGetIntraFracBitsQT( *csFull, partitioner, true, false );
#endif
        singleCostTmp     = m_pcRdCost->calcRdCost( singleTmpFracBits, singleDistTmpLuma ); // 依据bits和distortion 计算RDCost
      }

      if (singleCostTmp < dSingleCost) // 当前模式RD代价更小，更新最优率失真信息
      {
        dSingleCost       = singleCostTmp;
        uiSingleDistLuma  = singleDistTmpLuma;
        singleFracBits    = singleTmpFracBits;

#if JVET_M0464_UNI_MTS
        bestModeId[COMPONENT_Y] = trModes[modeId].first; // 最优变换模式
        if( trModes[modeId].first == 0 ) // 记录DCT2的cbf，用于提前终止
        {
          cbfDCT2  = TU::getCbfAtDepth( tu, COMPONENT_Y, currDepth );
        }
#else
        bestModeId[COMPONENT_Y] = modeId;
        cbfBestMode       = TU::getCbfAtDepth( tu, COMPONENT_Y, currDepth );
#endif

        if( bestModeId[COMPONENT_Y] != lastCheckId ) // 如果当前tu模式不是最后一个模式，记录最优的预测信号和重建信号，
        {
#if KEEP_PRED_AND_RESI_SIGNALS || JVET_M0427_INLOOP_RESHAPER
          saveCS.getPredBuf( tu.Y() ).copyFrom( csFull->getPredBuf( tu.Y() ) );
#endif
          saveCS.getRecoBuf( tu.Y() ).copyFrom( csFull->getRecoBuf( tu.Y() ) );

          if( keepResi )
          {
            saveCS.getResiBuf   ( tu.Y() ).copyFrom( csFull->getResiBuf   ( tu.Y() ) );
            saveCS.getOrgResiBuf( tu.Y() ).copyFrom( csFull->getOrgResiBuf( tu.Y() ) );
          }

          tmpTU->copyComponentFrom( tu, COMPONENT_Y );

          ctxBest = m_CABACEstimator->getCtx(); // 更新上下文
        }
      }
    }

    if( bestModeId[COMPONENT_Y] != lastCheckId ) // 如果最优tu模式不是最后测试的模式，记录最后一次预测变换重建信息
    {
#if KEEP_PRED_AND_RESI_SIGNALS || JVET_M0427_INLOOP_RESHAPER
      csFull->getPredBuf( tu.Y() ).copyFrom( saveCS.getPredBuf( tu.Y() ) );
#endif
      csFull->getRecoBuf( tu.Y() ).copyFrom( saveCS.getRecoBuf( tu.Y() ) );

      if( keepResi )
      {
        csFull->getResiBuf   ( tu.Y() ).copyFrom( saveCS.getResiBuf   ( tu.Y() ) );
        csFull->getOrgResiBuf( tu.Y() ).copyFrom( saveCS.getOrgResiBuf( tu.Y() ) );
      }

      tu.copyComponentFrom( *tmpTU, COMPONENT_Y );

      if( !bCheckSplit )
      {
        m_CABACEstimator->getCtx() = ctxBest;
      }
    }
    else if( bCheckSplit )
    {
      ctxBest = m_CABACEstimator->getCtx();
    }
    
	// 更新率失真代价信息
    csFull->cost     += dSingleCost; 
    csFull->dist     += uiSingleDistLuma;
    csFull->fracBits += singleFracBits;
  }

  if( bCheckSplit ) // 如果tu需要划分（isp），计算各个子tu的rdcost
  {
    //----- store full entropy coding status, load original entropy coding status -----
    if( bCheckFull )
    {
      m_CABACEstimator->getCtx() = ctxStart;
    }
    //----- code splitted block -----
    csSplit->cost = 0;

    bool uiSplitCbfLuma  = false;
    bool splitIsSelected = true;  // 最优的是否是划分
    if( partitioner.canSplit( TU_MAX_TR_SPLIT, cs ) )
    {
      partitioner.splitCurrArea( TU_MAX_TR_SPLIT, cs );
    }

#if JVET_M0102_INTRA_SUBPARTITIONS
    if( cu.ispMode )
    {
      partitioner.splitCurrArea( ispType, *csSplit ); // 区域划分
    }
#endif
    do
    {
#if JVET_M0102_INTRA_SUBPARTITIONS
      xRecurIntraCodingLumaQT( *csSplit, partitioner, bestCostSoFar, subTuCounter, ispType ); // 递归调用，计算子区域rdcost，cbf，残差变换量化
      subTuCounter += subTuCounter != -1 ? 1 : 0;
#else
      xRecurIntraCodingLumaQT( *csSplit, partitioner );
#endif

#if JVET_M0102_INTRA_SUBPARTITIONS
      if( !cu.ispMode )
      {
        csSplit->setDecomp( partitioner.currArea().Y() );
      }
      else if( CU::isISPFirst( cu, partitioner.currArea().Y(), COMPONENT_Y ) )
      {
        csSplit->setDecomp( cu.Y() ); // 更新重建
      }
#else
      csSplit->setDecomp( partitioner.currArea().Y() );
#endif

#if JVET_M0102_INTRA_SUBPARTITIONS
      uiSplitCbfLuma |= TU::getCbfAtDepth( *csSplit->getTU( partitioner.currArea().lumaPos(), partitioner.chType, subTuCounter - 1 ), COMPONENT_Y, partitioner.currTrDepth );
      if( cu.ispMode )
      {
        //exit condition if the accumulated cost is already larger than the best cost so far (no impact in RD performance) 终止，如果cost已经大于最优cost
        if( csSplit->cost > bestCostSoFar )
        {
          earlySkipISP    = true;
          splitIsSelected = false;
          break;
        }
        else
        {
          //more restrictive exit condition
          bool tuIsDividedInRows = CU::divideTuInRows( cu );
          int nSubPartitions = tuIsDividedInRows ? cu.lheight() >> g_aucLog2[cu.firstTU->lheight()] : cu.lwidth() >> g_aucLog2[cu.firstTU->lwidth()];
          double threshold = nSubPartitions == 2 ? 0.95 : subTuCounter == 1 ? 0.83 : 0.91;
          if( subTuCounter < nSubPartitions && csSplit->cost > bestCostSoFar*threshold )
          {
            earlySkipISP    = true;
            splitIsSelected = false;
            break;
          }
        }
      }
#else
      uiSplitCbfLuma |= TU::getCbfAtDepth( *csSplit->getTU( partitioner.currArea().lumaPos(), partitioner.chType ), COMPONENT_Y, partitioner.currTrDepth );
#endif



    } while( partitioner.nextPart( *csSplit ) );

    partitioner.exitCurrSplit();

    if( splitIsSelected )
    { // 如果选择split，遍历tus，设置cbf
      for( auto &ptu : csSplit->tus )
      {
        if( currArea.Y().contains( ptu->Y() ) )
        {
          TU::setCbfAtDepth( *ptu, COMPONENT_Y, currDepth, uiSplitCbfLuma ? 1 : 0 );
        }
      }

      //----- restore context states -----
      m_CABACEstimator->getCtx() = ctxStart;

      //----- determine rate and r-d cost -----
#if JVET_M0102_INTRA_SUBPARTITIONS
      csSplit->fracBits = xGetIntraFracBitsQT( *csSplit, partitioner, true, false, cu.ispMode ? 0 : -1, ispType );
#else
      csSplit->fracBits = xGetIntraFracBitsQT(*csSplit, partitioner, true, false);
#endif

      //--- update cost ---
      csSplit->cost     = m_pcRdCost->calcRdCost(csSplit->fracBits, csSplit->dist);
    }
  }

  if( csFull || csSplit ) // 更新picture信号信息，计算cs rdcost
  {
    {
      // otherwise this would've happened in useSubStructure
      cs.picture->getRecoBuf( currArea.Y() ).copyFrom( cs.getRecoBuf( currArea.Y() ) );
#if JVET_M0427_INLOOP_RESHAPER
      cs.picture->getPredBuf( currArea.Y() ).copyFrom( cs.getPredBuf( currArea.Y() ) );
#endif
    }

#if JVET_M0102_INTRA_SUBPARTITIONS
    if( cu.ispMode && earlySkipISP )
    {
      cs.cost = MAX_DOUBLE;
    }
    else
    {
      cs.cost = m_pcRdCost->calcRdCost( cs.fracBits, cs.dist );
    }
#else
    cs.cost = m_pcRdCost->calcRdCost( cs.fracBits, cs.dist );
#endif
  }
}
Aidoneus_y
关注
专栏目录
【Codecs系列】H.266/VVC视频编码标准(七)：帧内预测技术
CSDN明星博主，认证博客专家，视频、Matlab领域优质创作者。
09-29 1247
DATA: 2020.9.27 文章目录1、帧内预测原理2、67种帧内预测模式3、帧内预测编码4、宽角度帧内预测 WAIP5、色度跨分量线性模型预测 CCLM6、位置相关帧内预测组合PDPC7、多参考行预测MRL8、矩阵加权预测9、帧内子划分ISP 1、帧内预测原理 2、67种帧内预测模式 相比于HEVC中33种帧内预测方向，VVC中扩展到了65种帧内预测方向，再加上DC和planar模式，一共67种预测模式。如下图所示： VVC使用更加稠密的方向预测模式，在HEVC每两个方向之间又增加了一个方向，从而
【二】 VVC理论知识之帧内预测编码
weixin_45615071的博客
05-05 1385
帧内预测编码
VVC/JEM代码学习23：xRecurIntraCodingLumaQT()
小小柴的博客
04-22 740
在执行亮度分量的预测时，在确定好最后的要执行RD cost的候选模式后，对于每个模式，都调用一遍xRecurIntraCodingLumaQT()，在此函数里面完成预测，求残差，变换量化和重建，并返回失真。Void TEncSearch::xRecurIntraCodingLumaQT(TComYuv* pcOrgYuv, ...
H.266/VVC代码学习：xRecurIntraCodingLumaQT函数
BigDream123的博客
02-07 1095
xRecurIntraCodingLumaQT函数主要是用来遍历上层函数传来的变换集，通过调用xIntraCodingTUBlock计算相应的失真，从而计算RD Cost，从而选出最佳变换。 具体代码注释如下： bool IntraSearch::xRecurIntraCodingLumaQT( CodingStructure &cs, Partitioner &partit...
H.266代码学习：xRecurIntraCodingLumaQT函数
慢慢积累
03-10 2029
目前实验室的研究方向全面转向了H.266，以后我也将由HM转向JEM，不再更新HEVC代码学习了。JEM相对于HM看起来繁杂很多，毕竟加了很多内容，但框架是一样的，建议看的时候和HM比对着看，我也会在这里记录JEM相对于HM的对比学习。这里使用的是JEM7.0。 如果有从看过我之前博客的同学们，会发现我近期更加注意版面了有木有？嘿嘿=.=，舒服了很多有没有。好吧，我承认，是我有强迫症。 今天就...
VTM3.0代码阅读：xRecurIntraCodingLumaQT函数
矛盾统一
12-27 249
xRecurIntraCodingLumaQT是lumaIntra预测模式中最后进行RDO选最优模式的主要函数，xRecurIntraCodingLumaQT函数的作用就是计算一个具体的lumaIntra模式时的cost。 由于函数中涉及到很多的tu块变换方面的知识，没有太懂，以后对VTM变换量化方面看懂之后补充 本函数和VTM1中基本没有任何区别： VTM1.0代码阅读：xRecurIntraC...
VTM10.0代码学习15：xIntraCodingLumaISP()&xRecurIntraCodingLumaQT()
hjhyxq2014的博客
03-30 593
此系列是为了记录自己学习VTM10.0的过程，目前正在看编码端。主要的参考文档有JVET-S2001-vH和JVET-S2002-v1。由于本人水平有限，出现的错误恳请大家指正，欢迎与大家一起交流进步。 上一篇博文(VTM10.0代码学习14)留了两个计算RDcost的函数没讲，一个是xIntraCodingLumaISP()，另一个是xRecurIntraCodingLumaQT()。前一个是计算开启ISP时亮度的RDcost，后一个是计算不开启ISP时亮度RDcost，接下来就详细说说它们 1..
【三】 VVC理论知识之帧间预测（1）
weixin_45615071的博客
05-05 2882
帧间预测（1）
VVC/VTM 4.2 帧内编码——亮度预测理解
destination00的博客
06-04 1014
xCompressCU()是帧内编码的核心函数，它把从上层函数compressCtu()得到的基本编码单元CTU递归地用函数xCheckModeSplit()进行宏块划分。在此过程中，xCheckModeSplit()会调用xCompressCU ()。 xCompressCU()函数 xCompressCU()函数的主要流程如下： 1、初始化：设置各种可用模式，上下文模型等； 2、遍历各种帧内模...
VTM1.0代码阅读：xRecurIntraCodingLumaQT函数
矛盾统一
12-26 311
xRecurIntraCodingLumaQT是亮度帧内预测模式中最后进行RDO选最优模式的主要函数，xRecurIntraCodingLumaQT函数的作用就是计算一个具体的亮度帧内模式时的cost 由于函数中涉及到很多的tu块变换方面的知识，没有太懂，以后对VTM变换量化方面看懂之后补充。 函数流程大致为： 判断当前cu的在具体的lumaIntra模式时的处理，是否在tu变换过程中，需要对t...
H.266/VVC代码学习10：xRecurIntraCodingLumaQT函数
时间有泪
03-20 1029
初始化后分为两种情况：1.可以继续划分，2.不可继续划分 1.可以继续划分时，根据cost的大小进行TU的划分（递归调用多次划分），设置cbf，获取上下文模型并保存代价 2.不可继续划分时，设置变换的模式（6种，决定是否开启及开启几个），对可以进行变换的模式进行后续残差计算、变换量化和反变换重建等操作，即xIntraCodingTUBlock函数（DCT2与其余5种不同），更新率失真信息。 最终获...
H.266/VVC代码学习8：xRecurIntraChromaCodingQT函数
时间有泪
03-18 1446
对色度模式列表中的模式都调用一次，进行当前PU的色度分量的一系列编码工作，并求得失真 #if JVET_M0102_INTRA_SUBPARTITIONS ChromaCbfs IntraSearch::xRecurIntraChromaCodingQT( CodingStructure &amp;cs, Partitioner&amp; partitioner, const double bes...
H.266/VVC代码学习：xRecurIntraChromaCodingQT函数
BigDream123的博客
02-12 748
xRecurIntraChromaCodingQT函数主要是由上层函数estIntraPredChromaQT函数调用，利用传来的预测模式进行预测计算残差信号，接着遍历所有可用的变换模式，对残差信号进行变换、量化、重建等，从而可以求出相应的RD Cost。 注意：这里色度编码模式分为Cb Cr单独编码和JointCbCr（即CbCr联合编码）两种，并且都对这两种编码模式进行了变换模式的遍历。 ...
VTM1.0代码阅读：xRecurIntraChromaCodingQT函数
矛盾统一
12-26 259
xRecurIntraChromaCodingQT在estIntraPredChromaQT函数中被调用，用来计算每个帧内色度预测模式时的cost。 xRecurIntraChromaCodingQT函数通过调用xIntraCodingTUBlock函数，对每个色度预测模式进行预测变换量化反量化反变换之后，获得到resi和pred像素，继而得到reco像素，就可计算失真和cost。 xRecurI...
H.266/VVC代码学习笔记11：VTM5.0中的xRecurIntraChromaCodingQT（）函数
Peter_Red_Boy的博客
07-26 892
今天抽空讲一下目前VTM5.0中的编码端的xRecurIntraChromaCodingQT（）函数的代码细节，该函数是帧内色度预测编码的第二入口函数，里面有所有的帧内色度预测模式的底层的实现细节，根据所传递进来的模式号，对应特定的预测模式进行预测编码。 该函数的主要流程如下： 一、 一些初始化操作，定义一些缓存空间及变量（在代码里有详细备注） 二、 通过getFinalIntraMode（）函数...
HEVC函数入门（8）——变换的实现
不是他人太努力，只是自己努力不够罢了
06-21 1904
前面我们讲的都是预测，下面开始变换的实现。 本文参考http://blog.csdn.net/shaqoneal/article/details/44856469 1、HM中Intra模式的主要实现逻辑 以Intra的亮度模式为例。主要实现代码实现于TEncSearch::estIntraPredQT方法中。TEncSearch::estIntraPredQT实现时，首先获取当前CU的分割子块
HEVC代码学习42：estIntraPredLumaQT函数
慢慢积累
05-30 4036
在之前的 HEVC代码学习37：帧内预测代码整体学习 中已经提到，estIntraPredLumaQT是亮度帧内预测的入口函数，下面将对该函数进行详细学习。 estIntraPredLumaQT中完成了亮度分量的帧内预测，其主要流程如下： 一、初始化各种参数。 二、为了减少率失真优化次数，HEVC中默认使用帧内快速搜索算法，将分粗选和细选两个阶段进行。如果不使用快速搜索，将对所有帧内预测模式...
HEVC中的帧内预测
dragon_dy的博客
09-02 2342
今日对照HEVC标准TELECOMMUNICATION STANDARDIZATION SECTOR OF ITU (04/2013)阅读HM代码，代码版本2016-8-18,karls
VVC帧内亮度角度预测--帧内编码学习（二）
pengyouyou的博客
04-02 1546
对于帧内预测来说，主要包括角度预测和划分。 在xCompressCU函数中体现为 xCheckRDCostIntra( tempCS, bestCS, partitioner, currTestMode ); 以及 xCheckModeSplit( tempCS, bestCS, partitioner, currTestMode , tempMotCandLUTs ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值