git.sesse.net Git - ffmpeg/blob - libavutil/hwcontext_vaapi.c

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