FFmpeg解码的软解及硬解（cuda和qsv）使用方法

科技 08-15 来源： 音视频开发老舅

本次使用的ffmpeg版本是4.2，解码的调用方式为：

int32_t iRet = -1; // 最后一个包解码完成后，需要取完解码器中剩余的缓存帧;// 调用avcodec_send_packet时塞空包进去,;// 解码器就会知道所有包解码完成，再调用avcodec_receive_frame时，将会取出缓存帧;// AVPacket    packet;// av_init_packet(&packet);// pkt.data = NULL;// pkt.size = 0;// avcodec_send_packet(ctx, pkt); iRet = avcodec_send_packet(ctx, pkt);if (iRet != 0 && iRet != AVERROR(EAGAIN)) {    get_ffmepg_err_str(iRet);    if (iRet == AVERROR_EOF)        iRet = 0;    return iRet;} while (true) {    // 每解出来一帧，丢到队列中;    iRet = avcodec_receive_frame(ctx, frame);    if (iRet != 0) {        if (iRet == AVERROR(EAGAIN)) {            return 0;        } else            return iRet;    }    PushRenderBuffer();    // 音频解码后，如果需要重采样，也可以在此处进行resample; }

以前的版本解码方式为：

int32_t iRet = -1;iRet = avcodec_send_packet(ctx, pkt);if (iRet != 0 && iRet != AVERROR(EAGAIN)) {    get_ffmepg_err_str(iRet);    if (iRet == AVERROR_EOF)        iRet = 0;    return iRet;} avcodec_decode_video2(pCodecCtx, frame, iGotPicture, pkt);

新旧版本更新时，注意接口的使用方法，新版本avcodec_send_packet一次，需要循环调用avcodec_receive_frame多次，返回EAGAIN后，结束当前这次的解码，音频解码也是一样

C++音视频开发学习资料：点击领取→音视频开发（资料文档+视频教程+面试题）（FFmpeg+WebRTC+RTMP+RTSP+HLS+RTP）

一、软件解码：

先上一段代码，再做下说明，这是解码视频文件，以AVStream的方式获取文件信息，再创建解码器

int32_t ret = avformat_open_input(&m_pAVFormatIC, pPath, NULL, NULL);if (avformat_find_stream_info(m_pAVFormatIC, NULL) < 0) {    return;}for (uint32_t i = 0; i < m_pAVFormatIC->nb_streams; i++) {    switch (m_pAVFormatIC->streams[i]->codec->codec_type) {        case AVMEDIA_TYPE_VIDEO:            // 视频流;            AVCodec *find_codec = avcodec_find_decoder(m_pAVFormatIC->streams[i]->codec->codec_id);            AVCodecContext *codec_ctx = avcodec_alloc_context3(find_codec);            avcodec_parameters_to_context(codec_ctx, m_pAVFormatIC->streams[i]->codecpar);            codec_ctx->opaque = this;            codec_ctx->thread_count = 5;            codec_ctx->thread_safe_callbacks = 1;            // avcodec_receive_frame的frame数据内存交由自己申请，自己释放，减少内存申请及拷贝;            codec_ctx->get_buffer2 = DemuxStream::CustomFrameAllocBuffer;            avcodec_open2(codec_ctx, find_codec, NULL);            continue;        case AVMEDIA_TYPE_AUDIO:            // 音频流;            // 同上;            continue;    }}

1、m_pAVFormatIC->streams[i]->codec->codec_type 来判断是否包含音频和视频数据，如果是mp3文件，codec_type有Video是表示MP3的封面图片帧;

2、avcodec_find_decoder和avcodec_alloc_context3创建的指针，不需要覆盖stream中的指针，这是错误的用法，stream只是记录当前文件的流信息，不要用来保存context，创建的context由自己来保管；

3、avcodec_parameters_to_context，一定要做，这是把解析到的留信息设置到context，不需要在自己一个参数一个参数的设置；

4、多线程软解，thread_count不修改的话默认值是1，使用单个线程进行解码，遇到一些大文件，比如4K，30帧以上的视频流时，解码速度是跟不上的，有两种方案：多线程软解或者硬件解码（后面说）

thread_count为0，表示由ffmpeg调用最大线程数来进行软解，我的电脑的6核12线程，被创建了13个线程进行解码，实际上这会资源过剩，可以根据实际使用情况设置指定线程数量进行解码，这里我设置的是5,

切记！在设置thread_count大于1的值时，一定要把thread_safe_callbacks设置为1，否则的话必定会产生崩溃；

默认时，thread_safe_callbacks是为0，thread_count是1或者0的时候，都不需要这个标记

5、自行分配avcodec_receive_frame中frame的数据内存

调用avcodec_receive_frame获取到解码完成后的视频帧，如果需要获取视频的数据流，需要将frame中的data拷贝到连续的内存地址中，具体方法：

uint8_t* AllocBufferByFrame(const AVFrame *frame){    if (!frame)        return nullptr;    int32_t s = av_image_get_buffer_size((AVPixelFormat)frame->format,                                         frame->width,                                         frame->height, 1);    if (s <= 0)        return nullptr;    return new uint8_t[s]{0};} int32_t FillBufferFromFrame(uint8_t* alloced_buffer, const AVFrame *frame){    if (!alloced_buffer || !frame)        return -1;     uint8_t* dst_data[4]{};    int dst_linesize[4]{};    int32_t ret = av_image_fill_arrays(dst_data, dst_linesize, alloced_buffer,        (AVPixelFormat)frame->format,                                       frame->width,                                       frame->height,                                       1);    if (ret <= 0)        return ret;    av_image_copy(dst_data, dst_linesize,        (const uint8_t **)frame->data,                  frame->linesize,                  (AVPixelFormat)frame->format,                  frame->width,                  frame->height);    return ret;} uint8_t *buffer = AllocBufferByFrame(frame);FillBufferFromFrame(buffer, frame);// 使用完buffer的地方，释放buffer的内存;

按照这种使用方法，同一帧的数据会申请两份，解码器中申请了一份，拷贝到buffer中一份，增加了内存消耗以及数据拷贝，ffmpeg提供了解码时frame的内存由自己管理的回调接口，get_buffer2，这个回调接口在调用avcodec_receive_frame时，如果自定义了函数指针，将会调用自定义的函数接口，在接口内完成frame的data，linesize，buf的内容填充，在回调时，frame中的format，width，height已经被填充，可以直接拿来使用，注意：在get_buffer2的回调里，flag是AV_GET_BUFFER_FLAG_REF（1），我们申请的内存会被其他frame复用，不能直接释放，应该通过绑定的free接口来释放，我这里申请的是连续内存，回调free的接口每个平面都会调用，只有第一个平面也就是data[0]的时候，才能delete，方法如下：

void DemuxStream::CustomFrameFreeBuffer(void *opaque, uint8_t *data){    //申请的空间是连续的，只有第一个data，也就是data[0]的时候再删除，否则会崩溃;    int i = (int)opaque;    if (i == 0)        delete data;} int DemuxStream::CustomFrameAllocBuffer(struct AVCodecContext *s, AVFrame *frame, int flags){    int32_t size = av_image_get_buffer_size((AVPixelFormat)frame->format,                                            frame->width,                                            frame->height, 1);    if (size <= 0)        return -1;    // 这是由自己申请的内存，avcodec_receive_frame使用完后要自己释放;    uint8_t *buffer = new uint8_t[size]{0};    uint8_t* dst_data[AV_NUM_DATA_POINTERS]{};    int dst_linesize[AV_NUM_DATA_POINTERS]{};    int32_t ret = av_image_fill_arrays(dst_data, dst_linesize, buffer,        (AVPixelFormat)frame->format, frame->width, frame->height, 1);    if (ret < 0) {        delete[] buffer;        return ret;    }    for (int i = 0; i < AV_NUM_DATA_POINTERS; i++) {        frame->linesize[i] = dst_linesize[i];        frame->data[i] = dst_data[i];        frame->buf[i] = av_buffer_create(frame->data[i],                                         frame->linesize[i] * frame->height,                                         DemuxStream::CustomFrameFreeBuffer,                                         (void *)i, 0);    }    return 0;} // 解码时伪代码;avcodec_send_packet(ctx, pkt);while (true) {    // 每解出来一帧，丢到队列中;    iRet = avcodec_receive_frame(ctx, frame);    if (iRet != 0) {        if (iRet == AVERROR(EAGAIN)) {            return 0;        } else            return iRet;    }    push_render_buffer(frame);    //使用完成后，调用av_frame_unref,内存回收会在CustomFrameFreeBuffer执行;    //因为自行申请的buffer，交给ffmpeg后，有可能会被复用，不能直接删除buffer;}

C++音视频开发学习资料：点击领取→音视频开发（资料文档+视频教程+面试题）（FFmpeg+WebRTC+RTMP+RTSP+HLS+RTP）

二、硬件解码

硬件解码需要编译的ffmpeg库支持，具体编译方法就不再此赘述，本次用到的硬件解码为英伟达cuda和英特尔的qsv，硬解解码器的创建跟软解有所不同，使用的过程也只是存在一点差异

1、英伟达，cuda

AVPixelFormat DemuxStream::GetHwFormat(AVCodecContext * ctx, const AVPixelFormat * pix_fmts){    const enum AVPixelFormat *p;    DemuxStream *pThis = (DemuxStream *)ctx->opaque;    for (p = pix_fmts; *p != -1; p++) {        if (*p == pThis->m_AVStreamInfo.hw_pix_fmt) {            return *p;        }    }     fprintf(stderr, "Failed to get HW surface format.
");    return AV_PIX_FMT_NONE;}AVCodecContext * DemuxStream::GetCudaDecoder(AVStream *stream){    int32_t ret = avformat_open_input(&m_pAVFormatIC, pPath, NULL, NULL);    if (ret < 0)        return nullptr;    if (avformat_find_stream_info(m_pAVFormatIC, NULL) < 0)        return nullptr;    ret = av_find_best_stream(m_pAVFormatIC, AVMEDIA_TYPE_VIDEO, -1, -1, &find_codec, 0);    if (ret < 0)        return nullptr;    for (int i = 0;; i++) {        const AVCodecHWConfig *config = avcodec_get_hw_config(find_codec, i);        if (!config) {            // 没找到cuda解码器，不能使用;            return nullptr;        }        if (config->device_type == AV_HWDEVICE_TYPE_CUDA) {            // 找到了cuda解码器，记录对应的AVPixelFormat,后面get_format需要使用;            m_AVStreamInfo.hw_pix_fmt = config->pix_fmt;            m_AVStreamInfo.device_type = AV_HWDEVICE_TYPE_CUDA;            break;        }    }    AVCodecContext *decoder_ctx = avcodec_alloc_context3(find_codec);     avcodec_parameters_to_context(decoder_ctx, m_pAVFormatIC->stream[video_index]->codecpar);    decoder_ctx->opaque = this;    decoder_ctx->get_format = DemuxStream::GetHwFormat;     if (m_AVStreamInfo.hw_device_ctx) {        av_buffer_unref(&m_AVStreamInfo.hw_device_ctx);        m_AVStreamInfo.hw_device_ctx = NULL;    }    if (av_hwdevice_ctx_create(&m_AVStreamInfo.hw_device_ctx, m_AVStreamInfo.device_type,                               NULL, NULL, 0) < 0) {        fprintf(stderr, "Failed to create specified HW device.
");        // 创建硬解设备context失败，不能使用;        return nullptr;    }    decoder_ctx->hw_device_ctx = av_buffer_ref(m_AVStreamInfo.hw_device_ctx);    avcodec_open2(decoder_ctx, find_codec, NULL);}

avcodec_get_hw_config，从当前硬解的配置中，遍历寻找适用于当前AvCodec的cuda配置，找到后记录cuda解码后的AVPixelFormat，后面解码器初始化时会使用到这个pix_fmt；

设置get_format的回调接口，在回调接口里面，会遍历cuda解码器支持的输出格式，匹配记录的pix_fmt才可以使用，在get_format如果没有找到匹配的硬解设置，可以返回指定类型的软解输出格式，解码器会自动切换到软解进行解码

初始化cuda解码器之前，先创建硬解设备context，赋值AVCodecContext->hw_device_ctx为其引用

至此cuda解码器创建完成，接下来是解码获取视频帧，硬解获得的视频帧后续的处理方式与软解是一样的，硬解比软解多了一步av_hwframe_transfer_data，在avcodec_receive_frame执行完成后，获得的frame中的数据时GPU的数据，是不能直接拿出来用的，需要通过av_hwframe_transfer_data转到内存数据，转换完成后记得把frame的属性通过av_frame_copy_props设置给hw_frame，这里的硬解获取视频帧同样适用于qsv硬解；

iRet = avcodec_send_packet(ctx, pkt);if (iRet != 0 && iRet != AVERROR(EAGAIN)) {    get_ffmepg_err_str(iRet);    if (iRet == AVERROR_EOF)        iRet = 0;    return iRet;}while (true) {    // 每解出来一帧，丢到队列中;    iRet = avcodec_receive_frame(ctx, frame);    if (iRet != 0) {        if (iRet == AVERROR(EAGAIN)) {            return 0;        } else            return iRet;    }    if (m_pStreamInfo->hw_pix_fmt != AV_PIX_FMT_NONE &&        m_pStreamInfo->device_type != AV_HWDEVICE_TYPE_NONE) {        AVFrame *hw_frame = av_frame_alloc();        iRet = av_hwframe_transfer_data(hw_frame, frame, 0);        if (iRet < 0) {            av_frame_unref(hw_frame);            return iRet;        }        av_frame_copy_props(hw_frame, frame);        // hw_frame中的data，就是硬解完成后的视频帧数据;    }}

2、英特尔硬解，qsv

qsv的解码器创建的方式与cuda不同，解码获取视频帧内容与cuda完全一致，解码的部分看上面，qsv的解码器创建和cuda的区别在于，初始化AVCodecContext->hw_frames_ctx，cuda是在avcodec_open2之前创建，qsv是在get_format的回调里创建，并且qsv需要做一些额外的设置；

另外在查找codec_id的时候，需要加上“_qsv”的后缀，这个所支持的qsv的编码格式，可以通过ffmpeg.exe查看到

C++音视频开发学习资料：点击领取→音视频开发（资料文档+视频教程+面试题）（FFmpeg+WebRTC+RTMP+RTSP+HLS+RTP）

其他部分与cuda的创建基本一致

AVPixelFormat DemuxStream::GetHwFormat(AVCodecContext * ctx, const AVPixelFormat * pix_fmts){    const enum AVPixelFormat *p;    DemuxStream *pThis = (DemuxStream *)ctx->opaque;    for (p = pix_fmts; *p != -1; p++) {        if (*p == pThis->m_AVStreamInfo.hw_pix_fmt && *p == AV_PIX_FMT_QSV) {            if (pThis->HwQsvDecoderInit(ctx) < 0)                return AV_PIX_FMT_NONE;            return *p;        }    }     fprintf(stderr, "Failed to get HW surface format.
");    return AV_PIX_FMT_NONE;} int DemuxStream::HwQsvDecoderInit(AVCodecContext * ctx){    DemuxStream *pThis = (DemuxStream *)ctx->opaque;    AVHWFramesContext  *frames_ctx;    AVQSVFramesContext *frames_hwctx;     /* create a pool of surfaces to be used by the decoder */    ctx->hw_frames_ctx = av_hwframe_ctx_alloc(pThis->m_qsv_device_ref);    if (!ctx->hw_frames_ctx)        return -1;    frames_ctx = (AVHWFramesContext*)ctx->hw_frames_ctx->data;    frames_hwctx = (AVQSVFramesContext *)frames_ctx->hwctx;     frames_ctx->format = AV_PIX_FMT_QSV;    frames_ctx->sw_format = ctx->sw_pix_fmt;    frames_ctx->width = FFALIGN(ctx->coded_width, 32);    frames_ctx->height = FFALIGN(ctx->coded_height, 32);    frames_ctx->initial_pool_size = 16;     frames_hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;     return av_hwframe_ctx_init(ctx->hw_frames_ctx);} AVCodecContext * DemuxStream::GetQsvDecoder(AVStream *stream){    AVCodecContext *decoder_ctx = nullptr;    int ret = av_hwdevice_ctx_create(&m_qsv_device_ref, AV_HWDEVICE_TYPE_QSV,                                     "auto", NULL, 0);    if (ret < 0) {         goto failed;    }    AVCodec *find_decoder = avcodec_find_decoder(stream->codec->codec_id);    if (!find_decoder) {        goto failed;    }    find_decoder = avcodec_find_decoder_by_name((std::string(find_decoder->name) + "_qsv").c_str());    if (!find_decoder) {        goto failed;    }     for (int i = 0;; i++) {        const AVCodecHWConfig *config = avcodec_get_hw_config(find_decoder, i);        if (!config) {            fprintf(stderr, "Decoder %s does not support device type %s.
",                    find_decoder->name, av_hwdevice_get_type_name(AV_HWDEVICE_TYPE_QSV));            goto failed;        }        if (config->device_type == AV_HWDEVICE_TYPE_QSV) {            m_AVStreamInfo.hw_pix_fmt = config->pix_fmt;            m_AVStreamInfo.device_type = AV_HWDEVICE_TYPE_QSV;            break;        }    }    if (m_AVStreamInfo.device_type == AV_HWDEVICE_TYPE_NONE ||        m_AVStreamInfo.hw_pix_fmt == AV_PIX_FMT_NONE)        goto failed;    decoder_ctx = avcodec_alloc_context3(find_decoder);    if (!decoder_ctx)        goto failed;    if (avcodec_parameters_to_context(decoder_ctx, stream->codecpar) < 0)        goto failed;    decoder_ctx->opaque = this;    decoder_ctx->get_format = DemuxStream::GetHwFormat;    ret = avcodec_open2(decoder_ctx, NULL, NULL);    if (ret < 0)        goto failed;    return decoder_ctx;failed:    m_AVStreamInfo.hw_pix_fmt = AV_PIX_FMT_NONE;    m_AVStreamInfo.device_type = AV_HWDEVICE_TYPE_NONE;    av_buffer_unref(&m_qsv_device_ref);    m_qsv_device_ref = nullptr;    avcodec_free_context(&decoder_ctx);    return nullptr;}
  • 支付宝打赏
  • 微信打赏
    • 使用方法   FFmpeg   cuda
    发表评论
    留言与评论（共有 0 条评论） “”
       
    验证码：

    相关文章

    Zio 使用方法
    Zio 使用方法
    FFmpeg 开始集成英特尔 oneVPL 支持
    FFmpeg 开始集成英特尔 oneVPL 支
    Zabbix对Vault部署及加密转存使用方法
    Zabbix对Vault部署及加密转存使用
    直播分享｜一文读懂《MongoDB 可调一致性》的使用方法
    直播分享｜一文读懂《MongoDB 可调一
    Python之进度条模块tqdm使用方法
    Python之进度条模块tqdm使用方法
    FFmpeg Demo分析之encode_video.c
    FFmpeg Demo分析之encode_video.c

    推荐文章

    最热点击文章

    热门标签