git.sesse.net Git - ffmpeg/blob - doc/examples/qsvdec.c

   1 /*
   2  * Copyright (c) 2015 Anton Khirnov
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a copy
   5  * of this software and associated documentation files (the "Software"), to deal
   6  * in the Software without restriction, including without limitation the rights
   7  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   8  * copies of the Software, and to permit persons to whom the Software is
   9  * furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  17  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  18  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  19  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  20  * THE SOFTWARE.
  21  */
  22
  23 /**
  24  * @file
  25  * Intel QSV-accelerated H.264 decoding example.
  26  *
  27  * @example qsvdec.c
  28  * This example shows how to do QSV-accelerated H.264 decoding with output
  29  * frames in the GPU video surfaces.
  30  */
  31
  32 #include "config.h"
  33
  34 #include <stdio.h>
  35
  36 #include "libavformat/avformat.h"
  37 #include "libavformat/avio.h"
  38
  39 #include "libavcodec/avcodec.h"
  40
  41 #include "libavutil/buffer.h"
  42 #include "libavutil/error.h"
  43 #include "libavutil/hwcontext.h"
  44 #include "libavutil/hwcontext_qsv.h"
  45 #include "libavutil/mem.h"
  46
  47 typedef struct DecodeContext {
  48     AVBufferRef *hw_device_ref;
  49 } DecodeContext;
  50
  51 static int get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
  52 {
  53     while (*pix_fmts != AV_PIX_FMT_NONE) {
  54         if (*pix_fmts == AV_PIX_FMT_QSV) {
  55             DecodeContext *decode = avctx->opaque;
  56             AVHWFramesContext  *frames_ctx;
  57             AVQSVFramesContext *frames_hwctx;
  58             int ret;
  59
  60             /* create a pool of surfaces to be used by the decoder */
  61             avctx->hw_frames_ctx = av_hwframe_ctx_alloc(decode->hw_device_ref);
  62             if (!avctx->hw_frames_ctx)
  63                 return AV_PIX_FMT_NONE;
  64             frames_ctx   = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
  65             frames_hwctx = frames_ctx->hwctx;
  66
  67             frames_ctx->format            = AV_PIX_FMT_QSV;
  68             frames_ctx->sw_format         = avctx->sw_pix_fmt;
  69             frames_ctx->width             = FFALIGN(avctx->coded_width,  32);
  70             frames_ctx->height            = FFALIGN(avctx->coded_height, 32);
  71             frames_ctx->initial_pool_size = 32;
  72
  73             frames_hwctx->frame_type = MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET;
  74
  75             ret = av_hwframe_ctx_init(avctx->hw_frames_ctx);
  76             if (ret < 0)
  77                 return AV_PIX_FMT_NONE;
  78
  79             return AV_PIX_FMT_QSV;
  80         }
  81
  82         pix_fmts++;
  83     }
  84
  85     fprintf(stderr, "The QSV pixel format not offered in get_format()\n");
  86
  87     return AV_PIX_FMT_NONE;
  88 }
  89
  90 static int decode_packet(DecodeContext *decode, AVCodecContext *decoder_ctx,
  91                          AVFrame *frame, AVFrame *sw_frame,
  92                          AVPacket *pkt, AVIOContext *output_ctx)
  93 {
  94     int ret = 0;
  95
  96     ret = avcodec_send_packet(decoder_ctx, pkt);
  97     if (ret < 0) {
  98         fprintf(stderr, "Error during decoding\n");
  99         return ret;
 100     }
 101
 102     while (ret >= 0) {
 103         int i, j;
 104
 105         ret = avcodec_receive_frame(decoder_ctx, frame);
 106         if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
 107             break;
 108         else if (ret < 0) {
 109             fprintf(stderr, "Error during decoding\n");
 110             return ret;
 111         }
 112
 113         /* A real program would do something useful with the decoded frame here.
 114          * We just retrieve the raw data and write it to a file, which is rather
 115          * useless but pedagogic. */
 116         ret = av_hwframe_transfer_data(sw_frame, frame, 0);
 117         if (ret < 0) {
 118             fprintf(stderr, "Error transferring the data to system memory\n");
 119             goto fail;
 120         }
 121
 122         for (i = 0; i < FF_ARRAY_ELEMS(sw_frame->data) && sw_frame->data[i]; i++)
 123             for (j = 0; j < (sw_frame->height >> (i > 0)); j++)
 124                 avio_write(output_ctx, sw_frame->data[i] + j * sw_frame->linesize[i], sw_frame->width);
 125
 126 fail:
 127         av_frame_unref(sw_frame);
 128         av_frame_unref(frame);
 129
 130         if (ret < 0)
 131             return ret;
 132     }
 133
 134     return 0;
 135 }
 136
 137 int main(int argc, char **argv)
 138 {
 139     AVFormatContext *input_ctx = NULL;
 140     AVStream *video_st = NULL;
 141     AVCodecContext *decoder_ctx = NULL;
 142     const AVCodec *decoder;
 143
 144     AVPacket pkt = { 0 };
 145     AVFrame *frame = NULL, *sw_frame = NULL;
 146
 147     DecodeContext decode = { NULL };
 148
 149     AVIOContext *output_ctx = NULL;
 150
 151     int ret, i;
 152
 153     av_register_all();
 154
 155     if (argc < 3) {
 156         fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
 157         return 1;
 158     }
 159
 160     /* open the input file */
 161     ret = avformat_open_input(&input_ctx, argv[1], NULL, NULL);
 162     if (ret < 0) {
 163         fprintf(stderr, "Cannot open input file '%s': ", argv[1]);
 164         goto finish;
 165     }
 166
 167     /* find the first H.264 video stream */
 168     for (i = 0; i < input_ctx->nb_streams; i++) {
 169         AVStream *st = input_ctx->streams[i];
 170
 171         if (st->codecpar->codec_id == AV_CODEC_ID_H264 && !video_st)
 172             video_st = st;
 173         else
 174             st->discard = AVDISCARD_ALL;
 175     }
 176     if (!video_st) {
 177         fprintf(stderr, "No H.264 video stream in the input file\n");
 178         goto finish;
 179     }
 180
 181     /* open the hardware device */
 182     ret = av_hwdevice_ctx_create(&decode.hw_device_ref, AV_HWDEVICE_TYPE_QSV,
 183                                  "auto", NULL, 0);
 184     if (ret < 0) {
 185         fprintf(stderr, "Cannot open the hardware device\n");
 186         goto finish;
 187     }
 188
 189     /* initialize the decoder */
 190     decoder = avcodec_find_decoder_by_name("h264_qsv");
 191     if (!decoder) {
 192         fprintf(stderr, "The QSV decoder is not present in libavcodec\n");
 193         goto finish;
 194     }
 195
 196     decoder_ctx = avcodec_alloc_context3(decoder);
 197     if (!decoder_ctx) {
 198         ret = AVERROR(ENOMEM);
 199         goto finish;
 200     }
 201     decoder_ctx->codec_id = AV_CODEC_ID_H264;
 202     if (video_st->codecpar->extradata_size) {
 203         decoder_ctx->extradata = av_mallocz(video_st->codecpar->extradata_size +
 204                                             AV_INPUT_BUFFER_PADDING_SIZE);
 205         if (!decoder_ctx->extradata) {
 206             ret = AVERROR(ENOMEM);
 207             goto finish;
 208         }
 209         memcpy(decoder_ctx->extradata, video_st->codecpar->extradata,
 210                video_st->codecpar->extradata_size);
 211         decoder_ctx->extradata_size = video_st->codecpar->extradata_size;
 212     }
 213     decoder_ctx->refcounted_frames = 1;
 214
 215     decoder_ctx->opaque      = &decode;
 216     decoder_ctx->get_format  = get_format;
 217
 218     ret = avcodec_open2(decoder_ctx, NULL, NULL);
 219     if (ret < 0) {
 220         fprintf(stderr, "Error opening the decoder: ");
 221         goto finish;
 222     }
 223
 224     /* open the output stream */
 225     ret = avio_open(&output_ctx, argv[2], AVIO_FLAG_WRITE);
 226     if (ret < 0) {
 227         fprintf(stderr, "Error opening the output context: ");
 228         goto finish;
 229     }
 230
 231     frame    = av_frame_alloc();
 232     sw_frame = av_frame_alloc();
 233     if (!frame || !sw_frame) {
 234         ret = AVERROR(ENOMEM);
 235         goto finish;
 236     }
 237
 238     /* actual decoding */
 239     while (ret >= 0) {
 240         ret = av_read_frame(input_ctx, &pkt);
 241         if (ret < 0)
 242             break;
 243
 244         if (pkt.stream_index == video_st->index)
 245             ret = decode_packet(&decode, decoder_ctx, frame, sw_frame, &pkt, output_ctx);
 246
 247         av_packet_unref(&pkt);
 248     }
 249
 250     /* flush the decoder */
 251     pkt.data = NULL;
 252     pkt.size = 0;
 253     ret = decode_packet(&decode, decoder_ctx, frame, sw_frame, &pkt, output_ctx);
 254
 255 finish:
 256     if (ret < 0) {
 257         char buf[1024];
 258         av_strerror(ret, buf, sizeof(buf));
 259         fprintf(stderr, "%s\n", buf);
 260     }
 261
 262     avformat_close_input(&input_ctx);
 263
 264     av_frame_free(&frame);
 265     av_frame_free(&sw_frame);
 266
 267     avcodec_free_context(&decoder_ctx);
 268
 269     av_buffer_unref(&decode.hw_device_ref);
 270
 271     avio_close(output_ctx);
 272
 273     return ret;
 274 }