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