HM编码器代码阅读(11)——CU的初始化

最新推荐文章于 2020-07-28 15:19:15 发布
最新推荐文章于 2020-07-28 15:19:15 发布
阅读量3.4k 收藏 12
点赞数 4
分类专栏： HEVC编码器HM源码阅读 文章标签： H.265 c++ hevc 编码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nb_vol_1/article/details/51151983
版权
入口函数TComDataCU::initCU
主要流程：
（1）计算当前LCU在图像中的像素地址
（2）计算LCU可以被分成多少个4x4的CU
（3）把片的起始CU的地址存储起来
（4）设置每一个4x4子CU的参数信息
（5）设置当前LCU的左边、上方、右上角、左上角的相邻的LCU

（6）设置参考帧的数组

// 编码单元初始化
Void TComDataCU::initCU( TComPic* pcPic, UInt iCUAddr )
{
	// 当前CU所属的图像
	m_pcPic              = pcPic;
	// 当前CU所属的slice
	m_pcSlice            = pcPic->getSlice(pcPic->getCurrSliceIdx());
	// CU的地址
	m_uiCUAddr           = iCUAddr;
	// LCU在图像中的实际像素地址
	m_uiCUPelX           = ( iCUAddr % pcPic->getFrameWidthInCU() ) * g_uiMaxCUWidth;
	m_uiCUPelY           = ( iCUAddr / pcPic->getFrameWidthInCU() ) * g_uiMaxCUHeight;
	m_uiAbsIdxInLCU      = 0;
	// 总的RD消耗
	m_dTotalCost         = MAX_DOUBLE;
	// 总的失真
	m_uiTotalDistortion  = 0;
	// 总的比特数
	m_uiTotalBits        = 0;
	// 总的二进制数
	m_uiTotalBins        = 0;

	// 一帧图像最多可以分成256个CU（即深度是4,2^4 * 2^4 = 256）
	m_uiNumPartition     = pcPic->getNumPartInCU();

	// m_sliceStartCU初始化之后全都是0
	for(Int i=0; i<pcPic->getNumPartInCU(); i++)
	{
		if(pcPic->getPicSym()->getInverseCUOrderMap(iCUAddr)*pcPic->getNumPartInCU()+i>=getSlice()->getSliceCurStartCUAddr())
		{
			// 设置条带开始的CU的地址放到一个数组中
			m_sliceStartCU[i]=getSlice()->getSliceCurStartCUAddr();
		}
		else
		{
			// 获取slice中的所有CU，存放到一个数组中
			m_sliceStartCU[i]=pcPic->getCU(getAddr())->m_sliceStartCU[i];
		}
	}

	for(Int i=0; i<pcPic->getNumPartInCU(); i++)
	{
		if(pcPic->getPicSym()->getInverseCUOrderMap(iCUAddr)*pcPic->getNumPartInCU()+i>=getSlice()->getSliceSegmentCurStartCUAddr())
		{
			m_sliceSegmentStartCU[i]=getSlice()->getSliceSegmentCurStartCUAddr();
		}
		else
		{
			// 获取所有的条带片段中的CU，存放到数组中
			m_sliceSegmentStartCU[i]=pcPic->getCU(getAddr())->m_sliceSegmentStartCU[i];
		}
	}

	// getInverseCUOrderMap 这个函数是根据CU的地址获取CU的顺序索引
	Int partStartIdx = getSlice()->getSliceSegmentCurStartCUAddr() - pcPic->getPicSym()->getInverseCUOrderMap(iCUAddr) * pcPic->getNumPartInCU();

	// 元素的个数
	Int numElements = min<Int>( partStartIdx, m_uiNumPartition );
	for ( Int ui = 0; ui < numElements; ui++ )
	{
		TComDataCU * pcFrom = pcPic->getCU(getAddr());
		m_skipFlag[ui]   = pcFrom->getSkipFlag(ui);
		m_pePartSize[ui] = pcFrom->getPartitionSize(ui);
		m_pePredMode[ui] = pcFrom->getPredictionMode(ui);
		m_CUTransquantBypass[ui] = pcFrom->getCUTransquantBypass(ui);
		m_puhDepth[ui] = pcFrom->getDepth(ui);
		m_puhWidth  [ui] = pcFrom->getWidth(ui);
		m_puhHeight [ui] = pcFrom->getHeight(ui);
		m_puhTrIdx  [ui] = pcFrom->getTransformIdx(ui);
		m_puhTransformSkip[0][ui] = pcFrom->getTransformSkip(ui,TEXT_LUMA);
		m_puhTransformSkip[1][ui] = pcFrom->getTransformSkip(ui,TEXT_CHROMA_U);
		m_puhTransformSkip[2][ui] = pcFrom->getTransformSkip(ui,TEXT_CHROMA_V);
		m_apiMVPIdx[0][ui] = pcFrom->m_apiMVPIdx[0][ui];;
		m_apiMVPIdx[1][ui] = pcFrom->m_apiMVPIdx[1][ui];
		m_apiMVPNum[0][ui] = pcFrom->m_apiMVPNum[0][ui];
		m_apiMVPNum[1][ui] = pcFrom->m_apiMVPNum[1][ui];
		m_phQP[ui]=pcFrom->m_phQP[ui];
		m_pbMergeFlag[ui]=pcFrom->m_pbMergeFlag[ui];
		m_puhMergeIndex[ui]=pcFrom->m_puhMergeIndex[ui];
		m_puhLumaIntraDir[ui]=pcFrom->m_puhLumaIntraDir[ui];
		m_puhChromaIntraDir[ui]=pcFrom->m_puhChromaIntraDir[ui];
		m_puhInterDir[ui]=pcFrom->m_puhInterDir[ui];
		m_puhCbf[0][ui]=pcFrom->m_puhCbf[0][ui];
		m_puhCbf[1][ui]=pcFrom->m_puhCbf[1][ui];
		m_puhCbf[2][ui]=pcFrom->m_puhCbf[2][ui];
		m_pbIPCMFlag[ui] = pcFrom->m_pbIPCMFlag[ui];
	}

	// 第一个元素
	Int firstElement = max<Int>( partStartIdx, 0 );

	// 元素的个数
	numElements = m_uiNumPartition - firstElement;

	if ( numElements > 0 )
	{
		memset( m_skipFlag          + firstElement, false,                    numElements * sizeof( *m_skipFlag ) );

		memset( m_pePartSize        + firstElement, SIZE_NONE,                numElements * sizeof( *m_pePartSize ) );
		memset( m_pePredMode        + firstElement, MODE_NONE,                numElements * sizeof( *m_pePredMode ) );
		memset( m_CUTransquantBypass+ firstElement, false,                    numElements * sizeof( *m_CUTransquantBypass) );
		memset( m_puhDepth          + firstElement, 0,                        numElements * sizeof( *m_puhDepth ) );
		memset( m_puhTrIdx          + firstElement, 0,                        numElements * sizeof( *m_puhTrIdx ) );
		memset( m_puhTransformSkip[0] + firstElement, 0,                      numElements * sizeof( *m_puhTransformSkip[0]) );
		memset( m_puhTransformSkip[1] + firstElement, 0,                      numElements * sizeof( *m_puhTransformSkip[1]) );
		memset( m_puhTransformSkip[2] + firstElement, 0,                      numElements * sizeof( *m_puhTransformSkip[2]) );
		memset( m_puhWidth          + firstElement, g_uiMaxCUWidth,           numElements * sizeof( *m_puhWidth ) );
		memset( m_puhHeight         + firstElement, g_uiMaxCUHeight,          numElements * sizeof( *m_puhHeight ) );
		memset( m_apiMVPIdx[0]      + firstElement, -1,                       numElements * sizeof( *m_apiMVPIdx[0] ) );
		memset( m_apiMVPIdx[1]      + firstElement, -1,                       numElements * sizeof( *m_apiMVPIdx[1] ) );
		memset( m_apiMVPNum[0]      + firstElement, -1,                       numElements * sizeof( *m_apiMVPNum[0] ) );
		memset( m_apiMVPNum[1]      + firstElement, -1,                       numElements * sizeof( *m_apiMVPNum[1] ) );
		memset( m_phQP              + firstElement, getSlice()->getSliceQp(), numElements * sizeof( *m_phQP ) );
		memset( m_pbMergeFlag       + firstElement, false,                    numElements * sizeof( *m_pbMergeFlag ) );
		memset( m_puhMergeIndex     + firstElement, 0,                        numElements * sizeof( *m_puhMergeIndex ) );
		memset( m_puhLumaIntraDir   + firstElement, DC_IDX,                   numElements * sizeof( *m_puhLumaIntraDir ) );
		memset( m_puhChromaIntraDir + firstElement, 0,                        numElements * sizeof( *m_puhChromaIntraDir ) );
		memset( m_puhInterDir       + firstElement, 0,                        numElements * sizeof( *m_puhInterDir ) );
		memset( m_puhCbf[0]         + firstElement, 0,                        numElements * sizeof( *m_puhCbf[0] ) );
		memset( m_puhCbf[1]         + firstElement, 0,                        numElements * sizeof( *m_puhCbf[1] ) );
		memset( m_puhCbf[2]         + firstElement, 0,                        numElements * sizeof( *m_puhCbf[2] ) );
		memset( m_pbIPCMFlag        + firstElement, false,                    numElements * sizeof( *m_pbIPCMFlag ) );
	}

	UInt uiTmp = g_uiMaxCUWidth*g_uiMaxCUHeight;
	if ( 0 >= partStartIdx ) 
	{
		m_acCUMvField[0].clearMvField();
		m_acCUMvField[1].clearMvField();
		memset( m_pcTrCoeffY , 0, sizeof( TCoeff ) * uiTmp );
#if ADAPTIVE_QP_SELECTION
		memset( m_pcArlCoeffY , 0, sizeof( Int ) * uiTmp );  
#endif
		memset( m_pcIPCMSampleY , 0, sizeof( Pel ) * uiTmp );
		uiTmp  >>= 2;
		memset( m_pcTrCoeffCb, 0, sizeof( TCoeff ) * uiTmp );
		memset( m_pcTrCoeffCr, 0, sizeof( TCoeff ) * uiTmp );
#if ADAPTIVE_QP_SELECTION  
		memset( m_pcArlCoeffCb, 0, sizeof( Int ) * uiTmp );
		memset( m_pcArlCoeffCr, 0, sizeof( Int ) * uiTmp );
#endif
		memset( m_pcIPCMSampleCb , 0, sizeof( Pel ) * uiTmp );
		memset( m_pcIPCMSampleCr , 0, sizeof( Pel ) * uiTmp );
	}
	else 
	{
		TComDataCU * pcFrom = pcPic->getCU(getAddr());
		m_acCUMvField[0].copyFrom(&pcFrom->m_acCUMvField[0],m_uiNumPartition,0);
		m_acCUMvField[1].copyFrom(&pcFrom->m_acCUMvField[1],m_uiNumPartition,0);
		for(Int i=0; i<uiTmp; i++)
		{
			m_pcTrCoeffY[i]=pcFrom->m_pcTrCoeffY[i];
#if ADAPTIVE_QP_SELECTION
			m_pcArlCoeffY[i]=pcFrom->m_pcArlCoeffY[i];
#endif
			m_pcIPCMSampleY[i]=pcFrom->m_pcIPCMSampleY[i];
		}
		for(Int i=0; i<(uiTmp>>2); i++)
		{
			m_pcTrCoeffCb[i]=pcFrom->m_pcTrCoeffCb[i];
			m_pcTrCoeffCr[i]=pcFrom->m_pcTrCoeffCr[i];
#if ADAPTIVE_QP_SELECTION
			m_pcArlCoeffCb[i]=pcFrom->m_pcArlCoeffCb[i];
			m_pcArlCoeffCr[i]=pcFrom->m_pcArlCoeffCr[i];
#endif
			m_pcIPCMSampleCb[i]=pcFrom->m_pcIPCMSampleCb[i];
			m_pcIPCMSampleCr[i]=pcFrom->m_pcIPCMSampleCr[i];
		}
	}

	// Setting neighbor CU
	// 设置相邻CU
	m_pcCULeft        = NULL;			// 左边的CU
	m_pcCUAbove       = NULL;			// 上面的CU
	m_pcCUAboveLeft   = NULL;		// 左上方的CU
	m_pcCUAboveRight  = NULL;		// 右上方的CU

	// 位置数组，有两个元素
	m_apcCUColocated[0] = NULL;
	m_apcCUColocated[1] = NULL;

	// 获取一帧图片中，横向上CU的个数
	UInt uiWidthInCU = pcPic->getFrameWidthInCU();

	// 分别获取当前CU各个方向上相邻的CU

	// 如果CU地址不为图片上横向上CU个数的整数倍，那么它的左边有CU
	if ( m_uiCUAddr % uiWidthInCU )
	{
		m_pcCULeft = pcPic->getCU( m_uiCUAddr - 1 );
	}

	// 如果CU地址不为图像纵向上CU个数的整数倍，那么它的上方存在CU
	if ( m_uiCUAddr / uiWidthInCU )
	{
		m_pcCUAbove = pcPic->getCU( m_uiCUAddr - uiWidthInCU );
	}

	// 如果左边有CU，上方有CU，那么当前CU的上面有CU
	if ( m_pcCULeft && m_pcCUAbove )
	{
		m_pcCUAboveLeft = pcPic->getCU( m_uiCUAddr - uiWidthInCU - 1 );
	}

	// 如果上边有CU，而且当前CU不是当前行最后一个CU，那么它的右上角有CU
	if ( m_pcCUAbove && ( (m_uiCUAddr%uiWidthInCU) < (uiWidthInCU-1) )  )
	{
		m_pcCUAboveRight = pcPic->getCU( m_uiCUAddr - uiWidthInCU + 1 );
	}

	// getNumRefIdx从参考图片数组（数组0或1）获取参考图片的数量
	if ( getSlice()->getNumRefIdx( REF_PIC_LIST_0 ) > 0 )
	{
		m_apcCUColocated[0] = getSlice()->getRefPic( REF_PIC_LIST_0, 0)->getCU( m_uiCUAddr );
	}

	if ( getSlice()->getNumRefIdx( REF_PIC_LIST_1 ) > 0 )
	{
		m_apcCUColocated[1] = getSlice()->getRefPic( REF_PIC_LIST_1, 0)->getCU( m_uiCUAddr );
	}
}


NB_vol_1
关注
  • 4
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
HEVC视频编码调试环境HM9.0
10-06
2. **构建与运行**：使用Makefile或类似工具编译源代码，生成可执行的编码器和解码器程序。 3. **输入视频处理**：准备待编码的视频源文件，并根据需求配置编码参数，如比特率、分辨率、帧率等。 4. **编码与解码**...
改进《VVC/VTM中CU的划分结果打印》
pengyouyou的博客
03-22 4078
之前CU划分结果的打印：https://blog.csdn.net/pengyouyou/article/details/83152297 改进结果如下：四叉树（蓝色）、水平二叉树（绿色）、垂直二叉树（黄色）、水平三叉树（红色）和垂直三叉树（紫色）。 此结果在编码端实现，编码器下载地址：https://download.csdn.net/download/pengyouyou/110502...
HM编码器代码阅读(42)——率失真优化
NB_vol_1的专栏
02-20 3060
率失真优化 原理 一、率失真优化的目标就是： 1、在一定的码率（码率也表现为数据压缩的程度，码率越低，数据压缩的越厉害）限制下，减少视频的失真（减少失真就会提高视频的主观质量，看的人就会喜欢o(*≧▽≦)ツ）！ 2、在允许一定的失真下，把视频压缩到最小！ 二、编码器的率失真优化的工作主要是按照某种策略选取最优的编码参数，以实现最优的编码性能，某个模式下的率失真代价
统计编码HEVC（HM16.5）中CU的划分情况
qq_43404969的博客
10-10 615
Void TEncCu::init( TEncTop* pcEncTop ) { m_pcEncCfg = pcEncTop; m_pcPredSearch = pcEncTop->getPredSearch(); m_pcTrQuant = pcEncTop->getTrQuant(); m_pcRdCost ...
HEVC学习（十二） —— CU的最终划分
热门推荐
HEVC_CJL的专栏
12-09 2万+
相信会有不少人对如何确定CU最终的划分有所困惑（包括我在内，刚开始接触时也不知道该怎么做），我觉得很大的一个原因就是CU是递归划分的，这就导致在寻找确定最佳分割位置时比较困难。   其实，解决问题的办法说难也不难，关键在于思路的转换，既然对于xCompressCU中是如何保存划分模式的觉得难以理解，何不跳出这个小圈子寻找新的方法呢？   我们可以从解码器的角度来考虑，因为最终编码后的码流是
分析HM代码,首先必须把class TComDataCU完全搞明白!
飞翔 视频直播系统
11-29 1万+
分析HM代码,首先必须把class TComDataCU完全搞明白! 为了找到合适的模式或者合适的分割, 基本上都是采用两个TComDataCU来操作, TComDataCU*& rpcBestCU, TComDataCU*& rpcTempCU. 相当于两个指针对应两个乒乓buffer,  m_ppcBestCU[uiDepth], m_ppcTempCU[uiDepth], 当然每一个ui
HONEYWELL DCS HM 初始化资料.doc
10-20
【HONEYWELL DCS HM 初始化】是 Honeywell Distributed Control System (DCS) 中的一项重要操作，用于确保系统的正确配置和稳定运行。HM，可能是Honeywell Monitor或Human Machine Interface的缩写，是DCS系统中人机...
HM5.0——hevc测试代码最新版本
12-21
《HEVC测试代码详解——基于HM 5.0》 HEVC（High Efficiency Video Coding），即高效率视频编码，是继H.264/AVC之后的下一代视频压缩标准，旨在提供更高的压缩效率，降低视频存储和传输的需求。HM（Hevc Main Test ...
稀疏自编码器的参数初始化
08-16
UFLDL中训练稀疏编码器时，对参数初始化的标准程序，我只是翻译了注释
TComDataCU.h等主要类
zhuix7788的专栏
09-01 2821
/// Non-deblocking filter processing block border tag enum NDBFBlockBorderTag {   SGU_L = 0,   SGU_R,   SGU_T,   SGU_B,   SGU_TL,   SGU_TR,   SGU_BL,   SGU_BR,   NUM_SGU_BORDER }; ///
TComDataCU
tianzhijiaozi19的专栏
10-21 1627
/** \file TComDataCU.h \brief CU data structure (header) \todo not all entities are documented */ #ifndef _TCOMDATACU_ #define _TCOMDATACU_ #include // Include files #include "C
CU 级别的分析：TComDataCU
baidu_35812312的博客
04-27 1245
class TComDataCU { private: // ------------------------------------------------------------------------------------------------------------------- // class pointers // -----------...
H.265中针对scc的工具 -- transformskip
小小柴的博客
07-28 1783
transformskip和intra block copy, palatte mode 一样，是针对screen content 的编码工具，该工具的提出是因为对于screen content，其经常包含尖锐边缘或者跳变，相关性极差，这种情况下进行正常的transform反而会带来负面影响，还不如跳过变换环节，直接对残差进行量化。下面来直接看代码： if (pcCU->getTransformSkip(uiAbsPartIdx, compID) != 0)//开启transfor...
获得最终CU深度信息
u010289908的专栏
10-30 2263
参考了CJL的一些信息：http://blog.csdn.net/hevc_cjl/article/details/8275260 对CU最终的划分有些困惑主要原因是CU总是递归分割，这就导致了CU的分割位置比较难找寻，一直不懂HM是怎么把最后递归分割的那些cu的信息给一开始的CTU的，不过最近看着看着代码我也基本懂了，xcompresscu在递归分割后有这样一行代码：
HEVC函数入门（15）——重要变量以及CU索引
不是他人太努力，只是自己努力不够罢了
07-30 3401
本文整理自：1：http://blog.csdn.net/nb_vol_1/article/details/51145006 2：http://blog.csdn.net/NB_vol_1/article/details/71187426 首先感谢大神授权可以整理转载，后面会接着读大神的博客，所以后面一段时间里文章基本也是整理自这位大神。 1、TComDataCU。TComDataCU：LC
TComPicYuv、TComPic、TComPicSym、TComDataCU以及TComYuv的关系
NB_vol_1的专栏
05-04 5262
TComPicYuv、TComPic、TComPicSym、TComDataCU以及TComYuv的关系 首先用一张图来描述它们之间的关系 1、HM首先使用TComPicYuv保存从文件中读取出来的YUV数据 2、利用TComPicYuv构造TComPic，并把YUV数据复制给他（TComPic包含了TComPicYuv成员） 3、TComPic表示一帧图像，包含了
HEVC学习之琐事（三）：TEncCu::compressCU
成长Bar的博客专栏
11-07 2766
TEncCu::compressCU对应的代码如下：
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值