【音视频】H.264详细介绍及测试代码

H.264编码(AVC)

H.264从1999年开始，到2003年形成草案，最后在2007年定稿有待核实。在ITU的标准⾥称 为H.264，在MPEG的标准⾥是MPEG-4的⼀个组成部分–MPEG-4 Part 10，⼜叫Advanced Video Codec，因此常常称为MPEG-4 AVC或直接叫AVC。

视音频码流的处理程序:

H.264编码原理

对于视频⽂件来说，视频由单张图⽚帧所组成，⽐如每秒25帧，但是图⽚帧的像素块之间存在 相似性，因此视频帧图像可以进⾏图像压缩；H264采⽤了16*16的分块⼤⼩对，视频帧图像 进⾏相似⽐较和压缩编码。如下图所示

1. 内部压缩（空间压缩）
   1. 消除单帧图像内部的冗余数据
   2. 空间压缩解决单张图片的存储问题（如手机拍照）
2. 外部压缩（帧间/时间压缩）
   1. 利用连续帧之间的相似性（如图中正方形→圆形变化）
   2. • 时间压缩解决连续画面的传输问题（如在线视频）

H264中的I帧、P帧和B帧

H264使⽤帧内压缩和帧间压缩的⽅式提⾼编码压缩率；H264采⽤了独特的I帧、P帧和B帧策略 来实现，连续帧之间的压缩；

1. GOP（图像组） GOP是介于两个I帧之间的连续帧序列，包含一个I帧及其后续的P/B帧

   1. 作用：控制视频的随机访问能力、压缩效率及错误恢复能力。
   2. 常见配置：
      1. 直播场景：GOP长度通常为1-2秒（如30帧/秒下GOP=30~60帧），确保低延迟和快速错误恢复。
      2. 点播场景：GOP长度2-4秒（如GOP=60~120帧），平衡压缩率与随机访问性能
   3. GOP越长，P/B帧占比提升，平均压缩效率更高，但I帧质量需在固定码率下牺牲

2. I帧（帧内编码帧 intra picture 空间冗余）

   1. I 帧通常是每个 GOP 的第⼀个帧，经过适度地压缩，做为随机访问的参考点。I帧可以看成是⼀个图像经过压缩后的产物。 ⾃身可以通过视频解压算法解压成⼀张单独的完整的图⽚
   2. 压缩率低，解码复杂度低；
   3. 典型占比：5%~15%
   4. IDR（Instantaneous Decoding Refresh，即时解码刷新帧）
      1. 特殊类型的I帧，作为视频序列的强制起始点，IDR 图像都是 I 帧图像（反之未必）；
      2. ✅ 参考帧清空：解码器遇到IDR帧时，立即清空参考帧队列
      3. ✅ 序列隔离：后续帧禁止参考IDR之前的任何帧（如图中B9→IDR8的约束）（ I和IDR帧都使⽤帧内预测）
      4. 🔄 同步重置：重新加载SPS/PPS参数集 直播流中通常每2秒强制插入IDR帧
      5. 其核⼼作⽤是，是为了解码的重同步，当解码器解码到 IDR 图像时，⽴即将参考帧队列清 空，将已解码的数据全部输出或抛弃，重新查找参数集，开始⼀个新的序列。这样，如果前⼀ 个序列出现重⼤错误，在这⾥可以获得重新同步的机会。IDR图像之后的图像永远不会使⽤ IDR之前的图像的数据来解码。

3. P帧（前向预测编码帧 predictive-frame 时间冗余）

   1. 通过充分将低于图像序列中前⾯已编码帧的时间冗余信息来 压缩传输数据量的编码图像，也叫预测帧。 需要参考其前⾯的⼀个I frame 或者P frame来⽣成⼀张完整 的图⽚。
   2. 压缩率中，解码复杂度中；
   3. 典型占比：30%~50%

4. B帧（Instantaneous Decoding Refresh，即时解码刷新帧 时空冗余）

   1. 既考虑与源图像序列前⾯已编码帧，也顾及源图像序列后⾯ 已编码帧之间的时间冗余信息来压缩传输数据量的编码图像, 也叫双向预测帧。 则要参考其前⼀个I或者P帧及其后⾯的⼀个P帧来⽣成⼀张完 整的图⽚。
   2. 压缩率高，解码复杂度高；
   3. 典型占比：35%~60%
   4. 优势：B帧压缩率可达I帧的7倍（如相同内容下I帧100KB vs B帧15KB）。
   5. 劣势：增加编码延迟（需缓存后续帧），低延迟场景需禁用

5. GOP与帧类型优化策略
   1.

压缩率 B > P > I 字节数反过来

• 视频帧编码顺序（Decoding Time Stamp）:I1 P4 B2 B3 P7 B5 B6
• 显示顺序PTS（Presentation Time Stamp）：I1 B2 B3 P4 B5 B6 P7
  • B2/B3需等待P4编码完成（依赖P4数据）
  • 但显示时B2/B3要先于P4呈现（因为B帧的图像内容本来就是时间上先于P帧的）

H.264码流举例（从码流的帧分析可以看出来B帧不能被当做参考帧）

以25帧/s为例（没40ms传1帧）：（）里是发送出去帧的时间ms

• I（0） B(40) B(80) B(120) P(160)
• I（0） B(160)发现真正发出B帧的时间是160ms，距离上次发送间隔160ms（这就是B帧过多的后果，延迟太高，一般直播情况下不插入B帧的）

H264编码结构

H264除了实现了对视频的压缩处理之外，为了⽅便⽹络传输，提供了对应的视频编码和分⽚策略；类似于⽹络数据封装成IP帧，在H264中将其称为组(GOP, group of pictures)、⽚ （slice）、宏块（Macroblock）这些⼀起组成了H264的码流分层结构；H264将其组织成为 序列(GOP)、图⽚(pictrue)、⽚(Slice)、宏块(Macroblock)、⼦块(subblock)五个层次。 GOP （图像组）主要⽤作形容⼀个IDR帧 到下⼀个IDR帧之间的间隔了多少个帧;

NALU

H.264码流结构：

1. SPS：序列参数集，SPS中保存了⼀组编码视频序列(Coded video sequence)的全局参数。 eg分辨率/帧率;
   1. 每个视频流仅需1-2个
   2. 出现频率：每GOP开头
2. PPS：图像参数集，对应的是⼀个序列中某⼀幅图像或者某⼏幅图像的参数。
   1. 与SPS配合使用
   2. 每GOP开头
3. 发I帧之前，⾄少要发⼀次SPS和PPS。
4. 如果码流、fps等要改变，是要重发SPS、PPS的
5. if遇到H.264解不出，可能是SPS、PPS没发或者没解出来；

NALU是H.264/H.265视频码流的基本传输单元，作为网络抽象层（NAL）与视频编码层（VCL）的接口，，它的功能分为两层

1. VCL(视频编码层)：包括核⼼压缩引擎和块，宏块和⽚的语法级别定义，设计⽬标是尽可能地独⽴于⽹络进⾏⾼效的编码；
2. NAL(⽹络提取层)：负责将VCL产⽣的⽐特字符串适配到各种各样的⽹络和多元环境中，覆盖了所有⽚级 以上的语法级别；
3. 可认为NAL将VCL产生的编码数据适配到各种环境，即是 在VCL进⾏数据传输或存储之前，这些编码的VCL数据，被映射或封装进NAL单元，可认为NAL是传输单元

NALU结构

⼀个NALU = ⼀组对应于视频编码的NALU头部信息 + ⼀个原始字节序列负荷(RBSP,Raw Byte Sequence Payload)

H.264码流的基本传输单元为NALU，组成如下：

1. 起始码（Start Code）：标识NALU的起始位置，格式为3字节（0x000001）或4字节（0x00000001）。起始码用于分割NALU，常见于Annex B封装格式 ；
2. NALU Header：1字节的头部信息，包含以下字段

   1. 

   2. **T(type)**为负荷数据类型，占5bit；

      1. nal_unit_type：定义负载数据类型，这个NALU单元的类型,1～12由H.264使⽤，24～31由H.264以外的应⽤ 使⽤；
      2. 常见NALU类型（H.264）

   3. **R(NRI)**为重要性指示位，占2个bit

      1. nal_ref_idc.：0表示可丢弃，3表示关键数据（如SPS、PPS、I帧）

   4. F为禁⽌位，占1bit；

      1. forbidden_zero_bit： 在 H.264 规范中规定了这⼀位必须为 0.
3. RBSP（Raw Byte Sequence Payload）：编码后的原始数据，可能包含防竞争字节（Emulation Prevention Bytes）。当RBSP中出现连续两个0x00时，插入0x03避免与起始码冲突，解码时需移除

MP4与TS封装格式的Startcode设计差异

• TS文件：MPEG-TS（传输流）格式设计用于实时流传输，其每个NALU（网络抽象层单元）前必须包含Startcode（0x000001或0x00000001），以便接收端快速定位帧边界。TS解复用后的Packet自带Startcode，这是其传输协议的基本要求

• MP4文件：MP4作为容器格式，采用AVCC（AVC Configuration）格式存储H.264/H.265数据，通过头部的SPS/PPS参数集描述编码信息。解复用后的Packet为裸流数据（不含Startcode），需依赖外部参数重建完整码流

• 3字节的0x000001只有⼀种场合下使⽤，就是⼀个完整的帧被编为多个slice⽚的时 候，包含这些slice的NALU 使⽤3字节起始码。其余场合都是4字节0x00000001的。

H264 两种封装

AnnexB是H.264视频编码标准中定义的一种数据封装格式，主要用于流媒体传输和文件存储。其核心特点是通过**起始码（Start Code）**分隔NALU（网络抽象层单元），确保码流在网络传输和实时解码中的高效性

H264有两种封装

1. annexb模式，传统模式，

   1. NALU起始标志：startcode，SPS和PPS是在基本流（Elementary Stream, ES）中,
   2. 防竞争字节（Emulation Prevention Bytes）:为了防止原始数据中出现类似起始码的序列（如0x000000或0x000001），AnnexB引入转义机制;
      1. • 0x000000 → 0x00000300
      2. 0x000001 → 0x00000301 解码时需移除插入的0x03字节以恢复原始数据
   3. 参数集（SPS/PPS）位置：SPS（序列参数集）和PPS（图像参数集）通常位于码流最前端，提供全局解码参数（如分辨率、帧率）。若缺失会导致解码失败
   4. 一个典型的AnnexB码流如下： 0x000001 [NALU数据] | 0x000001 [NALU数据] | …
   5. 应用场景：
      1. 实时流媒体传输：AnnexB广泛用于RTSP、RTP协议和MPEG-TS流，因其起始码便于同步和错误恢复
      2. 例如，直播推流时，每个NALU可作为独立数据包传输，适应网络波动

2. mp4模式，AVCC（Advanced Video Coding Configuration）是H.264/AVC视频编码标准中用于描述视频流元数据的一种封装格式，主要用于MP4、MKV等容器文件以及流媒体传输场

   1. ⼀般mp4 mkv都是mp4模式，没有startcode，SPS和PPS以及其它信息 被封装在container中，每⼀个frame前⾯4个字节是这个frame的⻓度

3. 很多解码器只⽀持annexb这种模式，因此需要将mp4做转换：在ffmpeg中⽤ h264_mp4toannexb_filter可以做转换

1. 提取AVCC为Annex B
   1. • ffmpeg -i input.mp4 -c:v copy -bsf:v h264_mp4toannexb output.h264
2. 封装Annex B为AVCC
   1. • ffmpeg -i input.h264 -c:v copy -bsf:v h264_annexbtomp4 output.mp4

本地YUV文件编码为H264(qt里)

准备工作

• 配置FFMPEG开发环境，准备一个mp4文件提取其中的视频数据转为yuv420p,可以使用ffmpeg提供的命令：
  • ffmpeg -i input.mp4 -pix_fmt yuv420p -s 1280x720 output.yuv
    • -pix_fmt yuv420p：设置输出像素格式为YUV420P
    • -s 1280x720：设置输出分辨率
• 对于h264文件可以直接使用ffplay播放，命令为:
  • ffplay -i input.264

代码功能

• 输入：input.yuv（原始YUV420P格式视频）
• 输出：output.h264（H.264编码后的视频）
• 核心流程：
  1. 初始化H.264编码器
  2. 逐帧读取YUV数据
  3. 编码为H.264并写入文件

#include <QDebug>
extern "C" {
#include <libavcodec/avcodec.h>  // FFmpeg编码核心库
}

// 文件路径定义
const char* inFileName = "input.yuv";   // 输入：原始YUV420P文件
const char* outFileName = "output.h264"; // 输出：H.264编码文件

/**
 * @brief 编码函数（核心）
 * @param codecContent 编码器上下文
 * @param packet 存储编码后的数据包
 * @param frame 待编码的原始帧
 * @param outFile 输出文件指针
 * @return 0成功，-1失败
 */
int encode(AVCodecContext* codecContent, AVPacket* packet, AVFrame* frame, FILE* outFile) {
    // 发送原始帧到编码器
    int ret = avcodec_send_frame(codecContent, frame);
    if (ret < 0) {
        qDebug() << "Error sending frame:" << av_err2str(ret);
        return -1;
    }
    
    // 循环获取编码后的包
    while (ret >= 0) {
        ret = avcodec_receive_packet(codecContent, packet);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
            return 0;  // 需要更多输入或编码结束
        } else if (ret < 0) {
            qDebug() << "Encoding error:" << av_err2str(ret);
            return -1;
        }
        
        // 写入H.264数据到文件
        fwrite(packet->data, 1, packet->size, outFile);
        av_packet_unref(packet);  // 必须释放！防止内存泄漏
    }
    return 0;
}

int main(int argc, char* argv[]) {
    // 初始化变量
    int ret = 0;
    const AVCodec* codec = nullptr;
    AVCodecContext* codecContent = nullptr;
    AVPacket* packet = nullptr;
    AVFrame* frame = nullptr;
    FILE *inFile = nullptr, *outFile = nullptr;
    
    /* ================= 1. 初始化编码器 ================= */
    // 查找H.264编码器
    codec = avcodec_find_encoder(AV_CODEC_ID_H264);
    if (!codec) {
        qDebug() << "H.264 encoder not found";
        return -1;
    }
    
    // 创建编码器上下文
    codecContent = avcodec_alloc_context3(codec);
    if (!codecContent) {
        qDebug() << "Failed to allocate codec context";
        goto cleanup;
    }
    
    // 设置编码参数（必须与输入YUV匹配！）
    codecContent->width = 1280;      // 视频宽度
    codecContent->height = 720;      // 视频高度
    codecContent->time_base = {1, 25}; // 时间基（1/25秒）
    codecContent->framerate = {25, 1}; // 帧率25fps
    codecContent->pix_fmt = AV_PIX_FMT_YUV420P; // 像素格式
    codecContent->gop_size = 10;     // 关键帧间隔（可选）
    
    // 打开编码器
    if (avcodec_open2(codecContent, codec, NULL) < 0) {
        qDebug() << "Cannot open encoder";
        goto cleanup;
    }
    
    /* ================= 2. 准备数据容器 ================= */
    packet = av_packet_alloc();  // 存储编码后的包
    frame = av_frame_alloc();    // 存储原始帧
    if (!packet || !frame) {
        qDebug() << "Memory allocation failed";
        goto cleanup;
    }
    
    // 配置帧参数
    frame->width = codecContent->width;
    frame->height = codecContent->height;
    frame->format = codecContent->pix_fmt;
    
    // 分配帧缓冲区
    if (av_frame_get_buffer(frame, 32) < 0) { // 32字节对齐
        qDebug() << "Cannot allocate frame buffer";
        goto cleanup;
    }
    
    /* ================= 3. 文件IO初始化 ================= */
    inFile = fopen(inFileName, "rb");  // 二进制读YUV文件
    outFile = fopen(outFileName, "wb"); // 二进制写H.264文件
    if (!inFile || !outFile) {
        qDebug() << "Cannot open files";
        goto cleanup;
    }
    
    /* ================= 4. 编码主循环 ================= */
    while (!feof(inFile)) {
        // 确保帧可写入
        if (av_frame_make_writable(frame) < 0) {
            qDebug() << "Frame not writable";
            break;
        }
        
        // 读取YUV分量（注意YUV420P的存储布局）
        // Y分量（全分辨率）
        if (fread(frame->data[0], 1, frame->width * frame->height, inFile) <= 0)
            break;
        // U分量（1/4分辨率）
        if (fread(frame->data[1], 1, frame->width * frame->height / 4, inFile) <= 0)
            break;
        // V分量（1/4分辨率）
        if (fread(frame->data[2], 1, frame->width * frame->height / 4, inFile) <= 0)
            break;
        
        // 编码当前帧
        if (encode(codecContent, packet, frame, outFile) < 0)
            break;
    }
    
    // 刷新编码器（发送NULL帧）
    encode(codecContent, packet, nullptr, outFile);
    
    qDebug() << "Encoding completed";

cleanup:
    /* ================= 5. 资源释放 ================= */
    if (packet) av_packet_free(&packet);
    if (frame) av_frame_free(&frame);
    if (codecContent) avcodec_free_context(&codecContent);
    if (inFile) fclose(inFile);
    if (outFile) fclose(outFile);
    
    return ret < 0 ? -1 : 0;
}

编码流程

1. 初始化编码器并设置参数
2. 初始化AVPacket和AVFrame,设置参数
3. 读取视频文件，进行编码
4. 释放内存，结束

#include <QDebug>
extern "C"
{
#include <libavcodec/avcodec.h>
}
const char* inFileName = "input.yuv";
const char* outFileName = "output.h264";
int encode(AVCodecContext* codecContent, AVPacket* packet, AVFrame* frame, FILE* outFile)
{
    //编码
    int ret = avcodec_send_frame(codecContent, frame);
    if (ret < 0)
    {
        qDebug() << "Error sending a frame for encoding";
        return -1;
    }

    while (ret == 0)
    {
        ret = avcodec_receive_packet(codecContent, packet);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
            return 0;
        }
        else if (ret < 0) {
            qDebug() <<"Error encoding video frame";
            return -1;
        }
        if (ret == 0)
        {
            fwrite(packet->data, 1, packet->size, outFile);
        }
    }
}
int main(int argc, char* argv[])
{
    int ret = 0;
    const AVCodec* codec = nullptr;
    AVCodecContext* codecContent = nullptr;
    AVPacket* packet = nullptr;
    AVFrame* frame = nullptr;

    FILE* inFile = nullptr;
    FILE* outFile = nullptr;

    //查找指定编码器
    codec = avcodec_find_encoder(AV_CODEC_ID_H264);
    if (codec == nullptr)
    {
        qDebug() <<"could not find h264 encoder!";
        return -1;
    }

    //申请编码器上下文
    codecContent = avcodec_alloc_context3(codec);
    if (codecContent == nullptr)
    {
        qDebug() <<"could not alloc h264 content!";
        return -1;
    }

    //必设参数
    codecContent->width = 1280;
    codecContent->height = 720;
    codecContent->time_base = AVRational{ 1, 25 };
    codecContent->pix_fmt = AV_PIX_FMT_YUV420P;
    codecContent->framerate = AVRational{ 25, 1 };
    //初始化编码器上下文
    ret = avcodec_open2(codecContent, codec, NULL);
    if (ret < 0) {
        qDebug() << "Could not open codec";
        exit(1);
    }
    packet = av_packet_alloc();
    if (packet == nullptr)
    {
        qDebug() << "alloc packet error";
        return -1;
    }
    frame = av_frame_alloc();
    if (packet == nullptr)
    {
        qDebug() <<"alloc frame error";
        return -1;
    }
    //必设参数
    frame->width = codecContent->width;
    frame->height = codecContent->height;
    frame->format = codecContent->pix_fmt;
    //申请视频数据存储空间
    ret = av_frame_get_buffer(frame, 0);
    if (ret)
    {
        qDebug() <<"alloc frame buffer error!";
        return -1;
    }
    inFile = fopen(inFileName, "rb");
    if (inFile == nullptr)
    {
        qDebug() <<"error to open file";
        return -1;
    }
    outFile = fopen(outFileName, "wb");
    if (inFile == nullptr)
    {
        qDebug() <<"error to open file";
        return -1;
    }
    while (!feof(inFile))
    {
        ret = av_frame_is_writable(frame);
        if (ret < 0)
        {
            ret = av_frame_make_writable(frame);
        }
        fread(frame->data[0], 1, frame->width * frame->height, inFile); //y
        fread(frame->data[1], 1, frame->width * frame->height / 4, inFile); //u
        fread(frame->data[2], 1, frame->width * frame->height / 4, inFile);  //v
        qDebug() << "encode frame";
        encode(codecContent, packet, frame, outFile);

    }
    encode(codecContent, packet, nullptr, outFile);
    qDebug() <<"encode finish";
    av_packet_free(&packet);
    av_frame_free(&frame);
    avcodec_free_context(&codecContent);
    fclose(inFile);
    fclose(outFile);
    return 0;
}

FFmpeg从MP4等容器中提取H.264裸流

这是一个使用FFmpeg从MP4等容器中提取H.264裸流的工具程序，主要功能包括：

• 解析输入媒体文件（如MP4/MOV）
• 识别视频流并验证是否为H.264编码
• 提取视频帧数据并写入输出文件
• 可选使用h264_mp4toannexb比特流过滤器处理NAL单元

不同容器提取Annex B封装的H264

1. 从MP4提取H.264（需要过滤器） ./extract_h264 input.mp4 output.h264
2. 从TS流提取H.264（直接写入） ./extract_h264 input.ts output.h264

#include <stdio.h>
extern "C" {
    #include <libavutil/log.h>
    #include <libavformat/avio.h>
    #include <libavformat/avformat.h>
    #include <libavcodec/avcodec.h>  // 包含AVBSFContext定义
    #include <libavcodec/bsf.h>      // 包含比特流过滤器API
}

// 错误码转字符串的辅助函数
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)
{
    // FFmpeg结构体初始化
    AVFormatContext* ifmt_ctx = NULL;
    int             videoindex = -1;//视频流索引
    AVPacket* pkt = NULL; // 数据包
    int             ret = -1;
    int             file_end = 0; // 文件是否读取结束

    const char* outFile = "believe_h246.h264";
    const char* inFile = "believe.mp4";

    FILE* outfp = fopen(outFile, "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, inFile, 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);

    /* 比特流过滤器设置：将MP4格式的H.264数据转换为Annex B格式 
                    处理内容：1.添加00 00 00 01起始码 2.插入SPS/PPS等参数集 适用场景：MP4/MOV等容器格式*/
    //FLV/MP4/MKV等结构中，h264需要h264_mp4toannexb处理。添加SPS/PPS等信息。
    // FLV封装时，可以把多个NALU放在一个VIDEO TAG中,结构为4B NALU长度+NALU1+4B NALU长度+NALU2+...,
    // 需要做的处理把4B长度换成00000001或者000001
    // 
    // 获取H.264 MP4转Annex B的过滤器h264_mp4toannexb
    const AVBitStreamFilter* bsfilter = av_bsf_get_by_name("h264_mp4toannexb");
    AVBSFContext* bsf_ctx = NULL;
    // 2 初始化过滤器上下文
    av_bsf_alloc(bsfilter, &bsf_ctx); //AVBSFContext;
    // 3 添加解码器属性 将输入视频流的编解码参数（如 SPS/PPS）复制到过滤器中。
    avcodec_parameters_copy(bsf_ctx->par_in, ifmt_ctx->streams[videoindex]->codecpar);
    av_bsf_init(bsf_ctx);

    file_end = 0;

    //从MP4中循环读取所有帧
    while (0 == file_end)
    {
        if ((ret = av_read_frame(ifmt_ctx, pkt)) < 0)// 读取一帧数据
        {
            // 没有更多包可读
            file_end = 1;
            printf("read file end: ret:%d\n", ret);
        }
        //pkt->stream_index通过索引区分是视频流还是音频流
        if (ret == 0 && pkt->stream_index == videoindex)
        {
        // 使用比特流过滤器处理（适用于MP4等容器）
            if (strstr(inFile, ".mp4") || strstr(inFile, ".mov")) {
                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);   // 发送后需立即释放 pkt，因为过滤器内部会复制数据。
                // 接收处理后的包 当调用 av_bsf_receive_packet 从过滤器获取处理后的数据包时，h264_mp4toannexb 过滤器会按顺序执行起始码替换和SPS/PPS 插入
                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);
                }
            }
            // TS流可以直接写入,
            else {
                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);
            }
        }
        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;
}