2 * This file is part of FFmpeg.
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.
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.
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
23 // Include thread.h before redefining _WIN32_WINNT, to get
24 // the right implementation for AVOnce
27 #if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600
29 #define _WIN32_WINNT 0x0600
38 #include <dxgidebug.h>
43 #include "hwcontext.h"
44 #include "hwcontext_d3d11va.h"
45 #include "hwcontext_internal.h"
50 typedef HRESULT(WINAPI *PFN_CREATE_DXGI_FACTORY)(REFIID riid, void **ppFactory);
52 static AVOnce functions_loaded = AV_ONCE_INIT;
54 static PFN_CREATE_DXGI_FACTORY mCreateDXGIFactory;
55 static PFN_D3D11_CREATE_DEVICE mD3D11CreateDevice;
57 static av_cold void load_functions(void)
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;
65 d3dlib = LoadLibrary("d3d11.dll");
66 dxgilib = LoadLibrary("dxgi.dll");
67 if (!d3dlib || !dxgilib)
70 mD3D11CreateDevice = (PFN_D3D11_CREATE_DEVICE) GetProcAddress(d3dlib, "D3D11CreateDevice");
71 mCreateDXGIFactory = (PFN_CREATE_DXGI_FACTORY) GetProcAddress(dxgilib, "CreateDXGIFactory");
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;
80 typedef struct D3D11VAFramesContext {
85 ID3D11Texture2D *staging_texture;
86 } D3D11VAFramesContext;
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 },
99 static void d3d11va_default_lock(void *ctx)
101 WaitForSingleObjectEx(ctx, INFINITE, FALSE);
104 static void d3d11va_default_unlock(void *ctx)
109 static void d3d11va_frames_uninit(AVHWFramesContext *ctx)
111 AVD3D11VAFramesContext *frames_hwctx = ctx->hwctx;
112 D3D11VAFramesContext *s = ctx->internal->priv;
114 if (frames_hwctx->texture)
115 ID3D11Texture2D_Release(frames_hwctx->texture);
116 frames_hwctx->texture = NULL;
118 if (s->staging_texture)
119 ID3D11Texture2D_Release(s->staging_texture);
120 s->staging_texture = NULL;
123 static int d3d11va_frames_get_constraints(AVHWDeviceContext *ctx,
124 const void *hwconfig,
125 AVHWFramesConstraints *constraints)
127 AVD3D11VADeviceContext *device_hwctx = ctx->hwctx;
128 int nb_sw_formats = 0;
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);
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;
143 constraints->valid_sw_formats[nb_sw_formats] = AV_PIX_FMT_NONE;
145 constraints->valid_hw_formats = av_malloc_array(2, sizeof(*constraints->valid_hw_formats));
146 if (!constraints->valid_hw_formats)
147 return AVERROR(ENOMEM);
149 constraints->valid_hw_formats[0] = AV_PIX_FMT_D3D11;
150 constraints->valid_hw_formats[1] = AV_PIX_FMT_NONE;
155 static void free_texture(void *opaque, uint8_t *data)
157 ID3D11Texture2D_Release((ID3D11Texture2D *)opaque);
161 static AVBufferRef *wrap_texture_buf(ID3D11Texture2D *tex, int index)
164 AVD3D11FrameDescriptor *desc = av_mallocz(sizeof(*desc));
166 ID3D11Texture2D_Release(tex);
173 buf = av_buffer_create((uint8_t *)desc, sizeof(desc), free_texture, tex, 0);
175 ID3D11Texture2D_Release(tex);
183 static AVBufferRef *d3d11va_alloc_single(AVHWFramesContext *ctx)
185 D3D11VAFramesContext *s = ctx->internal->priv;
186 AVD3D11VAFramesContext *hwctx = ctx->hwctx;
187 AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
189 ID3D11Texture2D *tex;
190 D3D11_TEXTURE2D_DESC texDesc = {
192 .Height = ctx->height,
195 .SampleDesc = { .Count = 1 },
197 .Usage = D3D11_USAGE_DEFAULT,
198 .BindFlags = hwctx->BindFlags,
199 .MiscFlags = hwctx->MiscFlags,
202 hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &tex);
204 av_log(ctx, AV_LOG_ERROR, "Could not create the texture (%lx)\n", (long)hr);
208 return wrap_texture_buf(tex, 0);
211 static AVBufferRef *d3d11va_pool_alloc(void *opaque, int size)
213 AVHWFramesContext *ctx = (AVHWFramesContext*)opaque;
214 D3D11VAFramesContext *s = ctx->internal->priv;
215 AVD3D11VAFramesContext *hwctx = ctx->hwctx;
216 D3D11_TEXTURE2D_DESC texDesc;
219 return d3d11va_alloc_single(ctx);
221 ID3D11Texture2D_GetDesc(hwctx->texture, &texDesc);
223 if (s->nb_surfaces_used >= texDesc.ArraySize) {
224 av_log(ctx, AV_LOG_ERROR, "Static surface pool size exceeded.\n");
228 ID3D11Texture2D_AddRef(hwctx->texture);
229 return wrap_texture_buf(hwctx->texture, s->nb_surfaces_used++);
232 static int d3d11va_frames_init(AVHWFramesContext *ctx)
234 AVD3D11VAFramesContext *hwctx = ctx->hwctx;
235 AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
236 D3D11VAFramesContext *s = ctx->internal->priv;
240 D3D11_TEXTURE2D_DESC texDesc;
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;
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);
254 texDesc = (D3D11_TEXTURE2D_DESC){
256 .Height = ctx->height,
259 .SampleDesc = { .Count = 1 },
260 .ArraySize = ctx->initial_pool_size,
261 .Usage = D3D11_USAGE_DEFAULT,
262 .BindFlags = hwctx->BindFlags,
263 .MiscFlags = hwctx->MiscFlags,
266 if (hwctx->texture) {
267 D3D11_TEXTURE2D_DESC texDesc2;
268 ID3D11Texture2D_GetDesc(hwctx->texture, &texDesc2);
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);
276 } else if (texDesc.ArraySize > 0) {
277 hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &hwctx->texture);
279 av_log(ctx, AV_LOG_ERROR, "Could not create the texture (%lx)\n", (long)hr);
280 return AVERROR_UNKNOWN;
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);
292 static int d3d11va_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
294 AVD3D11FrameDescriptor *desc;
296 frame->buf[0] = av_buffer_pool_get(ctx->pool);
298 return AVERROR(ENOMEM);
300 desc = (AVD3D11FrameDescriptor *)frame->buf[0]->data;
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;
311 static int d3d11va_transfer_get_formats(AVHWFramesContext *ctx,
312 enum AVHWFrameTransferDirection dir,
313 enum AVPixelFormat **formats)
315 D3D11VAFramesContext *s = ctx->internal->priv;
316 enum AVPixelFormat *fmts;
318 fmts = av_malloc_array(2, sizeof(*fmts));
320 return AVERROR(ENOMEM);
322 fmts[0] = ctx->sw_format;
323 fmts[1] = AV_PIX_FMT_NONE;
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;
334 static int d3d11va_create_staging_texture(AVHWFramesContext *ctx)
336 AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
337 D3D11VAFramesContext *s = ctx->internal->priv;
339 D3D11_TEXTURE2D_DESC texDesc = {
341 .Height = ctx->height,
344 .SampleDesc = { .Count = 1 },
346 .Usage = D3D11_USAGE_STAGING,
347 .CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE,
350 hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &s->staging_texture);
352 av_log(ctx, AV_LOG_ERROR, "Could not create the staging texture (%lx)\n", (long)hr);
353 return AVERROR_UNKNOWN;
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)
366 for (i = 0; i < 4; i++)
367 linesize[i] = map->RowPitch;
369 av_image_fill_pointers(data, ctx->sw_format, desc->Height,
370 (uint8_t*)map->pData, linesize);
373 static int d3d11va_transfer_data(AVHWFramesContext *ctx, AVFrame *dst,
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];
389 D3D11_TEXTURE2D_DESC desc;
390 D3D11_MAPPED_SUBRESOURCE map;
393 if (frame->hw_frames_ctx->data != (uint8_t *)ctx || other->format != ctx->sw_format)
394 return AVERROR(EINVAL);
396 device_hwctx->lock(device_hwctx->lock_ctx);
398 if (!s->staging_texture) {
399 int res = d3d11va_create_staging_texture(ctx);
404 staging = (ID3D11Resource *)s->staging_texture;
406 ID3D11Texture2D_GetDesc(s->staging_texture, &desc);
409 ID3D11DeviceContext_CopySubresourceRegion(device_hwctx->device_context,
411 texture, index, NULL);
413 hr = ID3D11DeviceContext_Map(device_hwctx->device_context,
414 staging, 0, D3D11_MAP_READ, 0, &map);
418 fill_texture_ptrs(map_data, map_linesize, ctx, &desc, &map);
420 av_image_copy(dst->data, dst->linesize, map_data, map_linesize,
421 ctx->sw_format, w, h);
423 ID3D11DeviceContext_Unmap(device_hwctx->device_context, staging, 0);
425 hr = ID3D11DeviceContext_Map(device_hwctx->device_context,
426 staging, 0, D3D11_MAP_WRITE, 0, &map);
430 fill_texture_ptrs(map_data, map_linesize, ctx, &desc, &map);
432 av_image_copy(map_data, map_linesize, src->data, src->linesize,
433 ctx->sw_format, w, h);
435 ID3D11DeviceContext_Unmap(device_hwctx->device_context, staging, 0);
437 ID3D11DeviceContext_CopySubresourceRegion(device_hwctx->device_context,
438 texture, index, 0, 0, 0,
442 device_hwctx->unlock(device_hwctx->lock_ctx);
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;
451 static int d3d11va_device_init(AVHWDeviceContext *hwdev)
453 AVD3D11VADeviceContext *device_hwctx = hwdev->hwctx;
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);
462 device_hwctx->lock = d3d11va_default_lock;
463 device_hwctx->unlock = d3d11va_default_unlock;
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;
472 if (!device_hwctx->video_device) {
473 hr = ID3D11DeviceContext_QueryInterface(device_hwctx->device, &IID_ID3D11VideoDevice,
474 (void **)&device_hwctx->video_device);
476 return AVERROR_UNKNOWN;
479 if (!device_hwctx->video_context) {
480 hr = ID3D11DeviceContext_QueryInterface(device_hwctx->device_context, &IID_ID3D11VideoContext,
481 (void **)&device_hwctx->video_context);
483 return AVERROR_UNKNOWN;
489 static void d3d11va_device_uninit(AVHWDeviceContext *hwdev)
491 AVD3D11VADeviceContext *device_hwctx = hwdev->hwctx;
493 if (device_hwctx->device) {
494 ID3D11Device_Release(device_hwctx->device);
495 device_hwctx->device = NULL;
498 if (device_hwctx->device_context) {
499 ID3D11DeviceContext_Release(device_hwctx->device_context);
500 device_hwctx->device_context = NULL;
503 if (device_hwctx->video_device) {
504 ID3D11VideoDevice_Release(device_hwctx->video_device);
505 device_hwctx->video_device = NULL;
508 if (device_hwctx->video_context) {
509 ID3D11VideoContext_Release(device_hwctx->video_context);
510 device_hwctx->video_context = NULL;
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;
520 static int d3d11va_device_create(AVHWDeviceContext *ctx, const char *device,
521 AVDictionary *opts, int flags)
523 AVD3D11VADeviceContext *device_hwctx = ctx->hwctx;
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);
532 // (On UWP we can't check this.)
534 if (!LoadLibrary("d3d11_1sdklayers.dll"))
539 creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
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;
549 IDXGIFactory2 *pDXGIFactory;
550 hr = mCreateDXGIFactory(&IID_IDXGIFactory2, (void **)&pDXGIFactory);
552 int adapter = atoi(device);
553 if (FAILED(IDXGIFactory2_EnumAdapters(pDXGIFactory, adapter, &pAdapter)))
555 IDXGIFactory2_Release(pDXGIFactory);
560 DXGI_ADAPTER_DESC2 desc;
561 hr = IDXGIAdapter2_GetDesc(pAdapter, &desc);
563 av_log(ctx, AV_LOG_INFO, "Using device %04x:%04x (%ls).\n",
564 desc.VendorId, desc.DeviceId, desc.Description);
568 hr = mD3D11CreateDevice(pAdapter, pAdapter ? D3D_DRIVER_TYPE_UNKNOWN : D3D_DRIVER_TYPE_HARDWARE, NULL, creationFlags, NULL, 0,
569 D3D11_SDK_VERSION, &device_hwctx->device, NULL, NULL);
571 IDXGIAdapter_Release(pAdapter);
573 av_log(ctx, AV_LOG_ERROR, "Failed to create Direct3D device (%lx)\n", (long)hr);
574 return AVERROR_UNKNOWN;
577 hr = ID3D11Device_QueryInterface(device_hwctx->device, &IID_ID3D10Multithread, (void **)&pMultithread);
579 ID3D10Multithread_SetMultithreadProtected(pMultithread, TRUE);
580 ID3D10Multithread_Release(pMultithread);
583 #if !HAVE_UWP && HAVE_DXGIDEBUG_H
585 HANDLE dxgidebug_dll = LoadLibrary("dxgidebug.dll");
587 HRESULT (WINAPI * pf_DXGIGetDebugInterface)(const GUID *riid, void **ppDebug)
588 = (void *)GetProcAddress(dxgidebug_dll, "DXGIGetDebugInterface");
589 if (pf_DXGIGetDebugInterface) {
590 IDXGIDebug *dxgi_debug = NULL;
591 hr = pf_DXGIGetDebugInterface(&IID_IDXGIDebug, (void**)&dxgi_debug);
592 if (SUCCEEDED(hr) && dxgi_debug)
593 IDXGIDebug_ReportLiveObjects(dxgi_debug, DXGI_DEBUG_ALL, DXGI_DEBUG_RLO_ALL);
602 const HWContextType ff_hwcontext_type_d3d11va = {
603 .type = AV_HWDEVICE_TYPE_D3D11VA,
606 .device_hwctx_size = sizeof(AVD3D11VADeviceContext),
607 .frames_hwctx_size = sizeof(AVD3D11VAFramesContext),
608 .frames_priv_size = sizeof(D3D11VAFramesContext),
610 .device_create = d3d11va_device_create,
611 .device_init = d3d11va_device_init,
612 .device_uninit = d3d11va_device_uninit,
613 .frames_get_constraints = d3d11va_frames_get_constraints,
614 .frames_init = d3d11va_frames_init,
615 .frames_uninit = d3d11va_frames_uninit,
616 .frames_get_buffer = d3d11va_get_buffer,
617 .transfer_get_formats = d3d11va_transfer_get_formats,
618 .transfer_data_to = d3d11va_transfer_data,
619 .transfer_data_from = d3d11va_transfer_data,
621 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_D3D11, AV_PIX_FMT_NONE },