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