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
get_format(AVCodecContext * avctx,const enum AVPixelFormat * pix_fmts)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
decode_packet(DecodeContext * decode,AVCodecContext * decoder_ctx,AVFrame * frame,AVFrame * sw_frame,AVPacket * pkt,AVIOContext * output_ctx)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
main(int argc,char ** argv)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 if (argc < 3) {
154 fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
155 return 1;
156 }
157
158 /* open the input file */
159 ret = avformat_open_input(&input_ctx, argv[1], NULL, NULL);
160 if (ret < 0) {
161 fprintf(stderr, "Cannot open input file '%s': ", argv[1]);
162 goto finish;
163 }
164
165 /* find the first H.264 video stream */
166 for (i = 0; i < input_ctx->nb_streams; i++) {
167 AVStream *st = input_ctx->streams[i];
168
169 if (st->codecpar->codec_id == AV_CODEC_ID_H264 && !video_st)
170 video_st = st;
171 else
172 st->discard = AVDISCARD_ALL;
173 }
174 if (!video_st) {
175 fprintf(stderr, "No H.264 video stream in the input file\n");
176 goto finish;
177 }
178
179 /* open the hardware device */
180 ret = av_hwdevice_ctx_create(&decode.hw_device_ref, AV_HWDEVICE_TYPE_QSV,
181 "auto", NULL, 0);
182 if (ret < 0) {
183 fprintf(stderr, "Cannot open the hardware device\n");
184 goto finish;
185 }
186
187 /* initialize the decoder */
188 decoder = avcodec_find_decoder_by_name("h264_qsv");
189 if (!decoder) {
190 fprintf(stderr, "The QSV decoder is not present in libavcodec\n");
191 goto finish;
192 }
193
194 decoder_ctx = avcodec_alloc_context3(decoder);
195 if (!decoder_ctx) {
196 ret = AVERROR(ENOMEM);
197 goto finish;
198 }
199 decoder_ctx->codec_id = AV_CODEC_ID_H264;
200 if (video_st->codecpar->extradata_size) {
201 decoder_ctx->extradata = av_mallocz(video_st->codecpar->extradata_size +
202 AV_INPUT_BUFFER_PADDING_SIZE);
203 if (!decoder_ctx->extradata) {
204 ret = AVERROR(ENOMEM);
205 goto finish;
206 }
207 memcpy(decoder_ctx->extradata, video_st->codecpar->extradata,
208 video_st->codecpar->extradata_size);
209 decoder_ctx->extradata_size = video_st->codecpar->extradata_size;
210 }
211
212 decoder_ctx->opaque = &decode;
213 decoder_ctx->get_format = get_format;
214
215 ret = avcodec_open2(decoder_ctx, NULL, NULL);
216 if (ret < 0) {
217 fprintf(stderr, "Error opening the decoder: ");
218 goto finish;
219 }
220
221 /* open the output stream */
222 ret = avio_open(&output_ctx, argv[2], AVIO_FLAG_WRITE);
223 if (ret < 0) {
224 fprintf(stderr, "Error opening the output context: ");
225 goto finish;
226 }
227
228 frame = av_frame_alloc();
229 sw_frame = av_frame_alloc();
230 if (!frame || !sw_frame) {
231 ret = AVERROR(ENOMEM);
232 goto finish;
233 }
234
235 /* actual decoding */
236 while (ret >= 0) {
237 ret = av_read_frame(input_ctx, &pkt);
238 if (ret < 0)
239 break;
240
241 if (pkt.stream_index == video_st->index)
242 ret = decode_packet(&decode, decoder_ctx, frame, sw_frame, &pkt, output_ctx);
243
244 av_packet_unref(&pkt);
245 }
246
247 /* flush the decoder */
248 pkt.data = NULL;
249 pkt.size = 0;
250 ret = decode_packet(&decode, decoder_ctx, frame, sw_frame, &pkt, output_ctx);
251
252 finish:
253 if (ret < 0) {
254 char buf[1024];
255 av_strerror(ret, buf, sizeof(buf));
256 fprintf(stderr, "%s\n", buf);
257 }
258
259 avformat_close_input(&input_ctx);
260
261 av_frame_free(&frame);
262 av_frame_free(&sw_frame);
263
264 avcodec_free_context(&decoder_ctx);
265
266 av_buffer_unref(&decode.hw_device_ref);
267
268 avio_close(output_ctx);
269
270 return ret;
271 }
272