HM编码器代码阅读(9)——片编码器的初始化

最新推荐文章于 2021-12-06 20:09:23 发布
最新推荐文章于 2021-12-06 20:09:23 发布
阅读量3.2k 收藏 12
点赞数 6
分类专栏： HEVC编码器HM源码阅读 文章标签： c++ H.265 hevc 编码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nb_vol_1/article/details/51151645
版权
入口函数：TEncSlice::initEncSlice。
在处理图像组的时候，遍历图像组的每一帧，对每一帧调用 TEncSlice::initEncSlice。主要是设置和计算一些参数，为片的编码做准备。
主要功能包括：
（1）取出当前帧的第一片（HM15中每一帧只被划分成一片）
（2）设置片的SPS（序列参数集）和PPS（图像参数集）
（3）设置片所属的帧；片初始化（TComSlice::initSlice）；设置片的poc
（4）设置片的类型。
（5）根据片的类型和poc等参数，设置当前片是否允许被别人参考
（6）设置量化步长（QP）， λ参数数组
（7）设置片的参考帧数组中可用（或者活跃）的图像的个数
（8）去方块滤波相关标志的设置
（9）设置片的深度，帧和片所属的时域层
（10）设置预测图像缓存和残差图像缓存 
// 片编码器的初始化
Void TEncSlice::initEncSlice( TComPic* pcPic, Int pocLast, Int pocCurr, Int iNumPicRcvd, Int iGOPid, TComSlice*& rpcSlice, TComSPS* pSPS, TComPPS *pPPS, bool isField )
{
	Double dQP;
	Double dLambda;

	// 将rpcSlice设置为图像的第一个条带
	rpcSlice = pcPic->getSlice(0);
	rpcSlice->setSPS( pSPS );
	rpcSlice->setPPS( pPPS );

	// 设置条带的bit数量
	rpcSlice->setSliceBits(0);

	// 设置条带所属的图像
	rpcSlice->setPic( pcPic );

	// 条带初始化
	rpcSlice->initSlice();
    // 图像输出标志
	rpcSlice->setPicOutputFlag( true );

	// 设置条带的poc（picture of counter）
	rpcSlice->setPOC( pocCurr );

	// depth computation based on GOP size
    // 计算深度
	Int depth;
	{
#if FIX_FIELD_DEPTH    
		Int poc = rpcSlice->getPOC();
		if(isField)
		{
			poc = (poc/2)%(m_pcCfg->getGOPSize()/2);
		}
		else
		{
			LOG_DEBUG("m_pcCfg->getGOPSize()=%d",m_pcCfg->getGOPSize());
			poc = poc%m_pcCfg->getGOPSize();   
		}
#else
		Int poc = rpcSlice->getPOC()%m_pcCfg->getGOPSize();
#endif
        // 对于GOP中的第一帧
		if ( poc == 0 )
		{
			depth = 0;
		}
		else
		{
            // 一般说一个GOP的大小都是固定的（即一个GOP通常包含固定数量的帧）
			Int step = m_pcCfg->getGOPSize();
			depth    = 0;
			for( Int i=step>>1; i>=1; i>>=1 )
			{
				for ( Int j=i; j<m_pcCfg->getGOPSize(); j+=step )
				{
					if ( j == poc )
					{
						i=0;
						break;
					}
				}
				step >>= 1;
				depth++;
			}
		}
#if FIX_FIELD_DEPTH  
#if HARMONIZE_GOP_FIRST_FIELD_COUPLE
		if(poc != 0)
		{
#endif
			if(isField && rpcSlice->getPOC()%2 == 1)
			{
				depth ++;
			}
#if HARMONIZE_GOP_FIRST_FIELD_COUPLE
		}
#endif
#endif
	}

	// slice type
	// 条带类型
	//	B_SLICE,B类型
	// P_SLICE,P类型
	// I_SLICE，I类型
	SliceType eSliceType;

    // 初始的帧的类型是B
	eSliceType=B_SLICE;
#if EFFICIENT_FIELD_IRAP
	if(!(isField && pocLast == 1))
	{
		// 总是会进入这里，因为isField是false
#endif // EFFICIENT_FIELD_IRAP
#if ALLOW_RECOVERY_POINT_AS_RAP

        // 解码刷新类型
		if(m_pcCfg->getDecodingRefreshType() == 3)
		{
            eSliceType = (pocLast == 0 // 如果是GOP的第一帧
                          || pocCurr % m_pcCfg->getIntraPeriod() == 0   // 如果刚好是I帧
                          || m_pcGOPEncoder->getGOPSize() == 0) // 如果GOP的尺寸是0，满足这三种情况之一者的片的类型都是I片
                    ? I_SLICE : eSliceType;
		}
		else
		{
            // 判断和上面的类似
            eSliceType = (pocLast == 0
                          || (pocCurr - isField) % m_pcCfg->getIntraPeriod() == 0
                          || m_pcGOPEncoder->getGOPSize() == 0)
                    ? I_SLICE : eSliceType;
		}
#else
		eSliceType = (pocLast == 0 || (pocCurr - isField) % m_pcCfg->getIntraPeriod() == 0 || m_pcGOPEncoder->getGOPSize() == 0) ? I_SLICE : eSliceType;
#endif
#if EFFICIENT_FIELD_IRAP
	}
#endif

	rpcSlice->setSliceType    ( eSliceType );

	// ------------------------------------------------------------------------------------------------------------------
	// Non-referenced frame marking
	// ------------------------------------------------------------------------------------------------------------------

    // 如果是GOP的第一帧，那么它应该可以被别人参考，所以设置被参考的标志（时域层的）
	if(pocLast == 0)
	{
		rpcSlice->setTemporalLayerNonReferenceFlag(false);
	}
	else
	{
		rpcSlice->setTemporalLayerNonReferenceFlag(!m_pcCfg->getGOPEntry(iGOPid).m_refPic);
	}

	// 该条带可以被参考
	rpcSlice->setReferenced(true);

	// ------------------------------------------------------------------------------------------------------------------
	// QP setting 量化设置
	// ------------------------------------------------------------------------------------------------------------------

    // 量化步长
	dQP = m_pcCfg->getQP();
    // 如果不是I片
	if(eSliceType!=I_SLICE)
	{
        if (!(( m_pcCfg->getMaxDeltaQP() == 0 )
              && (dQP == -rpcSlice->getSPS()->getQpBDOffsetY() )
              && (rpcSlice->getPPS()->getTransquantBypassEnableFlag())))
		{
            // 加上对应的偏移
			dQP += m_pcCfg->getGOPEntry(iGOPid).m_QPOffset;
		}
	}

	// modify QP
    // 每一帧在数组中都有对应的一个位置存放QP
	Int* pdQPs = m_pcCfg->getdQPs();

	if ( pdQPs )
	{
        // 计算QP
		dQP += pdQPs[ rpcSlice->getPOC() ];
	}
	// ------------------------------------------------------------------------------------------------------------------
	// Lambda computation
	// ------------------------------------------------------------------------------------------------------------------

	Int iQP;

	// 32
	Double dOrigQP = dQP;

	// pre-compute lambda and QP values for all possible QP candidates
    // 计算所有可能的候选QP的值和入的值
	for ( Int iDQpIdx = 0; iDQpIdx < 2 * m_pcCfg->getDeltaQpRD() + 1; iDQpIdx++ )
	{
		// compute QP value
		dQP = dOrigQP + ((iDQpIdx+1)>>1)*(iDQpIdx%2 ? -1 : 1);

		// compute lambda value
        // B帧的数量
		Int    NumberBFrames = ( m_pcCfg->getGOPSize() - 1 ); // 0
        // QP偏移
		Int    SHIFT_QP = 12;

		// dLambda_scale == 1
		Double dLambda_scale = 1.0 - Clip3( 0.0, 0.5, 0.05*(Double)(isField ? NumberBFrames/2 : NumberBFrames) );

#if FULL_NBIT
		Int    bitdepth_luma_qp_scale = 6 * (g_bitDepth - 8);
#else
		Int    bitdepth_luma_qp_scale = 0;
#endif
		Double qp_temp = (Double) dQP + bitdepth_luma_qp_scale - SHIFT_QP; // 20
#if FULL_NBIT
		Double qp_temp_orig = (Double) dQP - SHIFT_QP;
#endif
		// Case #1: I or P-slices (key-frame)

        // QP因子
		Double dQPFactor = m_pcCfg->getGOPEntry(iGOPid).m_QPFactor; // 1
		if ( eSliceType==I_SLICE )
		{

			dQPFactor=0.57*dLambda_scale;
		}

		dLambda = dQPFactor*pow( 2.0, qp_temp/3.0 );

		if ( depth>0 )
		{
#if FULL_NBIT
			dLambda *= Clip3( 2.00, 4.00, (qp_temp_orig / 6.0) ); // (j == B_SLICE && p_cur_frm->layer != 0 )
#else
			dLambda *= Clip3( 2.00, 4.00, (qp_temp / 6.0) ); // (j == B_SLICE && p_cur_frm->layer != 0 )
#endif
		}

		// if hadamard is used in ME process
		if ( !m_pcCfg->getUseHADME() && rpcSlice->getSliceType( ) != I_SLICE )
		{
			dLambda *= 0.95;
		}

		// iQP = 32
		iQP = max( -pSPS->getQpBDOffsetY(), min( MAX_QP, (Int) floor( dQP + 0.5 ) ) );

		// 设置相应的量化步长
		m_pdRdPicLambda[iDQpIdx] = dLambda;//57.908....
		m_pdRdPicQp    [iDQpIdx] = dQP;
		m_piRdPicQp    [iDQpIdx] = iQP;
	}

	// obtain dQP = 0 case
	dLambda = m_pdRdPicLambda[0];
	dQP     = m_pdRdPicQp    [0];
	iQP     = m_piRdPicQp    [0];

	if( rpcSlice->getSliceType( ) != I_SLICE )
	{
		dLambda *= m_pcCfg->getLambdaModifier( m_pcCfg->getGOPEntry(iGOPid).m_temporalId );
	}

	// store lambda
	m_pcRdCost ->setLambda( dLambda );
	// for RDO
	// in RdCost there is only one lambda because the luma and chroma bits are not separated, instead we weight the distortion of chroma.
    // 两边的权重
	Double weight[2] = { 1.0, 1.0 };
	Int qpc;
	Int chromaQPOffset;


	chromaQPOffset = rpcSlice->getPPS()->getChromaCbQpOffset() + rpcSlice->getSliceQpDeltaCb();

	qpc = Clip3( 0, 57, iQP + chromaQPOffset);
	weight[0] = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset

	// 设置失真权重
	m_pcRdCost->setCbDistortionWeight(weight[0]);

	// chromaQPOffset == 0
	chromaQPOffset = rpcSlice->getPPS()->getChromaCrQpOffset() + rpcSlice->getSliceQpDeltaCr();
	qpc = Clip3( 0, 57, iQP + chromaQPOffset);
	weight[1] = pow( 2.0, (iQP-g_aucChromaScale[qpc])/3.0 );  // takes into account of the chroma qp mapping and chroma qp Offset

	m_pcRdCost->setCrDistortionWeight(weight[1]);


	const Double lambdaArray[3] = {dLambda, (dLambda / weight[0]), (dLambda / weight[1])};

#if RDOQ_CHROMA_LAMBDA 
	// for RDOQ
	// 设置量化步长
	// RDOQ 率失真优化的量化
	m_pcTrQuant->setLambdas( lambdaArray );
#else
	m_pcTrQuant->setLambda( dLambda );
#endif

	// For SAO
	rpcSlice->setLambdas( lambdaArray );

#if HB_LAMBDA_FOR_LDC
	// restore original slice type

#if EFFICIENT_FIELD_IRAP
	if(!(isField && pocLast == 1))
	{
#endif // EFFICIENT_FIELD_IRAP
#if ALLOW_RECOVERY_POINT_AS_RAP

        // 再次设置片的类型（为什么）
		if(m_pcCfg->getDecodingRefreshType() == 3)
		{
			eSliceType = (pocLast == 0 || (pocCurr)           % m_pcCfg->getIntraPeriod() == 0 || m_pcGOPEncoder->getGOPSize() == 0) ? I_SLICE : eSliceType;

		}
		else
		{

			eSliceType = (pocLast == 0 || (pocCurr - isField) % m_pcCfg->getIntraPeriod() == 0 || m_pcGOPEncoder->getGOPSize() == 0) ? I_SLICE : eSliceType;
		}
#else
		eSliceType = (pocLast == 0 || (pocCurr - isField) % m_pcCfg->getIntraPeriod() == 0 || m_pcGOPEncoder->getGOPSize() == 0) ? I_SLICE : eSliceType;
#endif
#if EFFICIENT_FIELD_IRAP
	}
#endif // EFFICIENT_FIELD_IRAP

	rpcSlice->setSliceType        ( eSliceType );
#endif


	if (m_pcCfg->getUseRecalculateQPAccordingToLambda())
	{
		dQP = xGetQPValueAccordingToLambda( dLambda );
		iQP = max( -pSPS->getQpBDOffsetY(), min( MAX_QP, (Int) floor( dQP + 0.5 ) ) );
	}

    // 设置量化步长
	rpcSlice->setSliceQp          ( iQP ); // iQP = 32
#if ADAPTIVE_QP_SELECTION
	rpcSlice->setSliceQpBase      ( iQP );
#endif
    // 分别设置了亮度、色度的QP
	rpcSlice->setSliceQpDelta     ( 0 );
	rpcSlice->setSliceQpDeltaCb   ( 0 );
	rpcSlice->setSliceQpDeltaCr   ( 0 );

    // 设置条带的参考数组中可用图像的个数
	rpcSlice->setNumRefIdx(REF_PIC_LIST_0,m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive);
	rpcSlice->setNumRefIdx(REF_PIC_LIST_1,m_pcCfg->getGOPEntry(iGOPid).m_numRefPicsActive);

    // 是否使用了去方块滤波
	if ( m_pcCfg->getDeblockingFilterMetric() )
	{
		rpcSlice->setDeblockingFilterOverrideFlag(true);
		rpcSlice->setDeblockingFilterDisable(false);
		rpcSlice->setDeblockingFilterBetaOffsetDiv2( 0 );
		rpcSlice->setDeblockingFilterTcOffsetDiv2( 0 );
	} 
    // 如果没有使用去方块滤波，但是PPS中出现了去方块滤波标志
	else if (rpcSlice->getPPS()->getDeblockingFilterControlPresentFlag())
	{
		rpcSlice->getPPS()->setDeblockingFilterOverrideEnabledFlag( !m_pcCfg->getLoopFilterOffsetInPPS() );
		rpcSlice->setDeblockingFilterOverrideFlag( !m_pcCfg->getLoopFilterOffsetInPPS() );
		rpcSlice->getPPS()->setPicDisableDeblockingFilterFlag( m_pcCfg->getLoopFilterDisable() );
		rpcSlice->setDeblockingFilterDisable( m_pcCfg->getLoopFilterDisable() );
		if ( !rpcSlice->getDeblockingFilterDisable())
		{
			if ( !m_pcCfg->getLoopFilterOffsetInPPS() && eSliceType!=I_SLICE)
			{
				rpcSlice->getPPS()->setDeblockingFilterBetaOffsetDiv2( m_pcCfg->getGOPEntry(iGOPid).m_betaOffsetDiv2 + m_pcCfg->getLoopFilterBetaOffset() );
				rpcSlice->getPPS()->setDeblockingFilterTcOffsetDiv2( m_pcCfg->getGOPEntry(iGOPid).m_tcOffsetDiv2 + m_pcCfg->getLoopFilterTcOffset() );
				rpcSlice->setDeblockingFilterBetaOffsetDiv2( m_pcCfg->getGOPEntry(iGOPid).m_betaOffsetDiv2 + m_pcCfg->getLoopFilterBetaOffset()  );
				rpcSlice->setDeblockingFilterTcOffsetDiv2( m_pcCfg->getGOPEntry(iGOPid).m_tcOffsetDiv2 + m_pcCfg->getLoopFilterTcOffset() );
			}
			else
			{
				rpcSlice->getPPS()->setDeblockingFilterBetaOffsetDiv2( m_pcCfg->getLoopFilterBetaOffset() );
				rpcSlice->getPPS()->setDeblockingFilterTcOffsetDiv2( m_pcCfg->getLoopFilterTcOffset() );
				rpcSlice->setDeblockingFilterBetaOffsetDiv2( m_pcCfg->getLoopFilterBetaOffset() );
				rpcSlice->setDeblockingFilterTcOffsetDiv2( m_pcCfg->getLoopFilterTcOffset() );
			}
		}
	}
	else
	{
		// 进入这里
		rpcSlice->setDeblockingFilterOverrideFlag( false );
		rpcSlice->setDeblockingFilterDisable( false );
		rpcSlice->setDeblockingFilterBetaOffsetDiv2( 0 );
		rpcSlice->setDeblockingFilterTcOffsetDiv2( 0 );
	}

    // 条带的深度
	rpcSlice->setDepth            ( depth );

    // 设置图像所属的层
	pcPic->setTLayer( m_pcCfg->getGOPEntry(iGOPid).m_temporalId );

    // 如果是I帧那么它所属的层是0层
	if(eSliceType==I_SLICE)
	{
		pcPic->setTLayer(0);
	}

	// 设置条带所属的层
	rpcSlice->setTLayer( pcPic->getTLayer() );

	assert( m_apcPicYuvPred );
	assert( m_apcPicYuvResi );

    // 设置图像的预测图像缓存
	pcPic->setPicYuvPred( m_apcPicYuvPred );
    // 设置图像的残差图像缓存
	pcPic->setPicYuvResi( m_apcPicYuvResi );

	rpcSlice->setSliceMode            ( m_pcCfg->getSliceMode()            );
	rpcSlice->setSliceArgument        ( m_pcCfg->getSliceArgument()        );
	rpcSlice->setSliceSegmentMode     ( m_pcCfg->getSliceSegmentMode()     );
	rpcSlice->setSliceSegmentArgument ( m_pcCfg->getSliceSegmentArgument() );
	rpcSlice->setMaxNumMergeCand        ( m_pcCfg->getMaxNumMergeCand()        );


    // 存储WPP参数
	xStoreWPparam( pPPS->getUseWP(), pPPS->getWPBiPred() );
}
// 片初始化
Void TComSlice::initSlice()
{
    // 参考的索引
	m_aiNumRefIdx[0]      = 0;
	m_aiNumRefIdx[1]      = 0;

    // 参考帧是否都是从list0中来
	m_colFromL0Flag = 1;

	m_colRefIdx = 0;
	initEqualRef();
	m_bCheckLDC = false;
	m_iSliceQpDeltaCb = 0;
	m_iSliceQpDeltaCr = 0;

    // merge模式的候选数量5
	m_maxNumMergeCand = MRG_MAX_NUM_CANDS;

	m_bFinalized=false;

	m_tileByteLocation.clear();
    // CABAC熵编码是否已经初始化
	m_cabacInitFlag        = false;
    // 入口点的数量
	m_numEntryPointOffsets = 0;
    // 启用MVP
	m_enableTMVPFlag = true;
}



NB_vol_1
关注
专栏目录
HEVC码率控制算法研究与HM相应代码分析（一）——HEVC标准及编码流程介绍
张晖的专栏
08-08 9985
本系列文章分为三个部分，首先对HEVC标准做一个介绍，然后回顾一下H.264中的码率控制方法，分析为什么不能直接沿用旧的方法，最后具体分析HEVC的码率控制方法和相应代码。 HEVC标准介绍 首先我们需要明白的是，其实每一代视频编码标准的更新都是为了实现两个大目标：更好的支持高分辨视频；以更高的压缩率达到同等的主观质量。除此之外，还有提高网络适配性（比如在H.264中定义的网络抽象层概念）、抗...
x265编码器命令行程序源码模块梳理
最新发布
想都是问题，做才有答案～～
09-28 556
x265编码器命令行程序源码模块梳理
【HEVC学习与研究】31、HM编码器的基本结构
Workshop of Wenjie.Yin
07-04 5406
通过解码器代码的研究，已经对HEVC的编解码技术有了一个初步的认识。现在可以对照
HM编码器代码阅读(1)——介绍以及相关知识
NB_vol_1的专栏
04-12 6720
HM是HEVC（H.265）的开源实现，可以从网上直接下载。 HEVC（H.265）是新一代的视频编解码标准。 本人目前研究的只是编码器部分，而且还是入门阶段！为了提高自己，边学边记，由于理解不够深入，难免会有误，请见谅！ 本人现在使用的版本是15.0，最新版本好像已经到16.0了 文件的功能以及作用： AccessUnit.h 定义了存取单元（或者说访问单元），实质是一个类型为
hm编码工具使用_HM编码器代码阅读(1)——介绍以及相关知识
weixin_42487788的博客
12-24 965
HM是HEVC(H.265)的开源实现，可以从网上直接下载。HEVC(H.265)是新一代的视频编解码标准。本人目前研究的只是编码器部分，而且还是入门阶段！为了提高自己，边学边记，由于理解不够深入，难免会有误，请见谅！本人现在使用的版本是15.0，最新版本好像已经到16.0了文件的功能以及作用：AccessUnit.h 定义了存取单元(或者说访问单元)，实质是一个类型为NALUnitEBSP的li...
HM编码器代码阅读
【黑键】
11-03 553
参考资料HM编码器的下载与配置 源码的文件/类的功能介绍 一些比较容易混淆的类和结构编码器流程图
HEVC函数入门（1）——HM编码器的基本结构
不是他人太努力，只是自己努力不够罢了
06-18 1895
首先说明这篇主要是记录用（意思是里面很多是我自己的理解，我也是刚入门的新手，肯定有许多不正确的地方，还请轻喷），使用的是HM 16.3 VS2015 当然如果有新手不太懂的话也可以看看。 本文主要参照http://blog.csdn.net/shaqoneal/article/details/36398707int main(int argc, char* argv[]) { TAppEncT
HM代码学习02——TAppEncTop::encode()
小惊大怪的博客
04-20 409
TAppEncTop::encode() 创建内部类 初始化内部变量 直到输入YUV文件结束，调用TEncTop类中的编码函数 删除分配的缓冲区 摧毁内部阶级 Void TAppEncTop::encode() { fstream bitstreamFile(m_bitstreamFileName.c_str(), fstream::binary | fstream::out); if (!bitstreamFile) { fprintf(stderr, "\nfailed to ope
HM编码器代码阅读(21)——熵编码的概念以及在HEVC中应用
NB_vol_1的专栏
04-22 9043
熵编码把一系列用于表示视频序列的元素符号转变为一个用来传输或存储的压缩码流。 信息的多少用信息量来度量，显然，信息量与不确定性的消除程度有关，消除的不确定性越大，信息量就越大。不确定性的大小与事件发生的概率相关，因此不确定性可以度量，更进一步信息量也可以度量。 假设某一个信源（就是产生信息的地方）的概率空间是： X（表示信源产生的符号的集合），P（
HM编码器代码阅读(7)——整个编码流程以及相关的函数
NB_vol_1的专栏
04-13 7264
来自网上的文档，但是最初来源不知道是哪，谢谢这个作者！ 整个流程可以从compressGOP函数开始着手： 1、compressGOP对一整个图像组（GOP）进行编码，主要是遍历GOP中每一帧，对每一帧进行单独编码 2、每一帧又会被划分成若干slice（HM15中，每一帧对应一个slice），因此对每一帧的处理就转换成对每一片的处理。 3、每一个slice都会调用com
【HEVC学习与研究】37、HM编码器的基本结构2：帧内编码部分的代码骨架
Workshop of Wenjie.Yin
10-09 5220
第31篇博文大体介绍了
HM编码器代码阅读(40)——帧内预测的总结
NB_vol_1的专栏
02-17 3496
帧内预测的总结 原理 HEVC/H.265理论知识（3）——帧内预测 代码实现 HM编码器代码阅读(34)——帧内预测（一） HM编码器代码阅读(35)——帧内预测（二）帧内预测总流程 HM编码器代码阅读(36)——帧内预测（三）帧内预测之参考像素块的预处理和滤波 HM编码器代码阅读(37)——帧内预测（四）帧内预测之候选模式列表的建立 HM
HM编码器代码阅读(10)——片的编码
NB_vol_1的专栏
04-14 3853
入口函数TEncSlice::compressSlice 这个函数主要是设置一些参数和初始化一些东西，然后对片中的每一个LCU调用initCU（初始化CU）和compressCU（对CU编码）和encodeCU（对CU进行熵编码，目的是选择最优参数）。 TEncSlice::compressSlice函数的详解： （1）计算当前slice的开始CU和结束CU （2）初始化Sbac编码器
HM编码器代码阅读(29)——码率控制
NB_vol_1的专栏
02-14 6137
码率控制 介绍 码率控制 码率控制也叫速率控制，主要是控制编码后的比特率。 存在码率控制模块的原因是，有时候解码器处理的速度不够快、网络带宽不行 这些情况的存在要求我们必须减少数据的发送量（即比特率要变小），减少数据的发送量 意味着我们要对数据进行更近一步的压缩，在编码器中就表现为量化参数QP的变化。 当满足一定码率要求的情况下，我们还需要让编码的失真尽量小。 码率控制的核
HEVC码率控制浅析——HM代码阅读之一
guoyaoyao1990的专栏
10-20 2350
http://blog.csdn.net/hevc_cjl/article/details/10982699 HM的码率控制提案主要参考如下三篇：K0103，M0036，M0257。本文及后续文章将基于HM12.0进行讨论，且首先仅讨论K0103对应的代码，之后再陆续补充M0036，M0257对应的代码分析，这么做可能会使得剧情不会显得那么地跳跃，分析起来能够更好地被接受。
H.266/VVC-VTM代码学习26-VTM中RDcost的计算与λ的设定（二）
liaojq2020的博客
09-10 1372
H.266/VVC专栏传送 上一篇：H.266/VVC-VTM代码学习24-根据当前块位置与尺寸确定隐藏划分模式getImplicitSplit() 下一篇：持续创作中… 目录H.266/VVC专栏传送前言一、简介二、代码详解1.initEncSlice()函数中对λ\lambdaλ的设置2.使用码率控制时λ\lambdaλ的调整代码 前言 VTM是H.266/VVC视频编码标准的参考软件，研究VTM代码给研究人员解释了VVC编码标准的详细标准规范与细节。 本文是笔者对VTM代码的一点学习记录，成文于笔者刚
HEVC 片与片段(Slice 和Slice Segment)说明
z373248439的博客
12-06 2021
HEVC 片与片段(Slice 和Slice Segment)说明 一幅图像可以被分割为一个或多个片(Slice)，每个片的压缩数据都是独立的，Slice头信息无法通过前一个Slice的头信息推断得到。这就要求Slice不能跨过它的边界来进行帧内或帧间预测，且在进行熵编码前需要进行初始化。但在进行环路滤波时，允许滤波器跨越Slice的边界进行滤波。除了Slice的边界可能受环路滤波影响外，Slice的解码过程可以不使用任何来自其他Slice的影响，且有利于实现并行运算。使用Slice的主要目的是当数据丢失后
H.265/HEVC率失真优化（RDO）及其HM代码注解
qq_35678048的博客
07-22 5061
本博客介绍了HEVC的率失真优化（RDO）的目的，并对编码CTU时的率失真优化过程作了简要说明。最后，对HEVC参考测试平台HM的代码作了注解，其中包括率失真优化过程中QP和拉格朗日乘子初始化，率失真代价值计算以及最优编码参数的选取。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值