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 
get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)47 static 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 
decode_packet(AVCodecContext *decoder_ctx, AVFrame *frame, AVFrame *sw_frame, AVPacket *pkt, AVIOContext *output_ctx)62 static 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 
98 fail:
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 
main(int argc, char **argv)109 int 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 
224 finish:
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