HEVC帧内预测函数estIntraPredLumaQT

最新推荐文章于 2021-03-22 15:25:52 发布
最新推荐文章于 2021-03-22 15:25:52 发布
阅读量402 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35752161/article/details/112362852
版权 
Void
TEncSearch::estIntraPredLumaQT(TComDataCU* pcCU,
                               TComYuv*    pcOrgYuv,
                               TComYuv*    pcPredYuv,
                               TComYuv*    pcResiYuv,
                               TComYuv*    pcRecoYuv,
                               Pel         resiLuma[NUMBER_OF_STORED_RESIDUAL_TYPES][MAX_CU_SIZE * MAX_CU_SIZE]
                               DEBUG_STRING_FN_DECLARE(sDebug))
{
  const UInt         uiDepth               = pcCU->getDepth(0);
  //<帧内预测模式，决定CU是否Split
  const UInt         uiInitTrDepth         = pcCU->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1;
  const UInt         uiNumPU               = 1<<(2*uiInitTrDepth);
  const UInt         uiQNumParts           = pcCU->getTotalNumPart() >> 2;
  const UInt         uiWidthBit            = pcCU->getIntraSizeIdx(0);
  const ChromaFormat chFmt                 = pcCU->getPic()->getChromaFormat();
  const UInt         numberValidComponents = getNumberValidComponents(chFmt);
  const TComSPS     &sps                   = *(pcCU->getSlice()->getSPS());
  const TComPPS     &pps                   = *(pcCU->getSlice()->getPPS());
        Distortion   uiOverallDistY        = 0;
        UInt         CandNum;
        Double       CandCostList[ FAST_UDI_MAX_RDMODE_NUM ];
        Pel          resiLumaPU[NUMBER_OF_STORED_RESIDUAL_TYPES][MAX_CU_SIZE * MAX_CU_SIZE];

        Bool    bMaintainResidual[NUMBER_OF_STORED_RESIDUAL_TYPES];
        for (UInt residualTypeIndex = 0; residualTypeIndex < NUMBER_OF_STORED_RESIDUAL_TYPES; residualTypeIndex++)
        {
          bMaintainResidual[residualTypeIndex] = true; //assume true unless specified otherwise
        }

        bMaintainResidual[RESIDUAL_ENCODER_SIDE] = !(m_pcEncCfg->getUseReconBasedCrossCPredictionEstimate());

  // Lambda calculation at equivalent Qp of 4 is recommended because at that Qp, the quantisation divisor is 1.
#if FULL_NBIT
  const Double sqrtLambdaForFirstPass= (m_pcEncCfg->getCostMode()==COST_MIXED_LOSSLESS_LOSSY_CODING && pcCU->getCUTransquantBypass(0)) ?
                sqrt(0.57 * pow(2.0, ((LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP_PRIME - 12) / 3.0)))
              : m_pcRdCost->getSqrtLambda();
#else
  const Double sqrtLambdaForFirstPass= (m_pcEncCfg->getCostMode()==COST_MIXED_LOSSLESS_LOSSY_CODING && pcCU->getCUTransquantBypass(0)) ?
                sqrt(0.57 * pow(2.0, ((LOSSLESS_AND_MIXED_LOSSLESS_RD_COST_TEST_QP_PRIME - 12 - 6 * (sps.getBitDepth(CHANNEL_TYPE_LUMA) - 8)) / 3.0)))
              : m_pcRdCost->getSqrtLambda();
#endif

  //===== set QP and clear Cbf =====
  if ( pps.getUseDQP() == true)
  {
    pcCU->setQPSubParts( pcCU->getQP(0), 0, uiDepth );
  }
  else
  {
    pcCU->setQPSubParts( pcCU->getSlice()->getSliceQp(), 0, uiDepth );
  }

  //===== loop over partitions =====
  TComTURecurse tuRecurseCU(pcCU, 0);
  TComTURecurse tuRecurseWithPU(tuRecurseCU, false, (uiInitTrDepth==0)?TComTU::DONT_SPLIT : TComTU::QUAD_SPLIT);

  do
  {
    const UInt uiPartOffset=tuRecurseWithPU.GetAbsPartIdxTU();
//  for( UInt uiPU = 0, uiPartOffset=0; uiPU < uiNumPU; uiPU++, uiPartOffset += uiQNumParts )
  //{
    //===== init pattern for luma prediction =====
    DEBUG_STRING_NEW(sTemp2)

    //===== determine set of modes to be tested (using prediction signal only) =====
    Int numModesAvailable     = 35; //total number of Intra modes
    UInt uiRdModeList[FAST_UDI_MAX_RDMODE_NUM];
    Int numModesForFullRD = m_pcEncCfg->getFastUDIUseMPMEnabled()?g_aucIntraModeNumFast_UseMPM[ uiWidthBit ] : g_aucIntraModeNumFast_NotUseMPM[ uiWidthBit ];

    // this should always be true
    assert (tuRecurseWithPU.ProcessComponentSection(COMPONENT_Y));
	//<参考像素的处理，包含产生滤波后的参考像素
    initIntraPatternChType( tuRecurseWithPU, COMPONENT_Y, true DEBUG_STRING_PASS_INTO(sTemp2) );

    Bool doFastSearch = (numModesForFullRD != numModesAvailable);
	//<粗估计，快速RD
    if (doFastSearch)
    {
      assert(numModesForFullRD < numModesAvailable);

      for( Int i=0; i < numModesForFullRD; i++ )
      {
        CandCostList[ i ] = MAX_DOUBLE;
      }
      CandNum = 0;

      const TComRectangle &puRect=tuRecurseWithPU.getRect(COMPONENT_Y);
      const UInt uiAbsPartIdx=tuRecurseWithPU.GetAbsPartIdxTU();

      Pel* piOrg         = pcOrgYuv ->getAddr( COMPONENT_Y, uiAbsPartIdx );
      Pel* piPred        = pcPredYuv->getAddr( COMPONENT_Y, uiAbsPartIdx );
      UInt uiStride      = pcPredYuv->getStride( COMPONENT_Y );
      DistParam distParam;
      const Bool bUseHadamard=pcCU->getCUTransquantBypass(0) == 0;
      m_pcRdCost->setDistParam(distParam, sps.getBitDepth(CHANNEL_TYPE_LUMA), piOrg, uiStride, piPred, uiStride, puRect.width, puRect.height, bUseHadamard);
      distParam.bApplyWeight = false;
      for( Int modeIdx = 0; modeIdx < numModesAvailable; modeIdx++ )
      {
        UInt       uiMode = modeIdx;
        Distortion uiSad  = 0;

        const Bool bUseFilter=TComPrediction::filteringIntraReferenceSamples(COMPONENT_Y, uiMode, puRect.width, puRect.height, chFmt, sps.getSpsRangeExtension().getIntraSmoothingDisabledFlag());

        predIntraAng( COMPONENT_Y, uiMode, piOrg, uiStride, piPred, uiStride, tuRecurseWithPU, bUseFilter, TComPrediction::UseDPCMForFirstPassIntraEstimation(tuRecurseWithPU, uiMode) );

        // use hadamard transform here
        uiSad+=distParam.DistFunc(&distParam);

        UInt   iModeBits = 0;

        // NB xModeBitsIntra will not affect the mode for chroma that may have already been pre-estimated.
		//<编码当前帧内预测所需的bits
        iModeBits+=xModeBitsIntra( pcCU, uiMode, uiPartOffset, uiDepth, CHANNEL_TYPE_LUMA );
		//<粗估计的cost：SATD+lamda*预测模式所需bits
        Double cost      = (Double)uiSad + (Double)iModeBits * sqrtLambdaForFirstPass;

#if DEBUG_INTRA_SEARCH_COSTS
        std::cout << "1st pass mode " << uiMode << " SAD = " << uiSad << ", mode bits = " << iModeBits << ", cost = " << cost << "\n";
#endif
		//<更新候选列表
        CandNum += xUpdateCandList( uiMode, cost, numModesForFullRD, uiRdModeList, CandCostList );
      }

      if (m_pcEncCfg->getFastUDIUseMPMEnabled())
      {
        Int uiPreds[NUM_MOST_PROBABLE_MODES] = {-1, -1, -1};

        Int iMode = -1;
		//<利用临近PU构建MPM
        pcCU->getIntraDirPredictor( uiPartOffset, uiPreds, COMPONENT_Y, &iMode );
		
        const Int numCand = ( iMode >= 0 ) ? iMode : Int(NUM_MOST_PROBABLE_MODES);
		//<如果当前候选列表中没有MPM中对应的模式，则加入当前候选列表
        for( Int j=0; j < numCand; j++)
        {
          Bool mostProbableModeIncluded = false;
          Int mostProbableMode = uiPreds[j];

          for( Int i=0; i < numModesForFullRD; i++)
          {
            mostProbableModeIncluded |= (mostProbableMode == uiRdModeList[i]);
          }
          if (!mostProbableModeIncluded)
          {
            uiRdModeList[numModesForFullRD++] = mostProbableMode;
          }
        }
      }
    }//<全RD
    else
    {
      for( Int i=0; i < numModesForFullRD; i++)
      {
        uiRdModeList[i] = i;
      }
    }

    //===== check modes (using r-d costs) =====
#if HHI_RQT_INTRA_SPEEDUP_MOD
    UInt   uiSecondBestMode  = MAX_UINT;
    Double dSecondBestPUCost = MAX_DOUBLE;
#endif
    DEBUG_STRING_NEW(sPU)
    UInt       uiBestPUMode  = 0;
    Distortion uiBestPUDistY = 0;
    Double     dBestPUCost   = MAX_DOUBLE;

#if ENVIRONMENT_VARIABLE_DEBUG_AND_TEST
    UInt max=numModesForFullRD;

    if (DebugOptionList::ForceLumaMode.isSet())
    {
      max=0;  // we are forcing a direction, so don't bother with mode check
    }
    for ( UInt uiMode = 0; uiMode < max; uiMode++)
#else
	//<全RD开始细选
    for( UInt uiMode = 0; uiMode < numModesForFullRD; uiMode++ )
#endif
    {
      // set luma prediction mode
      UInt uiOrgMode = uiRdModeList[uiMode];

      pcCU->setIntraDirSubParts ( CHANNEL_TYPE_LUMA, uiOrgMode, uiPartOffset, uiDepth + uiInitTrDepth );

      DEBUG_STRING_NEW(sMode)
      // set context models
      m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );

      // determine residual for partition
      Distortion uiPUDistY = 0;
      Double     dPUCost   = 0.0;
#if HHI_RQT_INTRA_SPEEDUP
	  //<对TU四叉树递归
      xRecurIntraCodingLumaQT( pcOrgYuv, pcPredYuv, pcResiYuv, resiLumaPU, uiPUDistY, true, dPUCost, tuRecurseWithPU DEBUG_STRING_PASS_INTO(sMode) );
#else
      xRecurIntraCodingLumaQT( pcOrgYuv, pcPredYuv, pcResiYuv, resiLumaPU, uiPUDistY, dPUCost, tuRecurseWithPU DEBUG_STRING_PASS_INTO(sMode) );
#endif

#if DEBUG_INTRA_SEARCH_COSTS
      std::cout << "2nd pass [luma,chroma] mode [" << Int(pcCU->getIntraDir(CHANNEL_TYPE_LUMA, uiPartOffset)) << "," << Int(pcCU->getIntraDir(CHANNEL_TYPE_CHROMA, uiPartOffset)) << "] cost = " << dPUCost << "\n";
#endif

      // check r-d cost
      if( dPUCost < dBestPUCost )
      {
        DEBUG_STRING_SWAP(sPU, sMode)
#if HHI_RQT_INTRA_SPEEDUP_MOD
        uiSecondBestMode  = uiBestPUMode;
        dSecondBestPUCost = dBestPUCost;
#endif
        uiBestPUMode  = uiOrgMode;
        uiBestPUDistY = uiPUDistY;
        dBestPUCost   = dPUCost;

        xSetIntraResultLumaQT( pcRecoYuv, tuRecurseWithPU );

        if (pps.getPpsRangeExtension().getCrossComponentPredictionEnabledFlag())
        {
          const Int xOffset = tuRecurseWithPU.getRect( COMPONENT_Y ).x0;
          const Int yOffset = tuRecurseWithPU.getRect( COMPONENT_Y ).y0;
          for (UInt storedResidualIndex = 0; storedResidualIndex < NUMBER_OF_STORED_RESIDUAL_TYPES; storedResidualIndex++)
          {
            if (bMaintainResidual[storedResidualIndex])
            {
              xStoreCrossComponentPredictionResult(resiLuma[storedResidualIndex], resiLumaPU[storedResidualIndex], tuRecurseWithPU, xOffset, yOffset, MAX_CU_SIZE, MAX_CU_SIZE );
            }
          }
        }

        UInt uiQPartNum = tuRecurseWithPU.GetAbsPartIdxNumParts();

        ::memcpy( m_puhQTTempTrIdx,  pcCU->getTransformIdx()       + uiPartOffset, uiQPartNum * sizeof( UChar ) );
        for (UInt component = 0; component < numberValidComponents; component++)
        {
          const ComponentID compID = ComponentID(component);
          ::memcpy( m_puhQTTempCbf[compID], pcCU->getCbf( compID  ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
          ::memcpy( m_puhQTTempTransformSkipFlag[compID],  pcCU->getTransformSkip(compID)  + uiPartOffset, uiQPartNum * sizeof( UChar ) );
        }
      }
#if HHI_RQT_INTRA_SPEEDUP_MOD
      else if( dPUCost < dSecondBestPUCost )
      {
        uiSecondBestMode  = uiOrgMode;
        dSecondBestPUCost = dPUCost;
      }
#endif
    } // Mode loop

#if HHI_RQT_INTRA_SPEEDUP
#if HHI_RQT_INTRA_SPEEDUP_MOD
    for( UInt ui =0; ui < 2; ++ui )
#endif
    {
#if HHI_RQT_INTRA_SPEEDUP_MOD
      UInt uiOrgMode   = ui ? uiSecondBestMode  : uiBestPUMode;
      if( uiOrgMode == MAX_UINT )
      {
        break;
      }
#else
      UInt uiOrgMode = uiBestPUMode;
#endif

#if ENVIRONMENT_VARIABLE_DEBUG_AND_TEST
      if (DebugOptionList::ForceLumaMode.isSet())
      {
        uiOrgMode = DebugOptionList::ForceLumaMode.getInt();
      }
#endif

      pcCU->setIntraDirSubParts ( CHANNEL_TYPE_LUMA, uiOrgMode, uiPartOffset, uiDepth + uiInitTrDepth );
      DEBUG_STRING_NEW(sModeTree)

      // set context models
      m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );

      // determine residual for partition
      Distortion uiPUDistY = 0;
      Double     dPUCost   = 0.0;

      xRecurIntraCodingLumaQT( pcOrgYuv, pcPredYuv, pcResiYuv, resiLumaPU, uiPUDistY, false, dPUCost, tuRecurseWithPU DEBUG_STRING_PASS_INTO(sModeTree));

      // check r-d cost
      if( dPUCost < dBestPUCost )
      {
        DEBUG_STRING_SWAP(sPU, sModeTree)
        uiBestPUMode  = uiOrgMode;
        uiBestPUDistY = uiPUDistY;
        dBestPUCost   = dPUCost;

        xSetIntraResultLumaQT( pcRecoYuv, tuRecurseWithPU );

        if (pps.getPpsRangeExtension().getCrossComponentPredictionEnabledFlag())
        {
          const Int xOffset = tuRecurseWithPU.getRect( COMPONENT_Y ).x0;
          const Int yOffset = tuRecurseWithPU.getRect( COMPONENT_Y ).y0;
          for (UInt storedResidualIndex = 0; storedResidualIndex < NUMBER_OF_STORED_RESIDUAL_TYPES; storedResidualIndex++)
          {
            if (bMaintainResidual[storedResidualIndex])
            {
              xStoreCrossComponentPredictionResult(resiLuma[storedResidualIndex], resiLumaPU[storedResidualIndex], tuRecurseWithPU, xOffset, yOffset, MAX_CU_SIZE, MAX_CU_SIZE );
            }
          }
        }

        const UInt uiQPartNum = tuRecurseWithPU.GetAbsPartIdxNumParts();
        ::memcpy( m_puhQTTempTrIdx,  pcCU->getTransformIdx()       + uiPartOffset, uiQPartNum * sizeof( UChar ) );

        for (UInt component = 0; component < numberValidComponents; component++)
        {
          const ComponentID compID = ComponentID(component);
          ::memcpy( m_puhQTTempCbf[compID], pcCU->getCbf( compID  ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
          ::memcpy( m_puhQTTempTransformSkipFlag[compID],  pcCU->getTransformSkip(compID)  + uiPartOffset, uiQPartNum * sizeof( UChar ) );
        }
      }
    } // Mode loop
#endif

    DEBUG_STRING_APPEND(sDebug, sPU)

    //--- update overall distortion ---
    uiOverallDistY += uiBestPUDistY;

    //--- update transform index and cbf ---
    const UInt uiQPartNum = tuRecurseWithPU.GetAbsPartIdxNumParts();
    ::memcpy( pcCU->getTransformIdx()       + uiPartOffset, m_puhQTTempTrIdx,  uiQPartNum * sizeof( UChar ) );
    for (UInt component = 0; component < numberValidComponents; component++)
    {
      const ComponentID compID = ComponentID(component);
      ::memcpy( pcCU->getCbf( compID  ) + uiPartOffset, m_puhQTTempCbf[compID], uiQPartNum * sizeof( UChar ) );
      ::memcpy( pcCU->getTransformSkip( compID  ) + uiPartOffset, m_puhQTTempTransformSkipFlag[compID ], uiQPartNum * sizeof( UChar ) );
    }

    //--- set reconstruction for next intra prediction blocks ---
    if( !tuRecurseWithPU.IsLastSection() )
    {
      const TComRectangle &puRect=tuRecurseWithPU.getRect(COMPONENT_Y);
      const UInt  uiCompWidth   = puRect.width;
      const UInt  uiCompHeight  = puRect.height;

      const UInt  uiZOrder      = pcCU->getZorderIdxInCtu() + uiPartOffset;
            Pel*  piDes         = pcCU->getPic()->getPicYuvRec()->getAddr( COMPONENT_Y, pcCU->getCtuRsAddr(), uiZOrder );
      const UInt  uiDesStride   = pcCU->getPic()->getPicYuvRec()->getStride( COMPONENT_Y);
      const Pel*  piSrc         = pcRecoYuv->getAddr( COMPONENT_Y, uiPartOffset );
      const UInt  uiSrcStride   = pcRecoYuv->getStride( COMPONENT_Y);

      for( UInt uiY = 0; uiY < uiCompHeight; uiY++, piSrc += uiSrcStride, piDes += uiDesStride )
      {
        for( UInt uiX = 0; uiX < uiCompWidth; uiX++ )
        {
          piDes[ uiX ] = piSrc[ uiX ];
        }
      }
    }

    //=== update PU data ====
    pcCU->setIntraDirSubParts     ( CHANNEL_TYPE_LUMA, uiBestPUMode, uiPartOffset, uiDepth + uiInitTrDepth );
  } while (tuRecurseWithPU.nextSection(tuRecurseCU));


  if( uiNumPU > 1 )
  { // set Cbf for all blocks
    UInt uiCombCbfY = 0;
    UInt uiCombCbfU = 0;
    UInt uiCombCbfV = 0;
    UInt uiPartIdx  = 0;
    for( UInt uiPart = 0; uiPart < 4; uiPart++, uiPartIdx += uiQNumParts )
    {
      uiCombCbfY |= pcCU->getCbf( uiPartIdx, COMPONENT_Y,  1 );
      uiCombCbfU |= pcCU->getCbf( uiPartIdx, COMPONENT_Cb, 1 );
      uiCombCbfV |= pcCU->getCbf( uiPartIdx, COMPONENT_Cr, 1 );
    }
    for( UInt uiOffs = 0; uiOffs < 4 * uiQNumParts; uiOffs++ )
    {
      pcCU->getCbf( COMPONENT_Y  )[ uiOffs ] |= uiCombCbfY;
      pcCU->getCbf( COMPONENT_Cb )[ uiOffs ] |= uiCombCbfU;
      pcCU->getCbf( COMPONENT_Cr )[ uiOffs ] |= uiCombCbfV;
    }
  }

  //===== reset context models =====
  m_pcRDGoOnSbacCoder->load(m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST]);

  //===== set distortion (rate and r-d costs are determined later) =====
  pcCU->getTotalDistortion() = uiOverallDistY;
}

 

循环是人递归是神
关注
专栏目录
HEVC代码学习42：estIntraPredLumaQT函数
慢慢积累
05-30 4099
在之前的 HEVC代码学习37：帧内预测代码整体学习 中已经提到，estIntraPredLumaQT是亮度帧内预测的入口函数，下面将对该函数进行详细学习。 estIntraPredLumaQT中完成了亮度分量的帧内预测，其主要流程如下： 一、初始化各种参数。 二、为了减少率失真优化次数，HEVC中默认使用帧内快速搜索算法，将分粗选和细选两个阶段进行。如果不使用快速搜索，将对所有帧内预测模式...
estIntraPredLumaQT函数
Villa_7的博客
04-12 1750
Void TEncSearch::estIntraPredLumaQT(TComDataCU* pcCU, TComYuv* pcOrgYuv, TComYuv* pcPredYuv, TComYuv*
H.266代码学习：estIntraPredLumaQT函数
慢慢积累
05-30 1626
之前 HEVC代码学习42：estIntraPredLumaQT函数 对HM中的estIntraPredLumaQT函数进行了学习，下面将对JEM中的该函数进行学习。 estIntraPredLumaQT estIntraPredLumaQT是亮度帧内预测的入口函数，完成了亮度帧内预测最优模式的选择。 JEM与HM主要区别有： 1.JEM中，亮度帧内模式预测模式数由35增加到67种，...
VVC/JEM代码学习2：estIntraPredLumaQT
小小柴的博客
01-15 973
（为个人理解）     此函数的作用是计算亮度分量的预测值，备选预测模式是67种，DC+planar+65种角度预测模式。首先通过getIntraDirPredictor函数得到6 MPMs。然后对HEVC中原始的35种角度模式进行遍历，根据SADT选取N(5)种作为初始候选列表；再根据SADT更新候选列表里的候选模式。再将N个候选模式和前3个MPM模式合并。最后在合并的模式中选取一个RD cos...
VTM3.0代码阅读：estIntraPredLumaQT函数
矛盾统一
12-27 404
estIntraPredLumaQT进行帧内亮度模式的预测，在67种帧内亮度模式中，获取帧内亮度模式的最优模式。 首先进行SATD粗选择，对HEVC中的35种角度模式进行SATD选择； 再分别对SATD所选择的角度模式的左右两种角度模式(即模式号±1)，进行再一次的SATD； 然后进行MRL模式的检测； 再添加亮度的MPM模式； 最后对列表中的帧内亮度模式进行RDO，分别调用xRecurIntra...
【HEVC代码阅读】帧内预测
qq_37200357的博客
11-18 816
HEVC的帧内预测的架构分为三个步骤： ①构建参考像素数组；②生成预测像素；③后处理操作。 HEVC标准将这三个步骤进行了精密设计，以求达到较高的编码效率，同时降低编码和解码端的运算要求。HEVC标准的多种预定义的预测模式构成一个模式集合，可以对包括视频和静态图像中的多种内容进行预测建模的方法。HEVC的角度预测提供了对包含方向性纹理的物体更高的预测精确度，此外平面和DC模式可以高效地表示图像的平...
HEVC函数入门（5）——帧内预测参考数据滤波及总结
不是他人太努力，只是自己努力不够罢了
06-20 1173
这里接着上一篇博客，并且稍微做下总结吧 首先是上篇讲到的滤波 依然是从http://blog.csdn.net/shaqoneal/article/details/39378973参考的 在帧内预测的过程中，获取临近的Prediction Unit的边缘数据作为当前PU的参考数据。数据获取完成后，并不一定会直接使用这些数据进行预测，而可能会先将这些预测数据进行一次滤波操作。帧内参考像素的滤波
HEVC代码学习37：帧内预测代码整体学习
慢慢积累
01-22 3689
最近一直在看变换部分的东西，由于很多变换模式是针对帧内预测模式设计的，来简单学习一下帧内预测流程。通过之前xCompressCU的学习，我们知道了帧内、帧间的入口函数都在xCompressCU中，下面回顾一下xCompressCU函数。xCompressCUxCompressCU主要作用是完成块划分，确定最优预测模式，其流程为： 1.帧间预测xCheckRDCostInter、xCheckRDCo
HEVC函数入门（7）——帧内预测-详细概念和HM16.3实现（下）
不是他人太努力，只是自己努力不够罢了
06-21 3097
首先说明本文引自：http://blog.csdn.net/shaqoneal/article/details/44759561 这里我看的就没有上一篇那么懂了，所以很多地方都只是单纯的复制，另外也有一些个人的理解 （1）亮度帧内预测模式的预测 HEVC对每种PU大小共支持总计33种角度模式，外加上DC和平面模式。由于支持的模式更多，类似于H.264的单一最可能模式在HEVC中效率不高。HEV
VTM1.0代码阅读：estIntraPredLumaQT函数
矛盾统一
12-26 235
estIntraPredLumaQT在67种帧内亮度模式中，获取帧内亮度模式的最优模式。 先对67中模式进行SATD粗选择；之后再加入MPM的帧内模式；最后RDO得到最优的帧内模式。 Void IntraSearch::estIntraPredLumaQT( CodingUnit &cu, Partitioner &partitioner ) { CodingStructure...
VTM10.0代码学习14：estIntraPredLumaQT()
hjhyxq2014的博客
03-22 991
此系列是为了记录自己学习VTM10.0的过程，目前正在看编码端。主要的参考文档有JVET-S2001-vH和JVET-S2002-v1。由于本人水平有限，出现的错误恳请大家指正，欢迎与大家一起交流进步。 上一篇博文提到(VTM10.0代码学习13)帧内模式是分亮度和色度处理的，这篇博文就先讲处理亮度的函数estIntraPredLumaQT()。这个函数会先用化简版的RDcost对帧内的亮度模式进行一个筛选，然后对筛选出来的模式执行完整的RDcost计算，来得到最佳的帧内亮度预测模式。 1. 预备变.
VVC学习之五：VTM帧内预测之亮度预测——estIntraPredLumaQT()详解
Aidoneus_y
05-14 2890
前一章讲解了VTM帧内预测的主要大致框架，接下来主要学习VTM中相关技术的代码实现。首先，是亮度分量进行帧内预测的入口函数estIntraPredLumaQT()，这个函数描述了亮度帧内预测的主要流程，包括参考样本生成，多行预测，RMD， MPM和最后Full RDO最优模式选择、ISP等。其主要流程见下图： 插入图片(estIntraPredLumaQT()流程) 代码具体实现如下（VTM-4....
H.266/VVC代码学习：亮度预测estIntraPredLumaQT函数
BigDream123的博客
02-10 3848
最近研究了VTM7.0中estIntraPredLumaQT函数的大体功能，之前大概看过一点，但是被这繁乱的代码搞自闭了，没有仔细研究过，这次借助H师兄的博客才勉强看懂大部分代码。 estIntraPredLumaQT函数主要是完成亮度分量的预测，并选出亮度预测的最佳模式。 主要流程如下： 一、初始化各种参数； 二、为了减少最终RDcost的次数，降低编码端的复杂度，estIntraPre...
VVC代码学习2：帧内亮度预测函数estIntraPredLumaQT
Everglow_zbz的博客
09-10 1038
一、estIntraPredLumaQT调用结构 xCheckRDCostIntra：帧内预测的入口函数，会调用estIntraPredLumaQT进行亮度的预测，调用estIntraPredChromaQT进行色度的预测。 estIntraPredLumaQT：亮度预测的入口函数，完成亮度的预测，角度模式的选择等操作。 preIntraAng：进行角度预测，获得预测像素值。 xIntraCod...
H.266/VVC代码学习笔记8：VTM5.0中帧内亮度预测函数——estIntraPredLumaQT()函数
Peter_Red_Boy的博客
06-02 3749
今天对VTM5.0中的亮度帧内预测的入口函数estIntraPredLumaQT()进行详细的学习 estIntraPredLumaQT中完成了亮度分量的帧内预测，其主要流程如下： 一、初始化各种参数。 二、为了减少最终RDcost的次数，降低编码端的复杂度，VVC的VTM5.0版本默认使用帧内快速搜索算法，主要经过两轮的SATD的粗选阶段和一轮RDcost的细选阶段 1、第一轮的SATD粗选，首...
VTM-1.1 estIntraPredLumaQT函数阅读
coding_lee的博客
11-12 543
estIntraPredLumaQT函数用作从0-66个intra modes中选出最佳模式（uiBestPUMode） Void IntraSearch::estIntraPredLumaQT( CodingUnit &amp;cu, Partitioner &amp;partitioner ) { CodingStructure &amp;cs = *...
H.266中estIntraPredLumaQT和estIntraChromaQT函数框架
小小柴的博客
03-20 509
VVC学习之五：VTM帧内预测之色度预测——estIntraPredChromaQT()
Aidoneus_y
05-25 1194
文章目录预测过程回顾 预测过程回顾 #include <iostream> #include <algorithm> using namespcce std; int main() { int a = 0 }
VVC代码 BMS 帧内预测学习之二：亮度色度预测函数 estIntraPredLumaQT()及estIntraPredChromaQT()
Veronica.。oO的博客
08-14 1335
亮度预测函数：estIntraPredLumaQT() Void IntraSearch::estIntraPredLumaQT( CodingUnit &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;cu, Partitioner &amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;partitioner ) { CodingStructure
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值