Updated dxsdk.

3rdparty/dxsdk/include/d3d12_1.h

@@ -0,0 +1,2539 @@
+/*-------------------------------------------------------------------------------------
+ *
+ * Copyright (c) Microsoft Corporation
+ *
+ *-------------------------------------------------------------------------------------*/
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 8.01.0622 */
+
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif /* __RPCNDR_H_VERSION__ */
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#ifndef __d3d12_1_h__
+#define __d3d12_1_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+/* Forward Declarations */ 
+
+#ifndef __ID3D12CryptoSession_FWD_DEFINED__
+#define __ID3D12CryptoSession_FWD_DEFINED__
+typedef interface ID3D12CryptoSession ID3D12CryptoSession;
+
+#endif 	/* __ID3D12CryptoSession_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12CryptoSessionPolicy_FWD_DEFINED__
+#define __ID3D12CryptoSessionPolicy_FWD_DEFINED__
+typedef interface ID3D12CryptoSessionPolicy ID3D12CryptoSessionPolicy;
+
+#endif 	/* __ID3D12CryptoSessionPolicy_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12ContentProtectionDevice_FWD_DEFINED__
+#define __ID3D12ContentProtectionDevice_FWD_DEFINED__
+typedef interface ID3D12ContentProtectionDevice ID3D12ContentProtectionDevice;
+
+#endif 	/* __ID3D12ContentProtectionDevice_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecodeCommandList2_FWD_DEFINED__
+#define __ID3D12VideoDecodeCommandList2_FWD_DEFINED__
+typedef interface ID3D12VideoDecodeCommandList2 ID3D12VideoDecodeCommandList2;
+
+#endif 	/* __ID3D12VideoDecodeCommandList2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessCommandList2_FWD_DEFINED__
+#define __ID3D12VideoProcessCommandList2_FWD_DEFINED__
+typedef interface ID3D12VideoProcessCommandList2 ID3D12VideoProcessCommandList2;
+
+#endif 	/* __ID3D12VideoProcessCommandList2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12StateObjectPrototype_FWD_DEFINED__
+#define __ID3D12StateObjectPrototype_FWD_DEFINED__
+typedef interface ID3D12StateObjectPrototype ID3D12StateObjectPrototype;
+
+#endif 	/* __ID3D12StateObjectPrototype_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12StateObjectPropertiesPrototype_FWD_DEFINED__
+#define __ID3D12StateObjectPropertiesPrototype_FWD_DEFINED__
+typedef interface ID3D12StateObjectPropertiesPrototype ID3D12StateObjectPropertiesPrototype;
+
+#endif 	/* __ID3D12StateObjectPropertiesPrototype_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DeviceRaytracingPrototype_FWD_DEFINED__
+#define __ID3D12DeviceRaytracingPrototype_FWD_DEFINED__
+typedef interface ID3D12DeviceRaytracingPrototype ID3D12DeviceRaytracingPrototype;
+
+#endif 	/* __ID3D12DeviceRaytracingPrototype_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12CommandListRaytracingPrototype_FWD_DEFINED__
+#define __ID3D12CommandListRaytracingPrototype_FWD_DEFINED__
+typedef interface ID3D12CommandListRaytracingPrototype ID3D12CommandListRaytracingPrototype;
+
+#endif 	/* __ID3D12CommandListRaytracingPrototype_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DeviceMetaCommand_FWD_DEFINED__
+#define __ID3D12DeviceMetaCommand_FWD_DEFINED__
+typedef interface ID3D12DeviceMetaCommand ID3D12DeviceMetaCommand;
+
+#endif 	/* __ID3D12DeviceMetaCommand_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12MetaCommand_FWD_DEFINED__
+#define __ID3D12MetaCommand_FWD_DEFINED__
+typedef interface ID3D12MetaCommand ID3D12MetaCommand;
+
+#endif 	/* __ID3D12MetaCommand_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12CommandListMetaCommand_FWD_DEFINED__
+#define __ID3D12CommandListMetaCommand_FWD_DEFINED__
+typedef interface ID3D12CommandListMetaCommand ID3D12CommandListMetaCommand;
+
+#endif 	/* __ID3D12CommandListMetaCommand_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "oaidl.h"
+#include "ocidl.h"
+#include "dxgicommon.h"
+#include "d3dcommon.h"
+#include "d3d12.h"
+#include "d3d12video.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_d3d12_1_0000_0000 */
+/* [local] */ 
+
+#include <winapifamily.h>
+#pragma region App Family
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+#define D3D12_FEATURE_VIDEO_DECODE_BITSTREAM_ENCRYPTION_SCHEMES       static_cast<D3D12_FEATURE_VIDEO>(4)
+#define D3D12_FEATURE_VIDEO_DECODE_BITSTREAM_ENCRYPTION_SCHEME_COUNT  static_cast<D3D12_FEATURE_VIDEO>(12)
+#define D3D12_FEATURE_VIDEO_CRYPTO_SESSION_SUPPORT                    static_cast<D3D12_FEATURE_VIDEO>(13)
+#define D3D12_FEATURE_VIDEO_CONTENT_PROTECTION_SYSTEM_COUNT           static_cast<D3D12_FEATURE_VIDEO>(14)
+#define D3D12_FEATURE_VIDEO_CONTENT_PROTECTION_SYSTEM_SUPPORT         static_cast<D3D12_FEATURE_VIDEO>(15)
+#define D3D12_FEATURE_VIDEO_CRYPTO_SESSION_TRANSFORM_SUPPORT          static_cast<D3D12_FEATURE_VIDEO>(16)
+#define D3D12_BITSTREAM_ENCRYPTION_TYPE_CENC_AES_CTR_128              static_cast<D3D12_BITSTREAM_ENCRYPTION_TYPE>(1)
+typedef struct D3D12_FEATURE_DATA_VIDEO_CONTENT_PROTECTION_SYSTEM_COUNT
+    {
+    UINT NodeIndex;
+    UINT ContentProtectionSystemCount;
+    } 	D3D12_FEATURE_DATA_VIDEO_CONTENT_PROTECTION_SYSTEM_COUNT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_CONTENT_PROTECTION_SYSTEM_SUPPORT
+    {
+    UINT NodeIndex;
+    UINT ContentProtectionSystemCount;
+    GUID *pContentProtectionSystems;
+    } 	D3D12_FEATURE_DATA_VIDEO_CONTENT_PROTECTION_SYSTEM_SUPPORT;
+
+typedef 
+enum D3D12_CRYPTO_SESSION_SUPPORT_FLAGS
+    {
+        D3D12_CRYPTO_SESSION_SUPPORT_FLAG_NONE	= 0,
+        D3D12_CRYPTO_SESSION_SUPPORT_FLAG_SUPPORTED	= 0x1,
+        D3D12_CRYPTO_SESSION_SUPPORT_FLAG_HEADER_DECRYPTION_REQUIRED	= 0x2,
+        D3D12_CRYPTO_SESSION_SUPPORT_FLAG_INDEPENDENT_DECRYPTION_REQUIRED	= 0x4,
+        D3D12_CRYPTO_SESSION_SUPPORT_FLAG_TRANSCRYPTION_REQUIRED	= 0x8
+    } 	D3D12_CRYPTO_SESSION_SUPPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_CRYPTO_SESSION_SUPPORT_FLAGS );
+typedef 
+enum D3D12_CRYPTO_SESSION_FLAGS
+    {
+        D3D12_CRYPTO_SESSION_FLAG_NONE	= 0,
+        D3D12_CRYPTO_SESSION_FLAG_HARDWARE	= 0x1
+    } 	D3D12_CRYPTO_SESSION_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_CRYPTO_SESSION_FLAGS );
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_BITSTREAM_ENCRYPTION_SCHEME_COUNT
+    {
+    UINT NodeIndex;
+    GUID DecodeProfile;
+    UINT EncryptionSchemeCount;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODE_BITSTREAM_ENCRYPTION_SCHEME_COUNT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_BITSTREAM_ENCRYPTION_SCHEMES
+    {
+    UINT NodeIndex;
+    GUID DecodeProfile;
+    UINT EncryptionSchemeCount;
+    _Field_size_full_(EncryptionSchemeCount)  D3D12_BITSTREAM_ENCRYPTION_TYPE *pEncryptionSchemes;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODE_BITSTREAM_ENCRYPTION_SCHEMES;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_CRYPTO_SESSION_SUPPORT
+    {
+    UINT NodeIndex;
+    GUID DecodeProfile;
+    GUID ContentProtectionSystem;
+    D3D12_CRYPTO_SESSION_FLAGS Flags;
+    D3D12_BITSTREAM_ENCRYPTION_TYPE BitstreamEncryption;
+    UINT KeyBaseDataSize;
+    D3D12_CRYPTO_SESSION_SUPPORT_FLAGS Support;
+    } 	D3D12_FEATURE_DATA_VIDEO_CRYPTO_SESSION_SUPPORT;
+
+typedef struct D3D12_CRYPTO_SESSION_DESC
+    {
+    UINT NodeMask;
+    GUID DecodeProfile;
+    GUID ContentProtectionSystem;
+    D3D12_BITSTREAM_ENCRYPTION_TYPE BitstreamEncryption;
+    D3D12_CRYPTO_SESSION_FLAGS Flags;
+    } 	D3D12_CRYPTO_SESSION_DESC;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_1_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_1_0000_0000_v0_0_s_ifspec;
+
+#ifndef __ID3D12CryptoSession_INTERFACE_DEFINED__
+#define __ID3D12CryptoSession_INTERFACE_DEFINED__
+
+/* interface ID3D12CryptoSession */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12CryptoSession;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("FC7C6C9D-C27D-4904-835D-A5F2096EC65F")
+    ID3D12CryptoSession : public ID3D12ProtectedSession
+    {
+    public:
+        virtual D3D12_CRYPTO_SESSION_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetKeyBaseData( 
+            UINT KeyInputDataSize,
+            _In_reads_bytes_( KeyInputDataSize )  const void *pKeyInputData,
+            UINT KeyBaseDataSize,
+            _Out_writes_bytes_( KeyBaseDataSize )  void *pKeyBaseData) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12CryptoSessionVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12CryptoSession * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12CryptoSession * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12CryptoSession * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12CryptoSession * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12CryptoSession * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12CryptoSession * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12CryptoSession * This,
+            _In_z_  LPCWSTR Name);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12CryptoSession * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetStatusFence )( 
+            ID3D12CryptoSession * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppFence);
+        
+        D3D12_PROTECTED_SESSION_STATUS ( STDMETHODCALLTYPE *GetSessionStatus )( 
+            ID3D12CryptoSession * This);
+        
+        D3D12_CRYPTO_SESSION_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12CryptoSession * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetKeyBaseData )( 
+            ID3D12CryptoSession * This,
+            UINT KeyInputDataSize,
+            _In_reads_bytes_( KeyInputDataSize )  const void *pKeyInputData,
+            UINT KeyBaseDataSize,
+            _Out_writes_bytes_( KeyBaseDataSize )  void *pKeyBaseData);
+        
+        END_INTERFACE
+    } ID3D12CryptoSessionVtbl;
+
+    interface ID3D12CryptoSession
+    {
+        CONST_VTBL struct ID3D12CryptoSessionVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12CryptoSession_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12CryptoSession_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12CryptoSession_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12CryptoSession_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12CryptoSession_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12CryptoSession_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12CryptoSession_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12CryptoSession_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12CryptoSession_GetStatusFence(This,riid,ppFence)	\
+    ( (This)->lpVtbl -> GetStatusFence(This,riid,ppFence) ) 
+
+#define ID3D12CryptoSession_GetSessionStatus(This)	\
+    ( (This)->lpVtbl -> GetSessionStatus(This) ) 
+
+
+#define ID3D12CryptoSession_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+
+#define ID3D12CryptoSession_GetKeyBaseData(This,KeyInputDataSize,pKeyInputData,KeyBaseDataSize,pKeyBaseData)	\
+    ( (This)->lpVtbl -> GetKeyBaseData(This,KeyInputDataSize,pKeyInputData,KeyBaseDataSize,pKeyBaseData) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12CryptoSession_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12CryptoSessionPolicy_INTERFACE_DEFINED__
+#define __ID3D12CryptoSessionPolicy_INTERFACE_DEFINED__
+
+/* interface ID3D12CryptoSessionPolicy */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12CryptoSessionPolicy;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("69FE3108-01A4-4AC3-AB91-F51E377A62AC")
+    ID3D12CryptoSessionPolicy : public ID3D12DeviceChild
+    {
+    public:
+        virtual UINT STDMETHODCALLTYPE GetKeyInfoSize( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetKeyInfo( 
+            _Out_writes_bytes_( KeyInfoDataSize )  void *pKeyInfo,
+            UINT KeyInfoDataSize) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetCryptoSession( 
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppCryptoSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12CryptoSessionPolicyVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12CryptoSessionPolicy * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12CryptoSessionPolicy * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12CryptoSessionPolicy * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12CryptoSessionPolicy * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12CryptoSessionPolicy * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12CryptoSessionPolicy * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12CryptoSessionPolicy * This,
+            _In_z_  LPCWSTR Name);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12CryptoSessionPolicy * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        UINT ( STDMETHODCALLTYPE *GetKeyInfoSize )( 
+            ID3D12CryptoSessionPolicy * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetKeyInfo )( 
+            ID3D12CryptoSessionPolicy * This,
+            _Out_writes_bytes_( KeyInfoDataSize )  void *pKeyInfo,
+            UINT KeyInfoDataSize);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetCryptoSession )( 
+            ID3D12CryptoSessionPolicy * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppCryptoSession);
+        
+        END_INTERFACE
+    } ID3D12CryptoSessionPolicyVtbl;
+
+    interface ID3D12CryptoSessionPolicy
+    {
+        CONST_VTBL struct ID3D12CryptoSessionPolicyVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12CryptoSessionPolicy_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12CryptoSessionPolicy_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12CryptoSessionPolicy_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12CryptoSessionPolicy_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12CryptoSessionPolicy_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12CryptoSessionPolicy_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12CryptoSessionPolicy_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12CryptoSessionPolicy_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12CryptoSessionPolicy_GetKeyInfoSize(This)	\
+    ( (This)->lpVtbl -> GetKeyInfoSize(This) ) 
+
+#define ID3D12CryptoSessionPolicy_GetKeyInfo(This,pKeyInfo,KeyInfoDataSize)	\
+    ( (This)->lpVtbl -> GetKeyInfo(This,pKeyInfo,KeyInfoDataSize) ) 
+
+#define ID3D12CryptoSessionPolicy_GetCryptoSession(This,riid,ppCryptoSession)	\
+    ( (This)->lpVtbl -> GetCryptoSession(This,riid,ppCryptoSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12CryptoSessionPolicy_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_1_0000_0002 */
+/* [local] */ 
+
+typedef 
+enum D3D12_CRYPTO_SESSION_TRANSFORM_OPERATION
+    {
+        D3D12_CRYPTO_SESSION_TRANSFORM_OPERATION_NONE	= 0,
+        D3D12_CRYPTO_SESSION_TRANSFORM_OPERATION_DECRYPT	= 1,
+        D3D12_CRYPTO_SESSION_TRANSFORM_OPERATION_DECRYPT_WITH_HEADER	= 2,
+        D3D12_CRYPTO_SESSION_TRANSFORM_OPERATION_TRANSCRYPT	= 3,
+        D3D12_CRYPTO_SESSION_TRANSFORM_OPERATION_TRANSCRYPT_WITH_HEADER	= 4,
+        D3D12_CRYPTO_SESSION_TRANSFORM_OPERATION_DECRYPT_HEADER	= 5
+    } 	D3D12_CRYPTO_SESSION_TRANSFORM_OPERATION;
+
+typedef 
+enum D3D12_CRYPTO_SESSION_TRANSFORM_SUPPORT_FLAGS
+    {
+        D3D12_CRYPTO_SESSION_TRANSFORM_SUPPORT_FLAG_NONE	= 0,
+        D3D12_CRYPTO_SESSION_TRANSFORM_SUPPORT_FLAG_SUPPORTED	= 0x1
+    } 	D3D12_CRYPTO_SESSION_TRANSFORM_SUPPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_CRYPTO_SESSION_TRANSFORM_SUPPORT_FLAGS );
+typedef struct D3D12_FEATURE_DATA_VIDEO_CRYPTO_SESSION_TRANSFORM_SUPPORT
+    {
+    UINT NodeIndex;
+    GUID DecodeProfile;
+    GUID ContentProtectionSystem;
+    D3D12_CRYPTO_SESSION_FLAGS Flags;
+    D3D12_BITSTREAM_ENCRYPTION_TYPE BitstreamEncryption;
+    D3D12_CRYPTO_SESSION_TRANSFORM_OPERATION Operation;
+    BOOL ProtectedOutputRequired;
+    UINT64 InputAlignment;
+    UINT64 InputPreambleSize;
+    UINT64 OutputAlignment;
+    UINT64 OutputPreambleSize;
+    D3D12_CRYPTO_SESSION_TRANSFORM_SUPPORT_FLAGS Support;
+    } 	D3D12_FEATURE_DATA_VIDEO_CRYPTO_SESSION_TRANSFORM_SUPPORT;
+
+typedef struct D3D12_CRYPTO_SESSION_TRANSFORM_DECRYPT_HEADER_INPUT_ARGUMENTS
+    {
+    BOOL Enable;
+    _Field_size_bytes_full_(SliceHeadersSize)  const void *pSliceHeaders;
+    UINT64 SliceHeadersSize;
+    _Field_size_full_(SliceHeaderCount)  const DWORD *pSliceHeadersOffsets;
+    UINT64 SliceHeaderCount;
+    _Field_size_bytes_full_(ContextSize)  const void *pContext;
+    UINT64 ContextSize;
+    } 	D3D12_CRYPTO_SESSION_TRANSFORM_DECRYPT_HEADER_INPUT_ARGUMENTS;
+
+typedef struct D3D12_CRYPTO_SESSION_TRANSFORM_INPUT_ARGUMENTS
+    {
+    ID3D12CryptoSessionPolicy *pCryptoSessionPolicy;
+    ID3D12Resource *pBuffer;
+    UINT64 Size;
+    UINT64 Offset;
+    _Field_size_bytes_full_(IVSize)  const void *pIV;
+    UINT IVSize;
+    UINT SubSampleMappingCount;
+    _Field_size_bytes_full_(SubSampleMappingCount)  const void *pSubSampleMappingBlock;
+    UINT64 ContextSize;
+    _Field_size_bytes_full_(ContextSize)  const void *pContext;
+    D3D12_CRYPTO_SESSION_TRANSFORM_DECRYPT_HEADER_INPUT_ARGUMENTS EncryptedHeader;
+    } 	D3D12_CRYPTO_SESSION_TRANSFORM_INPUT_ARGUMENTS;
+
+typedef struct D3D12_CRYPTO_SESSION_TRANSFORM_DECRYPT_OUTPUT_ARGUMENTS
+    {
+    BOOL Enable;
+    ID3D12ProtectedSession *pProtectedSession;
+    ID3D12Resource *pBuffer;
+    UINT64 Size;
+    UINT64 Offset;
+    } 	D3D12_CRYPTO_SESSION_TRANSFORM_DECRYPT_OUTPUT_ARGUMENTS;
+
+typedef struct D3D12_CRYPTO_SESSION_TRANSFORM_TRANSCRYPT_OUTPUT_ARGUMENTS
+    {
+    BOOL Enable;
+    _Field_size_bytes_full_(IVSize)  void *pIV;
+    UINT IVSize;
+    } 	D3D12_CRYPTO_SESSION_TRANSFORM_TRANSCRYPT_OUTPUT_ARGUMENTS;
+
+typedef struct D3D12_CRYPTO_SESSION_TRANSFORM_DECRYPT_HEADER_OUTPUT_ARGUMENTS
+    {
+    BOOL Enable;
+    UINT64 SliceHeadersSize;
+    _Field_size_bytes_full_(SliceHeadersSize)  const void *pSliceHeaders;
+    UINT64 ContextSize;
+    _Field_size_bytes_full_(ContextSize)  const void *pContext;
+    } 	D3D12_CRYPTO_SESSION_TRANSFORM_DECRYPT_HEADER_OUTPUT_ARGUMENTS;
+
+typedef struct D3D12_CRYPTO_SESSION_TRANSFORM_OUTPUT_ARGUMENTS
+    {
+    D3D12_CRYPTO_SESSION_TRANSFORM_DECRYPT_OUTPUT_ARGUMENTS Decrypt;
+    D3D12_CRYPTO_SESSION_TRANSFORM_TRANSCRYPT_OUTPUT_ARGUMENTS Transcrypt;
+    D3D12_CRYPTO_SESSION_TRANSFORM_DECRYPT_HEADER_OUTPUT_ARGUMENTS ClearHeader;
+    } 	D3D12_CRYPTO_SESSION_TRANSFORM_OUTPUT_ARGUMENTS;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_1_0000_0002_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_1_0000_0002_v0_0_s_ifspec;
+
+#ifndef __ID3D12ContentProtectionDevice_INTERFACE_DEFINED__
+#define __ID3D12ContentProtectionDevice_INTERFACE_DEFINED__
+
+/* interface ID3D12ContentProtectionDevice */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12ContentProtectionDevice;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("59975f53-bf5f-42f2-b84f-5e347c1e3d43")
+    ID3D12ContentProtectionDevice : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateCryptoSession( 
+            _In_  const D3D12_CRYPTO_SESSION_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppSession) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateCryptoSessionPolicy( 
+            _In_reads_bytes_( KeyInfoSize )  const void *pKeyInfo,
+            UINT KeyInfoSize,
+            _In_  ID3D12CryptoSession *pCryptoSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppCryptoSessionPolicy) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE TransformEncryptedData( 
+            D3D12_CRYPTO_SESSION_TRANSFORM_OPERATION Operation,
+            _In_  const D3D12_CRYPTO_SESSION_TRANSFORM_OUTPUT_ARGUMENTS *pOutputArguments,
+            _In_  const D3D12_CRYPTO_SESSION_TRANSFORM_INPUT_ARGUMENTS *pInputArguments) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12ContentProtectionDeviceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12ContentProtectionDevice * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12ContentProtectionDevice * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12ContentProtectionDevice * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *CreateCryptoSession )( 
+            ID3D12ContentProtectionDevice * This,
+            _In_  const D3D12_CRYPTO_SESSION_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppSession);
+        
+        HRESULT ( STDMETHODCALLTYPE *CreateCryptoSessionPolicy )( 
+            ID3D12ContentProtectionDevice * This,
+            _In_reads_bytes_( KeyInfoSize )  const void *pKeyInfo,
+            UINT KeyInfoSize,
+            _In_  ID3D12CryptoSession *pCryptoSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppCryptoSessionPolicy);
+        
+        HRESULT ( STDMETHODCALLTYPE *TransformEncryptedData )( 
+            ID3D12ContentProtectionDevice * This,
+            D3D12_CRYPTO_SESSION_TRANSFORM_OPERATION Operation,
+            _In_  const D3D12_CRYPTO_SESSION_TRANSFORM_OUTPUT_ARGUMENTS *pOutputArguments,
+            _In_  const D3D12_CRYPTO_SESSION_TRANSFORM_INPUT_ARGUMENTS *pInputArguments);
+        
+        END_INTERFACE
+    } ID3D12ContentProtectionDeviceVtbl;
+
+    interface ID3D12ContentProtectionDevice
+    {
+        CONST_VTBL struct ID3D12ContentProtectionDeviceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12ContentProtectionDevice_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12ContentProtectionDevice_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12ContentProtectionDevice_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12ContentProtectionDevice_CreateCryptoSession(This,pDesc,riid,ppSession)	\
+    ( (This)->lpVtbl -> CreateCryptoSession(This,pDesc,riid,ppSession) ) 
+
+#define ID3D12ContentProtectionDevice_CreateCryptoSessionPolicy(This,pKeyInfo,KeyInfoSize,pCryptoSession,riid,ppCryptoSessionPolicy)	\
+    ( (This)->lpVtbl -> CreateCryptoSessionPolicy(This,pKeyInfo,KeyInfoSize,pCryptoSession,riid,ppCryptoSessionPolicy) ) 
+
+#define ID3D12ContentProtectionDevice_TransformEncryptedData(This,Operation,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> TransformEncryptedData(This,Operation,pOutputArguments,pInputArguments) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12ContentProtectionDevice_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_1_0000_0003 */
+/* [local] */ 
+
+typedef struct D3D12_VIDEO_DECODE_DECRYPTION_ARGUMENTS
+    {
+    ID3D12CryptoSessionPolicy *pCryptoSessionPolicy;
+    _Field_size_bytes_full_(IVSize)  const void *pIV;
+    UINT IVSize;
+    _Field_size_bytes_full_(SubSampleMappingCount)  const void *pSubSampleMappingBlock;
+    UINT SubSampleMappingCount;
+    UINT cBlocksStripeEncrypted;
+    UINT cBlocksStripeClear;
+    } 	D3D12_VIDEO_DECODE_DECRYPTION_ARGUMENTS;
+
+typedef struct D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS1
+    {
+    UINT NumFrameArguments;
+    D3D12_VIDEO_DECODE_FRAME_ARGUMENT FrameArguments[ 10 ];
+    D3D12_VIDEO_DECODE_REFERENCE_FRAMES ReferenceFrames;
+    D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM CompressedBitstream;
+    D3D12_VIDEO_DECODE_DECRYPTION_ARGUMENTS DecryptionArguments;
+    ID3D12VideoDecoderHeap *pHeap;
+    } 	D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS1;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_1_0000_0003_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_1_0000_0003_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoDecodeCommandList2_INTERFACE_DEFINED__
+#define __ID3D12VideoDecodeCommandList2_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDecodeCommandList2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDecodeCommandList2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("EAD05737-EE1D-4442-9B18-7D992E9A8960")
+    ID3D12VideoDecodeCommandList2 : public ID3D12VideoDecodeCommandList1
+    {
+    public:
+        virtual void STDMETHODCALLTYPE DecodeFrame2( 
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS1 *pInputArguments) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetProtectedResourceSession( 
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecodeCommandList2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecodeCommandList2 * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecodeCommandList2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_z_  LPCWSTR Name);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoDecodeCommandList2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoDecodeCommandList2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoDecodeCommandList2 * This);
+        
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoDecodeCommandList2 * This);
+        
+        void ( STDMETHODCALLTYPE *DecodeFrame )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        void ( STDMETHODCALLTYPE *DecodeFrame1 )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        void ( STDMETHODCALLTYPE *DecodeFrame2 )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS1 *pInputArguments);
+        
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        END_INTERFACE
+    } ID3D12VideoDecodeCommandList2Vtbl;
+
+    interface ID3D12VideoDecodeCommandList2
+    {
+        CONST_VTBL struct ID3D12VideoDecodeCommandList2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDecodeCommandList2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDecodeCommandList2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDecodeCommandList2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDecodeCommandList2_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoDecodeCommandList2_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoDecodeCommandList2_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoDecodeCommandList2_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoDecodeCommandList2_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoDecodeCommandList2_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoDecodeCommandList2_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoDecodeCommandList2_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoDecodeCommandList2_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoDecodeCommandList2_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoDecodeCommandList2_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoDecodeCommandList2_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoDecodeCommandList2_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoDecodeCommandList2_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoDecodeCommandList2_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoDecodeCommandList2_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoDecodeCommandList2_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoDecodeCommandList2_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoDecodeCommandList2_DecodeFrame(This,pDecoder,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> DecodeFrame(This,pDecoder,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoDecodeCommandList2_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+
+#define ID3D12VideoDecodeCommandList2_DecodeFrame1(This,pDecoder,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> DecodeFrame1(This,pDecoder,pOutputArguments,pInputArguments) ) 
+
+
+#define ID3D12VideoDecodeCommandList2_DecodeFrame2(This,pDecoder,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> DecodeFrame2(This,pDecoder,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoDecodeCommandList2_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDecodeCommandList2_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessCommandList2_INTERFACE_DEFINED__
+#define __ID3D12VideoProcessCommandList2_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoProcessCommandList2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoProcessCommandList2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("569AB919-94DE-4529-8292-35DE97848059")
+    ID3D12VideoProcessCommandList2 : public ID3D12VideoProcessCommandList1
+    {
+    public:
+        virtual void STDMETHODCALLTYPE SetProtectedResourceSession( 
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoProcessCommandList2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoProcessCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoProcessCommandList2 * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoProcessCommandList2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_z_  LPCWSTR Name);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoProcessCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoProcessCommandList2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoProcessCommandList2 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoProcessCommandList2 * This);
+        
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoProcessCommandList2 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoProcessCommandList2 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoProcessCommandList2 * This);
+        
+        void ( STDMETHODCALLTYPE *ProcessFrames )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12VideoProcessor *pVideoProcessor,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            UINT NumInputStreams,
+            _In_reads_(NumInputStreams)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoProcessCommandList2 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        void ( STDMETHODCALLTYPE *ProcessFrames1 )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12VideoProcessor *pVideoProcessor,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            UINT NumInputStreams,
+            _In_reads_(NumInputStreams)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1 *pInputArguments);
+        
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        END_INTERFACE
+    } ID3D12VideoProcessCommandList2Vtbl;
+
+    interface ID3D12VideoProcessCommandList2
+    {
+        CONST_VTBL struct ID3D12VideoProcessCommandList2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoProcessCommandList2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoProcessCommandList2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoProcessCommandList2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoProcessCommandList2_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoProcessCommandList2_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoProcessCommandList2_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoProcessCommandList2_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoProcessCommandList2_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoProcessCommandList2_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoProcessCommandList2_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoProcessCommandList2_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoProcessCommandList2_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoProcessCommandList2_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoProcessCommandList2_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoProcessCommandList2_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoProcessCommandList2_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoProcessCommandList2_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoProcessCommandList2_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoProcessCommandList2_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoProcessCommandList2_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoProcessCommandList2_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoProcessCommandList2_ProcessFrames(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments)	\
+    ( (This)->lpVtbl -> ProcessFrames(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments) ) 
+
+#define ID3D12VideoProcessCommandList2_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+
+#define ID3D12VideoProcessCommandList2_ProcessFrames1(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments)	\
+    ( (This)->lpVtbl -> ProcessFrames1(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments) ) 
+
+
+#define ID3D12VideoProcessCommandList2_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoProcessCommandList2_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12StateObjectPrototype_INTERFACE_DEFINED__
+#define __ID3D12StateObjectPrototype_INTERFACE_DEFINED__
+
+/* interface ID3D12StateObjectPrototype */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12StateObjectPrototype;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("47016943-fca8-4594-93ea-af258b55346d")
+    ID3D12StateObjectPrototype : public ID3D12Pageable
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetCachedBlob( 
+            _COM_Outptr_  ID3DBlob **ppBlob) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12StateObjectPrototypeVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12StateObjectPrototype * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12StateObjectPrototype * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12StateObjectPrototype * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12StateObjectPrototype * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12StateObjectPrototype * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12StateObjectPrototype * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12StateObjectPrototype * This,
+            _In_z_  LPCWSTR Name);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12StateObjectPrototype * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetCachedBlob )( 
+            ID3D12StateObjectPrototype * This,
+            _COM_Outptr_  ID3DBlob **ppBlob);
+        
+        END_INTERFACE
+    } ID3D12StateObjectPrototypeVtbl;
+
+    interface ID3D12StateObjectPrototype
+    {
+        CONST_VTBL struct ID3D12StateObjectPrototypeVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12StateObjectPrototype_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12StateObjectPrototype_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12StateObjectPrototype_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12StateObjectPrototype_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12StateObjectPrototype_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12StateObjectPrototype_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12StateObjectPrototype_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12StateObjectPrototype_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12StateObjectPrototype_GetCachedBlob(This,ppBlob)	\
+    ( (This)->lpVtbl -> GetCachedBlob(This,ppBlob) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12StateObjectPrototype_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12StateObjectPropertiesPrototype_INTERFACE_DEFINED__
+#define __ID3D12StateObjectPropertiesPrototype_INTERFACE_DEFINED__
+
+/* interface ID3D12StateObjectPropertiesPrototype */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12StateObjectPropertiesPrototype;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("de5fa827-9bf9-4f26-89ff-d7f56fde3860")
+    ID3D12StateObjectPropertiesPrototype : public IUnknown
+    {
+    public:
+        virtual void *STDMETHODCALLTYPE GetShaderIdentifier( 
+            _In_  LPCWSTR pExportName) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetShaderStackSize( 
+            _In_  LPCWSTR pExportName) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetPipelineStackSize( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetPipelineStackSize( 
+            UINT64 PipelineStackSizeInBytes) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12StateObjectPropertiesPrototypeVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12StateObjectPropertiesPrototype * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12StateObjectPropertiesPrototype * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12StateObjectPropertiesPrototype * This);
+        
+        void *( STDMETHODCALLTYPE *GetShaderIdentifier )( 
+            ID3D12StateObjectPropertiesPrototype * This,
+            _In_  LPCWSTR pExportName);
+        
+        UINT64 ( STDMETHODCALLTYPE *GetShaderStackSize )( 
+            ID3D12StateObjectPropertiesPrototype * This,
+            _In_  LPCWSTR pExportName);
+        
+        UINT64 ( STDMETHODCALLTYPE *GetPipelineStackSize )( 
+            ID3D12StateObjectPropertiesPrototype * This);
+        
+        void ( STDMETHODCALLTYPE *SetPipelineStackSize )( 
+            ID3D12StateObjectPropertiesPrototype * This,
+            UINT64 PipelineStackSizeInBytes);
+        
+        END_INTERFACE
+    } ID3D12StateObjectPropertiesPrototypeVtbl;
+
+    interface ID3D12StateObjectPropertiesPrototype
+    {
+        CONST_VTBL struct ID3D12StateObjectPropertiesPrototypeVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12StateObjectPropertiesPrototype_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12StateObjectPropertiesPrototype_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12StateObjectPropertiesPrototype_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12StateObjectPropertiesPrototype_GetShaderIdentifier(This,pExportName)	\
+    ( (This)->lpVtbl -> GetShaderIdentifier(This,pExportName) ) 
+
+#define ID3D12StateObjectPropertiesPrototype_GetShaderStackSize(This,pExportName)	\
+    ( (This)->lpVtbl -> GetShaderStackSize(This,pExportName) ) 
+
+#define ID3D12StateObjectPropertiesPrototype_GetPipelineStackSize(This)	\
+    ( (This)->lpVtbl -> GetPipelineStackSize(This) ) 
+
+#define ID3D12StateObjectPropertiesPrototype_SetPipelineStackSize(This,PipelineStackSizeInBytes)	\
+    ( (This)->lpVtbl -> SetPipelineStackSize(This,PipelineStackSizeInBytes) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12StateObjectPropertiesPrototype_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_1_0000_0007 */
+/* [local] */ 
+
+typedef 
+enum D3D12_STATE_SUBOBJECT_TYPE
+    {
+        D3D12_STATE_SUBOBJECT_TYPE_FLAGS	= 0,
+        D3D12_STATE_SUBOBJECT_TYPE_ROOT_SIGNATURE	= 1,
+        D3D12_STATE_SUBOBJECT_TYPE_LOCAL_ROOT_SIGNATURE	= 2,
+        D3D12_STATE_SUBOBJECT_TYPE_NODE_MASK	= 3,
+        D3D12_STATE_SUBOBJECT_TYPE_CACHED_STATE_OBJECT	= 4,
+        D3D12_STATE_SUBOBJECT_TYPE_DXIL_LIBRARY	= 5,
+        D3D12_STATE_SUBOBJECT_TYPE_EXISTING_COLLECTION	= 6,
+        D3D12_STATE_SUBOBJECT_TYPE_SUBOBJECT_TO_EXPORTS_ASSOCIATION	= 7,
+        D3D12_STATE_SUBOBJECT_TYPE_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION	= 8,
+        D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_SHADER_CONFIG	= 9,
+        D3D12_STATE_SUBOBJECT_TYPE_RAYTRACING_PIPELINE_CONFIG	= 10,
+        D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP	= 11,
+        D3D12_STATE_SUBOBJECT_TYPE_MAX_VALID	= ( D3D12_STATE_SUBOBJECT_TYPE_HIT_GROUP + 1 ) 
+    } 	D3D12_STATE_SUBOBJECT_TYPE;
+
+typedef struct D3D12_STATE_SUBOBJECT
+    {
+    D3D12_STATE_SUBOBJECT_TYPE Type;
+    const void *pDesc;
+    } 	D3D12_STATE_SUBOBJECT;
+
+typedef 
+enum D3D12_STATE_OBJECT_FLAGS
+    {
+        D3D12_STATE_OBJECT_FLAG_NONE	= 0
+    } 	D3D12_STATE_OBJECT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_STATE_OBJECT_FLAGS );
+typedef 
+enum D3D12_EXPORT_FLAGS
+    {
+        D3D12_EXPORT_FLAG_NONE	= 0
+    } 	D3D12_EXPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_EXPORT_FLAGS );
+typedef struct D3D12_EXPORT_DESC
+    {
+    LPCWSTR Name;
+    _In_opt_  LPCWSTR ExportToRename;
+    D3D12_EXPORT_FLAGS Flags;
+    } 	D3D12_EXPORT_DESC;
+
+typedef struct D3D12_DXIL_LIBRARY_DESC
+    {
+    D3D12_SHADER_BYTECODE DXILLibrary;
+    UINT NumExports;
+    _In_reads_(NumExports)  D3D12_EXPORT_DESC *pExports;
+    } 	D3D12_DXIL_LIBRARY_DESC;
+
+typedef struct D3D12_EXISTING_COLLECTION_DESC
+    {
+    ID3D12StateObjectPrototype *pExistingCollection;
+    UINT NumExports;
+    _In_reads_(NumExports)  D3D12_EXPORT_DESC *pExports;
+    } 	D3D12_EXISTING_COLLECTION_DESC;
+
+typedef struct D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION
+    {
+    const D3D12_STATE_SUBOBJECT *pSubobjectToAssociate;
+    UINT NumExports;
+    _In_reads_(NumExports)  LPCWSTR *pExports;
+    } 	D3D12_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
+
+typedef struct D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION
+    {
+    LPCWSTR SubobjectToAssociate;
+    UINT NumExports;
+    _In_reads_(NumExports)  LPCWSTR *pExports;
+    } 	D3D12_DXIL_SUBOBJECT_TO_EXPORTS_ASSOCIATION;
+
+typedef struct D3D12_HIT_GROUP_DESC
+    {
+    LPCWSTR HitGroupExport;
+    _In_opt_  LPCWSTR AnyHitShaderImport;
+    _In_opt_  LPCWSTR ClosestHitShaderImport;
+    _In_opt_  LPCWSTR IntersectionShaderImport;
+    } 	D3D12_HIT_GROUP_DESC;
+
+typedef struct D3D12_RAYTRACING_SHADER_CONFIG
+    {
+    UINT MaxPayloadSizeInBytes;
+    UINT MaxAttributeSizeInBytes;
+    } 	D3D12_RAYTRACING_SHADER_CONFIG;
+
+typedef struct D3D12_RAYTRACING_PIPELINE_CONFIG
+    {
+    UINT MaxTraceRecursionDepth;
+    } 	D3D12_RAYTRACING_PIPELINE_CONFIG;
+
+typedef 
+enum D3D12_STATE_OBJECT_TYPE
+    {
+        D3D12_STATE_OBJECT_TYPE_COLLECTION	= 0,
+        D3D12_STATE_OBJECT_TYPE_RAYTRACING_PIPELINE	= 3
+    } 	D3D12_STATE_OBJECT_TYPE;
+
+typedef struct D3D12_STATE_OBJECT_DESC
+    {
+    D3D12_STATE_OBJECT_TYPE Type;
+    UINT NumSubobjects;
+    _In_reads_(NumSubobjects)  const D3D12_STATE_SUBOBJECT *pSubobjects;
+    } 	D3D12_STATE_OBJECT_DESC;
+
+typedef 
+enum D3D12_RAYTRACING_GEOMETRY_FLAGS
+    {
+        D3D12_RAYTRACING_GEOMETRY_FLAG_NONE	= 0,
+        D3D12_RAYTRACING_GEOMETRY_FLAG_OPAQUE	= 0x1,
+        D3D12_RAYTRACING_GEOMETRY_FLAG_NO_DUPLICATE_ANYHIT_INVOCATION	= 0x2
+    } 	D3D12_RAYTRACING_GEOMETRY_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_GEOMETRY_FLAGS );
+typedef 
+enum D3D12_RAYTRACING_GEOMETRY_TYPE
+    {
+        D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES	= 0,
+        D3D12_RAYTRACING_GEOMETRY_TYPE_PROCEDURAL_PRIMITIVE_AABBS	= ( D3D12_RAYTRACING_GEOMETRY_TYPE_TRIANGLES + 1 ) 
+    } 	D3D12_RAYTRACING_GEOMETRY_TYPE;
+
+typedef 
+enum D3D12_RAYTRACING_INSTANCE_FLAGS
+    {
+        D3D12_RAYTRACING_INSTANCE_FLAG_NONE	= 0,
+        D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_CULL_DISABLE	= 0x1,
+        D3D12_RAYTRACING_INSTANCE_FLAG_TRIANGLE_FRONT_COUNTERCLOCKWISE	= 0x2,
+        D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_OPAQUE	= 0x4,
+        D3D12_RAYTRACING_INSTANCE_FLAG_FORCE_NON_OPAQUE	= 0x8
+    } 	D3D12_RAYTRACING_INSTANCE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_INSTANCE_FLAGS );
+typedef struct D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS StartAddress;
+    UINT64 StrideInBytes;
+    } 	D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE;
+
+typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS StartAddress;
+    UINT64 SizeInBytes;
+    } 	D3D12_GPU_VIRTUAL_ADDRESS_RANGE;
+
+typedef struct D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS StartAddress;
+    UINT64 SizeInBytes;
+    UINT64 StrideInBytes;
+    } 	D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE;
+
+typedef struct D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS Transform;
+    DXGI_FORMAT IndexFormat;
+    DXGI_FORMAT VertexFormat;
+    UINT IndexCount;
+    UINT VertexCount;
+    D3D12_GPU_VIRTUAL_ADDRESS IndexBuffer;
+    D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE VertexBuffer;
+    } 	D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC;
+
+typedef struct D3D12_RAYTRACING_AABB
+    {
+    FLOAT MinX;
+    FLOAT MinY;
+    FLOAT MinZ;
+    FLOAT MaxX;
+    FLOAT MaxY;
+    FLOAT MaxZ;
+    } 	D3D12_RAYTRACING_AABB;
+
+typedef struct D3D12_RAYTRACING_GEOMETRY_AABBS_DESC
+    {
+    UINT64 AABBCount;
+    D3D12_GPU_VIRTUAL_ADDRESS_AND_STRIDE AABBs;
+    } 	D3D12_RAYTRACING_GEOMETRY_AABBS_DESC;
+
+typedef struct D3D12_RAYTRACING_GEOMETRY_DESC
+    {
+    D3D12_RAYTRACING_GEOMETRY_TYPE Type;
+    D3D12_RAYTRACING_GEOMETRY_FLAGS Flags;
+    union 
+        {
+        D3D12_RAYTRACING_GEOMETRY_TRIANGLES_DESC Triangles;
+        D3D12_RAYTRACING_GEOMETRY_AABBS_DESC AABBs;
+        } 	;
+    } 	D3D12_RAYTRACING_GEOMETRY_DESC;
+
+typedef 
+enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS
+    {
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_NONE	= 0,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_UPDATE	= 0x1,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_ALLOW_COMPACTION	= 0x2,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_TRACE	= 0x4,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PREFER_FAST_BUILD	= 0x8,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_MINIMIZE_MEMORY	= 0x10,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAG_PERFORM_UPDATE	= 0x20
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS );
+typedef 
+enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE
+    {
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_CLONE	= 0,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_COMPACT	= 0x1,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_VISUALIZATION_DECODE_FOR_TOOLS	= 0x2,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_SERIALIZE	= 0x3,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE_DESERIALIZE	= 0x4
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE;
+
+typedef 
+enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE
+    {
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL	= 0,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL	= 0x1
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE;
+
+typedef struct D3D12_RAYTRACING_INSTANCE_DESC
+    {
+    FLOAT Transform[ 12 ];
+    UINT InstanceID	: 24;
+    UINT InstanceMask	: 8;
+    UINT InstanceContributionToHitGroupIndex	: 24;
+    UINT Flags	: 8;
+    D3D12_GPU_VIRTUAL_ADDRESS AccelerationStructure;
+    } 	D3D12_RAYTRACING_INSTANCE_DESC;
+
+typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO
+    {
+    UINT64 ResultDataMaxSizeInBytes;
+    UINT64 ScratchDataSizeInBytes;
+    UINT64 UpdateScratchDataSizeInBytes;
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO;
+
+typedef 
+enum D3D12_ELEMENTS_LAYOUT
+    {
+        D3D12_ELEMENTS_LAYOUT_ARRAY	= 0,
+        D3D12_ELEMENTS_LAYOUT_ARRAY_OF_POINTERS	= 0x1
+    } 	D3D12_ELEMENTS_LAYOUT;
+
+typedef struct D3D12_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_DESC
+    {
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type;
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS Flags;
+    UINT NumDescs;
+    D3D12_ELEMENTS_LAYOUT DescsLayout;
+    union 
+        {
+        const D3D12_RAYTRACING_GEOMETRY_DESC *pGeometryDescs;
+        const D3D12_RAYTRACING_GEOMETRY_DESC *const *ppGeometryDescs;
+        } 	;
+    } 	D3D12_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_DESC;
+
+typedef 
+enum D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE
+    {
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE	= 0,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION	= ( D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE + 1 ) ,
+        D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION	= ( D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION + 1 ) 
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE;
+
+typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC
+    {
+    UINT64 CompactedSizeInBytes;
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_COMPACTED_SIZE_DESC;
+
+typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC
+    {
+    UINT64 DecodedSizeInBytes;
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TOOLS_VISUALIZATION_DESC;
+
+typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER
+    {
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type;
+    UINT NumDescs;
+    } 	D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER;
+
+// Regarding D3D12_BUILD_RAY_TRACING_ACCELERATION_STRUCTURE_TOOLS_VISUALIZATION_HEADER above,
+// depending on Type field, NumDescs above is followed by either:
+//       D3D12_RAY_TRACING_INSTANCE_DESC InstanceDescs[NumDescs]
+//    or D3D12_RAY_TRACING_GEOMETRY_DESC GeometryDescs[NumDescs].
+// There is 4 bytes of padding between GeometryDesc structs in the array so alignment is natural when viewed by CPU.
+
+typedef struct D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC
+    {
+    UINT64 SerializedSizeInBytes;
+    UINT64 NumBottomLevelAccelerationStructurePointers;
+    } 	D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_SERIALIZATION_DESC;
+
+typedef struct D3D12_SERIALIZED_ACCELERATION_STRUCTURE_HEADER
+    {
+    UINT64 SerializedSizeInBytesIncludingHeader;
+    UINT64 DeserializedSizeInBytes;
+    UINT64 NumBottomLevelAccelerationStructurePointersAfterHeader;
+    } 	D3D12_SERIALIZED_ACCELERATION_STRUCTURE_HEADER;
+
+typedef struct D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS_RANGE DestAccelerationStructureData;
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_TYPE Type;
+    UINT NumDescs;
+    D3D12_ELEMENTS_LAYOUT DescsLayout;
+    union 
+        {
+        D3D12_GPU_VIRTUAL_ADDRESS InstanceDescs;
+        const D3D12_RAYTRACING_GEOMETRY_DESC *pGeometryDescs;
+        const D3D12_RAYTRACING_GEOMETRY_DESC *const *ppGeometryDescs;
+        } 	;
+    D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS Flags;
+    _In_opt_  D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData;
+    D3D12_GPU_VIRTUAL_ADDRESS_RANGE ScratchAccelerationStructureData;
+    } 	D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC;
+
+typedef struct D3D12_DISPATCH_RAYS_DESC
+    {
+    D3D12_GPU_VIRTUAL_ADDRESS_RANGE RayGenerationShaderRecord;
+    D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE MissShaderTable;
+    D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE HitGroupTable;
+    D3D12_GPU_VIRTUAL_ADDRESS_RANGE_AND_STRIDE CallableShaderTable;
+    UINT Width;
+    UINT Height;
+    } 	D3D12_DISPATCH_RAYS_DESC;
+
+#define D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BYTE_ALIGNMENT 256
+#define D3D12_RAYTRACING_INSTANCE_DESCS_BYTE_ALIGNMENT 16
+#define D3D12_RAYTRACING_MAX_ATTRIBUTE_SIZE_IN_BYTES 32
+#define D3D12_RAYTRACING_SHADER_RECORD_BYTE_ALIGNMENT 16
+#define D3D12_RAYTRACING_MAX_DECLARABLE_TRACE_RECURSION_DEPTH 31
+#define D3D12_RAYTRACING_AABB_BYTE_ALIGNMENT 4
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_1_0000_0007_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_1_0000_0007_v0_0_s_ifspec;
+
+#ifndef __ID3D12DeviceRaytracingPrototype_INTERFACE_DEFINED__
+#define __ID3D12DeviceRaytracingPrototype_INTERFACE_DEFINED__
+
+/* interface ID3D12DeviceRaytracingPrototype */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DeviceRaytracingPrototype;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("f52ef3ca-f710-4ee4-b873-a7f504e43995")
+    ID3D12DeviceRaytracingPrototype : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateStateObject( 
+            const D3D12_STATE_OBJECT_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppStateObject) = 0;
+        
+        virtual UINT STDMETHODCALLTYPE GetShaderIdentifierSize( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE GetRaytracingAccelerationStructurePrebuildInfo( 
+            _In_  D3D12_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_DESC *pDesc,
+            _Out_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DeviceRaytracingPrototypeVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DeviceRaytracingPrototype * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DeviceRaytracingPrototype * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DeviceRaytracingPrototype * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *CreateStateObject )( 
+            ID3D12DeviceRaytracingPrototype * This,
+            const D3D12_STATE_OBJECT_DESC *pDesc,
+            REFIID riid,
+            _COM_Outptr_  void **ppStateObject);
+        
+        UINT ( STDMETHODCALLTYPE *GetShaderIdentifierSize )( 
+            ID3D12DeviceRaytracingPrototype * This);
+        
+        void ( STDMETHODCALLTYPE *GetRaytracingAccelerationStructurePrebuildInfo )( 
+            ID3D12DeviceRaytracingPrototype * This,
+            _In_  D3D12_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_DESC *pDesc,
+            _Out_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO *pInfo);
+        
+        END_INTERFACE
+    } ID3D12DeviceRaytracingPrototypeVtbl;
+
+    interface ID3D12DeviceRaytracingPrototype
+    {
+        CONST_VTBL struct ID3D12DeviceRaytracingPrototypeVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DeviceRaytracingPrototype_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DeviceRaytracingPrototype_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DeviceRaytracingPrototype_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DeviceRaytracingPrototype_CreateStateObject(This,pDesc,riid,ppStateObject)	\
+    ( (This)->lpVtbl -> CreateStateObject(This,pDesc,riid,ppStateObject) ) 
+
+#define ID3D12DeviceRaytracingPrototype_GetShaderIdentifierSize(This)	\
+    ( (This)->lpVtbl -> GetShaderIdentifierSize(This) ) 
+
+#define ID3D12DeviceRaytracingPrototype_GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo)	\
+    ( (This)->lpVtbl -> GetRaytracingAccelerationStructurePrebuildInfo(This,pDesc,pInfo) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DeviceRaytracingPrototype_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12CommandListRaytracingPrototype_INTERFACE_DEFINED__
+#define __ID3D12CommandListRaytracingPrototype_INTERFACE_DEFINED__
+
+/* interface ID3D12CommandListRaytracingPrototype */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12CommandListRaytracingPrototype;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("3c69787a-28fa-4701-970a-37a1ed1f9cab")
+    ID3D12CommandListRaytracingPrototype : public IUnknown
+    {
+    public:
+        virtual void STDMETHODCALLTYPE BuildRaytracingAccelerationStructure( 
+            _In_  const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc) = 0;
+        
+        virtual void STDMETHODCALLTYPE EmitRaytracingAccelerationStructurePostBuildInfo( 
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS_RANGE DestBuffer,
+            _In_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE InfoType,
+            _In_  UINT NumSourceAccelerationStructures,
+            _In_reads_( NumSourceAccelerationStructures )  const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData) = 0;
+        
+        virtual void STDMETHODCALLTYPE CopyRaytracingAccelerationStructure( 
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS_RANGE DestAccelerationStructureData,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData,
+            _In_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode) = 0;
+        
+        virtual void STDMETHODCALLTYPE DispatchRays( 
+            _In_  ID3D12StateObjectPrototype *pRaytracingPipelineState,
+            _In_  const D3D12_DISPATCH_RAYS_DESC *pDesc) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12CommandListRaytracingPrototypeVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12CommandListRaytracingPrototype * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12CommandListRaytracingPrototype * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12CommandListRaytracingPrototype * This);
+        
+        void ( STDMETHODCALLTYPE *BuildRaytracingAccelerationStructure )( 
+            ID3D12CommandListRaytracingPrototype * This,
+            _In_  const D3D12_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_DESC *pDesc);
+        
+        void ( STDMETHODCALLTYPE *EmitRaytracingAccelerationStructurePostBuildInfo )( 
+            ID3D12CommandListRaytracingPrototype * This,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS_RANGE DestBuffer,
+            _In_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_TYPE InfoType,
+            _In_  UINT NumSourceAccelerationStructures,
+            _In_reads_( NumSourceAccelerationStructures )  const D3D12_GPU_VIRTUAL_ADDRESS *pSourceAccelerationStructureData);
+        
+        void ( STDMETHODCALLTYPE *CopyRaytracingAccelerationStructure )( 
+            ID3D12CommandListRaytracingPrototype * This,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS_RANGE DestAccelerationStructureData,
+            _In_  D3D12_GPU_VIRTUAL_ADDRESS SourceAccelerationStructureData,
+            _In_  D3D12_RAYTRACING_ACCELERATION_STRUCTURE_COPY_MODE Mode);
+        
+        void ( STDMETHODCALLTYPE *DispatchRays )( 
+            ID3D12CommandListRaytracingPrototype * This,
+            _In_  ID3D12StateObjectPrototype *pRaytracingPipelineState,
+            _In_  const D3D12_DISPATCH_RAYS_DESC *pDesc);
+        
+        END_INTERFACE
+    } ID3D12CommandListRaytracingPrototypeVtbl;
+
+    interface ID3D12CommandListRaytracingPrototype
+    {
+        CONST_VTBL struct ID3D12CommandListRaytracingPrototypeVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12CommandListRaytracingPrototype_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12CommandListRaytracingPrototype_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12CommandListRaytracingPrototype_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12CommandListRaytracingPrototype_BuildRaytracingAccelerationStructure(This,pDesc)	\
+    ( (This)->lpVtbl -> BuildRaytracingAccelerationStructure(This,pDesc) ) 
+
+#define ID3D12CommandListRaytracingPrototype_EmitRaytracingAccelerationStructurePostBuildInfo(This,DestBuffer,InfoType,NumSourceAccelerationStructures,pSourceAccelerationStructureData)	\
+    ( (This)->lpVtbl -> EmitRaytracingAccelerationStructurePostBuildInfo(This,DestBuffer,InfoType,NumSourceAccelerationStructures,pSourceAccelerationStructureData) ) 
+
+#define ID3D12CommandListRaytracingPrototype_CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode)	\
+    ( (This)->lpVtbl -> CopyRaytracingAccelerationStructure(This,DestAccelerationStructureData,SourceAccelerationStructureData,Mode) ) 
+
+#define ID3D12CommandListRaytracingPrototype_DispatchRays(This,pRaytracingPipelineState,pDesc)	\
+    ( (This)->lpVtbl -> DispatchRays(This,pRaytracingPipelineState,pDesc) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12CommandListRaytracingPrototype_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_1_0000_0009 */
+/* [local] */ 
+
+typedef 
+enum D3D12_METACOMMAND_PARAMETER_TYPE
+    {
+        D3D12_METACOMMAND_PARAMETER_FLOAT	= 0,
+        D3D12_METACOMMAND_PARAMETER_UINT64	= 1,
+        D3D12_METACOMMAND_PARAMETER_BUFFER_UAV	= 2,
+        D3D12_METACOMMAND_PARAMETER_BINDPOINT_IN_SHADER	= 3
+    } 	D3D12_METACOMMAND_PARAMETER_TYPE;
+
+typedef 
+enum D3D12_METACOMMAND_PARAMETER_ATTRIBUTES
+    {
+        D3D12_METACOMMAND_PARAMETER_INPUT	= 0x1,
+        D3D12_METACOMMAND_PARAMETER_OUTPUT	= 0x2
+    } 	D3D12_METACOMMAND_PARAMETER_ATTRIBUTES;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_METACOMMAND_PARAMETER_ATTRIBUTES );
+typedef 
+enum D3D12_METACOMMAND_PARAMETER_MUTABILITY
+    {
+        D3D12_METACOMMAND_PARAMETER_MUTABILITY_PER_EXECUTE	= 0,
+        D3D12_METACOMMAND_PARAMETER_MUTABILITY_CREATION_ONLY	= 1,
+        D3D12_METACOMMAND_PARAMETER_MUTABILITY_INITIALIZATION_ONLY	= 2
+    } 	D3D12_METACOMMAND_PARAMETER_MUTABILITY;
+
+typedef struct D3D12_METACOMMAND_PARAMETER_DESC
+    {
+    char Name[ 128 ];
+    D3D12_METACOMMAND_PARAMETER_TYPE Type;
+    D3D12_METACOMMAND_PARAMETER_ATTRIBUTES Attributes;
+    D3D12_METACOMMAND_PARAMETER_MUTABILITY Mutability;
+    } 	D3D12_METACOMMAND_PARAMETER_DESC;
+
+typedef 
+enum D3D12_METACOMMAND_BINDPOINT_PARAMETER_TYPE
+    {
+        D3D12_METACOMMAND_BINDPOINT_PARAMETER_TYPE_CBV	= 0,
+        D3D12_METACOMMAND_BINDPOINT_PARAMETER_TYPE_SRV	= ( D3D12_METACOMMAND_BINDPOINT_PARAMETER_TYPE_CBV + 1 ) ,
+        D3D12_METACOMMAND_BINDPOINT_PARAMETER_TYPE_UAV	= ( D3D12_METACOMMAND_BINDPOINT_PARAMETER_TYPE_SRV + 1 ) 
+    } 	D3D12_METACOMMAND_BINDPOINT_PARAMETER_TYPE;
+
+typedef struct D3D12_BINDPOINT_IN_SHADER
+    {
+    D3D12_METACOMMAND_BINDPOINT_PARAMETER_TYPE Type;
+    UINT Register;
+    UINT Space;
+    } 	D3D12_BINDPOINT_IN_SHADER;
+
+typedef struct D3D12_METACOMMAND_PARAMETER_DATA
+    {
+    UINT ParameterIndex;
+    union 
+        {
+        FLOAT FloatValue;
+        UINT64 UnsignedInt64Value;
+        D3D12_GPU_VIRTUAL_ADDRESS BufferLocation;
+        D3D12_BINDPOINT_IN_SHADER BindingInfo;
+        } 	;
+    } 	D3D12_METACOMMAND_PARAMETER_DATA;
+
+typedef struct D3D12_METACOMMAND_DESCRIPTION
+    {
+    GUID Id;
+    char Name[ 128 ];
+    UINT SignatureCount;
+    } 	D3D12_METACOMMAND_DESCRIPTION;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_1_0000_0009_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_1_0000_0009_v0_0_s_ifspec;
+
+#ifndef __ID3D12DeviceMetaCommand_INTERFACE_DEFINED__
+#define __ID3D12DeviceMetaCommand_INTERFACE_DEFINED__
+
+/* interface ID3D12DeviceMetaCommand */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DeviceMetaCommand;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("547e33c7-ff86-4cd9-bea3-5d4a28375396")
+    ID3D12DeviceMetaCommand : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE EnumerateMetaCommands( 
+            _Inout_  UINT *pNumMetaCommands,
+            _Out_writes_opt_(*pNumMetaCommands)  D3D12_METACOMMAND_DESCRIPTION *pDescs) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE EnumerateMetaCommandSignature( 
+            _In_  REFGUID CommandId,
+            _In_  UINT SignatureId,
+            _Inout_  UINT *pParameterCount,
+            _Out_writes_opt_(*pParameterCount)  D3D12_METACOMMAND_PARAMETER_DESC *pParameterDescs) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateMetaCommand( 
+            _In_  REFGUID CommandId,
+            _In_  UINT SignatureId,
+            _In_opt_  ID3D12RootSignature *pRootSignature,
+            _In_  UINT NumParameters,
+            _In_reads_(NumParameters)  const D3D12_METACOMMAND_PARAMETER_DATA *pParameters,
+            REFIID riid,
+            _COM_Outptr_  void **ppMetaCommand) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DeviceMetaCommandVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DeviceMetaCommand * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DeviceMetaCommand * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DeviceMetaCommand * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommands )( 
+            ID3D12DeviceMetaCommand * This,
+            _Inout_  UINT *pNumMetaCommands,
+            _Out_writes_opt_(*pNumMetaCommands)  D3D12_METACOMMAND_DESCRIPTION *pDescs);
+        
+        HRESULT ( STDMETHODCALLTYPE *EnumerateMetaCommandSignature )( 
+            ID3D12DeviceMetaCommand * This,
+            _In_  REFGUID CommandId,
+            _In_  UINT SignatureId,
+            _Inout_  UINT *pParameterCount,
+            _Out_writes_opt_(*pParameterCount)  D3D12_METACOMMAND_PARAMETER_DESC *pParameterDescs);
+        
+        HRESULT ( STDMETHODCALLTYPE *CreateMetaCommand )( 
+            ID3D12DeviceMetaCommand * This,
+            _In_  REFGUID CommandId,
+            _In_  UINT SignatureId,
+            _In_opt_  ID3D12RootSignature *pRootSignature,
+            _In_  UINT NumParameters,
+            _In_reads_(NumParameters)  const D3D12_METACOMMAND_PARAMETER_DATA *pParameters,
+            REFIID riid,
+            _COM_Outptr_  void **ppMetaCommand);
+        
+        END_INTERFACE
+    } ID3D12DeviceMetaCommandVtbl;
+
+    interface ID3D12DeviceMetaCommand
+    {
+        CONST_VTBL struct ID3D12DeviceMetaCommandVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DeviceMetaCommand_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DeviceMetaCommand_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DeviceMetaCommand_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DeviceMetaCommand_EnumerateMetaCommands(This,pNumMetaCommands,pDescs)	\
+    ( (This)->lpVtbl -> EnumerateMetaCommands(This,pNumMetaCommands,pDescs) ) 
+
+#define ID3D12DeviceMetaCommand_EnumerateMetaCommandSignature(This,CommandId,SignatureId,pParameterCount,pParameterDescs)	\
+    ( (This)->lpVtbl -> EnumerateMetaCommandSignature(This,CommandId,SignatureId,pParameterCount,pParameterDescs) ) 
+
+#define ID3D12DeviceMetaCommand_CreateMetaCommand(This,CommandId,SignatureId,pRootSignature,NumParameters,pParameters,riid,ppMetaCommand)	\
+    ( (This)->lpVtbl -> CreateMetaCommand(This,CommandId,SignatureId,pRootSignature,NumParameters,pParameters,riid,ppMetaCommand) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DeviceMetaCommand_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12MetaCommand_INTERFACE_DEFINED__
+#define __ID3D12MetaCommand_INTERFACE_DEFINED__
+
+/* interface ID3D12MetaCommand */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12MetaCommand;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8AFDA767-8003-494F-9E9A-4AA8864F3524")
+    ID3D12MetaCommand : public ID3D12Pageable
+    {
+    public:
+        virtual void STDMETHODCALLTYPE GetRequiredParameterResourceSize( 
+            UINT32 ParameterIndex,
+            UINT64 *SizeInBytes) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12MetaCommandVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12MetaCommand * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12MetaCommand * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12MetaCommand * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12MetaCommand * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12MetaCommand * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12MetaCommand * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12MetaCommand * This,
+            _In_z_  LPCWSTR Name);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12MetaCommand * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        void ( STDMETHODCALLTYPE *GetRequiredParameterResourceSize )( 
+            ID3D12MetaCommand * This,
+            UINT32 ParameterIndex,
+            UINT64 *SizeInBytes);
+        
+        END_INTERFACE
+    } ID3D12MetaCommandVtbl;
+
+    interface ID3D12MetaCommand
+    {
+        CONST_VTBL struct ID3D12MetaCommandVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12MetaCommand_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12MetaCommand_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12MetaCommand_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12MetaCommand_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12MetaCommand_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12MetaCommand_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12MetaCommand_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12MetaCommand_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12MetaCommand_GetRequiredParameterResourceSize(This,ParameterIndex,SizeInBytes)	\
+    ( (This)->lpVtbl -> GetRequiredParameterResourceSize(This,ParameterIndex,SizeInBytes) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12MetaCommand_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12CommandListMetaCommand_INTERFACE_DEFINED__
+#define __ID3D12CommandListMetaCommand_INTERFACE_DEFINED__
+
+/* interface ID3D12CommandListMetaCommand */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12CommandListMetaCommand;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("5A5F59F3-7124-4766-8E9E-CB637764FB0B")
+    ID3D12CommandListMetaCommand : public IUnknown
+    {
+    public:
+        virtual void STDMETHODCALLTYPE InitializeMetaCommand( 
+            _In_  ID3D12MetaCommand *pMetaCommand,
+            _In_  UINT NumParameters,
+            _In_reads_(NumParameters)  const D3D12_METACOMMAND_PARAMETER_DATA *pParameters) = 0;
+        
+        virtual void STDMETHODCALLTYPE ExecuteMetaCommand( 
+            _In_  ID3D12MetaCommand *pMetaCommand,
+            _In_  UINT NumParameters,
+            _In_reads_(NumParameters)  const D3D12_METACOMMAND_PARAMETER_DATA *pParameters) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12CommandListMetaCommandVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12CommandListMetaCommand * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12CommandListMetaCommand * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12CommandListMetaCommand * This);
+        
+        void ( STDMETHODCALLTYPE *InitializeMetaCommand )( 
+            ID3D12CommandListMetaCommand * This,
+            _In_  ID3D12MetaCommand *pMetaCommand,
+            _In_  UINT NumParameters,
+            _In_reads_(NumParameters)  const D3D12_METACOMMAND_PARAMETER_DATA *pParameters);
+        
+        void ( STDMETHODCALLTYPE *ExecuteMetaCommand )( 
+            ID3D12CommandListMetaCommand * This,
+            _In_  ID3D12MetaCommand *pMetaCommand,
+            _In_  UINT NumParameters,
+            _In_reads_(NumParameters)  const D3D12_METACOMMAND_PARAMETER_DATA *pParameters);
+        
+        END_INTERFACE
+    } ID3D12CommandListMetaCommandVtbl;
+
+    interface ID3D12CommandListMetaCommand
+    {
+        CONST_VTBL struct ID3D12CommandListMetaCommandVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12CommandListMetaCommand_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12CommandListMetaCommand_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12CommandListMetaCommand_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12CommandListMetaCommand_InitializeMetaCommand(This,pMetaCommand,NumParameters,pParameters)	\
+    ( (This)->lpVtbl -> InitializeMetaCommand(This,pMetaCommand,NumParameters,pParameters) ) 
+
+#define ID3D12CommandListMetaCommand_ExecuteMetaCommand(This,pMetaCommand,NumParameters,pParameters)	\
+    ( (This)->lpVtbl -> ExecuteMetaCommand(This,pMetaCommand,NumParameters,pParameters) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12CommandListMetaCommand_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12_1_0000_0012 */
+/* [local] */ 
+
+#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */
+#pragma endregion
+DEFINE_GUID(IID_ID3D12CryptoSession,0xFC7C6C9D,0xC27D,0x4904,0x83,0x5D,0xA5,0xF2,0x09,0x6E,0xC6,0x5F);
+DEFINE_GUID(IID_ID3D12CryptoSessionPolicy,0x69FE3108,0x01A4,0x4AC3,0xAB,0x91,0xF5,0x1E,0x37,0x7A,0x62,0xAC);
+DEFINE_GUID(IID_ID3D12ContentProtectionDevice,0x59975f53,0xbf5f,0x42f2,0xb8,0x4f,0x5e,0x34,0x7c,0x1e,0x3d,0x43);
+DEFINE_GUID(IID_ID3D12VideoDecodeCommandList2,0xEAD05737,0xEE1D,0x4442,0x9B,0x18,0x7D,0x99,0x2E,0x9A,0x89,0x60);
+DEFINE_GUID(IID_ID3D12VideoProcessCommandList2,0x569AB919,0x94DE,0x4529,0x82,0x92,0x35,0xDE,0x97,0x84,0x80,0x59);
+DEFINE_GUID(IID_ID3D12StateObjectPrototype,0x47016943,0xfca8,0x4594,0x93,0xea,0xaf,0x25,0x8b,0x55,0x34,0x6d);
+DEFINE_GUID(IID_ID3D12StateObjectPropertiesPrototype,0xde5fa827,0x9bf9,0x4f26,0x89,0xff,0xd7,0xf5,0x6f,0xde,0x38,0x60);
+DEFINE_GUID(IID_ID3D12DeviceRaytracingPrototype,0xf52ef3ca,0xf710,0x4ee4,0xb8,0x73,0xa7,0xf5,0x04,0xe4,0x39,0x95);
+DEFINE_GUID(IID_ID3D12CommandListRaytracingPrototype,0x3c69787a,0x28fa,0x4701,0x97,0x0a,0x37,0xa1,0xed,0x1f,0x9c,0xab);
+DEFINE_GUID(IID_ID3D12DeviceMetaCommand,0x547e33c7,0xff86,0x4cd9,0xbe,0xa3,0x5d,0x4a,0x28,0x37,0x53,0x96);
+DEFINE_GUID(IID_ID3D12MetaCommand,0x8AFDA767,0x8003,0x494F,0x9E,0x9A,0x4A,0xA8,0x86,0x4F,0x35,0x24);
+DEFINE_GUID(IID_ID3D12CommandListMetaCommand,0x5A5F59F3,0x7124,0x4766,0x8E,0x9E,0xCB,0x63,0x77,0x64,0xFB,0x0B);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_1_0000_0012_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12_1_0000_0012_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+

3rdparty/dxsdk/include/d3d12video.h

@@ -0,0 +1,2440 @@
+/*-------------------------------------------------------------------------------------
+ *
+ * Copyright (c) Microsoft Corporation
+ *
+ *-------------------------------------------------------------------------------------*/
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 8.01.0622 */
+
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif /* __RPCNDR_H_VERSION__ */
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#ifndef __d3d12video_h__
+#define __d3d12video_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+/* Forward Declarations */ 
+
+#ifndef __ID3D12VideoDecoderHeap_FWD_DEFINED__
+#define __ID3D12VideoDecoderHeap_FWD_DEFINED__
+typedef interface ID3D12VideoDecoderHeap ID3D12VideoDecoderHeap;
+
+#endif 	/* __ID3D12VideoDecoderHeap_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDevice_FWD_DEFINED__
+#define __ID3D12VideoDevice_FWD_DEFINED__
+typedef interface ID3D12VideoDevice ID3D12VideoDevice;
+
+#endif 	/* __ID3D12VideoDevice_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecoder_FWD_DEFINED__
+#define __ID3D12VideoDecoder_FWD_DEFINED__
+typedef interface ID3D12VideoDecoder ID3D12VideoDecoder;
+
+#endif 	/* __ID3D12VideoDecoder_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessor_FWD_DEFINED__
+#define __ID3D12VideoProcessor_FWD_DEFINED__
+typedef interface ID3D12VideoProcessor ID3D12VideoProcessor;
+
+#endif 	/* __ID3D12VideoProcessor_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecodeCommandList_FWD_DEFINED__
+#define __ID3D12VideoDecodeCommandList_FWD_DEFINED__
+typedef interface ID3D12VideoDecodeCommandList ID3D12VideoDecodeCommandList;
+
+#endif 	/* __ID3D12VideoDecodeCommandList_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessCommandList_FWD_DEFINED__
+#define __ID3D12VideoProcessCommandList_FWD_DEFINED__
+typedef interface ID3D12VideoProcessCommandList ID3D12VideoProcessCommandList;
+
+#endif 	/* __ID3D12VideoProcessCommandList_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecodeCommandList1_FWD_DEFINED__
+#define __ID3D12VideoDecodeCommandList1_FWD_DEFINED__
+typedef interface ID3D12VideoDecodeCommandList1 ID3D12VideoDecodeCommandList1;
+
+#endif 	/* __ID3D12VideoDecodeCommandList1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessCommandList1_FWD_DEFINED__
+#define __ID3D12VideoProcessCommandList1_FWD_DEFINED__
+typedef interface ID3D12VideoProcessCommandList1 ID3D12VideoProcessCommandList1;
+
+#endif 	/* __ID3D12VideoProcessCommandList1_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "oaidl.h"
+#include "ocidl.h"
+#include "dxgicommon.h"
+#include "d3d12.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_d3d12video_0000_0000 */
+/* [local] */ 
+
+#include <winapifamily.h>
+#pragma region App Family
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+typedef 
+enum D3D12_VIDEO_FIELD_TYPE
+    {
+        D3D12_VIDEO_FIELD_TYPE_NONE	= 0,
+        D3D12_VIDEO_FIELD_TYPE_INTERLACED_TOP_FIELD_FIRST	= 1,
+        D3D12_VIDEO_FIELD_TYPE_INTERLACED_BOTTOM_FIELD_FIRST	= 2
+    } 	D3D12_VIDEO_FIELD_TYPE;
+
+typedef 
+enum D3D12_VIDEO_FRAME_STEREO_FORMAT
+    {
+        D3D12_VIDEO_FRAME_STEREO_FORMAT_NONE	= 0,
+        D3D12_VIDEO_FRAME_STEREO_FORMAT_MONO	= 1,
+        D3D12_VIDEO_FRAME_STEREO_FORMAT_HORIZONTAL	= 2,
+        D3D12_VIDEO_FRAME_STEREO_FORMAT_VERTICAL	= 3,
+        D3D12_VIDEO_FRAME_STEREO_FORMAT_SEPARATE	= 4
+    } 	D3D12_VIDEO_FRAME_STEREO_FORMAT;
+
+typedef struct D3D12_VIDEO_FORMAT
+    {
+    DXGI_FORMAT Format;
+    DXGI_COLOR_SPACE_TYPE ColorSpace;
+    } 	D3D12_VIDEO_FORMAT;
+
+typedef struct D3D12_VIDEO_SAMPLE
+    {
+    UINT Width;
+    UINT Height;
+    D3D12_VIDEO_FORMAT Format;
+    } 	D3D12_VIDEO_SAMPLE;
+
+typedef 
+enum D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE
+    {
+        D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE_NONE	= 0,
+        D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE_FIELD_BASED	= 1
+    } 	D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE;
+
+typedef 
+enum D3D12_FEATURE_VIDEO
+    {
+        D3D12_FEATURE_VIDEO_DECODE_SUPPORT	= 0,
+        D3D12_FEATURE_VIDEO_DECODE_PROFILES	= 1,
+        D3D12_FEATURE_VIDEO_DECODE_FORMATS	= 2,
+        D3D12_FEATURE_VIDEO_DECODE_CONVERSION_SUPPORT	= 3,
+        D3D12_FEATURE_VIDEO_PROCESS_SUPPORT	= 5,
+        D3D12_FEATURE_VIDEO_PROCESS_MAX_INPUT_STREAMS	= 6,
+        D3D12_FEATURE_VIDEO_PROCESS_REFERENCE_INFO	= 7,
+        D3D12_FEATURE_VIDEO_DECODER_HEAP_SIZE	= 8,
+        D3D12_FEATURE_VIDEO_PROCESSOR_SIZE	= 9,
+        D3D12_FEATURE_VIDEO_DECODE_PROFILE_COUNT	= 10,
+        D3D12_FEATURE_VIDEO_DECODE_FORMAT_COUNT	= 11,
+        D3D12_FEATURE_VIDEO_ARCHITECTURE	= 17,
+        D3D12_FEATURE_VIDEO_DECODE_HISTOGRAM	= 18
+    } 	D3D12_FEATURE_VIDEO;
+
+typedef 
+enum D3D12_BITSTREAM_ENCRYPTION_TYPE
+    {
+        D3D12_BITSTREAM_ENCRYPTION_TYPE_NONE	= 0
+    } 	D3D12_BITSTREAM_ENCRYPTION_TYPE;
+
+typedef struct D3D12_VIDEO_DECODE_CONFIGURATION
+    {
+    GUID DecodeProfile;
+    D3D12_BITSTREAM_ENCRYPTION_TYPE BitstreamEncryption;
+    D3D12_VIDEO_FRAME_CODED_INTERLACE_TYPE InterlaceType;
+    } 	D3D12_VIDEO_DECODE_CONFIGURATION;
+
+typedef struct D3D12_VIDEO_DECODER_DESC
+    {
+    UINT NodeMask;
+    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;
+    } 	D3D12_VIDEO_DECODER_DESC;
+
+typedef struct D3D12_VIDEO_DECODER_HEAP_DESC
+    {
+    UINT NodeMask;
+    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;
+    UINT DecodeWidth;
+    UINT DecodeHeight;
+    DXGI_FORMAT Format;
+    DXGI_RATIONAL FrameRate;
+    UINT BitRate;
+    UINT MaxDecodePictureBufferCount;
+    } 	D3D12_VIDEO_DECODER_HEAP_DESC;
+
+typedef struct D3D12_VIDEO_SIZE_RANGE
+    {
+    UINT MaxWidth;
+    UINT MaxHeight;
+    UINT MinWidth;
+    UINT MinHeight;
+    } 	D3D12_VIDEO_SIZE_RANGE;
+
+typedef 
+enum D3D12_VIDEO_PROCESS_FILTER
+    {
+        D3D12_VIDEO_PROCESS_FILTER_BRIGHTNESS	= 0,
+        D3D12_VIDEO_PROCESS_FILTER_CONTRAST	= 1,
+        D3D12_VIDEO_PROCESS_FILTER_HUE	= 2,
+        D3D12_VIDEO_PROCESS_FILTER_SATURATION	= 3,
+        D3D12_VIDEO_PROCESS_FILTER_NOISE_REDUCTION	= 4,
+        D3D12_VIDEO_PROCESS_FILTER_EDGE_ENHANCEMENT	= 5,
+        D3D12_VIDEO_PROCESS_FILTER_ANAMORPHIC_SCALING	= 6,
+        D3D12_VIDEO_PROCESS_FILTER_STEREO_ADJUSTMENT	= 7
+    } 	D3D12_VIDEO_PROCESS_FILTER;
+
+typedef 
+enum D3D12_VIDEO_PROCESS_FILTER_FLAGS
+    {
+        D3D12_VIDEO_PROCESS_FILTER_FLAG_NONE	= 0,
+        D3D12_VIDEO_PROCESS_FILTER_FLAG_BRIGHTNESS	= ( 1 << D3D12_VIDEO_PROCESS_FILTER_BRIGHTNESS ) ,
+        D3D12_VIDEO_PROCESS_FILTER_FLAG_CONTRAST	= ( 1 << D3D12_VIDEO_PROCESS_FILTER_CONTRAST ) ,
+        D3D12_VIDEO_PROCESS_FILTER_FLAG_HUE	= ( 1 << D3D12_VIDEO_PROCESS_FILTER_HUE ) ,
+        D3D12_VIDEO_PROCESS_FILTER_FLAG_SATURATION	= ( 1 << D3D12_VIDEO_PROCESS_FILTER_SATURATION ) ,
+        D3D12_VIDEO_PROCESS_FILTER_FLAG_NOISE_REDUCTION	= ( 1 << D3D12_VIDEO_PROCESS_FILTER_NOISE_REDUCTION ) ,
+        D3D12_VIDEO_PROCESS_FILTER_FLAG_EDGE_ENHANCEMENT	= ( 1 << D3D12_VIDEO_PROCESS_FILTER_EDGE_ENHANCEMENT ) ,
+        D3D12_VIDEO_PROCESS_FILTER_FLAG_ANAMORPHIC_SCALING	= ( 1 << D3D12_VIDEO_PROCESS_FILTER_ANAMORPHIC_SCALING ) ,
+        D3D12_VIDEO_PROCESS_FILTER_FLAG_STEREO_ADJUSTMENT	= ( 1 << D3D12_VIDEO_PROCESS_FILTER_STEREO_ADJUSTMENT ) 
+    } 	D3D12_VIDEO_PROCESS_FILTER_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_FILTER_FLAGS );
+typedef 
+enum D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS
+    {
+        D3D12_VIDEO_PROCESS_DEINTERLACE_FLAG_NONE	= 0,
+        D3D12_VIDEO_PROCESS_DEINTERLACE_FLAG_BOB	= 0x1,
+        D3D12_VIDEO_PROCESS_DEINTERLACE_FLAG_CUSTOM	= 0x80000000
+    } 	D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS );
+typedef struct D3D12_VIDEO_PROCESS_ALPHA_BLENDING
+    {
+    BOOL Enable;
+    FLOAT Alpha;
+    } 	D3D12_VIDEO_PROCESS_ALPHA_BLENDING;
+
+typedef struct D3D12_VIDEO_PROCESS_LUMA_KEY
+    {
+    BOOL Enable;
+    FLOAT Lower;
+    FLOAT Upper;
+    } 	D3D12_VIDEO_PROCESS_LUMA_KEY;
+
+typedef struct D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC
+    {
+    DXGI_FORMAT Format;
+    DXGI_COLOR_SPACE_TYPE ColorSpace;
+    DXGI_RATIONAL SourceAspectRatio;
+    DXGI_RATIONAL DestinationAspectRatio;
+    DXGI_RATIONAL FrameRate;
+    D3D12_VIDEO_SIZE_RANGE SourceSizeRange;
+    D3D12_VIDEO_SIZE_RANGE DestinationSizeRange;
+    BOOL EnableOrientation;
+    D3D12_VIDEO_PROCESS_FILTER_FLAGS FilterFlags;
+    D3D12_VIDEO_FRAME_STEREO_FORMAT StereoFormat;
+    D3D12_VIDEO_FIELD_TYPE FieldType;
+    D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS DeinterlaceMode;
+    BOOL EnableAlphaBlending;
+    D3D12_VIDEO_PROCESS_LUMA_KEY LumaKey;
+    UINT NumPastFrames;
+    UINT NumFutureFrames;
+    BOOL EnableAutoProcessing;
+    } 	D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC;
+
+typedef 
+enum D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE
+    {
+        D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_OPAQUE	= 0,
+        D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_BACKGROUND	= 1,
+        D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_DESTINATION	= 2,
+        D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE_SOURCE_STREAM	= 3
+    } 	D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE;
+
+typedef struct D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC
+    {
+    DXGI_FORMAT Format;
+    DXGI_COLOR_SPACE_TYPE ColorSpace;
+    D3D12_VIDEO_PROCESS_ALPHA_FILL_MODE AlphaFillMode;
+    UINT AlphaFillModeSourceStreamIndex;
+    FLOAT BackgroundColor[ 4 ];
+    DXGI_RATIONAL FrameRate;
+    BOOL EnableStereo;
+    } 	D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0000_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoDecoderHeap_INTERFACE_DEFINED__
+#define __ID3D12VideoDecoderHeap_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDecoderHeap */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDecoderHeap;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("0946B7C9-EBF6-4047-BB73-8683E27DBB1F")
+    ID3D12VideoDecoderHeap : public ID3D12Pageable
+    {
+    public:
+        virtual D3D12_VIDEO_DECODER_HEAP_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecoderHeapVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecoderHeap * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecoderHeap * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecoderHeap * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecoderHeap * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecoderHeap * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecoderHeap * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecoderHeap * This,
+            _In_z_  LPCWSTR Name);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecoderHeap * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        D3D12_VIDEO_DECODER_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoDecoderHeap * This);
+        
+        END_INTERFACE
+    } ID3D12VideoDecoderHeapVtbl;
+
+    interface ID3D12VideoDecoderHeap
+    {
+        CONST_VTBL struct ID3D12VideoDecoderHeapVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDecoderHeap_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDecoderHeap_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDecoderHeap_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDecoderHeap_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoDecoderHeap_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoDecoderHeap_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoDecoderHeap_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoDecoderHeap_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12VideoDecoderHeap_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDecoderHeap_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDevice_INTERFACE_DEFINED__
+#define __ID3D12VideoDevice_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDevice */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDevice;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("1F052807-0B46-4ACC-8A89-364F793718A4")
+    ID3D12VideoDevice : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CheckFeatureSupport( 
+            D3D12_FEATURE_VIDEO FeatureVideo,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoDecoder( 
+            _In_  const D3D12_VIDEO_DECODER_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoder) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoDecoderHeap( 
+            _In_  const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoderHeap) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoProcessor( 
+            UINT NodeMask,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *pOutputStreamDesc,
+            UINT NumInputStreamDescs,
+            _In_reads_(NumInputStreamDescs)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoProcessor) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDeviceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDevice * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDevice * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDevice * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12VideoDevice * This,
+            D3D12_FEATURE_VIDEO FeatureVideo,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoder )( 
+            ID3D12VideoDevice * This,
+            _In_  const D3D12_VIDEO_DECODER_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoder);
+        
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoderHeap )( 
+            ID3D12VideoDevice * This,
+            _In_  const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoderHeap);
+        
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoProcessor )( 
+            ID3D12VideoDevice * This,
+            UINT NodeMask,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *pOutputStreamDesc,
+            UINT NumInputStreamDescs,
+            _In_reads_(NumInputStreamDescs)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoProcessor);
+        
+        END_INTERFACE
+    } ID3D12VideoDeviceVtbl;
+
+    interface ID3D12VideoDevice
+    {
+        CONST_VTBL struct ID3D12VideoDeviceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDevice_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDevice_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDevice_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDevice_CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12VideoDevice_CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder)	\
+    ( (This)->lpVtbl -> CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder) ) 
+
+#define ID3D12VideoDevice_CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap)	\
+    ( (This)->lpVtbl -> CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap) ) 
+
+#define ID3D12VideoDevice_CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor)	\
+    ( (This)->lpVtbl -> CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDevice_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecoder_INTERFACE_DEFINED__
+#define __ID3D12VideoDecoder_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDecoder */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDecoder;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("C59B6BDC-7720-4074-A136-17A156037470")
+    ID3D12VideoDecoder : public ID3D12Pageable
+    {
+    public:
+        virtual D3D12_VIDEO_DECODER_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecoderVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecoder * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecoder * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecoder * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecoder * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecoder * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecoder * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecoder * This,
+            _In_z_  LPCWSTR Name);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecoder * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        D3D12_VIDEO_DECODER_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoDecoder * This);
+        
+        END_INTERFACE
+    } ID3D12VideoDecoderVtbl;
+
+    interface ID3D12VideoDecoder
+    {
+        CONST_VTBL struct ID3D12VideoDecoderVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDecoder_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDecoder_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDecoder_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDecoder_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoDecoder_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoDecoder_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoDecoder_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoDecoder_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12VideoDecoder_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDecoder_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0003 */
+/* [local] */ 
+
+typedef 
+enum D3D12_VIDEO_DECODE_TIER
+    {
+        D3D12_VIDEO_DECODE_TIER_NOT_SUPPORTED	= 0,
+        D3D12_VIDEO_DECODE_TIER_1	= 1,
+        D3D12_VIDEO_DECODE_TIER_2	= 2,
+        D3D12_VIDEO_DECODE_TIER_3	= 3
+    } 	D3D12_VIDEO_DECODE_TIER;
+
+typedef 
+enum D3D12_VIDEO_DECODE_SUPPORT_FLAGS
+    {
+        D3D12_VIDEO_DECODE_SUPPORT_FLAG_NONE	= 0,
+        D3D12_VIDEO_DECODE_SUPPORT_FLAG_SUPPORTED	= 0x1
+    } 	D3D12_VIDEO_DECODE_SUPPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_SUPPORT_FLAGS );
+typedef 
+enum D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS
+    {
+        D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_NONE	= 0,
+        D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_HEIGHT_ALIGNMENT_MULTIPLE_32_REQUIRED	= 0x1,
+        D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_POST_PROCESSING_SUPPORTED	= 0x2,
+        D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_REFERENCE_ONLY_ALLOCATIONS_REQUIRED	= 0x4,
+        D3D12_VIDEO_DECODE_CONFIGURATION_FLAG_ALLOW_RESOLUTION_CHANGE_ON_NON_KEY_FRAME	= 0x8
+    } 	D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS );
+typedef 
+enum D3D12_VIDEO_DECODE_STATUS
+    {
+        D3D12_VIDEO_DECODE_STATUS_OK	= 0,
+        D3D12_VIDEO_DECODE_STATUS_CONTINUE	= 1,
+        D3D12_VIDEO_DECODE_STATUS_CONTINUE_SKIP_DISPLAY	= 2,
+        D3D12_VIDEO_DECODE_STATUS_RESTART	= 3
+    } 	D3D12_VIDEO_DECODE_STATUS;
+
+typedef 
+enum D3D12_VIDEO_DECODE_ARGUMENT_TYPE
+    {
+        D3D12_VIDEO_DECODE_ARGUMENT_TYPE_PICTURE_PARAMETERS	= 0,
+        D3D12_VIDEO_DECODE_ARGUMENT_TYPE_INVERSE_QUANTIZATION_MATRIX	= 1,
+        D3D12_VIDEO_DECODE_ARGUMENT_TYPE_SLICE_CONTROL	= 2,
+        D3D12_VIDEO_DECODE_ARGUMENT_TYPE_MAX_VALID	= 3
+    } 	D3D12_VIDEO_DECODE_ARGUMENT_TYPE;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;
+    UINT Width;
+    UINT Height;
+    DXGI_FORMAT DecodeFormat;
+    DXGI_RATIONAL FrameRate;
+    UINT BitRate;
+    D3D12_VIDEO_DECODE_SUPPORT_FLAGS SupportFlags;
+    D3D12_VIDEO_DECODE_CONFIGURATION_FLAGS ConfigurationFlags;
+    D3D12_VIDEO_DECODE_TIER DecodeTier;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODE_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILE_COUNT
+    {
+    UINT NodeIndex;
+    UINT ProfileCount;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILE_COUNT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILES
+    {
+    UINT NodeIndex;
+    UINT ProfileCount;
+    _Field_size_full_(ProfileCount)  GUID *pProfiles;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODE_PROFILES;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_FORMAT_COUNT
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;
+    UINT FormatCount;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODE_FORMAT_COUNT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_FORMATS
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;
+    UINT FormatCount;
+    _Field_size_full_(FormatCount)  DXGI_FORMAT *pOutputFormats;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODE_FORMATS;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ARCHITECTURE
+    {
+    BOOL IOCoherent;
+    } 	D3D12_FEATURE_DATA_VIDEO_ARCHITECTURE;
+
+typedef 
+enum D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT
+    {
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_Y	= 0,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_U	= 1,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_V	= 2,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_R	= 0,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_G	= 1,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_B	= 2,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_A	= 3
+    } 	D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT;
+
+typedef 
+enum D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS
+    {
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_NONE	= 0,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_Y	= ( 1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_Y ) ,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_U	= ( 1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_U ) ,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_V	= ( 1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_V ) ,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_R	= ( 1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_R ) ,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_G	= ( 1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_G ) ,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_B	= ( 1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_B ) ,
+        D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAG_A	= ( 1 << D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_A ) 
+    } 	D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS );
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_HISTOGRAM
+    {
+    UINT NodeIndex;
+    GUID DecodeProfile;
+    UINT Width;
+    UINT Height;
+    DXGI_FORMAT DecodeFormat;
+    D3D12_VIDEO_DECODE_HISTOGRAM_COMPONENT_FLAGS Components;
+    UINT BinCount;
+    UINT CounterBitDepth;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODE_HISTOGRAM;
+
+typedef 
+enum D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS
+    {
+        D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAG_NONE	= 0,
+        D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAG_SUPPORTED	= 0x1
+    } 	D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS );
+typedef 
+enum D3D12_VIDEO_SCALE_SUPPORT_FLAGS
+    {
+        D3D12_VIDEO_SCALE_SUPPORT_FLAG_NONE	= 0,
+        D3D12_VIDEO_SCALE_SUPPORT_FLAG_POW2_ONLY	= 0x1,
+        D3D12_VIDEO_SCALE_SUPPORT_FLAG_EVEN_DIMENSIONS_ONLY	= 0x2
+    } 	D3D12_VIDEO_SCALE_SUPPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_SCALE_SUPPORT_FLAGS );
+typedef struct D3D12_VIDEO_SCALE_SUPPORT
+    {
+    D3D12_VIDEO_SIZE_RANGE OutputSizeRange;
+    D3D12_VIDEO_SCALE_SUPPORT_FLAGS Flags;
+    } 	D3D12_VIDEO_SCALE_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_CONVERSION_SUPPORT
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;
+    D3D12_VIDEO_SAMPLE DecodeSample;
+    D3D12_VIDEO_FORMAT OutputFormat;
+    DXGI_RATIONAL FrameRate;
+    UINT BitRate;
+    D3D12_VIDEO_DECODE_CONVERSION_SUPPORT_FLAGS SupportFlags;
+    D3D12_VIDEO_SCALE_SUPPORT ScaleSupport;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODE_CONVERSION_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE
+    {
+    D3D12_VIDEO_DECODER_HEAP_DESC VideoDecoderHeapDesc;
+    UINT64 MemoryPoolL0Size;
+    UINT64 MemoryPoolL1Size;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE
+    {
+    UINT NodeMask;
+    const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *pOutputStreamDesc;
+    UINT NumInputStreamDescs;
+    const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs;
+    UINT64 MemoryPoolL0Size;
+    UINT64 MemoryPoolL1Size;
+    } 	D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE;
+
+typedef struct D3D12_QUERY_DATA_VIDEO_DECODE_STATISTICS
+    {
+    UINT64 Status;
+    UINT64 NumMacroblocksAffected;
+    DXGI_RATIONAL FrameRate;
+    UINT BitRate;
+    } 	D3D12_QUERY_DATA_VIDEO_DECODE_STATISTICS;
+
+typedef struct D3D12_VIDEO_DECODE_SUB_SAMPLE_MAPPING_BLOCK
+    {
+    UINT ClearSize;
+    UINT EncryptedSize;
+    } 	D3D12_VIDEO_DECODE_SUB_SAMPLE_MAPPING_BLOCK;
+
+typedef struct D3D12_VIDEO_DECODE_FRAME_ARGUMENT
+    {
+    D3D12_VIDEO_DECODE_ARGUMENT_TYPE Type;
+    UINT Size;
+    _Field_size_bytes_full_(Size)  void *pData;
+    } 	D3D12_VIDEO_DECODE_FRAME_ARGUMENT;
+
+typedef struct D3D12_VIDEO_DECODE_REFERENCE_FRAMES
+    {
+    UINT NumTexture2Ds;
+    _Field_size_full_(NumTexture2Ds)  ID3D12Resource **ppTexture2Ds;
+    _Field_size_full_(NumTexture2Ds)  UINT *pSubresources;
+    _Field_size_full_opt_(NumTexture2Ds)  ID3D12VideoDecoderHeap **ppHeaps;
+    } 	D3D12_VIDEO_DECODE_REFERENCE_FRAMES;
+
+typedef struct D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM
+    {
+    ID3D12Resource *pBuffer;
+    UINT64 Offset;
+    UINT64 Size;
+    } 	D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM;
+
+typedef struct D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS
+    {
+    BOOL Enable;
+    ID3D12Resource *pReferenceTexture2D;
+    UINT ReferenceSubresource;
+    DXGI_COLOR_SPACE_TYPE OutputColorSpace;
+    DXGI_COLOR_SPACE_TYPE DecodeColorSpace;
+    } 	D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS;
+
+typedef struct D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS
+    {
+    UINT NumFrameArguments;
+    D3D12_VIDEO_DECODE_FRAME_ARGUMENT FrameArguments[ 10 ];
+    D3D12_VIDEO_DECODE_REFERENCE_FRAMES ReferenceFrames;
+    D3D12_VIDEO_DECODE_COMPRESSED_BITSTREAM CompressedBitstream;
+    ID3D12VideoDecoderHeap *pHeap;
+    } 	D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS;
+
+typedef struct D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS
+    {
+    ID3D12Resource *pOutputTexture2D;
+    UINT OutputSubresource;
+    D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS ConversionArguments;
+    } 	D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0003_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0003_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoProcessor_INTERFACE_DEFINED__
+#define __ID3D12VideoProcessor_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoProcessor */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoProcessor;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("304FDB32-BEDE-410A-8545-943AC6A46138")
+    ID3D12VideoProcessor : public ID3D12Pageable
+    {
+    public:
+        virtual UINT STDMETHODCALLTYPE GetNodeMask( void) = 0;
+        
+        virtual UINT STDMETHODCALLTYPE GetNumInputStreamDescs( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetInputStreamDescs( 
+            UINT NumInputStreamDescs,
+            _Out_writes_(NumInputStreamDescs)  D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs) = 0;
+        
+        virtual D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC STDMETHODCALLTYPE GetOutputStreamDesc( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoProcessorVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoProcessor * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoProcessor * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoProcessor * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoProcessor * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoProcessor * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoProcessor * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoProcessor * This,
+            _In_z_  LPCWSTR Name);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoProcessor * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        UINT ( STDMETHODCALLTYPE *GetNodeMask )( 
+            ID3D12VideoProcessor * This);
+        
+        UINT ( STDMETHODCALLTYPE *GetNumInputStreamDescs )( 
+            ID3D12VideoProcessor * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetInputStreamDescs )( 
+            ID3D12VideoProcessor * This,
+            UINT NumInputStreamDescs,
+            _Out_writes_(NumInputStreamDescs)  D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs);
+        
+        D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC ( STDMETHODCALLTYPE *GetOutputStreamDesc )( 
+            ID3D12VideoProcessor * This);
+        
+        END_INTERFACE
+    } ID3D12VideoProcessorVtbl;
+
+    interface ID3D12VideoProcessor
+    {
+        CONST_VTBL struct ID3D12VideoProcessorVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoProcessor_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoProcessor_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoProcessor_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoProcessor_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoProcessor_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoProcessor_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoProcessor_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoProcessor_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12VideoProcessor_GetNodeMask(This)	\
+    ( (This)->lpVtbl -> GetNodeMask(This) ) 
+
+#define ID3D12VideoProcessor_GetNumInputStreamDescs(This)	\
+    ( (This)->lpVtbl -> GetNumInputStreamDescs(This) ) 
+
+#define ID3D12VideoProcessor_GetInputStreamDescs(This,NumInputStreamDescs,pInputStreamDescs)	\
+    ( (This)->lpVtbl -> GetInputStreamDescs(This,NumInputStreamDescs,pInputStreamDescs) ) 
+
+#define ID3D12VideoProcessor_GetOutputStreamDesc(This)	\
+    ( (This)->lpVtbl -> GetOutputStreamDesc(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoProcessor_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0004 */
+/* [local] */ 
+
+typedef 
+enum D3D12_VIDEO_PROCESS_FEATURE_FLAGS
+    {
+        D3D12_VIDEO_PROCESS_FEATURE_FLAG_NONE	= 0,
+        D3D12_VIDEO_PROCESS_FEATURE_FLAG_ALPHA_FILL	= 0x1,
+        D3D12_VIDEO_PROCESS_FEATURE_FLAG_LUMA_KEY	= 0x2,
+        D3D12_VIDEO_PROCESS_FEATURE_FLAG_STEREO	= 0x4,
+        D3D12_VIDEO_PROCESS_FEATURE_FLAG_ROTATION	= 0x8,
+        D3D12_VIDEO_PROCESS_FEATURE_FLAG_FLIP	= 0x10,
+        D3D12_VIDEO_PROCESS_FEATURE_FLAG_ALPHA_BLENDING	= 0x20,
+        D3D12_VIDEO_PROCESS_FEATURE_FLAG_PIXEL_ASPECT_RATIO	= 0x40
+    } 	D3D12_VIDEO_PROCESS_FEATURE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_FEATURE_FLAGS );
+typedef 
+enum D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS
+    {
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_NONE	= 0,
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_DENOISE	= 0x1,
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_DERINGING	= 0x2,
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_EDGE_ENHANCEMENT	= 0x4,
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_COLOR_CORRECTION	= 0x8,
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_FLESH_TONE_MAPPING	= 0x10,
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_IMAGE_STABILIZATION	= 0x20,
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_SUPER_RESOLUTION	= 0x40,
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_ANAMORPHIC_SCALING	= 0x80,
+        D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAG_CUSTOM	= 0x80000000
+    } 	D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS );
+typedef 
+enum D3D12_VIDEO_PROCESS_ORIENTATION
+    {
+        D3D12_VIDEO_PROCESS_ORIENTATION_DEFAULT	= 0,
+        D3D12_VIDEO_PROCESS_ORIENTATION_FLIP_HORIZONTAL	= 1,
+        D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_90	= 2,
+        D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_90_FLIP_HORIZONTAL	= 3,
+        D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_180	= 4,
+        D3D12_VIDEO_PROCESS_ORIENTATION_FLIP_VERTICAL	= 5,
+        D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_270	= 6,
+        D3D12_VIDEO_PROCESS_ORIENTATION_CLOCKWISE_270_FLIP_HORIZONTAL	= 7
+    } 	D3D12_VIDEO_PROCESS_ORIENTATION;
+
+typedef 
+enum D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS
+    {
+        D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAG_NONE	= 0,
+        D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAG_FRAME_DISCONTINUITY	= 0x1,
+        D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAG_FRAME_REPEAT	= 0x2
+    } 	D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS );
+typedef struct D3D12_VIDEO_PROCESS_FILTER_RANGE
+    {
+    INT Minimum;
+    INT Maximum;
+    INT Default;
+    FLOAT Multiplier;
+    } 	D3D12_VIDEO_PROCESS_FILTER_RANGE;
+
+typedef 
+enum D3D12_VIDEO_PROCESS_SUPPORT_FLAGS
+    {
+        D3D12_VIDEO_PROCESS_SUPPORT_FLAG_NONE	= 0,
+        D3D12_VIDEO_PROCESS_SUPPORT_FLAG_SUPPORTED	= 0x1
+    } 	D3D12_VIDEO_PROCESS_SUPPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROCESS_SUPPORT_FLAGS );
+typedef struct D3D12_FEATURE_DATA_VIDEO_PROCESS_SUPPORT
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_SAMPLE InputSample;
+    D3D12_VIDEO_FIELD_TYPE InputFieldType;
+    D3D12_VIDEO_FRAME_STEREO_FORMAT InputStereoFormat;
+    DXGI_RATIONAL InputFrameRate;
+    D3D12_VIDEO_FORMAT OutputFormat;
+    D3D12_VIDEO_FRAME_STEREO_FORMAT OutputStereoFormat;
+    DXGI_RATIONAL OutputFrameRate;
+    D3D12_VIDEO_PROCESS_SUPPORT_FLAGS SupportFlags;
+    D3D12_VIDEO_SCALE_SUPPORT ScaleSupport;
+    D3D12_VIDEO_PROCESS_FEATURE_FLAGS FeatureSupport;
+    D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS DeinterlaceSupport;
+    D3D12_VIDEO_PROCESS_AUTO_PROCESSING_FLAGS AutoProcessingSupport;
+    D3D12_VIDEO_PROCESS_FILTER_FLAGS FilterSupport;
+    D3D12_VIDEO_PROCESS_FILTER_RANGE FilterRangeSupport[ 32 ];
+    } 	D3D12_FEATURE_DATA_VIDEO_PROCESS_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_PROCESS_MAX_INPUT_STREAMS
+    {
+    UINT NodeIndex;
+    UINT MaxInputStreams;
+    } 	D3D12_FEATURE_DATA_VIDEO_PROCESS_MAX_INPUT_STREAMS;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_PROCESS_REFERENCE_INFO
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_PROCESS_DEINTERLACE_FLAGS DeinterlaceMode;
+    D3D12_VIDEO_PROCESS_FILTER_FLAGS Filters;
+    D3D12_VIDEO_PROCESS_FEATURE_FLAGS FeatureSupport;
+    DXGI_RATIONAL InputFrameRate;
+    DXGI_RATIONAL OutputFrameRate;
+    BOOL EnableAutoProcessing;
+    UINT PastFrames;
+    UINT FutureFrames;
+    } 	D3D12_FEATURE_DATA_VIDEO_PROCESS_REFERENCE_INFO;
+
+typedef struct D3D12_VIDEO_PROCESS_REFERENCE_SET
+    {
+    UINT NumPastFrames;
+    ID3D12Resource **ppPastFrames;
+    UINT *pPastSubresources;
+    UINT NumFutureFrames;
+    ID3D12Resource **ppFutureFrames;
+    UINT *pFutureSubresources;
+    } 	D3D12_VIDEO_PROCESS_REFERENCE_SET;
+
+typedef struct D3D12_VIDEO_PROCESS_TRANSFORM
+    {
+    D3D12_RECT SourceRectangle;
+    D3D12_RECT DestinationRectangle;
+    D3D12_VIDEO_PROCESS_ORIENTATION Orientation;
+    } 	D3D12_VIDEO_PROCESS_TRANSFORM;
+
+typedef struct D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE
+    {
+    UINT OutputIndex;
+    UINT InputFrameOrField;
+    } 	D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE;
+
+typedef struct D3D12_VIDEO_PROCESS_INPUT_STREAM
+    {
+    ID3D12Resource *pTexture2D;
+    UINT Subresource;
+    D3D12_VIDEO_PROCESS_REFERENCE_SET ReferenceSet;
+    } 	D3D12_VIDEO_PROCESS_INPUT_STREAM;
+
+typedef struct D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS
+    {
+    D3D12_VIDEO_PROCESS_INPUT_STREAM InputStream[ 2 ];
+    D3D12_VIDEO_PROCESS_TRANSFORM Transform;
+    D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS Flags;
+    D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE RateInfo;
+    INT FilterLevels[ 32 ];
+    D3D12_VIDEO_PROCESS_ALPHA_BLENDING AlphaBlending;
+    } 	D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS;
+
+typedef struct D3D12_VIDEO_PROCESS_OUTPUT_STREAM
+    {
+    ID3D12Resource *pTexture2D;
+    UINT Subresource;
+    } 	D3D12_VIDEO_PROCESS_OUTPUT_STREAM;
+
+typedef struct D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS
+    {
+    D3D12_VIDEO_PROCESS_OUTPUT_STREAM OutputStream[ 2 ];
+    D3D12_RECT TargetRectangle;
+    } 	D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0004_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0004_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoDecodeCommandList_INTERFACE_DEFINED__
+#define __ID3D12VideoDecodeCommandList_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDecodeCommandList */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDecodeCommandList;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("3B60536E-AD29-4E64-A269-F853837E5E53")
+    ID3D12VideoDecodeCommandList : public ID3D12CommandList
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE Close( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( 
+            _In_  ID3D12CommandAllocator *pAllocator) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearState( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResourceBarrier( 
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers) = 0;
+        
+        virtual void STDMETHODCALLTYPE DiscardResource( 
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion) = 0;
+        
+        virtual void STDMETHODCALLTYPE BeginQuery( 
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index) = 0;
+        
+        virtual void STDMETHODCALLTYPE EndQuery( 
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResolveQueryData( 
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetPredication( 
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetMarker( 
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size) = 0;
+        
+        virtual void STDMETHODCALLTYPE BeginEvent( 
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size) = 0;
+        
+        virtual void STDMETHODCALLTYPE EndEvent( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE DecodeFrame( 
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments) = 0;
+        
+        virtual void STDMETHODCALLTYPE WriteBufferImmediate( 
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecodeCommandListVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecodeCommandList * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecodeCommandList * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecodeCommandList * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_z_  LPCWSTR Name);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecodeCommandList * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoDecodeCommandList * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoDecodeCommandList * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoDecodeCommandList * This);
+        
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoDecodeCommandList * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoDecodeCommandList * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoDecodeCommandList * This);
+        
+        void ( STDMETHODCALLTYPE *DecodeFrame )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoDecodeCommandList * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        END_INTERFACE
+    } ID3D12VideoDecodeCommandListVtbl;
+
+    interface ID3D12VideoDecodeCommandList
+    {
+        CONST_VTBL struct ID3D12VideoDecodeCommandListVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDecodeCommandList_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDecodeCommandList_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDecodeCommandList_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDecodeCommandList_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoDecodeCommandList_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoDecodeCommandList_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoDecodeCommandList_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoDecodeCommandList_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoDecodeCommandList_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoDecodeCommandList_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoDecodeCommandList_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoDecodeCommandList_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoDecodeCommandList_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoDecodeCommandList_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoDecodeCommandList_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoDecodeCommandList_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoDecodeCommandList_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoDecodeCommandList_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoDecodeCommandList_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoDecodeCommandList_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoDecodeCommandList_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoDecodeCommandList_DecodeFrame(This,pDecoder,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> DecodeFrame(This,pDecoder,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoDecodeCommandList_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDecodeCommandList_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessCommandList_INTERFACE_DEFINED__
+#define __ID3D12VideoProcessCommandList_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoProcessCommandList */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoProcessCommandList;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("AEB2543A-167F-4682-ACC8-D159ED4A6209")
+    ID3D12VideoProcessCommandList : public ID3D12CommandList
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE Close( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Reset( 
+            _In_  ID3D12CommandAllocator *pAllocator) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearState( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResourceBarrier( 
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers) = 0;
+        
+        virtual void STDMETHODCALLTYPE DiscardResource( 
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion) = 0;
+        
+        virtual void STDMETHODCALLTYPE BeginQuery( 
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index) = 0;
+        
+        virtual void STDMETHODCALLTYPE EndQuery( 
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResolveQueryData( 
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetPredication( 
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetMarker( 
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size) = 0;
+        
+        virtual void STDMETHODCALLTYPE BeginEvent( 
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size) = 0;
+        
+        virtual void STDMETHODCALLTYPE EndEvent( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE ProcessFrames( 
+            _In_  ID3D12VideoProcessor *pVideoProcessor,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            UINT NumInputStreams,
+            _In_reads_(NumInputStreams)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS *pInputArguments) = 0;
+        
+        virtual void STDMETHODCALLTYPE WriteBufferImmediate( 
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoProcessCommandListVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoProcessCommandList * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoProcessCommandList * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoProcessCommandList * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_z_  LPCWSTR Name);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoProcessCommandList * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoProcessCommandList * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoProcessCommandList * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoProcessCommandList * This);
+        
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoProcessCommandList * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoProcessCommandList * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoProcessCommandList * This);
+        
+        void ( STDMETHODCALLTYPE *ProcessFrames )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  ID3D12VideoProcessor *pVideoProcessor,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            UINT NumInputStreams,
+            _In_reads_(NumInputStreams)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoProcessCommandList * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        END_INTERFACE
+    } ID3D12VideoProcessCommandListVtbl;
+
+    interface ID3D12VideoProcessCommandList
+    {
+        CONST_VTBL struct ID3D12VideoProcessCommandListVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoProcessCommandList_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoProcessCommandList_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoProcessCommandList_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoProcessCommandList_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoProcessCommandList_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoProcessCommandList_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoProcessCommandList_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoProcessCommandList_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoProcessCommandList_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoProcessCommandList_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoProcessCommandList_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoProcessCommandList_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoProcessCommandList_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoProcessCommandList_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoProcessCommandList_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoProcessCommandList_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoProcessCommandList_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoProcessCommandList_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoProcessCommandList_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoProcessCommandList_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoProcessCommandList_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoProcessCommandList_ProcessFrames(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments)	\
+    ( (This)->lpVtbl -> ProcessFrames(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments) ) 
+
+#define ID3D12VideoProcessCommandList_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoProcessCommandList_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0006 */
+/* [local] */ 
+
+typedef struct D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM
+    {
+    UINT64 Offset;
+    ID3D12Resource *pBuffer;
+    } 	D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM;
+
+typedef struct D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1
+    {
+    BOOL Enable;
+    ID3D12Resource *pReferenceTexture2D;
+    UINT ReferenceSubresource;
+    DXGI_COLOR_SPACE_TYPE OutputColorSpace;
+    DXGI_COLOR_SPACE_TYPE DecodeColorSpace;
+    UINT OutputWidth;
+    UINT OutputHeight;
+    } 	D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1;
+
+typedef struct D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1
+    {
+    ID3D12Resource *pOutputTexture2D;
+    UINT OutputSubresource;
+    D3D12_VIDEO_DECODE_CONVERSION_ARGUMENTS1 ConversionArguments;
+    D3D12_VIDEO_DECODE_OUTPUT_HISTOGRAM Histograms[ 4 ];
+    } 	D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0006_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0006_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoDecodeCommandList1_INTERFACE_DEFINED__
+#define __ID3D12VideoDecodeCommandList1_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDecodeCommandList1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDecodeCommandList1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("D52F011B-B56E-453C-A05A-A7F311C8F472")
+    ID3D12VideoDecodeCommandList1 : public ID3D12VideoDecodeCommandList
+    {
+    public:
+        virtual void STDMETHODCALLTYPE DecodeFrame1( 
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecodeCommandList1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecodeCommandList1 * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecodeCommandList1 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoDecodeCommandList1 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoDecodeCommandList1 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoDecodeCommandList1 * This);
+        
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoDecodeCommandList1 * This);
+        
+        void ( STDMETHODCALLTYPE *DecodeFrame )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        void ( STDMETHODCALLTYPE *DecodeFrame1 )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        END_INTERFACE
+    } ID3D12VideoDecodeCommandList1Vtbl;
+
+    interface ID3D12VideoDecodeCommandList1
+    {
+        CONST_VTBL struct ID3D12VideoDecodeCommandList1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDecodeCommandList1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDecodeCommandList1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDecodeCommandList1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDecodeCommandList1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoDecodeCommandList1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoDecodeCommandList1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoDecodeCommandList1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoDecodeCommandList1_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoDecodeCommandList1_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoDecodeCommandList1_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoDecodeCommandList1_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoDecodeCommandList1_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoDecodeCommandList1_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoDecodeCommandList1_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoDecodeCommandList1_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoDecodeCommandList1_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoDecodeCommandList1_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoDecodeCommandList1_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoDecodeCommandList1_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoDecodeCommandList1_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoDecodeCommandList1_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoDecodeCommandList1_DecodeFrame(This,pDecoder,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> DecodeFrame(This,pDecoder,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoDecodeCommandList1_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+
+#define ID3D12VideoDecodeCommandList1_DecodeFrame1(This,pDecoder,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> DecodeFrame1(This,pDecoder,pOutputArguments,pInputArguments) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDecodeCommandList1_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0007 */
+/* [local] */ 
+
+typedef struct D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1
+    {
+    D3D12_VIDEO_PROCESS_INPUT_STREAM InputStream[ 2 ];
+    D3D12_VIDEO_PROCESS_TRANSFORM Transform;
+    D3D12_VIDEO_PROCESS_INPUT_STREAM_FLAGS Flags;
+    D3D12_VIDEO_PROCESS_INPUT_STREAM_RATE RateInfo;
+    INT FilterLevels[ 32 ];
+    D3D12_VIDEO_PROCESS_ALPHA_BLENDING AlphaBlending;
+    D3D12_VIDEO_FIELD_TYPE FieldType;
+    } 	D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0007_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0007_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoProcessCommandList1_INTERFACE_DEFINED__
+#define __ID3D12VideoProcessCommandList1_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoProcessCommandList1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoProcessCommandList1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("542C5C4D-7596-434F-8C93-4EFA6766F267")
+    ID3D12VideoProcessCommandList1 : public ID3D12VideoProcessCommandList
+    {
+    public:
+        virtual void STDMETHODCALLTYPE ProcessFrames1( 
+            _In_  ID3D12VideoProcessor *pVideoProcessor,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            UINT NumInputStreams,
+            _In_reads_(NumInputStreams)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1 *pInputArguments) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoProcessCommandList1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoProcessCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoProcessCommandList1 * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoProcessCommandList1 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoProcessCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoProcessCommandList1 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoProcessCommandList1 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoProcessCommandList1 * This);
+        
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoProcessCommandList1 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoProcessCommandList1 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoProcessCommandList1 * This);
+        
+        void ( STDMETHODCALLTYPE *ProcessFrames )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  ID3D12VideoProcessor *pVideoProcessor,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            UINT NumInputStreams,
+            _In_reads_(NumInputStreams)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoProcessCommandList1 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        void ( STDMETHODCALLTYPE *ProcessFrames1 )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  ID3D12VideoProcessor *pVideoProcessor,
+            _In_  const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            UINT NumInputStreams,
+            _In_reads_(NumInputStreams)  const D3D12_VIDEO_PROCESS_INPUT_STREAM_ARGUMENTS1 *pInputArguments);
+        
+        END_INTERFACE
+    } ID3D12VideoProcessCommandList1Vtbl;
+
+    interface ID3D12VideoProcessCommandList1
+    {
+        CONST_VTBL struct ID3D12VideoProcessCommandList1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoProcessCommandList1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoProcessCommandList1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoProcessCommandList1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoProcessCommandList1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoProcessCommandList1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoProcessCommandList1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoProcessCommandList1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoProcessCommandList1_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoProcessCommandList1_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoProcessCommandList1_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoProcessCommandList1_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoProcessCommandList1_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoProcessCommandList1_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoProcessCommandList1_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoProcessCommandList1_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoProcessCommandList1_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoProcessCommandList1_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoProcessCommandList1_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoProcessCommandList1_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoProcessCommandList1_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoProcessCommandList1_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoProcessCommandList1_ProcessFrames(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments)	\
+    ( (This)->lpVtbl -> ProcessFrames(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments) ) 
+
+#define ID3D12VideoProcessCommandList1_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+
+#define ID3D12VideoProcessCommandList1_ProcessFrames1(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments)	\
+    ( (This)->lpVtbl -> ProcessFrames1(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoProcessCommandList1_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0008 */
+/* [local] */ 
+
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MPEG2, 0xee27417f, 0x5e28, 0x4e65, 0xbe, 0xea, 0x1d, 0x26, 0xb5, 0x08, 0xad, 0xc9); 
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MPEG1_AND_MPEG2, 0x86695f12, 0x340e, 0x4f04, 0x9f, 0xd3, 0x92, 0x53, 0xdd, 0x32, 0x74, 0x60); 
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_H264, 0x1b81be68, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_H264_STEREO_PROGRESSIVE, 0xd79be8da, 0x0cf1, 0x4c81, 0xb8, 0x2a, 0x69, 0xa4, 0xe2, 0x36, 0xf4, 0x3d);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_H264_STEREO, 0xf9aaccbb, 0xc2b6, 0x4cfc, 0x87, 0x79, 0x57, 0x07, 0xb1, 0x76, 0x05, 0x52);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_H264_MULTIVIEW, 0x705b9d82, 0x76cf, 0x49d6, 0xb7, 0xe6, 0xac, 0x88, 0x72, 0xdb, 0x01, 0x3c);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VC1, 0x1b81beA3, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VC1_D2010, 0x1b81beA4, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MPEG4PT2_SIMPLE, 0xefd64d74, 0xc9e8,0x41d7,0xa5,0xe9,0xe9,0xb0,0xe3,0x9f,0xa3,0x19);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_MPEG4PT2_ADVSIMPLE_NOGMC, 0xed418a9f, 0x010d, 0x4eda, 0x9a, 0xe3, 0x9a, 0x65, 0x35, 0x8d, 0x8d, 0x2e);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN, 0x5b11d51b, 0x2f4c, 0x4452, 0xbc, 0xc3, 0x09, 0xf2, 0xa1, 0x16, 0x0c, 0xc0);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_HEVC_MAIN10, 0x107af0e0, 0xef1a, 0x4d19, 0xab, 0xa8, 0x67, 0xa1, 0x63, 0x07, 0x3d, 0x13);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VP9, 0x463707f8, 0xa1d0, 0x4585, 0x87, 0x6d, 0x83, 0xaa, 0x6d, 0x60, 0xb8, 0x9e);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VP9_10BIT_PROFILE2, 0xa4c749ef, 0x6ecf, 0x48aa, 0x84, 0x48, 0x50, 0xa7, 0xa1, 0x16, 0x5f, 0xf7);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_VP8, 0x90b899ea, 0x3a62, 0x4705, 0x88, 0xb3, 0x8d, 0xf0, 0x4b, 0x27, 0x44, 0xe7);
+#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */
+#pragma endregion
+DEFINE_GUID(IID_ID3D12VideoDecoderHeap,0x0946B7C9,0xEBF6,0x4047,0xBB,0x73,0x86,0x83,0xE2,0x7D,0xBB,0x1F);
+DEFINE_GUID(IID_ID3D12VideoDevice,0x1F052807,0x0B46,0x4ACC,0x8A,0x89,0x36,0x4F,0x79,0x37,0x18,0xA4);
+DEFINE_GUID(IID_ID3D12VideoDecoder,0xC59B6BDC,0x7720,0x4074,0xA1,0x36,0x17,0xA1,0x56,0x03,0x74,0x70);
+DEFINE_GUID(IID_ID3D12VideoProcessor,0x304FDB32,0xBEDE,0x410A,0x85,0x45,0x94,0x3A,0xC6,0xA4,0x61,0x38);
+DEFINE_GUID(IID_ID3D12VideoDecodeCommandList,0x3B60536E,0xAD29,0x4E64,0xA2,0x69,0xF8,0x53,0x83,0x7E,0x5E,0x53);
+DEFINE_GUID(IID_ID3D12VideoProcessCommandList,0xAEB2543A,0x167F,0x4682,0xAC,0xC8,0xD1,0x59,0xED,0x4A,0x62,0x09);
+DEFINE_GUID(IID_ID3D12VideoDecodeCommandList1,0xD52F011B,0xB56E,0x453C,0xA0,0x5A,0xA7,0xF3,0x11,0xC8,0xF4,0x72);
+DEFINE_GUID(IID_ID3D12VideoProcessCommandList1,0x542C5C4D,0x7596,0x434F,0x8C,0x93,0x4E,0xFA,0x67,0x66,0xF2,0x67);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0008_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0008_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+

3rdparty/dxsdk/include/d3d9.h

@@ -2021,8 +2021,8 @@ typedef struct IDirect3DQuery9 *LPDIRECT3DQUERY9, *PDIRECT3DQUERY9;
 
 
 /*********************
- * D3D9Ex interfaces
- *********************/
+/* D3D9Ex interfaces
+/*********************/
 
 HRESULT WINAPI Direct3DCreate9Ex(UINT SDKVersion, IDirect3D9Ex**);
 

3rdparty/dxsdk/include/d3d9types.h

@@ -10,6 +10,7 @@
 #ifndef _d3d9TYPES_H_
 #define _d3d9TYPES_H_
 
+
 #ifndef DIRECT3D_VERSION
 #define DIRECT3D_VERSION         0x0900
 #endif  //DIRECT3D_VERSION
@@ -78,6 +79,8 @@ typedef struct _D3DRECT {
 #define D3DRECT_DEFINED
 #endif
 
+
+
 #ifndef D3DMATRIX_DEFINED
 typedef struct _D3DMATRIX {
     union {
@@ -94,6 +97,8 @@ typedef struct _D3DMATRIX {
 #define D3DMATRIX_DEFINED
 #endif
 
+
+
 typedef struct _D3DVIEWPORT9 {
     DWORD       X;
     DWORD       Y;            /* Viewport Top left */
@@ -1166,6 +1171,24 @@ typedef enum _D3DSHADER_PARAM_SRCMOD_TYPE
     D3DSPSM_FORCE_DWORD = 0x7fffffff,        // force 32-bit size enum
 } D3DSHADER_PARAM_SRCMOD_TYPE;
 
+// Source or dest token bits [15:14]:
+// destination parameter modifiers
+#define D3DSP_MIN_PRECISION_SHIFT      14
+#define D3DSP_MIN_PRECISION_MASK       0x0000C000
+
+typedef enum _D3DSHADER_MIN_PRECISION
+{
+    D3DMP_DEFAULT   = 0, // Default precision for the shader model
+    D3DMP_16        = 1, // 16 bit per component
+    D3DMP_2_8       = 2, // 10 bits (2.8) per component
+} D3DSHADER_MIN_PRECISION;
+// If the older D3DSPDM_PARTIALPRECISION is set,
+// that is equivalent to the whole operation specifying
+// D3DMP_16 (on all operands).  The two encodings are not 
+// used together however.
+
+
+
 // pixel shader version token
 #define D3DPS_VERSION(_Major,_Minor) (0xFFFF0000|((_Major)<<8)|(_Minor))
 
@@ -1641,6 +1664,7 @@ typedef enum _D3DRESOURCETYPE {
 
 
 
+
 /* CubeMap Face identifiers */
 typedef enum _D3DCUBEMAP_FACES
 {

3rdparty/dxsdk/include/d3dcommon.h

@@ -3,7 +3,7 @@
 /* this ALWAYS GENERATED file contains the definitions for the interfaces */
 
 
- /* File created by MIDL compiler version 8.00.0613 */
+ /* File created by MIDL compiler version 8.01.0622 */
 /* @@MIDL_FILE_HEADING(  ) */
 
 
@@ -100,6 +100,13 @@ typedef interface ID3D10Blob ID3D10Blob;
 #endif 	/* __ID3D10Blob_FWD_DEFINED__ */
 
 
+#ifndef __ID3DDestructionNotifier_FWD_DEFINED__
+#define __ID3DDestructionNotifier_FWD_DEFINED__
+typedef interface ID3DDestructionNotifier ID3DDestructionNotifier;
+
+#endif 	/* __ID3DDestructionNotifier_FWD_DEFINED__ */
+
+
 /* header files for imported files */
 #include "oaidl.h"
 #include "ocidl.h"
@@ -496,6 +503,119 @@ typedef ID3D10Blob ID3DBlob;
 
 typedef ID3DBlob* LPD3DBLOB;
 #define IID_ID3DBlob IID_ID3D10Blob
+typedef void ( __stdcall *PFN_DESTRUCTION_CALLBACK )( 
+    void *pData);
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0001_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0001_v0_0_s_ifspec;
+
+#ifndef __ID3DDestructionNotifier_INTERFACE_DEFINED__
+#define __ID3DDestructionNotifier_INTERFACE_DEFINED__
+
+/* interface ID3DDestructionNotifier */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3DDestructionNotifier;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("a06eb39a-50da-425b-8c31-4eecd6c270f3")
+    ID3DDestructionNotifier : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE RegisterDestructionCallback( 
+            /* [annotation] */ 
+            _In_  PFN_DESTRUCTION_CALLBACK callbackFn,
+            /* [annotation] */ 
+            _In_  void *pData,
+            /* [annotation] */ 
+            _Out_  UINT *pCallbackID) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE UnregisterDestructionCallback( 
+            /* [annotation] */ 
+            _In_  UINT callbackID) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3DDestructionNotifierVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3DDestructionNotifier * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3DDestructionNotifier * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3DDestructionNotifier * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *RegisterDestructionCallback )( 
+            ID3DDestructionNotifier * This,
+            /* [annotation] */ 
+            _In_  PFN_DESTRUCTION_CALLBACK callbackFn,
+            /* [annotation] */ 
+            _In_  void *pData,
+            /* [annotation] */ 
+            _Out_  UINT *pCallbackID);
+        
+        HRESULT ( STDMETHODCALLTYPE *UnregisterDestructionCallback )( 
+            ID3DDestructionNotifier * This,
+            /* [annotation] */ 
+            _In_  UINT callbackID);
+        
+        END_INTERFACE
+    } ID3DDestructionNotifierVtbl;
+
+    interface ID3DDestructionNotifier
+    {
+        CONST_VTBL struct ID3DDestructionNotifierVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3DDestructionNotifier_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3DDestructionNotifier_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3DDestructionNotifier_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3DDestructionNotifier_RegisterDestructionCallback(This,callbackFn,pData,pCallbackID)	\
+    ( (This)->lpVtbl -> RegisterDestructionCallback(This,callbackFn,pData,pCallbackID) ) 
+
+#define ID3DDestructionNotifier_UnregisterDestructionCallback(This,callbackID)	\
+    ( (This)->lpVtbl -> UnregisterDestructionCallback(This,callbackID) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3DDestructionNotifier_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3dcommon_0000_0002 */
+/* [local] */ 
+
 typedef 
 enum _D3D_INCLUDE_TYPE
     {
@@ -920,8 +1040,8 @@ DEFINE_GUID(WKPDID_CommentStringW,0xd0149dc0,0x90e8,0x4ec8,0x81, 0x44, 0xe9, 0x0
 #define D3D_COMPONENT_MASK_W   8
 
 
-extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0001_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0001_v0_0_s_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0002_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0002_v0_0_s_ifspec;
 
 /* Additional Prototypes for ALL interfaces */
 

3rdparty/dxsdk/include/d3dcompiler.h

@@ -173,6 +173,14 @@ D3DWriteBlobToFile(_In_ ID3DBlob* pBlob,
 #define D3DCOMPILE_EFFECT_CHILD_EFFECT              (1 << 0)
 #define D3DCOMPILE_EFFECT_ALLOW_SLOW_OPS            (1 << 1)
 
+//----------------------------------------------------------------------------
+// D3DCOMPILE Flags2:
+// -----------------
+// Root signature flags. (passed in Flags2)
+#define D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_LATEST		0
+#define D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_1_0			(1 << 4)
+#define D3DCOMPILE_FLAGS2_FORCE_ROOT_SIGNATURE_1_1			(1 << 5)
+
 //----------------------------------------------------------------------------
 // D3DCompile:
 // ----------
@@ -303,9 +311,9 @@ D3DReflect(_In_reads_bytes_(SrcDataSize) LPCVOID pSrcData,
 
 HRESULT WINAPI
 D3DReflectLibrary(__in_bcount(SrcDataSize) LPCVOID pSrcData,
-                  SIZE_T SrcDataSize,
-	              REFIID riid,
-                  LPVOID * ppReflector);
+                  __in SIZE_T SrcDataSize,
+	              __in REFIID riid,
+                  __out LPVOID * ppReflector);
 
 //----------------------------------------------------------------------------
 // D3DDisassemble:
@@ -350,7 +358,7 @@ D3DDisassembleRegion(_In_reads_bytes_(SrcDataSize) LPCVOID pSrcData,
 // Shader linking and Function Linking Graph (FLG) APIs
 //----------------------------------------------------------------------------
 HRESULT WINAPI
-D3DCreateLinker(interface ID3D11Linker ** ppLinker);
+D3DCreateLinker(__out interface ID3D11Linker ** ppLinker);
 
 HRESULT WINAPI
 D3DLoadModule(_In_ LPCVOID pSrcData,

3rdparty/dxsdk/include/dxva2api.h

@@ -0,0 +1,1945 @@
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 8.01.0622 */
+/* @@MIDL_FILE_HEADING(  ) */
+
+
+
+/* verify that the <rpcndr.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 500
+#endif
+
+/* verify that the <rpcsal.h> version is high enough to compile this file*/
+#ifndef __REQUIRED_RPCSAL_H_VERSION__
+#define __REQUIRED_RPCSAL_H_VERSION__ 100
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error this stub requires an updated version of <rpcndr.h>
+#endif /* __RPCNDR_H_VERSION__ */
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#ifndef __dxva2api_h__
+#define __dxva2api_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+/* Forward Declarations */ 
+
+#ifndef __IDirect3DDeviceManager9_FWD_DEFINED__
+#define __IDirect3DDeviceManager9_FWD_DEFINED__
+typedef interface IDirect3DDeviceManager9 IDirect3DDeviceManager9;
+
+#endif 	/* __IDirect3DDeviceManager9_FWD_DEFINED__ */
+
+
+#ifndef __IDirectXVideoAccelerationService_FWD_DEFINED__
+#define __IDirectXVideoAccelerationService_FWD_DEFINED__
+typedef interface IDirectXVideoAccelerationService IDirectXVideoAccelerationService;
+
+#endif 	/* __IDirectXVideoAccelerationService_FWD_DEFINED__ */
+
+
+#ifndef __IDirectXVideoDecoderService_FWD_DEFINED__
+#define __IDirectXVideoDecoderService_FWD_DEFINED__
+typedef interface IDirectXVideoDecoderService IDirectXVideoDecoderService;
+
+#endif 	/* __IDirectXVideoDecoderService_FWD_DEFINED__ */
+
+
+#ifndef __IDirectXVideoProcessorService_FWD_DEFINED__
+#define __IDirectXVideoProcessorService_FWD_DEFINED__
+typedef interface IDirectXVideoProcessorService IDirectXVideoProcessorService;
+
+#endif 	/* __IDirectXVideoProcessorService_FWD_DEFINED__ */
+
+
+#ifndef __IDirectXVideoDecoder_FWD_DEFINED__
+#define __IDirectXVideoDecoder_FWD_DEFINED__
+typedef interface IDirectXVideoDecoder IDirectXVideoDecoder;
+
+#endif 	/* __IDirectXVideoDecoder_FWD_DEFINED__ */
+
+
+#ifndef __IDirectXVideoProcessor_FWD_DEFINED__
+#define __IDirectXVideoProcessor_FWD_DEFINED__
+typedef interface IDirectXVideoProcessor IDirectXVideoProcessor;
+
+#endif 	/* __IDirectXVideoProcessor_FWD_DEFINED__ */
+
+
+#ifndef __IDirectXVideoMemoryConfiguration_FWD_DEFINED__
+#define __IDirectXVideoMemoryConfiguration_FWD_DEFINED__
+typedef interface IDirectXVideoMemoryConfiguration IDirectXVideoMemoryConfiguration;
+
+#endif 	/* __IDirectXVideoMemoryConfiguration_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "unknwn.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_dxva2api_0000_0000 */
+/* [local] */ 
+
+//
+//   The following declarations within the 'if 0' block are dummy typedefs used to make
+//   the evr.idl file build. The actual definitions are contained in d3d9.h
+//
+#if 0
+typedef DWORD IDirect3DDevice9;
+
+typedef DWORD IDirect3DSurface9;
+
+typedef DWORD D3DFORMAT;
+
+typedef DWORD D3DPOOL;
+
+#endif
+#ifndef DXVA2_API_DEFINED
+#define DXVA2_API_DEFINED
+DEFINE_GUID(DXVA2_ModeMPEG2_MoComp, 0xe6a9f44b, 0x61b0, 0x4563,0x9e,0xa4,0x63,0xd2,0xa3,0xc6,0xfe,0x66);
+DEFINE_GUID(DXVA2_ModeMPEG2_IDCT,   0xbf22ad00, 0x03ea, 0x4690,0x80,0x77,0x47,0x33,0x46,0x20,0x9b,0x7e);
+DEFINE_GUID(DXVA2_ModeMPEG2_VLD,    0xee27417f, 0x5e28, 0x4e65,0xbe,0xea,0x1d,0x26,0xb5,0x08,0xad,0xc9);
+DEFINE_GUID(DXVA2_ModeMPEG1_VLD,    0x6f3ec719, 0x3735, 0x42cc,0x80,0x63,0x65,0xcc,0x3c,0xb3,0x66,0x16);
+DEFINE_GUID(DXVA2_ModeMPEG2and1_VLD,0x86695f12, 0x340e, 0x4f04,0x9f,0xd3,0x92,0x53,0xdd,0x32,0x74,0x60);
+DEFINE_GUID(DXVA2_ModeH264_A,  0x1b81be64, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(DXVA2_ModeH264_B,  0x1b81be65, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(DXVA2_ModeH264_C,  0x1b81be66, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(DXVA2_ModeH264_D,  0x1b81be67, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(DXVA2_ModeH264_E,  0x1b81be68, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(DXVA2_ModeH264_F,  0x1b81be69, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(DXVA2_ModeH264_VLD_WithFMOASO_NoFGT,  0xd5f04ff9, 0x3418,0x45d8,0x95,0x61,0x32,0xa7,0x6a,0xae,0x2d,0xdd);
+DEFINE_GUID(DXVA2_ModeH264_VLD_Stereo_Progressive_NoFGT, 0xd79be8da, 0x0cf1,0x4c81,0xb8,0x2a,0x69,0xa4,0xe2,0x36,0xf4,0x3d);
+DEFINE_GUID(DXVA2_ModeH264_VLD_Stereo_NoFGT,             0xf9aaccbb, 0xc2b6,0x4cfc,0x87,0x79,0x57,0x07,0xb1,0x76,0x05,0x52);
+DEFINE_GUID(DXVA2_ModeH264_VLD_Multiview_NoFGT,          0x705b9d82, 0x76cf,0x49d6,0xb7,0xe6,0xac,0x88,0x72,0xdb,0x01,0x3c);
+DEFINE_GUID(DXVA2_ModeWMV8_A,  0x1b81be80, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(DXVA2_ModeWMV8_B,  0x1b81be81, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(DXVA2_ModeWMV9_A,  0x1b81be90, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(DXVA2_ModeWMV9_B,  0x1b81be91, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(DXVA2_ModeWMV9_C,  0x1b81be94, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(DXVA2_ModeVC1_A,   0x1b81beA0, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(DXVA2_ModeVC1_B,   0x1b81beA1, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(DXVA2_ModeVC1_C,   0x1b81beA2, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(DXVA2_ModeVC1_D,   0x1b81beA3, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(DXVA2_ModeVC1_D2010,0x1b81beA4, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(DXVA2_NoEncrypt,   0x1b81beD0, 0xa0c7,0x11d3,0xb9,0x84,0x00,0xc0,0x4f,0x2e,0x73,0xc5);
+DEFINE_GUID(DXVA2_VideoProcProgressiveDevice, 0x5a54a0c9,0xc7ec,0x4bd9,0x8e,0xde,0xf3,0xc7,0x5d,0xc4,0x39,0x3b);
+DEFINE_GUID(DXVA2_VideoProcBobDevice,         0x335aa36e,0x7884,0x43a4,0x9c,0x91,0x7f,0x87,0xfa,0xf3,0xe3,0x7e);
+DEFINE_GUID(DXVA2_VideoProcSoftwareDevice,    0x4553d47f,0xee7e,0x4e3f,0x94,0x75,0xdb,0xf1,0x37,0x6c,0x48,0x10);
+DEFINE_GUID(DXVA2_ModeMPEG4pt2_VLD_Simple,           0xefd64d74, 0xc9e8,0x41d7,0xa5,0xe9,0xe9,0xb0,0xe3,0x9f,0xa3,0x19);
+DEFINE_GUID(DXVA2_ModeMPEG4pt2_VLD_AdvSimple_NoGMC,  0xed418a9f, 0x010d,0x4eda,0x9a,0xe3,0x9a,0x65,0x35,0x8d,0x8d,0x2e);
+DEFINE_GUID(DXVA2_ModeMPEG4pt2_VLD_AdvSimple_GMC,    0xab998b5b, 0x4258,0x44a9,0x9f,0xeb,0x94,0xe5,0x97,0xa6,0xba,0xae);
+DEFINE_GUID(DXVA2_ModeHEVC_VLD_Main,    0x5b11d51b, 0x2f4c,0x4452,0xbc,0xc3,0x09,0xf2,0xa1,0x16,0x0c,0xc0);
+DEFINE_GUID(DXVA2_ModeHEVC_VLD_Main10,  0x107af0e0, 0xef1a,0x4d19,0xab,0xa8,0x67,0xa1,0x63,0x07,0x3d,0x13);
+DEFINE_GUID(DXVA2_ModeVP9_VLD_Profile0,       0x463707f8, 0xa1d0, 0x4585, 0x87, 0x6d, 0x83, 0xaa, 0x6d, 0x60, 0xb8, 0x9e);
+DEFINE_GUID(DXVA2_ModeVP9_VLD_10bit_Profile2, 0xa4c749ef, 0x6ecf, 0x48aa, 0x84, 0x48, 0x50, 0xa7, 0xa1, 0x16, 0x5f, 0xf7);
+DEFINE_GUID(DXVA2_ModeVP8_VLD,                0x90b899ea, 0x3a62, 0x4705, 0x88, 0xb3, 0x8d, 0xf0, 0x4b, 0x27, 0x44, 0xe7);
+#define DXVA2_ModeMPEG2_MOCOMP      DXVA2_ModeMPEG2_MoComp
+#define DXVA2_ModeWMV8_PostProc     DXVA2_ModeWMV8_A
+#define DXVA2_ModeWMV8_MoComp       DXVA2_ModeWMV8_B
+#define DXVA2_ModeWMV9_PostProc     DXVA2_ModeWMV9_A
+#define DXVA2_ModeWMV9_MoComp       DXVA2_ModeWMV9_B
+#define DXVA2_ModeWMV9_IDCT         DXVA2_ModeWMV9_C
+#define DXVA2_ModeVC1_PostProc      DXVA2_ModeVC1_A
+#define DXVA2_ModeVC1_MoComp        DXVA2_ModeVC1_B
+#define DXVA2_ModeVC1_IDCT          DXVA2_ModeVC1_C
+#define DXVA2_ModeVC1_VLD           DXVA2_ModeVC1_D
+#define DXVA2_ModeH264_MoComp_NoFGT DXVA2_ModeH264_A
+#define DXVA2_ModeH264_MoComp_FGT   DXVA2_ModeH264_B
+#define DXVA2_ModeH264_IDCT_NoFGT   DXVA2_ModeH264_C
+#define DXVA2_ModeH264_IDCT_FGT     DXVA2_ModeH264_D
+#define DXVA2_ModeH264_VLD_NoFGT    DXVA2_ModeH264_E
+#define DXVA2_ModeH264_VLD_FGT      DXVA2_ModeH264_F
+#define DXVA2_E_NOT_INITIALIZED     ((HRESULT)0x80041000L)
+#define DXVA2_E_NEW_VIDEO_DEVICE    ((HRESULT)0x80041001L)
+#define DXVA2_E_VIDEO_DEVICE_LOCKED ((HRESULT)0x80041002L)
+#define DXVA2_E_NOT_AVAILABLE       ((HRESULT)0x80041003L)
+#if defined(_WIN32) && !defined(_NO_COM)
+DEFINE_GUID(IID_IDirect3DDeviceManager9,          0xa0cade0f,0x06d5,0x4cf4,0xa1,0xc7,0xf3,0xcd,0xd7,0x25,0xaa,0x75);
+DEFINE_GUID(IID_IDirectXVideoAccelerationService, 0xfc51a550,0xd5e7,0x11d9,0xaf,0x55,0x00,0x05,0x4e,0x43,0xff,0x02);
+DEFINE_GUID(IID_IDirectXVideoDecoderService,      0xfc51a551,0xd5e7,0x11d9,0xaf,0x55,0x00,0x05,0x4e,0x43,0xff,0x02);
+DEFINE_GUID(IID_IDirectXVideoProcessorService,    0xfc51a552,0xd5e7,0x11d9,0xaf,0x55,0x00,0x05,0x4e,0x43,0xff,0x02);
+DEFINE_GUID(IID_IDirectXVideoDecoder,             0xf2b0810a,0xfd00,0x43c9,0x91,0x8c,0xdf,0x94,0xe2,0xd8,0xef,0x7d);
+DEFINE_GUID(IID_IDirectXVideoProcessor,           0x8c3a39f0,0x916e,0x4690,0x80,0x4f,0x4c,0x80,0x01,0x35,0x5d,0x25);
+DEFINE_GUID(IID_IDirectXVideoMemoryConfiguration, 0xb7f916dd,0xdb3b,0x49c1,0x84,0xd7,0xe4,0x5e,0xf9,0x9e,0xc7,0x26);
+#endif
+#ifndef MAX_DEINTERLACE_SURFACES
+#define MAX_DEINTERLACE_SURFACES 32
+#endif
+#ifndef MAX_SUBSTREAMS
+#define MAX_SUBSTREAMS 15
+#endif
+#pragma warning( push )
+#pragma warning( disable : 4201 ) // nonstandard extension used : nameless struct/union
+typedef struct _DXVA2_ExtendedFormat
+    {
+    union 
+        {
+        struct 
+            {
+            UINT SampleFormat	: 8;
+            UINT VideoChromaSubsampling	: 4;
+            UINT NominalRange	: 3;
+            UINT VideoTransferMatrix	: 3;
+            UINT VideoLighting	: 4;
+            UINT VideoPrimaries	: 5;
+            UINT VideoTransferFunction	: 5;
+            } 	;
+        UINT value;
+        } 	;
+    } 	DXVA2_ExtendedFormat;
+
+#pragma warning( pop )
+typedef 
+enum _DXVA2_SampleFormat
+    {
+        DXVA2_SampleFormatMask	= 0xff,
+        DXVA2_SampleUnknown	= 0,
+        DXVA2_SampleProgressiveFrame	= 2,
+        DXVA2_SampleFieldInterleavedEvenFirst	= 3,
+        DXVA2_SampleFieldInterleavedOddFirst	= 4,
+        DXVA2_SampleFieldSingleEven	= 5,
+        DXVA2_SampleFieldSingleOdd	= 6,
+        DXVA2_SampleSubStream	= 7
+    } 	DXVA2_SampleFormat;
+
+typedef 
+enum _DXVA2_VideoChromaSubSampling
+    {
+        DXVA2_VideoChromaSubsamplingMask	= 0xf,
+        DXVA2_VideoChromaSubsampling_Unknown	= 0,
+        DXVA2_VideoChromaSubsampling_ProgressiveChroma	= 0x8,
+        DXVA2_VideoChromaSubsampling_Horizontally_Cosited	= 0x4,
+        DXVA2_VideoChromaSubsampling_Vertically_Cosited	= 0x2,
+        DXVA2_VideoChromaSubsampling_Vertically_AlignedChromaPlanes	= 0x1,
+        DXVA2_VideoChromaSubsampling_MPEG2	= ( DXVA2_VideoChromaSubsampling_Horizontally_Cosited | DXVA2_VideoChromaSubsampling_Vertically_AlignedChromaPlanes ) ,
+        DXVA2_VideoChromaSubsampling_MPEG1	= DXVA2_VideoChromaSubsampling_Vertically_AlignedChromaPlanes,
+        DXVA2_VideoChromaSubsampling_DV_PAL	= ( DXVA2_VideoChromaSubsampling_Horizontally_Cosited | DXVA2_VideoChromaSubsampling_Vertically_Cosited ) ,
+        DXVA2_VideoChromaSubsampling_Cosited	= ( ( DXVA2_VideoChromaSubsampling_Horizontally_Cosited | DXVA2_VideoChromaSubsampling_Vertically_Cosited )  | DXVA2_VideoChromaSubsampling_Vertically_AlignedChromaPlanes ) 
+    } 	DXVA2_VideoChromaSubSampling;
+
+typedef 
+enum _DXVA2_NominalRange
+    {
+        DXVA2_NominalRangeMask	= 0x7,
+        DXVA2_NominalRange_Unknown	= 0,
+        DXVA2_NominalRange_Normal	= 1,
+        DXVA2_NominalRange_Wide	= 2,
+        DXVA2_NominalRange_0_255	= 1,
+        DXVA2_NominalRange_16_235	= 2,
+        DXVA2_NominalRange_48_208	= 3
+    } 	DXVA2_NominalRange;
+
+typedef 
+enum _DXVA2_VideoTransferMatrix
+    {
+        DXVA2_VideoTransferMatrixMask	= 0x7,
+        DXVA2_VideoTransferMatrix_Unknown	= 0,
+        DXVA2_VideoTransferMatrix_BT709	= 1,
+        DXVA2_VideoTransferMatrix_BT601	= 2,
+        DXVA2_VideoTransferMatrix_SMPTE240M	= 3
+    } 	DXVA2_VideoTransferMatrix;
+
+typedef 
+enum _DXVA2_VideoLighting
+    {
+        DXVA2_VideoLightingMask	= 0xf,
+        DXVA2_VideoLighting_Unknown	= 0,
+        DXVA2_VideoLighting_bright	= 1,
+        DXVA2_VideoLighting_office	= 2,
+        DXVA2_VideoLighting_dim	= 3,
+        DXVA2_VideoLighting_dark	= 4
+    } 	DXVA2_VideoLighting;
+
+typedef 
+enum _DXVA2_VideoPrimaries
+    {
+        DXVA2_VideoPrimariesMask	= 0x1f,
+        DXVA2_VideoPrimaries_Unknown	= 0,
+        DXVA2_VideoPrimaries_reserved	= 1,
+        DXVA2_VideoPrimaries_BT709	= 2,
+        DXVA2_VideoPrimaries_BT470_2_SysM	= 3,
+        DXVA2_VideoPrimaries_BT470_2_SysBG	= 4,
+        DXVA2_VideoPrimaries_SMPTE170M	= 5,
+        DXVA2_VideoPrimaries_SMPTE240M	= 6,
+        DXVA2_VideoPrimaries_EBU3213	= 7,
+        DXVA2_VideoPrimaries_SMPTE_C	= 8
+    } 	DXVA2_VideoPrimaries;
+
+typedef 
+enum _DXVA2_VideoTransferFunction
+    {
+        DXVA2_VideoTransFuncMask	= 0x1f,
+        DXVA2_VideoTransFunc_Unknown	= 0,
+        DXVA2_VideoTransFunc_10	= 1,
+        DXVA2_VideoTransFunc_18	= 2,
+        DXVA2_VideoTransFunc_20	= 3,
+        DXVA2_VideoTransFunc_22	= 4,
+        DXVA2_VideoTransFunc_709	= 5,
+        DXVA2_VideoTransFunc_240M	= 6,
+        DXVA2_VideoTransFunc_sRGB	= 7,
+        DXVA2_VideoTransFunc_28	= 8
+    } 	DXVA2_VideoTransferFunction;
+
+//
+// Deprecated labels - please use the ones in the DXVA2_VideoTransferFunction enum.
+//
+#define DXVA2_VideoTransFunc_22_709         DXVA2_VideoTransFunc_709     
+#define DXVA2_VideoTransFunc_22_240M        DXVA2_VideoTransFunc_240M    
+#define DXVA2_VideoTransFunc_22_8bit_sRGB   DXVA2_VideoTransFunc_sRGB    
+typedef struct _DXVA2_Frequency
+    {
+    UINT Numerator;
+    UINT Denominator;
+    } 	DXVA2_Frequency;
+
+typedef struct _DXVA2_VideoDesc
+    {
+    UINT SampleWidth;
+    UINT SampleHeight;
+    DXVA2_ExtendedFormat SampleFormat;
+    D3DFORMAT Format;
+    DXVA2_Frequency InputSampleFreq;
+    DXVA2_Frequency OutputFrameFreq;
+    UINT UABProtectionLevel;
+    UINT Reserved;
+    } 	DXVA2_VideoDesc;
+
+
+enum __MIDL___MIDL_itf_dxva2api_0000_0000_0003
+    {
+        DXVA2_DeinterlaceTech_Unknown	= 0,
+        DXVA2_DeinterlaceTech_BOBLineReplicate	= 0x1,
+        DXVA2_DeinterlaceTech_BOBVerticalStretch	= 0x2,
+        DXVA2_DeinterlaceTech_BOBVerticalStretch4Tap	= 0x4,
+        DXVA2_DeinterlaceTech_MedianFiltering	= 0x8,
+        DXVA2_DeinterlaceTech_EdgeFiltering	= 0x10,
+        DXVA2_DeinterlaceTech_FieldAdaptive	= 0x20,
+        DXVA2_DeinterlaceTech_PixelAdaptive	= 0x40,
+        DXVA2_DeinterlaceTech_MotionVectorSteered	= 0x80,
+        DXVA2_DeinterlaceTech_InverseTelecine	= 0x100,
+        DXVA2_DeinterlaceTech_Mask	= 0x1ff
+    } ;
+
+enum __MIDL___MIDL_itf_dxva2api_0000_0000_0004
+    {
+        DXVA2_NoiseFilterLumaLevel	= 1,
+        DXVA2_NoiseFilterLumaThreshold	= 2,
+        DXVA2_NoiseFilterLumaRadius	= 3,
+        DXVA2_NoiseFilterChromaLevel	= 4,
+        DXVA2_NoiseFilterChromaThreshold	= 5,
+        DXVA2_NoiseFilterChromaRadius	= 6,
+        DXVA2_DetailFilterLumaLevel	= 7,
+        DXVA2_DetailFilterLumaThreshold	= 8,
+        DXVA2_DetailFilterLumaRadius	= 9,
+        DXVA2_DetailFilterChromaLevel	= 10,
+        DXVA2_DetailFilterChromaThreshold	= 11,
+        DXVA2_DetailFilterChromaRadius	= 12
+    } ;
+
+enum __MIDL___MIDL_itf_dxva2api_0000_0000_0005
+    {
+        DXVA2_NoiseFilterTech_Unsupported	= 0,
+        DXVA2_NoiseFilterTech_Unknown	= 0x1,
+        DXVA2_NoiseFilterTech_Median	= 0x2,
+        DXVA2_NoiseFilterTech_Temporal	= 0x4,
+        DXVA2_NoiseFilterTech_BlockNoise	= 0x8,
+        DXVA2_NoiseFilterTech_MosquitoNoise	= 0x10,
+        DXVA2_NoiseFilterTech_Mask	= 0x1f
+    } ;
+
+enum __MIDL___MIDL_itf_dxva2api_0000_0000_0006
+    {
+        DXVA2_DetailFilterTech_Unsupported	= 0,
+        DXVA2_DetailFilterTech_Unknown	= 0x1,
+        DXVA2_DetailFilterTech_Edge	= 0x2,
+        DXVA2_DetailFilterTech_Sharpening	= 0x4,
+        DXVA2_DetailFilterTech_Mask	= 0x7
+    } ;
+
+enum __MIDL___MIDL_itf_dxva2api_0000_0000_0007
+    {
+        DXVA2_ProcAmp_None	= 0,
+        DXVA2_ProcAmp_Brightness	= 0x1,
+        DXVA2_ProcAmp_Contrast	= 0x2,
+        DXVA2_ProcAmp_Hue	= 0x4,
+        DXVA2_ProcAmp_Saturation	= 0x8,
+        DXVA2_ProcAmp_Mask	= 0xf
+    } ;
+
+enum __MIDL___MIDL_itf_dxva2api_0000_0000_0008
+    {
+        DXVA2_VideoProcess_None	= 0,
+        DXVA2_VideoProcess_YUV2RGB	= 0x1,
+        DXVA2_VideoProcess_StretchX	= 0x2,
+        DXVA2_VideoProcess_StretchY	= 0x4,
+        DXVA2_VideoProcess_AlphaBlend	= 0x8,
+        DXVA2_VideoProcess_SubRects	= 0x10,
+        DXVA2_VideoProcess_SubStreams	= 0x20,
+        DXVA2_VideoProcess_SubStreamsExtended	= 0x40,
+        DXVA2_VideoProcess_YUV2RGBExtended	= 0x80,
+        DXVA2_VideoProcess_AlphaBlendExtended	= 0x100,
+        DXVA2_VideoProcess_Constriction	= 0x200,
+        DXVA2_VideoProcess_NoiseFilter	= 0x400,
+        DXVA2_VideoProcess_DetailFilter	= 0x800,
+        DXVA2_VideoProcess_PlanarAlpha	= 0x1000,
+        DXVA2_VideoProcess_LinearScaling	= 0x2000,
+        DXVA2_VideoProcess_GammaCompensated	= 0x4000,
+        DXVA2_VideoProcess_MaintainsOriginalFieldData	= 0x8000,
+        DXVA2_VideoProcess_Mask	= 0xffff
+    } ;
+
+enum __MIDL___MIDL_itf_dxva2api_0000_0000_0009
+    {
+        DXVA2_VPDev_HardwareDevice	= 0x1,
+        DXVA2_VPDev_EmulatedDXVA1	= 0x2,
+        DXVA2_VPDev_SoftwareDevice	= 0x4,
+        DXVA2_VPDev_Mask	= 0x7
+    } ;
+
+enum __MIDL___MIDL_itf_dxva2api_0000_0000_0010
+    {
+        DXVA2_SampleData_RFF	= 0x1,
+        DXVA2_SampleData_TFF	= 0x2,
+        DXVA2_SampleData_RFF_TFF_Present	= 0x4,
+        DXVA2_SampleData_Mask	= 0xffff
+    } ;
+
+enum __MIDL___MIDL_itf_dxva2api_0000_0000_0011
+    {
+        DXVA2_DestData_RFF	= 0x1,
+        DXVA2_DestData_TFF	= 0x2,
+        DXVA2_DestData_RFF_TFF_Present	= 0x4,
+        DXVA2_DestData_Mask	= 0xffff
+    } ;
+typedef struct _DXVA2_VideoProcessorCaps
+    {
+    UINT DeviceCaps;
+    D3DPOOL InputPool;
+    UINT NumForwardRefSamples;
+    UINT NumBackwardRefSamples;
+    UINT Reserved;
+    UINT DeinterlaceTechnology;
+    UINT ProcAmpControlCaps;
+    UINT VideoProcessorOperations;
+    UINT NoiseFilterTechnology;
+    UINT DetailFilterTechnology;
+    } 	DXVA2_VideoProcessorCaps;
+
+#ifdef __midl
+typedef LONG DXVA2_Fixed32;
+
+#else
+#pragma warning( push )
+#pragma warning( disable : 4201 ) // nonstandard extension used : nameless struct/union
+typedef struct _DXVA2_Fixed32
+{
+    union {
+        struct {
+            USHORT  Fraction;
+            SHORT   Value;
+        };
+        LONG ll;
+    };
+} DXVA2_Fixed32;
+#pragma warning( pop )
+#endif
+typedef struct _DXVA2_AYUVSample8
+    {
+    UCHAR Cr;
+    UCHAR Cb;
+    UCHAR Y;
+    UCHAR Alpha;
+    } 	DXVA2_AYUVSample8;
+
+typedef struct _DXVA2_AYUVSample16
+    {
+    USHORT Cr;
+    USHORT Cb;
+    USHORT Y;
+    USHORT Alpha;
+    } 	DXVA2_AYUVSample16;
+
+typedef LONGLONG REFERENCE_TIME;
+
+#if defined(_D3D9_H_) || defined(_d3d9P_H_)
+typedef struct _DXVA2_VideoSample
+    {
+    REFERENCE_TIME Start;
+    REFERENCE_TIME End;
+    DXVA2_ExtendedFormat SampleFormat;
+    IDirect3DSurface9 *SrcSurface;
+    RECT SrcRect;
+    RECT DstRect;
+    DXVA2_AYUVSample8 Pal[ 16 ];
+    DXVA2_Fixed32 PlanarAlpha;
+    DWORD SampleData;
+    } 	DXVA2_VideoSample;
+
+#endif  // _D3D9_H_
+typedef struct _DXVA2_ValueRange
+    {
+    DXVA2_Fixed32 MinValue;
+    DXVA2_Fixed32 MaxValue;
+    DXVA2_Fixed32 DefaultValue;
+    DXVA2_Fixed32 StepSize;
+    } 	DXVA2_ValueRange;
+
+typedef struct _DXVA2_ProcAmpValues
+    {
+    DXVA2_Fixed32 Brightness;
+    DXVA2_Fixed32 Contrast;
+    DXVA2_Fixed32 Hue;
+    DXVA2_Fixed32 Saturation;
+    } 	DXVA2_ProcAmpValues;
+
+typedef struct _DXVA2_FilterValues
+    {
+    DXVA2_Fixed32 Level;
+    DXVA2_Fixed32 Threshold;
+    DXVA2_Fixed32 Radius;
+    } 	DXVA2_FilterValues;
+
+typedef struct _DXVA2_VideoProcessBltParams
+    {
+    REFERENCE_TIME TargetFrame;
+    RECT TargetRect;
+    SIZE ConstrictionSize;
+    UINT StreamingFlags;
+    DXVA2_AYUVSample16 BackgroundColor;
+    DXVA2_ExtendedFormat DestFormat;
+    DXVA2_ProcAmpValues ProcAmpValues;
+    DXVA2_Fixed32 Alpha;
+    DXVA2_FilterValues NoiseFilterLuma;
+    DXVA2_FilterValues NoiseFilterChroma;
+    DXVA2_FilterValues DetailFilterLuma;
+    DXVA2_FilterValues DetailFilterChroma;
+    DWORD DestData;
+    } 	DXVA2_VideoProcessBltParams;
+
+
+enum __MIDL___MIDL_itf_dxva2api_0000_0000_0012
+    {
+        DXVA2_PictureParametersBufferType	= 0,
+        DXVA2_MacroBlockControlBufferType	= 1,
+        DXVA2_ResidualDifferenceBufferType	= 2,
+        DXVA2_DeblockingControlBufferType	= 3,
+        DXVA2_InverseQuantizationMatrixBufferType	= 4,
+        DXVA2_SliceControlBufferType	= 5,
+        DXVA2_BitStreamDateBufferType	= 6,
+        DXVA2_MotionVectorBuffer	= 7,
+        DXVA2_FilmGrainBuffer	= 8
+    } ;
+
+enum __MIDL___MIDL_itf_dxva2api_0000_0000_0013
+    {
+        DXVA2_VideoDecoderRenderTarget	= 0,
+        DXVA2_VideoProcessorRenderTarget	= 1,
+        DXVA2_VideoSoftwareRenderTarget	= 2
+    } ;
+typedef struct _DXVA2_ConfigPictureDecode
+    {
+    GUID guidConfigBitstreamEncryption;
+    GUID guidConfigMBcontrolEncryption;
+    GUID guidConfigResidDiffEncryption;
+    UINT ConfigBitstreamRaw;
+    UINT ConfigMBcontrolRasterOrder;
+    UINT ConfigResidDiffHost;
+    UINT ConfigSpatialResid8;
+    UINT ConfigResid8Subtraction;
+    UINT ConfigSpatialHost8or9Clipping;
+    UINT ConfigSpatialResidInterleaved;
+    UINT ConfigIntraResidUnsigned;
+    UINT ConfigResidDiffAccelerator;
+    UINT ConfigHostInverseScan;
+    UINT ConfigSpecificIDCT;
+    UINT Config4GroupedCoefs;
+    USHORT ConfigMinRenderTargetBuffCount;
+    USHORT ConfigDecoderSpecific;
+    } 	DXVA2_ConfigPictureDecode;
+
+typedef struct _DXVA2_DecodeBufferDesc
+    {
+    DWORD CompressedBufferType;
+    UINT BufferIndex;
+    UINT DataOffset;
+    UINT DataSize;
+    UINT FirstMBaddress;
+    UINT NumMBsInBuffer;
+    UINT Width;
+    UINT Height;
+    UINT Stride;
+    UINT ReservedBits;
+    PVOID pvPVPState;
+    } 	DXVA2_DecodeBufferDesc;
+
+// The value in pvPVPState depends on the type of crypo used.  For 
+// D3DCRYPTOTYPE_AES128_CTR, pvPState points to the following structure:
+ 
+typedef struct _DXVA2_AES_CTR_IV
+    {
+    UINT64 IV;
+    UINT64 Count;
+    } 	DXVA2_AES_CTR_IV;
+
+typedef struct _DXVA2_DecodeExtensionData
+    {
+    UINT Function;
+    PVOID pPrivateInputData;
+    UINT PrivateInputDataSize;
+    PVOID pPrivateOutputData;
+    UINT PrivateOutputDataSize;
+    } 	DXVA2_DecodeExtensionData;
+
+// DXVA2_DECODE_GET_DRIVER_HANDLE is an extension function that allows the 
+// driver to return a handle for the DXVA2 decode device that can be used to
+// associate it with a IDirect3DCryptoSession9 interface.  When this function
+// is used:
+//     pPrivateInputData = NULL
+//     pPrivateInputDataSize = 0
+//     pPrivateOutputData = HANDLE*
+//     pPrivateOutputDataSize = sizeof(HANDLE)
+#define DXVA2_DECODE_GET_DRIVER_HANDLE               0x725
+ 
+// DXVA2_DECODE_SPECIFY_ENCRYPTED_BLOCKS is an extension function that that allows 
+// the decoder to specify which portions of the compressed buffers are encrypted. 
+// If this fucntion is not used to specify this information, it is assumed that 
+// the entire buffer is encrypted. 
+//     pPrivateInputData = D3DENCRYPTED_BLOCK_INFO*; 
+//     PrivateInputDataSize = sizeof(D3DENCRYPTED_BLOCK_INFO); 
+//     pPrivateOutputData = NULL; 
+//     PrivateOutputDataSize = 0; 
+#define DXVA2_DECODE_SPECIFY_ENCRYPTED_BLOCKS	0x724 
+ 
+typedef struct _DXVA2_DecodeExecuteParams
+    {
+    UINT NumCompBuffers;
+    DXVA2_DecodeBufferDesc *pCompressedBuffers;
+    DXVA2_DecodeExtensionData *pExtensionData;
+    } 	DXVA2_DecodeExecuteParams;
+
+#if defined(_D3D9_H_) || defined(_d3d9P_H_)
+
+
+
+
+
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_dxva2api_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_dxva2api_0000_0000_v0_0_s_ifspec;
+
+#ifndef __IDirect3DDeviceManager9_INTERFACE_DEFINED__
+#define __IDirect3DDeviceManager9_INTERFACE_DEFINED__
+
+/* interface IDirect3DDeviceManager9 */
+/* [local][helpstring][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDirect3DDeviceManager9;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("a0cade0f-06d5-4cf4-a1c7-f3cdd725aa75")
+    IDirect3DDeviceManager9 : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE ResetDevice( 
+            /* [annotation][in] */ 
+            _In_  IDirect3DDevice9 *pDevice,
+            /* [annotation][in] */ 
+            _In_  UINT resetToken) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE OpenDeviceHandle( 
+            /* [annotation][out] */ 
+            _Out_  HANDLE *phDevice) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CloseDeviceHandle( 
+            /* [annotation][in] */ 
+            _In_  HANDLE hDevice) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE TestDevice( 
+            /* [annotation][in] */ 
+            _In_  HANDLE hDevice) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE LockDevice( 
+            /* [annotation][in] */ 
+            _In_  HANDLE hDevice,
+            /* [annotation][out] */ 
+            _Outptr_  IDirect3DDevice9 **ppDevice,
+            /* [annotation][in] */ 
+            _In_  BOOL fBlock) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE UnlockDevice( 
+            /* [annotation][in] */ 
+            _In_  HANDLE hDevice,
+            /* [annotation][in] */ 
+            _In_  BOOL fSaveState) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetVideoService( 
+            /* [annotation][in] */ 
+            _In_  HANDLE hDevice,
+            /* [annotation][in] */ 
+            _In_  REFIID riid,
+            /* [annotation][out] */ 
+            _Outptr_  void **ppService) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct IDirect3DDeviceManager9Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDirect3DDeviceManager9 * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDirect3DDeviceManager9 * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDirect3DDeviceManager9 * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *ResetDevice )( 
+            IDirect3DDeviceManager9 * This,
+            /* [annotation][in] */ 
+            _In_  IDirect3DDevice9 *pDevice,
+            /* [annotation][in] */ 
+            _In_  UINT resetToken);
+        
+        HRESULT ( STDMETHODCALLTYPE *OpenDeviceHandle )( 
+            IDirect3DDeviceManager9 * This,
+            /* [annotation][out] */ 
+            _Out_  HANDLE *phDevice);
+        
+        HRESULT ( STDMETHODCALLTYPE *CloseDeviceHandle )( 
+            IDirect3DDeviceManager9 * This,
+            /* [annotation][in] */ 
+            _In_  HANDLE hDevice);
+        
+        HRESULT ( STDMETHODCALLTYPE *TestDevice )( 
+            IDirect3DDeviceManager9 * This,
+            /* [annotation][in] */ 
+            _In_  HANDLE hDevice);
+        
+        HRESULT ( STDMETHODCALLTYPE *LockDevice )( 
+            IDirect3DDeviceManager9 * This,
+            /* [annotation][in] */ 
+            _In_  HANDLE hDevice,
+            /* [annotation][out] */ 
+            _Outptr_  IDirect3DDevice9 **ppDevice,
+            /* [annotation][in] */ 
+            _In_  BOOL fBlock);
+        
+        HRESULT ( STDMETHODCALLTYPE *UnlockDevice )( 
+            IDirect3DDeviceManager9 * This,
+            /* [annotation][in] */ 
+            _In_  HANDLE hDevice,
+            /* [annotation][in] */ 
+            _In_  BOOL fSaveState);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetVideoService )( 
+            IDirect3DDeviceManager9 * This,
+            /* [annotation][in] */ 
+            _In_  HANDLE hDevice,
+            /* [annotation][in] */ 
+            _In_  REFIID riid,
+            /* [annotation][out] */ 
+            _Outptr_  void **ppService);
+        
+        END_INTERFACE
+    } IDirect3DDeviceManager9Vtbl;
+
+    interface IDirect3DDeviceManager9
+    {
+        CONST_VTBL struct IDirect3DDeviceManager9Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDirect3DDeviceManager9_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDirect3DDeviceManager9_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDirect3DDeviceManager9_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDirect3DDeviceManager9_ResetDevice(This,pDevice,resetToken)	\
+    ( (This)->lpVtbl -> ResetDevice(This,pDevice,resetToken) ) 
+
+#define IDirect3DDeviceManager9_OpenDeviceHandle(This,phDevice)	\
+    ( (This)->lpVtbl -> OpenDeviceHandle(This,phDevice) ) 
+
+#define IDirect3DDeviceManager9_CloseDeviceHandle(This,hDevice)	\
+    ( (This)->lpVtbl -> CloseDeviceHandle(This,hDevice) ) 
+
+#define IDirect3DDeviceManager9_TestDevice(This,hDevice)	\
+    ( (This)->lpVtbl -> TestDevice(This,hDevice) ) 
+
+#define IDirect3DDeviceManager9_LockDevice(This,hDevice,ppDevice,fBlock)	\
+    ( (This)->lpVtbl -> LockDevice(This,hDevice,ppDevice,fBlock) ) 
+
+#define IDirect3DDeviceManager9_UnlockDevice(This,hDevice,fSaveState)	\
+    ( (This)->lpVtbl -> UnlockDevice(This,hDevice,fSaveState) ) 
+
+#define IDirect3DDeviceManager9_GetVideoService(This,hDevice,riid,ppService)	\
+    ( (This)->lpVtbl -> GetVideoService(This,hDevice,riid,ppService) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDirect3DDeviceManager9_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDirectXVideoAccelerationService_INTERFACE_DEFINED__
+#define __IDirectXVideoAccelerationService_INTERFACE_DEFINED__
+
+/* interface IDirectXVideoAccelerationService */
+/* [local][helpstring][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDirectXVideoAccelerationService;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("fc51a550-d5e7-11d9-af55-00054e43ff02")
+    IDirectXVideoAccelerationService : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateSurface( 
+            /* [annotation][in] */ 
+            _In_  UINT Width,
+            /* [annotation][in] */ 
+            _In_  UINT Height,
+            /* [annotation][in] */ 
+            _In_  UINT BackBuffers,
+            /* [annotation][in] */ 
+            _In_  D3DFORMAT Format,
+            /* [annotation][in] */ 
+            _In_  D3DPOOL Pool,
+            /* [annotation][in] */ 
+            _In_  DWORD Usage,
+            /* [annotation][in] */ 
+            _In_  DWORD DxvaType,
+            /* [annotation][size_is][out] */ 
+            _Out_writes_(BackBuffers+1)  IDirect3DSurface9 **ppSurface,
+            /* [annotation][out][in] */ 
+            _Inout_opt_  HANDLE *pSharedHandle) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct IDirectXVideoAccelerationServiceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDirectXVideoAccelerationService * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDirectXVideoAccelerationService * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDirectXVideoAccelerationService * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *CreateSurface )( 
+            IDirectXVideoAccelerationService * This,
+            /* [annotation][in] */ 
+            _In_  UINT Width,
+            /* [annotation][in] */ 
+            _In_  UINT Height,
+            /* [annotation][in] */ 
+            _In_  UINT BackBuffers,
+            /* [annotation][in] */ 
+            _In_  D3DFORMAT Format,
+            /* [annotation][in] */ 
+            _In_  D3DPOOL Pool,
+            /* [annotation][in] */ 
+            _In_  DWORD Usage,
+            /* [annotation][in] */ 
+            _In_  DWORD DxvaType,
+            /* [annotation][size_is][out] */ 
+            _Out_writes_(BackBuffers+1)  IDirect3DSurface9 **ppSurface,
+            /* [annotation][out][in] */ 
+            _Inout_opt_  HANDLE *pSharedHandle);
+        
+        END_INTERFACE
+    } IDirectXVideoAccelerationServiceVtbl;
+
+    interface IDirectXVideoAccelerationService
+    {
+        CONST_VTBL struct IDirectXVideoAccelerationServiceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDirectXVideoAccelerationService_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDirectXVideoAccelerationService_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDirectXVideoAccelerationService_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDirectXVideoAccelerationService_CreateSurface(This,Width,Height,BackBuffers,Format,Pool,Usage,DxvaType,ppSurface,pSharedHandle)	\
+    ( (This)->lpVtbl -> CreateSurface(This,Width,Height,BackBuffers,Format,Pool,Usage,DxvaType,ppSurface,pSharedHandle) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDirectXVideoAccelerationService_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDirectXVideoDecoderService_INTERFACE_DEFINED__
+#define __IDirectXVideoDecoderService_INTERFACE_DEFINED__
+
+/* interface IDirectXVideoDecoderService */
+/* [local][helpstring][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDirectXVideoDecoderService;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("fc51a551-d5e7-11d9-af55-00054e43ff02")
+    IDirectXVideoDecoderService : public IDirectXVideoAccelerationService
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetDecoderDeviceGuids( 
+            /* [annotation][out] */ 
+            _Out_  UINT *pCount,
+            /* [annotation][size_is][unique][out] */ 
+            _Outptr_result_buffer_maybenull_(*pCount)  GUID **pGuids) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetDecoderRenderTargets( 
+            /* [annotation][in] */ 
+            _In_  REFGUID Guid,
+            /* [annotation][out] */ 
+            _Out_  UINT *pCount,
+            /* [annotation][size_is][unique][out] */ 
+            _Outptr_result_buffer_maybenull_(*pCount)  D3DFORMAT **pFormats) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetDecoderConfigurations( 
+            /* [annotation][in] */ 
+            _In_  REFGUID Guid,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][in] */ 
+            _Reserved_  void *pReserved,
+            /* [annotation][out] */ 
+            _Out_  UINT *pCount,
+            /* [annotation][size_is][unique][out] */ 
+            _Outptr_result_buffer_maybenull_(*pCount)  DXVA2_ConfigPictureDecode **ppConfigs) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoDecoder( 
+            /* [annotation][in] */ 
+            _In_  REFGUID Guid,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_ConfigPictureDecode *pConfig,
+            /* [annotation][size_is][in] */ 
+            _In_reads_(NumRenderTargets)  IDirect3DSurface9 **ppDecoderRenderTargets,
+            /* [annotation][in] */ 
+            _In_  UINT NumRenderTargets,
+            /* [annotation][out] */ 
+            _Outptr_  IDirectXVideoDecoder **ppDecode) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct IDirectXVideoDecoderServiceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDirectXVideoDecoderService * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDirectXVideoDecoderService * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDirectXVideoDecoderService * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *CreateSurface )( 
+            IDirectXVideoDecoderService * This,
+            /* [annotation][in] */ 
+            _In_  UINT Width,
+            /* [annotation][in] */ 
+            _In_  UINT Height,
+            /* [annotation][in] */ 
+            _In_  UINT BackBuffers,
+            /* [annotation][in] */ 
+            _In_  D3DFORMAT Format,
+            /* [annotation][in] */ 
+            _In_  D3DPOOL Pool,
+            /* [annotation][in] */ 
+            _In_  DWORD Usage,
+            /* [annotation][in] */ 
+            _In_  DWORD DxvaType,
+            /* [annotation][size_is][out] */ 
+            _Out_writes_(BackBuffers+1)  IDirect3DSurface9 **ppSurface,
+            /* [annotation][out][in] */ 
+            _Inout_opt_  HANDLE *pSharedHandle);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetDecoderDeviceGuids )( 
+            IDirectXVideoDecoderService * This,
+            /* [annotation][out] */ 
+            _Out_  UINT *pCount,
+            /* [annotation][size_is][unique][out] */ 
+            _Outptr_result_buffer_maybenull_(*pCount)  GUID **pGuids);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetDecoderRenderTargets )( 
+            IDirectXVideoDecoderService * This,
+            /* [annotation][in] */ 
+            _In_  REFGUID Guid,
+            /* [annotation][out] */ 
+            _Out_  UINT *pCount,
+            /* [annotation][size_is][unique][out] */ 
+            _Outptr_result_buffer_maybenull_(*pCount)  D3DFORMAT **pFormats);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetDecoderConfigurations )( 
+            IDirectXVideoDecoderService * This,
+            /* [annotation][in] */ 
+            _In_  REFGUID Guid,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][in] */ 
+            _Reserved_  void *pReserved,
+            /* [annotation][out] */ 
+            _Out_  UINT *pCount,
+            /* [annotation][size_is][unique][out] */ 
+            _Outptr_result_buffer_maybenull_(*pCount)  DXVA2_ConfigPictureDecode **ppConfigs);
+        
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoder )( 
+            IDirectXVideoDecoderService * This,
+            /* [annotation][in] */ 
+            _In_  REFGUID Guid,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_ConfigPictureDecode *pConfig,
+            /* [annotation][size_is][in] */ 
+            _In_reads_(NumRenderTargets)  IDirect3DSurface9 **ppDecoderRenderTargets,
+            /* [annotation][in] */ 
+            _In_  UINT NumRenderTargets,
+            /* [annotation][out] */ 
+            _Outptr_  IDirectXVideoDecoder **ppDecode);
+        
+        END_INTERFACE
+    } IDirectXVideoDecoderServiceVtbl;
+
+    interface IDirectXVideoDecoderService
+    {
+        CONST_VTBL struct IDirectXVideoDecoderServiceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDirectXVideoDecoderService_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDirectXVideoDecoderService_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDirectXVideoDecoderService_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDirectXVideoDecoderService_CreateSurface(This,Width,Height,BackBuffers,Format,Pool,Usage,DxvaType,ppSurface,pSharedHandle)	\
+    ( (This)->lpVtbl -> CreateSurface(This,Width,Height,BackBuffers,Format,Pool,Usage,DxvaType,ppSurface,pSharedHandle) ) 
+
+
+#define IDirectXVideoDecoderService_GetDecoderDeviceGuids(This,pCount,pGuids)	\
+    ( (This)->lpVtbl -> GetDecoderDeviceGuids(This,pCount,pGuids) ) 
+
+#define IDirectXVideoDecoderService_GetDecoderRenderTargets(This,Guid,pCount,pFormats)	\
+    ( (This)->lpVtbl -> GetDecoderRenderTargets(This,Guid,pCount,pFormats) ) 
+
+#define IDirectXVideoDecoderService_GetDecoderConfigurations(This,Guid,pVideoDesc,pReserved,pCount,ppConfigs)	\
+    ( (This)->lpVtbl -> GetDecoderConfigurations(This,Guid,pVideoDesc,pReserved,pCount,ppConfigs) ) 
+
+#define IDirectXVideoDecoderService_CreateVideoDecoder(This,Guid,pVideoDesc,pConfig,ppDecoderRenderTargets,NumRenderTargets,ppDecode)	\
+    ( (This)->lpVtbl -> CreateVideoDecoder(This,Guid,pVideoDesc,pConfig,ppDecoderRenderTargets,NumRenderTargets,ppDecode) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDirectXVideoDecoderService_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDirectXVideoProcessorService_INTERFACE_DEFINED__
+#define __IDirectXVideoProcessorService_INTERFACE_DEFINED__
+
+/* interface IDirectXVideoProcessorService */
+/* [local][helpstring][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDirectXVideoProcessorService;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("fc51a552-d5e7-11d9-af55-00054e43ff02")
+    IDirectXVideoProcessorService : public IDirectXVideoAccelerationService
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE RegisterVideoProcessorSoftwareDevice( 
+            /* [annotation][in] */ 
+            _In_  void *pCallbacks) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetVideoProcessorDeviceGuids( 
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][out] */ 
+            _Out_  UINT *pCount,
+            /* [annotation][size_is][unique][out] */ 
+            _Outptr_result_buffer_maybenull_(*pCount)  GUID **pGuids) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetVideoProcessorRenderTargets( 
+            /* [annotation][in] */ 
+            _In_  REFGUID VideoProcDeviceGuid,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][out] */ 
+            _Out_  UINT *pCount,
+            /* [annotation][size_is][unique][out] */ 
+            _Outptr_result_buffer_maybenull_(*pCount)  D3DFORMAT **pFormats) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetVideoProcessorSubStreamFormats( 
+            /* [annotation][in] */ 
+            _In_  REFGUID VideoProcDeviceGuid,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][in] */ 
+            _In_  D3DFORMAT RenderTargetFormat,
+            /* [annotation][out] */ 
+            _Out_  UINT *pCount,
+            /* [annotation][size_is][unique][out] */ 
+            _Outptr_result_buffer_maybenull_(*pCount)  D3DFORMAT **pFormats) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetVideoProcessorCaps( 
+            /* [annotation][in] */ 
+            _In_  REFGUID VideoProcDeviceGuid,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][in] */ 
+            _In_  D3DFORMAT RenderTargetFormat,
+            /* [annotation][out] */ 
+            _Out_  DXVA2_VideoProcessorCaps *pCaps) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetProcAmpRange( 
+            /* [annotation][in] */ 
+            _In_  REFGUID VideoProcDeviceGuid,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][in] */ 
+            _In_  D3DFORMAT RenderTargetFormat,
+            /* [annotation][in] */ 
+            _In_  UINT ProcAmpCap,
+            /* [annotation][out] */ 
+            _Out_  DXVA2_ValueRange *pRange) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetFilterPropertyRange( 
+            /* [annotation][in] */ 
+            _In_  REFGUID VideoProcDeviceGuid,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][in] */ 
+            _In_  D3DFORMAT RenderTargetFormat,
+            /* [annotation][in] */ 
+            _In_  UINT FilterSetting,
+            /* [annotation][out] */ 
+            _Out_  DXVA2_ValueRange *pRange) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoProcessor( 
+            /* [annotation][in] */ 
+            _In_  REFGUID VideoProcDeviceGuid,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][in] */ 
+            _In_  D3DFORMAT RenderTargetFormat,
+            /* [annotation][in] */ 
+            _In_  UINT MaxNumSubStreams,
+            /* [annotation][out] */ 
+            _Outptr_  IDirectXVideoProcessor **ppVidProcess) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct IDirectXVideoProcessorServiceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDirectXVideoProcessorService * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDirectXVideoProcessorService * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDirectXVideoProcessorService * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *CreateSurface )( 
+            IDirectXVideoProcessorService * This,
+            /* [annotation][in] */ 
+            _In_  UINT Width,
+            /* [annotation][in] */ 
+            _In_  UINT Height,
+            /* [annotation][in] */ 
+            _In_  UINT BackBuffers,
+            /* [annotation][in] */ 
+            _In_  D3DFORMAT Format,
+            /* [annotation][in] */ 
+            _In_  D3DPOOL Pool,
+            /* [annotation][in] */ 
+            _In_  DWORD Usage,
+            /* [annotation][in] */ 
+            _In_  DWORD DxvaType,
+            /* [annotation][size_is][out] */ 
+            _Out_writes_(BackBuffers+1)  IDirect3DSurface9 **ppSurface,
+            /* [annotation][out][in] */ 
+            _Inout_opt_  HANDLE *pSharedHandle);
+        
+        HRESULT ( STDMETHODCALLTYPE *RegisterVideoProcessorSoftwareDevice )( 
+            IDirectXVideoProcessorService * This,
+            /* [annotation][in] */ 
+            _In_  void *pCallbacks);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetVideoProcessorDeviceGuids )( 
+            IDirectXVideoProcessorService * This,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][out] */ 
+            _Out_  UINT *pCount,
+            /* [annotation][size_is][unique][out] */ 
+            _Outptr_result_buffer_maybenull_(*pCount)  GUID **pGuids);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetVideoProcessorRenderTargets )( 
+            IDirectXVideoProcessorService * This,
+            /* [annotation][in] */ 
+            _In_  REFGUID VideoProcDeviceGuid,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][out] */ 
+            _Out_  UINT *pCount,
+            /* [annotation][size_is][unique][out] */ 
+            _Outptr_result_buffer_maybenull_(*pCount)  D3DFORMAT **pFormats);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetVideoProcessorSubStreamFormats )( 
+            IDirectXVideoProcessorService * This,
+            /* [annotation][in] */ 
+            _In_  REFGUID VideoProcDeviceGuid,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][in] */ 
+            _In_  D3DFORMAT RenderTargetFormat,
+            /* [annotation][out] */ 
+            _Out_  UINT *pCount,
+            /* [annotation][size_is][unique][out] */ 
+            _Outptr_result_buffer_maybenull_(*pCount)  D3DFORMAT **pFormats);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetVideoProcessorCaps )( 
+            IDirectXVideoProcessorService * This,
+            /* [annotation][in] */ 
+            _In_  REFGUID VideoProcDeviceGuid,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][in] */ 
+            _In_  D3DFORMAT RenderTargetFormat,
+            /* [annotation][out] */ 
+            _Out_  DXVA2_VideoProcessorCaps *pCaps);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetProcAmpRange )( 
+            IDirectXVideoProcessorService * This,
+            /* [annotation][in] */ 
+            _In_  REFGUID VideoProcDeviceGuid,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][in] */ 
+            _In_  D3DFORMAT RenderTargetFormat,
+            /* [annotation][in] */ 
+            _In_  UINT ProcAmpCap,
+            /* [annotation][out] */ 
+            _Out_  DXVA2_ValueRange *pRange);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetFilterPropertyRange )( 
+            IDirectXVideoProcessorService * This,
+            /* [annotation][in] */ 
+            _In_  REFGUID VideoProcDeviceGuid,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][in] */ 
+            _In_  D3DFORMAT RenderTargetFormat,
+            /* [annotation][in] */ 
+            _In_  UINT FilterSetting,
+            /* [annotation][out] */ 
+            _Out_  DXVA2_ValueRange *pRange);
+        
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoProcessor )( 
+            IDirectXVideoProcessorService * This,
+            /* [annotation][in] */ 
+            _In_  REFGUID VideoProcDeviceGuid,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][in] */ 
+            _In_  D3DFORMAT RenderTargetFormat,
+            /* [annotation][in] */ 
+            _In_  UINT MaxNumSubStreams,
+            /* [annotation][out] */ 
+            _Outptr_  IDirectXVideoProcessor **ppVidProcess);
+        
+        END_INTERFACE
+    } IDirectXVideoProcessorServiceVtbl;
+
+    interface IDirectXVideoProcessorService
+    {
+        CONST_VTBL struct IDirectXVideoProcessorServiceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDirectXVideoProcessorService_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDirectXVideoProcessorService_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDirectXVideoProcessorService_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDirectXVideoProcessorService_CreateSurface(This,Width,Height,BackBuffers,Format,Pool,Usage,DxvaType,ppSurface,pSharedHandle)	\
+    ( (This)->lpVtbl -> CreateSurface(This,Width,Height,BackBuffers,Format,Pool,Usage,DxvaType,ppSurface,pSharedHandle) ) 
+
+
+#define IDirectXVideoProcessorService_RegisterVideoProcessorSoftwareDevice(This,pCallbacks)	\
+    ( (This)->lpVtbl -> RegisterVideoProcessorSoftwareDevice(This,pCallbacks) ) 
+
+#define IDirectXVideoProcessorService_GetVideoProcessorDeviceGuids(This,pVideoDesc,pCount,pGuids)	\
+    ( (This)->lpVtbl -> GetVideoProcessorDeviceGuids(This,pVideoDesc,pCount,pGuids) ) 
+
+#define IDirectXVideoProcessorService_GetVideoProcessorRenderTargets(This,VideoProcDeviceGuid,pVideoDesc,pCount,pFormats)	\
+    ( (This)->lpVtbl -> GetVideoProcessorRenderTargets(This,VideoProcDeviceGuid,pVideoDesc,pCount,pFormats) ) 
+
+#define IDirectXVideoProcessorService_GetVideoProcessorSubStreamFormats(This,VideoProcDeviceGuid,pVideoDesc,RenderTargetFormat,pCount,pFormats)	\
+    ( (This)->lpVtbl -> GetVideoProcessorSubStreamFormats(This,VideoProcDeviceGuid,pVideoDesc,RenderTargetFormat,pCount,pFormats) ) 
+
+#define IDirectXVideoProcessorService_GetVideoProcessorCaps(This,VideoProcDeviceGuid,pVideoDesc,RenderTargetFormat,pCaps)	\
+    ( (This)->lpVtbl -> GetVideoProcessorCaps(This,VideoProcDeviceGuid,pVideoDesc,RenderTargetFormat,pCaps) ) 
+
+#define IDirectXVideoProcessorService_GetProcAmpRange(This,VideoProcDeviceGuid,pVideoDesc,RenderTargetFormat,ProcAmpCap,pRange)	\
+    ( (This)->lpVtbl -> GetProcAmpRange(This,VideoProcDeviceGuid,pVideoDesc,RenderTargetFormat,ProcAmpCap,pRange) ) 
+
+#define IDirectXVideoProcessorService_GetFilterPropertyRange(This,VideoProcDeviceGuid,pVideoDesc,RenderTargetFormat,FilterSetting,pRange)	\
+    ( (This)->lpVtbl -> GetFilterPropertyRange(This,VideoProcDeviceGuid,pVideoDesc,RenderTargetFormat,FilterSetting,pRange) ) 
+
+#define IDirectXVideoProcessorService_CreateVideoProcessor(This,VideoProcDeviceGuid,pVideoDesc,RenderTargetFormat,MaxNumSubStreams,ppVidProcess)	\
+    ( (This)->lpVtbl -> CreateVideoProcessor(This,VideoProcDeviceGuid,pVideoDesc,RenderTargetFormat,MaxNumSubStreams,ppVidProcess) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDirectXVideoProcessorService_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDirectXVideoDecoder_INTERFACE_DEFINED__
+#define __IDirectXVideoDecoder_INTERFACE_DEFINED__
+
+/* interface IDirectXVideoDecoder */
+/* [local][helpstring][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDirectXVideoDecoder;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("f2b0810a-fd00-43c9-918c-df94e2d8ef7d")
+    IDirectXVideoDecoder : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetVideoDecoderService( 
+            /* [annotation][out] */ 
+            _Outptr_  IDirectXVideoDecoderService **ppService) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetCreationParameters( 
+            /* [annotation][out] */ 
+            _Out_opt_  GUID *pDeviceGuid,
+            /* [annotation][out] */ 
+            _Out_opt_  DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][out] */ 
+            _Out_opt_  DXVA2_ConfigPictureDecode *pConfig,
+            /* [annotation][size_is][unique][out] */ 
+            _Out_writes_(*pNumSurfaces)  IDirect3DSurface9 ***pDecoderRenderTargets,
+            /* [annotation][out] */ 
+            _Out_opt_  UINT *pNumSurfaces) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetBuffer( 
+            /* [annotation][in] */ 
+            _In_  UINT BufferType,
+            /* [annotation][out] */ 
+            _Out_  void **ppBuffer,
+            /* [annotation][out] */ 
+            _Out_  UINT *pBufferSize) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReleaseBuffer( 
+            /* [annotation][in] */ 
+            _In_  UINT BufferType) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE BeginFrame( 
+            /* [annotation][in] */ 
+            _In_  IDirect3DSurface9 *pRenderTarget,
+            /* [annotation][in] */ 
+            _In_opt_  void *pvPVPData) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE EndFrame( 
+            /* [annotation][out] */ 
+            _Inout_opt_  HANDLE *pHandleComplete) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE Execute( 
+            /* [annotation][in] */ 
+            _In_  const DXVA2_DecodeExecuteParams *pExecuteParams) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct IDirectXVideoDecoderVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDirectXVideoDecoder * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDirectXVideoDecoder * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDirectXVideoDecoder * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetVideoDecoderService )( 
+            IDirectXVideoDecoder * This,
+            /* [annotation][out] */ 
+            _Outptr_  IDirectXVideoDecoderService **ppService);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetCreationParameters )( 
+            IDirectXVideoDecoder * This,
+            /* [annotation][out] */ 
+            _Out_opt_  GUID *pDeviceGuid,
+            /* [annotation][out] */ 
+            _Out_opt_  DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][out] */ 
+            _Out_opt_  DXVA2_ConfigPictureDecode *pConfig,
+            /* [annotation][size_is][unique][out] */ 
+            _Out_writes_(*pNumSurfaces)  IDirect3DSurface9 ***pDecoderRenderTargets,
+            /* [annotation][out] */ 
+            _Out_opt_  UINT *pNumSurfaces);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetBuffer )( 
+            IDirectXVideoDecoder * This,
+            /* [annotation][in] */ 
+            _In_  UINT BufferType,
+            /* [annotation][out] */ 
+            _Out_  void **ppBuffer,
+            /* [annotation][out] */ 
+            _Out_  UINT *pBufferSize);
+        
+        HRESULT ( STDMETHODCALLTYPE *ReleaseBuffer )( 
+            IDirectXVideoDecoder * This,
+            /* [annotation][in] */ 
+            _In_  UINT BufferType);
+        
+        HRESULT ( STDMETHODCALLTYPE *BeginFrame )( 
+            IDirectXVideoDecoder * This,
+            /* [annotation][in] */ 
+            _In_  IDirect3DSurface9 *pRenderTarget,
+            /* [annotation][in] */ 
+            _In_opt_  void *pvPVPData);
+        
+        HRESULT ( STDMETHODCALLTYPE *EndFrame )( 
+            IDirectXVideoDecoder * This,
+            /* [annotation][out] */ 
+            _Inout_opt_  HANDLE *pHandleComplete);
+        
+        HRESULT ( STDMETHODCALLTYPE *Execute )( 
+            IDirectXVideoDecoder * This,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_DecodeExecuteParams *pExecuteParams);
+        
+        END_INTERFACE
+    } IDirectXVideoDecoderVtbl;
+
+    interface IDirectXVideoDecoder
+    {
+        CONST_VTBL struct IDirectXVideoDecoderVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDirectXVideoDecoder_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDirectXVideoDecoder_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDirectXVideoDecoder_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDirectXVideoDecoder_GetVideoDecoderService(This,ppService)	\
+    ( (This)->lpVtbl -> GetVideoDecoderService(This,ppService) ) 
+
+#define IDirectXVideoDecoder_GetCreationParameters(This,pDeviceGuid,pVideoDesc,pConfig,pDecoderRenderTargets,pNumSurfaces)	\
+    ( (This)->lpVtbl -> GetCreationParameters(This,pDeviceGuid,pVideoDesc,pConfig,pDecoderRenderTargets,pNumSurfaces) ) 
+
+#define IDirectXVideoDecoder_GetBuffer(This,BufferType,ppBuffer,pBufferSize)	\
+    ( (This)->lpVtbl -> GetBuffer(This,BufferType,ppBuffer,pBufferSize) ) 
+
+#define IDirectXVideoDecoder_ReleaseBuffer(This,BufferType)	\
+    ( (This)->lpVtbl -> ReleaseBuffer(This,BufferType) ) 
+
+#define IDirectXVideoDecoder_BeginFrame(This,pRenderTarget,pvPVPData)	\
+    ( (This)->lpVtbl -> BeginFrame(This,pRenderTarget,pvPVPData) ) 
+
+#define IDirectXVideoDecoder_EndFrame(This,pHandleComplete)	\
+    ( (This)->lpVtbl -> EndFrame(This,pHandleComplete) ) 
+
+#define IDirectXVideoDecoder_Execute(This,pExecuteParams)	\
+    ( (This)->lpVtbl -> Execute(This,pExecuteParams) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDirectXVideoDecoder_INTERFACE_DEFINED__ */
+
+
+#ifndef __IDirectXVideoProcessor_INTERFACE_DEFINED__
+#define __IDirectXVideoProcessor_INTERFACE_DEFINED__
+
+/* interface IDirectXVideoProcessor */
+/* [local][helpstring][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDirectXVideoProcessor;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8c3a39f0-916e-4690-804f-4c8001355d25")
+    IDirectXVideoProcessor : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetVideoProcessorService( 
+            /* [annotation][out] */ 
+            _Outptr_  IDirectXVideoProcessorService **ppService) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetCreationParameters( 
+            /* [annotation][out] */ 
+            _Out_opt_  GUID *pDeviceGuid,
+            /* [annotation][out] */ 
+            _Out_opt_  DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][out] */ 
+            _Out_opt_  D3DFORMAT *pRenderTargetFormat,
+            /* [annotation][out] */ 
+            _Out_opt_  UINT *pMaxNumSubStreams) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetVideoProcessorCaps( 
+            /* [annotation][out] */ 
+            _Out_  DXVA2_VideoProcessorCaps *pCaps) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetProcAmpRange( 
+            /* [annotation][in] */ 
+            _In_  UINT ProcAmpCap,
+            /* [annotation][out] */ 
+            _Out_  DXVA2_ValueRange *pRange) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetFilterPropertyRange( 
+            /* [annotation][in] */ 
+            _In_  UINT FilterSetting,
+            /* [annotation][out] */ 
+            _Out_  DXVA2_ValueRange *pRange) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE VideoProcessBlt( 
+            /* [annotation][in] */ 
+            _In_  IDirect3DSurface9 *pRenderTarget,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoProcessBltParams *pBltParams,
+            /* [annotation][size_is][in] */ 
+            _In_reads_(NumSamples)  const DXVA2_VideoSample *pSamples,
+            /* [annotation][in] */ 
+            _In_  UINT NumSamples,
+            /* [annotation][out] */ 
+            _Inout_opt_  HANDLE *pHandleComplete) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct IDirectXVideoProcessorVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDirectXVideoProcessor * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDirectXVideoProcessor * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDirectXVideoProcessor * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetVideoProcessorService )( 
+            IDirectXVideoProcessor * This,
+            /* [annotation][out] */ 
+            _Outptr_  IDirectXVideoProcessorService **ppService);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetCreationParameters )( 
+            IDirectXVideoProcessor * This,
+            /* [annotation][out] */ 
+            _Out_opt_  GUID *pDeviceGuid,
+            /* [annotation][out] */ 
+            _Out_opt_  DXVA2_VideoDesc *pVideoDesc,
+            /* [annotation][out] */ 
+            _Out_opt_  D3DFORMAT *pRenderTargetFormat,
+            /* [annotation][out] */ 
+            _Out_opt_  UINT *pMaxNumSubStreams);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetVideoProcessorCaps )( 
+            IDirectXVideoProcessor * This,
+            /* [annotation][out] */ 
+            _Out_  DXVA2_VideoProcessorCaps *pCaps);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetProcAmpRange )( 
+            IDirectXVideoProcessor * This,
+            /* [annotation][in] */ 
+            _In_  UINT ProcAmpCap,
+            /* [annotation][out] */ 
+            _Out_  DXVA2_ValueRange *pRange);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetFilterPropertyRange )( 
+            IDirectXVideoProcessor * This,
+            /* [annotation][in] */ 
+            _In_  UINT FilterSetting,
+            /* [annotation][out] */ 
+            _Out_  DXVA2_ValueRange *pRange);
+        
+        HRESULT ( STDMETHODCALLTYPE *VideoProcessBlt )( 
+            IDirectXVideoProcessor * This,
+            /* [annotation][in] */ 
+            _In_  IDirect3DSurface9 *pRenderTarget,
+            /* [annotation][in] */ 
+            _In_  const DXVA2_VideoProcessBltParams *pBltParams,
+            /* [annotation][size_is][in] */ 
+            _In_reads_(NumSamples)  const DXVA2_VideoSample *pSamples,
+            /* [annotation][in] */ 
+            _In_  UINT NumSamples,
+            /* [annotation][out] */ 
+            _Inout_opt_  HANDLE *pHandleComplete);
+        
+        END_INTERFACE
+    } IDirectXVideoProcessorVtbl;
+
+    interface IDirectXVideoProcessor
+    {
+        CONST_VTBL struct IDirectXVideoProcessorVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDirectXVideoProcessor_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDirectXVideoProcessor_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDirectXVideoProcessor_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDirectXVideoProcessor_GetVideoProcessorService(This,ppService)	\
+    ( (This)->lpVtbl -> GetVideoProcessorService(This,ppService) ) 
+
+#define IDirectXVideoProcessor_GetCreationParameters(This,pDeviceGuid,pVideoDesc,pRenderTargetFormat,pMaxNumSubStreams)	\
+    ( (This)->lpVtbl -> GetCreationParameters(This,pDeviceGuid,pVideoDesc,pRenderTargetFormat,pMaxNumSubStreams) ) 
+
+#define IDirectXVideoProcessor_GetVideoProcessorCaps(This,pCaps)	\
+    ( (This)->lpVtbl -> GetVideoProcessorCaps(This,pCaps) ) 
+
+#define IDirectXVideoProcessor_GetProcAmpRange(This,ProcAmpCap,pRange)	\
+    ( (This)->lpVtbl -> GetProcAmpRange(This,ProcAmpCap,pRange) ) 
+
+#define IDirectXVideoProcessor_GetFilterPropertyRange(This,FilterSetting,pRange)	\
+    ( (This)->lpVtbl -> GetFilterPropertyRange(This,FilterSetting,pRange) ) 
+
+#define IDirectXVideoProcessor_VideoProcessBlt(This,pRenderTarget,pBltParams,pSamples,NumSamples,pHandleComplete)	\
+    ( (This)->lpVtbl -> VideoProcessBlt(This,pRenderTarget,pBltParams,pSamples,NumSamples,pHandleComplete) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDirectXVideoProcessor_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_dxva2api_0000_0006 */
+/* [local] */ 
+
+typedef /* [public][public][public] */ 
+enum __MIDL___MIDL_itf_dxva2api_0000_0006_0001
+    {
+        DXVA2_SurfaceType_DecoderRenderTarget	= 0,
+        DXVA2_SurfaceType_ProcessorRenderTarget	= 1,
+        DXVA2_SurfaceType_D3DRenderTargetTexture	= 2
+    } 	DXVA2_SurfaceType;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_dxva2api_0000_0006_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_dxva2api_0000_0006_v0_0_s_ifspec;
+
+#ifndef __IDirectXVideoMemoryConfiguration_INTERFACE_DEFINED__
+#define __IDirectXVideoMemoryConfiguration_INTERFACE_DEFINED__
+
+/* interface IDirectXVideoMemoryConfiguration */
+/* [local][helpstring][uuid][object] */ 
+
+
+EXTERN_C const IID IID_IDirectXVideoMemoryConfiguration;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("b7f916dd-db3b-49c1-84d7-e45ef99ec726")
+    IDirectXVideoMemoryConfiguration : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetAvailableSurfaceTypeByIndex( 
+            /* [annotation][in] */ 
+            _In_  DWORD dwTypeIndex,
+            /* [annotation][out] */ 
+            _Out_  DXVA2_SurfaceType *pdwType) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetSurfaceType( 
+            /* [annotation][in] */ 
+            _In_  DXVA2_SurfaceType dwType) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct IDirectXVideoMemoryConfigurationVtbl
+    {
+        BEGIN_INTERFACE
+        
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            IDirectXVideoMemoryConfiguration * This,
+            /* [in] */ REFIID riid,
+            /* [annotation][iid_is][out] */ 
+            _COM_Outptr_  void **ppvObject);
+        
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            IDirectXVideoMemoryConfiguration * This);
+        
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            IDirectXVideoMemoryConfiguration * This);
+        
+        HRESULT ( STDMETHODCALLTYPE *GetAvailableSurfaceTypeByIndex )( 
+            IDirectXVideoMemoryConfiguration * This,
+            /* [annotation][in] */ 
+            _In_  DWORD dwTypeIndex,
+            /* [annotation][out] */ 
+            _Out_  DXVA2_SurfaceType *pdwType);
+        
+        HRESULT ( STDMETHODCALLTYPE *SetSurfaceType )( 
+            IDirectXVideoMemoryConfiguration * This,
+            /* [annotation][in] */ 
+            _In_  DXVA2_SurfaceType dwType);
+        
+        END_INTERFACE
+    } IDirectXVideoMemoryConfigurationVtbl;
+
+    interface IDirectXVideoMemoryConfiguration
+    {
+        CONST_VTBL struct IDirectXVideoMemoryConfigurationVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define IDirectXVideoMemoryConfiguration_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define IDirectXVideoMemoryConfiguration_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define IDirectXVideoMemoryConfiguration_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define IDirectXVideoMemoryConfiguration_GetAvailableSurfaceTypeByIndex(This,dwTypeIndex,pdwType)	\
+    ( (This)->lpVtbl -> GetAvailableSurfaceTypeByIndex(This,dwTypeIndex,pdwType) ) 
+
+#define IDirectXVideoMemoryConfiguration_SetSurfaceType(This,dwType)	\
+    ( (This)->lpVtbl -> SetSurfaceType(This,dwType) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __IDirectXVideoMemoryConfiguration_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_dxva2api_0000_0007 */
+/* [local] */ 
+
+STDAPI DXVA2CreateDirect3DDeviceManager9(
+    _Out_ UINT* pResetToken,
+    _Outptr_ IDirect3DDeviceManager9** ppDeviceManager
+    );
+STDAPI DXVA2CreateVideoService(
+    _In_ IDirect3DDevice9* pDD,
+    _In_ REFIID riid,
+    _Outptr_ void** ppService
+    );
+#endif  // _D3D9_H_
+__inline DXVA2_Fixed32 DXVA2FloatToFixed(_In_ const float _float_)
+{
+    DXVA2_Fixed32 _fixed_;
+    _fixed_.Fraction = LOWORD(_float_ * 0x10000);
+    _fixed_.Value = HIWORD(_float_ * 0x10000);
+    return _fixed_;
+}
+__inline float DXVA2FixedToFloat(_In_ const DXVA2_Fixed32 _fixed_)
+{
+    return (FLOAT)_fixed_.Value + (FLOAT)_fixed_.Fraction / 0x10000;
+}
+__inline const DXVA2_Fixed32 DXVA2_Fixed32TransparentAlpha()
+{
+    DXVA2_Fixed32 _fixed_ = {0, 0};
+    return _fixed_;
+}
+__inline const DXVA2_Fixed32 DXVA2_Fixed32OpaqueAlpha()
+{
+    DXVA2_Fixed32 _fixed_ = {0, 1};
+    return _fixed_;
+}
+#endif
+
+
+extern RPC_IF_HANDLE __MIDL_itf_dxva2api_0000_0007_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_dxva2api_0000_0007_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+