avcodec/mlz: clear dict on allocation to ensure there are no uninitialized values
[ffmpeg.git] / ffmpeg_vaapi.c
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18
19 #include "config.h"
20
21 #include <fcntl.h>
22 #include <unistd.h>
23
24 #include <va/va.h>
25 #if HAVE_VAAPI_X11
26 #   include <va/va_x11.h>
27 #endif
28 #if HAVE_VAAPI_DRM
29 #   include <va/va_drm.h>
30 #endif
31
32 #include "libavutil/avassert.h"
33 #include "libavutil/avconfig.h"
34 #include "libavutil/buffer.h"
35 #include "libavutil/frame.h"
36 #include "libavutil/hwcontext.h"
37 #include "libavutil/hwcontext_vaapi.h"
38 #include "libavutil/imgutils.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/pixfmt.h"
41
42 #include "libavcodec/vaapi.h"
43
44 #include "ffmpeg.h"
45
46
47 static AVClass vaapi_class = {
48     .class_name = "vaapi",
49     .item_name  = av_default_item_name,
50     .version    = LIBAVUTIL_VERSION_INT,
51 };
52
53 #define DEFAULT_SURFACES 20
54
55 typedef struct VAAPIDecoderContext {
56     const AVClass *class;
57
58     AVBufferRef       *device_ref;
59     AVHWDeviceContext *device;
60     AVBufferRef       *frames_ref;
61     AVHWFramesContext *frames;
62
63     VAProfile    va_profile;
64     VAEntrypoint va_entrypoint;
65     VAConfigID   va_config;
66     VAContextID  va_context;
67
68     enum AVPixelFormat decode_format;
69     int decode_width;
70     int decode_height;
71     int decode_surfaces;
72
73     // The output need not have the same format, width and height as the
74     // decoded frames - the copy for non-direct-mapped access is actually
75     // a whole vpp instance which can do arbitrary scaling and format
76     // conversion.
77     enum AVPixelFormat output_format;
78
79     struct vaapi_context decoder_vaapi_context;
80 } VAAPIDecoderContext;
81
82
83 static int vaapi_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
84 {
85     InputStream *ist = avctx->opaque;
86     VAAPIDecoderContext *ctx = ist->hwaccel_ctx;
87     int err;
88
89     err = av_hwframe_get_buffer(ctx->frames_ref, frame, 0);
90     if (err < 0) {
91         av_log(ctx, AV_LOG_ERROR, "Failed to allocate decoder surface.\n");
92     } else {
93         av_log(ctx, AV_LOG_DEBUG, "Decoder given surface %#x.\n",
94                (unsigned int)(uintptr_t)frame->data[3]);
95     }
96     return err;
97 }
98
99 static int vaapi_retrieve_data(AVCodecContext *avctx, AVFrame *input)
100 {
101     InputStream *ist = avctx->opaque;
102     VAAPIDecoderContext *ctx = ist->hwaccel_ctx;
103     AVFrame *output = 0;
104     int err;
105
106     av_assert0(input->format == AV_PIX_FMT_VAAPI);
107
108     if (ctx->output_format == AV_PIX_FMT_VAAPI) {
109         // Nothing to do.
110         return 0;
111     }
112
113     av_log(ctx, AV_LOG_DEBUG, "Retrieve data from surface %#x.\n",
114            (unsigned int)(uintptr_t)input->data[3]);
115
116     output = av_frame_alloc();
117     if (!output)
118         return AVERROR(ENOMEM);
119
120     output->format = ctx->output_format;
121
122     err = av_hwframe_transfer_data(output, input, 0);
123     if (err < 0) {
124         av_log(ctx, AV_LOG_ERROR, "Failed to transfer data to "
125                "output frame: %d.\n", err);
126         goto fail;
127     }
128
129     err = av_frame_copy_props(output, input);
130     if (err < 0) {
131         av_frame_unref(output);
132         goto fail;
133     }
134
135     av_frame_unref(input);
136     av_frame_move_ref(input, output);
137     av_frame_free(&output);
138
139     return 0;
140
141 fail:
142     if (output)
143         av_frame_free(&output);
144     return err;
145 }
146
147
148 static const struct {
149     enum AVCodecID codec_id;
150     int codec_profile;
151     VAProfile va_profile;
152 } vaapi_profile_map[] = {
153 #define MAP(c, p, v) { AV_CODEC_ID_ ## c, FF_PROFILE_ ## p, VAProfile ## v }
154     MAP(MPEG2VIDEO,  MPEG2_SIMPLE,    MPEG2Simple ),
155     MAP(MPEG2VIDEO,  MPEG2_MAIN,      MPEG2Main   ),
156     MAP(H263,        UNKNOWN,         H263Baseline),
157     MAP(MPEG4,       MPEG4_SIMPLE,    MPEG4Simple ),
158     MAP(MPEG4,       MPEG4_ADVANCED_SIMPLE,
159                                MPEG4AdvancedSimple),
160     MAP(MPEG4,       MPEG4_MAIN,      MPEG4Main   ),
161     MAP(H264,        H264_CONSTRAINED_BASELINE,
162                            H264ConstrainedBaseline),
163     MAP(H264,        H264_BASELINE,   H264Baseline),
164     MAP(H264,        H264_MAIN,       H264Main    ),
165     MAP(H264,        H264_HIGH,       H264High    ),
166 #if VA_CHECK_VERSION(0, 37, 0)
167     MAP(HEVC,        HEVC_MAIN,       HEVCMain    ),
168 #endif
169     MAP(WMV3,        VC1_SIMPLE,      VC1Simple   ),
170     MAP(WMV3,        VC1_MAIN,        VC1Main     ),
171     MAP(WMV3,        VC1_COMPLEX,     VC1Advanced ),
172     MAP(WMV3,        VC1_ADVANCED,    VC1Advanced ),
173     MAP(VC1,         VC1_SIMPLE,      VC1Simple   ),
174     MAP(VC1,         VC1_MAIN,        VC1Main     ),
175     MAP(VC1,         VC1_COMPLEX,     VC1Advanced ),
176     MAP(VC1,         VC1_ADVANCED,    VC1Advanced ),
177 #if VA_CHECK_VERSION(0, 35, 0)
178     MAP(VP8,         UNKNOWN,       VP8Version0_3 ),
179 #endif
180 #if VA_CHECK_VERSION(0, 37, 1)
181     MAP(VP9,         VP9_0,           VP9Profile0 ),
182 #endif
183 #undef MAP
184 };
185
186 static int vaapi_build_decoder_config(VAAPIDecoderContext *ctx,
187                                       AVCodecContext *avctx,
188                                       int fallback_allowed)
189 {
190     AVVAAPIDeviceContext *hwctx = ctx->device->hwctx;
191     AVVAAPIHWConfig *hwconfig = NULL;
192     AVHWFramesConstraints *constraints = NULL;
193     VAStatus vas;
194     int err, i, j;
195     int loglevel = fallback_allowed ? AV_LOG_VERBOSE : AV_LOG_ERROR;
196     const AVCodecDescriptor *codec_desc;
197     const AVPixFmtDescriptor *pix_desc;
198     enum AVPixelFormat pix_fmt;
199     VAProfile profile, *profile_list = NULL;
200     int profile_count, exact_match, alt_profile;
201
202     codec_desc = avcodec_descriptor_get(avctx->codec_id);
203     if (!codec_desc) {
204         err = AVERROR(EINVAL);
205         goto fail;
206     }
207
208     profile_count = vaMaxNumProfiles(hwctx->display);
209     profile_list = av_malloc(profile_count * sizeof(VAProfile));
210     if (!profile_list) {
211         err = AVERROR(ENOMEM);
212         goto fail;
213     }
214
215     vas = vaQueryConfigProfiles(hwctx->display,
216                                 profile_list, &profile_count);
217     if (vas != VA_STATUS_SUCCESS) {
218         av_log(ctx, loglevel, "Failed to query profiles: %d (%s).\n",
219                vas, vaErrorStr(vas));
220         err = AVERROR(EIO);
221         goto fail;
222     }
223
224     profile = VAProfileNone;
225     exact_match = 0;
226
227     for (i = 0; i < FF_ARRAY_ELEMS(vaapi_profile_map); i++) {
228         int profile_match = 0;
229         if (avctx->codec_id != vaapi_profile_map[i].codec_id)
230             continue;
231         if (avctx->profile == vaapi_profile_map[i].codec_profile)
232             profile_match = 1;
233         profile = vaapi_profile_map[i].va_profile;
234         for (j = 0; j < profile_count; j++) {
235             if (profile == profile_list[j]) {
236                 exact_match = profile_match;
237                 break;
238             }
239         }
240         if (j < profile_count) {
241             if (exact_match)
242                 break;
243             alt_profile = vaapi_profile_map[i].codec_profile;
244         }
245     }
246     av_freep(&profile_list);
247
248     if (profile == VAProfileNone) {
249         av_log(ctx, loglevel, "No VAAPI support for codec %s.\n",
250                codec_desc->name);
251         err = AVERROR(ENOSYS);
252         goto fail;
253     }
254     if (!exact_match) {
255         if (fallback_allowed || !hwaccel_lax_profile_check) {
256             av_log(ctx, loglevel, "No VAAPI support for codec %s "
257                    "profile %d.\n", codec_desc->name, avctx->profile);
258             if (!fallback_allowed) {
259                 av_log(ctx, AV_LOG_WARNING, "If you want attempt decoding "
260                        "anyway with a possibly-incompatible profile, add "
261                        "the option -hwaccel_lax_profile_check.\n");
262             }
263             err = AVERROR(EINVAL);
264             goto fail;
265         } else {
266             av_log(ctx, AV_LOG_WARNING, "No VAAPI support for codec %s "
267                    "profile %d: trying instead with profile %d.\n",
268                    codec_desc->name, avctx->profile, alt_profile);
269             av_log(ctx, AV_LOG_WARNING, "This may fail or give "
270                    "incorrect results, depending on your hardware.\n");
271         }
272     }
273
274     ctx->va_profile = profile;
275     ctx->va_entrypoint = VAEntrypointVLD;
276
277     vas = vaCreateConfig(hwctx->display, ctx->va_profile,
278                          ctx->va_entrypoint, 0, 0, &ctx->va_config);
279     if (vas != VA_STATUS_SUCCESS) {
280         av_log(ctx, AV_LOG_ERROR, "Failed to create decode pipeline "
281                "configuration: %d (%s).\n", vas, vaErrorStr(vas));
282         err = AVERROR(EIO);
283         goto fail;
284     }
285
286     hwconfig = av_hwdevice_hwconfig_alloc(ctx->device_ref);
287     if (!hwconfig) {
288         err = AVERROR(ENOMEM);
289         goto fail;
290     }
291     hwconfig->config_id = ctx->va_config;
292
293     constraints = av_hwdevice_get_hwframe_constraints(ctx->device_ref,
294                                                       hwconfig);
295     if (!constraints)
296         goto fail;
297
298     // Decide on the decoder target format.
299     // If the user specified something with -hwaccel_output_format then
300     // try to use that to minimise conversions later.
301     ctx->decode_format = AV_PIX_FMT_NONE;
302     if (ctx->output_format != AV_PIX_FMT_NONE &&
303         ctx->output_format != AV_PIX_FMT_VAAPI) {
304         for (i = 0; constraints->valid_sw_formats[i] != AV_PIX_FMT_NONE; i++) {
305             if (constraints->valid_sw_formats[i] == ctx->decode_format) {
306                 ctx->decode_format = ctx->output_format;
307                 av_log(ctx, AV_LOG_DEBUG, "Using decode format %s (output "
308                        "format).\n", av_get_pix_fmt_name(ctx->decode_format));
309                 break;
310             }
311         }
312     }
313     // Otherwise, we would like to try to choose something which matches the
314     // decoder output, but there isn't enough information available here to
315     // do so.  Assume for now that we are always dealing with YUV 4:2:0, so
316     // pick a format which does that.
317     if (ctx->decode_format == AV_PIX_FMT_NONE) {
318         for (i = 0; constraints->valid_sw_formats[i] != AV_PIX_FMT_NONE; i++) {
319             pix_fmt  = constraints->valid_sw_formats[i];
320             pix_desc = av_pix_fmt_desc_get(pix_fmt);
321             if (pix_desc->nb_components == 3 &&
322                 pix_desc->log2_chroma_w == 1 &&
323                 pix_desc->log2_chroma_h == 1) {
324                 ctx->decode_format = pix_fmt;
325                 av_log(ctx, AV_LOG_DEBUG, "Using decode format %s (format "
326                        "matched).\n", av_get_pix_fmt_name(ctx->decode_format));
327                 break;
328             }
329         }
330     }
331     // Otherwise pick the first in the list and hope for the best.
332     if (ctx->decode_format == AV_PIX_FMT_NONE) {
333         ctx->decode_format = constraints->valid_sw_formats[0];
334         av_log(ctx, AV_LOG_DEBUG, "Using decode format %s (first in list).\n",
335                av_get_pix_fmt_name(ctx->decode_format));
336         if (i > 1) {
337             // There was a choice, and we picked randomly.  Warn the user
338             // that they might want to choose intelligently instead.
339             av_log(ctx, AV_LOG_WARNING, "Using randomly chosen decode "
340                    "format %s.\n", av_get_pix_fmt_name(ctx->decode_format));
341         }
342     }
343
344     // Ensure the picture size is supported by the hardware.
345     ctx->decode_width  = avctx->coded_width;
346     ctx->decode_height = avctx->coded_height;
347     if (ctx->decode_width  < constraints->min_width  ||
348         ctx->decode_height < constraints->min_height ||
349         ctx->decode_width  > constraints->max_width  ||
350         ctx->decode_height >constraints->max_height) {
351         av_log(ctx, AV_LOG_ERROR, "VAAPI hardware does not support image "
352                "size %dx%d (constraints: width %d-%d height %d-%d).\n",
353                ctx->decode_width, ctx->decode_height,
354                constraints->min_width,  constraints->max_width,
355                constraints->min_height, constraints->max_height);
356         err = AVERROR(EINVAL);
357         goto fail;
358     }
359
360     av_hwframe_constraints_free(&constraints);
361     av_freep(&hwconfig);
362
363     // Decide how many reference frames we need.  This might be doable more
364     // nicely based on the codec and input stream?
365     ctx->decode_surfaces = DEFAULT_SURFACES;
366     // For frame-threaded decoding, one additional surfaces is needed for
367     // each thread.
368     if (avctx->active_thread_type & FF_THREAD_FRAME)
369         ctx->decode_surfaces += avctx->thread_count;
370
371     return 0;
372
373 fail:
374     av_hwframe_constraints_free(&constraints);
375     av_freep(&hwconfig);
376     vaDestroyConfig(hwctx->display, ctx->va_config);
377     av_freep(&profile_list);
378     return err;
379 }
380
381 static void vaapi_decode_uninit(AVCodecContext *avctx)
382 {
383     InputStream *ist = avctx->opaque;
384     VAAPIDecoderContext *ctx = ist->hwaccel_ctx;
385
386     if (ctx) {
387         AVVAAPIDeviceContext *hwctx = ctx->device->hwctx;
388
389         if (ctx->va_context != VA_INVALID_ID) {
390             vaDestroyContext(hwctx->display, ctx->va_context);
391             ctx->va_context = VA_INVALID_ID;
392         }
393         if (ctx->va_config != VA_INVALID_ID) {
394             vaDestroyConfig(hwctx->display, ctx->va_config);
395             ctx->va_config = VA_INVALID_ID;
396         }
397
398         av_buffer_unref(&ctx->frames_ref);
399         av_buffer_unref(&ctx->device_ref);
400         av_free(ctx);
401     }
402
403     av_buffer_unref(&ist->hw_frames_ctx);
404
405     ist->hwaccel_ctx           = 0;
406     ist->hwaccel_uninit        = 0;
407     ist->hwaccel_get_buffer    = 0;
408     ist->hwaccel_retrieve_data = 0;
409 }
410
411 int vaapi_decode_init(AVCodecContext *avctx)
412 {
413     InputStream *ist = avctx->opaque;
414     AVVAAPIDeviceContext *hwctx;
415     AVVAAPIFramesContext *avfc;
416     VAAPIDecoderContext *ctx;
417     VAStatus vas;
418     int err;
419     int loglevel = (ist->hwaccel_id != HWACCEL_VAAPI ? AV_LOG_VERBOSE
420                                                      : AV_LOG_ERROR);
421
422     if (ist->hwaccel_ctx)
423         vaapi_decode_uninit(avctx);
424
425     // We have -hwaccel without -vaapi_device, so just initialise here with
426     // the device passed as -hwaccel_device (if -vaapi_device was passed, it
427     // will always have been called before now).
428     if (!hw_device_ctx) {
429         err = vaapi_device_init(ist->hwaccel_device);
430         if (err < 0)
431             return err;
432     }
433
434     ctx = av_mallocz(sizeof(*ctx));
435     if (!ctx)
436         return AVERROR(ENOMEM);
437     ctx->class = &vaapi_class;
438
439     ctx->device_ref = av_buffer_ref(hw_device_ctx);
440     ctx->device = (AVHWDeviceContext*)ctx->device_ref->data;
441
442     ctx->va_config  = VA_INVALID_ID;
443     ctx->va_context = VA_INVALID_ID;
444
445     hwctx = ctx->device->hwctx;
446
447     ctx->output_format = ist->hwaccel_output_format;
448
449     err = vaapi_build_decoder_config(ctx, avctx,
450                                      ist->hwaccel_id != HWACCEL_VAAPI);
451     if (err < 0) {
452         av_log(ctx, loglevel, "No supported configuration for this codec.");
453         goto fail;
454     }
455
456     avctx->pix_fmt = ctx->output_format;
457
458     ctx->frames_ref = av_hwframe_ctx_alloc(ctx->device_ref);
459     if (!ctx->frames_ref) {
460         av_log(ctx, loglevel, "Failed to create VAAPI frame context.\n");
461         err = AVERROR(ENOMEM);
462         goto fail;
463     }
464
465     ctx->frames = (AVHWFramesContext*)ctx->frames_ref->data;
466
467     ctx->frames->format    = AV_PIX_FMT_VAAPI;
468     ctx->frames->sw_format = ctx->decode_format;
469     ctx->frames->width     = ctx->decode_width;
470     ctx->frames->height    = ctx->decode_height;
471     ctx->frames->initial_pool_size = ctx->decode_surfaces;
472
473     err = av_hwframe_ctx_init(ctx->frames_ref);
474     if (err < 0) {
475         av_log(ctx, loglevel, "Failed to initialise VAAPI frame "
476                "context: %d\n", err);
477         goto fail;
478     }
479
480     avfc = ctx->frames->hwctx;
481
482     vas = vaCreateContext(hwctx->display, ctx->va_config,
483                           ctx->decode_width, ctx->decode_height,
484                           VA_PROGRESSIVE,
485                           avfc->surface_ids, avfc->nb_surfaces,
486                           &ctx->va_context);
487     if (vas != VA_STATUS_SUCCESS) {
488         av_log(ctx, AV_LOG_ERROR, "Failed to create decode pipeline "
489                "context: %d (%s).\n", vas, vaErrorStr(vas));
490         err = AVERROR(EINVAL);
491         goto fail;
492     }
493
494     av_log(ctx, AV_LOG_DEBUG, "VAAPI decoder (re)init complete.\n");
495
496     // We would like to set this on the AVCodecContext for use by whoever gets
497     // the frames from the decoder, but unfortunately the AVCodecContext we
498     // have here need not be the "real" one (H.264 makes many copies for
499     // threading purposes).  To avoid the problem, we instead store it in the
500     // InputStream and propagate it from there.
501     ist->hw_frames_ctx = av_buffer_ref(ctx->frames_ref);
502     if (!ist->hw_frames_ctx) {
503         err = AVERROR(ENOMEM);
504         goto fail;
505     }
506
507     ist->hwaccel_ctx           = ctx;
508     ist->hwaccel_uninit        = vaapi_decode_uninit;
509     ist->hwaccel_get_buffer    = vaapi_get_buffer;
510     ist->hwaccel_retrieve_data = vaapi_retrieve_data;
511
512     ctx->decoder_vaapi_context.display    = hwctx->display;
513     ctx->decoder_vaapi_context.config_id  = ctx->va_config;
514     ctx->decoder_vaapi_context.context_id = ctx->va_context;
515     avctx->hwaccel_context = &ctx->decoder_vaapi_context;
516
517     return 0;
518
519 fail:
520     vaapi_decode_uninit(avctx);
521     return err;
522 }
523
524 static AVClass *vaapi_log = &vaapi_class;
525
526 av_cold int vaapi_device_init(const char *device)
527 {
528     int err;
529
530     err = av_hwdevice_ctx_create(&hw_device_ctx, AV_HWDEVICE_TYPE_VAAPI,
531                                  device, NULL, 0);
532     if (err < 0) {
533         av_log(&vaapi_log, AV_LOG_ERROR, "Failed to create a VAAPI device\n");
534         return err;
535     }
536
537     return 0;
538 }