当前位置： 首页 > news >正文

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

news 来源：原创 2025/6/29 9:03:16

这里写目录标题

    • H.264编码(AVC)
      • H.264编码原理
      • H264中的I帧、P帧和B帧
      • H264编码结构
      • NALU
      • H264 两种封装
      • 本地YUV文件编码为H264(qt里)
      • FFmpeg从MP4等容器中提取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的分块⼤⼩对，视频帧图像 进⾏相似⽐较和压缩编码。如下图所示
image.png

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

H264中的I帧、P帧和B帧

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

  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 字节数反过来

image.png

  • 视频帧编码顺序（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帧不能被当做参考帧）
image.png

以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帧之间的间隔了多少个帧;
image.png

层级技术作用实际应用场景
视频序列完整视频流，以IDR帧为随机访问入口视频快进/后退时快速定位
图像帧单幅画面，可能是I/P/B帧类型JPEG静态图即单帧的独立编码
片(Slice)帧内并行处理单元，避免整帧解码失败H.264的多线程解码
宏块16x16像素基础单元，运动补偿/预测的基本单位视频马赛克效果的最小可见块
子块4x4/8x8变换单元，DCT/量化操作的最小粒度高频细节保留（如文字边缘

NALU

image.png
H.264码流结构：
image.png

  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结构
image.png

⼀个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. image.png

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

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

    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引入转义机制;
        • 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可以做转换

特性AVCCAnnex B
起始标识长度前缀（如4字节）起始码（0x000001或0x00000001）
元数据位置SPS/PPS存储于文件头SPS/PPS内嵌于码流中
适用场景文件存储（MP4、MKV）、流媒体（HLS/DASH）实时传输（TS流、RTP）
容错性低（依赖文件头完整性）高（SPS/PPS周期性重复）
转换工具FFmpeg的h264_annexbtomp4滤镜FFmpeg的h264_mp4toannexb滤镜
FFmpeg操作示例
  1. 提取AVCC为Annex B
      • ffmpeg -i input.mp4 -c:v copy -bsf:v h264_mp4toannexb output.h264
  2. 封装Annex B为AVCC
      • 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}; // 帧率25fpscodecContent->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); //yfread(frame->data[1], 1, frame->width * frame->height / 4, inFile); //ufread(frame->data[2], 1, frame->width * frame->height / 4, inFile);  //vqDebug() << "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/subtitlesvideoindex = -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_mp4toannexbconst 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;
}

相关文章：

  • 电子电气架构 --- 车辆产品的生产周期和研发周
  • 深入解析 Electron 架构：主进程 vs 渲染进程
  • Blender速成班-知识补充
  • Opencv计算机视觉PPT-算法篇
  • 在项目中如何巧妙使用缓存
  • nginx基本使用 linux（mac下的）
  • 【SpringBoot高级】SpringBoot与Kafka深度整合：从入门到企业级实战
  • PB应用变为Rust语言方案
  • 【Actix Web】构建高性能 Rust API：Actix Web 最佳实践与进阶指南
  • 【学习笔记】深入理解Java虚拟机学习笔记——第13章 线程安全与锁优化
  • 力扣网C语言编程题：在数组中查找目标值位置之二分查找法
  • Vue.js 中的数字格式化组件：`FormattedNumber`
  • C++ STL深度剖析：Stack、queue、deque容器适配器核心接口
  • LLM 安全防护解决方案，使用 Roberta 训练 LLM 提示词注入攻击判决模型
  • 案例开发 - 日程管理系统 - 第一期
  • Hadoop集群异常：两个NameNode全部为StandBy状态
  • uniapp image引用本地图片不显示问题
  • Centos 8设置固定IP
  • AlphaGenome：基因组学领域的人工智能革命
  • 【C++进阶】--- 继承