FFmpeg 全链路中间件深度分析

一、开源代码目录文件树形分析1.1 FFmpeg 源码整体架构树FFmpeg ├── configure # 配置脚本生成config.h/config.mak ├── Makefile # 顶层Makefile ├── Changelog # 版本变更记录 ├── README.md # 项目说明 │ ├── ffbuild/ # 编译辅助目录 │ ├── common.mak # 通用编译规则 │ ├── library.mak # 库编译规则 │ ├── arch.mak # 架构相关规则 │ └── config.log # 配置日志调试编译错误 │ ├── fftools/ # 命令行工具源码可执行程序入口 │ ├── ffmpeg.c # ffmpeg主程序转码/处理★核心 │ ├── ffmpeg.h # ffmpeg头文件 │ ├── ffmpeg_opt.c # 命令行参数解析 │ ├── ffmpeg_filter.c # 滤镜图处理 │ ├── ffmpeg_hw.c # 硬件加速 │ ├── ffplay.c # ffplay播放器基于SDL★核心 │ ├── ffprobe.c # ffprobe媒体分析工具 │ ├── cmdutils.c # 命令行工具公共函数 │ └── cmdutils.h │ ├── libavcodec/ # 编解码库核心★ │ ├── avcodec.h # 公共API头文件 │ ├── avcodec.c # 核心API实现 │ ├── decode.c # 解码核心逻辑 ★ │ ├── encode.c # 编码核心逻辑 ★ │ ├── codec_desc.c # 编解码器描述 │ ├── codec_par.c # 编解码参数 │ ├── parser.c # 码流解析器 │ ├── bitstream_filter.c # 比特流过滤器 │ ├── hwaccel.c # 硬件加速 │ ├── allcodecs.c # 所有编解码器注册 │ ├── │ │ ├── x86/ # x86平台优化 │ ├── arm/ # ARM平台优化 │ ├── aarch64/ # ARM64平台优化 │ ├── mips/ # MIPS平台优化 │ │ │ ├── libx264.c # H.264编码器封装 │ ├── libx265.c # H.265编码器封装 │ ├── aacenc.c # AAC编码器 │ ├── aacdec.c # AAC解码器 │ ├── h264dec.c # H.264解码器 │ ├── hevcdec.c # HEVC解码器 │ └── ... (数百个编解码器实现) │ ├── libavformat/ # 封装格式处理库解复用/复用★ │ ├── avformat.h # 公共API头文件 │ ├── avformat.c # 核心API实现 │ ├── demux.c # 解复用核心 ★ │ ├── mux.c # 复用核心 │ ├── avio.c # I/O核心 │ ├── avio_internal.h # I/O内部接口 │ ├── options.c # 格式选项 │ ├── allformats.c # 所有格式注册 │ │ │ ├── aviobuf.c # 缓冲I/O实现 ★ │ ├── url.c # URL协议层 │ │ │ ├── movenc.c # MP4/MOV封装 │ ├── mov.c # MP4/MOV解封装 │ ├── flvdec.c # FLV解封装 │ ├── flvenc.c # FLV封装 │ ├── mp3dec.c # MP3解封装 │ ├── aacdec.c # AAC解封装 │ ├── rtsp.c # RTSP协议 │ ├── rtmp.c # RTMP协议 │ ├── http.c # HTTP协议 │ └── ... (数百种格式和协议) │ ├── libavutil/ # 工具库所有模块共享★ │ ├── avutil.h # 公共API头文件 │ ├── common.h # 通用宏定义 │ ├── mem.c # 内存管理 ★ │ ├── mem.h # 内存管理头文件 │ ├── fifo.c # 环形FIFO缓冲区 ★ │ ├── fifo.h │ ├── buffer.c # 引用计数缓冲区 ★ │ ├── buffer.h │ ├── frame.c # AVFrame管理 │ ├── frame.h │ ├── dict.c # 字典管理 │ ├── log.c # 日志系统 │ ├── error.c # 错误处理 │ ├── time.c # 时间管理 │ ├── rational.c # 有理数运算时间基 │ ├── mathematics.c # 数学函数 │ ├── pixfmt.h # 像素格式定义 │ ├── samplefmt.h # 采样格式定义 │ ├── channel_layout.h # 声道布局 │ ├── hwcontext.c # 硬件上下文 │ ├── hwcontext_drm.c # DRM硬件加速 │ ├── hwcontext_vaapi.c # VAAPI硬件加速 │ └── ... │ ├── libswscale/ # 图像缩放/颜色空间转换 │ ├── swscale.h │ ├── swscale.c │ ├── swscale_internal.h │ ├── yuv2rgb.c # YUV转RGB │ ├── rgb2yuv.c │ └── x86/swscale_template.c # x86优化版本 │ ├── libswresample/ # 音频重采样/格式转换 │ ├── swresample.h │ ├── swresample.c │ ├── resample.c # 重采样核心 │ ├── rematrix.c # 声道矩阵变换 │ └── audioconvert.c # 音频格式转换 │ ├── libavfilter/ # 滤镜库 │ ├── avfilter.h │ ├── avfilter.c │ ├── avfiltergraph.c # 滤镜图管理 │ ├── buffersrc.c # 源滤镜 │ ├── buffersink.c # 接收滤镜 │ ├── video.c # 视频滤镜通用 │ ├── audio.c # 音频滤镜通用 │ ├── vf_scale.c # 缩放滤镜 │ ├── vf_crop.c # 裁剪滤镜 │ ├── vf_rotate.c # 旋转滤镜 │ ├── af_volume.c # 音量滤镜 │ └── ... (数百个滤镜) │ ├── libavdevice/ # 设备输入/输出 │ ├── avdevice.h │ ├── alldevices.c │ ├── v4l2.c # V4L2摄像头输入 │ ├── v4l2_common.c │ ├── alsa.c # ALSA音频输入/输出 │ ├── pulse_audio.c # PulseAudio │ ├── x11grab.c # X11屏幕抓取 │ ├── fbdev.c # Framebuffer设备 │ └── ... │ ├── libpostproc/ # 后处理库 │ └── postprocess.c │ ├── doc/ # 文档 │ ├── APIchanges # API变更记录 │ ├── examples/ # 示例代码 │ │ ├── decode_video.c # 视频解码示例 │ │ ├── encode_video.c # 视频编码示例 │ │ ├── demuxing_decoding.c # 解复用解码示例 │ │ ├── muxing.c # 复用示例 │ │ ├── filtering_video.c # 滤镜示例 │ │ ├── transcode_aac.c # 音频转码示例 │ │ └── hw_decode.c # 硬件解码示例 │ └── ... │ ├── tests/ # 测试套件 │ ├── fate/ # FATE回归测试 │ ├── ref/ # 参考输出 │ └── ... │ ├── tools/ # 辅助工具 │ ├── qt-faststart.c # MP4快速启动 │ ├── graph2dot.c # 滤镜图转dot │ └── ... │ └── compat/ # 兼容性代码 ├── atomics/ # 原子操作兼容 ├── windows/ # Windows兼容 └── ...二、关键函数树形分析2.1 解码链路函数调用树【avformat_open_input → 解码输出 AVFrame 完整调用链】 ​ avformat_open_input() ├── init_input() # 初始化输入 │ ├── io_open() # 打开I/O │ │ └── url_open() # 打开URL/文件 │ │ └── URLProtocol-url_open() # 具体协议openfile/rtmp/http │ ├── avio_open2() # 创建AVIOContext │ │ └── ffio_fdopen() # 包装文件描述符 │ └── av_probe_input_buffer() # 探测格式 │ └── av_probe_input_format2() # 匹配解复用器 │ └── avformat_find_stream_info() # 查找流信息 ├── avformat_find_stream_info() │ ├── read_frame_internal() # 读取帧探测 │ │ └── avio_read() # 读取数据 │ └── try_decode_frame() # 尝试解码 │ └── avcodec_send_packet() # 发送包到解码器 │ └── avcodec_receive_frame()# 接收帧 │ └── estimate_timings() # 估算时间 └── fill_all_stream_timings() ​ ​ av_read_frame() # 读取压缩包循环调用 ├── read_frame_internal() │ ├── ff_read_packet() # 从解复用器读包 │ │ └── AVInputFormat-read_packet() # 具体格式的read_packet │ │ └── avio_read() # 读取原始数据 │ └── parse_packet() # 解析包处理B帧等 │ └── av_parser_parse2() # 调用解析器 │ └── queue_packet() # 入队到流缓冲区 ​ ​ avcodec_send_packet() # 发送压缩包到解码器 ├── avcodec_send_packet() │ ├── decode_send_packet() # 发送到解码器 │ │ └── avcodec_send_packet() # 内部实现 │ │ ├── check_for_flush() # 检查是否flush │ │ └── ff_decode_bsfs_init() # 初始化比特流过滤器 │ │ │ └── encode_send_frame_internal() # 编码路径本文不展开 │ └── [返回] → 将数据放入解码器内部缓冲区 ​ ​ avcodec_receive_frame() # 接收解码后的帧 ├── decode_receive_frame_internal() # 核心解码接收 │ ├── decode_simple_receive_frame() │ │ ├── decode_simple_internal() │ │ │ ├── ff_decode_get_packet() # 从输入队列取包 │ │ │ ├── avcodec_decode_*() # 调用具体解码器 │ │ │ │ ├── h264_decode_frame() # H.264解码 │ │ │ │ │ ├── ff_h264_decode_slice() # 解码slice │ │ │ │ │ └── output_frame() # 输出帧 │ │ │ │ ├── hevc_decode_frame() # HEVC解码 │ │ │ │ ├── aac_decode_frame() # AAC解码 │ │ │ │ └── ... │ │ │ └── ff_thread_finish_setup() # 线程同步 │ │ └── [返回AVFrame] │ │ │ └── ff_decode_frame_props() # 设置帧属性 │ ├── set_frame_props() # 设置宽高、格式等 │ └── apply_cropping() # 应用裁剪 │ └── [返回AVFrame] → 用户处理显示/存储/推流 ​ ​ 【AVFilter 滤镜处理链路】 avfilter_graph_parse2() # 解析滤镜描述字符串 ├── parse_filter() # 解析单个滤镜 │ ├── avfilter_get_by_name() # 按名字找滤镜 │ ├── avfilter_graph_create_filter() # 创建滤镜实例 │ └── avfilter_link() # 连接滤镜 │ └── avfilter_graph_config() # 配置滤镜图 ├── link_filter_graph() # 建立连接 └── query_formats() # 查询支持的格式 ​ ​ av_buffersrc_add_frame() # 向滤镜图添加帧 ├── av_buffersrc_add_frame() │ └── buffer_source_add_frame() │ └── av_frame_clone() # 克隆帧 │ └── [入队到滤镜输入缓冲区] │ └── [滤镜处理线程/函数] → 逐帧处理 ​ ​ av_buffersink_get_frame() # 从滤镜图取帧 ├── av_buffersink_get_frame_flags() │ └── buffer_sink_get_frame() │ └── take_frame() # 从输出队列取帧 │ ├── filter_frame() # 调用滤镜处理 │ │ ├── AVFilter-filter_frame() │ │ │ ├── vf_scale-filter_frame() # 缩放 │ │ │ ├── vf_crop-filter_frame() # 裁剪 │ │ │ ├── vf_rotate-filter_frame() # 旋转 │ │ │ └── ... │ │ └── ff_filter_frame() # 传递到下一滤镜 │ └── [返回AVFrame] │ └── [返回处理后的AVFrame]2.2 编码链路函数调用树【AVFrame → 编码输出 AVPacket 完整调用链】 ​ avcodec_send_frame() # 发送原始帧到编码器 ├── encode_send_frame_internal() │ ├── check_frame() # 验证帧参数 │ ├── av_frame_ref() # 引用帧增加计数 │ └── av_fifo_write() # 写入编码器FIFO缓冲区 │ └── encode_receive_packet_internal() # 尝试编码可能立即输出 └── encode_simple_receive_packet() ├── encode_simple_internal() │ ├── ff_encode_get_frame() # 从FIFO取帧 │ │ └── av_fifo_read() # 从环形缓冲读取 │ ├── AVCodec-encode() # 调用具体编码器 │ │ ├── libx264_encode_frame() # x264编码 │ │ │ ├── x264_encoder_encode() │ │ │ └── convert_frame() # 格式转换 │ │ ├── libx265_encode_frame() │ │ ├── aac_encode_frame() │ │ └── ... │ └── encode_make_refcounted() # 使包可引用计数 │ └── [返回AVPacket] → 放入输出缓冲区 ​ ​ avcodec_receive_packet() # 接收编码后的包 ├── decode_receive_frame_internal() │ └── encode_simple_receive_packet() │ ├── [取缓冲区已有包] │ └── [或触发编码器刷新] │ └── [返回AVPacket] → 写入文件/推流 ​ ​ av_write_frame() / av_interleaved_write_frame() # 写入文件 ├── av_interleaved_write_frame() │ ├── interleave_packet() # 交错写入音视频同步 │ │ ├── AVOutputFormat-interleave_packet() │ │ └── av_interleaved_write_frame() │ │ │ └── write_packet() # 实际写入 │ ├── AVFormatContext-pb-write_packet() # AVIOContext写入 │ │ └── avio_write() # 缓冲写入 │ │ ├── flush_buffer() # 刷新缓冲 │ │ └── URLProtocol-url_write() # 具体协议write │ │ ├── file_write() # 文件写入 │ │ ├── tcp_write() # TCP发送 │ │ └── ... │ └── update_initial_timestamps() # 更新时间戳 │ └── [返回] → 数据已持久化三、内存管理树形分析3.1 内存管理整体架构【FFmpeg 内存管理层次结构】 ​ ┌─────────────────────────────────────────────────────────────────┐ │ 用户应用层 │ │ av_frame_alloc() / av_packet_alloc() / av_fifo_alloc() │ └──────────────────────────────┬──────────────────────────────────┘ ↓ ┌─────────────────────────────────────────────────────────────────┐ │ libavutil/mem.c基础内存分配 │ │ av_malloc() - 对齐分配默认32字节对齐 │ │ av_mallocz() - 分配并清零 │ │ av_realloc() - 重新分配 │ │ av_free() - 释放 │ │ av_memdup() - 复制内存 │ │ av_fast_malloc() - 快速分配带缓存 │ └──────────────────────────────┬──────────────────────────────────┘ ↓ ┌─────────────────────────────────────────────────────────────────┐ │ libavutil/buffer.c引用计数缓冲区 │ │ AVBufferRef 结构体 - 引用计数包装 │ │ av_buffer_alloc() - 分配引用计数缓冲区 │ │ av_buffer_create() - 创建缓冲区包装 │ │ av_buffer_ref() - 增加引用计数 │ │ av_buffer_unref() - 减少引用计数为0时释放 │ │ av_buffer_realloc() - 重新分配保持引用 │ └──────────────────────────────┬──────────────────────────────────┘ ↓ ┌─────────────────────────────────────────────────────────────────┐ │ libavutil/frame.c / packet.c │ │ AVFrame / AVPacket - 使用 AVBufferRef 管理数据 │ │ av_frame_alloc() - 分配AVFrame结构不含数据 │ │ av_frame_get_buffer() - 为AVFrame分配数据缓冲区 │ │ av_frame_ref() - 增加引用共享数据 │ │ av_frame_unref() - 减少引用释放数据 │ │ av_frame_clone() - 深拷贝新缓冲区 │ └─────────────────────────────────────────────────────────────────┘3.2 引用计数缓冲区详细结构/** * libavutil/buffer.h - 引用计数缓冲区核心结构 */ typedef struct AVBuffer { uint8_t *data; // 实际数据指针 size_t size; // 缓冲区大小 atomic_uint refcount; // 原子引用计数 void (*free)(void *opaque, uint8_t *data); // 释放回调 void *opaque; // 回调参数 } AVBuffer; ​ typedef struct AVBufferRef { AVBuffer *buffer; // 指向实际缓冲区 uint8_t *data; // 数据指针可能指向buffer-data offset size_t size; // 数据大小可能小于buffer-size } AVBufferRef; ​ ​ /* 引用计数操作流程 */ av_buffer_alloc(size) ├── AVBuffer *buf av_mallocz(sizeof(AVBufer)) ├── buf-data av_malloc(size AV_INPUT_BUFFER_PADDING_SIZE) ├── buf-size size ├── atomic_init(buf-refcount, 1) // 初始引用计数1 └── AVBufferRef *ref av_mallocz(sizeof(AVBuferRef)) ├── ref-buffer buf ├── ref-data buf-data ├── ref-size size └── return ref ​ av_buffer_ref(ref) // 增加引用 ├── atomic_fetch_add(ref-buffer-refcount, 1) // 原子1 └── return new_ref (指向同一buffer) ​ av_buffer_unref(ref) // 减少引用 ├── if (atomic_fetch_sub(ref-buffer-refcount, 1) 1) // 减到0 │ └── ref-buffer-free(ref-buffer-opaque, ref-buffer-data) │ └── av_free(ref-buffer-data) │ └── av_free(ref-buffer) └── av_free(ref) // 释放引用包装 ​ ​ /* 典型使用模式 - 零拷贝数据共享 */ AVFrame *frame1 av_frame_alloc(); AVFrame *frame2 av_frame_alloc(); ​ av_frame_get_buffer(frame1, 32); // frame1分配数据 av_frame_ref(frame2, frame1); // frame2共享frame1数据 // frame1和frame2共享同一份像素数据refcount2 ​ av_frame_unref(frame1); // refcount减到1数据不释放 av_frame_unref(frame2); // refcount减到0数据释放3.3 内存分配器选择与优化/** * FFmpeg 内存分配器可配置性 * 默认使用系统malloc可通过配置替换 */ /* 1. 默认分配器 (libavutil/mem.c) */ void *av_malloc(size_t size) { void *ptr NULL; if (size max_alloc_size) return NULL; /* 对齐分配默认32字节对齐 */ posix_memalign(ptr, ALIGN, size); return ptr; } ​ /* 2. 可替换的内存分配器 */ typedef struct { void *(*malloc)(size_t size); void *(*realloc)(void *ptr, size_t size); void (*free)(void *ptr); } AVMemoryAllocator; ​ /* 设置自定义分配器如使用jemalloc/tcmalloc */ av_mem_allocator_set(my_allocator); ​ /* 3. 硬件内存分配如cuda、drm */ av_hwframe_get_buffer() // 从硬件设备分配内存 av_hwframe_transfer_data() // 硬件/软件内存传输3.4 内存池与快速分配/** * av_fast_malloc / av_fast_realloc - 避免频繁分配 */ typedef struct { uint8_t *buffer; // 当前缓冲区 unsigned int size; // 缓冲区大小 unsigned int allocated; // 已分配大小 void (*free)(void *ptr); // 释放函数 } AVFastBuffer; ​ void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size) { AVFastBuffer *buf ptr; if (min_size buf-allocated) { // 空间足够直接返回 return; } // 空间不足以2倍增长策略重新分配 size_t new_size FFMAX(min_size, 2 * buf-allocated); buf-buffer av_realloc(buf-buffer, new_size); buf-allocated new_size; *size new_size; } ​ /* 使用示例 - 动态增长的缓冲区 */ static uint8_t *buffer NULL; static unsigned int buffer_size 0; ​ av_fast_malloc(buffer, buffer_size, needed_size); memcpy(buffer, src, needed_size);四、环形缓存树形分析4.1 AVFifoBuffer 核心结构/** * libavutil/fifo.h - FIFO环形缓冲区 * 源码位置: libavutil/fifo.c */ typedef struct AVFifoBuffer { uint8_t *buffer; // 缓冲区起始地址 uint8_t *rptr; // 读指针 uint8_t *wptr; // 写指针 uint8_t *end; // 缓冲区结束地址 uint32_t rndx; // 读索引辅助调试 uint32_t wndx; // 写索引辅助调试 } AVFifoBuffer;4.2 环形缓冲操作流程图【环形缓冲区状态机】 ​ 初始状态 (空): ┌─────────────────────────────────────┐ │ buffer ──┐ │ │ ↓ │ │ ┌───┬───┬───┬───┬───┬───┬───┬───┐ │ │ │ │ │ │ │ │ │ │ │ │ │ └───┴───┴───┴───┴───┴───┴───┴───┘ │ │ ↑ │ │ rptr/wptr │ │ end─────────────────────────────┘ └─────────────────────────────────────┘ ​ 写入3个元素后: ┌─────────────────────────────────────┐ │ ┌───┬───┬───┬───┬───┬───┬───┬───┐ │ │ │ A │ B │ C │ │ │ │ │ │ │ │ └───┴───┴───┴───┴───┴───┴───┴───┘ │ │ ↑ ↑ │ │ rptr wptr │ │ size() 3, space() 5 │ └─────────────────────────────────────┘ ​ 读取2个元素后: ┌─────────────────────────────────────┐ │ ┌───┬───┬───┬───┬───┬───┬───┬───┐ │ │ │ A │ B │ C │ │ │ │ │ │ │ │ └───┴───┴───┴───┴───┴───┴───┴───┘ │ │ ↑ ↑ │ │ rptr wptr │ │ size() 1, space() 7 │ └─────────────────────────────────────┘ ​ 继续写入直到绕回 (环形): ┌─────────────────────────────────────┐ │ ┌───┬───┬───┬───┬───┬───┬───┬───┐ │ │ │ X │ Y │ C │ D │ E │ F │ G │ H │ │ │ └───┴───┴───┴───┴───┴───┴───┴───┘ │ │ ↑ ↑ │ │ wptr rptr │ │ size() 7, space() 1 │ └─────────────────────────────────────┘4.3 FIFO核心函数实现分析/* libavutil/fifo.c - 核心函数实现 */ ​ /* 1. 创建FIFO */ AVFifoBuffer *av_fifo_alloc(size_t size) { AVFifoBuffer *f av_mallocz(sizeof(AVFifoBuffer)); f-buffer av_malloc(size); f-end f-buffer size; f-rptr f-buffer; f-wptr f-buffer; return f; } ​ /* 2. 写入数据泛型写入 */ int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int (*func)(void *, void *, int)) { int total size; do { int len FFMIN(f-end - f-wptr, size); if (func) { // 带回调的写入用于复杂数据类型 if (func(src, f-wptr, len) 0) break; } else { // 直接内存拷贝 memcpy(f-wptr, src, len); src (uint8_t *)src len; } f-wptr len; size - len; if (f-wptr f-end) f-wptr f-buffer; // 环形绕回 } while (size 0); return total - size; } ​ /* 3. 读取数据泛型读取 */ int av_fifo_generic_read(AVFifoBuffer *f, void *dst, int buf_size, void (*func)(void *, void *, int)) { do { int len FFMIN(f-end - f-rptr, buf_size); if (func) { // 带回调的读取如直接解码 func(dst, f-rptr, len); } else { memcpy(dst, f-rptr, len); dst (uint8_t *)dst len; } f-rptr len; if (f-rptr f-end) f-rptr f-buffer; buf_size - len; } while (buf_size 0); return 0; } ​ /* 4. 动态扩展FIFO */ void av_fifo_grow(AVFifoBuffer *f, unsigned int additional_space) { unsigned int old_size f-end - f-buffer; unsigned int new_size old_size additional_space; unsigned int offset_r f-rptr - f-buffer; unsigned int offset_w f-wptr - f-buffer; f-buffer av_realloc(f-buffer, new_size); f-end f-buffer new_size; // 处理环形情况 if (offset_r offset_w) { // 数据环绕需要移动 memmove(f-buffer new_size - (old_size - offset_r), f-buffer offset_r, old_size - offset_r); offset_r new_size - (old_size - offset_r); } f-rptr f-buffer offset_r; f-wptr f-buffer offset_w; }4.4 编解码器中的FIFO应用/** * 解码器中的FIFO使用场景 */ ​ /* 1. 解码器输入包队列 */ typedef struct Decoder { AVFifoBuffer *pkt_fifo; // 输入包FIFO AVCodecContext *avctx; // ... } Decoder; ​ /* 2. 接收包的流程 */ int decoder_receive_frame(Decoder *dec, AVFrame *frame) { AVPacket *pkt NULL; int ret; // 从FIFO取包 if (av_fifo_size(dec-pkt_fifo) sizeof(AVPacket)) { av_fifo_generic_read(dec-pkt_fifo, pkt, sizeof(AVPacket), NULL); } // 送包解码 ret avcodec_send_packet(dec-avctx, pkt); if (ret 0) return ret; // 取帧 return avcodec_receive_frame(dec-avctx, frame); } ​ /* 3. 向FIFO添加包 */ void decoder_add_packet(Decoder *dec, AVPacket *pkt) { // 深拷贝包因为包可能被复用 AVPacket *new_pkt av_packet_alloc(); av_packet_ref(new_pkt, pkt); // 写入FIFO av_fifo_generic_write(dec-pkt_fifo, new_pkt, sizeof(AVPacket), NULL); }五、事件分发 Reactor 设计模式分析5.1 FFmpeg 中的事件驱动模型/** * FFmpeg 并非传统意义上的 Reactor 模式 * 但 ffplay 播放器实现了类似的事件驱动机制 */ ​ /* ffplay.c - 主事件循环结构 */ typedef struct VideoState { // 消息队列 AVMessage msg_queue; // 事件队列 // ... } VideoState; ​ /* 消息结构体 */ typedef struct AVMessage { int what; // 消息类型 int arg1, arg2; // 参数 void *obj; // 对象指针 struct AVMessage *next; } AVMessage; ​ /* 消息类型定义 */ #define FF_QUIT_EVENT 1 // 退出事件 #define FF_REFRESH_EVENT 2 // 刷新事件重绘 #define FF_SEEK_EVENT 3 // 跳转事件 #define FF_PLAY_EVENT 4 // 播放事件 #define FF_PAUSE_EVENT 5 // 暂停事件5.2 消息队列实现/* ffplay.c - 消息队列操作 */ ​ /* 1. 消息入队 */ static void msg_queue_put(VideoState *is, AVMessage *msg) { AVMessage *msg1 av_malloc(sizeof(AVMessage)); *msg1 *msg; msg1-next NULL; pthread_mutex_lock(is-queue_mutex); if (!is-msg_queue.rear) { is-msg_queue.front is-msg_queue.rear msg1; } else { is-msg_queue.rear-next msg1; is-msg_queue.rear msg1; } pthread_cond_signal(is-msg_queue.cond); pthread_mutex_unlock(is-queue_mutex); } ​ /* 2. 消息出队阻塞 */ static int msg_queue_get(VideoState *is, AVMessage *msg, int block) { pthread_mutex_lock(is-queue_mutex); while (is-msg_queue.front NULL !is-abort_request) { if (block) { pthread_cond_wait(is-msg_queue.cond, is-queue_mutex); } else { pthread_mutex_unlock(is-queue_mutex); return -1; } } if (is-msg_queue.front) { AVMessage *msg1 is-msg_queue.front; *msg *msg1; is-msg_queue.front msg1-next; if (!is-msg_queue.front) is-msg_queue.rear NULL; av_free(msg1); } pthread_mutex_unlock(is-queue_mutex); return 0; }5.3 事件驱动流程图【ffplay 事件驱动架构】 ​ ┌─────────────────────────────────────┐ │ 主线程 (Main) │ │ while (!quit) { │ │ msg_queue_get(msg, block); │ │ switch(msg.what) { │ │ case FF_REFRESH_EVENT: │ │ video_refresh(); │ │ break; │ │ case FF_SEEK_EVENT: │ │ stream_seek(); │ │ break; │ │ case FF_QUIT_EVENT: │ │ quit 1; │ │ break; │ │ } │ │ } │ └─────────────────────────────────────┘ ↑ │ 消息入队 ┌───────────────┴───────────────┐ │ │ ↓ ↓ ┌───────────────────────┐ ┌───────────────────────┐ │ 解码线程 │ │ UI线程 │ │ (video_thread) │ │ (SDL事件循环) │ │ │ │ │ │ 解码完成后: │ │ 检测到键盘/鼠标事件: │ │ msg_queue_put( │ │ msg_queue_put( │ │ FF_REFRESH_EVENT) │ │ FF_SEEK_EVENT) │ └───────────────────────┘ └───────────────────────┘ ↑ ↑ │ │ └───────────────┬───────────────┘ │ ┌───────────┴───────────┐ │ 消息队列 │ │ (AVMessage FIFO) │ └───────────────────────┘六、数据量走向树形分析6.1 数据流层次结构【FFmpeg 数据流走向全景图】 ​ ┌─────────────────────────────────────────────────────────────────┐ │ 原始媒体数据 │ │ (文件/网络/设备) │ └─────────────────────────────┬───────────────────────────────────┘ ↓ ┌─────────────────────────────────────────────────────────────────┐ │ AVIOContext (I/O层) │ │ 数据量: 文件大小 / 网络流量 │ │ 缓冲区: 默认 32768 字节 │ └─────────────────────────────┬───────────────────────────────────┘ ↓ ┌─────────────────────────────────────────────────────────────────┐ │ AVFormatContext (解封装层) │ │ 输出: AVPacket (压缩数据) │ │ 数据量: 原始大小的 50%-90%取决于编码 │ │ 例如: 1GB 源文件 → AVPacket ≈ 200-500MB │ └─────────────────────────────┬───────────────────────────────────┘ ↓ ┌─────────────────────────────────────────────────────────────────┐ │ AVCodecContext (解码层) │ │ 输出: AVFrame (原始像素/音频) │ │ 数据量: 压缩数据的 10-100倍 │ │ H.264 1080p 帧: ≈ 3MB (YUV420p) │ │ 每秒: 30帧 × 3MB 90MB/s │ └─────────────────────────────┬───────────────────────────────────┘ ↓ ┌─────────────────────────────────────────────────────────────────┐ │ AVFilterGraph (滤镜处理层) │ │ 输入/输出: AVFrame │ │ 数据量: 不变或增加多输出 │ │ 例如: 缩放 4K→1080p → 数据量减少 75% │ └─────────────────────────────┬───────────────────────────────────┘ ↓ ┌─────────────────────────────────────────────────────────────────┐ │ AVCodecContext (编码层) │ │ 输出: AVPacket (压缩数据) │ │ 数据量: 原始帧的 1%-10%取决于码率 │ │ 1080p 视频: 约 2-8 Mbps │ └─────────────────────────────┬───────────────────────────────────┘ ↓ ┌─────────────────────────────────────────────────────────────────┐ │ AVFormatContext (封装层) │ │ 输出: 目标格式数据 │ │ 数据量: ≈ AVPacket总量 封装开销 │ └─────────────────────────────┬───────────────────────────────────┘ ↓ ┌─────────────────────────────────────────────────────────────────┐ │ AVIOContext (输出层) │ │ 最终写入: 文件/网络/设备 │ └─────────────────────────────────────────────────────────────────┘6.2 数据量计算公式/** * 数据量计算模型 */ ​ /* 1. 原始视频帧大小 */ frame_size width * height * bytes_per_pixel 例如: - YUV420p: bytes_per_pixel 1.5 1920x1080: 1920*1080*1.5 3,110,400 字节 ≈ 3 MB - NV12: 同上 - RGB24: bytes_per_pixel 3 1920x1080: 1920*1080*3 6,220,800 字节 ≈ 6 MB ​ /* 2. 原始视频码率 */ bitrate_raw frame_size * fps 例如: 3 MB/frame * 30 fps 90 MB/s 720 Mbps ​ /* 3. 压缩后码率 */ bitrate_compressed target_bitrate // 用户指定或自动选择 例如: H.264 1080p 典型码率 4-8 Mbps 压缩比 bitrate_raw / bitrate_compressed 720 / 8 90倍 ​ /* 4. 音频数据量 */ audio_frame_size sample_rate * channels * bytes_per_sample 例如: 48kHz, 立体声, 16bit 48000 * 2 * 2 192,000 字节/秒 ≈ 192 KB/s6.3 内存缓冲区配置/** * 关键缓冲区大小配置 */ ​ /* 1. AVIO 读写缓冲区 (libavformat/aviobuf.c) */ #define IO_BUFFER_SIZE 32768 // 32KB可通过avio_alloc_context自定义 ​ /* 2. 解码器内部缓冲区 (AVCodecContext) */ avctx-thread_count 4; // 多线程解码 avctx-internal-buffer_frame 队列 ​ /* 3. 帧缓冲区数量 */ #define VIDEO_PICTURE_QUEUE_SIZE 16 // ffplay默认视频队列大小 #define AUDIO_SAMPLE_QUEUE_SIZE 512 // 音频采样队列大小 ​ /* 4. 环形缓冲区示例配置 */ AVFifoBuffer *fifo av_fifo_alloc(1024 * 1024); // 1MB初始大小 av_fifo_grow(fifo, 2 * 1024 * 1024); // 扩展为2MB ​ /* 5. 编码器延迟 (B帧影响) */ int delay avctx-has_b_frames; // B帧导致的编码延迟 // 例如: H.264可能有2-5帧延迟七、多链路故障分析与定位7.1 典型故障场景/** * 问题1: 解码器初始化失败 * 症状: avcodec_open2 返回 -22 或 -1094995529 */ ​ /* 故障定位流程 */ int debug_decoder_open(AVCodecContext *avctx, const AVCodec *codec) { fprintf(stderr, Decoder Debug \n); fprintf(stderr, Codec: %s\n, codec-name); fprintf(stderr, Codec ID: %d\n, codec-id); fprintf(stderr, Width/Height: %d x %d\n, avctx-width, avctx-height); fprintf(stderr, Pixel Format: %d\n, avctx-pix_fmt); fprintf(stderr, Extradata size: %d\n, avctx-extradata_size); // 检查点1: 参数有效性 if (avctx-width 0 || avctx-height 0) { fprintf(stderr, ERROR: Invalid dimensions\n); return -1; } // 检查点2: extradata完整性 if (avctx-extradata_size 0) { // 检查H.264 SPS/PPS if (codec-id AV_CODEC_ID_H264) { uint8_t *sps avctx-extradata; if (sps[0] ! 0x01) { fprintf(stderr, WARNING: H.264 extradata format may be wrong\n); } } } // 尝试打开 int ret avcodec_open2(avctx, codec, NULL); if (ret 0) { char errbuf[128]; av_strerror(ret, errbuf, sizeof(errbuf)); fprintf(stderr, avcodec_open2 failed: %s (%d)\n, errbuf, ret); // 故障树定位 if (ret AVERROR(EINVAL)) { fprintf(stderr, - Likely cause: invalid parameters\n); fprintf(stderr, Check: width/height/pix_fmt/codec capabilities\n); } else if (ret AVERROR(ENOMEM)) { fprintf(stderr, - Out of memory\n); } else if (ret AVERROR_DECODER_NOT_FOUND) { fprintf(stderr, - Decoder not found\n); fprintf(stderr, Check: codec was found? avcodec_find_decoder_by_name\n); } } return ret; } ​ ​ /** * 问题2: av_read_frame 返回 -12 或 -11 (资源不足/重试) * 症状: 读取帧时卡住或返回错误 */ ​ int debug_read_frame(AVFormatContext *fmt_ctx, AVPacket *pkt) { int ret; int timeout 1000; // 毫秒 int64_t start_time av_gettime_relative(); while (1) { ret av_read_frame(fmt_ctx, pkt); if (ret 0) { // 成功读取 fprintf(stderr, Frame read: stream%d, size%d, pts%ld\n, pkt-stream_index, pkt-size, pkt-pts); return 0; } // 错误分析 if (ret AVERROR(EAGAIN) || ret AVERROR(ENOMEM)) { int64_t elapsed av_gettime_relative() - start_time; if (elapsed timeout * 1000) { fprintf(stderr, Timeout: no data after %d ms\n, timeout); return ret; } usleep(10000); // 10ms continue; } if (ret AVERROR_EOF) { fprintf(stderr, End of file\n); return ret; } // 其他错误 char errbuf[128]; av_strerror(ret, errbuf, sizeof(errbuf)); fprintf(stderr, av_read_frame error: %s (%d)\n, errbuf, ret); // 故障树定位 switch (ret) { case AVERROR_INVALIDDATA: fprintf(stderr, - Invalid data in stream\n); break; case AVERROR_PROTOCOL_NOT_FOUND: fprintf(stderr, - Protocol not found\n); break; case AVERROR_STREAM_NOT_FOUND: fprintf(stderr, - Stream not found\n); break; } return ret; } } ​ ​ /** * 问题3: 音视频不同步 (A/V desync) * 症状: 播放时音画不同步延迟逐渐增大 */ ​ typedef struct AVSyncDebug { int64_t last_video_pts; int64_t last_audio_pts; int64_t last_video_time; int64_t last_audio_time; int64_t drift_samples; } AVSyncDebug; ​ void debug_sync(AVSyncDebug *sync, int64_t video_pts, int64_t audio_pts) { int64_t now av_gettime_relative(); int64_t video_diff video_pts - sync-last_video_pts; int64_t audio_diff audio_pts - sync-last_audio_pts; if (sync-last_video_pts 0 sync-last_audio_pts 0) { int64_t video_delay (now - sync-last_video_time) - video_diff; int64_t audio_delay (now - sync-last_audio_time) - audio_diff; fprintf(stderr, Sync: video_delay%ld ms, audio_delay%ld ms, drift%ld\n, video_delay / 1000, audio_delay / 1000, (video_delay - audio_delay) / 1000); // 检测不同步阈值 if (llabs(video_delay - audio_delay) 1000000) { // 1秒 fprintf(stderr, WARNING: A/V desync detected!\n); fprintf(stderr, - Possible causes:\n); fprintf(stderr, - Bad timestamps in source\n); fprintf(stderr, - Dropped frames due to slow decoding\n); fprintf(stderr, - Audio/Video duration mismatch\n); } } sync-last_video_pts video_pts; sync-last_audio_pts audio_pts; sync-last_video_time now; sync-last_audio_time now; }7.2 常见错误码速查表错误码宏定义含义常见原因-541478725AVERROR_DECODER_NOT_FOUND解码器未找到未编译对应解码器/codec id错误-558323010AVERROR_ENCODER_NOT_FOUND编码器未找到未编译对应编码器/编码器名错误-22AVERROR(EINVAL)参数无效分辨率/格式不支持参数未初始化-12AVERROR(ENOMEM)内存不足缓冲区过大系统内存不足-11AVERROR(EAGAIN)重试解码器需要更多数据/输出缓冲区满-541478724AVERROR_EOF文件结束正常结束-1094995529AVERROR_INVALIDDATA数据无效码流损坏格式不支持-1414092869AVERROR_PROTOCOL_NOT_FOUND协议未找到未编译对应协议7.3 调试工具与技巧#!/bin/bash # ffmpeg_debug.sh - FFmpeg调试辅助脚本 ​ # 1. 查看编译配置 ffmpeg -buildconf ​ # 2. 查看支持的编解码器 ffmpeg -decoders | grep -i h264 ffmpeg -encoders | grep -i libx264 ​ # 3. 查看支持的格式 ffmpeg -formats | grep -i mp4 ​ # 4. 查看协议支持 ffmpeg -protocols ​ # 5. 详细日志级别 ffmpeg -loglevel debug -i input.mp4 -f null - ​ # 6. 打印所有帧信息 ffprobe -show_frames input.mp4 ​ # 7. 打印包信息 ffprobe -show_packets input.mp4 ​ # 8. 打印流信息 ffprobe -show_streams input.mp4 ​ # 9. 时间戳分析 ffprobe -show_frames input.mp4 | grep -E pkt_pts_time|pkt_dts_time ​ # 10. 内存泄漏检测 (valgrind) valgrind --leak-checkfull --track-originsyes ffmpeg -i input.mp4 -f null -7.4 典型故障树【故障树视频无法解码】 ​ 视频无法解码 │ ├─ 解码器未找到 │ ├─ 检查ffmpeg -decoders | grep codec │ ├─ 解决重新编译FFmpeg启用对应编解码器 │ └─ 示例--enable-libx264 │ ├─ 参数无效 │ ├─ 检查width/height/pix_fmt 是否正确设置 │ ├─ 检查extradata是否完整H.264需SPS/PPS │ ├─ 解决avcodec_parameters_to_context 正确复制 │ └─ 示例avctx-width codecpar-width │ ├─ 数据无效 │ ├─ 检查输入文件是否损坏 │ ├─ 检查av_read_frame 返回错误 │ ├─ 解决使用 ffmpeg -err_detect 检测错误 │ └─ 示例ffmpeg -err_detect explode │ ├─ 内存不足 │ ├─ 检查解码器内部缓冲区是否过大 │ ├─ 检查多线程配置是否合理 │ ├─ 解决降低 thread_count减少缓冲区 │ └─ 示例avctx-thread_count 1 │ └─ 时间戳异常 ├─ 检查AVPacket 的 pts/dts 是否正确 ├─ 检查时间基是否正确 ├─ 解决av_packet_rescale_ts 正确转换 └─ 示例av_packet_rescale_ts(pkt, st-time_base, avctx-time_base)八、总结分析维度核心要点关键文件源码目录8个核心库avcodec/avformat/avutil等fftools/ffmpeg.c函数调用链avformat_open_input → av_read_frame → avcodec_send_packet → avcodec_receive_framedecode.c, encode.c内存管理AVBufferRef引用计数av_fifo环形缓冲区libavutil/buffer.c, fifo.c环形缓存AVFifoBuffer读写指针环形操作libavutil/fifo.c事件分发ffplay消息队列模型fftools/ffplay.c数据量原始帧约3MB压缩后约30KB100倍压缩比-故障定位错误码、日志级别、调试工具-