FFmpeg
hwcontext_d3d11va.c
Go to the documentation of this file.
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 "mem.h"
40 #include "pixdesc.h"
41 #include "pixfmt.h"
42 #include "thread.h"
43 #include "compat/w32dlfcn.h"
44 
45 typedef HRESULT(WINAPI *PFN_CREATE_DXGI_FACTORY)(REFIID riid, void **ppFactory);
46 
48 
50 static PFN_D3D11_CREATE_DEVICE mD3D11CreateDevice;
51 
52 static av_cold void load_functions(void)
53 {
54 #if !HAVE_UWP
55  // We let these "leak" - this is fine, as unloading has no great benefit, and
56  // Windows will mark a DLL as loaded forever if its internal refcount overflows
57  // from too many LoadLibrary calls.
58  HANDLE d3dlib, dxgilib;
59 
60  d3dlib = dlopen("d3d11.dll", 0);
61  dxgilib = dlopen("dxgi.dll", 0);
62  if (!d3dlib || !dxgilib)
63  return;
64 
65  mD3D11CreateDevice = (PFN_D3D11_CREATE_DEVICE) GetProcAddress(d3dlib, "D3D11CreateDevice");
66  mCreateDXGIFactory = (PFN_CREATE_DXGI_FACTORY) GetProcAddress(dxgilib, "CreateDXGIFactory1");
67  if (!mCreateDXGIFactory)
68  mCreateDXGIFactory = (PFN_CREATE_DXGI_FACTORY) GetProcAddress(dxgilib, "CreateDXGIFactory");
69 #else
70  // In UWP (which lacks LoadLibrary), CreateDXGIFactory isn't available,
71  // only CreateDXGIFactory1
72  mD3D11CreateDevice = (PFN_D3D11_CREATE_DEVICE) D3D11CreateDevice;
73  mCreateDXGIFactory = (PFN_CREATE_DXGI_FACTORY) CreateDXGIFactory1;
74 #endif
75 }
76 
77 typedef struct D3D11VAFramesContext {
78  /**
79  * The public AVD3D11VAFramesContext. See hwcontext_d3d11va.h for it.
80  */
82 
85 
86  DXGI_FORMAT format;
87 
88  ID3D11Texture2D *staging_texture;
90 
91 static const struct {
92  DXGI_FORMAT d3d_format;
94 } supported_formats[] = {
95  { DXGI_FORMAT_NV12, AV_PIX_FMT_NV12 },
96  { DXGI_FORMAT_P010, AV_PIX_FMT_P010 },
98  { DXGI_FORMAT_R10G10B10A2_UNORM, AV_PIX_FMT_X2BGR10 },
100  { DXGI_FORMAT_AYUV, AV_PIX_FMT_VUYX },
101  { DXGI_FORMAT_YUY2, AV_PIX_FMT_YUYV422 },
102  { DXGI_FORMAT_Y210, AV_PIX_FMT_Y210 },
103  { DXGI_FORMAT_Y410, AV_PIX_FMT_XV30 },
104  { DXGI_FORMAT_P016, AV_PIX_FMT_P012 },
105  { DXGI_FORMAT_Y216, AV_PIX_FMT_Y212 },
106  { DXGI_FORMAT_Y416, AV_PIX_FMT_XV36 },
107  // Special opaque formats. The pix_fmt is merely a place holder, as the
108  // opaque format cannot be accessed directly.
109  { DXGI_FORMAT_420_OPAQUE, AV_PIX_FMT_YUV420P },
110 };
111 
112 static void d3d11va_default_lock(void *ctx)
113 {
114  WaitForSingleObjectEx(ctx, INFINITE, FALSE);
115 }
116 
117 static void d3d11va_default_unlock(void *ctx)
118 {
119  ReleaseMutex(ctx);
120 }
121 
123 {
124  D3D11VAFramesContext *s = ctx->hwctx;
125  AVD3D11VAFramesContext *frames_hwctx = &s->p;
126 
127  if (frames_hwctx->texture)
128  ID3D11Texture2D_Release(frames_hwctx->texture);
129  frames_hwctx->texture = NULL;
130 
131  if (s->staging_texture)
132  ID3D11Texture2D_Release(s->staging_texture);
133  s->staging_texture = NULL;
134 
135  av_freep(&frames_hwctx->texture_infos);
136 }
137 
139  const void *hwconfig,
140  AVHWFramesConstraints *constraints)
141 {
142  AVD3D11VADeviceContext *device_hwctx = ctx->hwctx;
143  int nb_sw_formats = 0;
144  HRESULT hr;
145  int i;
146 
148  sizeof(*constraints->valid_sw_formats));
149  if (!constraints->valid_sw_formats)
150  return AVERROR(ENOMEM);
151 
152  for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++) {
153  UINT format_support = 0;
154  hr = ID3D11Device_CheckFormatSupport(device_hwctx->device, supported_formats[i].d3d_format, &format_support);
155  if (SUCCEEDED(hr) && (format_support & D3D11_FORMAT_SUPPORT_TEXTURE2D))
156  constraints->valid_sw_formats[nb_sw_formats++] = supported_formats[i].pix_fmt;
157  }
158  constraints->valid_sw_formats[nb_sw_formats] = AV_PIX_FMT_NONE;
159 
160  constraints->valid_hw_formats = av_malloc_array(2, sizeof(*constraints->valid_hw_formats));
161  if (!constraints->valid_hw_formats)
162  return AVERROR(ENOMEM);
163 
164  constraints->valid_hw_formats[0] = AV_PIX_FMT_D3D11;
165  constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE;
166 
167  return 0;
168 }
169 
170 static void free_texture(void *opaque, uint8_t *data)
171 {
172  ID3D11Texture2D_Release((ID3D11Texture2D *)opaque);
173  av_free(data);
174 }
175 
176 static AVBufferRef *wrap_texture_buf(AVHWFramesContext *ctx, ID3D11Texture2D *tex, int index)
177 {
178  AVBufferRef *buf;
180  D3D11VAFramesContext *s = ctx->hwctx;
181  AVD3D11VAFramesContext *frames_hwctx = &s->p;
182  if (!desc) {
183  ID3D11Texture2D_Release(tex);
184  return NULL;
185  }
186 
187  if (s->nb_surfaces <= s->nb_surfaces_used) {
188  frames_hwctx->texture_infos = av_realloc_f(frames_hwctx->texture_infos,
189  s->nb_surfaces_used + 1,
190  sizeof(*frames_hwctx->texture_infos));
191  if (!frames_hwctx->texture_infos) {
192  ID3D11Texture2D_Release(tex);
193  return NULL;
194  }
195  s->nb_surfaces = s->nb_surfaces_used + 1;
196  }
197 
198  frames_hwctx->texture_infos[s->nb_surfaces_used].texture = tex;
199  frames_hwctx->texture_infos[s->nb_surfaces_used].index = index;
200  s->nb_surfaces_used++;
201 
202  desc->texture = tex;
203  desc->index = index;
204 
205  buf = av_buffer_create((uint8_t *)desc, sizeof(desc), free_texture, tex, 0);
206  if (!buf) {
207  ID3D11Texture2D_Release(tex);
208  av_free(desc);
209  return NULL;
210  }
211 
212  return buf;
213 }
214 
216 {
217  D3D11VAFramesContext *s = ctx->hwctx;
218  AVD3D11VAFramesContext *hwctx = &s->p;
219  AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
220  HRESULT hr;
221  ID3D11Texture2D *tex;
222  D3D11_TEXTURE2D_DESC texDesc = {
223  .Width = ctx->width,
224  .Height = ctx->height,
225  .MipLevels = 1,
226  .Format = s->format,
227  .SampleDesc = { .Count = 1 },
228  .ArraySize = 1,
229  .Usage = D3D11_USAGE_DEFAULT,
230  .BindFlags = hwctx->BindFlags,
231  .MiscFlags = hwctx->MiscFlags,
232  };
233 
234  hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &tex);
235  if (FAILED(hr)) {
236  av_log(ctx, AV_LOG_ERROR, "Could not create the texture (%lx)\n", (long)hr);
237  return NULL;
238  }
239 
240  return wrap_texture_buf(ctx, tex, 0);
241 }
242 
243 static AVBufferRef *d3d11va_pool_alloc(void *opaque, size_t size)
244 {
246  D3D11VAFramesContext *s = ctx->hwctx;
247  AVD3D11VAFramesContext *hwctx = &s->p;
248  D3D11_TEXTURE2D_DESC texDesc;
249 
250  if (!hwctx->texture)
251  return d3d11va_alloc_single(ctx);
252 
253  ID3D11Texture2D_GetDesc(hwctx->texture, &texDesc);
254 
255  if (s->nb_surfaces_used >= texDesc.ArraySize) {
256  av_log(ctx, AV_LOG_ERROR, "Static surface pool size exceeded.\n");
257  return NULL;
258  }
259 
260  ID3D11Texture2D_AddRef(hwctx->texture);
261  return wrap_texture_buf(ctx, hwctx->texture, s->nb_surfaces_used);
262 }
263 
265 {
266  AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
267  D3D11VAFramesContext *s = ctx->hwctx;
268  AVD3D11VAFramesContext *hwctx = &s->p;
269 
270  int i;
271  HRESULT hr;
272  D3D11_TEXTURE2D_DESC texDesc;
273 
274  for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++) {
275  if (ctx->sw_format == supported_formats[i].pix_fmt) {
276  s->format = supported_formats[i].d3d_format;
277  break;
278  }
279  }
281  av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format: %s\n",
282  av_get_pix_fmt_name(ctx->sw_format));
283  return AVERROR(EINVAL);
284  }
285 
286  texDesc = (D3D11_TEXTURE2D_DESC){
287  .Width = ctx->width,
288  .Height = ctx->height,
289  .MipLevels = 1,
290  .Format = s->format,
291  .SampleDesc = { .Count = 1 },
292  .ArraySize = ctx->initial_pool_size,
293  .Usage = D3D11_USAGE_DEFAULT,
294  .BindFlags = hwctx->BindFlags,
295  .MiscFlags = hwctx->MiscFlags,
296  };
297 
298  if (hwctx->texture) {
299  D3D11_TEXTURE2D_DESC texDesc2;
300  ID3D11Texture2D_GetDesc(hwctx->texture, &texDesc2);
301 
302  if (texDesc.Width != texDesc2.Width ||
303  texDesc.Height != texDesc2.Height ||
304  texDesc.Format != texDesc2.Format) {
305  av_log(ctx, AV_LOG_ERROR, "User-provided texture has mismatching parameters\n");
306  return AVERROR(EINVAL);
307  }
308 
309  ctx->initial_pool_size = texDesc2.ArraySize;
310  hwctx->BindFlags = texDesc2.BindFlags;
311  hwctx->MiscFlags = texDesc2.MiscFlags;
312  } else if (!(texDesc.BindFlags & D3D11_BIND_RENDER_TARGET) && texDesc.ArraySize > 0) {
313  hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &hwctx->texture);
314  if (FAILED(hr)) {
315  av_log(ctx, AV_LOG_ERROR, "Could not create the texture (%lx)\n", (long)hr);
316  return AVERROR_UNKNOWN;
317  }
318  }
319 
320  hwctx->texture_infos = av_realloc_f(NULL, ctx->initial_pool_size, sizeof(*hwctx->texture_infos));
321  if (!hwctx->texture_infos)
322  return AVERROR(ENOMEM);
323  s->nb_surfaces = ctx->initial_pool_size;
324 
328  if (!ffhwframesctx(ctx)->pool_internal)
329  return AVERROR(ENOMEM);
330 
331  return 0;
332 }
333 
335 {
337 
338  frame->buf[0] = av_buffer_pool_get(ctx->pool);
339  if (!frame->buf[0])
340  return AVERROR(ENOMEM);
341 
342  desc = (AVD3D11FrameDescriptor *)frame->buf[0]->data;
343 
344  frame->data[0] = (uint8_t *)desc->texture;
345  frame->data[1] = (uint8_t *)desc->index;
346  frame->format = AV_PIX_FMT_D3D11;
347  frame->width = ctx->width;
348  frame->height = ctx->height;
349 
350  return 0;
351 }
352 
355  enum AVPixelFormat **formats)
356 {
357  D3D11VAFramesContext *s = ctx->hwctx;
358  enum AVPixelFormat *fmts;
359 
360  fmts = av_malloc_array(2, sizeof(*fmts));
361  if (!fmts)
362  return AVERROR(ENOMEM);
363 
364  fmts[0] = ctx->sw_format;
365  fmts[1] = AV_PIX_FMT_NONE;
366 
367  // Don't signal support for opaque formats. Actual access would fail.
368  if (s->format == DXGI_FORMAT_420_OPAQUE)
369  fmts[0] = AV_PIX_FMT_NONE;
370 
371  *formats = fmts;
372 
373  return 0;
374 }
375 
377 {
378  AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
379  D3D11VAFramesContext *s = ctx->hwctx;
380  HRESULT hr;
381  D3D11_TEXTURE2D_DESC texDesc = {
382  .Width = ctx->width,
383  .Height = ctx->height,
384  .MipLevels = 1,
385  .Format = format,
386  .SampleDesc = { .Count = 1 },
387  .ArraySize = 1,
388  .Usage = D3D11_USAGE_STAGING,
389  .CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE,
390  };
391 
392  hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &s->staging_texture);
393  if (FAILED(hr)) {
394  av_log(ctx, AV_LOG_ERROR, "Could not create the staging texture (%lx)\n", (long)hr);
395  return AVERROR_UNKNOWN;
396  }
397 
398  return 0;
399 }
400 
401 static void fill_texture_ptrs(uint8_t *data[4], int linesize[4],
403  D3D11_TEXTURE2D_DESC *desc,
404  D3D11_MAPPED_SUBRESOURCE *map)
405 {
406  int i;
407 
408  for (i = 0; i < 4; i++)
409  linesize[i] = map->RowPitch;
410 
411  av_image_fill_pointers(data, ctx->sw_format, desc->Height,
412  (uint8_t*)map->pData, linesize);
413 }
414 
416  const AVFrame *src)
417 {
418  AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
419  D3D11VAFramesContext *s = ctx->hwctx;
420  int download = src->format == AV_PIX_FMT_D3D11;
421  const AVFrame *frame = download ? src : dst;
422  const AVFrame *other = download ? dst : src;
423  // (The interface types are compatible.)
424  ID3D11Resource *texture = (ID3D11Resource *)(ID3D11Texture2D *)frame->data[0];
425  int index = (intptr_t)frame->data[1];
426  ID3D11Resource *staging;
427  int w = FFMIN(dst->width, src->width);
428  int h = FFMIN(dst->height, src->height);
429  uint8_t *map_data[4];
430  int map_linesize[4];
431  D3D11_TEXTURE2D_DESC desc;
432  D3D11_MAPPED_SUBRESOURCE map;
433  HRESULT hr;
434  int res;
435 
436  if (frame->hw_frames_ctx->data != (uint8_t *)ctx || other->format != ctx->sw_format)
437  return AVERROR(EINVAL);
438 
439  device_hwctx->lock(device_hwctx->lock_ctx);
440 
441  if (!s->staging_texture) {
442  ID3D11Texture2D_GetDesc((ID3D11Texture2D *)texture, &desc);
443  res = d3d11va_create_staging_texture(ctx, desc.Format);
444  if (res < 0)
445  return res;
446  }
447 
448  staging = (ID3D11Resource *)s->staging_texture;
449 
450  ID3D11Texture2D_GetDesc(s->staging_texture, &desc);
451 
452  if (download) {
453  ID3D11DeviceContext_CopySubresourceRegion(device_hwctx->device_context,
454  staging, 0, 0, 0, 0,
455  texture, index, NULL);
456 
457  hr = ID3D11DeviceContext_Map(device_hwctx->device_context,
458  staging, 0, D3D11_MAP_READ, 0, &map);
459  if (FAILED(hr))
460  goto map_failed;
461 
462  fill_texture_ptrs(map_data, map_linesize, ctx, &desc, &map);
463 
464  av_image_copy2(dst->data, dst->linesize, map_data, map_linesize,
465  ctx->sw_format, w, h);
466 
467  ID3D11DeviceContext_Unmap(device_hwctx->device_context, staging, 0);
468  } else {
469  hr = ID3D11DeviceContext_Map(device_hwctx->device_context,
470  staging, 0, D3D11_MAP_WRITE, 0, &map);
471  if (FAILED(hr))
472  goto map_failed;
473 
474  fill_texture_ptrs(map_data, map_linesize, ctx, &desc, &map);
475 
476  av_image_copy2(map_data, map_linesize, src->data, src->linesize,
477  ctx->sw_format, w, h);
478 
479  ID3D11DeviceContext_Unmap(device_hwctx->device_context, staging, 0);
480 
481  ID3D11DeviceContext_CopySubresourceRegion(device_hwctx->device_context,
482  texture, index, 0, 0, 0,
483  staging, 0, NULL);
484  }
485 
486  device_hwctx->unlock(device_hwctx->lock_ctx);
487  return 0;
488 
489 map_failed:
490  av_log(ctx, AV_LOG_ERROR, "Unable to lock D3D11VA surface (%lx)\n", (long)hr);
491  device_hwctx->unlock(device_hwctx->lock_ctx);
492  return AVERROR_UNKNOWN;
493 }
494 
496 {
497  AVD3D11VADeviceContext *device_hwctx = hwdev->hwctx;
498  HRESULT hr;
499 
500  if (!device_hwctx->lock) {
501  device_hwctx->lock_ctx = CreateMutex(NULL, 0, NULL);
502  if (device_hwctx->lock_ctx == INVALID_HANDLE_VALUE) {
503  av_log(NULL, AV_LOG_ERROR, "Failed to create a mutex\n");
504  return AVERROR(EINVAL);
505  }
506  device_hwctx->lock = d3d11va_default_lock;
507  device_hwctx->unlock = d3d11va_default_unlock;
508  }
509 
510  if (!device_hwctx->device_context) {
511  ID3D11Device_GetImmediateContext(device_hwctx->device, &device_hwctx->device_context);
512  if (!device_hwctx->device_context)
513  return AVERROR_UNKNOWN;
514  }
515 
516  if (!device_hwctx->video_device) {
517  hr = ID3D11DeviceContext_QueryInterface(device_hwctx->device, &IID_ID3D11VideoDevice,
518  (void **)&device_hwctx->video_device);
519  if (FAILED(hr))
520  return AVERROR_UNKNOWN;
521  }
522 
523  if (!device_hwctx->video_context) {
524  hr = ID3D11DeviceContext_QueryInterface(device_hwctx->device_context, &IID_ID3D11VideoContext,
525  (void **)&device_hwctx->video_context);
526  if (FAILED(hr))
527  return AVERROR_UNKNOWN;
528  }
529 
530  return 0;
531 }
532 
534 {
535  AVD3D11VADeviceContext *device_hwctx = hwdev->hwctx;
536 
537  if (device_hwctx->device) {
538  ID3D11Device_Release(device_hwctx->device);
539  device_hwctx->device = NULL;
540  }
541 
542  if (device_hwctx->device_context) {
543  ID3D11DeviceContext_Release(device_hwctx->device_context);
544  device_hwctx->device_context = NULL;
545  }
546 
547  if (device_hwctx->video_device) {
548  ID3D11VideoDevice_Release(device_hwctx->video_device);
549  device_hwctx->video_device = NULL;
550  }
551 
552  if (device_hwctx->video_context) {
553  ID3D11VideoContext_Release(device_hwctx->video_context);
554  device_hwctx->video_context = NULL;
555  }
556 
557  if (device_hwctx->lock == d3d11va_default_lock) {
558  CloseHandle(device_hwctx->lock_ctx);
559  device_hwctx->lock_ctx = INVALID_HANDLE_VALUE;
560  device_hwctx->lock = NULL;
561  }
562 }
563 
564 static int d3d11va_device_find_adapter_by_vendor_id(AVHWDeviceContext *ctx, uint32_t flags, const char *vendor_id)
565 {
566  HRESULT hr;
567  IDXGIAdapter *adapter = NULL;
568  IDXGIFactory2 *factory;
569  int adapter_id = 0;
570  long int id = strtol(vendor_id, NULL, 0);
571 
572  hr = mCreateDXGIFactory(&IID_IDXGIFactory2, (void **)&factory);
573  if (FAILED(hr)) {
574  av_log(ctx, AV_LOG_ERROR, "CreateDXGIFactory returned error\n");
575  return -1;
576  }
577 
578  while (IDXGIFactory2_EnumAdapters(factory, adapter_id++, &adapter) != DXGI_ERROR_NOT_FOUND) {
579  ID3D11Device* device = NULL;
580  DXGI_ADAPTER_DESC adapter_desc;
581 
582  hr = mD3D11CreateDevice(adapter, D3D_DRIVER_TYPE_UNKNOWN, NULL, flags, NULL, 0, D3D11_SDK_VERSION, &device, NULL, NULL);
583  if (FAILED(hr)) {
584  av_log(ctx, AV_LOG_DEBUG, "D3D11CreateDevice returned error, try next adapter\n");
585  IDXGIAdapter_Release(adapter);
586  continue;
587  }
588 
589  hr = IDXGIAdapter2_GetDesc(adapter, &adapter_desc);
590  ID3D11Device_Release(device);
591  IDXGIAdapter_Release(adapter);
592  if (FAILED(hr)) {
593  av_log(ctx, AV_LOG_DEBUG, "IDXGIAdapter2_GetDesc returned error, try next adapter\n");
594  continue;
595  } else if (adapter_desc.VendorId == id) {
596  IDXGIFactory2_Release(factory);
597  return adapter_id - 1;
598  }
599  }
600 
601  IDXGIFactory2_Release(factory);
602  return -1;
603 }
604 
605 static int d3d11va_device_create(AVHWDeviceContext *ctx, const char *device,
606  AVDictionary *opts, int flags)
607 {
608  AVD3D11VADeviceContext *device_hwctx = ctx->hwctx;
609 
610  HRESULT hr;
611  IDXGIAdapter *pAdapter = NULL;
612  ID3D10Multithread *pMultithread;
613  UINT creationFlags = D3D11_CREATE_DEVICE_VIDEO_SUPPORT;
614  int is_debug = !!av_dict_get(opts, "debug", NULL, 0);
615  int ret;
616  int adapter = -1;
617 
618  if (is_debug) {
619  creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
620  av_log(ctx, AV_LOG_INFO, "Enabling d3d11 debugging.\n");
621  }
622 
624  return AVERROR_UNKNOWN;
626  av_log(ctx, AV_LOG_ERROR, "Failed to load D3D11 library or its functions\n");
627  return AVERROR_UNKNOWN;
628  }
629 
630  if (device) {
631  adapter = atoi(device);
632  } else {
633  AVDictionaryEntry *e = av_dict_get(opts, "vendor_id", NULL, 0);
634  if (e && e->value) {
635  adapter = d3d11va_device_find_adapter_by_vendor_id(ctx, creationFlags, e->value);
636  if (adapter < 0) {
637  av_log(ctx, AV_LOG_ERROR, "Failed to find d3d11va adapter by "
638  "vendor id %s\n", e->value);
639  return AVERROR_UNKNOWN;
640  }
641  }
642  }
643 
644  if (adapter >= 0) {
645  IDXGIFactory2 *pDXGIFactory;
646 
647  av_log(ctx, AV_LOG_VERBOSE, "Selecting d3d11va adapter %d\n", adapter);
648  hr = mCreateDXGIFactory(&IID_IDXGIFactory2, (void **)&pDXGIFactory);
649  if (SUCCEEDED(hr)) {
650  if (FAILED(IDXGIFactory2_EnumAdapters(pDXGIFactory, adapter, &pAdapter)))
651  pAdapter = NULL;
652  IDXGIFactory2_Release(pDXGIFactory);
653  }
654  }
655 
656  if (pAdapter) {
657  DXGI_ADAPTER_DESC desc;
658  hr = IDXGIAdapter2_GetDesc(pAdapter, &desc);
659  if (!FAILED(hr)) {
660  av_log(ctx, AV_LOG_INFO, "Using device %04x:%04x (%ls).\n",
661  desc.VendorId, desc.DeviceId, desc.Description);
662  }
663  }
664 
665  hr = mD3D11CreateDevice(pAdapter, pAdapter ? D3D_DRIVER_TYPE_UNKNOWN : D3D_DRIVER_TYPE_HARDWARE, NULL, creationFlags, NULL, 0,
666  D3D11_SDK_VERSION, &device_hwctx->device, NULL, NULL);
667  if (pAdapter)
668  IDXGIAdapter_Release(pAdapter);
669  if (FAILED(hr)) {
670  av_log(ctx, AV_LOG_ERROR, "Failed to create Direct3D device (%lx)\n", (long)hr);
671  return AVERROR_UNKNOWN;
672  }
673 
674  hr = ID3D11Device_QueryInterface(device_hwctx->device, &IID_ID3D10Multithread, (void **)&pMultithread);
675  if (SUCCEEDED(hr)) {
676  ID3D10Multithread_SetMultithreadProtected(pMultithread, TRUE);
677  ID3D10Multithread_Release(pMultithread);
678  }
679 
680 #if !HAVE_UWP && HAVE_DXGIDEBUG_H
681  if (is_debug) {
682  HANDLE dxgidebug_dll = LoadLibrary("dxgidebug.dll");
683  if (dxgidebug_dll) {
684  HRESULT (WINAPI * pf_DXGIGetDebugInterface)(const GUID *riid, void **ppDebug)
685  = (void *)GetProcAddress(dxgidebug_dll, "DXGIGetDebugInterface");
686  if (pf_DXGIGetDebugInterface) {
687  IDXGIDebug *dxgi_debug = NULL;
688  hr = pf_DXGIGetDebugInterface(&IID_IDXGIDebug, (void**)&dxgi_debug);
689  if (SUCCEEDED(hr) && dxgi_debug) {
690  IDXGIDebug_ReportLiveObjects(dxgi_debug, DXGI_DEBUG_ALL, DXGI_DEBUG_RLO_ALL);
691  av_log(ctx, AV_LOG_INFO, "Enabled dxgi debugging.\n");
692  } else {
693  av_log(ctx, AV_LOG_WARNING, "Failed enabling dxgi debugging.\n");
694  }
695  } else {
696  av_log(ctx, AV_LOG_WARNING, "Failed getting dxgi debug interface.\n");
697  }
698  } else {
699  av_log(ctx, AV_LOG_WARNING, "Failed loading dxgi debug library.\n");
700  }
701  }
702 #endif
703 
704  return 0;
705 }
706 
709  .name = "D3D11VA",
710 
711  .device_hwctx_size = sizeof(AVD3D11VADeviceContext),
712  .frames_hwctx_size = sizeof(D3D11VAFramesContext),
713 
714  .device_create = d3d11va_device_create,
715  .device_init = d3d11va_device_init,
716  .device_uninit = d3d11va_device_uninit,
717  .frames_get_constraints = d3d11va_frames_get_constraints,
718  .frames_init = d3d11va_frames_init,
719  .frames_uninit = d3d11va_frames_uninit,
720  .frames_get_buffer = d3d11va_get_buffer,
721  .transfer_get_formats = d3d11va_transfer_get_formats,
722  .transfer_data_to = d3d11va_transfer_data,
723  .transfer_data_from = d3d11va_transfer_data,
724 
725  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_D3D11, AV_PIX_FMT_NONE },
726 };
d3d11va_alloc_single
static AVBufferRef * d3d11va_alloc_single(AVHWFramesContext *ctx)
Definition: hwcontext_d3d11va.c:215
formats
formats
Definition: signature.h:48
AVHWDeviceContext::hwctx
void * hwctx
The format-specific data, allocated and freed by libavutil along with this context.
Definition: hwcontext.h:85
FFHWFramesContext::pool_internal
AVBufferPool * pool_internal
Definition: hwcontext_internal.h:101
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
DXGI_FORMAT_B8G8R8A8_UNORM
@ DXGI_FORMAT_B8G8R8A8_UNORM
Definition: dds.c:91
thread.h
d3d11va_transfer_get_formats
static int d3d11va_transfer_get_formats(AVHWFramesContext *ctx, enum AVHWFrameTransferDirection dir, enum AVPixelFormat **formats)
Definition: hwcontext_d3d11va.c:353
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
pixdesc.h
AVFrame::width
int width
Definition: frame.h:446
AVD3D11VAFramesContext::MiscFlags
UINT MiscFlags
D3D11_TEXTURE2D_DESC.MiscFlags used for texture creation.
Definition: hwcontext_d3d11va.h:166
w
uint8_t w
Definition: llviddspenc.c:38
data
const char data[16]
Definition: mxf.c:148
d3d11va_transfer_data
static int d3d11va_transfer_data(AVHWFramesContext *ctx, AVFrame *dst, const AVFrame *src)
Definition: hwcontext_d3d11va.c:415
AV_PIX_FMT_XV30
#define AV_PIX_FMT_XV30
Definition: pixfmt.h:534
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
supported_formats
static const struct @394 supported_formats[]
AVDictionary
Definition: dict.c:34
AVHWFramesConstraints::valid_hw_formats
enum AVPixelFormat * valid_hw_formats
A list of possible values for format in the hw_frames_ctx, terminated by AV_PIX_FMT_NONE.
Definition: hwcontext.h:446
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
fill_texture_ptrs
static void fill_texture_ptrs(uint8_t *data[4], int linesize[4], AVHWFramesContext *ctx, D3D11_TEXTURE2D_DESC *desc, D3D11_MAPPED_SUBRESOURCE *map)
Definition: hwcontext_d3d11va.c:401
PFN_CREATE_DXGI_FACTORY
HRESULT(WINAPI * PFN_CREATE_DXGI_FACTORY)(REFIID riid, void **ppFactory)
Definition: hwcontext_d3d11va.c:45
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:395
AVHWFramesConstraints
This struct describes the constraints on hardware frames attached to a given device with a hardware-s...
Definition: hwcontext.h:441
AVD3D11VAFramesContext::BindFlags
UINT BindFlags
D3D11_TEXTURE2D_DESC.BindFlags used for texture creation.
Definition: hwcontext_d3d11va.h:160
ff_hwcontext_type_d3d11va
const HWContextType ff_hwcontext_type_d3d11va
Definition: hwcontext_d3d11va.c:707
d3d11va_get_buffer
static int d3d11va_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
Definition: hwcontext_d3d11va.c:334
d3d_format
DXGI_FORMAT d3d_format
Definition: hwcontext_d3d11va.c:92
AVD3D11FrameDescriptor::texture
ID3D11Texture2D * texture
The texture in which the frame is located.
Definition: hwcontext_d3d11va.h:117
d3d11va_create_staging_texture
static int d3d11va_create_staging_texture(AVHWFramesContext *ctx, DXGI_FORMAT format)
Definition: hwcontext_d3d11va.c:376
D3D11VAFramesContext::format
DXGI_FORMAT format
Definition: hwcontext_d3d11va.c:86
AV_HWDEVICE_TYPE_D3D11VA
@ AV_HWDEVICE_TYPE_D3D11VA
Definition: hwcontext.h:35
av_buffer_pool_init2
AVBufferPool * av_buffer_pool_init2(size_t size, void *opaque, AVBufferRef *(*alloc)(void *opaque, size_t size), void(*pool_free)(void *opaque))
Allocate and initialize a buffer pool with a more complex allocator.
Definition: buffer.c:259
d3d11va_frames_uninit
static void d3d11va_frames_uninit(AVHWFramesContext *ctx)
Definition: hwcontext_d3d11va.c:122
d3d11va_default_unlock
static void d3d11va_default_unlock(void *ctx)
Definition: hwcontext_d3d11va.c:117
D3D11VAFramesContext::nb_surfaces_used
int nb_surfaces_used
Definition: hwcontext_d3d11va.c:84
av_image_fill_pointers
int av_image_fill_pointers(uint8_t *data[4], enum AVPixelFormat pix_fmt, int height, uint8_t *ptr, const int linesizes[4])
Fill plane data pointers for an image with pixel format pix_fmt and height height.
Definition: imgutils.c:145
d3d11va_frames_get_constraints
static int d3d11va_frames_get_constraints(AVHWDeviceContext *ctx, const void *hwconfig, AVHWFramesConstraints *constraints)
Definition: hwcontext_d3d11va.c:138
AVHWDeviceContext
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
Definition: hwcontext.h:60
AV_PIX_FMT_Y210
#define AV_PIX_FMT_Y210
Definition: pixfmt.h:532
avassert.h
HWContextType::type
enum AVHWDeviceType type
Definition: hwcontext_internal.h:30
ffhwframesctx
static FFHWFramesContext * ffhwframesctx(AVHWFramesContext *ctx)
Definition: hwcontext_internal.h:115
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
load_functions
static av_cold void load_functions(void)
Definition: hwcontext_d3d11va.c:52
AVHWFramesConstraints::valid_sw_formats
enum AVPixelFormat * valid_sw_formats
A list of possible values for sw_format in the hw_frames_ctx, terminated by AV_PIX_FMT_NONE.
Definition: hwcontext.h:453
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:62
av_buffer_pool_get
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:384
AVD3D11VADeviceContext::video_context
ID3D11VideoContext * video_context
If unset, this will be set from the device_context field on init.
Definition: hwcontext_d3d11va.h:80
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVD3D11VADeviceContext::device
ID3D11Device * device
Device used for texture creation and access.
Definition: hwcontext_d3d11va.h:56
d3d11va_device_create
static int d3d11va_device_create(AVHWDeviceContext *ctx, const char *device, AVDictionary *opts, int flags)
Definition: hwcontext_d3d11va.c:605
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
functions_loaded
static AVOnce functions_loaded
Definition: hwcontext_d3d11va.c:47
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:49
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
av_realloc_f
#define av_realloc_f(p, o, n)
Definition: tableprint_vlc.h:32
opts
AVDictionary * opts
Definition: movenc.c:51
D3D11VAFramesContext::nb_surfaces
int nb_surfaces
Definition: hwcontext_d3d11va.c:83
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
AVD3D11VAFramesContext::texture_infos
AVD3D11FrameDescriptor * texture_infos
In case if texture structure member above is not NULL contains the same texture pointer for all eleme...
Definition: hwcontext_d3d11va.h:175
AVD3D11VADeviceContext::lock_ctx
void * lock_ctx
Definition: hwcontext_d3d11va.h:96
NULL
#define NULL
Definition: coverity.c:32
d3d11va_default_lock
static void d3d11va_default_lock(void *ctx)
Definition: hwcontext_d3d11va.c:112
AVD3D11VADeviceContext::video_device
ID3D11VideoDevice * video_device
If unset, this will be set from the device field on init.
Definition: hwcontext_d3d11va.h:72
AV_PIX_FMT_YUYV422
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:74
wrap_texture_buf
static AVBufferRef * wrap_texture_buf(AVHWFramesContext *ctx, ID3D11Texture2D *tex, int index)
Definition: hwcontext_d3d11va.c:176
AVOnce
#define AVOnce
Definition: thread.h:202
index
int index
Definition: gxfenc.c:90
AVD3D11VADeviceContext::unlock
void(* unlock)(void *lock_ctx)
Definition: hwcontext_d3d11va.h:95
AVD3D11VAFramesContext
This struct is allocated as AVHWFramesContext.hwctx.
Definition: hwcontext_d3d11va.h:131
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
d3d11va_device_find_adapter_by_vendor_id
static int d3d11va_device_find_adapter_by_vendor_id(AVHWDeviceContext *ctx, uint32_t flags, const char *vendor_id)
Definition: hwcontext_d3d11va.c:564
AV_PIX_FMT_X2BGR10
#define AV_PIX_FMT_X2BGR10
Definition: pixfmt.h:537
AV_PIX_FMT_P012
#define AV_PIX_FMT_P012
Definition: pixfmt.h:529
size
int size
Definition: twinvq_data.h:10344
d3d11va_frames_init
static int d3d11va_frames_init(AVHWFramesContext *ctx)
Definition: hwcontext_d3d11va.c:264
mCreateDXGIFactory
static PFN_CREATE_DXGI_FACTORY mCreateDXGIFactory
Definition: hwcontext_d3d11va.c:49
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:461
free_texture
static void free_texture(void *opaque, uint8_t *data)
Definition: hwcontext_d3d11va.c:170
AV_PIX_FMT_Y212
#define AV_PIX_FMT_Y212
Definition: pixfmt.h:533
AVD3D11VAFramesContext::texture
ID3D11Texture2D * texture
The canonical texture used for pool allocation.
Definition: hwcontext_d3d11va.h:152
AV_PIX_FMT_D3D11
@ AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
Definition: pixfmt.h:336
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
DXGI_FORMAT_R16G16B16A16_FLOAT
@ DXGI_FORMAT_R16G16B16A16_FLOAT
Definition: dds.c:62
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
av_malloc_array
#define av_malloc_array(a, b)
Definition: tableprint_vlc.h:31
common.h
AVD3D11VADeviceContext
This struct is allocated as AVHWDeviceContext.hwctx.
Definition: hwcontext_d3d11va.h:45
AVD3D11FrameDescriptor::index
intptr_t index
The index into the array texture element representing the frame, or 0 if the texture is not an array ...
Definition: hwcontext_d3d11va.h:125
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
AVD3D11VADeviceContext::lock
void(* lock)(void *lock_ctx)
Callbacks for locking.
Definition: hwcontext_d3d11va.h:94
AVHWFrameTransferDirection
AVHWFrameTransferDirection
Definition: hwcontext.h:403
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:115
ret
ret
Definition: filter_design.txt:187
pixfmt.h
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:96
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
mD3D11CreateDevice
static PFN_D3D11_CREATE_DEVICE mD3D11CreateDevice
Definition: hwcontext_d3d11va.c:50
AVFrame::height
int height
Definition: frame.h:446
d3d11va_pool_alloc
static AVBufferRef * d3d11va_pool_alloc(void *opaque, size_t size)
Definition: hwcontext_d3d11va.c:243
pix_fmt
enum AVPixelFormat pix_fmt
Definition: hwcontext_d3d11va.c:93
av_image_copy2
static void av_image_copy2(uint8_t *const dst_data[4], const int dst_linesizes[4], uint8_t *const src_data[4], const int src_linesizes[4], enum AVPixelFormat pix_fmt, int width, int height)
Wrapper around av_image_copy() to workaround the limitation that the conversion from uint8_t * const ...
Definition: imgutils.h:184
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
D3D11VAFramesContext
Definition: hwcontext_d3d11va.c:77
d3d11va_device_uninit
static void d3d11va_device_uninit(AVHWDeviceContext *hwdev)
Definition: hwcontext_d3d11va.c:533
D3D11VAFramesContext::staging_texture
ID3D11Texture2D * staging_texture
Definition: hwcontext_d3d11va.c:88
AV_PIX_FMT_P010
#define AV_PIX_FMT_P010
Definition: pixfmt.h:528
desc
const char * desc
Definition: libsvtav1.c:79
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
d3d11va_device_init
static int d3d11va_device_init(AVHWDeviceContext *hwdev)
Definition: hwcontext_d3d11va.c:495
D3D11VAFramesContext::p
AVD3D11VAFramesContext p
The public AVD3D11VAFramesContext.
Definition: hwcontext_d3d11va.c:81
hwcontext_internal.h
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
AV_PIX_FMT_RGBAF16
#define AV_PIX_FMT_RGBAF16
Definition: pixfmt.h:546
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVD3D11FrameDescriptor
D3D11 frame descriptor for pool allocation.
Definition: hwcontext_d3d11va.h:109
imgutils.h
AV_PIX_FMT_XV36
#define AV_PIX_FMT_XV36
Definition: pixfmt.h:535
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
hwcontext.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:419
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
HWContextType
Definition: hwcontext_internal.h:29
AVD3D11VADeviceContext::device_context
ID3D11DeviceContext * device_context
If unset, this will be set from the device field on init.
Definition: hwcontext_d3d11va.h:64
ID3D11Device
void ID3D11Device
Definition: nvenc.h:28
h
h
Definition: vp9dsp_template.c:2038
AVDictionaryEntry::value
char * value
Definition: dict.h:91
AV_PIX_FMT_VUYX
@ AV_PIX_FMT_VUYX
packed VUYX 4:4:4, 32bpp, Variant of VUYA where alpha channel is left undefined
Definition: pixfmt.h:406
hwcontext_d3d11va.h
w32dlfcn.h
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2885