f8719aaf0adb4b7449537d917c59f580dcb84e6d
[ffmpeg.git] / libavutil / hwcontext_vaapi.c
1 /*
2  * This file is part of Libav.
3  *
4  * Libav 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  * Libav 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 Libav; 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 #if HAVE_VAAPI_X11
22 #   include <va/va_x11.h>
23 #endif
24 #if HAVE_VAAPI_DRM
25 #   include <va/va_drm.h>
26 #endif
27
28 #include <fcntl.h>
29 #if HAVE_UNISTD_H
30 #   include <unistd.h>
31 #endif
32
33
34 #include "avassert.h"
35 #include "buffer.h"
36 #include "common.h"
37 #include "hwcontext.h"
38 #include "hwcontext_internal.h"
39 #include "hwcontext_vaapi.h"
40 #include "mem.h"
41 #include "pixdesc.h"
42 #include "pixfmt.h"
43
44 typedef struct VAAPIDevicePriv {
45 #if HAVE_VAAPI_X11
46     Display *x11_display;
47 #endif
48
49     int drm_fd;
50 } VAAPIDevicePriv;
51
52 typedef struct VAAPISurfaceFormat {
53     enum AVPixelFormat pix_fmt;
54     VAImageFormat image_format;
55 } VAAPISurfaceFormat;
56
57 typedef struct VAAPIDeviceContext {
58     // Surface formats which can be used with this device.
59     VAAPISurfaceFormat *formats;
60     int              nb_formats;
61 } VAAPIDeviceContext;
62
63 typedef struct VAAPIFramesContext {
64     // Surface attributes set at create time.
65     VASurfaceAttrib *attributes;
66     int           nb_attributes;
67     // RT format of the underlying surface (Intel driver ignores this anyway).
68     unsigned int rt_format;
69     // Whether vaDeriveImage works.
70     int derive_works;
71 } VAAPIFramesContext;
72
73 typedef struct VAAPIMapping {
74     // Handle to the derived or copied image which is mapped.
75     VAImage image;
76     // The mapping flags actually used.
77     int flags;
78 } VAAPIMapping;
79
80 #define MAP(va, rt, av) { \
81         VA_FOURCC_ ## va, \
82         VA_RT_FORMAT_ ## rt, \
83         AV_PIX_FMT_ ## av \
84     }
85 // The map fourcc <-> pix_fmt isn't bijective because of the annoying U/V
86 // plane swap cases.  The frame handling below tries to hide these.
87 static const struct {
88     unsigned int fourcc;
89     unsigned int rt_format;
90     enum AVPixelFormat pix_fmt;
91 } vaapi_format_map[] = {
92     MAP(NV12, YUV420,  NV12),
93     MAP(YV12, YUV420,  YUV420P), // With U/V planes swapped.
94     MAP(IYUV, YUV420,  YUV420P),
95   //MAP(I420, YUV420,  YUV420P), // Not in libva but used by Intel driver.
96 #ifdef VA_FOURCC_YV16
97     MAP(YV16, YUV422,  YUV422P), // With U/V planes swapped.
98 #endif
99     MAP(422H, YUV422,  YUV422P),
100     MAP(UYVY, YUV422,  UYVY422),
101     MAP(YUY2, YUV422,  YUYV422),
102     MAP(Y800, YUV400,  GRAY8),
103 #ifdef VA_FOURCC_P010
104     MAP(P010, YUV420_10BPP, P010),
105 #endif
106     MAP(BGRA, RGB32,   BGRA),
107   //MAP(BGRX, RGB32,   BGR0),
108     MAP(RGBA, RGB32,   RGBA),
109   //MAP(RGBX, RGB32,   RGB0),
110     MAP(ABGR, RGB32,   ABGR),
111   //MAP(XBGR, RGB32,   0BGR),
112     MAP(ARGB, RGB32,   ARGB),
113   //MAP(XRGB, RGB32,   0RGB),
114 };
115 #undef MAP
116
117 static enum AVPixelFormat vaapi_pix_fmt_from_fourcc(unsigned int fourcc)
118 {
119     int i;
120     for (i = 0; i < FF_ARRAY_ELEMS(vaapi_format_map); i++)
121         if (vaapi_format_map[i].fourcc == fourcc)
122             return vaapi_format_map[i].pix_fmt;
123     return AV_PIX_FMT_NONE;
124 }
125
126 static int vaapi_get_image_format(AVHWDeviceContext *hwdev,
127                                   enum AVPixelFormat pix_fmt,
128                                   VAImageFormat **image_format)
129 {
130     VAAPIDeviceContext *ctx = hwdev->internal->priv;
131     int i;
132
133     for (i = 0; i < ctx->nb_formats; i++) {
134         if (ctx->formats[i].pix_fmt == pix_fmt) {
135             if (image_format)
136                 *image_format = &ctx->formats[i].image_format;
137             return 0;
138         }
139     }
140     return AVERROR(EINVAL);
141 }
142
143 static int vaapi_frames_get_constraints(AVHWDeviceContext *hwdev,
144                                         const void *hwconfig,
145                                         AVHWFramesConstraints *constraints)
146 {
147     AVVAAPIDeviceContext *hwctx = hwdev->hwctx;
148     const AVVAAPIHWConfig *config = hwconfig;
149     VAAPIDeviceContext *ctx = hwdev->internal->priv;
150     VASurfaceAttrib *attr_list = NULL;
151     VAStatus vas;
152     enum AVPixelFormat pix_fmt;
153     unsigned int fourcc;
154     int err, i, j, attr_count, pix_fmt_count;
155
156     if (config) {
157         attr_count = 0;
158         vas = vaQuerySurfaceAttributes(hwctx->display, config->config_id,
159                                        0, &attr_count);
160         if (vas != VA_STATUS_SUCCESS) {
161             av_log(hwdev, AV_LOG_ERROR, "Failed to query surface attributes: "
162                    "%d (%s).\n", vas, vaErrorStr(vas));
163             err = AVERROR(ENOSYS);
164             goto fail;
165         }
166
167         attr_list = av_malloc(attr_count * sizeof(*attr_list));
168         if (!attr_list) {
169             err = AVERROR(ENOMEM);
170             goto fail;
171         }
172
173         vas = vaQuerySurfaceAttributes(hwctx->display, config->config_id,
174                                        attr_list, &attr_count);
175         if (vas != VA_STATUS_SUCCESS) {
176             av_log(hwdev, AV_LOG_ERROR, "Failed to query surface attributes: "
177                    "%d (%s).\n", vas, vaErrorStr(vas));
178             err = AVERROR(ENOSYS);
179             goto fail;
180         }
181
182         pix_fmt_count = 0;
183         for (i = 0; i < attr_count; i++) {
184             switch (attr_list[i].type) {
185             case VASurfaceAttribPixelFormat:
186                 fourcc = attr_list[i].value.value.i;
187                 pix_fmt = vaapi_pix_fmt_from_fourcc(fourcc);
188                 if (pix_fmt != AV_PIX_FMT_NONE) {
189                     ++pix_fmt_count;
190                 } else {
191                     // Something unsupported - ignore.
192                 }
193                 break;
194             case VASurfaceAttribMinWidth:
195                 constraints->min_width  = attr_list[i].value.value.i;
196                 break;
197             case VASurfaceAttribMinHeight:
198                 constraints->min_height = attr_list[i].value.value.i;
199                 break;
200             case VASurfaceAttribMaxWidth:
201                 constraints->max_width  = attr_list[i].value.value.i;
202                 break;
203             case VASurfaceAttribMaxHeight:
204                 constraints->max_height = attr_list[i].value.value.i;
205                 break;
206             }
207         }
208         if (pix_fmt_count == 0) {
209             // Nothing usable found.  Presumably there exists something which
210             // works, so leave the set null to indicate unknown.
211             constraints->valid_sw_formats = NULL;
212         } else {
213             constraints->valid_sw_formats = av_malloc_array(pix_fmt_count + 1,
214                                                             sizeof(pix_fmt));
215             if (!constraints->valid_sw_formats) {
216                 err = AVERROR(ENOMEM);
217                 goto fail;
218             }
219
220             for (i = j = 0; i < attr_count; i++) {
221                 if (attr_list[i].type != VASurfaceAttribPixelFormat)
222                     continue;
223                 fourcc = attr_list[i].value.value.i;
224                 pix_fmt = vaapi_pix_fmt_from_fourcc(fourcc);
225                 if (pix_fmt != AV_PIX_FMT_NONE)
226                     constraints->valid_sw_formats[j++] = pix_fmt;
227             }
228             av_assert0(j == pix_fmt_count);
229             constraints->valid_sw_formats[j] = AV_PIX_FMT_NONE;
230         }
231     } else {
232         // No configuration supplied.
233         // Return the full set of image formats known by the implementation.
234         constraints->valid_sw_formats = av_malloc_array(ctx->nb_formats + 1,
235                                                         sizeof(pix_fmt));
236         if (!constraints->valid_sw_formats) {
237             err = AVERROR(ENOMEM);
238             goto fail;
239         }
240         for (i = 0; i < ctx->nb_formats; i++)
241             constraints->valid_sw_formats[i] = ctx->formats[i].pix_fmt;
242         constraints->valid_sw_formats[i] = AV_PIX_FMT_NONE;
243     }
244
245     constraints->valid_hw_formats = av_malloc_array(2, sizeof(pix_fmt));
246     if (!constraints->valid_hw_formats) {
247         err = AVERROR(ENOMEM);
248         goto fail;
249     }
250     constraints->valid_hw_formats[0] = AV_PIX_FMT_VAAPI;
251     constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE;
252
253     err = 0;
254 fail:
255     av_freep(&attr_list);
256     return err;
257 }
258
259 static const struct {
260     const char *friendly_name;
261     const char *match_string;
262     unsigned int quirks;
263 } vaapi_driver_quirks_table[] = {
264     {
265         "Intel i965 (Quick Sync)",
266         "i965",
267         AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS,
268     },
269     {
270         "Intel iHD",
271         "ubit",
272         AV_VAAPI_DRIVER_QUIRK_ATTRIB_MEMTYPE,
273     },
274 };
275
276 static int vaapi_device_init(AVHWDeviceContext *hwdev)
277 {
278     VAAPIDeviceContext *ctx = hwdev->internal->priv;
279     AVVAAPIDeviceContext *hwctx = hwdev->hwctx;
280     VAImageFormat *image_list = NULL;
281     VAStatus vas;
282     const char *vendor_string;
283     int err, i, image_count;
284     enum AVPixelFormat pix_fmt;
285     unsigned int fourcc;
286
287     image_count = vaMaxNumImageFormats(hwctx->display);
288     if (image_count <= 0) {
289         err = AVERROR(EIO);
290         goto fail;
291     }
292     image_list = av_malloc(image_count * sizeof(*image_list));
293     if (!image_list) {
294         err = AVERROR(ENOMEM);
295         goto fail;
296     }
297     vas = vaQueryImageFormats(hwctx->display, image_list, &image_count);
298     if (vas != VA_STATUS_SUCCESS) {
299         err = AVERROR(EIO);
300         goto fail;
301     }
302
303     ctx->formats  = av_malloc(image_count * sizeof(*ctx->formats));
304     if (!ctx->formats) {
305         err = AVERROR(ENOMEM);
306         goto fail;
307     }
308     ctx->nb_formats = 0;
309     for (i = 0; i < image_count; i++) {
310         fourcc  = image_list[i].fourcc;
311         pix_fmt = vaapi_pix_fmt_from_fourcc(fourcc);
312         if (pix_fmt == AV_PIX_FMT_NONE) {
313             av_log(hwdev, AV_LOG_DEBUG, "Format %#x -> unknown.\n",
314                    fourcc);
315         } else {
316             av_log(hwdev, AV_LOG_DEBUG, "Format %#x -> %s.\n",
317                    fourcc, av_get_pix_fmt_name(pix_fmt));
318             ctx->formats[ctx->nb_formats].pix_fmt      = pix_fmt;
319             ctx->formats[ctx->nb_formats].image_format = image_list[i];
320             ++ctx->nb_formats;
321         }
322     }
323
324     if (hwctx->driver_quirks & AV_VAAPI_DRIVER_QUIRK_USER_SET) {
325         av_log(hwdev, AV_LOG_VERBOSE, "Not detecting driver: "
326                "quirks set by user.\n");
327     } else {
328         // Detect the driver in use and set quirk flags if necessary.
329         vendor_string = vaQueryVendorString(hwctx->display);
330         hwctx->driver_quirks = 0;
331         if (vendor_string) {
332             for (i = 0; i < FF_ARRAY_ELEMS(vaapi_driver_quirks_table); i++) {
333                 if (strstr(vendor_string,
334                            vaapi_driver_quirks_table[i].match_string)) {
335                     av_log(hwdev, AV_LOG_VERBOSE, "Matched \"%s\" as known "
336                            "driver \"%s\".\n", vendor_string,
337                            vaapi_driver_quirks_table[i].friendly_name);
338                     hwctx->driver_quirks |=
339                         vaapi_driver_quirks_table[i].quirks;
340                     break;
341                 }
342             }
343             if (!(i < FF_ARRAY_ELEMS(vaapi_driver_quirks_table))) {
344                 av_log(hwdev, AV_LOG_VERBOSE, "Unknown driver \"%s\", "
345                        "assuming standard behaviour.\n", vendor_string);
346             }
347         }
348     }
349
350     av_free(image_list);
351     return 0;
352 fail:
353     av_freep(&ctx->formats);
354     av_free(image_list);
355     return err;
356 }
357
358 static void vaapi_device_uninit(AVHWDeviceContext *hwdev)
359 {
360     VAAPIDeviceContext *ctx = hwdev->internal->priv;
361
362     av_freep(&ctx->formats);
363 }
364
365 static void vaapi_buffer_free(void *opaque, uint8_t *data)
366 {
367     AVHWFramesContext     *hwfc = opaque;
368     AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
369     VASurfaceID surface_id;
370     VAStatus vas;
371
372     surface_id = (VASurfaceID)(uintptr_t)data;
373
374     vas = vaDestroySurfaces(hwctx->display, &surface_id, 1);
375     if (vas != VA_STATUS_SUCCESS) {
376         av_log(hwfc, AV_LOG_ERROR, "Failed to destroy surface %#x: "
377                "%d (%s).\n", surface_id, vas, vaErrorStr(vas));
378     }
379 }
380
381 static AVBufferRef *vaapi_pool_alloc(void *opaque, int size)
382 {
383     AVHWFramesContext     *hwfc = opaque;
384     VAAPIFramesContext     *ctx = hwfc->internal->priv;
385     AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
386     AVVAAPIFramesContext  *avfc = hwfc->hwctx;
387     VASurfaceID surface_id;
388     VAStatus vas;
389     AVBufferRef *ref;
390
391     if (hwfc->initial_pool_size > 0 &&
392         avfc->nb_surfaces >= hwfc->initial_pool_size)
393         return NULL;
394
395     vas = vaCreateSurfaces(hwctx->display, ctx->rt_format,
396                            hwfc->width, hwfc->height,
397                            &surface_id, 1,
398                            ctx->attributes, ctx->nb_attributes);
399     if (vas != VA_STATUS_SUCCESS) {
400         av_log(hwfc, AV_LOG_ERROR, "Failed to create surface: "
401                "%d (%s).\n", vas, vaErrorStr(vas));
402         return NULL;
403     }
404     av_log(hwfc, AV_LOG_DEBUG, "Created surface %#x.\n", surface_id);
405
406     ref = av_buffer_create((uint8_t*)(uintptr_t)surface_id,
407                            sizeof(surface_id), &vaapi_buffer_free,
408                            hwfc, AV_BUFFER_FLAG_READONLY);
409     if (!ref) {
410         vaDestroySurfaces(hwctx->display, &surface_id, 1);
411         return NULL;
412     }
413
414     if (hwfc->initial_pool_size > 0) {
415         // This is a fixed-size pool, so we must still be in the initial
416         // allocation sequence.
417         av_assert0(avfc->nb_surfaces < hwfc->initial_pool_size);
418         avfc->surface_ids[avfc->nb_surfaces] = surface_id;
419         ++avfc->nb_surfaces;
420     }
421
422     return ref;
423 }
424
425 static int vaapi_frames_init(AVHWFramesContext *hwfc)
426 {
427     AVVAAPIFramesContext  *avfc = hwfc->hwctx;
428     VAAPIFramesContext     *ctx = hwfc->internal->priv;
429     AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
430     VAImageFormat *expected_format;
431     AVBufferRef *test_surface = NULL;
432     VASurfaceID test_surface_id;
433     VAImage test_image;
434     VAStatus vas;
435     int err, i;
436     unsigned int fourcc, rt_format;
437
438     for (i = 0; i < FF_ARRAY_ELEMS(vaapi_format_map); i++) {
439         if (vaapi_format_map[i].pix_fmt == hwfc->sw_format) {
440             fourcc    = vaapi_format_map[i].fourcc;
441             rt_format = vaapi_format_map[i].rt_format;
442             break;
443         }
444     }
445     if (i >= FF_ARRAY_ELEMS(vaapi_format_map)) {
446         av_log(hwfc, AV_LOG_ERROR, "Unsupported format: %s.\n",
447                av_get_pix_fmt_name(hwfc->sw_format));
448         return AVERROR(EINVAL);
449     }
450
451     if (!hwfc->pool) {
452         int need_memory_type = !(hwctx->driver_quirks & AV_VAAPI_DRIVER_QUIRK_ATTRIB_MEMTYPE);
453         int need_pixel_format = 1;
454         for (i = 0; i < avfc->nb_attributes; i++) {
455             if (ctx->attributes[i].type == VASurfaceAttribMemoryType)
456                 need_memory_type  = 0;
457             if (ctx->attributes[i].type == VASurfaceAttribPixelFormat)
458                 need_pixel_format = 0;
459         }
460         ctx->nb_attributes =
461             avfc->nb_attributes + need_memory_type + need_pixel_format;
462
463         ctx->attributes = av_malloc(ctx->nb_attributes *
464                                         sizeof(*ctx->attributes));
465         if (!ctx->attributes) {
466             err = AVERROR(ENOMEM);
467             goto fail;
468         }
469
470         for (i = 0; i < avfc->nb_attributes; i++)
471             ctx->attributes[i] = avfc->attributes[i];
472         if (need_memory_type) {
473             ctx->attributes[i++] = (VASurfaceAttrib) {
474                 .type          = VASurfaceAttribMemoryType,
475                 .flags         = VA_SURFACE_ATTRIB_SETTABLE,
476                 .value.type    = VAGenericValueTypeInteger,
477                 .value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_VA,
478             };
479         }
480         if (need_pixel_format) {
481             ctx->attributes[i++] = (VASurfaceAttrib) {
482                 .type          = VASurfaceAttribPixelFormat,
483                 .flags         = VA_SURFACE_ATTRIB_SETTABLE,
484                 .value.type    = VAGenericValueTypeInteger,
485                 .value.value.i = fourcc,
486             };
487         }
488         av_assert0(i == ctx->nb_attributes);
489
490         ctx->rt_format = rt_format;
491
492         if (hwfc->initial_pool_size > 0) {
493             // This pool will be usable as a render target, so we need to store
494             // all of the surface IDs somewhere that vaCreateContext() calls
495             // will be able to access them.
496             avfc->nb_surfaces = 0;
497             avfc->surface_ids = av_malloc(hwfc->initial_pool_size *
498                                           sizeof(*avfc->surface_ids));
499             if (!avfc->surface_ids) {
500                 err = AVERROR(ENOMEM);
501                 goto fail;
502             }
503         } else {
504             // This pool allows dynamic sizing, and will not be usable as a
505             // render target.
506             avfc->nb_surfaces = 0;
507             avfc->surface_ids = NULL;
508         }
509
510         hwfc->internal->pool_internal =
511             av_buffer_pool_init2(sizeof(VASurfaceID), hwfc,
512                                  &vaapi_pool_alloc, NULL);
513         if (!hwfc->internal->pool_internal) {
514             av_log(hwfc, AV_LOG_ERROR, "Failed to create VAAPI surface pool.\n");
515             err = AVERROR(ENOMEM);
516             goto fail;
517         }
518     }
519
520     // Allocate a single surface to test whether vaDeriveImage() is going
521     // to work for the specific configuration.
522     if (hwfc->pool) {
523         test_surface = av_buffer_pool_get(hwfc->pool);
524         if (!test_surface) {
525             av_log(hwfc, AV_LOG_ERROR, "Unable to allocate a surface from "
526                    "user-configured buffer pool.\n");
527             err = AVERROR(ENOMEM);
528             goto fail;
529         }
530     } else {
531         test_surface = av_buffer_pool_get(hwfc->internal->pool_internal);
532         if (!test_surface) {
533             av_log(hwfc, AV_LOG_ERROR, "Unable to allocate a surface from "
534                    "internal buffer pool.\n");
535             err = AVERROR(ENOMEM);
536             goto fail;
537         }
538     }
539     test_surface_id = (VASurfaceID)(uintptr_t)test_surface->data;
540
541     ctx->derive_works = 0;
542
543     err = vaapi_get_image_format(hwfc->device_ctx,
544                                  hwfc->sw_format, &expected_format);
545     if (err == 0) {
546         vas = vaDeriveImage(hwctx->display, test_surface_id, &test_image);
547         if (vas == VA_STATUS_SUCCESS) {
548             if (expected_format->fourcc == test_image.format.fourcc) {
549                 av_log(hwfc, AV_LOG_DEBUG, "Direct mapping possible.\n");
550                 ctx->derive_works = 1;
551             } else {
552                 av_log(hwfc, AV_LOG_DEBUG, "Direct mapping disabled: "
553                        "derived image format %08x does not match "
554                        "expected format %08x.\n",
555                        expected_format->fourcc, test_image.format.fourcc);
556             }
557             vaDestroyImage(hwctx->display, test_image.image_id);
558         } else {
559             av_log(hwfc, AV_LOG_DEBUG, "Direct mapping disabled: "
560                    "deriving image does not work: "
561                    "%d (%s).\n", vas, vaErrorStr(vas));
562         }
563     } else {
564         av_log(hwfc, AV_LOG_DEBUG, "Direct mapping disabled: "
565                "image format is not supported.\n");
566     }
567
568     av_buffer_unref(&test_surface);
569     return 0;
570
571 fail:
572     av_buffer_unref(&test_surface);
573     av_freep(&avfc->surface_ids);
574     av_freep(&ctx->attributes);
575     return err;
576 }
577
578 static void vaapi_frames_uninit(AVHWFramesContext *hwfc)
579 {
580     AVVAAPIFramesContext *avfc = hwfc->hwctx;
581     VAAPIFramesContext    *ctx = hwfc->internal->priv;
582
583     av_freep(&avfc->surface_ids);
584     av_freep(&ctx->attributes);
585 }
586
587 static int vaapi_get_buffer(AVHWFramesContext *hwfc, AVFrame *frame)
588 {
589     frame->buf[0] = av_buffer_pool_get(hwfc->pool);
590     if (!frame->buf[0])
591         return AVERROR(ENOMEM);
592
593     frame->data[3] = frame->buf[0]->data;
594     frame->format  = AV_PIX_FMT_VAAPI;
595     frame->width   = hwfc->width;
596     frame->height  = hwfc->height;
597
598     return 0;
599 }
600
601 static int vaapi_transfer_get_formats(AVHWFramesContext *hwfc,
602                                       enum AVHWFrameTransferDirection dir,
603                                       enum AVPixelFormat **formats)
604 {
605     VAAPIDeviceContext *ctx = hwfc->device_ctx->internal->priv;
606     enum AVPixelFormat *pix_fmts, preferred_format;
607     int i, k;
608
609     preferred_format = hwfc->sw_format;
610
611     pix_fmts = av_malloc((ctx->nb_formats + 1) * sizeof(*pix_fmts));
612     if (!pix_fmts)
613         return AVERROR(ENOMEM);
614
615     pix_fmts[0] = preferred_format;
616     k = 1;
617     for (i = 0; i < ctx->nb_formats; i++) {
618         if (ctx->formats[i].pix_fmt == preferred_format)
619             continue;
620         av_assert0(k < ctx->nb_formats);
621         pix_fmts[k++] = ctx->formats[i].pix_fmt;
622     }
623     av_assert0(k == ctx->nb_formats);
624     pix_fmts[k] = AV_PIX_FMT_NONE;
625
626     *formats = pix_fmts;
627     return 0;
628 }
629
630 static void vaapi_unmap_frame(AVHWFramesContext *hwfc,
631                               HWMapDescriptor *hwmap)
632 {
633     AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
634     VAAPIMapping           *map = hwmap->priv;
635     VASurfaceID surface_id;
636     VAStatus vas;
637
638     surface_id = (VASurfaceID)(uintptr_t)hwmap->source->data[3];
639     av_log(hwfc, AV_LOG_DEBUG, "Unmap surface %#x.\n", surface_id);
640
641     vas = vaUnmapBuffer(hwctx->display, map->image.buf);
642     if (vas != VA_STATUS_SUCCESS) {
643         av_log(hwfc, AV_LOG_ERROR, "Failed to unmap image from surface "
644                "%#x: %d (%s).\n", surface_id, vas, vaErrorStr(vas));
645     }
646
647     if ((map->flags & AV_HWFRAME_MAP_WRITE) &&
648         !(map->flags & AV_HWFRAME_MAP_DIRECT)) {
649         vas = vaPutImage(hwctx->display, surface_id, map->image.image_id,
650                          0, 0, hwfc->width, hwfc->height,
651                          0, 0, hwfc->width, hwfc->height);
652         if (vas != VA_STATUS_SUCCESS) {
653             av_log(hwfc, AV_LOG_ERROR, "Failed to write image to surface "
654                    "%#x: %d (%s).\n", surface_id, vas, vaErrorStr(vas));
655         }
656     }
657
658     vas = vaDestroyImage(hwctx->display, map->image.image_id);
659     if (vas != VA_STATUS_SUCCESS) {
660         av_log(hwfc, AV_LOG_ERROR, "Failed to destroy image from surface "
661                "%#x: %d (%s).\n", surface_id, vas, vaErrorStr(vas));
662     }
663
664     av_free(map);
665 }
666
667 static int vaapi_map_frame(AVHWFramesContext *hwfc,
668                            AVFrame *dst, const AVFrame *src, int flags)
669 {
670     AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
671     VAAPIFramesContext *ctx = hwfc->internal->priv;
672     VASurfaceID surface_id;
673     VAImageFormat *image_format;
674     VAAPIMapping *map;
675     VAStatus vas;
676     void *address = NULL;
677     int err, i;
678
679     surface_id = (VASurfaceID)(uintptr_t)src->data[3];
680     av_log(hwfc, AV_LOG_DEBUG, "Map surface %#x.\n", surface_id);
681
682     if (!ctx->derive_works && (flags & AV_HWFRAME_MAP_DIRECT)) {
683         // Requested direct mapping but it is not possible.
684         return AVERROR(EINVAL);
685     }
686     if (dst->format == AV_PIX_FMT_NONE)
687         dst->format = hwfc->sw_format;
688     if (dst->format != hwfc->sw_format && (flags & AV_HWFRAME_MAP_DIRECT)) {
689         // Requested direct mapping but the formats do not match.
690         return AVERROR(EINVAL);
691     }
692
693     err = vaapi_get_image_format(hwfc->device_ctx, dst->format, &image_format);
694     if (err < 0) {
695         // Requested format is not a valid output format.
696         return AVERROR(EINVAL);
697     }
698
699     map = av_malloc(sizeof(*map));
700     if (!map)
701         return AVERROR(ENOMEM);
702     map->flags = flags;
703     map->image.image_id = VA_INVALID_ID;
704
705     vas = vaSyncSurface(hwctx->display, surface_id);
706     if (vas != VA_STATUS_SUCCESS) {
707         av_log(hwfc, AV_LOG_ERROR, "Failed to sync surface "
708                "%#x: %d (%s).\n", surface_id, vas, vaErrorStr(vas));
709         err = AVERROR(EIO);
710         goto fail;
711     }
712
713     // The memory which we map using derive need not be connected to the CPU
714     // in a way conducive to fast access.  On Gen7-Gen9 Intel graphics, the
715     // memory is mappable but not cached, so normal memcpy()-like access is
716     // very slow to read it (but writing is ok).  It is possible to read much
717     // faster with a copy routine which is aware of the limitation, but we
718     // assume for now that the user is not aware of that and would therefore
719     // prefer not to be given direct-mapped memory if they request read access.
720     if (ctx->derive_works && dst->format == hwfc->sw_format &&
721         ((flags & AV_HWFRAME_MAP_DIRECT) || !(flags & AV_HWFRAME_MAP_READ))) {
722         vas = vaDeriveImage(hwctx->display, surface_id, &map->image);
723         if (vas != VA_STATUS_SUCCESS) {
724             av_log(hwfc, AV_LOG_ERROR, "Failed to derive image from "
725                    "surface %#x: %d (%s).\n",
726                    surface_id, vas, vaErrorStr(vas));
727             err = AVERROR(EIO);
728             goto fail;
729         }
730         if (map->image.format.fourcc != image_format->fourcc) {
731             av_log(hwfc, AV_LOG_ERROR, "Derive image of surface %#x "
732                    "is in wrong format: expected %#08x, got %#08x.\n",
733                    surface_id, image_format->fourcc, map->image.format.fourcc);
734             err = AVERROR(EIO);
735             goto fail;
736         }
737         map->flags |= AV_HWFRAME_MAP_DIRECT;
738     } else {
739         vas = vaCreateImage(hwctx->display, image_format,
740                             hwfc->width, hwfc->height, &map->image);
741         if (vas != VA_STATUS_SUCCESS) {
742             av_log(hwfc, AV_LOG_ERROR, "Failed to create image for "
743                    "surface %#x: %d (%s).\n",
744                    surface_id, vas, vaErrorStr(vas));
745             err = AVERROR(EIO);
746             goto fail;
747         }
748         if (!(flags & AV_HWFRAME_MAP_OVERWRITE)) {
749             vas = vaGetImage(hwctx->display, surface_id, 0, 0,
750                              hwfc->width, hwfc->height, map->image.image_id);
751             if (vas != VA_STATUS_SUCCESS) {
752                 av_log(hwfc, AV_LOG_ERROR, "Failed to read image from "
753                        "surface %#x: %d (%s).\n",
754                        surface_id, vas, vaErrorStr(vas));
755                 err = AVERROR(EIO);
756                 goto fail;
757             }
758         }
759     }
760
761     vas = vaMapBuffer(hwctx->display, map->image.buf, &address);
762     if (vas != VA_STATUS_SUCCESS) {
763         av_log(hwfc, AV_LOG_ERROR, "Failed to map image from surface "
764                "%#x: %d (%s).\n", surface_id, vas, vaErrorStr(vas));
765         err = AVERROR(EIO);
766         goto fail;
767     }
768
769     err = ff_hwframe_map_create(src->hw_frames_ctx,
770                                 dst, src, &vaapi_unmap_frame, map);
771     if (err < 0)
772         goto fail;
773
774     dst->width  = src->width;
775     dst->height = src->height;
776
777     for (i = 0; i < map->image.num_planes; i++) {
778         dst->data[i] = (uint8_t*)address + map->image.offsets[i];
779         dst->linesize[i] = map->image.pitches[i];
780     }
781     if (
782 #ifdef VA_FOURCC_YV16
783         map->image.format.fourcc == VA_FOURCC_YV16 ||
784 #endif
785         map->image.format.fourcc == VA_FOURCC_YV12) {
786         // Chroma planes are YVU rather than YUV, so swap them.
787         FFSWAP(uint8_t*, dst->data[1], dst->data[2]);
788     }
789
790     return 0;
791
792 fail:
793     if (map) {
794         if (address)
795             vaUnmapBuffer(hwctx->display, map->image.buf);
796         if (map->image.image_id != VA_INVALID_ID)
797             vaDestroyImage(hwctx->display, map->image.image_id);
798         av_free(map);
799     }
800     return err;
801 }
802
803 static int vaapi_transfer_data_from(AVHWFramesContext *hwfc,
804                                     AVFrame *dst, const AVFrame *src)
805 {
806     AVFrame *map;
807     int err;
808
809     if (dst->width > hwfc->width || dst->height > hwfc->height)
810         return AVERROR(EINVAL);
811
812     map = av_frame_alloc();
813     if (!map)
814         return AVERROR(ENOMEM);
815     map->format = dst->format;
816
817     err = vaapi_map_frame(hwfc, map, src, AV_HWFRAME_MAP_READ);
818     if (err)
819         goto fail;
820
821     map->width  = dst->width;
822     map->height = dst->height;
823
824     err = av_frame_copy(dst, map);
825     if (err)
826         goto fail;
827
828     err = 0;
829 fail:
830     av_frame_free(&map);
831     return err;
832 }
833
834 static int vaapi_transfer_data_to(AVHWFramesContext *hwfc,
835                                   AVFrame *dst, const AVFrame *src)
836 {
837     AVFrame *map;
838     int err;
839
840     if (src->width > hwfc->width || src->height > hwfc->height)
841         return AVERROR(EINVAL);
842
843     map = av_frame_alloc();
844     if (!map)
845         return AVERROR(ENOMEM);
846     map->format = src->format;
847
848     err = vaapi_map_frame(hwfc, map, dst, AV_HWFRAME_MAP_WRITE | AV_HWFRAME_MAP_OVERWRITE);
849     if (err)
850         goto fail;
851
852     map->width  = src->width;
853     map->height = src->height;
854
855     err = av_frame_copy(map, src);
856     if (err)
857         goto fail;
858
859     err = 0;
860 fail:
861     av_frame_free(&map);
862     return err;
863 }
864
865 static int vaapi_map_from(AVHWFramesContext *hwfc, AVFrame *dst,
866                           const AVFrame *src, int flags)
867 {
868     int err;
869
870     if (dst->format != AV_PIX_FMT_NONE) {
871         err = vaapi_get_image_format(hwfc->device_ctx, dst->format, NULL);
872         if (err < 0)
873             return AVERROR(ENOSYS);
874     }
875
876     err = vaapi_map_frame(hwfc, dst, src, flags);
877     if (err)
878         return err;
879
880     err = av_frame_copy_props(dst, src);
881     if (err)
882         return err;
883
884     return 0;
885 }
886
887 static void vaapi_device_free(AVHWDeviceContext *ctx)
888 {
889     AVVAAPIDeviceContext *hwctx = ctx->hwctx;
890     VAAPIDevicePriv      *priv  = ctx->user_opaque;
891
892     if (hwctx->display)
893         vaTerminate(hwctx->display);
894
895 #if HAVE_VAAPI_X11
896     if (priv->x11_display)
897         XCloseDisplay(priv->x11_display);
898 #endif
899
900     if (priv->drm_fd >= 0)
901         close(priv->drm_fd);
902
903     av_freep(&priv);
904 }
905
906 static int vaapi_device_create(AVHWDeviceContext *ctx, const char *device,
907                                AVDictionary *opts, int flags)
908 {
909     AVVAAPIDeviceContext *hwctx = ctx->hwctx;
910     VAAPIDevicePriv *priv;
911     VADisplay display = 0;
912     VAStatus vas;
913     int major, minor;
914
915     priv = av_mallocz(sizeof(*priv));
916     if (!priv)
917         return AVERROR(ENOMEM);
918
919     priv->drm_fd = -1;
920
921     ctx->user_opaque = priv;
922     ctx->free        = vaapi_device_free;
923
924 #if HAVE_VAAPI_X11
925     if (!display && !(device && device[0] == '/')) {
926         // Try to open the device as an X11 display.
927         priv->x11_display = XOpenDisplay(device);
928         if (!priv->x11_display) {
929             av_log(ctx, AV_LOG_VERBOSE, "Cannot open X11 display "
930                    "%s.\n", XDisplayName(device));
931         } else {
932             display = vaGetDisplay(priv->x11_display);
933             if (!display) {
934                 av_log(ctx, AV_LOG_ERROR, "Cannot open a VA display "
935                        "from X11 display %s.\n", XDisplayName(device));
936                 return AVERROR_UNKNOWN;
937             }
938
939             av_log(ctx, AV_LOG_VERBOSE, "Opened VA display via "
940                    "X11 display %s.\n", XDisplayName(device));
941         }
942     }
943 #endif
944
945 #if HAVE_VAAPI_DRM
946     if (!display) {
947         // Try to open the device as a DRM path.
948         // Default to using the first render node if the user did not
949         // supply a path.
950         const char *path = device ? device : "/dev/dri/renderD128";
951         priv->drm_fd = open(path, O_RDWR);
952         if (priv->drm_fd < 0) {
953             av_log(ctx, AV_LOG_VERBOSE, "Cannot open DRM device %s.\n",
954                    path);
955         } else {
956             display = vaGetDisplayDRM(priv->drm_fd);
957             if (!display) {
958                 av_log(ctx, AV_LOG_ERROR, "Cannot open a VA display "
959                        "from DRM device %s.\n", path);
960                 return AVERROR_UNKNOWN;
961             }
962
963             av_log(ctx, AV_LOG_VERBOSE, "Opened VA display via "
964                    "DRM device %s.\n", path);
965         }
966     }
967 #endif
968
969     if (!display) {
970         av_log(ctx, AV_LOG_ERROR, "No VA display found for "
971                "device: %s.\n", device ? device : "");
972         return AVERROR(EINVAL);
973     }
974
975     hwctx->display = display;
976
977     vas = vaInitialize(display, &major, &minor);
978     if (vas != VA_STATUS_SUCCESS) {
979         av_log(ctx, AV_LOG_ERROR, "Failed to initialise VAAPI "
980                "connection: %d (%s).\n", vas, vaErrorStr(vas));
981         return AVERROR(EIO);
982     }
983     av_log(ctx, AV_LOG_VERBOSE, "Initialised VAAPI connection: "
984            "version %d.%d\n", major, minor);
985
986     return 0;
987 }
988
989 const HWContextType ff_hwcontext_type_vaapi = {
990     .type                   = AV_HWDEVICE_TYPE_VAAPI,
991     .name                   = "VAAPI",
992
993     .device_hwctx_size      = sizeof(AVVAAPIDeviceContext),
994     .device_priv_size       = sizeof(VAAPIDeviceContext),
995     .device_hwconfig_size   = sizeof(AVVAAPIHWConfig),
996     .frames_hwctx_size      = sizeof(AVVAAPIFramesContext),
997     .frames_priv_size       = sizeof(VAAPIFramesContext),
998
999     .device_create          = &vaapi_device_create,
1000     .device_init            = &vaapi_device_init,
1001     .device_uninit          = &vaapi_device_uninit,
1002     .frames_get_constraints = &vaapi_frames_get_constraints,
1003     .frames_init            = &vaapi_frames_init,
1004     .frames_uninit          = &vaapi_frames_uninit,
1005     .frames_get_buffer      = &vaapi_get_buffer,
1006     .transfer_get_formats   = &vaapi_transfer_get_formats,
1007     .transfer_data_to       = &vaapi_transfer_data_to,
1008     .transfer_data_from     = &vaapi_transfer_data_from,
1009     .map_to                 = NULL,
1010     .map_from               = &vaapi_map_from,
1011
1012     .pix_fmts = (const enum AVPixelFormat[]) {
1013         AV_PIX_FMT_VAAPI,
1014         AV_PIX_FMT_NONE
1015     },
1016 };