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

   1 /*
   2  * This file is part of FFmpeg.
   3  *
   4  * FFmpeg is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * FFmpeg is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with FFmpeg; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 #include "config.h"
  20
  21 #include <windows.h>
  22
  23 #define COBJMACROS
  24
  25 #include <initguid.h>
  26 #include <d3d11.h>
  27 #include <dxgi1_2.h>
  28
  29 #if HAVE_DXGIDEBUG_H
  30 #include <dxgidebug.h>
  31 #endif
  32
  33 #include "avassert.h"
  34 #include "common.h"
  35 #include "hwcontext.h"
  36 #include "hwcontext_d3d11va.h"
  37 #include "hwcontext_internal.h"
  38 #include "imgutils.h"
  39 #include "pixdesc.h"
  40 #include "pixfmt.h"
  41 #include "thread.h"
  42 #include "compat/w32dlfcn.h"
  43
  44 typedef HRESULT(WINAPI *PFN_CREATE_DXGI_FACTORY)(REFIID riid, void **ppFactory);
  45
  46 static AVOnce functions_loaded = AV_ONCE_INIT;
  47
  48 static PFN_CREATE_DXGI_FACTORY mCreateDXGIFactory;
  49 static PFN_D3D11_CREATE_DEVICE mD3D11CreateDevice;
  50
  51 static av_cold void load_functions(void)
  52 {
  53 #if !HAVE_UWP
  54     // We let these "leak" - this is fine, as unloading has no great benefit, and
  55     // Windows will mark a DLL as loaded forever if its internal refcount overflows
  56     // from too many LoadLibrary calls.
  57     HANDLE d3dlib, dxgilib;
  58
  59     d3dlib  = dlopen("d3d11.dll", 0);
  60     dxgilib = dlopen("dxgi.dll", 0);
  61     if (!d3dlib || !dxgilib)
  62         return;
  63
  64     mD3D11CreateDevice = (PFN_D3D11_CREATE_DEVICE) GetProcAddress(d3dlib, "D3D11CreateDevice");
  65     mCreateDXGIFactory = (PFN_CREATE_DXGI_FACTORY) GetProcAddress(dxgilib, "CreateDXGIFactory");
  66 #else
  67     // In UWP (which lacks LoadLibrary), CreateDXGIFactory isn't available,
  68     // only CreateDXGIFactory1
  69     mD3D11CreateDevice = (PFN_D3D11_CREATE_DEVICE) D3D11CreateDevice;
  70     mCreateDXGIFactory = (PFN_CREATE_DXGI_FACTORY) CreateDXGIFactory1;
  71 #endif
  72 }
  73
  74 typedef struct D3D11VAFramesContext {
  75     int nb_surfaces_used;
  76
  77     DXGI_FORMAT format;
  78
  79     ID3D11Texture2D *staging_texture;
  80 } D3D11VAFramesContext;
  81
  82 static const struct {
  83     DXGI_FORMAT d3d_format;
  84     enum AVPixelFormat pix_fmt;
  85 } supported_formats[] = {
  86     { DXGI_FORMAT_NV12,         AV_PIX_FMT_NV12 },
  87     { DXGI_FORMAT_P010,         AV_PIX_FMT_P010 },
  88     // Special opaque formats. The pix_fmt is merely a place holder, as the
  89     // opaque format cannot be accessed directly.
  90     { DXGI_FORMAT_420_OPAQUE,   AV_PIX_FMT_YUV420P },
  91 };
  92
  93 static void d3d11va_default_lock(void *ctx)
  94 {
  95     WaitForSingleObjectEx(ctx, INFINITE, FALSE);
  96 }
  97
  98 static void d3d11va_default_unlock(void *ctx)
  99 {
 100     ReleaseMutex(ctx);
 101 }
 102
 103 static void d3d11va_frames_uninit(AVHWFramesContext *ctx)
 104 {
 105     AVD3D11VAFramesContext *frames_hwctx = ctx->hwctx;
 106     D3D11VAFramesContext *s = ctx->internal->priv;
 107
 108     if (frames_hwctx->texture)
 109         ID3D11Texture2D_Release(frames_hwctx->texture);
 110     frames_hwctx->texture = NULL;
 111
 112     if (s->staging_texture)
 113         ID3D11Texture2D_Release(s->staging_texture);
 114     s->staging_texture = NULL;
 115 }
 116
 117 static int d3d11va_frames_get_constraints(AVHWDeviceContext *ctx,
 118                                           const void *hwconfig,
 119                                           AVHWFramesConstraints *constraints)
 120 {
 121     AVD3D11VADeviceContext *device_hwctx = ctx->hwctx;
 122     int nb_sw_formats = 0;
 123     HRESULT hr;
 124     int i;
 125
 126     constraints->valid_sw_formats = av_malloc_array(FF_ARRAY_ELEMS(supported_formats) + 1,
 127                                                     sizeof(*constraints->valid_sw_formats));
 128     if (!constraints->valid_sw_formats)
 129         return AVERROR(ENOMEM);
 130
 131     for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++) {
 132         UINT format_support = 0;
 133         hr = ID3D11Device_CheckFormatSupport(device_hwctx->device, supported_formats[i].d3d_format, &format_support);
 134         if (SUCCEEDED(hr) && (format_support & D3D11_FORMAT_SUPPORT_TEXTURE2D))
 135             constraints->valid_sw_formats[nb_sw_formats++] = supported_formats[i].pix_fmt;
 136     }
 137     constraints->valid_sw_formats[nb_sw_formats] = AV_PIX_FMT_NONE;
 138
 139     constraints->valid_hw_formats = av_malloc_array(2, sizeof(*constraints->valid_hw_formats));
 140     if (!constraints->valid_hw_formats)
 141         return AVERROR(ENOMEM);
 142
 143     constraints->valid_hw_formats[0] = AV_PIX_FMT_D3D11;
 144     constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE;
 145
 146     return 0;
 147 }
 148
 149 static void free_texture(void *opaque, uint8_t *data)
 150 {
 151     ID3D11Texture2D_Release((ID3D11Texture2D *)opaque);
 152     av_free(data);
 153 }
 154
 155 static AVBufferRef *wrap_texture_buf(ID3D11Texture2D *tex, int index)
 156 {
 157     AVBufferRef *buf;
 158     AVD3D11FrameDescriptor *desc = av_mallocz(sizeof(*desc));
 159     if (!desc) {
 160         ID3D11Texture2D_Release(tex);
 161         return NULL;
 162     }
 163
 164     desc->texture = tex;
 165     desc->index   = index;
 166
 167     buf = av_buffer_create((uint8_t *)desc, sizeof(desc), free_texture, tex, 0);
 168     if (!buf) {
 169         ID3D11Texture2D_Release(tex);
 170         av_free(desc);
 171         return NULL;
 172     }
 173
 174     return buf;
 175 }
 176
 177 static AVBufferRef *d3d11va_alloc_single(AVHWFramesContext *ctx)
 178 {
 179     D3D11VAFramesContext       *s = ctx->internal->priv;
 180     AVD3D11VAFramesContext *hwctx = ctx->hwctx;
 181     AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
 182     HRESULT hr;
 183     ID3D11Texture2D *tex;
 184     D3D11_TEXTURE2D_DESC texDesc = {
 185         .Width      = ctx->width,
 186         .Height     = ctx->height,
 187         .MipLevels  = 1,
 188         .Format     = s->format,
 189         .SampleDesc = { .Count = 1 },
 190         .ArraySize  = 1,
 191         .Usage      = D3D11_USAGE_DEFAULT,
 192         .BindFlags  = hwctx->BindFlags,
 193         .MiscFlags  = hwctx->MiscFlags,
 194     };
 195
 196     hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &tex);
 197     if (FAILED(hr)) {
 198         av_log(ctx, AV_LOG_ERROR, "Could not create the texture (%lx)\n", (long)hr);
 199         return NULL;
 200     }
 201
 202     return wrap_texture_buf(tex, 0);
 203 }
 204
 205 static AVBufferRef *d3d11va_pool_alloc(void *opaque, int size)
 206 {
 207     AVHWFramesContext        *ctx = (AVHWFramesContext*)opaque;
 208     D3D11VAFramesContext       *s = ctx->internal->priv;
 209     AVD3D11VAFramesContext *hwctx = ctx->hwctx;
 210     D3D11_TEXTURE2D_DESC  texDesc;
 211
 212     if (!hwctx->texture)
 213         return d3d11va_alloc_single(ctx);
 214
 215     ID3D11Texture2D_GetDesc(hwctx->texture, &texDesc);
 216
 217     if (s->nb_surfaces_used >= texDesc.ArraySize) {
 218         av_log(ctx, AV_LOG_ERROR, "Static surface pool size exceeded.\n");
 219         return NULL;
 220     }
 221
 222     ID3D11Texture2D_AddRef(hwctx->texture);
 223     return wrap_texture_buf(hwctx->texture, s->nb_surfaces_used++);
 224 }
 225
 226 static int d3d11va_frames_init(AVHWFramesContext *ctx)
 227 {
 228     AVD3D11VAFramesContext *hwctx        = ctx->hwctx;
 229     AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
 230     D3D11VAFramesContext              *s = ctx->internal->priv;
 231
 232     int i;
 233     HRESULT hr;
 234     D3D11_TEXTURE2D_DESC texDesc;
 235
 236     for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++) {
 237         if (ctx->sw_format == supported_formats[i].pix_fmt) {
 238             s->format = supported_formats[i].d3d_format;
 239             break;
 240         }
 241     }
 242     if (i == FF_ARRAY_ELEMS(supported_formats)) {
 243         av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format: %s\n",
 244                av_get_pix_fmt_name(ctx->sw_format));
 245         return AVERROR(EINVAL);
 246     }
 247
 248     texDesc = (D3D11_TEXTURE2D_DESC){
 249         .Width      = ctx->width,
 250         .Height     = ctx->height,
 251         .MipLevels  = 1,
 252         .Format     = s->format,
 253         .SampleDesc = { .Count = 1 },
 254         .ArraySize  = ctx->initial_pool_size,
 255         .Usage      = D3D11_USAGE_DEFAULT,
 256         .BindFlags  = hwctx->BindFlags,
 257         .MiscFlags  = hwctx->MiscFlags,
 258     };
 259
 260     if (hwctx->texture) {
 261         D3D11_TEXTURE2D_DESC texDesc2;
 262         ID3D11Texture2D_GetDesc(hwctx->texture, &texDesc2);
 263
 264         if (texDesc.Width != texDesc2.Width ||
 265             texDesc.Height != texDesc2.Height ||
 266             texDesc.Format != texDesc2.Format) {
 267             av_log(ctx, AV_LOG_ERROR, "User-provided texture has mismatching parameters\n");
 268             return AVERROR(EINVAL);
 269         }
 270     } else if (texDesc.ArraySize > 0) {
 271         hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &hwctx->texture);
 272         if (FAILED(hr)) {
 273             av_log(ctx, AV_LOG_ERROR, "Could not create the texture (%lx)\n", (long)hr);
 274             return AVERROR_UNKNOWN;
 275         }
 276     }
 277
 278     ctx->internal->pool_internal = av_buffer_pool_init2(sizeof(AVD3D11FrameDescriptor),
 279                                                         ctx, d3d11va_pool_alloc, NULL);
 280     if (!ctx->internal->pool_internal)
 281         return AVERROR(ENOMEM);
 282
 283     return 0;
 284 }
 285
 286 static int d3d11va_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
 287 {
 288     AVD3D11FrameDescriptor *desc;
 289
 290     frame->buf[0] = av_buffer_pool_get(ctx->pool);
 291     if (!frame->buf[0])
 292         return AVERROR(ENOMEM);
 293
 294     desc = (AVD3D11FrameDescriptor *)frame->buf[0]->data;
 295
 296     frame->data[0] = (uint8_t *)desc->texture;
 297     frame->data[1] = (uint8_t *)desc->index;
 298     frame->format  = AV_PIX_FMT_D3D11;
 299     frame->width   = ctx->width;
 300     frame->height  = ctx->height;
 301
 302     return 0;
 303 }
 304
 305 static int d3d11va_transfer_get_formats(AVHWFramesContext *ctx,
 306                                         enum AVHWFrameTransferDirection dir,
 307                                         enum AVPixelFormat **formats)
 308 {
 309     D3D11VAFramesContext *s = ctx->internal->priv;
 310     enum AVPixelFormat *fmts;
 311
 312     fmts = av_malloc_array(2, sizeof(*fmts));
 313     if (!fmts)
 314         return AVERROR(ENOMEM);
 315
 316     fmts[0] = ctx->sw_format;
 317     fmts[1] = AV_PIX_FMT_NONE;
 318
 319     // Don't signal support for opaque formats. Actual access would fail.
 320     if (s->format == DXGI_FORMAT_420_OPAQUE)
 321         fmts[0] = AV_PIX_FMT_NONE;
 322
 323     *formats = fmts;
 324
 325     return 0;
 326 }
 327
 328 static int d3d11va_create_staging_texture(AVHWFramesContext *ctx)
 329 {
 330     AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
 331     D3D11VAFramesContext              *s = ctx->internal->priv;
 332     HRESULT hr;
 333     D3D11_TEXTURE2D_DESC texDesc = {
 334         .Width          = ctx->width,
 335         .Height         = ctx->height,
 336         .MipLevels      = 1,
 337         .Format         = s->format,
 338         .SampleDesc     = { .Count = 1 },
 339         .ArraySize      = 1,
 340         .Usage          = D3D11_USAGE_STAGING,
 341         .CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE,
 342     };
 343
 344     hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &s->staging_texture);
 345     if (FAILED(hr)) {
 346         av_log(ctx, AV_LOG_ERROR, "Could not create the staging texture (%lx)\n", (long)hr);
 347         return AVERROR_UNKNOWN;
 348     }
 349
 350     return 0;
 351 }
 352
 353 static void fill_texture_ptrs(uint8_t *data[4], int linesize[4],
 354                               AVHWFramesContext *ctx,
 355                               D3D11_TEXTURE2D_DESC *desc,
 356                               D3D11_MAPPED_SUBRESOURCE *map)
 357 {
 358     int i;
 359
 360     for (i = 0; i < 4; i++)
 361         linesize[i] = map->RowPitch;
 362
 363     av_image_fill_pointers(data, ctx->sw_format, desc->Height,
 364                            (uint8_t*)map->pData, linesize);
 365 }
 366
 367 static int d3d11va_transfer_data(AVHWFramesContext *ctx, AVFrame *dst,
 368                                  const AVFrame *src)
 369 {
 370     AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
 371     D3D11VAFramesContext              *s = ctx->internal->priv;
 372     int download = src->format == AV_PIX_FMT_D3D11;
 373     const AVFrame *frame = download ? src : dst;
 374     const AVFrame *other = download ? dst : src;
 375     // (The interface types are compatible.)
 376     ID3D11Resource *texture = (ID3D11Resource *)(ID3D11Texture2D *)frame->data[0];
 377     int index = (intptr_t)frame->data[1];
 378     ID3D11Resource *staging;
 379     int w = FFMIN(dst->width,  src->width);
 380     int h = FFMIN(dst->height, src->height);
 381     uint8_t *map_data[4];
 382     int map_linesize[4];
 383     D3D11_TEXTURE2D_DESC desc;
 384     D3D11_MAPPED_SUBRESOURCE map;
 385     HRESULT hr;
 386
 387     if (frame->hw_frames_ctx->data != (uint8_t *)ctx || other->format != ctx->sw_format)
 388         return AVERROR(EINVAL);
 389
 390     device_hwctx->lock(device_hwctx->lock_ctx);
 391
 392     if (!s->staging_texture) {
 393         int res = d3d11va_create_staging_texture(ctx);
 394         if (res < 0)
 395             return res;
 396     }
 397
 398     staging = (ID3D11Resource *)s->staging_texture;
 399
 400     ID3D11Texture2D_GetDesc(s->staging_texture, &desc);
 401
 402     if (download) {
 403         ID3D11DeviceContext_CopySubresourceRegion(device_hwctx->device_context,
 404                                                   staging, 0, 0, 0, 0,
 405                                                   texture, index, NULL);
 406
 407         hr = ID3D11DeviceContext_Map(device_hwctx->device_context,
 408                                      staging, 0, D3D11_MAP_READ, 0, &map);
 409         if (FAILED(hr))
 410             goto map_failed;
 411
 412         fill_texture_ptrs(map_data, map_linesize, ctx, &desc, &map);
 413
 414         av_image_copy(dst->data, dst->linesize, (const uint8_t **)map_data, map_linesize,
 415                       ctx->sw_format, w, h);
 416
 417         ID3D11DeviceContext_Unmap(device_hwctx->device_context, staging, 0);
 418     } else {
 419         hr = ID3D11DeviceContext_Map(device_hwctx->device_context,
 420                                      staging, 0, D3D11_MAP_WRITE, 0, &map);
 421         if (FAILED(hr))
 422             goto map_failed;
 423
 424         fill_texture_ptrs(map_data, map_linesize, ctx, &desc, &map);
 425
 426         av_image_copy(map_data, map_linesize, (const uint8_t **)src->data, src->linesize,
 427                       ctx->sw_format, w, h);
 428
 429         ID3D11DeviceContext_Unmap(device_hwctx->device_context, staging, 0);
 430
 431         ID3D11DeviceContext_CopySubresourceRegion(device_hwctx->device_context,
 432                                                   texture, index, 0, 0, 0,
 433                                                   staging, 0, NULL);
 434     }
 435
 436     device_hwctx->unlock(device_hwctx->lock_ctx);
 437     return 0;
 438
 439 map_failed:
 440     av_log(ctx, AV_LOG_ERROR, "Unable to lock D3D11VA surface (%lx)\n", (long)hr);
 441     device_hwctx->unlock(device_hwctx->lock_ctx);
 442     return AVERROR_UNKNOWN;
 443 }
 444
 445 static int d3d11va_device_init(AVHWDeviceContext *hwdev)
 446 {
 447     AVD3D11VADeviceContext *device_hwctx = hwdev->hwctx;
 448     HRESULT hr;
 449
 450     if (!device_hwctx->lock) {
 451         device_hwctx->lock_ctx = CreateMutex(NULL, 0, NULL);
 452         if (device_hwctx->lock_ctx == INVALID_HANDLE_VALUE) {
 453             av_log(NULL, AV_LOG_ERROR, "Failed to create a mutex\n");
 454             return AVERROR(EINVAL);
 455         }
 456         device_hwctx->lock   = d3d11va_default_lock;
 457         device_hwctx->unlock = d3d11va_default_unlock;
 458     }
 459
 460     if (!device_hwctx->device_context) {
 461         ID3D11Device_GetImmediateContext(device_hwctx->device, &device_hwctx->device_context);
 462         if (!device_hwctx->device_context)
 463             return AVERROR_UNKNOWN;
 464     }
 465
 466     if (!device_hwctx->video_device) {
 467         hr = ID3D11DeviceContext_QueryInterface(device_hwctx->device, &IID_ID3D11VideoDevice,
 468                                                 (void **)&device_hwctx->video_device);
 469         if (FAILED(hr))
 470             return AVERROR_UNKNOWN;
 471     }
 472
 473     if (!device_hwctx->video_context) {
 474         hr = ID3D11DeviceContext_QueryInterface(device_hwctx->device_context, &IID_ID3D11VideoContext,
 475                                                 (void **)&device_hwctx->video_context);
 476         if (FAILED(hr))
 477             return AVERROR_UNKNOWN;
 478     }
 479
 480     return 0;
 481 }
 482
 483 static void d3d11va_device_uninit(AVHWDeviceContext *hwdev)
 484 {
 485     AVD3D11VADeviceContext *device_hwctx = hwdev->hwctx;
 486
 487     if (device_hwctx->device) {
 488         ID3D11Device_Release(device_hwctx->device);
 489         device_hwctx->device = NULL;
 490     }
 491
 492     if (device_hwctx->device_context) {
 493         ID3D11DeviceContext_Release(device_hwctx->device_context);
 494         device_hwctx->device_context = NULL;
 495     }
 496
 497     if (device_hwctx->video_device) {
 498         ID3D11VideoDevice_Release(device_hwctx->video_device);
 499         device_hwctx->video_device = NULL;
 500     }
 501
 502     if (device_hwctx->video_context) {
 503         ID3D11VideoContext_Release(device_hwctx->video_context);
 504         device_hwctx->video_context = NULL;
 505     }
 506
 507     if (device_hwctx->lock == d3d11va_default_lock) {
 508         CloseHandle(device_hwctx->lock_ctx);
 509         device_hwctx->lock_ctx = INVALID_HANDLE_VALUE;
 510         device_hwctx->lock = NULL;
 511     }
 512 }
 513
 514 static int d3d11va_device_create(AVHWDeviceContext *ctx, const char *device,
 515                                  AVDictionary *opts, int flags)
 516 {
 517     AVD3D11VADeviceContext *device_hwctx = ctx->hwctx;
 518
 519     HRESULT hr;
 520     IDXGIAdapter           *pAdapter = NULL;
 521     ID3D10Multithread      *pMultithread;
 522     UINT creationFlags = D3D11_CREATE_DEVICE_VIDEO_SUPPORT;
 523     int is_debug       = !!av_dict_get(opts, "debug", NULL, 0);
 524     int ret;
 525
 526     // (On UWP we can't check this.)
 527 #if !HAVE_UWP
 528     if (!LoadLibrary("d3d11_1sdklayers.dll"))
 529         is_debug = 0;
 530 #endif
 531
 532     if (is_debug)
 533         creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
 534
 535     if ((ret = ff_thread_once(&functions_loaded, load_functions)) != 0)
 536         return AVERROR_UNKNOWN;
 537     if (!mD3D11CreateDevice || !mCreateDXGIFactory) {
 538         av_log(ctx, AV_LOG_ERROR, "Failed to load D3D11 library or its functions\n");
 539         return AVERROR_UNKNOWN;
 540     }
 541
 542     if (device) {
 543         IDXGIFactory2 *pDXGIFactory;
 544         hr = mCreateDXGIFactory(&IID_IDXGIFactory2, (void **)&pDXGIFactory);
 545         if (SUCCEEDED(hr)) {
 546             int adapter = atoi(device);
 547             if (FAILED(IDXGIFactory2_EnumAdapters(pDXGIFactory, adapter, &pAdapter)))
 548                 pAdapter = NULL;
 549             IDXGIFactory2_Release(pDXGIFactory);
 550         }
 551     }
 552
 553     if (pAdapter) {
 554         DXGI_ADAPTER_DESC desc;
 555         hr = IDXGIAdapter2_GetDesc(pAdapter, &desc);
 556         if (!FAILED(hr)) {
 557             av_log(ctx, AV_LOG_INFO, "Using device %04x:%04x (%ls).\n",
 558                    desc.VendorId, desc.DeviceId, desc.Description);
 559         }
 560     }
 561
 562     hr = mD3D11CreateDevice(pAdapter, pAdapter ? D3D_DRIVER_TYPE_UNKNOWN : D3D_DRIVER_TYPE_HARDWARE, NULL, creationFlags, NULL, 0,
 563                    D3D11_SDK_VERSION, &device_hwctx->device, NULL, NULL);
 564     if (pAdapter)
 565         IDXGIAdapter_Release(pAdapter);
 566     if (FAILED(hr)) {
 567         av_log(ctx, AV_LOG_ERROR, "Failed to create Direct3D device (%lx)\n", (long)hr);
 568         return AVERROR_UNKNOWN;
 569     }
 570
 571     hr = ID3D11Device_QueryInterface(device_hwctx->device, &IID_ID3D10Multithread, (void **)&pMultithread);
 572     if (SUCCEEDED(hr)) {
 573         ID3D10Multithread_SetMultithreadProtected(pMultithread, TRUE);
 574         ID3D10Multithread_Release(pMultithread);
 575     }
 576
 577 #if !HAVE_UWP && HAVE_DXGIDEBUG_H
 578     if (is_debug) {
 579         HANDLE dxgidebug_dll = LoadLibrary("dxgidebug.dll");
 580         if (dxgidebug_dll) {
 581             HRESULT (WINAPI  * pf_DXGIGetDebugInterface)(const GUID *riid, void **ppDebug)
 582                 = (void *)GetProcAddress(dxgidebug_dll, "DXGIGetDebugInterface");
 583             if (pf_DXGIGetDebugInterface) {
 584                 IDXGIDebug *dxgi_debug = NULL;
 585                 hr = pf_DXGIGetDebugInterface(&IID_IDXGIDebug, (void**)&dxgi_debug);
 586                 if (SUCCEEDED(hr) && dxgi_debug)
 587                     IDXGIDebug_ReportLiveObjects(dxgi_debug, DXGI_DEBUG_ALL, DXGI_DEBUG_RLO_ALL);
 588             }
 589         }
 590     }
 591 #endif
 592
 593     return 0;
 594 }
 595
 596 const HWContextType ff_hwcontext_type_d3d11va = {
 597     .type                 = AV_HWDEVICE_TYPE_D3D11VA,
 598     .name                 = "D3D11VA",
 599
 600     .device_hwctx_size    = sizeof(AVD3D11VADeviceContext),
 601     .frames_hwctx_size    = sizeof(AVD3D11VAFramesContext),
 602     .frames_priv_size     = sizeof(D3D11VAFramesContext),
 603
 604     .device_create        = d3d11va_device_create,
 605     .device_init          = d3d11va_device_init,
 606     .device_uninit        = d3d11va_device_uninit,
 607     .frames_get_constraints = d3d11va_frames_get_constraints,
 608     .frames_init          = d3d11va_frames_init,
 609     .frames_uninit        = d3d11va_frames_uninit,
 610     .frames_get_buffer    = d3d11va_get_buffer,
 611     .transfer_get_formats = d3d11va_transfer_get_formats,
 612     .transfer_data_to     = d3d11va_transfer_data,
 613     .transfer_data_from   = d3d11va_transfer_data,
 614
 615     .pix_fmts             = (const enum AVPixelFormat[]){ AV_PIX_FMT_D3D11, AV_PIX_FMT_NONE },
 616 };