0a8cc5bc21f846a7f48346d4f8ffafb20c1d0f9e
[libav.git] / libavutil / hwcontext_d3d11va.c
1 /*
2 * This file is part of Libav.
3 *
4 * Libav 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 * Libav 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 Libav; 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 void free_texture(void *opaque, uint8_t *data)
124 {
125 ID3D11Texture2D_Release((ID3D11Texture2D *)opaque);
126 }
127
128 static AVBufferRef *wrap_texture_buf(ID3D11Texture2D *tex, int index)
129 {
130 AVBufferRef *buf;
131 AVD3D11FrameDescriptor *desc = av_mallocz(sizeof(*desc));
132 if (!desc) {
133 ID3D11Texture2D_Release(tex);
134 return NULL;
135 }
136
137 desc->texture = tex;
138 desc->index = index;
139
140 buf = av_buffer_create((uint8_t *)desc, sizeof(desc), free_texture, tex, 0);
141 if (!buf) {
142 ID3D11Texture2D_Release(tex);
143 av_free(desc);
144 return NULL;
145 }
146
147 return buf;
148 }
149
150 static AVBufferRef *d3d11va_alloc_single(AVHWFramesContext *ctx)
151 {
152 D3D11VAFramesContext *s = ctx->internal->priv;
153 AVD3D11VAFramesContext *hwctx = ctx->hwctx;
154 AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
155 HRESULT hr;
156 ID3D11Texture2D *tex;
157 D3D11_TEXTURE2D_DESC texDesc = {
158 .Width = ctx->width,
159 .Height = ctx->height,
160 .MipLevels = 1,
161 .Format = s->format,
162 .SampleDesc = { .Count = 1 },
163 .ArraySize = 1,
164 .Usage = D3D11_USAGE_DEFAULT,
165 .BindFlags = hwctx->BindFlags,
166 .MiscFlags = hwctx->MiscFlags,
167 };
168
169 hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &tex);
170 if (FAILED(hr)) {
171 av_log(ctx, AV_LOG_ERROR, "Could not create the texture (%lx)\n", (long)hr);
172 return NULL;
173 }
174
175 return wrap_texture_buf(tex, 0);
176 }
177
178 static AVBufferRef *d3d11va_pool_alloc(void *opaque, int size)
179 {
180 AVHWFramesContext *ctx = (AVHWFramesContext*)opaque;
181 D3D11VAFramesContext *s = ctx->internal->priv;
182 AVD3D11VAFramesContext *hwctx = ctx->hwctx;
183 D3D11_TEXTURE2D_DESC texDesc;
184
185 if (!hwctx->texture)
186 return d3d11va_alloc_single(ctx);
187
188 ID3D11Texture2D_GetDesc(hwctx->texture, &texDesc);
189
190 if (s->nb_surfaces_used >= texDesc.ArraySize) {
191 av_log(ctx, AV_LOG_ERROR, "Static surface pool size exceeded.\n");
192 return NULL;
193 }
194
195 ID3D11Texture2D_AddRef(hwctx->texture);
196 return wrap_texture_buf(hwctx->texture, s->nb_surfaces_used++);
197 }
198
199 static int d3d11va_frames_init(AVHWFramesContext *ctx)
200 {
201 AVD3D11VAFramesContext *hwctx = ctx->hwctx;
202 AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
203 D3D11VAFramesContext *s = ctx->internal->priv;
204
205 int i;
206 HRESULT hr;
207 D3D11_TEXTURE2D_DESC texDesc;
208
209 for (i = 0; i < FF_ARRAY_ELEMS(supported_formats); i++) {
210 if (ctx->sw_format == supported_formats[i].pix_fmt) {
211 s->format = supported_formats[i].d3d_format;
212 break;
213 }
214 }
215 if (i == FF_ARRAY_ELEMS(supported_formats)) {
216 av_log(ctx, AV_LOG_ERROR, "Unsupported pixel format: %s\n",
217 av_get_pix_fmt_name(ctx->sw_format));
218 return AVERROR(EINVAL);
219 }
220
221 texDesc = (D3D11_TEXTURE2D_DESC){
222 .Width = ctx->width,
223 .Height = ctx->height,
224 .MipLevels = 1,
225 .Format = s->format,
226 .SampleDesc = { .Count = 1 },
227 .ArraySize = ctx->initial_pool_size,
228 .Usage = D3D11_USAGE_DEFAULT,
229 .BindFlags = hwctx->BindFlags,
230 .MiscFlags = hwctx->MiscFlags,
231 };
232
233 if (hwctx->texture) {
234 D3D11_TEXTURE2D_DESC texDesc2;
235 ID3D11Texture2D_GetDesc(hwctx->texture, &texDesc2);
236
237 if (texDesc.Width != texDesc2.Width ||
238 texDesc.Height != texDesc2.Height ||
239 texDesc.Format != texDesc2.Format) {
240 av_log(ctx, AV_LOG_ERROR, "User-provided texture has mismatching parameters\n");
241 return AVERROR(EINVAL);
242 }
243 } else if (texDesc.ArraySize > 0) {
244 hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &hwctx->texture);
245 if (FAILED(hr)) {
246 av_log(ctx, AV_LOG_ERROR, "Could not create the texture (%lx)\n", (long)hr);
247 return AVERROR_UNKNOWN;
248 }
249 }
250
251 ctx->internal->pool_internal = av_buffer_pool_init2(sizeof(AVD3D11FrameDescriptor),
252 ctx, d3d11va_pool_alloc, NULL);
253 if (!ctx->internal->pool_internal)
254 return AVERROR(ENOMEM);
255
256 return 0;
257 }
258
259 static int d3d11va_get_buffer(AVHWFramesContext *ctx, AVFrame *frame)
260 {
261 AVD3D11FrameDescriptor *desc;
262
263 frame->buf[0] = av_buffer_pool_get(ctx->pool);
264 if (!frame->buf[0])
265 return AVERROR(ENOMEM);
266
267 desc = (AVD3D11FrameDescriptor *)frame->buf[0]->data;
268
269 frame->data[0] = (uint8_t *)desc->texture;
270 frame->data[1] = (uint8_t *)desc->index;
271 frame->format = AV_PIX_FMT_D3D11;
272 frame->width = ctx->width;
273 frame->height = ctx->height;
274
275 return 0;
276 }
277
278 static int d3d11va_transfer_get_formats(AVHWFramesContext *ctx,
279 enum AVHWFrameTransferDirection dir,
280 enum AVPixelFormat **formats)
281 {
282 D3D11VAFramesContext *s = ctx->internal->priv;
283 enum AVPixelFormat *fmts;
284
285 fmts = av_malloc_array(2, sizeof(*fmts));
286 if (!fmts)
287 return AVERROR(ENOMEM);
288
289 fmts[0] = ctx->sw_format;
290 fmts[1] = AV_PIX_FMT_NONE;
291
292 // Don't signal support for opaque formats. Actual access would fail.
293 if (s->format == DXGI_FORMAT_420_OPAQUE)
294 fmts[0] = AV_PIX_FMT_NONE;
295
296 *formats = fmts;
297
298 return 0;
299 }
300
301 static int d3d11va_create_staging_texture(AVHWFramesContext *ctx)
302 {
303 AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
304 D3D11VAFramesContext *s = ctx->internal->priv;
305 HRESULT hr;
306 D3D11_TEXTURE2D_DESC texDesc = {
307 .Width = ctx->width,
308 .Height = ctx->height,
309 .MipLevels = 1,
310 .Format = s->format,
311 .SampleDesc = { .Count = 1 },
312 .ArraySize = 1,
313 .Usage = D3D11_USAGE_STAGING,
314 .CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE,
315 };
316
317 hr = ID3D11Device_CreateTexture2D(device_hwctx->device, &texDesc, NULL, &s->staging_texture);
318 if (FAILED(hr)) {
319 av_log(ctx, AV_LOG_ERROR, "Could not create the staging texture (%lx)\n", (long)hr);
320 return AVERROR_UNKNOWN;
321 }
322
323 return 0;
324 }
325
326 static void fill_texture_ptrs(uint8_t *data[4], int linesize[4],
327 AVHWFramesContext *ctx,
328 D3D11_TEXTURE2D_DESC *desc,
329 D3D11_MAPPED_SUBRESOURCE *map)
330 {
331 int i;
332
333 for (i = 0; i < 4; i++)
334 linesize[i] = map->RowPitch;
335
336 av_image_fill_pointers(data, ctx->sw_format, desc->Height,
337 (uint8_t*)map->pData, linesize);
338 }
339
340 static int d3d11va_transfer_data(AVHWFramesContext *ctx, AVFrame *dst,
341 const AVFrame *src)
342 {
343 AVD3D11VADeviceContext *device_hwctx = ctx->device_ctx->hwctx;
344 D3D11VAFramesContext *s = ctx->internal->priv;
345 int download = src->format == AV_PIX_FMT_D3D11;
346 const AVFrame *frame = download ? src : dst;
347 const AVFrame *other = download ? dst : src;
348 // (The interface types are compatible.)
349 ID3D11Resource *texture = (ID3D11Resource *)(ID3D11Texture2D *)frame->data[0];
350 int index = (intptr_t)frame->data[1];
351 ID3D11Resource *staging;
352 int w = FFMIN(dst->width, src->width);
353 int h = FFMIN(dst->height, src->height);
354 uint8_t *map_data[4];
355 int map_linesize[4];
356 D3D11_TEXTURE2D_DESC desc;
357 D3D11_MAPPED_SUBRESOURCE map;
358 HRESULT hr;
359
360 if (frame->hw_frames_ctx->data != (uint8_t *)ctx || other->format != ctx->sw_format)
361 return AVERROR(EINVAL);
362
363 device_hwctx->lock(device_hwctx->lock_ctx);
364
365 if (!s->staging_texture) {
366 int res = d3d11va_create_staging_texture(ctx);
367 if (res < 0)
368 return res;
369 }
370
371 staging = (ID3D11Resource *)s->staging_texture;
372
373 ID3D11Texture2D_GetDesc(s->staging_texture, &desc);
374
375 if (download) {
376 ID3D11DeviceContext_CopySubresourceRegion(device_hwctx->device_context,
377 staging, 0, 0, 0, 0,
378 texture, index, NULL);
379
380 hr = ID3D11DeviceContext_Map(device_hwctx->device_context,
381 staging, 0, D3D11_MAP_READ, 0, &map);
382 if (FAILED(hr))
383 goto map_failed;
384
385 fill_texture_ptrs(map_data, map_linesize, ctx, &desc, &map);
386
387 av_image_copy(dst->data, dst->linesize, map_data, map_linesize,
388 ctx->sw_format, w, h);
389
390 ID3D11DeviceContext_Unmap(device_hwctx->device_context, staging, 0);
391 } else {
392 hr = ID3D11DeviceContext_Map(device_hwctx->device_context,
393 staging, 0, D3D11_MAP_WRITE, 0, &map);
394 if (FAILED(hr))
395 goto map_failed;
396
397 fill_texture_ptrs(map_data, map_linesize, ctx, &desc, &map);
398
399 av_image_copy(map_data, map_linesize, src->data, src->linesize,
400 ctx->sw_format, w, h);
401
402 ID3D11DeviceContext_Unmap(device_hwctx->device_context, staging, 0);
403
404 ID3D11DeviceContext_CopySubresourceRegion(device_hwctx->device_context,
405 texture, index, 0, 0, 0,
406 staging, 0, NULL);
407 }
408
409 device_hwctx->unlock(device_hwctx->lock_ctx);
410 return 0;
411
412 map_failed:
413 av_log(ctx, AV_LOG_ERROR, "Unable to lock D3D11VA surface (%lx)\n", (long)hr);
414 device_hwctx->unlock(device_hwctx->lock_ctx);
415 return AVERROR_UNKNOWN;
416 }
417
418 static int d3d11va_device_init(AVHWDeviceContext *hwdev)
419 {
420 AVD3D11VADeviceContext *device_hwctx = hwdev->hwctx;
421 HRESULT hr;
422
423 if (!device_hwctx->lock) {
424 device_hwctx->lock_ctx = CreateMutex(NULL, 0, NULL);
425 if (device_hwctx->lock_ctx == INVALID_HANDLE_VALUE) {
426 av_log(NULL, AV_LOG_ERROR, "Failed to create a mutex\n");
427 return AVERROR(EINVAL);
428 }
429 device_hwctx->lock = d3d11va_default_lock;
430 device_hwctx->unlock = d3d11va_default_unlock;
431 }
432
433 if (!device_hwctx->device_context) {
434 ID3D11Device_GetImmediateContext(device_hwctx->device, &device_hwctx->device_context);
435 if (!device_hwctx->device_context)
436 return AVERROR_UNKNOWN;
437 }
438
439 if (!device_hwctx->video_device) {
440 hr = ID3D11DeviceContext_QueryInterface(device_hwctx->device, &IID_ID3D11VideoDevice,
441 (void **)&device_hwctx->video_device);
442 if (FAILED(hr))
443 return AVERROR_UNKNOWN;
444 }
445
446 if (!device_hwctx->video_context) {
447 hr = ID3D11DeviceContext_QueryInterface(device_hwctx->device_context, &IID_ID3D11VideoContext,
448 (void **)&device_hwctx->video_context);
449 if (FAILED(hr))
450 return AVERROR_UNKNOWN;
451 }
452
453 return 0;
454 }
455
456 static void d3d11va_device_uninit(AVHWDeviceContext *hwdev)
457 {
458 AVD3D11VADeviceContext *device_hwctx = hwdev->hwctx;
459
460 if (device_hwctx->device)
461 ID3D11Device_Release(device_hwctx->device);
462
463 if (device_hwctx->device_context)
464 ID3D11DeviceContext_Release(device_hwctx->device_context);
465
466 if (device_hwctx->video_device)
467 ID3D11VideoDevice_Release(device_hwctx->video_device);
468
469 if (device_hwctx->video_context)
470 ID3D11VideoContext_Release(device_hwctx->video_context);
471
472 if (device_hwctx->lock == d3d11va_default_lock)
473 CloseHandle(device_hwctx->lock_ctx);
474 }
475
476 static int d3d11va_device_create(AVHWDeviceContext *ctx, const char *device,
477 AVDictionary *opts, int flags)
478 {
479 AVD3D11VADeviceContext *device_hwctx = ctx->hwctx;
480
481 HRESULT hr;
482 IDXGIAdapter *pAdapter = NULL;
483 ID3D10Multithread *pMultithread;
484 UINT creationFlags = D3D11_CREATE_DEVICE_VIDEO_SUPPORT;
485 int is_debug = !!av_dict_get(opts, "debug", NULL, 0);
486 int ret;
487
488 // (On UWP we can't check this.)
489 #if !HAVE_UWP
490 if (!LoadLibrary("d3d11_1sdklayers.dll"))
491 is_debug = 0;
492 #endif
493
494 if (is_debug)
495 creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
496
497 if ((ret = ff_thread_once(&functions_loaded, load_functions)) != 0)
498 return AVERROR_UNKNOWN;
499 if (!mD3D11CreateDevice || !mCreateDXGIFactory) {
500 av_log(ctx, AV_LOG_ERROR, "Failed to load D3D11 library or its functions\n");
501 return AVERROR_UNKNOWN;
502 }
503
504 if (device) {
505 IDXGIFactory2 *pDXGIFactory;
506 hr = mCreateDXGIFactory(&IID_IDXGIFactory2, (void **)&pDXGIFactory);
507 if (SUCCEEDED(hr)) {
508 int adapter = atoi(device);
509 if (FAILED(IDXGIFactory2_EnumAdapters(pDXGIFactory, adapter, &pAdapter)))
510 pAdapter = NULL;
511 IDXGIFactory2_Release(pDXGIFactory);
512 }
513 }
514
515 hr = mD3D11CreateDevice(pAdapter, pAdapter ? D3D_DRIVER_TYPE_UNKNOWN : D3D_DRIVER_TYPE_HARDWARE, NULL, creationFlags, NULL, 0,
516 D3D11_SDK_VERSION, &device_hwctx->device, NULL, NULL);
517 if (pAdapter)
518 IDXGIAdapter_Release(pAdapter);
519 if (FAILED(hr)) {
520 av_log(ctx, AV_LOG_ERROR, "Failed to create Direct3D device (%lx)\n", (long)hr);
521 return AVERROR_UNKNOWN;
522 }
523
524 hr = ID3D11Device_QueryInterface(device_hwctx->device, &IID_ID3D10Multithread, (void **)&pMultithread);
525 if (SUCCEEDED(hr)) {
526 ID3D10Multithread_SetMultithreadProtected(pMultithread, TRUE);
527 ID3D10Multithread_Release(pMultithread);
528 }
529
530 #if !HAVE_UWP && HAVE_DXGIDEBUG_H
531 if (is_debug) {
532 HANDLE dxgidebug_dll = LoadLibrary("dxgidebug.dll");
533 if (dxgidebug_dll) {
534 HRESULT (WINAPI * pf_DXGIGetDebugInterface)(const GUID *riid, void **ppDebug)
535 = (void *)GetProcAddress(dxgidebug_dll, "DXGIGetDebugInterface");
536 if (pf_DXGIGetDebugInterface) {
537 IDXGIDebug *dxgi_debug = NULL;
538 hr = pf_DXGIGetDebugInterface(&IID_IDXGIDebug, (void**)&dxgi_debug);
539 if (SUCCEEDED(hr) && dxgi_debug)
540 IDXGIDebug_ReportLiveObjects(dxgi_debug, DXGI_DEBUG_ALL, DXGI_DEBUG_RLO_ALL);
541 }
542 }
543 }
544 #endif
545
546 return 0;
547 }
548
549 const HWContextType ff_hwcontext_type_d3d11va = {
550 .type = AV_HWDEVICE_TYPE_D3D11VA,
551 .name = "D3D11VA",
552
553 .device_hwctx_size = sizeof(AVD3D11VADeviceContext),
554 .frames_hwctx_size = sizeof(AVD3D11VAFramesContext),
555 .frames_priv_size = sizeof(D3D11VAFramesContext),
556
557 .device_create = d3d11va_device_create,
558 .device_init = d3d11va_device_init,
559 .device_uninit = d3d11va_device_uninit,
560 .frames_init = d3d11va_frames_init,
561 .frames_uninit = d3d11va_frames_uninit,
562 .frames_get_buffer = d3d11va_get_buffer,
563 .transfer_get_formats = d3d11va_transfer_get_formats,
564 .transfer_data_to = d3d11va_transfer_data,
565 .transfer_data_from = d3d11va_transfer_data,
566
567 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_D3D11, AV_PIX_FMT_NONE },
568 };