VVC/JEM代码学习12：transformNxN

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

对残差次数进行量化编码的函数，相比于HEVC，JEM中加入了二次变换，即在第一次主变换又进行第二次变换；此外，还加入了EMT，和DCT2是并列关系，根据相关索引进行选择;

Void TComTrQuant::transformNxN(       TComTU        & rTu,

                                const ComponentID     compID,
                                      Pel          *  pcResidual,//残差;
                                const UInt            uiStride,
                                      TCoeff       *  rpcCoeff,//残差经变换量化后的系数;
#if ADAPTIVE_QP_SELECTION
                                      TCoeff       *  pcArlCoeff,
#endif
                                      TCoeff        & uiAbsSum,
                                const QpParam       & cQP 
#if VCEG_AZ08_KLT_COMMON
                                , Bool useKLT
#endif
                                )
{
  const TComRectangle &rect = rTu.getRect(compID);
  const UInt uiWidth        = rect.width;
  const UInt uiHeight       = rect.height;
  TComDataCU* pcCU          = rTu.getCU();
  const UInt uiAbsPartIdx   = rTu.GetAbsPartIdxTU();
  const UInt uiOrgTrDepth   = rTu.GetTransformDepthRel();

  uiAbsSum=0;//存放残差绝对值的和;

  RDPCMMode rdpcmMode = RDPCM_OFF;
  rdpcmNxN( rTu, compID, pcResidual, uiStride, cQP, rpcCoeff, uiAbsSum, rdpcmMode );

  if (rdpcmMode == RDPCM_OFF)
  {
    uiAbsSum = 0;
    //transform and quantise
    if(pcCU->getCUTransquantBypass(uiAbsPartIdx))//旁路掉变换和量化
    {
      const Bool rotateResidual = rTu.isNonTransformedResidualRotated(compID);
      const UInt uiSizeMinus1   = (uiWidth * uiHeight) - 1;

      for (UInt y = 0, coefficientIndex = 0; y<uiHeight; y++)
      {
        for (UInt x = 0; x<uiWidth; x++, coefficientIndex++)
        {
          const Pel currentSample = pcResidual[(y * uiStride) + x];

          rpcCoeff[rotateResidual ? (uiSizeMinus1 - coefficientIndex) : coefficientIndex] = currentSample;
          uiAbsSum += TCoeff(abs(currentSample));
        }
      }
    }
    else//不旁路变换量化
    {
#if DEBUG_TRANSFORM_AND_QUANTISE
      std::cout << g_debugCounter << ": " << uiWidth << "x" << uiHeight << " channel " << compID << " TU at input to transform\n";
      printBlock(pcResidual, uiWidth, uiHeight, uiStride);
#endif
#if JVET_C0024_QTBT
      assert( (pcCU->getSlice()->getSPS()->getCTUSize() >= uiWidth) );
#else
      assert( (pcCU->getSlice()->getSPS()->getMaxTrSize() >= uiWidth) );
#endif

      if(pcCU->getTransformSkip(uiAbsPartIdx, compID) != 0)//如果跳过变换;
      {
        xTransformSkip( pcResidual, uiStride, m_plTempCoeff, rTu, compID );
      }
      else//不跳过变换
      {
        const Int channelBitDepth=pcCU->getSlice()->getSPS()->getBitDepth(toChannelType(compID));//10;
        xT( channelBitDepth, rTu.useDST(compID), pcResidual, uiStride, m_plTempCoeff, uiWidth, uiHeight, pcCU->getSlice()->getSPS()->getMaxLog2TrDynamicRange(toChannelType(compID)) 
#if COM16_C806_EMT
          , getEmtMode ( rTu, compID )
          , getEmtTrIdx( rTu, compID )
#endif
#if VCEG_AZ08_KLT_COMMON
          , useKLT && (compID == 0)
#endif
          );//执行变换的主函数，也是第一次变换
      }

#if JVET_C0024_QTBT
    Char ucNsstIdx = pcCU->getROTIdx(toChannelType(compID), uiAbsPartIdx) ;//二次变换的索引
    if (ucNsstIdx && uiWidth>=4 && uiHeight>=4
#if  JVET_C0045_C0053_NO_NSST_FOR_TS
      && !pcCU->getTransformSkip(uiAbsPartIdx, compID)
#endif
      )//ucNsstIdx在不等于0的前提下才做二次变换；
#else
      if (pcCU->getROTIdx(uiAbsPartIdx) 
#if  JVET_C0045_C0053_NO_NSST_FOR_TS
        && !pcCU->getTransformSkip(uiAbsPartIdx, compID)
#endif
        )
#endif
      {           
#if JVET_D0120_NSST_IMPROV
        static Int NSST_MATRIX[64];
        const  Int iLog2SbSize   = (uiWidth > 4 && uiHeight > 4) ? 3 : 2;
        const  Int iSbSize       = (uiWidth > 4 && uiHeight > 4) ? 8 : 4;
        const  Int iSubGroupXMax = Clip3(1, 8, (Int)uiWidth ) >> iLog2SbSize;
        const  Int iSubGroupYMax = Clip3(1, 8, (Int)uiHeight) >> iLog2SbSize;
#else
        static Int NSST_MATRIX[16];
        Int iSubGroupXMax = Clip3 (1,16,(Int)( (uiWidth>>2)));
        Int iSubGroupYMax = Clip3 (1,16,(Int)( (uiHeight>>2)));
#endif

        Int iOffSetX = 0;
        Int iOffSetY = 0;
        Int y = 0;
        Int* piCoeffTemp = m_plTempCoeff;
        Int* piNsstTemp = NSST_MATRIX;
#if JVET_D0120_NSST_IMPROV
        Int iString2CopySize = iSbSize*sizeof(Int);
#else
        Int iString2CopySize = 4*sizeof(Int);
#endif
#if VCEG_AZ07_CTX_RESIDUALCODING
#if !JVET_C0024_QTBT
        const UInt uiLog2BlockSize = g_aucConvertToBit[ uiWidth ] + 2;
#endif
#endif
        const UInt uiScanIdx = pcCU->getCoefScanIdx(uiAbsPartIdx, uiWidth, uiHeight, compID);
#if JVET_C0024_QTBT
        const UInt log2BlockWidth  = g_aucConvertToBit[uiWidth]  + MIN_CU_LOG2;
        const UInt log2BlockHeight = g_aucConvertToBit[uiHeight] + MIN_CU_LOG2;
#else
        const UInt log2BlockWidth  = g_aucConvertToBit[uiWidth]  + 2;
        const UInt log2BlockHeight = g_aucConvertToBit[uiHeight] + 2;
#endif
#if VCEG_AZ07_CTX_RESIDUALCODING
#if JVET_D0120_NSST_IMPROV
#if JVET_C0024_QTBT
        const UInt *scan = (log2BlockWidth>=3 && log2BlockHeight>=3) ? g_auiCoefTopLeftDiagScan8x8[log2BlockWidth-3] : g_scanOrder[ SCAN_GROUPED_4x4 ][ uiScanIdx ][ log2BlockWidth    ][ log2BlockHeight    ];
#else
        const UInt *scan = uiLog2BlockSize>3 ? g_auiCoefTopLeftDiagScan8x8[log2BlockWidth-4] : g_scanOrder[ SCAN_GROUPED_4x4 ][ uiScanIdx ][ log2BlockWidth    ][ log2BlockHeight    ];

#endif

  UInt uiIntraMode = pcCU->getIntraDir( toChannelType(compID), uiAbsPartIdx);//得到帧内预测模式;
        if( compID != COMPONENT_Y )
        {
#if JVET_E0062_MULTI_DMS && COM16_C806_LMCHROMA
          if( uiIntraMode == LM_CHROMA_IDX )
          {
            uiIntraMode = PLANAR_IDX;
          }
#if JVET_E0077_ENHANCED_LM
          if (IsLMMode(uiIntraMode))
          {
              uiIntraMode = PLANAR_IDX;
          }

#endif

     }

        assert( uiIntraMode<NUM_INTRA_MODE-1 );
        const Int iNsstCandNum = ( uiIntraMode<=DC_IDX ) ? 3 : 4;//二次变换候选数量，DC和planar和CCLM模式的候选数量为3，其他为4;

#if JVET_C0024_QTBT
        if( iNsstCandNum > ucNsstIdx )
#else
        if( iNsstCandNum > pcCU->getROTIdx(uiAbsPartIdx) )
#endif
        {
#if JVET_D0120_NSST_IMPROV 
#if JVET_C0024_QTBT
          const Int * permut = iSbSize>4 ? g_nsstHyGTPermut8x8[g_NsstLut[uiIntraMode]][ucNsstIdx - 1] : g_nsstHyGTPermut4x4[g_NsstLut[uiIntraMode]][ucNsstIdx - 1];
#else
          const Int * permut = iSbSize>4 ? g_nsstHyGTPermut8x8[g_NsstLut[uiIntraMode]][pcCU->getROTIdx(uiAbsPartIdx) - 1] : g_nsstHyGTPermut4x4[g_NsstLut[uiIntraMode]][pcCU->getROTIdx(uiAbsPartIdx) - 1];
#endif
#endif
          for (Int iSubGroupX = 0; iSubGroupX<iSubGroupXMax; iSubGroupX++)
          {
            for (Int iSubGroupY = 0; iSubGroupY<iSubGroupYMax; iSubGroupY++)
            {
#if JVET_D0120_NSST_IMPROV
              iOffSetX = iSbSize*iSubGroupX;
              iOffSetY = iSbSize*iSubGroupY*uiWidth;
#else
              iOffSetX = 4*iSubGroupX;
              iOffSetY = 4*iSubGroupY*uiWidth;
#endif
              piNsstTemp = NSST_MATRIX;
              piCoeffTemp = m_plTempCoeff+iOffSetX+iOffSetY;

#if JVET_D0120_NSST_IMPROV
              for(  y = 0; y < iSbSize; y++ )
#else
              for(  y = 0; y < 4; y++ )
#endif
              {  
                if( uiIntraMode>DIA_IDX )//垂直方向,即将CoeffTemp转置后复制给NsstTemp;
                {
#if JVET_D0120_NSST_IMPROV
                  if( iSbSize==4 )
                  {
                    piNsstTemp[ 0] = piCoeffTemp[0]; piNsstTemp[ 4] = piCoeffTemp[1];
                    piNsstTemp[ 8] = piCoeffTemp[2]; piNsstTemp[12] = piCoeffTemp[3];
                  }
                  else if( iSbSize==8 )
                  {
                    piNsstTemp[ 0] = piCoeffTemp[0]; piNsstTemp[ 8] = piCoeffTemp[1];
                    piNsstTemp[16] = piCoeffTemp[2]; piNsstTemp[24] = piCoeffTemp[3];
                    piNsstTemp[32] = piCoeffTemp[4]; piNsstTemp[40] = piCoeffTemp[5];
                    piNsstTemp[48] = piCoeffTemp[6]; piNsstTemp[56] = piCoeffTemp[7];
                  }
#else
                  piNsstTemp[ 0] = piCoeffTemp[0]; piNsstTemp[ 4] = piCoeffTemp[1];
                  piNsstTemp[ 8] = piCoeffTemp[2]; piNsstTemp[12] = piCoeffTemp[3];
#endif
                  piNsstTemp ++;
                }
                else//uiIntraMode<=DIA_IDX
                {
                  ::memcpy(piNsstTemp, piCoeffTemp, iString2CopySize); //水平方向直接复制;
#if JVET_D0120_NSST_IMPROV
                  piNsstTemp += iSbSize;
#else
                  piNsstTemp +=4;
#endif
                }
                piCoeffTemp +=uiWidth;
              }

#if JVET_C0024_QTBT
#if JVET_D0120_NSST_IMPROV//NSST是JEM中新加的技术，有两种
              if ( iSbSize>4 )
              {
                FwdNsst8x8( NSST_MATRIX, g_NsstLut[uiIntraMode], ucNsstIdx-1 );//大于等于8x8的TU，使用8x8的NSST
              }
              else
              {
                FwdNsst4x4( NSST_MATRIX, g_NsstLut[uiIntraMode], ucNsstIdx-1 );//4x4的TU，使用4x4的NSST

              }

  piNsstTemp = NSST_MATRIX;
              piCoeffTemp = m_plTempCoeff+iOffSetX+iOffSetY;


#if JVET_D0120_NSST_IMPROV
              for(  y = 0; y < iSbSize*iSbSize; y++ )
#else
              for(  y = 0; y < 16; y++ )
#endif
              {
#if JVET_D0120_NSST_IMPROV 
                piCoeffTemp[scan[y]] = piNsstTemp[permut[y]];
#else
                piCoeffTemp[scan[y]] = piNsstTemp[y];
#endif
              }
            }
          }
        }
      }
#endif
#if VCEG_AZ08_KLT_COMMON
      if (useKLT && (compID == 0))//如果是亮度分量且使用KLT
      {
          TUEntropyCodingParameters codingParameters;
          getTUEntropyCodingParameters(codingParameters, rTu, compID);
          const UInt *scan = codingParameters.scan; 
          reOrderCoeff(m_plTempCoeff, scan, uiWidth, uiHeight);//对系数进行重排
      }
#endif 
      xQuant( rTu, m_plTempCoeff, rpcCoeff,

#if ADAPTIVE_QP_SELECTION
              pcArlCoeff,
#endif
              uiAbsSum, compID, cQP 
            );//进行量化的主函数

#if DEBUG_TRANSFORM_AND_QUANTISE
      std::cout << g_debugCounter << ": " << uiWidth << "x" << uiHeight << " channel " << compID << " TU at output of quantiser\n";
      printBlock(rpcCoeff, uiWidth, uiHeight, uiWidth);
#endif
    }
  }

    //set the CBF
#if JVET_C0024_QTBT
  assert(uiOrgTrDepth==0);
  pcCU->setCbfPartRange((uiAbsSum > 0) ? 1 : 0, compID, uiAbsPartIdx, 0);
#else
  pcCU->setCbfPartRange((((uiAbsSum > 0) ? 1 : 0) << uiOrgTrDepth), compID, uiAbsPartIdx, rTu.GetAbsPartIdxNumParts(compID));
#endif
}

小小柴
关注
专栏目录
H.266代码学习：transformNxN函数
慢慢积累
03-12 1302
在之前 HEVC代码学习36：transformNxN函数 中对HM中的transformNxN进行了学习，而后又在 H.266代码学习：MDNSST相关代码 中，间接的对JEM中的transformNxN进行了粗略学习。下面将对比HM，来学习一下JEM中的transformNxN。在JEM中，帧内预测在xIntraCodingTUBlock和xIntraCodingTUBlockTM（HM中没有，
HEVC代码学习36：xTrMxN函数
慢慢积累
01-15 977
之前在transformNxN的学习中提到，xT函数是前向变换的入口函数，实际上xT完成的是变换前的准备工作，真正的前向变换由xTrMxN函数实现。 先来看下xT函数。xT只是一个入口函数，首先定义了残差块和系数块，然后调用xTrMxN进行前向变换。 /** Wrapper function between HM interface and core NxN forward transfo
VVC/VTM：变换量化——变换Transform
Moomin的博客
05-13 2074
Transform 1.更大的变换尺寸&舍弃高频变换系数 在VTM中，允许变换的最大尺寸为64x64（原来只应用于1080p和4K）。对于长或宽等于64的大尺寸变换块，直接舍弃高频变换系数，仅保留低频变换系数。例如，对于长x宽为MxN的块，若M等于64，则只保留左边的32列，若N等于64，则只保留上方的32行。 如果当前为变换跳过模式，则保留所有变换系数。 2.多种变换核心（Multipl...
VVC/JEM代码学习1：estIntraPredChromaQT函数
小小柴的博客
01-15 771
       现在好像关于JEM的博客还很少，正好自己学习JEM，就把自己学习到的一点东西记录下来。省的学了就忘，先给自己定个目标，一天至少一篇吧。今天学习了色度帧内预测，先记录一下。estIntraPredChromaQT函数的主要功能是进行色度分量的帧内预测，在11种备选的预测模式中根据RD cost选择cost最小的一种模式作为最优预测模式。11种备选模式中，前6种是属于CCLM预测，用重建...
HEVC-Transform Skip技术
sheldonma的博客
07-26 3万+
Transform Skip简介X265中实现 简介 背景： HEVC为了提高屏幕内容编码的效率，采用了TSM（Transform Skip Mode）技术。研究表明，由于屏幕视频内容的各项异性特征，对于文本、图形、色调单一的背景等区域，如果不做频域变换，而直接对预测残差编码，效果会更好。 原理： 在人造序列（如动画片、游戏视频等）中，图像呈平缓区域无变化、边界区域剧烈变化的趋势，预测之后的残差与 自然图像有明显的区别。这些残差数量较少，但值很大。经过变换，这些残差会形成大量的高频信息，导致出现大量冗余。t
HEVC代码学习36：transformNxN函数
慢慢积累
01-15 1929
今天来学习变换相关的函数，帧内帧间最终都会调用transformNxN来进行变换。下面来对transformNxN进行学习。 其工作流程如下： 1.RDPCM，对残差进行PCM处理，利用周围临近残差值预测当前残差。 2.检测是否为Trans-quant-bypass模式，则直接使用RDPCM的残差。否则执行3。 3.Transform skip flag为真，调用xTransformSki
VVC/JEM（一）：VVC参考软件
Moomin的博客
05-14 4557
以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代码学习：xCompressCU
小小柴的博客
01-17 1336
        今天上午又看到一篇挺好的关于xCompressCU函数的总结文，不过是关于HM的，所以我就基于此文写一个JEM的吧。原文地址https://www.2cto.com/kf/201604/499329.html。       先来个文字版的简洁说明(写在下面的步骤不一定会执行，是需要经过条件判断的，其中还有很多步骤没写出来)，代码记录在下一篇吧。xCompressCU（） { （...
VVC/JEM代码学习13 : SAOProcess
小小柴的博客
03-29 1453
在compressSlice和encodeSlice之间，还有两个主要的处理函数，一个是SAOProcess，一个是ALFProcess(ALF是JEM中新加的)；也就是说，当前帧完成重构后要对重构图像进行样点自适应补偿和自适应环路滤波，最后才进行真正的熵编码。        样点自适应补偿的原理是由于量化导致高频信息的丢失从而在解码图像上产生振铃效应，为此，样点自适应补偿技术从像素域入手，对重构...
VVC/JEM代码学习14:loopFilterPic
小小柴的博客
03-30 965
在代码学习13中，记录了SAO技术的详细过程，其实在执行SAO之前，要先对重建图像进行去方块滤波；去方块滤波和样点自适应补偿合并称为环路滤波。今天就记录一下去方块滤波的详细过程。   去方块滤波的原理：由于在编码时各个块的变换量化相互独立，对不同的块使用了不同的量化参数，导致每个块引入的量化误差大小不一致，导致相邻块边界的不连续性。此外，运动补偿预测过程中，相邻块的预测值可能来自不同图像的不同位置...
Duanxx的HEVC学习（三）HEVC编码框架（二）帧内预测
08-05
一 、帧内预测简要说明 2 二 、帧内预测回路 3
残差信号编码(residual coding) 和CABAC 中TU-level 的上下文parsing 代码分析
cj423889的专栏
06-16 4562
CABAC 是唯一一个应用到HEVC中的熵编码方式，
H.266/VVC变换代码学习：transformNxN函数
BigDream123的博客
10-25 1890
H.266/VVC中有两个transformNxN函数，它们的参数不同，如下： void transformNxN( TransformUnit& tu, const ComponentID& compID, const QpParam& cQP, std::vector<TrMode>* trModes, const int maxCand ); ...
H.266/VVC技术学习：熵编码
BigDream123的博客
07-25 2481
在VVC中，与HEVC中的设计相比，CABAC包含以下主要变化： Core CABAC engine 分离变换块和变换跳过块的残差编码结构。 变换系数的上下文建模 一、Core CABAC engine HEVC中的CABAC engine 在64个不同的代表性概率状态之间使用基于表的概率转换过程。 在HEVC中，表示编码engine状态的范围ivlCurrRange在计算新的间隔范围之前被量化为一组4个值，将表示小概率符号（LPS）的概率pLPS量化为64个值，可以使用包含所有64x4的8位预计
HEVC：函数xEstimateInterResidualQT（）注释
Moomin的博客
03-21 1478
这个函数主要包括TU单元的变化量化，反变换反量化，熵编码其中transformNxN函数为变化量化主函数其中invtransformNxN函数为反变换反量化主函数/* ** 估计残差的编码代价 ** 主要是进行变换量化以及熵编码，然后选出最优的模式 */ Void TEncSearch::xEstimateInterResidualQT(TComYuv *pcResi, Dou...
CNN的池化分类
qq_31908897的博客
05-27 1384
池化层（Pooling）:对filter的特征进行降维操作，形成最终特征。 分类 1、Max Pooling Over Time操作 MaxPooling Over Time是NLP中CNN模型中最常见的一种下采样操作。 意思是对于某个Filter抽取到若干特征值，只取其中得分最大的那个值作为Pooling层保留值，其它特征值全部抛弃，值最大代表只保留这些特征中最强的，而抛弃其它弱的此类特征。 ...
VVC/JEM代码学习15：xCheckRDCostAffineMerge2Nx2N
小小柴的博客
04-01 832
Affine模式是JEM中新加的，属于帧间预测，与FRUC,merge,inter形成竞争关系。#if COM16_C1016_AFFINE Void TEncCu::xCheckRDCostAffineMerge2Nx2N( TComDataCU*&amp; rpcBestCU, TComDataCU*&amp; rpcTempCU ) { assert( rpcTempCU-&gt;ge...
HEVC函数入门（8）——变换的实现
不是他人太努力，只是自己努力不够罢了
06-21 1904
前面我们讲的都是预测，下面开始变换的实现。 本文参考http://blog.csdn.net/shaqoneal/article/details/44856469 1、HM中Intra模式的主要实现逻辑 以Intra的亮度模式为例。主要实现代码实现于TEncSearch::estIntraPredQT方法中。TEncSearch::estIntraPredQT实现时，首先获取当前CU的分割子块
H.266/VVC 视频编码标准详解
"该文档是关于最新的视频编码标准H.266（也称为VVC，Video Coding Standard）的中文版。文档详细介绍了H.266标准的基础知识，包括编码结构、帧内预测和帧间预测技术，以及变换编码和量化等核心概念。" 在H.266（VVC...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值