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

最新推荐文章于 2022-06-27 16:55:37 发布
最新推荐文章于 2022-06-27 16:55:37 发布
阅读量867 收藏 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
    评论
专栏目录
BMS/VTM代码学习：xCompressCU
慢慢积累
09-26 3755
找工作基本结束，收心回来看266了，从xCompressCU开始吧。在初学者阶段写过HEVC代码学习11：xCompressCU函数，当时实际看的一知半解，作为参考吧。 BMS/VTM中xCompressCU代码精简了很多，看起来容易多了，主要流程为： 1.初始化：设置可用模式、上下文模型等。 2.尝试帧间、帧内各种可用预测模式，当遍历完所有可用模式后，调用xCheckModeSplit进行划分，...
H.266/VVC代码学习4：VTM代码整体结构及最上层函数
时间有泪
03-02 6972
最近在做一些较上层的内容，从老师和师兄师姐的博客里学到了很多，对VTM代码有了进一步的理解。VTM4.0代码整体结构如下，并会后面分别介绍几个主要函数的作用。 EncSlice::encodeCtus 大体操作：以CTU为单位，对划分后的内容进行熵编码。 每个slice为一帧。一帧中对所有CTU（128*128）都进行编码（for循环每个CTU，分别调用compressCtu函数），具体来说主要...
VVC的VTM平台搭建
qq_44576434的博客
06-13 722
VVC平台搭建 1.获取VVC源码 VTM下载 网址：https://vcgit.hhi.fraunhofer.de/jvet/VVCSoftware_VTM 版本选择，zip下载 2.编译工具cmake下载 网址：https://cmake.org/download/ 配置：https://blog.csdn.net/Peter_Red_Boy/article/details/90321778 3.使用Visual Studio打开build中的NextSoftware.sln，开始学习吧 ...
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
VVC参考软件VTM数据结构
BigDream123的博客
07-07 1981
VTM的数据模型图如下所示： 数据结构分三种类型： 1. 导航信息 Size、Position、Area（Position+Size）：基本二维信息（位置、尺寸） CompArea：继承自Area，表示特定分量的二维信息 UnitArea：包含了多个分量的Area，表示多个分量的二维信息，描述同一位置处的一组块 2. 存储区域 AreaBuf：包含了一个二维信号在内存中的存储（buf 和 Stride），可以根据位置访问到相应的信号值，包含内存的操作方法（fill、copy等） Unit.
VVCSoftware_VTM-VTM-8.0.zip.zip
05-06
VVC/H.266的VTM8.0源码，之前有人私信我要源码地址，这里直接提供给大家。大家也可以在HHI网站下载，但是可能比较慢，经常下载失败，这里帮大家下载好方便大家学习使用 (很奇怪，我每次设置都是不需要积分就能下载，可是后面都会变成需要积分，而且随着下载次数变多需要的积分也变多。显然是官方想让你们充值，没有积分的可以私聊我，我再发给你)。VVC其他资源地址可以参考：https://blog.csdn.net/weixin_37524256/article/details/105673482
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中关于块划分的代码，在该部分代码上可研究如何优化块划分
简化VTM平台输出结果，仅按顺序输出码率、YPSNR、UPSNR、VPSNR、编码时间
01-15
简化VTM平台输出结果，仅按顺序输出码率、YPSNR、UPSNR、VPSNR、编码时间，将exe放在文件夹下双击运行即可。
VVC帧内亮度角度预测--帧内编码学习（二）
pengyouyou的博客
04-02 1528
对于帧内预测来说，主要包括角度预测和划分。 在xCompressCU函数中体现为 xCheckRDCostIntra( tempCS, bestCS, partitioner, currTestMode ); 以及 xCheckModeSplit( tempCS, bestCS, partitioner, currTestMode , tempMotCandLUTs ...
参考图像详解
热门推荐
Dillon2015的博客
03-20 5万+
由于帧间预测的需要，编码当前帧时需要参考其他帧，这些被参考的帧称为当前帧的参考帧。在前面一节DPB中我们知道，DPB中包含参考图像和非参考图像。 参考图像集（Reference Picture Set，RPS）:RPS中包含DPB内的参考图像，这些参考图像可能被当前的图像参考也可能被将来的图像参考。 参考图像列表（ Reference Picture Lists，RPL）：RPL中只包含当前图...
VVC/H.266代码阅读（VTM8.0）(四. CU划分 )
曹健的博客
05-05 3680
VVC（Versatile Video Coding）是下一代视频编解码标准，目前仍在制定阶段。本系列博客从解码端入手，结合标准draft一步步分析相关代码，深入理解VVC的编解码过程。 本文是本系列的第四篇博客，内容是分析CU划分代码。
VTM10.0代码学习3：DecSlice_decompressSlice()
hjhyxq2014的博客
10-23 1650
此系列是为了记录自己学习VTM10.0的过程和锻炼表达能力，主要是从解码端进行入手。由于本人水平有限，出现的错误恳请大家指正，欢迎与大家一起交流进步。 接着本系列的上一篇博客继续讲，上一篇博客的末尾讲到调用slice解码器进行解码，就是m_cSliceDecoder.decompressSlice()这个函数。大致的作用就是将slice切成CTU然后继续解码，下面开始讲解具体流程。 1. decompressSlice() //-- For time output for each slice .
VVC/VTM：代码学习——CIIP详细过程
Moomin的博客
04-21 1671
位于函数void EncCu::xCheckRDCostMerge2Nx2N（）中 if (isIntrainterEnabled) { int numTestIntraMode = 4; // prepare for Intra bits calculation const TempCtx ctxStart(m_CtxCac...
H.266/VVC测试软件VTM
慢慢积累
07-20 6878
JVET于2018年4月10日美国圣地亚哥会议上，为新一代视频编码标准定名为Versatile Video Coding，正式开启了H.266/VVC的标准化进程。 从H.265跟过来的同学们肯定都知道中间存在一个JEM（Joint Exploration Model ），实际就是一个过渡版本，其中的技术在H.266/VVC中并不一定会采纳，要重新评估决定。 在4月的J会议上，确定了VVC的初...
VS2017、windows、VVC参考代码VTM代码的编译和编码
TiramisuForever
11-23 3904
1、下载的代码在这一轮 现在最近的时候3.0版本，可能到你的时候已经不是最近，你就进去下最新的代码就好了。下载链接如下： https://vcgit.hhi.fraunhofer.de/jvet/VVCSoftware_VTM 2、下载完成之后，解压，在代码目录下面新建一个build文件夹 3、然后打开命令窗口，切换到你的build目录下面，因为我的VS是2017,所以我在readm...
VVC/VTM：代码学习——量化的实现（普通量化和Dependent scalar Quantization）
Moomin的博客
05-07 3673
VVC中引进了Dependent Scalar Quantization（依赖性的标量量化），所以代码中有三种量化函数，本文分为普通量化、率失真优化量化RDOQ和Dependent Quantization（简称DQ）
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、付费专栏及课程。

余额充值