ffmpeg源码如何添加一种新的gpu加速器

原创已于 2025-11-19 15:39:41 修改 · 529 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#ffmpeg

于 2025-11-19 15:33:03 首次发布

本文是基于ffmpeg 6.1.1实验的记录和总结，不同的ffmpeg版本可能略有不同，

1. 理解FFmpeg硬件加速架构

FFmpeg的硬件加速主要通过以下几个组件实现：

硬件设备上下文 (AVHWDeviceContext)
硬件帧上下文 (AVHWFramesContext)
硬件加速编解码器
硬件滤镜

2. 主要实现步骤

步骤1：定义新的硬件设备类型

在 libavutil/hwcontext.h 中添加新的设备类型：

enum AVHWDeviceType {
    // ... 现有类型
    AV_HWDEVICE_TYPE_MYGPU,  // 你的新GPU类型
    // ...
};

步骤2：实现硬件设备上下文

创建新的硬件设备上下文实现文件，如 libavutil/hwcontext_mygpu.c：

#include "hwcontext.h"
#include "hwcontext_internal.h"
#include "hwcontext_mygpu.h"

// 设备内部私有数据结构
typedef struct MyGPUDevicePriv {
    void *gpu_context;
    int device_index;
    // 其他GPU特定数据
} MyGPUDevicePriv;

// 帧内部私有数据结构
typedef struct MyGPUFramePriv {
    void *gpu_memory_handle;
    size_t size;
    // 帧特定数据
} MyGPUFramePriv;

// 设备创建函数
static int mygpu_device_create(AVHWDeviceContext *ctx, const char *device,
                               AVDictionary *opts, int flags)
{
    MyGPUDevicePriv *priv = ctx->user_opaque;
    int err;
    
    // 初始化你的GPU SDK
    err = my_gpu_sdk_init(&priv->gpu_context, device);
    if (err < 0) {
        return AVERROR(ENODEV);
    }
    
    return 0;
}

// 帧分配函数
static int mygpu_frames_init(AVHWFramesContext *ctx)
{
    MyGPUDevicePriv *dev_priv = ctx->device_ctx->user_opaque;
    MyGPUFramePriv *frame_priv;
    
    // 分配GPU内存池等
    // ...
    
    return 0;
}

// 传输数据到GPU
static int mygpu_transfer_data_to(AVHWFramesContext *ctx, AVFrame *dst,
                                  const AVFrame *src)
{
    // 实现系统内存到GPU内存的传输
    // ...
    return 0;
}

// 从GPU传输数据
static int mygpu_transfer_data_from(AVHWFramesContext *ctx, AVFrame *dst,
                                    const AVFrame *src)
{
    // 实现GPU内存到系统内存的传输
    // ...
    return 0;
}

// 硬件设备上下文类
const HWContextClass ff_hwcontext_mygpu = {
    .type                 = AV_HWDEVICE_TYPE_MYGPU,
    .name                 = "mygpu",
    
    .device_priv_size     = sizeof(MyGPUDevicePriv),
    .frames_priv_size     = sizeof(MyGPUFramePriv),
    
    .device_create        = mygpu_device_create,
    .device_derive        = NULL, // 如果支持设备派生
    .device_init          = NULL,
    .device_uninit        = mygpu_device_uninit,
    
    .frames_get_buffer    = mygpu_get_buffer,
    .frames_init          = mygpu_frames_init,
    .frames_uninit        = mygpu_frames_uninit,
    
    .transfer_get_formats = mygpu_transfer_get_formats,
    .transfer_data_to     = mygpu_transfer_data_to,
    .transfer_data_from   = mygpu_transfer_data_from,
    
    .pix_fmts             = (const enum AVPixelFormat[]) {
        AV_PIX_FMT_MYGPU,  // 你的GPU像素格式
        AV_PIX_FMT_NONE
    },
};

步骤3：注册硬件设备类型

在相应的文件中注册新的硬件设备类型：

// 在 libavutil/hwcontext.c 中
extern const char *const hw_type_names[] = {
    //...
    [AV_HWDEVICE_TYPE_MYGPU] = "mygpu"
};

static const HWContextType* const hw_table[] = {
    // ... 其他类
#if CONFIG_MYGPU
    &ff_hwcontext_mygpu,
#endif
    NULL
};

// 在 libavutil/hwcontext_internal.h 中
extern const HWContextType ff_hwcontext_type_mygpu;

// 在 libavutil/pixfmt.h 中
enum AVPixelFormat {
    // ... 其他
    AV_PIX_FMT_MYGPU,
};

// 在 libavutil/pixdesc.c 中
static const AVPixFmtDescriptor av_pix_fmt_descriptors[AV_PIX_FMT_NB] = {
    // ... 其他类
    [AV_PIX_FMT_MYGPU] = {
         .name = "mygpu",
         .flags = AV_PIX_FMT_FLAG_HWACCEL,
    }
};

步骤4：实现编解码器集成

为你的GPU创建新的编解码器包装器：

// 在 libavcodec/mygpu_dec.c
typedef struct MyGPUDecodeContext {
    void *gpu_decoder;
    AVBufferRef *hw_device_ctx;
    AVFrame *hw_frame;
} MyGPUDecodeContext;

static int mygpu_decode_init(AVCodecContext *avctx)
{
    MyGPUDecodeContext *ctx = avctx->priv_data;
    int err;
    
    // 获取硬件设备上下文
    if (!avctx->hw_device_ctx) {
        av_log(avctx, AV_LOG_ERROR, "No hardware device context provided\n");
        return AVERROR(EINVAL);
    }
    
    // 初始化GPU解码器
    err = my_gpu_create_decoder(&ctx->gpu_decoder, avctx);
    if (err < 0) {
        return AVERROR_EXTERNAL;
    }
    
    return 0;
}

static int mygpu_decode_frame(AVCodecContext *avctx, AVFrame *frame,
                              int *got_frame, AVPacket *pkt)
{
    MyGPUDecodeContext *ctx = avctx->priv_data;
    int err;
    
    // 使用GPU解码数据包
    err = my_gpu_decode_packet(ctx->gpu_decoder, pkt->data, pkt->size);
    if (err < 0) {
        return AVERROR_EXTERNAL;
    }
    
    // 获取解码后的帧
    err = my_gpu_get_frame(ctx->gpu_decoder, frame);
    if (err < 0) {
        return err;
    }
    
    *got_frame = 1;
    return pkt->size;
}

AVCodec ff_mygpu_decoder = {
    .name           = "mygpu",
    .long_name      = NULL_IF_CONFIG_SMALL("My GPU decoder"),
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_H264, // 或其他支持的编码格式
    .priv_data_size = sizeof(MyGPUDecodeContext),
    .init           = mygpu_decode_init,
    .decode         = mygpu_decode_frame,
    .close          = mygpu_decode_close,
    .capabilities   = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HARDWARE,
    .wrapper_name   = "mygpu",
    .pix_fmts       = (const enum AVPixelFormat[]) { 
        AV_PIX_FMT_MYGPU, 
        AV_PIX_FMT_NONE 
    },
};

步骤5：修改构建系统

修改 configure 脚本和相应的 Makefile：

makefile

# 在 libavutil/Makefile 中添加
OBJS-$(CONFIG_MYGPU)                += hwcontext_mygpu.o

# 在 libavcodec/Makefile 中添加
OBJS-$(CONFIG_MYGPU_DECODER)        += mygpu_dec.o

configure文件中添加

HWACCEL_AUTODETECT_LIBRARY_LIST="
    // ... 
    mygpu
"
..
mygpu_deps=""
...
mygpu_filter_deps="mygpu"
...
enable mygpu

3. 配置和编译

bash

# 配置时启用你的新GPU支持
./configure \
    --enable-mygpu \
    --extra-cflags="-I/path/to/your/gpu/sdk/include" \
    --extra-ldflags="-L/path/to/your/gpu/sdk/lib" \
    --extra-libs="-lmy_gpu_sdk"

# 编译
make -j$(nproc)

4. 使用示例

编译完成后，可以这样使用新的GPU加速器：

bash

# 解码
ffmpeg -hwaccel mygpu -c:v h264_mygpu -i input.mp4 output.yuv

# 转码
ffmpeg -hwaccel mygpu -c:v h264_mygpu -i input.mp4 -c:v libx264 output.mp4

5. 关键考虑因素

内存管理：正确处理GPU和系统内存之间的数据传输
格式支持：定义支持的像素格式和色彩空间
同步机制：处理CPU-GPU同步
错误处理：完善的错误处理和资源清理
性能优化：最小化内存拷贝和同步开销

6. 测试和验证

创建测试用例验证功能：

编解码正确性
内存泄漏检查
性能基准测试
多线程安全性

这个过程需要深入理解FFmpeg内部架构和你的GPU SDK。建议参考现有的硬件加速实现（如CUDA、VAAPI、DXVA2）作为模板。