VVC/JEM代码学习26：m_pcTrQuant->transformN*N

最新推荐文章于 2024-07-22 11:05:04 发布
最新推荐文章于 2024-07-22 11:05:04 发布
阅读量717 收藏 2
点赞数
分类专栏： H.266/VVC JEM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cxy19931018/article/details/80246790
版权
H.266/VVC 同时被 2 个专栏收录
50 篇文章 66 订阅
订阅专栏
JEM
26 篇文章 2 订阅
订阅专栏 
在H.266中，做完主变换后，还要进行二次变换，然后才进行量化；
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;//默认是关闭rdpcm的；
  rdpcmNxN( rTu, compID, pcResidual, uiStride, cQP, rpcCoeff, uiAbsSum, rdpcmMode );

  if (rdpcmMode == RDPCM_OFF)
  {
    uiAbsSum = 0;
    //transform and quantise
    if(pcCU->getCUTransquantBypass(uiAbsPartIdx))//旁路掉变换和量化，即直接把残差系数赋值给rpcCoeff；
    {
      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)//如果跳过变换，将残差系数经过伸缩和移位后赋值给m_plTempCoeff；
      {
        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 DEBUG_TRANSFORM_AND_QUANTISE
      std::cout << g_debugCounter << ": " << uiWidth << "x" << uiHeight << " channel " << compID << " TU between transform and quantiser\n";
      printBlock(m_plTempCoeff, uiWidth, uiHeight, uiWidth);
#endif
#if VCEG_AZ05_ROT_TR
#if JVET_C0024_QTBT
  Char ucROTIdx = pcCU->getROTIdx(toChannelType(compID), uiAbsPartIdx) ;
  if (ucROTIdx && uiWidth>=4 && uiHeight>=4)
#else
  if (pcCU->getROTIdx(uiAbsPartIdx) )
#endif
  {           
            static Int ROT_MATRIX[16];
      Int iSubGroupXMax = Clip3 (1,16,(Int)( (uiWidth>>2)));
      Int iSubGroupYMax = Clip3 (1,16,(Int)( (uiHeight>>2)));

      Int iOffSetX = 0;
      Int iOffSetY = 0;
      Int y = 0;
      Int* piCoeffTemp = m_plTempCoeff;
      Int* piROTTemp = ROT_MATRIX;
      Int iString2CopySize = 4*sizeof(Int);
    for (Int iSubGroupX = 0; iSubGroupX<iSubGroupXMax; iSubGroupX++)
      for (Int iSubGroupY = 0; iSubGroupY<iSubGroupYMax; iSubGroupY++)
      {
        iOffSetX = 4*iSubGroupX;
        iOffSetY = 4*iSubGroupY*uiWidth;
          piROTTemp = ROT_MATRIX;
          piCoeffTemp = m_plTempCoeff+iOffSetX+iOffSetY;
          for(  y = 0; y < 4; y++ )
           {  
             ::memcpy(piROTTemp, piCoeffTemp, iString2CopySize); 
                       piROTTemp +=4;
             piCoeffTemp +=uiWidth;
            }
#if JVET_C0024_QTBT
           RotTransform4I( ROT_MATRIX, ucROTIdx-1 );
#else
           RotTransform4I( ROT_MATRIX, pcCU->getROTIdx(uiAbsPartIdx)-1 );
#endif
          piROTTemp = ROT_MATRIX;
          piCoeffTemp = m_plTempCoeff+iOffSetX+iOffSetY;
          for(  y = 0; y < 4; y++ )
          {    
             ::memcpy(piCoeffTemp,piROTTemp, iString2CopySize);
                       piROTTemp +=4;
             piCoeffTemp +=uiWidth;
          }
             }
  }
#elif COM16_C1044_NSST
#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且宽和高都大于等于4且不是TS的前提下才做二次变换；
#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;//宽和高都大于4，则等于3，否则等于2
        const  Int iSbSize       = (uiWidth > 4 && uiHeight > 4) ? 8 : 4;//宽和高都大于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
#else
#if JVET_C0024_QTBT
        const UInt *scan = (log2BlockWidth==3 && log2BlockHeight==3) ? g_auiCoefScanFirstCG8x8[uiScanIdx] : g_scanOrder[ SCAN_GROUPED_4x4 ][ uiScanIdx ][ log2BlockWidth    ][ log2BlockHeight    ];
#else
        const UInt *scan = uiLog2BlockSize==3 ? g_auiCoefScanFirstCG8x8[uiScanIdx] : g_scanOrder[ SCAN_GROUPED_4x4 ][ uiScanIdx ][ log2BlockWidth    ][ log2BlockHeight    ];
#endif
#endif
#else
#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
#else
        const UInt *scan = g_scanOrder[ SCAN_GROUPED_4x4 ][ uiScanIdx ][ log2BlockWidth    ][ log2BlockHeight    ];
#endif
#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
#else
          if( uiIntraMode == DM_CHROMA_IDX )
          {
#if JVET_C0024_QTBT
            if( pcCU->getSlice()->isIntra() )
            {
              uiIntraMode = pcCU->getPic()->getCtu(pcCU->getCtuRsAddr())->getIntraDir(CHANNEL_TYPE_LUMA, pcCU->getZorderIdxInCtu()+uiAbsPartIdx);
            }
            else
            {
#endif
            uiIntraMode = pcCU->getIntraDir( CHANNEL_TYPE_LUMA, uiAbsPartIdx );
#if JVET_C0024_QTBT
            }
#endif
          }
#if COM16_C806_LMCHROMA
          else if( uiIntraMode == LM_CHROMA_IDX )
          {
            uiIntraMode = PLANAR_IDX;
          }
#endif


#if JVET_E0077_ENHANCED_LM
          if (IsLMMode(uiIntraMode))
          {
              uiIntraMode = PLANAR_IDX;
          }
#endif

#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 )
                  {//[0][1][2][3]是第一行，[0][4][8][12]是第一列
                    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
              }
#else
              FwdNsst4x4( NSST_MATRIX, g_NsstLut[uiIntraMode], ucNsstIdx-1 );
#endif
#else
#if JVET_D0120_NSST_IMPROV
              if ( iSbSize>4 )
              {
                FwdNsst8x8( NSST_MATRIX, g_NsstLut[uiIntraMode], pcCU->getROTIdx(uiAbsPartIdx)-1 );
              }
              else 
              {
                FwdNsst4x4( NSST_MATRIX, g_NsstLut[uiIntraMode], pcCU->getROTIdx(uiAbsPartIdx)-1 );
              }
#else
              FwdNsst4x4( NSST_MATRIX, g_NsstLut[uiIntraMode], pcCU->getROTIdx(uiAbsPartIdx)-1 );
#endif
#endif

              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);//设置cbf,如果uiAbsSum大于0，则为1，否则为0
#else
  pcCU->setCbfPartRange((((uiAbsSum > 0) ? 1 : 0) << uiOrgTrDepth), compID, uiAbsPartIdx, rTu.GetAbsPartIdxNumParts(compID));
#endif
}
Void TComTrQuant::xT( const Int channelBitDepth, Bool useDST, Pel* piBlkResi, UInt uiStride, TCoeff* psCoeff, Int iWidth, Int iHeight, const Int maxLog2TrDynamicRange 
#if COM16_C806_EMT
                     , UChar ucMode
                     , UChar ucTrIdx
#endif
#if VCEG_AZ08_KLT_COMMON
                     , Bool useKLT
#endif
                     )
{
#if MATRIX_MULT
  if( iWidth == iHeight)
  {
#if COM16_C806_EMT
    if( ucTrIdx!=DCT2_HEVC )
    {
      xTr_EMT(channelBitDepth, piBlkResi, psCoeff, uiStride, (UInt)iWidth, useDST, maxLog2TrDynamicRange, ucMode, ucTrIdx );
    }
    else
#endif
    xTr(channelBitDepth, piBlkResi, psCoeff, uiStride, (UInt)iWidth, useDST, maxLog2TrDynamicRange);
    return;
  }
#endif

  TCoeff block[ MAX_TU_SIZE * MAX_TU_SIZE ];
  TCoeff coeff[ MAX_TU_SIZE * MAX_TU_SIZE ];

  for (Int y = 0; y < iHeight; y++)
  {
    for (Int x = 0; x < iWidth; x++)
    {
      block[(y * iWidth) + x] = piBlkResi[(y * uiStride) + x];//先把残差数据赋值给临时数组block
    }
  }
#if COM16_C806_EMT
#if VCEG_AZ08_KLT_COMMON
  if( ucTrIdx!=DCT2_HEVC && useKLT == false)//不是DCT2_HEVC且不使用KLT时进行EMT
#else
  if( ucTrIdx!=DCT2_HEVC )
#endif
  {
    xTrMxN_EMT(channelBitDepth, block, coeff, iWidth, iHeight, useDST, maxLog2TrDynamicRange, ucMode, ucTrIdx );
  }
  else// ucTrIdx==DCT2_HEVC || useKLT==true
#endif

#if VCEG_AZ08_KLT_COMMON
  xTrMxN( channelBitDepth, block, coeff, iWidth, iHeight, useDST, maxLog2TrDynamicRange, useKLT);
#else
  xTrMxN( channelBitDepth, block, coeff, iWidth, iHeight, useDST, maxLog2TrDynamicRange );
#endif
  memcpy(psCoeff, coeff, (iWidth * iHeight * sizeof(TCoeff)));//把变换后的系数赋值给psCoeff
}
Void TComTrQuant::xQuant(       TComTU       &rTu,
                                TCoeff      * pSrc,
                                TCoeff      * pDes,
#if ADAPTIVE_QP_SELECTION
                                TCoeff      *pArlDes,
#endif
                                TCoeff       &uiAbsSum,
                          const ComponentID   compID,
                          const QpParam      &cQP 
                          )
{
  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 Int channelBitDepth = pcCU->getSlice()->getSPS()->getBitDepth(toChannelType(compID));

  TCoeff* piCoef    = pSrc;
  TCoeff* piQCoef   = pDes;
#if ADAPTIVE_QP_SELECTION
  TCoeff* piArlCCoef = pArlDes;
#endif

  const Bool useTransformSkip      = pcCU->getTransformSkip(uiAbsPartIdx, compID);
  const Int  maxLog2TrDynamicRange = pcCU->getSlice()->getSPS()->getMaxLog2TrDynamicRange(toChannelType(compID));

  Bool useRDOQ = useTransformSkip ? m_useRDOQTS : m_useRDOQ;//使用率失真优化量化
#if JVET_C0024_QTBT
  if (uiWidth<4 || uiHeight<4)//宽或高小于4，则不使用率失真优化量化
  {
    useRDOQ = false;
  }
#endif
  if ( useRDOQ && (isLuma(compID) || RDOQ_CHROMA) )
  {
#if T0196_SELECTIVE_RDOQ
    if ( !m_useSelectiveRDOQ || xNeedRDOQ( rTu, piCoef, compID, cQP ) )
    {
#endif
#if ADAPTIVE_QP_SELECTION
      xRateDistOptQuant( rTu, piCoef, pDes, pArlDes, uiAbsSum, compID, cQP );//率失真优化量化;
#else
      xRateDistOptQuant( rTu, piCoef, pDes, uiAbsSum, compID, cQP );
#endif
#if T0196_SELECTIVE_RDOQ
    }
    else//否则直接将量化后系数设置为0
    {
      memset( pDes, 0, sizeof( TCoeff ) * uiWidth *uiHeight );
      uiAbsSum = 0;
    }
#endif
  }
  else//不使用RDOQ或者不是亮度分量
  {
    TUEntropyCodingParameters codingParameters;
    getTUEntropyCodingParameters(codingParameters, rTu, compID);

    const TCoeff entropyCodingMinimum = -(1 << maxLog2TrDynamicRange);//熵编码的最小值，-2^15
    const TCoeff entropyCodingMaximum =  (1 << maxLog2TrDynamicRange) - 1;//熵编码的最大值，2^15

    TCoeff deltaU[MAX_TU_SIZE * MAX_TU_SIZE];

    const UInt uiLog2TrSize = rTu.GetEquivalentLog2TrSize(compID);  

    Int scalingListType = getScalingListType(pcCU->getPredictionMode(uiAbsPartIdx), compID);
    assert(scalingListType < SCALING_LIST_NUM);
#if JVET_C0024_QTBT
    const UInt uiLog2TrWidth = g_aucConvertToBit[uiWidth] + MIN_CU_LOG2;
    const UInt uiLog2TrHeight = g_aucConvertToBit[uiHeight] + MIN_CU_LOG2;
    Int *piQuantCoeff = getQuantCoeff(scalingListType, cQP.rem, uiLog2TrWidth-1, uiLog2TrHeight-1);
#else
    Int *piQuantCoeff = getQuantCoeff(scalingListType, cQP.rem, uiLog2TrSize-2);
#endif
	//指示是否使用加权量化矩阵
    const Bool enableScalingLists             = getUseScalingList(uiWidth, uiHeight, (pcCU->getTransformSkip(uiAbsPartIdx, compID) != 0));
    const Int  defaultQuantisationCoefficient = g_quantScales[cQP.rem];

    /* for 422 chroma blocks, the effective scaling applied during transformation is not a power of 2, hence it cannot be
     * implemented as a bit-shift (the quantised result will be sqrt(2) * larger than required). Alternatively, adjust the
     * uiLog2TrSize applied in iTransformShift, such that the result is 1/sqrt(2) the required result (i.e. smaller)
     * Then a QP+3 (sqrt(2)) or QP-3 (1/sqrt(2)) method could be used to get the required result
     */

    // Represents scaling through forward transform
    Int iTransformShift = getTransformShift(channelBitDepth, uiLog2TrSize, maxLog2TrDynamicRange);
    if (useTransformSkip && pcCU->getSlice()->getSPS()->getSpsRangeExtension().getExtendedPrecisionProcessingFlag())
    {
      iTransformShift = std::max<Int>(0, iTransformShift);
    }

#if JVET_C0024_QTBT
  Int iWHScale = 1;
  if ((g_aucConvertToBit[ uiWidth ] + g_aucConvertToBit[ uiHeight ] + (MIN_CU_LOG2<<1))%2 !=0)
  {
    iTransformShift += 7;
    iWHScale = 181;
  }
#endif

    const Int iQBits = QUANT_SHIFT + cQP.per + iTransformShift;
    // QBits will be OK for any internal bit depth as the reduction in transform shift is balanced by an increase in Qp_per due to QpBDOffset

#if ADAPTIVE_QP_SELECTION
    Int iQBitsC = MAX_INT;
    Int iAddC   = MAX_INT;

    if (m_bUseAdaptQpSelect)
    {
      iQBitsC = iQBits - ARL_C_PRECISION;
      iAddC   = 1 << (iQBitsC-1);
    }
#endif

    const Int64 iAdd   = (Int64)(pcCU->getSlice()->getSliceType()==I_SLICE ? 171 : 85) << ((Int64)iQBits-9);
    const Int qBits8 = iQBits - 8;

    for( Int uiBlockPos = 0; uiBlockPos < uiWidth*uiHeight; uiBlockPos++ )//遍历该CU的每个变换后系数
    {
      const TCoeff iLevel   = piCoef[uiBlockPos];//系数值
      const TCoeff iSign    = (iLevel < 0 ? -1: 1);//该系数的符号
	  //量化，enableScalingLists等于true则使用加权量化矩阵，否则使用默认的量化系数
      const Int64  tmpLevel = (Int64)abs(iLevel) * (enableScalingLists ? piQuantCoeff[uiBlockPos] : defaultQuantisationCoefficient);

#if ADAPTIVE_QP_SELECTION
      if( m_bUseAdaptQpSelect )
      {
#if JVET_C0024_QTBT
      piArlCCoef[uiBlockPos] = (TCoeff)((tmpLevel * iWHScale + iAddC ) >> iQBitsC);
#else
        piArlCCoef[uiBlockPos] = (TCoeff)((tmpLevel + iAddC ) >> iQBitsC);
#endif
      }
#endif

#if JVET_C0024_QTBT
      const TCoeff quantisedMagnitude = TCoeff((tmpLevel * iWHScale + iAdd ) >> iQBits);//量化后的幅值
    deltaU[uiBlockPos] = (TCoeff)((tmpLevel * iWHScale - ((Int64)quantisedMagnitude<<iQBits) )>> qBits8);
#else
      const TCoeff quantisedMagnitude = TCoeff((tmpLevel + iAdd ) >> iQBits);
      deltaU[uiBlockPos] = (TCoeff)((tmpLevel - (quantisedMagnitude<<iQBits) )>> qBits8);
#endif

      uiAbsSum += quantisedMagnitude;
      const TCoeff quantisedCoefficient = quantisedMagnitude * iSign;//量化系数等于量化幅值乘以符号

      piQCoef[uiBlockPos] = Clip3<TCoeff>( entropyCodingMinimum, entropyCodingMaximum, quantisedCoefficient );
    } // for n

#if JVET_C0024_QTBT
    if( pcCU->getSlice()->getPPS()->getSignHideFlag() && uiWidth>=4 && uiHeight>=4)//如果宽和高大于等于4且可以使用符号比特隐藏技术
#else
    if( pcCU->getSlice()->getPPS()->getSignHideFlag() )
#endif
    {
      if(uiAbsSum >= 2) //this prevents TUs with only one coefficient of value 1 from being tested
      {
        signBitHidingHDQ( piQCoef, piCoef, deltaU, codingParameters, maxLog2TrDynamicRange ) ;
      }
    }
  } //if RDOQ
  //return;
}



小小柴
关注
专栏目录
【Codecs系列】H.266/VVC视频编码标准(九)：变换与量化
CSDN明星博主，认证博客专家，视频、Matlab领域优质创作者。
10-13 1035
1.1. 大尺寸块变换 VVC中支持大尺寸块变换（64x64），主要用于大分辨率视频，比如1080p和4K。对于变换块尺寸等于64的情况下高频变换系数都为0。 VVC中支持的变换尺寸： 4x4 ~ 64x64 1.2. 多变换核选择MTS 除了HEVC中采用的DCT-II变换核，VVC中采用了多变换核选择MTS方案用于帧间和帧内编码块的残差编码。采用的多变换核有：DCT8、DST7。 MTS句法在SPS和CU层中表示，只用于亮度残差，应用于宽高小于等于64的CU，通过CU级别的flag控制是否使用。当CU级
【Codecs系列】H.266/VVC视频编码标准(四)：编码框架及各模块新技术一览
CSDN明星博主，认证博客专家，视频、Matlab领域优质创作者。
09-22 1496
DATE: 2020.9.22 文章目录1、编码框架2、编码各模块简要分析2.1 块划分结构2.2 帧内预测2.3 帧间预测2.4 变换2.5 量化2.6 熵编码2.7 环路滤波3、VVC关键技术分析 1、编码框架 2、编码各模块简要分析 2.1 块划分结构 MTT 2.2 帧内预测 2.3 帧间预测 2.4 变换 （1）更灵活的变换尺寸； （2）舍弃高频变换系数； （3）多变换核选择MTS。 2.5 量化 2.6 熵编码 2.7 环路滤波 3、VVC关键技术分析 参考自： https://zhuan
新一代视频编码定名VVC（Versatile Video Coding）
慢慢积累
05-07 9498
https://news.itu.int/versatile-video-coding-project-starts-strongly/JVET于2018年4月10日美国圣地亚哥会议上，为新一代视频编码标准定名为Versatile Video Coding，主要目标是改进现有HEVC，提供更高的压缩性能，同时会针对新兴应用（360°全景视频和HDR）进行优化。VVC预计在2020年之前完成标准化，目
VVC视频编码笔记
qq_42691604的博客
10-13 1128
在VVC中划分模式一共有六种，不划分（NS）、四叉树划分（QT）、二叉树水平划分（BTH）、二叉树垂直划分（BTV）、三叉树水平划分（TTH）和三叉树垂直划分（TTV）。
H.266/VVC标准文本
Dillon2015的博客
10-24 3018
H.266/VVC今年（2020年）7月份正式定稿。同等画质下比H.265/HEVC将节省近50%传输流量，清晰度越高，码率节省越多。H.266由MPEG和ITU联合开发，全球范围内包括高通、HHI、三星、索尼、英特尔、诺基亚、爱立信、华为、腾讯、阿里、字节跳动、快手等企业均有参与其中。H.266/VVC的编解码软件相继出炉，硬件芯片也在设计当中相信很快就会面世。 H.266/VVC标准的文本也于2020-09-09在ITU官网发布，可以到https://www.itu.int/rec/T-REC-H.2
VVC/JEM代码学习13 : SAOProcess
小小柴的博客
03-29 1473
在compressSlice和encodeSlice之间，还有两个主要的处理函数，一个是SAOProcess，一个是ALFProcess(ALF是JEM中新加的)；也就是说，当前帧完成重构后要对重构图像进行样点自适应补偿和自适应环路滤波，最后才进行真正的熵编码。        样点自适应补偿的原理是由于量化导致高频信息的丢失从而在解码图像上产生振铃效应，为此，样点自适应补偿技术从像素域入手，对重构...
VVC/JEM代码学习20：xCheckRDCostIntra
小小柴的博客
04-01 836
  在执行完所有的帧间模式的预测后，才执行帧内模式预测。Void TEncCu::xCheckRDCostIntra( TComDataCU *&amp;rpcBestCU, TComDataCU *&amp;rpcTempCU, Double &amp;cos...
VVC/JEM代码学习9：解码框架解析
小小柴的博客
01-21 1291
       只简单写了几个最重要的几个函数，调用层次关系为1--&gt;2--&gt;3--&gt;4--&gt;5--&gt;6--&gt;7--&gt;8--&gt;9--&gt;10--&gt;11，其中最重要的解码函数是xDecompressCU，在此函数完成图像的解码。1.mian（） { cTAppDecTop.decode(); } 2.Void TAppDe...
VVC/JEM代码学习6：xCompressCU（）
小小柴的博客
01-17 2506
      xCompressCU是一个递归函数，对于每一个CU，该函数都会被调用，主要是计算当前CU编码之后代价，然后再计算当前CU的每一个子CU编码后的代价，和当前CU的编码代价相比较，用来决定是否对当前CU进行分割。这个函数太复杂啦，继续慢慢学习吧。Void TEncCu::xCompressCU( TComDataCU*&amp; rpcBestCU, TComDataCU*&amp; r...
VVC/JEM代码学习1：estIntraPredChromaQT函数
小小柴的博客
01-15 783
       现在好像关于JEM的博客还很少，正好自己学习JEM，就把自己学习到的一点东西记录下来。省的学了就忘，先给自己定个目标，一天至少一篇吧。今天学习了色度帧内预测，先记录一下。estIntraPredChromaQT函数的主要功能是进行色度分量的帧内预测，在11种备选的预测模式中根据RD cost选择cost最小的一种模式作为最优预测模式。11种备选模式中，前6种是属于CCLM预测，用重建...
VVC反变换编码
01-18
包括测试代码、核心函数及测试数据，还有PPT简介，帮助你更好地了解VVC反变换编码的核心思想。
【深度解析H.266/VVC编码协议-环路滤波】
最新发布
九天之遥的博客
07-22 1028
对于SbTMVP和仿射预测子块，类似于HEVC中PU中的逻辑，在8x8网格上应用去块滤波器，同时考虑相邻预测子块的运动矢量和参考图片之间的差异。内部预测子块边界来自变换块边界的4个样本在每侧最多滤波1个样本，内部预测子块边界远离变换块边界的8个样本在边界的每侧最多滤波2个样本，并且其他内部预测子块边界在边界的每侧最多滤波3个样本。目前主流的视频编码标准都是基于分块的混合编码机制，其处理过程是针对每个块单独进行处理的，因此由于编码模式的差异以及量化误差的原因，会导致相邻块重建像素不连续的现象。
VVC多用途视频编码标准综述与应用1
edogofhe的博客
01-24 3137
1. VVC的进步之处 1.1 编码效率 1.2 新增工具
VVC系列（二）编码结构和块划分准则
weixin_43721070的博客
10-01 1210
介绍了VVC的编码结构和四叉树划分准则
VVC变换编码
qq_40124902的博客
07-07 1871
VVC变换编码小结
【VVC学习记录—00】VVC编码框架
Ronater的博客
03-26 2528
了解VVC编码框架的重要性毋庸置疑，参考了各位前辈的博客，作了流程图，为了加深印象。本流程图基于VTM-1.1，标准还在制定过程中，如果后续代码有更新，流程图也会尽快更新。 图1 VVC编码流程图 ...
新一代H.266 VVC视频编码标准正式发布
aflyeaglenku的博客(QQ1010316426）
07-13 1568
新一代H.266 VCC视频编码标准正式发布 德国弗劳恩霍夫通讯技术研究所(Fraunhofer HHI)正式宣布了新一代运动图像专家组MPEG)视频标准——它就是简称 H.266 的通用视频编码(VVC)。 过去三年，包括苹果、爱立信、英特尔、华为、微软、高通、索尼等在内的行业合作伙伴，一直在努力推动这项新技术的发展。 与简称 H.265 的高效视频编码(HEVC)前身一样，新标准有望将视频文件的比特率和大小降低 50% 左右，同时不会在视觉保真度上有明显的差异。支持 VVC 编解码功能的终端软件，亦有
【视频编码\VVC】变换编码基础知识及标准设计相关参数
weixin_43799497的博客
02-05 1594
DCT形式与输入信号无关并且存在快速实现算法，并且性能接近K-L变换。H.264第一次使用了整数DCTH.265沿用了整数DCT，进行了不同尺寸的变换形式，还引入了离散正弦变换H.266同时采用了DCT和DST，并且采用了多种基函数的变换形式，拓展了变换的尺寸（可分为8种类型，但是DCT-2因其较低的计算复杂度和相对高的编码效率，一直是核心变换技术）
VVC代码 BMS 帧内预测学习之一：帧内预测函数 xCheckRDCostIntra()
Veronica.。oO的博客
08-14 1023
这些只是自己初步的学习，若有问题烦请更正，共同进步~ void EncCu::xCheckRDCostIntra( CodingStructure *&amp;amp;amp;amp;amp;amp;amp;amp;tempCS, CodingStructure *&amp;amp;amp;amp;amp;amp;amp;amp;bestCS, Partitioner &amp;amp;amp;amp;amp;amp;amp;amp;partitioner, const EncTe
H266/VVC视频编码源代码发布
对于希望学习VVC标准，或者将其集成到产品中的开发者来说，这份源代码是了解和实现VVC编码技术的理想起点。对于学术界来说，源代码的开放性还意味着可以进行深入的研究和创新，推动视频编码技术的发展。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值