/*

  * This file is part of FFmpeg.

  *

  * FFmpeg is free software; you can redistribute it and/or

  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *

  * FFmpeg is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public

  * License along with FFmpeg; if not, write to the Free Software

  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 

 #include "config.h"
 
 #if HAVE_VAAPI_X11
 #   include <va/va_x11.h>
 #endif
 #if HAVE_VAAPI_DRM
 #   include <va/va_drm.h>
 #endif
 

 #if CONFIG_LIBDRM
 #   include <va/va_drmcommon.h>

 #   include <xf86drm.h>

 #   include <drm_fourcc.h>

 #   ifndef DRM_FORMAT_MOD_INVALID
 #       define DRM_FORMAT_MOD_INVALID ((1ULL << 56) - 1)
 #   endif

 #endif
 

 #include <fcntl.h>
 #if HAVE_UNISTD_H
 #   include <unistd.h>
 #endif
 
 

 #include "avassert.h"
 #include "buffer.h"
 #include "common.h"
 #include "hwcontext.h"

 #include "hwcontext_drm.h"

 #include "hwcontext_internal.h"
 #include "hwcontext_vaapi.h"
 #include "mem.h"
 #include "pixdesc.h"
 #include "pixfmt.h"
 

 typedef struct VAAPIDevicePriv {
 #if HAVE_VAAPI_X11
     Display *x11_display;
 #endif
 
     int drm_fd;
 } VAAPIDevicePriv;
 

 typedef struct VAAPISurfaceFormat {
     enum AVPixelFormat pix_fmt;
     VAImageFormat image_format;
 } VAAPISurfaceFormat;
 
 typedef struct VAAPIDeviceContext {
     // Surface formats which can be used with this device.
     VAAPISurfaceFormat *formats;
     int              nb_formats;
 } VAAPIDeviceContext;
 
 typedef struct VAAPIFramesContext {
     // Surface attributes set at create time.
     VASurfaceAttrib *attributes;
     int           nb_attributes;
     // RT format of the underlying surface (Intel driver ignores this anyway).
     unsigned int rt_format;
     // Whether vaDeriveImage works.
     int derive_works;
 } VAAPIFramesContext;
 

 typedef struct VAAPIMapping {

     // Handle to the derived or copied image which is mapped.
     VAImage image;

     // The mapping flags actually used.
     int flags;
 } VAAPIMapping;

 typedef struct VAAPIFormat {
     unsigned int fourcc;
     unsigned int rt_format;
     enum AVPixelFormat pix_fmt;
     int chroma_planes_swapped;
 } VAAPIFormatDescriptor;
 
 #define MAP(va, rt, av, swap_uv) { \

         VA_FOURCC_ ## va, \
         VA_RT_FORMAT_ ## rt, \

         AV_PIX_FMT_ ## av, \
         swap_uv, \

     }
 // The map fourcc <-> pix_fmt isn't bijective because of the annoying U/V
 // plane swap cases.  The frame handling below tries to hide these.

 static const VAAPIFormatDescriptor vaapi_format_map[] = {
     MAP(NV12, YUV420,  NV12,    0),

 #ifdef VA_FOURCC_I420

     MAP(I420, YUV420,  YUV420P, 0),

 #endif

     MAP(YV12, YUV420,  YUV420P, 1),
     MAP(IYUV, YUV420,  YUV420P, 0),
     MAP(422H, YUV422,  YUV422P, 0),

 #ifdef VA_FOURCC_YV16

     MAP(YV16, YUV422,  YUV422P, 1),

 #endif

     MAP(UYVY, YUV422,  UYVY422, 0),
     MAP(YUY2, YUV422,  YUYV422, 0),

 #ifdef VA_FOURCC_Y210
     MAP(Y210, YUV422_10,  Y210, 0),
 #endif

     MAP(411P, YUV411,  YUV411P, 0),
     MAP(422V, YUV422,  YUV440P, 0),
     MAP(444P, YUV444,  YUV444P, 0),
     MAP(Y800, YUV400,  GRAY8,   0),

 #ifdef VA_FOURCC_P010

     MAP(P010, YUV420_10BPP, P010, 0),

 #endif

     MAP(BGRA, RGB32,   BGRA, 0),
     MAP(BGRX, RGB32,   BGR0, 0),
     MAP(RGBA, RGB32,   RGBA, 0),
     MAP(RGBX, RGB32,   RGB0, 0),

 #ifdef VA_FOURCC_ABGR

     MAP(ABGR, RGB32,   ABGR, 0),
     MAP(XBGR, RGB32,   0BGR, 0),

 #endif

     MAP(ARGB, RGB32,   ARGB, 0),
     MAP(XRGB, RGB32,   0RGB, 0),

 };
 #undef MAP
 

 static const VAAPIFormatDescriptor *
     vaapi_format_from_fourcc(unsigned int fourcc)

 {
     int i;
     for (i = 0; i < FF_ARRAY_ELEMS(vaapi_format_map); i++)
         if (vaapi_format_map[i].fourcc == fourcc)

             return &vaapi_format_map[i];
     return NULL;
 }
 
 static const VAAPIFormatDescriptor *
     vaapi_format_from_pix_fmt(enum AVPixelFormat pix_fmt)
 {
     int i;
     for (i = 0; i < FF_ARRAY_ELEMS(vaapi_format_map); i++)
         if (vaapi_format_map[i].pix_fmt == pix_fmt)
             return &vaapi_format_map[i];
     return NULL;
 }
 
 static enum AVPixelFormat vaapi_pix_fmt_from_fourcc(unsigned int fourcc)
 {
     const VAAPIFormatDescriptor *desc;
     desc = vaapi_format_from_fourcc(fourcc);
     if (desc)
         return desc->pix_fmt;
     else
         return AV_PIX_FMT_NONE;

 }
 
 static int vaapi_get_image_format(AVHWDeviceContext *hwdev,
                                   enum AVPixelFormat pix_fmt,
                                   VAImageFormat **image_format)
 {
     VAAPIDeviceContext *ctx = hwdev->internal->priv;
     int i;
 
     for (i = 0; i < ctx->nb_formats; i++) {
         if (ctx->formats[i].pix_fmt == pix_fmt) {

             if (image_format)
                 *image_format = &ctx->formats[i].image_format;

             return 0;
         }
     }
     return AVERROR(EINVAL);
 }
 
 static int vaapi_frames_get_constraints(AVHWDeviceContext *hwdev,
                                         const void *hwconfig,
                                         AVHWFramesConstraints *constraints)
 {
     AVVAAPIDeviceContext *hwctx = hwdev->hwctx;
     const AVVAAPIHWConfig *config = hwconfig;

     VAAPIDeviceContext *ctx = hwdev->internal->priv;

     VASurfaceAttrib *attr_list = NULL;
     VAStatus vas;
     enum AVPixelFormat pix_fmt;
     unsigned int fourcc;
     int err, i, j, attr_count, pix_fmt_count;
 

     if (config &&
         !(hwctx->driver_quirks & AV_VAAPI_DRIVER_QUIRK_SURFACE_ATTRIBUTES)) {

         attr_count = 0;
         vas = vaQuerySurfaceAttributes(hwctx->display, config->config_id,
                                        0, &attr_count);

         if (vas != VA_STATUS_SUCCESS) {

             av_log(hwdev, AV_LOG_ERROR, "Failed to query surface attributes: "
                    "%d (%s).\n", vas, vaErrorStr(vas));
             err = AVERROR(ENOSYS);
             goto fail;

         }
 

         attr_list = av_malloc(attr_count * sizeof(*attr_list));
         if (!attr_list) {
             err = AVERROR(ENOMEM);
             goto fail;
         }

         vas = vaQuerySurfaceAttributes(hwctx->display, config->config_id,
                                        attr_list, &attr_count);
         if (vas != VA_STATUS_SUCCESS) {
             av_log(hwdev, AV_LOG_ERROR, "Failed to query surface attributes: "
                    "%d (%s).\n", vas, vaErrorStr(vas));
             err = AVERROR(ENOSYS);
             goto fail;
         }

         pix_fmt_count = 0;
         for (i = 0; i < attr_count; i++) {
             switch (attr_list[i].type) {
             case VASurfaceAttribPixelFormat:
                 fourcc = attr_list[i].value.value.i;
                 pix_fmt = vaapi_pix_fmt_from_fourcc(fourcc);
                 if (pix_fmt != AV_PIX_FMT_NONE) {
                     ++pix_fmt_count;
                 } else {
                     // Something unsupported - ignore.
                 }
                 break;
             case VASurfaceAttribMinWidth:
                 constraints->min_width  = attr_list[i].value.value.i;
                 break;
             case VASurfaceAttribMinHeight:
                 constraints->min_height = attr_list[i].value.value.i;
                 break;
             case VASurfaceAttribMaxWidth:
                 constraints->max_width  = attr_list[i].value.value.i;
                 break;
             case VASurfaceAttribMaxHeight:
                 constraints->max_height = attr_list[i].value.value.i;
                 break;
             }
         }
         if (pix_fmt_count == 0) {
             // Nothing usable found.  Presumably there exists something which
             // works, so leave the set null to indicate unknown.
             constraints->valid_sw_formats = NULL;
         } else {
             constraints->valid_sw_formats = av_malloc_array(pix_fmt_count + 1,
                                                             sizeof(pix_fmt));
             if (!constraints->valid_sw_formats) {
                 err = AVERROR(ENOMEM);
                 goto fail;
             }

             for (i = j = 0; i < attr_count; i++) {
                 if (attr_list[i].type != VASurfaceAttribPixelFormat)
                     continue;
                 fourcc = attr_list[i].value.value.i;
                 pix_fmt = vaapi_pix_fmt_from_fourcc(fourcc);
                 if (pix_fmt != AV_PIX_FMT_NONE)
                     constraints->valid_sw_formats[j++] = pix_fmt;

             }

             av_assert0(j == pix_fmt_count);
             constraints->valid_sw_formats[j] = AV_PIX_FMT_NONE;

         }
     } else {

         // No configuration supplied.
         // Return the full set of image formats known by the implementation.
         constraints->valid_sw_formats = av_malloc_array(ctx->nb_formats + 1,

                                                         sizeof(pix_fmt));
         if (!constraints->valid_sw_formats) {
             err = AVERROR(ENOMEM);
             goto fail;
         }

         for (i = 0; i < ctx->nb_formats; i++)
             constraints->valid_sw_formats[i] = ctx->formats[i].pix_fmt;
         constraints->valid_sw_formats[i] = AV_PIX_FMT_NONE;

     }
 
     constraints->valid_hw_formats = av_malloc_array(2, sizeof(pix_fmt));
     if (!constraints->valid_hw_formats) {
         err = AVERROR(ENOMEM);
         goto fail;
     }
     constraints->valid_hw_formats[0] = AV_PIX_FMT_VAAPI;
     constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE;
 
     err = 0;
 fail:
     av_freep(&attr_list);
     return err;
 }
 

 static const struct {
     const char *friendly_name;
     const char *match_string;
     unsigned int quirks;
 } vaapi_driver_quirks_table[] = {

 #if !VA_CHECK_VERSION(1, 0, 0)
     // The i965 driver did not conform before version 2.0.

     {
         "Intel i965 (Quick Sync)",
         "i965",
         AV_VAAPI_DRIVER_QUIRK_RENDER_PARAM_BUFFERS,
     },

 #endif

     {
         "Intel iHD",
         "ubit",
         AV_VAAPI_DRIVER_QUIRK_ATTRIB_MEMTYPE,
     },

     {
         "VDPAU wrapper",
         "Splitted-Desktop Systems VDPAU backend for VA-API",
         AV_VAAPI_DRIVER_QUIRK_SURFACE_ATTRIBUTES,
     },

 };
 

 static int vaapi_device_init(AVHWDeviceContext *hwdev)
 {
     VAAPIDeviceContext *ctx = hwdev->internal->priv;
     AVVAAPIDeviceContext *hwctx = hwdev->hwctx;
     VAImageFormat *image_list = NULL;
     VAStatus vas;

     const char *vendor_string;

     int err, i, image_count;

     enum AVPixelFormat pix_fmt;
     unsigned int fourcc;
 
     image_count = vaMaxNumImageFormats(hwctx->display);
     if (image_count <= 0) {
         err = AVERROR(EIO);
         goto fail;
     }
     image_list = av_malloc(image_count * sizeof(*image_list));
     if (!image_list) {
         err = AVERROR(ENOMEM);
         goto fail;
     }
     vas = vaQueryImageFormats(hwctx->display, image_list, &image_count);
     if (vas != VA_STATUS_SUCCESS) {
         err = AVERROR(EIO);
         goto fail;
     }
 
     ctx->formats  = av_malloc(image_count * sizeof(*ctx->formats));
     if (!ctx->formats) {
         err = AVERROR(ENOMEM);
         goto fail;
     }
     ctx->nb_formats = 0;
     for (i = 0; i < image_count; i++) {
         fourcc  = image_list[i].fourcc;
         pix_fmt = vaapi_pix_fmt_from_fourcc(fourcc);

         if (pix_fmt == AV_PIX_FMT_NONE) {
             av_log(hwdev, AV_LOG_DEBUG, "Format %#x -> unknown.\n",
                    fourcc);
         } else {

             av_log(hwdev, AV_LOG_DEBUG, "Format %#x -> %s.\n",
                    fourcc, av_get_pix_fmt_name(pix_fmt));
             ctx->formats[ctx->nb_formats].pix_fmt      = pix_fmt;
             ctx->formats[ctx->nb_formats].image_format = image_list[i];
             ++ctx->nb_formats;
         }
     }
 

     vendor_string = vaQueryVendorString(hwctx->display);
     if (vendor_string)
         av_log(hwdev, AV_LOG_VERBOSE, "VAAPI driver: %s.\n", vendor_string);
 

     if (hwctx->driver_quirks & AV_VAAPI_DRIVER_QUIRK_USER_SET) {

         av_log(hwdev, AV_LOG_VERBOSE, "Using quirks set by user (%#x).\n",
                hwctx->driver_quirks);

     } else {
         // Detect the driver in use and set quirk flags if necessary.
         hwctx->driver_quirks = 0;
         if (vendor_string) {
             for (i = 0; i < FF_ARRAY_ELEMS(vaapi_driver_quirks_table); i++) {
                 if (strstr(vendor_string,
                            vaapi_driver_quirks_table[i].match_string)) {

                     av_log(hwdev, AV_LOG_VERBOSE, "Matched driver string "
                            "as known nonstandard driver \"%s\", setting "
                            "quirks (%#x).\n",
                            vaapi_driver_quirks_table[i].friendly_name,
                            vaapi_driver_quirks_table[i].quirks);

                     hwctx->driver_quirks |=
                         vaapi_driver_quirks_table[i].quirks;
                     break;
                 }
             }
             if (!(i < FF_ARRAY_ELEMS(vaapi_driver_quirks_table))) {

                 av_log(hwdev, AV_LOG_VERBOSE, "Driver not found in known "
                        "nonstandard list, using standard behaviour.\n");

             }

         } else {
             av_log(hwdev, AV_LOG_VERBOSE, "Driver has no vendor string, "
                    "assuming standard behaviour.\n");

         }
     }
 

     av_free(image_list);
     return 0;
 fail:
     av_freep(&ctx->formats);
     av_free(image_list);
     return err;
 }
 
 static void vaapi_device_uninit(AVHWDeviceContext *hwdev)
 {
     VAAPIDeviceContext *ctx = hwdev->internal->priv;
 
     av_freep(&ctx->formats);
 }
 
 static void vaapi_buffer_free(void *opaque, uint8_t *data)
 {
     AVHWFramesContext     *hwfc = opaque;
     AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
     VASurfaceID surface_id;
     VAStatus vas;
 
     surface_id = (VASurfaceID)(uintptr_t)data;
 
     vas = vaDestroySurfaces(hwctx->display, &surface_id, 1);
     if (vas != VA_STATUS_SUCCESS) {
         av_log(hwfc, AV_LOG_ERROR, "Failed to destroy surface %#x: "
                "%d (%s).\n", surface_id, vas, vaErrorStr(vas));
     }
 }
 
 static AVBufferRef *vaapi_pool_alloc(void *opaque, int size)
 {
     AVHWFramesContext     *hwfc = opaque;
     VAAPIFramesContext     *ctx = hwfc->internal->priv;
     AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
     AVVAAPIFramesContext  *avfc = hwfc->hwctx;
     VASurfaceID surface_id;
     VAStatus vas;
     AVBufferRef *ref;
 

     if (hwfc->initial_pool_size > 0 &&
         avfc->nb_surfaces >= hwfc->initial_pool_size)
         return NULL;
 

     vas = vaCreateSurfaces(hwctx->display, ctx->rt_format,
                            hwfc->width, hwfc->height,
                            &surface_id, 1,
                            ctx->attributes, ctx->nb_attributes);
     if (vas != VA_STATUS_SUCCESS) {
         av_log(hwfc, AV_LOG_ERROR, "Failed to create surface: "
                "%d (%s).\n", vas, vaErrorStr(vas));
         return NULL;
     }
     av_log(hwfc, AV_LOG_DEBUG, "Created surface %#x.\n", surface_id);
 
     ref = av_buffer_create((uint8_t*)(uintptr_t)surface_id,
                            sizeof(surface_id), &vaapi_buffer_free,
                            hwfc, AV_BUFFER_FLAG_READONLY);
     if (!ref) {
         vaDestroySurfaces(hwctx->display, &surface_id, 1);
         return NULL;
     }
 
     if (hwfc->initial_pool_size > 0) {
         // This is a fixed-size pool, so we must still be in the initial
         // allocation sequence.
         av_assert0(avfc->nb_surfaces < hwfc->initial_pool_size);
         avfc->surface_ids[avfc->nb_surfaces] = surface_id;
         ++avfc->nb_surfaces;
     }
 
     return ref;
 }
 
 static int vaapi_frames_init(AVHWFramesContext *hwfc)
 {
     AVVAAPIFramesContext  *avfc = hwfc->hwctx;
     VAAPIFramesContext     *ctx = hwfc->internal->priv;
     AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;

     const VAAPIFormatDescriptor *desc;

     VAImageFormat *expected_format;
     AVBufferRef *test_surface = NULL;
     VASurfaceID test_surface_id;
     VAImage test_image;
     VAStatus vas;
     int err, i;
 

     desc = vaapi_format_from_pix_fmt(hwfc->sw_format);
     if (!desc) {

         av_log(hwfc, AV_LOG_ERROR, "Unsupported format: %s.\n",
                av_get_pix_fmt_name(hwfc->sw_format));
         return AVERROR(EINVAL);
     }
 
     if (!hwfc->pool) {

         if (!(hwctx->driver_quirks & AV_VAAPI_DRIVER_QUIRK_SURFACE_ATTRIBUTES)) {
             int need_memory_type = !(hwctx->driver_quirks & AV_VAAPI_DRIVER_QUIRK_ATTRIB_MEMTYPE);
             int need_pixel_format = 1;
             for (i = 0; i < avfc->nb_attributes; i++) {

                 if (avfc->attributes[i].type == VASurfaceAttribMemoryType)

                     need_memory_type  = 0;

                 if (avfc->attributes[i].type == VASurfaceAttribPixelFormat)

                     need_pixel_format = 0;
             }
             ctx->nb_attributes =
                 avfc->nb_attributes + need_memory_type + need_pixel_format;

             ctx->attributes = av_malloc(ctx->nb_attributes *

                                         sizeof(*ctx->attributes));

             if (!ctx->attributes) {
                 err = AVERROR(ENOMEM);
                 goto fail;
             }

             for (i = 0; i < avfc->nb_attributes; i++)
                 ctx->attributes[i] = avfc->attributes[i];
             if (need_memory_type) {
                 ctx->attributes[i++] = (VASurfaceAttrib) {
                     .type          = VASurfaceAttribMemoryType,
                     .flags         = VA_SURFACE_ATTRIB_SETTABLE,
                     .value.type    = VAGenericValueTypeInteger,
                     .value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_VA,
                 };
             }
             if (need_pixel_format) {
                 ctx->attributes[i++] = (VASurfaceAttrib) {
                     .type          = VASurfaceAttribPixelFormat,
                     .flags         = VA_SURFACE_ATTRIB_SETTABLE,
                     .value.type    = VAGenericValueTypeInteger,

                     .value.value.i = desc->fourcc,

                 };
             }
             av_assert0(i == ctx->nb_attributes);
         } else {
             ctx->attributes = NULL;
             ctx->nb_attributes = 0;

         }
 

         ctx->rt_format = desc->rt_format;

 
         if (hwfc->initial_pool_size > 0) {
             // This pool will be usable as a render target, so we need to store
             // all of the surface IDs somewhere that vaCreateContext() calls
             // will be able to access them.
             avfc->nb_surfaces = 0;
             avfc->surface_ids = av_malloc(hwfc->initial_pool_size *
                                           sizeof(*avfc->surface_ids));
             if (!avfc->surface_ids) {
                 err = AVERROR(ENOMEM);
                 goto fail;
             }
         } else {
             // This pool allows dynamic sizing, and will not be usable as a
             // render target.
             avfc->nb_surfaces = 0;
             avfc->surface_ids = NULL;
         }
 
         hwfc->internal->pool_internal =
             av_buffer_pool_init2(sizeof(VASurfaceID), hwfc,
                                  &vaapi_pool_alloc, NULL);
         if (!hwfc->internal->pool_internal) {
             av_log(hwfc, AV_LOG_ERROR, "Failed to create VAAPI surface pool.\n");
             err = AVERROR(ENOMEM);
             goto fail;
         }
     }
 
     // Allocate a single surface to test whether vaDeriveImage() is going
     // to work for the specific configuration.
     if (hwfc->pool) {
         test_surface = av_buffer_pool_get(hwfc->pool);
         if (!test_surface) {
             av_log(hwfc, AV_LOG_ERROR, "Unable to allocate a surface from "
                    "user-configured buffer pool.\n");
             err = AVERROR(ENOMEM);
             goto fail;
         }
     } else {
         test_surface = av_buffer_pool_get(hwfc->internal->pool_internal);
         if (!test_surface) {
             av_log(hwfc, AV_LOG_ERROR, "Unable to allocate a surface from "
                    "internal buffer pool.\n");
             err = AVERROR(ENOMEM);
             goto fail;
         }
     }
     test_surface_id = (VASurfaceID)(uintptr_t)test_surface->data;
 
     ctx->derive_works = 0;
 
     err = vaapi_get_image_format(hwfc->device_ctx,
                                  hwfc->sw_format, &expected_format);
     if (err == 0) {
         vas = vaDeriveImage(hwctx->display, test_surface_id, &test_image);
         if (vas == VA_STATUS_SUCCESS) {
             if (expected_format->fourcc == test_image.format.fourcc) {
                 av_log(hwfc, AV_LOG_DEBUG, "Direct mapping possible.\n");
                 ctx->derive_works = 1;
             } else {
                 av_log(hwfc, AV_LOG_DEBUG, "Direct mapping disabled: "
                        "derived image format %08x does not match "
                        "expected format %08x.\n",
                        expected_format->fourcc, test_image.format.fourcc);
             }
             vaDestroyImage(hwctx->display, test_image.image_id);
         } else {
             av_log(hwfc, AV_LOG_DEBUG, "Direct mapping disabled: "
                    "deriving image does not work: "
                    "%d (%s).\n", vas, vaErrorStr(vas));
         }
     } else {
         av_log(hwfc, AV_LOG_DEBUG, "Direct mapping disabled: "
                "image format is not supported.\n");
     }
 
     av_buffer_unref(&test_surface);
     return 0;
 
 fail:
     av_buffer_unref(&test_surface);
     av_freep(&avfc->surface_ids);
     av_freep(&ctx->attributes);
     return err;
 }
 
 static void vaapi_frames_uninit(AVHWFramesContext *hwfc)
 {
     AVVAAPIFramesContext *avfc = hwfc->hwctx;
     VAAPIFramesContext    *ctx = hwfc->internal->priv;
 
     av_freep(&avfc->surface_ids);
     av_freep(&ctx->attributes);
 }
 
 static int vaapi_get_buffer(AVHWFramesContext *hwfc, AVFrame *frame)
 {
     frame->buf[0] = av_buffer_pool_get(hwfc->pool);
     if (!frame->buf[0])
         return AVERROR(ENOMEM);
 
     frame->data[3] = frame->buf[0]->data;
     frame->format  = AV_PIX_FMT_VAAPI;
     frame->width   = hwfc->width;
     frame->height  = hwfc->height;
 
     return 0;
 }
 
 static int vaapi_transfer_get_formats(AVHWFramesContext *hwfc,
                                       enum AVHWFrameTransferDirection dir,
                                       enum AVPixelFormat **formats)
 {
     VAAPIDeviceContext *ctx = hwfc->device_ctx->internal->priv;

     enum AVPixelFormat *pix_fmts;
     int i, k, sw_format_available;

     sw_format_available = 0;
     for (i = 0; i < ctx->nb_formats; i++) {
         if (ctx->formats[i].pix_fmt == hwfc->sw_format)
             sw_format_available = 1;
     }

 
     pix_fmts = av_malloc((ctx->nb_formats + 1) * sizeof(*pix_fmts));
     if (!pix_fmts)
         return AVERROR(ENOMEM);
 

     if (sw_format_available) {
         pix_fmts[0] = hwfc->sw_format;
         k = 1;
     } else {
         k = 0;
     }

     for (i = 0; i < ctx->nb_formats; i++) {

         if (ctx->formats[i].pix_fmt == hwfc->sw_format)

             continue;
         av_assert0(k < ctx->nb_formats);
         pix_fmts[k++] = ctx->formats[i].pix_fmt;
     }
     pix_fmts[k] = AV_PIX_FMT_NONE;
 
     *formats = pix_fmts;
     return 0;
 }
 

 static void vaapi_unmap_frame(AVHWFramesContext *hwfc,
                               HWMapDescriptor *hwmap)

 {
     AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;

     VAAPIMapping           *map = hwmap->priv;

     VASurfaceID surface_id;
     VAStatus vas;
 

     surface_id = (VASurfaceID)(uintptr_t)hwmap->source->data[3];

     av_log(hwfc, AV_LOG_DEBUG, "Unmap surface %#x.\n", surface_id);
 
     vas = vaUnmapBuffer(hwctx->display, map->image.buf);
     if (vas != VA_STATUS_SUCCESS) {
         av_log(hwfc, AV_LOG_ERROR, "Failed to unmap image from surface "
                "%#x: %d (%s).\n", surface_id, vas, vaErrorStr(vas));
     }
 

     if ((map->flags & AV_HWFRAME_MAP_WRITE) &&
         !(map->flags & AV_HWFRAME_MAP_DIRECT)) {

         vas = vaPutImage(hwctx->display, surface_id, map->image.image_id,
                          0, 0, hwfc->width, hwfc->height,
                          0, 0, hwfc->width, hwfc->height);
         if (vas != VA_STATUS_SUCCESS) {
             av_log(hwfc, AV_LOG_ERROR, "Failed to write image to surface "
                    "%#x: %d (%s).\n", surface_id, vas, vaErrorStr(vas));
         }
     }
 
     vas = vaDestroyImage(hwctx->display, map->image.image_id);
     if (vas != VA_STATUS_SUCCESS) {
         av_log(hwfc, AV_LOG_ERROR, "Failed to destroy image from surface "
                "%#x: %d (%s).\n", surface_id, vas, vaErrorStr(vas));
     }
 
     av_free(map);
 }
 
 static int vaapi_map_frame(AVHWFramesContext *hwfc,
                            AVFrame *dst, const AVFrame *src, int flags)
 {
     AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
     VAAPIFramesContext *ctx = hwfc->internal->priv;
     VASurfaceID surface_id;

     const VAAPIFormatDescriptor *desc;

     VAImageFormat *image_format;

     VAAPIMapping *map;

     VAStatus vas;
     void *address = NULL;
     int err, i;
 
     surface_id = (VASurfaceID)(uintptr_t)src->data[3];
     av_log(hwfc, AV_LOG_DEBUG, "Map surface %#x.\n", surface_id);
 

     if (!ctx->derive_works && (flags & AV_HWFRAME_MAP_DIRECT)) {

         // Requested direct mapping but it is not possible.
         return AVERROR(EINVAL);
     }
     if (dst->format == AV_PIX_FMT_NONE)
         dst->format = hwfc->sw_format;

     if (dst->format != hwfc->sw_format && (flags & AV_HWFRAME_MAP_DIRECT)) {

         // Requested direct mapping but the formats do not match.
         return AVERROR(EINVAL);
     }
 
     err = vaapi_get_image_format(hwfc->device_ctx, dst->format, &image_format);
     if (err < 0) {
         // Requested format is not a valid output format.
         return AVERROR(EINVAL);
     }
 

     map = av_malloc(sizeof(*map));

     if (!map)
         return AVERROR(ENOMEM);

     map->flags = flags;

     map->image.image_id = VA_INVALID_ID;
 
     vas = vaSyncSurface(hwctx->display, surface_id);
     if (vas != VA_STATUS_SUCCESS) {
         av_log(hwfc, AV_LOG_ERROR, "Failed to sync surface "
                "%#x: %d (%s).\n", surface_id, vas, vaErrorStr(vas));
         err = AVERROR(EIO);
         goto fail;
     }
 
     // The memory which we map using derive need not be connected to the CPU
     // in a way conducive to fast access.  On Gen7-Gen9 Intel graphics, the
     // memory is mappable but not cached, so normal memcpy()-like access is
     // very slow to read it (but writing is ok).  It is possible to read much
     // faster with a copy routine which is aware of the limitation, but we
     // assume for now that the user is not aware of that and would therefore
     // prefer not to be given direct-mapped memory if they request read access.

     if (ctx->derive_works && dst->format == hwfc->sw_format &&
         ((flags & AV_HWFRAME_MAP_DIRECT) || !(flags & AV_HWFRAME_MAP_READ))) {

         vas = vaDeriveImage(hwctx->display, surface_id, &map->image);
         if (vas != VA_STATUS_SUCCESS) {
             av_log(hwfc, AV_LOG_ERROR, "Failed to derive image from "
                    "surface %#x: %d (%s).\n",
                    surface_id, vas, vaErrorStr(vas));
             err = AVERROR(EIO);
             goto fail;
         }
         if (map->image.format.fourcc != image_format->fourcc) {
             av_log(hwfc, AV_LOG_ERROR, "Derive image of surface %#x "
                    "is in wrong format: expected %#08x, got %#08x.\n",
                    surface_id, image_format->fourcc, map->image.format.fourcc);
             err = AVERROR(EIO);
             goto fail;
         }

         map->flags |= AV_HWFRAME_MAP_DIRECT;

     } else {
         vas = vaCreateImage(hwctx->display, image_format,
                             hwfc->width, hwfc->height, &map->image);
         if (vas != VA_STATUS_SUCCESS) {
             av_log(hwfc, AV_LOG_ERROR, "Failed to create image for "
                    "surface %#x: %d (%s).\n",
                    surface_id, vas, vaErrorStr(vas));
             err = AVERROR(EIO);
             goto fail;
         }

         if (!(flags & AV_HWFRAME_MAP_OVERWRITE)) {

             vas = vaGetImage(hwctx->display, surface_id, 0, 0,
                              hwfc->width, hwfc->height, map->image.image_id);
             if (vas != VA_STATUS_SUCCESS) {
                 av_log(hwfc, AV_LOG_ERROR, "Failed to read image from "
                        "surface %#x: %d (%s).\n",
                        surface_id, vas, vaErrorStr(vas));
                 err = AVERROR(EIO);
                 goto fail;
             }
         }
     }
 
     vas = vaMapBuffer(hwctx->display, map->image.buf, &address);
     if (vas != VA_STATUS_SUCCESS) {
         av_log(hwfc, AV_LOG_ERROR, "Failed to map image from surface "
                "%#x: %d (%s).\n", surface_id, vas, vaErrorStr(vas));
         err = AVERROR(EIO);
         goto fail;
     }
 

     err = ff_hwframe_map_create(src->hw_frames_ctx,
                                 dst, src, &vaapi_unmap_frame, map);
     if (err < 0)
         goto fail;
 

     dst->width  = src->width;
     dst->height = src->height;
 
     for (i = 0; i < map->image.num_planes; i++) {
         dst->data[i] = (uint8_t*)address + map->image.offsets[i];
         dst->linesize[i] = map->image.pitches[i];
     }

 
     desc = vaapi_format_from_fourcc(map->image.format.fourcc);
     if (desc && desc->chroma_planes_swapped) {

         // Chroma planes are YVU rather than YUV, so swap them.
         FFSWAP(uint8_t*, dst->data[1], dst->data[2]);
     }
 
     return 0;
 
 fail:
     if (map) {
         if (address)
             vaUnmapBuffer(hwctx->display, map->image.buf);
         if (map->image.image_id != VA_INVALID_ID)
             vaDestroyImage(hwctx->display, map->image.image_id);
         av_free(map);
     }
     return err;
 }
 
 static int vaapi_transfer_data_from(AVHWFramesContext *hwfc,
                                     AVFrame *dst, const AVFrame *src)
 {
     AVFrame *map;
     int err;
 

     if (dst->width > hwfc->width || dst->height > hwfc->height)
         return AVERROR(EINVAL);
 

     map = av_frame_alloc();
     if (!map)
         return AVERROR(ENOMEM);
     map->format = dst->format;
 

     err = vaapi_map_frame(hwfc, map, src, AV_HWFRAME_MAP_READ);

     if (err)
         goto fail;
 

     map->width  = dst->width;
     map->height = dst->height;
 

     err = av_frame_copy(dst, map);
     if (err)
         goto fail;
 
     err = 0;
 fail:
     av_frame_free(&map);
     return err;
 }
 
 static int vaapi_transfer_data_to(AVHWFramesContext *hwfc,
                                   AVFrame *dst, const AVFrame *src)
 {
     AVFrame *map;
     int err;
 

     if (src->width > hwfc->width || src->height > hwfc->height)
         return AVERROR(EINVAL);
 

     map = av_frame_alloc();
     if (!map)
         return AVERROR(ENOMEM);
     map->format = src->format;
 

     err = vaapi_map_frame(hwfc, map, dst, AV_HWFRAME_MAP_WRITE | AV_HWFRAME_MAP_OVERWRITE);

     if (err)
         goto fail;
 

     map->width  = src->width;
     map->height = src->height;
 

     err = av_frame_copy(map, src);
     if (err)
         goto fail;
 
     err = 0;
 fail:
     av_frame_free(&map);
     return err;
 }
 

 static int vaapi_map_to_memory(AVHWFramesContext *hwfc, AVFrame *dst,
                                const AVFrame *src, int flags)

 {
     int err;
 
     if (dst->format != AV_PIX_FMT_NONE) {
         err = vaapi_get_image_format(hwfc->device_ctx, dst->format, NULL);
         if (err < 0)
             return AVERROR(ENOSYS);
     }
 
     err = vaapi_map_frame(hwfc, dst, src, flags);
     if (err)
         return err;
 
     err = av_frame_copy_props(dst, src);
     if (err)
         return err;
 
     return 0;
 }
 

 #if CONFIG_LIBDRM
 
 #define DRM_MAP(va, layers, ...) { \
         VA_FOURCC_ ## va, \
         layers, \
         { __VA_ARGS__ } \
     }
 static const struct {
     uint32_t va_fourcc;
     int   nb_layer_formats;
     uint32_t layer_formats[AV_DRM_MAX_PLANES];
 } vaapi_drm_format_map[] = {

 #ifdef DRM_FORMAT_R8

     DRM_MAP(NV12, 2, DRM_FORMAT_R8,  DRM_FORMAT_RG88),

 #endif

     DRM_MAP(NV12, 1, DRM_FORMAT_NV12),

 #if defined(VA_FOURCC_P010) && defined(DRM_FORMAT_R16)

     DRM_MAP(P010, 2, DRM_FORMAT_R16, DRM_FORMAT_RG1616),
 #endif

     DRM_MAP(BGRA, 1, DRM_FORMAT_ARGB8888),
     DRM_MAP(BGRX, 1, DRM_FORMAT_XRGB8888),
     DRM_MAP(RGBA, 1, DRM_FORMAT_ABGR8888),
     DRM_MAP(RGBX, 1, DRM_FORMAT_XBGR8888),

 #ifdef VA_FOURCC_ABGR

     DRM_MAP(ABGR, 1, DRM_FORMAT_RGBA8888),
     DRM_MAP(XBGR, 1, DRM_FORMAT_RGBX8888),

 #endif

     DRM_MAP(ARGB, 1, DRM_FORMAT_BGRA8888),
     DRM_MAP(XRGB, 1, DRM_FORMAT_BGRX8888),

 };
 #undef DRM_MAP
 
 static void vaapi_unmap_from_drm(AVHWFramesContext *dst_fc,
                                  HWMapDescriptor *hwmap)
 {
     AVVAAPIDeviceContext *dst_dev = dst_fc->device_ctx->hwctx;
 
     VASurfaceID surface_id = (VASurfaceID)(uintptr_t)hwmap->priv;
 
     av_log(dst_fc, AV_LOG_DEBUG, "Destroy surface %#x.\n", surface_id);
 
     vaDestroySurfaces(dst_dev->display, &surface_id, 1);
 }
 
 static int vaapi_map_from_drm(AVHWFramesContext *src_fc, AVFrame *dst,
                               const AVFrame *src, int flags)
 {
     AVHWFramesContext      *dst_fc =
         (AVHWFramesContext*)dst->hw_frames_ctx->data;
     AVVAAPIDeviceContext  *dst_dev = dst_fc->device_ctx->hwctx;
     const AVDRMFrameDescriptor *desc;

     const VAAPIFormatDescriptor *format_desc;

     VASurfaceID surface_id;
     VAStatus vas;

     uint32_t va_fourcc;

     int err, i, j, k;
 
     unsigned long buffer_handle;
     VASurfaceAttribExternalBuffers buffer_desc;
     VASurfaceAttrib attrs[2] = {
         {
             .type  = VASurfaceAttribMemoryType,
             .flags = VA_SURFACE_ATTRIB_SETTABLE,
             .value.type    = VAGenericValueTypeInteger,
             .value.value.i = VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME,
         },
         {
             .type  = VASurfaceAttribExternalBufferDescriptor,
             .flags = VA_SURFACE_ATTRIB_SETTABLE,
             .value.type    = VAGenericValueTypePointer,
             .value.value.p = &buffer_desc,
         }
     };
 
     desc = (AVDRMFrameDescriptor*)src->data[0];
 
     if (desc->nb_objects != 1) {
         av_log(dst_fc, AV_LOG_ERROR, "VAAPI can only map frames "
                "made from a single DRM object.\n");
         return AVERROR(EINVAL);
     }
 
     va_fourcc = 0;
     for (i = 0; i < FF_ARRAY_ELEMS(vaapi_drm_format_map); i++) {
         if (desc->nb_layers != vaapi_drm_format_map[i].nb_layer_formats)
             continue;
         for (j = 0; j < desc->nb_layers; j++) {
             if (desc->layers[j].format !=
                 vaapi_drm_format_map[i].layer_formats[j])
                 break;
         }
         if (j != desc->nb_layers)
             continue;
         va_fourcc = vaapi_drm_format_map[i].va_fourcc;
         break;
     }
     if (!va_fourcc) {
         av_log(dst_fc, AV_LOG_ERROR, "DRM format not supported "
                "by VAAPI.\n");
         return AVERROR(EINVAL);
     }
 
     av_log(dst_fc, AV_LOG_DEBUG, "Map DRM object %d to VAAPI as "
            "%08x.\n", desc->objects[0].fd, va_fourcc);
 

     format_desc = vaapi_format_from_fourcc(va_fourcc);
     av_assert0(format_desc);

     buffer_handle = desc->objects[0].fd;
     buffer_desc.pixel_format = va_fourcc;
     buffer_desc.width        = src_fc->width;
     buffer_desc.height       = src_fc->height;
     buffer_desc.data_size    = desc->objects[0].size;
     buffer_desc.buffers      = &buffer_handle;
     buffer_desc.num_buffers  = 1;
     buffer_desc.flags        = 0;
 
     k = 0;
     for (i = 0; i < desc->nb_layers; i++) {
         for (j = 0; j < desc->layers[i].nb_planes; j++) {
             buffer_desc.pitches[k] = desc->layers[i].planes[j].pitch;
             buffer_desc.offsets[k] = desc->layers[i].planes[j].offset;
             ++k;
         }
     }
     buffer_desc.num_planes = k;
 

     if (format_desc->chroma_planes_swapped &&
         buffer_desc.num_planes == 3) {
         FFSWAP(uint32_t, buffer_desc.pitches[1], buffer_desc.pitches[2]);
         FFSWAP(uint32_t, buffer_desc.offsets[1], buffer_desc.offsets[2]);
     }
 
     vas = vaCreateSurfaces(dst_dev->display, format_desc->rt_format,

                            src->width, src->height,
                            &surface_id, 1,
                            attrs, FF_ARRAY_ELEMS(attrs));
     if (vas != VA_STATUS_SUCCESS) {
         av_log(dst_fc, AV_LOG_ERROR, "Failed to create surface from DRM "
                "object: %d (%s).\n", vas, vaErrorStr(vas));
         return AVERROR(EIO);
     }
     av_log(dst_fc, AV_LOG_DEBUG, "Create surface %#x.\n", surface_id);
 
     err = ff_hwframe_map_create(dst->hw_frames_ctx, dst, src,
                                 &vaapi_unmap_from_drm,
                                 (void*)(uintptr_t)surface_id);
     if (err < 0)
         return err;
 
     dst->width   = src->width;
     dst->height  = src->height;
     dst->data[3] = (uint8_t*)(uintptr_t)surface_id;
 
     av_log(dst_fc, AV_LOG_DEBUG, "Mapped DRM object %d to "
            "surface %#x.\n", desc->objects[0].fd, surface_id);
 
     return 0;
 }

 #if VA_CHECK_VERSION(1, 1, 0)
 static void vaapi_unmap_to_drm_esh(AVHWFramesContext *hwfc,
                                    HWMapDescriptor *hwmap)

 {
     AVDRMFrameDescriptor *drm_desc = hwmap->priv;
     int i;
 
     for (i = 0; i < drm_desc->nb_objects; i++)
         close(drm_desc->objects[i].fd);
 
     av_freep(&drm_desc);
 }
 

 static int vaapi_map_to_drm_esh(AVHWFramesContext *hwfc, AVFrame *dst,
                                 const AVFrame *src, int flags)

 {
     AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
     VASurfaceID surface_id;
     VAStatus vas;
     VADRMPRIMESurfaceDescriptor va_desc;
     AVDRMFrameDescriptor *drm_desc = NULL;

     uint32_t export_flags;

     int err, i, j;
 
     surface_id = (VASurfaceID)(uintptr_t)src->data[3];
 

     export_flags = VA_EXPORT_SURFACE_SEPARATE_LAYERS;
     if (flags & AV_HWFRAME_MAP_READ)
         export_flags |= VA_EXPORT_SURFACE_READ_ONLY;
     if (flags & AV_HWFRAME_MAP_WRITE)
         export_flags |= VA_EXPORT_SURFACE_WRITE_ONLY;
 

     vas = vaExportSurfaceHandle(hwctx->display, surface_id,
                                 VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME_2,

                                 export_flags, &va_desc);

     if (vas != VA_STATUS_SUCCESS) {
         if (vas == VA_STATUS_ERROR_UNIMPLEMENTED)
             return AVERROR(ENOSYS);
         av_log(hwfc, AV_LOG_ERROR, "Failed to export surface %#x: "
                "%d (%s).\n", surface_id, vas, vaErrorStr(vas));
         return AVERROR(EIO);
     }
 
     drm_desc = av_mallocz(sizeof(*drm_desc));
     if (!drm_desc) {
         err = AVERROR(ENOMEM);
         goto fail;
     }
 
     // By some bizarre coincidence, these structures are very similar...
     drm_desc->nb_objects = va_desc.num_objects;
     for (i = 0; i < va_desc.num_objects; i++) {
         drm_desc->objects[i].fd   = va_desc.objects[i].fd;
         drm_desc->objects[i].size = va_desc.objects[i].size;
         drm_desc->objects[i].format_modifier =
             va_desc.objects[i].drm_format_modifier;
     }
     drm_desc->nb_layers = va_desc.num_layers;
     for (i = 0; i < va_desc.num_layers; i++) {
         drm_desc->layers[i].format    = va_desc.layers[i].drm_format;
         drm_desc->layers[i].nb_planes = va_desc.layers[i].num_planes;
         for (j = 0; j < va_desc.layers[i].num_planes; j++) {
             drm_desc->layers[i].planes[j].object_index =
                 va_desc.layers[i].object_index[j];
             drm_desc->layers[i].planes[j].offset =
                 va_desc.layers[i].offset[j];
             drm_desc->layers[i].planes[j].pitch =
                 va_desc.layers[i].pitch[j];
         }
     }
 
     err = ff_hwframe_map_create(src->hw_frames_ctx, dst, src,

                                 &vaapi_unmap_to_drm_esh, drm_desc);

     if (err < 0)
         goto fail;
 
     dst->width   = src->width;
     dst->height  = src->height;
     dst->data[0] = (uint8_t*)drm_desc;
 
     return 0;
 
 fail:
     for (i = 0; i < va_desc.num_objects; i++)
         close(va_desc.objects[i].fd);
     av_freep(&drm_desc);
     return err;

 }

 #endif

 #if VA_CHECK_VERSION(0, 36, 0)

 typedef struct VAAPIDRMImageBufferMapping {
     VAImage      image;
     VABufferInfo buffer_info;
 
     AVDRMFrameDescriptor drm_desc;
 } VAAPIDRMImageBufferMapping;
 
 static void vaapi_unmap_to_drm_abh(AVHWFramesContext *hwfc,
                                   HWMapDescriptor *hwmap)
 {
     AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
     VAAPIDRMImageBufferMapping *mapping = hwmap->priv;
     VASurfaceID surface_id;
     VAStatus vas;
 
     surface_id = (VASurfaceID)(uintptr_t)hwmap->source->data[3];
     av_log(hwfc, AV_LOG_DEBUG, "Unmap VAAPI surface %#x from DRM.\n",
            surface_id);
 
     // DRM PRIME file descriptors are closed by vaReleaseBufferHandle(),
     // so we shouldn't close them separately.
 
     vas = vaReleaseBufferHandle(hwctx->display, mapping->image.buf);
     if (vas != VA_STATUS_SUCCESS) {
         av_log(hwfc, AV_LOG_ERROR, "Failed to release buffer "
                "handle of image %#x (derived from surface %#x): "
                "%d (%s).\n", mapping->image.buf, surface_id,
                vas, vaErrorStr(vas));
     }
 
     vas = vaDestroyImage(hwctx->display, mapping->image.image_id);
     if (vas != VA_STATUS_SUCCESS) {
         av_log(hwfc, AV_LOG_ERROR, "Failed to destroy image "
                "derived from surface %#x: %d (%s).\n",
                surface_id, vas, vaErrorStr(vas));
     }
 
     av_free(mapping);
 }
 
 static int vaapi_map_to_drm_abh(AVHWFramesContext *hwfc, AVFrame *dst,
                                 const AVFrame *src, int flags)
 {
     AVVAAPIDeviceContext *hwctx = hwfc->device_ctx->hwctx;
     VAAPIDRMImageBufferMapping *mapping = NULL;
     VASurfaceID surface_id;
     VAStatus vas;
     int err, i, p;
 
     surface_id = (VASurfaceID)(uintptr_t)src->data[3];
     av_log(hwfc, AV_LOG_DEBUG, "Map VAAPI surface %#x to DRM.\n",
            surface_id);
 
     mapping = av_mallocz(sizeof(*mapping));
     if (!mapping)
         return AVERROR(ENOMEM);
 
     vas = vaDeriveImage(hwctx->display, surface_id,
                         &mapping->image);
     if (vas != VA_STATUS_SUCCESS) {
         av_log(hwfc, AV_LOG_ERROR, "Failed to derive image from "
                "surface %#x: %d (%s).\n",
                surface_id, vas, vaErrorStr(vas));
         err = AVERROR(EIO);
         goto fail;
     }
 
     for (i = 0; i < FF_ARRAY_ELEMS(vaapi_drm_format_map); i++) {
         if (vaapi_drm_format_map[i].va_fourcc ==
             mapping->image.format.fourcc)
             break;
     }
     if (i >= FF_ARRAY_ELEMS(vaapi_drm_format_map)) {
         av_log(hwfc, AV_LOG_ERROR, "No matching DRM format for "
                "VAAPI format %#x.\n", mapping->image.format.fourcc);
         err = AVERROR(EINVAL);
         goto fail_derived;
     }
 
     mapping->buffer_info.mem_type =
         VA_SURFACE_ATTRIB_MEM_TYPE_DRM_PRIME;
 
     mapping->drm_desc.nb_layers =
         vaapi_drm_format_map[i].nb_layer_formats;
     if (mapping->drm_desc.nb_layers > 1) {
         if (mapping->drm_desc.nb_layers != mapping->image.num_planes) {
             av_log(hwfc, AV_LOG_ERROR, "Image properties do not match "
                    "expected format: got %d planes, but expected %d.\n",
                    mapping->image.num_planes, mapping->drm_desc.nb_layers);
             err = AVERROR(EINVAL);
             goto fail_derived;
         }
 
         for(p = 0; p < mapping->drm_desc.nb_layers; p++) {
             mapping->drm_desc.layers[p] = (AVDRMLayerDescriptor) {
                 .format    = vaapi_drm_format_map[i].layer_formats[p],
                 .nb_planes = 1,
                 .planes[0] = {
                     .object_index = 0,
                     .offset       = mapping->image.offsets[p],
                     .pitch        = mapping->image.pitches[p],
                 },
             };
         }
     } else {
         mapping->drm_desc.layers[0].format =
             vaapi_drm_format_map[i].layer_formats[0];
         mapping->drm_desc.layers[0].nb_planes = mapping->image.num_planes;
         for (p = 0; p < mapping->image.num_planes; p++) {
             mapping->drm_desc.layers[0].planes[p] = (AVDRMPlaneDescriptor) {
                 .object_index = 0,
                 .offset       = mapping->image.offsets[p],
                 .pitch        = mapping->image.pitches[p],
             };
         }
     }
 
     vas = vaAcquireBufferHandle(hwctx->display, mapping->image.buf,
                                 &mapping->buffer_info);
     if (vas != VA_STATUS_SUCCESS) {
         av_log(hwfc, AV_LOG_ERROR, "Failed to get buffer "
                "handle from image %#x (derived from surface %#x): "
                "%d (%s).\n", mapping->image.buf, surface_id,
                vas, vaErrorStr(vas));
         err = AVERROR(EIO);
         goto fail_derived;
     }
 
     av_log(hwfc, AV_LOG_DEBUG, "DRM PRIME fd is %ld.\n",
            mapping->buffer_info.handle);
 
     mapping->drm_desc.nb_objects = 1;
     mapping->drm_desc.objects[0] = (AVDRMObjectDescriptor) {
         .fd   = mapping->buffer_info.handle,
         .size = mapping->image.data_size,
         // There is no way to get the format modifier with this API.
         .format_modifier = DRM_FORMAT_MOD_INVALID,
     };
 
     err = ff_hwframe_map_create(src->hw_frames_ctx,
                                 dst, src, &vaapi_unmap_to_drm_abh,
                                 mapping);
     if (err < 0)
         goto fail_mapped;
 
     dst->data[0] = (uint8_t*)&mapping->drm_desc;
     dst->width   = src->width;
     dst->height  = src->height;
 
     return 0;
 
 fail_mapped:
     vaReleaseBufferHandle(hwctx->display, mapping->image.buf);
 fail_derived:
     vaDestroyImage(hwctx->display, mapping->image.image_id);
 fail:
     av_freep(&mapping);
     return err;

 }

 #endif

 
 static int vaapi_map_to_drm(AVHWFramesContext *hwfc, AVFrame *dst,
                             const AVFrame *src, int flags)
 {
 #if VA_CHECK_VERSION(1, 1, 0)
     int err;
     err = vaapi_map_to_drm_esh(hwfc, dst, src, flags);
     if (err != AVERROR(ENOSYS))
         return err;

 #endif

 #if VA_CHECK_VERSION(0, 36, 0)

     return vaapi_map_to_drm_abh(hwfc, dst, src, flags);

 #endif
     return AVERROR(ENOSYS);

 }
 
 #endif /* CONFIG_LIBDRM */

 
 static int vaapi_map_to(AVHWFramesContext *hwfc, AVFrame *dst,
                         const AVFrame *src, int flags)
 {
     switch (src->format) {
 #if CONFIG_LIBDRM
     case AV_PIX_FMT_DRM_PRIME:
         return vaapi_map_from_drm(hwfc, dst, src, flags);
 #endif
     default:
         return AVERROR(ENOSYS);
     }
 }
 

 static int vaapi_map_from(AVHWFramesContext *hwfc, AVFrame *dst,
                           const AVFrame *src, int flags)
 {
     switch (dst->format) {
 #if CONFIG_LIBDRM
     case AV_PIX_FMT_DRM_PRIME:
         return vaapi_map_to_drm(hwfc, dst, src, flags);
 #endif
     default:
         return vaapi_map_to_memory(hwfc, dst, src, flags);
     }
 }
 

 static void vaapi_device_free(AVHWDeviceContext *ctx)
 {
     AVVAAPIDeviceContext *hwctx = ctx->hwctx;
     VAAPIDevicePriv      *priv  = ctx->user_opaque;
 
     if (hwctx->display)
         vaTerminate(hwctx->display);
 
 #if HAVE_VAAPI_X11
     if (priv->x11_display)
         XCloseDisplay(priv->x11_display);
 #endif
 
     if (priv->drm_fd >= 0)
         close(priv->drm_fd);
 
     av_freep(&priv);
 }
 

 #if CONFIG_VAAPI_1
 static void vaapi_device_log_error(void *context, const char *message)
 {
     AVHWDeviceContext *ctx = context;
 
     av_log(ctx, AV_LOG_ERROR, "libva: %s", message);
 }
 
 static void vaapi_device_log_info(void *context, const char *message)
 {
     AVHWDeviceContext *ctx = context;
 
     av_log(ctx, AV_LOG_VERBOSE, "libva: %s", message);
 }
 #endif
 

 static int vaapi_device_connect(AVHWDeviceContext *ctx,
                                 VADisplay display)
 {
     AVVAAPIDeviceContext *hwctx = ctx->hwctx;
     int major, minor;
     VAStatus vas;
 

 #if CONFIG_VAAPI_1
     vaSetErrorCallback(display, &vaapi_device_log_error, ctx);
     vaSetInfoCallback (display, &vaapi_device_log_info,  ctx);
 #endif
 

     hwctx->display = display;
 
     vas = vaInitialize(display, &major, &minor);
     if (vas != VA_STATUS_SUCCESS) {
         av_log(ctx, AV_LOG_ERROR, "Failed to initialise VAAPI "
                "connection: %d (%s).\n", vas, vaErrorStr(vas));
         return AVERROR(EIO);
     }
     av_log(ctx, AV_LOG_VERBOSE, "Initialised VAAPI connection: "
            "version %d.%d\n", major, minor);
 
     return 0;
 }
 

 static int vaapi_device_create(AVHWDeviceContext *ctx, const char *device,
                                AVDictionary *opts, int flags)
 {
     VAAPIDevicePriv *priv;

     VADisplay display = NULL;

     const AVDictionaryEntry *ent;
     int try_drm, try_x11, try_all;

 
     priv = av_mallocz(sizeof(*priv));
     if (!priv)
         return AVERROR(ENOMEM);
 
     priv->drm_fd = -1;
 
     ctx->user_opaque = priv;
     ctx->free        = vaapi_device_free;
 

     ent = av_dict_get(opts, "connection_type", NULL, 0);
     if (ent) {
         try_all = try_drm = try_x11 = 0;
         if (!strcmp(ent->value, "drm")) {
             try_drm = 1;
         } else if (!strcmp(ent->value, "x11")) {
             try_x11 = 1;
         } else {
             av_log(ctx, AV_LOG_ERROR, "Invalid connection type %s.\n",
                    ent->value);
             return AVERROR(EINVAL);
         }
     } else {
         try_all = 1;
         try_drm = HAVE_VAAPI_DRM;
         try_x11 = HAVE_VAAPI_X11;
     }
 

 #if HAVE_VAAPI_DRM

     while (!display && try_drm) {
         // If the device is specified, try to open it as a DRM device node.
         // If not, look for a usable render node, possibly restricted to those
         // using a specified kernel driver.
         int loglevel = try_all ? AV_LOG_VERBOSE : AV_LOG_ERROR;
         if (device) {
             priv->drm_fd = open(device, O_RDWR);
             if (priv->drm_fd < 0) {
                 av_log(ctx, loglevel, "Failed to open %s as "
                        "DRM device node.\n", device);
                 break;
             }

         } else {

             char path[64];
             int n, max_devices = 8;

 #if CONFIG_LIBDRM
             const AVDictionaryEntry *kernel_driver;

             kernel_driver = av_dict_get(opts, "kernel_driver", NULL, 0);

 #endif

             for (n = 0; n < max_devices; n++) {
                 snprintf(path, sizeof(path),
                          "/dev/dri/renderD%d", 128 + n);
                 priv->drm_fd = open(path, O_RDWR);
                 if (priv->drm_fd < 0) {
                     av_log(ctx, AV_LOG_VERBOSE, "Cannot open "
                            "DRM render node for device %d.\n", n);
                     break;
                 }
 #if CONFIG_LIBDRM
                 if (kernel_driver) {
                     drmVersion *info;
                     info = drmGetVersion(priv->drm_fd);
                     if (strcmp(kernel_driver->value, info->name)) {
                         av_log(ctx, AV_LOG_VERBOSE, "Ignoring device %d "
                                "with non-matching kernel driver (%s).\n",
                                n, info->name);
                         drmFreeVersion(info);
                         close(priv->drm_fd);
                         priv->drm_fd = -1;
                         continue;
                     }
                     av_log(ctx, AV_LOG_VERBOSE, "Trying to use "
                            "DRM render node for device %d, "
                            "with matching kernel driver (%s).\n",
                            n, info->name);
                     drmFreeVersion(info);
                 } else
 #endif
                 {
                     av_log(ctx, AV_LOG_VERBOSE, "Trying to use "
                            "DRM render node for device %d.\n", n);
                 }
                 break;

             }

             if (n >= max_devices)
                 break;
         }

         display = vaGetDisplayDRM(priv->drm_fd);
         if (!display) {
             av_log(ctx, AV_LOG_VERBOSE, "Cannot open a VA display "
                    "from DRM device %s.\n", device);
             return AVERROR_EXTERNAL;

         }

         break;

     }
 #endif
 

 #if HAVE_VAAPI_X11
     if (!display && try_x11) {
         // Try to open the device as an X11 display.
         priv->x11_display = XOpenDisplay(device);
         if (!priv->x11_display) {
             av_log(ctx, AV_LOG_VERBOSE, "Cannot open X11 display "
                    "%s.\n", XDisplayName(device));
         } else {
             display = vaGetDisplay(priv->x11_display);
             if (!display) {
                 av_log(ctx, AV_LOG_ERROR, "Cannot open a VA display "
                        "from X11 display %s.\n", XDisplayName(device));
                 return AVERROR_UNKNOWN;
             }
 
             av_log(ctx, AV_LOG_VERBOSE, "Opened VA display via "
                    "X11 display %s.\n", XDisplayName(device));
         }
     }
 #endif
 

     if (!display) {

         if (device)
             av_log(ctx, AV_LOG_ERROR, "No VA display found for "
                    "device %s.\n", device);
         else
             av_log(ctx, AV_LOG_ERROR, "No VA display found for "
                    "any default device.\n");

         return AVERROR(EINVAL);
     }
 

     ent = av_dict_get(opts, "driver", NULL, 0);
     if (ent) {
 #if VA_CHECK_VERSION(0, 38, 0)
         VAStatus vas;
         vas = vaSetDriverName(display, ent->value);
         if (vas != VA_STATUS_SUCCESS) {
             av_log(ctx, AV_LOG_ERROR, "Failed to set driver name to "
                    "%s: %d (%s).\n", ent->value, vas, vaErrorStr(vas));
             vaTerminate(display);
             return AVERROR_EXTERNAL;
         }
 #else
         av_log(ctx, AV_LOG_WARNING, "Driver name setting is not "
                "supported with this VAAPI version.\n");
 #endif
     }
 

     return vaapi_device_connect(ctx, display);

 }
 

 static int vaapi_device_derive(AVHWDeviceContext *ctx,

                                AVHWDeviceContext *src_ctx,
                                AVDictionary *opts, int flags)

 {

 #if HAVE_VAAPI_DRM

     if (src_ctx->type == AV_HWDEVICE_TYPE_DRM) {
         AVDRMDeviceContext *src_hwctx = src_ctx->hwctx;
         VADisplay *display;
         VAAPIDevicePriv *priv;

         int fd;

 
         if (src_hwctx->fd < 0) {
             av_log(ctx, AV_LOG_ERROR, "DRM instance requires an associated "
                    "device to derive a VA display from.\n");
             return AVERROR(EINVAL);
         }
 

 #if CONFIG_LIBDRM
         {
             int node_type = drmGetNodeTypeFromFd(src_hwctx->fd);
             char *render_node;
             if (node_type < 0) {
                 av_log(ctx, AV_LOG_ERROR, "DRM instance fd does not appear "
                        "to refer to a DRM device.\n");
                 return AVERROR(EINVAL);
             }
             if (node_type == DRM_NODE_RENDER) {
                 fd = src_hwctx->fd;
             } else {
                 render_node = drmGetRenderDeviceNameFromFd(src_hwctx->fd);
                 if (!render_node) {
                     av_log(ctx, AV_LOG_ERROR, "Failed to find a render node "
                            "matching the DRM device.\n");
                     return AVERROR(ENODEV);
                 }
                 fd = open(render_node, O_RDWR);
                 if (fd < 0) {
                     av_log(ctx, AV_LOG_ERROR, "Failed to open render node %s"
                            "matching the DRM device.\n", render_node);
                     free(render_node);
                     return AVERROR(errno);
                 }
                 av_log(ctx, AV_LOG_VERBOSE, "Using render node %s in place "
                        "of non-render DRM device.\n", render_node);
                 free(render_node);
             }
         }
 #else
         fd = src_hwctx->fd;
 #endif
 

         priv = av_mallocz(sizeof(*priv));
         if (!priv)
             return AVERROR(ENOMEM);
 

         if (fd == src_hwctx->fd) {
             // The fd is inherited from the source context and we are holding
             // a reference to that, we don't want to close it from here.
             priv->drm_fd = -1;
         } else {
             priv->drm_fd = fd;
         }

 
         ctx->user_opaque = priv;
         ctx->free        = &vaapi_device_free;
 

         display = vaGetDisplayDRM(fd);

         if (!display) {
             av_log(ctx, AV_LOG_ERROR, "Failed to open a VA display from "
                    "DRM device.\n");
             return AVERROR(EIO);
         }
 

         return vaapi_device_connect(ctx, display);

     }
 #endif
     return AVERROR(ENOSYS);
 }
 

 const HWContextType ff_hwcontext_type_vaapi = {
     .type                   = AV_HWDEVICE_TYPE_VAAPI,
     .name                   = "VAAPI",
 
     .device_hwctx_size      = sizeof(AVVAAPIDeviceContext),
     .device_priv_size       = sizeof(VAAPIDeviceContext),
     .device_hwconfig_size   = sizeof(AVVAAPIHWConfig),
     .frames_hwctx_size      = sizeof(AVVAAPIFramesContext),
     .frames_priv_size       = sizeof(VAAPIFramesContext),
 

     .device_create          = &vaapi_device_create,

     .device_derive          = &vaapi_device_derive,

     .device_init            = &vaapi_device_init,
     .device_uninit          = &vaapi_device_uninit,
     .frames_get_constraints = &vaapi_frames_get_constraints,
     .frames_init            = &vaapi_frames_init,
     .frames_uninit          = &vaapi_frames_uninit,
     .frames_get_buffer      = &vaapi_get_buffer,
     .transfer_get_formats   = &vaapi_transfer_get_formats,
     .transfer_data_to       = &vaapi_transfer_data_to,
     .transfer_data_from     = &vaapi_transfer_data_from,

     .map_to                 = &vaapi_map_to,

     .map_from               = &vaapi_map_from,

 
     .pix_fmts = (const enum AVPixelFormat[]) {
         AV_PIX_FMT_VAAPI,
         AV_PIX_FMT_NONE
     },
 };