2f26f41ebdaba8f4dbbffcaa4e9781fa118e8f64
[libav.git] / 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 VA-API video surfaces.
30 */
31
32 #include "config.h"
33
34 #include <stdio.h>
35
36 #include <mfx/mfxvideo.h>
37
38 #include <va/va.h>
39 #include <va/va_x11.h>
40 #include <X11/Xlib.h>
41
42 #include "libavformat/avformat.h"
43 #include "libavformat/avio.h"
44
45 #include "libavcodec/avcodec.h"
46 #include "libavcodec/qsv.h"
47
48 #include "libavutil/error.h"
49 #include "libavutil/mem.h"
50
51 typedef struct DecodeContext {
52 mfxSession mfx_session;
53 VADisplay va_dpy;
54
55 VASurfaceID *surfaces;
56 mfxMemId *surface_ids;
57 int *surface_used;
58 int nb_surfaces;
59
60 mfxFrameInfo frame_info;
61 } DecodeContext;
62
63 static mfxStatus frame_alloc(mfxHDL pthis, mfxFrameAllocRequest *req,
64 mfxFrameAllocResponse *resp)
65 {
66 DecodeContext *decode = pthis;
67 int err, i;
68
69 if (decode->surfaces) {
70 fprintf(stderr, "Multiple allocation requests.\n");
71 return MFX_ERR_MEMORY_ALLOC;
72 }
73 if (!(req->Type & MFX_MEMTYPE_VIDEO_MEMORY_DECODER_TARGET)) {
74 fprintf(stderr, "Unsupported surface type: %d\n", req->Type);
75 return MFX_ERR_UNSUPPORTED;
76 }
77 if (req->Info.BitDepthLuma != 8 || req->Info.BitDepthChroma != 8 ||
78 req->Info.Shift || req->Info.FourCC != MFX_FOURCC_NV12 ||
79 req->Info.ChromaFormat != MFX_CHROMAFORMAT_YUV420) {
80 fprintf(stderr, "Unsupported surface properties.\n");
81 return MFX_ERR_UNSUPPORTED;
82 }
83
84 decode->surfaces = av_malloc_array (req->NumFrameSuggested, sizeof(*decode->surfaces));
85 decode->surface_ids = av_malloc_array (req->NumFrameSuggested, sizeof(*decode->surface_ids));
86 decode->surface_used = av_mallocz_array(req->NumFrameSuggested, sizeof(*decode->surface_used));
87 if (!decode->surfaces || !decode->surface_ids || !decode->surface_used)
88 goto fail;
89
90 err = vaCreateSurfaces(decode->va_dpy, VA_RT_FORMAT_YUV420,
91 req->Info.Width, req->Info.Height,
92 decode->surfaces, req->NumFrameSuggested,
93 NULL, 0);
94 if (err != VA_STATUS_SUCCESS) {
95 fprintf(stderr, "Error allocating VA surfaces\n");
96 goto fail;
97 }
98 decode->nb_surfaces = req->NumFrameSuggested;
99
100 for (i = 0; i < decode->nb_surfaces; i++)
101 decode->surface_ids[i] = &decode->surfaces[i];
102
103 resp->mids = decode->surface_ids;
104 resp->NumFrameActual = decode->nb_surfaces;
105
106 decode->frame_info = req->Info;
107
108 return MFX_ERR_NONE;
109 fail:
110 av_freep(&decode->surfaces);
111 av_freep(&decode->surface_ids);
112 av_freep(&decode->surface_used);
113
114 return MFX_ERR_MEMORY_ALLOC;
115 }
116
117 static mfxStatus frame_free(mfxHDL pthis, mfxFrameAllocResponse *resp)
118 {
119 return MFX_ERR_NONE;
120 }
121
122 static mfxStatus frame_lock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
123 {
124 return MFX_ERR_UNSUPPORTED;
125 }
126
127 static mfxStatus frame_unlock(mfxHDL pthis, mfxMemId mid, mfxFrameData *ptr)
128 {
129 return MFX_ERR_UNSUPPORTED;
130 }
131
132 static mfxStatus frame_get_hdl(mfxHDL pthis, mfxMemId mid, mfxHDL *hdl)
133 {
134 *hdl = mid;
135 return MFX_ERR_NONE;
136 }
137
138 static void free_surfaces(DecodeContext *decode)
139 {
140 if (decode->surfaces)
141 vaDestroySurfaces(decode->va_dpy, decode->surfaces, decode->nb_surfaces);
142 av_freep(&decode->surfaces);
143 av_freep(&decode->surface_ids);
144 av_freep(&decode->surface_used);
145 decode->nb_surfaces = 0;
146 }
147
148 static void free_buffer(void *opaque, uint8_t *data)
149 {
150 int *used = opaque;
151 *used = 0;
152 av_freep(&data);
153 }
154
155 static int get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
156 {
157 DecodeContext *decode = avctx->opaque;
158
159 mfxFrameSurface1 *surf;
160 AVBufferRef *surf_buf;
161 int idx;
162
163 for (idx = 0; idx < decode->nb_surfaces; idx++) {
164 if (!decode->surface_used[idx])
165 break;
166 }
167 if (idx == decode->nb_surfaces) {
168 fprintf(stderr, "No free surfaces\n");
169 return AVERROR(ENOMEM);
170 }
171
172 surf = av_mallocz(sizeof(*surf));
173 if (!surf)
174 return AVERROR(ENOMEM);
175 surf_buf = av_buffer_create((uint8_t*)surf, sizeof(*surf), free_buffer,
176 &decode->surface_used[idx], AV_BUFFER_FLAG_READONLY);
177 if (!surf_buf) {
178 av_freep(&surf);
179 return AVERROR(ENOMEM);
180 }
181
182 surf->Info = decode->frame_info;
183 surf->Data.MemId = &decode->surfaces[idx];
184
185 frame->buf[0] = surf_buf;
186 frame->data[3] = (uint8_t*)surf;
187
188 decode->surface_used[idx] = 1;
189
190 return 0;
191 }
192
193 static int get_format(AVCodecContext *avctx, const enum AVPixelFormat *pix_fmts)
194 {
195 while (*pix_fmts != AV_PIX_FMT_NONE) {
196 if (*pix_fmts == AV_PIX_FMT_QSV) {
197 if (!avctx->hwaccel_context) {
198 DecodeContext *decode = avctx->opaque;
199 AVQSVContext *qsv = av_qsv_alloc_context();
200 if (!qsv)
201 return AV_PIX_FMT_NONE;
202
203 qsv->session = decode->mfx_session;
204 qsv->iopattern = MFX_IOPATTERN_OUT_VIDEO_MEMORY;
205
206 avctx->hwaccel_context = qsv;
207 }
208
209 return AV_PIX_FMT_QSV;
210 }
211
212 pix_fmts++;
213 }
214
215 fprintf(stderr, "The QSV pixel format not offered in get_format()\n");
216
217 return AV_PIX_FMT_NONE;
218 }
219
220 static int decode_packet(DecodeContext *decode, AVCodecContext *decoder_ctx,
221 AVFrame *frame, AVPacket *pkt,
222 AVIOContext *output_ctx)
223 {
224 int ret = 0;
225 int got_frame = 1;
226
227 while (pkt->size > 0 || (!pkt->data && got_frame)) {
228 ret = avcodec_decode_video2(decoder_ctx, frame, &got_frame, pkt);
229 if (ret < 0) {
230 fprintf(stderr, "Error during decoding\n");
231 return ret;
232 }
233
234 pkt->data += ret;
235 pkt->size -= ret;
236
237 /* A real program would do something useful with the decoded frame here.
238 * We just retrieve the raw data and write it to a file, which is rather
239 * useless but pedagogic. */
240 if (got_frame) {
241 mfxFrameSurface1 *surf = (mfxFrameSurface1*)frame->data[3];
242 VASurfaceID surface = *(VASurfaceID*)surf->Data.MemId;
243
244 VAImageFormat img_fmt = {
245 .fourcc = VA_FOURCC_NV12,
246 .byte_order = VA_LSB_FIRST,
247 .bits_per_pixel = 8,
248 .depth = 8,
249 };
250
251 VAImage img;
252
253 VAStatus err;
254 uint8_t *data;
255 int i, j;
256
257 img.buf = VA_INVALID_ID;
258 img.image_id = VA_INVALID_ID;
259
260 err = vaCreateImage(decode->va_dpy, &img_fmt,
261 frame->width, frame->height, &img);
262 if (err != VA_STATUS_SUCCESS) {
263 fprintf(stderr, "Error creating an image: %s\n",
264 vaErrorStr(err));
265 ret = AVERROR_UNKNOWN;
266 goto fail;
267 }
268
269 err = vaGetImage(decode->va_dpy, surface, 0, 0,
270 frame->width, frame->height,
271 img.image_id);
272 if (err != VA_STATUS_SUCCESS) {
273 fprintf(stderr, "Error getting an image: %s\n",
274 vaErrorStr(err));
275 ret = AVERROR_UNKNOWN;
276 goto fail;
277 }
278
279 err = vaMapBuffer(decode->va_dpy, img.buf, (void**)&data);
280 if (err != VA_STATUS_SUCCESS) {
281 fprintf(stderr, "Error mapping the image buffer: %s\n",
282 vaErrorStr(err));
283 ret = AVERROR_UNKNOWN;
284 goto fail;
285 }
286
287 for (i = 0; i < img.num_planes; i++)
288 for (j = 0; j < (img.height >> (i > 0)); j++)
289 avio_write(output_ctx, data + img.offsets[i] + j * img.pitches[i], img.width);
290
291 fail:
292 if (img.buf != VA_INVALID_ID)
293 vaUnmapBuffer(decode->va_dpy, img.buf);
294 if (img.image_id != VA_INVALID_ID)
295 vaDestroyImage(decode->va_dpy, img.image_id);
296 av_frame_unref(frame);
297
298 if (ret < 0)
299 return ret;
300 }
301 }
302
303 return 0;
304 }
305
306 int main(int argc, char **argv)
307 {
308 AVFormatContext *input_ctx = NULL;
309 AVStream *video_st = NULL;
310 AVCodecContext *decoder_ctx = NULL;
311 const AVCodec *decoder;
312
313 AVPacket pkt = { 0 };
314 AVFrame *frame = NULL;
315
316 DecodeContext decode = { NULL };
317
318 Display *dpy = NULL;
319 int va_ver_major, va_ver_minor;
320
321 mfxIMPL mfx_impl = MFX_IMPL_AUTO_ANY;
322 mfxVersion mfx_ver = { { 1, 1 } };
323
324 mfxFrameAllocator frame_allocator = {
325 .pthis = &decode,
326 .Alloc = frame_alloc,
327 .Lock = frame_lock,
328 .Unlock = frame_unlock,
329 .GetHDL = frame_get_hdl,
330 .Free = frame_free,
331 };
332
333 AVIOContext *output_ctx = NULL;
334
335 int ret, i, err;
336
337 av_register_all();
338
339 if (argc < 3) {
340 fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
341 return 1;
342 }
343
344 /* open the input file */
345 ret = avformat_open_input(&input_ctx, argv[1], NULL, NULL);
346 if (ret < 0) {
347 fprintf(stderr, "Cannot open input file '%s': ", argv[1]);
348 goto finish;
349 }
350
351 /* find the first H.264 video stream */
352 for (i = 0; i < input_ctx->nb_streams; i++) {
353 AVStream *st = input_ctx->streams[i];
354
355 if (st->codec->codec_id == AV_CODEC_ID_H264 && !video_st)
356 video_st = st;
357 else
358 st->discard = AVDISCARD_ALL;
359 }
360 if (!video_st) {
361 fprintf(stderr, "No H.264 video stream in the input file\n");
362 goto finish;
363 }
364
365 /* initialize VA-API */
366 dpy = XOpenDisplay(NULL);
367 if (!dpy) {
368 fprintf(stderr, "Cannot open the X display\n");
369 goto finish;
370 }
371 decode.va_dpy = vaGetDisplay(dpy);
372 if (!decode.va_dpy) {
373 fprintf(stderr, "Cannot open the VA display\n");
374 goto finish;
375 }
376
377 err = vaInitialize(decode.va_dpy, &va_ver_major, &va_ver_minor);
378 if (err != VA_STATUS_SUCCESS) {
379 fprintf(stderr, "Cannot initialize VA: %s\n", vaErrorStr(err));
380 goto finish;
381 }
382 fprintf(stderr, "Initialized VA v%d.%d\n", va_ver_major, va_ver_minor);
383
384 /* initialize an MFX session */
385 err = MFXInit(mfx_impl, &mfx_ver, &decode.mfx_session);
386 if (err != MFX_ERR_NONE) {
387 fprintf(stderr, "Error initializing an MFX session\n");
388 goto finish;
389 }
390
391 MFXVideoCORE_SetHandle(decode.mfx_session, MFX_HANDLE_VA_DISPLAY, decode.va_dpy);
392 MFXVideoCORE_SetFrameAllocator(decode.mfx_session, &frame_allocator);
393
394 /* initialize the decoder */
395 decoder = avcodec_find_decoder_by_name("h264_qsv");
396 if (!decoder) {
397 fprintf(stderr, "The QSV decoder is not present in libavcodec\n");
398 goto finish;
399 }
400
401 decoder_ctx = avcodec_alloc_context3(decoder);
402 if (!decoder_ctx) {
403 ret = AVERROR(ENOMEM);
404 goto finish;
405 }
406 decoder_ctx->codec_id = AV_CODEC_ID_H264;
407 if (video_st->codec->extradata_size) {
408 decoder_ctx->extradata = av_mallocz(video_st->codec->extradata_size +
409 AV_INPUT_BUFFER_PADDING_SIZE);
410 if (!decoder_ctx->extradata) {
411 ret = AVERROR(ENOMEM);
412 goto finish;
413 }
414 memcpy(decoder_ctx->extradata, video_st->codec->extradata,
415 video_st->codec->extradata_size);
416 decoder_ctx->extradata_size = video_st->codec->extradata_size;
417 }
418 decoder_ctx->refcounted_frames = 1;
419
420 decoder_ctx->opaque = &decode;
421 decoder_ctx->get_buffer2 = get_buffer;
422 decoder_ctx->get_format = get_format;
423
424 ret = avcodec_open2(decoder_ctx, NULL, NULL);
425 if (ret < 0) {
426 fprintf(stderr, "Error opening the decoder: ");
427 goto finish;
428 }
429
430 /* open the output stream */
431 ret = avio_open(&output_ctx, argv[2], AVIO_FLAG_WRITE);
432 if (ret < 0) {
433 fprintf(stderr, "Error opening the output context: ");
434 goto finish;
435 }
436
437 frame = av_frame_alloc();
438 if (!frame) {
439 ret = AVERROR(ENOMEM);
440 goto finish;
441 }
442
443 /* actual decoding */
444 while (ret >= 0) {
445 ret = av_read_frame(input_ctx, &pkt);
446 if (ret < 0)
447 break;
448
449 if (pkt.stream_index == video_st->index)
450 ret = decode_packet(&decode, decoder_ctx, frame, &pkt, output_ctx);
451
452 av_packet_unref(&pkt);
453 }
454
455 /* flush the decoder */
456 pkt.data = NULL;
457 pkt.size = 0;
458 ret = decode_packet(&decode, decoder_ctx, frame, &pkt, output_ctx);
459
460 finish:
461 if (ret < 0) {
462 char buf[1024];
463 av_strerror(ret, buf, sizeof(buf));
464 fprintf(stderr, "%s\n", buf);
465 }
466
467 avformat_close_input(&input_ctx);
468
469 av_frame_free(&frame);
470
471 free_surfaces(&decode);
472
473 if (decode.mfx_session)
474 MFXClose(decode.mfx_session);
475 if (decode.va_dpy)
476 vaTerminate(decode.va_dpy);
477 if (dpy)
478 XCloseDisplay(dpy);
479
480 if (decoder_ctx)
481 av_freep(&decoder_ctx->hwaccel_context);
482 avcodec_free_context(&decoder_ctx);
483
484 avio_close(output_ctx);
485
486 return ret;
487 }