examples/qsvdec: free the lavc decoder before closing MFX/VAAPI
[ffmpeg.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     if (decoder_ctx)
472         av_freep(&decoder_ctx->hwaccel_context);
473     avcodec_free_context(&decoder_ctx);
474
475     free_surfaces(&decode);
476
477     if (decode.mfx_session)
478         MFXClose(decode.mfx_session);
479     if (decode.va_dpy)
480         vaTerminate(decode.va_dpy);
481     if (dpy)
482         XCloseDisplay(dpy);
483
484     avio_close(output_ctx);
485
486     return ret;
487 }