HEVC函数解析

最新推荐文章于 2021-01-08 21:52:39 发布
最新推荐文章于 2021-01-08 21:52:39 发布
阅读量1k 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： 视频编码 文章标签： 函数 hevc 编码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xidianliye/article/details/78172912
本文介绍了HEVC编码器的设计原理，包括核心类TEncEntropyIf和TEncEntropy的功能及其实现方式，以及TEncCavlc子类的具体作用。探讨了熵编码在HEVC中的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

getUseAdaptiveQP()函数：在parseConfig()函数中，根据命令读入，由成员变量m_bUseAdaptiveQP保存，默认选项为false

("AdaptiveQP,-aq",  m_bUseAdaptiveQP,   false, "QP adaptation based on a psycho-visual model")

HEVC编码主要包括两个过程：模式选择和写码流，分别对应compress()和encode()。在模式选择时要统计bit信息，写码流时往bin文件中写入码流。这两种情况下都会调用EncEntropyEncoder这个类，而统计bit和写比特操作，是通过类的多态继承来实现的。
首先是两个主要的类：TEncEntropyIf和TEncEntropy，在TEncEntropy.hpp中定义类

/// entropy encoder pure class
class TEncEntropyIf
{
public:
  virtual Void  resetEntropy          (const TComSlice *pSlice)                = 0;
  virtual SliceType determineCabacInitIdx (const TComSlice *pSlice)                = 0;
  virtual Void  setBitstream          ( TComBitIf* p )  = 0;
  virtual Void  resetBits             ()                = 0;
  virtual UInt  getNumberOfWrittenBits()                = 0;

  virtual Void  codeVPS                 ( const TComVPS* pcVPS )                                      = 0;
  virtual Void  codeSPS                 ( const TComSPS* pcSPS )                                      = 0;
  virtual Void  codePPS                 ( const TComPPS* pcPPS )                                      = 0;
  virtual Void  codeSliceHeader         ( TComSlice* pcSlice )                                  = 0;

  virtual Void  codeTilesWPPEntryPoint  ( TComSlice* pSlice )     = 0;
  virtual Void  codeTerminatingBit      ( UInt uilsLast )                                       = 0;
  virtual Void  codeSliceFinish         ()                                                      = 0;
  virtual Void  codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList ) = 0;

public:
  virtual Void codeCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
  virtual Void codeSkipFlag      ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
  virtual Void codeMergeFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
  virtual Void codeMergeIndex    ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
  virtual Void codeSplitFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth ) = 0;

  virtual Void codePartSize      ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth ) = 0;
  virtual Void codePredMode      ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;

  virtual Void codeIPCMInfo      ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;

  virtual Void codeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx ) = 0;
  virtual Void codeQtCbf         ( TComTU &rTu, const ComponentID compID, const Bool lowestLevel ) = 0;
  virtual Void codeQtRootCbf     ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
  virtual Void codeQtCbfZero     ( TComTU &rTu, const ChannelType chType ) = 0;
  virtual Void codeQtRootCbfZero ( ) = 0;
  virtual Void codeIntraDirLumaAng( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool isMultiplePU ) = 0;

  virtual Void codeIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
  virtual Void codeInterDir      ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
  virtual Void codeRefFrmIdx     ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )      = 0;
  virtual Void codeMvd           ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList )      = 0;

  virtual Void codeCrossComponentPrediction( TComTU &rTu, ComponentID compID ) = 0;

  virtual Void codeDeltaQP       ( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
  virtual Void codeChromaQpAdjustment( TComDataCU* pcCU, UInt uiAbsPartIdx ) = 0;
  virtual Void codeCoeffNxN      ( TComTU &rTu, TCoeff* pcCoef, const ComponentID compID ) = 0;
  virtual Void codeTransformSkipFlags ( TComTU &rTu, ComponentID component ) = 0;
  virtual Void codeSAOBlkParam   (SAOBlkParam& saoBlkParam, const BitDepths &bitDepths, Bool* sliceEnabled, Bool leftMergeAvail, Bool aboveMergeAvail, Bool onlyEstMergeInfo = false)    =0;
  virtual Void estBit               (estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, ChannelType chType) = 0;

  virtual Void codeExplicitRdpcmMode ( TComTU &rTu, const ComponentID compID ) = 0;

  virtual ~TEncEntropyIf() {}
};

TEncEntropyIf是一个由纯虚函数定义的抽象类，其成员函数被申明为纯虚函数，具体的函数功能实现留待派生类中定义。

/// entropy encoder class
class TEncEntropy
{
public:
  Void    setEntropyCoder           ( TEncEntropyIf* e );
  Void    setBitstream              ( TComBitIf* p )          { m_pcEntropyCoderIf->setBitstream(p);  }
  Void    resetBits                 ()                        { m_pcEntropyCoderIf->resetBits();      }
  UInt    getNumberOfWrittenBits    ()                        { return m_pcEntropyCoderIf->getNumberOfWrittenBits(); }
  Void    resetEntropy              (const TComSlice *pSlice) { m_pcEntropyCoderIf->resetEntropy(pSlice);  }
  SliceType determineCabacInitIdx   (const TComSlice *pSlice) { return m_pcEntropyCoderIf->determineCabacInitIdx(pSlice); }

  Void    encodeSliceHeader         ( TComSlice* pcSlice );
  Void    encodeTilesWPPEntryPoint( TComSlice* pSlice );
  Void    encodeTerminatingBit      ( UInt uiIsLast );
  Void    encodeSliceFinish         ();
  TEncEntropyIf*      m_pcEntropyCoderIf;

public:
  Void encodeVPS               ( const TComVPS* pcVPS);
  // SPS
  Void encodeSPS               ( const TComSPS* pcSPS );
  Void encodePPS               ( const TComPPS* pcPPS );
  Void encodeSplitFlag         ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, Bool bRD = false );
  Void encodeCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
  Void encodeSkipFlag          ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
  Void encodePUWise       ( TComDataCU* pcCU, UInt uiAbsPartIdx );
  Void encodeInterDirPU   ( TComDataCU* pcSubCU, UInt uiAbsPartIdx  );
  Void encodeRefFrmIdxPU  ( TComDataCU* pcSubCU, UInt uiAbsPartIdx, RefPicList eRefList );
  Void encodeMvdPU        ( TComDataCU* pcSubCU, UInt uiAbsPartIdx, RefPicList eRefList );
  Void encodeMVPIdxPU     ( TComDataCU* pcSubCU, UInt uiAbsPartIdx, RefPicList eRefList );
  Void encodeMergeFlag    ( TComDataCU* pcCU, UInt uiAbsPartIdx );
  Void encodeMergeIndex   ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
  Void encodePredMode          ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
  Void encodePartSize          ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, Bool bRD = false );
  Void encodeIPCMInfo          ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
  Void encodePredInfo          ( TComDataCU* pcCU, UInt uiAbsPartIdx );
  Void encodeIntraDirModeLuma  ( TComDataCU* pcCU, UInt absPartIdx, Bool isMultiplePU = false );

  Void encodeIntraDirModeChroma( TComDataCU* pcCU, UInt uiAbsPartIdx );

  Void encodeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx );
  Void encodeQtCbf             ( TComTU &rTu, const ComponentID compID, const Bool lowestLevel );

  Void encodeQtCbfZero         ( TComTU &rTu, const ChannelType chType );
  Void encodeQtRootCbfZero     ( );
  Void encodeQtRootCbf         ( TComDataCU* pcCU, UInt uiAbsPartIdx );
  Void encodeQP                ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );
  Void encodeChromaQpAdjustment ( TComDataCU* pcCU, UInt uiAbsPartIdx, Bool bRD = false );

  Void encodeCrossComponentPrediction( TComTU &rTu, ComponentID compID );

private:
  Void xEncodeTransform        ( Bool& bCodeDQP, Bool& codeChromaQpAdj, TComTU &rTu );

public:
  Void encodeCoeff             ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, Bool& bCodeDQP, Bool& codeChromaQpAdj );

  Void encodeCoeffNxN         ( TComTU &rTu, TCoeff* pcCoef, const ComponentID compID );

  Void estimateBit             ( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, ChannelType chType );

  Void encodeSAOBlkParam(SAOBlkParam& saoBlkParam, const BitDepths &bitDepths, Bool* sliceEnabled, Bool leftMergeAvail, Bool aboveMergeAvail){m_pcEntropyCoderIf->codeSAOBlkParam(saoBlkParam, bitDepths, sliceEnabled, leftMergeAvail, aboveMergeAvail, false);}

  static Int countNonZeroCoeffs( TCoeff* pcCoef, UInt uiSize );

};// END CLASS DEFINITION TEncEntropy

TEncEntropy是具体类，也是在代码中经常见到的，常作为GOPEncoder,SliceEncoder等类的成员变量：m_pcEntropyCoder
该类包含唯一的 一个成员变量，指向的抽象类的指针：m_pcEntropyCoderIf

TEncEntropyIf*      m_pcEntropyCoderIf;

这个成员变量通过set()函数被赋值

Void TEncEntropy::setEntropyCoder ( TEncEntropyIf* e )
{
  m_pcEntropyCoderIf = e;
}

同时TEncEntropy的其他进行encode函数，也都是由m_pcEntropyCoderIf来实现，例如

Void TEncEntropy::encodeSliceHeader ( TComSlice* pcSlice )
{
  m_pcEntropyCoderIf->codeSliceHeader( pcSlice );
  return;

这样关系一下子就明朗了：首先由派生类的指针或引用作为参数传递给setEntropyCoder函数，这样m_pcEntropyCoderIf成员变代表了不同的派生子类，然后具体的encode任务由不同的派生类来完成，程序对外只有唯一的一个TEncEntropy的函数定义的接口。
那么，继承了TEncEntropyIf的子类有哪些呢？
派生子类TEncCavlc

/// CAVLC encoder class
class TEncCavlc : public SyntaxElementWriter, public TEncEntropyIf
{
public:
  TEncCavlc();
  virtual ~TEncCavlc();

protected:
  Void codeShortTermRefPicSet              ( const TComReferencePictureSet* pcRPS, Bool calledFromSliceHeader, Int idx );
  Bool findMatchingLTRP ( TComSlice* pcSlice, UInt *ltrpsIndex, Int ltrpPOC, Bool usedFlag );

public:

  Void  resetEntropy          (const TComSlice *pSlice);
  SliceType determineCabacInitIdx  (const TComSlice* /*pSlice*/) { assert(0); return I_SLICE; };

  Void  setBitstream          ( TComBitIf* p )  { m_pcBitIf = p;  }
  Void  resetBits             ()                { m_pcBitIf->resetBits(); }
  UInt  getNumberOfWrittenBits()                { return  m_pcBitIf->getNumberOfWrittenBits();  }
  Void  codeVPS                 ( const TComVPS* pcVPS );
  Void  codeVUI                 ( const TComVUI *pcVUI, const TComSPS* pcSPS );
  Void  codeSPS                 ( const TComSPS* pcSPS );
  Void  codePPS                 ( const TComPPS* pcPPS );
  Void  codeSliceHeader         ( TComSlice* pcSlice );
  Void  codePTL                 ( const TComPTL* pcPTL, Bool profilePresentFlag, Int maxNumSubLayersMinus1);
  Void  codeProfileTier         ( const ProfileTierLevel* ptl, const Bool bIsSubLayer );
  Void  codeHrdParameters       ( const TComHRD *hrd, Bool commonInfPresentFlag, UInt maxNumSubLayersMinus1 );
  Void  codeTilesWPPEntryPoint( TComSlice* pSlice );
  Void  codeTerminatingBit      ( UInt uilsLast );
  Void  codeSliceFinish         ();

  Void codeMVPIdx ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList );
  Void codeSAOBlkParam(SAOBlkParam& /*saoBlkParam*/, const BitDepths& /*bitDepths*/, Bool* /*sliceEnabled*/, Bool /*leftMergeAvail*/, Bool /*aboveMergeAvail*/, Bool /*onlyEstMergeInfo*/ = false){printf("only supported in CABAC"); assert(0); exit(-1);}
  Void codeCUTransquantBypassFlag( TComDataCU* pcCU, UInt uiAbsPartIdx );
  Void codeSkipFlag      ( TComDataCU* pcCU, UInt uiAbsPartIdx );
  Void codeMergeFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx );
  Void codeMergeIndex    ( TComDataCU* pcCU, UInt uiAbsPartIdx );

  Void codeAlfCtrlFlag   ( ComponentID /*component*/, UInt /*code*/ ) {printf("Not supported\n"); assert(0);}
  Void codeInterModeFlag( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth, UInt uiEncMode );
  Void codeSplitFlag     ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );

  Void codePartSize      ( TComDataCU* pcCU, UInt uiAbsPartIdx, UInt uiDepth );
  Void codePredMode      ( TComDataCU* pcCU, UInt uiAbsPartIdx );

  Void codeIPCMInfo      ( TComDataCU* pcCU, UInt uiAbsPartIdx );

  Void codeTransformSubdivFlag( UInt uiSymbol, UInt uiCtx );
  Void codeQtCbf         ( TComTU &rTu, const ComponentID compID, const Bool lowestLevel );
  Void codeQtRootCbf     ( TComDataCU* pcCU, UInt uiAbsPartIdx );
  Void codeQtCbfZero     ( TComTU &rTu, const ChannelType chType );
  Void codeQtRootCbfZero ( );
  Void codeIntraDirLumaAng( TComDataCU* pcCU, UInt absPartIdx, Bool isMultiple);
  Void codeIntraDirChroma( TComDataCU* pcCU, UInt uiAbsPartIdx );
  Void codeInterDir      ( TComDataCU* pcCU, UInt uiAbsPartIdx );
  Void codeRefFrmIdx     ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList );
  Void codeMvd           ( TComDataCU* pcCU, UInt uiAbsPartIdx, RefPicList eRefList );

  Void codeCrossComponentPrediction( TComTU &rTu, ComponentID compID );

  Void codeDeltaQP       ( TComDataCU* pcCU, UInt uiAbsPartIdx );
  Void codeChromaQpAdjustment( TComDataCU* pcCU, UInt uiAbsPartIdx );

  Void codeCoeffNxN      ( TComTU &rTu, TCoeff* pcCoef, const ComponentID compID );
  Void codeTransformSkipFlags ( TComTU &rTu, ComponentID component );

  Void estBit            ( estBitsSbacStruct* pcEstBitsSbac, Int width, Int height, ChannelType chType );

  Void xCodePredWeightTable          ( TComSlice* pcSlice );

  Void codeScalingList  ( const TComScalingList &scalingList );
  Void xCodeScalingList ( const TComScalingList* scalingList, UInt sizeId, UInt listId);

  Void codeExplicitRdpcmMode( TComTU &rTu, const ComponentID compID );
};

TEncCavlc是写码流的子类，同时还多继承了父类syntaxElementWritter。TEncCavlc执行code()操作的基本单元，都是调用父类syntaxElementWriter的下面几个函数

#define WRITE_CODE( value, length, name)     xWriteCode ( value, length )
#define WRITE_UVLC( value,         name)     xWriteUvlc ( value )
#define WRITE_SVLC( value,         name)     xWriteSvlc ( value )
#define WRITE_FLAG( value,         name)     xWriteFlag ( value )
class SyntaxElementWriter
{
protected:
  TComBitIf*    m_pcBitIf;

  SyntaxElementWriter()
  :m_pcBitIf(NULL)
  {};
  virtual ~SyntaxElementWriter() {};

  Void  setBitstream          ( TComBitIf* p )  { m_pcBitIf = p;  }

  Void  xWriteCode            ( UInt uiCode, UInt uiLength );
  Void  xWriteUvlc            ( UInt uiCode );
  Void  xWriteSvlc            ( Int  iCode   );
  Void  xWriteFlag            ( UInt uiCode );
#if ENC_DEC_TRACE
  Void  xWriteCodeTr          ( UInt value, UInt  length, const TChar *pSymbolName);
  Void  xWriteUvlcTr          ( UInt value,               const TChar *pSymbolName);
  Void  xWriteSvlcTr          ( Int  value,               const TChar *pSymbolName);
  Void  xWriteFlagTr          ( UInt value,               const TChar *pSymbolName);
#endif
  Void xWriteRbspTrailingBits();

  UInt  xConvertToUInt        ( Int iValue ) {  return ( iValue <= 0) ? -iValue<<1 : (iValue<<1)-1; }
};
Void SyntaxElementWriter::xWriteCode     ( UInt uiCode, UInt uiLength )
{
  assert ( uiLength > 0 );
  m_pcBitIf->write( uiCode, uiLength );
}
关于HM配置文件的TEncCfg类
小熊的专栏
01-07 2793
关于 class TEncCfg { protected: //==== File I/O ======== Int m_iFrameRate;//帧率 Int m_FrameSkip;//跳帧 Int m_iSourceWidth;//宽度 Int m_iSourceHeight;//高度 Int m_conf
compressCtu函数代码跟踪
weixin_42394155的博客
10-18 269
Slice再上篇对付了一下，好嘛，这不得把CTU也安排一下，这么短的代码不解读也罢！只跟踪！！！ Void TEncCu::compressCtu( TComDataCU* pCtu ) { // initialize CU data m_ppcBestCU[0]->initCtu( pCtu->getPic(), pCtu->getCtuRsAddr() ); m_ppcTempCU[0]->initCtu( pCtu->getPic(), pCtu->
HM编码器代码阅读(7)——整个编码流程以及相关的函数
NB_vol_1的专栏
04-13 7474
来自网上的文档，但是最初来源不知道是哪，谢谢这个作者！ 整个流程可以从compressGOP函数开始着手： 1、compressGOP对一整个图像组（GOP）进行编码，主要是遍历GOP中每一帧，对每一帧进行单独编码 2、每一帧又会被划分成若干slice（HM15中，每一帧对应一个slice），因此对每一帧的处理就转换成对每一片的处理。 3、每一个slice都会调用com
自适应QP(Adaptive QP)
热门推荐
Dillon2015的博客
04-03 5万+
Adaptive QP Adaptive QP是为每个CU自适应的选择QP以提升编码质量。由配置参数AdaptiveQP指定是否开启该功能。默认不开启。 ("AdaptiveQP,-aq", m_bUseAdaptiveQP,false, "QP adaptation based on a psycho-visual model") 其QP计算原则是：对于平坦块选择较小的QP，对于活动...
HEVC代码追踪（八。三）:encodeCoeff
成长Bar的博客专栏
11-30 2210
// texture /** encode coefficients * \param pcCU * \param uiAbsPartIdx * \param uiDepth * \param uiWidth * \param uiHeight */ Void TEncEntropy::encodeCoeff( TComDataCU* pcCU, UInt uiAbsPartIdx,
HEVC函数入门（9）——tile相关
不是他人太努力，只是自己努力不够罢了
06-26 2116
前面八篇博客主要整理自殷汶杰大神的博客，主要是为了了解函数的作用及其调用关系，下面呢，为了实现我想要的将图像tile的目标，有必要去找和tile有关的资料
数字图像处理课程项目：DCT变换与H.265/HEVC编码解析
在H.265/HEVC的编码实现中，会用到HM（HEVC Reference Software）这样的参考软件，它提供了标准的实现框架，供研究者和开发者进行算法测试和应用开发。 在Windows平台上，可以使用SVN（Subversion）版本控制系统来...
HEVC函数入门（1）——HM编码器的基本结构
不是他人太努力，只是自己努力不够罢了
06-18 1990
首先说明这篇主要是记录用（意思是里面很多是我自己的理解，我也是刚入门的新手，肯定有许多不正确的地方，还请轻喷），使用的是HM 16.3 VS2015 当然如果有新手不太懂的话也可以看看。 本文主要参照http://blog.youkuaiyun.com/shaqoneal/article/details/36398707int main(int argc, char* argv[]) { TAppEncT
HEVC：函数xEstimateInterResidualQT（）注释
Moomin的博客
03-21 1548
这个函数主要包括TU单元的变化量化，反变换反量化，熵编码其中transformNxN函数为变化量化主函数其中invtransformNxN函数为反变换反量化主函数/* ** 估计残差的编码代价 ** 主要是进行变换量化以及熵编码，然后选出最优的模式 */ Void TEncSearch::xEstimateInterResidualQT(TComYuv *pcResi, Dou...
HEVC码率控制解析：标准、技术与代码分析
此外，文章还可能深入到HM10参考软件的源代码层面，详细解析码率控制模块的实现细节，包括计算率失真优化、宏块级别的码率分配函数以及如何在实际编码过程中动态调整码率。通过对这些代码的分析，读者可以理解HEVC...
H.266中帧内预测的亮度预测模式和色度模式的熵编解码
小小柴的博客
04-26 1492
一.帧内预测的亮度模式的熵编码过程 将67种预测模式分为3部分： a.6种MPM模式；        对于使用6 MPMs选择的模式的熵编码，使用一个截断的一元码。前三个bins用上下文进行编码，上下文取决于与当前正在被发送的bin相关的MPM模式。MPM模式可以被分成3类：（a）水平主导的模式，即MPM模式的编号小于或等于对角方向的模式编号（b）垂直主导的模式，即MPM模式的编号大于对角方...
HEVC函数入门（14）——建议先看：整个编码流程以及相关的函数
不是他人太努力，只是自己努力不够罢了
07-30 3339
这篇文章本来要放在前面的，但是我看到的晚，然后发现很有用，就转载一下吧。 转自：http://blog.youkuaiyun.com/nb_vol_1/article/details/51144828该作者也是转载，但是没有找到原地址。在此表示对这篇文章作者的感谢。 整个流程可以从compressGOP函数开始着手： 1、compressGOP对一整个图像组（GOP）进行编码，主要是遍历GOP中每
x265帧内预测模式RDO过程
BigDream123的博客
01-08 2603
x265的帧内预测模式的选择流程如下图所示： compressIntraCU函数进行递归划分CU的操作，对于每一个划分后的CU，调用CheckIntra函数进行帧内预测模式的RDO过程。 CheckIntra主要是调用estIntraPredQT和estIntraPredChromaQT分别选出当前CU的亮度最优预测模式和色度最优预测模式，然后计算编码当前CU所使用的的RD Cost。代码及注释如下： void Search::checkIntra(Mode& intraMode, co
【待写】HEVC的三种编码结构以及对应的在x265中的实现
video coding
07-07 356
CRA
HEVC代码追踪（二）:encode
成长Bar的博客专栏
11-24 1806
// ==================================================================================================================== // Public member functions // ==================================================
【HEVC学习与研究】44、HEVC量化系数的解析——反量化过程
Workshop of Wenjie.Yin
04-08 4861
【同其他模块一样，HEVC标准文档中只实现了反量化过程，量化过程交由编码器实现。这样可使得编码器采用如自适应量化AQ、率失真优化量化RDOQ等更优的量化方法。这里首先简要记录标准文档的实现，然后再在参考代码中寻找对应的实现。具体可参见标准文档8.6.3】 1、输入与输出数据 反量化过程的输入数据主要有： ①(xTbY,yTbY)：当前亮度TB的左上顶点相对于整帧左上顶点的相对位置坐标；
Chroma from Luma 预测方法总结
yue huang的视频编解码专栏
09-09 2069
Glossary 术语 【AV1】 CfL：Chroma from luma 【HM-Rext】 CCP：Cross component predition 【JEM/BMS】 CCLM：Cross-component linear model prediction 背景 技术 代码
x264中Encode_frame函数解析
HEVC_CJL的专栏
12-17 3669
static int Encode_frame( x264_t *h, hnd_t hout, x264_picture_t *pic ) { x264_picture_t pic_out; //!< 待编码帧 x264_nal_t *nal; //!< NAL打包指针 int i_nal, i; //!< NAL包数目 int i_file = 0;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值