FFMPEG硬件编解码器使用

-vcodec xxx

ffplay -x 800 -y 600 -vcodec h264_qsv h264.mp4
ffplay -x 800 -y 600 -vcodec hevc_qsv 4k_hevc.mp4
ffmpeg.exe -i test.ts -vcodec hevc_amf -s 1280x720 output.ts

AV_CODEC_ID_H264

avcodec_find_decoder(ID)

avcodec_find_encoder(ID)

avcodec_find_encoder_by_name(name)

avcodec_find_decoder_by_name(name)

//codec = avcodec_find_decoder(AV_CODEC_ID_H264);
codec = avcodec_find_decoder_by_name("h264_cuvid");
if (!codec) {
    fprintf(stderr, "Codec not found\n");
    exit(1);
}

static AVBufferRef* hw_device_ctx = NULL;
static enum AVPixelFormat hw_pix_fmt;
static FILE* output_file = NULL;
<p>//硬件加速初始化
static int hw_decoder_init(AVCodecContext* ctx, const enum AVHWDeviceType type) {
int err = 0;
//创建一个硬件设备上下文
if ((err = av_hwdevice_ctx_create(&hw_device_ctx, type, NULL, NULL, 0)) < 0) {
fprintf(stderr, "Failed to create specified HW device.\n");
return err;
}
ctx->hw_device_ctx = av_buffer_ref(hw_device_ctx);
return err;
}</p><p>//获取GPU硬件解码帧的格式
static enum AVPixelFormat get_hw_format(AVCodecContext<em> ctx, const enum AVPixelFormat</em> pix_fmts) {
const enum AVPixelFormat<em> p;
for (p = pix_fmts; </em>p != -1; p++) {
if (<em>p == hw_pix_fmt)
return </em>p;
}
fprintf(stderr, "Failed to get HW surface format.\n");
return AV_PIX_FMT_NONE;
}</p><p>//解码后数据格式转换，GPU到CPU拷贝，YUV数据dump到文件
static int decode_write(AVCodecContext<em> avctx, AVPacket</em> packet) {
AVFrame<em> frame = NULL, </em>sw_frame = NULL;
AVFrame<em> tmp_frame = NULL;
uint8_t</em> buffer = NULL;
int size;
int ret = 0;</p><pre class="brush:php;toolbar:false;"><pre class="brush:php;toolbar:false;">ret = avcodec_send_packet(avctx, packet);
if (ret < 0) {
    fprintf(stderr, "Error sending a packet for decoding\n");
    return ret;
}

while (ret >= 0) {
    if (!(frame = av_frame_alloc()) || !(sw_frame = av_frame_alloc())) {
        fprintf(stderr, "Can not alloc frame\n");
        ret = AVERROR(ENOMEM);
        goto fail;
    }

    ret = avcodec_receive_frame(avctx, frame);
    if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
        av_frame_free(&frame);
        av_frame_free(&sw_frame);
        return 0;
    } else if (ret < 0) {
        fprintf(stderr, "Error during decoding\n");
        goto fail;
    }

    if (frame->format == hw_pix_fmt) {
        /* 将解码后的数据从GPU内存格式转为CPU内存格式，并完成GPU到CPU内存的拷贝*/
        if ((ret = av_hwframe_transfer_data(sw_frame, frame, 0)) < 0) {
            fprintf(stderr, "Error transferring the data to system memory\n");
            goto fail;
        }
        tmp_frame = sw_frame;
    } else {
        tmp_frame = frame;
    }

    size = av_image_get_buffer_size((AVPixelFormat)tmp_frame->format, tmp_frame->width, tmp_frame->height, 1);
    //分配内存
    buffer = (uint8_t *)av_malloc(size);
    if (!buffer) {
        fprintf(stderr, "Can not alloc buffer\n");
        ret = AVERROR(ENOMEM);
        goto fail;
    }

    //将图片数据拷贝到buffer中(按行拷贝)
    ret = av_image_copy_to_buffer(buffer, size, (const uint8_t* const*)tmp_frame->data, (const int*)tmp_frame->linesize, (AVPixelFormat)tmp_frame->format, tmp_frame->width, tmp_frame->height, 1);
    if (ret < 0) {
        fprintf(stderr, "Can not copy image to buffer\n");
        goto fail;
    }

    fwrite(buffer, 1, size, output_file);
    av_frame_free(&frame);
    av_frame_free(&sw_frame);
    av_free(buffer);
}

<pre class="brush:php;toolbar:false;">if (argc < 4) {
    fprintf(stderr, "Usage: %s <device type> <input file> <output file>\n", argv[0]);
    return -1;
}

// 设备类型为：cuda dxva2 qsv d3d11va opencl，通常在windows使用d3d11va或者dxva2
type = av_hwdevice_find_type_by_name(argv[1]);
if (type == AV_HWDEVICE_TYPE_NONE) {
    fprintf(stderr, "Device type %s is not supported.\n", argv[1]);
    fprintf(stderr, "Available device types:");
    while ((type = av_hwdevice_iterate_types(type)) != AV_HWDEVICE_TYPE_NONE)
        fprintf(stderr, " %s", av_hwdevice_get_type_name(type));
    fprintf(stderr, "\n");
    return -1;
}

/* open the input file */
if (avformat_open_input(&input_ctx, argv[2], NULL, NULL) != 0) {
    fprintf(stderr, "Cannot open input file '%s'\n", argv[2]);
    return -1;
}

if (avformat_find_stream_info(input_ctx, NULL) < 0) {
    fprintf(stderr, "Cannot find stream information\n");
    return -1;
}

for (int i = 0; i < input_ctx->nb_streams; i++) {
    if (input_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
        video_stream = i;
        break;
    }
}

if (video_stream == -1) {
    fprintf(stderr, "No video stream found\n");
    return -1;
}

decoder = avcodec_find_decoder(input_ctx->streams[video_stream]->codecpar->codec_id);
if (!decoder) {
    fprintf(stderr, "Failed to find %s codec\n", av_get_media_type_string(AVMEDIA_TYPE_VIDEO));
    return -1;
}

while ((config = avcodec_get_hw_config(decoder, config ? config->config_id + 1 : 0))) {
    if (config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX &&
        config->device_type == type) {
        hw_pix_fmt = config->pix_fmt;
        break;
    }
}

if (!(decoder_ctx = avcodec_alloc_context3(decoder)))
    return AVERROR(ENOMEM);

video = input_ctx->streams[video_stream];
if (avcodec_parameters_to_context(decoder_ctx, video->codecpar) < 0)
    return -1;

decoder_ctx->get_format = get_hw_format;

//硬件加速初始化
if (hw_decoder_init(decoder_ctx, type) < 0)
    return -1;

if (avcodec_open2(decoder_ctx, decoder, NULL) < 0)
    return -1;

output_file = fopen(argv[3], "wb");
if (!output_file) {
    fprintf(stderr, "Could not open %s\n", argv[3]);
    return -1;
}

av_init_packet(&packet);
packet.data = NULL;
packet.size = 0;

while (av_read_frame(input_ctx, &packet) >= 0) {
    if (packet.stream_index == video_stream) {
        ret = decode_write(decoder_ctx, &packet);
        if (ret < 0)
            goto end;
    }
    av_packet_unref(&packet);
}

// Flush the decoder
packet.data = NULL;
packet.size = 0;
ret = decode_write(decoder_ctx, &packet);
if (ret < 0)
    goto end;

<pre class="brush:php;toolbar:false;">return ret;

hw_decoder.exe

hw_decoder.exe dxva2 D:\videos\hevcdemo.ts test.yuv