modules/codec/avcodec/d3d11va.c

   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     d3d11_handle_t               hd3d;
 113     d3d11_device_t               d3d_dev;
 114
 115 #if !defined(NDEBUG) && defined(HAVE_DXGIDEBUG_H)
 116     HINSTANCE                    dxgidebug_dll;
 117 #endif
 118
 119     /* Video service */
 120     ID3D11VideoContext           *d3dvidctx;
 121     DXGI_FORMAT                  render;
 122
 123     HANDLE                       context_mutex;
 124
 125     /* pool */
 126     picture_t                    *extern_pics[MAX_SURFACE_COUNT];
 127
 128     /* Video decoder */
 129     D3D11_VIDEO_DECODER_CONFIG   cfg;
 130
 131     /* avcodec internals */
 132     struct AVD3D11VAContext      hw;
 133
 134     ID3D11ShaderResourceView     *resourceView[MAX_SURFACE_COUNT * D3D11_MAX_SHADER_VIEW];
 135 };
 136
 137 /* */
 138 static int D3dCreateDevice(vlc_va_t *);
 139 static void D3dDestroyDevice(vlc_va_t *);
 140 static char *DxDescribe(vlc_va_sys_t *);
 141
 142 static int DxCreateVideoService(vlc_va_t *);
 143 static void DxDestroyVideoService(vlc_va_t *);
 144 static int DxGetInputList(vlc_va_t *, input_list_t *);
 145 static int DxSetupOutput(vlc_va_t *, const GUID *, const video_format_t *);
 146
 147 static int DxCreateDecoderSurfaces(vlc_va_t *, int codec_id,
 148                                    const video_format_t *fmt, unsigned surface_count);
 149 static void DxDestroySurfaces(vlc_va_t *);
 150 static void SetupAVCodecContext(vlc_va_t *);
 151
 152 void SetupAVCodecContext(vlc_va_t *va)
 153 {
 154     vlc_va_sys_t *sys = va->sys;
 155     directx_sys_t *dx_sys = &sys->dx_sys;
 156
 157     sys->hw.video_context = sys->d3dvidctx;
 158     sys->hw.decoder = dx_sys->decoder;
 159     sys->hw.cfg = &sys->cfg;
 160     sys->hw.surface_count = dx_sys->va_pool.surface_count;
 161     sys->hw.surface = dx_sys->hw_surface;
 162     sys->hw.context_mutex = sys->context_mutex;
 163
 164     if (IsEqualGUID(&dx_sys->input, &DXVA_Intel_H264_NoFGT_ClearVideo))
 165         sys->hw.workaround |= FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO;
 166 }
 167
 168 static void d3d11_pic_context_destroy(struct picture_context_t *opaque)
 169 {
 170     struct va_pic_context *pic_ctx = (struct va_pic_context*)opaque;
 171     if (pic_ctx->va_surface)
 172         va_surface_Release(pic_ctx->va_surface);
 173     ReleasePictureSys(&pic_ctx->picsys);
 174     free(pic_ctx);
 175 }
 176
 177 static struct va_pic_context *CreatePicContext(ID3D11VideoDecoderOutputView *,
 178                                                ID3D11Resource *,
 179                                                ID3D11DeviceContext *,
 180                                                UINT slice,
 181                                                ID3D11ShaderResourceView *resourceView[D3D11_MAX_SHADER_VIEW]);
 182
 183 static struct picture_context_t *d3d11_pic_context_copy(struct picture_context_t *ctx)
 184 {
 185     struct va_pic_context *src_ctx = (struct va_pic_context*)ctx;
 186     struct va_pic_context *pic_ctx = CreatePicContext(src_ctx->picsys.decoder,
 187                                                       src_ctx->picsys.resource[0], src_ctx->picsys.context,
 188                                                       src_ctx->picsys.slice_index, src_ctx->picsys.resourceView);
 189     if (unlikely(pic_ctx==NULL))
 190         return NULL;
 191     if (src_ctx->va_surface) {
 192         pic_ctx->va_surface = src_ctx->va_surface;
 193         va_surface_AddRef(pic_ctx->va_surface);
 194     }
 195     return &pic_ctx->s;
 196 }
 197
 198 static struct va_pic_context *CreatePicContext(
 199                                                   ID3D11VideoDecoderOutputView *decoderSurface,
 200                                                   ID3D11Resource *p_resource,
 201                                                   ID3D11DeviceContext *context,
 202                                                   UINT slice,
 203                                                   ID3D11ShaderResourceView *resourceView[D3D11_MAX_SHADER_VIEW])
 204 {
 205     struct va_pic_context *pic_ctx = calloc(1, sizeof(*pic_ctx));
 206     if (unlikely(pic_ctx==NULL))
 207         goto done;
 208     pic_ctx->s.destroy = d3d11_pic_context_destroy;
 209     pic_ctx->s.copy    = d3d11_pic_context_copy;
 210
 211     D3D11_TEXTURE2D_DESC txDesc;
 212     ID3D11Texture2D_GetDesc((ID3D11Texture2D*)p_resource, &txDesc);
 213
 214     pic_ctx->picsys.formatTexture = txDesc.Format;
 215     pic_ctx->picsys.context = context;
 216     pic_ctx->picsys.slice_index = slice;
 217     pic_ctx->picsys.decoder = decoderSurface;
 218     for (int i=0;i<D3D11_MAX_SHADER_VIEW; i++)
 219     {
 220         pic_ctx->picsys.resource[i] = p_resource;
 221         pic_ctx->picsys.resourceView[i] = resourceView[i];
 222     }
 223     AcquirePictureSys(&pic_ctx->picsys);
 224     pic_ctx->picsys.context = context;
 225 done:
 226     return pic_ctx;
 227 }
 228
 229 static struct va_pic_context* NewSurfacePicContext(vlc_va_t *va, int surface_index)
 230 {
 231     vlc_va_sys_t *sys = va->sys;
 232     directx_sys_t *dx_sys = &sys->dx_sys;
 233     ID3D11VideoDecoderOutputView *surface = dx_sys->hw_surface[surface_index];
 234     ID3D11ShaderResourceView *resourceView[D3D11_MAX_SHADER_VIEW];
 235     ID3D11Resource *p_resource;
 236     ID3D11VideoDecoderOutputView_GetResource(surface, &p_resource);
 237
 238     D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC viewDesc;
 239     ID3D11VideoDecoderOutputView_GetDesc(surface, &viewDesc);
 240
 241     for (int i=0; i<D3D11_MAX_SHADER_VIEW; i++)
 242         resourceView[i] = sys->resourceView[viewDesc.Texture2D.ArraySlice*D3D11_MAX_SHADER_VIEW + i];
 243
 244     struct va_pic_context *pic_ctx = CreatePicContext(
 245                                                   surface,
 246                                                   p_resource,
 247                                                   sys->d3d_dev.d3dcontext,
 248                                                   viewDesc.Texture2D.ArraySlice,
 249                                                   resourceView);
 250     ID3D11Resource_Release(p_resource);
 251     if (unlikely(pic_ctx==NULL))
 252         return NULL;
 253     /* all the resources are acquired during surfaces init, and a second time in
 254      * CreatePicContext(), undo one of them otherwise we need an extra release
 255      * when the pool is emptied */
 256     ReleasePictureSys(&pic_ctx->picsys);
 257     return pic_ctx;
 258 }
 259
 260 static int Get(vlc_va_t *va, picture_t *pic, uint8_t **data)
 261 {
 262 #if D3D11_DIRECT_DECODE
 263     if (va->sys->dx_sys.can_extern_pool)
 264     {
 265         /* copy the original picture_sys_t in the va_pic_context */
 266         if (!pic->context)
 267         {
 268             assert(pic->p_sys!=NULL);
 269             if (!pic->p_sys->decoder)
 270             {
 271                 HRESULT hr;
 272                 D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC viewDesc;
 273                 ZeroMemory(&viewDesc, sizeof(viewDesc));
 274                 viewDesc.DecodeProfile = va->sys->dx_sys.input;
 275                 viewDesc.ViewDimension = D3D11_VDOV_DIMENSION_TEXTURE2D;
 276                 viewDesc.Texture2D.ArraySlice = pic->p_sys->slice_index;
 277
 278                 hr = ID3D11VideoDevice_CreateVideoDecoderOutputView( va->sys->dx_sys.d3ddec,
 279                                                                      pic->p_sys->resource[KNOWN_DXGI_INDEX],
 280                                                                      &viewDesc,
 281                                                                      &pic->p_sys->decoder );
 282                 if (FAILED(hr))
 283                     return VLC_EGENERIC;
 284             }
 285
 286             pic->context = (picture_context_t*)CreatePicContext(
 287                                              pic->p_sys->decoder,
 288                                              pic->p_sys->resource[KNOWN_DXGI_INDEX],
 289                                              va->sys->d3d_dev.d3dcontext,
 290                                              pic->p_sys->slice_index,
 291                                              pic->p_sys->resourceView );
 292             if (pic->context == NULL)
 293                 return VLC_EGENERIC;
 294         }
 295     }
 296     else
 297 #endif
 298     {
 299         int res = va_pool_Get(&va->sys->dx_sys.va_pool, pic);
 300         if (unlikely(res != VLC_SUCCESS))
 301             return res;
 302     }
 303     *data = (uint8_t*)((struct va_pic_context *)pic->context)->picsys.decoder;
 304     return VLC_SUCCESS;
 305 }
 306
 307 static void Close(vlc_va_t *va, void **ctx)
 308 {
 309     vlc_va_sys_t *sys = va->sys;
 310
 311     (void) ctx;
 312
 313     directx_va_Close(va, &sys->dx_sys);
 314
 315     D3D11_Destroy( &sys->hd3d );
 316
 317 #if !defined(NDEBUG) && defined(HAVE_DXGIDEBUG_H)
 318     if (sys->dxgidebug_dll)
 319         FreeLibrary(sys->dxgidebug_dll);
 320 #endif
 321
 322     free((char *)va->description);
 323     free(sys);
 324 }
 325
 326 static int Open(vlc_va_t *va, AVCodecContext *ctx, enum PixelFormat pix_fmt,
 327                 const es_format_t *fmt, picture_sys_t *p_sys)
 328 {
 329     int err = VLC_EGENERIC;
 330     directx_sys_t *dx_sys;
 331
 332     ctx->hwaccel_context = NULL;
 333
 334     if (pix_fmt != AV_PIX_FMT_D3D11VA_VLD)
 335         return VLC_EGENERIC;
 336
 337     vlc_va_sys_t *sys = calloc(1, sizeof (*sys));
 338     if (unlikely(sys == NULL))
 339         return VLC_ENOMEM;
 340
 341 #if !defined(NDEBUG) && defined(HAVE_DXGIDEBUG_H)
 342     sys->dxgidebug_dll = LoadLibrary(TEXT("DXGIDEBUG.DLL"));
 343 #endif
 344
 345     dx_sys = &sys->dx_sys;
 346
 347     dx_sys->va_pool.pf_create_device           = D3dCreateDevice;
 348     dx_sys->va_pool.pf_destroy_device          = D3dDestroyDevice;
 349     dx_sys->va_pool.pf_create_video_service    = DxCreateVideoService;
 350     dx_sys->va_pool.pf_destroy_video_service   = DxDestroyVideoService;
 351     dx_sys->va_pool.pf_create_decoder_surfaces = DxCreateDecoderSurfaces;
 352     dx_sys->va_pool.pf_destroy_surfaces        = DxDestroySurfaces;
 353     dx_sys->va_pool.pf_setup_avcodec_ctx       = SetupAVCodecContext;
 354     dx_sys->va_pool.pf_new_surface_context     = NewSurfacePicContext;
 355     dx_sys->pf_get_input_list          = DxGetInputList;
 356     dx_sys->pf_setup_output            = DxSetupOutput;
 357
 358     va->sys = sys;
 359
 360     sys->d3d_dev.d3ddevice = NULL;
 361     va->sys->render = DXGI_FORMAT_UNKNOWN;
 362     if ( p_sys != NULL && p_sys->context != NULL ) {
 363         void *d3dvidctx = NULL;
 364         HRESULT hr = ID3D11DeviceContext_QueryInterface(p_sys->context, &IID_ID3D11VideoContext, &d3dvidctx);
 365         if (FAILED(hr)) {
 366            msg_Err(va, "Could not Query ID3D11VideoContext Interface from the picture. (hr=0x%lX)", hr);
 367         } else {
 368             ID3D11DeviceContext_GetDevice( p_sys->context, &sys->d3d_dev.d3ddevice );
 369             HANDLE context_lock = INVALID_HANDLE_VALUE;
 370             UINT dataSize = sizeof(context_lock);
 371             hr = ID3D11Device_GetPrivateData(sys->d3d_dev.d3ddevice, &GUID_CONTEXT_MUTEX, &dataSize, &context_lock);
 372             if (FAILED(hr))
 373                 msg_Warn(va, "No mutex found to lock the decoder");
 374             sys->context_mutex = context_lock;
 375
 376             dx_sys->d3ddev = sys->d3d_dev.d3ddevice;
 377             sys->d3d_dev.d3dcontext = p_sys->context;
 378             sys->d3d_dev.owner = false;
 379             sys->d3dvidctx = d3dvidctx;
 380
 381             assert(p_sys->texture[KNOWN_DXGI_INDEX] != NULL);
 382             D3D11_TEXTURE2D_DESC dstDesc;
 383             ID3D11Texture2D_GetDesc( p_sys->texture[KNOWN_DXGI_INDEX], &dstDesc);
 384             sys->render = dstDesc.Format;
 385             va->sys->textureWidth = dstDesc.Width;
 386             va->sys->textureHeight = dstDesc.Height;
 387             va->sys->totalTextureSlices = dstDesc.ArraySize;
 388         }
 389     }
 390     if (!va->sys->textureWidth || !va->sys->textureHeight)
 391     {
 392         va->sys->textureWidth  = fmt->video.i_width;
 393         va->sys->textureHeight = fmt->video.i_height;
 394     }
 395
 396     err = D3D11_Create( va, &sys->hd3d );
 397     if (err != VLC_SUCCESS)
 398         goto error;
 399
 400     err = directx_va_Open(va, &sys->dx_sys);
 401     if (err!=VLC_SUCCESS)
 402         goto error;
 403
 404     err = directx_va_Setup(va, &sys->dx_sys, ctx, fmt);
 405     if (err != VLC_SUCCESS)
 406         goto error;
 407
 408     ctx->hwaccel_context = &sys->hw;
 409
 410     /* TODO print the hardware name/vendor for debugging purposes */
 411     va->description = DxDescribe(sys);
 412     va->get     = Get;
 413
 414     return VLC_SUCCESS;
 415
 416 error:
 417     Close(va, NULL);
 418     return err;
 419 }
 420
 421 /**
 422  * It creates a Direct3D device usable for decoding
 423  */
 424 static int D3dCreateDevice(vlc_va_t *va)
 425 {
 426     vlc_va_sys_t *sys = va->sys;
 427     directx_sys_t *dx_sys = &sys->dx_sys;
 428     HRESULT hr;
 429
 430     if (sys->d3d_dev.d3ddevice && sys->d3d_dev.d3dcontext) {
 431         msg_Dbg(va, "Reusing Direct3D11 device");
 432         ID3D11DeviceContext_AddRef(sys->d3d_dev.d3dcontext);
 433         return VLC_SUCCESS;
 434     }
 435
 436     /* */
 437     hr = D3D11_CreateDevice(va, &sys->hd3d, true, &sys->d3d_dev);
 438     if (FAILED(hr)) {
 439         msg_Err(va, "D3D11CreateDevice failed. (hr=0x%lX)", hr);
 440         return VLC_EGENERIC;
 441     }
 442     dx_sys->d3ddev = sys->d3d_dev.d3ddevice;
 443
 444     void *d3dvidctx = NULL;
 445     hr = ID3D11DeviceContext_QueryInterface(sys->d3d_dev.d3dcontext, &IID_ID3D11VideoContext, &d3dvidctx);
 446     if (FAILED(hr)) {
 447        msg_Err(va, "Could not Query ID3D11VideoContext Interface. (hr=0x%lX)", hr);
 448        return VLC_EGENERIC;
 449     }
 450     sys->d3dvidctx = d3dvidctx;
 451
 452 #if !defined(NDEBUG) && defined(HAVE_DXGIDEBUG_H)
 453     HRESULT (WINAPI  * pf_DXGIGetDebugInterface)(const GUID *riid, void **ppDebug);
 454     if (sys->dxgidebug_dll) {
 455         pf_DXGIGetDebugInterface = (void *)GetProcAddress(sys->dxgidebug_dll, "DXGIGetDebugInterface");
 456         if (pf_DXGIGetDebugInterface) {
 457             IDXGIDebug *pDXGIDebug = NULL;
 458             hr = pf_DXGIGetDebugInterface(&IID_IDXGIDebug, (void**)&pDXGIDebug);
 459             if (SUCCEEDED(hr) && pDXGIDebug) {
 460                 hr = IDXGIDebug_ReportLiveObjects(pDXGIDebug, DXGI_DEBUG_ALL, DXGI_DEBUG_RLO_ALL);
 461             }
 462         }
 463     }
 464 #endif
 465
 466     return VLC_SUCCESS;
 467 }
 468
 469 /**
 470  * It releases a Direct3D device and its resources.
 471  */
 472 static void D3dDestroyDevice(vlc_va_t *va)
 473 {
 474     vlc_va_sys_t *sys = va->sys;
 475     if (sys->d3dvidctx)
 476         ID3D11VideoContext_Release(sys->d3dvidctx);
 477     D3D11_ReleaseDevice( &sys->d3d_dev );
 478 }
 479 /**
 480  * It describes our Direct3D object
 481  */
 482 static char *DxDescribe(vlc_va_sys_t *sys)
 483 {
 484     static const struct {
 485         unsigned id;
 486         char     name[32];
 487     } vendors [] = {
 488         { 0x1002, "ATI" },
 489         { 0x10DE, "NVIDIA" },
 490         { 0x1106, "VIA" },
 491         { 0x8086, "Intel" },
 492         { 0x5333, "S3 Graphics" },
 493         { 0x4D4F4351, "Qualcomm" },
 494         { 0, "" }
 495     };
 496
 497     IDXGIAdapter *p_adapter = D3D11DeviceAdapter(sys->d3d_dev.d3ddevice);
 498     if (!p_adapter) {
 499        return NULL;
 500     }
 501
 502     char *description = NULL;
 503     DXGI_ADAPTER_DESC adapterDesc;
 504     if (SUCCEEDED(IDXGIAdapter_GetDesc(p_adapter, &adapterDesc))) {
 505         const char *vendor = "Unknown";
 506         for (int i = 0; vendors[i].id != 0; i++) {
 507             if (vendors[i].id == adapterDesc.VendorId) {
 508                 vendor = vendors[i].name;
 509                 break;
 510             }
 511         }
 512
 513         char *utfdesc = FromWide(adapterDesc.Description);
 514         if (likely(utfdesc!=NULL))
 515         {
 516             if (asprintf(&description, "D3D11VA (%s, vendor %u(%s), device %u, revision %u)",
 517                          utfdesc,
 518                          adapterDesc.VendorId, vendor, adapterDesc.DeviceId, adapterDesc.Revision) < 0)
 519                 description = NULL;
 520             free(utfdesc);
 521         }
 522     }
 523
 524     IDXGIAdapter_Release(p_adapter);
 525     return description;
 526 }
 527
 528 /**
 529  * It creates a DirectX video service
 530  */
 531 static int DxCreateVideoService(vlc_va_t *va)
 532 {
 533     directx_sys_t *dx_sys = &va->sys->dx_sys;
 534
 535     void *d3dviddev = NULL;
 536     HRESULT hr = ID3D11Device_QueryInterface(va->sys->d3d_dev.d3ddevice, &IID_ID3D11VideoDevice, &d3dviddev);
 537     if (FAILED(hr)) {
 538        msg_Err(va, "Could not Query ID3D11VideoDevice Interface. (hr=0x%lX)", hr);
 539        return VLC_EGENERIC;
 540     }
 541     dx_sys->d3ddec = d3dviddev;
 542
 543     return VLC_SUCCESS;
 544 }
 545
 546 /**
 547  * It destroys a DirectX video service
 548  */
 549 static void DxDestroyVideoService(vlc_va_t *va)
 550 {
 551     directx_sys_t *dx_sys = &va->sys->dx_sys;
 552     if (dx_sys->d3ddec)
 553         ID3D11VideoDevice_Release(dx_sys->d3ddec);
 554 }
 555
 556 static void ReleaseInputList(input_list_t *p_list)
 557 {
 558     free(p_list->list);
 559 }
 560
 561 static int DxGetInputList(vlc_va_t *va, input_list_t *p_list)
 562 {
 563     directx_sys_t *dx_sys = &va->sys->dx_sys;
 564     HRESULT hr;
 565
 566     UINT input_count = ID3D11VideoDevice_GetVideoDecoderProfileCount(dx_sys->d3ddec);
 567
 568     p_list->count = input_count;
 569     p_list->list = calloc(input_count, sizeof(*p_list->list));
 570     if (unlikely(p_list->list == NULL)) {
 571         return VLC_ENOMEM;
 572     }
 573     p_list->pf_release = ReleaseInputList;
 574
 575     for (unsigned i = 0; i < input_count; i++) {
 576         hr = ID3D11VideoDevice_GetVideoDecoderProfile(dx_sys->d3ddec, i, &p_list->list[i]);
 577         if (FAILED(hr))
 578         {
 579             msg_Err(va, "GetVideoDecoderProfile %d failed. (hr=0x%lX)", i, hr);
 580             ReleaseInputList(p_list);
 581             return VLC_EGENERIC;
 582         }
 583     }
 584
 585     return VLC_SUCCESS;
 586 }
 587
 588 static int DxSetupOutput(vlc_va_t *va, const GUID *input, const video_format_t *fmt)
 589 {
 590     vlc_va_sys_t *sys = va->sys;
 591     directx_sys_t *dx_sys = &sys->dx_sys;
 592     HRESULT hr;
 593
 594 #ifndef NDEBUG
 595     BOOL bSupported = false;
 596     for (int format = 0; format < 188; format++) {
 597         hr = ID3D11VideoDevice_CheckVideoDecoderFormat(dx_sys->d3ddec, input, format, &bSupported);
 598         if (SUCCEEDED(hr) && bSupported)
 599             msg_Dbg(va, "format %s is supported for output", DxgiFormatToStr(format));
 600     }
 601 #endif
 602
 603     DXGI_FORMAT processorInput[4];
 604     int idx = 0;
 605     if ( sys->render != DXGI_FORMAT_UNKNOWN )
 606         processorInput[idx++] = sys->render;
 607     processorInput[idx++] = DXGI_FORMAT_NV12;
 608     processorInput[idx++] = DXGI_FORMAT_420_OPAQUE;
 609     processorInput[idx++] = DXGI_FORMAT_UNKNOWN;
 610
 611     char *psz_decoder_name = directx_va_GetDecoderName(input);
 612
 613     /* */
 614     for (idx = 0; processorInput[idx] != DXGI_FORMAT_UNKNOWN; ++idx)
 615     {
 616         BOOL is_supported = false;
 617         hr = ID3D11VideoDevice_CheckVideoDecoderFormat(dx_sys->d3ddec, input, processorInput[idx], &is_supported);
 618         if (SUCCEEDED(hr) && is_supported)
 619             msg_Dbg(va, "%s output is supported for decoder %s.", DxgiFormatToStr(processorInput[idx]), psz_decoder_name);
 620         else
 621         {
 622             msg_Dbg(va, "Can't get a decoder output format %s for decoder %s.", DxgiFormatToStr(processorInput[idx]), psz_decoder_name);
 623             continue;
 624         }
 625
 626        // check if we can create render texture of that format
 627        // check the decoder can output to that format
 628        if ( !DeviceSupportsFormat(sys->d3d_dev.d3ddevice, processorInput[idx],
 629                                   D3D11_FORMAT_SUPPORT_SHADER_LOAD) )
 630        {
 631 #ifndef ID3D11VideoContext_VideoProcessorBlt
 632            msg_Dbg(va, "Format %s needs a processor but is not supported",
 633                    DxgiFormatToStr(processorInput[idx]));
 634 #else
 635            if ( !DeviceSupportsFormat(sys->d3d_dev.d3ddevice, processorInput[idx],
 636                                       D3D11_FORMAT_SUPPORT_VIDEO_PROCESSOR_INPUT) )
 637            {
 638                msg_Dbg(va, "Format %s needs a processor but is not available",
 639                        DxgiFormatToStr(processorInput[idx]));
 640                continue;
 641            }
 642 #endif
 643         }
 644
 645         D3D11_VIDEO_DECODER_DESC decoderDesc;
 646         ZeroMemory(&decoderDesc, sizeof(decoderDesc));
 647         decoderDesc.Guid = *input;
 648         decoderDesc.SampleWidth = fmt->i_width;
 649         decoderDesc.SampleHeight = fmt->i_height;
 650         decoderDesc.OutputFormat = processorInput[idx];
 651
 652         UINT cfg_count = 0;
 653         hr = ID3D11VideoDevice_GetVideoDecoderConfigCount( dx_sys->d3ddec, &decoderDesc, &cfg_count );
 654         if (FAILED(hr))
 655         {
 656             msg_Err( va, "Failed to get configuration for decoder %s. (hr=0x%lX)", psz_decoder_name, hr );
 657             continue;
 658         }
 659         if (cfg_count == 0) {
 660             msg_Err( va, "No decoder configuration possible for %s %dx%d",
 661                      DxgiFormatToStr(decoderDesc.OutputFormat),
 662                      decoderDesc.SampleWidth, decoderDesc.SampleHeight );
 663             continue;
 664         }
 665
 666         msg_Dbg(va, "Using output format %s for decoder %s", DxgiFormatToStr(processorInput[idx]), psz_decoder_name);
 667         if ( sys->render == processorInput[idx] )
 668         {
 669             /* NVIDIA cards crash when calling CreateVideoDecoderOutputView
 670              * on more than 30 slices */
 671             if (sys->totalTextureSlices <= 30 || !isNvidiaHardware(sys->d3d_dev.d3ddevice))
 672                 dx_sys->can_extern_pool = true;
 673             else
 674                 msg_Warn( va, "NVIDIA GPU with too many slices (%d) detected, use internal pool",
 675                           sys->totalTextureSlices );
 676         }
 677         sys->render = processorInput[idx];
 678         free(psz_decoder_name);
 679         return VLC_SUCCESS;
 680     }
 681     free(psz_decoder_name);
 682
 683     msg_Dbg(va, "Output format from picture source not supported.");
 684     return VLC_EGENERIC;
 685 }
 686
 687 static bool CanUseDecoderPadding(vlc_va_sys_t *sys)
 688 {
 689     IDXGIAdapter *pAdapter = D3D11DeviceAdapter(sys->d3d_dev.d3ddevice);
 690     if (!pAdapter)
 691         return false;
 692
 693     DXGI_ADAPTER_DESC adapterDesc;
 694     HRESULT hr = IDXGIAdapter_GetDesc(pAdapter, &adapterDesc);
 695     IDXGIAdapter_Release(pAdapter);
 696     if (FAILED(hr))
 697         return false;
 698
 699     /* Qualcomm hardware has issues with textures and pixels that should not be
 700     * part of the decoded area */
 701     return adapterDesc.VendorId != 0x4D4F4351;
 702 }
 703
 704 /**
 705  * It creates a Direct3D11 decoder using the given video format
 706  */
 707 static int DxCreateDecoderSurfaces(vlc_va_t *va, int codec_id,
 708                                    const video_format_t *fmt, unsigned surface_count)
 709 {
 710     vlc_va_sys_t *sys = va->sys;
 711     directx_sys_t *dx_sys = &va->sys->dx_sys;
 712     HRESULT hr;
 713
 714     ID3D10Multithread *pMultithread;
 715     hr = ID3D11Device_QueryInterface( sys->d3d_dev.d3ddevice, &IID_ID3D10Multithread, (void **)&pMultithread);
 716     if (SUCCEEDED(hr)) {
 717         ID3D10Multithread_SetMultithreadProtected(pMultithread, TRUE);
 718         ID3D10Multithread_Release(pMultithread);
 719     }
 720
 721 #if VLC_WINSTORE_APP
 722     /* On the Xbox 1/S, any decoding of H264 with one dimension over 2304
 723      * crashes totally the device */
 724     if (codec_id == AV_CODEC_ID_H264 &&
 725         (fmt->i_width > 2304 || fmt->i_height > 2304) &&
 726         isXboxHardware(sys->d3d_dev.dev))
 727     {
 728         msg_Warn(va, "%dx%d resolution not supported by your hardware", fmt->i_width, fmt->i_height);
 729         return VLC_EGENERIC;
 730     }
 731 #endif
 732     if ((sys->textureWidth != fmt->i_width || sys->textureHeight != fmt->i_height) &&
 733         !CanUseDecoderPadding(sys))
 734     {
 735         msg_Dbg(va, "mismatching external pool sizes use the internal one %dx%d vs %dx%d",
 736                 sys->textureWidth, sys->textureHeight, fmt->i_width, fmt->i_height);
 737         dx_sys->can_extern_pool = false;
 738     }
 739
 740     D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC viewDesc;
 741     ZeroMemory(&viewDesc, sizeof(viewDesc));
 742     viewDesc.DecodeProfile = dx_sys->input;
 743     viewDesc.ViewDimension = D3D11_VDOV_DIMENSION_TEXTURE2D;
 744
 745     const d3d_format_t *textureFmt = NULL;
 746     for (const d3d_format_t *output_format = GetRenderFormatList();
 747          output_format->name != NULL; ++output_format)
 748     {
 749         if (output_format->formatTexture == sys->render &&
 750             (output_format->fourcc == VLC_CODEC_D3D11_OPAQUE || output_format->fourcc == VLC_CODEC_D3D11_OPAQUE_10B))
 751         {
 752             textureFmt = output_format;
 753             break;
 754         }
 755     }
 756     if (unlikely(textureFmt==NULL))
 757     {
 758         msg_Dbg(va, "no hardware decoder matching %s", DxgiFormatToStr(sys->render));
 759         return VLC_EGENERIC;
 760     }
 761
 762     if (dx_sys->can_extern_pool)
 763     {
 764 #if !D3D11_DIRECT_DECODE
 765         size_t surface_idx;
 766         for (surface_idx = 0; surface_idx < surface_count; surface_idx++) {
 767             picture_t *pic = decoder_NewPicture( (decoder_t*) va->obj.parent );
 768             sys->extern_pics[surface_idx] = pic;
 769             dx_sys->hw_surface[surface_idx] = NULL;
 770             if (pic==NULL)
 771             {
 772                 msg_Warn(va, "not enough decoder pictures %d out of %d", surface_idx, surface_count);
 773                 dx_sys->can_extern_pool = false;
 774                 break;
 775             }
 776
 777             D3D11_TEXTURE2D_DESC texDesc;
 778             ID3D11Texture2D_GetDesc(pic->p_sys->texture[KNOWN_DXGI_INDEX], &texDesc);
 779             if (texDesc.ArraySize < surface_count)
 780             {
 781                 msg_Warn(va, "not enough decoding slices in the texture (%d/%d)",
 782                          texDesc.ArraySize, surface_count);
 783                 dx_sys->can_extern_pool = false;
 784                 break;
 785             }
 786             assert(texDesc.Format == sys->render);
 787             assert(texDesc.BindFlags & D3D11_BIND_DECODER);
 788
 789 #if !LIBAVCODEC_VERSION_CHECK( 57, 27, 2, 61, 102 )
 790             if (pic->p_sys->slice_index != surface_idx)
 791             {
 792                 msg_Warn(va, "d3d11va requires decoding slices to be the first in the texture (%d/%d)",
 793                          pic->p_sys->slice_index, surface_idx);
 794                 dx_sys->can_extern_pool = false;
 795                 break;
 796             }
 797 #endif
 798
 799             viewDesc.Texture2D.ArraySlice = pic->p_sys->slice_index;
 800             hr = ID3D11VideoDevice_CreateVideoDecoderOutputView( dx_sys->d3ddec,
 801                                                                  pic->p_sys->resource[KNOWN_DXGI_INDEX],
 802                                                                  &viewDesc,
 803                                                                  &pic->p_sys->decoder );
 804             if (FAILED(hr)) {
 805                 msg_Warn(va, "CreateVideoDecoderOutputView %d failed. (hr=0x%0lx)", surface_idx, hr);
 806                 dx_sys->can_extern_pool = false;
 807                 break;
 808             }
 809
 810             AllocateShaderView(VLC_OBJECT(va), sys->d3d_dev.d3ddevice, textureFmt, pic->p_sys->texture, pic->p_sys->slice_index, pic->p_sys->resourceView);
 811
 812             dx_sys->hw_surface[surface_idx] = pic->p_sys->decoder;
 813         }
 814
 815         if (!dx_sys->can_extern_pool)
 816         {
 817             for (size_t i = 0; i < surface_idx; ++i)
 818             {
 819                 if (dx_sys->hw_surface[i])
 820                 {
 821                     ID3D11VideoDecoderOutputView_Release(dx_sys->hw_surface[i]);
 822                     dx_sys->hw_surface[i] = NULL;
 823                 }
 824                 if (sys->extern_pics[i])
 825                 {
 826                     sys->extern_pics[i]->p_sys->decoder = NULL;
 827                     picture_Release(sys->extern_pics[i]);
 828                     sys->extern_pics[i] = NULL;
 829                 }
 830             }
 831         }
 832         else
 833 #endif
 834             msg_Dbg(va, "using external surface pool");
 835     }
 836
 837     if (!dx_sys->can_extern_pool)
 838     {
 839         D3D11_TEXTURE2D_DESC texDesc;
 840         ZeroMemory(&texDesc, sizeof(texDesc));
 841         texDesc.Width = sys->textureWidth;
 842         texDesc.Height = sys->textureHeight;
 843         texDesc.MipLevels = 1;
 844         texDesc.Format = sys->render;
 845         texDesc.SampleDesc.Count = 1;
 846         texDesc.MiscFlags = 0;
 847         texDesc.ArraySize = surface_count;
 848         texDesc.Usage = D3D11_USAGE_DEFAULT;
 849         texDesc.BindFlags = D3D11_BIND_DECODER;
 850         texDesc.CPUAccessFlags = 0;
 851
 852         if (DeviceSupportsFormat(sys->d3d_dev.d3ddevice, texDesc.Format, D3D11_FORMAT_SUPPORT_SHADER_LOAD))
 853             texDesc.BindFlags |= D3D11_BIND_SHADER_RESOURCE;
 854
 855         ID3D11Texture2D *p_texture;
 856         hr = ID3D11Device_CreateTexture2D( sys->d3d_dev.d3ddevice, &texDesc, NULL, &p_texture );
 857         if (FAILED(hr)) {
 858             msg_Err(va, "CreateTexture2D %d failed. (hr=0x%0lx)", surface_count, hr);
 859             return VLC_EGENERIC;
 860         }
 861
 862         unsigned surface_idx;
 863         for (surface_idx = 0; surface_idx < surface_count; surface_idx++) {
 864             sys->extern_pics[surface_idx] = NULL;
 865             viewDesc.Texture2D.ArraySlice = surface_idx;
 866
 867             hr = ID3D11VideoDevice_CreateVideoDecoderOutputView( dx_sys->d3ddec,
 868                                                                  (ID3D11Resource*) p_texture,
 869                                                                  &viewDesc,
 870                                                                  &dx_sys->hw_surface[surface_idx] );
 871             if (FAILED(hr)) {
 872                 msg_Err(va, "CreateVideoDecoderOutputView %d failed. (hr=0x%0lx)", surface_idx, hr);
 873                 ID3D11Texture2D_Release(p_texture);
 874                 return VLC_EGENERIC;
 875             }
 876
 877             if (texDesc.BindFlags & D3D11_BIND_SHADER_RESOURCE)
 878             {
 879                 ID3D11Texture2D *textures[D3D11_MAX_SHADER_VIEW] = {p_texture, p_texture};
 880                 AllocateShaderView(VLC_OBJECT(va), sys->d3d_dev.d3ddevice, textureFmt, textures, surface_idx,
 881                                    &sys->resourceView[surface_idx * D3D11_MAX_SHADER_VIEW]);
 882             }
 883         }
 884     }
 885     msg_Dbg(va, "ID3D11VideoDecoderOutputView succeed with %d surfaces (%dx%d)",
 886             surface_count, fmt->i_width, fmt->i_height);
 887
 888     D3D11_VIDEO_DECODER_DESC decoderDesc;
 889     ZeroMemory(&decoderDesc, sizeof(decoderDesc));
 890     decoderDesc.Guid = dx_sys->input;
 891     decoderDesc.SampleWidth = fmt->i_width;
 892     decoderDesc.SampleHeight = fmt->i_height;
 893     decoderDesc.OutputFormat = sys->render;
 894
 895     UINT cfg_count;
 896     hr = ID3D11VideoDevice_GetVideoDecoderConfigCount( dx_sys->d3ddec, &decoderDesc, &cfg_count );
 897     if (FAILED(hr)) {
 898         msg_Err(va, "GetVideoDecoderConfigCount failed. (hr=0x%lX)", hr);
 899         return VLC_EGENERIC;
 900     }
 901
 902     /* List all configurations available for the decoder */
 903     D3D11_VIDEO_DECODER_CONFIG cfg_list[cfg_count];
 904     for (unsigned i = 0; i < cfg_count; i++) {
 905         hr = ID3D11VideoDevice_GetVideoDecoderConfig( dx_sys->d3ddec, &decoderDesc, i, &cfg_list[i] );
 906         if (FAILED(hr)) {
 907             msg_Err(va, "GetVideoDecoderConfig failed. (hr=0x%lX)", hr);
 908             return VLC_EGENERIC;
 909         }
 910     }
 911
 912     msg_Dbg(va, "we got %d decoder configurations", cfg_count);
 913
 914     /* Select the best decoder configuration */
 915     int cfg_score = 0;
 916     for (unsigned i = 0; i < cfg_count; i++) {
 917         const D3D11_VIDEO_DECODER_CONFIG *cfg = &cfg_list[i];
 918
 919         /* */
 920         msg_Dbg(va, "configuration[%d] ConfigBitstreamRaw %d",
 921                 i, cfg->ConfigBitstreamRaw);
 922
 923         /* */
 924         int score;
 925         if (cfg->ConfigBitstreamRaw == 1)
 926             score = 1;
 927         else if (codec_id == AV_CODEC_ID_H264 && cfg->ConfigBitstreamRaw == 2)
 928             score = 2;
 929         else
 930             continue;
 931         if (IsEqualGUID(&cfg->guidConfigBitstreamEncryption, &DXVA2_NoEncrypt))
 932             score += 16;
 933
 934         if (cfg_score < score) {
 935             sys->cfg = *cfg;
 936             cfg_score = score;
 937         }
 938     }
 939     if (cfg_score <= 0) {
 940         msg_Err(va, "Failed to find a supported decoder configuration");
 941         return VLC_EGENERIC;
 942     }
 943
 944     /* Create the decoder */
 945     ID3D11VideoDecoder *decoder;
 946     hr = ID3D11VideoDevice_CreateVideoDecoder( dx_sys->d3ddec, &decoderDesc, &sys->cfg, &decoder );
 947     if (FAILED(hr)) {
 948         msg_Err(va, "ID3D11VideoDevice_CreateVideoDecoder failed. (hr=0x%lX)", hr);
 949         dx_sys->decoder = NULL;
 950         return VLC_EGENERIC;
 951     }
 952     dx_sys->decoder = decoder;
 953
 954     msg_Dbg(va, "DxCreateDecoderSurfaces succeed");
 955     return VLC_SUCCESS;
 956 }
 957
 958 static void DxDestroySurfaces(vlc_va_t *va)
 959 {
 960     directx_sys_t *dx_sys = &va->sys->dx_sys;
 961     if (dx_sys->va_pool.surface_count && !dx_sys->can_extern_pool) {
 962         ID3D11Resource *p_texture;
 963         ID3D11VideoDecoderOutputView_GetResource( dx_sys->hw_surface[0], &p_texture );
 964         ID3D11Resource_Release(p_texture);
 965         ID3D11Resource_Release(p_texture);
 966     }
 967     for (unsigned i = 0; i < dx_sys->va_pool.surface_count; i++)
 968     {
 969         ID3D11VideoDecoderOutputView_Release( dx_sys->hw_surface[i] );
 970         for (int j = 0; j < D3D11_MAX_SHADER_VIEW; j++)
 971         {
 972             if (va->sys->resourceView[i*D3D11_MAX_SHADER_VIEW + j])
 973                 ID3D11ShaderResourceView_Release(va->sys->resourceView[i*D3D11_MAX_SHADER_VIEW + j]);
 974         }
 975     }
 976     if (dx_sys->decoder)
 977     {
 978         ID3D11VideoDecoder_Release(dx_sys->decoder);
 979         dx_sys->decoder = NULL;
 980     }
 981 }