title: ffmpeg_sample解讀_qsvdec
date: 2020-10-28 10:15:02
tags: [讀書(shū)筆記](méi)
typora-copy-images-to: ./imgs
typora-root-url: ./imgs

總結(jié)

讀取視頻流.解碼出視頻幀后進(jìn)行處理.使用了硬件編碼,最后寫(xiě)出文件的過(guò)程

流程圖

graph TB
afoi[avformat_open_input] 
-->ahcc[av_hwdevice_ctx_create]
-->acfdbn[avcodec_find_decoder_by_name]
-->aac[avcodec_alloc_context3]
-->aco[avcodec_open2]
-->ao[avio_open]
-->afa[av_frame_alloc]
-->arf{av_read_frame>0?}
-->|no|release[release]
arf-->|yes|dp[decode_packet]
-->acsp[avcodec_send_packet]
-->acrf[avcodec_receive_frame]
-->aw[avio_write]
-->release

image-20201030152827979

代碼

/**
 * @file
 * Intel QSV-accelerated H.264 decoding example.
 *
 * @example qsvdec.c
 * This example shows how to do QSV-accelerated H.264 decoding with output
 * frames in the GPU video surfaces.
 */

//#include "config.h"

#include <stdio.h>

#include "libavformat/avformat.h"
#include "libavformat/avio.h"

#include "libavcodec/avcodec.h"

#include "libavutil/buffer.h"
#include "libavutil/error.h"
#include "libavutil/hwcontext.h"
//#include "libavutil/hwcontext_qsv.h"
#include "libavutil/mem.h"

typedef struct DecodeContext {
    AVBufferRef *hw_device_ref;
} DecodeContext;

static int get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts) {
    while (*pix_fmts != AV_PIX_FMT_NONE) {
        if (*pix_fmts == AV_PIX_FMT_QSV) {
            DecodeContext *decode = avctx->opaque;
            AVHWFramesContext *frames_ctx;
//            AVQSVFramesContext *frames_hwctx;
            int ret;

            /* create a pool of surfaces to be used by the decoder */
            avctx->hw_frames_ctx = av_hwframe_ctx_alloc(decode->hw_device_ref);
            if (!avctx->hw_frames_ctx)
                return AV_PIX_FMT_NONE;
            frames_ctx = (AVHWFramesContext *) avctx->hw_frames_ctx->data;
//            frames_hwctx = frames_ctx->hwctx;

            frames_ctx->format = AV_PIX_FMT_QSV;
            frames_ctx->sw_format = avctx->sw_pix_fmt;
            frames_ctx->width = FFALIGN(avctx->coded_width, 32);
            frames_ctx->height = FFALIGN(avctx->coded_height, 32);
            frames_ctx->initial_pool_size = 32;

//            frames_hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;

            ret = av_hwframe_ctx_init(avctx->hw_frames_ctx);
            if (ret < 0)
                return AV_PIX_FMT_NONE;

            return AV_PIX_FMT_QSV;
        }

        pix_fmts++;
    }

    fprintf(stderr, "The QSV pixel format not offered in get_format()\n");

    return AV_PIX_FMT_NONE;
}

/**
 * 解碼數(shù)據(jù)報(bào)
 * @param decode
 * @param decoder_ctx
 * @param frame
 * @param sw_frame
 * @param pkt
 * @param output_ctx
 * @return
 */
static int decode_packet(DecodeContext *decode, AVCodecContext *decoder_ctx,
                         AVFrame *frame, AVFrame *sw_frame,
                         AVPacket *pkt, AVIOContext *output_ctx) {
    int ret = 0;
//數(shù)據(jù)送入解碼器,獲取解碼后的幀
    ret = avcodec_send_packet(decoder_ctx, pkt);
    if (ret < 0) {
        fprintf(stderr, "Error during decoding\n");
        return ret;
    }

    while (ret >= 0) {
        int i, j;
//取出解碼幀
        ret = avcodec_receive_frame(decoder_ctx, frame);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
            break;
        else if (ret < 0) {
            fprintf(stderr, "Error during decoding\n");
            return ret;
        }

        /* A real program would do something useful with the decoded frame here.
         * We just retrieve the raw data and write it to a file, which is rather
         * useless but pedagogic. */
        //解碼后的幀經(jīng)過(guò)硬件轉(zhuǎn)換
        ret = av_hwframe_transfer_data(sw_frame, frame, 0);
        if (ret < 0) {
            fprintf(stderr, "Error transferring the data to system memory\n");
            goto fail;
        }

        for (i = 0; i < FF_ARRAY_ELEMS(sw_frame->data) && sw_frame->data[i]; i++)
            for (j = 0; j < (sw_frame->height >> (i > 0)); j++)
                //把數(shù)據(jù)寫(xiě)出到ouput上下文
                avio_write(output_ctx, sw_frame->data[i] + j * sw_frame->linesize[i],
                           sw_frame->width);

        fail:
        av_frame_unref(sw_frame);
        av_frame_unref(frame);

        if (ret < 0)
            return ret;
    }

    return 0;
}

/**
 *讀取視頻流.解碼出視頻幀后進(jìn)行處理.使用了硬件編碼
 * @param argc
 * @param argv
 * @return
 */
int qsvdec_main(int argc, char **argv) {
    AVFormatContext *input_ctx = NULL;
    AVStream *video_st = NULL;
    AVCodecContext *decoder_ctx = NULL;
    const AVCodec *decoder;

    AVPacket pkt = {0};
    AVFrame *frame = NULL, *sw_frame = NULL;

    DecodeContext decode = {NULL};

    AVIOContext *output_ctx = NULL;

    int ret, i;

    if (argc < 3) {
        fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
        return 1;
    }

    /* open the input file */
    //打開(kāi)文件 .創(chuàng)建格式上下文
    ret = avformat_open_input(&input_ctx, argv[1], NULL, NULL);
    if (ret < 0) {
        fprintf(stderr, "Cannot open input file '%s': ", argv[1]);
        goto finish;
    }

    /* find the first H.264 video stream */
    for (i = 0; i < input_ctx->nb_streams; i++) {
        AVStream *st = input_ctx->streams[i];
//找到 h264的視頻流.這里使用的是用編解碼器參數(shù)里的id來(lái)匹配,也可以使用類型codec_type,但是只能區(qū)分音頻視頻流,codec_id則可以區(qū)
//分具體哪種格式的流
        if (st->codecpar->codec_id == AV_CODEC_ID_H264 && !video_st)
            video_st = st;
        else
            st->discard = AVDISCARD_ALL;
    }
    if (!video_st) {
        fprintf(stderr, "No H.264 video stream in the input file\n");
        goto finish;
    }

    /* open the hardware device */
    //打開(kāi)硬件解碼器,使用默認(rèn)的AV_HWDEVICE_TYPE_QSV格式,輸出到decode的參數(shù)里
    ret = av_hwdevice_ctx_create(&decode.hw_device_ref, AV_HWDEVICE_TYPE_QSV,
                                 "auto", NULL, 0);
    if (ret < 0) {
        fprintf(stderr, "Cannot open the hardware device\n");
        goto finish;
    }

    /* initialize the decoder */
    //初始化解碼器,
    decoder = avcodec_find_decoder_by_name("h264_qsv");
    if (!decoder) {
        fprintf(stderr, "The QSV decoder is not present in libavcodec\n");
        goto finish;
    }
//初始化解碼器上下文
    decoder_ctx = avcodec_alloc_context3(decoder);
    if (!decoder_ctx) {
        ret = AVERROR(ENOMEM);
        goto finish;
    }
    decoder_ctx->codec_id = AV_CODEC_ID_H264;
    if (video_st->codecpar->extradata_size) {
        //分配空間給 extradata 額外的數(shù)據(jù).同時(shí)添加了64位的數(shù)據(jù)對(duì)齊
        decoder_ctx->extradata = av_mallocz(video_st->codecpar->extradata_size +
                                            AV_INPUT_BUFFER_PADDING_SIZE);
        if (!decoder_ctx->extradata) {
            ret = AVERROR(ENOMEM);
            goto finish;
        }
        //拷貝視頻住的額外數(shù)據(jù)到解碼器上下文中,同時(shí)設(shè)置大小
        memcpy(decoder_ctx->extradata, video_st->codecpar->extradata,
               video_st->codecpar->extradata_size);
        decoder_ctx->extradata_size = video_st->codecpar->extradata_size;
    }

    decoder_ctx->opaque = &decode;
    decoder_ctx->get_format = get_format;
//初始化解碼器上下文
    ret = avcodec_open2(decoder_ctx, NULL, NULL);
    if (ret < 0) {
        fprintf(stderr, "Error opening the decoder: ");
        goto finish;
    }

    /* open the output stream */
    //用給定的url 打開(kāi)io上下文,用于寫(xiě)出數(shù)據(jù)
    ret = avio_open(&output_ctx, argv[2], AVIO_FLAG_WRITE);
    if (ret < 0) {
        fprintf(stderr, "Error opening the output context: ");
        goto finish;
    }

    frame = av_frame_alloc();
    sw_frame = av_frame_alloc();
    if (!frame || !sw_frame) {
        ret = AVERROR(ENOMEM);
        goto finish;
    }

    /* actual decoding */
    while (ret >= 0) {
        //讀取一個(gè)packet
        ret = av_read_frame(input_ctx, &pkt);
        if (ret < 0)
            break;

        if (pkt.stream_index == video_st->index)
            //解碼packet
            ret = decode_packet(&decode, decoder_ctx, frame, sw_frame, &pkt, output_ctx);
//釋放packet
        av_packet_unref(&pkt);
    }
//刷新解碼器中的數(shù)據(jù)
    /* flush the decoder */
    pkt.data = NULL;
    pkt.size = 0;
    ret = decode_packet(&decode, decoder_ctx, frame, sw_frame, &pkt, output_ctx);
//最后的資源回收操作
    finish:
    if (ret < 0) {
        char buf[1024];
        av_strerror(ret, buf, sizeof(buf));
        fprintf(stderr, "%s\n", buf);
    }

    avformat_close_input(&input_ctx);

    av_frame_free(&frame);
    av_frame_free(&sw_frame);

    avcodec_free_context(&decoder_ctx);

    av_buffer_unref(&decode.hw_device_ref);

    avio_close(output_ctx);

    return ret;
}