?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3d11_fmt: group the ID3D11Device and ID3D11DeviceContext in a structure
[vlc.git] / modules / codec / avcodec / d3d11va.c
blobcfea13cc7b6b9cf417866a8c669a970beb00872e
1 /*****************************************************************************
2 * d3d11va.c: Direct3D11 Video Acceleration decoder
3 *****************************************************************************
4 * Copyright © 2009 Geoffroy Couprie
5 * Copyright © 2009 Laurent Aimar
6 * Copyright © 2015 Steve Lhomme
7 * Copyright © 2015 VideoLabs
8 *
9 * Authors: Geoffroy Couprie <geal@videolan.org>
10 * Laurent Aimar <fenrir _AT_ videolan _DOT_ org>
11 * Steve Lhomme <robux4@gmail.com>
12 *
13 * This program is free software; you can redistribute it and/or modify it
14 * under the terms of the GNU Lesser General Public License as published by
15 * the Free Software Foundation; either version 2.1 of the License, or
16 * (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License for more details.
22 *
23 * You should have received a copy of the GNU Lesser General Public License
24 * along with this program; if not, write to the Free Software Foundation,
25 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
26 *****************************************************************************/
27
28 /**
29 * See https://msdn.microsoft.com/en-us/library/windows/desktop/hh162912%28v=vs.85%29.aspx
30 **/
31 #ifdef HAVE_CONFIG_H
32 # include "config.h"
33 #endif
34
35 # undef WINAPI_FAMILY
36 # define WINAPI_FAMILY WINAPI_FAMILY_DESKTOP_APP
37
38 #include <assert.h>
39
40 #include <vlc_common.h>
41 #include <vlc_picture.h>
42 #include <vlc_plugin.h>
43 #include <vlc_charset.h>
44 #include <vlc_codec.h>
45
46 #define COBJMACROS
47 #include <initguid.h>
48 #include <d3d11.h>
49 #include <libavcodec/d3d11va.h>
50
51 #include "../../video_chroma/d3d11_fmt.h"
52
53 #define D3D_Device ID3D11Device
54 #define D3D_DecoderType ID3D11VideoDecoder
55 #define D3D_DecoderDevice ID3D11VideoDevice
56 #define D3D_DecoderSurface ID3D11VideoDecoderOutputView
57 #include "directx_va.h"
58
59 static int Open(vlc_va_t *, AVCodecContext *, enum PixelFormat,
60 const es_format_t *, picture_sys_t *p_sys);
61 static void Close(vlc_va_t *, void **);
62
63 vlc_module_begin()
64 set_description(N_("Direct3D11 Video Acceleration"))
65 set_capability("hw decoder", 110)
66 set_category(CAT_INPUT)
67 set_subcategory(SUBCAT_INPUT_VCODEC)
68 set_callbacks(Open, Close)
69 vlc_module_end()
70
71 /*
72 * In this mode libavcodec doesn't need the whole array on texture on startup
73 * So we get the surfaces from the decoder pool when needed. We don't need to
74 * extract the decoded surface into the decoder picture anymore.
75 */
76 #define D3D11_DIRECT_DECODE LIBAVCODEC_VERSION_CHECK( 57, 30, 3, 72, 101 )
77
78 #include <initguid.h> /* must be last included to not redefine existing GUIDs */
79
80 /* dxva2api.h GUIDs: http://msdn.microsoft.com/en-us/library/windows/desktop/ms697067(v=vs100).aspx
81 * assume that they are declared in dxva2api.h */
82 #define MS_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8)
83
84 #ifdef __MINGW32__
85 # include <_mingw.h>
86
87 # if !defined(__MINGW64_VERSION_MAJOR)
88 # undef MS_GUID
89 # define MS_GUID DEFINE_GUID /* dxva2api.h fails to declare those, redefine as static */
90 # define DXVA2_E_NEW_VIDEO_DEVICE MAKE_HRESULT(1, 4, 4097)
91 # else
92 # include <dxva.h>
93 # endif
94
95 #endif /* __MINGW32__ */
96
97 #if !defined(NDEBUG) && defined(HAVE_DXGIDEBUG_H)
98 # include <dxgidebug.h>
99 #endif
100
101 DEFINE_GUID(DXVA_Intel_H264_NoFGT_ClearVideo, 0x604F8E68, 0x4951, 0x4c54, 0x88, 0xFE, 0xAB, 0xD2, 0x5C, 0x15, 0xB3, 0xD6);
102
103 DEFINE_GUID(DXVA2_NoEncrypt, 0x1b81bed0, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);
104
105 struct vlc_va_sys_t
106 {
107 directx_sys_t dx_sys;
108 UINT totalTextureSlices;
109 unsigned textureWidth;
110 unsigned textureHeight;
111
112 #if !defined(NDEBUG) && defined(HAVE_DXGIDEBUG_H)
113 HINSTANCE dxgidebug_dll;
114 #endif
115
116 /* Video service */
117 ID3D11VideoContext *d3dvidctx;
118 DXGI_FORMAT render;
119
120 ID3D11DeviceContext *d3dctx;
121 HANDLE context_mutex;
122
123 /* pool */
124 picture_t *extern_pics[MAX_SURFACE_COUNT];
125
126 /* Video decoder */
127 D3D11_VIDEO_DECODER_CONFIG cfg;
128
129 /* avcodec internals */
130 struct AVD3D11VAContext hw;
131
132 ID3D11ShaderResourceView *resourceView[MAX_SURFACE_COUNT * D3D11_MAX_SHADER_VIEW];
133 };
134
135 /* */
136 static int D3dCreateDevice(vlc_va_t *);
137 static void D3dDestroyDevice(vlc_va_t *);
138 static char *DxDescribe(directx_sys_t *);
139
140 static int DxCreateVideoService(vlc_va_t *);
141 static void DxDestroyVideoService(vlc_va_t *);
142 static int DxGetInputList(vlc_va_t *, input_list_t *);
143 static int DxSetupOutput(vlc_va_t *, const GUID *, const video_format_t *);
144
145 static int DxCreateDecoderSurfaces(vlc_va_t *, int codec_id,
146 const video_format_t *fmt, unsigned surface_count);
147 static void DxDestroySurfaces(vlc_va_t *);
148 static void SetupAVCodecContext(vlc_va_t *);
149
150 void SetupAVCodecContext(vlc_va_t *va)
151 {
152 vlc_va_sys_t *sys = va->sys;
153 directx_sys_t *dx_sys = &sys->dx_sys;
154
155 sys->hw.video_context = sys->d3dvidctx;
156 sys->hw.decoder = dx_sys->decoder;
157 sys->hw.cfg = &sys->cfg;
158 sys->hw.surface_count = dx_sys->va_pool.surface_count;
159 sys->hw.surface = dx_sys->hw_surface;
160 sys->hw.context_mutex = sys->context_mutex;
161
162 if (IsEqualGUID(&dx_sys->input, &DXVA_Intel_H264_NoFGT_ClearVideo))
163 sys->hw.workaround |= FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO;
164 }
165
166 static void d3d11_pic_context_destroy(struct picture_context_t *opaque)
167 {
168 struct va_pic_context *pic_ctx = (struct va_pic_context*)opaque;
169 if (pic_ctx->va_surface)
170 va_surface_Release(pic_ctx->va_surface);
171 ReleasePictureSys(&pic_ctx->picsys);
172 free(pic_ctx);
173 }
174
175 static struct va_pic_context *CreatePicContext(ID3D11VideoDecoderOutputView *,
176 ID3D11Resource *,
177 ID3D11DeviceContext *,
178 UINT slice,
179 ID3D11ShaderResourceView *resourceView[D3D11_MAX_SHADER_VIEW]);
180
181 static struct picture_context_t *d3d11_pic_context_copy(struct picture_context_t *ctx)
182 {
183 struct va_pic_context *src_ctx = (struct va_pic_context*)ctx;
184 struct va_pic_context *pic_ctx = CreatePicContext(src_ctx->picsys.decoder,
185 src_ctx->picsys.resource[0], src_ctx->picsys.context,
186 src_ctx->picsys.slice_index, src_ctx->picsys.resourceView);
187 if (unlikely(pic_ctx==NULL))
188 return NULL;
189 if (src_ctx->va_surface) {
190 pic_ctx->va_surface = src_ctx->va_surface;
191 va_surface_AddRef(pic_ctx->va_surface);
192 }
193 return &pic_ctx->s;
194 }
195
196 static struct va_pic_context *CreatePicContext(
197 ID3D11VideoDecoderOutputView *decoderSurface,
198 ID3D11Resource *p_resource,
199 ID3D11DeviceContext *context,
200 UINT slice,
201 ID3D11ShaderResourceView *resourceView[D3D11_MAX_SHADER_VIEW])
202 {
203 struct va_pic_context *pic_ctx = calloc(1, sizeof(*pic_ctx));
204 if (unlikely(pic_ctx==NULL))
205 goto done;
206 pic_ctx->s.destroy = d3d11_pic_context_destroy;
207 pic_ctx->s.copy = d3d11_pic_context_copy;
208
209 D3D11_TEXTURE2D_DESC txDesc;
210 ID3D11Texture2D_GetDesc((ID3D11Texture2D*)p_resource, &txDesc);
211
212 pic_ctx->picsys.formatTexture = txDesc.Format;
213 pic_ctx->picsys.context = context;
214 pic_ctx->picsys.slice_index = slice;
215 pic_ctx->picsys.decoder = decoderSurface;
216 for (int i=0;i<D3D11_MAX_SHADER_VIEW; i++)
217 {
218 pic_ctx->picsys.resource[i] = p_resource;
219 pic_ctx->picsys.resourceView[i] = resourceView[i];
220 }
221 AcquirePictureSys(&pic_ctx->picsys);
222 pic_ctx->picsys.context = context;
223 done:
224 return pic_ctx;
225 }
226
227 static struct va_pic_context* NewSurfacePicContext(vlc_va_t *va, int surface_index)
228 {
229 directx_sys_t *dx_sys = &va->sys->dx_sys;
230 ID3D11VideoDecoderOutputView *surface = dx_sys->hw_surface[surface_index];
231 ID3D11ShaderResourceView *resourceView[D3D11_MAX_SHADER_VIEW];
232 ID3D11Resource *p_resource;
233 ID3D11VideoDecoderOutputView_GetResource(surface, &p_resource);
234
235 D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC viewDesc;
236 ID3D11VideoDecoderOutputView_GetDesc(surface, &viewDesc);
237
238 for (int i=0; i<D3D11_MAX_SHADER_VIEW; i++)
239 resourceView[i] = va->sys->resourceView[viewDesc.Texture2D.ArraySlice*D3D11_MAX_SHADER_VIEW + i];
240
241 struct va_pic_context *pic_ctx = CreatePicContext(
242 surface,
243 p_resource,
244 va->sys->d3dctx,
245 viewDesc.Texture2D.ArraySlice,
246 resourceView);
247 ID3D11Resource_Release(p_resource);
248 if (unlikely(pic_ctx==NULL))
249 return NULL;
250 /* all the resources are acquired during surfaces init, and a second time in
251 * CreatePicContext(), undo one of them otherwise we need an extra release
252 * when the pool is emptied */
253 ReleasePictureSys(&pic_ctx->picsys);
254 return pic_ctx;
255 }
256
257 static int Get(vlc_va_t *va, picture_t *pic, uint8_t **data)
258 {
259 #if D3D11_DIRECT_DECODE
260 if (va->sys->dx_sys.can_extern_pool)
261 {
262 /* copy the original picture_sys_t in the va_pic_context */
263 if (!pic->context)
264 {
265 assert(pic->p_sys!=NULL);
266 if (!pic->p_sys->decoder)
267 {
268 HRESULT hr;
269 D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC viewDesc;
270 ZeroMemory(&viewDesc, sizeof(viewDesc));
271 viewDesc.DecodeProfile = va->sys->dx_sys.input;
272 viewDesc.ViewDimension = D3D11_VDOV_DIMENSION_TEXTURE2D;
273 viewDesc.Texture2D.ArraySlice = pic->p_sys->slice_index;
274
275 hr = ID3D11VideoDevice_CreateVideoDecoderOutputView( va->sys->dx_sys.d3ddec,
276 pic->p_sys->resource[KNOWN_DXGI_INDEX],
277 &viewDesc,
278 &pic->p_sys->decoder );
279 if (FAILED(hr))
280 return VLC_EGENERIC;
281 }
282
283 pic->context = (picture_context_t*)CreatePicContext(
284 pic->p_sys->decoder,
285 pic->p_sys->resource[KNOWN_DXGI_INDEX],
286 va->sys->d3dctx,
287 pic->p_sys->slice_index,
288 pic->p_sys->resourceView );
289 if (pic->context == NULL)
290 return VLC_EGENERIC;
291 }
292 }
293 else
294 #endif
295 {
296 int res = va_pool_Get(&va->sys->dx_sys.va_pool, pic);
297 if (unlikely(res != VLC_SUCCESS))
298 return res;
299 }
300 *data = (uint8_t*)((struct va_pic_context *)pic->context)->picsys.decoder;
301 return VLC_SUCCESS;
302 }
303
304 static void Close(vlc_va_t *va, void **ctx)
305 {
306 vlc_va_sys_t *sys = va->sys;
307
308 (void) ctx;
309
310 directx_va_Close(va, &sys->dx_sys);
311
312 #if !defined(NDEBUG) && defined(HAVE_DXGIDEBUG_H)
313 if (sys->dxgidebug_dll)
314 FreeLibrary(sys->dxgidebug_dll);
315 #endif
316
317 free((char *)va->description);
318 free(sys);
319 }
320
321 static int Open(vlc_va_t *va, AVCodecContext *ctx, enum PixelFormat pix_fmt,
322 const es_format_t *fmt, picture_sys_t *p_sys)
323 {
324 int err = VLC_EGENERIC;
325 directx_sys_t *dx_sys;
326
327 ctx->hwaccel_context = NULL;
328
329 if (pix_fmt != AV_PIX_FMT_D3D11VA_VLD)
330 return VLC_EGENERIC;
331
332 vlc_va_sys_t *sys = calloc(1, sizeof (*sys));
333 if (unlikely(sys == NULL))
334 return VLC_ENOMEM;
335
336 #if !defined(NDEBUG) && defined(HAVE_DXGIDEBUG_H)
337 sys->dxgidebug_dll = LoadLibrary(TEXT("DXGIDEBUG.DLL"));
338 #endif
339
340 dx_sys = &sys->dx_sys;
341
342 dx_sys->va_pool.pf_create_device = D3dCreateDevice;
343 dx_sys->va_pool.pf_destroy_device = D3dDestroyDevice;
344 dx_sys->va_pool.pf_create_video_service = DxCreateVideoService;
345 dx_sys->va_pool.pf_destroy_video_service = DxDestroyVideoService;
346 dx_sys->va_pool.pf_create_decoder_surfaces = DxCreateDecoderSurfaces;
347 dx_sys->va_pool.pf_destroy_surfaces = DxDestroySurfaces;
348 dx_sys->va_pool.pf_setup_avcodec_ctx = SetupAVCodecContext;
349 dx_sys->va_pool.pf_new_surface_context = NewSurfacePicContext;
350 dx_sys->pf_get_input_list = DxGetInputList;
351 dx_sys->pf_setup_output = DxSetupOutput;
352 dx_sys->psz_decoder_dll = TEXT("D3D11.DLL");
353
354 va->sys = sys;
355
356 dx_sys->d3ddev = NULL;
357 va->sys->render = DXGI_FORMAT_UNKNOWN;
358 if ( p_sys != NULL && p_sys->context != NULL ) {
359 void *d3dvidctx = NULL;
360 HRESULT hr = ID3D11DeviceContext_QueryInterface(p_sys->context, &IID_ID3D11VideoContext, &d3dvidctx);
361 if (FAILED(hr)) {
362 msg_Err(va, "Could not Query ID3D11VideoContext Interface from the picture. (hr=0x%lX)", hr);
363 } else {
364 ID3D11DeviceContext_GetDevice( p_sys->context, &dx_sys->d3ddev );
365 HANDLE context_lock = INVALID_HANDLE_VALUE;
366 UINT dataSize = sizeof(context_lock);
367 hr = ID3D11Device_GetPrivateData(dx_sys->d3ddev, &GUID_CONTEXT_MUTEX, &dataSize, &context_lock);
368 if (FAILED(hr))
369 msg_Warn(va, "No mutex found to lock the decoder");
370 sys->context_mutex = context_lock;
371
372 sys->d3dctx = p_sys->context;
373 sys->d3dvidctx = d3dvidctx;
374
375 assert(p_sys->texture[KNOWN_DXGI_INDEX] != NULL);
376 D3D11_TEXTURE2D_DESC dstDesc;
377 ID3D11Texture2D_GetDesc( p_sys->texture[KNOWN_DXGI_INDEX], &dstDesc);
378 sys->render = dstDesc.Format;
379 va->sys->textureWidth = dstDesc.Width;
380 va->sys->textureHeight = dstDesc.Height;
381 va->sys->totalTextureSlices = dstDesc.ArraySize;
382 }
383 }
384 if (!va->sys->textureWidth || !va->sys->textureHeight)
385 {
386 va->sys->textureWidth = fmt->video.i_width;
387 va->sys->textureHeight = fmt->video.i_height;
388 }
389
390 #if VLC_WINSTORE_APP
391 err = directx_va_Open(va, &sys->dx_sys, false);
392 #else
393 err = directx_va_Open(va, &sys->dx_sys, true);
394 #endif
395 if (err!=VLC_SUCCESS)
396 goto error;
397
398 err = directx_va_Setup(va, &sys->dx_sys, ctx, fmt);
399 if (err != VLC_SUCCESS)
400 goto error;
401
402 ctx->hwaccel_context = &sys->hw;
403
404 /* TODO print the hardware name/vendor for debugging purposes */
405 va->description = DxDescribe(dx_sys);
406 va->get = Get;
407
408 return VLC_SUCCESS;
409
410 error:
411 Close(va, NULL);
412 return err;
413 }
414
415 /**
416 * It creates a Direct3D device usable for decoding
417 */
418 static int D3dCreateDevice(vlc_va_t *va)
419 {
420 directx_sys_t *dx_sys = &va->sys->dx_sys;
421 HRESULT hr;
422
423 if (dx_sys->d3ddev && va->sys->d3dctx) {
424 msg_Dbg(va, "Reusing Direct3D11 device");
425 ID3D11DeviceContext_AddRef(va->sys->d3dctx);
426 return VLC_SUCCESS;
427 }
428
429 /* */
430 d3d11_handle_t hd3d11;
431 hr = D3D11_CreateDevice(VLC_OBJECT(va), dx_sys->hdecoder_dll, true, &hd3d11);
432 if (FAILED(hr)) {
433 msg_Err(va, "D3D11CreateDevice failed. (hr=0x%lX)", hr);
434 return VLC_EGENERIC;
435 }
436 dx_sys->d3ddev = hd3d11.d3ddevice;
437 va->sys->d3dctx = hd3d11.d3dcontext;
438
439 void *d3dvidctx = NULL;
440 hr = ID3D11DeviceContext_QueryInterface(dx_sys->d3ddev, &IID_ID3D11VideoContext, &d3dvidctx);
441 if (FAILED(hr)) {
442 msg_Err(va, "Could not Query ID3D11VideoContext Interface. (hr=0x%lX)", hr);
443 return VLC_EGENERIC;
444 }
445 va->sys->d3dvidctx = d3dvidctx;
446
447 #if !defined(NDEBUG) && defined(HAVE_DXGIDEBUG_H)
448 HRESULT (WINAPI * pf_DXGIGetDebugInterface)(const GUID *riid, void **ppDebug);
449 if (va->sys->dxgidebug_dll) {
450 pf_DXGIGetDebugInterface = (void *)GetProcAddress(va->sys->dxgidebug_dll, "DXGIGetDebugInterface");
451 if (pf_DXGIGetDebugInterface) {
452 IDXGIDebug *pDXGIDebug = NULL;
453 hr = pf_DXGIGetDebugInterface(&IID_IDXGIDebug, (void**)&pDXGIDebug);
454 if (SUCCEEDED(hr) && pDXGIDebug) {
455 hr = IDXGIDebug_ReportLiveObjects(pDXGIDebug, DXGI_DEBUG_ALL, DXGI_DEBUG_RLO_ALL);
456 }
457 }
458 }
459 #endif
460
461 return VLC_SUCCESS;
462 }
463
464 /**
465 * It releases a Direct3D device and its resources.
466 */
467 static void D3dDestroyDevice(vlc_va_t *va)
468 {
469 directx_sys_t *dx_sys = &va->sys->dx_sys;
470 if (va->sys->d3dvidctx)
471 ID3D11VideoContext_Release(va->sys->d3dvidctx);
472 if (va->sys->d3dctx)
473 ID3D11DeviceContext_Release(va->sys->d3dctx);
474 if (dx_sys->d3ddev)
475 ID3D11Device_Release(dx_sys->d3ddev);
476 }
477 /**
478 * It describes our Direct3D object
479 */
480 static char *DxDescribe(directx_sys_t *dx_sys)
481 {
482 static const struct {
483 unsigned id;
484 char name[32];
485 } vendors [] = {
486 { 0x1002, "ATI" },
487 { 0x10DE, "NVIDIA" },
488 { 0x1106, "VIA" },
489 { 0x8086, "Intel" },
490 { 0x5333, "S3 Graphics" },
491 { 0x4D4F4351, "Qualcomm" },
492 { 0, "" }
493 };
494
495 IDXGIAdapter *p_adapter = D3D11DeviceAdapter(dx_sys->d3ddev);
496 if (!p_adapter) {
497 return NULL;
498 }
499
500 char *description = NULL;
501 DXGI_ADAPTER_DESC adapterDesc;
502 if (SUCCEEDED(IDXGIAdapter_GetDesc(p_adapter, &adapterDesc))) {
503 const char *vendor = "Unknown";
504 for (int i = 0; vendors[i].id != 0; i++) {
505 if (vendors[i].id == adapterDesc.VendorId) {
506 vendor = vendors[i].name;
507 break;
508 }
509 }
510
511 char *utfdesc = FromWide(adapterDesc.Description);
512 if (likely(utfdesc!=NULL))
513 {
514 if (asprintf(&description, "D3D11VA (%s, vendor %u(%s), device %u, revision %u)",
515 utfdesc,
516 adapterDesc.VendorId, vendor, adapterDesc.DeviceId, adapterDesc.Revision) < 0)
517 description = NULL;
518 free(utfdesc);
519 }
520 }
521
522 IDXGIAdapter_Release(p_adapter);
523 return description;
524 }
525
526 /**
527 * It creates a DirectX video service
528 */
529 static int DxCreateVideoService(vlc_va_t *va)
530 {
531 directx_sys_t *dx_sys = &va->sys->dx_sys;
532
533 void *d3dviddev = NULL;
534 HRESULT hr = ID3D11Device_QueryInterface(dx_sys->d3ddev, &IID_ID3D11VideoDevice, &d3dviddev);
535 if (FAILED(hr)) {
536 msg_Err(va, "Could not Query ID3D11VideoDevice Interface. (hr=0x%lX)", hr);
537 return VLC_EGENERIC;
538 }
539 dx_sys->d3ddec = d3dviddev;
540
541 return VLC_SUCCESS;
542 }
543
544 /**
545 * It destroys a DirectX video service
546 */
547 static void DxDestroyVideoService(vlc_va_t *va)
548 {
549 directx_sys_t *dx_sys = &va->sys->dx_sys;
550 if (dx_sys->d3ddec)
551 ID3D11VideoDevice_Release(dx_sys->d3ddec);
552 }
553
554 static void ReleaseInputList(input_list_t *p_list)
555 {
556 free(p_list->list);
557 }
558
559 static int DxGetInputList(vlc_va_t *va, input_list_t *p_list)
560 {
561 directx_sys_t *dx_sys = &va->sys->dx_sys;
562 HRESULT hr;
563
564 UINT input_count = ID3D11VideoDevice_GetVideoDecoderProfileCount(dx_sys->d3ddec);
565
566 p_list->count = input_count;
567 p_list->list = calloc(input_count, sizeof(*p_list->list));
568 if (unlikely(p_list->list == NULL)) {
569 return VLC_ENOMEM;
570 }
571 p_list->pf_release = ReleaseInputList;
572
573 for (unsigned i = 0; i < input_count; i++) {
574 hr = ID3D11VideoDevice_GetVideoDecoderProfile(dx_sys->d3ddec, i, &p_list->list[i]);
575 if (FAILED(hr))
576 {
577 msg_Err(va, "GetVideoDecoderProfile %d failed. (hr=0x%lX)", i, hr);
578 ReleaseInputList(p_list);
579 return VLC_EGENERIC;
580 }
581 }
582
583 return VLC_SUCCESS;
584 }
585
586 static int DxSetupOutput(vlc_va_t *va, const GUID *input, const video_format_t *fmt)
587 {
588 directx_sys_t *dx_sys = &va->sys->dx_sys;
589 HRESULT hr;
590
591 #ifndef NDEBUG
592 BOOL bSupported = false;
593 for (int format = 0; format < 188; format++) {
594 hr = ID3D11VideoDevice_CheckVideoDecoderFormat(dx_sys->d3ddec, input, format, &bSupported);
595 if (SUCCEEDED(hr) && bSupported)
596 msg_Dbg(va, "format %s is supported for output", DxgiFormatToStr(format));
597 }
598 #endif
599
600 DXGI_FORMAT processorInput[4];
601 int idx = 0;
602 if ( va->sys->render != DXGI_FORMAT_UNKNOWN )
603 processorInput[idx++] = va->sys->render;
604 processorInput[idx++] = DXGI_FORMAT_NV12;
605 processorInput[idx++] = DXGI_FORMAT_420_OPAQUE;
606 processorInput[idx++] = DXGI_FORMAT_UNKNOWN;
607
608 char *psz_decoder_name = directx_va_GetDecoderName(input);
609
610 /* */
611 for (idx = 0; processorInput[idx] != DXGI_FORMAT_UNKNOWN; ++idx)
612 {
613 BOOL is_supported = false;
614 hr = ID3D11VideoDevice_CheckVideoDecoderFormat(dx_sys->d3ddec, input, processorInput[idx], &is_supported);
615 if (SUCCEEDED(hr) && is_supported)
616 msg_Dbg(va, "%s output is supported for decoder %s.", DxgiFormatToStr(processorInput[idx]), psz_decoder_name);
617 else
618 {
619 msg_Dbg(va, "Can't get a decoder output format %s for decoder %s.", DxgiFormatToStr(processorInput[idx]), psz_decoder_name);
620 continue;
621 }
622
623 // check if we can create render texture of that format
624 // check the decoder can output to that format
625 if ( !DeviceSupportsFormat(dx_sys->d3ddev, processorInput[idx],
626 D3D11_FORMAT_SUPPORT_SHADER_LOAD) )
627 {
628 #ifndef ID3D11VideoContext_VideoProcessorBlt
629 msg_Dbg(va, "Format %s needs a processor but is not supported",
630 DxgiFormatToStr(processorInput[idx]));
631 #else
632 if ( !DeviceSupportsFormat(dx_sys->d3ddev, processorInput[idx],
633 D3D11_FORMAT_SUPPORT_VIDEO_PROCESSOR_INPUT) )
634 {
635 msg_Dbg(va, "Format %s needs a processor but is not available",
636 DxgiFormatToStr(processorInput[idx]));
637 continue;
638 }
639 #endif
640 }
641
642 D3D11_VIDEO_DECODER_DESC decoderDesc;
643 ZeroMemory(&decoderDesc, sizeof(decoderDesc));
644 decoderDesc.Guid = *input;
645 decoderDesc.SampleWidth = fmt->i_width;
646 decoderDesc.SampleHeight = fmt->i_height;
647 decoderDesc.OutputFormat = processorInput[idx];
648
649 UINT cfg_count = 0;
650 hr = ID3D11VideoDevice_GetVideoDecoderConfigCount( dx_sys->d3ddec, &decoderDesc, &cfg_count );
651 if (FAILED(hr))
652 {
653 msg_Err( va, "Failed to get configuration for decoder %s. (hr=0x%lX)", psz_decoder_name, hr );
654 continue;
655 }
656 if (cfg_count == 0) {
657 msg_Err( va, "No decoder configuration possible for %s %dx%d",
658 DxgiFormatToStr(decoderDesc.OutputFormat),
659 decoderDesc.SampleWidth, decoderDesc.SampleHeight );
660 continue;
661 }
662
663 msg_Dbg(va, "Using output format %s for decoder %s", DxgiFormatToStr(processorInput[idx]), psz_decoder_name);
664 if ( va->sys->render == processorInput[idx] )
665 {
666 /* NVIDIA cards crash when calling CreateVideoDecoderOutputView
667 * on more than 30 slices */
668 if (va->sys->totalTextureSlices <= 30 || !isNvidiaHardware(dx_sys->d3ddev))
669 dx_sys->can_extern_pool = true;
670 else
671 msg_Warn( va, "NVIDIA GPU with too many slices (%d) detected, use internal pool",
672 va->sys->totalTextureSlices );
673 }
674 va->sys->render = processorInput[idx];
675 free(psz_decoder_name);
676 return VLC_SUCCESS;
677 }
678 free(psz_decoder_name);
679
680 msg_Dbg(va, "Output format from picture source not supported.");
681 return VLC_EGENERIC;
682 }
683
684 static bool CanUseDecoderPadding(directx_sys_t *dx_sys)
685 {
686 IDXGIAdapter *pAdapter = D3D11DeviceAdapter(dx_sys->d3ddev);
687 if (!pAdapter)
688 return false;
689
690 DXGI_ADAPTER_DESC adapterDesc;
691 HRESULT hr = IDXGIAdapter_GetDesc(pAdapter, &adapterDesc);
692 IDXGIAdapter_Release(pAdapter);
693 if (FAILED(hr))
694 return false;
695
696 /* Qualcomm hardware has issues with textures and pixels that should not be
697 * part of the decoded area */
698 return adapterDesc.VendorId != 0x4D4F4351;
699 }
700
701 /**
702 * It creates a Direct3D11 decoder using the given video format
703 */
704 static int DxCreateDecoderSurfaces(vlc_va_t *va, int codec_id,
705 const video_format_t *fmt, unsigned surface_count)
706 {
707 vlc_va_sys_t *sys = va->sys;
708 directx_sys_t *dx_sys = &va->sys->dx_sys;
709 HRESULT hr;
710
711 ID3D10Multithread *pMultithread;
712 hr = ID3D11Device_QueryInterface( dx_sys->d3ddev, &IID_ID3D10Multithread, (void **)&pMultithread);
713 if (SUCCEEDED(hr)) {
714 ID3D10Multithread_SetMultithreadProtected(pMultithread, TRUE);
715 ID3D10Multithread_Release(pMultithread);
716 }
717
718 #if VLC_WINSTORE_APP
719 /* On the Xbox 1/S, any decoding of H264 with one dimension over 2304
720 * crashes totally the device */
721 if (codec_id == AV_CODEC_ID_H264 &&
722 (fmt->i_width > 2304 || fmt->i_height > 2304) &&
723 isXboxHardware(dx_sys->d3ddev))
724 {
725 msg_Warn(va, "%dx%d resolution not supported by your hardware", fmt->i_width, fmt->i_height);
726 return VLC_EGENERIC;
727 }
728 #endif
729 if ((sys->textureWidth != fmt->i_width || sys->textureHeight != fmt->i_height) &&
730 !CanUseDecoderPadding(dx_sys))
731 {
732 msg_Dbg(va, "mismatching external pool sizes use the internal one %dx%d vs %dx%d",
733 sys->textureWidth, sys->textureHeight, fmt->i_width, fmt->i_height);
734 dx_sys->can_extern_pool = false;
735 }
736
737 D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC viewDesc;
738 ZeroMemory(&viewDesc, sizeof(viewDesc));
739 viewDesc.DecodeProfile = dx_sys->input;
740 viewDesc.ViewDimension = D3D11_VDOV_DIMENSION_TEXTURE2D;
741
742 const d3d_format_t *textureFmt = NULL;
743 for (const d3d_format_t *output_format = GetRenderFormatList();
744 output_format->name != NULL; ++output_format)
745 {
746 if (output_format->formatTexture == sys->render &&
747 (output_format->fourcc == VLC_CODEC_D3D11_OPAQUE || output_format->fourcc == VLC_CODEC_D3D11_OPAQUE_10B))
748 {
749 textureFmt = output_format;
750 break;
751 }
752 }
753 if (unlikely(textureFmt==NULL))
754 {
755 msg_Dbg(va, "no hardware decoder matching %s", DxgiFormatToStr(sys->render));
756 return VLC_EGENERIC;
757 }
758
759 if (dx_sys->can_extern_pool)
760 {
761 #if !D3D11_DIRECT_DECODE
762 size_t surface_idx;
763 for (surface_idx = 0; surface_idx < surface_count; surface_idx++) {
764 picture_t *pic = decoder_NewPicture( (decoder_t*) va->obj.parent );
765 sys->extern_pics[surface_idx] = pic;
766 dx_sys->hw_surface[surface_idx] = NULL;
767 if (pic==NULL)
768 {
769 msg_Warn(va, "not enough decoder pictures %d out of %d", surface_idx, surface_count);
770 dx_sys->can_extern_pool = false;
771 break;
772 }
773
774 D3D11_TEXTURE2D_DESC texDesc;
775 ID3D11Texture2D_GetDesc(pic->p_sys->texture[KNOWN_DXGI_INDEX], &texDesc);
776 if (texDesc.ArraySize < surface_count)
777 {
778 msg_Warn(va, "not enough decoding slices in the texture (%d/%d)",
779 texDesc.ArraySize, surface_count);
780 dx_sys->can_extern_pool = false;
781 break;
782 }
783 assert(texDesc.Format == sys->render);
784 assert(texDesc.BindFlags & D3D11_BIND_DECODER);
785
786 #if !LIBAVCODEC_VERSION_CHECK( 57, 27, 2, 61, 102 )
787 if (pic->p_sys->slice_index != surface_idx)
788 {
789 msg_Warn(va, "d3d11va requires decoding slices to be the first in the texture (%d/%d)",
790 pic->p_sys->slice_index, surface_idx);
791 dx_sys->can_extern_pool = false;
792 break;
793 }
794 #endif
795
796 viewDesc.Texture2D.ArraySlice = pic->p_sys->slice_index;
797 hr = ID3D11VideoDevice_CreateVideoDecoderOutputView( dx_sys->d3ddec,
798 pic->p_sys->resource[KNOWN_DXGI_INDEX],
799 &viewDesc,
800 &pic->p_sys->decoder );
801 if (FAILED(hr)) {
802 msg_Warn(va, "CreateVideoDecoderOutputView %d failed. (hr=0x%0lx)", surface_idx, hr);
803 dx_sys->can_extern_pool = false;
804 break;
805 }
806
807 AllocateShaderView(VLC_OBJECT(va), dx_sys->d3ddev, textureFmt, pic->p_sys->texture, pic->p_sys->slice_index, pic->p_sys->resourceView);
808
809 dx_sys->hw_surface[surface_idx] = pic->p_sys->decoder;
810 }
811
812 if (!dx_sys->can_extern_pool)
813 {
814 for (size_t i = 0; i < surface_idx; ++i)
815 {
816 if (dx_sys->hw_surface[i])
817 {
818 ID3D11VideoDecoderOutputView_Release(dx_sys->hw_surface[i]);
819 dx_sys->hw_surface[i] = NULL;
820 }
821 if (sys->extern_pics[i])
822 {
823 sys->extern_pics[i]->p_sys->decoder = NULL;
824 picture_Release(sys->extern_pics[i]);
825 sys->extern_pics[i] = NULL;
826 }
827 }
828 }
829 else
830 #endif
831 msg_Dbg(va, "using external surface pool");
832 }
833
834 if (!dx_sys->can_extern_pool)
835 {
836 D3D11_TEXTURE2D_DESC texDesc;
837 ZeroMemory(&texDesc, sizeof(texDesc));
838 texDesc.Width = sys->textureWidth;
839 texDesc.Height = sys->textureHeight;
840 texDesc.MipLevels = 1;
841 texDesc.Format = sys->render;
842 texDesc.SampleDesc.Count = 1;
843 texDesc.MiscFlags = 0;
844 texDesc.ArraySize = surface_count;
845 texDesc.Usage = D3D11_USAGE_DEFAULT;
846 texDesc.BindFlags = D3D11_BIND_DECODER;
847 texDesc.CPUAccessFlags = 0;
848
849 if (DeviceSupportsFormat(dx_sys->d3ddev, texDesc.Format, D3D11_FORMAT_SUPPORT_SHADER_LOAD))
850 texDesc.BindFlags |= D3D11_BIND_SHADER_RESOURCE;
851
852 ID3D11Texture2D *p_texture;
853 hr = ID3D11Device_CreateTexture2D( dx_sys->d3ddev, &texDesc, NULL, &p_texture );
854 if (FAILED(hr)) {
855 msg_Err(va, "CreateTexture2D %d failed. (hr=0x%0lx)", surface_count, hr);
856 return VLC_EGENERIC;
857 }
858
859 unsigned surface_idx;
860 for (surface_idx = 0; surface_idx < surface_count; surface_idx++) {
861 sys->extern_pics[surface_idx] = NULL;
862 viewDesc.Texture2D.ArraySlice = surface_idx;
863
864 hr = ID3D11VideoDevice_CreateVideoDecoderOutputView( dx_sys->d3ddec,
865 (ID3D11Resource*) p_texture,
866 &viewDesc,
867 &dx_sys->hw_surface[surface_idx] );
868 if (FAILED(hr)) {
869 msg_Err(va, "CreateVideoDecoderOutputView %d failed. (hr=0x%0lx)", surface_idx, hr);
870 ID3D11Texture2D_Release(p_texture);
871 return VLC_EGENERIC;
872 }
873
874 if (texDesc.BindFlags & D3D11_BIND_SHADER_RESOURCE)
875 {
876 ID3D11Texture2D *textures[D3D11_MAX_SHADER_VIEW] = {p_texture, p_texture};
877 AllocateShaderView(VLC_OBJECT(va), dx_sys->d3ddev, textureFmt, textures, surface_idx,
878 &sys->resourceView[surface_idx * D3D11_MAX_SHADER_VIEW]);
879 }
880 }
881 }
882 msg_Dbg(va, "ID3D11VideoDecoderOutputView succeed with %d surfaces (%dx%d)",
883 surface_count, fmt->i_width, fmt->i_height);
884
885 D3D11_VIDEO_DECODER_DESC decoderDesc;
886 ZeroMemory(&decoderDesc, sizeof(decoderDesc));
887 decoderDesc.Guid = dx_sys->input;
888 decoderDesc.SampleWidth = fmt->i_width;
889 decoderDesc.SampleHeight = fmt->i_height;
890 decoderDesc.OutputFormat = sys->render;
891
892 UINT cfg_count;
893 hr = ID3D11VideoDevice_GetVideoDecoderConfigCount( dx_sys->d3ddec, &decoderDesc, &cfg_count );
894 if (FAILED(hr)) {
895 msg_Err(va, "GetVideoDecoderConfigCount failed. (hr=0x%lX)", hr);
896 return VLC_EGENERIC;
897 }
898
899 /* List all configurations available for the decoder */
900 D3D11_VIDEO_DECODER_CONFIG cfg_list[cfg_count];
901 for (unsigned i = 0; i < cfg_count; i++) {
902 hr = ID3D11VideoDevice_GetVideoDecoderConfig( dx_sys->d3ddec, &decoderDesc, i, &cfg_list[i] );
903 if (FAILED(hr)) {
904 msg_Err(va, "GetVideoDecoderConfig failed. (hr=0x%lX)", hr);
905 return VLC_EGENERIC;
906 }
907 }
908
909 msg_Dbg(va, "we got %d decoder configurations", cfg_count);
910
911 /* Select the best decoder configuration */
912 int cfg_score = 0;
913 for (unsigned i = 0; i < cfg_count; i++) {
914 const D3D11_VIDEO_DECODER_CONFIG *cfg = &cfg_list[i];
915
916 /* */
917 msg_Dbg(va, "configuration[%d] ConfigBitstreamRaw %d",
918 i, cfg->ConfigBitstreamRaw);
919
920 /* */
921 int score;
922 if (cfg->ConfigBitstreamRaw == 1)
923 score = 1;
924 else if (codec_id == AV_CODEC_ID_H264 && cfg->ConfigBitstreamRaw == 2)
925 score = 2;
926 else
927 continue;
928 if (IsEqualGUID(&cfg->guidConfigBitstreamEncryption, &DXVA2_NoEncrypt))
929 score += 16;
930
931 if (cfg_score < score) {
932 sys->cfg = *cfg;
933 cfg_score = score;
934 }
935 }
936 if (cfg_score <= 0) {
937 msg_Err(va, "Failed to find a supported decoder configuration");
938 return VLC_EGENERIC;
939 }
940
941 /* Create the decoder */
942 ID3D11VideoDecoder *decoder;
943 hr = ID3D11VideoDevice_CreateVideoDecoder( dx_sys->d3ddec, &decoderDesc, &sys->cfg, &decoder );
944 if (FAILED(hr)) {
945 msg_Err(va, "ID3D11VideoDevice_CreateVideoDecoder failed. (hr=0x%lX)", hr);
946 dx_sys->decoder = NULL;
947 return VLC_EGENERIC;
948 }
949 dx_sys->decoder = decoder;
950
951 msg_Dbg(va, "DxCreateDecoderSurfaces succeed");
952 return VLC_SUCCESS;
953 }
954
955 static void DxDestroySurfaces(vlc_va_t *va)
956 {
957 directx_sys_t *dx_sys = &va->sys->dx_sys;
958 if (dx_sys->va_pool.surface_count && !dx_sys->can_extern_pool) {
959 ID3D11Resource *p_texture;
960 ID3D11VideoDecoderOutputView_GetResource( dx_sys->hw_surface[0], &p_texture );
961 ID3D11Resource_Release(p_texture);
962 ID3D11Resource_Release(p_texture);
963 }
964 for (unsigned i = 0; i < dx_sys->va_pool.surface_count; i++)
965 {
966 ID3D11VideoDecoderOutputView_Release( dx_sys->hw_surface[i] );
967 for (int j = 0; j < D3D11_MAX_SHADER_VIEW; j++)
968 {
969 if (va->sys->resourceView[i*D3D11_MAX_SHADER_VIEW + j])
970 ID3D11ShaderResourceView_Release(va->sys->resourceView[i*D3D11_MAX_SHADER_VIEW + j]);
971 }
972 }
973 if (dx_sys->decoder)
974 {
975 ID3D11VideoDecoder_Release(dx_sys->decoder);
976 dx_sys->decoder = NULL;
977 }
978 }
VLC Development tree mirror