音视频入门（1）——H.264视频码流分析

最新推荐文章于 2024-05-03 07:00:00 发布

永不秃头的程序员

最新推荐文章于 2024-05-03 07:00:00 发布

阅读量1.5k

点赞数 3

本文链接：https://blog.csdn.net/weixin_51178981/article/details/117917120

版权

文章目录

一、原理
二、h264编码格式
三、h264解码

这篇文章主要是对视频码流数据进行编辑
在这里插入图片描述

一、原理

H.264原始码流（又称为“裸流”）是由一个一个的NALU组成的。他们的结构如下图所示：
在这里插入图片描述
NALU (Network Abstraction Layer Unit) 翻译过来就是网络抽象层单元。在 H.264/AVC 视频编码标准中，所有的码流数据，最终都被封装成了一个一个的 NALU（Network Abstract Layer Unit）就是网络抽象层单元。

既然是视频流，那么NALU里面存放的必然有视频数据，除此之外，还有一些其他的信息，比如说时间戳，帧率，画面是否翻转等等信息。这些数据以每个NALU为一个单元，可以进行网络传输（推流），或者本地解码（播放）。

其中每个NALU之间通过startcode（起始码）进行分隔，起始码分成两种：0x000001（3Byte）或者0x00000001（4Byte）。
如果NALU对应的Slice为一帧的开始就用0x00000001，否则就用0x000001。

脱壳操作（防止竞争字节）：因为每个NALU都有对应的起始码，0x00000001或者0x000001,如果在一个NALU中间出现了相对应的的起始码的数据，这样是不是就把一个NALU给分成两个或者多个NALU了呢，所以我们要区别这中间数据。
两个字节（连续）的0，就插入一字节0x03。例如:

0x00 00 01  ==>  0x00 00 03 01
......
0x00 00 03   ==>   0x00 00 03 03

这样我们就区分开来了，但是我们在解码的时候又不能让增加的03留存下来，不然我们的数据就变了啊，所以解码的时候一定要排除03。

二、h264编码格式

H.264的功能分为两层：视频编码层（VCL, Video Coding Layer）和网络提取层（NAL, Network Abstraction Layer）
VCL数据即编码处理的输出，它表示被压缩编码后的视频数据序列。在VCL数据传输或存储之前，这些编码的VCL数据，先被映射或封装进NAL单元中。每个NAL单元包括一个原始字节序列负荷（RBSP, Raw Byte Sequence Payload）、一组对应于视频编码的NAL头信息。
RBSP的基本结构是：在原始编码数据的后面填加了结尾比特。一个bit“1”若干比特“0”，以便字节对齐。
像这样
在这里插入图片描述
下图是RBSP的类型和代表的作用描述。

三、h264解码

解码第一步就是找到对应的头，头信息里面有很多的类型，也代表不同的东西（我也不知道为啥有这么多东西），这也是雷神代码里面的第一个结构体，不同的数字代表不同的类型。
NAL头信息的隐藏比特位，在H.264编码器中默认为0，当网络识别到单元中存在比特错误时，可将其置为1。隐藏比特位主要用于适应不同种类的网络环境（比如有线无线相结合的环境）。
在这里插入图片描述
解码流程就是从NALU里面提取RBSP，然后再进行解码。

下面参考代码，来自于雷神，有些没看懂，也就没写注释
雷神源码


/*
本项目包含如下几种视音频测试示例：
* (1)像素数据处理程序。包含RGB和YUV像素格式处理的函数。
* (2)音频采样数据处理程序。包含PCM音频采样格式处理的函数。
* (3)H.264码流分析程序。可以分离并解析NALU。
* (4)AAC码流分析程序。可以分离并解析ADTS帧。
* (5)FLV封装格式分析程序。可以将FLV中的MP3音频码流分离出来。
* (6)UDP - RTP协议分析程序。可以将分析UDP / RTP / MPEG - TS数据包。
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef enum 
{
	NALU_TYPE_SLICE = 1,	//进入编码过程
	NALU_TYPE_DPA = 2,		//进入DPA编码
	NALU_TYPE_DPB = 3,		//....
	NALU_TYPE_DPC = 4,
	NALU_TYPE_IDR = 5,
	NALU_TYPE_SEI = 6,
	NALU_TYPE_SPS = 7,
	NALU_TYPE_PPS = 8,
	NALU_TYPE_AUD = 9,		
	NALU_TYPE_EOSEQ = 10,		//结束
	NALU_TYPE_EOSTREAM = 11,	//码流结束
	NALU_TYPE_FILL = 12,		//填充，保持字节对齐
}NaluType;

typedef enum
{
	NALU_PRIORITY_DISPOSABLE = 0,
	NALU_PRIRITY_LOW = 1,
	NALU_PRIORITY_HIGH = 2,
	NALU_PRIORITY_HIGHEST = 3,
}NaluPriority;

typedef struct
{
	int startcodeprefix_len;   		//起始码的长度
	unsigned len;                	//NALU单元长度，不包括起始码
	unsigned max_size;    			//缓冲区大小   
	int forbidden_bit;            	//
	int nal_reference_idc;        	//
	int nal_unit_type;           	//类型
	char* buf; 						//定义字符包含RSBP的第一个字节
}NALU_t;

FILE *h264bitstream = NULL;   

int info2 = 0, info3 = 0;

//判断是不是 0X000001
static int FindStartCode2(unsigned char* Buf)
{
	if (Buf[0] != 0 || Buf[1] != 0 || Buf[2] != 1)
	{
		return 0;
	}
	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;
	}
	else
	{
		return 1;
	}
}

//起始码的长度
int GetAnnexbNALU(NALU_t* nalu)
{
	int pos = 0;
	int StartCodeFound, rewind;
	unsigned char* Buf;
	//calloc与malloc类似但是calloc的内存可以设置为0，二而malloc的不会
	if ((Buf = (unsigned char*)calloc(nalu->max_size, sizeof(char))) == NULL)
	{
		printf("GetAnnexbNALU: Could not allocate Buf memory\n");
	}
	//第一个
	nalu->startcodeprefix_len = 3;
	if (3 != fread(Buf, 1, 3, h264bitstream))
	{
		free(Buf);
		return 0;
	}
	
	info2 = FindStartCode2(Buf);
	if (info2 != 1) {
		if (1 != fread(Buf + 3, 1, 1, h264bitstream)) {
			free(Buf);
			return 0;
		}
		info3 = FindStartCode3(Buf);
		if (info3 != 1) {
			free(Buf);
			return -1;
		}
		else {
			pos = 4;
			nalu->startcodeprefix_len = 4;
		}
	}
	else {
		nalu->startcodeprefix_len = 3;
		pos = 3;
	}
	StartCodeFound = 0;
	info2 = 0;
	info3 = 0;

	while (!StartCodeFound)
	{
		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;
		}
		Buf[pos++] = fgetc(h264bitstream);
		info3 = FindStartCode3(&Buf[pos - 4]);
		if (info3 != 1)
			info2 = FindStartCode2(&Buf[pos - 3]);
		StartCodeFound = (info2 == 1 || info3 == 1);
	}
	//另一个
	rewind == (info3 == 1) ? -4 : -3;
	if (0 != fseek(h264bitstream, rewind, SEEK_CUR))
	{
		free(Buf);
		printf("GetAnnexbNALU: Cannot fseek in the bit stream file");
	}
	//这里说过要减去起始码
	nalu->len = (pos + rewind) - nalu->startcodeprefix_len;
	memcpy(nalu->buf, &Buf[nalu->startcodeprefix_len], nalu->len);
	nalu->forbidden_bit = nalu->buf[0] & 0x80;
	nalu->nal_reference_idc = nalu->buf[0] & 0x60;
	nalu->nal_unit_type = (nalu->buf[0]) & 0x1f;
	free(Buf);
	return (pos + rewind);
}
//开始解码
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;
	}

	n = (NALU_t*)calloc(1, sizeof(NALU_t));
	if (n == NULL) 
	{
		printf("Alloc NALU Error\n");
		return 0;
	}

	n->max_size = buffersize;
	n->buf = (char*)calloc(buffersize, sizeof(char));
	if (n->buf == NULL)
	{
		free(n);
		printf("AllocNALU: n->buf");
		return 0;
	}
	int data_offset = 0;
	int nal_num = 0;
	printf("-----+-------- NALU Table ------+---------+\n");
	printf(" NUM |    POS  |    IDC |  TYPE |   LEN   |\n");
	printf("-----+---------+--------+-------+---------+\n");

	while (!feof(h264bitstream))
	{
		int data_lenth;
		data_lenth = GetAnnexbNALU(n);

		char type_str[20] = { 0 };
		switch (n->nal_unit_type)
		{
			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;
		}
		char idc_str[20] = { 0 };
		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;
		}

		fprintf(myout, "%5d| %8d| %7s| %6s| %8d|\n", nal_num, data_offset, idc_str, type_str, n->len);

		data_offset = data_offset + data_lenth;

		nal_num++;
	}

	//Free
	if (n) 
	{
		if (n->buf) 
		{
			free(n->buf);
			n->buf = NULL;
		}
		free(n);
	}
	return 0;
}

int main()
{
	simplest_h264_parser("sintel.h264");
	return 0;
}

在这里插入图片描述

永不秃头的程序员

关注

3
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
0
评论
音视频入门（1）——H.264视频码流分析

文章目录一、原理一、原理H.264原始码流（又称为“裸流”）是由一个一个的NALU组成的。他们的结构如下图所示：NALU (Network Abstraction Layer Unit) 翻译过来就是网络抽象层单元。在 H.264/AVC 视频编码标准中，所有的码流数据，最终都被封装成了一个一个的 NALU（Network Abstract Layer Unit）就是网络抽象层单元。既然是视频流，那么NALU里面存放的必然有视频数据，除此之外，还有一些其他的信息，比如说时间戳，帧率，画面是否翻转
复制链接

扫一扫