VVC参考软件VTM6.0中变换的相关代码讲解与注释（一）

最新推荐文章于 2022-10-24 15:40:40 发布
最新推荐文章于 2022-10-24 15:40:40 发布
阅读量865 收藏 5
点赞数
分类专栏： 视频编解码 文章标签： VVC 变换
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44139966/article/details/103277603
版权

1、变换的相关知识

https://blog.csdn.net/allen_sdz/article/details/101764568
我当时主要是参考了这篇博客，相关理论知识在CSDN博客上基本能搜到。

2、代码实现

感觉VVC的代码真的复杂很多，我是看的AI 配置下的代码过程，看了很久才看懂大概的过程，先记录下来顺便再和大家分享下。
从void EncCu::xCheckRDCostIntra( CodingStructure *&tempCS, CodingStructure *&bestCS, Partitioner &partitioner, const EncTestMode& encTestMode )开始就有和变换有关的代码。注意：若开启了MTS，在这里控制MTS的变换核的选择，判断是否选择下一个变换核进行变换的条件在这个函数的结尾部分。

void EncCu::xCheckRDCostIntra( CodingStructure *&tempCS, CodingStructure *&bestCS, Partitioner &partitioner, const EncTestMode& encTestMode )
{
  double          bestInterCost             = m_modeCtrl->getBestInterCost();
  double          costSize2Nx2NmtsFirstPass = m_modeCtrl->getMtsSize2Nx2NFirstPassCost();//FirstPass
  bool            skipSecondMtsPass         = m_modeCtrl->getSkipSecondMTSPass();//是否跳过MTS的第二阶段
  const SPS&      sps                       = *tempCS->sps;
  const int       maxSizeMTS                = MTS_INTRA_MAX_CU_SIZE;//32
  
  uint8_t         considerMtsSecondPass     = ( sps.getUseIntraMTS() && isLuma( partitioner.chType ) && partitioner.currArea().lwidth() <= maxSizeMTS && partitioner.currArea().lheight() <= maxSizeMTS ) ? 1 : 0;
  
  const PPS &pps      = *tempCS->pps;

  bool   useIntraSubPartitions   = false;
  double maxCostAllowedForChroma = MAX_DOUBLE;
  const  CodingUnit *bestCU      = bestCS->getCU( partitioner.chType );
  Distortion interHad = m_modeCtrl->getInterHad();


  double dct2Cost                =   MAX_DOUBLE;
  double trGrpBestCost     [ 4 ] = { MAX_DOUBLE, MAX_DOUBLE, MAX_DOUBLE, MAX_DOUBLE };
  double globalBestCost          =   MAX_DOUBLE;
  bool   bestSelFlag       [ 4 ] = { false, false, false, false };//若最优代价更新了，则trGrpIdx对应的bestSelFlag[trGrpIdx]置为true;
  bool   trGrpCheck        [ 4 ] = { true, true, true, true };
  int    startMTSIdx       [ 4 ] = { 0, 1, 2, 3 };//表示多变换核的4个类型。0：DST7_DST7 1：DCT8_DST7 2：DST7_DST8 3：DCT8_DCT8
  int    endMTSIdx         [ 4 ] = { 0, 1, 2, 3 };//由下面的trGrpIdx来控制
  double trGrpStopThreshold[ 3 ] = { 1.001, 1.001, 1.001 };
  int    bestMtsFlag             =   0;
  int    bestLfnstIdx            =   0;

#if JVET_O0213_RESTRICT_LFNST_TO_MAX_TB_SIZE
#if JVET_O0050_LOCAL_DUAL_TREE
  const int  maxLfnstIdx         = ( partitioner.isSepTree( *tempCS ) && partitioner.chType == CHANNEL_TYPE_CHROMA && ( partitioner.currArea().lwidth() < 8 || partitioner.currArea().lheight() < 8 ) )
#else
  const int  maxLfnstIdx         = ( CS::isDualITree( *tempCS ) && partitioner.chType == CHANNEL_TYPE_CHROMA && ( partitioner.currArea().lwidth() < 8 || partitioner.currArea().lheight() < 8 ) )
#endif
#if JVET_O0545_MAX_TB_SIGNALLING
                                   || ( partitioner.currArea().lwidth() > sps.getMaxTbSize() || partitioner.currArea().lheight() > sps.getMaxTbSize() ) ? 0 : 2;
#else
                                   || ( partitioner.currArea().lwidth() > MAX_TB_SIZEY || partitioner.currArea().lheight() > MAX_TB_SIZEY ) ? 0 : 2;
#endif
#else
#if JVET_O0050_LOCAL_DUAL_TREE
  const int  maxLfnstIdx         = partitioner.isSepTree( *tempCS ) && partitioner.chType == CHANNEL_TYPE_CHROMA && ( partitioner.currArea().lwidth() < 8 || partitioner.currArea().lheight() < 8 ) ? 0 : 2;
#else
  const int  maxLfnstIdx         = CS::isDualITree( *tempCS ) && partitioner.chType == CHANNEL_TYPE_CHROMA && ( partitioner.currArea().lwidth() < 8 || partitioner.currArea().lheight() < 8 ) ? 0 : 2;
#endif
#endif
  bool       skipOtherLfnst      = false;
  int        startLfnstIdx       = 0;
  int        endLfnstIdx         = sps.getUseLFNST() ? maxLfnstIdx : 0;//0或2

  int grpNumMax = sps.getUseLFNST() ? 4 : 1;
  m_pcIntraSearch->invalidateBestModeCost();
 
  for( int trGrpIdx = 0; trGrpIdx < grpNumMax; trGrpIdx++ )//用来控制选择MTS4个变换核中一个，按照索引序号的优先值：0-0；1-1；2-2；3-3（1和2的时候还和预测方向有关）
  {
    const uint8_t startMtsFlag = trGrpIdx > 0;//0或1
    const uint8_t endMtsFlag   = sps.getUseLFNST() ? considerMtsSecondPass : 0;//取0或1 
  
    if( ( trGrpIdx == 0 || ( !skipSecondMtsPass && considerMtsSecondPass ) ) && trGrpCheck[ trGrpIdx ] )
    { 
      /*
    对于帧内编码CU，CU级的RD检测以LFNST索引值为循环索引。
    每个帧内预测模式对应的变换集中有3种LFNST候选索引值:0,1,2
    //0表示不使用二次变换，1、2是每个变换集中的2个不可分的变换矩阵内核
   */     
      for( int lfnstIdx = startLfnstIdx; lfnstIdx <= endLfnstIdx; lfnstIdx++ )//0,1,2
      {
        // MTS flag=0或1，即MTS的两个阶段
        for( uint8_t mtsFlag = startMtsFlag; mtsFlag <= endMtsFlag; mtsFlag++ )
        {
#if JVET_O0368_LFNST_WITH_DCT2_ONLY
          if (mtsFlag > 0 && lfnstIdx > 0)//当lfstIdx等于1或2时，不执行mtsflag=1的情况；lfnst变换只在mts_flag=0的时候执行
          {
            continue;
          }
#endif  
          //3) if interHad is 0, only try further modes if some intra mode was already better than inter
          if( sps.getUseLFNST() && m_pcEncCfg->getUsePbIntraFast() && !tempCS->slice->isIntra() && bestCU && CU::isInter( *bestCS->getCU( partitioner.chType ) ) && interHad == 0 )
          {
            continue;
          }

          tempCS->initStructData( encTestMode.qp, encTestMode.lossless );

          CodingUnit &cu      = tempCS->addCU( CS::getArea( *tempCS, tempCS->area, partitioner.chType ), partitioner.chType );

          partitioner.setCUData( cu );
          cu.slice            = tempCS->slice;
          cu.tileIdx          = tempCS->picture->brickMap->getBrickIdxRsMap( tempCS->area.lumaPos() );
          cu.skip             = false;
          cu.mmvdSkip = false;
          cu.predMode         = MODE_INTRA;
          cu.transQuantBypass = encTestMode.lossless;
          cu.chromaQpAdj      = cu.transQuantBypass ? 0 : m_cuChromaQpOffsetIdxPlus1;
          cu.qp               = encTestMode.qp;
          //cu.ipcm             = false;
          cu.lfnstIdx         = lfnstIdx;
          cu.mtsFlag          = mtsFlag;
          cu.ispMode          = NOT_INTRA_SUBPARTITIONS;
          
          CU::addPUs( cu );

          tempCS->interHad    = interHad;

          m_bestModeUpdated = tempCS->useDbCost = bestCS->useDbCost = false;

          bool validCandRet = false;
          if( isLuma( partitioner.chType ) )
          {
#if JVET_O0502_ISP_CLEANUP
            //ISP uses the value of the best cost so far (luma if it is the fast version) to avoid test non-necessary subpartitions
            //ISP使用到目前为止最佳成本的值（如果是快速版本，则为luma）以避免测试不必要的子分区
#if JVET_O0050_LOCAL_DUAL_TREE
            double bestCostSoFar = partitioner.isSepTree(*tempCS) ? m_modeCtrl->getBestCostWithoutSplitFlags() : bestCU && bestCU->predMode == MODE_INTRA ? bestCS->lumaCost : bestCS->cost;
            if (partitioner.isSepTree(*tempCS) && encTestMode.maxCostAllowed < bestCostSoFar)
#else
            double bestCostSoFar = CS::isDualITree(*tempCS) ? m_modeCtrl->getBestCostWithoutSplitFlags() : bestCU && bestCU->predMode == MODE_INTRA ? bestCS->lumaCost : bestCS->cost;
            if (CS::isDualITree(*tempCS) && encTestMode.maxCostAllowed < bestCostSoFar)
#endif
            {
              bestCostSoFar = encTestMode.maxCostAllowed;
            }
#else
            //the Intra SubPartitions mode uses the value of the best cost so far (luma if it is the fast version) to avoid test non-necessary lines
#if JVET_O0050_LOCAL_DUAL_TREE
            const double bestCostSoFar = partitioner.isSepTree( *tempCS ) ? m_modeCtrl->getBestCostWithoutSplitFlags() : bestCU && bestCU->predMode == MODE_INTRA ? bestCS->lumaCost : bestCS->cost;
#else
            const double bestCostSoFar = CS::isDualITree( *tempCS ) ? m_modeCtrl->getBestCostWithoutSplitFlags() : bestCU && bestCU->predMode == MODE_INTRA ? bestCS->lumaCost : bestCS->cost;
#endif
#endif         //亮度分量预测          
            validCandRet = m_pcIntraSearch->estIntraPredLumaQT( cu, partitioner, bestCostSoFar, mtsFlag, startMTSIdx[ trGrpIdx ], endMTSIdx[ trGrpIdx ], ( trGrpIdx > 0 ) );
            if( sps.getUseLFNST() && ( !validCandRet || ( cu.ispMode && cu.firstTU->cbf[ COMPONENT_Y ] == 0 ) ) )
            {
              continue;
            }

            useIntraSubPartitions = cu.ispMode != NOT_INTRA_SUBPARTITIONS;
#if JVET_O0050_LOCAL_DUAL_TREE
            if( !partitioner.isSepTree( *tempCS ) )
#else
            if( !CS::isDualITree( *tempCS ) )
#endif
            {
              tempCS->lumaCost = m_pcRdCost->calcRdCost( tempCS->fracBits, tempCS->dist );
              if( useIntraSubPartitions )
              {
                //the difference between the best cost so far and the current luma cost is stored to avoid testing the Cr component if the cost of luma + Cb is larger than the best cost
                maxCostAllowedForChroma = bestCS->cost < MAX_DOUBLE ? bestCS->cost - tempCS->lumaCost : MAX_DOUBLE;
              }
            }

            if (m_pcEncCfg->getUsePbIntraFast() && tempCS->dist == std::numeric_limits<Distortion>::max()
                && tempCS->interHad == 0)
            {
              interHad = 0;
              // JEM assumes only perfect reconstructions can from now on beat the inter mode
              m_modeCtrl->enforceInterHad( 0 );
              continue;
            }

#if JVET_O0050_LOCAL_DUAL_TREE
            if( !partitioner.isSepTree( *tempCS ) )
#else
            if( !CS::isDualITree( *tempCS ) )
#endif
            {//如果不是I帧，则将重建的YUV数据复制到亮度分量中，以备下面色度预测使用;
              cu.cs->picture->getRecoBuf( cu.Y() ).copyFrom( cu.cs->getRecoBuf( COMPONENT_Y ) );
              cu.cs->picture->getPredBuf(cu.Y()).copyFrom(cu.cs->getPredBuf(COMPONENT_Y));
            }
          }
//色度块的帧内预测
#if JVET_O0050_LOCAL_DUAL_TREE      
          if( tempCS->area.chromaFormat != CHROMA_400 && ( partitioner.chType == CHANNEL_TYPE_CHROMA || !cu.isSepTree() ) )//如果是色度分量或者是B SLICE或者是P  SLICE
#else
          if( tempCS->area.chromaFormat != CHROMA_400 && ( partitioner.chType == CHANNEL_TYPE_CHROMA || !CS::isDualITree( *tempCS ) ) )
#endif
          {//选择当前块的色度最优预测模式，I帧是先亮度后色度预测，B帧和P帧是亮度色度同时进行（对于一个CTU来说）
            TUIntraSubPartitioner subTuPartitioner( partitioner );
#if JVET_O0050_LOCAL_DUAL_TREE
            m_pcIntraSearch->estIntraPredChromaQT( cu, ( !useIntraSubPartitions || ( cu.isSepTree() && !isLuma( CHANNEL_TYPE_CHROMA ) ) ) ? partitioner : subTuPartitioner, maxCostAllowedForChroma );
#else
            m_pcIntraSearch->estIntraPredChromaQT( cu, ( !useIntraSubPartitions || ( CS::isDualITree( *cu.cs ) && !isLuma( CHANNEL_TYPE_CHROMA ) ) ) ? partitioner : subTuPartitioner, maxCostAllowedForChroma );
#endif
            if( useIntraSubPartitions && !cu.ispMode )
            {
              //At this point the temp cost is larger than the best cost. Therefore, we can already skip the remaining calculations
              continue;
            }
          }

          cu.rootCbf = false;

          for( uint32_t t = 0; t < getNumberValidTBlocks( *cu.cs->pcv ); t++ )
          {
            cu.rootCbf |= cu.firstTU->cbf[t] != 0;
          }

          // Get total bits for current mode: encode CU
          m_CABACEstimator->resetBits();

          if( pps.getTransquantBypassEnabledFlag() )
          {
            m_CABACEstimator->cu_transquant_bypass_flag( cu );
          }

          if ((!cu.cs->slice->isIntra() || cu.cs->slice->getSPS()->getIBCFlag())
            && cu.Y().valid()
            )
          {
            m_CABACEstimator->cu_skip_flag ( cu );
          }
          m_CABACEstimator->pred_mode      ( cu );
          m_CABACEstimator->pcm_data       ( cu, partitioner );
          m_CABACEstimator->cu_pred_data   ( cu );
          m_CABACEstimator->bdpcm_mode     ( cu, ComponentID(partitioner.chType) );

          // Encode Coefficients
          CUCtx cuCtx;
          cuCtx.isDQPCoded = true;
          cuCtx.isChromaQpAdjCoded = true;
          m_CABACEstimator->cu_residual( cu, partitioner, cuCtx );

          tempCS->fracBits = m_CABACEstimator->getEstFracBits();
          tempCS->cost     = m_pcRdCost->calcRdCost(tempCS->fracBits, tempCS->dist);//得到当前CU的总代价;

#if JVET_O0050_LOCAL_DUAL_TREE
          double bestIspCost = cu.ispMode ? cu.isSepTree() ? tempCS->cost : tempCS->lumaCost : MAX_DOUBLE;
#else
          double bestIspCost = cu.ispMode ? CS::isDualITree( *tempCS ) ? tempCS->cost : tempCS->lumaCost : MAX_DOUBLE;
#endif

          const double tmpCostWithoutSplitFlags = tempCS->cost;
          xEncodeDontSplit( *tempCS, partitioner );

          xCheckDQP( *tempCS, partitioner );

          // Check if low frequency non-separable transform (LFNST) is too expensive
#if JVET_O0472_LFNST_SIGNALLING_LAST_SCAN_POS
          if( lfnstIdx && !cuCtx.lfnstLastScanPos )
          {
#if JVET_O0050_LOCAL_DUAL_TREE
            bool cbfAtZeroDepth = cu.isSepTree() ? cu.rootCbf : std::min( cu.firstTU->blocks[ 1 ].width, cu.firstTU->blocks[ 1 ].height ) < 4 ? TU::getCbfAtDepth( *cu.firstTU, COMPONENT_Y, 0 ) : cu.rootCbf;
#else
            bool cbfAtZeroDepth = CS::isDualITree( *tempCS ) ? cu.rootCbf : std::min( cu.firstTU->blocks[ 1 ].width, cu.firstTU->blocks[ 1 ].height ) < 4 ? TU::getCbfAtDepth( *cu.firstTU, COMPONENT_Y, 0 ) : cu.rootCbf;
#endif
            if( cbfAtZeroDepth )
            {
              tempCS->cost = MAX_DOUBLE;
            }
          }
#else
#if JVET_O0050_LOCAL_DUAL_TREE
          const int nonZeroCoeffThr = cu.isSepTree() ? ( isLuma( partitioner.chType ) ? LFNST_SIG_NZ_LUMA : LFNST_SIG_NZ_CHROMA ) : LFNST_SIG_NZ_LUMA + LFNST_SIG_NZ_CHROMA;
#else
          const int nonZeroCoeffThr = CS::isDualITree( *tempCS ) ? ( isLuma( partitioner.chType ) ? LFNST_SIG_NZ_LUMA : LFNST_SIG_NZ_CHROMA ) : LFNST_SIG_NZ_LUMA + LFNST_SIG_NZ_CHROMA;
#endif
          if( lfnstIdx && cuCtx.numNonZeroCoeffNonTs <= nonZeroCoeffThr )
          {
            if (cuCtx.numNonZeroCoeffNonTs > 0)
            {
              tempCS->cost = MAX_DOUBLE;
            }
          }
#endif

          if( mtsFlag == 0 && lfnstIdx == 0 )
          {
            dct2Cost = tempCS->cost;
          }

          if( tempCS->cost < bestCS->cost )
          {
            m_modeCtrl->setBestCostWithoutSplitFlags( tmpCostWithoutSplitFlags );
          }

          if( !mtsFlag ) static_cast< double& >( costSize2Nx2NmtsFirstPass ) = tempCS->cost;

          if( sps.getUseLFNST() && !tempCS->cus.empty() )
          {
            skipOtherLfnst = m_modeCtrl->checkSkipOtherLfnst( encTestMode, tempCS, partitioner );
          }

          xCalDebCost( *tempCS, partitioner );
          tempCS->useDbCost = m_pcEncCfg->getUseEncDbOpt();


#if WCG_EXT
          DTRACE_MODE_COST( *tempCS, m_pcRdCost->getLambda( true ) );
#else
          DTRACE_MODE_COST( *tempCS, m_pcRdCost->getLambda() );
#endif
          if( !sps.getUseLFNST() )
          {
            xCheckBestMode( tempCS, bestCS, partitioner, encTestMode );
          }
          else
          { 
            if( xCheckBestMode( tempCS, bestCS, partitioner, encTestMode ) )
            {
              trGrpBestCost[ trGrpIdx ] = globalBestCost = bestCS->cost;
              bestSelFlag  [ trGrpIdx ] = true;
              bestMtsFlag               = mtsFlag;
              bestLfnstIdx              = lfnstIdx;
              if( bestCS->cus.size() == 1 )
              {
                CodingUnit &cu = *bestCS->cus.front();
                if( cu.firstTU->mtsIdx == MTS_SKIP )
                {
                  if( ( g_aucLog2[ cu.firstTU->blocks[ COMPONENT_Y ].width ] + g_aucLog2[ cu.firstTU->blocks[ COMPONENT_Y ].height ] ) >= 6 )
                  {
                    endLfnstIdx = 0;
                  }
                }
              }
            }

#if JVET_O0502_ISP_CLEANUP
            //we decide to skip the non-DCT-II transforms and LFNST according to the ISP results
            if ((endMtsFlag > 0 || endLfnstIdx > 0) && cu.ispMode && !mtsFlag && !lfnstIdx && tempCS->slice->isIntra() && m_pcEncCfg->getUseFastISP())
#else
            //we decide to skip the second emt pass or not according to the ISP results
            if( considerMtsSecondPass && cu.ispMode && !mtsFlag && tempCS->slice->isIntra() )
#endif
            {
              double bestCostDct2NoIsp = m_modeCtrl->getMtsFirstPassNoIspCost();
              CHECKD( bestCostDct2NoIsp <= bestIspCost, "wrong cost!" );
#if JVET_O0502_ISP_CLEANUP
              double threshold = 1.4;
#else
              double nSamples  = ( double ) ( cu.lwidth() << g_aucLog2[ cu.lheight() ] );
              double threshold = 1 + 1.4 / sqrt( nSamples );
#endif

              double lfnstThreshold = 1.01 * threshold;
              if( bestCostDct2NoIsp > bestIspCost*lfnstThreshold )
              {
                endLfnstIdx = lfnstIdx;//跳过剩下的LFNST
              }

              if( bestCostDct2NoIsp > bestIspCost*threshold )//跳过第二阶段的MTS
              {
                skipSecondMtsPass = true;
                m_modeCtrl->setSkipSecondMTSPass( true );
                break;
              }
            }
            //now we check whether the second pass of SIZE_2Nx2N and the whole Intra SIZE_NxN should be skipped or not
            if( !mtsFlag && !tempCS->slice->isIntra() && bestCU && bestCU->predMode != MODE_INTRA )
            {
              const double thEmtInterFastSkipIntra = 1.4; // Skip checking Intra if "2Nx2N using DCT2" is worse than best Inter mode
              if( costSize2Nx2NmtsFirstPass > thEmtInterFastSkipIntra * bestInterCost )
              {
                skipSecondMtsPass = true;
                m_modeCtrl->setSkipSecondMTSPass( true );
                break;
              }
            }
          }

        } //for emtCuFlag
        if( skipOtherLfnst )//跳过其他的lfnst变换
        {
          startLfnstIdx = lfnstIdx;
          endLfnstIdx   = lfnstIdx;
          break;
        }
      } //for lfnstIdx
    } //if (!skipSecondMtsPass && considerMtsSecondPass && trGrpCheck[iGrpIdx])

    if( sps.getUseLFNST() && trGrpIdx < 3 )
    {
      trGrpCheck[ trGrpIdx + 1 ] = false;//用来判断trGrpIdx+1对应的变换核是否可以进行；才开始都初始化为true，再判断满足条件之前要置为false

      if( bestSelFlag[ trGrpIdx ] && considerMtsSecondPass )
      {
        double dCostRatio = dct2Cost / trGrpBestCost[ trGrpIdx ];
        //若最优代价比DCT2变换的代价小，且相差的部分在一定范围内则trGrpCheck[ trGrpIdx + 1 ] = true,
        //会选择trGrpIdx+1对应的变换:（因为startMTSIdx[ trGrpIdx ]、endMTSIdx[ trGrpIdx ]，对应xRecurIntraCodingLumaQT中的mtsFirstCheckId、mtsLastCheckId）
        trGrpCheck[ trGrpIdx + 1 ] = ( bestMtsFlag != 0 || bestLfnstIdx != 0 ) && dCostRatio < trGrpStopThreshold[ trGrpIdx ];
      }
    }
  } //trGrpIdx
}

在bool IntraSearch::xRecurIntraCodingLumaQT里真正的选定变换核，为接下来的变换做准备：
我使用AI配置时，最终都会进入到下面这段代码中确定变换核

 //使用低频不可分变换（LFNST）
      if (sps.getUseLFNST())
      {
        if (cu.mtsFlag)
        {
          if (moreProbMTSIdxFirst)   //由trGrpIdx>0控制
          {
            const ChannelType     chType      = toChannelType(COMPONENT_Y);
            const CompArea &      area        = tu.blocks[COMPONENT_Y];
            const PredictionUnit &pu          = *cs.getPU(area.pos(), chType);
            uint32_t              uiIntraMode = pu.intraDir[chType];

            if (transformIndex == 1)
            {
              tu.mtsIdx = (uiIntraMode < 34) ? MTS_DST7_DCT8 : MTS_DCT8_DST7;
            }
            else if (transformIndex == 2)
            {
              tu.mtsIdx = (uiIntraMode < 34) ? MTS_DCT8_DST7 : MTS_DST7_DCT8;
            }
            else
            {
              tu.mtsIdx = MTS_DST7_DST7 + transformIndex;
            }
          }
          else
          {
           
            tu.mtsIdx = MTS_DST7_DST7 + transformIndex;
             }
        }
        else
        {
          tu.mtsIdx = transformIndex;
        }

3、总结

这是我写的第一篇博客，写的有点混乱，自己也还是个小白，要是有什么错误的话大家可以直接指出来。希望能和大家一起探讨学习！

sky_Ryota
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
H.266/VVC代码学习：xCheckRDCostIntra函数
BigDream123的博客
11-17 2358
xCheckRDCostIntra函数主要是选出最佳帧内模式和变换类型。 其中通过调用estIntraPredLumaQT函数遍历所有的亮度帧内预测模式选出最佳亮度帧内预测模式，通过调用estIntraPredChromaQT函数选出最佳色度帧内预测模式。 xCheckRDCostIntra函数是遍历了所有的变换模式并计算相应的RD Cost。 主要分为两个阶段 阶段1：mts_flag标...
H.266/VVC代码学习4：VTM代码整体结构及最上层函数
时间有泪
03-02 6965
最近在做一些较上层的内容，从老师和师兄师姐的博客里学到了很多，对VTM代码有了进一步的理解。VTM4.0代码整体结构如下，并会后面分别介绍几个主要函数的作用。 EncSlice::encodeCtus 大体操作：以CTU为单位，对划分后的内容进行熵编码。 每个slice为一帧。一帧中对所有CTU（128*128）都进行编码（for循环每个CTU，分别调用compressCtu函数），具体来说主要...
VVC/VTM在AI配置下统计结果的问题
pengyouyou的博客
11-05 901
今天调试程序的时候发现一个问题，本来是在统计完整的64*64CU深度（AI配置）。统计了416*240的序列第一帧时（不统计边界的CU），发现结果是加起来是36个CU（应该只有18个64*64的CU）。最后发现是在DualITree : 1（亮度和色度单独进行划分，我之前只看过HEVC，以前帧内亮度和色度是一起划分的），因此在亮度和色度中均进行了统计，增加对亮度的判断即可。 partition...
VVC代码阅读 xCompressCU(2) do while结构 最后面有两小段函数没看
dfhg54的博客
04-20 627
H.266/VVC代码学习：xCompressCU函数_涵小呆的博客-CSDN博客 尝试当前编码器各种可用的模式：如skip，帧间，帧内，PCM等，进行预测及划分。 do { } while( m_modeCtrl->nextMode( *tempCS, partitioner ) ); for (int i = compBegin; i < (compBegin + numComp); i++) { ComponentID comID = jointPLT ?
VVC代码阅读 帧内预测部分(1) xCheckRDCostIntra()函数（部分）
dfhg54的博客
06-27 454
VVC参考软件VTM6.0中变换的相关代码讲解与注释（一）_sky_Ryota的博客-CSDN博客VTM6变换算法小结（译自O2002）_Allen---Jiang的博客-CSDN博客亮度预测函数前 MTS：多变换核选择LFNST:低频不可分离变换trGrp：推测应该是代表一个过程，测试MTS和LFNST在不同情况下的模式。有很多个trGrp 变换的部分先粗略看，可参考VTM10.0代码学习13：xCheckRDCostIntra()_柴门风雪夜的博客-CSDN博客addPUs()可参考之前写的ad
VVCSoftware-VTM-VTM-20.0 H.266/VVC 参考软件
04-27
2023年4月更新到20.0版本，安装可以参考压缩包内的readme.md文件
VVC参考软件
07-15
新发布的H.266/VVC的参考软件VTM1.0，是学习研究266b编码标准必备的软件
H266/VVC Software_VTM编译和视频测试序列-附件资源
03-02
H266/VVC Software_VTM编译和视频测试序列-附件资源
VTM块划分代码_块划分；_H.266_statementzbb_VVC_
10-03
VTM中关于块划分的代码，在该部分代码上可研究如何优化块划分
H.266/VVC、VTM、YUV中的各种参数(函数)：slice、sps、pps、ss、vps、luma、chroma等
qq_42691604的博客
10-24 1123
H.266/VVC、VTM、YUV中的各种参数(函数)：slice、sps、pps、ss、vps、luma、chroma等
VVC帧内亮度角度预测--帧内编码学习（二）
pengyouyou的博客
04-02 1527
对于帧内预测来说，主要包括角度预测和划分。 在xCompressCU函数中体现为 xCheckRDCostIntra( tempCS, bestCS, partitioner, currTestMode ); 以及 xCheckModeSplit( tempCS, bestCS, partitioner, currTestMode , tempMotCandLUTs ...
什么是RDCost？
smells2的专栏
06-28 8446
Rate Distortion Optimation (率失真优化)        在H.264编码过程中有许多的模式可以选择，有些模式的图像失真较小，但是码率却很大；有些模式的图像失真较大，但是码率却很小。人们就想了，有没有一种方法使得在不超过某最大码率的情况下，失真达到最小。即 min{D} s.t. R 实现过程可以描述为： 1.以特定的编码参数将视频编码，计算编码后的码率和失
VVC/H.266中的划分函数void EncCu::xCheckModeSplit
zhang2039的博客
08-17 1575
VVC中的编码块的划分与HEVC中有很大的不同。VVC中专门的一个函数来实现划分xCheckModeSplit。在void EncCu::xCheckModeSplit中的会进行具体的QT.BT.TT的划分，在xCompressCUz这个函数也会调用xCheckModeSplit这里面的划分结果，首先先看一个EncTestMode，会得到具体的CU划分模式 ETM_SPLIT_QT, ETM_SPLIT_BT_H, ETM_SPLIT_BT_V, ETM_SPLIT_TT_H, ETM...
Dual-tree （快速计算核密度估计算法）
u013247002的博客
08-29 2203
Dual-tree （快速计算核密度估计算法） 介绍 使用kd-tree实现空间划分：   Kd-tree：k-dimensional树的简称，是一种分割k维数据空间的数据结构。 对数据点在k维空间{二维(x，y)，三维(x，y，z)，k维(x，y，z..)}中划分的一种数据结构，主要应用于多维空间关键数据的搜索(如：范围搜索和最近邻搜索)。 Kd-Tree的构建算法： （1）在K维数...
VVC/JEM代码学习6：xCompressCU（）
小小柴的博客
01-17 2441
      xCompressCU是一个递归函数，对于每一个CU，该函数都会被调用，主要是计算当前CU编码之后代价，然后再计算当前CU的每一个子CU编码后的代价，和当前CU的编码代价相比较，用来决定是否对当前CU进行分割。这个函数太复杂啦，继续慢慢学习吧。Void TEncCu::xCompressCU( TComDataCU*&amp; rpcBestCU, TComDataCU*&amp; r...
VVC代码学习1：xCompressCU函数
Everglow_zbz的博客
09-14 1928
一、函数简述 xCompressCU这个函数通过递归的调用自己来完成对整个CTU的划分和每个CU的模式选择。与HEVC中该函数不同的是，VVC中加入了很多新的模式，比如帧间Affine模式，帧内IBC模式等。 亮度块最大允许尺寸为128×128，并且划分方式采用多类型树结构，CU可以进行四叉划分，水平二叉划分，垂直二叉划分，水平三叉划分，垂直三叉划分。最优划分模式的确定在xCheckModeSpl...
VTM1.0代码阅读：decompressCtu函数
矛盾统一
12-26 207
decompressCtu函数用来对coding_tree_unit函数解码得到的数据进行解析，根据解码得到的运动参数恢复ctu的像素信息，即重建像素reco信息。 入口参数cs是picture的cs，其中包括了一帧内所有ctu的所有信息，ctuArea即需要decompress的ctu区域。 获取ctu区域内的所有cu，判断这些cu的预测模式是intra还是inter，然后分别进行帧内和帧间的像...
BMS/VTM代码学习：CodingStructure和CodingUnit
慢慢积累
07-17 2714
在BMS中对CU类进行了简化，看起来好舒服啊，代码量少了很多。今天就从指定CU的提取入手，来说下BMS中的CodingStructure和CodingUnit。 HM/JEM：TComDataCU 先来看HM和JEM。CU信息存储在TComDataCU中，来看官方给的介绍： TComDataCU里面的确存放了大量信息，在日常使用中从这样一个cu对象就可以取到大部分所需要的信息。这里就不贴...
VVC新技术（汇总中）
iuvgood
08-27 3196
内容非原创 帧内预测： 简介https://blog.csdn.net/u012038173/article/details/90084591#2_CCLM_66 1. 扩展角度帧内模式 ：65个帧内预测模式和WAIP预测模式 ：https://cloud.tencent.com/developer/article/1430270 针对这个非对称问题，对于水平的预测单元，模式67~ 80...
HEVC、AV1、VVC变换、量化的差异
最新发布
10-13
HEVC、AV1、VVC是当前主流的视频编码标准，它们在变换和量化方面有以下差异： 1. 变换方式：HEVC和AV1采用离散余弦变换（DCT），而VVC采用了更高效的离散正弦变换（DST）。 2. 变换大小：HEVC和AV1的变换块大小为最大64x64，而VVC将最大块大小增加到了128x128，从而提高了编码效率。 3. 量化方式：HEVC和AV1采用了类似的量化方式，即将变换系数除以一个固定的量化因子。而VVC引入了自适应量化，根据图像内容和编码质量动态调整量化因子，从而提高了编码效率和视频质量。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值