H264码流插入和读取自定义数据（SEI字段）

news/2024/7/10 21:12:35 标签: 音视频, ffmpeg

目录

  • 1. 前言
  • 2. H264码流结构
    • 2.1 文字说明
    • 2.2 码流格式图解
  • 3. 自定义数据封装以及H264码流插入
    • 3.1 将自定义数据封装成SEI字段通用格式即可插入H264码流中
    • 3.2 编码逻辑
  • 4. 代码
  • 5. 总结

1. 前言

本文主要记录，如何在已有的H264码流中插入自定义的数据，并且不破坏H264码流结构，改造后的H264码流可以通过解码器正常解析出来，插入的自定义数据对H264码流解析不造成任何影响。
代码在文末附上，基于C/C++实现。

2. H264码流结构

2.1 文字说明

（1）H264码流，是由一个个独立的数据块NALU组成，NALU数据块之间相互关联，NALU数据块的顺序不可以调换，但NALU数据块之间可以插入指定格式的数据，理论上插入数据的长度不限。
（2）解码器在解码时，首先遍历码流中的Start code（00 00 00 01），找到Start code后紧跟着解析NALU单元，解析时从前往后遍历，直至找到下一个Start code，并开始下一帧NALU单元的解析。
（3）H264码流中插入自定义数据，首先将自定义数据按特定的格式封装成一个数组，然后在码流的每个I帧或者P帧之前插入自定义数据即可

2.2 码流格式图解

在这里插入图片描述
图2.1 H264码流基础数据块
在这里插入图片描述
图2.2 H264码流数据块组合示例

3. 自定义数据封装以及H264码流插入

3.1 将自定义数据封装成SEI字段通用格式即可插入H264码流中

在这里插入图片描述
图3.1 自定义数据封装格式

SEI字段自定义封装包格式为：

Start code：每个NALU单元的起始码
NRI：高四位的第一位为禁止位0，决定该NALU单元是否有效；高四位中间两位表示该NALU单元的重要程度，解码时根据该数值决定该NALU单元解析或丢弃。高四位的最后一位与低四位组成NALU单元识别码，06表示该单元为SEI字段。
payload type：05表示该SEI字段的编码格式符合H264标准格式
UUID：用户自定义的识别码，16字节长度，只要不与Start code冲突即可
自定义数据长度：用两个字节表示封装自定义数据的长度，解码时依据该数值做校验
自定义数据：用户自己封装的数据，类型必须为unsigned char
结尾对齐码：80表示SEI字段的结束对齐

3.2 编码逻辑

对H264码流进行for循环遍历，依据Start code 以及NALU头识别NALU单元类型，当识别到I帧或P帧时，将封装好的SEI数据包直接插入

4. 代码

h264Process.h

#include <stdio.h>
#include <string.h>
// uuid: 54 80 83 97 f0 23 47 4b b7 f7 4f 32 b5 4e 06 ac
// 定义SEI格式固定识别码
namespace SEI{
    static unsigned char start_code[] = {0x00,0x00,0x00,0x01};  //起始码
    static unsigned char sei_uuid[] = { 0x54, 0x8f, 0x83, 0x97, 0xf3, 0x23, 0x97, 0x4b, 
                                        0xb7, 0xc7, 0x4f, 0x3a, 0xb5, 0x6e, 0x89, 0x52 };   //自定义标识码
    static int sei_uuid_size = sizeof(sei_uuid);    //自定义标识码长度
    static unsigned char nal_type = 0x06;   //NAL类型,0x06标识该NAL单元为SEI
    static unsigned char payload_type = 0x05;   //0x05标识当前SEI编码格式为标准格式
    static unsigned char sei_tail = 0x80;   //SEI结尾对齐码
}
// 定位当前位置是否为SEI起始位置，返回值为SEI字段长度
int FindSei(unsigned char* h264_buf, int cur_index,int buf_size);

// 定位当前位置是否为I帧起始位置，若当前字节为I帧开始，返回1，否则返回0
int IFramelocat(unsigned char* h264_buf, int cur_index,int buf_size);

// 定位当前位置是否为P帧起始位置，若当前字节为P帧开始，返回1，否则返回0
int PFramelocat(unsigned char* h264_buf, int cur_index,int buf_size);

// 读取H264码流buffer,删除码流中原始SEI字段，并插入用户自定义数据，写入tmp文件中
int H264DelSeiInsertSeiBeforeFrame(unsigned char* h264_buf,int buf_size,unsigned char* sei_buf,int sei_buf_size,FILE *tmp);

// 将用户自定义数据user_data按照SEI格式封装进sei_buffer里
int FillSeiPacket(unsigned char* sei_buffer, int sei_size, unsigned char* user_data, int user_data_size);

// 从H264码流中解析SEI封装包，并从SEI封装包中解析用户数据
int H264GetSeiUserdata(unsigned char* h264_buf, int h264_buf_size, unsigned char* user_buf, int user_buf_size);

h264Process.cpp

#include "h264Process.h"

int FindSei(unsigned char* h264_buf, int cur_index,int buf_size){
    int cur_index_bak = cur_index;
    if(cur_index > buf_size-5)  return 0;
    else if(h264_buf[cur_index]==0x00 && h264_buf[cur_index+1]==0x00 && h264_buf[cur_index+2]==0x00 
                                 && h264_buf[cur_index+3]==0x01 && h264_buf[cur_index+4]==0x06)
    {   cur_index += 5;
        while(cur_index < buf_size){
            if(h264_buf[cur_index]==0 && h264_buf[cur_index+1]==0 && h264_buf[cur_index+2]==0 && h264_buf[cur_index+3]==1)
                break;
            else
                ++cur_index;
        }
        // printf("cur_index:%d,cur_index_bak:%d,len is:%d\n",cur_index,cur_index_bak,cur_index-cur_index_bak);
        return cur_index-cur_index_bak;   //如果找到SEI字段，返回SEI字段长度
    }
    else return cur_index-cur_index_bak;  //如果没找到SEI字段，则返回0
}

int IFramelocat(unsigned char* h264_buf, int cur_index,int buf_size){
    if(cur_index > buf_size-5)  return 0;
    else if(h264_buf[cur_index]==0x00 && h264_buf[cur_index+1]==0x00 && h264_buf[cur_index+2]==0x00 
                                 && h264_buf[cur_index+3]==0x01 && h264_buf[cur_index+4]==0x25)
        return 1;
    else return 0;
}

int PFramelocat(unsigned char* h264_buf, int cur_index,int buf_size){
    if(cur_index > buf_size-5)  return 0;
    else if(h264_buf[cur_index]==0x00 && h264_buf[cur_index+1]==0x00 && h264_buf[cur_index+2]==0x00 
                                 && h264_buf[cur_index+3]==0x01 && h264_buf[cur_index+4]==0x21)
        return 1;
    else return 0;
}

int H264DelSeiInsertSeiBeforeFrame(unsigned char* h264_buf,int buf_size,unsigned char* sei_buf,
                                                int sei_buf_size,FILE *tmp){
    for(int i=0; i<buf_size; i++){
        int len_sei = FindSei(h264_buf,i,buf_size);   //查找SEI字段位置，若当前位置为SEI开始字符，则返回SEI长度，否则返回0
        if(len_sei == 0){         //SEI字段长度为0，未找到SEI字段，原始内容直接写入
            if(IFramelocat(h264_buf,i,buf_size))   //SEI字段插入I帧之前
                fwrite(sei_buf, 1, sei_buf_size, tmp);
            else if(PFramelocat(h264_buf,i,buf_size))    //SEI字段插入P帧之前
                fwrite(sei_buf, 1, sei_buf_size, tmp);
            fwrite(&h264_buf[i], 1, 1, tmp);    //将原始码流写入文件
        }
        else if(len_sei > 0){
            i = i+len_sei-1;    //找到SEI字段，跳过码流buffer中SEI字段长度，相当于删除码流中原始SEI字段
            // --i;    //判断程序处理完之后，当前下标已经为下一个单元的起始位，for循环还会再加一，因为在此需要减一
        }
        else printf("error: findSei() return value min i!\n");
    }
    return 1;
}

int FillSeiPacket(unsigned char* sei_buffer, int sei_size, unsigned char* user_data, int user_data_size)
{
    if(sei_size-user_data_size < 25) return -1;

	unsigned char* data = (unsigned char*)sei_buffer;
    unsigned char user_data_size_high = user_data_size >> 8;    // 取用户数据长度高8位
    unsigned char user_data_size_low = user_data_size & 0xFF;   // 取用户数据长度低8位
	
    memcpy(data, SEI::start_code, sizeof(unsigned int)); // 插入4字节NALU开始码
	data += sizeof(unsigned int);   
	*data++ = SEI::nal_type; // 插入1字节NAL类型识别码,data指针偏移
	*data++ = SEI::payload_type; // 插入1字节SEI字段编码格式识别码,data指针偏移
	memcpy(data, SEI::sei_uuid, SEI::sei_uuid_size);  // 插入16字节UUID自定义识别码
	data += SEI::sei_uuid_size;   
    *data++ = user_data_size_high;  // 插入1字节用户数据长度高8位
    *data++ = user_data_size_low;  // 插入1字节用户数据长度低8位
	memcpy(data, user_data, user_data_size);    // 插入n字节用户自定义数据
	data += user_data_size;     
    sei_buffer[sei_size-1] = SEI::sei_tail;  // 插入1字节SEI封装包结尾对齐码

    if(data-sei_buffer>sei_size) return -2;
	else return 1;
}

int H264GetSeiUserdata(unsigned char* h264_buf, int h264_buf_size, unsigned char* user_buf, int user_buf_size){
    int sei_num=0,not_match_num=0;
    unsigned char* user_buf_point = user_buf;
    for(int i=0; i<h264_buf_size; i++){
        int len_sei = FindSei(h264_buf,i,h264_buf_size);    //获取码流中当前位置SEI字段长度
        if(len_sei>0){
            ++sei_num;
            int not_match_flag=0;
            for(int j=0; j<16; j++){    //判断SEI字段中UUID是否匹配
                if(h264_buf[i+6+j] == SEI::sei_uuid[j])
                    continue;
                else{
                    ++not_match_flag;
                    break;
                }
            }
            if(not_match_flag)  //如果not_match_flag为1，则该SEI字段不是我们定义的
                not_match_num += not_match_flag;
            else{   //否则该SEI是我们自定义的
                int h264_user_data_len = (h264_buf[i+22]<<8) + (h264_buf[i+23]&0xFF);
                printf("h264_buf[i+22]:%d,h264_buf[i+23]:%d,len_sei:%d\n",h264_buf[i+22],h264_buf[i+23],len_sei);
                printf("h264_user_data_len is %d\n",h264_user_data_len);
                if(h264_user_data_len!=(len_sei-25)){    //如果读取到的用户数据长度与实际测到的数据长度不匹配
                    printf("error:User data contains a stream header!\n");
                    printf("h264_buf[i+22]:%d,h264_buf[i+23]:%d,len_sei:%d\n",h264_buf[i+22],h264_buf[i+23],len_sei);
                    printf("h264_user_data_len is %d\n",h264_user_data_len);
                }
                else{   //若匹配，则正常提取用户数据
                    unsigned char* h264_usr_data = h264_buf+i+24;
                    if(h264_user_data_len > (user_buf_size+user_buf-user_buf_point)){ //判定当前写入的用户数据长度是否大于接收BUF的长度
                        printf("error:recv user_buf_size is too min! \n");
                        break;
                    }
                    memcpy(user_buf_point,h264_usr_data,sizeof(unsigned char)*h264_user_data_len);//将解析出的用户数据复制到接收BUF中
                    user_buf_point += h264_user_data_len;    //接收BUF指针偏移，方便下一帧数据写入
                    for(int k=0;k<10;k++)   //用户数据后面添加10个0作为用户数据分割标识
                       *user_buf_point++ = 0;
                }
            }
            i+=len_sei-1;
        }
        else 
            continue;
    }
    // printf("not_match_num is %d\n",not_match_num);
    return sei_num;
}

main.cpp

// #include <stdio.h>
#include <unistd.h>
#include <malloc.h>
#include "h264Process.h"

// #define H264_SIZE 1*1024*1024   //读取1MB文件大小
#define H264_SIZE 2*1024*1024   //读取0.1MB文件大小，大概包含2-3帧图像
#define USER_DATA_SIZE 512   //定义用户自定义数据大小
#define SEI_FIX_SIZE 25     //SEI封装包固有长度为25

//SEI字段插入H264码流文件程序
int insertSeiProcess(){
    //读取H264源文件，删去SEI字段 
    FILE* h264_file=NULL;
    FILE *tmp = NULL;
	static unsigned char fullBuffer[H264_SIZE+4] = {0};
	unsigned char* buffer = fullBuffer;
	h264_file = fopen("test.h264", "rb+");  //带SEI字段的H264源文件
    tmp = fopen("tmp.h264","wb+");  //写入自定义数据的的新H264文件
	if (!h264_file)
	{
		printf("ERROR:Open h264 file fialed.\n");
		return -1;
	}
	int size = fread(buffer, 1, H264_SIZE, h264_file);
    printf("h264 size:%d\n",size);

    int user_data_size = 512;
    int sei_size = user_data_size + SEI_FIX_SIZE;
    unsigned char* user_data_buf = (unsigned char*)malloc(sizeof(unsigned char)*user_data_size);
    unsigned char* sei_buf = (unsigned char*)malloc(sizeof(unsigned char)*sei_size);
    if(user_data_buf==NULL || sei_buf==NULL){
        printf("malloc faild!\n");
        return -1;
    }
    memset(user_data_buf,0,sizeof(unsigned char)*user_data_size);
    memset(sei_buf,0,sizeof(unsigned char)*sei_size);
    for(int i=0; i<100; i++){   //填充自定义数据
        user_data_buf[i]=i+1;
        // printf("%x ",user_data_buf[i]);
    }     
    // printf("\n");
    int sei_stat = FillSeiPacket(sei_buf, sei_size, user_data_buf, user_data_size);   //将用户自定义数据封装成SEI格式包
    if(sei_stat < 0) printf("fillSeiPacket faild\n");
    else printf("fillSeiPacket successed\n");
    // for(int i=0; i<sei_size;i++) printf("%x ",sei_buf[i]);
    // printf("\n");

    H264DelSeiInsertSeiBeforeFrame(buffer,size,sei_buf,sei_size,tmp);
    
    free(user_data_buf);    //释放动态内存空间
    free(sei_buf);
	fclose(h264_file);
	fclose(tmp);
}

//从H264文件中提取自定义SEI字段
int getSeiProcess(){
    FILE* h264_file = fopen("all_sei.h264","rb+");	//码流源文件
    FILE* sei_file = fopen("tmp.txt","w+");	//将读取到的自定义数据写入txt文档
    FILE* tmp1_file = fopen("h264.txt","w+");	//将H264码流数据读出来以便debug
    if (!h264_file || !sei_file){
		printf("ERROR:Open tmp.h264 or tmp.txt fialed.\n");
		return -1;
	}
    fseek(h264_file, 0, SEEK_END);      //将文件指针偏移到文件尾
    int file_size = ftell(h264_file);   //获取h264文件大小
    fseek(h264_file, 0, SEEK_SET);      //将文件指针偏移到文件头
    unsigned char* h264_buf = (unsigned char*)malloc(sizeof(unsigned char)*file_size);  //开辟h264_buf空间
    memset(h264_buf,0,sizeof(unsigned char)*file_size);     //初始化h264_buf
    int h264_size = fread(h264_buf, 1, file_size, h264_file);   //将h264文件读到h264_buf中
    printf("h264 file size is %d\n",h264_size);

    unsigned char* user_buf = (unsigned char*)malloc(sizeof(unsigned char)*h264_size);  //开辟SEI接收B空间
    memset(user_buf,0,sizeof(unsigned char)*h264_size);     //初始化h264_buf
    int find_sei_num = H264GetSeiUserdata(h264_buf, h264_size, user_buf, h264_size);
    printf("found sei num is %d\n",find_sei_num);
    for(int i=0; i<h264_size; i++)
        fprintf(tmp1_file, "%x ", h264_buf[i]);
    for(int i=0; i<file_size; i++)
        fprintf(sei_file, "%d ", user_buf[i]);

    printf("\n");
    free(h264_buf);
    free(user_buf);
    fclose(h264_file);
    fclose(sei_file);
    fclose(tmp1_file);
}

int main(int argc, char** argv)
{
    insertSeiProcess();
    //getSeiProcess();

	return 0;
}

5. 总结

以上就是H264码流中插入自定义数据的代码，H264码流文件是一个二进制文件，该代码是直接对二进制文件进行改造，不依赖于FFMPEG或者X264库。本代码中识别的I帧和P帧的帧头为25和21，常见的帧头为65和61，区别只是解码器识别该帧的重要程度，可自行修改。

转自：https://blog.csdn.net/weixin_42289213/article/details/125279309


http://www.niftyadmin.cn/n/468387.html

相关文章

[Leetcode] 0026. 删除有序数组中的重复项

[Leetcode] 0026. 删除有序数组中的重复项

26. 删除有序数组中的重复项 点击上方&#xff0c;跳转至Leetcode 题目描述 给你一个 升序排列 的数组 nums &#xff0c;请你 原地 删除重复出现的元素&#xff0c;使每个元素 只出现一次 &#xff0c;返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。 由于在某些语…
阅读更多...
Flutter延迟执行一段代码的几种方式以及Timer的说明

Flutter延迟执行一段代码的几种方式以及Timer的说明

延迟执行 在 Flutter 中&#xff0c;可以使用以下方式实现延迟执行一段代码的效果 使用 Future.delayed 方法&#xff1a; Future.delayed(Duration(milliseconds: 500), () {// 延迟执行的代码 });使用 Timer 类&#xff1a; Timer(Duration(milliseconds: 500), () {// 延…
阅读更多...
Dockerfile的应用

Dockerfile的应用

Dockerfile的应用 Dockerfile就是一个由一条条指令构成的批处理文件&#xff0c;是一个构建镜像的计划文件。 1.他是啥 Dockerfile 是用于定义 Docker 镜像构建过程的文本文件。它包含了一系列的指令和参数&#xff0c;用于描述构建一个 Docker 镜像所需的步骤和配置。 通过…
阅读更多...
2023年上海/广州/深圳DAMA-CDGA/CDGP数据治理认证班

2023年上海/广州/深圳DAMA-CDGA/CDGP数据治理认证班

DAMA认证为数据管理专业人士提供职业目标晋升规划&#xff0c;彰显了职业发展里程碑及发展阶梯定义&#xff0c;帮助数据管理从业人士获得企业数字化转型战略下的必备职业能力&#xff0c;促进开展工作实践应用及实际问题解决&#xff0c;形成企业所需的新数字经济下的核心职业…
阅读更多...
BCSP-玄子Java开发之Java Web编程CH011_Ajax交互扩展

BCSP-玄子Java开发之Java Web编程CH011_Ajax交互扩展

BCSP-玄子Java开发之Java Web编程CH011_Ajax交互扩展 jQuery灵活的Ajax实现 $.ajax()$.get()$.post()$.getJSON().load()…… $.get()方法 $.get(url[,data][,success][,dataType]);常用参数 参数类型说明urlString必选&#xff0c;发送请求的地址dataPlainObject 或 Stri…
阅读更多...
Numpy数组

Numpy数组

NumPy 最重要的一个特点是其 N 维数组对象 ndarray&#xff0c;它是一系列同类型数据的集合&#xff0c;以 0 下标为开始进行集合中元素的索引。 ndarray 对象是用于存放同类型元素的多维数组。 ndarray 中的每个元素在内存中都有相同存储大小的区域。 ndarray 内部由以下内…
阅读更多...
Flask高级（四）

Flask高级（四）

目录 前言 Flask_信号机制 信号机制 自定义信号步骤 创建信号 监听信号 发送信号 小结 Flask信号使用场景_存储用户登录日志 信号使用场景 导入所需模块和函数和创建登录信号 记录登录信息&#xff08;登录日志&#xff09; 触发登录信号 Flask_内置信号 temp…
阅读更多...
ECS 简略版说明一：Entities and components

ECS 简略版说明一：Entities and components

目录 Entities and components Worlds and EntityManagers Archetypes Chunks Queries Entity IDs IComponentData Managed IComponentData components DynamicBuffer components Aspects Allocator overview Allocator.Temp Allocator.TempJob Allocator.Persis…
阅读更多...
最新文章

Copyright @ 2022~2023