xref: /third_party/ffmpeg/doc/examples/qsvdec.c (revision cabdff1a) 
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
47static int get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
48{
49    while (*pix_fmts != AV_PIX_FMT_NONE) {
50        if (*pix_fmts == AV_PIX_FMT_QSV) {
51            return AV_PIX_FMT_QSV;
52        }
53
54        pix_fmts++;
55    }
56
57    fprintf(stderr, "The QSV pixel format not offered in get_format()\n");
58
59    return AV_PIX_FMT_NONE;
60}
61
62static int decode_packet(AVCodecContext *decoder_ctx,
63                         AVFrame *frame, AVFrame *sw_frame,
64                         AVPacket *pkt, AVIOContext *output_ctx)
65{
66    int ret = 0;
67
68    ret = avcodec_send_packet(decoder_ctx, pkt);
69    if (ret < 0) {
70        fprintf(stderr, "Error during decoding\n");
71        return ret;
72    }
73
74    while (ret >= 0) {
75        int i, j;
76
77        ret = avcodec_receive_frame(decoder_ctx, frame);
78        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
79            break;
80        else if (ret < 0) {
81            fprintf(stderr, "Error during decoding\n");
82            return ret;
83        }
84
85        /* A real program would do something useful with the decoded frame here.
86         * We just retrieve the raw data and write it to a file, which is rather
87         * useless but pedagogic. */
88        ret = av_hwframe_transfer_data(sw_frame, frame, 0);
89        if (ret < 0) {
90            fprintf(stderr, "Error transferring the data to system memory\n");
91            goto fail;
92        }
93
94        for (i = 0; i < FF_ARRAY_ELEMS(sw_frame->data) && sw_frame->data[i]; i++)
95            for (j = 0; j < (sw_frame->height >> (i > 0)); j++)
96                avio_write(output_ctx, sw_frame->data[i] + j * sw_frame->linesize[i], sw_frame->width);
97
98fail:
99        av_frame_unref(sw_frame);
100        av_frame_unref(frame);
101
102        if (ret < 0)
103            return ret;
104    }
105
106    return 0;
107}
108
109int main(int argc, char **argv)
110{
111    AVFormatContext *input_ctx = NULL;
112    AVStream *video_st = NULL;
113    AVCodecContext *decoder_ctx = NULL;
114    const AVCodec *decoder;
115
116    AVPacket *pkt = NULL;
117    AVFrame *frame = NULL, *sw_frame = NULL;
118
119    AVIOContext *output_ctx = NULL;
120
121    int ret, i;
122
123    AVBufferRef *device_ref = NULL;
124
125    if (argc < 3) {
126        fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
127        return 1;
128    }
129
130    /* open the input file */
131    ret = avformat_open_input(&input_ctx, argv[1], NULL, NULL);
132    if (ret < 0) {
133        fprintf(stderr, "Cannot open input file '%s': ", argv[1]);
134        goto finish;
135    }
136
137    /* find the first H.264 video stream */
138    for (i = 0; i < input_ctx->nb_streams; i++) {
139        AVStream *st = input_ctx->streams[i];
140
141        if (st->codecpar->codec_id == AV_CODEC_ID_H264 && !video_st)
142            video_st = st;
143        else
144            st->discard = AVDISCARD_ALL;
145    }
146    if (!video_st) {
147        fprintf(stderr, "No H.264 video stream in the input file\n");
148        goto finish;
149    }
150
151    /* open the hardware device */
152    ret = av_hwdevice_ctx_create(&device_ref, AV_HWDEVICE_TYPE_QSV,
153                                 "auto", NULL, 0);
154    if (ret < 0) {
155        fprintf(stderr, "Cannot open the hardware device\n");
156        goto finish;
157    }
158
159    /* initialize the decoder */
160    decoder = avcodec_find_decoder_by_name("h264_qsv");
161    if (!decoder) {
162        fprintf(stderr, "The QSV decoder is not present in libavcodec\n");
163        goto finish;
164    }
165
166    decoder_ctx = avcodec_alloc_context3(decoder);
167    if (!decoder_ctx) {
168        ret = AVERROR(ENOMEM);
169        goto finish;
170    }
171    decoder_ctx->codec_id = AV_CODEC_ID_H264;
172    if (video_st->codecpar->extradata_size) {
173        decoder_ctx->extradata = av_mallocz(video_st->codecpar->extradata_size +
174                                            AV_INPUT_BUFFER_PADDING_SIZE);
175        if (!decoder_ctx->extradata) {
176            ret = AVERROR(ENOMEM);
177            goto finish;
178        }
179        memcpy(decoder_ctx->extradata, video_st->codecpar->extradata,
180               video_st->codecpar->extradata_size);
181        decoder_ctx->extradata_size = video_st->codecpar->extradata_size;
182    }
183
184
185    decoder_ctx->hw_device_ctx = av_buffer_ref(device_ref);
186    decoder_ctx->get_format  = get_format;
187
188    ret = avcodec_open2(decoder_ctx, NULL, NULL);
189    if (ret < 0) {
190        fprintf(stderr, "Error opening the decoder: ");
191        goto finish;
192    }
193
194    /* open the output stream */
195    ret = avio_open(&output_ctx, argv[2], AVIO_FLAG_WRITE);
196    if (ret < 0) {
197        fprintf(stderr, "Error opening the output context: ");
198        goto finish;
199    }
200
201    frame    = av_frame_alloc();
202    sw_frame = av_frame_alloc();
203    pkt      = av_packet_alloc();
204    if (!frame || !sw_frame || !pkt) {
205        ret = AVERROR(ENOMEM);
206        goto finish;
207    }
208
209    /* actual decoding */
210    while (ret >= 0) {
211        ret = av_read_frame(input_ctx, pkt);
212        if (ret < 0)
213            break;
214
215        if (pkt->stream_index == video_st->index)
216            ret = decode_packet(decoder_ctx, frame, sw_frame, pkt, output_ctx);
217
218        av_packet_unref(pkt);
219    }
220
221    /* flush the decoder */
222    ret = decode_packet(decoder_ctx, frame, sw_frame, NULL, output_ctx);
223
224finish:
225    if (ret < 0) {
226        char buf[1024];
227        av_strerror(ret, buf, sizeof(buf));
228        fprintf(stderr, "%s\n", buf);
229    }
230
231    avformat_close_input(&input_ctx);
232
233    av_frame_free(&frame);
234    av_frame_free(&sw_frame);
235    av_packet_free(&pkt);
236
237    avcodec_free_context(&decoder_ctx);
238
239    av_buffer_unref(&device_ref);
240
241    avio_close(output_ctx);
242
243    return ret;
244}
245