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