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