【H264/AVC 句法和语义详解】(七):C语言实现Exp-Golomb指数哥伦布编码(解码篇)

看过编码篇,再看这篇就容易多了。

不需多言,解码是编码的逆过程,以code_num = 5为例,我们将5通过指数哥伦布编码,编码为00110,然后再通过解码过程,将00110解码为5,这一过程也是描述子ue(v)干的事情。

同时,因为h264码流的解析,也是我们学习H.264/AVC 句法和语义所采取的路线。所以这篇文章就显得极其重要,学习了ue(v)、se(v)、te(v)的解码过程,再加上顺序读取n个比特的b(8)、f(n)、i(n)、u(n),我们就可以完全解析出sps、pps、slice_header的全部语法元素,和slice_data的部分语法元素。当然要解析出slice_data的全部语法元素,需要加上后面要学习的CAVLC和CABAC。

所以呢,学完了这篇文章,我们相当于在h264码流解析的道路上,又向前跨了重要的一步。话不多说,我们这就开始,当然我们还是从最重要的ue(v)的解码开始。

1. ue(v)的解码实现

在理论篇我们就知道,码字和被编码的code_num之间,有一个重要的公式:

codeNum = 2^leadingzerobits − 1 + read_bits( leadingZeroBits ) (1)

其中leadingZeroBits,就是码字中,第一个比特值为1的前面0的个数,也即前导零个数。而 read_bits( leadingZeroBits ),则是从这第一个1后面,再顺序读取leadingZeroBits个比特。

比如我们以code_num = 9为例,它的码字为:0001010,前导零leadingZeroBits = 3, read_bits( leadingZeroBits )结果为末尾的两个比特:010,010的十进制值为2。这样一来:

codeNum = 2^3 - 1 + 2 = 9

整个过程可以分为:

【H264/AVC 句法和语义详解】(七):C语言实现Exp-Golomb指数哥伦布编码(解码篇)_第1张图片

也即两步:

第一步:每次读取一个比特,如果是0就继续读,直至读到1为止,此时读取比特的个数即leadingZeroBits
第二步:从第一步读到的比特1后,再顺序读leadingZeroBits比特

然后代入公式(1)计算可得codeNum,所以ue(v)的实现为:

/**
ue(v) 解码
*/
uint32_t bs_read_ue(bs_t* b)
{
	int32_t r = 0; // 解码得到的返回值
	int i = 0;     // leadingZeroBits
	
	// 1.计算leadingZeroBits
	while( (bs_read_u1(b) == 0) && (i < 32) && (!bs_eof(b)) )
	{
		i++;
	}
	// 2.计算read_bits( leadingZeroBits )
	r = bs_read_u(b, i);
	// 3.计算codeNum,1 << i即为2的i次幂
	r += (1 << i) - 1;
	return r;
}

其中bs_read_u1()的实现也很简单,就是顺序读取1个比特:

/** 读取1个比特 */
uint32_t bs_read_u1(bs_t* b)
{
	uint32_t r = 0; // 读取比特返回值
	// 1.剩余比特先减1
	b->bits_left--;
	if (! bs_eof(b))
	{
		// 2.计算返回值
		r = ((*(b->p)) >> b->bits_left) & 0x01;
	}
	// 3.判断是否读到字节末尾,如果是指针位置移向下一字节,比特位初始为8
	if (b->bits_left == 0) { b->p ++; b->bits_left = 8; }
	return r;
}

其中第二步可分为三步:

1*(b->p):取出指针(b->p)位置处的值
(2(*(b->p)) >> b->bits_left:将第(1)步的值右移b->bits_left位,也即将待处理比特位,移至最低位
(3((*(b->p)) >> b->bits_left) & 0x01:按位与计算,只保留第(2)步的最低位比特值,其他比特位全部置为0

bs_read_u()的实现也很简单,就是顺序读取n个比特:

/**
读取n个比特
@param b 比特流操作句柄
@param n 读取多少个比特
@return 返回读取到的值
*/
uint32_t bs_read_u(bs_t* b, int n)
{
	uint32_t r = 0; // 读取比特返回值
	int i;  // 当前读取到的比特位索引
	for (i = 0; i < n; i++)
	{
		// 1.每次读取1比特,并依次从高位到低位放在r中
		r |= ( bs_read_u1(b) << ( n - i - 1 ) );
	}
	return r;
}

其中的主要步骤为循环里的读取操作,它分为四步:

1bs_read_u1(b):顺序读取1个比特
(2bs_read_u1(b) << ( n - i - 1 ):将第(1)步的值移至r的( n - i - 1 )位,考虑到for循环 i 值每次加1,也即将每次读到的比特值,从高位到低位顺序放在r中
(3)r | ( bs_read_u1(b) << ( n - i - 1 ) ):按位或计算新的r值,这样既不影响之前放在r中的比特位值,又能将新读取的值加入进来
(4)r = ( bs_read_u1(b) << ( n - i - 1 ) ):赋值给r

2. se(v)的解码实现

因为se(v)的编码过程,是将有符号的整数,变换后使用ue(v)进行编码,因此se(v)的解码过程可分为两步:

第一步,通过bs_read_ue(),获取codeNum的值。
第二步:根据codeNum的奇偶性,计算出se(v)编码前的值
/**
se(v) 解码
*/
int32_t bs_read_se(bs_t* b)
{
	// 1.解码出codeNum,记为r
	int32_t r = bs_read_ue(b);
	// 2.判断r的奇偶性
	if (r & 0x01) // 如果为奇数,说明编码前>0
	{
		r = (r+1)/2;
	}
	else // 如果为偶数,说明编码前<=0
	{
		r = -(r/2);
	}
	return r;
}

奇偶性判断完之后的处理,为编码过程的逆处理,不熟悉的同学可以参考下编码篇。

3. te(v)的解码实现

te(v)也与编码过程一致,首先要做的就是判断语法元素的取值范围,在这里也即判断输入参数x的取值

/**
te(v) 解码
*/
uint32_t bs_read_te( bs_t *b, int x )
{
	// 1.判断取值上限
	if( x == 1 ) // 如果为1则将读取到的比特值取反
	{
		return 1 - bs_read_u1( b );
	}
	else if( x > 1 ) // 否则按照ue(v)进行解码
	{
		return bs_read_ue( b );
	}
	return 0;
}

4. 测试

测试过程很简单,调用一次即解码一个值,但是有一点需要注意,就是假如我们用同一个bs_t句柄测试完编码后,又测试解码,需要将bs_t中的指针位置和剩余比特,重置至初始位置

即:

// 设置比特流句柄指针至初始位置
bs->p = buffer;
bs->bits_left = 8;

本文源码地址如下(含编码和解码):

1、GitHub:https://github.com/Gosivn/Exp-Golomb-C-implementation

2、CSDN:https://download.csdn.net/download/u011399342/10332229

简单代码实现:

#include 
#include 
using namespace std;
 
typedef unsigned char uint8_t;
typedef unsigned int  uint32_t;
typedef struct
{
	uint8_t *start; // 指向buf头部指针
	uint8_t *p;     // 当前指针位置
	uint8_t *end;   // 指向buf尾部指针
	int bits_left;  // 当前读取字节的剩余可用比特个数
} bs_t;
//函数申明
int bs_eof(bs_t* b);
void read_bit(unsigned char b);
 
//
bs_t* bs_init(bs_t* b, uint8_t* buf, size_t size)
{
	b->p = buf;      // 初始位置与start保持一致
	b->bits_left = 8;   // 默认剩余8比特可用
	return b;
}
 
bs_t* bs_new(uint8_t* buf, size_t size)
{
	bs_t* b = (bs_t*)malloc(sizeof(bs_t));
	bs_init(b, buf, size);
	return b;
}
 
void bs_free(bs_t* b)
{
	free(b);
}
 
void bs_write_u1(bs_t* b, uint32_t v)
{
	// 1.剩余比特先减1
	b->bits_left--;
	if (! bs_eof(b))
	{
		cout<<v;
		// 2.见文章
		*(b->p) <<= 1;
		*(b->p) |= (v & 0x01);
	}
	// 3.判断是否写到字节末尾,如果是指针位置移向下一字节,比特位初始为8
	if (b->bits_left == 0) {
		b->p++;
		b->bits_left = 8;//这样就保证了每次写入不会受比特的影响
	}
}
 
/** 是否已读到末尾(end_of_file) */
int bs_eof(bs_t* b)
{
	if (b->p >= b->end) {
		return 1;
	} else {
		return 0;
	}
}
 
/**
写入n个比特
@param b 比特流操作句柄
@param n 参数v所需的比特位个数
@param v 待写入的值
*/
void bs_write_u(bs_t* b, int n, uint32_t v)
{
	int i;
	//cout<< "n=" << n << "v=" << v <
	cout<<"转换后的数:";
	for (i = 0; i < n; i++)
	{
		// 循环调用bs_write_u1(),写入 v 的后 n 个比特
		bs_write_u1(b, (v >> ( n - i - 1 ))&0x01 );
	}
	cout<<endl;

}
 
/**ue(v) 无符号指数哥伦布编码*/
unsigned int bs_write_ue( bs_t *b, unsigned int val)
{
	// val + 1所需的比特个数
	int i_size = 0;
	// 1.值为0~255时,所需的比特位个数表
	static const int i_size0_255[256] =
	{
		1,      // 0的二进制所需的比特个数
		1,      // 1的二进制所需的比特个数
		2,2,    // 2~3的二进制所需的比特个数
		3,3,3,3,    // 4~7的二进制所需的比特个数
		4,4,4,4,4,4,4,4,  // 8~15的二进制所需的比特个数
		5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,  // 16~31的二进制所需的比特个数
		6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,  // 32~63的二进制所需的比特个数
		6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
		7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,  // 64~127的二进制所需的比特个数
		7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
		7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
		7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,
		8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,  // 128~255的二进制所需的比特个数
		8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
		8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
		8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
		8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
		8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
		8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
		8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
	};
	
	if( val == 0 ) // 输入为0,直接编码为1
	{
		bs_write_u1( b, 1 );
	}
	else
	{
		// 1.指数哥伦布编码第一步,先把输入值+1
		unsigned int tmp = ++val;
		
		// 2.判断所需比特个数是否大于16位
		if( tmp >= 0x00010000 )
		{
			i_size += 16;
			tmp >>= 16;
		}
		
		// 3.判断此时所需比特个数是否大于8位
		if( tmp >= 0x100 )
		{
			i_size += 8;
			tmp >>= 8;
		}
		
		// 4.最终tmp移位至8位以内,去查表
		i_size += i_size0_255[tmp];
		
		// 5.最终得出编码val所需的总比特数:2 * i_size - 1
		// 写入Buffer
		bs_write_u( b, 2 * i_size - 1, val );
		return (2 * i_size - 1);
	}
}
 
void my_print(unsigned char *s, unsigned int n)
{
	int j;
	int i;
	unsigned int num;
	i = n % 8; //16进制中每3位为一个字节,为8
	//printf("n = %u\n", n);
	num = (n >> 3) + 1;//占用几个数组元素
	j = 0;
	while (j < num) {
	
		if (j == num - 1) i = n % 8;//最高的一个字节不需要移8位
		else              i = 8;
		//printf("j = %d i = %d num = %d\n", j, i, num);
		for (; i > 0; i--) {
			cout<< ((s[j] >> (i - 1)) & 0x01) ;
		}		
		++j;
	}
	cout<<endl;
}
 
/**
ue(v) 解码 **************************************************************
*/
void my_decode(unsigned char *s, unsigned int n)
{
	int j;
	int i;
	unsigned int num;
	i = n % 8; //16进制中每3位为一个字节,为8
	//printf("n = %u\n", n);
	num = (n >> 3) + 1;//占用几个数组元素
	j = 0;
	while (j < num) {
	
		if (j == num - 1) i = n % 8;//最高的一个字节不需要移8位
		else              i = 8;
		//printf("j = %d i = %d num = %d\n", j, i, num);
		for (; i > 0; i--) {
			//cout<< "解码" <<((s[j] >> (i - 1)) & 0x01) <
			read_bit( ((s[j] >> (i - 1)) & 0x01) );
		}		
		++j;
	}
	cout<<endl;
}
void read_bit(unsigned char b)
{
	static unsigned int i = 0;
	static unsigned int j = 0;
	static bool is = false;//用来判断是否找到一个有用的数据
	if ((b == 0x00) && (!is)) {
		i++;
	}else if ((b == 0x01) && (!is)) {
		is = true;
		j = (j << 1) + b;
	}else if ((i > 0) && (is)) {
		i--;
		j = (j << 1) + b;
		if ((i <= 0) && (is)) {
			is = false; //关上
			cout<<j - 1;
			j = 0;
		}
	}
}
 
int main()
{	
	uint8_t buf[64] = {0};
	unsigned int i;
	memset(buf, 0, sizeof(buf));
	bs_t *pb = bs_new(buf, sizeof(buf));
	unsigned int j = 0;
	while (1) {
		cout<<"输入:";
		cin>> i;
		j += bs_write_ue(pb, i);
		cout<<"输出整个数据流:";
		my_print((unsigned char*)buf, j);
		cout<<"解码:";
		my_decode((unsigned char*)buf, j);
		//memset(buf, 0, sizeof(buf));
	}
	bs_free(pb);
	return 0;
}

运行结果:

输入:1
转换后的数:010
输出整个数据流:010
解码:1
输入:2
转换后的数:011
输出整个数据流:010011
解码:12
输入:3
转换后的数:00100
输出整个数据流:01001100100
解码:123
输入:4
转换后的数:00101
输出整个数据流:0100110010000101
解码:1234

你可能感兴趣的:(视频编解码,H264,C语言,指数哥伦布,编码)