基础文献：
通过上面几篇不错的博客，对h264有了初步的认识。下面记录下学习 雷霄骅---H.264视频码流解析 里面的代码后，明白了如何从h264中的字节数据中获得每个NALU和它里面的每个参数。
首先要明白h264是通过startcode（起始码）进行分隔00 00 00 01或者00 00 01将二进制数据切分为一段段字节。而每一段字节就是一个NALU。
h264 字节数据图：
NALU 结构体：
typedef struct
{
int startcodeprefix_len; //! 值为4表示参数集和图片中的第一个切片，3表示其他所有内容（建
议）
unsigned len; //! NAL单元的长度（不包括不属于NALU的起始代码）
unsigned max_size; //! Nalu单位缓冲区大小，即最大缓存几个字节
int forbidden_bit; //! 禁止位，初始为0，当网络发现NAL单元有比特错误时可设置该比特
为1，以便接收方纠错或丢掉该单元。
在 H.264 规范中规定了这一位必须为 0
int nal_reference_idc; //! 表示NALU的优先级。
0--3，取值越大，该NALU越重要，需要优先保护
00值表示该NALU不用于帧间图像预测重构参考图像，可以
丢弃不用冒参考图像完整性风险。
如果NALU是参考帧slice、PPS、SPS时，该值必须大于0
解码器在解码处理不过来的时候，可以丢掉重要性为0的
NALU。
int nal_unit_type; //! NALU类型
char *buf; //! 缓存区大小===(char*)calloc (max_size, sizeof (char))
} NALU_t;
下面我将以上图的数据举例：
startcodeprefix_len-----等于startcode（起始码）的字节数，如果是00 00 00 01则为4，是00 00 01为3
len -------等于一个NALU中的字节数,即两个startcode（起始码）之间的字节数。如上图h264 字节数据图中第一个startcode和第 二个之间有25个字节，表示第一个NALU的大小为25Byte
max_size-------等于这个是开发者自己设置的
buf--------等于NALU字节数据，如上图h264 字节数据图中：第一个NALU的为：67 64 .。。。。。2D 96的25个字节数据。
最后还剩下三个：
forbidden_bit、nal_reference_idc、nal_unit_type
它们的取值都是来自于NALU的第一个字节中的不同位。
forbidden_bit---------等于NALU的第一个字节的前1位的值。h264一定为0（1bit）
nal_reference_idc---------等于NALU的第一个字节的前2位的值。（2bit）
nal_unit_type---------等于NALU的第一个字节的最后5位的值。（5bit）
如上图h264 字节数据图中：第一个NALU的第一个字节为67，这个是16进制表示的，转换为二进制位-----01100111，取第一位0（后面补位7个0），（即10进制的0），给forbidden_bit。取前两个位11（后面补位5个0），（即10进制的96）给nal_reference_idc，最后5位00111（即10进制的7）给nal_unit_type。代码如下：
// 0x80===10000000
// 0x60===01100000
// 0x1f===00011111
//取一个Byte的第一位----0或者1
nalu->forbidden_bit = nalu->buf[0] & 0x80; //1 bit
//取第二位和第三位的组合---96，64，32，0，
//提醒下：由于nal_reference_idc的取值范围是0---3
//所以在使用时要nal_reference_idc>>5将其降为0到3的取值区间
nalu->nal_reference_idc = nalu->buf[0] & 0x60; // 2 bit
//取最后五位的组合
nalu->nal_unit_type = (nalu->buf[0]) & 0x1f;// 5 bitok,分析完毕，还需要去了解下h264防止竞争机制。
感谢雷霄骅的代码教学。最后是在他的代码上加入了我的注解。希望对自己以后复习和入门的人有帮助。
/**
* Analysis H.264 Bitstream
* @param url Location of input H.264 bitstream file.
*/
int simplest_h264_parser(char *url){
NALU_t *n;
int buffersize=100000;
//FILE *myout=fopen("output_log.txt","wb+");
FILE *myout=stdout;
h264bitstream=fopen(url, "rb+");
if (h264bitstream==NULL){
printf("Open file error\n");
return 0;
}
//calloc申请一个单位为NALU_t的空间，并对空间逐一进行初始化，设置值为0。
//malloc申请后空间的值是随机的，并没有进行初始化
n = (NALU_t*)calloc (1, sizeof (NALU_t));
if (n == NULL){
printf("Alloc NALU Error\n");
return 0;
}
//设置可以缓存几个NALU
n->max_size=buffersize;
//申请buffersize个单位为sizeof (char）的缓存空间，
//每次读取NALU_t大小的数据到buf中，这意味着后一个NALU_t会覆盖前一个NALU_t
n->buf = (char*)calloc (buffersize, sizeof (char));
if (n->buf == NULL){
free (n);
printf ("AllocNALU: n->buf");
return 0;
}
int data_offset=0;
//记录nalu的个数
int nal_num=0;
//nal_reference_bit=====nrb
//forbidden_bit======FB
printf("-----+---------+--------+----NALU Table---+---------+---------+\n");
printf(" NUM | POS | IDC | TYPE | LEN | NRI | FB |\n");
printf("-----+---------+--------+-------+---------+---------+---------+\n");
int data_lenth;
char type_str[20];
char idc_str[20];
while(!feof(h264bitstream))
{
//从文件中读取一个nal，分析数据并赋值到结构体，然后返回已经从文件中读取的所有数据大小
data_lenth=GetAnnexbNALU(n);
memset(type_str, 0, 20); //清零
//判断nal_unit_type的类型
switch(n->nal_unit_type){
//1
case NALU_TYPE_SLICE:sprintf(type_str,"SLICE");break;
case NALU_TYPE_DPA:sprintf(type_str,"DPA");break;
case NALU_TYPE_DPB:sprintf(type_str,"DPB");break;
case NALU_TYPE_DPC:sprintf(type_str,"DPC");break;
case NALU_TYPE_IDR:sprintf(type_str,"IDR");break;
case NALU_TYPE_SEI:sprintf(type_str,"SEI");break;
case NALU_TYPE_SPS:sprintf(type_str,"SPS");break;
case NALU_TYPE_PPS:sprintf(type_str,"PPS");break;
case NALU_TYPE_AUD:sprintf(type_str,"AUD");break;
case NALU_TYPE_EOSEQ:sprintf(type_str,"EOSEQ");break;
case NALU_TYPE_EOSTREAM:sprintf(type_str,"EOSTREAM");break;
case NALU_TYPE_FILL:sprintf(type_str,"FILL");break;
default:
sprintf(type_str, "default");
}
memset(idc_str, 0, 20); //清零
//将其取值范围控制在0-3之间
switch(n->nal_reference_idc>>5){
case NALU_PRIORITY_DISPOSABLE:sprintf(idc_str,"DISPOS");break;
case NALU_PRIRITY_LOW:sprintf(idc_str,"LOW");break;
case NALU_PRIORITY_HIGH:sprintf(idc_str,"HIGH");break;
case NALU_PRIORITY_HIGHEST:sprintf(idc_str,"HIGHEST");break;
}
//%8d----表示预留8个d，对齐
fprintf(myout, "%5d| %8d| %7s| %6s| %8d| %8d| %8d|\n", nal_num, data_offset, idc_str, type_str, n->len, n->nal_reference_idc, n->forbidden_bit);
data_offset=data_offset+data_lenth;
nal_num++;
}
//Free
if (n){
if (n->buf){
free(n->buf);
n->buf=NULL;
}
free (n);
}
system("pause");
return 0;
}
int GetAnnexbNALU (NALU_t *nalu){
// 偏移位置
int pos = 0;
int StartCodeFound, rewind;
unsigned char *Buf;
//创建100000个字节的缓存区,用于存放从文件中读取的数据
if ((Buf = (unsigned char*)calloc (nalu->max_size , sizeof(char))) == NULL)
printf ("GetAnnexbNALU: Could not allocate Buf memory\n");
nalu->startcodeprefix_len=3;
//FILE *outFile = fopen("h264_outFile.h264");
//h264bitstream----h264视频流
//fread-----返回的是成功有效的读取的item元素的个数
//先取三个字节
if (3 != fread (Buf, 1, 3, h264bitstream)){
free(Buf);
return 0;
}
//判断是否是0x000001开头
info2 = FindStartCode2 (Buf);
//如果不是0x000001开头
if(info2 != 1) {
//再读取一位，现在Buf中有4个字节
if(1 != fread(Buf+3, 1, 1, h264bitstream)){
free(Buf);
return 0;
}
//判断是不是0x00000001开头的
info3 = FindStartCode3 (Buf);
//如果还不是，则不满足h264编码规则，退出
if (info3 != 1){
free(Buf);
return -1;
}else {
pos = 4;
nalu->startcodeprefix_len = 4;
}
}else{
nalu->startcodeprefix_len = 3;
pos = 3;
}
StartCodeFound = 0;
//全局int类型，
//标记是否是0x000001开头的，0表示不是
info2 = 0;
//标记是否是0x00000001开头的，0表示不是
info3 = 0;
//寻找开始的code
while (!StartCodeFound){
//判断流是否结束，结束返回true
if (feof (h264bitstream)){
nalu->len = (pos-1)-nalu->startcodeprefix_len;
memcpy (nalu->buf, &Buf[nalu->startcodeprefix_len], nalu->len);
nalu->forbidden_bit = nalu->buf[0] & 0x80; //1 bit
nalu->nal_reference_idc = nalu->buf[0] & 0x60; // 2 bit
nalu->nal_unit_type = (nalu->buf[0]) & 0x1f;// 5 bit
free(Buf);
return pos-1;
}
//流未结束
//读取一个字节的h264bitstream添加到Buf
Buf[pos++] = fgetc (h264bitstream);
//取Buf倒数第四个存储地址，检验最后四字节是否0x00000001？是，返回1
info3 = FindStartCode3(&Buf[pos-4]);
//如果不是是0x00000001
if (info3 != 1){
//取Buf倒数第三个存储地址，检验最后三字节是否0x000001？ 是，返回1
info2 = FindStartCode2(&Buf[pos - 3]);
}
//是否是发现了开始的code
StartCodeFound = (info2 == 1 || info3 == 1);
}
// Here, we have found another start code (and read length of startcode bytes more than we should
// have. Hence, go back in the file
rewind = (info3 == 1)? -4 : -3;
if (0 != fseek (h264bitstream, rewind, SEEK_CUR)){
free(Buf);
printf("GetAnnexbNALU: Cannot fseek in the bit stream file");
}
// Here the Start code, the complete NALU, and the next start code is in the Buf.
// The size of Buf is pos, pos+rewind are the number of bytes excluding the next
// start code, and (pos+rewind)-startcodeprefix_len is the size of the NALU excluding the start code
//计算出两个开始code(0x00000001或0x000001)之间的字节数
nalu->len = (pos+rewind)-nalu->startcodeprefix_len;
//将两个开始code(0x00000001或0x000001)之间的字节数据拷贝到bufnalu->buf中
memcpy (nalu->buf, &Buf[nalu->startcodeprefix_len], nalu->len);
// 0x80===10000000
// 0x60===01100000
// 0x1f===00011111
//取一个Byte的第一位----0或者1
nalu->forbidden_bit = nalu->buf[0] & 0x80; //1 bit
//取第二位和第三位的组合---96，64，32，0，我们可以>>5将其降为0到3的取值区间
nalu->nal_reference_idc = nalu->buf[0] & 0x60; // 2 bit
//取最后五位的组合
nalu->nal_unit_type = (nalu->buf[0]) & 0x1f;// 5 bit
free(Buf);
return (pos+rewind);
}FILE *h264bitstream = NULL; //!< the bit stream file
int info2=0, info3=0;
//判断是否是0x000001
static int FindStartCode2 (unsigned char *Buf){
if(Buf[0]!=0 || Buf[1]!=0 || Buf[2] !=1) return 0; //0x000001?
else return 1;
}
//判断是否是0x00000001
static int FindStartCode3 (unsigned char *Buf){
if(Buf[0]!=0 || Buf[1]!=0 || Buf[2] !=0 || Buf[3] !=1) return 0;//0x00000001?
else return 1;
}
扫一扫
734
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
