13、OpenCV与FFmpeg结合：使用OpenCV处理FFmpeg解码帧，实现图像增强与特效。

说实话，做音视频开发这么多年，我遇到过不少这样的场景：FFmpeg 把视频流解码出来，得到一帧一帧的原始数据，然后你想对这些帧做点“额外的事情”——比如调个色、加个滤镜、或者做点图像增强。这时候，OpenCV 就是最好的搭档。

为什么这么说？因为 FFmpeg 擅长的是编解码和封装，而 OpenCV 擅长的是像素级的图像处理。两者结合，说白了就是“解码交给 FFmpeg，处理交给 OpenCV，编码再交回 FFmpeg”。这个流程我几乎在每个项目中都用过，今天就把这套组合拳的实战经验分享给你。

13.1 为什么需要结合？

你想想看，FFmpeg 本身也提供了一些滤镜（filter），比如 scale、crop、hue 等。但如果你要做更复杂的图像处理——比如人脸美颜、背景虚化、或者基于深度学习的特效，FFmpeg 的滤镜就有点力不从心了。

OpenCV 就不一样了。它内置了上百种图像处理函数，从简单的亮度对比度调整，到复杂的边缘检测、直方图均衡化，甚至还能调用深度学习模型。我在做一个直播美颜项目时，就是先用 FFmpeg 解码摄像头采集的 YUV 数据，然后转成 OpenCV 的 Mat，用双边滤波做磨皮，再用直方图均衡化提亮肤色——效果立竿见影。

13.2 数据格式转换：AVFrame ↔ Mat

这是整个结合的关键。FFmpeg 解码出来的 AVFrame，默认是 YUV420P 格式（像素格式为 AV_PIX_FMT_YUV420P）。而 OpenCV 的 Mat 默认是 BGR 格式（三通道 8 位）。所以我们需要做一次格式转换。

我个人习惯用 sws_scale 来做这个转换。为什么不用 OpenCV 的 cvtColor？因为 sws_scale 是 FFmpeg 自带的，性能优化得非常好，而且支持硬件加速。你想想看，视频处理最怕的就是性能瓶颈，sws_scale 在这方面比 OpenCV 的软件转换要快不少。

13.2.1 YUV420P → BGR Mat

// 假设已经通过 avcodec_receive_frame 拿到了 AVFrame* frame
// 1. 创建 SwsContext
SwsContext* sws_ctx = sws_getContext(
    frame->width, frame->height, AV_PIX_FMT_YUV420P,  // 源格式
    frame->width, frame->height, AV_PIX_FMT_BGR24,    // 目标格式
    SWS_BILINEAR, nullptr, nullptr, nullptr
);

// 2. 分配目标缓冲区
uint8_t* dst_data[4];
int dst_linesize[4];
av_image_alloc(dst_data, dst_linesize, 
               frame->width, frame->height, AV_PIX_FMT_BGR24, 1);

// 3. 执行转换
sws_scale(sws_ctx, 
          frame->data, frame->linesize, 0, frame->height,
          dst_data, dst_linesize);

// 4. 创建 OpenCV Mat
cv::Mat bgr_frame(frame->height, frame->width, CV_8UC3, dst_data[0]);

// 现在 bgr_frame 就是 OpenCV 可以处理的图像了
// 处理完后记得释放资源
av_freep(&dst_data[0]);
sws_freeContext(sws_ctx);

13.2.2 BGR Mat → YUV420P AVFrame

处理完图像后，你需要把 Mat 转回 AVFrame，才能交给编码器。这个过程其实就是上面的逆操作：

// 假设已经处理完的 Mat: processed_bgr
// 1. 创建目标 AVFrame
AVFrame* out_frame = av_frame_alloc();
out_frame->format = AV_PIX_FMT_YUV420P;
out_frame->width = processed_bgr.cols;
out_frame->height = processed_bgr.rows;
av_frame_get_buffer(out_frame, 32);  // 32 字节对齐

// 2. 创建 SwsContext（目标格式改为 YUV420P）
SwsContext* sws_ctx = sws_getContext(
    processed_bgr.cols, processed_bgr.rows, AV_PIX_FMT_BGR24,
    processed_bgr.cols, processed_bgr.rows, AV_PIX_FMT_YUV420P,
    SWS_BILINEAR, nullptr, nullptr, nullptr
);

// 3. 准备源数据（Mat 的数据指针）
uint8_t* src_data[4] = { processed_bgr.data, nullptr, nullptr, nullptr };
int src_linesize[4] = { (int)processed_bgr.step, 0, 0, 0 };

// 4. 执行转换
sws_scale(sws_ctx, src_data, src_linesize, 0, processed_bgr.rows,
          out_frame->data, out_frame->linesize);

// 现在 out_frame 就可以交给编码器了
// 记得释放
sws_freeContext(sws_ctx);

13.3 实战：图像增强与特效

好了，数据通道打通了，接下来就是发挥 OpenCV 威力的时候了。我挑几个常用的增强和特效场景，给你看看实际代码怎么写。

13.3.1 亮度与对比度调整

这个是最基础的图像增强。OpenCV 提供了 convertTo 函数，可以一次性调整亮度和对比度：

cv::Mat enhance_brightness_contrast(const cv::Mat& src, 
                                     double alpha,  // 对比度增益，1.0 为原始
                                     double beta)   // 亮度增益，0 为原始
{
    cv::Mat dst;
    // dst = src * alpha + beta
    src.convertTo(dst, -1, alpha, beta);
    return dst;
}

// 使用示例：对比度提升 1.2 倍，亮度增加 30
cv::Mat enhanced = enhance_brightness_contrast(bgr_frame, 1.2, 30);

我在做安防监控项目时，经常遇到夜间视频太暗的情况。这时候把 alpha 设为 1.0，beta 设为 50~80，画面一下子就亮起来了。不过要注意，beta 太大会导致过曝，白色区域一片死白——嗯，这个得根据实际场景调参。

13.3.2 直方图均衡化（提升对比度）

如果画面整体偏暗或者偏亮，直方图均衡化是个好办法。但 OpenCV 的 equalizeHist 只支持单通道灰度图，所以我们需要先转成 YUV，只对 Y 通道做均衡化：

cv::Mat histogram_equalization(const cv::Mat& bgr)
{
    cv::Mat yuv, y_channel, equalized;
    cv::cvtColor(bgr, yuv, cv::COLOR_BGR2YUV);
    
    // 分离通道
    std::vector<cv::Mat> channels;
    cv::split(yuv, channels);
    
    // 对 Y 通道做直方图均衡化
    cv::equalizeHist(channels[0], channels[0]);
    
    // 合并回去
    cv::merge(channels, yuv);
    
    // 转回 BGR
    cv::cvtColor(yuv, equalized, cv::COLOR_YUV2BGR);
    return equalized;
}

13.3.3 高斯模糊与锐化

高斯模糊可以用来降噪，而锐化可以增强细节。这两个经常搭配使用：

cv::Mat sharpen(const cv::Mat& src)
{
    // 先做一点高斯模糊，去除噪声
    cv::Mat blurred;
    cv::GaussianBlur(src, blurred, cv::Size(3, 3), 1.0);
    
    // 锐化核：中心为 5，周围为 -1
    cv::Mat kernel = (cv::Mat_<float>(3, 3) <<
        0, -1, 0,
        -1, 5, -1,
        0, -1, 0);
    
    cv::Mat dst;
    cv::filter2D(blurred, dst, src.depth(), kernel);
    return dst;
}

这个锐化核是我比较常用的。如果你觉得锐化过度，可以把中心值调小一点，比如从 5 改成 4，效果会柔和很多。

13.3.4 添加滤镜特效

滤镜特效其实就是在像素层面做颜色映射。比如做一个“怀旧风格”滤镜：

cv::Mat sepia_filter(const cv::Mat& src)
{
    cv::Mat dst = src.clone();
    for (int y = 0; y < dst.rows; y++) {
        for (int x = 0; x < dst.cols; x++) {
            cv::Vec3b& pixel = dst.at<cv::Vec3b>(y, x);
            int b = pixel[0], g = pixel[1], r = pixel[2];
            
            // 怀旧色调映射
            int new_r = std::min(255, (int)(r * 0.393 + g * 0.769 + b * 0.189));
            int new_g = std::min(255, (int)(r * 0.349 + g * 0.686 + b * 0.168));
            int new_b = std::min(255, (int)(r * 0.272 + g * 0.534 + b * 0.131));
            
            pixel[0] = new_b;
            pixel[1] = new_g;
            pixel[2] = new_r;
        }
    }
    return dst;
}

当然，实际项目中不会用这种逐像素循环的方式，性能太差了。更好的做法是用 OpenCV 的 LUT（查找表）或者矩阵运算。但这里为了让你看清楚原理，我就用最直观的方式写了。

13.4 完整流程：解码 → 处理 → 编码

把上面的知识点串起来，一个完整的处理流程大概是这样的：

// 伪代码，展示整体流程
void process_video(const char* input_file, const char* output_file)
{
    // 1. 初始化 FFmpeg 解码器和编码器（省略细节）
    AVFormatContext* ifmt_ctx = nullptr;
    AVCodecContext* dec_ctx = nullptr;
    // ... 打开文件、查找流、打开解码器等
    
    AVFormatContext* ofmt_ctx = nullptr;
    AVCodecContext* enc_ctx = nullptr;
    // ... 创建输出文件、初始化编码器等
    
    // 2. 创建 SwsContext（用于 YUV ↔ BGR 转换）
    SwsContext* sws_to_bgr = sws_getContext(/* ... */);
    SwsContext* sws_to_yuv = sws_getContext(/* ... */);
    
    // 3. 分配缓冲区
    uint8_t* bgr_buffer[4];
    int bgr_linesize[4];
    av_image_alloc(bgr_buffer, bgr_linesize, 
                   width, height, AV_PIX_FMT_BGR24, 1);
    
    AVPacket* pkt = av_packet_alloc();
    AVFrame* frame = av_frame_alloc();
    
    // 4. 逐帧处理
    while (av_read_frame(ifmt_ctx, pkt) >= 0) {
        if (pkt->stream_index == video_stream_idx) {
            avcodec_send_packet(dec_ctx, pkt);
            while (avcodec_receive_frame(dec_ctx, frame) == 0) {
                // 4.1 YUV → BGR Mat
                sws_scale(sws_to_bgr, 
                          frame->data, frame->linesize, 0, height,
                          bgr_buffer, bgr_linesize);
                cv::Mat bgr_mat(height, width, CV_8UC3, bgr_buffer[0]);
                
                // 4.2 图像处理（这里可以调用任意 OpenCV 函数）
                cv::Mat processed = sharpen(bgr_mat);  // 锐化
                // cv::Mat processed = sepia_filter(bgr_mat);  // 怀旧滤镜
                // cv::Mat processed = histogram_equalization(bgr_mat);  // 直方图均衡
                
                // 4.3 BGR Mat → YUV AVFrame
                AVFrame* out_frame = av_frame_alloc();
                out_frame->format = AV_PIX_FMT_YUV420P;
                out_frame->width = width;
                out_frame->height = height;
                av_frame_get_buffer(out_frame, 32);
                
                uint8_t* src_data[4] = { processed.data, nullptr, nullptr, nullptr };
                int src_linesize[4] = { (int)processed.step, 0, 0, 0 };
                sws_scale(sws_to_yuv, src_data, src_linesize, 0, height,
                          out_frame->data, out_frame->linesize);
                
                // 4.4 编码并写入
                avcodec_send_frame(enc_ctx, out_frame);
                AVPacket* out_pkt = av_packet_alloc();
                while (avcodec_receive_packet(enc_ctx, out_pkt) == 0) {
                    av_interleaved_write_frame(ofmt_ctx, out_pkt);
                    av_packet_unref(out_pkt);
                }
                av_packet_free(&out_pkt);
                av_frame_free(&out_frame);
            }
        }
        av_packet_unref(pkt);
    }
    
    // 5. 清理资源
    av_frame_free(&frame);
    av_packet_free(&pkt);
    av_freep(&bgr_buffer[0]);
    sws_freeContext(sws_to_bgr);
    sws_freeContext(sws_to_yuv);
    // ... 关闭解码器、编码器、文件等
}

13.5 知识体系与核心逻辑

下面这张图总结了本章的核心逻辑，你可以对照着理解整个流程：

13.6 避坑指南

最后，分享几个我踩过的坑，希望能帮你省点时间：

• 内存泄漏： 每帧都 av_frame_alloc 但不释放，跑几分钟内存就爆了。记得每帧处理完后调用 av_frame_free。
• 颜色空间问题： OpenCV 默认是 BGR 顺序，而 FFmpeg 的 RGB 是 RGB 顺序。如果你直接用 cvtColor 转成 RGB，颜色会错乱。我建议统一用 BGR24 作为中间格式。
• 性能瓶颈： sws_scale 虽然快，但每帧都做两次转换（YUV→BGR 和 BGR→YUV）还是有开销的。如果对性能要求极高，可以考虑直接操作 YUV 数据，跳过 BGR 转换。但那样 OpenCV 的处理函数就不能直接用了，需要自己写 YUV 级别的算法。
• 对齐问题： OpenCV 的 Mat 默认是 4 字节对齐，而 FFmpeg 的 AVFrame 可能需要 32 字节对齐。在 av_frame_get_buffer 时指定对齐参数，或者在 sws_scale 时注意 linesize 的匹配。

嗯，差不多就这些了。OpenCV 和 FFmpeg 的结合，说白了就是“各取所长”——FFmpeg 管好它的编解码，OpenCV 管好它的图像处理。你只要把中间的桥梁搭好，剩下的就是发挥想象力了。

---