HM编码器代码阅读(38)——帧内预测（五）帧内预测之正式的预测操作

最新推荐文章于 2022-02-24 15:41:07 发布
最新推荐文章于 2022-02-24 15:41:07 发布
阅读量2.9k 收藏 9
点赞数 5
分类专栏： HEVC编码器HM源码阅读 文章标签： h.265 hevc 编码 编解码 压缩
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NB_vol_1/article/details/55515294
版权

正式的预测操作


    在前面的操作中，我们已经得到了模式候选列表，但是我们的目的是要得到一个最优的模式，因此我们还需要对这个列表中的模式进行遍历，对于每一个模式，进行预测操作，为了计算率失真代价还必须进行变换量化，根据率失真代价来选取最优的预测模式。得到最优的预测模式的同时，我们也得到了变换系数（因为预测之后我们还进行了变换量化操作）。

    执行正式的预测操作的相关代码在estIntraPredQT中，主要的功能是遍历模式候选列表中的所有模式，对每一个模式进行预测（顺带变换量化），选出最优的预测模式

		// 遍历候选集中的模式
		for( UInt uiMode = 0; uiMode < numModesForFullRD; uiMode++ )
		{
			// set luma prediction mode
			UInt uiOrgMode = uiRdModeList[uiMode];

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

			// set context models
			// 设置上下文模型
			m_pcRDGoOnSbacCoder->load( m_pppcRDSbacCoder[uiDepth][CI_CURR_BEST] );

			// determine residual for partition
			UInt   uiPUDistY = 0;
			UInt   uiPUDistC = 0;
			Double dPUCost   = 0.0;
#if HHI_RQT_INTRA_SPEEDUP

			// 通过多候选模式进行预测、变换、量化等操作来计算代价
			// 注意倒数第二个参数bCheckFirst是true，表示会继续按照四叉树的方式向下划分
			xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, true, dPUCost );
			// 重要函数end
#else
			xRecurIntraCodingQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiPUDistY, uiPUDistC, dPUCost );
#endif

			// check r-d cost
			// 从候选列表中选取最优的模式
			if( dPUCost < dBestPUCost )
			{
#if HHI_RQT_INTRA_SPEEDUP_MOD
				uiSecondBestMode  = uiBestPUMode;
				dSecondBestPUCost = dBestPUCost;
#endif
				uiBestPUMode  = uiOrgMode;
				uiBestPUDistY = uiPUDistY;
				uiBestPUDistC = uiPUDistC;
				dBestPUCost   = dPUCost;

				xSetIntraResultQT( pcCU, uiInitTrDepth, uiPartOffset, bLumaOnly, pcRecoYuv );

				UInt uiQPartNum = pcCU->getPic()->getNumPartInCU() >> ( ( pcCU->getDepth(0) + uiInitTrDepth ) << 1 );
				::memcpy( m_puhQTTempTrIdx,  pcCU->getTransformIdx()       + uiPartOffset, uiQPartNum * sizeof( UChar ) );
				::memcpy( m_puhQTTempCbf[0], pcCU->getCbf( TEXT_LUMA     ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
				::memcpy( m_puhQTTempCbf[1], pcCU->getCbf( TEXT_CHROMA_U ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
				::memcpy( m_puhQTTempCbf[2], pcCU->getCbf( TEXT_CHROMA_V ) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
				::memcpy( m_puhQTTempTransformSkipFlag[0], pcCU->getTransformSkip(TEXT_LUMA)     + uiPartOffset, uiQPartNum * sizeof( UChar ) );
				::memcpy( m_puhQTTempTransformSkipFlag[1], pcCU->getTransformSkip(TEXT_CHROMA_U) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
				::memcpy( m_puhQTTempTransformSkipFlag[2], pcCU->getTransformSkip(TEXT_CHROMA_V) + uiPartOffset, uiQPartNum * sizeof( UChar ) );
			}
#if HHI_RQT_INTRA_SPEEDUP_MOD
			else if( dPUCost < dSecondBestPUCost )
			{
				uiSecondBestMode  = uiOrgMode;
				dSecondBestPUCost = dPUCost;
			}
#endif
		} // Mode loop



正式预测操作的入口函数

入口函数是xRecurIntraCodingQT，它的流程如下：

一、检测bCheckFull标识是否为true，如果是true，那么进行下面操作：
    1、检查TransformSkip标识是否为true，如果是true（表示将会跳过变换步骤），进行下面操作
        （1）进行两次遍历，每一次遍历都调用xIntraCodingLumaBlk、xIntraCodingChromaBlk对三个分量进行预测、计算残差（没有变换步骤）、量化
        （2）选取两次遍历中更优的模式
    2、如果TransformSkip是false，那么进行下面操作：
        （1）调用xIntraCodingLumaBlk、xIntraCodingChromaBlk对三个分量进行预测、变换、量化
二、检查bCheckSplit表示是否为true，如果为true，那么对子PU进行递归处理

/*
** 正式的预测操作（顺便进行了变换量化）
** 为了清晰易懂，把不太相关的代码删除，只保留了清晰的架构
*/
Void TEncSearch::xRecurIntraCodingQT( TComDataCU*  pcCU, 
	UInt         uiTrDepth,
	UInt         uiAbsPartIdx, 
	Bool         bLumaOnly,
	TComYuv*     pcOrgYuv, 
	TComYuv*     pcPredYuv, 
	TComYuv*     pcResiYuv, 
	UInt&        ruiDistY,
	UInt&        ruiDistC,
#if HHI_RQT_INTRA_SPEEDUP
	Bool         bCheckFirst,
#endif
	Double&      dRDCost )
{
	
	// 删除不太重要的代码******
	
	Bool    bCheckFull    = ( uiLog2TrSize  <= pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() );
	Bool    bCheckSplit   = ( uiLog2TrSize  >  pcCU->getQuadtreeTULog2MinSizeInCU(uiAbsPartIdx) );


	// 删除不太重要的代码******

	Bool noSplitIntraMaxTuSize = bCheckFull;
	if(m_pcEncCfg->getRDpenalty() && ! isIntraSlice)
	{
		// in addition don't check split if TU size is less or equal to 16x16 TU size for non-intra slice
		noSplitIntraMaxTuSize = ( uiLog2TrSize  <= min(maxTuSize,4) );

		// if maximum RD-penalty don't check TU size 32x32 
		if(m_pcEncCfg->getRDpenalty()==2)
		{
			bCheckFull    = ( uiLog2TrSize  <= min(maxTuSize,4));
		}
	}
	if( bCheckFirst && noSplitIntraMaxTuSize )
	{
		bCheckSplit = false;
	}

	// 删除不太重要的代码******
	
	Bool    checkTransformSkip  = pcCU->getSlice()->getPPS()->getUseTransformSkip();
	UInt    widthTransformSkip  = pcCU->getWidth ( 0 ) >> uiTrDepth;
	UInt    heightTransformSkip = pcCU->getHeight( 0 ) >> uiTrDepth;
	
	// 删除不太重要的代码******
	
	checkTransformSkip         &= (widthTransformSkip == 4 && heightTransformSkip == 4);
	checkTransformSkip         &= (!pcCU->getCUTransquantBypass(0));
	if ( m_pcEncCfg->getUseTransformSkipFast() )
	{
		checkTransformSkip       &= (pcCU->getPartitionSize(uiAbsPartIdx)==SIZE_NxN);
	}
	
	if( bCheckFull )
	{
		// skip模式为真
		if(checkTransformSkip == true)
		{
			// 删除不太重要的代码******

			// 遍历两次也是为了选取最优的模式，modeId能够决定xIntraCodingLumaBlk的最后一个参数，该参数控制了预测像素如何生成
			for(Int modeId = firstCheckId; modeId < 2; modeId ++)
			{
				// 删除不太重要的代码******
				
				// 亮度块的预测、变换和量化
				xIntraCodingLumaBlk( pcCU, uiTrDepth, uiAbsPartIdx, pcOrgYuv, pcPredYuv, pcResiYuv, singleDistYTmp,default0Save1Load2); 

				singleCbfYTmp = pcCU->getCbf( uiAbsPartIdx, TEXT_LUMA, uiTrDepth );
				//----- code chroma blocks with given intra prediction mode and store Cbf-----
				if( !bLumaOnly )
				{
					// 删除不太重要的代码******
					
					// 色度块的预测、变换和量化
					xIntraCodingChromaBlk ( pcCU, uiTrDepth, uiAbsPartIdx, pcOrgYuv, pcPredYuv, pcResiYuv, singleDistCTmp, 0, default0Save1Load2); 
					xIntraCodingChromaBlk ( pcCU, uiTrDepth, uiAbsPartIdx, pcOrgYuv, pcPredYuv, pcResiYuv, singleDistCTmp, 1, default0Save1Load2); 
					
					// 删除不太重要的代码******
				}
				
				// 删除不太重要的代码******

				// 代价更新
				if(singleCostTmp < dSingleCost)
				{
					dSingleCost   = singleCostTmp;
					uiSingleDistY = singleDistYTmp;
					uiSingleDistC = singleDistCTmp;
					uiSingleCbfY  = singleCbfYTmp;
					uiSingleCbfU  = singleCbfUTmp;
					uiSingleCbfV  = singleCbfVTmp;
					bestModeId    = modeId;
					if(bestModeId == firstCheckId)
					{
						xStoreIntraResultQT(pcCU, uiTrDepth, uiAbsPartIdx,bLumaOnly );
						m_pcRDGoOnSbacCoder->store( m_pppcRDSbacCoder[ uiFullDepth ][ CI_TEMP_BEST ] );
					}
				}
				
				// 删除不太重要的代码******
			}

			// 删除不太重要的代码******
		}
		else
		{
			// 删除不太重要的代码******
			
			xIntraCodingLumaBlk( pcCU, uiTrDepth, uiAbsPartIdx, pcOrgYuv, pcPredYuv, pcResiYuv, uiSingleDistY ); 
			
			// 删除不太重要的代码******
			
			if( !bLumaOnly )
			{
				// 删除不太重要的代码******
				
				xIntraCodingChromaBlk ( pcCU, uiTrDepth, uiAbsPartIdx, pcOrgYuv, pcPredYuv, pcResiYuv, uiSingleDistC, 0 ); 
				xIntraCodingChromaBlk ( pcCU, uiTrDepth, uiAbsPartIdx, pcOrgYuv, pcPredYuv, pcResiYuv, uiSingleDistC, 1 ); 
				
				// 删除不太重要的代码******
			}
			
			// 删除不太重要的代码******
		}
	}

	// 当前块是否向下继续划分为4个子块，如果是，那么就递归处理
	if( bCheckSplit )
	{
		// 删除不太重要的代码******

		for( UInt uiPart = 0; uiPart < 4; uiPart++, uiAbsPartIdxSub += uiQPartsDiv )
		{
#if HHI_RQT_INTRA_SPEEDUP
			// 递归调用
			xRecurIntraCodingQT( pcCU, uiTrDepth + 1, uiAbsPartIdxSub, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiSplitDistY, uiSplitDistC, bCheckFirst, dSplitCost );
#else
			xRecurIntraCodingQT( pcCU, uiTrDepth + 1, uiAbsPartIdxSub, bLumaOnly, pcOrgYuv, pcPredYuv, pcResiYuv, uiSplitDistY, uiSplitDistC, dSplitCost );
#endif

			// 删除不太重要的代码******
		}

		// 删除不太重要的代码******
		
		//----- determine rate and r-d cost -----
		UInt uiSplitBits = xGetIntraBitsQT( pcCU, uiTrDepth, uiAbsPartIdx, true, !bLumaOnly, false );
		dSplitCost       = m_pcRdCost->calcRdCost( uiSplitBits, uiSplitDistY + uiSplitDistC );

		//===== compare and set best =====
		if( dSplitCost < dSingleCost )
		{
			//--- update cost ---
			ruiDistY += uiSplitDistY;
			ruiDistC += uiSplitDistC;
			dRDCost  += dSplitCost;
			return;
		}
		
		// 删除不太重要的代码******

		//--- set reconstruction for next intra prediction blocks ---
		
		// 到这里是像素块的重建操作，这里把相关的代码删了
	}
	ruiDistY += uiSingleDistY;
	ruiDistC += uiSingleDistC;
	dRDCost  += dSingleCost;
}


对某个分量进行预测（顺带变换量化）

流程很简单：

1、先进行预测，得到预测像素

2、计算残差

3、对残差进行变换、量化

4、进行反变换、反量化

5、重建像素块

/*
** 帧内预测的一整套流程：预测+变换量化+反变换反量化+重建像素
** 被xRecurIntraCodingQT调用
*/
Void TEncSearch::xIntraCodingLumaBlk( TComDataCU* pcCU,
	UInt        uiTrDepth,
	UInt        uiAbsPartIdx,
	TComYuv*    pcOrgYuv, 
	TComYuv*    pcPredYuv, 
	TComYuv*    pcResiYuv, 
	UInt&       ruiDist,
	Int        default0Save1Load2 )
{
	// 获取亮度块的预测模式
	UInt    uiLumaPredMode    = pcCU     ->getLumaIntraDir     ( uiAbsPartIdx );
	// 获取深度
	UInt    uiFullDepth       = pcCU     ->getDepth   ( 0 )  + uiTrDepth;
	// 获取宽高
	UInt    uiWidth           = pcCU     ->getWidth   ( 0 ) >> uiTrDepth;
	UInt    uiHeight          = pcCU     ->getHeight  ( 0 ) >> uiTrDepth;
	// 获取偏移
	UInt    uiStride          = pcOrgYuv ->getStride  ();
	// 原始的像素地址
	Pel*    piOrg             = pcOrgYuv ->getLumaAddr( uiAbsPartIdx );
	// 预测的像素地址
	Pel*    piPred            = pcPredYuv->getLumaAddr( uiAbsPartIdx );
	// 残差的像素地址
	Pel*    piResi            = pcResiYuv->getLumaAddr( uiAbsPartIdx );
	// 重建的像素地址
	Pel*    piReco            = pcPredYuv->getLumaAddr( uiAbsPartIdx );

	UInt    uiLog2TrSize      = g_aucConvertToBit[ pcCU->getSlice()->getSPS()->getMaxCUWidth() >> uiFullDepth ] + 2;
	UInt    uiQTLayer         = pcCU->getSlice()->getSPS()->getQuadtreeTULog2MaxSize() - uiLog2TrSize;
	UInt    uiNumCoeffPerInc  = pcCU->getSlice()->getSPS()->getMaxCUWidth() * pcCU->getSlice()->getSPS()->getMaxCUHeight() >> ( pcCU->getSlice()->getSPS()->getMaxCUDepth() << 1 );
	// 系数（实际是一个int数组）
	TCoeff* pcCoeff           = m_ppcQTTempCoeffY[ uiQTLayer ] + uiNumCoeffPerInc * uiAbsPartIdx;

#if ADAPTIVE_QP_SELECTION
	Int*    pcArlCoeff        = m_ppcQTTempArlCoeffY[ uiQTLayer ] + uiNumCoeffPerInc * uiAbsPartIdx;
#endif

	Pel*    piRecQt           = m_pcQTTempTComYuv[ uiQTLayer ].getLumaAddr( uiAbsPartIdx );
	UInt    uiRecQtStride     = m_pcQTTempTComYuv[ uiQTLayer ].getStride  ();

	// Z扫描的顺序
	UInt    uiZOrder          = pcCU->getZorderIdxInCU() + uiAbsPartIdx;
	Pel*    piRecIPred        = pcCU->getPic()->getPicYuvRec()->getLumaAddr( pcCU->getAddr(), uiZOrder );
	UInt    uiRecIPredStride  = pcCU->getPic()->getPicYuvRec()->getStride  ();
	Bool    useTransformSkip  = pcCU->getTransformSkip(uiAbsPartIdx, TEXT_LUMA);
	//===== init availability pattern =====

	// 上方是否有效
	Bool  bAboveAvail = false;
	// 左侧是否有效
	Bool  bLeftAvail  = false;

	// default0Save1Load2参数控制了预测像素的生成方式
	if(default0Save1Load2 != 2)
	{
		pcCU->getPattern()->initPattern   ( pcCU, uiTrDepth, uiAbsPartIdx );

		pcCU->getPattern()->initAdiPattern( pcCU, uiAbsPartIdx, uiTrDepth, m_piYuvExt, m_iYuvExtStride, m_iYuvExtHeight, bAboveAvail, bLeftAvail );

		// 预测操作
		predIntraLumaAng( pcCU->getPattern(), uiLumaPredMode, piPred, uiStride, uiWidth, uiHeight, bAboveAvail, bLeftAvail );
		// save prediction 
		// 保存预测信息
		if(default0Save1Load2 == 1)
		{
			Pel*  pPred   = piPred;
			Pel*  pPredBuf = m_pSharedPredTransformSkip[0];
			Int k = 0;
			for( UInt uiY = 0; uiY < uiHeight; uiY++ )
			{
				for( UInt uiX = 0; uiX < uiWidth; uiX++ )
				{
					pPredBuf[ k ++ ] = pPred[ uiX ];
				}
				pPred += uiStride;
			}
		}
	}
	else 
	{
		// load prediction
		
		// 直接计算预测值！
		Pel*  pPred   = piPred;
		Pel*  pPredBuf = m_pSharedPredTransformSkip[0];
		Int k = 0;
		for( UInt uiY = 0; uiY < uiHeight; uiY++ )
		{
			for( UInt uiX = 0; uiX < uiWidth; uiX++ )
			{
				pPred[ uiX ] = pPredBuf[ k ++ ];
			}
			pPred += uiStride;
		}
	}


	//===== get residual signal =====
	{
		// get residual
		
		// 计算残差
		Pel*  pOrg    = piOrg;
		Pel*  pPred   = piPred;
		Pel*  pResi   = piResi;
		for( UInt uiY = 0; uiY < uiHeight; uiY++ )
		{
			for( UInt uiX = 0; uiX < uiWidth; uiX++ )
			{
				// 此处计算残差数据
				pResi[ uiX ] = pOrg[ uiX ] - pPred[ uiX ];
			}
			pOrg  += uiStride;
			pResi += uiStride;
			pPred += uiStride;
		}
	}

	// 变换和量化
	//===== transform and quantization =====
	//--- init rate estimation arrays for RDOQ ---
	// 是否跳过变换操作
	if( useTransformSkip? m_pcEncCfg->getUseRDOQTS():m_pcEncCfg->getUseRDOQ())
	{
		// 比特数估计
		m_pcEntropyCoder->estimateBit( m_pcTrQuant->m_pcEstBitsSbac, uiWidth, uiWidth, TEXT_LUMA );
	}

	//--- transform and quantization ---
	UInt uiAbsSum = 0;
	pcCU       ->setTrIdxSubParts ( uiTrDepth, uiAbsPartIdx, uiFullDepth );

	m_pcTrQuant->setQPforQuant    ( pcCU->getQP( 0 ), TEXT_LUMA, pcCU->getSlice()->getSPS()->getQpBDOffsetY(), 0 );

#if RDOQ_CHROMA_LAMBDA 
	m_pcTrQuant->selectLambda     (TEXT_LUMA);  
#endif

	// 变换（连同量化一起）
	m_pcTrQuant->transformNxN     ( pcCU, piResi, uiStride, pcCoeff, 
#if ADAPTIVE_QP_SELECTION
		pcArlCoeff, 
#endif
		uiWidth, uiHeight, uiAbsSum, TEXT_LUMA, uiAbsPartIdx,useTransformSkip );

	//--- set coded block flag ---
	pcCU->setCbfSubParts          ( ( uiAbsSum ? 1 : 0 ) << uiTrDepth, TEXT_LUMA, uiAbsPartIdx, uiFullDepth );
	//--- inverse transform ---
	
	// uiAbsSum表示变换系数的绝对值只和
	if( uiAbsSum )
	{
		Int scalingListType = 0 + g_eTTable[(Int)TEXT_LUMA];
		assert(scalingListType < SCALING_LIST_NUM);

		// 反变换
		m_pcTrQuant->invtransformNxN( pcCU->getCUTransquantBypass(uiAbsPartIdx), TEXT_LUMA,pcCU->getLumaIntraDir( uiAbsPartIdx ), piResi, uiStride, pcCoeff, uiWidth, uiHeight, scalingListType, useTransformSkip );
	}
	else
	{
		Pel* pResi = piResi;
		memset( pcCoeff, 0, sizeof( TCoeff ) * uiWidth * uiHeight );
		for( UInt uiY = 0; uiY < uiHeight; uiY++ )
		{
			memset( pResi, 0, sizeof( Pel ) * uiWidth );
			pResi += uiStride;
		}
	}

	// 图像重建
	//===== reconstruction =====
	{
		Pel* pPred      = piPred;
		Pel* pResi      = piResi;
		Pel* pReco      = piReco;
		Pel* pRecQt     = piRecQt;
		Pel* pRecIPred  = piRecIPred;
		for( UInt uiY = 0; uiY < uiHeight; uiY++ )
		{
			for( UInt uiX = 0; uiX < uiWidth; uiX++ )
			{
				pReco    [ uiX ] = ClipY( pPred[ uiX ] + pResi[ uiX ] );
				pRecQt   [ uiX ] = pReco[ uiX ];
				pRecIPred[ uiX ] = pReco[ uiX ];
			}
			pPred     += uiStride;
			pResi     += uiStride;
			pReco     += uiStride;
			pRecQt    += uiRecQtStride;
			pRecIPred += uiRecIPredStride;
		}
	}

	//===== update distortion =====
	// 失真代价更新！
	ruiDist += m_pcRdCost->getDistPart(g_bitDepthY, piReco, uiStride, piOrg, uiStride, uiWidth, uiHeight );
}


预测函数

流程也很简单：

1、判断模式属于哪一类：planar模式、水平类型的模式、垂直类型的模式、DC模式

2、根据模式来调用不同的函数，进行预测

// 亮度块的帧内预测
Void TComPrediction::predIntraLumaAng(TComPattern* pcTComPattern, UInt uiDirMode, Pel* piPred, UInt uiStride, Int iWidth, Int iHeight, Bool bAbove, Bool bLeft )
{
	Pel *pDst = piPred;
	Int *ptrSrc;

	assert( g_aucConvertToBit[ iWidth ] >= 0 ); //   4x  4
	assert( g_aucConvertToBit[ iWidth ] <= 5 ); // 128x128
	assert( iWidth == iHeight  );

	// 获取数据的指针
	ptrSrc = pcTComPattern->getPredictorPtr( uiDirMode, g_aucConvertToBit[ iWidth ] + 2, m_piYuvExt );

	// get starting pixel in block
	// 获取块中的开始像素
	Int sw = 2 * iWidth + 1; // 9

	// Create the prediction
	// 如果指定了planar模式
	if ( uiDirMode == PLANAR_IDX )
	{
		// planar预测模式
		xPredIntraPlanar( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight );
	}
	else
	{
		// 没有指定planar模式
		// 区分水平或者垂直模式进行预测
		if ( (iWidth > 16) || (iHeight > 16) )
		{
			xPredIntraAng(g_bitDepthY, ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, uiDirMode, bAbove, bLeft, false );
		}
		else
		{
			xPredIntraAng(g_bitDepthY, ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight, uiDirMode, bAbove, bLeft, true );

			// 观察是否为DC模式
			if( (uiDirMode == DC_IDX ) && bAbove && bLeft )
			{
				// 对DC模式进行滤波
				xDCPredFiltering( ptrSrc+sw+1, sw, pDst, uiStride, iWidth, iHeight);
			}
		}
	}
}


预测的实现细节

下面这些函数基本都是某个公式的实现，详细信息请参考标准

planar模式：xPredIntraPlanar

DC模式和其他模式：xPredIntraAng


变换和量化

处理变换和量化的函数是transformNxN，这个函数等讲解变换量化的时候再细讲

HEVC学习（三） —— 帧内预测系列之一
HEVC_CJL的专栏
11-12 3万+
今天开始进入实质性内容的讨论，主要是从代码实现的角度比较深入地研究帧内预测算法。由于帧内预测涉及到的函数的数量相对于编解码器复杂部分来说少，但事实上大大小小也牵涉到了十几二十个函数（没具体统计过，只是大概估算了下），想要一下子讨论完比较困难，所以打算在接下来的若干篇文章里逐步地尽可能详尽地分析每一个较为重要的函数。今天所要讨论的是fillReferenceSamples这个函数，它主要功能是在真正
HEVC函数入门（6）——帧内预测-详细概念和HM16.3实现（上）
不是他人太努力，只是自己努力不够罢了
06-21 1529
前面已经讲过了帧内预测的原理，但是只是讲了一下方向DC以及平面预测的概念，对其中的细节没有细讲，这里，整理http://blog.csdn.net/shaqoneal/article/details/44749057这篇博文来看看具体概念。 （1）角度预测 HEVC中的角度预测方法用于高效地对图像和视频的不同方向性结构进行建模的方法。该方法所选择的预测方向经过设计，可以达到对典型视频内容的编码效
HM编码器代码阅读(37)——帧内预测（四）帧内预测之候选模式列表的建立
NB_vol_1的专栏
02-17 3261
候选模式列表的建立     帧内预测也可以分成两种方式，一种是常规方式，另一种是快速方式 在常规方式     所有的35种帧内预测模式都被添加到候选模式列表中，在后续的惭怍中，对每一个模式都进行预测、变换、量化等操作，速度很慢。     相关代码在estIntraPredQT函数中 UInt uiRdModeList[FAST_UDI_MAX_RDMODE_NUM];
HM编码器代码阅读(39)——帧内预测（六）帧内预测之色度色度的操作
NB_vol_1的专栏
02-17 2085
色度分量的帧内预测 入口函数 对色度分量进行帧内预测的入口函数是：estIntraPredChromaQT 1、调用getAllowedChromaDir构造色度分量的帧内预测候选模式列表 2、遍历候选模式列表，对于每一个模式，调用xRecurIntraChromaCodingQT进行预测、变换量化操作，并得出率失真代价 3、通过比较率失真代价得到最优的模式 Voi
HM代码学习①批处理与生成测试结果
小惊大怪的博客
03-25 457
测试结果的保存、批处理及数据处理 一.测试结果的单一保存 这些天跑了一些程序，发现按照原始状态的话，得到的结果没法保存。刚开始只是跑着玩玩，认为只要把结果截图下来，然后进行处理。后来发现，这样的做法对测试一两个序列还是可以接受的，但当自已在测试多个序列时，工作量实在太大了，浪费了好多时间。于是，就想怎样使测试结果自已保存起来？网上搜了一下，发现了一个函数“freopen”,可以简单的实现测试结果的保存。即，将测试输出直接转化为TXT，保存在工程目录下（与生...
H.266/VVC代码学习：xRecurIntraCodingLumaQT函数
BigDream123的博客
02-07 1140
xRecurIntraCodingLumaQT函数主要是用来遍历上层函数传来的变换集，通过调用xIntraCodingTUBlock计算相应的失真，从而计算RD Cost，从而选出最佳变换。 具体代码注释如下： bool IntraSearch::xRecurIntraCodingLumaQT( CodingStructure &cs, Partitioner &partit...
hm编码工具使用_HM编码器代码阅读(1)——介绍以及相关知识
m0_54437879的博客
02-24 456
HM是HEVC(H.265)的开源实现，可以从网上直接下载。 HEVC(H.265)是新一代的视频编解码标准。 本人目前研究的只是编码器部分，而且还是入门阶段！为了提高自己，边学边记，由于理解不够深入，难免会有误，请见谅！ 本人现在使用的版本是15.0，最新版本好像已经到16.0了 文件的功能以及作用： AccessUnit.h 定义了存取单元(或者说访问单元)，实质是一个类型为NALUnitEBSP的list NAL.h 定义了NALUnit(NAL单元)和NALUnitEBSP(EBSP类型
HEVC函数入门（7）——帧内预测-详细概念和HM16.3实现（下）
不是他人太努力，只是自己努力不够罢了
06-21 3097
首先说明本文引自：http://blog.csdn.net/shaqoneal/article/details/44759561 这里我看的就没有上一篇那么懂了，所以很多地方都只是单纯的复制，另外也有一些个人的理解 （1）亮度帧内预测模式的预测 HEVC对每种PU大小共支持总计33种角度模式，外加上DC和平面模式。由于支持的模式更多，类似于H.264的单一最可能模式在HEVC中效率不高。HEV
HEVC函数入门（3）——参数命名及帧内预测
不是他人太努力，只是自己努力不够罢了
06-19 1282
前面看了几个函数，里面参数极其复杂，是不是眼花了，下面将整理一下CJL大神博客的部分内容。 http://blog.csdn.net/hevc_cjl/article/details/8170646 以及今天要看的帧内预测各种模式的实现 http://blog.csdn.net/shaqoneal/article/details/38225189 （1）类的命名： 一般来说，一个头文件只包
HTM-16.2代码（2）——帧间预测（理论）
Eyrane的博客
12-30 2097
一、帧间预测，利用相邻图像中已经编码的像素生成预测值 二、生成预测值之后，和原始的值相减，得到残差，后续的变换量化等操作就是基于残差进行处理的 三、主要原理是，为当前的PU在参考帧上寻找一个最佳的匹配块，这个找到的匹配块就可以当作预测值，这个过程就是运动估计。但是注意，运动估计不是一步就位的，它需要在整像素的基础上进行运动补偿（即进行插值），然后进行1/2、1/4像素精度的运动估计，最后得到最...
HEVC学习代码HM16.0
09-15
最新版本的HM代码,学习标准视频编码必备，HEVC代码
VVC学习之五——帧内预测：xRecurIntraCodingLumaQT()
Aidoneus_y
05-22 891
#if JVET_M0102_INTRA_SUBPARTITIONS void IntraSearch::xRecurIntraCodingLumaQT( CodingStructure &cs, Partitioner &partitioner, const double bestCostSoFar, const int subTuIdx, const PartSplit isp...
HM16.9代码阅读-帧内预测
shayashi的博客
10-13 1592
先推荐几篇帧内预测的文章： https://blog.csdn.net/shaqoneal/article/details/44856469 https://blog.csdn.net/nb_vol_1/article/details/51144828 https://blog.csdn.net/cpp12341234/article/details/46043615 和HEVC_CJL大神的帧内...
HEVC函数入门（8）——变换的实现
不是他人太努力，只是自己努力不够罢了
06-21 1926
前面我们讲的都是预测，下面开始变换的实现。 本文参考http://blog.csdn.net/shaqoneal/article/details/44856469 1、HM中Intra模式的主要实现逻辑 以Intra的亮度模式为例。主要实现代码实现于TEncSearch::estIntraPredQT方法中。TEncSearch::estIntraPredQT实现时，首先获取当前CU的分割子块
关于HM配置文件的TEncCfg类
小熊的专栏
01-07 2744
关于 class TEncCfg { protected: //==== File I/O ======== Int m_iFrameRate;//帧率 Int m_FrameSkip;//跳帧 Int m_iSourceWidth;//宽度 Int m_iSourceHeight;//高度 Int m_conf
HEVC/H.265整个程序调用流程分析以及函数复杂度分析
飞翔 视频直播系统
09-04 1万+
HEVC整个程序调用流程: Encode -> compressGOP -> compressCU ->xCompressCU->copyFromPicYuv ->xCheckRDCostIntra-> initEstData ->xCheckRDCostInter ->xCheckRDCostMerge2Nx2N ->getNumberOfWrittenBits ->copyToPi
帧内预测模式RDO
Buyi_Shizi的博客
03-12 1653
在对候选模式进行选择的时候，我们会用RDO方法选择最佳预测模式。帧内预测模式的RDO过程如下所述：     1，计算当前预测模式下的SSE，即残差平方和，作为RDO计算中的失真量。     2，计算当前预测模式下，编码TU所需要的比特数，这个是预测模式RDO的主要工作。需要进行编码的参数以及编码的过程如下面所述：     （1），编码PU参数，其实就是编码帧内预测模式     （2），编码
HEVC学习（十二） —— CU的最终划分
热门推荐
HEVC_CJL的专栏
12-09 2万+
相信会有不少人对如何确定CU最终的划分有所困惑（包括我在内，刚开始接触时也不知道该怎么做），我觉得很大的一个原因就是CU是递归划分的，这就导致在寻找确定最佳分割位置时比较困难。   其实，解决问题的办法说难也不难，关键在于思路的转换，既然对于xCompressCU中是如何保存划分模式的觉得难以理解，何不跳出这个小圈子寻找新的方法呢？   我们可以从解码器的角度来考虑，因为最终编码后的码流是
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值