git.sesse.net Git - vlc/blob - modules/codec/avcodec/dxva2.c

   1 /*****************************************************************************
   2  * dxva2.c: Video Acceleration helpers
   3  *****************************************************************************
   4  * Copyright (C) 2009 Geoffroy Couprie
   5  * Copyright (C) 2009 Laurent Aimar
   6  * $Id$
   7  *
   8  * Authors: Geoffroy Couprie <geal@videolan.org>
   9  *          Laurent Aimar <fenrir _AT_ videolan _DOT_ org>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24  *****************************************************************************/
  25
  26 #ifdef HAVE_CONFIG_H
  27 # include "config.h"
  28 #endif
  29
  30
  31 #if defined(HAVE_LIBAVCODEC_AVCODEC_H) && defined(HAVE_AVCODEC_DXVA2)
  32 # if _WIN32_WINNT < 0x600
  33 /* dxva2 needs Vista support */
  34 #  undef _WIN32_WINNT
  35 #  define _WIN32_WINNT 0x600
  36 # endif
  37 #endif
  38
  39 #include <vlc_common.h>
  40 #include <vlc_picture.h>
  41 #include <vlc_fourcc.h>
  42 #include <vlc_cpu.h>
  43 #include <assert.h>
  44
  45 #ifdef HAVE_LIBAVCODEC_AVCODEC_H
  46 #   include <libavcodec/avcodec.h>
  47 #   ifdef HAVE_AVCODEC_DXVA2
  48 #       define DXVA2API_USE_BITFIELDS
  49 #       define COBJMACROS
  50 #       include <libavcodec/dxva2.h>
  51 #   endif
  52 #else
  53 #   include <avcodec.h>
  54 #endif
  55
  56 #include "avcodec.h"
  57 #include "va.h"
  58 #include "copy.h"
  59
  60 #ifdef HAVE_AVCODEC_DXVA2
  61
  62 #include <windows.h>
  63 #include <windowsx.h>
  64 #include <ole2.h>
  65 #include <commctrl.h>
  66 #include <shlwapi.h>
  67 #include <d3d9.h>
  68
  69 /* */
  70 #define DXVA2_E_NOT_INITIALIZED     MAKE_HRESULT(1, 4, 4096)
  71 #define DXVA2_E_NEW_VIDEO_DEVICE    MAKE_HRESULT(1, 4, 4097)
  72 #define DXVA2_E_VIDEO_DEVICE_LOCKED MAKE_HRESULT(1, 4, 4098)
  73 #define DXVA2_E_NOT_AVAILABLE       MAKE_HRESULT(1, 4, 4099)
  74
  75 static const GUID DXVA2_ModeMPEG2_MoComp = {
  76     0xe6a9f44b, 0x61b0,0x4563, {0x9e,0xa4,0x63,0xd2,0xa3,0xc6,0xfe,0x66}
  77 };
  78 static const GUID DXVA2_ModeMPEG2_IDCT = {
  79     0xbf22ad00, 0x03ea,0x4690, {0x80,0x77,0x47,0x33,0x46,0x20,0x9b,0x7e}
  80 };
  81 static const GUID DXVA2_ModeMPEG2_VLD = {
  82     0xee27417f, 0x5e28,0x4e65, {0xbe,0xea,0x1d,0x26,0xb5,0x08,0xad,0xc9}
  83 };
  84 static const GUID DXVA2_ModeMPEG2and1_VLD = {
  85     0x86695f12, 0x340e,0x4f04, {0x9f,0xd3,0x92,0x53,0xdd,0x32,0x74,0x60}
  86 };
  87 static const GUID DXVA2_ModeMPEG1_VLD = {
  88     0x6f3ec719, 0x3735,0x42cc, {0x80,0x63,0x65,0xcc,0x3c,0xb3,0x66,0x16}
  89 };
  90
  91 static const GUID DXVA2_ModeH264_A = {
  92     0x1b81be64, 0xa0c7,0x11d3, {0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5}
  93 };
  94 static const GUID DXVA2_ModeH264_B = {
  95     0x1b81be65, 0xa0c7,0x11d3, {0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5}
  96 };
  97 static const GUID DXVA2_ModeH264_C = {
  98     0x1b81be66, 0xa0c7,0x11d3, {0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5}
  99 };
 100 static const GUID DXVA2_ModeH264_D = {
 101     0x1b81be67, 0xa0c7,0x11d3, {0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5}
 102 };
 103 static const GUID DXVA2_ModeH264_E = {
 104     0x1b81be68, 0xa0c7,0x11d3, {0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5}
 105 };
 106 static const GUID DXVA2_ModeH264_F = {
 107     0x1b81be69, 0xa0c7,0x11d3, {0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5}
 108 };
 109 static const GUID DXVA_ModeH264_VLD_WithFMOASO_NoFGT = {
 110     0xd5f04ff9, 0x3418,0x45d8, {0x95,0x61,0x32,0xa7,0x6a,0xae,0x2d,0xdd}
 111 };
 112 static const GUID DXVADDI_Intel_ModeH264_A = {
 113     0x604F8E64, 0x4951,0x4c54, {0x88,0xFE,0xAB,0xD2,0x5C,0x15,0xB3,0xD6}
 114 };
 115 static const GUID DXVADDI_Intel_ModeH264_C = {
 116     0x604F8E66, 0x4951,0x4c54, {0x88,0xFE,0xAB,0xD2,0x5C,0x15,0xB3,0xD6}
 117 };
 118 static const GUID DXVADDI_Intel_ModeH264_E = { // DXVA_Intel_H264_NoFGT_ClearVideo
 119     0x604F8E68, 0x4951,0x4c54, {0x88,0xFE,0xAB,0xD2,0x5C,0x15,0xB3,0xD6}
 120 };
 121 static const GUID DXVA_ModeH264_VLD_NoFGT_Flash = {
 122     0x4245F676, 0x2BBC,0x4166, {0xa0,0xBB,0x54,0xE7,0xB8,0x49,0xC3,0x80}
 123 };
 124
 125 static const GUID DXVA2_ModeWMV8_A = {
 126     0x1b81be80, 0xa0c7,0x11d3, {0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5}
 127 };
 128 static const GUID DXVA2_ModeWMV8_B = {
 129     0x1b81be81, 0xa0c7,0x11d3, {0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5}
 130 };
 131 static const GUID DXVA2_ModeWMV9_A = {
 132     0x1b81be90, 0xa0c7,0x11d3, {0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5}
 133 };
 134 static const GUID DXVA2_ModeWMV9_B = {
 135     0x1b81be91, 0xa0c7,0x11d3, {0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5}
 136 };
 137 static const GUID DXVA2_ModeWMV9_C = {
 138     0x1b81be94, 0xa0c7,0x11d3, {0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5}
 139 };
 140
 141 static const GUID DXVA2_ModeVC1_A = {
 142     0x1b81beA0, 0xa0c7,0x11d3, {0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5}
 143 };
 144 static const GUID DXVA2_ModeVC1_B = {
 145     0x1b81beA1, 0xa0c7,0x11d3, {0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5}
 146 };
 147 static const GUID DXVA2_ModeVC1_C = {
 148     0x1b81beA2, 0xa0c7,0x11d3, {0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5}
 149 };
 150 static const GUID DXVA2_ModeVC1_D = {
 151     0x1b81beA3, 0xa0c7,0x11d3, {0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5}
 152 };
 153 /* Conformity to the August 2010 update of the specification, ModeVC1_VLD2010 */
 154 static const GUID DXVA2_ModeVC1_D2010 = {
 155     0x1b81beA4, 0xa0c7,0x11d3, {0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5}
 156 };
 157
 158 static const GUID DXVA_NoEncrypt = {
 159     0x1b81bed0, 0xa0c7,0x11d3, {0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5}
 160 };
 161
 162 static const GUID DXVA_Intel_VC1_ClearVideo = {
 163     0xBCC5DB6D, 0xA2B6,0x4AF0, {0xAC,0xE4,0xAD,0xB1,0xF7,0x87,0xBC,0x89}
 164 };
 165 static const GUID DXVA_Intel_VC1_ClearVideo_2 = {
 166     0xE07EC519, 0xE651,0x4CD6, {0xAC,0x84,0x13,0x70,0xCC,0xEE,0xC8,0x51}
 167 };
 168
 169
 170 static const GUID DXVA_nVidia_MPEG4_ASP = {
 171     0x9947EC6F, 0x689B,0x11DC, {0xA3,0x20,0x00,0x19,0xDB,0xBC,0x41,0x84}
 172 };
 173 static const GUID DXVA_ModeMPEG4pt2_VLD_Simple = {
 174     0xefd64d74, 0xc9e8,0x41d7, {0xa5,0xe9,0xe9,0xb0,0xe3,0x9f,0xa3,0x19}
 175 };
 176 static const GUID DXVA_ModeMPEG4pt2_VLD_AdvSimple_NoGMC = {
 177     0xed418a9f, 0x10d,0x4eda,  {0x9a,0xe3,0x9a,0x65,0x35,0x8d,0x8d,0x2e}
 178 };
 179 static const GUID DXVA_ModeMPEG4pt2_VLD_AdvSimple_GMC = {
 180     0xab998b5b, 0x4258,0x44a9, {0x9f,0xeb,0x94,0xe5,0x97,0xa6,0xba,0xae}
 181 };
 182 static const GUID DXVA_ModeMPEG4pt2_VLD_AdvSimple_Avivo = {
 183     0x7C74ADC6, 0xe2ba,0x4ade, {0x86,0xde,0x30,0xbe,0xab,0xb4,0x0c,0xc1}
 184 };
 185
 186 /* MVC */
 187 static const GUID DXVA_ModeH264_VLD_Multiview = {
 188     0x9901CCD3, 0xca12,0x4b7e, {0x86,0x7a,0xe2,0x22,0x3d,0x92,0x55,0xc3}
 189 };
 190
 191 /* */
 192 typedef struct {
 193     const char   *name;
 194     const GUID   *guid;
 195     int          codec;
 196 } dxva2_mode_t;
 197 /* XXX Prefered modes must come first */
 198 static const dxva2_mode_t dxva2_modes[] = {
 199     /* MPEG-1/2 */
 200     { "MPEG-2 variable-length decoder",                                               &DXVA2_ModeMPEG2_VLD,                   CODEC_ID_MPEG2VIDEO },
 201     { "MPEG-2 & MPEG-1 variable-length decoder",                                      &DXVA2_ModeMPEG2and1_VLD,               CODEC_ID_MPEG2VIDEO },
 202     { "MPEG-2 motion compensation",                                                   &DXVA2_ModeMPEG2_MoComp,                0 },
 203     { "MPEG-2 inverse discrete cosine transform",                                     &DXVA2_ModeMPEG2_IDCT,                  0 },
 204
 205     { "MPEG-1 variable-length decoder",                                               &DXVA2_ModeMPEG1_VLD,                   0 },
 206
 207     /* H.264 */
 208     { "H.264 variable-length decoder, film grain technology",                         &DXVA2_ModeH264_F,                      CODEC_ID_H264 },
 209     { "H.264 variable-length decoder, no film grain technology",                      &DXVA2_ModeH264_E,                      CODEC_ID_H264 },
 210     { "H.264 variable-length decoder, no film grain technology (Intel ClearVideo)",   &DXVADDI_Intel_ModeH264_E,              CODEC_ID_H264 },
 211     { "H.264 variable-length decoder, no film grain technology, FMO/ASO",             &DXVA_ModeH264_VLD_WithFMOASO_NoFGT,    CODEC_ID_H264 },
 212     { "H.264 variable-length decoder, no film grain technology, Flash",               &DXVA_ModeH264_VLD_NoFGT_Flash,         CODEC_ID_H264 },
 213
 214     { "H.264 inverse discrete cosine transform, film grain technology",               &DXVA2_ModeH264_D,                      0 },
 215     { "H.264 inverse discrete cosine transform, no film grain technology",            &DXVA2_ModeH264_C,                      0 },
 216     { "H.264 inverse discrete cosine transform, no film grain technology (Intel)",    &DXVADDI_Intel_ModeH264_C,              0 },
 217
 218     { "H.264 motion compensation, film grain technology",                             &DXVA2_ModeH264_B,                      0 },
 219     { "H.264 motion compensation, no film grain technology",                          &DXVA2_ModeH264_A,                      0 },
 220     { "H.264 motion compensation, no film grain technology (Intel)",                  &DXVADDI_Intel_ModeH264_A,              0 },
 221
 222     /* WMV */
 223     { "Windows Media Video 8 motion compensation",                                    &DXVA2_ModeWMV8_B,                      0 },
 224     { "Windows Media Video 8 post processing",                                        &DXVA2_ModeWMV8_A,                      0 },
 225
 226     { "Windows Media Video 9 IDCT",                                                   &DXVA2_ModeWMV9_C,                      0 },
 227     { "Windows Media Video 9 motion compensation",                                    &DXVA2_ModeWMV9_B,                      0 },
 228     { "Windows Media Video 9 post processing",                                        &DXVA2_ModeWMV9_A,                      0 },
 229
 230     /* VC-1 */
 231     { "VC-1 variable-length decoder",                                                 &DXVA2_ModeVC1_D,                       CODEC_ID_VC1 },
 232     { "VC-1 variable-length decoder",                                                 &DXVA2_ModeVC1_D,                       CODEC_ID_WMV3 },
 233     { "VC-1 variable-length decoder",                                                 &DXVA2_ModeVC1_D2010,                   CODEC_ID_VC1 },
 234     { "VC-1 variable-length decoder",                                                 &DXVA2_ModeVC1_D2010,                   CODEC_ID_WMV3 },
 235     { "VC-1 variable-length decoder 2 (Intel)",                                       &DXVA_Intel_VC1_ClearVideo_2,           0 },
 236     { "VC-1 variable-length decoder (Intel)",                                         &DXVA_Intel_VC1_ClearVideo,             0 },
 237
 238     { "VC-1 inverse discrete cosine transform",                                       &DXVA2_ModeVC1_C,                       0 },
 239     { "VC-1 motion compensation",                                                     &DXVA2_ModeVC1_B,                       0 },
 240     { "VC-1 post processing",                                                         &DXVA2_ModeVC1_A,                       0 },
 241
 242     /* Xvid/Divx: TODO */
 243     { "MPEG-4 Part 2 nVidia bitstream decoder",                                       &DXVA_nVidia_MPEG4_ASP,                 0 },
 244     { "MPEG-4 Part 2 variable-length decoder, Simple Profile",                        &DXVA_ModeMPEG4pt2_VLD_Simple,          0 },
 245     { "MPEG-4 Part 2 variable-length decoder, Simple&Advanced Profile, no GMC",       &DXVA_ModeMPEG4pt2_VLD_AdvSimple_NoGMC, 0 },
 246     { "MPEG-4 Part 2 variable-length decoder, Simple&Advanced Profile, GMC",          &DXVA_ModeMPEG4pt2_VLD_AdvSimple_GMC,   0 },
 247     { "MPEG-4 Part 2 variable-length decoder, Simple&Advanced Profile, Avivo",        &DXVA_ModeMPEG4pt2_VLD_AdvSimple_Avivo, 0 },
 248
 249     { NULL, NULL, 0 }
 250 };
 251
 252 static const dxva2_mode_t *Dxva2FindMode(const GUID *guid)
 253 {
 254     for (unsigned i = 0; dxva2_modes[i].name; i++) {
 255         if (IsEqualGUID(dxva2_modes[i].guid, guid))
 256             return &dxva2_modes[i];
 257     }
 258     return NULL;
 259 }
 260
 261 /* */
 262 typedef struct {
 263     const char   *name;
 264     D3DFORMAT    format;
 265     vlc_fourcc_t codec;
 266 } d3d_format_t;
 267 /* XXX Prefered format must come first */
 268 static const d3d_format_t d3d_formats[] = {
 269     { "YV12",   MAKEFOURCC('Y','V','1','2'),    VLC_CODEC_YV12 },
 270     { "NV12",   MAKEFOURCC('N','V','1','2'),    VLC_CODEC_NV12 },
 271
 272     { NULL, 0, 0 }
 273 };
 274
 275 static const d3d_format_t *D3dFindFormat(D3DFORMAT format)
 276 {
 277     for (unsigned i = 0; d3d_formats[i].name; i++) {
 278         if (d3d_formats[i].format == format)
 279             return &d3d_formats[i];
 280     }
 281     return NULL;
 282 }
 283
 284 static const GUID IID_IDirectXVideoDecoderService = {
 285     0xfc51a551, 0xd5e7, 0x11d9, {0xaf,0x55,0x00,0x05,0x4e,0x43,0xff,0x02}
 286 };
 287 static const GUID IID_IDirectXVideoAccelerationService = {
 288     0xfc51a550, 0xd5e7, 0x11d9, {0xaf,0x55,0x00,0x05,0x4e,0x43,0xff,0x02}
 289 };
 290
 291 /* */
 292 typedef struct {
 293     LPDIRECT3DSURFACE9 d3d;
 294     int                refcount;
 295     unsigned int       order;
 296 } vlc_va_surface_t;
 297
 298 #define VA_DXVA2_MAX_SURFACE_COUNT (64)
 299 typedef struct
 300 {
 301     /* */
 302     vlc_va_t va;
 303
 304     /* */
 305     vlc_object_t *log;
 306     int          codec_id;
 307     int          width;
 308     int          height;
 309
 310     /* DLL */
 311     HINSTANCE             hd3d9_dll;
 312     HINSTANCE             hdxva2_dll;
 313
 314     /* Direct3D */
 315     D3DPRESENT_PARAMETERS  d3dpp;
 316     LPDIRECT3D9            d3dobj;
 317     D3DADAPTER_IDENTIFIER9 d3dai;
 318     LPDIRECT3DDEVICE9      d3ddev;
 319
 320     /* Device manager */
 321     UINT                     token;
 322     IDirect3DDeviceManager9  *devmng;
 323     HANDLE                   device;
 324
 325     /* Video service */
 326     IDirectXVideoDecoderService  *vs;
 327     GUID                         input;
 328     D3DFORMAT                    render;
 329
 330     /* Video decoder */
 331     DXVA2_ConfigPictureDecode    cfg;
 332     IDirectXVideoDecoder         *decoder;
 333
 334     /* Option conversion */
 335     D3DFORMAT                    output;
 336     copy_cache_t                 surface_cache;
 337
 338     /* */
 339     struct dxva_context hw;
 340
 341     /* */
 342     unsigned     surface_count;
 343     unsigned     surface_order;
 344     int          surface_width;
 345     int          surface_height;
 346     vlc_fourcc_t surface_chroma;
 347
 348     vlc_va_surface_t surface[VA_DXVA2_MAX_SURFACE_COUNT];
 349     LPDIRECT3DSURFACE9 hw_surface[VA_DXVA2_MAX_SURFACE_COUNT];
 350 } vlc_va_dxva2_t;
 351
 352 /* */
 353 static vlc_va_dxva2_t *vlc_va_dxva2_Get(void *external)
 354 {
 355     assert(external == (void*)(&((vlc_va_dxva2_t*)external)->va));
 356     return external;
 357 }
 358
 359 /* */
 360 static int D3dCreateDevice(vlc_va_dxva2_t *);
 361 static void D3dDestroyDevice(vlc_va_dxva2_t *);
 362 static char *DxDescribe(vlc_va_dxva2_t *);
 363
 364 static int D3dCreateDeviceManager(vlc_va_dxva2_t *);
 365 static void D3dDestroyDeviceManager(vlc_va_dxva2_t *);
 366
 367 static int DxCreateVideoService(vlc_va_dxva2_t *);
 368 static void DxDestroyVideoService(vlc_va_dxva2_t *);
 369 static int DxFindVideoServiceConversion(vlc_va_dxva2_t *, GUID *input, D3DFORMAT *output);
 370
 371 static int DxCreateVideoDecoder(vlc_va_dxva2_t *,
 372                                 int codec_id, const video_format_t *);
 373 static void DxDestroyVideoDecoder(vlc_va_dxva2_t *);
 374 static int DxResetVideoDecoder(vlc_va_dxva2_t *);
 375
 376 static void DxCreateVideoConversion(vlc_va_dxva2_t *);
 377 static void DxDestroyVideoConversion(vlc_va_dxva2_t *);
 378
 379 /* */
 380 static int Setup(vlc_va_t *external, void **hw, vlc_fourcc_t *chroma,
 381                  int width, int height)
 382 {
 383     vlc_va_dxva2_t *va = vlc_va_dxva2_Get(external);
 384
 385     if (va->width == width && va->height == height && va->decoder)
 386         goto ok;
 387
 388     /* */
 389     DxDestroyVideoConversion(va);
 390     DxDestroyVideoDecoder(va);
 391
 392     *hw = NULL;
 393     *chroma = 0;
 394     if (width <= 0 || height <= 0)
 395         return VLC_EGENERIC;
 396
 397     /* FIXME transmit a video_format_t by VaSetup directly */
 398     video_format_t fmt;
 399     memset(&fmt, 0, sizeof(fmt));
 400     fmt.i_width = width;
 401     fmt.i_height = height;
 402
 403     if (DxCreateVideoDecoder(va, va->codec_id, &fmt))
 404         return VLC_EGENERIC;
 405     /* */
 406     va->hw.decoder = va->decoder;
 407     va->hw.cfg = &va->cfg;
 408     va->hw.surface_count = va->surface_count;
 409     va->hw.surface = va->hw_surface;
 410     for (unsigned i = 0; i < va->surface_count; i++)
 411         va->hw.surface[i] = va->surface[i].d3d;
 412
 413     /* */
 414     DxCreateVideoConversion(va);
 415
 416     /* */
 417 ok:
 418     *hw = &va->hw;
 419     const d3d_format_t *output = D3dFindFormat(va->output);
 420     *chroma = output->codec;
 421
 422     return VLC_SUCCESS;
 423 }
 424
 425 static int Extract(vlc_va_t *external, picture_t *picture, AVFrame *ff)
 426 {
 427     vlc_va_dxva2_t *va = vlc_va_dxva2_Get(external);
 428     LPDIRECT3DSURFACE9 d3d = (LPDIRECT3DSURFACE9)(uintptr_t)ff->data[3];
 429
 430     if (!va->surface_cache.buffer)
 431         return VLC_EGENERIC;
 432
 433     /* */
 434     assert(va->output == MAKEFOURCC('Y','V','1','2'));
 435
 436     /* */
 437     D3DLOCKED_RECT lock;
 438     if (FAILED(IDirect3DSurface9_LockRect(d3d, &lock, NULL, D3DLOCK_READONLY))) {
 439         msg_Err(va->log, "Failed to lock surface");
 440         return VLC_EGENERIC;
 441     }
 442
 443     if (va->render == MAKEFOURCC('Y','V','1','2')) {
 444         uint8_t *plane[3] = {
 445             lock.pBits,
 446             (uint8_t*)lock.pBits + lock.Pitch * va->surface_height,
 447             (uint8_t*)lock.pBits + lock.Pitch * va->surface_height
 448                                  + (lock.Pitch/2) * (va->surface_height/2)
 449         };
 450         size_t  pitch[3] = {
 451             lock.Pitch,
 452             lock.Pitch / 2,
 453             lock.Pitch / 2,
 454         };
 455         CopyFromYv12(picture, plane, pitch,
 456                      va->width, va->height,
 457                      &va->surface_cache);
 458     } else {
 459         assert(va->render == MAKEFOURCC('N','V','1','2'));
 460         uint8_t *plane[2] = {
 461             lock.pBits,
 462             (uint8_t*)lock.pBits + lock.Pitch * va->surface_height
 463         };
 464         size_t  pitch[2] = {
 465             lock.Pitch,
 466             lock.Pitch,
 467         };
 468         CopyFromNv12(picture, plane, pitch,
 469                      va->width, va->height,
 470                      &va->surface_cache);
 471     }
 472
 473     /* */
 474     IDirect3DSurface9_UnlockRect(d3d);
 475     return VLC_SUCCESS;
 476 }
 477 /* FIXME it is nearly common with VAAPI */
 478 static int Get(vlc_va_t *external, AVFrame *ff)
 479 {
 480     vlc_va_dxva2_t *va = vlc_va_dxva2_Get(external);
 481
 482     /* Check the device */
 483     HRESULT hr = IDirect3DDeviceManager9_TestDevice(va->devmng, va->device);
 484     if (hr == DXVA2_E_NEW_VIDEO_DEVICE) {
 485         if (DxResetVideoDecoder(va))
 486             return VLC_EGENERIC;
 487     } else if (FAILED(hr)) {
 488         msg_Err(va->log, "IDirect3DDeviceManager9_TestDevice %u", (unsigned)hr);
 489         return VLC_EGENERIC;
 490     }
 491
 492     /* Grab an unused surface, in case none are, try the oldest
 493      * XXX using the oldest is a workaround in case a problem happens with ffmpeg */
 494     unsigned i, old;
 495     for (i = 0, old = 0; i < va->surface_count; i++) {
 496         vlc_va_surface_t *surface = &va->surface[i];
 497
 498         if (!surface->refcount)
 499             break;
 500
 501         if (surface->order < va->surface[old].order)
 502             old = i;
 503     }
 504     if (i >= va->surface_count)
 505         i = old;
 506
 507     vlc_va_surface_t *surface = &va->surface[i];
 508
 509     surface->refcount = 1;
 510     surface->order = va->surface_order++;
 511
 512     /* */
 513     for (int i = 0; i < 4; i++) {
 514         ff->data[i] = NULL;
 515         ff->linesize[i] = 0;
 516
 517         if (i == 0 || i == 3)
 518             ff->data[i] = (void*)surface->d3d;/* Yummie */
 519     }
 520     return VLC_SUCCESS;
 521 }
 522 static void Release(vlc_va_t *external, AVFrame *ff)
 523 {
 524     vlc_va_dxva2_t *va = vlc_va_dxva2_Get(external);
 525     LPDIRECT3DSURFACE9 d3d = (LPDIRECT3DSURFACE9)(uintptr_t)ff->data[3];
 526
 527     for (unsigned i = 0; i < va->surface_count; i++) {
 528         vlc_va_surface_t *surface = &va->surface[i];
 529
 530         if (surface->d3d == d3d)
 531             surface->refcount--;
 532     }
 533 }
 534 static void Close(vlc_va_t *external)
 535 {
 536     vlc_va_dxva2_t *va = vlc_va_dxva2_Get(external);
 537
 538     DxDestroyVideoConversion(va);
 539     DxDestroyVideoDecoder(va);
 540     DxDestroyVideoService(va);
 541     D3dDestroyDeviceManager(va);
 542     D3dDestroyDevice(va);
 543
 544     if (va->hdxva2_dll)
 545         FreeLibrary(va->hdxva2_dll);
 546     if (va->hd3d9_dll)
 547         FreeLibrary(va->hd3d9_dll);
 548
 549     free(va->va.description);
 550     free(va);
 551 }
 552
 553 vlc_va_t *vlc_va_NewDxva2(vlc_object_t *log, int codec_id)
 554 {
 555     vlc_va_dxva2_t *va = calloc(1, sizeof(*va));
 556     if (!va)
 557         return NULL;
 558
 559     /* */
 560     va->log = log;
 561     va->codec_id = codec_id;
 562
 563     /* Load dll*/
 564     va->hd3d9_dll = LoadLibrary(TEXT("D3D9.DLL"));
 565     if (!va->hd3d9_dll) {
 566         msg_Warn(va->log, "cannot load d3d9.dll");
 567         goto error;
 568     }
 569     va->hdxva2_dll = LoadLibrary(TEXT("DXVA2.DLL"));
 570     if (!va->hdxva2_dll) {
 571         msg_Warn(va->log, "cannot load dxva2.dll");
 572         goto error;
 573     }
 574     msg_Dbg(va->log, "DLLs loaded");
 575
 576     /* */
 577     if (D3dCreateDevice(va)) {
 578         msg_Err(va->log, "Failed to create Direct3D device");
 579         goto error;
 580     }
 581     msg_Dbg(va->log, "D3dCreateDevice succeed");
 582
 583     if (D3dCreateDeviceManager(va)) {
 584         msg_Err(va->log, "D3dCreateDeviceManager failed");
 585         goto error;
 586     }
 587
 588     if (DxCreateVideoService(va)) {
 589         msg_Err(va->log, "DxCreateVideoService failed");
 590         goto error;
 591     }
 592
 593     /* */
 594     if (DxFindVideoServiceConversion(va, &va->input, &va->render)) {
 595         msg_Err(va->log, "DxFindVideoServiceConversion failed");
 596         goto error;
 597     }
 598
 599     /* TODO print the hardware name/vendor for debugging purposes */
 600     va->va.description = DxDescribe(va);
 601     va->va.setup   = Setup;
 602     va->va.get     = Get;
 603     va->va.release = Release;
 604     va->va.extract = Extract;
 605     va->va.close   = Close;
 606     return &va->va;
 607
 608 error:
 609     Close(&va->va);
 610     return NULL;
 611 }
 612 /* */
 613
 614 /**
 615  * It creates a Direct3D device usable for DXVA 2
 616  */
 617 static int D3dCreateDevice(vlc_va_dxva2_t *va)
 618 {
 619     /* */
 620     LPDIRECT3D9 (WINAPI *Create9)(UINT SDKVersion);
 621     Create9 = (void *)GetProcAddress(va->hd3d9_dll,
 622                                      TEXT("Direct3DCreate9"));
 623     if (!Create9) {
 624         msg_Err(va->log, "Cannot locate reference to Direct3DCreate9 ABI in DLL");
 625         return VLC_EGENERIC;
 626     }
 627
 628     /* */
 629     LPDIRECT3D9 d3dobj;
 630     d3dobj = Create9(D3D_SDK_VERSION);
 631     if (!d3dobj) {
 632         msg_Err(va->log, "Direct3DCreate9 failed");
 633         return VLC_EGENERIC;
 634     }
 635     va->d3dobj = d3dobj;
 636
 637     /* */
 638     D3DADAPTER_IDENTIFIER9 *d3dai = &va->d3dai;
 639     if (FAILED(IDirect3D9_GetAdapterIdentifier(va->d3dobj,
 640                                                D3DADAPTER_DEFAULT, 0, d3dai))) {
 641         msg_Warn(va->log, "IDirect3D9_GetAdapterIdentifier failed");
 642         ZeroMemory(d3dai, sizeof(*d3dai));
 643     }
 644
 645     /* */
 646     D3DPRESENT_PARAMETERS *d3dpp = &va->d3dpp;
 647     ZeroMemory(d3dpp, sizeof(*d3dpp));
 648     d3dpp->Flags                  = D3DPRESENTFLAG_VIDEO;
 649     d3dpp->Windowed               = TRUE;
 650     d3dpp->hDeviceWindow          = NULL;
 651     d3dpp->SwapEffect             = D3DSWAPEFFECT_DISCARD;
 652     d3dpp->MultiSampleType        = D3DMULTISAMPLE_NONE;
 653     d3dpp->PresentationInterval   = D3DPRESENT_INTERVAL_DEFAULT;
 654     d3dpp->BackBufferCount        = 0;                  /* FIXME what to put here */
 655     d3dpp->BackBufferFormat       = D3DFMT_X8R8G8B8;    /* FIXME what to put here */
 656     d3dpp->BackBufferWidth        = 0;
 657     d3dpp->BackBufferHeight       = 0;
 658     d3dpp->EnableAutoDepthStencil = FALSE;
 659
 660     /* Direct3D needs a HWND to create a device, even without using ::Present
 661     this HWND is used to alert Direct3D when there's a change of focus window.
 662     For now, use GetShellWindow, as it looks harmless */
 663     LPDIRECT3DDEVICE9 d3ddev;
 664     if (FAILED(IDirect3D9_CreateDevice(d3dobj, D3DADAPTER_DEFAULT,
 665                                        D3DDEVTYPE_HAL, GetShellWindow(),
 666                                        D3DCREATE_SOFTWARE_VERTEXPROCESSING |
 667                                        D3DCREATE_MULTITHREADED,
 668                                        d3dpp, &d3ddev))) {
 669         msg_Err(va->log, "IDirect3D9_CreateDevice failed");
 670         return VLC_EGENERIC;
 671     }
 672     va->d3ddev = d3ddev;
 673
 674     return VLC_SUCCESS;
 675 }
 676 /**
 677  * It releases a Direct3D device and its resources.
 678  */
 679 static void D3dDestroyDevice(vlc_va_dxva2_t *va)
 680 {
 681     if (va->d3ddev)
 682         IDirect3DDevice9_Release(va->d3ddev);
 683     if (va->d3dobj)
 684         IDirect3D9_Release(va->d3dobj);
 685 }
 686 /**
 687  * It describes our Direct3D object
 688  */
 689 static char *DxDescribe(vlc_va_dxva2_t *va)
 690 {
 691     static const struct {
 692         unsigned id;
 693         char     name[32];
 694     } vendors [] = {
 695         { 0x1002, "ATI" },
 696         { 0x10DE, "NVIDIA" },
 697         { 0x8086, "Intel" },
 698         { 0x5333, "S3 Graphics" },
 699         { 0, "" }
 700     };
 701     D3DADAPTER_IDENTIFIER9 *id = &va->d3dai;
 702
 703     const char *vendor = "Unknown";
 704     for (int i = 0; vendors[i].id != 0; i++) {
 705         if (vendors[i].id == id->VendorId) {
 706             vendor = vendors[i].name;
 707             break;
 708         }
 709     }
 710
 711     char *description;
 712     if (asprintf(&description, "DXVA2 (%.*s, vendor %d(%s), device %d, revision %d)",
 713                  sizeof(id->Description), id->Description,
 714                  id->VendorId, vendor, id->DeviceId, id->Revision) < 0)
 715         return NULL;
 716     return description;
 717 }
 718
 719 /**
 720  * It creates a Direct3D device manager
 721  */
 722 static int D3dCreateDeviceManager(vlc_va_dxva2_t *va)
 723 {
 724     HRESULT (WINAPI *CreateDeviceManager9)(UINT *pResetToken,
 725                                            IDirect3DDeviceManager9 **);
 726     CreateDeviceManager9 =
 727       (void *)GetProcAddress(va->hdxva2_dll,
 728                              TEXT("DXVA2CreateDirect3DDeviceManager9"));
 729
 730     if (!CreateDeviceManager9) {
 731         msg_Err(va->log, "cannot load function");
 732         return VLC_EGENERIC;
 733     }
 734     msg_Dbg(va->log, "OurDirect3DCreateDeviceManager9 Success!");
 735
 736     UINT token;
 737     IDirect3DDeviceManager9 *devmng;
 738     if (FAILED(CreateDeviceManager9(&token, &devmng))) {
 739         msg_Err(va->log, " OurDirect3DCreateDeviceManager9 failed");
 740         return VLC_EGENERIC;
 741     }
 742     va->token  = token;
 743     va->devmng = devmng;
 744     msg_Info(va->log, "obtained IDirect3DDeviceManager9");
 745
 746     HRESULT hr = IDirect3DDeviceManager9_ResetDevice(devmng, va->d3ddev, token);
 747     if (FAILED(hr)) {
 748         msg_Err(va->log, "IDirect3DDeviceManager9_ResetDevice failed: %08x", (unsigned)hr);
 749         return VLC_EGENERIC;
 750     }
 751     return VLC_SUCCESS;
 752 }
 753 /**
 754  * It destroys a Direct3D device manager
 755  */
 756 static void D3dDestroyDeviceManager(vlc_va_dxva2_t *va)
 757 {
 758     if (va->devmng)
 759         IDirect3DDeviceManager9_Release(va->devmng);
 760 }
 761
 762 /**
 763  * It creates a DirectX video service
 764  */
 765 static int DxCreateVideoService(vlc_va_dxva2_t *va)
 766 {
 767     HRESULT (WINAPI *CreateVideoService)(IDirect3DDevice9 *,
 768                                          REFIID riid,
 769                                          void **ppService);
 770     CreateVideoService =
 771       (void *)GetProcAddress(va->hdxva2_dll,
 772                              TEXT("DXVA2CreateVideoService"));
 773
 774     if (!CreateVideoService) {
 775         msg_Err(va->log, "cannot load function");
 776         return 4;
 777     }
 778     msg_Info(va->log, "DXVA2CreateVideoService Success!");
 779
 780     HRESULT hr;
 781
 782     HANDLE device;
 783     hr = IDirect3DDeviceManager9_OpenDeviceHandle(va->devmng, &device);
 784     if (FAILED(hr)) {
 785         msg_Err(va->log, "OpenDeviceHandle failed");
 786         return VLC_EGENERIC;
 787     }
 788     va->device = device;
 789
 790     IDirectXVideoDecoderService *vs;
 791     hr = IDirect3DDeviceManager9_GetVideoService(va->devmng, device,
 792                                                  &IID_IDirectXVideoDecoderService,
 793                                                  (void**)&vs);
 794     if (FAILED(hr)) {
 795         msg_Err(va->log, "GetVideoService failed");
 796         return VLC_EGENERIC;
 797     }
 798     va->vs = vs;
 799
 800     return VLC_SUCCESS;
 801 }
 802 /**
 803  * It destroys a DirectX video service
 804  */
 805 static void DxDestroyVideoService(vlc_va_dxva2_t *va)
 806 {
 807     if (va->device)
 808         IDirect3DDeviceManager9_CloseDeviceHandle(va->devmng, va->device);
 809     if (va->vs)
 810         IDirectXVideoDecoderService_Release(va->vs);
 811 }
 812 /**
 813  * Find the best suited decoder mode GUID and render format.
 814  */
 815 static int DxFindVideoServiceConversion(vlc_va_dxva2_t *va, GUID *input, D3DFORMAT *output)
 816 {
 817     /* Retreive supported modes from the decoder service */
 818     UINT input_count = 0;
 819     GUID *input_list = NULL;
 820     if (FAILED(IDirectXVideoDecoderService_GetDecoderDeviceGuids(va->vs,
 821                                                                  &input_count,
 822                                                                  &input_list))) {
 823         msg_Err(va->log, "IDirectXVideoDecoderService_GetDecoderDeviceGuids failed");
 824         return VLC_EGENERIC;
 825     }
 826     for (unsigned i = 0; i < input_count; i++) {
 827         const GUID *g = &input_list[i];
 828         const dxva2_mode_t *mode = Dxva2FindMode(g);
 829         if (mode) {
 830             msg_Dbg(va->log, "- '%s' is supported by hardware", mode->name);
 831         } else {
 832             msg_Warn(va->log, "- Unknown GUID = %08X-%04x-%04x-XXXX",
 833                      (unsigned)g->Data1, g->Data2, g->Data3);
 834         }
 835     }
 836
 837     /* Try all supported mode by our priority */
 838     for (unsigned i = 0; dxva2_modes[i].name; i++) {
 839         const dxva2_mode_t *mode = &dxva2_modes[i];
 840         if (!mode->codec || mode->codec != va->codec_id)
 841             continue;
 842
 843         /* */
 844         bool is_suported = false;
 845         for (const GUID *g = &input_list[0]; !is_suported && g < &input_list[input_count]; g++) {
 846             is_suported = IsEqualGUID(mode->guid, g);
 847         }
 848         if (!is_suported)
 849             continue;
 850
 851         /* */
 852         msg_Dbg(va->log, "Trying to use '%s' as input", mode->name);
 853         UINT      output_count = 0;
 854         D3DFORMAT *output_list = NULL;
 855         if (FAILED(IDirectXVideoDecoderService_GetDecoderRenderTargets(va->vs, mode->guid,
 856                                                                        &output_count,
 857                                                                        &output_list))) {
 858             msg_Err(va->log, "IDirectXVideoDecoderService_GetDecoderRenderTargets failed");
 859             continue;
 860         }
 861         for (unsigned j = 0; j < output_count; j++) {
 862             const D3DFORMAT f = output_list[j];
 863             const d3d_format_t *format = D3dFindFormat(f);
 864             if (format) {
 865                 msg_Dbg(va->log, "%s is supported for output", format->name);
 866             } else {
 867                 msg_Dbg(va->log, "%d is supported for output (%4.4s)", f, (const char*)&f);
 868             }
 869         }
 870
 871         /* */
 872         for (unsigned j = 0; d3d_formats[j].name; j++) {
 873             const d3d_format_t *format = &d3d_formats[j];
 874
 875             /* */
 876             bool is_suported = false;
 877             for (unsigned k = 0; !is_suported && k < output_count; k++) {
 878                 is_suported = format->format == output_list[k];
 879             }
 880             if (!is_suported)
 881                 continue;
 882
 883             /* We have our solution */
 884             msg_Dbg(va->log, "Using '%s' to decode to '%s'", mode->name, format->name);
 885             *input  = *mode->guid;
 886             *output = format->format;
 887             CoTaskMemFree(output_list);
 888             CoTaskMemFree(input_list);
 889             return VLC_SUCCESS;
 890         }
 891         CoTaskMemFree(output_list);
 892     }
 893     CoTaskMemFree(input_list);
 894     return VLC_EGENERIC;
 895 }
 896
 897 /**
 898  * It creates a DXVA2 decoder using the given video format
 899  */
 900 static int DxCreateVideoDecoder(vlc_va_dxva2_t *va,
 901                                 int codec_id, const video_format_t *fmt)
 902 {
 903     /* */
 904     msg_Dbg(va->log, "DxCreateVideoDecoder id %d %dx%d",
 905             codec_id, fmt->i_width, fmt->i_height);
 906
 907     va->width  = fmt->i_width;
 908     va->height = fmt->i_height;
 909
 910     /* Allocates all surfaces needed for the decoder */
 911     va->surface_width  = (fmt->i_width  + 15) & ~15;
 912     va->surface_height = (fmt->i_height + 15) & ~15;
 913     switch (codec_id) {
 914     case CODEC_ID_H264:
 915         va->surface_count = 16 + 1;
 916         break;
 917     default:
 918         va->surface_count = 2 + 1;
 919         break;
 920     }
 921     LPDIRECT3DSURFACE9 surface_list[VA_DXVA2_MAX_SURFACE_COUNT];
 922     if (FAILED(IDirectXVideoDecoderService_CreateSurface(va->vs,
 923                                                          va->surface_width,
 924                                                          va->surface_height,
 925                                                          va->surface_count - 1,
 926                                                          va->render,
 927                                                          D3DPOOL_DEFAULT,
 928                                                          0,
 929                                                          DXVA2_VideoDecoderRenderTarget,
 930                                                          surface_list,
 931                                                          NULL))) {
 932         msg_Err(va->log, "IDirectXVideoAccelerationService_CreateSurface failed");
 933         va->surface_count = 0;
 934         return VLC_EGENERIC;
 935     }
 936     for (unsigned i = 0; i < va->surface_count; i++) {
 937         vlc_va_surface_t *surface = &va->surface[i];
 938         surface->d3d = surface_list[i];
 939         surface->refcount = 0;
 940         surface->order = 0;
 941     }
 942     msg_Dbg(va->log, "IDirectXVideoAccelerationService_CreateSurface succeed with %d surfaces (%dx%d)",
 943             va->surface_count, fmt->i_width, fmt->i_height);
 944
 945     /* */
 946     DXVA2_VideoDesc dsc;
 947     ZeroMemory(&dsc, sizeof(dsc));
 948     dsc.SampleWidth     = fmt->i_width;
 949     dsc.SampleHeight    = fmt->i_height;
 950     dsc.Format          = va->render;
 951     if (fmt->i_frame_rate > 0 && fmt->i_frame_rate_base > 0) {
 952         dsc.InputSampleFreq.Numerator   = fmt->i_frame_rate;
 953         dsc.InputSampleFreq.Denominator = fmt->i_frame_rate_base;
 954     } else {
 955         dsc.InputSampleFreq.Numerator   = 0;
 956         dsc.InputSampleFreq.Denominator = 0;
 957     }
 958     dsc.OutputFrameFreq = dsc.InputSampleFreq;
 959     dsc.UABProtectionLevel = FALSE;
 960     dsc.Reserved = 0;
 961
 962     /* FIXME I am unsure we can let unknown everywhere */
 963     DXVA2_ExtendedFormat *ext = &dsc.SampleFormat;
 964     ext->SampleFormat = 0;//DXVA2_SampleUnknown;
 965     ext->VideoChromaSubsampling = 0;//DXVA2_VideoChromaSubsampling_Unknown;
 966     ext->NominalRange = 0;//DXVA2_NominalRange_Unknown;
 967     ext->VideoTransferMatrix = 0;//DXVA2_VideoTransferMatrix_Unknown;
 968     ext->VideoLighting = 0;//DXVA2_VideoLighting_Unknown;
 969     ext->VideoPrimaries = 0;//DXVA2_VideoPrimaries_Unknown;
 970     ext->VideoTransferFunction = 0;//DXVA2_VideoTransFunc_Unknown;
 971
 972     /* List all configurations available for the decoder */
 973     UINT                      cfg_count = 0;
 974     DXVA2_ConfigPictureDecode *cfg_list = NULL;
 975     if (FAILED(IDirectXVideoDecoderService_GetDecoderConfigurations(va->vs,
 976                                                                     &va->input,
 977                                                                     &dsc,
 978                                                                     NULL,
 979                                                                     &cfg_count,
 980                                                                     &cfg_list))) {
 981         msg_Err(va->log, "IDirectXVideoDecoderService_GetDecoderConfigurations failed");
 982         return VLC_EGENERIC;
 983     }
 984     msg_Dbg(va->log, "we got %d decoder configurations", cfg_count);
 985
 986     /* Select the best decoder configuration */
 987     int cfg_score = 0;
 988     for (unsigned i = 0; i < cfg_count; i++) {
 989         const DXVA2_ConfigPictureDecode *cfg = &cfg_list[i];
 990
 991         /* */
 992         msg_Dbg(va->log, "configuration[%d] ConfigBitstreamRaw %d",
 993                 i, cfg->ConfigBitstreamRaw);
 994
 995         /* */
 996         int score;
 997         if (cfg->ConfigBitstreamRaw == 1)
 998             score = 1;
 999         else if (codec_id == CODEC_ID_H264 && cfg->ConfigBitstreamRaw == 2)
1000             score = 2;
1001         else
1002             continue;
1003         if (IsEqualGUID(&cfg->guidConfigBitstreamEncryption, &DXVA_NoEncrypt))
1004             score += 16;
1005
1006         if (cfg_score < score) {
1007             va->cfg = *cfg;
1008             cfg_score = score;
1009         }
1010     }
1011     CoTaskMemFree(cfg_list);
1012     if (cfg_score <= 0) {
1013         msg_Err(va->log, "Failed to find a supported decoder configuration");
1014         return VLC_EGENERIC;
1015     }
1016
1017     /* Create the decoder */
1018     IDirectXVideoDecoder *decoder;
1019     if (FAILED(IDirectXVideoDecoderService_CreateVideoDecoder(va->vs,
1020                                                               &va->input,
1021                                                               &dsc,
1022                                                               &va->cfg,
1023                                                               surface_list,
1024                                                               va->surface_count,
1025                                                               &decoder))) {
1026         msg_Err(va->log, "IDirectXVideoDecoderService_CreateVideoDecoder failed");
1027         return VLC_EGENERIC;
1028     }
1029     va->decoder = decoder;
1030     msg_Dbg(va->log, "IDirectXVideoDecoderService_CreateVideoDecoder succeed");
1031     return VLC_SUCCESS;
1032 }
1033 static void DxDestroyVideoDecoder(vlc_va_dxva2_t *va)
1034 {
1035     if (va->decoder)
1036         IDirectXVideoDecoder_Release(va->decoder);
1037     va->decoder = NULL;
1038
1039     for (unsigned i = 0; i < va->surface_count; i++)
1040         IDirect3DSurface9_Release(va->surface[i].d3d);
1041     va->surface_count = 0;
1042 }
1043 static int DxResetVideoDecoder(vlc_va_dxva2_t *va)
1044 {
1045     msg_Err(va->log, "DxResetVideoDecoder unimplemented");
1046     return VLC_EGENERIC;
1047 }
1048
1049 static void DxCreateVideoConversion(vlc_va_dxva2_t *va)
1050 {
1051     switch (va->render) {
1052     case MAKEFOURCC('N','V','1','2'):
1053         va->output = MAKEFOURCC('Y','V','1','2');
1054         break;
1055     default:
1056         va->output = va->render;
1057         break;
1058     }
1059     CopyInitCache(&va->surface_cache, va->surface_width);
1060 }
1061 static void DxDestroyVideoConversion(vlc_va_dxva2_t *va)
1062 {
1063     CopyCleanCache(&va->surface_cache);
1064 }
1065 #else
1066 vlc_va_t *vlc_va_NewDxva2(vlc_object_t *log, int codec_id)
1067 {
1068     (void)log;
1069     (void)codec_id;
1070     return NULL;
1071 }
1072 #endif