FFmepg --08-解封装视频格式h264

原创已于 2025-10-23 09:30:05 修改 · 790 阅读

6 ·

CC 4.0 BY-SA版权

文章标签：

#ffmpeg

于 2024-03-09 10:23:54 首次发布

FFmpeg从放弃到入门专栏收录该内容

37 篇文章

订阅专栏

本文详细介绍了H264视频编码协议，IPB帧的特性，NALU结构，以及两种主要的封装模式——annexb模式和MP4模式。重点讲解了如何使用AVBitStreamFilter进行H264MP4文件到annexb格式的转换并写入文件。

文章目录

基础概念

H264视频编解码协议，又称为MPEG-4 AVC或AVC

I P B 帧

I帧：可独立解码
P帧：前向预测编码帧，参考I帧或者 P帧
B帧：双向预测帧，参考I 帧,P帧
压缩率：B>P>I

例子：

解码顺序：IDR1 → P4 → B2 → B3 → P7 → B5 → B6
解析步骤：

解码IDR1：独立解码，输出图像，清空参考帧队列并添加IDR1。

解码P4：参考IDR1，运动补偿后解码，输出图像，添加P4到参考帧队列。

解码B2：参考IDR1（前向）和P4（后向），双向预测解码，输出图像（显示顺序可能早于P4）。

解码B3：类似B2。

解码P7：参考P4或IDR1，解码后输出，添加P7到参考帧队列。

解码B5：参考P4（前向）和P7（后向），解码输出。

解码B6：类似B5。

显示顺序：可能为IDR1、B2、B3、P4、B5、B6、P7（具体取决于时间戳）。

NALU结构

H.264原始码流由一个接一个的NALU组成
⼀个原始的H.264 NALU单元通常由
[StartCode] [NALUHeader] [NALU Payload]三部分组成，其中 Start Code ⽤于标示这是⼀个NALU 单元的开
始，必须是"00 00 00 01" 或"00 00 01"

H.264有两种封装格式：

annexb模式：传统模式，有startcode，SPS和PPS
MP4模式：没有startcode，SPS和PPS ，对mp4视频文件解码为h264文件需在h264_mp4toannexb_filter中转换
（flv格式也需要加startcode ,ts流不需要加startcode）

封装格式

annexb模式
传统模式，有startcode，SPS和PPS
MP4模式
需要加startcode，SPS和PPS以及其它信息
对mp4视频文件解码为h264文件需在h264_mp4toannexb_filter中转换
（flv格式也需要加startcode ,ts流不需要加startcode）

// 1 获取相应的比特流过滤器
//FLV/MP4/MKV等结构中，h264需要h264_mp4toannexb处理。添加SPS/PPS等信息。
// FLV封装时，可以把多个NALU放在一个VIDEO TAG中,结构为4B NALU长度+NALU1+4B NALU长度+NALU2+...,
// 需要做的处理把4B长度换成00000001或者000001
const AVBitStreamFilter *bsfilter = av_bsf_get_by_name("h264_mp4toannexb");
AVBSFContext *bsf_ctx = NULL;
// 2 初始化过滤器上下文
av_bsf_alloc(bsfilter, &bsf_ctx); //AVBSFContext;
// 3 添加解码器属性
avcodec_parameters_copy(bsf_ctx->par_in, ifmt_ctx->streams[videoindex]->codecpar);
av_bsf_init(bsf_ctx);

file_end = 0;
while (0 == file_end)
{
    if((ret = av_read_frame(ifmt_ctx, pkt)) < 0)
    {
        // 没有更多包可读
        file_end = 1;
        printf("read file end: ret:%d\n", ret);
    }
    if(ret == 0 && pkt->stream_index == videoindex)
    {
#if 1
        int input_size = pkt->size;
        int out_pkt_count = 0;
        if (av_bsf_send_packet(bsf_ctx, pkt) != 0) // bitstreamfilter内部去维护内存空间
        {
            av_packet_unref(pkt);   // 你不用了就把资源释放掉
            continue;       // 继续送
        }
        av_packet_unref(pkt);   // 释放资源
        while(av_bsf_receive_packet(bsf_ctx, pkt) == 0)
        {
            out_pkt_count++;
            // printf("fwrite size:%d\n", pkt->size);
            size_t size = fwrite(pkt->data, 1, pkt->size, outfp);
            if(size != pkt->size)
            {
                printf("fwrite failed-> write:%u, pkt_size:%u\n", size, pkt->size);
            }
            av_packet_unref(pkt);
        }
        if(out_pkt_count >= 2)
        {
            printf("cur pkt(size:%d) only get 1 out pkt, it get %d pkts\n",
                   input_size, out_pkt_count);
        }
#else       // TS流可以直接写入
        size_t size = fwrite(pkt->data, 1, pkt->size, outfp);
        if(size != pkt->size)
        {
            printf("fwrite failed-> write:%u, pkt_size:%u\n", size, pkt->size);
        }
        av_packet_unref(pkt);
#endif
    }
    else
    {
        if(ret == 0)
            av_packet_unref(pkt);        // 释放内存
    }
}

代码解析

变量初始化与资源管理

input_size = pkt->size：保存原始输入包大小，用于后续调试
out_pkt_count = 0：记录比特流过滤器输出包数量的计数器

数据包发送到比特流过滤器

av_bsf_send_packet(bsf_ctx, pkt)：将H.264数据包（AVCC格式）发送至过滤器
返回值处理：

非0返回值时调用av_packet_unref(pkt)释放资源并跳过当前循环
成功发送后仍需立即调用av_packet_unref(pkt)，因过滤器内部已复制数据

处理后的数据包接收与输出

while(av_bsf_receive_packet(bsf_ctx, pkt) == 0)：循环获取转换后的Annex B格式包
关键操作：

out_pkt_count++统计输出包数量
fwrite(pkt->data, 1, pkt->size, outfp)写入标准H.264数据（含0x00000001起始码）
每次循环结束调用av_packet_unref(pkt)释放处理后的包

调试信息逻辑

条件判断if(out_pkt_count >= 2)：
打印原始包大小与输出包数量的不匹配警告（注：当前逻辑可能存在表述矛盾）

格式转换细节

原始MP4（AVCC）→过滤器→标准H.264（Annex B）
转换特征：

4字节长度前缀替换为0x00000001起始码
SPS/PPS参数集自动插入IDR帧前
NALU可能被拆分或合并

内存管理流程

完整链条：
av_read_frame() → 原始包 → av_bsf_send_packet() → 立即释放
↓
过滤器内部处理
→ av_bsf_receive_packet() → 新包 → 写入文件 → 释放

完整代码

#include <stdio.h>
#include <libavutil/log.h>
#include <libavformat/avio.h>
#include <libavformat/avformat.h>



static char err_buf[128] = {0};
static char* av_get_err(int errnum)
{
    av_strerror(errnum, err_buf, 128);
    return err_buf;
}

/*
AvCodecContext->extradata[]中为nalu长度
*   codec_extradata:
*   1, 64, 0, 1f, ff, e1, [0, 18], 67, 64, 0, 1f, ac, c8, 60, 78, 1b, 7e,
*   78, 40, 0, 0, fa, 40, 0, 3a, 98, 3, c6, c, 66, 80,
*   1, [0, 5],68, e9, 78, bc, b0, 0,
*/

//ffmpeg -i 2018.mp4 -codec copy -bsf:h264_mp4toannexb -f h264 tmp.h264
//ffmpeg 从mp4上提取H264的nalu h
int main(int argc, char **argv)
{
    AVFormatContext *ifmt_ctx = NULL;
    int             videoindex = -1;
    AVPacket        *pkt = NULL;
    int             ret = -1;
    int             file_end = 0; // 文件是否读取结束

    if(argc < 3)
    {
        printf("usage inputfile outfile\n");
        return -1;
    }
    FILE *outfp=fopen(argv[2],"wb");
    printf("in:%s out:%s\n", argv[1], argv[2]);

    // 分配解复用器的内存，使用avformat_close_input释放
    ifmt_ctx = avformat_alloc_context();
    if (!ifmt_ctx)
    {
        printf("[error] Could not allocate context.\n");
        return -1;
    }

    // 根据url打开码流，并选择匹配的解复用器
    ret = avformat_open_input(&ifmt_ctx,argv[1], NULL, NULL);
    if(ret != 0)
    {
        printf("[error]avformat_open_input: %s\n", av_get_err(ret));
        return -1;
    }

    // 读取媒体文件的部分数据包以获取码流信息
    ret = avformat_find_stream_info(ifmt_ctx, NULL);
    if(ret < 0)
    {
        printf("[error]avformat_find_stream_info: %s\n", av_get_err(ret));
        avformat_close_input(&ifmt_ctx);
        return -1;
    }

    // 查找出哪个码流是video/audio/subtitles
    videoindex = -1;
    // 推荐的方式
    videoindex = av_find_best_stream(ifmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
    if(videoindex == -1)
    {
        printf("Didn't find a video stream.\n");
        avformat_close_input(&ifmt_ctx);
        return -1;
    }

    // 分配数据包
    pkt = av_packet_alloc();
    av_init_packet(pkt);

    // 1 获取相应的比特流过滤器
    //FLV/MP4/MKV等结构中，h264需要h264_mp4toannexb处理。添加SPS/PPS等信息。
    // FLV封装时，可以把多个NALU放在一个VIDEO TAG中,结构为4B NALU长度+NALU1+4B NALU长度+NALU2+...,
    // 需要做的处理把4B长度换成00000001或者000001
    const AVBitStreamFilter *bsfilter = av_bsf_get_by_name("h264_mp4toannexb");
    AVBSFContext *bsf_ctx = NULL;
    // 2 初始化过滤器上下文
    av_bsf_alloc(bsfilter, &bsf_ctx); //AVBSFContext;
    // 3 添加解码器属性
    avcodec_parameters_copy(bsf_ctx->par_in, ifmt_ctx->streams[videoindex]->codecpar);
    av_bsf_init(bsf_ctx);

    file_end = 0;
    while (0 == file_end)
    {
        if((ret = av_read_frame(ifmt_ctx, pkt)) < 0)
        {
            // 没有更多包可读
            file_end = 1;
            printf("read file end: ret:%d\n", ret);
        }
        if(ret == 0 && pkt->stream_index == videoindex)
        {
#if 1
            int input_size = pkt->size;
            int out_pkt_count = 0;
            if (av_bsf_send_packet(bsf_ctx, pkt) != 0) // bitstreamfilter内部去维护内存空间
            {
                av_packet_unref(pkt);   // 你不用了就把资源释放掉
                continue;       // 继续送
            }
            av_packet_unref(pkt);   // 释放资源
            while(av_bsf_receive_packet(bsf_ctx, pkt) == 0)
            {
                out_pkt_count++;
                // printf("fwrite size:%d\n", pkt->size);
                size_t size = fwrite(pkt->data, 1, pkt->size, outfp);
                if(size != pkt->size)
                {
                    printf("fwrite failed-> write:%u, pkt_size:%u\n", size, pkt->size);
                }
                av_packet_unref(pkt);
            }
            if(out_pkt_count >= 2)
            {
                printf("cur pkt(size:%d) only get 1 out pkt, it get %d pkts\n",
                       input_size, out_pkt_count);
            }
#else       // TS流可以直接写入
            size_t size = fwrite(pkt->data, 1, pkt->size, outfp);
            if(size != pkt->size)
            {
                printf("fwrite failed-> write:%u, pkt_size:%u\n", size, pkt->size);
            }
            av_packet_unref(pkt);
#endif
        }
        else
        {
            if(ret == 0)
                av_packet_unref(pkt);        // 释放内存
        }
    }
    if(outfp)
        fclose(outfp);
    if(bsf_ctx)
        av_bsf_free(&bsf_ctx);
    if(pkt)
        av_packet_free(&pkt);
    if(ifmt_ctx)
        avformat_close_input(&ifmt_ctx);
    printf("finish\n");

    return 0;
}