Updated directx-headers.

3rdparty/directx-headers/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) Microsoft Corporation.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

3rdparty/directx-headers/include/directx/d3d12compatibility.h

@@ -0,0 +1,739 @@
+/*-------------------------------------------------------------------------------------
+ *
+ * Copyright (c) Microsoft Corporation
+ * Licensed under the MIT license
+ *
+ *-------------------------------------------------------------------------------------*/
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 8.01.0628 */
+
+
+
+/* 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 __d3d12compatibility_h__
+#define __d3d12compatibility_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+#ifndef DECLSPEC_XFGVIRT
+#if defined(_CONTROL_FLOW_GUARD_XFG)
+#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func))
+#else
+#define DECLSPEC_XFGVIRT(base, func)
+#endif
+#endif
+
+/* Forward Declarations */ 
+
+#ifndef __ID3D12CompatibilityDevice_FWD_DEFINED__
+#define __ID3D12CompatibilityDevice_FWD_DEFINED__
+typedef interface ID3D12CompatibilityDevice ID3D12CompatibilityDevice;
+
+#endif 	/* __ID3D12CompatibilityDevice_FWD_DEFINED__ */
+
+
+#ifndef __D3D11On12CreatorID_FWD_DEFINED__
+#define __D3D11On12CreatorID_FWD_DEFINED__
+typedef interface D3D11On12CreatorID D3D11On12CreatorID;
+
+#endif 	/* __D3D11On12CreatorID_FWD_DEFINED__ */
+
+
+#ifndef __D3D9On12CreatorID_FWD_DEFINED__
+#define __D3D9On12CreatorID_FWD_DEFINED__
+typedef interface D3D9On12CreatorID D3D9On12CreatorID;
+
+#endif 	/* __D3D9On12CreatorID_FWD_DEFINED__ */
+
+
+#ifndef __OpenGLOn12CreatorID_FWD_DEFINED__
+#define __OpenGLOn12CreatorID_FWD_DEFINED__
+typedef interface OpenGLOn12CreatorID OpenGLOn12CreatorID;
+
+#endif 	/* __OpenGLOn12CreatorID_FWD_DEFINED__ */
+
+
+#ifndef __OpenCLOn12CreatorID_FWD_DEFINED__
+#define __OpenCLOn12CreatorID_FWD_DEFINED__
+typedef interface OpenCLOn12CreatorID OpenCLOn12CreatorID;
+
+#endif 	/* __OpenCLOn12CreatorID_FWD_DEFINED__ */
+
+
+#ifndef __DirectMLTensorFlowCreatorID_FWD_DEFINED__
+#define __DirectMLTensorFlowCreatorID_FWD_DEFINED__
+typedef interface DirectMLTensorFlowCreatorID DirectMLTensorFlowCreatorID;
+
+#endif 	/* __DirectMLTensorFlowCreatorID_FWD_DEFINED__ */
+
+
+#ifndef __DirectMLPyTorchCreatorID_FWD_DEFINED__
+#define __DirectMLPyTorchCreatorID_FWD_DEFINED__
+typedef interface DirectMLPyTorchCreatorID DirectMLPyTorchCreatorID;
+
+#endif 	/* __DirectMLPyTorchCreatorID_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "oaidl.h"
+#include "ocidl.h"
+#include "d3d11on12.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_d3d12compatibility_0000_0000 */
+/* [local] */ 
+
+#include <winapifamily.h>
+#pragma region Desktop Family
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES)
+typedef 
+enum D3D12_COMPATIBILITY_SHARED_FLAGS
+    {
+        D3D12_COMPATIBILITY_SHARED_FLAG_NONE	= 0,
+        D3D12_COMPATIBILITY_SHARED_FLAG_NON_NT_HANDLE	= 0x1,
+        D3D12_COMPATIBILITY_SHARED_FLAG_KEYED_MUTEX	= 0x2,
+        D3D12_COMPATIBILITY_SHARED_FLAG_9_ON_12	= 0x4
+    } 	D3D12_COMPATIBILITY_SHARED_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_COMPATIBILITY_SHARED_FLAGS );
+typedef 
+enum D3D12_REFLECT_SHARED_PROPERTY
+    {
+        D3D12_REFLECT_SHARED_PROPERTY_D3D11_RESOURCE_FLAGS	= 0,
+        D3D12_REFELCT_SHARED_PROPERTY_COMPATIBILITY_SHARED_FLAGS	= ( D3D12_REFLECT_SHARED_PROPERTY_D3D11_RESOURCE_FLAGS + 1 ) ,
+        D3D12_REFLECT_SHARED_PROPERTY_NON_NT_SHARED_HANDLE	= ( D3D12_REFELCT_SHARED_PROPERTY_COMPATIBILITY_SHARED_FLAGS + 1 ) 
+    } 	D3D12_REFLECT_SHARED_PROPERTY;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0000_v0_0_s_ifspec;
+
+#ifndef __ID3D12CompatibilityDevice_INTERFACE_DEFINED__
+#define __ID3D12CompatibilityDevice_INTERFACE_DEFINED__
+
+/* interface ID3D12CompatibilityDevice */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12CompatibilityDevice;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8f1c0e3c-fae3-4a82-b098-bfe1708207ff")
+    ID3D12CompatibilityDevice : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateSharedResource( 
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  const D3D11_RESOURCE_FLAGS *pFlags11,
+            D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
+            _In_opt_  ID3D12LifetimeTracker *pLifetimeTracker,
+            _In_opt_  ID3D12SwapChainAssistant *pOwningSwapchain,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppResource) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateSharedHeap( 
+            _In_  const D3D12_HEAP_DESC *pHeapDesc,
+            D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppHeap) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReflectSharedProperties( 
+            _In_  ID3D12Object *pHeapOrResource,
+            D3D12_REFLECT_SHARED_PROPERTY ReflectType,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12CompatibilityDeviceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12CompatibilityDevice * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12CompatibilityDevice * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12CompatibilityDevice * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompatibilityDevice, CreateSharedResource)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedResource )( 
+            ID3D12CompatibilityDevice * This,
+            _In_  const D3D12_HEAP_PROPERTIES *pHeapProperties,
+            D3D12_HEAP_FLAGS HeapFlags,
+            _In_  const D3D12_RESOURCE_DESC *pDesc,
+            D3D12_RESOURCE_STATES InitialResourceState,
+            _In_opt_  const D3D12_CLEAR_VALUE *pOptimizedClearValue,
+            _In_opt_  const D3D11_RESOURCE_FLAGS *pFlags11,
+            D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
+            _In_opt_  ID3D12LifetimeTracker *pLifetimeTracker,
+            _In_opt_  ID3D12SwapChainAssistant *pOwningSwapchain,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppResource);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompatibilityDevice, CreateSharedHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateSharedHeap )( 
+            ID3D12CompatibilityDevice * This,
+            _In_  const D3D12_HEAP_DESC *pHeapDesc,
+            D3D12_COMPATIBILITY_SHARED_FLAGS CompatibilityFlags,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12CompatibilityDevice, ReflectSharedProperties)
+        HRESULT ( STDMETHODCALLTYPE *ReflectSharedProperties )( 
+            ID3D12CompatibilityDevice * This,
+            _In_  ID3D12Object *pHeapOrResource,
+            D3D12_REFLECT_SHARED_PROPERTY ReflectType,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize);
+        
+        END_INTERFACE
+    } ID3D12CompatibilityDeviceVtbl;
+
+    interface ID3D12CompatibilityDevice
+    {
+        CONST_VTBL struct ID3D12CompatibilityDeviceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12CompatibilityDevice_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12CompatibilityDevice_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12CompatibilityDevice_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12CompatibilityDevice_CreateSharedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pFlags11,CompatibilityFlags,pLifetimeTracker,pOwningSwapchain,riid,ppResource)	\
+    ( (This)->lpVtbl -> CreateSharedResource(This,pHeapProperties,HeapFlags,pDesc,InitialResourceState,pOptimizedClearValue,pFlags11,CompatibilityFlags,pLifetimeTracker,pOwningSwapchain,riid,ppResource) ) 
+
+#define ID3D12CompatibilityDevice_CreateSharedHeap(This,pHeapDesc,CompatibilityFlags,riid,ppHeap)	\
+    ( (This)->lpVtbl -> CreateSharedHeap(This,pHeapDesc,CompatibilityFlags,riid,ppHeap) ) 
+
+#define ID3D12CompatibilityDevice_ReflectSharedProperties(This,pHeapOrResource,ReflectType,pData,DataSize)	\
+    ( (This)->lpVtbl -> ReflectSharedProperties(This,pHeapOrResource,ReflectType,pData,DataSize) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12CompatibilityDevice_INTERFACE_DEFINED__ */
+
+
+#ifndef __D3D11On12CreatorID_INTERFACE_DEFINED__
+#define __D3D11On12CreatorID_INTERFACE_DEFINED__
+
+/* interface D3D11On12CreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_D3D11On12CreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("edbf5678-2960-4e81-8429-99d4b2630c4e")
+    D3D11On12CreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct D3D11On12CreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            D3D11On12CreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            D3D11On12CreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            D3D11On12CreatorID * This);
+        
+        END_INTERFACE
+    } D3D11On12CreatorIDVtbl;
+
+    interface D3D11On12CreatorID
+    {
+        CONST_VTBL struct D3D11On12CreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define D3D11On12CreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define D3D11On12CreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define D3D11On12CreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __D3D11On12CreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __D3D9On12CreatorID_INTERFACE_DEFINED__
+#define __D3D9On12CreatorID_INTERFACE_DEFINED__
+
+/* interface D3D9On12CreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_D3D9On12CreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("fffcbb7f-15d3-42a2-841e-9d8d32f37ddd")
+    D3D9On12CreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct D3D9On12CreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            D3D9On12CreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            D3D9On12CreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            D3D9On12CreatorID * This);
+        
+        END_INTERFACE
+    } D3D9On12CreatorIDVtbl;
+
+    interface D3D9On12CreatorID
+    {
+        CONST_VTBL struct D3D9On12CreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define D3D9On12CreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define D3D9On12CreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define D3D9On12CreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __D3D9On12CreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __OpenGLOn12CreatorID_INTERFACE_DEFINED__
+#define __OpenGLOn12CreatorID_INTERFACE_DEFINED__
+
+/* interface OpenGLOn12CreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_OpenGLOn12CreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("6bb3cd34-0d19-45ab-97ed-d720ba3dfc80")
+    OpenGLOn12CreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct OpenGLOn12CreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            OpenGLOn12CreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            OpenGLOn12CreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            OpenGLOn12CreatorID * This);
+        
+        END_INTERFACE
+    } OpenGLOn12CreatorIDVtbl;
+
+    interface OpenGLOn12CreatorID
+    {
+        CONST_VTBL struct OpenGLOn12CreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define OpenGLOn12CreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define OpenGLOn12CreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define OpenGLOn12CreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __OpenGLOn12CreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __OpenCLOn12CreatorID_INTERFACE_DEFINED__
+#define __OpenCLOn12CreatorID_INTERFACE_DEFINED__
+
+/* interface OpenCLOn12CreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_OpenCLOn12CreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("3f76bb74-91b5-4a88-b126-20ca0331cd60")
+    OpenCLOn12CreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct OpenCLOn12CreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            OpenCLOn12CreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            OpenCLOn12CreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            OpenCLOn12CreatorID * This);
+        
+        END_INTERFACE
+    } OpenCLOn12CreatorIDVtbl;
+
+    interface OpenCLOn12CreatorID
+    {
+        CONST_VTBL struct OpenCLOn12CreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define OpenCLOn12CreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define OpenCLOn12CreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define OpenCLOn12CreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __OpenCLOn12CreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __DirectMLTensorFlowCreatorID_INTERFACE_DEFINED__
+#define __DirectMLTensorFlowCreatorID_INTERFACE_DEFINED__
+
+/* interface DirectMLTensorFlowCreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_DirectMLTensorFlowCreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("cb7490ac-8a0f-44ec-9b7b-6f4cafe8e9ab")
+    DirectMLTensorFlowCreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct DirectMLTensorFlowCreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            DirectMLTensorFlowCreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            DirectMLTensorFlowCreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            DirectMLTensorFlowCreatorID * This);
+        
+        END_INTERFACE
+    } DirectMLTensorFlowCreatorIDVtbl;
+
+    interface DirectMLTensorFlowCreatorID
+    {
+        CONST_VTBL struct DirectMLTensorFlowCreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define DirectMLTensorFlowCreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define DirectMLTensorFlowCreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define DirectMLTensorFlowCreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __DirectMLTensorFlowCreatorID_INTERFACE_DEFINED__ */
+
+
+#ifndef __DirectMLPyTorchCreatorID_INTERFACE_DEFINED__
+#define __DirectMLPyTorchCreatorID_INTERFACE_DEFINED__
+
+/* interface DirectMLPyTorchCreatorID */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_DirectMLPyTorchCreatorID;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("af029192-fba1-4b05-9116-235e06560354")
+    DirectMLPyTorchCreatorID : public IUnknown
+    {
+    public:
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct DirectMLPyTorchCreatorIDVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            DirectMLPyTorchCreatorID * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            DirectMLPyTorchCreatorID * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            DirectMLPyTorchCreatorID * This);
+        
+        END_INTERFACE
+    } DirectMLPyTorchCreatorIDVtbl;
+
+    interface DirectMLPyTorchCreatorID
+    {
+        CONST_VTBL struct DirectMLPyTorchCreatorIDVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define DirectMLPyTorchCreatorID_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define DirectMLPyTorchCreatorID_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define DirectMLPyTorchCreatorID_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __DirectMLPyTorchCreatorID_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12compatibility_0000_0007 */
+/* [local] */ 
+
+#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */
+#pragma endregion
+DEFINE_GUID(IID_ID3D12CompatibilityDevice,0x8f1c0e3c,0xfae3,0x4a82,0xb0,0x98,0xbf,0xe1,0x70,0x82,0x07,0xff);
+DEFINE_GUID(IID_D3D11On12CreatorID,0xedbf5678,0x2960,0x4e81,0x84,0x29,0x99,0xd4,0xb2,0x63,0x0c,0x4e);
+DEFINE_GUID(IID_D3D9On12CreatorID,0xfffcbb7f,0x15d3,0x42a2,0x84,0x1e,0x9d,0x8d,0x32,0xf3,0x7d,0xdd);
+DEFINE_GUID(IID_OpenGLOn12CreatorID,0x6bb3cd34,0x0d19,0x45ab,0x97,0xed,0xd7,0x20,0xba,0x3d,0xfc,0x80);
+DEFINE_GUID(IID_OpenCLOn12CreatorID,0x3f76bb74,0x91b5,0x4a88,0xb1,0x26,0x20,0xca,0x03,0x31,0xcd,0x60);
+DEFINE_GUID(IID_DirectMLTensorFlowCreatorID,0xcb7490ac,0x8a0f,0x44ec,0x9b,0x7b,0x6f,0x4c,0xaf,0xe8,0xe9,0xab);
+DEFINE_GUID(IID_DirectMLPyTorchCreatorID,0xaf029192,0xfba1,0x4b05,0x91,0x16,0x23,0x5e,0x06,0x56,0x03,0x54);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0007_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12compatibility_0000_0007_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+

3rdparty/directx-headers/include/directx/d3d12sdklayers.h

@@ -0,0 +1,4110 @@
+/*-------------------------------------------------------------------------------------
+ *
+ * Copyright (c) Microsoft Corporation
+ * Licensed under the MIT license
+ *
+ *-------------------------------------------------------------------------------------*/
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 8.01.0628 */
+
+
+
+/* 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 __d3d12sdklayers_h__
+#define __d3d12sdklayers_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+#ifndef DECLSPEC_XFGVIRT
+#if defined(_CONTROL_FLOW_GUARD_XFG)
+#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func))
+#else
+#define DECLSPEC_XFGVIRT(base, func)
+#endif
+#endif
+
+/* Forward Declarations */ 
+
+#ifndef __ID3D12Debug_FWD_DEFINED__
+#define __ID3D12Debug_FWD_DEFINED__
+typedef interface ID3D12Debug ID3D12Debug;
+
+#endif 	/* __ID3D12Debug_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Debug1_FWD_DEFINED__
+#define __ID3D12Debug1_FWD_DEFINED__
+typedef interface ID3D12Debug1 ID3D12Debug1;
+
+#endif 	/* __ID3D12Debug1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Debug2_FWD_DEFINED__
+#define __ID3D12Debug2_FWD_DEFINED__
+typedef interface ID3D12Debug2 ID3D12Debug2;
+
+#endif 	/* __ID3D12Debug2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Debug3_FWD_DEFINED__
+#define __ID3D12Debug3_FWD_DEFINED__
+typedef interface ID3D12Debug3 ID3D12Debug3;
+
+#endif 	/* __ID3D12Debug3_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Debug4_FWD_DEFINED__
+#define __ID3D12Debug4_FWD_DEFINED__
+typedef interface ID3D12Debug4 ID3D12Debug4;
+
+#endif 	/* __ID3D12Debug4_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Debug5_FWD_DEFINED__
+#define __ID3D12Debug5_FWD_DEFINED__
+typedef interface ID3D12Debug5 ID3D12Debug5;
+
+#endif 	/* __ID3D12Debug5_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12Debug6_FWD_DEFINED__
+#define __ID3D12Debug6_FWD_DEFINED__
+typedef interface ID3D12Debug6 ID3D12Debug6;
+
+#endif 	/* __ID3D12Debug6_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DebugDevice1_FWD_DEFINED__
+#define __ID3D12DebugDevice1_FWD_DEFINED__
+typedef interface ID3D12DebugDevice1 ID3D12DebugDevice1;
+
+#endif 	/* __ID3D12DebugDevice1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DebugDevice_FWD_DEFINED__
+#define __ID3D12DebugDevice_FWD_DEFINED__
+typedef interface ID3D12DebugDevice ID3D12DebugDevice;
+
+#endif 	/* __ID3D12DebugDevice_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DebugDevice2_FWD_DEFINED__
+#define __ID3D12DebugDevice2_FWD_DEFINED__
+typedef interface ID3D12DebugDevice2 ID3D12DebugDevice2;
+
+#endif 	/* __ID3D12DebugDevice2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandQueue_FWD_DEFINED__
+#define __ID3D12DebugCommandQueue_FWD_DEFINED__
+typedef interface ID3D12DebugCommandQueue ID3D12DebugCommandQueue;
+
+#endif 	/* __ID3D12DebugCommandQueue_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandQueue1_FWD_DEFINED__
+#define __ID3D12DebugCommandQueue1_FWD_DEFINED__
+typedef interface ID3D12DebugCommandQueue1 ID3D12DebugCommandQueue1;
+
+#endif 	/* __ID3D12DebugCommandQueue1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandList1_FWD_DEFINED__
+#define __ID3D12DebugCommandList1_FWD_DEFINED__
+typedef interface ID3D12DebugCommandList1 ID3D12DebugCommandList1;
+
+#endif 	/* __ID3D12DebugCommandList1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandList_FWD_DEFINED__
+#define __ID3D12DebugCommandList_FWD_DEFINED__
+typedef interface ID3D12DebugCommandList ID3D12DebugCommandList;
+
+#endif 	/* __ID3D12DebugCommandList_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandList2_FWD_DEFINED__
+#define __ID3D12DebugCommandList2_FWD_DEFINED__
+typedef interface ID3D12DebugCommandList2 ID3D12DebugCommandList2;
+
+#endif 	/* __ID3D12DebugCommandList2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandList3_FWD_DEFINED__
+#define __ID3D12DebugCommandList3_FWD_DEFINED__
+typedef interface ID3D12DebugCommandList3 ID3D12DebugCommandList3;
+
+#endif 	/* __ID3D12DebugCommandList3_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12SharingContract_FWD_DEFINED__
+#define __ID3D12SharingContract_FWD_DEFINED__
+typedef interface ID3D12SharingContract ID3D12SharingContract;
+
+#endif 	/* __ID3D12SharingContract_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12InfoQueue_FWD_DEFINED__
+#define __ID3D12InfoQueue_FWD_DEFINED__
+typedef interface ID3D12InfoQueue ID3D12InfoQueue;
+
+#endif 	/* __ID3D12InfoQueue_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12InfoQueue1_FWD_DEFINED__
+#define __ID3D12InfoQueue1_FWD_DEFINED__
+typedef interface ID3D12InfoQueue1 ID3D12InfoQueue1;
+
+#endif 	/* __ID3D12InfoQueue1_FWD_DEFINED__ */
+
+
+/* header files for imported files */
+#include "oaidl.h"
+#include "ocidl.h"
+#include "d3d12.h"
+
+#ifdef __cplusplus
+extern "C"{
+#endif 
+
+
+/* interface __MIDL_itf_d3d12sdklayers_0000_0000 */
+/* [local] */ 
+
+#include <winapifamily.h>
+#pragma region App Family
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES)
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0000_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0000_v0_0_s_ifspec;
+
+#ifndef __ID3D12Debug_INTERFACE_DEFINED__
+#define __ID3D12Debug_INTERFACE_DEFINED__
+
+/* interface ID3D12Debug */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Debug;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("344488b7-6846-474b-b989-f027448245e0")
+    ID3D12Debug : public IUnknown
+    {
+    public:
+        virtual void STDMETHODCALLTYPE EnableDebugLayer( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Debug * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Debug * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Debug * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug, EnableDebugLayer)
+        void ( STDMETHODCALLTYPE *EnableDebugLayer )( 
+            ID3D12Debug * This);
+        
+        END_INTERFACE
+    } ID3D12DebugVtbl;
+
+    interface ID3D12Debug
+    {
+        CONST_VTBL struct ID3D12DebugVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Debug_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Debug_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Debug_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Debug_EnableDebugLayer(This)	\
+    ( (This)->lpVtbl -> EnableDebugLayer(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Debug_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12sdklayers_0000_0001 */
+/* [local] */ 
+
+typedef 
+enum D3D12_GPU_BASED_VALIDATION_FLAGS
+    {
+        D3D12_GPU_BASED_VALIDATION_FLAGS_NONE	= 0,
+        D3D12_GPU_BASED_VALIDATION_FLAGS_DISABLE_STATE_TRACKING	= 0x1
+    } 	D3D12_GPU_BASED_VALIDATION_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_GPU_BASED_VALIDATION_FLAGS)
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0001_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0001_v0_0_s_ifspec;
+
+#ifndef __ID3D12Debug1_INTERFACE_DEFINED__
+#define __ID3D12Debug1_INTERFACE_DEFINED__
+
+/* interface ID3D12Debug1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Debug1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("affaa4ca-63fe-4d8e-b8ad-159000af4304")
+    ID3D12Debug1 : public IUnknown
+    {
+    public:
+        virtual void STDMETHODCALLTYPE EnableDebugLayer( void) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetEnableGPUBasedValidation( 
+            BOOL Enable) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetEnableSynchronizedCommandQueueValidation( 
+            BOOL Enable) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Debug1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Debug1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Debug1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Debug1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug1, EnableDebugLayer)
+        void ( STDMETHODCALLTYPE *EnableDebugLayer )( 
+            ID3D12Debug1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug1, SetEnableGPUBasedValidation)
+        void ( STDMETHODCALLTYPE *SetEnableGPUBasedValidation )( 
+            ID3D12Debug1 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug1, SetEnableSynchronizedCommandQueueValidation)
+        void ( STDMETHODCALLTYPE *SetEnableSynchronizedCommandQueueValidation )( 
+            ID3D12Debug1 * This,
+            BOOL Enable);
+        
+        END_INTERFACE
+    } ID3D12Debug1Vtbl;
+
+    interface ID3D12Debug1
+    {
+        CONST_VTBL struct ID3D12Debug1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Debug1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Debug1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Debug1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Debug1_EnableDebugLayer(This)	\
+    ( (This)->lpVtbl -> EnableDebugLayer(This) ) 
+
+#define ID3D12Debug1_SetEnableGPUBasedValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableGPUBasedValidation(This,Enable) ) 
+
+#define ID3D12Debug1_SetEnableSynchronizedCommandQueueValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableSynchronizedCommandQueueValidation(This,Enable) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Debug1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Debug2_INTERFACE_DEFINED__
+#define __ID3D12Debug2_INTERFACE_DEFINED__
+
+/* interface ID3D12Debug2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Debug2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("93a665c4-a3b2-4e5d-b692-a26ae14e3374")
+    ID3D12Debug2 : public IUnknown
+    {
+    public:
+        virtual void STDMETHODCALLTYPE SetGPUBasedValidationFlags( 
+            D3D12_GPU_BASED_VALIDATION_FLAGS Flags) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Debug2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Debug2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Debug2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Debug2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug2, SetGPUBasedValidationFlags)
+        void ( STDMETHODCALLTYPE *SetGPUBasedValidationFlags )( 
+            ID3D12Debug2 * This,
+            D3D12_GPU_BASED_VALIDATION_FLAGS Flags);
+        
+        END_INTERFACE
+    } ID3D12Debug2Vtbl;
+
+    interface ID3D12Debug2
+    {
+        CONST_VTBL struct ID3D12Debug2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Debug2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Debug2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Debug2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Debug2_SetGPUBasedValidationFlags(This,Flags)	\
+    ( (This)->lpVtbl -> SetGPUBasedValidationFlags(This,Flags) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Debug2_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Debug3_INTERFACE_DEFINED__
+#define __ID3D12Debug3_INTERFACE_DEFINED__
+
+/* interface ID3D12Debug3 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Debug3;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("5cf4e58f-f671-4ff1-a542-3686e3d153d1")
+    ID3D12Debug3 : public ID3D12Debug
+    {
+    public:
+        virtual void STDMETHODCALLTYPE SetEnableGPUBasedValidation( 
+            BOOL Enable) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetEnableSynchronizedCommandQueueValidation( 
+            BOOL Enable) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetGPUBasedValidationFlags( 
+            D3D12_GPU_BASED_VALIDATION_FLAGS Flags) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Debug3Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Debug3 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Debug3 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Debug3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug, EnableDebugLayer)
+        void ( STDMETHODCALLTYPE *EnableDebugLayer )( 
+            ID3D12Debug3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetEnableGPUBasedValidation)
+        void ( STDMETHODCALLTYPE *SetEnableGPUBasedValidation )( 
+            ID3D12Debug3 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetEnableSynchronizedCommandQueueValidation)
+        void ( STDMETHODCALLTYPE *SetEnableSynchronizedCommandQueueValidation )( 
+            ID3D12Debug3 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetGPUBasedValidationFlags)
+        void ( STDMETHODCALLTYPE *SetGPUBasedValidationFlags )( 
+            ID3D12Debug3 * This,
+            D3D12_GPU_BASED_VALIDATION_FLAGS Flags);
+        
+        END_INTERFACE
+    } ID3D12Debug3Vtbl;
+
+    interface ID3D12Debug3
+    {
+        CONST_VTBL struct ID3D12Debug3Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Debug3_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Debug3_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Debug3_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Debug3_EnableDebugLayer(This)	\
+    ( (This)->lpVtbl -> EnableDebugLayer(This) ) 
+
+
+#define ID3D12Debug3_SetEnableGPUBasedValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableGPUBasedValidation(This,Enable) ) 
+
+#define ID3D12Debug3_SetEnableSynchronizedCommandQueueValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableSynchronizedCommandQueueValidation(This,Enable) ) 
+
+#define ID3D12Debug3_SetGPUBasedValidationFlags(This,Flags)	\
+    ( (This)->lpVtbl -> SetGPUBasedValidationFlags(This,Flags) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Debug3_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Debug4_INTERFACE_DEFINED__
+#define __ID3D12Debug4_INTERFACE_DEFINED__
+
+/* interface ID3D12Debug4 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Debug4;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("014b816e-9ec5-4a2f-a845-ffbe441ce13a")
+    ID3D12Debug4 : public ID3D12Debug3
+    {
+    public:
+        virtual void STDMETHODCALLTYPE DisableDebugLayer( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Debug4Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Debug4 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Debug4 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Debug4 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug, EnableDebugLayer)
+        void ( STDMETHODCALLTYPE *EnableDebugLayer )( 
+            ID3D12Debug4 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetEnableGPUBasedValidation)
+        void ( STDMETHODCALLTYPE *SetEnableGPUBasedValidation )( 
+            ID3D12Debug4 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetEnableSynchronizedCommandQueueValidation)
+        void ( STDMETHODCALLTYPE *SetEnableSynchronizedCommandQueueValidation )( 
+            ID3D12Debug4 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetGPUBasedValidationFlags)
+        void ( STDMETHODCALLTYPE *SetGPUBasedValidationFlags )( 
+            ID3D12Debug4 * This,
+            D3D12_GPU_BASED_VALIDATION_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug4, DisableDebugLayer)
+        void ( STDMETHODCALLTYPE *DisableDebugLayer )( 
+            ID3D12Debug4 * This);
+        
+        END_INTERFACE
+    } ID3D12Debug4Vtbl;
+
+    interface ID3D12Debug4
+    {
+        CONST_VTBL struct ID3D12Debug4Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Debug4_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Debug4_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Debug4_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Debug4_EnableDebugLayer(This)	\
+    ( (This)->lpVtbl -> EnableDebugLayer(This) ) 
+
+
+#define ID3D12Debug4_SetEnableGPUBasedValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableGPUBasedValidation(This,Enable) ) 
+
+#define ID3D12Debug4_SetEnableSynchronizedCommandQueueValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableSynchronizedCommandQueueValidation(This,Enable) ) 
+
+#define ID3D12Debug4_SetGPUBasedValidationFlags(This,Flags)	\
+    ( (This)->lpVtbl -> SetGPUBasedValidationFlags(This,Flags) ) 
+
+
+#define ID3D12Debug4_DisableDebugLayer(This)	\
+    ( (This)->lpVtbl -> DisableDebugLayer(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Debug4_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Debug5_INTERFACE_DEFINED__
+#define __ID3D12Debug5_INTERFACE_DEFINED__
+
+/* interface ID3D12Debug5 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Debug5;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("548d6b12-09fa-40e0-9069-5dcd589a52c9")
+    ID3D12Debug5 : public ID3D12Debug4
+    {
+    public:
+        virtual void STDMETHODCALLTYPE SetEnableAutoName( 
+            BOOL Enable) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Debug5Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Debug5 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Debug5 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Debug5 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug, EnableDebugLayer)
+        void ( STDMETHODCALLTYPE *EnableDebugLayer )( 
+            ID3D12Debug5 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetEnableGPUBasedValidation)
+        void ( STDMETHODCALLTYPE *SetEnableGPUBasedValidation )( 
+            ID3D12Debug5 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetEnableSynchronizedCommandQueueValidation)
+        void ( STDMETHODCALLTYPE *SetEnableSynchronizedCommandQueueValidation )( 
+            ID3D12Debug5 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetGPUBasedValidationFlags)
+        void ( STDMETHODCALLTYPE *SetGPUBasedValidationFlags )( 
+            ID3D12Debug5 * This,
+            D3D12_GPU_BASED_VALIDATION_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug4, DisableDebugLayer)
+        void ( STDMETHODCALLTYPE *DisableDebugLayer )( 
+            ID3D12Debug5 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug5, SetEnableAutoName)
+        void ( STDMETHODCALLTYPE *SetEnableAutoName )( 
+            ID3D12Debug5 * This,
+            BOOL Enable);
+        
+        END_INTERFACE
+    } ID3D12Debug5Vtbl;
+
+    interface ID3D12Debug5
+    {
+        CONST_VTBL struct ID3D12Debug5Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Debug5_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Debug5_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Debug5_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Debug5_EnableDebugLayer(This)	\
+    ( (This)->lpVtbl -> EnableDebugLayer(This) ) 
+
+
+#define ID3D12Debug5_SetEnableGPUBasedValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableGPUBasedValidation(This,Enable) ) 
+
+#define ID3D12Debug5_SetEnableSynchronizedCommandQueueValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableSynchronizedCommandQueueValidation(This,Enable) ) 
+
+#define ID3D12Debug5_SetGPUBasedValidationFlags(This,Flags)	\
+    ( (This)->lpVtbl -> SetGPUBasedValidationFlags(This,Flags) ) 
+
+
+#define ID3D12Debug5_DisableDebugLayer(This)	\
+    ( (This)->lpVtbl -> DisableDebugLayer(This) ) 
+
+
+#define ID3D12Debug5_SetEnableAutoName(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableAutoName(This,Enable) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Debug5_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12Debug6_INTERFACE_DEFINED__
+#define __ID3D12Debug6_INTERFACE_DEFINED__
+
+/* interface ID3D12Debug6 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12Debug6;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("82a816d6-5d01-4157-97d0-4975463fd1ed")
+    ID3D12Debug6 : public ID3D12Debug5
+    {
+    public:
+        virtual void STDMETHODCALLTYPE SetForceLegacyBarrierValidation( 
+            BOOL Enable) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12Debug6Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12Debug6 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12Debug6 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12Debug6 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug, EnableDebugLayer)
+        void ( STDMETHODCALLTYPE *EnableDebugLayer )( 
+            ID3D12Debug6 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetEnableGPUBasedValidation)
+        void ( STDMETHODCALLTYPE *SetEnableGPUBasedValidation )( 
+            ID3D12Debug6 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetEnableSynchronizedCommandQueueValidation)
+        void ( STDMETHODCALLTYPE *SetEnableSynchronizedCommandQueueValidation )( 
+            ID3D12Debug6 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug3, SetGPUBasedValidationFlags)
+        void ( STDMETHODCALLTYPE *SetGPUBasedValidationFlags )( 
+            ID3D12Debug6 * This,
+            D3D12_GPU_BASED_VALIDATION_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug4, DisableDebugLayer)
+        void ( STDMETHODCALLTYPE *DisableDebugLayer )( 
+            ID3D12Debug6 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug5, SetEnableAutoName)
+        void ( STDMETHODCALLTYPE *SetEnableAutoName )( 
+            ID3D12Debug6 * This,
+            BOOL Enable);
+        
+        DECLSPEC_XFGVIRT(ID3D12Debug6, SetForceLegacyBarrierValidation)
+        void ( STDMETHODCALLTYPE *SetForceLegacyBarrierValidation )( 
+            ID3D12Debug6 * This,
+            BOOL Enable);
+        
+        END_INTERFACE
+    } ID3D12Debug6Vtbl;
+
+    interface ID3D12Debug6
+    {
+        CONST_VTBL struct ID3D12Debug6Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12Debug6_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12Debug6_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12Debug6_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12Debug6_EnableDebugLayer(This)	\
+    ( (This)->lpVtbl -> EnableDebugLayer(This) ) 
+
+
+#define ID3D12Debug6_SetEnableGPUBasedValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableGPUBasedValidation(This,Enable) ) 
+
+#define ID3D12Debug6_SetEnableSynchronizedCommandQueueValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableSynchronizedCommandQueueValidation(This,Enable) ) 
+
+#define ID3D12Debug6_SetGPUBasedValidationFlags(This,Flags)	\
+    ( (This)->lpVtbl -> SetGPUBasedValidationFlags(This,Flags) ) 
+
+
+#define ID3D12Debug6_DisableDebugLayer(This)	\
+    ( (This)->lpVtbl -> DisableDebugLayer(This) ) 
+
+
+#define ID3D12Debug6_SetEnableAutoName(This,Enable)	\
+    ( (This)->lpVtbl -> SetEnableAutoName(This,Enable) ) 
+
+
+#define ID3D12Debug6_SetForceLegacyBarrierValidation(This,Enable)	\
+    ( (This)->lpVtbl -> SetForceLegacyBarrierValidation(This,Enable) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12Debug6_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12sdklayers_0000_0007 */
+/* [local] */ 
+
+DEFINE_GUID(WKPDID_D3DAutoDebugObjectNameW, 0xd4902e36, 0x757a, 0x4942, 0x95, 0x94, 0xb6, 0x76, 0x9a, 0xfa, 0x43, 0xcd);
+typedef 
+enum D3D12_RLDO_FLAGS
+    {
+        D3D12_RLDO_NONE	= 0,
+        D3D12_RLDO_SUMMARY	= 0x1,
+        D3D12_RLDO_DETAIL	= 0x2,
+        D3D12_RLDO_IGNORE_INTERNAL	= 0x4
+    } 	D3D12_RLDO_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_RLDO_FLAGS)
+typedef 
+enum D3D12_DEBUG_DEVICE_PARAMETER_TYPE
+    {
+        D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS	= 0,
+        D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS	= ( D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS + 1 ) ,
+        D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR	= ( D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS + 1 ) 
+    } 	D3D12_DEBUG_DEVICE_PARAMETER_TYPE;
+
+typedef 
+enum D3D12_DEBUG_FEATURE
+    {
+        D3D12_DEBUG_FEATURE_NONE	= 0,
+        D3D12_DEBUG_FEATURE_ALLOW_BEHAVIOR_CHANGING_DEBUG_AIDS	= 0x1,
+        D3D12_DEBUG_FEATURE_CONSERVATIVE_RESOURCE_STATE_TRACKING	= 0x2,
+        D3D12_DEBUG_FEATURE_DISABLE_VIRTUALIZED_BUNDLES_VALIDATION	= 0x4,
+        D3D12_DEBUG_FEATURE_EMULATE_WINDOWS7	= 0x8
+    } 	D3D12_DEBUG_FEATURE;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_DEBUG_FEATURE)
+typedef 
+enum D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE
+    {
+        D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_NONE	= 0,
+        D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_STATE_TRACKING_ONLY	= ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_NONE + 1 ) ,
+        D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_UNGUARDED_VALIDATION	= ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_STATE_TRACKING_ONLY + 1 ) ,
+        D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_GUARDED_VALIDATION	= ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_UNGUARDED_VALIDATION + 1 ) ,
+        NUM_D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODES	= ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_GUARDED_VALIDATION + 1 ) 
+    } 	D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE;
+
+typedef 
+enum D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS
+    {
+        D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_NONE	= 0,
+        D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_TRACKING_ONLY_SHADERS	= 0x1,
+        D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_UNGUARDED_VALIDATION_SHADERS	= 0x2,
+        D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_GUARDED_VALIDATION_SHADERS	= 0x4,
+        D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS_VALID_MASK	= 0x7
+    } 	D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS)
+typedef struct D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS
+    {
+    UINT MaxMessagesPerCommandList;
+    D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE DefaultShaderPatchMode;
+    D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS PipelineStateCreateFlags;
+    } 	D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS;
+
+typedef struct D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR
+    {
+    FLOAT SlowdownFactor;
+    } 	D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0007_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0007_v0_0_s_ifspec;
+
+#ifndef __ID3D12DebugDevice1_INTERFACE_DEFINED__
+#define __ID3D12DebugDevice1_INTERFACE_DEFINED__
+
+/* interface ID3D12DebugDevice1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DebugDevice1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("a9b71770-d099-4a65-a698-3dee10020f88")
+    ID3D12DebugDevice1 : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( 
+            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
+            _In_reads_bytes_(DataSize)  const void *pData,
+            UINT DataSize) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( 
+            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReportLiveDeviceObjects( 
+            D3D12_RLDO_FLAGS Flags) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugDevice1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DebugDevice1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DebugDevice1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DebugDevice1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice1, SetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( 
+            ID3D12DebugDevice1 * This,
+            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
+            _In_reads_bytes_(DataSize)  const void *pData,
+            UINT DataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice1, GetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( 
+            ID3D12DebugDevice1 * This,
+            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice1, ReportLiveDeviceObjects)
+        HRESULT ( STDMETHODCALLTYPE *ReportLiveDeviceObjects )( 
+            ID3D12DebugDevice1 * This,
+            D3D12_RLDO_FLAGS Flags);
+        
+        END_INTERFACE
+    } ID3D12DebugDevice1Vtbl;
+
+    interface ID3D12DebugDevice1
+    {
+        CONST_VTBL struct ID3D12DebugDevice1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DebugDevice1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DebugDevice1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DebugDevice1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DebugDevice1_SetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) 
+
+#define ID3D12DebugDevice1_GetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) 
+
+#define ID3D12DebugDevice1_ReportLiveDeviceObjects(This,Flags)	\
+    ( (This)->lpVtbl -> ReportLiveDeviceObjects(This,Flags) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DebugDevice1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DebugDevice_INTERFACE_DEFINED__
+#define __ID3D12DebugDevice_INTERFACE_DEFINED__
+
+/* interface ID3D12DebugDevice */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DebugDevice;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("3febd6dd-4973-4787-8194-e45f9e28923e")
+    ID3D12DebugDevice : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE SetFeatureMask( 
+            D3D12_DEBUG_FEATURE Mask) = 0;
+        
+        virtual D3D12_DEBUG_FEATURE STDMETHODCALLTYPE GetFeatureMask( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ReportLiveDeviceObjects( 
+            D3D12_RLDO_FLAGS Flags) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugDeviceVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DebugDevice * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DebugDevice * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DebugDevice * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice, SetFeatureMask)
+        HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( 
+            ID3D12DebugDevice * This,
+            D3D12_DEBUG_FEATURE Mask);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice, GetFeatureMask)
+        D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( 
+            ID3D12DebugDevice * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice, ReportLiveDeviceObjects)
+        HRESULT ( STDMETHODCALLTYPE *ReportLiveDeviceObjects )( 
+            ID3D12DebugDevice * This,
+            D3D12_RLDO_FLAGS Flags);
+        
+        END_INTERFACE
+    } ID3D12DebugDeviceVtbl;
+
+    interface ID3D12DebugDevice
+    {
+        CONST_VTBL struct ID3D12DebugDeviceVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DebugDevice_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DebugDevice_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DebugDevice_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DebugDevice_SetFeatureMask(This,Mask)	\
+    ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) 
+
+#define ID3D12DebugDevice_GetFeatureMask(This)	\
+    ( (This)->lpVtbl -> GetFeatureMask(This) ) 
+
+#define ID3D12DebugDevice_ReportLiveDeviceObjects(This,Flags)	\
+    ( (This)->lpVtbl -> ReportLiveDeviceObjects(This,Flags) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DebugDevice_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DebugDevice2_INTERFACE_DEFINED__
+#define __ID3D12DebugDevice2_INTERFACE_DEFINED__
+
+/* interface ID3D12DebugDevice2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DebugDevice2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("60eccbc1-378d-4df1-894c-f8ac5ce4d7dd")
+    ID3D12DebugDevice2 : public ID3D12DebugDevice
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( 
+            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
+            _In_reads_bytes_(DataSize)  const void *pData,
+            UINT DataSize) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( 
+            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugDevice2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DebugDevice2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DebugDevice2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DebugDevice2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice, SetFeatureMask)
+        HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( 
+            ID3D12DebugDevice2 * This,
+            D3D12_DEBUG_FEATURE Mask);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice, GetFeatureMask)
+        D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( 
+            ID3D12DebugDevice2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice, ReportLiveDeviceObjects)
+        HRESULT ( STDMETHODCALLTYPE *ReportLiveDeviceObjects )( 
+            ID3D12DebugDevice2 * This,
+            D3D12_RLDO_FLAGS Flags);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice2, SetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( 
+            ID3D12DebugDevice2 * This,
+            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
+            _In_reads_bytes_(DataSize)  const void *pData,
+            UINT DataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugDevice2, GetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( 
+            ID3D12DebugDevice2 * This,
+            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize);
+        
+        END_INTERFACE
+    } ID3D12DebugDevice2Vtbl;
+
+    interface ID3D12DebugDevice2
+    {
+        CONST_VTBL struct ID3D12DebugDevice2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DebugDevice2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DebugDevice2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DebugDevice2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DebugDevice2_SetFeatureMask(This,Mask)	\
+    ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) 
+
+#define ID3D12DebugDevice2_GetFeatureMask(This)	\
+    ( (This)->lpVtbl -> GetFeatureMask(This) ) 
+
+#define ID3D12DebugDevice2_ReportLiveDeviceObjects(This,Flags)	\
+    ( (This)->lpVtbl -> ReportLiveDeviceObjects(This,Flags) ) 
+
+
+#define ID3D12DebugDevice2_SetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) 
+
+#define ID3D12DebugDevice2_GetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DebugDevice2_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12sdklayers_0000_0010 */
+/* [local] */ 
+
+DEFINE_GUID(DXGI_DEBUG_D3D12, 0xcf59a98c, 0xa950, 0x4326, 0x91, 0xef, 0x9b, 0xba, 0xa1, 0x7b, 0xfd, 0x95);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0010_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0010_v0_0_s_ifspec;
+
+#ifndef __ID3D12DebugCommandQueue_INTERFACE_DEFINED__
+#define __ID3D12DebugCommandQueue_INTERFACE_DEFINED__
+
+/* interface ID3D12DebugCommandQueue */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DebugCommandQueue;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("09e0bf36-54ac-484f-8847-4baeeab6053a")
+    ID3D12DebugCommandQueue : public IUnknown
+    {
+    public:
+        virtual BOOL STDMETHODCALLTYPE AssertResourceState( 
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            UINT State) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugCommandQueueVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DebugCommandQueue * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DebugCommandQueue * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DebugCommandQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandQueue, AssertResourceState)
+        BOOL ( STDMETHODCALLTYPE *AssertResourceState )( 
+            ID3D12DebugCommandQueue * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            UINT State);
+        
+        END_INTERFACE
+    } ID3D12DebugCommandQueueVtbl;
+
+    interface ID3D12DebugCommandQueue
+    {
+        CONST_VTBL struct ID3D12DebugCommandQueueVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DebugCommandQueue_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DebugCommandQueue_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DebugCommandQueue_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DebugCommandQueue_AssertResourceState(This,pResource,Subresource,State)	\
+    ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DebugCommandQueue_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandQueue1_INTERFACE_DEFINED__
+#define __ID3D12DebugCommandQueue1_INTERFACE_DEFINED__
+
+/* interface ID3D12DebugCommandQueue1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DebugCommandQueue1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("16be35a2-bfd6-49f2-bcae-eaae4aff862d")
+    ID3D12DebugCommandQueue1 : public ID3D12DebugCommandQueue
+    {
+    public:
+        virtual void STDMETHODCALLTYPE AssertResourceAccess( 
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            D3D12_BARRIER_ACCESS Access) = 0;
+        
+        virtual void STDMETHODCALLTYPE AssertTextureLayout( 
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            D3D12_BARRIER_LAYOUT Layout) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugCommandQueue1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DebugCommandQueue1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DebugCommandQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DebugCommandQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandQueue, AssertResourceState)
+        BOOL ( STDMETHODCALLTYPE *AssertResourceState )( 
+            ID3D12DebugCommandQueue1 * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            UINT State);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandQueue1, AssertResourceAccess)
+        void ( STDMETHODCALLTYPE *AssertResourceAccess )( 
+            ID3D12DebugCommandQueue1 * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            D3D12_BARRIER_ACCESS Access);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandQueue1, AssertTextureLayout)
+        void ( STDMETHODCALLTYPE *AssertTextureLayout )( 
+            ID3D12DebugCommandQueue1 * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            D3D12_BARRIER_LAYOUT Layout);
+        
+        END_INTERFACE
+    } ID3D12DebugCommandQueue1Vtbl;
+
+    interface ID3D12DebugCommandQueue1
+    {
+        CONST_VTBL struct ID3D12DebugCommandQueue1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DebugCommandQueue1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DebugCommandQueue1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DebugCommandQueue1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DebugCommandQueue1_AssertResourceState(This,pResource,Subresource,State)	\
+    ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) 
+
+
+#define ID3D12DebugCommandQueue1_AssertResourceAccess(This,pResource,Subresource,Access)	\
+    ( (This)->lpVtbl -> AssertResourceAccess(This,pResource,Subresource,Access) ) 
+
+#define ID3D12DebugCommandQueue1_AssertTextureLayout(This,pResource,Subresource,Layout)	\
+    ( (This)->lpVtbl -> AssertTextureLayout(This,pResource,Subresource,Layout) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DebugCommandQueue1_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12sdklayers_0000_0012 */
+/* [local] */ 
+
+typedef 
+enum D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE
+    {
+        D3D12_DEBUG_COMMAND_LIST_PARAMETER_GPU_BASED_VALIDATION_SETTINGS	= 0
+    } 	D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE;
+
+typedef struct D3D12_DEBUG_COMMAND_LIST_GPU_BASED_VALIDATION_SETTINGS
+    {
+    D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE ShaderPatchMode;
+    } 	D3D12_DEBUG_COMMAND_LIST_GPU_BASED_VALIDATION_SETTINGS;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0012_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0012_v0_0_s_ifspec;
+
+#ifndef __ID3D12DebugCommandList1_INTERFACE_DEFINED__
+#define __ID3D12DebugCommandList1_INTERFACE_DEFINED__
+
+/* interface ID3D12DebugCommandList1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DebugCommandList1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("102ca951-311b-4b01-b11f-ecb83e061b37")
+    ID3D12DebugCommandList1 : public IUnknown
+    {
+    public:
+        virtual BOOL STDMETHODCALLTYPE AssertResourceState( 
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            UINT State) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( 
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _In_reads_bytes_(DataSize)  const void *pData,
+            UINT DataSize) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( 
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugCommandList1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DebugCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DebugCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DebugCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList1, AssertResourceState)
+        BOOL ( STDMETHODCALLTYPE *AssertResourceState )( 
+            ID3D12DebugCommandList1 * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            UINT State);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList1, SetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( 
+            ID3D12DebugCommandList1 * This,
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _In_reads_bytes_(DataSize)  const void *pData,
+            UINT DataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList1, GetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( 
+            ID3D12DebugCommandList1 * This,
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize);
+        
+        END_INTERFACE
+    } ID3D12DebugCommandList1Vtbl;
+
+    interface ID3D12DebugCommandList1
+    {
+        CONST_VTBL struct ID3D12DebugCommandList1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DebugCommandList1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DebugCommandList1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DebugCommandList1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DebugCommandList1_AssertResourceState(This,pResource,Subresource,State)	\
+    ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) 
+
+#define ID3D12DebugCommandList1_SetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) 
+
+#define ID3D12DebugCommandList1_GetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DebugCommandList1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandList_INTERFACE_DEFINED__
+#define __ID3D12DebugCommandList_INTERFACE_DEFINED__
+
+/* interface ID3D12DebugCommandList */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DebugCommandList;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("09e0bf36-54ac-484f-8847-4baeeab6053f")
+    ID3D12DebugCommandList : public IUnknown
+    {
+    public:
+        virtual BOOL STDMETHODCALLTYPE AssertResourceState( 
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            UINT State) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetFeatureMask( 
+            D3D12_DEBUG_FEATURE Mask) = 0;
+        
+        virtual D3D12_DEBUG_FEATURE STDMETHODCALLTYPE GetFeatureMask( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugCommandListVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DebugCommandList * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DebugCommandList * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DebugCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList, AssertResourceState)
+        BOOL ( STDMETHODCALLTYPE *AssertResourceState )( 
+            ID3D12DebugCommandList * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            UINT State);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList, SetFeatureMask)
+        HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( 
+            ID3D12DebugCommandList * This,
+            D3D12_DEBUG_FEATURE Mask);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList, GetFeatureMask)
+        D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( 
+            ID3D12DebugCommandList * This);
+        
+        END_INTERFACE
+    } ID3D12DebugCommandListVtbl;
+
+    interface ID3D12DebugCommandList
+    {
+        CONST_VTBL struct ID3D12DebugCommandListVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DebugCommandList_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DebugCommandList_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DebugCommandList_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DebugCommandList_AssertResourceState(This,pResource,Subresource,State)	\
+    ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) 
+
+#define ID3D12DebugCommandList_SetFeatureMask(This,Mask)	\
+    ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) 
+
+#define ID3D12DebugCommandList_GetFeatureMask(This)	\
+    ( (This)->lpVtbl -> GetFeatureMask(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DebugCommandList_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandList2_INTERFACE_DEFINED__
+#define __ID3D12DebugCommandList2_INTERFACE_DEFINED__
+
+/* interface ID3D12DebugCommandList2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DebugCommandList2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("aeb575cf-4e06-48be-ba3b-c450fc96652e")
+    ID3D12DebugCommandList2 : public ID3D12DebugCommandList
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( 
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _In_reads_bytes_(DataSize)  const void *pData,
+            UINT DataSize) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( 
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugCommandList2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DebugCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DebugCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DebugCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList, AssertResourceState)
+        BOOL ( STDMETHODCALLTYPE *AssertResourceState )( 
+            ID3D12DebugCommandList2 * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            UINT State);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList, SetFeatureMask)
+        HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( 
+            ID3D12DebugCommandList2 * This,
+            D3D12_DEBUG_FEATURE Mask);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList, GetFeatureMask)
+        D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( 
+            ID3D12DebugCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList2, SetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( 
+            ID3D12DebugCommandList2 * This,
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _In_reads_bytes_(DataSize)  const void *pData,
+            UINT DataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList2, GetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( 
+            ID3D12DebugCommandList2 * This,
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize);
+        
+        END_INTERFACE
+    } ID3D12DebugCommandList2Vtbl;
+
+    interface ID3D12DebugCommandList2
+    {
+        CONST_VTBL struct ID3D12DebugCommandList2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DebugCommandList2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DebugCommandList2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DebugCommandList2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DebugCommandList2_AssertResourceState(This,pResource,Subresource,State)	\
+    ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) 
+
+#define ID3D12DebugCommandList2_SetFeatureMask(This,Mask)	\
+    ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) 
+
+#define ID3D12DebugCommandList2_GetFeatureMask(This)	\
+    ( (This)->lpVtbl -> GetFeatureMask(This) ) 
+
+
+#define ID3D12DebugCommandList2_SetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) 
+
+#define ID3D12DebugCommandList2_GetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DebugCommandList2_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12DebugCommandList3_INTERFACE_DEFINED__
+#define __ID3D12DebugCommandList3_INTERFACE_DEFINED__
+
+/* interface ID3D12DebugCommandList3 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12DebugCommandList3;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("197d5e15-4d37-4d34-af78-724cd70fdb1f")
+    ID3D12DebugCommandList3 : public ID3D12DebugCommandList2
+    {
+    public:
+        virtual void STDMETHODCALLTYPE AssertResourceAccess( 
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            D3D12_BARRIER_ACCESS Access) = 0;
+        
+        virtual void STDMETHODCALLTYPE AssertTextureLayout( 
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            D3D12_BARRIER_LAYOUT Layout) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12DebugCommandList3Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12DebugCommandList3 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12DebugCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12DebugCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList, AssertResourceState)
+        BOOL ( STDMETHODCALLTYPE *AssertResourceState )( 
+            ID3D12DebugCommandList3 * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            UINT State);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList, SetFeatureMask)
+        HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( 
+            ID3D12DebugCommandList3 * This,
+            D3D12_DEBUG_FEATURE Mask);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList, GetFeatureMask)
+        D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( 
+            ID3D12DebugCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList2, SetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( 
+            ID3D12DebugCommandList3 * This,
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _In_reads_bytes_(DataSize)  const void *pData,
+            UINT DataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList2, GetDebugParameter)
+        HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( 
+            ID3D12DebugCommandList3 * This,
+            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
+            _Out_writes_bytes_(DataSize)  void *pData,
+            UINT DataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList3, AssertResourceAccess)
+        void ( STDMETHODCALLTYPE *AssertResourceAccess )( 
+            ID3D12DebugCommandList3 * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            D3D12_BARRIER_ACCESS Access);
+        
+        DECLSPEC_XFGVIRT(ID3D12DebugCommandList3, AssertTextureLayout)
+        void ( STDMETHODCALLTYPE *AssertTextureLayout )( 
+            ID3D12DebugCommandList3 * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            D3D12_BARRIER_LAYOUT Layout);
+        
+        END_INTERFACE
+    } ID3D12DebugCommandList3Vtbl;
+
+    interface ID3D12DebugCommandList3
+    {
+        CONST_VTBL struct ID3D12DebugCommandList3Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12DebugCommandList3_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12DebugCommandList3_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12DebugCommandList3_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12DebugCommandList3_AssertResourceState(This,pResource,Subresource,State)	\
+    ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) 
+
+#define ID3D12DebugCommandList3_SetFeatureMask(This,Mask)	\
+    ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) 
+
+#define ID3D12DebugCommandList3_GetFeatureMask(This)	\
+    ( (This)->lpVtbl -> GetFeatureMask(This) ) 
+
+
+#define ID3D12DebugCommandList3_SetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) 
+
+#define ID3D12DebugCommandList3_GetDebugParameter(This,Type,pData,DataSize)	\
+    ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) 
+
+
+#define ID3D12DebugCommandList3_AssertResourceAccess(This,pResource,Subresource,Access)	\
+    ( (This)->lpVtbl -> AssertResourceAccess(This,pResource,Subresource,Access) ) 
+
+#define ID3D12DebugCommandList3_AssertTextureLayout(This,pResource,Subresource,Layout)	\
+    ( (This)->lpVtbl -> AssertTextureLayout(This,pResource,Subresource,Layout) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12DebugCommandList3_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12SharingContract_INTERFACE_DEFINED__
+#define __ID3D12SharingContract_INTERFACE_DEFINED__
+
+/* interface ID3D12SharingContract */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12SharingContract;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("0adf7d52-929c-4e61-addb-ffed30de66ef")
+    ID3D12SharingContract : public IUnknown
+    {
+    public:
+        virtual void STDMETHODCALLTYPE Present( 
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            _In_  HWND window) = 0;
+        
+        virtual void STDMETHODCALLTYPE SharedFenceSignal( 
+            _In_  ID3D12Fence *pFence,
+            UINT64 FenceValue) = 0;
+        
+        virtual void STDMETHODCALLTYPE BeginCapturableWork( 
+            _In_  REFGUID guid) = 0;
+        
+        virtual void STDMETHODCALLTYPE EndCapturableWork( 
+            _In_  REFGUID guid) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12SharingContractVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12SharingContract * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12SharingContract * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12SharingContract * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12SharingContract, Present)
+        void ( STDMETHODCALLTYPE *Present )( 
+            ID3D12SharingContract * This,
+            _In_  ID3D12Resource *pResource,
+            UINT Subresource,
+            _In_  HWND window);
+        
+        DECLSPEC_XFGVIRT(ID3D12SharingContract, SharedFenceSignal)
+        void ( STDMETHODCALLTYPE *SharedFenceSignal )( 
+            ID3D12SharingContract * This,
+            _In_  ID3D12Fence *pFence,
+            UINT64 FenceValue);
+        
+        DECLSPEC_XFGVIRT(ID3D12SharingContract, BeginCapturableWork)
+        void ( STDMETHODCALLTYPE *BeginCapturableWork )( 
+            ID3D12SharingContract * This,
+            _In_  REFGUID guid);
+        
+        DECLSPEC_XFGVIRT(ID3D12SharingContract, EndCapturableWork)
+        void ( STDMETHODCALLTYPE *EndCapturableWork )( 
+            ID3D12SharingContract * This,
+            _In_  REFGUID guid);
+        
+        END_INTERFACE
+    } ID3D12SharingContractVtbl;
+
+    interface ID3D12SharingContract
+    {
+        CONST_VTBL struct ID3D12SharingContractVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12SharingContract_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12SharingContract_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12SharingContract_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12SharingContract_Present(This,pResource,Subresource,window)	\
+    ( (This)->lpVtbl -> Present(This,pResource,Subresource,window) ) 
+
+#define ID3D12SharingContract_SharedFenceSignal(This,pFence,FenceValue)	\
+    ( (This)->lpVtbl -> SharedFenceSignal(This,pFence,FenceValue) ) 
+
+#define ID3D12SharingContract_BeginCapturableWork(This,guid)	\
+    ( (This)->lpVtbl -> BeginCapturableWork(This,guid) ) 
+
+#define ID3D12SharingContract_EndCapturableWork(This,guid)	\
+    ( (This)->lpVtbl -> EndCapturableWork(This,guid) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12SharingContract_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12sdklayers_0000_0017 */
+/* [local] */ 
+
+typedef 
+enum D3D12_MESSAGE_CATEGORY
+    {
+        D3D12_MESSAGE_CATEGORY_APPLICATION_DEFINED	= 0,
+        D3D12_MESSAGE_CATEGORY_MISCELLANEOUS	= ( D3D12_MESSAGE_CATEGORY_APPLICATION_DEFINED + 1 ) ,
+        D3D12_MESSAGE_CATEGORY_INITIALIZATION	= ( D3D12_MESSAGE_CATEGORY_MISCELLANEOUS + 1 ) ,
+        D3D12_MESSAGE_CATEGORY_CLEANUP	= ( D3D12_MESSAGE_CATEGORY_INITIALIZATION + 1 ) ,
+        D3D12_MESSAGE_CATEGORY_COMPILATION	= ( D3D12_MESSAGE_CATEGORY_CLEANUP + 1 ) ,
+        D3D12_MESSAGE_CATEGORY_STATE_CREATION	= ( D3D12_MESSAGE_CATEGORY_COMPILATION + 1 ) ,
+        D3D12_MESSAGE_CATEGORY_STATE_SETTING	= ( D3D12_MESSAGE_CATEGORY_STATE_CREATION + 1 ) ,
+        D3D12_MESSAGE_CATEGORY_STATE_GETTING	= ( D3D12_MESSAGE_CATEGORY_STATE_SETTING + 1 ) ,
+        D3D12_MESSAGE_CATEGORY_RESOURCE_MANIPULATION	= ( D3D12_MESSAGE_CATEGORY_STATE_GETTING + 1 ) ,
+        D3D12_MESSAGE_CATEGORY_EXECUTION	= ( D3D12_MESSAGE_CATEGORY_RESOURCE_MANIPULATION + 1 ) ,
+        D3D12_MESSAGE_CATEGORY_SHADER	= ( D3D12_MESSAGE_CATEGORY_EXECUTION + 1 ) 
+    } 	D3D12_MESSAGE_CATEGORY;
+
+typedef 
+enum D3D12_MESSAGE_SEVERITY
+    {
+        D3D12_MESSAGE_SEVERITY_CORRUPTION	= 0,
+        D3D12_MESSAGE_SEVERITY_ERROR	= ( D3D12_MESSAGE_SEVERITY_CORRUPTION + 1 ) ,
+        D3D12_MESSAGE_SEVERITY_WARNING	= ( D3D12_MESSAGE_SEVERITY_ERROR + 1 ) ,
+        D3D12_MESSAGE_SEVERITY_INFO	= ( D3D12_MESSAGE_SEVERITY_WARNING + 1 ) ,
+        D3D12_MESSAGE_SEVERITY_MESSAGE	= ( D3D12_MESSAGE_SEVERITY_INFO + 1 ) 
+    } 	D3D12_MESSAGE_SEVERITY;
+
+typedef 
+enum D3D12_MESSAGE_ID
+    {
+        D3D12_MESSAGE_ID_UNKNOWN	= 0,
+        D3D12_MESSAGE_ID_STRING_FROM_APPLICATION	= 1,
+        D3D12_MESSAGE_ID_CORRUPTED_THIS	= 2,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER1	= 3,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER2	= 4,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER3	= 5,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER4	= 6,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER5	= 7,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER6	= 8,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER7	= 9,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER8	= 10,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER9	= 11,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER10	= 12,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER11	= 13,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER12	= 14,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER13	= 15,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER14	= 16,
+        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER15	= 17,
+        D3D12_MESSAGE_ID_CORRUPTED_MULTITHREADING	= 18,
+        D3D12_MESSAGE_ID_MESSAGE_REPORTING_OUTOFMEMORY	= 19,
+        D3D12_MESSAGE_ID_GETPRIVATEDATA_MOREDATA	= 20,
+        D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDFREEDATA	= 21,
+        D3D12_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS	= 24,
+        D3D12_MESSAGE_ID_SETPRIVATEDATA_OUTOFMEMORY	= 25,
+        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT	= 26,
+        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDESC	= 27,
+        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFORMAT	= 28,
+        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANESLICE	= 29,
+        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDPLANESLICE	= 30,
+        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS	= 31,
+        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDRESOURCE	= 32,
+        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT	= 35,
+        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT	= 36,
+        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDESC	= 37,
+        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDFORMAT	= 38,
+        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDVIDEOPLANESLICE	= 39,
+        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDPLANESLICE	= 40,
+        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDIMENSIONS	= 41,
+        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDRESOURCE	= 42,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT	= 45,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDESC	= 46,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFORMAT	= 47,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS	= 48,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE	= 49,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_OUTOFMEMORY	= 52,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TOOMANYELEMENTS	= 53,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDFORMAT	= 54,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT	= 55,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOT	= 56,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS	= 57,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH	= 58,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE	= 59,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE	= 60,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDALIGNMENT	= 61,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_DUPLICATESEMANTIC	= 62,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE	= 63,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_NULLSEMANTIC	= 64,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_MISSINGELEMENT	= 65,
+        D3D12_MESSAGE_ID_CREATEVERTEXSHADER_OUTOFMEMORY	= 66,
+        D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERBYTECODE	= 67,
+        D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERTYPE	= 68,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_OUTOFMEMORY	= 69,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE	= 70,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERTYPE	= 71,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY	= 72,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE	= 73,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE	= 74,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES	= 75,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED	= 76,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED	= 79,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT	= 80,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT	= 81,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT	= 82,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT	= 83,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION	= 84,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT	= 85,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE	= 86,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC	= 87,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH	= 88,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS	= 89,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX	= 90,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE	= 91,
+        D3D12_MESSAGE_ID_CREATEPIXELSHADER_OUTOFMEMORY	= 92,
+        D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERBYTECODE	= 93,
+        D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERTYPE	= 94,
+        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFILLMODE	= 95,
+        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDCULLMODE	= 96,
+        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP	= 97,
+        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS	= 98,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK	= 100,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC	= 101,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP	= 102,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP	= 103,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP	= 104,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC	= 105,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP	= 106,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP	= 107,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP	= 108,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC	= 109,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLEND	= 111,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLEND	= 112,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOP	= 113,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLENDALPHA	= 114,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA	= 115,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA	= 116,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK	= 117,
+        D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID	= 135,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_NOT_SET	= 200,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_MISMATCH	= 201,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_NOT_SET	= 202,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL	= 209,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_TOO_SMALL	= 210,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_NOT_SET	= 211,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_FORMAT_INVALID	= 212,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_TOO_SMALL	= 213,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INVALID_PRIMITIVETOPOLOGY	= 219,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_STRIDE_UNALIGNED	= 221,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_OFFSET_UNALIGNED	= 222,
+        D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_AT_FAULT	= 232,
+        D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT	= 233,
+        D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT	= 234,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC	= 239,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC	= 240,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH	= 245,
+        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_EMPTY_LAYOUT	= 253,
+        D3D12_MESSAGE_ID_LIVE_OBJECT_SUMMARY	= 255,
+        D3D12_MESSAGE_ID_LIVE_DEVICE	= 274,
+        D3D12_MESSAGE_ID_LIVE_SWAPCHAIN	= 275,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFLAGS	= 276,
+        D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDCLASSLINKAGE	= 277,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDCLASSLINKAGE	= 278,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAMTORASTERIZER	= 280,
+        D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDCLASSLINKAGE	= 283,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAM	= 284,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDENTRIES	= 285,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTRIDES	= 286,
+        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTRIDES	= 287,
+        D3D12_MESSAGE_ID_CREATEHULLSHADER_OUTOFMEMORY	= 289,
+        D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERBYTECODE	= 290,
+        D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERTYPE	= 291,
+        D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDCLASSLINKAGE	= 292,
+        D3D12_MESSAGE_ID_CREATEDOMAINSHADER_OUTOFMEMORY	= 294,
+        D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERBYTECODE	= 295,
+        D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERTYPE	= 296,
+        D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCLASSLINKAGE	= 297,
+        D3D12_MESSAGE_ID_RESOURCE_UNMAP_NOTMAPPED	= 310,
+        D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_MISMATCHED_DATA_SIZE	= 318,
+        D3D12_MESSAGE_ID_CREATECOMPUTESHADER_OUTOFMEMORY	= 321,
+        D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDSHADERBYTECODE	= 322,
+        D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCLASSLINKAGE	= 323,
+        D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEFLOATOPSNOTSUPPORTED	= 331,
+        D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEFLOATOPSNOTSUPPORTED	= 332,
+        D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEFLOATOPSNOTSUPPORTED	= 333,
+        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEFLOATOPSNOTSUPPORTED	= 334,
+        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEFLOATOPSNOTSUPPORTED	= 335,
+        D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEFLOATOPSNOTSUPPORTED	= 336,
+        D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEFLOATOPSNOTSUPPORTED	= 337,
+        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDRESOURCE	= 340,
+        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDESC	= 341,
+        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFORMAT	= 342,
+        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANESLICE	= 343,
+        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDPLANESLICE	= 344,
+        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDIMENSIONS	= 345,
+        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_UNRECOGNIZEDFORMAT	= 346,
+        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFLAGS	= 354,
+        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFORCEDSAMPLECOUNT	= 401,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDLOGICOPS	= 403,
+        D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEEXTENSIONSNOTSUPPORTED	= 410,
+        D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEEXTENSIONSNOTSUPPORTED	= 412,
+        D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEEXTENSIONSNOTSUPPORTED	= 414,
+        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEEXTENSIONSNOTSUPPORTED	= 416,
+        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEEXTENSIONSNOTSUPPORTED	= 418,
+        D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEEXTENSIONSNOTSUPPORTED	= 420,
+        D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEEXTENSIONSNOTSUPPORTED	= 422,
+        D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_UAVSNOTSUPPORTED	= 425,
+        D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_UAVSNOTSUPPORTED	= 426,
+        D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_UAVSNOTSUPPORTED	= 427,
+        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_UAVSNOTSUPPORTED	= 428,
+        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UAVSNOTSUPPORTED	= 429,
+        D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_UAVSNOTSUPPORTED	= 430,
+        D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_UAVSNOTSUPPORTED	= 431,
+        D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDSOURCERECT	= 447,
+        D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_EMPTYRECT	= 448,
+        D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_INVALID_PARAMETER	= 493,
+        D3D12_MESSAGE_ID_COPYTILEMAPPINGS_INVALID_PARAMETER	= 494,
+        D3D12_MESSAGE_ID_CREATEDEVICE_INVALIDARGS	= 506,
+        D3D12_MESSAGE_ID_CREATEDEVICE_WARNING	= 507,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_TYPE	= 519,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_NULL_POINTER	= 520,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SUBRESOURCE	= 521,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_RESERVED_BITS	= 522,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISSING_BIND_FLAGS	= 523,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_MISC_FLAGS	= 524,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_MATCHING_STATES	= 525,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINATION	= 526,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_BEFORE_AFTER_MISMATCH	= 527,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_RESOURCE	= 528,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_SAMPLE_COUNT	= 529,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS	= 530,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINED_FLAGS	= 531,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS_FOR_FORMAT	= 532,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SPLIT_BARRIER	= 533,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_END	= 534,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_BEGIN	= 535,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAG	= 536,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMMAND_LIST_TYPE	= 537,
+        D3D12_MESSAGE_ID_INVALID_SUBRESOURCE_STATE	= 538,
+        D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CONTENTION	= 540,
+        D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET	= 541,
+        D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET_BUNDLE	= 542,
+        D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CANNOT_RESET	= 543,
+        D3D12_MESSAGE_ID_COMMAND_LIST_OPEN	= 544,
+        D3D12_MESSAGE_ID_INVALID_BUNDLE_API	= 546,
+        D3D12_MESSAGE_ID_COMMAND_LIST_CLOSED	= 547,
+        D3D12_MESSAGE_ID_WRONG_COMMAND_ALLOCATOR_TYPE	= 549,
+        D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_SYNC	= 552,
+        D3D12_MESSAGE_ID_COMMAND_LIST_SYNC	= 553,
+        D3D12_MESSAGE_ID_SET_DESCRIPTOR_HEAP_INVALID	= 554,
+        D3D12_MESSAGE_ID_CREATE_COMMANDQUEUE	= 557,
+        D3D12_MESSAGE_ID_CREATE_COMMANDALLOCATOR	= 558,
+        D3D12_MESSAGE_ID_CREATE_PIPELINESTATE	= 559,
+        D3D12_MESSAGE_ID_CREATE_COMMANDLIST12	= 560,
+        D3D12_MESSAGE_ID_CREATE_RESOURCE	= 562,
+        D3D12_MESSAGE_ID_CREATE_DESCRIPTORHEAP	= 563,
+        D3D12_MESSAGE_ID_CREATE_ROOTSIGNATURE	= 564,
+        D3D12_MESSAGE_ID_CREATE_LIBRARY	= 565,
+        D3D12_MESSAGE_ID_CREATE_HEAP	= 566,
+        D3D12_MESSAGE_ID_CREATE_MONITOREDFENCE	= 567,
+        D3D12_MESSAGE_ID_CREATE_QUERYHEAP	= 568,
+        D3D12_MESSAGE_ID_CREATE_COMMANDSIGNATURE	= 569,
+        D3D12_MESSAGE_ID_LIVE_COMMANDQUEUE	= 570,
+        D3D12_MESSAGE_ID_LIVE_COMMANDALLOCATOR	= 571,
+        D3D12_MESSAGE_ID_LIVE_PIPELINESTATE	= 572,
+        D3D12_MESSAGE_ID_LIVE_COMMANDLIST12	= 573,
+        D3D12_MESSAGE_ID_LIVE_RESOURCE	= 575,
+        D3D12_MESSAGE_ID_LIVE_DESCRIPTORHEAP	= 576,
+        D3D12_MESSAGE_ID_LIVE_ROOTSIGNATURE	= 577,
+        D3D12_MESSAGE_ID_LIVE_LIBRARY	= 578,
+        D3D12_MESSAGE_ID_LIVE_HEAP	= 579,
+        D3D12_MESSAGE_ID_LIVE_MONITOREDFENCE	= 580,
+        D3D12_MESSAGE_ID_LIVE_QUERYHEAP	= 581,
+        D3D12_MESSAGE_ID_LIVE_COMMANDSIGNATURE	= 582,
+        D3D12_MESSAGE_ID_DESTROY_COMMANDQUEUE	= 583,
+        D3D12_MESSAGE_ID_DESTROY_COMMANDALLOCATOR	= 584,
+        D3D12_MESSAGE_ID_DESTROY_PIPELINESTATE	= 585,
+        D3D12_MESSAGE_ID_DESTROY_COMMANDLIST12	= 586,
+        D3D12_MESSAGE_ID_DESTROY_RESOURCE	= 588,
+        D3D12_MESSAGE_ID_DESTROY_DESCRIPTORHEAP	= 589,
+        D3D12_MESSAGE_ID_DESTROY_ROOTSIGNATURE	= 590,
+        D3D12_MESSAGE_ID_DESTROY_LIBRARY	= 591,
+        D3D12_MESSAGE_ID_DESTROY_HEAP	= 592,
+        D3D12_MESSAGE_ID_DESTROY_MONITOREDFENCE	= 593,
+        D3D12_MESSAGE_ID_DESTROY_QUERYHEAP	= 594,
+        D3D12_MESSAGE_ID_DESTROY_COMMANDSIGNATURE	= 595,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONS	= 597,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMISCFLAGS	= 599,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDARG_RETURN	= 602,
+        D3D12_MESSAGE_ID_CREATERESOURCE_OUTOFMEMORY_RETURN	= 603,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDESC	= 604,
+        D3D12_MESSAGE_ID_POSSIBLY_INVALID_SUBRESOURCE_STATE	= 607,
+        D3D12_MESSAGE_ID_INVALID_USE_OF_NON_RESIDENT_RESOURCE	= 608,
+        D3D12_MESSAGE_ID_POSSIBLE_INVALID_USE_OF_NON_RESIDENT_RESOURCE	= 609,
+        D3D12_MESSAGE_ID_BUNDLE_PIPELINE_STATE_MISMATCH	= 610,
+        D3D12_MESSAGE_ID_PRIMITIVE_TOPOLOGY_MISMATCH_PIPELINE_STATE	= 611,
+        D3D12_MESSAGE_ID_RENDER_TARGET_FORMAT_MISMATCH_PIPELINE_STATE	= 613,
+        D3D12_MESSAGE_ID_RENDER_TARGET_SAMPLE_DESC_MISMATCH_PIPELINE_STATE	= 614,
+        D3D12_MESSAGE_ID_DEPTH_STENCIL_FORMAT_MISMATCH_PIPELINE_STATE	= 615,
+        D3D12_MESSAGE_ID_DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_PIPELINE_STATE	= 616,
+        D3D12_MESSAGE_ID_CREATESHADER_INVALIDBYTECODE	= 622,
+        D3D12_MESSAGE_ID_CREATEHEAP_NULLDESC	= 623,
+        D3D12_MESSAGE_ID_CREATEHEAP_INVALIDSIZE	= 624,
+        D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDHEAPTYPE	= 625,
+        D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES	= 626,
+        D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMEMORYPOOL	= 627,
+        D3D12_MESSAGE_ID_CREATEHEAP_INVALIDPROPERTIES	= 628,
+        D3D12_MESSAGE_ID_CREATEHEAP_INVALIDALIGNMENT	= 629,
+        D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMISCFLAGS	= 630,
+        D3D12_MESSAGE_ID_CREATEHEAP_INVALIDMISCFLAGS	= 631,
+        D3D12_MESSAGE_ID_CREATEHEAP_INVALIDARG_RETURN	= 632,
+        D3D12_MESSAGE_ID_CREATEHEAP_OUTOFMEMORY_RETURN	= 633,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAPPROPERTIES	= 634,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPTYPE	= 635,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES	= 636,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDMEMORYPOOL	= 637,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPPROPERTIES	= 638,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPMISCFLAGS	= 639,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPMISCFLAGS	= 640,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDARG_RETURN	= 641,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_OUTOFMEMORY_RETURN	= 642,
+        D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_UNRECOGNIZEDHEAPTYPE	= 643,
+        D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_INVALIDHEAPTYPE	= 644,
+        D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_INVALID_DESC	= 645,
+        D3D12_MESSAGE_ID_INVALID_DESCRIPTOR_HANDLE	= 646,
+        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALID_CONSERVATIVERASTERMODE	= 647,
+        D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_RESOURCE	= 649,
+        D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_DESC	= 650,
+        D3D12_MESSAGE_ID_CREATE_UNORDEREDACCESS_VIEW_INVALID_COUNTER_USAGE	= 652,
+        D3D12_MESSAGE_ID_COPY_DESCRIPTORS_INVALID_RANGES	= 653,
+        D3D12_MESSAGE_ID_COPY_DESCRIPTORS_WRITE_ONLY_DESCRIPTOR	= 654,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RTV_FORMAT_NOT_UNKNOWN	= 655,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_RENDER_TARGET_COUNT	= 656,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VERTEX_SHADER_NOT_SET	= 657,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_NOT_SET	= 658,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_HS_DS_SIGNATURE_MISMATCH	= 659,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERINDEX	= 660,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_COMPONENTTYPE	= 661,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERMASK	= 662,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SYSTEMVALUE	= 663,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS	= 664,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_MINPRECISION	= 665,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND	= 666,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_XOR_DS_MISMATCH	= 667,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH	= 668,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_CONTROL_POINT_COUNT_MISMATCH	= 669,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_TESSELLATOR_DOMAIN_MISMATCH	= 670,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN	= 671,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_FORCED_SAMPLE_COUNT	= 672,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_PRIMITIVETOPOLOGY	= 673,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SYSTEMVALUE	= 674,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0	= 675,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING	= 676,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_TYPE_MISMATCH	= 677,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS	= 678,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RENDERTARGETVIEW_NOT_SET	= 679,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DEPTHSTENCILVIEW_NOT_SET	= 680,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_INPUT_PRIMITIVE_MISMATCH	= 681,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_POSITION_NOT_PRESENT	= 682,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE_FLAGS	= 683,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_INDEX_BUFFER_PROPERTIES	= 684,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SAMPLE_DESC	= 685,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_ROOT_SIGNATURE_MISMATCH	= 686,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DS_ROOT_SIGNATURE_MISMATCH	= 687,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VS_ROOT_SIGNATURE_MISMATCH	= 688,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_ROOT_SIGNATURE_MISMATCH	= 689,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_ROOT_SIGNATURE_MISMATCH	= 690,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE	= 691,
+        D3D12_MESSAGE_ID_EXECUTE_BUNDLE_OPEN_BUNDLE	= 692,
+        D3D12_MESSAGE_ID_EXECUTE_BUNDLE_DESCRIPTOR_HEAP_MISMATCH	= 693,
+        D3D12_MESSAGE_ID_EXECUTE_BUNDLE_TYPE	= 694,
+        D3D12_MESSAGE_ID_DRAW_EMPTY_SCISSOR_RECTANGLE	= 695,
+        D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_BLOB_NOT_FOUND	= 696,
+        D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_DESERIALIZE_FAILED	= 697,
+        D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_INVALID_CONFIGURATION	= 698,
+        D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_SUPPORTED_ON_DEVICE	= 699,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLRESOURCEPROPERTIES	= 700,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAP	= 701,
+        D3D12_MESSAGE_ID_GETRESOURCEALLOCATIONINFO_INVALIDRDESCS	= 702,
+        D3D12_MESSAGE_ID_MAKERESIDENT_NULLOBJECTARRAY	= 703,
+        D3D12_MESSAGE_ID_EVICT_NULLOBJECTARRAY	= 705,
+        D3D12_MESSAGE_ID_SET_DESCRIPTOR_TABLE_INVALID	= 708,
+        D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_INVALID	= 709,
+        D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_BUFFER_VIEW_INVALID	= 710,
+        D3D12_MESSAGE_ID_SET_ROOT_SHADER_RESOURCE_VIEW_INVALID	= 711,
+        D3D12_MESSAGE_ID_SET_ROOT_UNORDERED_ACCESS_VIEW_INVALID	= 712,
+        D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID_DESC	= 713,
+        D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID_DESC	= 715,
+        D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID_DESC	= 717,
+        D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDDIMENSIONALITY	= 718,
+        D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDLAYOUT	= 719,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONALITY	= 720,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDALIGNMENT	= 721,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMIPLEVELS	= 722,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDSAMPLEDESC	= 723,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDLAYOUT	= 724,
+        D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID	= 725,
+        D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID	= 726,
+        D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID	= 727,
+        D3D12_MESSAGE_ID_SET_RENDER_TARGETS_INVALID	= 728,
+        D3D12_MESSAGE_ID_CREATEQUERY_HEAP_INVALID_PARAMETERS	= 729,
+        D3D12_MESSAGE_ID_BEGIN_END_QUERY_INVALID_PARAMETERS	= 731,
+        D3D12_MESSAGE_ID_CLOSE_COMMAND_LIST_OPEN_QUERY	= 732,
+        D3D12_MESSAGE_ID_RESOLVE_QUERY_DATA_INVALID_PARAMETERS	= 733,
+        D3D12_MESSAGE_ID_SET_PREDICATION_INVALID_PARAMETERS	= 734,
+        D3D12_MESSAGE_ID_TIMESTAMPS_NOT_SUPPORTED	= 735,
+        D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDFORMAT	= 737,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDFORMAT	= 738,
+        D3D12_MESSAGE_ID_GETCOPYABLEFOOTPRINTS_INVALIDSUBRESOURCERANGE	= 739,
+        D3D12_MESSAGE_ID_GETCOPYABLEFOOTPRINTS_INVALIDBASEOFFSET	= 740,
+        D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDSUBRESOURCERANGE	= 739,
+        D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDBASEOFFSET	= 740,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_HEAP	= 741,
+        D3D12_MESSAGE_ID_CREATE_SAMPLER_INVALID	= 742,
+        D3D12_MESSAGE_ID_CREATECOMMANDSIGNATURE_INVALID	= 743,
+        D3D12_MESSAGE_ID_EXECUTE_INDIRECT_INVALID_PARAMETERS	= 744,
+        D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_RESOURCE_DIMENSION	= 745,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUE	= 815,
+        D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDCLEARVALUEFORMAT	= 816,
+        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUEFORMAT	= 817,
+        D3D12_MESSAGE_ID_CREATERESOURCE_CLEARVALUEDENORMFLUSH	= 818,
+        D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_MISMATCHINGCLEARVALUE	= 820,
+        D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_MISMATCHINGCLEARVALUE	= 821,
+        D3D12_MESSAGE_ID_MAP_INVALIDHEAP	= 822,
+        D3D12_MESSAGE_ID_UNMAP_INVALIDHEAP	= 823,
+        D3D12_MESSAGE_ID_MAP_INVALIDRESOURCE	= 824,
+        D3D12_MESSAGE_ID_UNMAP_INVALIDRESOURCE	= 825,
+        D3D12_MESSAGE_ID_MAP_INVALIDSUBRESOURCE	= 826,
+        D3D12_MESSAGE_ID_UNMAP_INVALIDSUBRESOURCE	= 827,
+        D3D12_MESSAGE_ID_MAP_INVALIDRANGE	= 828,
+        D3D12_MESSAGE_ID_UNMAP_INVALIDRANGE	= 829,
+        D3D12_MESSAGE_ID_MAP_INVALIDDATAPOINTER	= 832,
+        D3D12_MESSAGE_ID_MAP_INVALIDARG_RETURN	= 833,
+        D3D12_MESSAGE_ID_MAP_OUTOFMEMORY_RETURN	= 834,
+        D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_BUNDLENOTSUPPORTED	= 835,
+        D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_COMMANDLISTMISMATCH	= 836,
+        D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_OPENCOMMANDLIST	= 837,
+        D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_FAILEDCOMMANDLIST	= 838,
+        D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLDST	= 839,
+        D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDDSTRESOURCEDIMENSION	= 840,
+        D3D12_MESSAGE_ID_COPYBUFFERREGION_DSTRANGEOUTOFBOUNDS	= 841,
+        D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLSRC	= 842,
+        D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDSRCRESOURCEDIMENSION	= 843,
+        D3D12_MESSAGE_ID_COPYBUFFERREGION_SRCRANGEOUTOFBOUNDS	= 844,
+        D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDCOPYFLAGS	= 845,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLDST	= 846,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTTYPE	= 847,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCEDIMENSION	= 848,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCE	= 849,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTSUBRESOURCE	= 850,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTOFFSET	= 851,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTFORMAT	= 852,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTFORMAT	= 853,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDIMENSIONS	= 854,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTROWPITCH	= 855,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTPLACEMENT	= 856,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDSPLACEDFOOTPRINTFORMAT	= 857,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_DSTREGIONOUTOFBOUNDS	= 858,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLSRC	= 859,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCTYPE	= 860,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCEDIMENSION	= 861,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCE	= 862,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCSUBRESOURCE	= 863,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCOFFSET	= 864,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCFORMAT	= 865,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCFORMAT	= 866,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDIMENSIONS	= 867,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCROWPITCH	= 868,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCPLACEMENT	= 869,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDSPLACEDFOOTPRINTFORMAT	= 870,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_SRCREGIONOUTOFBOUNDS	= 871,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTCOORDINATES	= 872,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCBOX	= 873,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_FORMATMISMATCH	= 874,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_EMPTYBOX	= 875,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDCOPYFLAGS	= 876,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SUBRESOURCE_INDEX	= 877,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_FORMAT	= 878,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_MISMATCH	= 879,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SAMPLE_COUNT	= 880,
+        D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_INVALID_SHADER	= 881,
+        D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_CS_ROOT_SIGNATURE_MISMATCH	= 882,
+        D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_MISSING_ROOT_SIGNATURE	= 883,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALIDCACHEDBLOB	= 884,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBADAPTERMISMATCH	= 885,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDRIVERVERSIONMISMATCH	= 886,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDESCMISMATCH	= 887,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBIGNORED	= 888,
+        D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDHEAP	= 889,
+        D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDRESOURCE	= 890,
+        D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDBOX	= 891,
+        D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDSUBRESOURCE	= 892,
+        D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_EMPTYBOX	= 893,
+        D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDHEAP	= 894,
+        D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDRESOURCE	= 895,
+        D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDBOX	= 896,
+        D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDSUBRESOURCE	= 897,
+        D3D12_MESSAGE_ID_READFROMSUBRESOURCE_EMPTYBOX	= 898,
+        D3D12_MESSAGE_ID_TOO_MANY_NODES_SPECIFIED	= 899,
+        D3D12_MESSAGE_ID_INVALID_NODE_INDEX	= 900,
+        D3D12_MESSAGE_ID_GETHEAPPROPERTIES_INVALIDRESOURCE	= 901,
+        D3D12_MESSAGE_ID_NODE_MASK_MISMATCH	= 902,
+        D3D12_MESSAGE_ID_COMMAND_LIST_OUTOFMEMORY	= 903,
+        D3D12_MESSAGE_ID_COMMAND_LIST_MULTIPLE_SWAPCHAIN_BUFFER_REFERENCES	= 904,
+        D3D12_MESSAGE_ID_COMMAND_LIST_TOO_MANY_SWAPCHAIN_REFERENCES	= 905,
+        D3D12_MESSAGE_ID_COMMAND_QUEUE_TOO_MANY_SWAPCHAIN_REFERENCES	= 906,
+        D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_WRONGSWAPCHAINBUFFERREFERENCE	= 907,
+        D3D12_MESSAGE_ID_COMMAND_LIST_SETRENDERTARGETS_INVALIDNUMRENDERTARGETS	= 908,
+        D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_TYPE	= 909,
+        D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_FLAGS	= 910,
+        D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFLAGS	= 911,
+        D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFORMAT	= 912,
+        D3D12_MESSAGE_ID_CREATESHAREDHEAP_INVALIDFLAGS	= 913,
+        D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_UNRECOGNIZEDPROPERTIES	= 914,
+        D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDSIZE	= 915,
+        D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDOBJECT	= 916,
+        D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDOBJECT	= 917,
+        D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDKEY	= 918,
+        D3D12_MESSAGE_ID_KEYEDMUTEX_WRONGSTATE	= 919,
+        D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_PRIORITY	= 920,
+        D3D12_MESSAGE_ID_OBJECT_DELETED_WHILE_STILL_IN_USE	= 921,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_FLAGS	= 922,
+        D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_HAS_NO_RESOURCE	= 923,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RENDER_TARGET_DELETED	= 924,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_ALL_RENDER_TARGETS_HAVE_UNKNOWN_FORMAT	= 925,
+        D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_INTERSECTS_MULTIPLE_BUFFERS	= 926,
+        D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_GPU_WRITTEN_READBACK_RESOURCE_MAPPED	= 927,
+        D3D12_MESSAGE_ID_UNMAP_RANGE_NOT_EMPTY	= 929,
+        D3D12_MESSAGE_ID_MAP_INVALID_NULLRANGE	= 930,
+        D3D12_MESSAGE_ID_UNMAP_INVALID_NULLRANGE	= 931,
+        D3D12_MESSAGE_ID_NO_GRAPHICS_API_SUPPORT	= 932,
+        D3D12_MESSAGE_ID_NO_COMPUTE_API_SUPPORT	= 933,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_FLAGS_NOT_SUPPORTED	= 934,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_ARGUMENT_UNINITIALIZED	= 935,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_HEAP_INDEX_OUT_OF_BOUNDS	= 936,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TABLE_REGISTER_INDEX_OUT_OF_BOUNDS	= 937,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_UNINITIALIZED	= 938,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TYPE_MISMATCH	= 939,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SRV_RESOURCE_DIMENSION_MISMATCH	= 940,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UAV_RESOURCE_DIMENSION_MISMATCH	= 941,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INCOMPATIBLE_RESOURCE_STATE	= 942,
+        D3D12_MESSAGE_ID_COPYRESOURCE_NULLDST	= 943,
+        D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDDSTRESOURCE	= 944,
+        D3D12_MESSAGE_ID_COPYRESOURCE_NULLSRC	= 945,
+        D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSRCRESOURCE	= 946,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLDST	= 947,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDDSTRESOURCE	= 948,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLSRC	= 949,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDSRCRESOURCE	= 950,
+        D3D12_MESSAGE_ID_PIPELINE_STATE_TYPE_MISMATCH	= 951,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_NOT_SET	= 952,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_MISMATCH	= 953,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_ZERO_BARRIERS	= 954,
+        D3D12_MESSAGE_ID_BEGIN_END_EVENT_MISMATCH	= 955,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_POSSIBLE_BEFORE_AFTER_MISMATCH	= 956,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_BEGIN_END	= 957,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INVALID_RESOURCE	= 958,
+        D3D12_MESSAGE_ID_USE_OF_ZERO_REFCOUNT_OBJECT	= 959,
+        D3D12_MESSAGE_ID_OBJECT_EVICTED_WHILE_STILL_IN_USE	= 960,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_DESCRIPTOR_ACCESS_OUT_OF_BOUNDS	= 961,
+        D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_INVALIDLIBRARYBLOB	= 962,
+        D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_DRIVERVERSIONMISMATCH	= 963,
+        D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_ADAPTERVERSIONMISMATCH	= 964,
+        D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_UNSUPPORTED	= 965,
+        D3D12_MESSAGE_ID_CREATE_PIPELINELIBRARY	= 966,
+        D3D12_MESSAGE_ID_LIVE_PIPELINELIBRARY	= 967,
+        D3D12_MESSAGE_ID_DESTROY_PIPELINELIBRARY	= 968,
+        D3D12_MESSAGE_ID_STOREPIPELINE_NONAME	= 969,
+        D3D12_MESSAGE_ID_STOREPIPELINE_DUPLICATENAME	= 970,
+        D3D12_MESSAGE_ID_LOADPIPELINE_NAMENOTFOUND	= 971,
+        D3D12_MESSAGE_ID_LOADPIPELINE_INVALIDDESC	= 972,
+        D3D12_MESSAGE_ID_PIPELINELIBRARY_SERIALIZE_NOTENOUGHMEMORY	= 973,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_RT_OUTPUT_MISMATCH	= 974,
+        D3D12_MESSAGE_ID_SETEVENTONMULTIPLEFENCECOMPLETION_INVALIDFLAGS	= 975,
+        D3D12_MESSAGE_ID_CREATE_QUEUE_VIDEO_NOT_SUPPORTED	= 976,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_ALLOCATOR_VIDEO_NOT_SUPPORTED	= 977,
+        D3D12_MESSAGE_ID_CREATEQUERY_HEAP_VIDEO_DECODE_STATISTICS_NOT_SUPPORTED	= 978,
+        D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDLIST	= 979,
+        D3D12_MESSAGE_ID_CREATE_VIDEODECODER	= 980,
+        D3D12_MESSAGE_ID_CREATE_VIDEODECODESTREAM	= 981,
+        D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDLIST	= 982,
+        D3D12_MESSAGE_ID_LIVE_VIDEODECODER	= 983,
+        D3D12_MESSAGE_ID_LIVE_VIDEODECODESTREAM	= 984,
+        D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDLIST	= 985,
+        D3D12_MESSAGE_ID_DESTROY_VIDEODECODER	= 986,
+        D3D12_MESSAGE_ID_DESTROY_VIDEODECODESTREAM	= 987,
+        D3D12_MESSAGE_ID_DECODE_FRAME_INVALID_PARAMETERS	= 988,
+        D3D12_MESSAGE_ID_DEPRECATED_API	= 989,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_COMMAND_LIST_TYPE	= 990,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DESCRIPTOR_TABLE_NOT_SET	= 991,
+        D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_CONSTANT_BUFFER_VIEW_NOT_SET	= 992,
+        D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_SHADER_RESOURCE_VIEW_NOT_SET	= 993,
+        D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_UNORDERED_ACCESS_VIEW_NOT_SET	= 994,
+        D3D12_MESSAGE_ID_DISCARD_INVALID_SUBRESOURCE_RANGE	= 995,
+        D3D12_MESSAGE_ID_DISCARD_ONE_SUBRESOURCE_FOR_MIPS_WITH_RECTS	= 996,
+        D3D12_MESSAGE_ID_DISCARD_NO_RECTS_FOR_NON_TEXTURE2D	= 997,
+        D3D12_MESSAGE_ID_COPY_ON_SAME_SUBRESOURCE	= 998,
+        D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PAGEABLE	= 999,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UNSUPPORTED	= 1000,
+        D3D12_MESSAGE_ID_STATIC_DESCRIPTOR_INVALID_DESCRIPTOR_CHANGE	= 1001,
+        D3D12_MESSAGE_ID_DATA_STATIC_DESCRIPTOR_INVALID_DATA_CHANGE	= 1002,
+        D3D12_MESSAGE_ID_DATA_STATIC_WHILE_SET_AT_EXECUTE_DESCRIPTOR_INVALID_DATA_CHANGE	= 1003,
+        D3D12_MESSAGE_ID_EXECUTE_BUNDLE_STATIC_DESCRIPTOR_DATA_STATIC_NOT_SET	= 1004,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_ACCESS_OUT_OF_BOUNDS	= 1005,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SAMPLER_MODE_MISMATCH	= 1006,
+        D3D12_MESSAGE_ID_CREATE_FENCE_INVALID_FLAGS	= 1007,
+        D3D12_MESSAGE_ID_RESOURCE_BARRIER_DUPLICATE_SUBRESOURCE_TRANSITIONS	= 1008,
+        D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PRIORITY	= 1009,
+        D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_LARGE_NUM_DESCRIPTORS	= 1013,
+        D3D12_MESSAGE_ID_BEGIN_EVENT	= 1014,
+        D3D12_MESSAGE_ID_END_EVENT	= 1015,
+        D3D12_MESSAGE_ID_CREATEDEVICE_DEBUG_LAYER_STARTUP_OPTIONS	= 1016,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_DEPTHBOUNDSTEST_UNSUPPORTED	= 1017,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_DUPLICATE_SUBOBJECT	= 1018,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_UNKNOWN_SUBOBJECT	= 1019,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_ZERO_SIZE_STREAM	= 1020,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_STREAM	= 1021,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CANNOT_DEDUCE_TYPE	= 1022,
+        D3D12_MESSAGE_ID_COMMAND_LIST_STATIC_DESCRIPTOR_RESOURCE_DIMENSION_MISMATCH	= 1023,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_PRIVILEGE_FOR_GLOBAL_REALTIME	= 1024,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_HARDWARE_SUPPORT_FOR_GLOBAL_REALTIME	= 1025,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_ARCHITECTURE	= 1026,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DST	= 1027,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE_DIMENSION	= 1028,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DST_RANGE_OUT_OF_BOUNDS	= 1029,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_SRC	= 1030,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE_DIMENSION	= 1031,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_SRC_RANGE_OUT_OF_BOUNDS	= 1032,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_OFFSET_ALIGNMENT	= 1033,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_RESOURCES	= 1034,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_SUBRESOURCE_RANGES	= 1035,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_RESOURCE	= 1036,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_SUBRESOURCE_RANGE	= 1037,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_SUBRESOURCE_OUT_OF_BOUNDS	= 1038,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_RANGE_OUT_OF_BOUNDS	= 1039,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_ZERO_DEPENDENCIES	= 1040,
+        D3D12_MESSAGE_ID_DEVICE_CREATE_SHARED_HANDLE_INVALIDARG	= 1041,
+        D3D12_MESSAGE_ID_DESCRIPTOR_HANDLE_WITH_INVALID_RESOURCE	= 1042,
+        D3D12_MESSAGE_ID_SETDEPTHBOUNDS_INVALIDARGS	= 1043,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_STATE_IMPRECISE	= 1044,
+        D3D12_MESSAGE_ID_COMMAND_LIST_PIPELINE_STATE_NOT_SET	= 1045,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_MODEL_MISMATCH	= 1046,
+        D3D12_MESSAGE_ID_OBJECT_ACCESSED_WHILE_STILL_IN_USE	= 1047,
+        D3D12_MESSAGE_ID_PROGRAMMABLE_MSAA_UNSUPPORTED	= 1048,
+        D3D12_MESSAGE_ID_SETSAMPLEPOSITIONS_INVALIDARGS	= 1049,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCEREGION_INVALID_RECT	= 1050,
+        D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDQUEUE	= 1051,
+        D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDLIST	= 1052,
+        D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDQUEUE	= 1053,
+        D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDQUEUE	= 1054,
+        D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDLIST	= 1055,
+        D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDQUEUE	= 1056,
+        D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDQUEUE	= 1057,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDLIST	= 1058,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDQUEUE	= 1059,
+        D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSOR	= 1060,
+        D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSSTREAM	= 1061,
+        D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSOR	= 1062,
+        D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSSTREAM	= 1063,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSOR	= 1064,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSSTREAM	= 1065,
+        D3D12_MESSAGE_ID_PROCESS_FRAME_INVALID_PARAMETERS	= 1066,
+        D3D12_MESSAGE_ID_COPY_INVALIDLAYOUT	= 1067,
+        D3D12_MESSAGE_ID_CREATE_CRYPTO_SESSION	= 1068,
+        D3D12_MESSAGE_ID_CREATE_CRYPTO_SESSION_POLICY	= 1069,
+        D3D12_MESSAGE_ID_CREATE_PROTECTED_RESOURCE_SESSION	= 1070,
+        D3D12_MESSAGE_ID_LIVE_CRYPTO_SESSION	= 1071,
+        D3D12_MESSAGE_ID_LIVE_CRYPTO_SESSION_POLICY	= 1072,
+        D3D12_MESSAGE_ID_LIVE_PROTECTED_RESOURCE_SESSION	= 1073,
+        D3D12_MESSAGE_ID_DESTROY_CRYPTO_SESSION	= 1074,
+        D3D12_MESSAGE_ID_DESTROY_CRYPTO_SESSION_POLICY	= 1075,
+        D3D12_MESSAGE_ID_DESTROY_PROTECTED_RESOURCE_SESSION	= 1076,
+        D3D12_MESSAGE_ID_PROTECTED_RESOURCE_SESSION_UNSUPPORTED	= 1077,
+        D3D12_MESSAGE_ID_FENCE_INVALIDOPERATION	= 1078,
+        D3D12_MESSAGE_ID_CREATEQUERY_HEAP_COPY_QUEUE_TIMESTAMPS_NOT_SUPPORTED	= 1079,
+        D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_DEFERRED	= 1080,
+        D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMFIRSTUSE	= 1081,
+        D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMCLEAR	= 1082,
+        D3D12_MESSAGE_ID_CREATE_VIDEODECODERHEAP	= 1083,
+        D3D12_MESSAGE_ID_LIVE_VIDEODECODERHEAP	= 1084,
+        D3D12_MESSAGE_ID_DESTROY_VIDEODECODERHEAP	= 1085,
+        D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDARG_RETURN	= 1086,
+        D3D12_MESSAGE_ID_OPENEXISTINGHEAP_OUTOFMEMORY_RETURN	= 1087,
+        D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDADDRESS	= 1088,
+        D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDHANDLE	= 1089,
+        D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_DEST	= 1090,
+        D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_MODE	= 1091,
+        D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_ALIGNMENT	= 1092,
+        D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_NOT_SUPPORTED	= 1093,
+        D3D12_MESSAGE_ID_SETVIEWINSTANCEMASK_INVALIDARGS	= 1094,
+        D3D12_MESSAGE_ID_VIEW_INSTANCING_UNSUPPORTED	= 1095,
+        D3D12_MESSAGE_ID_VIEW_INSTANCING_INVALIDARGS	= 1096,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_MISMATCH_DECODE_REFERENCE_ONLY_FLAG	= 1097,
+        D3D12_MESSAGE_ID_COPYRESOURCE_MISMATCH_DECODE_REFERENCE_ONLY_FLAG	= 1098,
+        D3D12_MESSAGE_ID_CREATE_VIDEO_DECODE_HEAP_CAPS_FAILURE	= 1099,
+        D3D12_MESSAGE_ID_CREATE_VIDEO_DECODE_HEAP_CAPS_UNSUPPORTED	= 1100,
+        D3D12_MESSAGE_ID_VIDEO_DECODE_SUPPORT_INVALID_INPUT	= 1101,
+        D3D12_MESSAGE_ID_CREATE_VIDEO_DECODER_UNSUPPORTED	= 1102,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_METADATA_ERROR	= 1103,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VIEW_INSTANCING_VERTEX_SIZE_EXCEEDED	= 1104,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RUNTIME_INTERNAL_ERROR	= 1105,
+        D3D12_MESSAGE_ID_NO_VIDEO_API_SUPPORT	= 1106,
+        D3D12_MESSAGE_ID_VIDEO_PROCESS_SUPPORT_INVALID_INPUT	= 1107,
+        D3D12_MESSAGE_ID_CREATE_VIDEO_PROCESSOR_CAPS_FAILURE	= 1108,
+        D3D12_MESSAGE_ID_VIDEO_PROCESS_SUPPORT_UNSUPPORTED_FORMAT	= 1109,
+        D3D12_MESSAGE_ID_VIDEO_DECODE_FRAME_INVALID_ARGUMENT	= 1110,
+        D3D12_MESSAGE_ID_ENQUEUE_MAKE_RESIDENT_INVALID_FLAGS	= 1111,
+        D3D12_MESSAGE_ID_OPENEXISTINGHEAP_UNSUPPORTED	= 1112,
+        D3D12_MESSAGE_ID_VIDEO_PROCESS_FRAMES_INVALID_ARGUMENT	= 1113,
+        D3D12_MESSAGE_ID_VIDEO_DECODE_SUPPORT_UNSUPPORTED	= 1114,
+        D3D12_MESSAGE_ID_CREATE_COMMANDRECORDER	= 1115,
+        D3D12_MESSAGE_ID_LIVE_COMMANDRECORDER	= 1116,
+        D3D12_MESSAGE_ID_DESTROY_COMMANDRECORDER	= 1117,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_VIDEO_NOT_SUPPORTED	= 1118,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_INVALID_SUPPORT_FLAGS	= 1119,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_INVALID_FLAGS	= 1120,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_MORE_RECORDERS_THAN_LOGICAL_PROCESSORS	= 1121,
+        D3D12_MESSAGE_ID_CREATE_COMMANDPOOL	= 1122,
+        D3D12_MESSAGE_ID_LIVE_COMMANDPOOL	= 1123,
+        D3D12_MESSAGE_ID_DESTROY_COMMANDPOOL	= 1124,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_POOL_INVALID_FLAGS	= 1125,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_VIDEO_NOT_SUPPORTED	= 1126,
+        D3D12_MESSAGE_ID_COMMAND_RECORDER_SUPPORT_FLAGS_MISMATCH	= 1127,
+        D3D12_MESSAGE_ID_COMMAND_RECORDER_CONTENTION	= 1128,
+        D3D12_MESSAGE_ID_COMMAND_RECORDER_USAGE_WITH_CREATECOMMANDLIST_COMMAND_LIST	= 1129,
+        D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_USAGE_WITH_CREATECOMMANDLIST1_COMMAND_LIST	= 1130,
+        D3D12_MESSAGE_ID_CANNOT_EXECUTE_EMPTY_COMMAND_LIST	= 1131,
+        D3D12_MESSAGE_ID_CANNOT_RESET_COMMAND_POOL_WITH_OPEN_COMMAND_LISTS	= 1132,
+        D3D12_MESSAGE_ID_CANNOT_USE_COMMAND_RECORDER_WITHOUT_CURRENT_TARGET	= 1133,
+        D3D12_MESSAGE_ID_CANNOT_CHANGE_COMMAND_RECORDER_TARGET_WHILE_RECORDING	= 1134,
+        D3D12_MESSAGE_ID_COMMAND_POOL_SYNC	= 1135,
+        D3D12_MESSAGE_ID_EVICT_UNDERFLOW	= 1136,
+        D3D12_MESSAGE_ID_CREATE_META_COMMAND	= 1137,
+        D3D12_MESSAGE_ID_LIVE_META_COMMAND	= 1138,
+        D3D12_MESSAGE_ID_DESTROY_META_COMMAND	= 1139,
+        D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALID_DST_RESOURCE	= 1140,
+        D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALID_SRC_RESOURCE	= 1141,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE	= 1142,
+        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE	= 1143,
+        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_NULL_BUFFER	= 1144,
+        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_NULL_RESOURCE_DESC	= 1145,
+        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_UNSUPPORTED	= 1146,
+        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_DIMENSION	= 1147,
+        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_FLAGS	= 1148,
+        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_OFFSET	= 1149,
+        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_DIMENSION	= 1150,
+        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_FLAGS	= 1151,
+        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_OUTOFMEMORY_RETURN	= 1152,
+        D3D12_MESSAGE_ID_CANNOT_CREATE_GRAPHICS_AND_VIDEO_COMMAND_RECORDER	= 1153,
+        D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_POSSIBLY_MISMATCHING_PROPERTIES	= 1154,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE	= 1155,
+        D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_INCOMPATIBLE_WITH_STRUCTURED_BUFFERS	= 1156,
+        D3D12_MESSAGE_ID_COMPUTE_ONLY_DEVICE_OPERATION_UNSUPPORTED	= 1157,
+        D3D12_MESSAGE_ID_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INVALID	= 1158,
+        D3D12_MESSAGE_ID_EMIT_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_INVALID	= 1159,
+        D3D12_MESSAGE_ID_COPY_RAYTRACING_ACCELERATION_STRUCTURE_INVALID	= 1160,
+        D3D12_MESSAGE_ID_DISPATCH_RAYS_INVALID	= 1161,
+        D3D12_MESSAGE_ID_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_INVALID	= 1162,
+        D3D12_MESSAGE_ID_CREATE_LIFETIMETRACKER	= 1163,
+        D3D12_MESSAGE_ID_LIVE_LIFETIMETRACKER	= 1164,
+        D3D12_MESSAGE_ID_DESTROY_LIFETIMETRACKER	= 1165,
+        D3D12_MESSAGE_ID_DESTROYOWNEDOBJECT_OBJECTNOTOWNED	= 1166,
+        D3D12_MESSAGE_ID_CREATE_TRACKEDWORKLOAD	= 1167,
+        D3D12_MESSAGE_ID_LIVE_TRACKEDWORKLOAD	= 1168,
+        D3D12_MESSAGE_ID_DESTROY_TRACKEDWORKLOAD	= 1169,
+        D3D12_MESSAGE_ID_RENDER_PASS_ERROR	= 1170,
+        D3D12_MESSAGE_ID_META_COMMAND_ID_INVALID	= 1171,
+        D3D12_MESSAGE_ID_META_COMMAND_UNSUPPORTED_PARAMS	= 1172,
+        D3D12_MESSAGE_ID_META_COMMAND_FAILED_ENUMERATION	= 1173,
+        D3D12_MESSAGE_ID_META_COMMAND_PARAMETER_SIZE_MISMATCH	= 1174,
+        D3D12_MESSAGE_ID_UNINITIALIZED_META_COMMAND	= 1175,
+        D3D12_MESSAGE_ID_META_COMMAND_INVALID_GPU_VIRTUAL_ADDRESS	= 1176,
+        D3D12_MESSAGE_ID_CREATE_VIDEOENCODECOMMANDLIST	= 1177,
+        D3D12_MESSAGE_ID_LIVE_VIDEOENCODECOMMANDLIST	= 1178,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOENCODECOMMANDLIST	= 1179,
+        D3D12_MESSAGE_ID_CREATE_VIDEOENCODECOMMANDQUEUE	= 1180,
+        D3D12_MESSAGE_ID_LIVE_VIDEOENCODECOMMANDQUEUE	= 1181,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOENCODECOMMANDQUEUE	= 1182,
+        D3D12_MESSAGE_ID_CREATE_VIDEOMOTIONESTIMATOR	= 1183,
+        D3D12_MESSAGE_ID_LIVE_VIDEOMOTIONESTIMATOR	= 1184,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOMOTIONESTIMATOR	= 1185,
+        D3D12_MESSAGE_ID_CREATE_VIDEOMOTIONVECTORHEAP	= 1186,
+        D3D12_MESSAGE_ID_LIVE_VIDEOMOTIONVECTORHEAP	= 1187,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOMOTIONVECTORHEAP	= 1188,
+        D3D12_MESSAGE_ID_MULTIPLE_TRACKED_WORKLOADS	= 1189,
+        D3D12_MESSAGE_ID_MULTIPLE_TRACKED_WORKLOAD_PAIRS	= 1190,
+        D3D12_MESSAGE_ID_OUT_OF_ORDER_TRACKED_WORKLOAD_PAIR	= 1191,
+        D3D12_MESSAGE_ID_CANNOT_ADD_TRACKED_WORKLOAD	= 1192,
+        D3D12_MESSAGE_ID_INCOMPLETE_TRACKED_WORKLOAD_PAIR	= 1193,
+        D3D12_MESSAGE_ID_CREATE_STATE_OBJECT_ERROR	= 1194,
+        D3D12_MESSAGE_ID_GET_SHADER_IDENTIFIER_ERROR	= 1195,
+        D3D12_MESSAGE_ID_GET_SHADER_STACK_SIZE_ERROR	= 1196,
+        D3D12_MESSAGE_ID_GET_PIPELINE_STACK_SIZE_ERROR	= 1197,
+        D3D12_MESSAGE_ID_SET_PIPELINE_STACK_SIZE_ERROR	= 1198,
+        D3D12_MESSAGE_ID_GET_SHADER_IDENTIFIER_SIZE_INVALID	= 1199,
+        D3D12_MESSAGE_ID_CHECK_DRIVER_MATCHING_IDENTIFIER_INVALID	= 1200,
+        D3D12_MESSAGE_ID_CHECK_DRIVER_MATCHING_IDENTIFIER_DRIVER_REPORTED_ISSUE	= 1201,
+        D3D12_MESSAGE_ID_RENDER_PASS_INVALID_RESOURCE_BARRIER	= 1202,
+        D3D12_MESSAGE_ID_RENDER_PASS_DISALLOWED_API_CALLED	= 1203,
+        D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_NEST_RENDER_PASSES	= 1204,
+        D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_END_WITHOUT_BEGIN	= 1205,
+        D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_CLOSE_COMMAND_LIST	= 1206,
+        D3D12_MESSAGE_ID_RENDER_PASS_GPU_WORK_WHILE_SUSPENDED	= 1207,
+        D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_SUSPEND_RESUME	= 1208,
+        D3D12_MESSAGE_ID_RENDER_PASS_NO_PRIOR_SUSPEND_WITHIN_EXECUTECOMMANDLISTS	= 1209,
+        D3D12_MESSAGE_ID_RENDER_PASS_NO_SUBSEQUENT_RESUME_WITHIN_EXECUTECOMMANDLISTS	= 1210,
+        D3D12_MESSAGE_ID_TRACKED_WORKLOAD_COMMAND_QUEUE_MISMATCH	= 1211,
+        D3D12_MESSAGE_ID_TRACKED_WORKLOAD_NOT_SUPPORTED	= 1212,
+        D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_NO_ACCESS	= 1213,
+        D3D12_MESSAGE_ID_RENDER_PASS_UNSUPPORTED_RESOLVE	= 1214,
+        D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_INVALID_RESOURCE_PTR	= 1215,
+        D3D12_MESSAGE_ID_WINDOWS7_FENCE_OUTOFORDER_SIGNAL	= 1216,
+        D3D12_MESSAGE_ID_WINDOWS7_FENCE_OUTOFORDER_WAIT	= 1217,
+        D3D12_MESSAGE_ID_VIDEO_CREATE_MOTION_ESTIMATOR_INVALID_ARGUMENT	= 1218,
+        D3D12_MESSAGE_ID_VIDEO_CREATE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT	= 1219,
+        D3D12_MESSAGE_ID_ESTIMATE_MOTION_INVALID_ARGUMENT	= 1220,
+        D3D12_MESSAGE_ID_RESOLVE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT	= 1221,
+        D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_HEAP_TYPE	= 1222,
+        D3D12_MESSAGE_ID_SET_BACKGROUND_PROCESSING_MODE_INVALID_ARGUMENT	= 1223,
+        D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE_FOR_FEATURE_LEVEL	= 1224,
+        D3D12_MESSAGE_ID_CREATE_VIDEOEXTENSIONCOMMAND	= 1225,
+        D3D12_MESSAGE_ID_LIVE_VIDEOEXTENSIONCOMMAND	= 1226,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOEXTENSIONCOMMAND	= 1227,
+        D3D12_MESSAGE_ID_INVALID_VIDEO_EXTENSION_COMMAND_ID	= 1228,
+        D3D12_MESSAGE_ID_VIDEO_EXTENSION_COMMAND_INVALID_ARGUMENT	= 1229,
+        D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_UNIQUE_IN_DXIL_LIBRARY	= 1230,
+        D3D12_MESSAGE_ID_VARIABLE_SHADING_RATE_NOT_ALLOWED_WITH_TIR	= 1231,
+        D3D12_MESSAGE_ID_GEOMETRY_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE	= 1232,
+        D3D12_MESSAGE_ID_RSSETSHADING_RATE_INVALID_SHADING_RATE	= 1233,
+        D3D12_MESSAGE_ID_RSSETSHADING_RATE_SHADING_RATE_NOT_PERMITTED_BY_CAP	= 1234,
+        D3D12_MESSAGE_ID_RSSETSHADING_RATE_INVALID_COMBINER	= 1235,
+        D3D12_MESSAGE_ID_RSSETSHADINGRATEIMAGE_REQUIRES_TIER_2	= 1236,
+        D3D12_MESSAGE_ID_RSSETSHADINGRATE_REQUIRES_TIER_1	= 1237,
+        D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_FORMAT	= 1238,
+        D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_ARRAY_SIZE	= 1239,
+        D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_MIP_LEVEL	= 1240,
+        D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_SAMPLE_COUNT	= 1241,
+        D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_SAMPLE_QUALITY	= 1242,
+        D3D12_MESSAGE_ID_NON_RETAIL_SHADER_MODEL_WONT_VALIDATE	= 1243,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_AS_ROOT_SIGNATURE_MISMATCH	= 1244,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MS_ROOT_SIGNATURE_MISMATCH	= 1245,
+        D3D12_MESSAGE_ID_ADD_TO_STATE_OBJECT_ERROR	= 1246,
+        D3D12_MESSAGE_ID_CREATE_PROTECTED_RESOURCE_SESSION_INVALID_ARGUMENT	= 1247,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MS_PSO_DESC_MISMATCH	= 1248,
+        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_MS_INCOMPLETE_TYPE	= 1249,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_AS_NOT_MS_MISMATCH	= 1250,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MS_NOT_PS_MISMATCH	= 1251,
+        D3D12_MESSAGE_ID_NONZERO_SAMPLER_FEEDBACK_MIP_REGION_WITH_INCOMPATIBLE_FORMAT	= 1252,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_SHADER_MISMATCH	= 1253,
+        D3D12_MESSAGE_ID_EMPTY_DISPATCH	= 1254,
+        D3D12_MESSAGE_ID_RESOURCE_FORMAT_REQUIRES_SAMPLER_FEEDBACK_CAPABILITY	= 1255,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_MIP_REGION	= 1256,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_DIMENSION	= 1257,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_SAMPLE_COUNT	= 1258,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_SAMPLE_QUALITY	= 1259,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_INVALID_LAYOUT	= 1260,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_MAP_REQUIRES_UNORDERED_ACCESS_FLAG	= 1261,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_CREATE_UAV_NULL_ARGUMENTS	= 1262,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_UAV_REQUIRES_SAMPLER_FEEDBACK_CAPABILITY	= 1263,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_CREATE_UAV_REQUIRES_FEEDBACK_MAP_FORMAT	= 1264,
+        D3D12_MESSAGE_ID_CREATEMESHSHADER_INVALIDSHADERBYTECODE	= 1265,
+        D3D12_MESSAGE_ID_CREATEMESHSHADER_OUTOFMEMORY	= 1266,
+        D3D12_MESSAGE_ID_CREATEMESHSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE	= 1267,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_TRANSCODE_INVALID_FORMAT	= 1268,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_INVALID_MIP_LEVEL_COUNT	= 1269,
+        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_SAMPLER_FEEDBACK_TRANSCODE_ARRAY_SIZE_MISMATCH	= 1270,
+        D3D12_MESSAGE_ID_SAMPLER_FEEDBACK_CREATE_UAV_MISMATCHING_TARGETED_RESOURCE	= 1271,
+        D3D12_MESSAGE_ID_CREATEMESHSHADER_OUTPUTEXCEEDSMAXSIZE	= 1272,
+        D3D12_MESSAGE_ID_CREATEMESHSHADER_GROUPSHAREDEXCEEDSMAXSIZE	= 1273,
+        D3D12_MESSAGE_ID_VERTEX_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE	= 1274,
+        D3D12_MESSAGE_ID_MESH_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE	= 1275,
+        D3D12_MESSAGE_ID_CREATEMESHSHADER_MISMATCHEDASMSPAYLOADSIZE	= 1276,
+        D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_UNBOUNDED_STATIC_DESCRIPTORS	= 1277,
+        D3D12_MESSAGE_ID_CREATEAMPLIFICATIONSHADER_INVALIDSHADERBYTECODE	= 1278,
+        D3D12_MESSAGE_ID_CREATEAMPLIFICATIONSHADER_OUTOFMEMORY	= 1279,
+        D3D12_MESSAGE_ID_CREATE_SHADERCACHESESSION	= 1280,
+        D3D12_MESSAGE_ID_LIVE_SHADERCACHESESSION	= 1281,
+        D3D12_MESSAGE_ID_DESTROY_SHADERCACHESESSION	= 1282,
+        D3D12_MESSAGE_ID_CREATESHADERCACHESESSION_INVALIDARGS	= 1283,
+        D3D12_MESSAGE_ID_CREATESHADERCACHESESSION_DISABLED	= 1284,
+        D3D12_MESSAGE_ID_CREATESHADERCACHESESSION_ALREADYOPEN	= 1285,
+        D3D12_MESSAGE_ID_SHADERCACHECONTROL_DEVELOPERMODE	= 1286,
+        D3D12_MESSAGE_ID_SHADERCACHECONTROL_INVALIDFLAGS	= 1287,
+        D3D12_MESSAGE_ID_SHADERCACHECONTROL_STATEALREADYSET	= 1288,
+        D3D12_MESSAGE_ID_SHADERCACHECONTROL_IGNOREDFLAG	= 1289,
+        D3D12_MESSAGE_ID_SHADERCACHESESSION_STOREVALUE_ALREADYPRESENT	= 1290,
+        D3D12_MESSAGE_ID_SHADERCACHESESSION_STOREVALUE_HASHCOLLISION	= 1291,
+        D3D12_MESSAGE_ID_SHADERCACHESESSION_STOREVALUE_CACHEFULL	= 1292,
+        D3D12_MESSAGE_ID_SHADERCACHESESSION_FINDVALUE_NOTFOUND	= 1293,
+        D3D12_MESSAGE_ID_SHADERCACHESESSION_CORRUPT	= 1294,
+        D3D12_MESSAGE_ID_SHADERCACHESESSION_DISABLED	= 1295,
+        D3D12_MESSAGE_ID_OVERSIZED_DISPATCH	= 1296,
+        D3D12_MESSAGE_ID_CREATE_VIDEOENCODER	= 1297,
+        D3D12_MESSAGE_ID_LIVE_VIDEOENCODER	= 1298,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOENCODER	= 1299,
+        D3D12_MESSAGE_ID_CREATE_VIDEOENCODERHEAP	= 1300,
+        D3D12_MESSAGE_ID_LIVE_VIDEOENCODERHEAP	= 1301,
+        D3D12_MESSAGE_ID_DESTROY_VIDEOENCODERHEAP	= 1302,
+        D3D12_MESSAGE_ID_COPYTEXTUREREGION_MISMATCH_ENCODE_REFERENCE_ONLY_FLAG	= 1303,
+        D3D12_MESSAGE_ID_COPYRESOURCE_MISMATCH_ENCODE_REFERENCE_ONLY_FLAG	= 1304,
+        D3D12_MESSAGE_ID_ENCODE_FRAME_INVALID_PARAMETERS	= 1305,
+        D3D12_MESSAGE_ID_ENCODE_FRAME_UNSUPPORTED_PARAMETERS	= 1306,
+        D3D12_MESSAGE_ID_RESOLVE_ENCODER_OUTPUT_METADATA_INVALID_PARAMETERS	= 1307,
+        D3D12_MESSAGE_ID_RESOLVE_ENCODER_OUTPUT_METADATA_UNSUPPORTED_PARAMETERS	= 1308,
+        D3D12_MESSAGE_ID_CREATE_VIDEO_ENCODER_INVALID_PARAMETERS	= 1309,
+        D3D12_MESSAGE_ID_CREATE_VIDEO_ENCODER_UNSUPPORTED_PARAMETERS	= 1310,
+        D3D12_MESSAGE_ID_CREATE_VIDEO_ENCODER_HEAP_INVALID_PARAMETERS	= 1311,
+        D3D12_MESSAGE_ID_CREATE_VIDEO_ENCODER_HEAP_UNSUPPORTED_PARAMETERS	= 1312,
+        D3D12_MESSAGE_ID_CREATECOMMANDLIST_NULL_COMMANDALLOCATOR	= 1313,
+        D3D12_MESSAGE_ID_CLEAR_UNORDERED_ACCESS_VIEW_INVALID_DESCRIPTOR_HANDLE	= 1314,
+        D3D12_MESSAGE_ID_DESCRIPTOR_HEAP_NOT_SHADER_VISIBLE	= 1315,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_BLENDOP_WARNING	= 1316,
+        D3D12_MESSAGE_ID_CREATEBLENDSTATE_BLENDOPALPHA_WARNING	= 1317,
+        D3D12_MESSAGE_ID_WRITE_COMBINE_PERFORMANCE_WARNING	= 1318,
+        D3D12_MESSAGE_ID_RESOLVE_QUERY_INVALID_QUERY_STATE	= 1319,
+        D3D12_MESSAGE_ID_SETPRIVATEDATA_NO_ACCESS	= 1320,
+        D3D12_MESSAGE_ID_COMMAND_LIST_STATIC_DESCRIPTOR_SAMPLER_MODE_MISMATCH	= 1321,
+        D3D12_MESSAGE_ID_GETCOPYABLEFOOTPRINTS_UNSUPPORTED_BUFFER_WIDTH	= 1322,
+        D3D12_MESSAGE_ID_CREATEMESHSHADER_TOPOLOGY_MISMATCH	= 1323,
+        D3D12_MESSAGE_ID_VRS_SUM_COMBINER_REQUIRES_CAPABILITY	= 1324,
+        D3D12_MESSAGE_ID_SETTING_SHADING_RATE_FROM_MS_REQUIRES_CAPABILITY	= 1325,
+        D3D12_MESSAGE_ID_SHADERCACHESESSION_SHADERCACHEDELETE_NOTSUPPORTED	= 1326,
+        D3D12_MESSAGE_ID_SHADERCACHECONTROL_SHADERCACHECLEAR_NOTSUPPORTED	= 1327,
+        D3D12_MESSAGE_ID_CREATERESOURCE_STATE_IGNORED	= 1328,
+        D3D12_MESSAGE_ID_UNUSED_CROSS_EXECUTE_SPLIT_BARRIER	= 1329,
+        D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_HANDLE_ACCESS_DENIED	= 1330,
+        D3D12_MESSAGE_ID_INCOMPATIBLE_BARRIER_VALUES	= 1331,
+        D3D12_MESSAGE_ID_INCOMPATIBLE_BARRIER_ACCESS	= 1332,
+        D3D12_MESSAGE_ID_INCOMPATIBLE_BARRIER_SYNC	= 1333,
+        D3D12_MESSAGE_ID_INCOMPATIBLE_BARRIER_LAYOUT	= 1334,
+        D3D12_MESSAGE_ID_INCOMPATIBLE_BARRIER_TYPE	= 1335,
+        D3D12_MESSAGE_ID_OUT_OF_BOUNDS_BARRIER_SUBRESOURCE_RANGE	= 1336,
+        D3D12_MESSAGE_ID_INCOMPATIBLE_BARRIER_RESOURCE_DIMENSION	= 1337,
+        D3D12_MESSAGE_ID_SET_SCISSOR_RECTS_INVALID_RECT	= 1338,
+        D3D12_MESSAGE_ID_SHADING_RATE_SOURCE_REQUIRES_DIMENSION_TEXTURE2D	= 1339,
+        D3D12_MESSAGE_ID_BUFFER_BARRIER_SUBREGION_OUT_OF_BOUNDS	= 1340,
+        D3D12_MESSAGE_ID_UNSUPPORTED_BARRIER_LAYOUT	= 1341,
+        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALID_PARAMETERS	= 1342,
+        D3D12_MESSAGE_ID_ENHANCED_BARRIERS_NOT_SUPPORTED	= 1343,
+        D3D12_MESSAGE_ID_CAST_TARGET_TEXEL_SIZE_MISMATCH	= 1344,
+        D3D12_MESSAGE_ID_CAST_TO_PLANAR_NOT_SUPORTED	= 1345,
+        D3D12_MESSAGE_ID_LEGACY_BARRIER_VALIDATION_FORCED_ON	= 1346,
+        D3D12_MESSAGE_ID_EMPTY_ROOT_DESCRIPTOR_TABLE	= 1347,
+        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ELEMENT_OFFSET_UNALIGNED	= 1348,
+        D3D12_MESSAGE_ID_ALPHA_BLEND_FACTOR_NOT_SUPPORTED	= 1349,
+        D3D12_MESSAGE_ID_BARRIER_INTEROP_INVALID_LAYOUT	= 1350,
+        D3D12_MESSAGE_ID_BARRIER_INTEROP_INVALID_STATE	= 1351,
+        D3D12_MESSAGE_ID_GRAPHICS_PIPELINE_STATE_DESC_ZERO_SAMPLE_MASK	= 1352,
+        D3D12_MESSAGE_ID_INDEPENDENT_STENCIL_REF_NOT_SUPPORTED	= 1353,
+        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INDEPENDENT_MASKS_UNSUPPORTED	= 1354,
+        D3D12_MESSAGE_ID_TEXTURE_BARRIER_SUBRESOURCES_OUT_OF_BOUNDS	= 1355,
+        D3D12_MESSAGE_ID_NON_OPTIMAL_BARRIER_ONLY_EXECUTE_COMMAND_LISTS	= 1356,
+        D3D12_MESSAGE_ID_EXECUTE_INDIRECT_ZERO_COMMAND_COUNT	= 1357,
+        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INCOMPATIBLE_TEXTURE_LAYOUT	= 1358,
+        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DYNAMIC_INDEX_BUFFER_STRIP_CUT_NOT_SUPPORTED	= 1359,
+        D3D12_MESSAGE_ID_PRIMITIVE_TOPOLOGY_TRIANGLE_FANS_NOT_SUPPORTED	= 1360,
+        D3D12_MESSAGE_ID_CREATE_SAMPLER_COMPARISON_FUNC_IGNORED	= 1361,
+        D3D12_MESSAGE_ID_D3D12_MESSAGES_END	= ( D3D12_MESSAGE_ID_CREATE_SAMPLER_COMPARISON_FUNC_IGNORED + 1 ) 
+    } 	D3D12_MESSAGE_ID;
+
+typedef struct D3D12_MESSAGE
+    {
+    D3D12_MESSAGE_CATEGORY Category;
+    D3D12_MESSAGE_SEVERITY Severity;
+    D3D12_MESSAGE_ID ID;
+    _Field_size_(DescriptionByteLength)  const char *pDescription;
+    SIZE_T DescriptionByteLength;
+    } 	D3D12_MESSAGE;
+
+typedef struct D3D12_INFO_QUEUE_FILTER_DESC
+    {
+    UINT NumCategories;
+    _Field_size_(NumCategories)  D3D12_MESSAGE_CATEGORY *pCategoryList;
+    UINT NumSeverities;
+    _Field_size_(NumSeverities)  D3D12_MESSAGE_SEVERITY *pSeverityList;
+    UINT NumIDs;
+    _Field_size_(NumIDs)  D3D12_MESSAGE_ID *pIDList;
+    } 	D3D12_INFO_QUEUE_FILTER_DESC;
+
+typedef struct D3D12_INFO_QUEUE_FILTER
+    {
+    D3D12_INFO_QUEUE_FILTER_DESC AllowList;
+    D3D12_INFO_QUEUE_FILTER_DESC DenyList;
+    } 	D3D12_INFO_QUEUE_FILTER;
+
+#define D3D12_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMIT 1024
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0017_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0017_v0_0_s_ifspec;
+
+#ifndef __ID3D12InfoQueue_INTERFACE_DEFINED__
+#define __ID3D12InfoQueue_INTERFACE_DEFINED__
+
+/* interface ID3D12InfoQueue */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12InfoQueue;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("0742a90b-c387-483f-b946-30a7e4e61458")
+    ID3D12InfoQueue : public IUnknown
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE SetMessageCountLimit( 
+            _In_  UINT64 MessageCountLimit) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearStoredMessages( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetMessage( 
+            _In_  UINT64 MessageIndex,
+            _Out_writes_bytes_opt_(*pMessageByteLength)  D3D12_MESSAGE *pMessage,
+            _Inout_  SIZE_T *pMessageByteLength) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetNumMessagesAllowedByStorageFilter( void) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetNumMessagesDeniedByStorageFilter( void) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetNumStoredMessages( void) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetNumStoredMessagesAllowedByRetrievalFilter( void) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetNumMessagesDiscardedByMessageCountLimit( void) = 0;
+        
+        virtual UINT64 STDMETHODCALLTYPE GetMessageCountLimit( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE AddStorageFilterEntries( 
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetStorageFilter( 
+            _Out_writes_bytes_opt_(*pFilterByteLength)  D3D12_INFO_QUEUE_FILTER *pFilter,
+            _Inout_  SIZE_T *pFilterByteLength) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearStorageFilter( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushEmptyStorageFilter( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushCopyOfStorageFilter( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushStorageFilter( 
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter) = 0;
+        
+        virtual void STDMETHODCALLTYPE PopStorageFilter( void) = 0;
+        
+        virtual UINT STDMETHODCALLTYPE GetStorageFilterStackSize( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE AddRetrievalFilterEntries( 
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetRetrievalFilter( 
+            _Out_writes_bytes_opt_(*pFilterByteLength)  D3D12_INFO_QUEUE_FILTER *pFilter,
+            _Inout_  SIZE_T *pFilterByteLength) = 0;
+        
+        virtual void STDMETHODCALLTYPE ClearRetrievalFilter( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushEmptyRetrievalFilter( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushCopyOfRetrievalFilter( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE PushRetrievalFilter( 
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter) = 0;
+        
+        virtual void STDMETHODCALLTYPE PopRetrievalFilter( void) = 0;
+        
+        virtual UINT STDMETHODCALLTYPE GetRetrievalFilterStackSize( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE AddMessage( 
+            _In_  D3D12_MESSAGE_CATEGORY Category,
+            _In_  D3D12_MESSAGE_SEVERITY Severity,
+            _In_  D3D12_MESSAGE_ID ID,
+            _In_  LPCSTR pDescription) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE AddApplicationMessage( 
+            _In_  D3D12_MESSAGE_SEVERITY Severity,
+            _In_  LPCSTR pDescription) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetBreakOnCategory( 
+            _In_  D3D12_MESSAGE_CATEGORY Category,
+            _In_  BOOL bEnable) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetBreakOnSeverity( 
+            _In_  D3D12_MESSAGE_SEVERITY Severity,
+            _In_  BOOL bEnable) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE SetBreakOnID( 
+            _In_  D3D12_MESSAGE_ID ID,
+            _In_  BOOL bEnable) = 0;
+        
+        virtual BOOL STDMETHODCALLTYPE GetBreakOnCategory( 
+            _In_  D3D12_MESSAGE_CATEGORY Category) = 0;
+        
+        virtual BOOL STDMETHODCALLTYPE GetBreakOnSeverity( 
+            _In_  D3D12_MESSAGE_SEVERITY Severity) = 0;
+        
+        virtual BOOL STDMETHODCALLTYPE GetBreakOnID( 
+            _In_  D3D12_MESSAGE_ID ID) = 0;
+        
+        virtual void STDMETHODCALLTYPE SetMuteDebugOutput( 
+            _In_  BOOL bMute) = 0;
+        
+        virtual BOOL STDMETHODCALLTYPE GetMuteDebugOutput( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12InfoQueueVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12InfoQueue * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetMessageCountLimit)
+        HRESULT ( STDMETHODCALLTYPE *SetMessageCountLimit )( 
+            ID3D12InfoQueue * This,
+            _In_  UINT64 MessageCountLimit);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, ClearStoredMessages)
+        void ( STDMETHODCALLTYPE *ClearStoredMessages )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetMessage)
+        HRESULT ( STDMETHODCALLTYPE *GetMessage )( 
+            ID3D12InfoQueue * This,
+            _In_  UINT64 MessageIndex,
+            _Out_writes_bytes_opt_(*pMessageByteLength)  D3D12_MESSAGE *pMessage,
+            _Inout_  SIZE_T *pMessageByteLength);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumMessagesAllowedByStorageFilter)
+        UINT64 ( STDMETHODCALLTYPE *GetNumMessagesAllowedByStorageFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumMessagesDeniedByStorageFilter)
+        UINT64 ( STDMETHODCALLTYPE *GetNumMessagesDeniedByStorageFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumStoredMessages)
+        UINT64 ( STDMETHODCALLTYPE *GetNumStoredMessages )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumStoredMessagesAllowedByRetrievalFilter)
+        UINT64 ( STDMETHODCALLTYPE *GetNumStoredMessagesAllowedByRetrievalFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumMessagesDiscardedByMessageCountLimit)
+        UINT64 ( STDMETHODCALLTYPE *GetNumMessagesDiscardedByMessageCountLimit )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetMessageCountLimit)
+        UINT64 ( STDMETHODCALLTYPE *GetMessageCountLimit )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, AddStorageFilterEntries)
+        HRESULT ( STDMETHODCALLTYPE *AddStorageFilterEntries )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetStorageFilter)
+        HRESULT ( STDMETHODCALLTYPE *GetStorageFilter )( 
+            ID3D12InfoQueue * This,
+            _Out_writes_bytes_opt_(*pFilterByteLength)  D3D12_INFO_QUEUE_FILTER *pFilter,
+            _Inout_  SIZE_T *pFilterByteLength);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, ClearStorageFilter)
+        void ( STDMETHODCALLTYPE *ClearStorageFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushEmptyStorageFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushEmptyStorageFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushCopyOfStorageFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushCopyOfStorageFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushStorageFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushStorageFilter )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PopStorageFilter)
+        void ( STDMETHODCALLTYPE *PopStorageFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetStorageFilterStackSize)
+        UINT ( STDMETHODCALLTYPE *GetStorageFilterStackSize )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, AddRetrievalFilterEntries)
+        HRESULT ( STDMETHODCALLTYPE *AddRetrievalFilterEntries )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetRetrievalFilter)
+        HRESULT ( STDMETHODCALLTYPE *GetRetrievalFilter )( 
+            ID3D12InfoQueue * This,
+            _Out_writes_bytes_opt_(*pFilterByteLength)  D3D12_INFO_QUEUE_FILTER *pFilter,
+            _Inout_  SIZE_T *pFilterByteLength);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, ClearRetrievalFilter)
+        void ( STDMETHODCALLTYPE *ClearRetrievalFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushEmptyRetrievalFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushEmptyRetrievalFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushCopyOfRetrievalFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushCopyOfRetrievalFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushRetrievalFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushRetrievalFilter )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PopRetrievalFilter)
+        void ( STDMETHODCALLTYPE *PopRetrievalFilter )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetRetrievalFilterStackSize)
+        UINT ( STDMETHODCALLTYPE *GetRetrievalFilterStackSize )( 
+            ID3D12InfoQueue * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, AddMessage)
+        HRESULT ( STDMETHODCALLTYPE *AddMessage )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_MESSAGE_CATEGORY Category,
+            _In_  D3D12_MESSAGE_SEVERITY Severity,
+            _In_  D3D12_MESSAGE_ID ID,
+            _In_  LPCSTR pDescription);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, AddApplicationMessage)
+        HRESULT ( STDMETHODCALLTYPE *AddApplicationMessage )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_MESSAGE_SEVERITY Severity,
+            _In_  LPCSTR pDescription);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetBreakOnCategory)
+        HRESULT ( STDMETHODCALLTYPE *SetBreakOnCategory )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_MESSAGE_CATEGORY Category,
+            _In_  BOOL bEnable);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetBreakOnSeverity)
+        HRESULT ( STDMETHODCALLTYPE *SetBreakOnSeverity )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_MESSAGE_SEVERITY Severity,
+            _In_  BOOL bEnable);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetBreakOnID)
+        HRESULT ( STDMETHODCALLTYPE *SetBreakOnID )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_MESSAGE_ID ID,
+            _In_  BOOL bEnable);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetBreakOnCategory)
+        BOOL ( STDMETHODCALLTYPE *GetBreakOnCategory )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_MESSAGE_CATEGORY Category);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetBreakOnSeverity)
+        BOOL ( STDMETHODCALLTYPE *GetBreakOnSeverity )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_MESSAGE_SEVERITY Severity);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetBreakOnID)
+        BOOL ( STDMETHODCALLTYPE *GetBreakOnID )( 
+            ID3D12InfoQueue * This,
+            _In_  D3D12_MESSAGE_ID ID);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetMuteDebugOutput)
+        void ( STDMETHODCALLTYPE *SetMuteDebugOutput )( 
+            ID3D12InfoQueue * This,
+            _In_  BOOL bMute);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetMuteDebugOutput)
+        BOOL ( STDMETHODCALLTYPE *GetMuteDebugOutput )( 
+            ID3D12InfoQueue * This);
+        
+        END_INTERFACE
+    } ID3D12InfoQueueVtbl;
+
+    interface ID3D12InfoQueue
+    {
+        CONST_VTBL struct ID3D12InfoQueueVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12InfoQueue_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12InfoQueue_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12InfoQueue_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12InfoQueue_SetMessageCountLimit(This,MessageCountLimit)	\
+    ( (This)->lpVtbl -> SetMessageCountLimit(This,MessageCountLimit) ) 
+
+#define ID3D12InfoQueue_ClearStoredMessages(This)	\
+    ( (This)->lpVtbl -> ClearStoredMessages(This) ) 
+
+#define ID3D12InfoQueue_GetMessage(This,MessageIndex,pMessage,pMessageByteLength)	\
+    ( (This)->lpVtbl -> GetMessage(This,MessageIndex,pMessage,pMessageByteLength) ) 
+
+#define ID3D12InfoQueue_GetNumMessagesAllowedByStorageFilter(This)	\
+    ( (This)->lpVtbl -> GetNumMessagesAllowedByStorageFilter(This) ) 
+
+#define ID3D12InfoQueue_GetNumMessagesDeniedByStorageFilter(This)	\
+    ( (This)->lpVtbl -> GetNumMessagesDeniedByStorageFilter(This) ) 
+
+#define ID3D12InfoQueue_GetNumStoredMessages(This)	\
+    ( (This)->lpVtbl -> GetNumStoredMessages(This) ) 
+
+#define ID3D12InfoQueue_GetNumStoredMessagesAllowedByRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> GetNumStoredMessagesAllowedByRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue_GetNumMessagesDiscardedByMessageCountLimit(This)	\
+    ( (This)->lpVtbl -> GetNumMessagesDiscardedByMessageCountLimit(This) ) 
+
+#define ID3D12InfoQueue_GetMessageCountLimit(This)	\
+    ( (This)->lpVtbl -> GetMessageCountLimit(This) ) 
+
+#define ID3D12InfoQueue_AddStorageFilterEntries(This,pFilter)	\
+    ( (This)->lpVtbl -> AddStorageFilterEntries(This,pFilter) ) 
+
+#define ID3D12InfoQueue_GetStorageFilter(This,pFilter,pFilterByteLength)	\
+    ( (This)->lpVtbl -> GetStorageFilter(This,pFilter,pFilterByteLength) ) 
+
+#define ID3D12InfoQueue_ClearStorageFilter(This)	\
+    ( (This)->lpVtbl -> ClearStorageFilter(This) ) 
+
+#define ID3D12InfoQueue_PushEmptyStorageFilter(This)	\
+    ( (This)->lpVtbl -> PushEmptyStorageFilter(This) ) 
+
+#define ID3D12InfoQueue_PushCopyOfStorageFilter(This)	\
+    ( (This)->lpVtbl -> PushCopyOfStorageFilter(This) ) 
+
+#define ID3D12InfoQueue_PushStorageFilter(This,pFilter)	\
+    ( (This)->lpVtbl -> PushStorageFilter(This,pFilter) ) 
+
+#define ID3D12InfoQueue_PopStorageFilter(This)	\
+    ( (This)->lpVtbl -> PopStorageFilter(This) ) 
+
+#define ID3D12InfoQueue_GetStorageFilterStackSize(This)	\
+    ( (This)->lpVtbl -> GetStorageFilterStackSize(This) ) 
+
+#define ID3D12InfoQueue_AddRetrievalFilterEntries(This,pFilter)	\
+    ( (This)->lpVtbl -> AddRetrievalFilterEntries(This,pFilter) ) 
+
+#define ID3D12InfoQueue_GetRetrievalFilter(This,pFilter,pFilterByteLength)	\
+    ( (This)->lpVtbl -> GetRetrievalFilter(This,pFilter,pFilterByteLength) ) 
+
+#define ID3D12InfoQueue_ClearRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> ClearRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue_PushEmptyRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> PushEmptyRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue_PushCopyOfRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> PushCopyOfRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue_PushRetrievalFilter(This,pFilter)	\
+    ( (This)->lpVtbl -> PushRetrievalFilter(This,pFilter) ) 
+
+#define ID3D12InfoQueue_PopRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> PopRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue_GetRetrievalFilterStackSize(This)	\
+    ( (This)->lpVtbl -> GetRetrievalFilterStackSize(This) ) 
+
+#define ID3D12InfoQueue_AddMessage(This,Category,Severity,ID,pDescription)	\
+    ( (This)->lpVtbl -> AddMessage(This,Category,Severity,ID,pDescription) ) 
+
+#define ID3D12InfoQueue_AddApplicationMessage(This,Severity,pDescription)	\
+    ( (This)->lpVtbl -> AddApplicationMessage(This,Severity,pDescription) ) 
+
+#define ID3D12InfoQueue_SetBreakOnCategory(This,Category,bEnable)	\
+    ( (This)->lpVtbl -> SetBreakOnCategory(This,Category,bEnable) ) 
+
+#define ID3D12InfoQueue_SetBreakOnSeverity(This,Severity,bEnable)	\
+    ( (This)->lpVtbl -> SetBreakOnSeverity(This,Severity,bEnable) ) 
+
+#define ID3D12InfoQueue_SetBreakOnID(This,ID,bEnable)	\
+    ( (This)->lpVtbl -> SetBreakOnID(This,ID,bEnable) ) 
+
+#define ID3D12InfoQueue_GetBreakOnCategory(This,Category)	\
+    ( (This)->lpVtbl -> GetBreakOnCategory(This,Category) ) 
+
+#define ID3D12InfoQueue_GetBreakOnSeverity(This,Severity)	\
+    ( (This)->lpVtbl -> GetBreakOnSeverity(This,Severity) ) 
+
+#define ID3D12InfoQueue_GetBreakOnID(This,ID)	\
+    ( (This)->lpVtbl -> GetBreakOnID(This,ID) ) 
+
+#define ID3D12InfoQueue_SetMuteDebugOutput(This,bMute)	\
+    ( (This)->lpVtbl -> SetMuteDebugOutput(This,bMute) ) 
+
+#define ID3D12InfoQueue_GetMuteDebugOutput(This)	\
+    ( (This)->lpVtbl -> GetMuteDebugOutput(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12InfoQueue_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12sdklayers_0000_0018 */
+/* [local] */ 
+
+typedef 
+enum D3D12_MESSAGE_CALLBACK_FLAGS
+    {
+        D3D12_MESSAGE_CALLBACK_FLAG_NONE	= 0,
+        D3D12_MESSAGE_CALLBACK_IGNORE_FILTERS	= 0x1
+    } 	D3D12_MESSAGE_CALLBACK_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_MESSAGE_CALLBACK_FLAGS)
+typedef void ( __stdcall *D3D12MessageFunc )( 
+    D3D12_MESSAGE_CATEGORY Category,
+    D3D12_MESSAGE_SEVERITY Severity,
+    D3D12_MESSAGE_ID ID,
+    LPCSTR pDescription,
+    void *pContext);
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0018_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0018_v0_0_s_ifspec;
+
+#ifndef __ID3D12InfoQueue1_INTERFACE_DEFINED__
+#define __ID3D12InfoQueue1_INTERFACE_DEFINED__
+
+/* interface ID3D12InfoQueue1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12InfoQueue1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("2852dd88-b484-4c0c-b6b1-67168500e600")
+    ID3D12InfoQueue1 : public ID3D12InfoQueue
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE RegisterMessageCallback( 
+            _In_  D3D12MessageFunc CallbackFunc,
+            _In_  D3D12_MESSAGE_CALLBACK_FLAGS CallbackFilterFlags,
+            _In_  void *pContext,
+            _Inout_  DWORD *pCallbackCookie) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE UnregisterMessageCallback( 
+            _In_  DWORD CallbackCookie) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12InfoQueue1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12InfoQueue1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetMessageCountLimit)
+        HRESULT ( STDMETHODCALLTYPE *SetMessageCountLimit )( 
+            ID3D12InfoQueue1 * This,
+            _In_  UINT64 MessageCountLimit);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, ClearStoredMessages)
+        void ( STDMETHODCALLTYPE *ClearStoredMessages )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetMessage)
+        HRESULT ( STDMETHODCALLTYPE *GetMessage )( 
+            ID3D12InfoQueue1 * This,
+            _In_  UINT64 MessageIndex,
+            _Out_writes_bytes_opt_(*pMessageByteLength)  D3D12_MESSAGE *pMessage,
+            _Inout_  SIZE_T *pMessageByteLength);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumMessagesAllowedByStorageFilter)
+        UINT64 ( STDMETHODCALLTYPE *GetNumMessagesAllowedByStorageFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumMessagesDeniedByStorageFilter)
+        UINT64 ( STDMETHODCALLTYPE *GetNumMessagesDeniedByStorageFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumStoredMessages)
+        UINT64 ( STDMETHODCALLTYPE *GetNumStoredMessages )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumStoredMessagesAllowedByRetrievalFilter)
+        UINT64 ( STDMETHODCALLTYPE *GetNumStoredMessagesAllowedByRetrievalFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetNumMessagesDiscardedByMessageCountLimit)
+        UINT64 ( STDMETHODCALLTYPE *GetNumMessagesDiscardedByMessageCountLimit )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetMessageCountLimit)
+        UINT64 ( STDMETHODCALLTYPE *GetMessageCountLimit )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, AddStorageFilterEntries)
+        HRESULT ( STDMETHODCALLTYPE *AddStorageFilterEntries )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetStorageFilter)
+        HRESULT ( STDMETHODCALLTYPE *GetStorageFilter )( 
+            ID3D12InfoQueue1 * This,
+            _Out_writes_bytes_opt_(*pFilterByteLength)  D3D12_INFO_QUEUE_FILTER *pFilter,
+            _Inout_  SIZE_T *pFilterByteLength);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, ClearStorageFilter)
+        void ( STDMETHODCALLTYPE *ClearStorageFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushEmptyStorageFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushEmptyStorageFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushCopyOfStorageFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushCopyOfStorageFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushStorageFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushStorageFilter )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PopStorageFilter)
+        void ( STDMETHODCALLTYPE *PopStorageFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetStorageFilterStackSize)
+        UINT ( STDMETHODCALLTYPE *GetStorageFilterStackSize )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, AddRetrievalFilterEntries)
+        HRESULT ( STDMETHODCALLTYPE *AddRetrievalFilterEntries )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetRetrievalFilter)
+        HRESULT ( STDMETHODCALLTYPE *GetRetrievalFilter )( 
+            ID3D12InfoQueue1 * This,
+            _Out_writes_bytes_opt_(*pFilterByteLength)  D3D12_INFO_QUEUE_FILTER *pFilter,
+            _Inout_  SIZE_T *pFilterByteLength);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, ClearRetrievalFilter)
+        void ( STDMETHODCALLTYPE *ClearRetrievalFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushEmptyRetrievalFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushEmptyRetrievalFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushCopyOfRetrievalFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushCopyOfRetrievalFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PushRetrievalFilter)
+        HRESULT ( STDMETHODCALLTYPE *PushRetrievalFilter )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, PopRetrievalFilter)
+        void ( STDMETHODCALLTYPE *PopRetrievalFilter )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetRetrievalFilterStackSize)
+        UINT ( STDMETHODCALLTYPE *GetRetrievalFilterStackSize )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, AddMessage)
+        HRESULT ( STDMETHODCALLTYPE *AddMessage )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_MESSAGE_CATEGORY Category,
+            _In_  D3D12_MESSAGE_SEVERITY Severity,
+            _In_  D3D12_MESSAGE_ID ID,
+            _In_  LPCSTR pDescription);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, AddApplicationMessage)
+        HRESULT ( STDMETHODCALLTYPE *AddApplicationMessage )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_MESSAGE_SEVERITY Severity,
+            _In_  LPCSTR pDescription);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetBreakOnCategory)
+        HRESULT ( STDMETHODCALLTYPE *SetBreakOnCategory )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_MESSAGE_CATEGORY Category,
+            _In_  BOOL bEnable);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetBreakOnSeverity)
+        HRESULT ( STDMETHODCALLTYPE *SetBreakOnSeverity )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_MESSAGE_SEVERITY Severity,
+            _In_  BOOL bEnable);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetBreakOnID)
+        HRESULT ( STDMETHODCALLTYPE *SetBreakOnID )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_MESSAGE_ID ID,
+            _In_  BOOL bEnable);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetBreakOnCategory)
+        BOOL ( STDMETHODCALLTYPE *GetBreakOnCategory )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_MESSAGE_CATEGORY Category);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetBreakOnSeverity)
+        BOOL ( STDMETHODCALLTYPE *GetBreakOnSeverity )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_MESSAGE_SEVERITY Severity);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetBreakOnID)
+        BOOL ( STDMETHODCALLTYPE *GetBreakOnID )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12_MESSAGE_ID ID);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, SetMuteDebugOutput)
+        void ( STDMETHODCALLTYPE *SetMuteDebugOutput )( 
+            ID3D12InfoQueue1 * This,
+            _In_  BOOL bMute);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue, GetMuteDebugOutput)
+        BOOL ( STDMETHODCALLTYPE *GetMuteDebugOutput )( 
+            ID3D12InfoQueue1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue1, RegisterMessageCallback)
+        HRESULT ( STDMETHODCALLTYPE *RegisterMessageCallback )( 
+            ID3D12InfoQueue1 * This,
+            _In_  D3D12MessageFunc CallbackFunc,
+            _In_  D3D12_MESSAGE_CALLBACK_FLAGS CallbackFilterFlags,
+            _In_  void *pContext,
+            _Inout_  DWORD *pCallbackCookie);
+        
+        DECLSPEC_XFGVIRT(ID3D12InfoQueue1, UnregisterMessageCallback)
+        HRESULT ( STDMETHODCALLTYPE *UnregisterMessageCallback )( 
+            ID3D12InfoQueue1 * This,
+            _In_  DWORD CallbackCookie);
+        
+        END_INTERFACE
+    } ID3D12InfoQueue1Vtbl;
+
+    interface ID3D12InfoQueue1
+    {
+        CONST_VTBL struct ID3D12InfoQueue1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12InfoQueue1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12InfoQueue1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12InfoQueue1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12InfoQueue1_SetMessageCountLimit(This,MessageCountLimit)	\
+    ( (This)->lpVtbl -> SetMessageCountLimit(This,MessageCountLimit) ) 
+
+#define ID3D12InfoQueue1_ClearStoredMessages(This)	\
+    ( (This)->lpVtbl -> ClearStoredMessages(This) ) 
+
+#define ID3D12InfoQueue1_GetMessage(This,MessageIndex,pMessage,pMessageByteLength)	\
+    ( (This)->lpVtbl -> GetMessage(This,MessageIndex,pMessage,pMessageByteLength) ) 
+
+#define ID3D12InfoQueue1_GetNumMessagesAllowedByStorageFilter(This)	\
+    ( (This)->lpVtbl -> GetNumMessagesAllowedByStorageFilter(This) ) 
+
+#define ID3D12InfoQueue1_GetNumMessagesDeniedByStorageFilter(This)	\
+    ( (This)->lpVtbl -> GetNumMessagesDeniedByStorageFilter(This) ) 
+
+#define ID3D12InfoQueue1_GetNumStoredMessages(This)	\
+    ( (This)->lpVtbl -> GetNumStoredMessages(This) ) 
+
+#define ID3D12InfoQueue1_GetNumStoredMessagesAllowedByRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> GetNumStoredMessagesAllowedByRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue1_GetNumMessagesDiscardedByMessageCountLimit(This)	\
+    ( (This)->lpVtbl -> GetNumMessagesDiscardedByMessageCountLimit(This) ) 
+
+#define ID3D12InfoQueue1_GetMessageCountLimit(This)	\
+    ( (This)->lpVtbl -> GetMessageCountLimit(This) ) 
+
+#define ID3D12InfoQueue1_AddStorageFilterEntries(This,pFilter)	\
+    ( (This)->lpVtbl -> AddStorageFilterEntries(This,pFilter) ) 
+
+#define ID3D12InfoQueue1_GetStorageFilter(This,pFilter,pFilterByteLength)	\
+    ( (This)->lpVtbl -> GetStorageFilter(This,pFilter,pFilterByteLength) ) 
+
+#define ID3D12InfoQueue1_ClearStorageFilter(This)	\
+    ( (This)->lpVtbl -> ClearStorageFilter(This) ) 
+
+#define ID3D12InfoQueue1_PushEmptyStorageFilter(This)	\
+    ( (This)->lpVtbl -> PushEmptyStorageFilter(This) ) 
+
+#define ID3D12InfoQueue1_PushCopyOfStorageFilter(This)	\
+    ( (This)->lpVtbl -> PushCopyOfStorageFilter(This) ) 
+
+#define ID3D12InfoQueue1_PushStorageFilter(This,pFilter)	\
+    ( (This)->lpVtbl -> PushStorageFilter(This,pFilter) ) 
+
+#define ID3D12InfoQueue1_PopStorageFilter(This)	\
+    ( (This)->lpVtbl -> PopStorageFilter(This) ) 
+
+#define ID3D12InfoQueue1_GetStorageFilterStackSize(This)	\
+    ( (This)->lpVtbl -> GetStorageFilterStackSize(This) ) 
+
+#define ID3D12InfoQueue1_AddRetrievalFilterEntries(This,pFilter)	\
+    ( (This)->lpVtbl -> AddRetrievalFilterEntries(This,pFilter) ) 
+
+#define ID3D12InfoQueue1_GetRetrievalFilter(This,pFilter,pFilterByteLength)	\
+    ( (This)->lpVtbl -> GetRetrievalFilter(This,pFilter,pFilterByteLength) ) 
+
+#define ID3D12InfoQueue1_ClearRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> ClearRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue1_PushEmptyRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> PushEmptyRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue1_PushCopyOfRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> PushCopyOfRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue1_PushRetrievalFilter(This,pFilter)	\
+    ( (This)->lpVtbl -> PushRetrievalFilter(This,pFilter) ) 
+
+#define ID3D12InfoQueue1_PopRetrievalFilter(This)	\
+    ( (This)->lpVtbl -> PopRetrievalFilter(This) ) 
+
+#define ID3D12InfoQueue1_GetRetrievalFilterStackSize(This)	\
+    ( (This)->lpVtbl -> GetRetrievalFilterStackSize(This) ) 
+
+#define ID3D12InfoQueue1_AddMessage(This,Category,Severity,ID,pDescription)	\
+    ( (This)->lpVtbl -> AddMessage(This,Category,Severity,ID,pDescription) ) 
+
+#define ID3D12InfoQueue1_AddApplicationMessage(This,Severity,pDescription)	\
+    ( (This)->lpVtbl -> AddApplicationMessage(This,Severity,pDescription) ) 
+
+#define ID3D12InfoQueue1_SetBreakOnCategory(This,Category,bEnable)	\
+    ( (This)->lpVtbl -> SetBreakOnCategory(This,Category,bEnable) ) 
+
+#define ID3D12InfoQueue1_SetBreakOnSeverity(This,Severity,bEnable)	\
+    ( (This)->lpVtbl -> SetBreakOnSeverity(This,Severity,bEnable) ) 
+
+#define ID3D12InfoQueue1_SetBreakOnID(This,ID,bEnable)	\
+    ( (This)->lpVtbl -> SetBreakOnID(This,ID,bEnable) ) 
+
+#define ID3D12InfoQueue1_GetBreakOnCategory(This,Category)	\
+    ( (This)->lpVtbl -> GetBreakOnCategory(This,Category) ) 
+
+#define ID3D12InfoQueue1_GetBreakOnSeverity(This,Severity)	\
+    ( (This)->lpVtbl -> GetBreakOnSeverity(This,Severity) ) 
+
+#define ID3D12InfoQueue1_GetBreakOnID(This,ID)	\
+    ( (This)->lpVtbl -> GetBreakOnID(This,ID) ) 
+
+#define ID3D12InfoQueue1_SetMuteDebugOutput(This,bMute)	\
+    ( (This)->lpVtbl -> SetMuteDebugOutput(This,bMute) ) 
+
+#define ID3D12InfoQueue1_GetMuteDebugOutput(This)	\
+    ( (This)->lpVtbl -> GetMuteDebugOutput(This) ) 
+
+
+#define ID3D12InfoQueue1_RegisterMessageCallback(This,CallbackFunc,CallbackFilterFlags,pContext,pCallbackCookie)	\
+    ( (This)->lpVtbl -> RegisterMessageCallback(This,CallbackFunc,CallbackFilterFlags,pContext,pCallbackCookie) ) 
+
+#define ID3D12InfoQueue1_UnregisterMessageCallback(This,CallbackCookie)	\
+    ( (This)->lpVtbl -> UnregisterMessageCallback(This,CallbackCookie) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12InfoQueue1_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12sdklayers_0000_0019 */
+/* [local] */ 
+
+#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */
+#pragma endregion
+DEFINE_GUID(IID_ID3D12Debug,0x344488b7,0x6846,0x474b,0xb9,0x89,0xf0,0x27,0x44,0x82,0x45,0xe0);
+DEFINE_GUID(IID_ID3D12Debug1,0xaffaa4ca,0x63fe,0x4d8e,0xb8,0xad,0x15,0x90,0x00,0xaf,0x43,0x04);
+DEFINE_GUID(IID_ID3D12Debug2,0x93a665c4,0xa3b2,0x4e5d,0xb6,0x92,0xa2,0x6a,0xe1,0x4e,0x33,0x74);
+DEFINE_GUID(IID_ID3D12Debug3,0x5cf4e58f,0xf671,0x4ff1,0xa5,0x42,0x36,0x86,0xe3,0xd1,0x53,0xd1);
+DEFINE_GUID(IID_ID3D12Debug4,0x014b816e,0x9ec5,0x4a2f,0xa8,0x45,0xff,0xbe,0x44,0x1c,0xe1,0x3a);
+DEFINE_GUID(IID_ID3D12Debug5,0x548d6b12,0x09fa,0x40e0,0x90,0x69,0x5d,0xcd,0x58,0x9a,0x52,0xc9);
+DEFINE_GUID(IID_ID3D12Debug6,0x82a816d6,0x5d01,0x4157,0x97,0xd0,0x49,0x75,0x46,0x3f,0xd1,0xed);
+DEFINE_GUID(IID_ID3D12DebugDevice1,0xa9b71770,0xd099,0x4a65,0xa6,0x98,0x3d,0xee,0x10,0x02,0x0f,0x88);
+DEFINE_GUID(IID_ID3D12DebugDevice,0x3febd6dd,0x4973,0x4787,0x81,0x94,0xe4,0x5f,0x9e,0x28,0x92,0x3e);
+DEFINE_GUID(IID_ID3D12DebugDevice2,0x60eccbc1,0x378d,0x4df1,0x89,0x4c,0xf8,0xac,0x5c,0xe4,0xd7,0xdd);
+DEFINE_GUID(IID_ID3D12DebugCommandQueue,0x09e0bf36,0x54ac,0x484f,0x88,0x47,0x4b,0xae,0xea,0xb6,0x05,0x3a);
+DEFINE_GUID(IID_ID3D12DebugCommandQueue1,0x16be35a2,0xbfd6,0x49f2,0xbc,0xae,0xea,0xae,0x4a,0xff,0x86,0x2d);
+DEFINE_GUID(IID_ID3D12DebugCommandList1,0x102ca951,0x311b,0x4b01,0xb1,0x1f,0xec,0xb8,0x3e,0x06,0x1b,0x37);
+DEFINE_GUID(IID_ID3D12DebugCommandList,0x09e0bf36,0x54ac,0x484f,0x88,0x47,0x4b,0xae,0xea,0xb6,0x05,0x3f);
+DEFINE_GUID(IID_ID3D12DebugCommandList2,0xaeb575cf,0x4e06,0x48be,0xba,0x3b,0xc4,0x50,0xfc,0x96,0x65,0x2e);
+DEFINE_GUID(IID_ID3D12DebugCommandList3,0x197d5e15,0x4d37,0x4d34,0xaf,0x78,0x72,0x4c,0xd7,0x0f,0xdb,0x1f);
+DEFINE_GUID(IID_ID3D12SharingContract,0x0adf7d52,0x929c,0x4e61,0xad,0xdb,0xff,0xed,0x30,0xde,0x66,0xef);
+DEFINE_GUID(IID_ID3D12InfoQueue,0x0742a90b,0xc387,0x483f,0xb9,0x46,0x30,0xa7,0xe4,0xe6,0x14,0x58);
+DEFINE_GUID(IID_ID3D12InfoQueue1,0x2852dd88,0xb484,0x4c0c,0xb6,0xb1,0x67,0x16,0x85,0x00,0xe6,0x00);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0019_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0019_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+

3rdparty/dxsdk/include/d3d12shader.h → 3rdparty/directx-headers/include/directx/d3d12shader.h

@@ -1,6 +1,7 @@
 //////////////////////////////////////////////////////////////////////////////
 //
-//  Copyright (c) Microsoft Corporation.  All rights reserved.
+//  Copyright (c) Microsoft Corporation.
+//  Licensed under the MIT license.
 //
 //  File:       D3D12Shader.h
 //  Content:    D3D12 Shader Types and APIs
@@ -14,16 +15,29 @@
 
 typedef enum D3D12_SHADER_VERSION_TYPE
 {
-    D3D12_SHVER_PIXEL_SHADER    = 0,
-    D3D12_SHVER_VERTEX_SHADER   = 1,
-    D3D12_SHVER_GEOMETRY_SHADER = 2,
+    D3D12_SHVER_PIXEL_SHADER          = 0,
+    D3D12_SHVER_VERTEX_SHADER         = 1,
+    D3D12_SHVER_GEOMETRY_SHADER       = 2,
     
     // D3D11 Shaders
-    D3D12_SHVER_HULL_SHADER     = 3,
-    D3D12_SHVER_DOMAIN_SHADER   = 4,
-    D3D12_SHVER_COMPUTE_SHADER  = 5,
+    D3D12_SHVER_HULL_SHADER           = 3,
+    D3D12_SHVER_DOMAIN_SHADER         = 4,
+    D3D12_SHVER_COMPUTE_SHADER        = 5,
 
-    D3D12_SHVER_RESERVED0       = 0xFFF0,
+    // D3D12 Shaders
+    D3D12_SHVER_LIBRARY               = 6,
+
+    D3D12_SHVER_RAY_GENERATION_SHADER = 7,
+    D3D12_SHVER_INTERSECTION_SHADER   = 8,
+    D3D12_SHVER_ANY_HIT_SHADER        = 9,
+    D3D12_SHVER_CLOSEST_HIT_SHADER    = 10,
+    D3D12_SHVER_MISS_SHADER           = 11,
+    D3D12_SHVER_CALLABLE_SHADER       = 12,
+
+    D3D12_SHVER_MESH_SHADER           = 13,
+    D3D12_SHVER_AMPLIFICATION_SHADER  = 14,
+
+    D3D12_SHVER_RESERVED0             = 0xFFF0,
 } D3D12_SHADER_VERSION_TYPE;
 
 #define D3D12_SHVER_GET_TYPE(_Version) \
@@ -172,6 +186,23 @@ typedef struct _D3D12_SHADER_INPUT_BIND_DESC
 #define D3D_SHADER_REQUIRES_TYPED_UAV_LOAD_ADDITIONAL_FORMATS                               0x00000800
 #define D3D_SHADER_REQUIRES_ROVS                                                            0x00001000
 #define D3D_SHADER_REQUIRES_VIEWPORT_AND_RT_ARRAY_INDEX_FROM_ANY_SHADER_FEEDING_RASTERIZER  0x00002000
+#define D3D_SHADER_REQUIRES_WAVE_OPS                                                        0x00004000
+#define D3D_SHADER_REQUIRES_INT64_OPS                                                       0x00008000
+#define D3D_SHADER_REQUIRES_VIEW_ID                                                         0x00010000
+#define D3D_SHADER_REQUIRES_BARYCENTRICS                                                    0x00020000
+#define D3D_SHADER_REQUIRES_NATIVE_16BIT_OPS                                                0x00040000
+#define D3D_SHADER_REQUIRES_SHADING_RATE                                                    0x00080000
+#define D3D_SHADER_REQUIRES_RAYTRACING_TIER_1_1                                             0x00100000
+#define D3D_SHADER_REQUIRES_SAMPLER_FEEDBACK                                                0x00200000
+#define D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_TYPED_RESOURCE                                  0x00400000
+#define D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_GROUP_SHARED                                    0x00800000
+#define D3D_SHADER_REQUIRES_DERIVATIVES_IN_MESH_AND_AMPLIFICATION_SHADERS                   0x01000000
+#define D3D_SHADER_REQUIRES_RESOURCE_DESCRIPTOR_HEAP_INDEXING                               0x02000000
+#define D3D_SHADER_REQUIRES_SAMPLER_DESCRIPTOR_HEAP_INDEXING                                0x04000000
+#define D3D_SHADER_REQUIRES_WAVE_MMA                                                        0x08000000
+#define D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE                        0x10000000
+#define D3D_SHADER_FEATURE_ADVANCED_TEXTURE_OPS                                             0x20000000
+#define D3D_SHADER_FEATURE_WRITEABLE_MSAA_TEXTURES                                          0x40000000
 
 
 typedef struct _D3D12_LIBRARY_DESC

3rdparty/directx-headers/include/directx/d3d12video.h

@@ -0,0 +1,8584 @@
+/*-------------------------------------------------------------------------------------
+ *
+ * Copyright (c) Microsoft Corporation
+ * Licensed under the MIT license
+ *
+ *-------------------------------------------------------------------------------------*/
+
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+
+ /* File created by MIDL compiler version 8.01.0628 */
+
+
+
+/* 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
+
+#ifndef DECLSPEC_XFGVIRT
+#if defined(_CONTROL_FLOW_GUARD_XFG)
+#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func))
+#else
+#define DECLSPEC_XFGVIRT(base, func)
+#endif
+#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__ */
+
+
+#ifndef __ID3D12VideoMotionEstimator_FWD_DEFINED__
+#define __ID3D12VideoMotionEstimator_FWD_DEFINED__
+typedef interface ID3D12VideoMotionEstimator ID3D12VideoMotionEstimator;
+
+#endif 	/* __ID3D12VideoMotionEstimator_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoMotionVectorHeap_FWD_DEFINED__
+#define __ID3D12VideoMotionVectorHeap_FWD_DEFINED__
+typedef interface ID3D12VideoMotionVectorHeap ID3D12VideoMotionVectorHeap;
+
+#endif 	/* __ID3D12VideoMotionVectorHeap_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDevice1_FWD_DEFINED__
+#define __ID3D12VideoDevice1_FWD_DEFINED__
+typedef interface ID3D12VideoDevice1 ID3D12VideoDevice1;
+
+#endif 	/* __ID3D12VideoDevice1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoEncodeCommandList_FWD_DEFINED__
+#define __ID3D12VideoEncodeCommandList_FWD_DEFINED__
+typedef interface ID3D12VideoEncodeCommandList ID3D12VideoEncodeCommandList;
+
+#endif 	/* __ID3D12VideoEncodeCommandList_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecoder1_FWD_DEFINED__
+#define __ID3D12VideoDecoder1_FWD_DEFINED__
+typedef interface ID3D12VideoDecoder1 ID3D12VideoDecoder1;
+
+#endif 	/* __ID3D12VideoDecoder1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecoderHeap1_FWD_DEFINED__
+#define __ID3D12VideoDecoderHeap1_FWD_DEFINED__
+typedef interface ID3D12VideoDecoderHeap1 ID3D12VideoDecoderHeap1;
+
+#endif 	/* __ID3D12VideoDecoderHeap1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessor1_FWD_DEFINED__
+#define __ID3D12VideoProcessor1_FWD_DEFINED__
+typedef interface ID3D12VideoProcessor1 ID3D12VideoProcessor1;
+
+#endif 	/* __ID3D12VideoProcessor1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoExtensionCommand_FWD_DEFINED__
+#define __ID3D12VideoExtensionCommand_FWD_DEFINED__
+typedef interface ID3D12VideoExtensionCommand ID3D12VideoExtensionCommand;
+
+#endif 	/* __ID3D12VideoExtensionCommand_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDevice2_FWD_DEFINED__
+#define __ID3D12VideoDevice2_FWD_DEFINED__
+typedef interface ID3D12VideoDevice2 ID3D12VideoDevice2;
+
+#endif 	/* __ID3D12VideoDevice2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecodeCommandList2_FWD_DEFINED__
+#define __ID3D12VideoDecodeCommandList2_FWD_DEFINED__
+typedef interface ID3D12VideoDecodeCommandList2 ID3D12VideoDecodeCommandList2;
+
+#endif 	/* __ID3D12VideoDecodeCommandList2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecodeCommandList3_FWD_DEFINED__
+#define __ID3D12VideoDecodeCommandList3_FWD_DEFINED__
+typedef interface ID3D12VideoDecodeCommandList3 ID3D12VideoDecodeCommandList3;
+
+#endif 	/* __ID3D12VideoDecodeCommandList3_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessCommandList2_FWD_DEFINED__
+#define __ID3D12VideoProcessCommandList2_FWD_DEFINED__
+typedef interface ID3D12VideoProcessCommandList2 ID3D12VideoProcessCommandList2;
+
+#endif 	/* __ID3D12VideoProcessCommandList2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessCommandList3_FWD_DEFINED__
+#define __ID3D12VideoProcessCommandList3_FWD_DEFINED__
+typedef interface ID3D12VideoProcessCommandList3 ID3D12VideoProcessCommandList3;
+
+#endif 	/* __ID3D12VideoProcessCommandList3_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoEncodeCommandList1_FWD_DEFINED__
+#define __ID3D12VideoEncodeCommandList1_FWD_DEFINED__
+typedef interface ID3D12VideoEncodeCommandList1 ID3D12VideoEncodeCommandList1;
+
+#endif 	/* __ID3D12VideoEncodeCommandList1_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoEncoder_FWD_DEFINED__
+#define __ID3D12VideoEncoder_FWD_DEFINED__
+typedef interface ID3D12VideoEncoder ID3D12VideoEncoder;
+
+#endif 	/* __ID3D12VideoEncoder_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoEncoderHeap_FWD_DEFINED__
+#define __ID3D12VideoEncoderHeap_FWD_DEFINED__
+typedef interface ID3D12VideoEncoderHeap ID3D12VideoEncoderHeap;
+
+#endif 	/* __ID3D12VideoEncoderHeap_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDevice3_FWD_DEFINED__
+#define __ID3D12VideoDevice3_FWD_DEFINED__
+typedef interface ID3D12VideoDevice3 ID3D12VideoDevice3;
+
+#endif 	/* __ID3D12VideoDevice3_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoEncodeCommandList2_FWD_DEFINED__
+#define __ID3D12VideoEncodeCommandList2_FWD_DEFINED__
+typedef interface ID3D12VideoEncodeCommandList2 ID3D12VideoEncodeCommandList2;
+
+#endif 	/* __ID3D12VideoEncodeCommandList2_FWD_DEFINED__ */
+
+
+#ifndef __ID3D12VideoEncodeCommandList3_FWD_DEFINED__
+#define __ID3D12VideoEncodeCommandList3_FWD_DEFINED__
+typedef interface ID3D12VideoEncodeCommandList3 ID3D12VideoEncodeCommandList3;
+
+#endif 	/* __ID3D12VideoEncodeCommandList3_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 | WINAPI_PARTITION_GAMES)
+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_FEATURE_AREA_SUPPORT	= 19,
+        D3D12_FEATURE_VIDEO_MOTION_ESTIMATOR	= 20,
+        D3D12_FEATURE_VIDEO_MOTION_ESTIMATOR_SIZE	= 21,
+        D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_COUNT	= 22,
+        D3D12_FEATURE_VIDEO_EXTENSION_COMMANDS	= 23,
+        D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_PARAMETER_COUNT	= 24,
+        D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_PARAMETERS	= 25,
+        D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_SUPPORT	= 26,
+        D3D12_FEATURE_VIDEO_EXTENSION_COMMAND_SIZE	= 27,
+        D3D12_FEATURE_VIDEO_DECODE_PROTECTED_RESOURCES	= 28,
+        D3D12_FEATURE_VIDEO_PROCESS_PROTECTED_RESOURCES	= 29,
+        D3D12_FEATURE_VIDEO_MOTION_ESTIMATOR_PROTECTED_RESOURCES	= 30,
+        D3D12_FEATURE_VIDEO_DECODER_HEAP_SIZE1	= 31,
+        D3D12_FEATURE_VIDEO_PROCESSOR_SIZE1	= 32,
+        D3D12_FEATURE_VIDEO_ENCODER_CODEC	= 33,
+        D3D12_FEATURE_VIDEO_ENCODER_PROFILE_LEVEL	= 34,
+        D3D12_FEATURE_VIDEO_ENCODER_OUTPUT_RESOLUTION_RATIOS_COUNT	= 35,
+        D3D12_FEATURE_VIDEO_ENCODER_OUTPUT_RESOLUTION	= 36,
+        D3D12_FEATURE_VIDEO_ENCODER_INPUT_FORMAT	= 37,
+        D3D12_FEATURE_VIDEO_ENCODER_RATE_CONTROL_MODE	= 38,
+        D3D12_FEATURE_VIDEO_ENCODER_INTRA_REFRESH_MODE	= 39,
+        D3D12_FEATURE_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE	= 40,
+        D3D12_FEATURE_VIDEO_ENCODER_HEAP_SIZE	= 41,
+        D3D12_FEATURE_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT	= 42,
+        D3D12_FEATURE_VIDEO_ENCODER_SUPPORT	= 43,
+        D3D12_FEATURE_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT	= 44,
+        D3D12_FEATURE_VIDEO_ENCODER_RESOURCE_REQUIREMENTS	= 45
+    } 	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:
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_VIDEO_DECODER_HEAP_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+#else
+        virtual D3D12_VIDEO_DECODER_HEAP_DESC *STDMETHODCALLTYPE GetDesc( 
+            D3D12_VIDEO_DECODER_HEAP_DESC * RetVal) = 0;
+#endif
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecoderHeapVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecoderHeap * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecoderHeap * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecoderHeap * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecoderHeap * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecoderHeap * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecoderHeap * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecoderHeap * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecoderHeap * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecoderHeap, GetDesc)
+#if !defined(_WIN32)
+        D3D12_VIDEO_DECODER_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoDecoderHeap * This);
+        
+#else
+        D3D12_VIDEO_DECODER_HEAP_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoDecoderHeap * This,
+            D3D12_VIDEO_DECODER_HEAP_DESC * RetVal);
+        
+#endif
+        
+        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) ) 
+
+
+#if !defined(_WIN32)
+
+#define ID3D12VideoDecoderHeap_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12VideoDecoderHeap_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#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
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDevice * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDevice * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDevice * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12VideoDevice * This,
+            D3D12_FEATURE_VIDEO FeatureVideo,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoDecoder)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoder )( 
+            ID3D12VideoDevice * This,
+            _In_  const D3D12_VIDEO_DECODER_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoder);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoDecoderHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoderHeap )( 
+            ID3D12VideoDevice * This,
+            _In_  const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoderHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoProcessor)
+        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:
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_VIDEO_DECODER_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+#else
+        virtual D3D12_VIDEO_DECODER_DESC *STDMETHODCALLTYPE GetDesc( 
+            D3D12_VIDEO_DECODER_DESC * RetVal) = 0;
+#endif
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecoderVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecoder * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecoder * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecoder * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecoder * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecoder * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecoder * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecoder * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecoder * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecoder, GetDesc)
+#if !defined(_WIN32)
+        D3D12_VIDEO_DECODER_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoDecoder * This);
+        
+#else
+        D3D12_VIDEO_DECODER_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoDecoder * This,
+            D3D12_VIDEO_DECODER_DESC * RetVal);
+        
+#endif
+        
+        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) ) 
+
+
+#if !defined(_WIN32)
+
+#define ID3D12VideoDecoder_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12VideoDecoder_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#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_RATE_EXCEEDED	= 4
+    } 	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_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;
+        
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC STDMETHODCALLTYPE GetOutputStreamDesc( void) = 0;
+#else
+        virtual D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *STDMETHODCALLTYPE GetOutputStreamDesc( 
+            D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC * RetVal) = 0;
+#endif
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoProcessorVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoProcessor * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoProcessor * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoProcessor * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoProcessor * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoProcessor * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoProcessor * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoProcessor * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoProcessor * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessor, GetNodeMask)
+        UINT ( STDMETHODCALLTYPE *GetNodeMask )( 
+            ID3D12VideoProcessor * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessor, GetNumInputStreamDescs)
+        UINT ( STDMETHODCALLTYPE *GetNumInputStreamDescs )( 
+            ID3D12VideoProcessor * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessor, GetInputStreamDescs)
+        HRESULT ( STDMETHODCALLTYPE *GetInputStreamDescs )( 
+            ID3D12VideoProcessor * This,
+            UINT NumInputStreamDescs,
+            _Out_writes_(NumInputStreamDescs)  D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessor, GetOutputStreamDesc)
+#if !defined(_WIN32)
+        D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC ( STDMETHODCALLTYPE *GetOutputStreamDesc )( 
+            ID3D12VideoProcessor * This);
+        
+#else
+        D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *( STDMETHODCALLTYPE *GetOutputStreamDesc )( 
+            ID3D12VideoProcessor * This,
+            D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC * RetVal);
+        
+#endif
+        
+        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) ) 
+#if !defined(_WIN32)
+
+#define ID3D12VideoProcessor_GetOutputStreamDesc(This)	\
+    ( (This)->lpVtbl -> GetOutputStreamDesc(This) ) 
+#else
+#define ID3D12VideoProcessor_GetOutputStreamDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetOutputStreamDesc(This,RetVal) ) 
+#endif
+
+#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
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecodeCommandList * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecodeCommandList * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoDecodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoDecodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoDecodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ResolveQueryData)
+        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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoDecodeCommandList * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoDecodeCommandList * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoDecodeCommandList * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoDecodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, DecodeFrame)
+        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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, WriteBufferImmediate)
+        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
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoProcessCommandList * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoProcessCommandList * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoProcessCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoProcessCommandList * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoProcessCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoProcessCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoProcessCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ResolveQueryData)
+        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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoProcessCommandList * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoProcessCommandList * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoProcessCommandList * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoProcessCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ProcessFrames)
+        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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, WriteBufferImmediate)
+        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
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoDecodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoDecodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoDecodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ResolveQueryData)
+        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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoDecodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, DecodeFrame)
+        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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoDecodeCommandList1 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList1, DecodeFrame1)
+        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
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoProcessCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoProcessCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoProcessCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoProcessCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoProcessCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoProcessCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoProcessCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ResolveQueryData)
+        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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoProcessCommandList1 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoProcessCommandList1 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoProcessCommandList1 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoProcessCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ProcessFrames)
+        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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoProcessCommandList1 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList1, ProcessFrames1)
+        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] */ 
+
+typedef 
+enum D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE
+    {
+        D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_8X8	= 0,
+        D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_16X16	= 1
+    } 	D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE;
+
+typedef 
+enum D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS
+    {
+        D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAG_NONE	= 0,
+        D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAG_8X8	= ( 1 << D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_8X8 ) ,
+        D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAG_16X16	= ( 1 << D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_16X16 ) 
+    } 	D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS );
+typedef 
+enum D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION
+    {
+        D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_QUARTER_PEL	= 0
+    } 	D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION;
+
+typedef 
+enum D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS
+    {
+        D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAG_NONE	= 0,
+        D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAG_QUARTER_PEL	= ( 1 << D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_QUARTER_PEL ) 
+    } 	D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS );
+typedef struct D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT
+    {
+    UINT NodeIndex;
+    BOOL VideoDecodeSupport;
+    BOOL VideoProcessSupport;
+    BOOL VideoEncodeSupport;
+    } 	D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR
+    {
+    UINT NodeIndex;
+    DXGI_FORMAT InputFormat;
+    D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS BlockSizeFlags;
+    D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS PrecisionFlags;
+    D3D12_VIDEO_SIZE_RANGE SizeRange;
+    } 	D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_SIZE
+    {
+    UINT NodeIndex;
+    DXGI_FORMAT InputFormat;
+    D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE BlockSize;
+    D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION Precision;
+    D3D12_VIDEO_SIZE_RANGE SizeRange;
+    BOOL Protected;
+    UINT64 MotionVectorHeapMemoryPoolL0Size;
+    UINT64 MotionVectorHeapMemoryPoolL1Size;
+    UINT64 MotionEstimatorMemoryPoolL0Size;
+    UINT64 MotionEstimatorMemoryPoolL1Size;
+    } 	D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_SIZE;
+
+typedef struct D3D12_VIDEO_MOTION_ESTIMATOR_DESC
+    {
+    UINT NodeMask;
+    DXGI_FORMAT InputFormat;
+    D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE BlockSize;
+    D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION Precision;
+    D3D12_VIDEO_SIZE_RANGE SizeRange;
+    } 	D3D12_VIDEO_MOTION_ESTIMATOR_DESC;
+
+
+
+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;
+
+#ifndef __ID3D12VideoMotionEstimator_INTERFACE_DEFINED__
+#define __ID3D12VideoMotionEstimator_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoMotionEstimator */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoMotionEstimator;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("33FDAE0E-098B-428F-87BB-34B695DE08F8")
+    ID3D12VideoMotionEstimator : public ID3D12Pageable
+    {
+    public:
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_VIDEO_MOTION_ESTIMATOR_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+#else
+        virtual D3D12_VIDEO_MOTION_ESTIMATOR_DESC *STDMETHODCALLTYPE GetDesc( 
+            D3D12_VIDEO_MOTION_ESTIMATOR_DESC * RetVal) = 0;
+#endif
+        
+        virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( 
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoMotionEstimatorVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoMotionEstimator * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoMotionEstimator * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoMotionEstimator * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoMotionEstimator * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoMotionEstimator * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoMotionEstimator * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoMotionEstimator * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoMotionEstimator * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoMotionEstimator, GetDesc)
+#if !defined(_WIN32)
+        D3D12_VIDEO_MOTION_ESTIMATOR_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoMotionEstimator * This);
+        
+#else
+        D3D12_VIDEO_MOTION_ESTIMATOR_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoMotionEstimator * This,
+            D3D12_VIDEO_MOTION_ESTIMATOR_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoMotionEstimator, GetProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( 
+            ID3D12VideoMotionEstimator * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession);
+        
+        END_INTERFACE
+    } ID3D12VideoMotionEstimatorVtbl;
+
+    interface ID3D12VideoMotionEstimator
+    {
+        CONST_VTBL struct ID3D12VideoMotionEstimatorVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoMotionEstimator_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoMotionEstimator_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoMotionEstimator_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoMotionEstimator_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoMotionEstimator_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoMotionEstimator_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoMotionEstimator_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoMotionEstimator_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#if !defined(_WIN32)
+
+#define ID3D12VideoMotionEstimator_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12VideoMotionEstimator_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#define ID3D12VideoMotionEstimator_GetProtectedResourceSession(This,riid,ppProtectedSession)	\
+    ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoMotionEstimator_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0009 */
+/* [local] */ 
+
+typedef struct D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC
+    {
+    UINT NodeMask;
+    DXGI_FORMAT InputFormat;
+    D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE BlockSize;
+    D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION Precision;
+    D3D12_VIDEO_SIZE_RANGE SizeRange;
+    } 	D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0009_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0009_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoMotionVectorHeap_INTERFACE_DEFINED__
+#define __ID3D12VideoMotionVectorHeap_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoMotionVectorHeap */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoMotionVectorHeap;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("5BE17987-743A-4061-834B-23D22DAEA505")
+    ID3D12VideoMotionVectorHeap : public ID3D12Pageable
+    {
+    public:
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+#else
+        virtual D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC *STDMETHODCALLTYPE GetDesc( 
+            D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC * RetVal) = 0;
+#endif
+        
+        virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( 
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoMotionVectorHeapVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoMotionVectorHeap * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoMotionVectorHeap * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoMotionVectorHeap * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoMotionVectorHeap * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoMotionVectorHeap * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoMotionVectorHeap * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoMotionVectorHeap * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoMotionVectorHeap * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoMotionVectorHeap, GetDesc)
+#if !defined(_WIN32)
+        D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoMotionVectorHeap * This);
+        
+#else
+        D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoMotionVectorHeap * This,
+            D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoMotionVectorHeap, GetProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( 
+            ID3D12VideoMotionVectorHeap * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession);
+        
+        END_INTERFACE
+    } ID3D12VideoMotionVectorHeapVtbl;
+
+    interface ID3D12VideoMotionVectorHeap
+    {
+        CONST_VTBL struct ID3D12VideoMotionVectorHeapVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoMotionVectorHeap_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoMotionVectorHeap_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoMotionVectorHeap_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoMotionVectorHeap_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoMotionVectorHeap_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoMotionVectorHeap_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoMotionVectorHeap_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoMotionVectorHeap_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#if !defined(_WIN32)
+
+#define ID3D12VideoMotionVectorHeap_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12VideoMotionVectorHeap_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#define ID3D12VideoMotionVectorHeap_GetProtectedResourceSession(This,riid,ppProtectedSession)	\
+    ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoMotionVectorHeap_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDevice1_INTERFACE_DEFINED__
+#define __ID3D12VideoDevice1_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDevice1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDevice1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("981611AD-A144-4C83-9890-F30E26D658AB")
+    ID3D12VideoDevice1 : public ID3D12VideoDevice
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoMotionEstimator( 
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoMotionEstimator) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoMotionVectorHeap( 
+            _In_  const D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoMotionVectorHeap) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDevice1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDevice1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDevice1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDevice1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12VideoDevice1 * This,
+            D3D12_FEATURE_VIDEO FeatureVideo,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoDecoder)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoder )( 
+            ID3D12VideoDevice1 * This,
+            _In_  const D3D12_VIDEO_DECODER_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoder);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoDecoderHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoderHeap )( 
+            ID3D12VideoDevice1 * This,
+            _In_  const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoderHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoProcessor)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoProcessor )( 
+            ID3D12VideoDevice1 * 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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice1, CreateVideoMotionEstimator)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoMotionEstimator )( 
+            ID3D12VideoDevice1 * This,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoMotionEstimator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice1, CreateVideoMotionVectorHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoMotionVectorHeap )( 
+            ID3D12VideoDevice1 * This,
+            _In_  const D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoMotionVectorHeap);
+        
+        END_INTERFACE
+    } ID3D12VideoDevice1Vtbl;
+
+    interface ID3D12VideoDevice1
+    {
+        CONST_VTBL struct ID3D12VideoDevice1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDevice1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDevice1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDevice1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDevice1_CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12VideoDevice1_CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder)	\
+    ( (This)->lpVtbl -> CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder) ) 
+
+#define ID3D12VideoDevice1_CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap)	\
+    ( (This)->lpVtbl -> CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap) ) 
+
+#define ID3D12VideoDevice1_CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor)	\
+    ( (This)->lpVtbl -> CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor) ) 
+
+
+#define ID3D12VideoDevice1_CreateVideoMotionEstimator(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionEstimator)	\
+    ( (This)->lpVtbl -> CreateVideoMotionEstimator(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionEstimator) ) 
+
+#define ID3D12VideoDevice1_CreateVideoMotionVectorHeap(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionVectorHeap)	\
+    ( (This)->lpVtbl -> CreateVideoMotionVectorHeap(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionVectorHeap) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDevice1_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0011 */
+/* [local] */ 
+
+typedef struct D3D12_RESOURCE_COORDINATE
+    {
+    UINT64 X;
+    UINT Y;
+    UINT Z;
+    UINT SubresourceIndex;
+    } 	D3D12_RESOURCE_COORDINATE;
+
+typedef struct D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT
+    {
+    ID3D12VideoMotionVectorHeap *pMotionVectorHeap;
+    } 	D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT;
+
+typedef struct D3D12_VIDEO_MOTION_ESTIMATOR_INPUT
+    {
+    ID3D12Resource *pInputTexture2D;
+    UINT InputSubresourceIndex;
+    ID3D12Resource *pReferenceTexture2D;
+    UINT ReferenceSubresourceIndex;
+    ID3D12VideoMotionVectorHeap *pHintMotionVectorHeap;
+    } 	D3D12_VIDEO_MOTION_ESTIMATOR_INPUT;
+
+typedef struct D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT
+    {
+    ID3D12Resource *pMotionVectorTexture2D;
+    D3D12_RESOURCE_COORDINATE MotionVectorCoordinate;
+    } 	D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT;
+
+typedef struct D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT
+    {
+    ID3D12VideoMotionVectorHeap *pMotionVectorHeap;
+    UINT PixelWidth;
+    UINT PixelHeight;
+    } 	D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0011_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0011_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoEncodeCommandList_INTERFACE_DEFINED__
+#define __ID3D12VideoEncodeCommandList_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoEncodeCommandList */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoEncodeCommandList;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("8455293A-0CBD-4831-9B39-FBDBAB724723")
+    ID3D12VideoEncodeCommandList : 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 EstimateMotion( 
+            _In_  ID3D12VideoMotionEstimator *pMotionEstimator,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT *pOutputArguments,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_INPUT *pInputArguments) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResolveMotionVectorHeap( 
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT *pOutputArguments,
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT *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;
+        
+        virtual void STDMETHODCALLTYPE SetProtectedResourceSession( 
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoEncodeCommandListVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoEncodeCommandList * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoEncodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoEncodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoEncodeCommandList * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoEncodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoEncodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoEncodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoEncodeCommandList * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoEncodeCommandList * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoEncodeCommandList * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EstimateMotion)
+        void ( STDMETHODCALLTYPE *EstimateMotion )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_  ID3D12VideoMotionEstimator *pMotionEstimator,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT *pOutputArguments,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_INPUT *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResolveMotionVectorHeap)
+        void ( STDMETHODCALLTYPE *ResolveMotionVectorHeap )( 
+            ID3D12VideoEncodeCommandList * This,
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT *pOutputArguments,
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoEncodeCommandList * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12VideoEncodeCommandList * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        END_INTERFACE
+    } ID3D12VideoEncodeCommandListVtbl;
+
+    interface ID3D12VideoEncodeCommandList
+    {
+        CONST_VTBL struct ID3D12VideoEncodeCommandListVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoEncodeCommandList_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoEncodeCommandList_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoEncodeCommandList_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoEncodeCommandList_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoEncodeCommandList_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoEncodeCommandList_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoEncodeCommandList_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoEncodeCommandList_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoEncodeCommandList_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoEncodeCommandList_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoEncodeCommandList_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoEncodeCommandList_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoEncodeCommandList_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoEncodeCommandList_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoEncodeCommandList_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoEncodeCommandList_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoEncodeCommandList_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoEncodeCommandList_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoEncodeCommandList_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoEncodeCommandList_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoEncodeCommandList_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoEncodeCommandList_EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList_ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+#define ID3D12VideoEncodeCommandList_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoEncodeCommandList_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0012 */
+/* [local] */ 
+
+typedef 
+enum D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS
+    {
+        D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAG_NONE	= 0,
+        D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAG_SUPPORTED	= 0x1
+    } 	D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS );
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODE_PROTECTED_RESOURCES
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_DECODE_CONFIGURATION Configuration;
+    D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS SupportFlags;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODE_PROTECTED_RESOURCES;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_PROCESS_PROTECTED_RESOURCES
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS SupportFlags;
+    } 	D3D12_FEATURE_DATA_VIDEO_PROCESS_PROTECTED_RESOURCES;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_PROTECTED_RESOURCES
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_PROTECTED_RESOURCE_SUPPORT_FLAGS SupportFlags;
+    } 	D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_PROTECTED_RESOURCES;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE1
+    {
+    D3D12_VIDEO_DECODER_HEAP_DESC VideoDecoderHeapDesc;
+    BOOL Protected;
+    UINT64 MemoryPoolL0Size;
+    UINT64 MemoryPoolL1Size;
+    } 	D3D12_FEATURE_DATA_VIDEO_DECODER_HEAP_SIZE1;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE1
+    {
+    UINT NodeMask;
+    const D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *pOutputStreamDesc;
+    UINT NumInputStreamDescs;
+    const D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs;
+    BOOL Protected;
+    UINT64 MemoryPoolL0Size;
+    UINT64 MemoryPoolL1Size;
+    } 	D3D12_FEATURE_DATA_VIDEO_PROCESSOR_SIZE1;
+
+typedef 
+enum D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE
+    {
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_CREATION	= 0,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_INITIALIZATION	= 1,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_EXECUTION	= 2,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_CAPS_INPUT	= 3,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_CAPS_OUTPUT	= 4,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_DEVICE_EXECUTE_INPUT	= 5,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE_DEVICE_EXECUTE_OUTPUT	= 6
+    } 	D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE;
+
+typedef 
+enum D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE
+    {
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_UINT8	= 0,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_UINT16	= 1,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_UINT32	= 2,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_UINT64	= 3,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_SINT8	= 4,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_SINT16	= 5,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_SINT32	= 6,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_SINT64	= 7,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_FLOAT	= 8,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_DOUBLE	= 9,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE_RESOURCE	= 10
+    } 	D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE;
+
+typedef 
+enum D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS
+    {
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAG_NONE	= 0,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAG_READ	= 0x1,
+        D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAG_WRITE	= 0x2
+    } 	D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS );
+typedef struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_COUNT
+    {
+    UINT NodeIndex;
+    UINT CommandCount;
+    } 	D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_COUNT;
+
+typedef struct D3D12_VIDEO_EXTENSION_COMMAND_INFO
+    {
+    GUID CommandId;
+    LPCWSTR Name;
+    D3D12_COMMAND_LIST_SUPPORT_FLAGS CommandListSupportFlags;
+    } 	D3D12_VIDEO_EXTENSION_COMMAND_INFO;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMANDS
+    {
+    UINT NodeIndex;
+    UINT CommandCount;
+    _Field_size_full_(CommandCount)  D3D12_VIDEO_EXTENSION_COMMAND_INFO *pCommandInfos;
+    } 	D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMANDS;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETER_COUNT
+    {
+    GUID CommandId;
+    D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE Stage;
+    UINT ParameterCount;
+    UINT ParameterPacking;
+    } 	D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETER_COUNT;
+
+typedef struct D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_INFO
+    {
+    LPCWSTR Name;
+    D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_TYPE Type;
+    D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_FLAGS Flags;
+    } 	D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_INFO;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETERS
+    {
+    GUID CommandId;
+    D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_STAGE Stage;
+    UINT ParameterCount;
+    _Field_size_full_(ParameterCount)  D3D12_VIDEO_EXTENSION_COMMAND_PARAMETER_INFO *pParameterInfos;
+    } 	D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_PARAMETERS;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SUPPORT
+    {
+    UINT NodeIndex;
+    GUID CommandId;
+    _Field_size_bytes_full_opt_(InputDataSizeInBytes)  const void *pInputData;
+    SIZE_T InputDataSizeInBytes;
+    _Field_size_bytes_full_opt_(OutputDataSizeInBytes)  void *pOutputData;
+    SIZE_T OutputDataSizeInBytes;
+    } 	D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SIZE
+    {
+    UINT NodeIndex;
+    GUID CommandId;
+    _Field_size_bytes_full_(CreationParametersDataSizeInBytes)  const void *pCreationParameters;
+    SIZE_T CreationParametersSizeInBytes;
+    UINT64 MemoryPoolL0Size;
+    UINT64 MemoryPoolL1Size;
+    } 	D3D12_FEATURE_DATA_VIDEO_EXTENSION_COMMAND_SIZE;
+
+typedef struct D3D12_VIDEO_EXTENSION_COMMAND_DESC
+    {
+    UINT NodeMask;
+    GUID CommandId;
+    } 	D3D12_VIDEO_EXTENSION_COMMAND_DESC;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0012_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0012_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoDecoder1_INTERFACE_DEFINED__
+#define __ID3D12VideoDecoder1_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDecoder1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDecoder1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("79A2E5FB-CCD2-469A-9FDE-195D10951F7E")
+    ID3D12VideoDecoder1 : public ID3D12VideoDecoder
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( 
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecoder1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecoder1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecoder1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecoder1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecoder1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecoder1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecoder1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecoder1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecoder1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecoder, GetDesc)
+#if !defined(_WIN32)
+        D3D12_VIDEO_DECODER_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoDecoder1 * This);
+        
+#else
+        D3D12_VIDEO_DECODER_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoDecoder1 * This,
+            D3D12_VIDEO_DECODER_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecoder1, GetProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( 
+            ID3D12VideoDecoder1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession);
+        
+        END_INTERFACE
+    } ID3D12VideoDecoder1Vtbl;
+
+    interface ID3D12VideoDecoder1
+    {
+        CONST_VTBL struct ID3D12VideoDecoder1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDecoder1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDecoder1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDecoder1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDecoder1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoDecoder1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoDecoder1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoDecoder1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoDecoder1_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#if !defined(_WIN32)
+
+#define ID3D12VideoDecoder1_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12VideoDecoder1_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+
+#define ID3D12VideoDecoder1_GetProtectedResourceSession(This,riid,ppProtectedSession)	\
+    ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDecoder1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecoderHeap1_INTERFACE_DEFINED__
+#define __ID3D12VideoDecoderHeap1_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDecoderHeap1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDecoderHeap1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("DA1D98C5-539F-41B2-BF6B-1198A03B6D26")
+    ID3D12VideoDecoderHeap1 : public ID3D12VideoDecoderHeap
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( 
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecoderHeap1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecoderHeap1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecoderHeap1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecoderHeap1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecoderHeap1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecoderHeap1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecoderHeap1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecoderHeap1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecoderHeap1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecoderHeap, GetDesc)
+#if !defined(_WIN32)
+        D3D12_VIDEO_DECODER_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoDecoderHeap1 * This);
+        
+#else
+        D3D12_VIDEO_DECODER_HEAP_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoDecoderHeap1 * This,
+            D3D12_VIDEO_DECODER_HEAP_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecoderHeap1, GetProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( 
+            ID3D12VideoDecoderHeap1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession);
+        
+        END_INTERFACE
+    } ID3D12VideoDecoderHeap1Vtbl;
+
+    interface ID3D12VideoDecoderHeap1
+    {
+        CONST_VTBL struct ID3D12VideoDecoderHeap1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDecoderHeap1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDecoderHeap1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDecoderHeap1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDecoderHeap1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoDecoderHeap1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoDecoderHeap1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoDecoderHeap1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoDecoderHeap1_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#if !defined(_WIN32)
+
+#define ID3D12VideoDecoderHeap1_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12VideoDecoderHeap1_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+
+#define ID3D12VideoDecoderHeap1_GetProtectedResourceSession(This,riid,ppProtectedSession)	\
+    ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDecoderHeap1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessor1_INTERFACE_DEFINED__
+#define __ID3D12VideoProcessor1_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoProcessor1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoProcessor1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("F3CFE615-553F-425C-86D8-EE8C1B1FB01C")
+    ID3D12VideoProcessor1 : public ID3D12VideoProcessor
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( 
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoProcessor1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoProcessor1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoProcessor1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoProcessor1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoProcessor1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoProcessor1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoProcessor1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoProcessor1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoProcessor1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessor, GetNodeMask)
+        UINT ( STDMETHODCALLTYPE *GetNodeMask )( 
+            ID3D12VideoProcessor1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessor, GetNumInputStreamDescs)
+        UINT ( STDMETHODCALLTYPE *GetNumInputStreamDescs )( 
+            ID3D12VideoProcessor1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessor, GetInputStreamDescs)
+        HRESULT ( STDMETHODCALLTYPE *GetInputStreamDescs )( 
+            ID3D12VideoProcessor1 * This,
+            UINT NumInputStreamDescs,
+            _Out_writes_(NumInputStreamDescs)  D3D12_VIDEO_PROCESS_INPUT_STREAM_DESC *pInputStreamDescs);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessor, GetOutputStreamDesc)
+#if !defined(_WIN32)
+        D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC ( STDMETHODCALLTYPE *GetOutputStreamDesc )( 
+            ID3D12VideoProcessor1 * This);
+        
+#else
+        D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC *( STDMETHODCALLTYPE *GetOutputStreamDesc )( 
+            ID3D12VideoProcessor1 * This,
+            D3D12_VIDEO_PROCESS_OUTPUT_STREAM_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessor1, GetProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( 
+            ID3D12VideoProcessor1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession);
+        
+        END_INTERFACE
+    } ID3D12VideoProcessor1Vtbl;
+
+    interface ID3D12VideoProcessor1
+    {
+        CONST_VTBL struct ID3D12VideoProcessor1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoProcessor1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoProcessor1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoProcessor1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoProcessor1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoProcessor1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoProcessor1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoProcessor1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoProcessor1_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12VideoProcessor1_GetNodeMask(This)	\
+    ( (This)->lpVtbl -> GetNodeMask(This) ) 
+
+#define ID3D12VideoProcessor1_GetNumInputStreamDescs(This)	\
+    ( (This)->lpVtbl -> GetNumInputStreamDescs(This) ) 
+
+#define ID3D12VideoProcessor1_GetInputStreamDescs(This,NumInputStreamDescs,pInputStreamDescs)	\
+    ( (This)->lpVtbl -> GetInputStreamDescs(This,NumInputStreamDescs,pInputStreamDescs) ) 
+#if !defined(_WIN32)
+
+#define ID3D12VideoProcessor1_GetOutputStreamDesc(This)	\
+    ( (This)->lpVtbl -> GetOutputStreamDesc(This) ) 
+#else
+#define ID3D12VideoProcessor1_GetOutputStreamDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetOutputStreamDesc(This,RetVal) ) 
+#endif
+
+
+#define ID3D12VideoProcessor1_GetProtectedResourceSession(This,riid,ppProtectedSession)	\
+    ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoProcessor1_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoExtensionCommand_INTERFACE_DEFINED__
+#define __ID3D12VideoExtensionCommand_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoExtensionCommand */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoExtensionCommand;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("554E41E8-AE8E-4A8C-B7D2-5B4F274A30E4")
+    ID3D12VideoExtensionCommand : public ID3D12Pageable
+    {
+    public:
+#if defined(_MSC_VER) || !defined(_WIN32)
+        virtual D3D12_VIDEO_EXTENSION_COMMAND_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
+#else
+        virtual D3D12_VIDEO_EXTENSION_COMMAND_DESC *STDMETHODCALLTYPE GetDesc( 
+            D3D12_VIDEO_EXTENSION_COMMAND_DESC * RetVal) = 0;
+#endif
+        
+        virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( 
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoExtensionCommandVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoExtensionCommand * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoExtensionCommand * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoExtensionCommand * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoExtensionCommand * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoExtensionCommand * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoExtensionCommand * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoExtensionCommand * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoExtensionCommand * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoExtensionCommand, GetDesc)
+#if !defined(_WIN32)
+        D3D12_VIDEO_EXTENSION_COMMAND_DESC ( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoExtensionCommand * This);
+        
+#else
+        D3D12_VIDEO_EXTENSION_COMMAND_DESC *( STDMETHODCALLTYPE *GetDesc )( 
+            ID3D12VideoExtensionCommand * This,
+            D3D12_VIDEO_EXTENSION_COMMAND_DESC * RetVal);
+        
+#endif
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoExtensionCommand, GetProtectedResourceSession)
+        HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( 
+            ID3D12VideoExtensionCommand * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppProtectedSession);
+        
+        END_INTERFACE
+    } ID3D12VideoExtensionCommandVtbl;
+
+    interface ID3D12VideoExtensionCommand
+    {
+        CONST_VTBL struct ID3D12VideoExtensionCommandVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoExtensionCommand_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoExtensionCommand_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoExtensionCommand_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoExtensionCommand_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoExtensionCommand_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoExtensionCommand_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoExtensionCommand_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoExtensionCommand_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#if !defined(_WIN32)
+
+#define ID3D12VideoExtensionCommand_GetDesc(This)	\
+    ( (This)->lpVtbl -> GetDesc(This) ) 
+#else
+#define ID3D12VideoExtensionCommand_GetDesc(This,RetVal)	\
+    ( (This)->lpVtbl -> GetDesc(This,RetVal) ) 
+#endif
+
+#define ID3D12VideoExtensionCommand_GetProtectedResourceSession(This,riid,ppProtectedSession)	\
+    ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoExtensionCommand_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDevice2_INTERFACE_DEFINED__
+#define __ID3D12VideoDevice2_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDevice2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDevice2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("F019AC49-F838-4A95-9B17-579437C8F513")
+    ID3D12VideoDevice2 : public ID3D12VideoDevice1
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoDecoder1( 
+            _In_  const D3D12_VIDEO_DECODER_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoder) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoDecoderHeap1( 
+            _In_  const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoderHeap) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoProcessor1( 
+            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_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoProcessor) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoExtensionCommand( 
+            _In_  const D3D12_VIDEO_EXTENSION_COMMAND_DESC *pDesc,
+            _In_reads_bytes_(CreationParametersDataSizeInBytes)  const void *pCreationParameters,
+            SIZE_T CreationParametersDataSizeInBytes,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoExtensionCommand) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE ExecuteExtensionCommand( 
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes,
+            _Out_writes_bytes_(OutputDataSizeInBytes)  void *pOutputData,
+            SIZE_T OutputDataSizeInBytes) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDevice2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDevice2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDevice2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDevice2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12VideoDevice2 * This,
+            D3D12_FEATURE_VIDEO FeatureVideo,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoDecoder)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoder )( 
+            ID3D12VideoDevice2 * This,
+            _In_  const D3D12_VIDEO_DECODER_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoder);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoDecoderHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoderHeap )( 
+            ID3D12VideoDevice2 * This,
+            _In_  const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoderHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoProcessor)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoProcessor )( 
+            ID3D12VideoDevice2 * 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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice1, CreateVideoMotionEstimator)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoMotionEstimator )( 
+            ID3D12VideoDevice2 * This,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoMotionEstimator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice1, CreateVideoMotionVectorHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoMotionVectorHeap )( 
+            ID3D12VideoDevice2 * This,
+            _In_  const D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoMotionVectorHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoDecoder1)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoder1 )( 
+            ID3D12VideoDevice2 * This,
+            _In_  const D3D12_VIDEO_DECODER_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoder);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoDecoderHeap1)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoderHeap1 )( 
+            ID3D12VideoDevice2 * This,
+            _In_  const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoderHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoProcessor1)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoProcessor1 )( 
+            ID3D12VideoDevice2 * 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_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoProcessor);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoExtensionCommand)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoExtensionCommand )( 
+            ID3D12VideoDevice2 * This,
+            _In_  const D3D12_VIDEO_EXTENSION_COMMAND_DESC *pDesc,
+            _In_reads_bytes_(CreationParametersDataSizeInBytes)  const void *pCreationParameters,
+            SIZE_T CreationParametersDataSizeInBytes,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoExtensionCommand);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, ExecuteExtensionCommand)
+        HRESULT ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( 
+            ID3D12VideoDevice2 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes,
+            _Out_writes_bytes_(OutputDataSizeInBytes)  void *pOutputData,
+            SIZE_T OutputDataSizeInBytes);
+        
+        END_INTERFACE
+    } ID3D12VideoDevice2Vtbl;
+
+    interface ID3D12VideoDevice2
+    {
+        CONST_VTBL struct ID3D12VideoDevice2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDevice2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDevice2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDevice2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDevice2_CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12VideoDevice2_CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder)	\
+    ( (This)->lpVtbl -> CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder) ) 
+
+#define ID3D12VideoDevice2_CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap)	\
+    ( (This)->lpVtbl -> CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap) ) 
+
+#define ID3D12VideoDevice2_CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor)	\
+    ( (This)->lpVtbl -> CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor) ) 
+
+
+#define ID3D12VideoDevice2_CreateVideoMotionEstimator(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionEstimator)	\
+    ( (This)->lpVtbl -> CreateVideoMotionEstimator(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionEstimator) ) 
+
+#define ID3D12VideoDevice2_CreateVideoMotionVectorHeap(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionVectorHeap)	\
+    ( (This)->lpVtbl -> CreateVideoMotionVectorHeap(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionVectorHeap) ) 
+
+
+#define ID3D12VideoDevice2_CreateVideoDecoder1(This,pDesc,pProtectedResourceSession,riid,ppVideoDecoder)	\
+    ( (This)->lpVtbl -> CreateVideoDecoder1(This,pDesc,pProtectedResourceSession,riid,ppVideoDecoder) ) 
+
+#define ID3D12VideoDevice2_CreateVideoDecoderHeap1(This,pVideoDecoderHeapDesc,pProtectedResourceSession,riid,ppVideoDecoderHeap)	\
+    ( (This)->lpVtbl -> CreateVideoDecoderHeap1(This,pVideoDecoderHeapDesc,pProtectedResourceSession,riid,ppVideoDecoderHeap) ) 
+
+#define ID3D12VideoDevice2_CreateVideoProcessor1(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,pProtectedResourceSession,riid,ppVideoProcessor)	\
+    ( (This)->lpVtbl -> CreateVideoProcessor1(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,pProtectedResourceSession,riid,ppVideoProcessor) ) 
+
+#define ID3D12VideoDevice2_CreateVideoExtensionCommand(This,pDesc,pCreationParameters,CreationParametersDataSizeInBytes,pProtectedResourceSession,riid,ppVideoExtensionCommand)	\
+    ( (This)->lpVtbl -> CreateVideoExtensionCommand(This,pDesc,pCreationParameters,CreationParametersDataSizeInBytes,pProtectedResourceSession,riid,ppVideoExtensionCommand) ) 
+
+#define ID3D12VideoDevice2_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes,pOutputData,OutputDataSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes,pOutputData,OutputDataSizeInBytes) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDevice2_INTERFACE_DEFINED__ */
+
+
+#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("6e120880-c114-4153-8036-d247051e1729")
+    ID3D12VideoDecodeCommandList2 : public ID3D12VideoDecodeCommandList1
+    {
+    public:
+        virtual void STDMETHODCALLTYPE SetProtectedResourceSession( 
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession) = 0;
+        
+        virtual void STDMETHODCALLTYPE InitializeExtensionCommand( 
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes) = 0;
+        
+        virtual void STDMETHODCALLTYPE ExecuteExtensionCommand( 
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecodeCommandList2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoDecodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoDecodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoDecodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ResolveQueryData)
+        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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoDecodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, DecodeFrame)
+        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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList1, DecodeFrame1)
+        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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList2, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList2, InitializeExtensionCommand)
+        void ( STDMETHODCALLTYPE *InitializeExtensionCommand )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList2, ExecuteExtensionCommand)
+        void ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( 
+            ID3D12VideoDecodeCommandList2 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes);
+        
+        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_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+#define ID3D12VideoDecodeCommandList2_InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes) ) 
+
+#define ID3D12VideoDecodeCommandList2_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDecodeCommandList2_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDecodeCommandList3_INTERFACE_DEFINED__
+#define __ID3D12VideoDecodeCommandList3_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDecodeCommandList3 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDecodeCommandList3;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("2aee8c37-9562-42da-8abf-61efeb2e4513")
+    ID3D12VideoDecodeCommandList3 : public ID3D12VideoDecodeCommandList2
+    {
+    public:
+        virtual void STDMETHODCALLTYPE Barrier( 
+            UINT32 NumBarrierGroups,
+            _In_reads_(NumBarrierGroups)  const D3D12_BARRIER_GROUP *pBarrierGroups) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDecodeCommandList3Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDecodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDecodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoDecodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoDecodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoDecodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoDecodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, DecodeFrame)
+        void ( STDMETHODCALLTYPE *DecodeFrame )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList1, DecodeFrame1)
+        void ( STDMETHODCALLTYPE *DecodeFrame1 )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  ID3D12VideoDecoder *pDecoder,
+            _In_  const D3D12_VIDEO_DECODE_OUTPUT_STREAM_ARGUMENTS1 *pOutputArguments,
+            _In_  const D3D12_VIDEO_DECODE_INPUT_STREAM_ARGUMENTS *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList2, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList2, InitializeExtensionCommand)
+        void ( STDMETHODCALLTYPE *InitializeExtensionCommand )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList2, ExecuteExtensionCommand)
+        void ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDecodeCommandList3, Barrier)
+        void ( STDMETHODCALLTYPE *Barrier )( 
+            ID3D12VideoDecodeCommandList3 * This,
+            UINT32 NumBarrierGroups,
+            _In_reads_(NumBarrierGroups)  const D3D12_BARRIER_GROUP *pBarrierGroups);
+        
+        END_INTERFACE
+    } ID3D12VideoDecodeCommandList3Vtbl;
+
+    interface ID3D12VideoDecodeCommandList3
+    {
+        CONST_VTBL struct ID3D12VideoDecodeCommandList3Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDecodeCommandList3_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDecodeCommandList3_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDecodeCommandList3_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDecodeCommandList3_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoDecodeCommandList3_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoDecodeCommandList3_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoDecodeCommandList3_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoDecodeCommandList3_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoDecodeCommandList3_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoDecodeCommandList3_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoDecodeCommandList3_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoDecodeCommandList3_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoDecodeCommandList3_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoDecodeCommandList3_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoDecodeCommandList3_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoDecodeCommandList3_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoDecodeCommandList3_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoDecodeCommandList3_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoDecodeCommandList3_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoDecodeCommandList3_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoDecodeCommandList3_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoDecodeCommandList3_DecodeFrame(This,pDecoder,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> DecodeFrame(This,pDecoder,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoDecodeCommandList3_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+
+#define ID3D12VideoDecodeCommandList3_DecodeFrame1(This,pDecoder,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> DecodeFrame1(This,pDecoder,pOutputArguments,pInputArguments) ) 
+
+
+#define ID3D12VideoDecodeCommandList3_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+#define ID3D12VideoDecodeCommandList3_InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes) ) 
+
+#define ID3D12VideoDecodeCommandList3_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes) ) 
+
+
+#define ID3D12VideoDecodeCommandList3_Barrier(This,NumBarrierGroups,pBarrierGroups)	\
+    ( (This)->lpVtbl -> Barrier(This,NumBarrierGroups,pBarrierGroups) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDecodeCommandList3_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("db525ae4-6ad6-473c-baa7-59b2e37082e4")
+    ID3D12VideoProcessCommandList2 : public ID3D12VideoProcessCommandList1
+    {
+    public:
+        virtual void STDMETHODCALLTYPE SetProtectedResourceSession( 
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession) = 0;
+        
+        virtual void STDMETHODCALLTYPE InitializeExtensionCommand( 
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes) = 0;
+        
+        virtual void STDMETHODCALLTYPE ExecuteExtensionCommand( 
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoProcessCommandList2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoProcessCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoProcessCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoProcessCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoProcessCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoProcessCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoProcessCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoProcessCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ResolveQueryData)
+        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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoProcessCommandList2 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoProcessCommandList2 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoProcessCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ProcessFrames)
+        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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoProcessCommandList2 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList1, ProcessFrames1)
+        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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList2, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList2, InitializeExtensionCommand)
+        void ( STDMETHODCALLTYPE *InitializeExtensionCommand )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList2, ExecuteExtensionCommand)
+        void ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( 
+            ID3D12VideoProcessCommandList2 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes);
+        
+        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) ) 
+
+#define ID3D12VideoProcessCommandList2_InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes) ) 
+
+#define ID3D12VideoProcessCommandList2_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoProcessCommandList2_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoProcessCommandList3_INTERFACE_DEFINED__
+#define __ID3D12VideoProcessCommandList3_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoProcessCommandList3 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoProcessCommandList3;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("1a0a4ca4-9f08-40ce-9558-b411fd2666ff")
+    ID3D12VideoProcessCommandList3 : public ID3D12VideoProcessCommandList2
+    {
+    public:
+        virtual void STDMETHODCALLTYPE Barrier( 
+            UINT32 NumBarrierGroups,
+            _In_reads_(NumBarrierGroups)  const D3D12_BARRIER_GROUP *pBarrierGroups) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoProcessCommandList3Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoProcessCommandList3 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoProcessCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoProcessCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoProcessCommandList3 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoProcessCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoProcessCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoProcessCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoProcessCommandList3 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoProcessCommandList3 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoProcessCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, ProcessFrames)
+        void ( STDMETHODCALLTYPE *ProcessFrames )( 
+            ID3D12VideoProcessCommandList3 * 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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoProcessCommandList3 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList1, ProcessFrames1)
+        void ( STDMETHODCALLTYPE *ProcessFrames1 )( 
+            ID3D12VideoProcessCommandList3 * 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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList2, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList2, InitializeExtensionCommand)
+        void ( STDMETHODCALLTYPE *InitializeExtensionCommand )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList2, ExecuteExtensionCommand)
+        void ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( 
+            ID3D12VideoProcessCommandList3 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoProcessCommandList3, Barrier)
+        void ( STDMETHODCALLTYPE *Barrier )( 
+            ID3D12VideoProcessCommandList3 * This,
+            UINT32 NumBarrierGroups,
+            _In_reads_(NumBarrierGroups)  const D3D12_BARRIER_GROUP *pBarrierGroups);
+        
+        END_INTERFACE
+    } ID3D12VideoProcessCommandList3Vtbl;
+
+    interface ID3D12VideoProcessCommandList3
+    {
+        CONST_VTBL struct ID3D12VideoProcessCommandList3Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoProcessCommandList3_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoProcessCommandList3_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoProcessCommandList3_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoProcessCommandList3_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoProcessCommandList3_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoProcessCommandList3_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoProcessCommandList3_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoProcessCommandList3_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoProcessCommandList3_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoProcessCommandList3_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoProcessCommandList3_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoProcessCommandList3_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoProcessCommandList3_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoProcessCommandList3_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoProcessCommandList3_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoProcessCommandList3_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoProcessCommandList3_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoProcessCommandList3_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoProcessCommandList3_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoProcessCommandList3_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoProcessCommandList3_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoProcessCommandList3_ProcessFrames(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments)	\
+    ( (This)->lpVtbl -> ProcessFrames(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments) ) 
+
+#define ID3D12VideoProcessCommandList3_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+
+#define ID3D12VideoProcessCommandList3_ProcessFrames1(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments)	\
+    ( (This)->lpVtbl -> ProcessFrames1(This,pVideoProcessor,pOutputArguments,NumInputStreams,pInputArguments) ) 
+
+
+#define ID3D12VideoProcessCommandList3_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+#define ID3D12VideoProcessCommandList3_InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes) ) 
+
+#define ID3D12VideoProcessCommandList3_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes) ) 
+
+
+#define ID3D12VideoProcessCommandList3_Barrier(This,NumBarrierGroups,pBarrierGroups)	\
+    ( (This)->lpVtbl -> Barrier(This,NumBarrierGroups,pBarrierGroups) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoProcessCommandList3_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoEncodeCommandList1_INTERFACE_DEFINED__
+#define __ID3D12VideoEncodeCommandList1_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoEncodeCommandList1 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoEncodeCommandList1;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("94971eca-2bdb-4769-88cf-3675ea757ebc")
+    ID3D12VideoEncodeCommandList1 : public ID3D12VideoEncodeCommandList
+    {
+    public:
+        virtual void STDMETHODCALLTYPE InitializeExtensionCommand( 
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes) = 0;
+        
+        virtual void STDMETHODCALLTYPE ExecuteExtensionCommand( 
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoEncodeCommandList1Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoEncodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoEncodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoEncodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoEncodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoEncodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoEncodeCommandList1 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EstimateMotion)
+        void ( STDMETHODCALLTYPE *EstimateMotion )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  ID3D12VideoMotionEstimator *pMotionEstimator,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT *pOutputArguments,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_INPUT *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResolveMotionVectorHeap)
+        void ( STDMETHODCALLTYPE *ResolveMotionVectorHeap )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT *pOutputArguments,
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList1, InitializeExtensionCommand)
+        void ( STDMETHODCALLTYPE *InitializeExtensionCommand )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList1, ExecuteExtensionCommand)
+        void ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( 
+            ID3D12VideoEncodeCommandList1 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes);
+        
+        END_INTERFACE
+    } ID3D12VideoEncodeCommandList1Vtbl;
+
+    interface ID3D12VideoEncodeCommandList1
+    {
+        CONST_VTBL struct ID3D12VideoEncodeCommandList1Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoEncodeCommandList1_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoEncodeCommandList1_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoEncodeCommandList1_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoEncodeCommandList1_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoEncodeCommandList1_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoEncodeCommandList1_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoEncodeCommandList1_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoEncodeCommandList1_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoEncodeCommandList1_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoEncodeCommandList1_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoEncodeCommandList1_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoEncodeCommandList1_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoEncodeCommandList1_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoEncodeCommandList1_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoEncodeCommandList1_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoEncodeCommandList1_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoEncodeCommandList1_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoEncodeCommandList1_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoEncodeCommandList1_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoEncodeCommandList1_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoEncodeCommandList1_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoEncodeCommandList1_EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList1_ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList1_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+#define ID3D12VideoEncodeCommandList1_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+
+#define ID3D12VideoEncodeCommandList1_InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes) ) 
+
+#define ID3D12VideoEncodeCommandList1_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoEncodeCommandList1_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0022 */
+/* [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);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_PROFILE0, 0xb8be4ccb, 0xcf53, 0x46ba, 0x8d, 0x59, 0xd6, 0xb8, 0xa6, 0xda, 0x5d, 0x2a);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_PROFILE1, 0x6936ff0f, 0x45b1, 0x4163, 0x9c, 0xc1, 0x64, 0x6e, 0xf6, 0x94, 0x61, 0x08);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_PROFILE2, 0x0c5f2aa1, 0xe541, 0x4089, 0xbb, 0x7b, 0x98, 0x11, 0x0a, 0x19, 0xd7, 0xc8);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_12BIT_PROFILE2, 0x17127009, 0xa00f, 0x4ce1, 0x99, 0x4e, 0xbf, 0x40, 0x81, 0xf6, 0xf3, 0xf0);
+DEFINE_GUID(D3D12_VIDEO_DECODE_PROFILE_AV1_12BIT_PROFILE2_420, 0x2d80bed6, 0x9cac, 0x4835, 0x9e, 0x91, 0x32, 0x7b, 0xbc, 0x4f, 0x9e, 0xe8);
+typedef 
+enum D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE
+    {
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_ABSOLUTE_QP_MAP	= 0,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_CQP	= 1,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_CBR	= 2,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_VBR	= 3,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE_QVBR	= 4
+    } 	D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_DELTA_QP	= 0x1,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_FRAME_ANALYSIS	= 0x2,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_QP_RANGE	= 0x4,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_INITIAL_QP	= 0x8,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_MAX_FRAME_SIZE	= 0x10,
+        D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAG_ENABLE_VBV_SIZES	= 0x20
+    } 	D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP
+    {
+    UINT ConstantQP_FullIntracodedFrame;
+    UINT ConstantQP_InterPredictedFrame_PrevRefOnly;
+    UINT ConstantQP_InterPredictedFrame_BiDirectionalRef;
+    } 	D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP;
+
+typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR
+    {
+    UINT InitialQP;
+    UINT MinQP;
+    UINT MaxQP;
+    UINT64 MaxFrameBitSize;
+    UINT64 TargetBitRate;
+    UINT64 VBVCapacity;
+    UINT64 InitialVBVFullness;
+    } 	D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR;
+
+typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR
+    {
+    UINT InitialQP;
+    UINT MinQP;
+    UINT MaxQP;
+    UINT64 MaxFrameBitSize;
+    UINT64 TargetAvgBitRate;
+    UINT64 PeakBitRate;
+    UINT64 VBVCapacity;
+    UINT64 InitialVBVFullness;
+    } 	D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR;
+
+typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR
+    {
+    UINT InitialQP;
+    UINT MinQP;
+    UINT MaxQP;
+    UINT64 MaxFrameBitSize;
+    UINT64 TargetAvgBitRate;
+    UINT64 PeakBitRate;
+    UINT ConstantQualityTarget;
+    } 	D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR;
+
+typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS
+    {
+    UINT DataSize;
+    union 
+        {
+        const D3D12_VIDEO_ENCODER_RATE_CONTROL_CQP *pConfiguration_CQP;
+        const D3D12_VIDEO_ENCODER_RATE_CONTROL_CBR *pConfiguration_CBR;
+        const D3D12_VIDEO_ENCODER_RATE_CONTROL_VBR *pConfiguration_VBR;
+        const D3D12_VIDEO_ENCODER_RATE_CONTROL_QVBR *pConfiguration_QVBR;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS;
+
+typedef struct D3D12_VIDEO_ENCODER_RATE_CONTROL
+    {
+    D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE Mode;
+    D3D12_VIDEO_ENCODER_RATE_CONTROL_FLAGS Flags;
+    D3D12_VIDEO_ENCODER_RATE_CONTROL_CONFIGURATION_PARAMS ConfigParams;
+    DXGI_RATIONAL TargetFrameRate;
+    } 	D3D12_VIDEO_ENCODER_RATE_CONTROL;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC
+    {
+        D3D12_VIDEO_ENCODER_CODEC_H264	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_HEVC	= 1
+    } 	D3D12_VIDEO_ENCODER_CODEC;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    BOOL IsSupported;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_PROFILE_H264
+    {
+        D3D12_VIDEO_ENCODER_PROFILE_H264_MAIN	= 0,
+        D3D12_VIDEO_ENCODER_PROFILE_H264_HIGH	= 1,
+        D3D12_VIDEO_ENCODER_PROFILE_H264_HIGH_10	= 2
+    } 	D3D12_VIDEO_ENCODER_PROFILE_H264;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_PROFILE_HEVC
+    {
+        D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN	= 0,
+        D3D12_VIDEO_ENCODER_PROFILE_HEVC_MAIN10	= 1
+    } 	D3D12_VIDEO_ENCODER_PROFILE_HEVC;
+
+typedef struct D3D12_VIDEO_ENCODER_PROFILE_DESC
+    {
+    UINT DataSize;
+    union 
+        {
+        D3D12_VIDEO_ENCODER_PROFILE_H264 *pH264Profile;
+        D3D12_VIDEO_ENCODER_PROFILE_HEVC *pHEVCProfile;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_PROFILE_DESC;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_LEVELS_H264
+    {
+        D3D12_VIDEO_ENCODER_LEVELS_H264_1	= 0,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_1b	= 1,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_11	= 2,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_12	= 3,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_13	= 4,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_2	= 5,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_21	= 6,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_22	= 7,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_3	= 8,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_31	= 9,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_32	= 10,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_4	= 11,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_41	= 12,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_42	= 13,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_5	= 14,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_51	= 15,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_52	= 16,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_6	= 17,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_61	= 18,
+        D3D12_VIDEO_ENCODER_LEVELS_H264_62	= 19
+    } 	D3D12_VIDEO_ENCODER_LEVELS_H264;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_TIER_HEVC
+    {
+        D3D12_VIDEO_ENCODER_TIER_HEVC_MAIN	= 0,
+        D3D12_VIDEO_ENCODER_TIER_HEVC_HIGH	= 1
+    } 	D3D12_VIDEO_ENCODER_TIER_HEVC;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_LEVELS_HEVC
+    {
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_1	= 0,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_2	= 1,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_21	= 2,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_3	= 3,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_31	= 4,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_4	= 5,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_41	= 6,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_5	= 7,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_51	= 8,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_52	= 9,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_6	= 10,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_61	= 11,
+        D3D12_VIDEO_ENCODER_LEVELS_HEVC_62	= 12
+    } 	D3D12_VIDEO_ENCODER_LEVELS_HEVC;
+
+typedef struct D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC
+    {
+    D3D12_VIDEO_ENCODER_LEVELS_HEVC Level;
+    D3D12_VIDEO_ENCODER_TIER_HEVC Tier;
+    } 	D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC;
+
+typedef struct D3D12_VIDEO_ENCODER_LEVEL_SETTING
+    {
+    UINT DataSize;
+    union 
+        {
+        D3D12_VIDEO_ENCODER_LEVELS_H264 *pH264LevelSetting;
+        D3D12_VIDEO_ENCODER_LEVEL_TIER_CONSTRAINTS_HEVC *pHEVCLevelSetting;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_LEVEL_SETTING;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_PROFILE_LEVEL
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC Profile;
+    BOOL IsSupported;
+    D3D12_VIDEO_ENCODER_LEVEL_SETTING MinSupportedLevel;
+    D3D12_VIDEO_ENCODER_LEVEL_SETTING MaxSupportedLevel;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_PROFILE_LEVEL;
+
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC
+    {
+    UINT Width;
+    UINT Height;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC;
+
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_RATIO_DESC
+    {
+    UINT WidthRatio;
+    UINT HeightRatio;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_RATIO_DESC;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION_RATIOS_COUNT
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    UINT ResolutionRatiosCount;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION_RATIOS_COUNT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    UINT ResolutionRatiosCount;
+    BOOL IsSupported;
+    D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC MinResolutionSupported;
+    D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC MaxResolutionSupported;
+    UINT ResolutionWidthMultipleRequirement;
+    UINT ResolutionHeightMultipleRequirement;
+    _Field_size_full_(ResolutionRatiosCount)  D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_RATIO_DESC *pResolutionRatios;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_OUTPUT_RESOLUTION;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_INPUT_FORMAT
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC Profile;
+    DXGI_FORMAT Format;
+    BOOL IsSupported;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_INPUT_FORMAT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RATE_CONTROL_MODE
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    D3D12_VIDEO_ENCODER_RATE_CONTROL_MODE RateControlMode;
+    BOOL IsSupported;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_RATE_CONTROL_MODE;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE
+    {
+        D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE_NONE	= 0,
+        D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE_ROW_BASED	= 1
+    } 	D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_INTRA_REFRESH_MODE
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC Profile;
+    D3D12_VIDEO_ENCODER_LEVEL_SETTING Level;
+    D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE IntraRefreshMode;
+    BOOL IsSupported;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_INTRA_REFRESH_MODE;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE
+    {
+        D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_FULL_FRAME	= 0,
+        D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_BYTES_PER_SUBREGION	= 1,
+        D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_SQUARE_UNITS_PER_SUBREGION_ROW_UNALIGNED	= 2,
+        D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_UNIFORM_PARTITIONING_ROWS_PER_SUBREGION	= 3,
+        D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE_UNIFORM_PARTITIONING_SUBREGIONS_PER_FRAME	= 4
+    } 	D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC Profile;
+    D3D12_VIDEO_ENCODER_LEVEL_SETTING Level;
+    D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE SubregionMode;
+    BOOL IsSupported;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_HEAP_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_HEAP_FLAG_NONE	= 0
+    } 	D3D12_VIDEO_ENCODER_HEAP_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_HEAP_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_HEAP_DESC
+    {
+    UINT NodeMask;
+    D3D12_VIDEO_ENCODER_HEAP_FLAGS Flags;
+    D3D12_VIDEO_ENCODER_CODEC EncodeCodec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC EncodeProfile;
+    D3D12_VIDEO_ENCODER_LEVEL_SETTING EncodeLevel;
+    UINT ResolutionsListCount;
+    _Field_size_full_(ResolutionsListCount)  const D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC *pResolutionList;
+    } 	D3D12_VIDEO_ENCODER_HEAP_DESC;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_HEAP_SIZE
+    {
+    D3D12_VIDEO_ENCODER_HEAP_DESC HeapDesc;
+    BOOL IsSupported;
+    UINT64 MemoryPoolL0Size;
+    UINT64 MemoryPoolL1Size;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_HEAP_SIZE;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_CABAC_ENCODING_SUPPORT	= 0x1,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_INTRA_SLICE_CONSTRAINED_ENCODING_SUPPORT	= 0x2,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_BFRAME_LTR_COMBINED_SUPPORT	= 0x4,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_ADAPTIVE_8x8_TRANSFORM_ENCODING_SUPPORT	= 0x8,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_DIRECT_SPATIAL_ENCODING_SUPPORT	= 0x10,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_DIRECT_TEMPORAL_ENCODING_SUPPORT	= 0x20,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAG_CONSTRAINED_INTRAPREDICTION_SUPPORT	= 0x40
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS);
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES
+    {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_0_ALL_LUMA_CHROMA_SLICE_BLOCK_EDGES_ALWAYS_FILTERED	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_1_DISABLE_ALL_SLICE_BLOCK_EDGES	= 1,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_2_DISABLE_SLICE_BOUNDARIES_BLOCKS	= 2,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_3_USE_TWO_STAGE_DEBLOCKING	= 3,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_4_DISABLE_CHROMA_BLOCK_EDGES	= 4,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_5_DISABLE_CHROMA_BLOCK_EDGES_AND_LUMA_BOUNDARIES	= 5,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_6_DISABLE_CHROMA_BLOCK_EDGES_AND_USE_LUMA_TWO_STAGE_DEBLOCKING	= 6
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_0_ALL_LUMA_CHROMA_SLICE_BLOCK_EDGES_ALWAYS_FILTERED	= ( 1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_0_ALL_LUMA_CHROMA_SLICE_BLOCK_EDGES_ALWAYS_FILTERED ) ,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_1_DISABLE_ALL_SLICE_BLOCK_EDGES	= ( 1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_1_DISABLE_ALL_SLICE_BLOCK_EDGES ) ,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_2_DISABLE_SLICE_BOUNDARIES_BLOCKS	= ( 1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_2_DISABLE_SLICE_BOUNDARIES_BLOCKS ) ,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_3_USE_TWO_STAGE_DEBLOCKING	= ( 1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_3_USE_TWO_STAGE_DEBLOCKING ) ,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_4_DISABLE_CHROMA_BLOCK_EDGES	= ( 1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_4_DISABLE_CHROMA_BLOCK_EDGES ) ,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_5_DISABLE_CHROMA_BLOCK_EDGES_AND_LUMA_BOUNDARIES	= ( 1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_5_DISABLE_CHROMA_BLOCK_EDGES_AND_LUMA_BOUNDARIES ) ,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAG_6_DISABLE_CHROMA_BLOCK_EDGES_AND_USE_LUMA_TWO_STAGE_DEBLOCKING	= ( 1 << D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_6_DISABLE_CHROMA_BLOCK_EDGES_AND_USE_LUMA_TWO_STAGE_DEBLOCKING ) 
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264
+    {
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264_FLAGS SupportFlags;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODE_FLAGS DisableDeblockingFilterSupportedModes;
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_BFRAME_LTR_COMBINED_SUPPORT	= 0x1,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_INTRA_SLICE_CONSTRAINED_ENCODING_SUPPORT	= 0x2,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_CONSTRAINED_INTRAPREDICTION_SUPPORT	= 0x4,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_SAO_FILTER_SUPPORT	= 0x8,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_ASYMETRIC_MOTION_PARTITION_SUPPORT	= 0x10,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_ASYMETRIC_MOTION_PARTITION_REQUIRED	= 0x20,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_TRANSFORM_SKIP_SUPPORT	= 0x40,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_DISABLING_LOOP_FILTER_ACROSS_SLICES_SUPPORT	= 0x80,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAG_P_FRAMES_IMPLEMENTED_AS_LOW_DELAY_B_FRAMES	= 0x100
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS);
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE
+    {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_8x8	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_16x16	= 1,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_32x32	= 2,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE_64x64	= 3
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE
+    {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_4x4	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_8x8	= 1,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_16x16	= 2,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE_32x32	= 3
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE;
+
+typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC
+    {
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC_FLAGS SupportFlags;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE MinLumaCodingUnitSize;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE MaxLumaCodingUnitSize;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE MinLumaTransformUnitSize;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE MaxLumaTransformUnitSize;
+    UCHAR max_transform_hierarchy_depth_inter;
+    UCHAR max_transform_hierarchy_depth_intra;
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC;
+
+typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT
+    {
+    UINT DataSize;
+    union 
+        {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_H264 *pH264Support;
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT_HEVC *pHEVCSupport;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC Profile;
+    BOOL IsSupported;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT CodecSupportLimits;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_CONFIGURATION_SUPPORT;
+
+typedef struct D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264
+    {
+    UINT MaxL0ReferencesForP;
+    UINT MaxL0ReferencesForB;
+    UINT MaxL1ReferencesForB;
+    UINT MaxLongTermReferences;
+    UINT MaxDPBCapacity;
+    } 	D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264;
+
+typedef struct D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC
+    {
+    UINT MaxL0ReferencesForP;
+    UINT MaxL0ReferencesForB;
+    UINT MaxL1ReferencesForB;
+    UINT MaxLongTermReferences;
+    UINT MaxDPBCapacity;
+    } 	D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC;
+
+typedef struct D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT
+    {
+    UINT DataSize;
+    union 
+        {
+        D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_H264 *pH264Support;
+        D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT_HEVC *pHEVCSupport;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC Profile;
+    BOOL IsSupported;
+    D3D12_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT PictureSupport;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_CODEC_PICTURE_CONTROL_SUPPORT;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_SUPPORT_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_GENERAL_SUPPORT_OK	= 0x1,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_RECONFIGURATION_AVAILABLE	= 0x2,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RESOLUTION_RECONFIGURATION_AVAILABLE	= 0x4,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_VBV_SIZE_CONFIG_AVAILABLE	= 0x8,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_FRAME_ANALYSIS_AVAILABLE	= 0x10,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RECONSTRUCTED_FRAMES_REQUIRE_TEXTURE_ARRAYS	= 0x20,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_DELTA_QP_AVAILABLE	= 0x40,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_SUBREGION_LAYOUT_RECONFIGURATION_AVAILABLE	= 0x80,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_ADJUSTABLE_QP_RANGE_AVAILABLE	= 0x100,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_INITIAL_QP_AVAILABLE	= 0x200,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_RATE_CONTROL_MAX_FRAME_SIZE_AVAILABLE	= 0x400,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_SEQUENCE_GOP_RECONFIGURATION_AVAILABLE	= 0x800,
+        D3D12_VIDEO_ENCODER_SUPPORT_FLAG_MOTION_ESTIMATION_PRECISION_MODE_LIMIT_AVAILABLE	= 0x1000
+    } 	D3D12_VIDEO_ENCODER_SUPPORT_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_SUPPORT_FLAGS);
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_USE_CONSTRAINED_INTRAPREDICTION	= 0x1,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_USE_ADAPTIVE_8x8_TRANSFORM	= 0x2,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_ENABLE_CABAC_ENCODING	= 0x4,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAG_ALLOW_REQUEST_INTRA_CONSTRAINED_SLICES	= 0x8
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS);
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES
+    {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES_DISABLED	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES_TEMPORAL	= 1,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES_SPATIAL	= 2
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES;
+
+typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264
+    {
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_FLAGS ConfigurationFlags;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_DIRECT_MODES DirectModeConfig;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264_SLICES_DEBLOCKING_MODES DisableDeblockingFilterConfig;
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_DISABLE_LOOP_FILTER_ACROSS_SLICES	= 0x1,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ALLOW_REQUEST_INTRA_CONSTRAINED_SLICES	= 0x2,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ENABLE_SAO_FILTER	= 0x4,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ENABLE_LONG_TERM_REFERENCES	= 0x8,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_USE_ASYMETRIC_MOTION_PARTITION	= 0x10,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_ENABLE_TRANSFORM_SKIPPING	= 0x20,
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAG_USE_CONSTRAINED_INTRAPREDICTION	= 0x40
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC
+    {
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_FLAGS ConfigurationFlags;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE MinLumaCodingUnitSize;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_CUSIZE MaxLumaCodingUnitSize;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE MinLumaTransformUnitSize;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC_TUSIZE MaxLumaTransformUnitSize;
+    UCHAR max_transform_hierarchy_depth_inter;
+    UCHAR max_transform_hierarchy_depth_intra;
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC;
+
+typedef struct D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION
+    {
+    UINT DataSize;
+    union 
+        {
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_H264 *pH264Config;
+        D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION_HEVC *pHEVCConfig;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION;
+
+typedef struct D3D12_VIDEO_ENCODER_INTRA_REFRESH
+    {
+    D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE Mode;
+    UINT IntraRefreshDuration;
+    } 	D3D12_VIDEO_ENCODER_INTRA_REFRESH;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE
+    {
+        D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_MAXIMUM	= 0,
+        D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_FULL_PIXEL	= 1,
+        D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_HALF_PIXEL	= 2,
+        D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE_QUARTER_PIXEL	= 3
+    } 	D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS
+    {
+    UINT MaxSubregionsNumber;
+    UINT MaxIntraRefreshFrameDuration;
+    UINT SubregionBlockPixelsSize;
+    UINT QPMapRegionPixelsSize;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_VALIDATION_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_CODEC_NOT_SUPPORTED	= 0x1,
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_INPUT_FORMAT_NOT_SUPPORTED	= 0x8,
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_CODEC_CONFIGURATION_NOT_SUPPORTED	= 0x10,
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_RATE_CONTROL_MODE_NOT_SUPPORTED	= 0x20,
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_RATE_CONTROL_CONFIGURATION_NOT_SUPPORTED	= 0x40,
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_INTRA_REFRESH_MODE_NOT_SUPPORTED	= 0x80,
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_SUBREGION_LAYOUT_MODE_NOT_SUPPORTED	= 0x100,
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_RESOLUTION_NOT_SUPPORTED_IN_LIST	= 0x200,
+        D3D12_VIDEO_ENCODER_VALIDATION_FLAG_GOP_STRUCTURE_NOT_SUPPORTED	= 0x800
+    } 	D3D12_VIDEO_ENCODER_VALIDATION_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_VALIDATION_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264
+    {
+    UINT GOPLength;
+    UINT PPicturePeriod;
+    UCHAR pic_order_cnt_type;
+    UCHAR log2_max_frame_num_minus4;
+    UCHAR log2_max_pic_order_cnt_lsb_minus4;
+    } 	D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264;
+
+typedef struct D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC
+    {
+    UINT GOPLength;
+    UINT PPicturePeriod;
+    UCHAR log2_max_pic_order_cnt_lsb_minus4;
+    } 	D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC;
+
+typedef struct D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE
+    {
+    UINT DataSize;
+    union 
+        {
+        D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_H264 *pH264GroupOfPictures;
+        D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE_HEVC *pHEVCGroupOfPictures;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    DXGI_FORMAT InputFormat;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION CodecConfiguration;
+    D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE CodecGopSequence;
+    D3D12_VIDEO_ENCODER_RATE_CONTROL RateControl;
+    D3D12_VIDEO_ENCODER_INTRA_REFRESH_MODE IntraRefresh;
+    D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE SubregionFrameEncoding;
+    UINT ResolutionsListCount;
+    const D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC *pResolutionList;
+    UINT MaxReferenceFramesInDPB;
+    D3D12_VIDEO_ENCODER_VALIDATION_FLAGS ValidationFlags;
+    D3D12_VIDEO_ENCODER_SUPPORT_FLAGS SupportFlags;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC SuggestedProfile;
+    D3D12_VIDEO_ENCODER_LEVEL_SETTING SuggestedLevel;
+    _Field_size_full_(ResolutionsListCount)  D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOLUTION_SUPPORT_LIMITS *pResolutionDependentSupport;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_SUPPORT;
+
+typedef struct D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOURCE_REQUIREMENTS
+    {
+    UINT NodeIndex;
+    D3D12_VIDEO_ENCODER_CODEC Codec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC Profile;
+    DXGI_FORMAT InputFormat;
+    D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC PictureTargetResolution;
+    BOOL IsSupported;
+    UINT CompressedBitstreamBufferAccessAlignment;
+    UINT EncoderMetadataBufferAccessAlignment;
+    UINT MaxEncoderOutputMetadataBufferSize;
+    } 	D3D12_FEATURE_DATA_VIDEO_ENCODER_RESOURCE_REQUIREMENTS;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_FLAG_NONE	= 0
+    } 	D3D12_VIDEO_ENCODER_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_DESC
+    {
+    UINT NodeMask;
+    D3D12_VIDEO_ENCODER_FLAGS Flags;
+    D3D12_VIDEO_ENCODER_CODEC EncodeCodec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC EncodeProfile;
+    DXGI_FORMAT InputFormat;
+    D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION CodecConfiguration;
+    D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE MaxMotionEstimationPrecision;
+    } 	D3D12_VIDEO_ENCODER_DESC;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0022_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0022_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoEncoder_INTERFACE_DEFINED__
+#define __ID3D12VideoEncoder_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoEncoder */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoEncoder;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("2E0D212D-8DF9-44A6-A770-BB289B182737")
+    ID3D12VideoEncoder : public ID3D12Pageable
+    {
+    public:
+        virtual UINT STDMETHODCALLTYPE GetNodeMask( void) = 0;
+        
+        virtual D3D12_VIDEO_ENCODER_FLAGS STDMETHODCALLTYPE GetEncoderFlags( void) = 0;
+        
+        virtual D3D12_VIDEO_ENCODER_CODEC STDMETHODCALLTYPE GetCodec( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetCodecProfile( 
+            _Inout_  D3D12_VIDEO_ENCODER_PROFILE_DESC dstProfile) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetCodecConfiguration( 
+            _Inout_  D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION dstCodecConfig) = 0;
+        
+        virtual DXGI_FORMAT STDMETHODCALLTYPE GetInputFormat( void) = 0;
+        
+        virtual D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE STDMETHODCALLTYPE GetMaxMotionEstimationPrecision( void) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoEncoderVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoEncoder * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoEncoder * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoEncoder * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoEncoder * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoEncoder * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoEncoder * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoEncoder * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoEncoder * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoder, GetNodeMask)
+        UINT ( STDMETHODCALLTYPE *GetNodeMask )( 
+            ID3D12VideoEncoder * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoder, GetEncoderFlags)
+        D3D12_VIDEO_ENCODER_FLAGS ( STDMETHODCALLTYPE *GetEncoderFlags )( 
+            ID3D12VideoEncoder * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoder, GetCodec)
+        D3D12_VIDEO_ENCODER_CODEC ( STDMETHODCALLTYPE *GetCodec )( 
+            ID3D12VideoEncoder * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoder, GetCodecProfile)
+        HRESULT ( STDMETHODCALLTYPE *GetCodecProfile )( 
+            ID3D12VideoEncoder * This,
+            _Inout_  D3D12_VIDEO_ENCODER_PROFILE_DESC dstProfile);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoder, GetCodecConfiguration)
+        HRESULT ( STDMETHODCALLTYPE *GetCodecConfiguration )( 
+            ID3D12VideoEncoder * This,
+            _Inout_  D3D12_VIDEO_ENCODER_CODEC_CONFIGURATION dstCodecConfig);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoder, GetInputFormat)
+        DXGI_FORMAT ( STDMETHODCALLTYPE *GetInputFormat )( 
+            ID3D12VideoEncoder * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoder, GetMaxMotionEstimationPrecision)
+        D3D12_VIDEO_ENCODER_MOTION_ESTIMATION_PRECISION_MODE ( STDMETHODCALLTYPE *GetMaxMotionEstimationPrecision )( 
+            ID3D12VideoEncoder * This);
+        
+        END_INTERFACE
+    } ID3D12VideoEncoderVtbl;
+
+    interface ID3D12VideoEncoder
+    {
+        CONST_VTBL struct ID3D12VideoEncoderVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoEncoder_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoEncoder_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoEncoder_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoEncoder_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoEncoder_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoEncoder_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoEncoder_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoEncoder_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12VideoEncoder_GetNodeMask(This)	\
+    ( (This)->lpVtbl -> GetNodeMask(This) ) 
+
+#define ID3D12VideoEncoder_GetEncoderFlags(This)	\
+    ( (This)->lpVtbl -> GetEncoderFlags(This) ) 
+
+#define ID3D12VideoEncoder_GetCodec(This)	\
+    ( (This)->lpVtbl -> GetCodec(This) ) 
+
+#define ID3D12VideoEncoder_GetCodecProfile(This,dstProfile)	\
+    ( (This)->lpVtbl -> GetCodecProfile(This,dstProfile) ) 
+
+#define ID3D12VideoEncoder_GetCodecConfiguration(This,dstCodecConfig)	\
+    ( (This)->lpVtbl -> GetCodecConfiguration(This,dstCodecConfig) ) 
+
+#define ID3D12VideoEncoder_GetInputFormat(This)	\
+    ( (This)->lpVtbl -> GetInputFormat(This) ) 
+
+#define ID3D12VideoEncoder_GetMaxMotionEstimationPrecision(This)	\
+    ( (This)->lpVtbl -> GetMaxMotionEstimationPrecision(This) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoEncoder_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoEncoderHeap_INTERFACE_DEFINED__
+#define __ID3D12VideoEncoderHeap_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoEncoderHeap */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoEncoderHeap;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("22B35D96-876A-44C0-B25E-FB8C9C7F1C4A")
+    ID3D12VideoEncoderHeap : public ID3D12Pageable
+    {
+    public:
+        virtual UINT STDMETHODCALLTYPE GetNodeMask( void) = 0;
+        
+        virtual D3D12_VIDEO_ENCODER_HEAP_FLAGS STDMETHODCALLTYPE GetEncoderHeapFlags( void) = 0;
+        
+        virtual D3D12_VIDEO_ENCODER_CODEC STDMETHODCALLTYPE GetCodec( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetCodecProfile( 
+            _Inout_  D3D12_VIDEO_ENCODER_PROFILE_DESC dstProfile) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetCodecLevel( 
+            _Inout_  D3D12_VIDEO_ENCODER_LEVEL_SETTING dstLevel) = 0;
+        
+        virtual UINT STDMETHODCALLTYPE GetResolutionListCount( void) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE GetResolutionList( 
+            const UINT ResolutionsListCount,
+            _Out_writes_(ResolutionsListCount)  D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC *pResolutionList) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoEncoderHeapVtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoEncoderHeap * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoEncoderHeap * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoEncoderHeap * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoEncoderHeap * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoEncoderHeap * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoEncoderHeap * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoEncoderHeap * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoEncoderHeap * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetNodeMask)
+        UINT ( STDMETHODCALLTYPE *GetNodeMask )( 
+            ID3D12VideoEncoderHeap * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetEncoderHeapFlags)
+        D3D12_VIDEO_ENCODER_HEAP_FLAGS ( STDMETHODCALLTYPE *GetEncoderHeapFlags )( 
+            ID3D12VideoEncoderHeap * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetCodec)
+        D3D12_VIDEO_ENCODER_CODEC ( STDMETHODCALLTYPE *GetCodec )( 
+            ID3D12VideoEncoderHeap * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetCodecProfile)
+        HRESULT ( STDMETHODCALLTYPE *GetCodecProfile )( 
+            ID3D12VideoEncoderHeap * This,
+            _Inout_  D3D12_VIDEO_ENCODER_PROFILE_DESC dstProfile);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetCodecLevel)
+        HRESULT ( STDMETHODCALLTYPE *GetCodecLevel )( 
+            ID3D12VideoEncoderHeap * This,
+            _Inout_  D3D12_VIDEO_ENCODER_LEVEL_SETTING dstLevel);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetResolutionListCount)
+        UINT ( STDMETHODCALLTYPE *GetResolutionListCount )( 
+            ID3D12VideoEncoderHeap * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncoderHeap, GetResolutionList)
+        HRESULT ( STDMETHODCALLTYPE *GetResolutionList )( 
+            ID3D12VideoEncoderHeap * This,
+            const UINT ResolutionsListCount,
+            _Out_writes_(ResolutionsListCount)  D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC *pResolutionList);
+        
+        END_INTERFACE
+    } ID3D12VideoEncoderHeapVtbl;
+
+    interface ID3D12VideoEncoderHeap
+    {
+        CONST_VTBL struct ID3D12VideoEncoderHeapVtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoEncoderHeap_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoEncoderHeap_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoEncoderHeap_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoEncoderHeap_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoEncoderHeap_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoEncoderHeap_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoEncoderHeap_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoEncoderHeap_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+
+#define ID3D12VideoEncoderHeap_GetNodeMask(This)	\
+    ( (This)->lpVtbl -> GetNodeMask(This) ) 
+
+#define ID3D12VideoEncoderHeap_GetEncoderHeapFlags(This)	\
+    ( (This)->lpVtbl -> GetEncoderHeapFlags(This) ) 
+
+#define ID3D12VideoEncoderHeap_GetCodec(This)	\
+    ( (This)->lpVtbl -> GetCodec(This) ) 
+
+#define ID3D12VideoEncoderHeap_GetCodecProfile(This,dstProfile)	\
+    ( (This)->lpVtbl -> GetCodecProfile(This,dstProfile) ) 
+
+#define ID3D12VideoEncoderHeap_GetCodecLevel(This,dstLevel)	\
+    ( (This)->lpVtbl -> GetCodecLevel(This,dstLevel) ) 
+
+#define ID3D12VideoEncoderHeap_GetResolutionListCount(This)	\
+    ( (This)->lpVtbl -> GetResolutionListCount(This) ) 
+
+#define ID3D12VideoEncoderHeap_GetResolutionList(This,ResolutionsListCount,pResolutionList)	\
+    ( (This)->lpVtbl -> GetResolutionList(This,ResolutionsListCount,pResolutionList) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoEncoderHeap_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoDevice3_INTERFACE_DEFINED__
+#define __ID3D12VideoDevice3_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoDevice3 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoDevice3;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("4243ADB4-3A32-4666-973C-0CCC5625DC44")
+    ID3D12VideoDevice3 : public ID3D12VideoDevice2
+    {
+    public:
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoEncoder( 
+            _In_  const D3D12_VIDEO_ENCODER_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoEncoder) = 0;
+        
+        virtual HRESULT STDMETHODCALLTYPE CreateVideoEncoderHeap( 
+            _In_  const D3D12_VIDEO_ENCODER_HEAP_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoEncoderHeap) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoDevice3Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoDevice3 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoDevice3 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoDevice3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CheckFeatureSupport)
+        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
+            ID3D12VideoDevice3 * This,
+            D3D12_FEATURE_VIDEO FeatureVideo,
+            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
+            UINT FeatureSupportDataSize);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoDecoder)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoder )( 
+            ID3D12VideoDevice3 * This,
+            _In_  const D3D12_VIDEO_DECODER_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoder);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoDecoderHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoderHeap )( 
+            ID3D12VideoDevice3 * This,
+            _In_  const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoderHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice, CreateVideoProcessor)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoProcessor )( 
+            ID3D12VideoDevice3 * 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);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice1, CreateVideoMotionEstimator)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoMotionEstimator )( 
+            ID3D12VideoDevice3 * This,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoMotionEstimator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice1, CreateVideoMotionVectorHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoMotionVectorHeap )( 
+            ID3D12VideoDevice3 * This,
+            _In_  const D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoMotionVectorHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoDecoder1)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoder1 )( 
+            ID3D12VideoDevice3 * This,
+            _In_  const D3D12_VIDEO_DECODER_DESC *pDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoder);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoDecoderHeap1)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoderHeap1 )( 
+            ID3D12VideoDevice3 * This,
+            _In_  const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoDecoderHeap);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoProcessor1)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoProcessor1 )( 
+            ID3D12VideoDevice3 * 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_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoProcessor);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, CreateVideoExtensionCommand)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoExtensionCommand )( 
+            ID3D12VideoDevice3 * This,
+            _In_  const D3D12_VIDEO_EXTENSION_COMMAND_DESC *pDesc,
+            _In_reads_bytes_(CreationParametersDataSizeInBytes)  const void *pCreationParameters,
+            SIZE_T CreationParametersDataSizeInBytes,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoExtensionCommand);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice2, ExecuteExtensionCommand)
+        HRESULT ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( 
+            ID3D12VideoDevice3 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes,
+            _Out_writes_bytes_(OutputDataSizeInBytes)  void *pOutputData,
+            SIZE_T OutputDataSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice3, CreateVideoEncoder)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoEncoder )( 
+            ID3D12VideoDevice3 * This,
+            _In_  const D3D12_VIDEO_ENCODER_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoEncoder);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoDevice3, CreateVideoEncoderHeap)
+        HRESULT ( STDMETHODCALLTYPE *CreateVideoEncoderHeap )( 
+            ID3D12VideoDevice3 * This,
+            _In_  const D3D12_VIDEO_ENCODER_HEAP_DESC *pDesc,
+            _In_  REFIID riid,
+            _COM_Outptr_  void **ppVideoEncoderHeap);
+        
+        END_INTERFACE
+    } ID3D12VideoDevice3Vtbl;
+
+    interface ID3D12VideoDevice3
+    {
+        CONST_VTBL struct ID3D12VideoDevice3Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoDevice3_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoDevice3_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoDevice3_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoDevice3_CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize)	\
+    ( (This)->lpVtbl -> CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize) ) 
+
+#define ID3D12VideoDevice3_CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder)	\
+    ( (This)->lpVtbl -> CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder) ) 
+
+#define ID3D12VideoDevice3_CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap)	\
+    ( (This)->lpVtbl -> CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap) ) 
+
+#define ID3D12VideoDevice3_CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor)	\
+    ( (This)->lpVtbl -> CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor) ) 
+
+
+#define ID3D12VideoDevice3_CreateVideoMotionEstimator(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionEstimator)	\
+    ( (This)->lpVtbl -> CreateVideoMotionEstimator(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionEstimator) ) 
+
+#define ID3D12VideoDevice3_CreateVideoMotionVectorHeap(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionVectorHeap)	\
+    ( (This)->lpVtbl -> CreateVideoMotionVectorHeap(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionVectorHeap) ) 
+
+
+#define ID3D12VideoDevice3_CreateVideoDecoder1(This,pDesc,pProtectedResourceSession,riid,ppVideoDecoder)	\
+    ( (This)->lpVtbl -> CreateVideoDecoder1(This,pDesc,pProtectedResourceSession,riid,ppVideoDecoder) ) 
+
+#define ID3D12VideoDevice3_CreateVideoDecoderHeap1(This,pVideoDecoderHeapDesc,pProtectedResourceSession,riid,ppVideoDecoderHeap)	\
+    ( (This)->lpVtbl -> CreateVideoDecoderHeap1(This,pVideoDecoderHeapDesc,pProtectedResourceSession,riid,ppVideoDecoderHeap) ) 
+
+#define ID3D12VideoDevice3_CreateVideoProcessor1(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,pProtectedResourceSession,riid,ppVideoProcessor)	\
+    ( (This)->lpVtbl -> CreateVideoProcessor1(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,pProtectedResourceSession,riid,ppVideoProcessor) ) 
+
+#define ID3D12VideoDevice3_CreateVideoExtensionCommand(This,pDesc,pCreationParameters,CreationParametersDataSizeInBytes,pProtectedResourceSession,riid,ppVideoExtensionCommand)	\
+    ( (This)->lpVtbl -> CreateVideoExtensionCommand(This,pDesc,pCreationParameters,CreationParametersDataSizeInBytes,pProtectedResourceSession,riid,ppVideoExtensionCommand) ) 
+
+#define ID3D12VideoDevice3_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes,pOutputData,OutputDataSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes,pOutputData,OutputDataSizeInBytes) ) 
+
+
+#define ID3D12VideoDevice3_CreateVideoEncoder(This,pDesc,riid,ppVideoEncoder)	\
+    ( (This)->lpVtbl -> CreateVideoEncoder(This,pDesc,riid,ppVideoEncoder) ) 
+
+#define ID3D12VideoDevice3_CreateVideoEncoderHeap(This,pDesc,riid,ppVideoEncoderHeap)	\
+    ( (This)->lpVtbl -> CreateVideoEncoderHeap(This,pDesc,riid,ppVideoEncoderHeap) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoDevice3_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0025 */
+/* [local] */ 
+
+typedef 
+enum D3D12_VIDEO_ENCODER_FRAME_TYPE_H264
+    {
+        D3D12_VIDEO_ENCODER_FRAME_TYPE_H264_I_FRAME	= 0,
+        D3D12_VIDEO_ENCODER_FRAME_TYPE_H264_P_FRAME	= 1,
+        D3D12_VIDEO_ENCODER_FRAME_TYPE_H264_B_FRAME	= 2,
+        D3D12_VIDEO_ENCODER_FRAME_TYPE_H264_IDR_FRAME	= 3
+    } 	D3D12_VIDEO_ENCODER_FRAME_TYPE_H264;
+
+typedef struct D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_H264
+    {
+    UINT ReconstructedPictureResourceIndex;
+    BOOL IsLongTermReference;
+    UINT LongTermPictureIdx;
+    UINT PictureOrderCountNumber;
+    UINT FrameDecodingOrderNumber;
+    UINT TemporalLayerIndex;
+    } 	D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_H264;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAG_REQUEST_INTRA_CONSTRAINED_SLICES	= 0x1
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION
+    {
+    UCHAR memory_management_control_operation;
+    UINT difference_of_pic_nums_minus1;
+    UINT long_term_pic_num;
+    UINT long_term_frame_idx;
+    UINT max_long_term_frame_idx_plus1;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION;
+
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION
+    {
+    UCHAR modification_of_pic_nums_idc;
+    UINT abs_diff_pic_num_minus1;
+    UINT long_term_pic_num;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION;
+
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264
+    {
+    D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_FLAGS Flags;
+    D3D12_VIDEO_ENCODER_FRAME_TYPE_H264 FrameType;
+    UINT pic_parameter_set_id;
+    UINT idr_pic_id;
+    UINT PictureOrderCountNumber;
+    UINT FrameDecodingOrderNumber;
+    UINT TemporalLayerIndex;
+    UINT List0ReferenceFramesCount;
+    _Field_size_full_(List0ReferenceFramesCount)  UINT *pList0ReferenceFrames;
+    UINT List1ReferenceFramesCount;
+    _Field_size_full_(List1ReferenceFramesCount)  UINT *pList1ReferenceFrames;
+    UINT ReferenceFramesReconPictureDescriptorsCount;
+    _Field_size_full_(ReferenceFramesReconPictureDescriptorsCount)  D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_H264 *pReferenceFramesReconPictureDescriptors;
+    UCHAR adaptive_ref_pic_marking_mode_flag;
+    UINT RefPicMarkingOperationsCommandsCount;
+    _Field_size_full_(RefPicMarkingOperationsCommandsCount)  D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_MARKING_OPERATION *pRefPicMarkingOperationsCommands;
+    UINT List0RefPicModificationsCount;
+    _Field_size_full_(List0RefPicModificationsCount)  D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION *pList0RefPicModifications;
+    UINT List1RefPicModificationsCount;
+    _Field_size_full_(List1RefPicModificationsCount)  D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264_REFERENCE_PICTURE_LIST_MODIFICATION_OPERATION *pList1RefPicModifications;
+    UINT QPMapValuesCount;
+    _Field_size_full_(QPMapValuesCount)  INT8 *pRateControlQPMap;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC
+    {
+        D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC_I_FRAME	= 0,
+        D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC_P_FRAME	= 1,
+        D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC_B_FRAME	= 2,
+        D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC_IDR_FRAME	= 3
+    } 	D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC;
+
+typedef struct D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC
+    {
+    UINT ReconstructedPictureResourceIndex;
+    BOOL IsRefUsedByCurrentPic;
+    BOOL IsLongTermReference;
+    UINT PictureOrderCountNumber;
+    UINT TemporalLayerIndex;
+    } 	D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAG_REQUEST_INTRA_CONSTRAINED_SLICES	= 0x1
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC
+    {
+    D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC_FLAGS Flags;
+    D3D12_VIDEO_ENCODER_FRAME_TYPE_HEVC FrameType;
+    UINT slice_pic_parameter_set_id;
+    UINT PictureOrderCountNumber;
+    UINT TemporalLayerIndex;
+    UINT List0ReferenceFramesCount;
+    _Field_size_full_(List0ReferenceFramesCount)  UINT *pList0ReferenceFrames;
+    UINT List1ReferenceFramesCount;
+    _Field_size_full_(List1ReferenceFramesCount)  UINT *pList1ReferenceFrames;
+    UINT ReferenceFramesReconPictureDescriptorsCount;
+    _Field_size_full_(ReferenceFramesReconPictureDescriptorsCount)  D3D12_VIDEO_ENCODER_REFERENCE_PICTURE_DESCRIPTOR_HEVC *pReferenceFramesReconPictureDescriptors;
+    UINT List0RefPicModificationsCount;
+    _Field_size_full_(List0RefPicModificationsCount)  UINT *pList0RefPicModifications;
+    UINT List1RefPicModificationsCount;
+    _Field_size_full_(List1RefPicModificationsCount)  UINT *pList1RefPicModifications;
+    UINT QPMapValuesCount;
+    _Field_size_full_(QPMapValuesCount)  INT8 *pRateControlQPMap;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC;
+
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA
+    {
+    UINT DataSize;
+    union 
+        {
+        D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_H264 *pH264PicData;
+        D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA_HEVC *pHEVCPicData;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA;
+
+typedef struct D3D12_VIDEO_ENCODE_REFERENCE_FRAMES
+    {
+    UINT NumTexture2Ds;
+    _Field_size_full_(NumTexture2Ds)  ID3D12Resource **ppTexture2Ds;
+    _Field_size_full_(NumTexture2Ds)  UINT *pSubresources;
+    } 	D3D12_VIDEO_ENCODE_REFERENCE_FRAMES;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAG_USED_AS_REFERENCE_PICTURE	= 0x1
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC
+    {
+    UINT IntraRefreshFrameIndex;
+    D3D12_VIDEO_ENCODER_PICTURE_CONTROL_FLAGS Flags;
+    D3D12_VIDEO_ENCODER_PICTURE_CONTROL_CODEC_DATA PictureControlCodecData;
+    D3D12_VIDEO_ENCODE_REFERENCE_FRAMES ReferenceFrames;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_NONE	= 0,
+        D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_RESOLUTION_CHANGE	= 0x1,
+        D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_RATE_CONTROL_CHANGE	= 0x2,
+        D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_SUBREGION_LAYOUT_CHANGE	= 0x4,
+        D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_REQUEST_INTRA_REFRESH	= 0x8,
+        D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAG_GOP_SEQUENCE_CHANGE	= 0x10
+    } 	D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES
+    {
+    union 
+        {
+        UINT MaxBytesPerSlice;
+        UINT NumberOfCodingUnitsPerSlice;
+        UINT NumberOfRowsPerSlice;
+        UINT NumberOfSlicesPerFrame;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES;
+
+typedef struct D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA
+    {
+    UINT DataSize;
+    union 
+        {
+        const D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES *pSlicesPartition_H264;
+        const D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA_SLICES *pSlicesPartition_HEVC;
+        } 	;
+    } 	D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA;
+
+typedef struct D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC
+    {
+    D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_FLAGS Flags;
+    D3D12_VIDEO_ENCODER_INTRA_REFRESH IntraRefreshConfig;
+    D3D12_VIDEO_ENCODER_RATE_CONTROL RateControl;
+    D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC PictureTargetResolution;
+    D3D12_VIDEO_ENCODER_FRAME_SUBREGION_LAYOUT_MODE SelectedLayoutMode;
+    D3D12_VIDEO_ENCODER_PICTURE_CONTROL_SUBREGIONS_LAYOUT_DATA FrameSubregionsLayoutData;
+    D3D12_VIDEO_ENCODER_SEQUENCE_GOP_STRUCTURE CodecGopSequence;
+    } 	D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC;
+
+typedef struct D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS
+    {
+    D3D12_VIDEO_ENCODER_SEQUENCE_CONTROL_DESC SequenceControlDesc;
+    D3D12_VIDEO_ENCODER_PICTURE_CONTROL_DESC PictureControlDesc;
+    ID3D12Resource *pInputFrame;
+    UINT InputFrameSubresource;
+    UINT CurrentFrameBitstreamMetadataSize;
+    } 	D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS;
+
+typedef struct D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM
+    {
+    ID3D12Resource *pBuffer;
+    UINT64 FrameStartOffset;
+    } 	D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM;
+
+typedef struct D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE
+    {
+    ID3D12Resource *pReconstructedPicture;
+    UINT ReconstructedPictureSubresource;
+    } 	D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE;
+
+typedef struct D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA
+    {
+    UINT64 bSize;
+    UINT64 bStartOffset;
+    UINT64 bHeaderSize;
+    } 	D3D12_VIDEO_ENCODER_FRAME_SUBREGION_METADATA;
+
+typedef 
+enum D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS
+    {
+        D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_NO_ERROR	= 0,
+        D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_CODEC_PICTURE_CONTROL_NOT_SUPPORTED	= 0x1,
+        D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_SUBREGION_LAYOUT_CONFIGURATION_NOT_SUPPORTED	= 0x2,
+        D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_INVALID_REFERENCE_PICTURES	= 0x4,
+        D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_RECONFIGURATION_REQUEST_NOT_SUPPORTED	= 0x8,
+        D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAG_INVALID_METADATA_BUFFER_SOURCE	= 0x10
+    } 	D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS;
+
+DEFINE_ENUM_FLAG_OPERATORS(D3D12_VIDEO_ENCODER_ENCODE_ERROR_FLAGS);
+typedef struct D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS
+    {
+    UINT64 AverageQP;
+    UINT64 IntraCodingUnitsCount;
+    UINT64 InterCodingUnitsCount;
+    UINT64 SkipCodingUnitsCount;
+    UINT64 AverageMotionEstimationXDirection;
+    UINT64 AverageMotionEstimationYDirection;
+    } 	D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS;
+
+typedef struct D3D12_VIDEO_ENCODER_OUTPUT_METADATA
+    {
+    UINT64 EncodeErrorFlags;
+    D3D12_VIDEO_ENCODER_OUTPUT_METADATA_STATISTICS EncodeStats;
+    UINT64 EncodedBitstreamWrittenBytesCount;
+    UINT64 WrittenSubregionsCount;
+    } 	D3D12_VIDEO_ENCODER_OUTPUT_METADATA;
+
+typedef struct D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER
+    {
+    ID3D12Resource *pBuffer;
+    UINT64 Offset;
+    } 	D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER;
+
+typedef struct D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS
+    {
+    D3D12_VIDEO_ENCODER_CODEC EncoderCodec;
+    D3D12_VIDEO_ENCODER_PROFILE_DESC EncoderProfile;
+    DXGI_FORMAT EncoderInputFormat;
+    D3D12_VIDEO_ENCODER_PICTURE_RESOLUTION_DESC EncodedPictureEffectiveResolution;
+    D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER HWLayoutMetadata;
+    } 	D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS;
+
+typedef struct D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS
+    {
+    D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER ResolvedLayoutMetadata;
+    } 	D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS;
+
+typedef struct D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS
+    {
+    D3D12_VIDEO_ENCODER_COMPRESSED_BITSTREAM Bitstream;
+    D3D12_VIDEO_ENCODER_RECONSTRUCTED_PICTURE ReconstructedPicture;
+    D3D12_VIDEO_ENCODER_ENCODE_OPERATION_METADATA_BUFFER EncoderOutputMetadata;
+    } 	D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS;
+
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0025_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0025_v0_0_s_ifspec;
+
+#ifndef __ID3D12VideoEncodeCommandList2_INTERFACE_DEFINED__
+#define __ID3D12VideoEncodeCommandList2_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoEncodeCommandList2 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoEncodeCommandList2;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("895491e2-e701-46a9-9a1f-8d3480ed867a")
+    ID3D12VideoEncodeCommandList2 : public ID3D12VideoEncodeCommandList1
+    {
+    public:
+        virtual void STDMETHODCALLTYPE EncodeFrame( 
+            _In_  ID3D12VideoEncoder *pEncoder,
+            _In_  ID3D12VideoEncoderHeap *pHeap,
+            _In_  const D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS *pInputArguments,
+            _In_  const D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS *pOutputArguments) = 0;
+        
+        virtual void STDMETHODCALLTYPE ResolveEncoderOutputMetadata( 
+            _In_  const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS *pInputArguments,
+            _In_  const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS *pOutputArguments) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoEncodeCommandList2Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoEncodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoEncodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoEncodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoEncodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoEncodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoEncodeCommandList2 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EstimateMotion)
+        void ( STDMETHODCALLTYPE *EstimateMotion )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  ID3D12VideoMotionEstimator *pMotionEstimator,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT *pOutputArguments,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_INPUT *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResolveMotionVectorHeap)
+        void ( STDMETHODCALLTYPE *ResolveMotionVectorHeap )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT *pOutputArguments,
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList1, InitializeExtensionCommand)
+        void ( STDMETHODCALLTYPE *InitializeExtensionCommand )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList1, ExecuteExtensionCommand)
+        void ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList2, EncodeFrame)
+        void ( STDMETHODCALLTYPE *EncodeFrame )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  ID3D12VideoEncoder *pEncoder,
+            _In_  ID3D12VideoEncoderHeap *pHeap,
+            _In_  const D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS *pInputArguments,
+            _In_  const D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS *pOutputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList2, ResolveEncoderOutputMetadata)
+        void ( STDMETHODCALLTYPE *ResolveEncoderOutputMetadata )( 
+            ID3D12VideoEncodeCommandList2 * This,
+            _In_  const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS *pInputArguments,
+            _In_  const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS *pOutputArguments);
+        
+        END_INTERFACE
+    } ID3D12VideoEncodeCommandList2Vtbl;
+
+    interface ID3D12VideoEncodeCommandList2
+    {
+        CONST_VTBL struct ID3D12VideoEncodeCommandList2Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoEncodeCommandList2_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoEncodeCommandList2_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoEncodeCommandList2_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoEncodeCommandList2_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoEncodeCommandList2_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoEncodeCommandList2_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoEncodeCommandList2_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoEncodeCommandList2_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoEncodeCommandList2_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoEncodeCommandList2_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoEncodeCommandList2_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoEncodeCommandList2_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoEncodeCommandList2_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoEncodeCommandList2_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoEncodeCommandList2_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoEncodeCommandList2_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoEncodeCommandList2_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoEncodeCommandList2_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoEncodeCommandList2_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoEncodeCommandList2_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoEncodeCommandList2_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoEncodeCommandList2_EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList2_ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList2_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+#define ID3D12VideoEncodeCommandList2_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+
+#define ID3D12VideoEncodeCommandList2_InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes) ) 
+
+#define ID3D12VideoEncodeCommandList2_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes) ) 
+
+
+#define ID3D12VideoEncodeCommandList2_EncodeFrame(This,pEncoder,pHeap,pInputArguments,pOutputArguments)	\
+    ( (This)->lpVtbl -> EncodeFrame(This,pEncoder,pHeap,pInputArguments,pOutputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList2_ResolveEncoderOutputMetadata(This,pInputArguments,pOutputArguments)	\
+    ( (This)->lpVtbl -> ResolveEncoderOutputMetadata(This,pInputArguments,pOutputArguments) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoEncodeCommandList2_INTERFACE_DEFINED__ */
+
+
+#ifndef __ID3D12VideoEncodeCommandList3_INTERFACE_DEFINED__
+#define __ID3D12VideoEncodeCommandList3_INTERFACE_DEFINED__
+
+/* interface ID3D12VideoEncodeCommandList3 */
+/* [unique][local][object][uuid] */ 
+
+
+EXTERN_C const IID IID_ID3D12VideoEncodeCommandList3;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+    
+    MIDL_INTERFACE("7f027b22-1515-4e85-aa0d-026486580576")
+    ID3D12VideoEncodeCommandList3 : public ID3D12VideoEncodeCommandList2
+    {
+    public:
+        virtual void STDMETHODCALLTYPE Barrier( 
+            UINT32 NumBarrierGroups,
+            _In_reads_(NumBarrierGroups)  const D3D12_BARRIER_GROUP *pBarrierGroups) = 0;
+        
+    };
+    
+    
+#else 	/* C style interface */
+
+    typedef struct ID3D12VideoEncodeCommandList3Vtbl
+    {
+        BEGIN_INTERFACE
+        
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
+        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            REFIID riid,
+            _COM_Outptr_  void **ppvObject);
+        
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
+        ULONG ( STDMETHODCALLTYPE *AddRef )( 
+            ID3D12VideoEncodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(IUnknown, Release)
+        ULONG ( STDMETHODCALLTYPE *Release )( 
+            ID3D12VideoEncodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, GetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  REFGUID guid,
+            _Inout_  UINT *pDataSize,
+            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateData)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  REFGUID guid,
+            _In_  UINT DataSize,
+            _In_reads_bytes_opt_( DataSize )  const void *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetPrivateDataInterface)
+        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  REFGUID guid,
+            _In_opt_  const IUnknown *pData);
+        
+        DECLSPEC_XFGVIRT(ID3D12Object, SetName)
+        HRESULT ( STDMETHODCALLTYPE *SetName )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_z_  LPCWSTR Name);
+        
+        DECLSPEC_XFGVIRT(ID3D12DeviceChild, GetDevice)
+        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            REFIID riid,
+            _COM_Outptr_opt_  void **ppvDevice);
+        
+        DECLSPEC_XFGVIRT(ID3D12CommandList, GetType)
+        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
+            ID3D12VideoEncodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, Close)
+        HRESULT ( STDMETHODCALLTYPE *Close )( 
+            ID3D12VideoEncodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, Reset)
+        HRESULT ( STDMETHODCALLTYPE *Reset )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  ID3D12CommandAllocator *pAllocator);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ClearState)
+        void ( STDMETHODCALLTYPE *ClearState )( 
+            ID3D12VideoEncodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResourceBarrier)
+        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  UINT NumBarriers,
+            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, DiscardResource)
+        void ( STDMETHODCALLTYPE *DiscardResource )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  ID3D12Resource *pResource,
+            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, BeginQuery)
+        void ( STDMETHODCALLTYPE *BeginQuery )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EndQuery)
+        void ( STDMETHODCALLTYPE *EndQuery )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT Index);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResolveQueryData)
+        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  ID3D12QueryHeap *pQueryHeap,
+            _In_  D3D12_QUERY_TYPE Type,
+            _In_  UINT StartIndex,
+            _In_  UINT NumQueries,
+            _In_  ID3D12Resource *pDestinationBuffer,
+            _In_  UINT64 AlignedDestinationBufferOffset);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetPredication)
+        void ( STDMETHODCALLTYPE *SetPredication )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_opt_  ID3D12Resource *pBuffer,
+            _In_  UINT64 AlignedBufferOffset,
+            _In_  D3D12_PREDICATION_OP Operation);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetMarker)
+        void ( STDMETHODCALLTYPE *SetMarker )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, BeginEvent)
+        void ( STDMETHODCALLTYPE *BeginEvent )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            UINT Metadata,
+            _In_reads_bytes_opt_(Size)  const void *pData,
+            UINT Size);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EndEvent)
+        void ( STDMETHODCALLTYPE *EndEvent )( 
+            ID3D12VideoEncodeCommandList3 * This);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, EstimateMotion)
+        void ( STDMETHODCALLTYPE *EstimateMotion )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  ID3D12VideoMotionEstimator *pMotionEstimator,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT *pOutputArguments,
+            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_INPUT *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, ResolveMotionVectorHeap)
+        void ( STDMETHODCALLTYPE *ResolveMotionVectorHeap )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT *pOutputArguments,
+            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT *pInputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, WriteBufferImmediate)
+        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            UINT Count,
+            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
+            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList, SetProtectedResourceSession)
+        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList1, InitializeExtensionCommand)
+        void ( STDMETHODCALLTYPE *InitializeExtensionCommand )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(InitializationParametersSizeInBytes)  const void *pInitializationParameters,
+            SIZE_T InitializationParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList1, ExecuteExtensionCommand)
+        void ( STDMETHODCALLTYPE *ExecuteExtensionCommand )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  ID3D12VideoExtensionCommand *pExtensionCommand,
+            _In_reads_bytes_(ExecutionParametersSizeInBytes)  const void *pExecutionParameters,
+            SIZE_T ExecutionParametersSizeInBytes);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList2, EncodeFrame)
+        void ( STDMETHODCALLTYPE *EncodeFrame )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  ID3D12VideoEncoder *pEncoder,
+            _In_  ID3D12VideoEncoderHeap *pHeap,
+            _In_  const D3D12_VIDEO_ENCODER_ENCODEFRAME_INPUT_ARGUMENTS *pInputArguments,
+            _In_  const D3D12_VIDEO_ENCODER_ENCODEFRAME_OUTPUT_ARGUMENTS *pOutputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList2, ResolveEncoderOutputMetadata)
+        void ( STDMETHODCALLTYPE *ResolveEncoderOutputMetadata )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            _In_  const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_INPUT_ARGUMENTS *pInputArguments,
+            _In_  const D3D12_VIDEO_ENCODER_RESOLVE_METADATA_OUTPUT_ARGUMENTS *pOutputArguments);
+        
+        DECLSPEC_XFGVIRT(ID3D12VideoEncodeCommandList3, Barrier)
+        void ( STDMETHODCALLTYPE *Barrier )( 
+            ID3D12VideoEncodeCommandList3 * This,
+            UINT32 NumBarrierGroups,
+            _In_reads_(NumBarrierGroups)  const D3D12_BARRIER_GROUP *pBarrierGroups);
+        
+        END_INTERFACE
+    } ID3D12VideoEncodeCommandList3Vtbl;
+
+    interface ID3D12VideoEncodeCommandList3
+    {
+        CONST_VTBL struct ID3D12VideoEncodeCommandList3Vtbl *lpVtbl;
+    };
+
+    
+
+#ifdef COBJMACROS
+
+
+#define ID3D12VideoEncodeCommandList3_QueryInterface(This,riid,ppvObject)	\
+    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
+
+#define ID3D12VideoEncodeCommandList3_AddRef(This)	\
+    ( (This)->lpVtbl -> AddRef(This) ) 
+
+#define ID3D12VideoEncodeCommandList3_Release(This)	\
+    ( (This)->lpVtbl -> Release(This) ) 
+
+
+#define ID3D12VideoEncodeCommandList3_GetPrivateData(This,guid,pDataSize,pData)	\
+    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
+
+#define ID3D12VideoEncodeCommandList3_SetPrivateData(This,guid,DataSize,pData)	\
+    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
+
+#define ID3D12VideoEncodeCommandList3_SetPrivateDataInterface(This,guid,pData)	\
+    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
+
+#define ID3D12VideoEncodeCommandList3_SetName(This,Name)	\
+    ( (This)->lpVtbl -> SetName(This,Name) ) 
+
+
+#define ID3D12VideoEncodeCommandList3_GetDevice(This,riid,ppvDevice)	\
+    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
+
+
+#define ID3D12VideoEncodeCommandList3_GetType(This)	\
+    ( (This)->lpVtbl -> GetType(This) ) 
+
+
+#define ID3D12VideoEncodeCommandList3_Close(This)	\
+    ( (This)->lpVtbl -> Close(This) ) 
+
+#define ID3D12VideoEncodeCommandList3_Reset(This,pAllocator)	\
+    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
+
+#define ID3D12VideoEncodeCommandList3_ClearState(This)	\
+    ( (This)->lpVtbl -> ClearState(This) ) 
+
+#define ID3D12VideoEncodeCommandList3_ResourceBarrier(This,NumBarriers,pBarriers)	\
+    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
+
+#define ID3D12VideoEncodeCommandList3_DiscardResource(This,pResource,pRegion)	\
+    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
+
+#define ID3D12VideoEncodeCommandList3_BeginQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoEncodeCommandList3_EndQuery(This,pQueryHeap,Type,Index)	\
+    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
+
+#define ID3D12VideoEncodeCommandList3_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
+    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
+
+#define ID3D12VideoEncodeCommandList3_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
+    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
+
+#define ID3D12VideoEncodeCommandList3_SetMarker(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoEncodeCommandList3_BeginEvent(This,Metadata,pData,Size)	\
+    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
+
+#define ID3D12VideoEncodeCommandList3_EndEvent(This)	\
+    ( (This)->lpVtbl -> EndEvent(This) ) 
+
+#define ID3D12VideoEncodeCommandList3_EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList3_ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments)	\
+    ( (This)->lpVtbl -> ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList3_WriteBufferImmediate(This,Count,pParams,pModes)	\
+    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
+
+#define ID3D12VideoEncodeCommandList3_SetProtectedResourceSession(This,pProtectedResourceSession)	\
+    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
+
+
+#define ID3D12VideoEncodeCommandList3_InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> InitializeExtensionCommand(This,pExtensionCommand,pInitializationParameters,InitializationParametersSizeInBytes) ) 
+
+#define ID3D12VideoEncodeCommandList3_ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes)	\
+    ( (This)->lpVtbl -> ExecuteExtensionCommand(This,pExtensionCommand,pExecutionParameters,ExecutionParametersSizeInBytes) ) 
+
+
+#define ID3D12VideoEncodeCommandList3_EncodeFrame(This,pEncoder,pHeap,pInputArguments,pOutputArguments)	\
+    ( (This)->lpVtbl -> EncodeFrame(This,pEncoder,pHeap,pInputArguments,pOutputArguments) ) 
+
+#define ID3D12VideoEncodeCommandList3_ResolveEncoderOutputMetadata(This,pInputArguments,pOutputArguments)	\
+    ( (This)->lpVtbl -> ResolveEncoderOutputMetadata(This,pInputArguments,pOutputArguments) ) 
+
+
+#define ID3D12VideoEncodeCommandList3_Barrier(This,NumBarrierGroups,pBarrierGroups)	\
+    ( (This)->lpVtbl -> Barrier(This,NumBarrierGroups,pBarrierGroups) ) 
+
+#endif /* COBJMACROS */
+
+
+#endif 	/* C style interface */
+
+
+
+
+#endif 	/* __ID3D12VideoEncodeCommandList3_INTERFACE_DEFINED__ */
+
+
+/* interface __MIDL_itf_d3d12video_0000_0027 */
+/* [local] */ 
+
+#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_GAMES) */
+#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);
+DEFINE_GUID(IID_ID3D12VideoMotionEstimator,0x33FDAE0E,0x098B,0x428F,0x87,0xBB,0x34,0xB6,0x95,0xDE,0x08,0xF8);
+DEFINE_GUID(IID_ID3D12VideoMotionVectorHeap,0x5BE17987,0x743A,0x4061,0x83,0x4B,0x23,0xD2,0x2D,0xAE,0xA5,0x05);
+DEFINE_GUID(IID_ID3D12VideoDevice1,0x981611AD,0xA144,0x4C83,0x98,0x90,0xF3,0x0E,0x26,0xD6,0x58,0xAB);
+DEFINE_GUID(IID_ID3D12VideoEncodeCommandList,0x8455293A,0x0CBD,0x4831,0x9B,0x39,0xFB,0xDB,0xAB,0x72,0x47,0x23);
+DEFINE_GUID(IID_ID3D12VideoDecoder1,0x79A2E5FB,0xCCD2,0x469A,0x9F,0xDE,0x19,0x5D,0x10,0x95,0x1F,0x7E);
+DEFINE_GUID(IID_ID3D12VideoDecoderHeap1,0xDA1D98C5,0x539F,0x41B2,0xBF,0x6B,0x11,0x98,0xA0,0x3B,0x6D,0x26);
+DEFINE_GUID(IID_ID3D12VideoProcessor1,0xF3CFE615,0x553F,0x425C,0x86,0xD8,0xEE,0x8C,0x1B,0x1F,0xB0,0x1C);
+DEFINE_GUID(IID_ID3D12VideoExtensionCommand,0x554E41E8,0xAE8E,0x4A8C,0xB7,0xD2,0x5B,0x4F,0x27,0x4A,0x30,0xE4);
+DEFINE_GUID(IID_ID3D12VideoDevice2,0xF019AC49,0xF838,0x4A95,0x9B,0x17,0x57,0x94,0x37,0xC8,0xF5,0x13);
+DEFINE_GUID(IID_ID3D12VideoDecodeCommandList2,0x6e120880,0xc114,0x4153,0x80,0x36,0xd2,0x47,0x05,0x1e,0x17,0x29);
+DEFINE_GUID(IID_ID3D12VideoDecodeCommandList3,0x2aee8c37,0x9562,0x42da,0x8a,0xbf,0x61,0xef,0xeb,0x2e,0x45,0x13);
+DEFINE_GUID(IID_ID3D12VideoProcessCommandList2,0xdb525ae4,0x6ad6,0x473c,0xba,0xa7,0x59,0xb2,0xe3,0x70,0x82,0xe4);
+DEFINE_GUID(IID_ID3D12VideoProcessCommandList3,0x1a0a4ca4,0x9f08,0x40ce,0x95,0x58,0xb4,0x11,0xfd,0x26,0x66,0xff);
+DEFINE_GUID(IID_ID3D12VideoEncodeCommandList1,0x94971eca,0x2bdb,0x4769,0x88,0xcf,0x36,0x75,0xea,0x75,0x7e,0xbc);
+DEFINE_GUID(IID_ID3D12VideoEncoder,0x2E0D212D,0x8DF9,0x44A6,0xA7,0x70,0xBB,0x28,0x9B,0x18,0x27,0x37);
+DEFINE_GUID(IID_ID3D12VideoEncoderHeap,0x22B35D96,0x876A,0x44C0,0xB2,0x5E,0xFB,0x8C,0x9C,0x7F,0x1C,0x4A);
+DEFINE_GUID(IID_ID3D12VideoDevice3,0x4243ADB4,0x3A32,0x4666,0x97,0x3C,0x0C,0xCC,0x56,0x25,0xDC,0x44);
+DEFINE_GUID(IID_ID3D12VideoEncodeCommandList2,0x895491e2,0xe701,0x46a9,0x9a,0x1f,0x8d,0x34,0x80,0xed,0x86,0x7a);
+DEFINE_GUID(IID_ID3D12VideoEncodeCommandList3,0x7f027b22,0x1515,0x4e85,0xaa,0x0d,0x02,0x64,0x86,0x58,0x05,0x76);
+
+
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0027_v0_0_c_ifspec;
+extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0027_v0_0_s_ifspec;
+
+/* Additional Prototypes for ALL interfaces */
+
+/* end of Additional Prototypes */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
+

3rdparty/dxsdk/include/d3dcommon.h → 3rdparty/directx-headers/include/directx/d3dcommon.h

@@ -1,9 +1,15 @@
+/*-------------------------------------------------------------------------------------
+ *
+ * Copyright (c) Microsoft Corporation
+ * Licensed under the MIT license
+ *
+ *-------------------------------------------------------------------------------------*/
 
 
 /* this ALWAYS GENERATED file contains the definitions for the interfaces */
 
 
- /* File created by MIDL compiler version 8.01.0622 */
+ /* File created by MIDL compiler version 8.01.0628 */
 /* @@MIDL_FILE_HEADING(  ) */
 
 
@@ -37,59 +43,13 @@
 #pragma once
 #endif
 
-#if defined(_MSC_VER) && _MSC_VER <= 1600
-#ifndef VS2008_SAL_COMPAT
-#define VS2008_SAL_COMPAT
-// BK - SAL compatibility for VS2008
-
-#if _MSC_VER < 1600
-#define DEFINE_ENUM_FLAG_OPERATORS(ENUMTYPE) \
-			extern "C++" { \
-				inline ENUMTYPE operator |  (ENUMTYPE  _a, ENUMTYPE _b) { return  ENUMTYPE   ( ( (int)  _a) |  ( (int)_b) ); } \
-				inline ENUMTYPE operator |= (ENUMTYPE &_a, ENUMTYPE _b) { return (ENUMTYPE &)( ( (int &)_a) |= ( (int)_b) ); } \
-				inline ENUMTYPE operator &  (ENUMTYPE  _a, ENUMTYPE _b) { return  ENUMTYPE   ( ( (int)  _a) &  ( (int)_b) ); } \
-				inline ENUMTYPE operator &= (ENUMTYPE &_a, ENUMTYPE _b) { return (ENUMTYPE &)( ( (int &)_a) &= ( (int)_b) ); } \
-				inline ENUMTYPE operator ~  (ENUMTYPE  _a)              { return (ENUMTYPE)  (~( (int)  _a) );               } \
-				inline ENUMTYPE operator ^  (ENUMTYPE  _a, ENUMTYPE _b) { return  ENUMTYPE   ( ( (int)  _a) ^  ( (int)_b) ); } \
-				inline ENUMTYPE operator ^= (ENUMTYPE &_a, ENUMTYPE _b) { return (ENUMTYPE &)( ( (int &)_a) ^= ( (int)_b) ); } \
-			}
-#endif // _MSC_VER < 1600
-
-#undef _Out_
-#define _Out_
-#undef _In_
-#define _In_
-#undef _Always_
-#define _Always_(annos)
-#define _In_reads_(size)
-#define _In_reads_opt_(size)
-#define _In_reads_bytes_(size)
-#define _In_reads_bytes_opt_(size)
-#define _Inout_updates_bytes_(size)
-#define _Out_writes_(size)
-#define _Out_writes_opt_(size)
-#define _Out_writes_to_opt_(size,count)
-#define _Out_writes_bytes_(size)
-#define _Out_writes_bytes_opt_(size)
-#define _Out_writes_bytes_to_(size,count)
-#define _Outptr_
-#define _Outptr_opt_
-#define _Outptr_opt_result_maybenull_
-#define _Outptr_opt_result_bytebuffer_(size)
-#define _Outptr_result_maybenull_
-#define _Outptr_result_bytebuffer_(size)
-#define _Out_writes_all_opt_(size)
-#define _COM_Outptr_
-#define _COM_Outptr_opt_
-#define _COM_Outptr_opt_result_maybenull_
-#define _Field_size_(size)
-#define _Field_size_full_(size)
-#define _Field_size_opt_(size)
-#define _Field_size_bytes_full_(size)
-#define nullptr NULL
-
-#endif // BK - VS2008_SAL_COMPAT
-#endif //
+#ifndef DECLSPEC_XFGVIRT
+#if defined(_CONTROL_FLOW_GUARD_XFG)
+#define DECLSPEC_XFGVIRT(base, func) __declspec(xfg_virtual(base, func))
+#else
+#define DECLSPEC_XFGVIRT(base, func)
+#endif
+#endif
 
 /* Forward Declarations */ 
 
@@ -133,6 +93,7 @@ enum D3D_DRIVER_TYPE
 typedef 
 enum D3D_FEATURE_LEVEL
     {
+        D3D_FEATURE_LEVEL_1_0_CORE	= 0x1000,
         D3D_FEATURE_LEVEL_9_1	= 0x9100,
         D3D_FEATURE_LEVEL_9_2	= 0x9200,
         D3D_FEATURE_LEVEL_9_3	= 0x9300,
@@ -141,7 +102,8 @@ enum D3D_FEATURE_LEVEL
         D3D_FEATURE_LEVEL_11_0	= 0xb000,
         D3D_FEATURE_LEVEL_11_1	= 0xb100,
         D3D_FEATURE_LEVEL_12_0	= 0xc000,
-        D3D_FEATURE_LEVEL_12_1	= 0xc100
+        D3D_FEATURE_LEVEL_12_1	= 0xc100,
+        D3D_FEATURE_LEVEL_12_2	= 0xc200
     } 	D3D_FEATURE_LEVEL;
 
 #define D3D_FL9_1_REQ_TEXTURE1D_U_DIMENSION          2048
@@ -168,6 +130,7 @@ enum D3D_PRIMITIVE_TOPOLOGY
         D3D_PRIMITIVE_TOPOLOGY_LINESTRIP	= 3,
         D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST	= 4,
         D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP	= 5,
+        D3D_PRIMITIVE_TOPOLOGY_TRIANGLEFAN	= 6,
         D3D_PRIMITIVE_TOPOLOGY_LINELIST_ADJ	= 10,
         D3D_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ	= 11,
         D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ	= 12,
@@ -395,6 +358,37 @@ enum D3D_SRV_DIMENSION
         D3D11_SRV_DIMENSION_BUFFEREX	= D3D_SRV_DIMENSION_BUFFEREX
     } 	D3D_SRV_DIMENSION;
 
+#define D3D_SHADER_FEATURE_DOUBLES                                                        0x00001
+#define D3D_SHADER_FEATURE_COMPUTE_SHADERS_PLUS_RAW_AND_STRUCTURED_BUFFERS_VIA_SHADER_4_X 0x00002
+#define D3D_SHADER_FEATURE_UAVS_AT_EVERY_STAGE                                            0x00004
+#define D3D_SHADER_FEATURE_64_UAVS                                                        0x00008
+#define D3D_SHADER_FEATURE_MINIMUM_PRECISION                                              0x00010
+#define D3D_SHADER_FEATURE_11_1_DOUBLE_EXTENSIONS                                         0x00020
+#define D3D_SHADER_FEATURE_11_1_SHADER_EXTENSIONS                                         0x00040
+#define D3D_SHADER_FEATURE_LEVEL_9_COMPARISON_FILTERING                                   0x00080
+#define D3D_SHADER_FEATURE_TILED_RESOURCES                                                0x00100
+#define D3D_SHADER_FEATURE_STENCIL_REF                                                    0x00200
+#define D3D_SHADER_FEATURE_INNER_COVERAGE                                                 0x00400
+#define D3D_SHADER_FEATURE_TYPED_UAV_LOAD_ADDITIONAL_FORMATS                              0x00800
+#define D3D_SHADER_FEATURE_ROVS                                                           0x01000
+#define D3D_SHADER_FEATURE_VIEWPORT_AND_RT_ARRAY_INDEX_FROM_ANY_SHADER_FEEDING_RASTERIZER 0x02000
+#define D3D_SHADER_FEATURE_WAVE_OPS                                                       0x04000
+#define D3D_SHADER_FEATURE_INT64_OPS                                                      0x08000
+#define D3D_SHADER_FEATURE_VIEW_ID                                                        0x10000
+#define D3D_SHADER_FEATURE_BARYCENTRICS                                                   0x20000
+#define D3D_SHADER_FEATURE_NATIVE_16BIT_OPS                                               0x40000
+#define D3D_SHADER_FEATURE_SHADING_RATE                                                   0x80000
+#define D3D_SHADER_FEATURE_RAYTRACING_TIER_1_1                                            0x100000
+#define D3D_SHADER_FEATURE_SAMPLER_FEEDBACK                                               0x200000
+#define D3D_SHADER_FEATURE_ATOMIC_INT64_ON_TYPED_RESOURCE                                 0x400000
+#define D3D_SHADER_FEATURE_ATOMIC_INT64_ON_GROUP_SHARED                                   0x800000
+#define D3D_SHADER_FEATURE_DERIVATIVES_IN_MESH_AND_AMPLIFICATION_SHADERS                  0x1000000
+#define D3D_SHADER_FEATURE_RESOURCE_DESCRIPTOR_HEAP_INDEXING                              0x2000000
+#define D3D_SHADER_FEATURE_SAMPLER_DESCRIPTOR_HEAP_INDEXING                               0x4000000
+#define D3D_SHADER_FEATURE_WAVE_MMA                                                       0x8000000
+#define D3D_SHADER_FEATURE_ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE                       0x10000000
+#define D3D_SHADER_FEATURE_ADVANCED_TEXTURE_OPS                                           0x20000000
+#define D3D_SHADER_FEATURE_WRITEABLE_MSAA_TEXTURES                                        0x40000000
 typedef struct _D3D_SHADER_MACRO
     {
     LPCSTR Name;
@@ -437,21 +431,26 @@ EXTERN_C const IID IID_ID3D10Blob;
     {
         BEGIN_INTERFACE
         
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
         HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
             ID3D10Blob * This,
             /* [in] */ REFIID riid,
             /* [annotation][iid_is][out] */ 
             _COM_Outptr_  void **ppvObject);
         
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
         ULONG ( STDMETHODCALLTYPE *AddRef )( 
             ID3D10Blob * This);
         
+        DECLSPEC_XFGVIRT(IUnknown, Release)
         ULONG ( STDMETHODCALLTYPE *Release )( 
             ID3D10Blob * This);
         
+        DECLSPEC_XFGVIRT(ID3D10Blob, GetBufferPointer)
         LPVOID ( STDMETHODCALLTYPE *GetBufferPointer )( 
             ID3D10Blob * This);
         
+        DECLSPEC_XFGVIRT(ID3D10Blob, GetBufferSize)
         SIZE_T ( STDMETHODCALLTYPE *GetBufferSize )( 
             ID3D10Blob * This);
         
@@ -547,18 +546,22 @@ EXTERN_C const IID IID_ID3DDestructionNotifier;
     {
         BEGIN_INTERFACE
         
+        DECLSPEC_XFGVIRT(IUnknown, QueryInterface)
         HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
             ID3DDestructionNotifier * This,
             /* [in] */ REFIID riid,
             /* [annotation][iid_is][out] */ 
             _COM_Outptr_  void **ppvObject);
         
+        DECLSPEC_XFGVIRT(IUnknown, AddRef)
         ULONG ( STDMETHODCALLTYPE *AddRef )( 
             ID3DDestructionNotifier * This);
         
+        DECLSPEC_XFGVIRT(IUnknown, Release)
         ULONG ( STDMETHODCALLTYPE *Release )( 
             ID3DDestructionNotifier * This);
         
+        DECLSPEC_XFGVIRT(ID3DDestructionNotifier, RegisterDestructionCallback)
         HRESULT ( STDMETHODCALLTYPE *RegisterDestructionCallback )( 
             ID3DDestructionNotifier * This,
             /* [annotation] */ 
@@ -568,6 +571,7 @@ EXTERN_C const IID IID_ID3DDestructionNotifier;
             /* [annotation] */ 
             _Out_  UINT *pCallbackID);
         
+        DECLSPEC_XFGVIRT(ID3DDestructionNotifier, UnregisterDestructionCallback)
         HRESULT ( STDMETHODCALLTYPE *UnregisterDestructionCallback )( 
             ID3DDestructionNotifier * This,
             /* [annotation] */ 
@@ -732,6 +736,11 @@ enum _D3D_SHADER_VARIABLE_TYPE
         D3D_SVT_MIN12INT	= 55,
         D3D_SVT_MIN16INT	= 56,
         D3D_SVT_MIN16UINT	= 57,
+        D3D_SVT_INT16	= 58,
+        D3D_SVT_UINT16	= 59,
+        D3D_SVT_FLOAT16	= 60,
+        D3D_SVT_INT64	= 61,
+        D3D_SVT_UINT64	= 62,
         D3D10_SVT_VOID	= D3D_SVT_VOID,
         D3D10_SVT_BOOL	= D3D_SVT_BOOL,
         D3D10_SVT_INT	= D3D_SVT_INT,
@@ -819,6 +828,8 @@ enum _D3D_SHADER_INPUT_TYPE
         D3D_SIT_UAV_APPEND_STRUCTURED	= ( D3D_SIT_UAV_RWBYTEADDRESS + 1 ) ,
         D3D_SIT_UAV_CONSUME_STRUCTURED	= ( D3D_SIT_UAV_APPEND_STRUCTURED + 1 ) ,
         D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER	= ( D3D_SIT_UAV_CONSUME_STRUCTURED + 1 ) ,
+        D3D_SIT_RTACCELERATIONSTRUCTURE	= ( D3D_SIT_UAV_RWSTRUCTURED_WITH_COUNTER + 1 ) ,
+        D3D_SIT_UAV_FEEDBACKTEXTURE	= ( D3D_SIT_RTACCELERATIONSTRUCTURE + 1 ) ,
         D3D10_SIT_CBUFFER	= D3D_SIT_CBUFFER,
         D3D10_SIT_TBUFFER	= D3D_SIT_TBUFFER,
         D3D10_SIT_TEXTURE	= D3D_SIT_TEXTURE,
@@ -876,6 +887,9 @@ enum D3D_NAME
         D3D_NAME_FINAL_TRI_INSIDE_TESSFACTOR	= 14,
         D3D_NAME_FINAL_LINE_DETAIL_TESSFACTOR	= 15,
         D3D_NAME_FINAL_LINE_DENSITY_TESSFACTOR	= 16,
+        D3D_NAME_BARYCENTRICS	= 23,
+        D3D_NAME_SHADINGRATE	= 24,
+        D3D_NAME_CULLPRIMITIVE	= 25,
         D3D_NAME_TARGET	= 64,
         D3D_NAME_DEPTH	= 65,
         D3D_NAME_COVERAGE	= 66,
@@ -906,7 +920,10 @@ enum D3D_NAME
         D3D11_NAME_DEPTH_GREATER_EQUAL	= D3D_NAME_DEPTH_GREATER_EQUAL,
         D3D11_NAME_DEPTH_LESS_EQUAL	= D3D_NAME_DEPTH_LESS_EQUAL,
         D3D11_NAME_STENCIL_REF	= D3D_NAME_STENCIL_REF,
-        D3D11_NAME_INNER_COVERAGE	= D3D_NAME_INNER_COVERAGE
+        D3D11_NAME_INNER_COVERAGE	= D3D_NAME_INNER_COVERAGE,
+        D3D12_NAME_BARYCENTRICS	= D3D_NAME_BARYCENTRICS,
+        D3D12_NAME_SHADINGRATE	= D3D_NAME_SHADINGRATE,
+        D3D12_NAME_CULLPRIMITIVE	= D3D_NAME_CULLPRIMITIVE
     } 	D3D_NAME;
 
 typedef 
@@ -1027,9 +1044,50 @@ enum _D3D_PARAMETER_FLAGS
         D3D_PF_FORCE_DWORD	= 0x7fffffff
     } 	D3D_PARAMETER_FLAGS;
 
+typedef 
+enum D3D_FORMAT_LAYOUT
+    {
+        D3DFL_STANDARD	= 0,
+        D3DFL_CUSTOM	= -1
+    } 	D3D_FORMAT_LAYOUT;
+
+typedef 
+enum D3D_FORMAT_TYPE_LEVEL
+    {
+        D3DFTL_NO_TYPE	= 0,
+        D3DFTL_PARTIAL_TYPE	= -2,
+        D3DFTL_FULL_TYPE	= -1
+    } 	D3D_FORMAT_TYPE_LEVEL;
+
+typedef 
+enum D3D_FORMAT_COMPONENT_NAME
+    {
+        D3DFCN_R	= -4,
+        D3DFCN_G	= -3,
+        D3DFCN_B	= -2,
+        D3DFCN_A	= -1,
+        D3DFCN_D	= 0,
+        D3DFCN_S	= 1,
+        D3DFCN_X	= 2
+    } 	D3D_FORMAT_COMPONENT_NAME;
+
+typedef 
+enum D3D_FORMAT_COMPONENT_INTERPRETATION
+    {
+        D3DFCI_TYPELESS	= 0,
+        D3DFCI_FLOAT	= -4,
+        D3DFCI_SNORM	= -3,
+        D3DFCI_UNORM	= -2,
+        D3DFCI_SINT	= -1,
+        D3DFCI_UINT	= 1,
+        D3DFCI_UNORM_SRGB	= 2,
+        D3DFCI_BIASED_FIXED_2_8	= 3
+    } 	D3D_FORMAT_COMPONENT_INTERPRETATION;
+
 DEFINE_GUID(WKPDID_D3DDebugObjectName,0x429b8c22,0x9188,0x4b0c,0x87,0x42,0xac,0xb0,0xbf,0x85,0xc2,0x00);
 DEFINE_GUID(WKPDID_D3DDebugObjectNameW,0x4cca5fd8,0x921f,0x42c8,0x85,0x66,0x70,0xca,0xf2,0xa9,0xb7,0x41);
 DEFINE_GUID(WKPDID_CommentStringW,0xd0149dc0,0x90e8,0x4ec8,0x81, 0x44, 0xe9, 0x00, 0xad, 0x26, 0x6b, 0xb2);
+DEFINE_GUID(WKPDID_D3D12UniqueObjectId, 0x1b39de15, 0xec04, 0x4bae, 0xba, 0x4d, 0x8c, 0xef, 0x79, 0xfc, 0x04, 0xc1);
 #define D3D_SET_OBJECT_NAME_N_A(pObject, Chars, pName) (pObject)->SetPrivateData(WKPDID_D3DDebugObjectName, Chars, pName)
 #define D3D_SET_OBJECT_NAME_A(pObject, pName) D3D_SET_OBJECT_NAME_N_A(pObject, lstrlenA(pName), pName)
 #define D3D_SET_OBJECT_NAME_N_W(pObject, Chars, pName) (pObject)->SetPrivateData(WKPDID_D3DDebugObjectNameW, Chars*2, pName)
@@ -1038,6 +1096,8 @@ DEFINE_GUID(WKPDID_CommentStringW,0xd0149dc0,0x90e8,0x4ec8,0x81, 0x44, 0xe9, 0x0
 #define D3D_COMPONENT_MASK_Y   2
 #define D3D_COMPONENT_MASK_Z   4
 #define D3D_COMPONENT_MASK_W   8
+DEFINE_GUID(D3D_TEXTURE_LAYOUT_ROW_MAJOR,0xb5dc234f,0x72bb,0x4bec,0x97,0x05,0x8c,0xf2,0x58,0xdf,0x6b,0x6c);
+DEFINE_GUID(D3D_TEXTURE_LAYOUT_64KB_STANDARD_SWIZZLE,0x4c0f29e3,0x3f5f,0x4d35,0x84,0xc9,0xbc,0x09,0x83,0xb6,0x2c,0x28);
 
 
 extern RPC_IF_HANDLE __MIDL_itf_d3dcommon_0000_0002_v0_0_c_ifspec;

3rdparty/dxsdk/include/d3dx12.h → 3rdparty/directx-headers/include/directx/d3dx12.h

@@ -1349,13 +1349,13 @@ namespace MinGW_Workaround
 {
 	inline D3D12_RESOURCE_DESC ID3D12ResourceGetDesc(ID3D12Resource* _resource)
 	{
+#if BX_COMPILER_MSVC
+		return _resource->GetDesc();
+#else
 		D3D12_RESOURCE_DESC desc;
-		union {
-			D3D12_RESOURCE_DESC (STDMETHODCALLTYPE ID3D12Resource::*w)();
-			void (STDMETHODCALLTYPE ID3D12Resource::*f)(D3D12_RESOURCE_DESC *);
-		} conversion = { &ID3D12Resource::GetDesc };
-		(_resource->*conversion.f)(&desc);
+		_resource->GetDesc(&desc);
 		return desc;
+#endif // BX_COMPILER_MSVC
 	}
 }
 

3rdparty/directx-headers/include/directx/dxcore.h

@@ -0,0 +1,41 @@
+/************************************************************
+*                                                           *
+* Copyright (c) Microsoft Corporation.                      *
+* Licensed under the MIT license.                           *
+*                                                           *
+************************************************************/
+
+#ifndef _DXCOREEXTMODULE_H_
+#define _DXCOREEXTMODULE_H_
+
+#include <winapifamily.h>
+#include "dxcore_interface.h"
+
+#pragma region Application Family or OneCore Family
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM)
+
+#if (_WIN32_WINNT >= _WIN32_WINNT_WIN10)
+
+STDAPI
+DXCoreCreateAdapterFactory(
+    REFIID riid,
+    _COM_Outptr_ void** ppvFactory
+);
+
+template <class T>
+HRESULT
+DXCoreCreateAdapterFactory(
+    _COM_Outptr_ T** ppvFactory
+)
+{
+    return DXCoreCreateAdapterFactory(IID_PPV_ARGS(ppvFactory));
+}
+
+#endif // (_WIN32_WINNT >= _WIN32_WINNT_WIN10)
+
+#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP | WINAPI_PARTITION_SYSTEM) */
+#pragma endregion
+
+#endif // _DXCOREEXTMODULE_H_
+
+

3rdparty/directx-headers/include/directx/dxcore_interface.h

@@ -0,0 +1,316 @@
+//
+// DXCore Interface
+// Copyright (C) Microsoft Corporation.
+// Licensed under the MIT license.
+//
+
+#ifndef __dxcore_interface_h__
+#define __dxcore_interface_h__
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif /*COM_NO_WINDOWS_H*/
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+
+#define _FACDXCORE    0x880
+#define MAKE_DXCORE_HRESULT( code )     MAKE_HRESULT( 1, _FACDXCORE, code )
+
+enum class DXCoreAdapterProperty : uint32_t
+{
+    InstanceLuid = 0,
+    DriverVersion = 1,
+    DriverDescription = 2,
+    HardwareID = 3, // Use HardwareIDParts instead, if available.
+    KmdModelVersion = 4,
+    ComputePreemptionGranularity = 5,
+    GraphicsPreemptionGranularity = 6,
+    DedicatedAdapterMemory = 7,
+    DedicatedSystemMemory = 8,
+    SharedSystemMemory = 9,
+    AcgCompatible = 10,
+    IsHardware = 11,
+    IsIntegrated = 12,
+    IsDetachable = 13,
+    HardwareIDParts = 14
+};
+
+enum class DXCoreAdapterState : uint32_t
+{
+    IsDriverUpdateInProgress = 0,
+    AdapterMemoryBudget = 1
+};
+
+enum class DXCoreSegmentGroup : uint32_t
+{
+    Local = 0,
+    NonLocal = 1
+};
+
+enum class DXCoreNotificationType : uint32_t
+{
+    AdapterListStale = 0,
+    AdapterNoLongerValid = 1,
+    AdapterBudgetChange = 2,
+    AdapterHardwareContentProtectionTeardown = 3
+};
+
+enum class DXCoreAdapterPreference : uint32_t
+{
+    Hardware = 0,
+    MinimumPower = 1,
+    HighPerformance = 2
+};
+
+struct DXCoreHardwareID
+{
+    uint32_t vendorID;
+    uint32_t deviceID;
+    uint32_t subSysID;
+    uint32_t revision;
+};
+
+struct DXCoreHardwareIDParts
+{
+    uint32_t vendorID;
+    uint32_t deviceID;
+    uint32_t subSystemID;
+    uint32_t subVendorID;
+    uint32_t revisionID;
+};
+
+struct DXCoreAdapterMemoryBudgetNodeSegmentGroup
+{
+    uint32_t nodeIndex;
+    DXCoreSegmentGroup segmentGroup;
+};
+
+struct DXCoreAdapterMemoryBudget
+{
+    uint64_t budget;
+    uint64_t currentUsage;
+    uint64_t availableForReservation;
+    uint64_t currentReservation;
+};
+
+typedef void (STDMETHODCALLTYPE *PFN_DXCORE_NOTIFICATION_CALLBACK)(
+    DXCoreNotificationType notificationType,
+    _In_ IUnknown *object,
+    _In_opt_ void *context);
+
+static_assert(sizeof(bool) == 1, "bool assumed as one byte");
+
+DEFINE_GUID(IID_IDXCoreAdapterFactory, 0x78ee5945, 0xc36e, 0x4b13, 0xa6, 0x69, 0x00, 0x5d, 0xd1, 0x1c, 0x0f, 0x06);
+DEFINE_GUID(IID_IDXCoreAdapterList, 0x526c7776, 0x40e9, 0x459b, 0xb7, 0x11, 0xf3, 0x2a, 0xd7, 0x6d, 0xfc, 0x28);
+DEFINE_GUID(IID_IDXCoreAdapter, 0xf0db4c7f, 0xfe5a, 0x42a2, 0xbd, 0x62, 0xf2, 0xa6, 0xcf, 0x6f, 0xc8, 0x3e);
+DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D11_GRAPHICS, 0x8c47866b, 0x7583, 0x450d, 0xf0, 0xf0, 0x6b, 0xad, 0xa8, 0x95, 0xaf, 0x4b);
+DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D12_GRAPHICS, 0x0c9ece4d, 0x2f6e, 0x4f01, 0x8c, 0x96, 0xe8, 0x9e, 0x33, 0x1b, 0x47, 0xb1);
+DEFINE_GUID(DXCORE_ADAPTER_ATTRIBUTE_D3D12_CORE_COMPUTE, 0x248e2800, 0xa793, 0x4724, 0xab, 0xaa, 0x23, 0xa6, 0xde, 0x1b, 0xe0, 0x90);
+
+/* interface IDXCoreAdapter */
+MIDL_INTERFACE("f0db4c7f-fe5a-42a2-bd62-f2a6cf6fc83e")
+IDXCoreAdapter : public IUnknown
+{
+public:
+    virtual bool STDMETHODCALLTYPE IsValid() = 0;
+
+    virtual bool STDMETHODCALLTYPE IsAttributeSupported( 
+        REFGUID attributeGUID) = 0;
+
+    virtual bool STDMETHODCALLTYPE IsPropertySupported( 
+        DXCoreAdapterProperty property) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE GetProperty( 
+        DXCoreAdapterProperty property,
+        size_t bufferSize,
+        _Out_writes_bytes_(bufferSize)  void *propertyData) = 0;
+
+    template <class T>
+    HRESULT GetProperty( 
+        DXCoreAdapterProperty property,
+        _Out_writes_bytes_(sizeof(T))  T *propertyData)
+    {
+        return GetProperty(property,
+                           sizeof(T),
+                           (void*)propertyData);
+    }
+
+    virtual HRESULT STDMETHODCALLTYPE GetPropertySize( 
+        DXCoreAdapterProperty property,
+        _Out_ size_t *bufferSize) = 0;
+
+    virtual bool STDMETHODCALLTYPE IsQueryStateSupported( 
+        DXCoreAdapterState property) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE QueryState( 
+        DXCoreAdapterState state,
+        size_t inputStateDetailsSize,
+        _In_reads_bytes_opt_(inputStateDetailsSize) const void *inputStateDetails,
+        size_t outputBufferSize,
+        _Out_writes_bytes_(outputBufferSize) void *outputBuffer) = 0;
+
+    template <class T1, class T2>
+    HRESULT QueryState( 
+        DXCoreAdapterState state,
+        _In_reads_bytes_opt_(sizeof(T1)) const T1 *inputStateDetails,
+        _Out_writes_bytes_(sizeof(T2)) T2 *outputBuffer)
+    {
+        return QueryState(state,
+                          sizeof(T1),
+                          (const void*)inputStateDetails,
+                          sizeof(T2),
+                          (void*)outputBuffer);
+    }
+
+    template <class T>
+    HRESULT QueryState( 
+        DXCoreAdapterState state,
+        _Out_writes_bytes_(sizeof(T)) T *outputBuffer)
+    {
+        return QueryState(state,
+                          0,
+                          nullptr,
+                          sizeof(T),
+                          (void*)outputBuffer);
+    }
+
+    virtual bool STDMETHODCALLTYPE IsSetStateSupported( 
+        DXCoreAdapterState property) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE SetState( 
+        DXCoreAdapterState state,
+        size_t inputStateDetailsSize,
+        _In_reads_bytes_opt_(inputStateDetailsSize) const void *inputStateDetails,
+        size_t inputDataSize,
+        _In_reads_bytes_(inputDataSize) const void *inputData) = 0;
+
+    template <class T1, class T2>
+    HRESULT SetState( 
+        DXCoreAdapterState state,
+        const T1 *inputStateDetails,
+        const T2 *inputData)
+    {
+        return SetState(state,
+                        sizeof(T1),
+                        (const void*)inputStateDetails,
+                        sizeof(T2),
+                        (const void*)inputData);
+    }
+
+    virtual HRESULT STDMETHODCALLTYPE GetFactory(
+        REFIID riid,
+        _COM_Outptr_ void** ppvFactory
+    ) = 0;
+
+    template <class T>
+    HRESULT GetFactory(
+        _COM_Outptr_ T** ppvFactory
+    )
+    {
+        return GetFactory(IID_PPV_ARGS(ppvFactory));
+    }
+};
+
+/* interface IDXCoreAdapterList */
+MIDL_INTERFACE("526c7776-40e9-459b-b711-f32ad76dfc28")
+IDXCoreAdapterList : public IUnknown
+{
+public:
+    virtual HRESULT STDMETHODCALLTYPE GetAdapter( 
+        uint32_t index,
+        REFIID riid,
+        _COM_Outptr_ void **ppvAdapter) = 0;
+
+    template<class T>
+    HRESULT STDMETHODCALLTYPE GetAdapter( 
+        uint32_t index,
+        _COM_Outptr_ T **ppvAdapter)
+    {
+        return GetAdapter(index,
+                          IID_PPV_ARGS(ppvAdapter));
+    }
+
+    virtual uint32_t STDMETHODCALLTYPE GetAdapterCount() = 0;
+
+    virtual bool STDMETHODCALLTYPE IsStale() = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE GetFactory(
+        REFIID riid,
+        _COM_Outptr_ void** ppvFactory
+    ) = 0;
+
+    template <class T>
+    HRESULT GetFactory(
+        _COM_Outptr_ T** ppvFactory
+    )
+    {
+        return GetFactory(IID_PPV_ARGS(ppvFactory));
+    }
+
+    virtual HRESULT STDMETHODCALLTYPE Sort(
+        uint32_t numPreferences,
+        _In_reads_(numPreferences) const DXCoreAdapterPreference* preferences) = 0;
+
+    virtual bool STDMETHODCALLTYPE IsAdapterPreferenceSupported( 
+        DXCoreAdapterPreference preference) = 0;
+};
+
+/* interface IDXCoreAdapterFactory */
+MIDL_INTERFACE("78ee5945-c36e-4b13-a669-005dd11c0f06")
+IDXCoreAdapterFactory : public IUnknown
+{
+public:
+
+    virtual HRESULT STDMETHODCALLTYPE CreateAdapterList( 
+        uint32_t numAttributes,
+        _In_reads_(numAttributes) const GUID *filterAttributes,
+        REFIID riid,
+        _COM_Outptr_ void **ppvAdapterList) = 0;
+
+    template<class T>
+    HRESULT STDMETHODCALLTYPE CreateAdapterList( 
+        uint32_t numAttributes,
+        _In_reads_(numAttributes) const GUID *filterAttributes,
+        _COM_Outptr_ T **ppvAdapterList)
+    {
+        return CreateAdapterList(numAttributes,
+                                 filterAttributes,
+                                 IID_PPV_ARGS(ppvAdapterList));
+    }
+
+    virtual HRESULT STDMETHODCALLTYPE GetAdapterByLuid( 
+        const LUID &adapterLUID,
+        REFIID riid,
+        _COM_Outptr_ void **ppvAdapter) = 0;
+
+    template<class T>
+    HRESULT STDMETHODCALLTYPE GetAdapterByLuid( 
+        const LUID &adapterLUID,
+        _COM_Outptr_ T **ppvAdapter)
+    {
+        return GetAdapterByLuid(adapterLUID,
+                                IID_PPV_ARGS(ppvAdapter));
+    }
+
+    virtual bool STDMETHODCALLTYPE IsNotificationTypeSupported( 
+        DXCoreNotificationType notificationType) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE RegisterEventNotification( 
+        _In_ IUnknown *dxCoreObject,
+        DXCoreNotificationType notificationType,
+        _In_ PFN_DXCORE_NOTIFICATION_CALLBACK callbackFunction,
+        _In_opt_ void *callbackContext,
+        _Out_ uint32_t *eventCookie) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE UnregisterEventNotification( 
+        uint32_t eventCookie) = 0;
+};
+
+#endif // __cplusplus
+
+#endif // __dxcore_interface_h__
+
+

3rdparty/dxsdk/include/dxgicommon.h → 3rdparty/directx-headers/include/directx/dxgicommon.h

@@ -1,5 +1,6 @@
 //
-//    Copyright (C) Microsoft.  All rights reserved.
+//    Copyright (C) Microsoft Corporation.
+//    Licensed under the MIT license
 //
 
 #ifndef __dxgicommon_h__

3rdparty/directx-headers/include/directx/dxgiformat.h

@@ -0,0 +1,142 @@
+//
+//    Copyright (C) Microsoft Corporation.
+//    Licensed under the MIT license
+//
+
+#ifndef __dxgiformat_h__
+#define __dxgiformat_h__
+
+#define DXGI_FORMAT_DEFINED 1
+
+typedef enum DXGI_FORMAT
+{
+    DXGI_FORMAT_UNKNOWN	                                = 0,
+    DXGI_FORMAT_R32G32B32A32_TYPELESS                   = 1,
+    DXGI_FORMAT_R32G32B32A32_FLOAT                      = 2,
+    DXGI_FORMAT_R32G32B32A32_UINT                       = 3,
+    DXGI_FORMAT_R32G32B32A32_SINT                       = 4,
+    DXGI_FORMAT_R32G32B32_TYPELESS                      = 5,
+    DXGI_FORMAT_R32G32B32_FLOAT                         = 6,
+    DXGI_FORMAT_R32G32B32_UINT                          = 7,
+    DXGI_FORMAT_R32G32B32_SINT                          = 8,
+    DXGI_FORMAT_R16G16B16A16_TYPELESS                   = 9,
+    DXGI_FORMAT_R16G16B16A16_FLOAT                      = 10,
+    DXGI_FORMAT_R16G16B16A16_UNORM                      = 11,
+    DXGI_FORMAT_R16G16B16A16_UINT                       = 12,
+    DXGI_FORMAT_R16G16B16A16_SNORM                      = 13,
+    DXGI_FORMAT_R16G16B16A16_SINT                       = 14,
+    DXGI_FORMAT_R32G32_TYPELESS                         = 15,
+    DXGI_FORMAT_R32G32_FLOAT                            = 16,
+    DXGI_FORMAT_R32G32_UINT                             = 17,
+    DXGI_FORMAT_R32G32_SINT                             = 18,
+    DXGI_FORMAT_R32G8X24_TYPELESS                       = 19,
+    DXGI_FORMAT_D32_FLOAT_S8X24_UINT                    = 20,
+    DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS                = 21,
+    DXGI_FORMAT_X32_TYPELESS_G8X24_UINT                 = 22,
+    DXGI_FORMAT_R10G10B10A2_TYPELESS                    = 23,
+    DXGI_FORMAT_R10G10B10A2_UNORM                       = 24,
+    DXGI_FORMAT_R10G10B10A2_UINT                        = 25,
+    DXGI_FORMAT_R11G11B10_FLOAT                         = 26,
+    DXGI_FORMAT_R8G8B8A8_TYPELESS                       = 27,
+    DXGI_FORMAT_R8G8B8A8_UNORM                          = 28,
+    DXGI_FORMAT_R8G8B8A8_UNORM_SRGB                     = 29,
+    DXGI_FORMAT_R8G8B8A8_UINT                           = 30,
+    DXGI_FORMAT_R8G8B8A8_SNORM                          = 31,
+    DXGI_FORMAT_R8G8B8A8_SINT                           = 32,
+    DXGI_FORMAT_R16G16_TYPELESS                         = 33,
+    DXGI_FORMAT_R16G16_FLOAT                            = 34,
+    DXGI_FORMAT_R16G16_UNORM                            = 35,
+    DXGI_FORMAT_R16G16_UINT                             = 36,
+    DXGI_FORMAT_R16G16_SNORM                            = 37,
+    DXGI_FORMAT_R16G16_SINT                             = 38,
+    DXGI_FORMAT_R32_TYPELESS                            = 39,
+    DXGI_FORMAT_D32_FLOAT                               = 40,
+    DXGI_FORMAT_R32_FLOAT                               = 41,
+    DXGI_FORMAT_R32_UINT                                = 42,
+    DXGI_FORMAT_R32_SINT                                = 43,
+    DXGI_FORMAT_R24G8_TYPELESS                          = 44,
+    DXGI_FORMAT_D24_UNORM_S8_UINT                       = 45,
+    DXGI_FORMAT_R24_UNORM_X8_TYPELESS                   = 46,
+    DXGI_FORMAT_X24_TYPELESS_G8_UINT                    = 47,
+    DXGI_FORMAT_R8G8_TYPELESS                           = 48,
+    DXGI_FORMAT_R8G8_UNORM                              = 49,
+    DXGI_FORMAT_R8G8_UINT                               = 50,
+    DXGI_FORMAT_R8G8_SNORM                              = 51,
+    DXGI_FORMAT_R8G8_SINT                               = 52,
+    DXGI_FORMAT_R16_TYPELESS                            = 53,
+    DXGI_FORMAT_R16_FLOAT                               = 54,
+    DXGI_FORMAT_D16_UNORM                               = 55,
+    DXGI_FORMAT_R16_UNORM                               = 56,
+    DXGI_FORMAT_R16_UINT                                = 57,
+    DXGI_FORMAT_R16_SNORM                               = 58,
+    DXGI_FORMAT_R16_SINT                                = 59,
+    DXGI_FORMAT_R8_TYPELESS                             = 60,
+    DXGI_FORMAT_R8_UNORM                                = 61,
+    DXGI_FORMAT_R8_UINT                                 = 62,
+    DXGI_FORMAT_R8_SNORM                                = 63,
+    DXGI_FORMAT_R8_SINT                                 = 64,
+    DXGI_FORMAT_A8_UNORM                                = 65,
+    DXGI_FORMAT_R1_UNORM                                = 66,
+    DXGI_FORMAT_R9G9B9E5_SHAREDEXP                      = 67,
+    DXGI_FORMAT_R8G8_B8G8_UNORM                         = 68,
+    DXGI_FORMAT_G8R8_G8B8_UNORM                         = 69,
+    DXGI_FORMAT_BC1_TYPELESS                            = 70,
+    DXGI_FORMAT_BC1_UNORM                               = 71,
+    DXGI_FORMAT_BC1_UNORM_SRGB                          = 72,
+    DXGI_FORMAT_BC2_TYPELESS                            = 73,
+    DXGI_FORMAT_BC2_UNORM                               = 74,
+    DXGI_FORMAT_BC2_UNORM_SRGB                          = 75,
+    DXGI_FORMAT_BC3_TYPELESS                            = 76,
+    DXGI_FORMAT_BC3_UNORM                               = 77,
+    DXGI_FORMAT_BC3_UNORM_SRGB                          = 78,
+    DXGI_FORMAT_BC4_TYPELESS                            = 79,
+    DXGI_FORMAT_BC4_UNORM                               = 80,
+    DXGI_FORMAT_BC4_SNORM                               = 81,
+    DXGI_FORMAT_BC5_TYPELESS                            = 82,
+    DXGI_FORMAT_BC5_UNORM                               = 83,
+    DXGI_FORMAT_BC5_SNORM                               = 84,
+    DXGI_FORMAT_B5G6R5_UNORM                            = 85,
+    DXGI_FORMAT_B5G5R5A1_UNORM                          = 86,
+    DXGI_FORMAT_B8G8R8A8_UNORM                          = 87,
+    DXGI_FORMAT_B8G8R8X8_UNORM                          = 88,
+    DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM              = 89,
+    DXGI_FORMAT_B8G8R8A8_TYPELESS                       = 90,
+    DXGI_FORMAT_B8G8R8A8_UNORM_SRGB                     = 91,
+    DXGI_FORMAT_B8G8R8X8_TYPELESS                       = 92,
+    DXGI_FORMAT_B8G8R8X8_UNORM_SRGB                     = 93,
+    DXGI_FORMAT_BC6H_TYPELESS                           = 94,
+    DXGI_FORMAT_BC6H_UF16                               = 95,
+    DXGI_FORMAT_BC6H_SF16                               = 96,
+    DXGI_FORMAT_BC7_TYPELESS                            = 97,
+    DXGI_FORMAT_BC7_UNORM                               = 98,
+    DXGI_FORMAT_BC7_UNORM_SRGB                          = 99,
+    DXGI_FORMAT_AYUV                                    = 100,
+    DXGI_FORMAT_Y410                                    = 101,
+    DXGI_FORMAT_Y416                                    = 102,
+    DXGI_FORMAT_NV12                                    = 103,
+    DXGI_FORMAT_P010                                    = 104,
+    DXGI_FORMAT_P016                                    = 105,
+    DXGI_FORMAT_420_OPAQUE                              = 106,
+    DXGI_FORMAT_YUY2                                    = 107,
+    DXGI_FORMAT_Y210                                    = 108,
+    DXGI_FORMAT_Y216                                    = 109,
+    DXGI_FORMAT_NV11                                    = 110,
+    DXGI_FORMAT_AI44                                    = 111,
+    DXGI_FORMAT_IA44                                    = 112,
+    DXGI_FORMAT_P8                                      = 113,
+    DXGI_FORMAT_A8P8                                    = 114,
+    DXGI_FORMAT_B4G4R4A4_UNORM                          = 115,
+
+    DXGI_FORMAT_P208                                    = 130,
+    DXGI_FORMAT_V208                                    = 131,
+    DXGI_FORMAT_V408                                    = 132,
+
+
+    DXGI_FORMAT_SAMPLER_FEEDBACK_MIN_MIP_OPAQUE         = 189,
+    DXGI_FORMAT_SAMPLER_FEEDBACK_MIP_REGION_USED_OPAQUE = 190,
+
+
+    DXGI_FORMAT_FORCE_UINT                  = 0xffffffff
+} DXGI_FORMAT;
+
+#endif // __dxgiformat_h__

3rdparty/directx-headers/include/wsl/stubs/basetsd.h

@@ -0,0 +1,405 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+// These #defines prevent the idl-generated headers from trying to include
+// Windows.h from the SDK rather than this one.
+#define RPC_NO_WINDOWS_H
+#define COM_NO_WINDOWS_H
+
+// Allcaps type definitions
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <limits.h>
+
+// Note: using fixed-width here to match Windows widths
+// Specifically this is different for 'long' vs 'LONG'
+typedef uint8_t UINT8;
+typedef int8_t INT8;
+typedef uint16_t UINT16;
+typedef int16_t INT16;
+typedef uint32_t UINT32, UINT, ULONG, DWORD, BOOL, WINBOOL;
+typedef int32_t INT32, INT, LONG;
+typedef uint64_t UINT64, ULONG_PTR;
+typedef int64_t INT64, LONG_PTR;
+typedef void VOID, *HANDLE, *RPC_IF_HANDLE, *LPVOID;
+typedef const void *LPCVOID;
+typedef size_t SIZE_T;
+typedef float FLOAT;
+typedef double DOUBLE;
+typedef unsigned char BYTE;
+typedef int HWND;
+typedef int PALETTEENTRY;
+typedef int HDC;
+typedef uint16_t WORD;
+typedef void* PVOID;
+typedef char BOOLEAN;
+typedef uint64_t ULONGLONG;
+typedef uint16_t USHORT, *PUSHORT;
+typedef int64_t LONGLONG, *PLONGLONG;
+typedef int64_t LONG_PTR, *PLONG_PTR;
+typedef int64_t LONG64, *PLONG64;
+typedef uint64_t ULONG64, *PULONG64;
+typedef wchar_t WCHAR, *PWSTR;
+typedef uint8_t UCHAR, *PUCHAR;
+typedef uint64_t ULONG_PTR, *PULONG_PTR;
+typedef uint64_t UINT_PTR, *PUINT_PTR;
+typedef int64_t INT_PTR, *PINT_PTR;
+
+// Note: WCHAR is not the same between Windows and Linux, to enable
+// string manipulation APIs to work with resulting strings.
+// APIs to D3D/DXCore will work on Linux wchars, but beware with
+// interactions directly with the Windows kernel.
+typedef char CHAR, *PSTR, *LPSTR, TCHAR, *PTSTR;
+typedef const char *LPCSTR, *PCSTR, *LPCTSTR, *PCTSTR;
+typedef wchar_t WCHAR, *PWSTR, *LPWSTR, *PWCHAR;
+typedef const wchar_t *LPCWSTR, *PCWSTR;
+
+#undef LONG_MAX
+#define LONG_MAX INT_MAX
+#undef ULONG_MAX
+#define ULONG_MAX UINT_MAX
+
+// Misc defines
+#define MIDL_INTERFACE(x) interface
+#define __analysis_assume(x)
+#define TRUE 1u
+#define FALSE 0u
+#define DECLSPEC_UUID(x)
+#define DECLSPEC_NOVTABLE
+#define DECLSPEC_SELECTANY
+#ifdef __cplusplus
+#define EXTERN_C extern "C"
+#else
+#define EXTERN_C extern
+#endif
+#define APIENTRY
+#define OUT
+#define IN
+#define CONST const
+#define MAX_PATH 260
+#define GENERIC_ALL 0x10000000L
+#define C_ASSERT(expr) static_assert((expr))
+#define _countof(a) (sizeof(a) / sizeof(*(a)))
+
+typedef struct tagRECTL
+{
+    LONG left;
+    LONG top;
+    LONG right;
+    LONG bottom;
+} RECTL;
+
+typedef struct tagPOINT
+{
+    int x;
+    int y;
+} POINT;
+
+typedef struct _GUID {
+    uint32_t Data1;
+    uint16_t Data2;
+    uint16_t Data3;
+    uint8_t  Data4[ 8 ];
+} GUID;
+
+#ifdef INITGUID
+#ifdef __cplusplus
+#define DEFINE_GUID(name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) EXTERN_C const GUID DECLSPEC_SELECTANY name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
+#else
+#define DEFINE_GUID(name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) const GUID DECLSPEC_SELECTANY name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
+#endif
+#else
+#define DEFINE_GUID(name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8) EXTERN_C const GUID name
+#endif
+
+typedef GUID IID;
+typedef GUID UUID;
+typedef GUID CLSID;
+#ifdef __cplusplus
+#define REFGUID const GUID &
+#define REFIID const IID &
+#define REFCLSID const IID &
+
+__inline int InlineIsEqualGUID(REFGUID rguid1, REFGUID rguid2)
+{
+    return (
+        ((uint32_t *)&rguid1)[0] == ((uint32_t *)&rguid2)[0] &&
+        ((uint32_t *)&rguid1)[1] == ((uint32_t *)&rguid2)[1] &&
+        ((uint32_t *)&rguid1)[2] == ((uint32_t *)&rguid2)[2] &&
+        ((uint32_t *)&rguid1)[3] == ((uint32_t *)&rguid2)[3]);
+}
+
+inline bool operator==(REFGUID guidOne, REFGUID guidOther)
+{
+    return !!InlineIsEqualGUID(guidOne, guidOther);
+}
+
+inline bool operator!=(REFGUID guidOne, REFGUID guidOther)
+{
+    return !(guidOne == guidOther);
+}
+
+#else
+#define REFGUID const GUID *
+#define REFIID const IID *
+#define REFCLSID const IID *
+#endif
+
+// SAL annotations
+#define _In_
+#define _In_z_
+#define _In_opt_
+#define _In_opt_z_
+#define _In_reads_(x)
+#define _In_reads_opt_(x)
+#define _In_reads_bytes_(x)
+#define _In_reads_bytes_opt_(x)
+#define _In_range_(x, y)
+#define _In_bytecount_(x)
+#define _Out_
+#define _Out_opt_
+#define _Outptr_
+#define _Outptr_opt_result_z_
+#define _Outptr_opt_result_bytebuffer_(x)
+#define _COM_Outptr_
+#define _COM_Outptr_result_maybenull_
+#define _COM_Outptr_opt_
+#define _COM_Outptr_opt_result_maybenull_
+#define _Out_writes_(x)
+#define _Out_writes_z_(x)
+#define _Out_writes_opt_(x)
+#define _Out_writes_all_(x)
+#define _Out_writes_all_opt_(x)
+#define _Out_writes_to_opt_(x, y)
+#define _Out_writes_bytes_(x)
+#define _Out_writes_bytes_all_(x)
+#define _Out_writes_bytes_all_opt_(x)
+#define _Out_writes_bytes_opt_(x)
+#define _Inout_
+#define _Inout_opt_
+#define _Inout_updates_(x)
+#define _Inout_updates_bytes_(x)
+#define _Field_size_(x)
+#define _Field_size_opt_(x)
+#define _Field_size_bytes_(x)
+#define _Field_size_full_(x)
+#define _Field_size_full_opt_(x)
+#define _Field_size_bytes_full_(x)
+#define _Field_size_bytes_full_opt_(x)
+#define _Field_size_bytes_part_(x, y)
+#define _Field_range_(x, y)
+#define _Field_z_
+#define _Check_return_
+#define _IRQL_requires_(x)
+#define _IRQL_requires_min_(x)
+#define _IRQL_requires_max_(x)
+#define _At_(x, y)
+#define _Always_(x)
+#define _Return_type_success_(x)
+#define _Translates_Win32_to_HRESULT_(x)
+#define _Maybenull_
+#define _Outptr_result_maybenull_
+#define _Outptr_result_nullonfailure_
+#define _Analysis_assume_(x)
+#define _Success_(x)
+#define _In_count_(x)
+#define _In_opt_count_(x)
+#define _Use_decl_annotations_
+#define _Null_terminated_
+
+// Calling conventions
+#define __cdecl
+#define __stdcall
+#define STDMETHODCALLTYPE
+#define STDAPICALLTYPE
+#define STDAPI EXTERN_C HRESULT STDAPICALLTYPE
+#define WINAPI
+
+#define interface struct
+#if defined (__cplusplus) && !defined (CINTERFACE)
+#define STDMETHOD(method) virtual HRESULT STDMETHODCALLTYPE method
+#define STDMETHOD_(type, method) virtual type STDMETHODCALLTYPE method
+#define PURE = 0
+#define THIS_
+#define THIS void
+#define DECLARE_INTERFACE(iface) interface DECLSPEC_NOVTABLE iface
+#define DECLARE_INTERFACE_(iface, baseiface) interface DECLSPEC_NOVTABLE iface : public baseiface
+
+interface IUnknown;
+extern "C++"
+{
+    template<typename T> void** IID_PPV_ARGS_Helper(T** pp)
+    {
+        (void)static_cast<IUnknown*>(*pp);
+        return reinterpret_cast<void**>(pp);
+    }
+}
+#define IID_PPV_ARGS(ppType) __uuidof (**(ppType)), IID_PPV_ARGS_Helper (ppType)
+#else
+#define STDMETHOD(method) HRESULT (STDMETHODCALLTYPE *method)
+#define STDMETHOD_(type, method) type (STDMETHODCALLTYPE *method)
+#define PURE
+#define THIS_ INTERFACE *This,
+#define THIS INTERFACE *This
+#ifdef CONST_VTABLE
+#define DECLARE_INTERFACE(iface) typedef interface iface { const struct iface##Vtbl *lpVtbl; } iface; typedef const struct iface##Vtbl iface##Vtbl; const struct iface##Vtbl
+#else
+#define DECLARE_INTERFACE(iface) typedef interface iface { struct iface##Vtbl *lpVtbl; } iface; typedef struct iface##Vtbl iface##Vtbl; struct iface##Vtbl
+#endif
+#define DECLARE_INTERFACE_(iface, baseiface) DECLARE_INTERFACE (iface)
+#endif
+
+#define IFACEMETHOD(method) /*override*/ STDMETHOD (method)
+#define IFACEMETHOD_(type, method) /*override*/ STDMETHOD_(type, method)
+#ifndef BEGIN_INTERFACE
+#define BEGIN_INTERFACE
+#define END_INTERFACE
+#endif
+
+// Error codes
+typedef LONG HRESULT;
+#define SUCCEEDED(hr)  (((HRESULT)(hr)) >= 0)
+#define FAILED(hr)     (((HRESULT)(hr)) < 0)
+#define S_OK           ((HRESULT)0L)
+#define S_FALSE        ((HRESULT)1L)
+#define E_NOTIMPL      ((HRESULT)0x80004001L)
+#define E_OUTOFMEMORY  ((HRESULT)0x8007000EL)
+#define E_INVALIDARG   ((HRESULT)0x80070057L)
+#define E_NOINTERFACE  ((HRESULT)0x80004002L)
+#define E_POINTER      ((HRESULT)0x80004003L)
+#define E_HANDLE       ((HRESULT)0x80070006L)
+#define E_ABORT        ((HRESULT)0x80004004L)
+#define E_FAIL         ((HRESULT)0x80004005L)
+#define E_ACCESSDENIED ((HRESULT)0x80070005L)
+#define E_UNEXPECTED   ((HRESULT)0x8000FFFFL)
+#define DXGI_ERROR_INVALID_CALL ((HRESULT)0x887A0001L)
+#define DXGI_ERROR_NOT_FOUND ((HRESULT)0x887A0002L)
+#define DXGI_ERROR_MORE_DATA ((HRESULT)0x887A0003L)
+#define DXGI_ERROR_UNSUPPORTED ((HRESULT)0x887A0004L)
+#define DXGI_ERROR_DEVICE_REMOVED ((HRESULT)0x887A0005L)
+#define DXGI_ERROR_DEVICE_HUNG ((HRESULT)0x887A0006L)
+#define DXGI_ERROR_DEVICE_RESET ((HRESULT)0x887A0007L)
+#define DXGI_ERROR_DRIVER_INTERNAL_ERROR ((HRESULT)0x887A0020L)
+
+typedef struct _LUID
+{
+    ULONG LowPart;
+    LONG HighPart;
+} LUID;
+
+typedef struct _RECT
+{
+    int left;
+    int top;
+    int right;
+    int bottom;
+} RECT;
+
+typedef union _LARGE_INTEGER {
+  struct {
+    uint32_t LowPart;
+    uint32_t HighPart;
+  } u;
+  int64_t QuadPart;
+} LARGE_INTEGER;
+typedef LARGE_INTEGER *PLARGE_INTEGER;
+
+typedef union _ULARGE_INTEGER {
+  struct {
+    uint32_t LowPart;
+    uint32_t HighPart;
+  } u;
+  uint64_t QuadPart;
+} ULARGE_INTEGER;
+typedef ULARGE_INTEGER *PULARGE_INTEGER;
+
+#define DECLARE_HANDLE(name)                                                   \
+  struct name##__ {                                                            \
+    int unused;                                                                \
+  };                                                                           \
+  typedef struct name##__ *name
+
+typedef struct _SECURITY_ATTRIBUTES {
+    DWORD nLength;
+    LPVOID lpSecurityDescriptor;
+    WINBOOL bInheritHandle;
+} SECURITY_ATTRIBUTES;
+
+struct STATSTG;
+
+#ifdef __cplusplus
+// ENUM_FLAG_OPERATORS
+// Define operator overloads to enable bit operations on enum values that are
+// used to define flags. Use DEFINE_ENUM_FLAG_OPERATORS(YOUR_TYPE) to enable these
+// operators on YOUR_TYPE.
+extern "C++" {
+    template <size_t S>
+    struct _ENUM_FLAG_INTEGER_FOR_SIZE;
+
+    template <>
+    struct _ENUM_FLAG_INTEGER_FOR_SIZE<1>
+    {
+        typedef int8_t type;
+    };
+
+    template <>
+    struct _ENUM_FLAG_INTEGER_FOR_SIZE<2>
+    {
+        typedef int16_t type;
+    };
+
+    template <>
+    struct _ENUM_FLAG_INTEGER_FOR_SIZE<4>
+    {
+        typedef int32_t type;
+    };
+
+    template <>
+    struct _ENUM_FLAG_INTEGER_FOR_SIZE<8>
+    {
+        typedef int64_t type;
+    };
+
+    // used as an approximation of std::underlying_type<T>
+    template <class T>
+    struct _ENUM_FLAG_SIZED_INTEGER
+    {
+        typedef typename _ENUM_FLAG_INTEGER_FOR_SIZE<sizeof(T)>::type type;
+    };
+
+}
+#define DEFINE_ENUM_FLAG_OPERATORS(ENUMTYPE) \
+extern "C++" { \
+inline constexpr ENUMTYPE operator | (ENUMTYPE a, ENUMTYPE b) { return ENUMTYPE(((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)a) | ((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)b)); } \
+inline ENUMTYPE &operator |= (ENUMTYPE &a, ENUMTYPE b) { return (ENUMTYPE &)(((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type &)a) |= ((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)b)); } \
+inline constexpr ENUMTYPE operator & (ENUMTYPE a, ENUMTYPE b) { return ENUMTYPE(((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)a) & ((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)b)); } \
+inline ENUMTYPE &operator &= (ENUMTYPE &a, ENUMTYPE b) { return (ENUMTYPE &)(((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type &)a) &= ((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)b)); } \
+inline constexpr ENUMTYPE operator ~ (ENUMTYPE a) { return ENUMTYPE(~((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)a)); } \
+inline constexpr ENUMTYPE operator ^ (ENUMTYPE a, ENUMTYPE b) { return ENUMTYPE(((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)a) ^ ((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)b)); } \
+inline ENUMTYPE &operator ^= (ENUMTYPE &a, ENUMTYPE b) { return (ENUMTYPE &)(((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type &)a) ^= ((_ENUM_FLAG_SIZED_INTEGER<ENUMTYPE>::type)b)); } \
+}
+#else
+#define DEFINE_ENUM_FLAG_OPERATORS(ENUMTYPE) /* */
+#endif
+
+// D3DX12 uses these
+#include <stdlib.h>
+#define HeapAlloc(heap, flags, size) malloc(size)
+#define HeapFree(heap, flags, ptr) free(ptr)
+
+#if defined(lint)
+// Note: lint -e530 says don't complain about uninitialized variables for
+// this variable.  Error 527 has to do with unreachable code.
+// -restore restores checking to the -save state
+#define UNREFERENCED_PARAMETER(P) \
+    /*lint -save -e527 -e530 */ \
+    { \
+        (P) = (P); \
+    } \
+    /*lint -restore */
+#else
+#define UNREFERENCED_PARAMETER(P) (P)
+#endif

3rdparty/directx-headers/include/wsl/stubs/oaidl.h

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// Stub header to satisfy d3d12.h include
+#pragma once

3rdparty/directx-headers/include/wsl/stubs/ocidl.h

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// Stub header to satisfy d3d12.h include
+#pragma once

3rdparty/directx-headers/include/wsl/stubs/rpc.h

@@ -0,0 +1,5 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// Stub header to satisfy d3d12.h include
+#pragma once

3rdparty/directx-headers/include/wsl/stubs/rpcndr.h

@@ -0,0 +1,78 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// Stub header to satisfy d3d12.h include
+#pragma once
+
+#include "basetsd.h"
+
+#define __RPCNDR_H_VERSION__
+
+#ifdef CONST_VTABLE
+#define CONST_VTBL const
+#else
+#define CONST_VTBL
+#endif
+
+/* Macros for __uuidof template-based emulation */
+#if defined(__cplusplus)
+#if __cpp_constexpr >= 200704l && __cpp_inline_variables >= 201606L
+#define __wsl_stub_uuidof_use_constexpr 1
+#else
+#define __wsl_stub_uuidof_use_constexpr 0
+#endif
+#ifndef __GNUC__
+#error "Only support for compilers that support for `GNU C++ extension`"
+#endif
+extern "C++"                                                         {
+#if __wsl_stub_uuidof_use_constexpr
+    __extension__ template<typename T> struct __wsl_stub_uuidof_s;
+    __extension__ template<typename T> constexpr const GUID &__wsl_stub_uuidof();
+#else
+    __extension__ template<typename T> const GUID &__wsl_stub_uuidof();
+#endif
+}
+
+#if __wsl_stub_uuidof_use_constexpr
+#define __CRT_UUID_DECL(type, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+    extern "C++"                                                         \
+    {                                                                    \
+        template <>                                                      \
+        struct __wsl_stub_uuidof_s<type>                                 \
+        {                                                                \
+            static constexpr IID __uuid_inst = {                         \
+                l, w1, w2, {b1, b2, b3, b4, b5, b6, b7, b8}};            \
+        };                                                               \
+        template <>                                                      \
+        constexpr const GUID &__wsl_stub_uuidof<type>()                  \
+        {                                                                \
+            return __wsl_stub_uuidof_s<type>::__uuid_inst;               \
+        }                                                                \
+        template <>                                                      \
+        constexpr const GUID &__wsl_stub_uuidof<type *>()                \
+        {                                                                \
+            return __wsl_stub_uuidof_s<type>::__uuid_inst;               \
+        }                                                                \
+    }
+#else
+#define __CRT_UUID_DECL(type, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+    extern "C++"                                                         \
+    {                                                                    \
+        template <>                                                      \
+        inline const GUID &__wsl_stub_uuidof<type>()                     \
+        {                                                                \
+            static const IID __uuid_inst = {                             \
+                l, w1, w2, {b1, b2, b3, b4, b5, b6, b7, b8}};            \
+            return __uuid_inst;                                          \
+        }                                                                \
+        template <>                                                      \
+        inline const GUID &__wsl_stub_uuidof<type *>()                   \
+        {                                                                \
+            return __wsl_stub_uuidof<type>();                            \
+        }                                                                \
+    }
+#endif
+#define __uuidof(type) __wsl_stub_uuidof<__typeof(type)>()
+#else
+#define __CRT_UUID_DECL(type, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8)
+#endif

3rdparty/directx-headers/include/wsl/stubs/unknwn.h

@@ -0,0 +1,3 @@
+#pragma once
+
+#include "unknwnbase.h"

3rdparty/directx-headers/include/wsl/stubs/unknwnbase.h

@@ -0,0 +1,124 @@
+/*-------------------------------------------------------------------------------------
+ *
+ * Copyright (c) Microsoft Corporation
+ * Licensed under the MIT license
+ *
+ *-------------------------------------------------------------------------------------*/
+
+/* this ALWAYS GENERATED file contains the definitions for the interfaces */
+
+/* File created by MIDL compiler version 8.01.0627 */
+
+/* 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 __unknwnbase_h__
+#define __unknwnbase_h__
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+#pragma once
+#endif
+
+/* Forward Declarations */
+
+#ifndef __IUnknown_FWD_DEFINED__
+#define __IUnknown_FWD_DEFINED__
+typedef interface IUnknown IUnknown;
+
+#endif 	/* __IUnknown_FWD_DEFINED__ */
+
+#ifndef __IUnknown_INTERFACE_DEFINED__
+#define __IUnknown_INTERFACE_DEFINED__
+
+/* interface IUnknown */
+/* [unique][uuid][object][local] */
+
+typedef /* [unique] */ IUnknown *LPUNKNOWN;
+
+EXTERN_C const IID IID_IUnknown;
+
+#if defined(__cplusplus) && !defined(CINTERFACE)
+extern "C++"
+{
+    MIDL_INTERFACE("00000000-0000-0000-c000-000000000046")
+    IUnknown
+    {
+        BEGIN_INTERFACE
+
+        virtual HRESULT STDMETHODCALLTYPE QueryInterface(
+            REFIID riid,
+            void **ppvObject) = 0;
+
+        virtual ULONG STDMETHODCALLTYPE AddRef() = 0;
+
+        virtual ULONG STDMETHODCALLTYPE Release() = 0;
+
+        template <class Q>
+        HRESULT
+            STDMETHODCALLTYPE
+            QueryInterface(_COM_Outptr_ Q * *pp)
+        {
+            return QueryInterface(__uuidof(Q), (void **)pp);
+        }
+        END_INTERFACE
+    };
+}
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(IUnknown, 0x00000000, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46)
+#endif
+#else
+typedef struct IUnknownVtbl {
+    BEGIN_INTERFACE
+
+    /*** IUnknown methods ***/
+    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+        IUnknown *This,
+        REFIID riid,
+        void **ppvObject);
+
+    ULONG (STDMETHODCALLTYPE *AddRef)(
+        IUnknown *This);
+
+    ULONG (STDMETHODCALLTYPE *Release)(
+        IUnknown *This);
+
+    END_INTERFACE
+} IUnknownVtbl;
+
+interface IUnknown {
+    CONST_VTBL IUnknownVtbl* lpVtbl;
+};
+
+#ifdef COBJMACROS
+/*** IUnknown methods ***/
+#define IUnknown_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IUnknown_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IUnknown_Release(This) (This)->lpVtbl->Release(This)
+#endif
+
+#endif
+
+#endif /* __IUnknown_INTERFACE_DEFINED__ */
+
+DEFINE_GUID(IID_IUnknown, 0x00000000, 0x0000, 0x0000, 0xc0,0x00, 0x00,0x00,0x00,0x00,0x00,0x46);
+
+#endif /* __unknwnbase_h__ */

3rdparty/directx-headers/include/wsl/stubs/winapifamily.h

@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// Stub header to satisfy d3d12.h include. Unconditionally light up all APIs.
+#pragma once
+#define WINAPI_FAMILY_PARTITION(Partitions) 1

3rdparty/directx-headers/include/wsl/stubs/wrl/client.h

@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// Stub to satisfy d3dx12.h include
+#pragma once
+#include <wsl/wrladapter.h>

3rdparty/directx-headers/include/wsl/stubs/wrl/implements.h

@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+// Stub to satisfy DML TF runtime includes
+#pragma once
+#include <wsl/wrladapter.h>

3rdparty/directx-headers/include/wsl/winadapter.h

@@ -0,0 +1,6 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <unknwn.h>

3rdparty/directx-headers/include/wsl/wrladapter.h

@@ -0,0 +1,803 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "winadapter.h"
+
+// defined by winadapter.h and needed by some windows headers, but conflicts
+// with some libc++ implementation headers
+#ifdef __in
+#undef __in
+#endif
+#ifdef __out
+#undef __out
+#endif
+
+#include <type_traits>
+#include <atomic>
+#include <memory>
+#include <new>
+#include <climits>
+#include <cassert>
+
+namespace Microsoft
+{
+namespace WRL
+{
+    namespace Details
+    {
+        struct BoolStruct { int Member; };
+        typedef int BoolStruct::* BoolType;
+
+        template <typename T> // T should be the ComPtr<T> or a derived type of it, not just the interface
+        class ComPtrRefBase
+        {
+        public:
+            typedef typename T::InterfaceType InterfaceType;
+
+            operator IUnknown**() const throw()
+            {
+                static_assert(__is_base_of(IUnknown, InterfaceType), "Invalid cast: InterfaceType does not derive from IUnknown");
+                return reinterpret_cast<IUnknown**>(ptr_->ReleaseAndGetAddressOf());
+            }
+
+        protected:
+            T* ptr_;
+        };
+
+        template <typename T>
+        class ComPtrRef : public Details::ComPtrRefBase<T> // T should be the ComPtr<T> or a derived type of it, not just the interface
+        {
+            using Super = Details::ComPtrRefBase<T>;
+            using InterfaceType = typename Super::InterfaceType;
+        public:
+            ComPtrRef(_In_opt_ T* ptr) throw()
+            {
+                this->ptr_ = ptr;
+            }
+
+            // Conversion operators
+            operator void**() const throw()
+            {
+                return reinterpret_cast<void**>(this->ptr_->ReleaseAndGetAddressOf());
+            }
+
+            // This is our operator ComPtr<U> (or the latest derived class from ComPtr (e.g. WeakRef))
+            operator T*() throw()
+            {
+                *this->ptr_ = nullptr;
+                return this->ptr_;
+            }
+
+            // We define operator InterfaceType**() here instead of on ComPtrRefBase<T>, since
+            // if InterfaceType is IUnknown or IInspectable, having it on the base will collide.
+            operator InterfaceType**() throw()
+            {
+                return this->ptr_->ReleaseAndGetAddressOf();
+            }
+
+            // This is used for IID_PPV_ARGS in order to do __uuidof(**(ppType)).
+            // It does not need to clear  ptr_ at this point, it is done at IID_PPV_ARGS_Helper(ComPtrRef&) later in this file.
+            InterfaceType* operator *() throw()
+            {
+                return this->ptr_->Get();
+            }
+
+            // Explicit functions
+            InterfaceType* const * GetAddressOf() const throw()
+            {
+                return this->ptr_->GetAddressOf();
+            }
+
+            InterfaceType** ReleaseAndGetAddressOf() throw()
+            {
+                return this->ptr_->ReleaseAndGetAddressOf();
+            }
+        };
+    }
+
+    template <typename T>
+    class ComPtr
+    {
+    public:
+        typedef T InterfaceType;
+
+    protected:
+        InterfaceType *ptr_;
+        template<class U> friend class ComPtr;
+
+        void InternalAddRef() const throw()
+        {
+            if (ptr_ != nullptr)
+            {
+                ptr_->AddRef();
+            }
+        }
+
+        unsigned long InternalRelease() throw()
+        {
+            unsigned long ref = 0;
+            T* temp = ptr_;
+
+            if (temp != nullptr)
+            {
+                ptr_ = nullptr;
+                ref = temp->Release();
+            }
+
+            return ref;
+        }
+
+    public:
+        ComPtr() throw() : ptr_(nullptr)
+        {
+        }
+
+        ComPtr(decltype(nullptr)) throw() : ptr_(nullptr)
+        {
+        }
+
+        template<class U>
+        ComPtr(_In_opt_ U *other) throw() : ptr_(other)
+        {
+            InternalAddRef();
+        }
+
+        ComPtr(const ComPtr& other) throw() : ptr_(other.ptr_)
+        {
+            InternalAddRef();
+        }
+
+        // copy constructor that allows to instantiate class when U* is convertible to T*
+        template<class U>
+        ComPtr(const ComPtr<U> &other, typename std::enable_if<std::is_convertible<U*, T*>::value, void *>::type * = 0) throw() :
+            ptr_(other.ptr_)
+        {
+            InternalAddRef();
+        }
+
+        ComPtr(_Inout_ ComPtr &&other) throw() : ptr_(nullptr)
+        {
+            if (this != reinterpret_cast<ComPtr*>(&reinterpret_cast<unsigned char&>(other)))
+            {
+                Swap(other);
+            }
+        }
+
+        // Move constructor that allows instantiation of a class when U* is convertible to T*
+        template<class U>
+        ComPtr(_Inout_ ComPtr<U>&& other, typename std::enable_if<std::is_convertible<U*, T*>::value, void *>::type * = 0) throw() :
+            ptr_(other.ptr_)
+        {
+            other.ptr_ = nullptr;
+        }
+
+        ~ComPtr() throw()
+        {
+            InternalRelease();
+        }
+
+        ComPtr& operator=(decltype(nullptr)) throw()
+        {
+            InternalRelease();
+            return *this;
+        }
+
+        ComPtr& operator=(_In_opt_ T *other) throw()
+        {
+            if (ptr_ != other)
+            {
+                ComPtr(other).Swap(*this);
+            }
+            return *this;
+        }
+
+        template <typename U>
+        ComPtr& operator=(_In_opt_ U *other) throw()
+        {
+            ComPtr(other).Swap(*this);
+            return *this;
+        }
+
+        ComPtr& operator=(const ComPtr &other) throw()
+        {
+            if (ptr_ != other.ptr_)
+            {
+                ComPtr(other).Swap(*this);
+            }
+            return *this;
+        }
+
+        template<class U>
+        ComPtr& operator=(const ComPtr<U>& other) throw()
+        {
+            ComPtr(other).Swap(*this);
+            return *this;
+        }
+
+        ComPtr& operator=(_Inout_ ComPtr &&other) throw()
+        {
+            ComPtr(static_cast<ComPtr&&>(other)).Swap(*this);
+            return *this;
+        }
+
+        template<class U>
+        ComPtr& operator=(_Inout_ ComPtr<U>&& other) throw()
+        {
+            ComPtr(static_cast<ComPtr<U>&&>(other)).Swap(*this);
+            return *this;
+        }
+
+        void Swap(_Inout_ ComPtr&& r) throw()
+        {
+            T* tmp = ptr_;
+            ptr_ = r.ptr_;
+            r.ptr_ = tmp;
+        }
+
+        void Swap(_Inout_ ComPtr& r) throw()
+        {
+            T* tmp = ptr_;
+            ptr_ = r.ptr_;
+            r.ptr_ = tmp;
+        }
+
+        operator Details::BoolType() const throw()
+        {
+            return Get() != nullptr ? &Details::BoolStruct::Member : nullptr;
+        }
+
+        T* Get() const throw()
+        {
+            return ptr_;
+        }
+
+        InterfaceType* operator->() const throw()
+        {
+            return ptr_;
+        }
+
+        Details::ComPtrRef<ComPtr<T>> operator&() throw()
+        {
+            return Details::ComPtrRef<ComPtr<T>>(this);
+        }
+
+        const Details::ComPtrRef<const ComPtr<T>> operator&() const throw()
+        {
+            return Details::ComPtrRef<const ComPtr<T>>(this);
+        }
+
+        T* const* GetAddressOf() const throw()
+        {
+            return &ptr_;
+        }
+
+        T** GetAddressOf() throw()
+        {
+            return &ptr_;
+        }
+
+        T** ReleaseAndGetAddressOf() throw()
+        {
+            InternalRelease();
+            return &ptr_;
+        }
+
+        T* Detach() throw()
+        {
+            T* ptr = ptr_;
+            ptr_ = nullptr;
+            return ptr;
+        }
+
+        void Attach(_In_opt_ InterfaceType* other) throw()
+        {
+            if (ptr_ != nullptr)
+            {
+                auto ref = ptr_->Release();
+                // DBG_UNREFERENCED_LOCAL_VARIABLE(ref);
+                // Attaching to the same object only works if duplicate references are being coalesced. Otherwise
+                // re-attaching will cause the pointer to be released and may cause a crash on a subsequent dereference.
+                assert(ref != 0 || ptr_ != other);
+            }
+
+            ptr_ = other;
+        }
+
+        unsigned long Reset()
+        {
+            return InternalRelease();
+        }
+
+        // Previously, unsafe behavior could be triggered when 'this' is ComPtr<IInspectable> or ComPtr<IUnknown> and CopyTo is used to copy to another type U. 
+        // The user will use operator& to convert the destination into a ComPtrRef, which can then implicit cast to IInspectable** and IUnknown**. 
+        // If this overload of CopyTo is not present, it will implicitly cast to IInspectable or IUnknown and match CopyTo(InterfaceType**) instead.
+        // A valid polymoprhic downcast requires run-time type checking via QueryInterface, so CopyTo(InterfaceType**) will break type safety.
+        // This overload matches ComPtrRef before the implicit cast takes place, preventing the unsafe downcast.
+        template <typename U>
+        HRESULT CopyTo(Details::ComPtrRef<ComPtr<U>> ptr, typename std::enable_if<
+            (std::is_same<T, IUnknown>::value)
+            && !std::is_same<U*, T*>::value, void *>::type * = 0) const throw()
+        {
+            return ptr_->QueryInterface(__uuidof(U), ptr);
+        }
+
+        HRESULT CopyTo(_Outptr_result_maybenull_ InterfaceType** ptr) const throw()
+        {
+            InternalAddRef();
+            *ptr = ptr_;
+            return S_OK;
+        }
+
+        HRESULT CopyTo(REFIID riid, _Outptr_result_nullonfailure_ void** ptr) const throw()
+        {
+            return ptr_->QueryInterface(riid, ptr);
+        }
+
+        template<typename U>
+        HRESULT CopyTo(_Outptr_result_nullonfailure_ U** ptr) const throw()
+        {
+            return ptr_->QueryInterface(__uuidof(U), reinterpret_cast<void**>(ptr));
+        }
+
+        // query for U interface
+        template<typename U>
+        HRESULT As(_Inout_ Details::ComPtrRef<ComPtr<U>> p) const throw()
+        {
+            return ptr_->QueryInterface(__uuidof(U), p);
+        }
+
+        // query for U interface
+        template<typename U>
+        HRESULT As(_Out_ ComPtr<U>* p) const throw()
+        {
+            return ptr_->QueryInterface(__uuidof(U), reinterpret_cast<void**>(p->ReleaseAndGetAddressOf()));
+        }
+
+        // query for riid interface and return as IUnknown
+        HRESULT AsIID(REFIID riid, _Out_ ComPtr<IUnknown>* p) const throw()
+        {
+            return ptr_->QueryInterface(riid, reinterpret_cast<void**>(p->ReleaseAndGetAddressOf()));
+        }
+
+    };    // ComPtr
+
+
+    namespace Details
+    {
+        // Empty struct used as default template parameter
+        class Nil
+        {
+        };
+
+        // Empty struct used for validating template parameter types in Implements
+        struct ImplementsBase
+        {
+        };
+
+        class RuntimeClassBase
+        {
+        protected:
+            template<typename T>
+            static HRESULT AsIID(_In_ T* implements, REFIID riid, _Outptr_result_nullonfailure_ void **ppvObject) noexcept
+            {
+                *ppvObject = nullptr;
+                bool isRefDelegated = false;
+                // Prefer InlineIsEqualGUID over other forms since it's better perf on 4-byte aligned data, which is almost always the case.
+                if (InlineIsEqualGUID(riid, __uuidof(IUnknown)))
+                {
+                    *ppvObject = implements->CastToUnknown();
+                    static_cast<IUnknown*>(*ppvObject)->AddRef();
+                    return S_OK;
+                }
+
+                HRESULT hr = implements->CanCastTo(riid, ppvObject, &isRefDelegated);
+                if (SUCCEEDED(hr) && !isRefDelegated)
+                {
+                    static_cast<IUnknown*>(*ppvObject)->AddRef();
+                }
+
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 6102) // '*ppvObject' is used but may not be initialized
+#endif
+                _Analysis_assume_(SUCCEEDED(hr) || (*ppvObject == nullptr));
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+                return hr;
+            }
+
+        public:
+            HRESULT RuntimeClassInitialize() noexcept
+            {
+                return S_OK;
+            }
+        };
+
+        // Interface traits provides casting and filling iids methods helpers
+        template<typename I0>
+        struct InterfaceTraits
+        {
+            typedef I0 Base;
+
+            template<typename T>
+            static Base* CastToBase(_In_ T* ptr) noexcept
+            {
+                return static_cast<Base*>(ptr);
+            }
+
+            template<typename T>
+            static IUnknown* CastToUnknown(_In_ T* ptr) noexcept
+            {
+                return static_cast<IUnknown*>(static_cast<Base*>(ptr));
+            }
+
+            template <typename T>
+            _Success_(return == true)
+                static bool CanCastTo(_In_ T* ptr, REFIID riid, _Outptr_ void **ppv) noexcept
+            {
+                // Prefer InlineIsEqualGUID over other forms since it's better perf on 4-byte aligned data, which is almost always the case.
+                if (InlineIsEqualGUID(riid, __uuidof(Base)))
+                {
+                    *ppv = static_cast<Base*>(ptr);
+                    return true;
+                }
+
+                return false;
+            }
+        };
+
+        // Specialization for Nil parameter
+        template<>
+        struct InterfaceTraits<Nil>
+        {
+            typedef Nil Base;
+
+            template <typename T>
+            _Success_(return == true)
+                static bool CanCastTo(_In_ T*, REFIID, _Outptr_ void **) noexcept
+            {
+                return false;
+            }
+        };
+
+        // ChainInterfaces - template allows specifying a derived COM interface along with its class hierarchy to allow QI for the base interfaces
+        template <typename I0, typename I1, typename I2 = Nil, typename I3 = Nil,
+            typename I4 = Nil, typename I5 = Nil, typename I6 = Nil,
+            typename I7 = Nil, typename I8 = Nil, typename I9 = Nil>
+            struct ChainInterfaces : I0
+        {
+        protected:
+            HRESULT CanCastTo(REFIID riid, _Outptr_ void **ppv) throw()
+            {
+                typename InterfaceTraits<I0>::Base* ptr = InterfaceTraits<I0>::CastToBase(this);
+
+                return (InterfaceTraits<I0>::CanCastTo(this, riid, ppv) ||
+                    InterfaceTraits<I1>::CanCastTo(ptr, riid, ppv) ||
+                    InterfaceTraits<I2>::CanCastTo(ptr, riid, ppv) ||
+                    InterfaceTraits<I3>::CanCastTo(ptr, riid, ppv) ||
+                    InterfaceTraits<I4>::CanCastTo(ptr, riid, ppv) ||
+                    InterfaceTraits<I5>::CanCastTo(ptr, riid, ppv) ||
+                    InterfaceTraits<I6>::CanCastTo(ptr, riid, ppv) ||
+                    InterfaceTraits<I7>::CanCastTo(ptr, riid, ppv) ||
+                    InterfaceTraits<I8>::CanCastTo(ptr, riid, ppv) ||
+                    InterfaceTraits<I9>::CanCastTo(ptr, riid, ppv)) ? S_OK : E_NOINTERFACE;
+            }
+
+            IUnknown* CastToUnknown() throw()
+            {
+                return InterfaceTraits<I0>::CastToUnknown(this);
+            }
+        };
+
+        // Helper template used by Implements. This template traverses a list of interfaces and adds them as base class and information
+        // to enable QI.
+        template <typename ...TInterfaces>
+        struct ImplementsHelper;
+
+        template <typename T>
+        struct ImplementsMarker
+        {};
+
+        template <typename I0, bool isImplements>
+        struct MarkImplements;
+
+        template <typename I0>
+        struct MarkImplements<I0, false>
+        {
+            typedef I0 Type;
+        };
+
+        template <typename I0>
+        struct MarkImplements<I0, true>
+        {
+            typedef ImplementsMarker<I0> Type;
+        };
+
+        // AdjustImplements pre-processes the type list for more efficient builds.
+        template <typename ...Bases>
+        struct AdjustImplements;
+
+        template <typename I0, typename ...Bases>
+        struct AdjustImplements<I0, Bases...>
+        {
+            typedef ImplementsHelper<typename MarkImplements<I0, std::is_base_of<ImplementsBase, I0>::value>::Type, Bases...> Type;
+        };
+
+        // Use AdjustImplements to remove instances of "Nil" from the type list.
+        template <typename ...Bases>
+        struct AdjustImplements<Nil, Bases...>
+        {
+            typedef typename AdjustImplements<Bases...>::Type Type;
+        };
+
+        template <>
+        struct AdjustImplements<>
+        {
+            typedef ImplementsHelper<> Type;
+        };
+
+        // Specialization handles unadorned interfaces
+        template <typename I0, typename ...TInterfaces>
+        struct ImplementsHelper<I0, TInterfaces...> :
+            I0,
+            AdjustImplements<TInterfaces...>::Type
+        {
+            template <typename ...> friend struct ImplementsHelper;
+            friend class RuntimeClassBase;
+
+        protected:
+
+            HRESULT CanCastTo(REFIID riid, _Outptr_ void **ppv, bool *pRefDelegated = nullptr) noexcept
+            {
+                // Prefer InlineIsEqualGUID over other forms since it's better perf on 4-byte aligned data, which is almost always the case.
+                if (InlineIsEqualGUID(riid, __uuidof(I0)))
+                {
+                    *ppv = reinterpret_cast<I0*>(reinterpret_cast<void*>(this));
+                    return S_OK;
+                }
+                return AdjustImplements<TInterfaces...>::Type::CanCastTo(riid, ppv, pRefDelegated);
+            }
+
+            IUnknown* CastToUnknown() noexcept
+            {
+                return reinterpret_cast<I0*>(reinterpret_cast<void*>(this));
+            }
+        };
+
+
+        // Selector is used to "tag" base interfaces to be used in casting, since a runtime class may indirectly derive from 
+        // the same interface or Implements<> template multiple times
+        template <typename base, typename disciminator>
+        struct  Selector : public base
+        {
+        };
+
+        // Specialization handles types that derive from ImplementsHelper (e.g. nested Implements).
+        template <typename I0, typename ...TInterfaces>
+        struct ImplementsHelper<ImplementsMarker<I0>, TInterfaces...> :
+            Selector<I0, ImplementsHelper<ImplementsMarker<I0>, TInterfaces...>>,
+            Selector<typename AdjustImplements<TInterfaces...>::Type, ImplementsHelper<ImplementsMarker<I0>, TInterfaces...>>
+        {
+            template <typename ...> friend struct ImplementsHelper;
+            friend class RuntimeClassBase;
+
+        protected:
+            typedef Selector<I0, ImplementsHelper<ImplementsMarker<I0>, TInterfaces...>> CurrentType;
+            typedef Selector<typename AdjustImplements<TInterfaces...>::Type, ImplementsHelper<ImplementsMarker<I0>, TInterfaces...>> BaseType;
+
+            HRESULT CanCastTo(REFIID riid, _Outptr_ void **ppv, bool *pRefDelegated = nullptr) noexcept
+            {
+                HRESULT hr = CurrentType::CanCastTo(riid, ppv);
+                if (hr == E_NOINTERFACE)
+                {
+                    hr = BaseType::CanCastTo(riid, ppv, pRefDelegated);
+                }
+                return hr;
+            }
+
+            IUnknown* CastToUnknown() noexcept
+            {
+                // First in list wins.
+                return CurrentType::CastToUnknown();
+            }
+        };
+
+        // terminal case specialization.
+        template <>
+        struct ImplementsHelper<>
+        {
+            template <typename ...> friend struct ImplementsHelper;
+            friend class RuntimeClassBase;
+
+        protected:
+            HRESULT CanCastTo(_In_ REFIID /*riid*/, _Outptr_ void ** /*ppv*/, bool * /*pRefDelegated*/ = nullptr) noexcept
+            {
+                return E_NOINTERFACE;
+            }
+
+            // IUnknown* CastToUnknown() noexcept; // not defined for terminal case.
+        };
+
+        // Specialization handles chaining interfaces
+        template <typename C0, typename C1, typename C2, typename C3, typename C4, typename C5, typename C6, typename C7, typename C8, typename C9, typename ...TInterfaces>
+        struct ImplementsHelper<ChainInterfaces<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>, TInterfaces...> :
+            ChainInterfaces<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>,
+            AdjustImplements<TInterfaces...>::Type
+        {
+            template <typename ...> friend struct ImplementsHelper;
+            friend class RuntimeClassBase;
+
+        protected:
+            typedef typename AdjustImplements<TInterfaces...>::Type BaseType;
+
+            HRESULT CanCastTo(REFIID riid, _Outptr_ void **ppv, bool *pRefDelegated = nullptr) noexcept
+            {
+                HRESULT hr = ChainInterfaces<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>::CanCastTo(riid, ppv);
+                if (FAILED(hr))
+                {
+                    hr = BaseType::CanCastTo(riid, ppv, pRefDelegated);
+                }
+
+                return hr;
+            }
+
+            IUnknown* CastToUnknown() noexcept
+            {
+                return ChainInterfaces<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9>::CastToUnknown();
+            }
+        };
+
+        // Implements - template implementing QI using the information provided through its template parameters
+        // Each template parameter has to be one of the following:
+        // * COM Interface
+        // * A class that implements one or more COM interfaces
+        // * ChainInterfaces template
+        template <typename I0, typename ...TInterfaces>
+        struct Implements :
+            AdjustImplements<I0, TInterfaces...>::Type,
+            ImplementsBase
+        {
+        public:
+            typedef I0 FirstInterface;
+        protected:
+            typedef typename AdjustImplements<I0, TInterfaces...>::Type BaseType;
+            template <typename ...> friend struct ImplementsHelper;
+            friend class RuntimeClassBase;
+
+            HRESULT CanCastTo(REFIID riid, _Outptr_ void **ppv) noexcept
+            {
+                return BaseType::CanCastTo(riid, ppv);
+            }
+
+            IUnknown* CastToUnknown() noexcept
+            {
+                return BaseType::CastToUnknown();
+            }
+        };
+
+        // Used on RuntimeClass to protect it from being constructed with new
+        class DontUseNewUseMake
+        {
+        private:
+            void* operator new(size_t) noexcept
+            {
+                assert(false);
+                return 0;
+            }
+
+        public:
+            void* operator new(size_t, _In_ void* placement) noexcept
+            {
+                return placement;
+            }
+        };
+
+        template <typename ...TInterfaces>
+        class RuntimeClassImpl :
+            public AdjustImplements<TInterfaces...>::Type,
+            public RuntimeClassBase,
+            public DontUseNewUseMake
+        {
+        public:
+            STDMETHOD(QueryInterface)(REFIID riid, _Outptr_result_nullonfailure_ void **ppvObject)
+            {
+                return Super::AsIID(this, riid, ppvObject);
+            }
+
+            STDMETHOD_(ULONG, AddRef)()
+            {
+                return InternalAddRef();
+            }
+
+            STDMETHOD_(ULONG, Release)()
+            {
+                ULONG ref = InternalRelease();
+                if (ref == 0)
+                {
+                    this->~RuntimeClassImpl();
+                    delete[] reinterpret_cast<char*>(this);
+                }
+
+                return ref;
+            }
+
+        protected:
+            using Super = RuntimeClassBase;
+            static const LONG c_lProtectDestruction = -(LONG_MAX / 2);
+
+            RuntimeClassImpl() noexcept = default;
+
+            virtual ~RuntimeClassImpl() noexcept
+            {
+                // Set refcount_ to -(LONG_MAX/2) to protect destruction and
+                // also catch mismatched Release in debug builds
+                refcount_ = static_cast<ULONG>(c_lProtectDestruction);
+            }
+
+            ULONG InternalAddRef() noexcept
+            {
+                return ++refcount_;
+            }
+
+            ULONG InternalRelease() noexcept
+            {
+                return --refcount_;
+            }
+
+            unsigned long GetRefCount() const noexcept
+            {
+                return refcount_;
+            }
+
+            std::atomic<ULONG> refcount_{1};
+        };
+    }
+
+    template <typename ...TInterfaces>
+    class Base : public Details::RuntimeClassImpl<TInterfaces...>
+    {
+        Base(const Base&) = delete;
+        Base& operator=(const Base&) = delete;
+
+    protected:
+        HRESULT CustomQueryInterface(REFIID /*riid*/, _Outptr_result_nullonfailure_ void** /*ppvObject*/, _Out_ bool *handled)
+        {
+            *handled = false;
+            return S_OK;
+        }
+
+    public:
+        Base() throw() = default;
+        typedef Base RuntimeClassT;
+    };
+
+    // Creates a Nano-COM object wrapped in a smart pointer.
+    template <typename T, typename ...TArgs>
+    ComPtr<T> Make(TArgs&&... args)
+    {
+        std::unique_ptr<char[]> buffer(new(std::nothrow) char[sizeof(T)]);
+        ComPtr<T> object;
+
+        if (buffer)
+        {
+            T* ptr = new (buffer.get())T(std::forward<TArgs>(args)...);
+            object.Attach(ptr);
+            buffer.release();
+        }
+
+        return object;
+    }
+
+    using Details::ChainInterfaces;
+}
+}
+
+// Overloaded global function to provide to IID_PPV_ARGS that support Details::ComPtrRef
+template<typename T>
+void** IID_PPV_ARGS_Helper(Microsoft::WRL::Details::ComPtrRef<T> pp) throw()
+{
+    return pp;
+}

3rdparty/dxsdk/directx-sdk-eula.txt

@@ -1,77 +0,0 @@
-MICROSOFT SOFTWARE LICENSE TERMS
-MICROSOFT DIRECTX SOFTWARE DEVELOPMENT KIT (SDK)
-These license terms are an agreement between Microsoft Corporation (or based on where you live, one of its affiliates) and you.  Please read them.  They apply to the software named above, which includes the media on which you received it, if any.  The terms also apply to any Microsoft
-•	updates,
-•	supplements,
-•	Internet-based services, and 
-•	support services
-for this software, unless other terms accompany those items.  If so, those terms apply.
-BY USING THE SOFTWARE, YOU ACCEPT THESE TERMS.  IF YOU DO NOT ACCEPT THEM, DO NOT USE THE SOFTWARE.
-If you comply with these license terms, you have the rights below.
-1.	INSTALLATION AND USE RIGHTS.  
-a.	Installation and Use.  You may install and use any number of copies of the software on your devices.
-b.	Included Microsoft Programs.  The software contains other Microsoft programs.  The license terms with those programs apply to your use of them.
-2.	ADDITIONAL LICENSING REQUIREMENTS AND/OR USE RIGHTS.
-a.	Media Elements and Templates.  You may copy and use images, clip art, animations, sounds, music, shapes, video clips and templates provided with the software and identified for such use in documents and projects that you create.  You may distribute those documents and projects non-commercially.  If you wish to use these media elements or templates for any other purpose, go to www.microsoft.com/permission to learn whether that use is allowed.
-b.	Distributable Code.  The software contains code that you are permitted to distribute in programs you develop if you comply with the terms below.
-i.	Right to Use and Distribute.  The code and text files listed below are “Distributable Code.”
-•	DIRECTX REDIST.TXT Files.  You may copy and distribute the object code form of code listed in DIRECTX REDIST.TXT files.
-•	Sample Code.  You may modify, copy, and distribute the source and object code form of code marked as “sample”, as well as those marked as follows:
-\Utilities\bin\x86\dxerr
-\Utilities\bin\x64\dxerr
-\Utilities\bin\x86\dxtex
-\Utilities\bin\x64\dxtex
-\Utilities\bin\x86\DxViewer
-\Utilities\bin\x64\DxViewer
-\Utilities\bin\x86\GDFTrace
-\Utilities\bin\x64\GDFTrace
-\Utilities\bin\x86\MeshConvert
-\Utilities\bin\x64\MeshConvert
-\Utilities\Source\Sas
-\Utilities\Source\Effects11
-•	Third Party Distribution.  You may permit distributors of your programs to copy and distribute the Distributable Code as part of those programs.
-ii.	Distribution Requirements.  For any Distributable Code you distribute, you must
-•	add significant primary functionality to it in your programs;
-•	require distributors and external end users to agree to terms that protect it at least as much as this agreement; 
-•	display your valid copyright notice on your programs; and
-•	indemnify, defend, and hold harmless Microsoft from any claims, including attorneys’ fees, related to the distribution or use of your programs.
-iii.	Distribution Restrictions.  You may not
-•	alter any copyright, trademark or patent notice in the Distributable Code; 
-•	use Microsoft’s trademarks in your programs’ names or in a way that suggests your programs come from or are endorsed by Microsoft; 
-•	distribute Distributable Code to run on a platform other than the Windows, Xbox and Windows Mobile platforms;
-•	include Distributable Code in malicious, deceptive or unlawful programs; or
-•	modify or distribute the source code of any Distributable Code so that any part of it becomes subject to an Excluded License.  An Excluded License is one that requires, as a condition of use, modification or distribution, that
-•	the code be disclosed or distributed in source code form; or 
-•	others have the right to modify it.
-3.	SCOPE OF LICENSE.  The software is licensed, not sold. This agreement only gives you some rights to use the software.  Microsoft reserves all other rights.  Unless applicable law gives you more rights despite this limitation, you may use the software only as expressly permitted in this agreement.  In doing so, you must comply with any technical limitations in the software that only allow you to use it in certain ways.    You may not
-•	disclose the results of any benchmark tests of the software to any third party without Microsoft’s prior written approval;
-•	work around any technical limitations in the software;
-•	reverse engineer, decompile or disassemble the software, except and only to the extent that applicable law expressly permits, despite this limitation;
-•	make more copies of the software than specified in this agreement or allowed by applicable law, despite this limitation;
-•	publish the software for others to copy;
-•	rent, lease or lend the software; or
-•	use the software for commercial software hosting services.
-4.	BACKUP COPY.  You may make one backup copy of the software.  You may use it only to reinstall the software.
-5.	DOCUMENTATION.  Any person that has valid access to your computer or internal network may copy and use the documentation for your internal, reference purposes.
-6.	EXPORT RESTRICTIONS.  The software is subject to United States export laws and regulations.  You must comply with all domestic and international export laws and regulations that apply to the software.  These laws include restrictions on destinations, end users and end use.  For additional information, see www.microsoft.com/exporting.
-7.	SUPPORT SERVICES. Because this software is “as is,” we may not provide support services for it.
-8.	ENTIRE AGREEMENT.  This agreement, and the terms for supplements, updates, Internet-based services and support services that you use, are the entire agreement for the software and support services.
-9.	APPLICABLE LAW.
-a.	United States.  If you acquired the software in the United States, Washington state law governs the interpretation of this agreement and applies to claims for breach of it, regardless of conflict of laws principles.  The laws of the state where you live govern all other claims, including claims under state consumer protection laws, unfair competition laws, and in tort.
-b.	Outside the United States.  If you acquired the software in any other country, the laws of that country apply.
-10.	LEGAL EFFECT.  This agreement describes certain legal rights.  You may have other rights under the laws of your country.  You may also have rights with respect to the party from whom you acquired the software.  This agreement does not change your rights under the laws of your country if the laws of your country do not permit it to do so.
-11.	DISCLAIMER OF WARRANTY.   THE SOFTWARE IS LICENSED “AS-IS.”  YOU BEAR THE RISK OF USING IT.  MICROSOFT GIVES NO EXPRESS WARRANTIES, GUARANTEES OR CONDITIONS.  YOU MAY HAVE ADDITIONAL CONSUMER RIGHTS UNDER YOUR LOCAL LAWS WHICH THIS AGREEMENT CANNOT CHANGE.  TO THE EXTENT PERMITTED UNDER YOUR LOCAL LAWS, MICROSOFT EXCLUDES THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
-12.	LIMITATION ON AND EXCLUSION OF REMEDIES AND DAMAGES.  YOU CAN RECOVER FROM MICROSOFT AND ITS SUPPLIERS ONLY DIRECT DAMAGES UP TO U.S. $5.00.  YOU CANNOT RECOVER ANY OTHER DAMAGES, INCLUDING CONSEQUENTIAL, LOST PROFITS, SPECIAL, INDIRECT OR INCIDENTAL DAMAGES.
-This limitation applies to
-•	anything related to the software, services, content (including code) on third party Internet sites, or third party programs; and
-•	claims for breach of contract, breach of warranty, guarantee or condition, strict liability, negligence, or other tort to the extent permitted by applicable law.
-It also applies even if Microsoft knew or should have known about the possibility of the damages.  The above limitation or exclusion may not apply to you because your country may not allow the exclusion or limitation of incidental, consequential or other damages.
-Please note: As this software is distributed in Quebec, Canada, some of the clauses in this agreement are provided below in French.
-Remarque : Ce logiciel étant distribué au Québec, Canada, certaines des clauses dans ce contrat sont fournies ci-dessous en français.
-EXONÉRATION DE GARANTIE. Le logiciel visé par une licence est offert « tel quel ». Toute utilisation de ce logiciel est à votre seule risque et péril. Microsoft n’accorde aucune autre garantie expresse. Vous pouvez bénéficier de droits additionnels en vertu du droit local sur la protection des consommateurs, que ce contrat ne peut modifier. La ou elles sont permises par le droit locale, les garanties implicites de qualité marchande, d’adéquation à un usage particulier et d’absence de contrefaçon sont exclues.
-LIMITATION DES DOMMAGES-INTÉRÊTS ET EXCLUSION DE RESPONSABILITÉ POUR LES DOMMAGES.  Vous pouvez obtenir de Microsoft et de ses fournisseurs une indemnisation en cas de dommages directs uniquement à hauteur de 5,00 $ US. Vous ne pouvez prétendre à aucune indemnisation pour les autres dommages, y compris les dommages spéciaux, indirects ou accessoires et pertes de bénéfices.
-Cette limitation concerne :
-•	tout  ce qui est relié au logiciel, aux services ou au contenu (y compris le code) figurant sur des sites Internet tiers ou dans des programmes tiers ; et
-•	les réclamations au titre de violation de contrat ou de garantie, ou au titre de responsabilité stricte, de négligence ou d’une autre faute dans la limite autorisée par la loi en vigueur.
-Elle s’applique également, même si Microsoft connaissait ou devrait connaître l’éventualité d’un tel dommage.  Si votre pays n’autorise pas l’exclusion ou la limitation de responsabilité pour les dommages indirects, accessoires ou de quelque nature que ce soit, il se peut que la limitation ou l’exclusion ci-dessus ne s’appliquera pas à votre égard.
-EFFET JURIDIQUE.  Le présent contrat décrit certains droits juridiques. Vous pourriez avoir d’autres droits prévus par les lois de votre pays.  Le présent contrat ne modifie pas les droits que vous confèrent les lois de votre pays si celles-ci ne le permettent pas.

3rdparty/dxsdk/include/d3d12_1.h

@@ -1,2539 +0,0 @@
-/*-------------------------------------------------------------------------------------
- *
- * 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__ 475
-#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>
-// BK - 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) */
-// BK - 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/d3d12sdklayers.h

@@ -1,3225 +0,0 @@
-/*-------------------------------------------------------------------------------------
- *
- * 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__ 475
-#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 __d3d12sdklayers_h__
-#define __d3d12sdklayers_h__
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-#pragma once
-#endif
-
-/* Forward Declarations */ 
-
-#ifndef __ID3D12Debug_FWD_DEFINED__
-#define __ID3D12Debug_FWD_DEFINED__
-typedef interface ID3D12Debug ID3D12Debug;
-
-#endif 	/* __ID3D12Debug_FWD_DEFINED__ */
-
-
-#ifndef __ID3D12Debug1_FWD_DEFINED__
-#define __ID3D12Debug1_FWD_DEFINED__
-typedef interface ID3D12Debug1 ID3D12Debug1;
-
-#endif 	/* __ID3D12Debug1_FWD_DEFINED__ */
-
-
-#ifndef __ID3D12Debug2_FWD_DEFINED__
-#define __ID3D12Debug2_FWD_DEFINED__
-typedef interface ID3D12Debug2 ID3D12Debug2;
-
-#endif 	/* __ID3D12Debug2_FWD_DEFINED__ */
-
-
-#ifndef __ID3D12Debug3_FWD_DEFINED__
-#define __ID3D12Debug3_FWD_DEFINED__
-typedef interface ID3D12Debug3 ID3D12Debug3;
-
-#endif 	/* __ID3D12Debug3_FWD_DEFINED__ */
-
-
-#ifndef __ID3D12DebugDevice1_FWD_DEFINED__
-#define __ID3D12DebugDevice1_FWD_DEFINED__
-typedef interface ID3D12DebugDevice1 ID3D12DebugDevice1;
-
-#endif 	/* __ID3D12DebugDevice1_FWD_DEFINED__ */
-
-
-#ifndef __ID3D12DebugDevice_FWD_DEFINED__
-#define __ID3D12DebugDevice_FWD_DEFINED__
-typedef interface ID3D12DebugDevice ID3D12DebugDevice;
-
-#endif 	/* __ID3D12DebugDevice_FWD_DEFINED__ */
-
-
-#ifndef __ID3D12DebugDevice2_FWD_DEFINED__
-#define __ID3D12DebugDevice2_FWD_DEFINED__
-typedef interface ID3D12DebugDevice2 ID3D12DebugDevice2;
-
-#endif 	/* __ID3D12DebugDevice2_FWD_DEFINED__ */
-
-
-#ifndef __ID3D12DebugCommandQueue_FWD_DEFINED__
-#define __ID3D12DebugCommandQueue_FWD_DEFINED__
-typedef interface ID3D12DebugCommandQueue ID3D12DebugCommandQueue;
-
-#endif 	/* __ID3D12DebugCommandQueue_FWD_DEFINED__ */
-
-
-#ifndef __ID3D12DebugCommandList1_FWD_DEFINED__
-#define __ID3D12DebugCommandList1_FWD_DEFINED__
-typedef interface ID3D12DebugCommandList1 ID3D12DebugCommandList1;
-
-#endif 	/* __ID3D12DebugCommandList1_FWD_DEFINED__ */
-
-
-#ifndef __ID3D12DebugCommandList_FWD_DEFINED__
-#define __ID3D12DebugCommandList_FWD_DEFINED__
-typedef interface ID3D12DebugCommandList ID3D12DebugCommandList;
-
-#endif 	/* __ID3D12DebugCommandList_FWD_DEFINED__ */
-
-
-#ifndef __ID3D12DebugCommandList2_FWD_DEFINED__
-#define __ID3D12DebugCommandList2_FWD_DEFINED__
-typedef interface ID3D12DebugCommandList2 ID3D12DebugCommandList2;
-
-#endif 	/* __ID3D12DebugCommandList2_FWD_DEFINED__ */
-
-
-#ifndef __ID3D12SharingContract_FWD_DEFINED__
-#define __ID3D12SharingContract_FWD_DEFINED__
-typedef interface ID3D12SharingContract ID3D12SharingContract;
-
-#endif 	/* __ID3D12SharingContract_FWD_DEFINED__ */
-
-
-#ifndef __ID3D12InfoQueue_FWD_DEFINED__
-#define __ID3D12InfoQueue_FWD_DEFINED__
-typedef interface ID3D12InfoQueue ID3D12InfoQueue;
-
-#endif 	/* __ID3D12InfoQueue_FWD_DEFINED__ */
-
-
-/* header files for imported files */
-#include "oaidl.h"
-#include "ocidl.h"
-#include "d3d12.h"
-
-#ifdef __cplusplus
-extern "C"{
-#endif 
-
-
-/* interface __MIDL_itf_d3d12sdklayers_0000_0000 */
-/* [local] */ 
-
-
-
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0000_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0000_v0_0_s_ifspec;
-
-#ifndef __ID3D12Debug_INTERFACE_DEFINED__
-#define __ID3D12Debug_INTERFACE_DEFINED__
-
-/* interface ID3D12Debug */
-/* [unique][local][object][uuid] */ 
-
-
-EXTERN_C const IID IID_ID3D12Debug;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("344488b7-6846-474b-b989-f027448245e0")
-    ID3D12Debug : public IUnknown
-    {
-    public:
-        virtual void STDMETHODCALLTYPE EnableDebugLayer( void) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct ID3D12DebugVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            ID3D12Debug * This,
-            REFIID riid,
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            ID3D12Debug * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            ID3D12Debug * This);
-        
-        void ( STDMETHODCALLTYPE *EnableDebugLayer )( 
-            ID3D12Debug * This);
-        
-        END_INTERFACE
-    } ID3D12DebugVtbl;
-
-    interface ID3D12Debug
-    {
-        CONST_VTBL struct ID3D12DebugVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define ID3D12Debug_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define ID3D12Debug_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define ID3D12Debug_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define ID3D12Debug_EnableDebugLayer(This)	\
-    ( (This)->lpVtbl -> EnableDebugLayer(This) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __ID3D12Debug_INTERFACE_DEFINED__ */
-
-
-/* interface __MIDL_itf_d3d12sdklayers_0000_0001 */
-/* [local] */ 
-
-typedef 
-enum D3D12_GPU_BASED_VALIDATION_FLAGS
-    {
-        D3D12_GPU_BASED_VALIDATION_FLAGS_NONE	= 0,
-        D3D12_GPU_BASED_VALIDATION_FLAGS_DISABLE_STATE_TRACKING	= 0x1
-    } 	D3D12_GPU_BASED_VALIDATION_FLAGS;
-
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_GPU_BASED_VALIDATION_FLAGS)
-
-
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0001_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0001_v0_0_s_ifspec;
-
-#ifndef __ID3D12Debug1_INTERFACE_DEFINED__
-#define __ID3D12Debug1_INTERFACE_DEFINED__
-
-/* interface ID3D12Debug1 */
-/* [unique][local][object][uuid] */ 
-
-
-EXTERN_C const IID IID_ID3D12Debug1;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("affaa4ca-63fe-4d8e-b8ad-159000af4304")
-    ID3D12Debug1 : public IUnknown
-    {
-    public:
-        virtual void STDMETHODCALLTYPE EnableDebugLayer( void) = 0;
-        
-        virtual void STDMETHODCALLTYPE SetEnableGPUBasedValidation( 
-            BOOL Enable) = 0;
-        
-        virtual void STDMETHODCALLTYPE SetEnableSynchronizedCommandQueueValidation( 
-            BOOL Enable) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct ID3D12Debug1Vtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            ID3D12Debug1 * This,
-            REFIID riid,
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            ID3D12Debug1 * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            ID3D12Debug1 * This);
-        
-        void ( STDMETHODCALLTYPE *EnableDebugLayer )( 
-            ID3D12Debug1 * This);
-        
-        void ( STDMETHODCALLTYPE *SetEnableGPUBasedValidation )( 
-            ID3D12Debug1 * This,
-            BOOL Enable);
-        
-        void ( STDMETHODCALLTYPE *SetEnableSynchronizedCommandQueueValidation )( 
-            ID3D12Debug1 * This,
-            BOOL Enable);
-        
-        END_INTERFACE
-    } ID3D12Debug1Vtbl;
-
-    interface ID3D12Debug1
-    {
-        CONST_VTBL struct ID3D12Debug1Vtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define ID3D12Debug1_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define ID3D12Debug1_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define ID3D12Debug1_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define ID3D12Debug1_EnableDebugLayer(This)	\
-    ( (This)->lpVtbl -> EnableDebugLayer(This) ) 
-
-#define ID3D12Debug1_SetEnableGPUBasedValidation(This,Enable)	\
-    ( (This)->lpVtbl -> SetEnableGPUBasedValidation(This,Enable) ) 
-
-#define ID3D12Debug1_SetEnableSynchronizedCommandQueueValidation(This,Enable)	\
-    ( (This)->lpVtbl -> SetEnableSynchronizedCommandQueueValidation(This,Enable) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __ID3D12Debug1_INTERFACE_DEFINED__ */
-
-
-#ifndef __ID3D12Debug2_INTERFACE_DEFINED__
-#define __ID3D12Debug2_INTERFACE_DEFINED__
-
-/* interface ID3D12Debug2 */
-/* [unique][local][object][uuid] */ 
-
-
-EXTERN_C const IID IID_ID3D12Debug2;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("93a665c4-a3b2-4e5d-b692-a26ae14e3374")
-    ID3D12Debug2 : public IUnknown
-    {
-    public:
-        virtual void STDMETHODCALLTYPE SetGPUBasedValidationFlags( 
-            D3D12_GPU_BASED_VALIDATION_FLAGS Flags) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct ID3D12Debug2Vtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            ID3D12Debug2 * This,
-            REFIID riid,
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            ID3D12Debug2 * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            ID3D12Debug2 * This);
-        
-        void ( STDMETHODCALLTYPE *SetGPUBasedValidationFlags )( 
-            ID3D12Debug2 * This,
-            D3D12_GPU_BASED_VALIDATION_FLAGS Flags);
-        
-        END_INTERFACE
-    } ID3D12Debug2Vtbl;
-
-    interface ID3D12Debug2
-    {
-        CONST_VTBL struct ID3D12Debug2Vtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define ID3D12Debug2_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define ID3D12Debug2_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define ID3D12Debug2_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define ID3D12Debug2_SetGPUBasedValidationFlags(This,Flags)	\
-    ( (This)->lpVtbl -> SetGPUBasedValidationFlags(This,Flags) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __ID3D12Debug2_INTERFACE_DEFINED__ */
-
-
-#ifndef __ID3D12Debug3_INTERFACE_DEFINED__
-#define __ID3D12Debug3_INTERFACE_DEFINED__
-
-/* interface ID3D12Debug3 */
-/* [unique][local][object][uuid] */ 
-
-
-EXTERN_C const IID IID_ID3D12Debug3;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("5cf4e58f-f671-4ff1-a542-3686e3d153d1")
-    ID3D12Debug3 : public ID3D12Debug
-    {
-    public:
-        virtual void STDMETHODCALLTYPE SetEnableGPUBasedValidation( 
-            BOOL Enable) = 0;
-        
-        virtual void STDMETHODCALLTYPE SetEnableSynchronizedCommandQueueValidation( 
-            BOOL Enable) = 0;
-        
-        virtual void STDMETHODCALLTYPE SetGPUBasedValidationFlags( 
-            D3D12_GPU_BASED_VALIDATION_FLAGS Flags) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct ID3D12Debug3Vtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            ID3D12Debug3 * This,
-            REFIID riid,
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            ID3D12Debug3 * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            ID3D12Debug3 * This);
-        
-        void ( STDMETHODCALLTYPE *EnableDebugLayer )( 
-            ID3D12Debug3 * This);
-        
-        void ( STDMETHODCALLTYPE *SetEnableGPUBasedValidation )( 
-            ID3D12Debug3 * This,
-            BOOL Enable);
-        
-        void ( STDMETHODCALLTYPE *SetEnableSynchronizedCommandQueueValidation )( 
-            ID3D12Debug3 * This,
-            BOOL Enable);
-        
-        void ( STDMETHODCALLTYPE *SetGPUBasedValidationFlags )( 
-            ID3D12Debug3 * This,
-            D3D12_GPU_BASED_VALIDATION_FLAGS Flags);
-        
-        END_INTERFACE
-    } ID3D12Debug3Vtbl;
-
-    interface ID3D12Debug3
-    {
-        CONST_VTBL struct ID3D12Debug3Vtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define ID3D12Debug3_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define ID3D12Debug3_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define ID3D12Debug3_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define ID3D12Debug3_EnableDebugLayer(This)	\
-    ( (This)->lpVtbl -> EnableDebugLayer(This) ) 
-
-
-#define ID3D12Debug3_SetEnableGPUBasedValidation(This,Enable)	\
-    ( (This)->lpVtbl -> SetEnableGPUBasedValidation(This,Enable) ) 
-
-#define ID3D12Debug3_SetEnableSynchronizedCommandQueueValidation(This,Enable)	\
-    ( (This)->lpVtbl -> SetEnableSynchronizedCommandQueueValidation(This,Enable) ) 
-
-#define ID3D12Debug3_SetGPUBasedValidationFlags(This,Flags)	\
-    ( (This)->lpVtbl -> SetGPUBasedValidationFlags(This,Flags) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __ID3D12Debug3_INTERFACE_DEFINED__ */
-
-
-/* interface __MIDL_itf_d3d12sdklayers_0000_0004 */
-/* [local] */ 
-
-typedef 
-enum D3D12_RLDO_FLAGS
-    {
-        D3D12_RLDO_NONE	= 0,
-        D3D12_RLDO_SUMMARY	= 0x1,
-        D3D12_RLDO_DETAIL	= 0x2,
-        D3D12_RLDO_IGNORE_INTERNAL	= 0x4
-    } 	D3D12_RLDO_FLAGS;
-
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_RLDO_FLAGS)
-typedef 
-enum D3D12_DEBUG_DEVICE_PARAMETER_TYPE
-    {
-        D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS	= 0,
-        D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS	= ( D3D12_DEBUG_DEVICE_PARAMETER_FEATURE_FLAGS + 1 ) ,
-        D3D12_DEBUG_DEVICE_PARAMETER_GPU_SLOWDOWN_PERFORMANCE_FACTOR	= ( D3D12_DEBUG_DEVICE_PARAMETER_GPU_BASED_VALIDATION_SETTINGS + 1 ) 
-    } 	D3D12_DEBUG_DEVICE_PARAMETER_TYPE;
-
-typedef 
-enum D3D12_DEBUG_FEATURE
-    {
-        D3D12_DEBUG_FEATURE_NONE	= 0,
-        D3D12_DEBUG_FEATURE_ALLOW_BEHAVIOR_CHANGING_DEBUG_AIDS	= 0x1,
-        D3D12_DEBUG_FEATURE_CONSERVATIVE_RESOURCE_STATE_TRACKING	= 0x2,
-        D3D12_DEBUG_FEATURE_DISABLE_VIRTUALIZED_BUNDLES_VALIDATION	= 0x4,
-        D3D12_DEBUG_FEATURE_EMULATE_WINDOWS7	= 0x8
-    } 	D3D12_DEBUG_FEATURE;
-
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_DEBUG_FEATURE)
-typedef 
-enum D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE
-    {
-        D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_NONE	= 0,
-        D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_STATE_TRACKING_ONLY	= ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_NONE + 1 ) ,
-        D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_UNGUARDED_VALIDATION	= ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_STATE_TRACKING_ONLY + 1 ) ,
-        D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_GUARDED_VALIDATION	= ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_UNGUARDED_VALIDATION + 1 ) ,
-        NUM_D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODES	= ( D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE_GUARDED_VALIDATION + 1 ) 
-    } 	D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE;
-
-typedef 
-enum D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS
-    {
-        D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_NONE	= 0,
-        D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_TRACKING_ONLY_SHADERS	= 0x1,
-        D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_UNGUARDED_VALIDATION_SHADERS	= 0x2,
-        D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAG_FRONT_LOAD_CREATE_GUARDED_VALIDATION_SHADERS	= 0x4,
-        D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS_VALID_MASK	= 0x7
-    } 	D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS;
-
-DEFINE_ENUM_FLAG_OPERATORS(D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS)
-typedef struct D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS
-    {
-    UINT MaxMessagesPerCommandList;
-    D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE DefaultShaderPatchMode;
-    D3D12_GPU_BASED_VALIDATION_PIPELINE_STATE_CREATE_FLAGS PipelineStateCreateFlags;
-    } 	D3D12_DEBUG_DEVICE_GPU_BASED_VALIDATION_SETTINGS;
-
-typedef struct D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR
-    {
-    FLOAT SlowdownFactor;
-    } 	D3D12_DEBUG_DEVICE_GPU_SLOWDOWN_PERFORMANCE_FACTOR;
-
-
-
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0004_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0004_v0_0_s_ifspec;
-
-#ifndef __ID3D12DebugDevice1_INTERFACE_DEFINED__
-#define __ID3D12DebugDevice1_INTERFACE_DEFINED__
-
-/* interface ID3D12DebugDevice1 */
-/* [unique][local][object][uuid] */ 
-
-
-EXTERN_C const IID IID_ID3D12DebugDevice1;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("a9b71770-d099-4a65-a698-3dee10020f88")
-    ID3D12DebugDevice1 : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( 
-            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
-            _In_reads_bytes_(DataSize)  const void *pData,
-            UINT DataSize) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( 
-            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
-            _Out_writes_bytes_(DataSize)  void *pData,
-            UINT DataSize) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE ReportLiveDeviceObjects( 
-            D3D12_RLDO_FLAGS Flags) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct ID3D12DebugDevice1Vtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            ID3D12DebugDevice1 * This,
-            REFIID riid,
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            ID3D12DebugDevice1 * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            ID3D12DebugDevice1 * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( 
-            ID3D12DebugDevice1 * This,
-            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
-            _In_reads_bytes_(DataSize)  const void *pData,
-            UINT DataSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( 
-            ID3D12DebugDevice1 * This,
-            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
-            _Out_writes_bytes_(DataSize)  void *pData,
-            UINT DataSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *ReportLiveDeviceObjects )( 
-            ID3D12DebugDevice1 * This,
-            D3D12_RLDO_FLAGS Flags);
-        
-        END_INTERFACE
-    } ID3D12DebugDevice1Vtbl;
-
-    interface ID3D12DebugDevice1
-    {
-        CONST_VTBL struct ID3D12DebugDevice1Vtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define ID3D12DebugDevice1_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define ID3D12DebugDevice1_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define ID3D12DebugDevice1_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define ID3D12DebugDevice1_SetDebugParameter(This,Type,pData,DataSize)	\
-    ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) 
-
-#define ID3D12DebugDevice1_GetDebugParameter(This,Type,pData,DataSize)	\
-    ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) 
-
-#define ID3D12DebugDevice1_ReportLiveDeviceObjects(This,Flags)	\
-    ( (This)->lpVtbl -> ReportLiveDeviceObjects(This,Flags) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __ID3D12DebugDevice1_INTERFACE_DEFINED__ */
-
-
-#ifndef __ID3D12DebugDevice_INTERFACE_DEFINED__
-#define __ID3D12DebugDevice_INTERFACE_DEFINED__
-
-/* interface ID3D12DebugDevice */
-/* [unique][local][object][uuid] */ 
-
-
-EXTERN_C const IID IID_ID3D12DebugDevice;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("3febd6dd-4973-4787-8194-e45f9e28923e")
-    ID3D12DebugDevice : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE SetFeatureMask( 
-            D3D12_DEBUG_FEATURE Mask) = 0;
-        
-        virtual D3D12_DEBUG_FEATURE STDMETHODCALLTYPE GetFeatureMask( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE ReportLiveDeviceObjects( 
-            D3D12_RLDO_FLAGS Flags) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct ID3D12DebugDeviceVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            ID3D12DebugDevice * This,
-            REFIID riid,
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            ID3D12DebugDevice * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            ID3D12DebugDevice * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( 
-            ID3D12DebugDevice * This,
-            D3D12_DEBUG_FEATURE Mask);
-        
-        D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( 
-            ID3D12DebugDevice * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *ReportLiveDeviceObjects )( 
-            ID3D12DebugDevice * This,
-            D3D12_RLDO_FLAGS Flags);
-        
-        END_INTERFACE
-    } ID3D12DebugDeviceVtbl;
-
-    interface ID3D12DebugDevice
-    {
-        CONST_VTBL struct ID3D12DebugDeviceVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define ID3D12DebugDevice_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define ID3D12DebugDevice_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define ID3D12DebugDevice_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define ID3D12DebugDevice_SetFeatureMask(This,Mask)	\
-    ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) 
-
-#define ID3D12DebugDevice_GetFeatureMask(This)	\
-    ( (This)->lpVtbl -> GetFeatureMask(This) ) 
-
-#define ID3D12DebugDevice_ReportLiveDeviceObjects(This,Flags)	\
-    ( (This)->lpVtbl -> ReportLiveDeviceObjects(This,Flags) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __ID3D12DebugDevice_INTERFACE_DEFINED__ */
-
-
-#ifndef __ID3D12DebugDevice2_INTERFACE_DEFINED__
-#define __ID3D12DebugDevice2_INTERFACE_DEFINED__
-
-/* interface ID3D12DebugDevice2 */
-/* [unique][local][object][uuid] */ 
-
-
-EXTERN_C const IID IID_ID3D12DebugDevice2;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("60eccbc1-378d-4df1-894c-f8ac5ce4d7dd")
-    ID3D12DebugDevice2 : public ID3D12DebugDevice
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( 
-            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
-            _In_reads_bytes_(DataSize)  const void *pData,
-            UINT DataSize) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( 
-            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
-            _Out_writes_bytes_(DataSize)  void *pData,
-            UINT DataSize) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct ID3D12DebugDevice2Vtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            ID3D12DebugDevice2 * This,
-            REFIID riid,
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            ID3D12DebugDevice2 * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            ID3D12DebugDevice2 * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( 
-            ID3D12DebugDevice2 * This,
-            D3D12_DEBUG_FEATURE Mask);
-        
-        D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( 
-            ID3D12DebugDevice2 * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *ReportLiveDeviceObjects )( 
-            ID3D12DebugDevice2 * This,
-            D3D12_RLDO_FLAGS Flags);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( 
-            ID3D12DebugDevice2 * This,
-            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
-            _In_reads_bytes_(DataSize)  const void *pData,
-            UINT DataSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( 
-            ID3D12DebugDevice2 * This,
-            D3D12_DEBUG_DEVICE_PARAMETER_TYPE Type,
-            _Out_writes_bytes_(DataSize)  void *pData,
-            UINT DataSize);
-        
-        END_INTERFACE
-    } ID3D12DebugDevice2Vtbl;
-
-    interface ID3D12DebugDevice2
-    {
-        CONST_VTBL struct ID3D12DebugDevice2Vtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define ID3D12DebugDevice2_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define ID3D12DebugDevice2_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define ID3D12DebugDevice2_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define ID3D12DebugDevice2_SetFeatureMask(This,Mask)	\
-    ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) 
-
-#define ID3D12DebugDevice2_GetFeatureMask(This)	\
-    ( (This)->lpVtbl -> GetFeatureMask(This) ) 
-
-#define ID3D12DebugDevice2_ReportLiveDeviceObjects(This,Flags)	\
-    ( (This)->lpVtbl -> ReportLiveDeviceObjects(This,Flags) ) 
-
-
-#define ID3D12DebugDevice2_SetDebugParameter(This,Type,pData,DataSize)	\
-    ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) 
-
-#define ID3D12DebugDevice2_GetDebugParameter(This,Type,pData,DataSize)	\
-    ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __ID3D12DebugDevice2_INTERFACE_DEFINED__ */
-
-
-/* interface __MIDL_itf_d3d12sdklayers_0000_0007 */
-/* [local] */ 
-
-DEFINE_GUID(DXGI_DEBUG_D3D12, 0xcf59a98c, 0xa950, 0x4326, 0x91, 0xef, 0x9b, 0xba, 0xa1, 0x7b, 0xfd, 0x95);
-
-
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0007_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0007_v0_0_s_ifspec;
-
-#ifndef __ID3D12DebugCommandQueue_INTERFACE_DEFINED__
-#define __ID3D12DebugCommandQueue_INTERFACE_DEFINED__
-
-/* interface ID3D12DebugCommandQueue */
-/* [unique][local][object][uuid] */ 
-
-
-EXTERN_C const IID IID_ID3D12DebugCommandQueue;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("09e0bf36-54ac-484f-8847-4baeeab6053a")
-    ID3D12DebugCommandQueue : public IUnknown
-    {
-    public:
-        virtual BOOL STDMETHODCALLTYPE AssertResourceState( 
-            _In_  ID3D12Resource *pResource,
-            UINT Subresource,
-            UINT State) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct ID3D12DebugCommandQueueVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            ID3D12DebugCommandQueue * This,
-            REFIID riid,
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            ID3D12DebugCommandQueue * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            ID3D12DebugCommandQueue * This);
-        
-        BOOL ( STDMETHODCALLTYPE *AssertResourceState )( 
-            ID3D12DebugCommandQueue * This,
-            _In_  ID3D12Resource *pResource,
-            UINT Subresource,
-            UINT State);
-        
-        END_INTERFACE
-    } ID3D12DebugCommandQueueVtbl;
-
-    interface ID3D12DebugCommandQueue
-    {
-        CONST_VTBL struct ID3D12DebugCommandQueueVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define ID3D12DebugCommandQueue_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define ID3D12DebugCommandQueue_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define ID3D12DebugCommandQueue_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define ID3D12DebugCommandQueue_AssertResourceState(This,pResource,Subresource,State)	\
-    ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __ID3D12DebugCommandQueue_INTERFACE_DEFINED__ */
-
-
-/* interface __MIDL_itf_d3d12sdklayers_0000_0008 */
-/* [local] */ 
-
-typedef 
-enum D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE
-    {
-        D3D12_DEBUG_COMMAND_LIST_PARAMETER_GPU_BASED_VALIDATION_SETTINGS	= 0
-    } 	D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE;
-
-typedef struct D3D12_DEBUG_COMMAND_LIST_GPU_BASED_VALIDATION_SETTINGS
-    {
-    D3D12_GPU_BASED_VALIDATION_SHADER_PATCH_MODE ShaderPatchMode;
-    } 	D3D12_DEBUG_COMMAND_LIST_GPU_BASED_VALIDATION_SETTINGS;
-
-
-
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0008_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0008_v0_0_s_ifspec;
-
-#ifndef __ID3D12DebugCommandList1_INTERFACE_DEFINED__
-#define __ID3D12DebugCommandList1_INTERFACE_DEFINED__
-
-/* interface ID3D12DebugCommandList1 */
-/* [unique][local][object][uuid] */ 
-
-
-EXTERN_C const IID IID_ID3D12DebugCommandList1;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("102ca951-311b-4b01-b11f-ecb83e061b37")
-    ID3D12DebugCommandList1 : public IUnknown
-    {
-    public:
-        virtual BOOL STDMETHODCALLTYPE AssertResourceState( 
-            _In_  ID3D12Resource *pResource,
-            UINT Subresource,
-            UINT State) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( 
-            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
-            _In_reads_bytes_(DataSize)  const void *pData,
-            UINT DataSize) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( 
-            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
-            _Out_writes_bytes_(DataSize)  void *pData,
-            UINT DataSize) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct ID3D12DebugCommandList1Vtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            ID3D12DebugCommandList1 * This,
-            REFIID riid,
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            ID3D12DebugCommandList1 * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            ID3D12DebugCommandList1 * This);
-        
-        BOOL ( STDMETHODCALLTYPE *AssertResourceState )( 
-            ID3D12DebugCommandList1 * This,
-            _In_  ID3D12Resource *pResource,
-            UINT Subresource,
-            UINT State);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( 
-            ID3D12DebugCommandList1 * This,
-            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
-            _In_reads_bytes_(DataSize)  const void *pData,
-            UINT DataSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( 
-            ID3D12DebugCommandList1 * This,
-            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
-            _Out_writes_bytes_(DataSize)  void *pData,
-            UINT DataSize);
-        
-        END_INTERFACE
-    } ID3D12DebugCommandList1Vtbl;
-
-    interface ID3D12DebugCommandList1
-    {
-        CONST_VTBL struct ID3D12DebugCommandList1Vtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define ID3D12DebugCommandList1_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define ID3D12DebugCommandList1_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define ID3D12DebugCommandList1_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define ID3D12DebugCommandList1_AssertResourceState(This,pResource,Subresource,State)	\
-    ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) 
-
-#define ID3D12DebugCommandList1_SetDebugParameter(This,Type,pData,DataSize)	\
-    ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) 
-
-#define ID3D12DebugCommandList1_GetDebugParameter(This,Type,pData,DataSize)	\
-    ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __ID3D12DebugCommandList1_INTERFACE_DEFINED__ */
-
-
-#ifndef __ID3D12DebugCommandList_INTERFACE_DEFINED__
-#define __ID3D12DebugCommandList_INTERFACE_DEFINED__
-
-/* interface ID3D12DebugCommandList */
-/* [unique][local][object][uuid] */ 
-
-
-EXTERN_C const IID IID_ID3D12DebugCommandList;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("09e0bf36-54ac-484f-8847-4baeeab6053f")
-    ID3D12DebugCommandList : public IUnknown
-    {
-    public:
-        virtual BOOL STDMETHODCALLTYPE AssertResourceState( 
-            _In_  ID3D12Resource *pResource,
-            UINT Subresource,
-            UINT State) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE SetFeatureMask( 
-            D3D12_DEBUG_FEATURE Mask) = 0;
-        
-        virtual D3D12_DEBUG_FEATURE STDMETHODCALLTYPE GetFeatureMask( void) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct ID3D12DebugCommandListVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            ID3D12DebugCommandList * This,
-            REFIID riid,
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            ID3D12DebugCommandList * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            ID3D12DebugCommandList * This);
-        
-        BOOL ( STDMETHODCALLTYPE *AssertResourceState )( 
-            ID3D12DebugCommandList * This,
-            _In_  ID3D12Resource *pResource,
-            UINT Subresource,
-            UINT State);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( 
-            ID3D12DebugCommandList * This,
-            D3D12_DEBUG_FEATURE Mask);
-        
-        D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( 
-            ID3D12DebugCommandList * This);
-        
-        END_INTERFACE
-    } ID3D12DebugCommandListVtbl;
-
-    interface ID3D12DebugCommandList
-    {
-        CONST_VTBL struct ID3D12DebugCommandListVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define ID3D12DebugCommandList_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define ID3D12DebugCommandList_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define ID3D12DebugCommandList_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define ID3D12DebugCommandList_AssertResourceState(This,pResource,Subresource,State)	\
-    ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) 
-
-#define ID3D12DebugCommandList_SetFeatureMask(This,Mask)	\
-    ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) 
-
-#define ID3D12DebugCommandList_GetFeatureMask(This)	\
-    ( (This)->lpVtbl -> GetFeatureMask(This) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __ID3D12DebugCommandList_INTERFACE_DEFINED__ */
-
-
-#ifndef __ID3D12DebugCommandList2_INTERFACE_DEFINED__
-#define __ID3D12DebugCommandList2_INTERFACE_DEFINED__
-
-/* interface ID3D12DebugCommandList2 */
-/* [unique][local][object][uuid] */ 
-
-
-EXTERN_C const IID IID_ID3D12DebugCommandList2;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("aeb575cf-4e06-48be-ba3b-c450fc96652e")
-    ID3D12DebugCommandList2 : public ID3D12DebugCommandList
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE SetDebugParameter( 
-            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
-            _In_reads_bytes_(DataSize)  const void *pData,
-            UINT DataSize) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetDebugParameter( 
-            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
-            _Out_writes_bytes_(DataSize)  void *pData,
-            UINT DataSize) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct ID3D12DebugCommandList2Vtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            ID3D12DebugCommandList2 * This,
-            REFIID riid,
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            ID3D12DebugCommandList2 * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            ID3D12DebugCommandList2 * This);
-        
-        BOOL ( STDMETHODCALLTYPE *AssertResourceState )( 
-            ID3D12DebugCommandList2 * This,
-            _In_  ID3D12Resource *pResource,
-            UINT Subresource,
-            UINT State);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetFeatureMask )( 
-            ID3D12DebugCommandList2 * This,
-            D3D12_DEBUG_FEATURE Mask);
-        
-        D3D12_DEBUG_FEATURE ( STDMETHODCALLTYPE *GetFeatureMask )( 
-            ID3D12DebugCommandList2 * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetDebugParameter )( 
-            ID3D12DebugCommandList2 * This,
-            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
-            _In_reads_bytes_(DataSize)  const void *pData,
-            UINT DataSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetDebugParameter )( 
-            ID3D12DebugCommandList2 * This,
-            D3D12_DEBUG_COMMAND_LIST_PARAMETER_TYPE Type,
-            _Out_writes_bytes_(DataSize)  void *pData,
-            UINT DataSize);
-        
-        END_INTERFACE
-    } ID3D12DebugCommandList2Vtbl;
-
-    interface ID3D12DebugCommandList2
-    {
-        CONST_VTBL struct ID3D12DebugCommandList2Vtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define ID3D12DebugCommandList2_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define ID3D12DebugCommandList2_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define ID3D12DebugCommandList2_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define ID3D12DebugCommandList2_AssertResourceState(This,pResource,Subresource,State)	\
-    ( (This)->lpVtbl -> AssertResourceState(This,pResource,Subresource,State) ) 
-
-#define ID3D12DebugCommandList2_SetFeatureMask(This,Mask)	\
-    ( (This)->lpVtbl -> SetFeatureMask(This,Mask) ) 
-
-#define ID3D12DebugCommandList2_GetFeatureMask(This)	\
-    ( (This)->lpVtbl -> GetFeatureMask(This) ) 
-
-
-#define ID3D12DebugCommandList2_SetDebugParameter(This,Type,pData,DataSize)	\
-    ( (This)->lpVtbl -> SetDebugParameter(This,Type,pData,DataSize) ) 
-
-#define ID3D12DebugCommandList2_GetDebugParameter(This,Type,pData,DataSize)	\
-    ( (This)->lpVtbl -> GetDebugParameter(This,Type,pData,DataSize) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __ID3D12DebugCommandList2_INTERFACE_DEFINED__ */
-
-
-#ifndef __ID3D12SharingContract_INTERFACE_DEFINED__
-#define __ID3D12SharingContract_INTERFACE_DEFINED__
-
-/* interface ID3D12SharingContract */
-/* [unique][local][object][uuid] */ 
-
-
-EXTERN_C const IID IID_ID3D12SharingContract;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("0adf7d52-929c-4e61-addb-ffed30de66ef")
-    ID3D12SharingContract : public IUnknown
-    {
-    public:
-        virtual void STDMETHODCALLTYPE Present( 
-            _In_  ID3D12Resource *pResource,
-            UINT Subresource,
-            _In_  HWND window) = 0;
-        
-        virtual void STDMETHODCALLTYPE SharedFenceSignal( 
-            _In_  ID3D12Fence *pFence,
-            UINT64 FenceValue) = 0;
-        
-        virtual void STDMETHODCALLTYPE BeginCapturableWork( 
-            _In_  REFGUID guid) = 0;
-        
-        virtual void STDMETHODCALLTYPE EndCapturableWork( 
-            _In_  REFGUID guid) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct ID3D12SharingContractVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            ID3D12SharingContract * This,
-            REFIID riid,
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            ID3D12SharingContract * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            ID3D12SharingContract * This);
-        
-        void ( STDMETHODCALLTYPE *Present )( 
-            ID3D12SharingContract * This,
-            _In_  ID3D12Resource *pResource,
-            UINT Subresource,
-            _In_  HWND window);
-        
-        void ( STDMETHODCALLTYPE *SharedFenceSignal )( 
-            ID3D12SharingContract * This,
-            _In_  ID3D12Fence *pFence,
-            UINT64 FenceValue);
-        
-        void ( STDMETHODCALLTYPE *BeginCapturableWork )( 
-            ID3D12SharingContract * This,
-            _In_  REFGUID guid);
-        
-        void ( STDMETHODCALLTYPE *EndCapturableWork )( 
-            ID3D12SharingContract * This,
-            _In_  REFGUID guid);
-        
-        END_INTERFACE
-    } ID3D12SharingContractVtbl;
-
-    interface ID3D12SharingContract
-    {
-        CONST_VTBL struct ID3D12SharingContractVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define ID3D12SharingContract_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define ID3D12SharingContract_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define ID3D12SharingContract_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define ID3D12SharingContract_Present(This,pResource,Subresource,window)	\
-    ( (This)->lpVtbl -> Present(This,pResource,Subresource,window) ) 
-
-#define ID3D12SharingContract_SharedFenceSignal(This,pFence,FenceValue)	\
-    ( (This)->lpVtbl -> SharedFenceSignal(This,pFence,FenceValue) ) 
-
-#define ID3D12SharingContract_BeginCapturableWork(This,guid)	\
-    ( (This)->lpVtbl -> BeginCapturableWork(This,guid) ) 
-
-#define ID3D12SharingContract_EndCapturableWork(This,guid)	\
-    ( (This)->lpVtbl -> EndCapturableWork(This,guid) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __ID3D12SharingContract_INTERFACE_DEFINED__ */
-
-
-/* interface __MIDL_itf_d3d12sdklayers_0000_0012 */
-/* [local] */ 
-
-typedef 
-enum D3D12_MESSAGE_CATEGORY
-    {
-        D3D12_MESSAGE_CATEGORY_APPLICATION_DEFINED	= 0,
-        D3D12_MESSAGE_CATEGORY_MISCELLANEOUS	= ( D3D12_MESSAGE_CATEGORY_APPLICATION_DEFINED + 1 ) ,
-        D3D12_MESSAGE_CATEGORY_INITIALIZATION	= ( D3D12_MESSAGE_CATEGORY_MISCELLANEOUS + 1 ) ,
-        D3D12_MESSAGE_CATEGORY_CLEANUP	= ( D3D12_MESSAGE_CATEGORY_INITIALIZATION + 1 ) ,
-        D3D12_MESSAGE_CATEGORY_COMPILATION	= ( D3D12_MESSAGE_CATEGORY_CLEANUP + 1 ) ,
-        D3D12_MESSAGE_CATEGORY_STATE_CREATION	= ( D3D12_MESSAGE_CATEGORY_COMPILATION + 1 ) ,
-        D3D12_MESSAGE_CATEGORY_STATE_SETTING	= ( D3D12_MESSAGE_CATEGORY_STATE_CREATION + 1 ) ,
-        D3D12_MESSAGE_CATEGORY_STATE_GETTING	= ( D3D12_MESSAGE_CATEGORY_STATE_SETTING + 1 ) ,
-        D3D12_MESSAGE_CATEGORY_RESOURCE_MANIPULATION	= ( D3D12_MESSAGE_CATEGORY_STATE_GETTING + 1 ) ,
-        D3D12_MESSAGE_CATEGORY_EXECUTION	= ( D3D12_MESSAGE_CATEGORY_RESOURCE_MANIPULATION + 1 ) ,
-        D3D12_MESSAGE_CATEGORY_SHADER	= ( D3D12_MESSAGE_CATEGORY_EXECUTION + 1 ) 
-    } 	D3D12_MESSAGE_CATEGORY;
-
-typedef 
-enum D3D12_MESSAGE_SEVERITY
-    {
-        D3D12_MESSAGE_SEVERITY_CORRUPTION	= 0,
-        D3D12_MESSAGE_SEVERITY_ERROR	= ( D3D12_MESSAGE_SEVERITY_CORRUPTION + 1 ) ,
-        D3D12_MESSAGE_SEVERITY_WARNING	= ( D3D12_MESSAGE_SEVERITY_ERROR + 1 ) ,
-        D3D12_MESSAGE_SEVERITY_INFO	= ( D3D12_MESSAGE_SEVERITY_WARNING + 1 ) ,
-        D3D12_MESSAGE_SEVERITY_MESSAGE	= ( D3D12_MESSAGE_SEVERITY_INFO + 1 ) 
-    } 	D3D12_MESSAGE_SEVERITY;
-
-typedef 
-enum D3D12_MESSAGE_ID
-    {
-        D3D12_MESSAGE_ID_UNKNOWN	= 0,
-        D3D12_MESSAGE_ID_STRING_FROM_APPLICATION	= ( D3D12_MESSAGE_ID_UNKNOWN + 1 ) ,
-        D3D12_MESSAGE_ID_CORRUPTED_THIS	= ( D3D12_MESSAGE_ID_STRING_FROM_APPLICATION + 1 ) ,
-        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER1	= ( D3D12_MESSAGE_ID_CORRUPTED_THIS + 1 ) ,
-        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER2	= ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER1 + 1 ) ,
-        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER3	= ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER2 + 1 ) ,
-        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER4	= ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER3 + 1 ) ,
-        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER5	= ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER4 + 1 ) ,
-        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER6	= ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER5 + 1 ) ,
-        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER7	= ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER6 + 1 ) ,
-        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER8	= ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER7 + 1 ) ,
-        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER9	= ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER8 + 1 ) ,
-        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER10	= ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER9 + 1 ) ,
-        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER11	= ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER10 + 1 ) ,
-        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER12	= ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER11 + 1 ) ,
-        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER13	= ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER12 + 1 ) ,
-        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER14	= ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER13 + 1 ) ,
-        D3D12_MESSAGE_ID_CORRUPTED_PARAMETER15	= ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER14 + 1 ) ,
-        D3D12_MESSAGE_ID_CORRUPTED_MULTITHREADING	= ( D3D12_MESSAGE_ID_CORRUPTED_PARAMETER15 + 1 ) ,
-        D3D12_MESSAGE_ID_MESSAGE_REPORTING_OUTOFMEMORY	= ( D3D12_MESSAGE_ID_CORRUPTED_MULTITHREADING + 1 ) ,
-        D3D12_MESSAGE_ID_GETPRIVATEDATA_MOREDATA	= ( D3D12_MESSAGE_ID_MESSAGE_REPORTING_OUTOFMEMORY + 1 ) ,
-        D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDFREEDATA	= ( D3D12_MESSAGE_ID_GETPRIVATEDATA_MOREDATA + 1 ) ,
-        D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDIUNKNOWN	= ( D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDFREEDATA + 1 ) ,
-        D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDFLAGS	= ( D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDIUNKNOWN + 1 ) ,
-        D3D12_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS	= ( D3D12_MESSAGE_ID_SETPRIVATEDATA_INVALIDFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_SETPRIVATEDATA_OUTOFMEMORY	= ( D3D12_MESSAGE_ID_SETPRIVATEDATA_CHANGINGPARAMS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT	= ( D3D12_MESSAGE_ID_SETPRIVATEDATA_OUTOFMEMORY + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDESC	= ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_UNRECOGNIZEDFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFORMAT	= ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDESC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANESLICE	= ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDPLANESLICE	= ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANESLICE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS	= ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDPLANESLICE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDRESOURCE	= ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDDIMENSIONS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDARG_RETURN	= ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_OUTOFMEMORY_RETURN	= ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDARG_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT	= ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_OUTOFMEMORY_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT	= ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNRECOGNIZEDFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDESC	= ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_UNSUPPORTEDFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDFORMAT	= ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDESC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDVIDEOPLANESLICE	= ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDPLANESLICE	= ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDVIDEOPLANESLICE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDIMENSIONS	= ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDPLANESLICE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDRESOURCE	= ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDDIMENSIONS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDARG_RETURN	= ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_OUTOFMEMORY_RETURN	= ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDARG_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT	= ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_OUTOFMEMORY_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDESC	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_UNRECOGNIZEDFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFORMAT	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDESC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDDIMENSIONS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDARG_RETURN	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_OUTOFMEMORY_RETURN	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDARG_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_OUTOFMEMORY	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_OUTOFMEMORY_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TOOMANYELEMENTS	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_OUTOFMEMORY + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDFORMAT	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TOOMANYELEMENTS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOT	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INCOMPATIBLEFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDINPUTSLOTCLASS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_STEPRATESLOTCLASSMISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSLOTCLASSCHANGE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDALIGNMENT	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDSTEPRATECHANGE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_DUPLICATESEMANTIC	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_INVALIDALIGNMENT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_DUPLICATESEMANTIC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_NULLSEMANTIC	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_UNPARSEABLEINPUTSIGNATURE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_MISSINGELEMENT	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_NULLSEMANTIC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEVERTEXSHADER_OUTOFMEMORY	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_MISSINGELEMENT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERBYTECODE	= ( D3D12_MESSAGE_ID_CREATEVERTEXSHADER_OUTOFMEMORY + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERTYPE	= ( D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERBYTECODE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_OUTOFMEMORY	= ( D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDSHADERTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_OUTOFMEMORY + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERTYPE	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERBYTECODE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDSHADERTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTOFMEMORY + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERBYTECODE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSHADERTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMENTRIES + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDDECL	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSTREAMSTRIDEUNUSED + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_EXPECTEDDECL	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDDECL + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_EXPECTEDDECL + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_OUTPUTSLOT0EXPECTED + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSLOT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_ONLYONEELEMENTPERSLOT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCOMPONENTCOUNT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTARTCOMPONENTANDCOMPONENTCOUNT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDGAPDEFINITION + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_REPEATEDOUTPUT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDOUTPUTSTREAMSTRIDE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGSEMANTIC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MASKMISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_CANTHAVEONLYGAPS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DECLTOOCOMPLEX + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIXELSHADER_OUTOFMEMORY	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_MISSINGOUTPUTSIGNATURE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERBYTECODE	= ( D3D12_MESSAGE_ID_CREATEPIXELSHADER_OUTOFMEMORY + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERTYPE	= ( D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERBYTECODE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFILLMODE	= ( D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDSHADERTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDCULLMODE	= ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFILLMODE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP	= ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDCULLMODE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS	= ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDDEPTHBIASCLAMP + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_NULLDESC	= ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDSLOPESCALEDDEPTHBIAS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK	= ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_NULLDESC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHWRITEMASK + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDDEPTHFUNC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFAILOP + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILZFAILOP + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILPASSOP + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDFRONTFACESTENCILFUNC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFAILOP + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILZFAILOP + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILPASSOP + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_NULLDESC	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_INVALIDBACKFACESTENCILFUNC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLEND	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_NULLDESC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLEND	= ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLEND + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOP	= ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLEND + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLENDALPHA	= ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOP + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA	= ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDSRCBLENDALPHA + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA	= ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDDESTBLENDALPHA + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK	= ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDBLENDOPALPHA + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEBLENDSTATE_NULLDESC	= ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDRENDERTARGETWRITEMASK + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDFILTER	= ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_NULLDESC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSU	= ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDFILTER + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSV	= ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSU + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSW	= ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSV + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMIPLODBIAS	= ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDADDRESSW + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXANISOTROPY	= ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMIPLODBIAS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDCOMPARISONFUNC	= ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXANISOTROPY + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMINLOD	= ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDCOMPARISONFUNC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXLOD	= ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMINLOD + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESAMPLERSTATE_NULLDESC	= ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_INVALIDMAXLOD + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNRECOGNIZED	= ( D3D12_MESSAGE_ID_CREATESAMPLERSTATE_NULLDESC + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNDEFINED	= ( D3D12_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNRECOGNIZED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_INVALIDVIEWPORT	= ( D3D12_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNDEFINED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_INVALIDSCISSOR	= ( D3D12_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_INVALIDVIEWPORT + 1 ) ,
-        D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_DENORMFLUSH	= ( D3D12_MESSAGE_ID_DEVICE_RSSETSCISSORRECTS_INVALIDSCISSOR + 1 ) ,
-        D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DENORMFLUSH	= ( D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_DENORMFLUSH + 1 ) ,
-        D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID	= ( D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DENORMFLUSH + 1 ) ,
-        D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCE	= ( D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDDESTINATIONSTATE	= ( D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCESTATE	= ( D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDDESTINATIONSTATE + 1 ) ,
-        D3D12_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSUBRESOURCE	= ( D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSOURCESTATE + 1 ) ,
-        D3D12_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONBOX	= ( D3D12_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSTATE	= ( D3D12_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONBOX + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_INVALID	= ( D3D12_MESSAGE_ID_UPDATESUBRESOURCE_INVALIDDESTINATIONSTATE + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_SUBRESOURCE_INVALID	= ( D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_INVALID	= ( D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_DESTINATION_SUBRESOURCE_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_SUBRESOURCE_INVALID	= ( D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_FORMAT_INVALID	= ( D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_SOURCE_SUBRESOURCE_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_BUFFER_MAP_INVALIDMAPTYPE	= ( D3D12_MESSAGE_ID_DEVICE_RESOLVESUBRESOURCE_FORMAT_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_BUFFER_MAP_INVALIDFLAGS	= ( D3D12_MESSAGE_ID_BUFFER_MAP_INVALIDMAPTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_BUFFER_MAP_ALREADYMAPPED	= ( D3D12_MESSAGE_ID_BUFFER_MAP_INVALIDFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_BUFFER_MAP_DEVICEREMOVED_RETURN	= ( D3D12_MESSAGE_ID_BUFFER_MAP_ALREADYMAPPED + 1 ) ,
-        D3D12_MESSAGE_ID_BUFFER_UNMAP_NOTMAPPED	= ( D3D12_MESSAGE_ID_BUFFER_MAP_DEVICEREMOVED_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE1D_MAP_INVALIDMAPTYPE	= ( D3D12_MESSAGE_ID_BUFFER_UNMAP_NOTMAPPED + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE1D_MAP_INVALIDSUBRESOURCE	= ( D3D12_MESSAGE_ID_TEXTURE1D_MAP_INVALIDMAPTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE1D_MAP_INVALIDFLAGS	= ( D3D12_MESSAGE_ID_TEXTURE1D_MAP_INVALIDSUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE1D_MAP_ALREADYMAPPED	= ( D3D12_MESSAGE_ID_TEXTURE1D_MAP_INVALIDFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE1D_MAP_DEVICEREMOVED_RETURN	= ( D3D12_MESSAGE_ID_TEXTURE1D_MAP_ALREADYMAPPED + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE1D_UNMAP_INVALIDSUBRESOURCE	= ( D3D12_MESSAGE_ID_TEXTURE1D_MAP_DEVICEREMOVED_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE1D_UNMAP_NOTMAPPED	= ( D3D12_MESSAGE_ID_TEXTURE1D_UNMAP_INVALIDSUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE2D_MAP_INVALIDMAPTYPE	= ( D3D12_MESSAGE_ID_TEXTURE1D_UNMAP_NOTMAPPED + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE2D_MAP_INVALIDSUBRESOURCE	= ( D3D12_MESSAGE_ID_TEXTURE2D_MAP_INVALIDMAPTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE2D_MAP_INVALIDFLAGS	= ( D3D12_MESSAGE_ID_TEXTURE2D_MAP_INVALIDSUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE2D_MAP_ALREADYMAPPED	= ( D3D12_MESSAGE_ID_TEXTURE2D_MAP_INVALIDFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE2D_MAP_DEVICEREMOVED_RETURN	= ( D3D12_MESSAGE_ID_TEXTURE2D_MAP_ALREADYMAPPED + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE2D_UNMAP_INVALIDSUBRESOURCE	= ( D3D12_MESSAGE_ID_TEXTURE2D_MAP_DEVICEREMOVED_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE2D_UNMAP_NOTMAPPED	= ( D3D12_MESSAGE_ID_TEXTURE2D_UNMAP_INVALIDSUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE3D_MAP_INVALIDMAPTYPE	= ( D3D12_MESSAGE_ID_TEXTURE2D_UNMAP_NOTMAPPED + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE3D_MAP_INVALIDSUBRESOURCE	= ( D3D12_MESSAGE_ID_TEXTURE3D_MAP_INVALIDMAPTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE3D_MAP_INVALIDFLAGS	= ( D3D12_MESSAGE_ID_TEXTURE3D_MAP_INVALIDSUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE3D_MAP_ALREADYMAPPED	= ( D3D12_MESSAGE_ID_TEXTURE3D_MAP_INVALIDFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE3D_MAP_DEVICEREMOVED_RETURN	= ( D3D12_MESSAGE_ID_TEXTURE3D_MAP_ALREADYMAPPED + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE3D_UNMAP_INVALIDSUBRESOURCE	= ( D3D12_MESSAGE_ID_TEXTURE3D_MAP_DEVICEREMOVED_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_TEXTURE3D_UNMAP_NOTMAPPED	= ( D3D12_MESSAGE_ID_TEXTURE3D_UNMAP_INVALIDSUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_DEPRECATED	= ( D3D12_MESSAGE_ID_TEXTURE3D_UNMAP_NOTMAPPED + 1 ) ,
-        D3D12_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_FORMAT_DEPRECATED	= ( D3D12_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_DEPRECATED + 1 ) ,
-        D3D12_MESSAGE_ID_SETEXCEPTIONMODE_UNRECOGNIZEDFLAGS	= ( D3D12_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_FORMAT_DEPRECATED + 1 ) ,
-        D3D12_MESSAGE_ID_SETEXCEPTIONMODE_INVALIDARG_RETURN	= ( D3D12_MESSAGE_ID_SETEXCEPTIONMODE_UNRECOGNIZEDFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_SETEXCEPTIONMODE_DEVICEREMOVED_RETURN	= ( D3D12_MESSAGE_ID_SETEXCEPTIONMODE_INVALIDARG_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_REF_SIMULATING_INFINITELY_FAST_HARDWARE	= ( D3D12_MESSAGE_ID_SETEXCEPTIONMODE_DEVICEREMOVED_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_REF_THREADING_MODE	= ( D3D12_MESSAGE_ID_REF_SIMULATING_INFINITELY_FAST_HARDWARE + 1 ) ,
-        D3D12_MESSAGE_ID_REF_UMDRIVER_EXCEPTION	= ( D3D12_MESSAGE_ID_REF_THREADING_MODE + 1 ) ,
-        D3D12_MESSAGE_ID_REF_KMDRIVER_EXCEPTION	= ( D3D12_MESSAGE_ID_REF_UMDRIVER_EXCEPTION + 1 ) ,
-        D3D12_MESSAGE_ID_REF_HARDWARE_EXCEPTION	= ( D3D12_MESSAGE_ID_REF_KMDRIVER_EXCEPTION + 1 ) ,
-        D3D12_MESSAGE_ID_REF_ACCESSING_INDEXABLE_TEMP_OUT_OF_RANGE	= ( D3D12_MESSAGE_ID_REF_HARDWARE_EXCEPTION + 1 ) ,
-        D3D12_MESSAGE_ID_REF_PROBLEM_PARSING_SHADER	= ( D3D12_MESSAGE_ID_REF_ACCESSING_INDEXABLE_TEMP_OUT_OF_RANGE + 1 ) ,
-        D3D12_MESSAGE_ID_REF_OUT_OF_MEMORY	= ( D3D12_MESSAGE_ID_REF_PROBLEM_PARSING_SHADER + 1 ) ,
-        D3D12_MESSAGE_ID_REF_INFO	= ( D3D12_MESSAGE_ID_REF_OUT_OF_MEMORY + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_VERTEXPOS_OVERFLOW	= ( D3D12_MESSAGE_ID_REF_INFO + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAWINDEXED_INDEXPOS_OVERFLOW	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_VERTEXPOS_OVERFLOW + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAWINSTANCED_VERTEXPOS_OVERFLOW	= ( D3D12_MESSAGE_ID_DEVICE_DRAWINDEXED_INDEXPOS_OVERFLOW + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAWINSTANCED_INSTANCEPOS_OVERFLOW	= ( D3D12_MESSAGE_ID_DEVICE_DRAWINSTANCED_VERTEXPOS_OVERFLOW + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INSTANCEPOS_OVERFLOW	= ( D3D12_MESSAGE_ID_DEVICE_DRAWINSTANCED_INSTANCEPOS_OVERFLOW + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INDEXPOS_OVERFLOW	= ( D3D12_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INSTANCEPOS_OVERFLOW + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_VERTEX_SHADER_NOT_SET	= ( D3D12_MESSAGE_ID_DEVICE_DRAWINDEXEDINSTANCED_INDEXPOS_OVERFLOW + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_VERTEX_SHADER_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERINDEX	= ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_COMPONENTTYPE	= ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERINDEX + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERMASK	= ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_COMPONENTTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SYSTEMVALUE	= ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_REGISTERMASK + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS	= ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_SYSTEMVALUE + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_NOT_SET	= ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_MISMATCH	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_NOT_SET	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_ROOT_SIGNATURE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INPUTLAYOUT_NOT_SET	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_CONSTANT_BUFFER_NOT_SET	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INPUTLAYOUT_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_CONSTANT_BUFFER_TOO_SMALL	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_CONSTANT_BUFFER_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SAMPLER_NOT_SET	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_CONSTANT_BUFFER_TOO_SMALL + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SHADERRESOURCEVIEW_NOT_SET	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SAMPLER_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VIEW_DIMENSION_MISMATCH	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SHADERRESOURCEVIEW_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VIEW_DIMENSION_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_TOO_SMALL	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_STRIDE_TOO_SMALL + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_NOT_SET	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_BUFFER_TOO_SMALL + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_FORMAT_INVALID	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_TOO_SMALL	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_FORMAT_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_GS_INPUT_PRIMITIVE_MISMATCH	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_BUFFER_TOO_SMALL + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_RETURN_TYPE_MISMATCH	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_GS_INPUT_PRIMITIVE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_POSITION_NOT_PRESENT	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_RETURN_TYPE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OUTPUT_STREAM_NOT_SET	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_POSITION_NOT_PRESENT + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_BOUND_RESOURCE_MAPPED	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OUTPUT_STREAM_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INVALID_PRIMITIVETOPOLOGY	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_BOUND_RESOURCE_MAPPED + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_OFFSET_UNALIGNED	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INVALID_PRIMITIVETOPOLOGY + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_STRIDE_UNALIGNED	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_OFFSET_UNALIGNED + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_OFFSET_UNALIGNED	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_VERTEX_STRIDE_UNALIGNED + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OUTPUT_STREAM_OFFSET_UNALIGNED	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_INDEX_OFFSET_UNALIGNED + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_FORMAT_LD_UNSUPPORTED	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OUTPUT_STREAM_OFFSET_UNALIGNED + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_FORMAT_SAMPLE_UNSUPPORTED	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_FORMAT_LD_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_FORMAT_SAMPLE_C_UNSUPPORTED	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_FORMAT_SAMPLE_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_MULTISAMPLE_UNSUPPORTED	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_FORMAT_SAMPLE_C_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SO_TARGETS_BOUND_WITHOUT_SOURCE	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RESOURCE_MULTISAMPLE_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SO_STRIDE_LARGER_THAN_BUFFER	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SO_TARGETS_BOUND_WITHOUT_SOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_SO_STRIDE_LARGER_THAN_BUFFER + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_AT_FAULT	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0 + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT	= ( D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_AT_FAULT + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT	= ( D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_POSSIBLY_AT_FAULT + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_INVALIDARG_RETURN	= ( D3D12_MESSAGE_ID_DEVICE_REMOVAL_PROCESS_NOT_AT_FAULT + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_OUTOFMEMORY_RETURN	= ( D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_INVALIDARG_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BADINTERFACE_RETURN	= ( D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_OUTOFMEMORY_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_VIEWPORT_NOT_SET	= ( D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BADINTERFACE_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_VIEWPORT_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TRAILING_DIGIT_IN_SEMANTIC + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_DENORMFLUSH	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_TRAILING_DIGIT_IN_SEMANTIC + 1 ) ,
-        D3D12_MESSAGE_ID_OMSETRENDERTARGETS_INVALIDVIEW	= ( D3D12_MESSAGE_ID_DEVICE_RSSETVIEWPORTS_DENORMFLUSH + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_SETTEXTFILTERSIZE_INVALIDDIMENSIONS	= ( D3D12_MESSAGE_ID_OMSETRENDERTARGETS_INVALIDVIEW + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_SAMPLER_MISMATCH	= ( D3D12_MESSAGE_ID_DEVICE_SETTEXTFILTERSIZE_INVALIDDIMENSIONS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_SAMPLER_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_BLENDSTATE_GETDESC_LEGACY	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_SHADERRESOURCEVIEW_GETDESC_LEGACY	= ( D3D12_MESSAGE_ID_BLENDSTATE_GETDESC_LEGACY + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_PS_OUTPUT_TYPE_MISMATCH	= ( D3D12_MESSAGE_ID_SHADERRESOURCEVIEW_GETDESC_LEGACY + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_GATHER_UNSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_PS_OUTPUT_TYPE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_RESOURCE_FORMAT_GATHER_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_STRIDE_TOO_LARGE	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_INVALIDRANGE	= ( D3D12_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_STRIDE_TOO_LARGE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_EMPTY_LAYOUT	= ( D3D12_MESSAGE_ID_DEVICE_IASETVERTEXBUFFERS_INVALIDRANGE + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_RESOURCE_SAMPLE_COUNT_MISMATCH	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_EMPTY_LAYOUT + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_OBJECT_SUMMARY	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_RESOURCE_SAMPLE_COUNT_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_BUFFER	= ( D3D12_MESSAGE_ID_LIVE_OBJECT_SUMMARY + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_TEXTURE1D	= ( D3D12_MESSAGE_ID_LIVE_BUFFER + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_TEXTURE2D	= ( D3D12_MESSAGE_ID_LIVE_TEXTURE1D + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_TEXTURE3D	= ( D3D12_MESSAGE_ID_LIVE_TEXTURE2D + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_SHADERRESOURCEVIEW	= ( D3D12_MESSAGE_ID_LIVE_TEXTURE3D + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_RENDERTARGETVIEW	= ( D3D12_MESSAGE_ID_LIVE_SHADERRESOURCEVIEW + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_DEPTHSTENCILVIEW	= ( D3D12_MESSAGE_ID_LIVE_RENDERTARGETVIEW + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_VERTEXSHADER	= ( D3D12_MESSAGE_ID_LIVE_DEPTHSTENCILVIEW + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_GEOMETRYSHADER	= ( D3D12_MESSAGE_ID_LIVE_VERTEXSHADER + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_PIXELSHADER	= ( D3D12_MESSAGE_ID_LIVE_GEOMETRYSHADER + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_INPUTLAYOUT	= ( D3D12_MESSAGE_ID_LIVE_PIXELSHADER + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_SAMPLER	= ( D3D12_MESSAGE_ID_LIVE_INPUTLAYOUT + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_BLENDSTATE	= ( D3D12_MESSAGE_ID_LIVE_SAMPLER + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_DEPTHSTENCILSTATE	= ( D3D12_MESSAGE_ID_LIVE_BLENDSTATE + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_RASTERIZERSTATE	= ( D3D12_MESSAGE_ID_LIVE_DEPTHSTENCILSTATE + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_QUERY	= ( D3D12_MESSAGE_ID_LIVE_RASTERIZERSTATE + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_PREDICATE	= ( D3D12_MESSAGE_ID_LIVE_QUERY + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_COUNTER	= ( D3D12_MESSAGE_ID_LIVE_PREDICATE + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_DEVICE	= ( D3D12_MESSAGE_ID_LIVE_COUNTER + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_SWAPCHAIN	= ( D3D12_MESSAGE_ID_LIVE_DEVICE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFLAGS	= ( D3D12_MESSAGE_ID_LIVE_SWAPCHAIN + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDCLASSLINKAGE	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILVIEW_INVALIDFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDCLASSLINKAGE	= ( D3D12_MESSAGE_ID_CREATEVERTEXSHADER_INVALIDCLASSLINKAGE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTREAMS	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADER_INVALIDCLASSLINKAGE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAMTORASTERIZER	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTREAMS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTREAMS	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAMTORASTERIZER + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCLASSLINKAGE	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTREAMS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDCLASSLINKAGE	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDCLASSLINKAGE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAM	= ( D3D12_MESSAGE_ID_CREATEPIXELSHADER_INVALIDCLASSLINKAGE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDENTRIES	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDSTREAM + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTRIDES	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDENTRIES + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTRIDES	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UNEXPECTEDSTRIDES + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDCALL	= ( D3D12_MESSAGE_ID_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_INVALIDNUMSTRIDES + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEHULLSHADER_OUTOFMEMORY	= ( D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDCALL + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERBYTECODE	= ( D3D12_MESSAGE_ID_CREATEHULLSHADER_OUTOFMEMORY + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERTYPE	= ( D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERBYTECODE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDCLASSLINKAGE	= ( D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDSHADERTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCALL	= ( D3D12_MESSAGE_ID_CREATEHULLSHADER_INVALIDCLASSLINKAGE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDOMAINSHADER_OUTOFMEMORY	= ( D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCALL + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERBYTECODE	= ( D3D12_MESSAGE_ID_CREATEDOMAINSHADER_OUTOFMEMORY + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERTYPE	= ( D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERBYTECODE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCLASSLINKAGE	= ( D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDSHADERTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_HS_XOR_DS_MISMATCH	= ( D3D12_MESSAGE_ID_CREATEDOMAINSHADER_INVALIDCLASSLINKAGE + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAWINDIRECT_INVALID_ARG_BUFFER	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_HS_XOR_DS_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAWINDIRECT_OFFSET_UNALIGNED	= ( D3D12_MESSAGE_ID_DEVICE_DRAWINDIRECT_INVALID_ARG_BUFFER + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAWINDIRECT_OFFSET_OVERFLOW	= ( D3D12_MESSAGE_ID_DEVICE_DRAWINDIRECT_OFFSET_UNALIGNED + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_MAP_INVALIDMAPTYPE	= ( D3D12_MESSAGE_ID_DEVICE_DRAWINDIRECT_OFFSET_OVERFLOW + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_MAP_INVALIDSUBRESOURCE	= ( D3D12_MESSAGE_ID_RESOURCE_MAP_INVALIDMAPTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_MAP_INVALIDFLAGS	= ( D3D12_MESSAGE_ID_RESOURCE_MAP_INVALIDSUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_MAP_ALREADYMAPPED	= ( D3D12_MESSAGE_ID_RESOURCE_MAP_INVALIDFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_MAP_DEVICEREMOVED_RETURN	= ( D3D12_MESSAGE_ID_RESOURCE_MAP_ALREADYMAPPED + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_MAP_OUTOFMEMORY_RETURN	= ( D3D12_MESSAGE_ID_RESOURCE_MAP_DEVICEREMOVED_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_MAP_WITHOUT_INITIAL_DISCARD	= ( D3D12_MESSAGE_ID_RESOURCE_MAP_OUTOFMEMORY_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_UNMAP_INVALIDSUBRESOURCE	= ( D3D12_MESSAGE_ID_RESOURCE_MAP_WITHOUT_INITIAL_DISCARD + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_UNMAP_NOTMAPPED	= ( D3D12_MESSAGE_ID_RESOURCE_UNMAP_INVALIDSUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_RASTERIZING_CONTROL_POINTS	= ( D3D12_MESSAGE_ID_RESOURCE_UNMAP_NOTMAPPED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_RASTERIZING_CONTROL_POINTS + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_HS_DS_SIGNATURE_MISMATCH	= ( D3D12_MESSAGE_ID_DEVICE_IASETPRIMITIVETOPOLOGY_TOPOLOGY_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_HS_DS_SIGNATURE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_HS_DS_CONTROL_POINT_COUNT_MISMATCH	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_HS_DS_TESSELLATOR_DOMAIN_MISMATCH	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_HS_DS_CONTROL_POINT_COUNT_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_UNRECOGNIZED_FEATURE	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_HS_DS_TESSELLATOR_DOMAIN_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_MISMATCHED_DATA_SIZE	= ( D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_UNRECOGNIZED_FEATURE + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_INVALIDARG_RETURN	= ( D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_MISMATCHED_DATA_SIZE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCALL	= ( D3D12_MESSAGE_ID_DEVICE_CHECKFEATURESUPPORT_INVALIDARG_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_CREATECOMPUTESHADER_OUTOFMEMORY	= ( D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCALL + 1 ) ,
-        D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDSHADERBYTECODE	= ( D3D12_MESSAGE_ID_CREATECOMPUTESHADER_OUTOFMEMORY + 1 ) ,
-        D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCLASSLINKAGE	= ( D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDSHADERBYTECODE + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CSSETSHADERRESOURCES_VIEWS_EMPTY	= ( D3D12_MESSAGE_ID_CREATECOMPUTESHADER_INVALIDCLASSLINKAGE + 1 ) ,
-        D3D12_MESSAGE_ID_CSSETCONSTANTBUFFERS_INVALIDBUFFER	= ( D3D12_MESSAGE_ID_DEVICE_CSSETSHADERRESOURCES_VIEWS_EMPTY + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CSSETCONSTANTBUFFERS_BUFFERS_EMPTY	= ( D3D12_MESSAGE_ID_CSSETCONSTANTBUFFERS_INVALIDBUFFER + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CSSETSAMPLERS_SAMPLERS_EMPTY	= ( D3D12_MESSAGE_ID_DEVICE_CSSETCONSTANTBUFFERS_BUFFERS_EMPTY + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CSGETSHADERRESOURCES_VIEWS_EMPTY	= ( D3D12_MESSAGE_ID_DEVICE_CSSETSAMPLERS_SAMPLERS_EMPTY + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CSGETCONSTANTBUFFERS_BUFFERS_EMPTY	= ( D3D12_MESSAGE_ID_DEVICE_CSGETSHADERRESOURCES_VIEWS_EMPTY + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CSGETSAMPLERS_SAMPLERS_EMPTY	= ( D3D12_MESSAGE_ID_DEVICE_CSGETCONSTANTBUFFERS_BUFFERS_EMPTY + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEFLOATOPSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CSGETSAMPLERS_SAMPLERS_EMPTY + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEFLOATOPSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEFLOATOPSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEFLOATOPSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEFLOATOPSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEFLOATOPSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEFLOATOPSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEBUFFER_INVALIDSTRUCTURESTRIDE	= ( D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEFLOATOPSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFLAGS	= ( D3D12_MESSAGE_ID_CREATEBUFFER_INVALIDSTRUCTURESTRIDE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDRESOURCE	= ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDESC	= ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFORMAT	= ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDESC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANESLICE	= ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDPLANESLICE	= ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANESLICE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDIMENSIONS	= ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDPLANESLICE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_UNRECOGNIZEDFORMAT	= ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDDIMENSIONS + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_OVERLAPPING_OLD_SLOTS	= ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_UNRECOGNIZEDFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_NO_OP	= ( D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_OVERLAPPING_OLD_SLOTS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDARG_RETURN	= ( D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_NO_OP + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_OUTOFMEMORY_RETURN	= ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDARG_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_DENORMFLUSH	= ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_OUTOFMEMORY_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSS_VIEWS_EMPTY	= ( D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_DENORMFLUSH + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CSGETUNORDEREDACCESSS_VIEWS_EMPTY	= ( D3D12_MESSAGE_ID_DEVICE_CSSETUNORDEREDACCESSS_VIEWS_EMPTY + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFLAGS	= ( D3D12_MESSAGE_ID_DEVICE_CSGETUNORDEREDACCESSS_VIEWS_EMPTY + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_INVALID_ARG_BUFFER	= ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_OFFSET_UNALIGNED	= ( D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_INVALID_ARG_BUFFER + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_OFFSET_OVERFLOW	= ( D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_OFFSET_UNALIGNED + 1 ) ,
-        D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DEPTH_READONLY	= ( D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_OFFSET_OVERFLOW + 1 ) ,
-        D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_STENCIL_READONLY	= ( D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_DEPTH_READONLY + 1 ) ,
-        D3D12_MESSAGE_ID_CHECKFEATURESUPPORT_FORMAT_DEPRECATED	= ( D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_STENCIL_READONLY + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_RETURN_TYPE_MISMATCH	= ( D3D12_MESSAGE_ID_CHECKFEATURESUPPORT_FORMAT_DEPRECATED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_NOT_SET	= ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_RETURN_TYPE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_UNORDEREDACCESSVIEW_RENDERTARGETVIEW_OVERLAP	= ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_DIMENSION_MISMATCH	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_UNORDEREDACCESSVIEW_RENDERTARGETVIEW_OVERLAP + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_APPEND_UNSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_DIMENSION_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMICS_UNSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_APPEND_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_STRUCTURE_STRIDE_MISMATCH	= ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMICS_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_BUFFER_TYPE_MISMATCH	= ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_STRUCTURE_STRIDE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_RAW_UNSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_BUFFER_TYPE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_FORMAT_LD_UNSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_RAW_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_FORMAT_STORE_UNSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_FORMAT_LD_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_ADD_UNSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_FORMAT_STORE_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_BITWISE_OPS_UNSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_ADD_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_CMPSTORE_CMPEXCHANGE_UNSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_BITWISE_OPS_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_EXCHANGE_UNSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_CMPSTORE_CMPEXCHANGE_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_SIGNED_MINMAX_UNSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_EXCHANGE_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_UNSIGNED_MINMAX_UNSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_SIGNED_MINMAX_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DISPATCH_BOUND_RESOURCE_MAPPED	= ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_ATOMIC_UNSIGNED_MINMAX_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DISPATCH_THREADGROUPCOUNT_OVERFLOW	= ( D3D12_MESSAGE_ID_DEVICE_DISPATCH_BOUND_RESOURCE_MAPPED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DISPATCH_THREADGROUPCOUNT_ZERO	= ( D3D12_MESSAGE_ID_DEVICE_DISPATCH_THREADGROUPCOUNT_OVERFLOW + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_STRUCTURE_STRIDE_MISMATCH	= ( D3D12_MESSAGE_ID_DEVICE_DISPATCH_THREADGROUPCOUNT_ZERO + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_BUFFER_TYPE_MISMATCH	= ( D3D12_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_STRUCTURE_STRIDE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_RAW_UNSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_BUFFER_TYPE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DISPATCH_UNSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_SHADERRESOURCEVIEW_RAW_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_UNSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_DISPATCH_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDOFFSET	= ( D3D12_MESSAGE_ID_DEVICE_DISPATCHINDIRECT_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_LARGEOFFSET	= ( D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDOFFSET + 1 ) ,
-        D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDDESTINATIONSTATE	= ( D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_LARGEOFFSET + 1 ) ,
-        D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDSOURCESTATE	= ( D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDDESTINATIONSTATE + 1 ) ,
-        D3D12_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_NOT_SUPPORTED	= ( D3D12_MESSAGE_ID_COPYSTRUCTURECOUNT_INVALIDSOURCESTATE + 1 ) ,
-        D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEWFLOAT_INVALIDFORMAT	= ( D3D12_MESSAGE_ID_CHECKFORMATSUPPORT_FORMAT_NOT_SUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_COUNTER_UNSUPPORTED	= ( D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEWFLOAT_INVALIDFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_PIXEL_SHADER_WITHOUT_RTV_OR_DSV	= ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_COUNTER_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_SHADER_ABORT	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_PIXEL_SHADER_WITHOUT_RTV_OR_DSV + 1 ) ,
-        D3D12_MESSAGE_ID_SHADER_MESSAGE	= ( D3D12_MESSAGE_ID_SHADER_ABORT + 1 ) ,
-        D3D12_MESSAGE_ID_SHADER_ERROR	= ( D3D12_MESSAGE_ID_SHADER_MESSAGE + 1 ) ,
-        D3D12_MESSAGE_ID_OFFERRESOURCES_INVALIDRESOURCE	= ( D3D12_MESSAGE_ID_SHADER_ERROR + 1 ) ,
-        D3D12_MESSAGE_ID_ENQUEUESETEVENT_INVALIDARG_RETURN	= ( D3D12_MESSAGE_ID_OFFERRESOURCES_INVALIDRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_ENQUEUESETEVENT_OUTOFMEMORY_RETURN	= ( D3D12_MESSAGE_ID_ENQUEUESETEVENT_INVALIDARG_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_ENQUEUESETEVENT_ACCESSDENIED_RETURN	= ( D3D12_MESSAGE_ID_ENQUEUESETEVENT_OUTOFMEMORY_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFORCEDSAMPLECOUNT	= ( D3D12_MESSAGE_ID_ENQUEUESETEVENT_ACCESSDENIED_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_FORCED_SAMPLE_COUNT	= ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALIDFORCEDSAMPLECOUNT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDLOGICOPS	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_INVALID_USE_OF_FORCED_SAMPLE_COUNT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDARRAYWITHDECODER	= ( D3D12_MESSAGE_ID_CREATEBLENDSTATE_INVALIDLOGICOPS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDARRAYWITHDECODER	= ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDARRAYWITHDECODER + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDARRAYWITHDECODER	= ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDARRAYWITHDECODER + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_LOCKEDOUT_INTERFACE	= ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDARRAYWITHDECODER + 1 ) ,
-        D3D12_MESSAGE_ID_OFFERRESOURCES_INVALIDPRIORITY	= ( D3D12_MESSAGE_ID_DEVICE_LOCKEDOUT_INTERFACE + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDVIEW	= ( D3D12_MESSAGE_ID_OFFERRESOURCES_INVALIDPRIORITY + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEEXTENSIONSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDVIEW + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_SHADEREXTENSIONSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEEXTENSIONSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_SHADEREXTENSIONSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_SHADEREXTENSIONSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEEXTENSIONSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_SHADEREXTENSIONSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_SHADEREXTENSIONSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEEXTENSIONSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_SHADEREXTENSIONSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_SHADEREXTENSIONSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEEXTENSIONSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_SHADEREXTENSIONSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_SHADEREXTENSIONSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEEXTENSIONSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_SHADEREXTENSIONSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_SHADEREXTENSIONSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEEXTENSIONSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_SHADEREXTENSIONSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_SHADEREXTENSIONSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_DOUBLEEXTENSIONSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_MINPRECISION	= ( D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_SHADEREXTENSIONSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_UAVSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_SHADER_LINKAGE_MINPRECISION + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_UAVSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEVERTEXSHADER_UAVSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_UAVSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEHULLSHADER_UAVSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_UAVSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEDOMAINSHADER_UAVSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UAVSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADER_UAVSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_UAVSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEGEOMETRYSHADERWITHSTREAMOUTPUT_UAVSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_UAVSNOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CREATEPIXELSHADER_UAVSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_INVALIDOFFSET	= ( D3D12_MESSAGE_ID_DEVICE_CREATECOMPUTESHADER_UAVSNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_TOOMANYVIEWS	= ( D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_INVALIDOFFSET + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_NOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_OMSETRENDERTARGETSANDUNORDEREDACCESSVIEWS_TOOMANYVIEWS + 1 ) ,
-        D3D12_MESSAGE_ID_SWAPDEVICECONTEXTSTATE_NOTSUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_NOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_UPDATESUBRESOURCE_PREFERUPDATESUBRESOURCE1	= ( D3D12_MESSAGE_ID_SWAPDEVICECONTEXTSTATE_NOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_GETDC_INACCESSIBLE	= ( D3D12_MESSAGE_ID_UPDATESUBRESOURCE_PREFERUPDATESUBRESOURCE1 + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDRECT	= ( D3D12_MESSAGE_ID_GETDC_INACCESSIBLE + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_SAMPLE_MASK_IGNORED_ON_FL9	= ( D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDRECT + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE1_NOT_SUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_SAMPLE_MASK_IGNORED_ON_FL9 + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BY_NAME_NOT_SUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE1_NOT_SUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_ENQUEUESETEVENT_NOT_SUPPORTED	= ( D3D12_MESSAGE_ID_DEVICE_OPEN_SHARED_RESOURCE_BY_NAME_NOT_SUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_OFFERRELEASE_NOT_SUPPORTED	= ( D3D12_MESSAGE_ID_ENQUEUESETEVENT_NOT_SUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_OFFERRESOURCES_INACCESSIBLE	= ( D3D12_MESSAGE_ID_OFFERRELEASE_NOT_SUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDMSAA	= ( D3D12_MESSAGE_ID_OFFERRESOURCES_INACCESSIBLE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDMSAA	= ( D3D12_MESSAGE_ID_CREATEVIDEOPROCESSORINPUTVIEW_INVALIDMSAA + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDSOURCERECT	= ( D3D12_MESSAGE_ID_CREATEVIDEOPROCESSOROUTPUTVIEW_INVALIDMSAA + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_EMPTYRECT	= ( D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_INVALIDSOURCERECT + 1 ) ,
-        D3D12_MESSAGE_ID_UPDATESUBRESOURCE_EMPTYDESTBOX	= ( D3D12_MESSAGE_ID_DEVICE_CLEARVIEW_EMPTYRECT + 1 ) ,
-        D3D12_MESSAGE_ID_COPYSUBRESOURCEREGION_EMPTYSOURCEBOX	= ( D3D12_MESSAGE_ID_UPDATESUBRESOURCE_EMPTYDESTBOX + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS	= ( D3D12_MESSAGE_ID_COPYSUBRESOURCEREGION_EMPTYSOURCEBOX + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_DEPTHSTENCILVIEW_NOT_SET	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_DEPTHSTENCILVIEW_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET_DUE_TO_FLIP_PRESENT	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_NOT_SET_DUE_TO_FLIP_PRESENT	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_RENDERTARGETVIEW_NOT_SET_DUE_TO_FLIP_PRESENT + 1 ) ,
-        D3D12_MESSAGE_ID_GETDATAFORNEWHARDWAREKEY_NULLPARAM	= ( D3D12_MESSAGE_ID_DEVICE_UNORDEREDACCESSVIEW_NOT_SET_DUE_TO_FLIP_PRESENT + 1 ) ,
-        D3D12_MESSAGE_ID_CHECKCRYPTOSESSIONSTATUS_NULLPARAM	= ( D3D12_MESSAGE_ID_GETDATAFORNEWHARDWAREKEY_NULLPARAM + 1 ) ,
-        D3D12_MESSAGE_ID_SETEVENTONHARDWARECONTENTPROTECTIONTILT_NULLPARAM	= ( D3D12_MESSAGE_ID_CHECKCRYPTOSESSIONSTATUS_NULLPARAM + 1 ) ,
-        D3D12_MESSAGE_ID_GETVIDEODECODERCAPS_NULLPARAM	= ( D3D12_MESSAGE_ID_SETEVENTONHARDWARECONTENTPROTECTIONTILT_NULLPARAM + 1 ) ,
-        D3D12_MESSAGE_ID_GETVIDEODECODERCAPS_ZEROWIDTHHEIGHT	= ( D3D12_MESSAGE_ID_GETVIDEODECODERCAPS_NULLPARAM + 1 ) ,
-        D3D12_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_NULLPARAM	= ( D3D12_MESSAGE_ID_GETVIDEODECODERCAPS_ZEROWIDTHHEIGHT + 1 ) ,
-        D3D12_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_INVALIDCOLORSPACE	= ( D3D12_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_NULLPARAM + 1 ) ,
-        D3D12_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_ZEROWIDTHHEIGHT	= ( D3D12_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_INVALIDCOLORSPACE + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEODECODERENABLEDOWNSAMPLING_NULLPARAM	= ( D3D12_MESSAGE_ID_CHECKVIDEODECODERDOWNSAMPLING_ZEROWIDTHHEIGHT + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEODECODERENABLEDOWNSAMPLING_UNSUPPORTED	= ( D3D12_MESSAGE_ID_VIDEODECODERENABLEDOWNSAMPLING_NULLPARAM + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEODECODERUPDATEDOWNSAMPLING_NULLPARAM	= ( D3D12_MESSAGE_ID_VIDEODECODERENABLEDOWNSAMPLING_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEODECODERUPDATEDOWNSAMPLING_UNSUPPORTED	= ( D3D12_MESSAGE_ID_VIDEODECODERUPDATEDOWNSAMPLING_NULLPARAM + 1 ) ,
-        D3D12_MESSAGE_ID_CHECKVIDEOPROCESSORFORMATCONVERSION_NULLPARAM	= ( D3D12_MESSAGE_ID_VIDEODECODERUPDATEDOWNSAMPLING_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTCOLORSPACE1_NULLPARAM	= ( D3D12_MESSAGE_ID_CHECKVIDEOPROCESSORFORMATCONVERSION_NULLPARAM + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTCOLORSPACE1_NULLPARAM	= ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTCOLORSPACE1_NULLPARAM + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMCOLORSPACE1_NULLPARAM	= ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTCOLORSPACE1_NULLPARAM + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMCOLORSPACE1_INVALIDSTREAM	= ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMCOLORSPACE1_NULLPARAM + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_NULLPARAM	= ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMCOLORSPACE1_INVALIDSTREAM + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_INVALIDSTREAM	= ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_NULLPARAM + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_UNSUPPORTED	= ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_INVALIDSTREAM + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEOPROCESSORGETSTREAMCOLORSPACE1_NULLPARAM	= ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETSTREAMMIRROR_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEOPROCESSORGETSTREAMMIRROR_NULLPARAM	= ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETSTREAMCOLORSPACE1_NULLPARAM + 1 ) ,
-        D3D12_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_NULLPARAM	= ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETSTREAMMIRROR_NULLPARAM + 1 ) ,
-        D3D12_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_INVALIDCOLORSPACE	= ( D3D12_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_NULLPARAM + 1 ) ,
-        D3D12_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_ZEROWIDTHHEIGHT	= ( D3D12_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_INVALIDCOLORSPACE + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTSHADERUSAGE_NULLPARAM	= ( D3D12_MESSAGE_ID_RECOMMENDVIDEODECODERDOWNSAMPLING_ZEROWIDTHHEIGHT + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTSHADERUSAGE_NULLPARAM	= ( D3D12_MESSAGE_ID_VIDEOPROCESSORSETOUTPUTSHADERUSAGE_NULLPARAM + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_NULLPARAM	= ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETOUTPUTSHADERUSAGE_NULLPARAM + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDSTREAMCOUNT	= ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_NULLPARAM + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_TARGETRECT	= ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDSTREAMCOUNT + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDSOURCERECT	= ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_TARGETRECT + 1 ) ,
-        D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDDESTRECT	= ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDSOURCERECT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEBUFFER_INVALIDUSAGE	= ( D3D12_MESSAGE_ID_VIDEOPROCESSORGETBEHAVIORHINTS_INVALIDDESTRECT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATETEXTURE1D_INVALIDUSAGE	= ( D3D12_MESSAGE_ID_CREATEBUFFER_INVALIDUSAGE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATETEXTURE2D_INVALIDUSAGE	= ( D3D12_MESSAGE_ID_CREATETEXTURE1D_INVALIDUSAGE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_LEVEL9_STEPRATE_NOT_1	= ( D3D12_MESSAGE_ID_CREATETEXTURE2D_INVALIDUSAGE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_LEVEL9_INSTANCING_NOT_SUPPORTED	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_LEVEL9_STEPRATE_NOT_1 + 1 ) ,
-        D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_INVALID_PARAMETER	= ( D3D12_MESSAGE_ID_CREATEINPUTLAYOUT_LEVEL9_INSTANCING_NOT_SUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTILEMAPPINGS_INVALID_PARAMETER	= ( D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_INVALID_PARAMETER + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTILES_INVALID_PARAMETER	= ( D3D12_MESSAGE_ID_COPYTILEMAPPINGS_INVALID_PARAMETER + 1 ) ,
-        D3D12_MESSAGE_ID_NULL_TILE_MAPPING_ACCESS_WARNING	= ( D3D12_MESSAGE_ID_COPYTILES_INVALID_PARAMETER + 1 ) ,
-        D3D12_MESSAGE_ID_NULL_TILE_MAPPING_ACCESS_ERROR	= ( D3D12_MESSAGE_ID_NULL_TILE_MAPPING_ACCESS_WARNING + 1 ) ,
-        D3D12_MESSAGE_ID_DIRTY_TILE_MAPPING_ACCESS	= ( D3D12_MESSAGE_ID_NULL_TILE_MAPPING_ACCESS_ERROR + 1 ) ,
-        D3D12_MESSAGE_ID_DUPLICATE_TILE_MAPPINGS_IN_COVERED_AREA	= ( D3D12_MESSAGE_ID_DIRTY_TILE_MAPPING_ACCESS + 1 ) ,
-        D3D12_MESSAGE_ID_TILE_MAPPINGS_IN_COVERED_AREA_DUPLICATED_OUTSIDE	= ( D3D12_MESSAGE_ID_DUPLICATE_TILE_MAPPINGS_IN_COVERED_AREA + 1 ) ,
-        D3D12_MESSAGE_ID_TILE_MAPPINGS_SHARED_BETWEEN_INCOMPATIBLE_RESOURCES	= ( D3D12_MESSAGE_ID_TILE_MAPPINGS_IN_COVERED_AREA_DUPLICATED_OUTSIDE + 1 ) ,
-        D3D12_MESSAGE_ID_TILE_MAPPINGS_SHARED_BETWEEN_INPUT_AND_OUTPUT	= ( D3D12_MESSAGE_ID_TILE_MAPPINGS_SHARED_BETWEEN_INCOMPATIBLE_RESOURCES + 1 ) ,
-        D3D12_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_INVALIDFLAGS	= ( D3D12_MESSAGE_ID_TILE_MAPPINGS_SHARED_BETWEEN_INPUT_AND_OUTPUT + 1 ) ,
-        D3D12_MESSAGE_ID_GETRESOURCETILING_NONTILED_RESOURCE	= ( D3D12_MESSAGE_ID_CHECKMULTISAMPLEQUALITYLEVELS_INVALIDFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_NEED_TO_CALL_TILEDRESOURCEBARRIER	= ( D3D12_MESSAGE_ID_GETRESOURCETILING_NONTILED_RESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEVICE_INVALIDARGS	= ( D3D12_MESSAGE_ID_NEED_TO_CALL_TILEDRESOURCEBARRIER + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEVICE_WARNING	= ( D3D12_MESSAGE_ID_CREATEDEVICE_INVALIDARGS + 1 ) ,
-        D3D12_MESSAGE_ID_TILED_RESOURCE_TIER_1_BUFFER_TEXTURE_MISMATCH	= ( D3D12_MESSAGE_ID_CREATEDEVICE_WARNING + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_CRYPTOSESSION	= ( D3D12_MESSAGE_ID_TILED_RESOURCE_TIER_1_BUFFER_TEXTURE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_AUTHENTICATEDCHANNEL	= ( D3D12_MESSAGE_ID_CREATE_CRYPTOSESSION + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_CRYPTOSESSION	= ( D3D12_MESSAGE_ID_CREATE_AUTHENTICATEDCHANNEL + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_AUTHENTICATEDCHANNEL	= ( D3D12_MESSAGE_ID_LIVE_CRYPTOSESSION + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_CRYPTOSESSION	= ( D3D12_MESSAGE_ID_LIVE_AUTHENTICATEDCHANNEL + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_AUTHENTICATEDCHANNEL	= ( D3D12_MESSAGE_ID_DESTROY_CRYPTOSESSION + 1 ) ,
-        D3D12_MESSAGE_ID_MAP_INVALID_SUBRESOURCE	= ( D3D12_MESSAGE_ID_DESTROY_AUTHENTICATEDCHANNEL + 1 ) ,
-        D3D12_MESSAGE_ID_MAP_INVALID_TYPE	= ( D3D12_MESSAGE_ID_MAP_INVALID_SUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_MAP_UNSUPPORTED_TYPE	= ( D3D12_MESSAGE_ID_MAP_INVALID_TYPE + 1 ) ,
-        D3D12_MESSAGE_ID_UNMAP_INVALID_SUBRESOURCE	= ( D3D12_MESSAGE_ID_MAP_UNSUPPORTED_TYPE + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_TYPE	= ( D3D12_MESSAGE_ID_UNMAP_INVALID_SUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_NULL_POINTER	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_TYPE + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SUBRESOURCE	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_NULL_POINTER + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_RESERVED_BITS	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISSING_BIND_FLAGS	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_RESERVED_BITS + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_MISC_FLAGS	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISSING_BIND_FLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_MATCHING_STATES	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_MISC_FLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINATION	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_MATCHING_STATES + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_BEFORE_AFTER_MISMATCH	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINATION + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_RESOURCE	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_BEFORE_AFTER_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_SAMPLE_COUNT	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_RESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_SAMPLE_COUNT + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINED_FLAGS	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS_FOR_FORMAT	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMBINED_FLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SPLIT_BARRIER	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAGS_FOR_FORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_END	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_SPLIT_BARRIER + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_BEGIN	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_END + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAG	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_UNMATCHED_BEGIN + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMMAND_LIST_TYPE	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_FLAG + 1 ) ,
-        D3D12_MESSAGE_ID_INVALID_SUBRESOURCE_STATE	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_COMMAND_LIST_TYPE + 1 ) ,
-        D3D12_MESSAGE_ID_INEFFICIENT_PRESENT	= ( D3D12_MESSAGE_ID_INVALID_SUBRESOURCE_STATE + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CONTENTION	= ( D3D12_MESSAGE_ID_INEFFICIENT_PRESENT + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET	= ( D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CONTENTION + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET_BUNDLE	= ( D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CANNOT_RESET	= ( D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_RESET_BUNDLE + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_OPEN	= ( D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_CANNOT_RESET + 1 ) ,
-        D3D12_MESSAGE_ID_QUERY_STATE_MISMATCH	= ( D3D12_MESSAGE_ID_COMMAND_LIST_OPEN + 1 ) ,
-        D3D12_MESSAGE_ID_INVALID_BUNDLE_API	= ( D3D12_MESSAGE_ID_QUERY_STATE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_CLOSED	= ( D3D12_MESSAGE_ID_INVALID_BUNDLE_API + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_CLOSED_WITH_INVALID_RESOURCE	= ( D3D12_MESSAGE_ID_COMMAND_LIST_CLOSED + 1 ) ,
-        D3D12_MESSAGE_ID_WRONG_COMMAND_ALLOCATOR_TYPE	= ( D3D12_MESSAGE_ID_COMMAND_LIST_CLOSED_WITH_INVALID_RESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_INVALID_INDIRECT_ARGUMENT_BUFFER	= ( D3D12_MESSAGE_ID_WRONG_COMMAND_ALLOCATOR_TYPE + 1 ) ,
-        D3D12_MESSAGE_ID_COMPUTE_AND_GRAPHICS_PIPELINE	= ( D3D12_MESSAGE_ID_INVALID_INDIRECT_ARGUMENT_BUFFER + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_SYNC	= ( D3D12_MESSAGE_ID_COMPUTE_AND_GRAPHICS_PIPELINE + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_SYNC	= ( D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_SYNC + 1 ) ,
-        D3D12_MESSAGE_ID_SET_DESCRIPTOR_HEAP_INVALID	= ( D3D12_MESSAGE_ID_COMMAND_LIST_SYNC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_QUEUE_IMAGE_NOT_SUPPORTED	= ( D3D12_MESSAGE_ID_SET_DESCRIPTOR_HEAP_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_COMMAND_ALLOCATOR_IMAGE_NOT_SUPPORTED	= ( D3D12_MESSAGE_ID_CREATE_QUEUE_IMAGE_NOT_SUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_COMMANDQUEUE	= ( D3D12_MESSAGE_ID_CREATE_COMMAND_ALLOCATOR_IMAGE_NOT_SUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_COMMANDALLOCATOR	= ( D3D12_MESSAGE_ID_CREATE_COMMANDQUEUE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_PIPELINESTATE	= ( D3D12_MESSAGE_ID_CREATE_COMMANDALLOCATOR + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_COMMANDLIST12	= ( D3D12_MESSAGE_ID_CREATE_PIPELINESTATE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_IMAGECOMMANDLIST	= ( D3D12_MESSAGE_ID_CREATE_COMMANDLIST12 + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_RESOURCE	= ( D3D12_MESSAGE_ID_CREATE_IMAGECOMMANDLIST + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_DESCRIPTORHEAP	= ( D3D12_MESSAGE_ID_CREATE_RESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_ROOTSIGNATURE	= ( D3D12_MESSAGE_ID_CREATE_DESCRIPTORHEAP + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_LIBRARY	= ( D3D12_MESSAGE_ID_CREATE_ROOTSIGNATURE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_HEAP	= ( D3D12_MESSAGE_ID_CREATE_LIBRARY + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_MONITOREDFENCE	= ( D3D12_MESSAGE_ID_CREATE_HEAP + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_QUERYHEAP	= ( D3D12_MESSAGE_ID_CREATE_MONITOREDFENCE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_COMMANDSIGNATURE	= ( D3D12_MESSAGE_ID_CREATE_QUERYHEAP + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_COMMANDQUEUE	= ( D3D12_MESSAGE_ID_CREATE_COMMANDSIGNATURE + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_COMMANDALLOCATOR	= ( D3D12_MESSAGE_ID_LIVE_COMMANDQUEUE + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_PIPELINESTATE	= ( D3D12_MESSAGE_ID_LIVE_COMMANDALLOCATOR + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_COMMANDLIST12	= ( D3D12_MESSAGE_ID_LIVE_PIPELINESTATE + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_IMAGECOMMANDLIST	= ( D3D12_MESSAGE_ID_LIVE_COMMANDLIST12 + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_RESOURCE	= ( D3D12_MESSAGE_ID_LIVE_IMAGECOMMANDLIST + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_DESCRIPTORHEAP	= ( D3D12_MESSAGE_ID_LIVE_RESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_ROOTSIGNATURE	= ( D3D12_MESSAGE_ID_LIVE_DESCRIPTORHEAP + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_LIBRARY	= ( D3D12_MESSAGE_ID_LIVE_ROOTSIGNATURE + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_HEAP	= ( D3D12_MESSAGE_ID_LIVE_LIBRARY + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_MONITOREDFENCE	= ( D3D12_MESSAGE_ID_LIVE_HEAP + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_QUERYHEAP	= ( D3D12_MESSAGE_ID_LIVE_MONITOREDFENCE + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_COMMANDSIGNATURE	= ( D3D12_MESSAGE_ID_LIVE_QUERYHEAP + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_COMMANDQUEUE	= ( D3D12_MESSAGE_ID_LIVE_COMMANDSIGNATURE + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_COMMANDALLOCATOR	= ( D3D12_MESSAGE_ID_DESTROY_COMMANDQUEUE + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_PIPELINESTATE	= ( D3D12_MESSAGE_ID_DESTROY_COMMANDALLOCATOR + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_COMMANDLIST12	= ( D3D12_MESSAGE_ID_DESTROY_PIPELINESTATE + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_IMAGECOMMANDLIST	= ( D3D12_MESSAGE_ID_DESTROY_COMMANDLIST12 + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_RESOURCE	= ( D3D12_MESSAGE_ID_DESTROY_IMAGECOMMANDLIST + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_DESCRIPTORHEAP	= ( D3D12_MESSAGE_ID_DESTROY_RESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_ROOTSIGNATURE	= ( D3D12_MESSAGE_ID_DESTROY_DESCRIPTORHEAP + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_LIBRARY	= ( D3D12_MESSAGE_ID_DESTROY_ROOTSIGNATURE + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_HEAP	= ( D3D12_MESSAGE_ID_DESTROY_LIBRARY + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_MONITOREDFENCE	= ( D3D12_MESSAGE_ID_DESTROY_HEAP + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_QUERYHEAP	= ( D3D12_MESSAGE_ID_DESTROY_MONITOREDFENCE + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_COMMANDSIGNATURE	= ( D3D12_MESSAGE_ID_DESTROY_QUERYHEAP + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDHEAPTYPE	= ( D3D12_MESSAGE_ID_DESTROY_COMMANDSIGNATURE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONS	= ( D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDHEAPTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDMISCFLAGS	= ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMISCFLAGS	= ( D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDMISCFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_LARGEALLOCATION	= ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMISCFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_SMALLALLOCATION	= ( D3D12_MESSAGE_ID_CREATERESOURCE_LARGEALLOCATION + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDARG_RETURN	= ( D3D12_MESSAGE_ID_CREATERESOURCE_SMALLALLOCATION + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_OUTOFMEMORY_RETURN	= ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDARG_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDESC	= ( D3D12_MESSAGE_ID_CREATERESOURCE_OUTOFMEMORY_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDINITIALSTATE	= ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDESC + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_HAS_PENDING_INITIAL_DATA	= ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDINITIALSTATE + 1 ) ,
-        D3D12_MESSAGE_ID_POSSIBLY_INVALID_SUBRESOURCE_STATE	= ( D3D12_MESSAGE_ID_RESOURCE_HAS_PENDING_INITIAL_DATA + 1 ) ,
-        D3D12_MESSAGE_ID_INVALID_USE_OF_NON_RESIDENT_RESOURCE	= ( D3D12_MESSAGE_ID_POSSIBLY_INVALID_SUBRESOURCE_STATE + 1 ) ,
-        D3D12_MESSAGE_ID_POSSIBLE_INVALID_USE_OF_NON_RESIDENT_RESOURCE	= ( D3D12_MESSAGE_ID_INVALID_USE_OF_NON_RESIDENT_RESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_BUNDLE_PIPELINE_STATE_MISMATCH	= ( D3D12_MESSAGE_ID_POSSIBLE_INVALID_USE_OF_NON_RESIDENT_RESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_PRIMITIVE_TOPOLOGY_MISMATCH_PIPELINE_STATE	= ( D3D12_MESSAGE_ID_BUNDLE_PIPELINE_STATE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_RENDER_TARGET_NUMBER_MISMATCH_PIPELINE_STATE	= ( D3D12_MESSAGE_ID_PRIMITIVE_TOPOLOGY_MISMATCH_PIPELINE_STATE + 1 ) ,
-        D3D12_MESSAGE_ID_RENDER_TARGET_FORMAT_MISMATCH_PIPELINE_STATE	= ( D3D12_MESSAGE_ID_RENDER_TARGET_NUMBER_MISMATCH_PIPELINE_STATE + 1 ) ,
-        D3D12_MESSAGE_ID_RENDER_TARGET_SAMPLE_DESC_MISMATCH_PIPELINE_STATE	= ( D3D12_MESSAGE_ID_RENDER_TARGET_FORMAT_MISMATCH_PIPELINE_STATE + 1 ) ,
-        D3D12_MESSAGE_ID_DEPTH_STENCIL_FORMAT_MISMATCH_PIPELINE_STATE	= ( D3D12_MESSAGE_ID_RENDER_TARGET_SAMPLE_DESC_MISMATCH_PIPELINE_STATE + 1 ) ,
-        D3D12_MESSAGE_ID_DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_PIPELINE_STATE	= ( D3D12_MESSAGE_ID_DEPTH_STENCIL_FORMAT_MISMATCH_PIPELINE_STATE + 1 ) ,
-        D3D12_MESSAGE_ID_RENDER_TARGET_NUMBER_MISMATCH_BUNDLE_PIPELINE_STATE	= ( D3D12_MESSAGE_ID_DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_PIPELINE_STATE + 1 ) ,
-        D3D12_MESSAGE_ID_RENDER_TARGET_FORMAT_MISMATCH_BUNDLE_PIPELINE_STATE	= ( D3D12_MESSAGE_ID_RENDER_TARGET_NUMBER_MISMATCH_BUNDLE_PIPELINE_STATE + 1 ) ,
-        D3D12_MESSAGE_ID_RENDER_TARGET_SAMPLE_DESC_MISMATCH_BUNDLE_PIPELINE_STATE	= ( D3D12_MESSAGE_ID_RENDER_TARGET_FORMAT_MISMATCH_BUNDLE_PIPELINE_STATE + 1 ) ,
-        D3D12_MESSAGE_ID_DEPTH_STENCIL_FORMAT_MISMATCH_BUNDLE_PIPELINE_STATE	= ( D3D12_MESSAGE_ID_RENDER_TARGET_SAMPLE_DESC_MISMATCH_BUNDLE_PIPELINE_STATE + 1 ) ,
-        D3D12_MESSAGE_ID_DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_BUNDLE_PIPELINE_STATE	= ( D3D12_MESSAGE_ID_DEPTH_STENCIL_FORMAT_MISMATCH_BUNDLE_PIPELINE_STATE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESHADER_INVALIDBYTECODE	= ( D3D12_MESSAGE_ID_DEPTH_STENCIL_SAMPLE_DESC_MISMATCH_BUNDLE_PIPELINE_STATE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEHEAP_NULLDESC	= ( D3D12_MESSAGE_ID_CREATESHADER_INVALIDBYTECODE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEHEAP_INVALIDSIZE	= ( D3D12_MESSAGE_ID_CREATEHEAP_NULLDESC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDHEAPTYPE	= ( D3D12_MESSAGE_ID_CREATEHEAP_INVALIDSIZE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES	= ( D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDHEAPTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMEMORYPOOL	= ( D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEHEAP_INVALIDPROPERTIES	= ( D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMEMORYPOOL + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEHEAP_INVALIDALIGNMENT	= ( D3D12_MESSAGE_ID_CREATEHEAP_INVALIDPROPERTIES + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMISCFLAGS	= ( D3D12_MESSAGE_ID_CREATEHEAP_INVALIDALIGNMENT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEHEAP_INVALIDMISCFLAGS	= ( D3D12_MESSAGE_ID_CREATEHEAP_UNRECOGNIZEDMISCFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEHEAP_INVALIDARG_RETURN	= ( D3D12_MESSAGE_ID_CREATEHEAP_INVALIDMISCFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEHEAP_OUTOFMEMORY_RETURN	= ( D3D12_MESSAGE_ID_CREATEHEAP_INVALIDARG_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAPPROPERTIES	= ( D3D12_MESSAGE_ID_CREATEHEAP_OUTOFMEMORY_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPTYPE	= ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAPPROPERTIES + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES	= ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDMEMORYPOOL	= ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDCPUPAGEPROPERTIES + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPPROPERTIES	= ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDMEMORYPOOL + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPMISCFLAGS	= ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPPROPERTIES + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPMISCFLAGS	= ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_UNRECOGNIZEDHEAPMISCFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDARG_RETURN	= ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDHEAPMISCFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_OUTOFMEMORY_RETURN	= ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_INVALIDARG_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_UNRECOGNIZEDHEAPTYPE	= ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_OUTOFMEMORY_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_INVALIDHEAPTYPE	= ( D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_UNRECOGNIZEDHEAPTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_INVALID_DESC	= ( D3D12_MESSAGE_ID_GETCUSTOMHEAPPROPERTIES_INVALIDHEAPTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_INVALID_DESCRIPTOR_HANDLE	= ( D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_INVALID_DESC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALID_CONSERVATIVERASTERMODE	= ( D3D12_MESSAGE_ID_INVALID_DESCRIPTOR_HANDLE + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_DRAW_INVALID_SYSTEMVALUE	= ( D3D12_MESSAGE_ID_CREATERASTERIZERSTATE_INVALID_CONSERVATIVERASTERMODE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_RESOURCE	= ( D3D12_MESSAGE_ID_DEVICE_DRAW_INVALID_SYSTEMVALUE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_DESC	= ( D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_RESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_LARGE_OFFSET	= ( D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_INVALID_DESC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_UNORDEREDACCESS_VIEW_INVALID_COUNTER_USAGE	= ( D3D12_MESSAGE_ID_CREATE_CONSTANT_BUFFER_VIEW_LARGE_OFFSET + 1 ) ,
-        D3D12_MESSAGE_ID_COPY_DESCRIPTORS_INVALID_RANGES	= ( D3D12_MESSAGE_ID_CREATE_UNORDEREDACCESS_VIEW_INVALID_COUNTER_USAGE + 1 ) ,
-        D3D12_MESSAGE_ID_COPY_DESCRIPTORS_WRITE_ONLY_DESCRIPTOR	= ( D3D12_MESSAGE_ID_COPY_DESCRIPTORS_INVALID_RANGES + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RTV_FORMAT_NOT_UNKNOWN	= ( D3D12_MESSAGE_ID_COPY_DESCRIPTORS_WRITE_ONLY_DESCRIPTOR + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_RENDER_TARGET_COUNT	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RTV_FORMAT_NOT_UNKNOWN + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VERTEX_SHADER_NOT_SET	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_RENDER_TARGET_COUNT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_NOT_SET	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VERTEX_SHADER_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_HS_DS_SIGNATURE_MISMATCH	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INPUTLAYOUT_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERINDEX	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_HS_DS_SIGNATURE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_COMPONENTTYPE	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERINDEX + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERMASK	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_COMPONENTTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SYSTEMVALUE	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_REGISTERMASK + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SYSTEMVALUE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_MINPRECISION	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_NEVERWRITTEN_ALWAYSREADS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_MINPRECISION + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_XOR_DS_MISMATCH	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_LINKAGE_SEMANTICNAME_NOT_FOUND + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_XOR_DS_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_CONTROL_POINT_COUNT_MISMATCH	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_TESSELLATOR_DOMAIN_MISMATCH	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_CONTROL_POINT_COUNT_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_DS_TESSELLATOR_DOMAIN_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_FORCED_SAMPLE_COUNT	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_CENTER_MULTISAMPLE_PATTERN + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_PRIMITIVETOPOLOGY	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_USE_OF_FORCED_SAMPLE_COUNT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SYSTEMVALUE	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_PRIMITIVETOPOLOGY + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SYSTEMVALUE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_DUAL_SOURCE_BLENDING_CAN_ONLY_HAVE_RENDER_TARGET_0 + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_TYPE_MISMATCH	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_BLENDING + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_TYPE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RENDERTARGETVIEW_NOT_SET	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_OM_RENDER_TARGET_DOES_NOT_SUPPORT_LOGIC_OPS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DEPTHSTENCILVIEW_NOT_SET	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RENDERTARGETVIEW_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_INPUT_PRIMITIVE_MISMATCH	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DEPTHSTENCILVIEW_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_POSITION_NOT_PRESENT	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_INPUT_PRIMITIVE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE_FLAGS	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_POSITION_NOT_PRESENT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_INDEX_BUFFER_PROPERTIES	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE_FLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SAMPLE_DESC	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_INDEX_BUFFER_PROPERTIES + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_ROOT_SIGNATURE_MISMATCH	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_INVALID_SAMPLE_DESC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DS_ROOT_SIGNATURE_MISMATCH	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_HS_ROOT_SIGNATURE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VS_ROOT_SIGNATURE_MISMATCH	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_DS_ROOT_SIGNATURE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_ROOT_SIGNATURE_MISMATCH	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VS_ROOT_SIGNATURE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_ROOT_SIGNATURE_MISMATCH	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_GS_ROOT_SIGNATURE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_ROOT_SIGNATURE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_EXECUTE_BUNDLE_OPEN_BUNDLE	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_MISSING_ROOT_SIGNATURE + 1 ) ,
-        D3D12_MESSAGE_ID_EXECUTE_BUNDLE_DESCRIPTOR_HEAP_MISMATCH	= ( D3D12_MESSAGE_ID_EXECUTE_BUNDLE_OPEN_BUNDLE + 1 ) ,
-        D3D12_MESSAGE_ID_EXECUTE_BUNDLE_TYPE	= ( D3D12_MESSAGE_ID_EXECUTE_BUNDLE_DESCRIPTOR_HEAP_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_DRAW_EMPTY_SCISSOR_RECTANGLE	= ( D3D12_MESSAGE_ID_EXECUTE_BUNDLE_TYPE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_BLOB_NOT_FOUND	= ( D3D12_MESSAGE_ID_DRAW_EMPTY_SCISSOR_RECTANGLE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_DESERIALIZE_FAILED	= ( D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_BLOB_NOT_FOUND + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_INVALID_CONFIGURATION	= ( D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_DESERIALIZE_FAILED + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_SUPPORTED_ON_DEVICE	= ( D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_INVALID_CONFIGURATION + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLRESOURCEPROPERTIES	= ( D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_SUPPORTED_ON_DEVICE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAP	= ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLRESOURCEPROPERTIES + 1 ) ,
-        D3D12_MESSAGE_ID_GETRESOURCEALLOCATIONINFO_INVALIDRDESCS	= ( D3D12_MESSAGE_ID_CREATERESOURCEANDHEAP_NULLHEAP + 1 ) ,
-        D3D12_MESSAGE_ID_MAKERESIDENT_NULLOBJECTARRAY	= ( D3D12_MESSAGE_ID_GETRESOURCEALLOCATIONINFO_INVALIDRDESCS + 1 ) ,
-        D3D12_MESSAGE_ID_MAKERESIDENT_INVALIDOBJECT	= ( D3D12_MESSAGE_ID_MAKERESIDENT_NULLOBJECTARRAY + 1 ) ,
-        D3D12_MESSAGE_ID_EVICT_NULLOBJECTARRAY	= ( D3D12_MESSAGE_ID_MAKERESIDENT_INVALIDOBJECT + 1 ) ,
-        D3D12_MESSAGE_ID_EVICT_INVALIDOBJECT	= ( D3D12_MESSAGE_ID_EVICT_NULLOBJECTARRAY + 1 ) ,
-        D3D12_MESSAGE_ID_HEAPS_UNSUPPORTED	= ( D3D12_MESSAGE_ID_EVICT_INVALIDOBJECT + 1 ) ,
-        D3D12_MESSAGE_ID_SET_DESCRIPTOR_TABLE_INVALID	= ( D3D12_MESSAGE_ID_HEAPS_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_INVALID	= ( D3D12_MESSAGE_ID_SET_DESCRIPTOR_TABLE_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_BUFFER_VIEW_INVALID	= ( D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_SET_ROOT_SHADER_RESOURCE_VIEW_INVALID	= ( D3D12_MESSAGE_ID_SET_ROOT_CONSTANT_BUFFER_VIEW_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_SET_ROOT_UNORDERED_ACCESS_VIEW_INVALID	= ( D3D12_MESSAGE_ID_SET_ROOT_SHADER_RESOURCE_VIEW_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID_DESC	= ( D3D12_MESSAGE_ID_SET_ROOT_UNORDERED_ACCESS_VIEW_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_LARGE_OFFSET	= ( D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID_DESC + 1 ) ,
-        D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID_DESC	= ( D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_LARGE_OFFSET + 1 ) ,
-        D3D12_MESSAGE_ID_SET_INDEX_BUFFER_LARGE_OFFSET	= ( D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID_DESC + 1 ) ,
-        D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID_DESC	= ( D3D12_MESSAGE_ID_SET_INDEX_BUFFER_LARGE_OFFSET + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDDIMENSIONALITY	= ( D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID_DESC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDLAYOUT	= ( D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDDIMENSIONALITY + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONALITY	= ( D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDLAYOUT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDALIGNMENT	= ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDDIMENSIONALITY + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMIPLEVELS	= ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDALIGNMENT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDSAMPLEDESC	= ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDMIPLEVELS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDLAYOUT	= ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDSAMPLEDESC + 1 ) ,
-        D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID	= ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDLAYOUT + 1 ) ,
-        D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID	= ( D3D12_MESSAGE_ID_SET_INDEX_BUFFER_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID	= ( D3D12_MESSAGE_ID_SET_VERTEX_BUFFERS_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_SET_RENDER_TARGETS_INVALID	= ( D3D12_MESSAGE_ID_SET_STREAM_OUTPUT_BUFFERS_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEQUERY_HEAP_INVALID_PARAMETERS	= ( D3D12_MESSAGE_ID_SET_RENDER_TARGETS_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEQUERY_HEAP_JPEG_NOT_SUPPORTED	= ( D3D12_MESSAGE_ID_CREATEQUERY_HEAP_INVALID_PARAMETERS + 1 ) ,
-        D3D12_MESSAGE_ID_BEGIN_END_QUERY_INVALID_PARAMETERS	= ( D3D12_MESSAGE_ID_CREATEQUERY_HEAP_JPEG_NOT_SUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_CLOSE_COMMAND_LIST_OPEN_QUERY	= ( D3D12_MESSAGE_ID_BEGIN_END_QUERY_INVALID_PARAMETERS + 1 ) ,
-        D3D12_MESSAGE_ID_RESOLVE_QUERY_DATA_INVALID_PARAMETERS	= ( D3D12_MESSAGE_ID_CLOSE_COMMAND_LIST_OPEN_QUERY + 1 ) ,
-        D3D12_MESSAGE_ID_SET_PREDICATION_INVALID_PARAMETERS	= ( D3D12_MESSAGE_ID_RESOLVE_QUERY_DATA_INVALID_PARAMETERS + 1 ) ,
-        D3D12_MESSAGE_ID_TIMESTAMPS_NOT_SUPPORTED	= ( D3D12_MESSAGE_ID_SET_PREDICATION_INVALID_PARAMETERS + 1 ) ,
-        D3D12_MESSAGE_ID_UNSTABLE_POWER_STATE	= ( D3D12_MESSAGE_ID_TIMESTAMPS_NOT_SUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDFORMAT	= ( D3D12_MESSAGE_ID_UNSTABLE_POWER_STATE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDFORMAT	= ( D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDSUBRESOURCERANGE	= ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDBASEOFFSET	= ( D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDSUBRESOURCERANGE + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_HEAP	= ( D3D12_MESSAGE_ID_GETCOPYABLELAYOUT_INVALIDBASEOFFSET + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_SAMPLER_INVALID	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_INVALID_HEAP + 1 ) ,
-        D3D12_MESSAGE_ID_CREATECOMMANDSIGNATURE_INVALID	= ( D3D12_MESSAGE_ID_CREATE_SAMPLER_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_EXECUTE_INDIRECT_INVALID_PARAMETERS	= ( D3D12_MESSAGE_ID_CREATECOMMANDSIGNATURE_INVALID + 1 ) ,
-        D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_RESOURCE_DIMENSION	= ( D3D12_MESSAGE_ID_EXECUTE_INDIRECT_INVALID_PARAMETERS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDPLANEINDEX	= ( D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_RESOURCE_DIMENSION + 4 ) ,
-        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANEINDEX	= ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDPLANEINDEX + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_AMBIGUOUSVIDEOPLANEINDEX	= ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_INVALIDVIDEOPLANEINDEX + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDPLANEINDEX	= ( D3D12_MESSAGE_ID_CREATESHADERRESOURCEVIEW_AMBIGUOUSVIDEOPLANEINDEX + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDVIDEOPLANEINDEX	= ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDPLANEINDEX + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_AMBIGUOUSVIDEOPLANEINDEX	= ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_INVALIDVIDEOPLANEINDEX + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDPLANEINDEX	= ( D3D12_MESSAGE_ID_CREATERENDERTARGETVIEW_AMBIGUOUSVIDEOPLANEINDEX + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANEINDEX	= ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDPLANEINDEX + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_AMBIGUOUSVIDEOPLANEINDEX	= ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_INVALIDVIDEOPLANEINDEX + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_INVALIDSCANDATAOFFSET	= ( D3D12_MESSAGE_ID_CREATEUNORDEREDACCESSVIEW_AMBIGUOUSVIDEOPLANEINDEX + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_NOTSUPPORTED	= ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDSCANDATAOFFSET + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_DIMENSIONSTOOLARGE	= ( D3D12_MESSAGE_ID_JPEGDECODE_NOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_INVALIDCOMPONENTS	= ( D3D12_MESSAGE_ID_JPEGDECODE_DIMENSIONSTOOLARGE + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDCOMPONENTS	= ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDCOMPONENTS + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_DESTINATIONNOT2D	= ( D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDCOMPONENTS + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_TILEDRESOURCESUNSUPPORTED	= ( D3D12_MESSAGE_ID_JPEGDECODE_DESTINATIONNOT2D + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_GUARDRECTSUNSUPPORTED	= ( D3D12_MESSAGE_ID_JPEGDECODE_TILEDRESOURCESUNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_FORMATUNSUPPORTED	= ( D3D12_MESSAGE_ID_JPEGDECODE_GUARDRECTSUNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_INVALIDSUBRESOURCE	= ( D3D12_MESSAGE_ID_JPEGDECODE_FORMATUNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_INVALIDMIPLEVEL	= ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDSUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_EMPTYDESTBOX	= ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDMIPLEVEL + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_DESTBOXNOT2D	= ( D3D12_MESSAGE_ID_JPEGDECODE_EMPTYDESTBOX + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_DESTBOXNOTSUB	= ( D3D12_MESSAGE_ID_JPEGDECODE_DESTBOXNOT2D + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_DESTBOXESINTERSECT	= ( D3D12_MESSAGE_ID_JPEGDECODE_DESTBOXNOTSUB + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_XSUBSAMPLEMISMATCH	= ( D3D12_MESSAGE_ID_JPEGDECODE_DESTBOXESINTERSECT + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_YSUBSAMPLEMISMATCH	= ( D3D12_MESSAGE_ID_JPEGDECODE_XSUBSAMPLEMISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_XSUBSAMPLEODD	= ( D3D12_MESSAGE_ID_JPEGDECODE_YSUBSAMPLEMISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_YSUBSAMPLEODD	= ( D3D12_MESSAGE_ID_JPEGDECODE_XSUBSAMPLEODD + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_UPSCALEUNSUPPORTED	= ( D3D12_MESSAGE_ID_JPEGDECODE_YSUBSAMPLEODD + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_TIER4DOWNSCALETOLARGE	= ( D3D12_MESSAGE_ID_JPEGDECODE_UPSCALEUNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_TIER3DOWNSCALEUNSUPPORTED	= ( D3D12_MESSAGE_ID_JPEGDECODE_TIER4DOWNSCALETOLARGE + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_CHROMASIZEMISMATCH	= ( D3D12_MESSAGE_ID_JPEGDECODE_TIER3DOWNSCALEUNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_LUMACHROMASIZEMISMATCH	= ( D3D12_MESSAGE_ID_JPEGDECODE_CHROMASIZEMISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_INVALIDNUMDESTINATIONS	= ( D3D12_MESSAGE_ID_JPEGDECODE_LUMACHROMASIZEMISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_SUBBOXUNSUPPORTED	= ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDNUMDESTINATIONS + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_1DESTUNSUPPORTEDFORMAT	= ( D3D12_MESSAGE_ID_JPEGDECODE_SUBBOXUNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_3DESTUNSUPPORTEDFORMAT	= ( D3D12_MESSAGE_ID_JPEGDECODE_1DESTUNSUPPORTEDFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_SCALEUNSUPPORTED	= ( D3D12_MESSAGE_ID_JPEGDECODE_3DESTUNSUPPORTEDFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_INVALIDSOURCESIZE	= ( D3D12_MESSAGE_ID_JPEGDECODE_SCALEUNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_INVALIDCOPYFLAGS	= ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDSOURCESIZE + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_HAZARD	= ( D3D12_MESSAGE_ID_JPEGDECODE_INVALIDCOPYFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDSRCBUFFERUSAGE	= ( D3D12_MESSAGE_ID_JPEGDECODE_HAZARD + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDSRCBUFFERMISCFLAGS	= ( D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDSRCBUFFERUSAGE + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDDSTTEXTUREUSAGE	= ( D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDSRCBUFFERMISCFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_BACKBUFFERNOTSUPPORTED	= ( D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDDSTTEXTUREUSAGE + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDCOPYFLAGS	= ( D3D12_MESSAGE_ID_JPEGDECODE_BACKBUFFERNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGENCODE_NOTSUPPORTED	= ( D3D12_MESSAGE_ID_JPEGDECODE_UNSUPPORTEDCOPYFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGENCODE_INVALIDSCANDATAOFFSET	= ( D3D12_MESSAGE_ID_JPEGENCODE_NOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGENCODE_INVALIDCOMPONENTS	= ( D3D12_MESSAGE_ID_JPEGENCODE_INVALIDSCANDATAOFFSET + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGENCODE_SOURCENOT2D	= ( D3D12_MESSAGE_ID_JPEGENCODE_INVALIDCOMPONENTS + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGENCODE_TILEDRESOURCESUNSUPPORTED	= ( D3D12_MESSAGE_ID_JPEGENCODE_SOURCENOT2D + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGENCODE_GUARDRECTSUNSUPPORTED	= ( D3D12_MESSAGE_ID_JPEGENCODE_TILEDRESOURCESUNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGENCODE_XSUBSAMPLEMISMATCH	= ( D3D12_MESSAGE_ID_JPEGENCODE_GUARDRECTSUNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGENCODE_YSUBSAMPLEMISMATCH	= ( D3D12_MESSAGE_ID_JPEGENCODE_XSUBSAMPLEMISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDCOMPONENTS	= ( D3D12_MESSAGE_ID_JPEGENCODE_YSUBSAMPLEMISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGENCODE_FORMATUNSUPPORTED	= ( D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDCOMPONENTS + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGENCODE_INVALIDSUBRESOURCE	= ( D3D12_MESSAGE_ID_JPEGENCODE_FORMATUNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGENCODE_INVALIDMIPLEVEL	= ( D3D12_MESSAGE_ID_JPEGENCODE_INVALIDSUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGENCODE_DIMENSIONSTOOLARGE	= ( D3D12_MESSAGE_ID_JPEGENCODE_INVALIDMIPLEVEL + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGENCODE_HAZARD	= ( D3D12_MESSAGE_ID_JPEGENCODE_DIMENSIONSTOOLARGE + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDDSTBUFFERUSAGE	= ( D3D12_MESSAGE_ID_JPEGENCODE_HAZARD + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDDSTBUFFERMISCFLAGS	= ( D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDDSTBUFFERUSAGE + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDSRCTEXTUREUSAGE	= ( D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDDSTBUFFERMISCFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_JPEGENCODE_BACKBUFFERNOTSUPPORTED	= ( D3D12_MESSAGE_ID_JPEGENCODE_UNSUPPORTEDSRCTEXTUREUSAGE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEQUERYORPREDICATE_UNSUPPORTEDCONTEXTTYPEFORQUERY	= ( D3D12_MESSAGE_ID_JPEGENCODE_BACKBUFFERNOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_FLUSH1_INVALIDCONTEXTTYPE	= ( D3D12_MESSAGE_ID_CREATEQUERYORPREDICATE_UNSUPPORTEDCONTEXTTYPEFORQUERY + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUE	= ( D3D12_MESSAGE_ID_FLUSH1_INVALIDCONTEXTTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDCLEARVALUEFORMAT	= ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUEFORMAT	= ( D3D12_MESSAGE_ID_CREATERESOURCE_UNRECOGNIZEDCLEARVALUEFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATERESOURCE_CLEARVALUEDENORMFLUSH	= ( D3D12_MESSAGE_ID_CREATERESOURCE_INVALIDCLEARVALUEFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALIDDEPTH	= ( D3D12_MESSAGE_ID_CREATERESOURCE_CLEARVALUEDENORMFLUSH + 1 ) ,
-        D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_MISMATCHINGCLEARVALUE	= ( D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_INVALIDDEPTH + 1 ) ,
-        D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_MISMATCHINGCLEARVALUE	= ( D3D12_MESSAGE_ID_CLEARRENDERTARGETVIEW_MISMATCHINGCLEARVALUE + 1 ) ,
-        D3D12_MESSAGE_ID_MAP_INVALIDHEAP	= ( D3D12_MESSAGE_ID_CLEARDEPTHSTENCILVIEW_MISMATCHINGCLEARVALUE + 1 ) ,
-        D3D12_MESSAGE_ID_UNMAP_INVALIDHEAP	= ( D3D12_MESSAGE_ID_MAP_INVALIDHEAP + 1 ) ,
-        D3D12_MESSAGE_ID_MAP_INVALIDRESOURCE	= ( D3D12_MESSAGE_ID_UNMAP_INVALIDHEAP + 1 ) ,
-        D3D12_MESSAGE_ID_UNMAP_INVALIDRESOURCE	= ( D3D12_MESSAGE_ID_MAP_INVALIDRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_MAP_INVALIDSUBRESOURCE	= ( D3D12_MESSAGE_ID_UNMAP_INVALIDRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_UNMAP_INVALIDSUBRESOURCE	= ( D3D12_MESSAGE_ID_MAP_INVALIDSUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_MAP_INVALIDRANGE	= ( D3D12_MESSAGE_ID_UNMAP_INVALIDSUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_UNMAP_INVALIDRANGE	= ( D3D12_MESSAGE_ID_MAP_INVALIDRANGE + 1 ) ,
-        D3D12_MESSAGE_ID_MAP_NULLRANGE	= ( D3D12_MESSAGE_ID_UNMAP_INVALIDRANGE + 1 ) ,
-        D3D12_MESSAGE_ID_UNMAP_NULLRANGE	= ( D3D12_MESSAGE_ID_MAP_NULLRANGE + 1 ) ,
-        D3D12_MESSAGE_ID_MAP_INVALIDDATAPOINTER	= ( D3D12_MESSAGE_ID_UNMAP_NULLRANGE + 1 ) ,
-        D3D12_MESSAGE_ID_MAP_INVALIDARG_RETURN	= ( D3D12_MESSAGE_ID_MAP_INVALIDDATAPOINTER + 1 ) ,
-        D3D12_MESSAGE_ID_MAP_OUTOFMEMORY_RETURN	= ( D3D12_MESSAGE_ID_MAP_INVALIDARG_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_BUNDLENOTSUPPORTED	= ( D3D12_MESSAGE_ID_MAP_OUTOFMEMORY_RETURN + 1 ) ,
-        D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_COMMANDLISTMISMATCH	= ( D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_BUNDLENOTSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_OPENCOMMANDLIST	= ( D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_COMMANDLISTMISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_FAILEDCOMMANDLIST	= ( D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_OPENCOMMANDLIST + 1 ) ,
-        D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLDST	= ( D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_FAILEDCOMMANDLIST + 1 ) ,
-        D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDDSTRESOURCEDIMENSION	= ( D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLDST + 1 ) ,
-        D3D12_MESSAGE_ID_COPYBUFFERREGION_DSTRANGEOUTOFBOUNDS	= ( D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDDSTRESOURCEDIMENSION + 1 ) ,
-        D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLSRC	= ( D3D12_MESSAGE_ID_COPYBUFFERREGION_DSTRANGEOUTOFBOUNDS + 1 ) ,
-        D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDSRCRESOURCEDIMENSION	= ( D3D12_MESSAGE_ID_COPYBUFFERREGION_NULLSRC + 1 ) ,
-        D3D12_MESSAGE_ID_COPYBUFFERREGION_SRCRANGEOUTOFBOUNDS	= ( D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDSRCRESOURCEDIMENSION + 1 ) ,
-        D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDCOPYFLAGS	= ( D3D12_MESSAGE_ID_COPYBUFFERREGION_SRCRANGEOUTOFBOUNDS + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLDST	= ( D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALIDCOPYFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTTYPE	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLDST + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCEDIMENSION	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCE	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCEDIMENSION + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTSUBRESOURCE	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTOFFSET	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTSUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTFORMAT	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTOFFSET + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTFORMAT	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDDSTFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDIMENSIONS	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTROWPITCH	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDIMENSIONS + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTPLACEMENT	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTROWPITCH + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDSPLACEDFOOTPRINTFORMAT	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTPLACEMENT + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_DSTREGIONOUTOFBOUNDS	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTDSPLACEDFOOTPRINTFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLSRC	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_DSTREGIONOUTOFBOUNDS + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCTYPE	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_NULLSRC + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCEDIMENSION	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCTYPE + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCE	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCEDIMENSION + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCSUBRESOURCE	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCOFFSET	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCSUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCFORMAT	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCOFFSET + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCFORMAT	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_UNRECOGNIZEDSRCFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDIMENSIONS	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCROWPITCH	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDIMENSIONS + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCPLACEMENT	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCROWPITCH + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDSPLACEDFOOTPRINTFORMAT	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCPLACEMENT + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_SRCREGIONOUTOFBOUNDS	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCDSPLACEDFOOTPRINTFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTCOORDINATES	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_SRCREGIONOUTOFBOUNDS + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCBOX	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDDSTCOORDINATES + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_FORMATMISMATCH	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDSRCBOX + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_EMPTYBOX	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_FORMATMISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDCOPYFLAGS	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_EMPTYBOX + 1 ) ,
-        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SUBRESOURCE_INDEX	= ( D3D12_MESSAGE_ID_COPYTEXTUREREGION_INVALIDCOPYFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_FORMAT	= ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SUBRESOURCE_INDEX + 1 ) ,
-        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_MISMATCH	= ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_FORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SAMPLE_COUNT	= ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_INVALID_SHADER	= ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALID_SAMPLE_COUNT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_CS_ROOT_SIGNATURE_MISMATCH	= ( D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_INVALID_SHADER + 1 ) ,
-        D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_MISSING_ROOT_SIGNATURE	= ( D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_CS_ROOT_SIGNATURE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALIDCACHEDBLOB	= ( D3D12_MESSAGE_ID_CREATECOMPUTEPIPELINESTATE_MISSING_ROOT_SIGNATURE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBADAPTERMISMATCH	= ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALIDCACHEDBLOB + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDRIVERVERSIONMISMATCH	= ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBADAPTERMISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDESCMISMATCH	= ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDRIVERVERSIONMISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBIGNORED	= ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBDESCMISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDHEAP	= ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CACHEDBLOBIGNORED + 1 ) ,
-        D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDRESOURCE	= ( D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDHEAP + 1 ) ,
-        D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDBOX	= ( D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDSUBRESOURCE	= ( D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDBOX + 1 ) ,
-        D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_EMPTYBOX	= ( D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_INVALIDSUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDHEAP	= ( D3D12_MESSAGE_ID_WRITETOSUBRESOURCE_EMPTYBOX + 1 ) ,
-        D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDRESOURCE	= ( D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDHEAP + 1 ) ,
-        D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDBOX	= ( D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDSUBRESOURCE	= ( D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDBOX + 1 ) ,
-        D3D12_MESSAGE_ID_READFROMSUBRESOURCE_EMPTYBOX	= ( D3D12_MESSAGE_ID_READFROMSUBRESOURCE_INVALIDSUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_TOO_MANY_NODES_SPECIFIED	= ( D3D12_MESSAGE_ID_READFROMSUBRESOURCE_EMPTYBOX + 1 ) ,
-        D3D12_MESSAGE_ID_INVALID_NODE_INDEX	= ( D3D12_MESSAGE_ID_TOO_MANY_NODES_SPECIFIED + 1 ) ,
-        D3D12_MESSAGE_ID_GETHEAPPROPERTIES_INVALIDRESOURCE	= ( D3D12_MESSAGE_ID_INVALID_NODE_INDEX + 1 ) ,
-        D3D12_MESSAGE_ID_NODE_MASK_MISMATCH	= ( D3D12_MESSAGE_ID_GETHEAPPROPERTIES_INVALIDRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_OUTOFMEMORY	= ( D3D12_MESSAGE_ID_NODE_MASK_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_MULTIPLE_SWAPCHAIN_BUFFER_REFERENCES	= ( D3D12_MESSAGE_ID_COMMAND_LIST_OUTOFMEMORY + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_TOO_MANY_SWAPCHAIN_REFERENCES	= ( D3D12_MESSAGE_ID_COMMAND_LIST_MULTIPLE_SWAPCHAIN_BUFFER_REFERENCES + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_QUEUE_TOO_MANY_SWAPCHAIN_REFERENCES	= ( D3D12_MESSAGE_ID_COMMAND_LIST_TOO_MANY_SWAPCHAIN_REFERENCES + 1 ) ,
-        D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_WRONGSWAPCHAINBUFFERREFERENCE	= ( D3D12_MESSAGE_ID_COMMAND_QUEUE_TOO_MANY_SWAPCHAIN_REFERENCES + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_SETRENDERTARGETS_INVALIDNUMRENDERTARGETS	= ( D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_WRONGSWAPCHAINBUFFERREFERENCE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_TYPE	= ( D3D12_MESSAGE_ID_COMMAND_LIST_SETRENDERTARGETS_INVALIDNUMRENDERTARGETS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_FLAGS	= ( D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_TYPE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFLAGS	= ( D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_FLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFORMAT	= ( D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATESHAREDHEAP_INVALIDFLAGS	= ( D3D12_MESSAGE_ID_CREATESHAREDRESOURCE_INVALIDFORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_UNRECOGNIZEDPROPERTIES	= ( D3D12_MESSAGE_ID_CREATESHAREDHEAP_INVALIDFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDSIZE	= ( D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_UNRECOGNIZEDPROPERTIES + 1 ) ,
-        D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDOBJECT	= ( D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDSIZE + 1 ) ,
-        D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDOBJECT	= ( D3D12_MESSAGE_ID_REFLECTSHAREDPROPERTIES_INVALIDOBJECT + 1 ) ,
-        D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDKEY	= ( D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDOBJECT + 1 ) ,
-        D3D12_MESSAGE_ID_KEYEDMUTEX_WRONGSTATE	= ( D3D12_MESSAGE_ID_KEYEDMUTEX_INVALIDKEY + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_PRIORITY	= ( D3D12_MESSAGE_ID_KEYEDMUTEX_WRONGSTATE + 1 ) ,
-        D3D12_MESSAGE_ID_OBJECT_DELETED_WHILE_STILL_IN_USE	= ( D3D12_MESSAGE_ID_CREATE_QUEUE_INVALID_PRIORITY + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_FLAGS	= ( D3D12_MESSAGE_ID_OBJECT_DELETED_WHILE_STILL_IN_USE + 1 ) ,
-        D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_HAS_NO_RESOURCE	= ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_FLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RENDER_TARGET_DELETED	= ( D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_HAS_NO_RESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_ALL_RENDER_TARGETS_HAVE_UNKNOWN_FORMAT	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DRAW_RENDER_TARGET_DELETED + 1 ) ,
-        D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_INTERSECTS_MULTIPLE_BUFFERS	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_ALL_RENDER_TARGETS_HAVE_UNKNOWN_FORMAT + 1 ) ,
-        D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_GPU_WRITTEN_READBACK_RESOURCE_MAPPED	= ( D3D12_MESSAGE_ID_HEAP_ADDRESS_RANGE_INTERSECTS_MULTIPLE_BUFFERS + 1 ) ,
-        D3D12_MESSAGE_ID_UNMAP_RANGE_NOT_NEEDED	= ( D3D12_MESSAGE_ID_EXECUTECOMMANDLISTS_GPU_WRITTEN_READBACK_RESOURCE_MAPPED + 1 ) ,
-        D3D12_MESSAGE_ID_UNMAP_RANGE_NOT_EMPTY	= ( D3D12_MESSAGE_ID_UNMAP_RANGE_NOT_NEEDED + 1 ) ,
-        D3D12_MESSAGE_ID_MAP_INVALID_NULLRANGE	= ( D3D12_MESSAGE_ID_UNMAP_RANGE_NOT_EMPTY + 1 ) ,
-        D3D12_MESSAGE_ID_UNMAP_INVALID_NULLRANGE	= ( D3D12_MESSAGE_ID_MAP_INVALID_NULLRANGE + 1 ) ,
-        D3D12_MESSAGE_ID_NO_GRAPHICS_API_SUPPORT	= ( D3D12_MESSAGE_ID_UNMAP_INVALID_NULLRANGE + 1 ) ,
-        D3D12_MESSAGE_ID_NO_COMPUTE_API_SUPPORT	= ( D3D12_MESSAGE_ID_NO_GRAPHICS_API_SUPPORT + 1 ) ,
-        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_FLAGS_NOT_SUPPORTED	= ( D3D12_MESSAGE_ID_NO_COMPUTE_API_SUPPORT + 1 ) ,
-        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_ARGUMENT_UNINITIALIZED	= ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_RESOURCE_FLAGS_NOT_SUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_HEAP_INDEX_OUT_OF_BOUNDS	= ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_ARGUMENT_UNINITIALIZED + 1 ) ,
-        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TABLE_REGISTER_INDEX_OUT_OF_BOUNDS	= ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_HEAP_INDEX_OUT_OF_BOUNDS + 1 ) ,
-        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_UNINITIALIZED	= ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TABLE_REGISTER_INDEX_OUT_OF_BOUNDS + 1 ) ,
-        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TYPE_MISMATCH	= ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_UNINITIALIZED + 1 ) ,
-        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SRV_RESOURCE_DIMENSION_MISMATCH	= ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_DESCRIPTOR_TYPE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UAV_RESOURCE_DIMENSION_MISMATCH	= ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SRV_RESOURCE_DIMENSION_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INCOMPATIBLE_RESOURCE_STATE	= ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UAV_RESOURCE_DIMENSION_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_COPYRESOURCE_NULLDST	= ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INCOMPATIBLE_RESOURCE_STATE + 1 ) ,
-        D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDDSTRESOURCE	= ( D3D12_MESSAGE_ID_COPYRESOURCE_NULLDST + 1 ) ,
-        D3D12_MESSAGE_ID_COPYRESOURCE_NULLSRC	= ( D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDDSTRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSRCRESOURCE	= ( D3D12_MESSAGE_ID_COPYRESOURCE_NULLSRC + 1 ) ,
-        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLDST	= ( D3D12_MESSAGE_ID_COPYRESOURCE_INVALIDSRCRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDDSTRESOURCE	= ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLDST + 1 ) ,
-        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLSRC	= ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDDSTRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDSRCRESOURCE	= ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_NULLSRC + 1 ) ,
-        D3D12_MESSAGE_ID_PIPELINE_STATE_TYPE_MISMATCH	= ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCE_INVALIDSRCRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_NOT_SET	= ( D3D12_MESSAGE_ID_PIPELINE_STATE_TYPE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_MISMATCH	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_ZERO_BARRIERS	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DISPATCH_ROOT_SIGNATURE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_BEGIN_END_EVENT_MISMATCH	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_ZERO_BARRIERS + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_POSSIBLE_BEFORE_AFTER_MISMATCH	= ( D3D12_MESSAGE_ID_BEGIN_END_EVENT_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_BEGIN_END	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_POSSIBLE_BEFORE_AFTER_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INVALID_RESOURCE	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_BEGIN_END + 1 ) ,
-        D3D12_MESSAGE_ID_USE_OF_ZERO_REFCOUNT_OBJECT	= ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_INVALID_RESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_OBJECT_EVICTED_WHILE_STILL_IN_USE	= ( D3D12_MESSAGE_ID_USE_OF_ZERO_REFCOUNT_OBJECT + 1 ) ,
-        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_DESCRIPTOR_ACCESS_OUT_OF_BOUNDS	= ( D3D12_MESSAGE_ID_OBJECT_EVICTED_WHILE_STILL_IN_USE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_INVALIDLIBRARYBLOB	= ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_ROOT_DESCRIPTOR_ACCESS_OUT_OF_BOUNDS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_DRIVERVERSIONMISMATCH	= ( D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_INVALIDLIBRARYBLOB + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_ADAPTERVERSIONMISMATCH	= ( D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_DRIVERVERSIONMISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_UNSUPPORTED	= ( D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_ADAPTERVERSIONMISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_PIPELINELIBRARY	= ( D3D12_MESSAGE_ID_CREATEPIPELINELIBRARY_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_PIPELINELIBRARY	= ( D3D12_MESSAGE_ID_CREATE_PIPELINELIBRARY + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_PIPELINELIBRARY	= ( D3D12_MESSAGE_ID_LIVE_PIPELINELIBRARY + 1 ) ,
-        D3D12_MESSAGE_ID_STOREPIPELINE_NONAME	= ( D3D12_MESSAGE_ID_DESTROY_PIPELINELIBRARY + 1 ) ,
-        D3D12_MESSAGE_ID_STOREPIPELINE_DUPLICATENAME	= ( D3D12_MESSAGE_ID_STOREPIPELINE_NONAME + 1 ) ,
-        D3D12_MESSAGE_ID_LOADPIPELINE_NAMENOTFOUND	= ( D3D12_MESSAGE_ID_STOREPIPELINE_DUPLICATENAME + 1 ) ,
-        D3D12_MESSAGE_ID_LOADPIPELINE_INVALIDDESC	= ( D3D12_MESSAGE_ID_LOADPIPELINE_NAMENOTFOUND + 1 ) ,
-        D3D12_MESSAGE_ID_PIPELINELIBRARY_SERIALIZE_NOTENOUGHMEMORY	= ( D3D12_MESSAGE_ID_LOADPIPELINE_INVALIDDESC + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_RT_OUTPUT_MISMATCH	= ( D3D12_MESSAGE_ID_PIPELINELIBRARY_SERIALIZE_NOTENOUGHMEMORY + 1 ) ,
-        D3D12_MESSAGE_ID_SETEVENTONMULTIPLEFENCECOMPLETION_INVALIDFLAGS	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_PS_OUTPUT_RT_OUTPUT_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_QUEUE_VIDEO_NOT_SUPPORTED	= ( D3D12_MESSAGE_ID_SETEVENTONMULTIPLEFENCECOMPLETION_INVALIDFLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_COMMAND_ALLOCATOR_VIDEO_NOT_SUPPORTED	= ( D3D12_MESSAGE_ID_CREATE_QUEUE_VIDEO_NOT_SUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEQUERY_HEAP_VIDEO_DECODE_STATISTICS_NOT_SUPPORTED	= ( D3D12_MESSAGE_ID_CREATE_COMMAND_ALLOCATOR_VIDEO_NOT_SUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDLIST	= ( D3D12_MESSAGE_ID_CREATEQUERY_HEAP_VIDEO_DECODE_STATISTICS_NOT_SUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_VIDEODECODER	= ( D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDLIST + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_VIDEODECODESTREAM	= ( D3D12_MESSAGE_ID_CREATE_VIDEODECODER + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDLIST	= ( D3D12_MESSAGE_ID_CREATE_VIDEODECODESTREAM + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_VIDEODECODER	= ( D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDLIST + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_VIDEODECODESTREAM	= ( D3D12_MESSAGE_ID_LIVE_VIDEODECODER + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDLIST	= ( D3D12_MESSAGE_ID_LIVE_VIDEODECODESTREAM + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_VIDEODECODER	= ( D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDLIST + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_VIDEODECODESTREAM	= ( D3D12_MESSAGE_ID_DESTROY_VIDEODECODER + 1 ) ,
-        D3D12_MESSAGE_ID_DECODE_FRAME_INVALID_PARAMETERS	= ( D3D12_MESSAGE_ID_DESTROY_VIDEODECODESTREAM + 1 ) ,
-        D3D12_MESSAGE_ID_DEPRECATED_API	= ( D3D12_MESSAGE_ID_DECODE_FRAME_INVALID_PARAMETERS + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_COMMAND_LIST_TYPE	= ( D3D12_MESSAGE_ID_DEPRECATED_API + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_DESCRIPTOR_TABLE_NOT_SET	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_MISMATCHING_COMMAND_LIST_TYPE + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_CONSTANT_BUFFER_VIEW_NOT_SET	= ( D3D12_MESSAGE_ID_COMMAND_LIST_DESCRIPTOR_TABLE_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_SHADER_RESOURCE_VIEW_NOT_SET	= ( D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_CONSTANT_BUFFER_VIEW_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_UNORDERED_ACCESS_VIEW_NOT_SET	= ( D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_SHADER_RESOURCE_VIEW_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_DISCARD_INVALID_SUBRESOURCE_RANGE	= ( D3D12_MESSAGE_ID_COMMAND_LIST_ROOT_UNORDERED_ACCESS_VIEW_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_DISCARD_ONE_SUBRESOURCE_FOR_MIPS_WITH_RECTS	= ( D3D12_MESSAGE_ID_DISCARD_INVALID_SUBRESOURCE_RANGE + 1 ) ,
-        D3D12_MESSAGE_ID_DISCARD_NO_RECTS_FOR_NON_TEXTURE2D	= ( D3D12_MESSAGE_ID_DISCARD_ONE_SUBRESOURCE_FOR_MIPS_WITH_RECTS + 1 ) ,
-        D3D12_MESSAGE_ID_COPY_ON_SAME_SUBRESOURCE	= ( D3D12_MESSAGE_ID_DISCARD_NO_RECTS_FOR_NON_TEXTURE2D + 1 ) ,
-        D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PAGEABLE	= ( D3D12_MESSAGE_ID_COPY_ON_SAME_SUBRESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UNSUPPORTED	= ( D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PAGEABLE + 1 ) ,
-        D3D12_MESSAGE_ID_STATIC_DESCRIPTOR_INVALID_DESCRIPTOR_CHANGE	= ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_DATA_STATIC_DESCRIPTOR_INVALID_DATA_CHANGE	= ( D3D12_MESSAGE_ID_STATIC_DESCRIPTOR_INVALID_DESCRIPTOR_CHANGE + 1 ) ,
-        D3D12_MESSAGE_ID_DATA_STATIC_WHILE_SET_AT_EXECUTE_DESCRIPTOR_INVALID_DATA_CHANGE	= ( D3D12_MESSAGE_ID_DATA_STATIC_DESCRIPTOR_INVALID_DATA_CHANGE + 1 ) ,
-        D3D12_MESSAGE_ID_EXECUTE_BUNDLE_STATIC_DESCRIPTOR_DATA_STATIC_NOT_SET	= ( D3D12_MESSAGE_ID_DATA_STATIC_WHILE_SET_AT_EXECUTE_DESCRIPTOR_INVALID_DATA_CHANGE + 1 ) ,
-        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_ACCESS_OUT_OF_BOUNDS	= ( D3D12_MESSAGE_ID_EXECUTE_BUNDLE_STATIC_DESCRIPTOR_DATA_STATIC_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SAMPLER_MODE_MISMATCH	= ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_ACCESS_OUT_OF_BOUNDS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_FENCE_INVALID_FLAGS	= ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_SAMPLER_MODE_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_RESOURCE_BARRIER_DUPLICATE_SUBRESOURCE_TRANSITIONS	= ( D3D12_MESSAGE_ID_CREATE_FENCE_INVALID_FLAGS + 1 ) ,
-        D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PRIORITY	= ( D3D12_MESSAGE_ID_RESOURCE_BARRIER_DUPLICATE_SUBRESOURCE_TRANSITIONS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_PASS	= ( D3D12_MESSAGE_ID_SETRESIDENCYPRIORITY_INVALID_PRIORITY + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_PASS	= ( D3D12_MESSAGE_ID_CREATE_PASS + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_PASS	= ( D3D12_MESSAGE_ID_DESTROY_PASS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_LARGE_NUM_DESCRIPTORS	= ( D3D12_MESSAGE_ID_LIVE_PASS + 1 ) ,
-        D3D12_MESSAGE_ID_BEGIN_EVENT	= ( D3D12_MESSAGE_ID_CREATE_DESCRIPTOR_HEAP_LARGE_NUM_DESCRIPTORS + 1 ) ,
-        D3D12_MESSAGE_ID_END_EVENT	= ( D3D12_MESSAGE_ID_BEGIN_EVENT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEVICE_DEBUG_LAYER_STARTUP_OPTIONS	= ( D3D12_MESSAGE_ID_END_EVENT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_DEPTHBOUNDSTEST_UNSUPPORTED	= ( D3D12_MESSAGE_ID_CREATEDEVICE_DEBUG_LAYER_STARTUP_OPTIONS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_DUPLICATE_SUBOBJECT	= ( D3D12_MESSAGE_ID_CREATEDEPTHSTENCILSTATE_DEPTHBOUNDSTEST_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_UNKNOWN_SUBOBJECT	= ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_DUPLICATE_SUBOBJECT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_ZERO_SIZE_STREAM	= ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_UNKNOWN_SUBOBJECT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_STREAM	= ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_ZERO_SIZE_STREAM + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CANNOT_DEDUCE_TYPE	= ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_INVALID_STREAM + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_STATIC_DESCRIPTOR_RESOURCE_DIMENSION_MISMATCH	= ( D3D12_MESSAGE_ID_CREATEPIPELINESTATE_CANNOT_DEDUCE_TYPE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_PRIVILEGE_FOR_GLOBAL_REALTIME	= ( D3D12_MESSAGE_ID_COMMAND_LIST_STATIC_DESCRIPTOR_RESOURCE_DIMENSION_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_HARDWARE_SUPPORT_FOR_GLOBAL_REALTIME	= ( D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_PRIVILEGE_FOR_GLOBAL_REALTIME + 1 ) ,
-        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_ARCHITECTURE	= ( D3D12_MESSAGE_ID_CREATE_COMMAND_QUEUE_INSUFFICIENT_HARDWARE_SUPPORT_FOR_GLOBAL_REALTIME + 1 ) ,
-        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DST	= ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_ARCHITECTURE + 1 ) ,
-        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE_DIMENSION	= ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DST + 1 ) ,
-        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DST_RANGE_OUT_OF_BOUNDS	= ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE_DIMENSION + 1 ) ,
-        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_SRC	= ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DST_RANGE_OUT_OF_BOUNDS + 1 ) ,
-        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE_DIMENSION	= ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_SRC + 1 ) ,
-        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_SRC_RANGE_OUT_OF_BOUNDS	= ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE_DIMENSION + 1 ) ,
-        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_OFFSET_ALIGNMENT	= ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_SRC_RANGE_OUT_OF_BOUNDS + 1 ) ,
-        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_RESOURCES	= ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_OFFSET_ALIGNMENT + 1 ) ,
-        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_SUBRESOURCE_RANGES	= ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_RESOURCES + 1 ) ,
-        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_RESOURCE	= ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_NULL_DEPENDENT_SUBRESOURCE_RANGES + 1 ) ,
-        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_SUBRESOURCE_RANGE	= ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_RESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_SUBRESOURCE_OUT_OF_BOUNDS	= ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DEPENDENT_SUBRESOURCE_RANGE + 1 ) ,
-        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_RANGE_OUT_OF_BOUNDS	= ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_SUBRESOURCE_OUT_OF_BOUNDS + 1 ) ,
-        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_ZERO_DEPENDENCIES	= ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_DEPENDENT_RANGE_OUT_OF_BOUNDS + 1 ) ,
-        D3D12_MESSAGE_ID_DEVICE_CREATE_SHARED_HANDLE_INVALIDARG	= ( D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_ZERO_DEPENDENCIES + 1 ) ,
-        D3D12_MESSAGE_ID_DESCRIPTOR_HANDLE_WITH_INVALID_RESOURCE	= ( D3D12_MESSAGE_ID_DEVICE_CREATE_SHARED_HANDLE_INVALIDARG + 1 ) ,
-        D3D12_MESSAGE_ID_SETDEPTHBOUNDS_INVALIDARGS	= ( D3D12_MESSAGE_ID_DESCRIPTOR_HANDLE_WITH_INVALID_RESOURCE + 1 ) ,
-        D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_STATE_IMPRECISE	= ( D3D12_MESSAGE_ID_SETDEPTHBOUNDS_INVALIDARGS + 1 ) ,
-        D3D12_MESSAGE_ID_COMMAND_LIST_PIPELINE_STATE_NOT_SET	= ( D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_RESOURCE_STATE_IMPRECISE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_MODEL_MISMATCH	= ( D3D12_MESSAGE_ID_COMMAND_LIST_PIPELINE_STATE_NOT_SET + 1 ) ,
-        D3D12_MESSAGE_ID_OBJECT_ACCESSED_WHILE_STILL_IN_USE	= ( D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_SHADER_MODEL_MISMATCH + 1 ) ,
-        D3D12_MESSAGE_ID_PROGRAMMABLE_MSAA_UNSUPPORTED	= ( D3D12_MESSAGE_ID_OBJECT_ACCESSED_WHILE_STILL_IN_USE + 1 ) ,
-        D3D12_MESSAGE_ID_SETSAMPLEPOSITIONS_INVALIDARGS	= ( D3D12_MESSAGE_ID_PROGRAMMABLE_MSAA_UNSUPPORTED + 1 ) ,
-        D3D12_MESSAGE_ID_RESOLVESUBRESOURCEREGION_INVALID_RECT	= ( D3D12_MESSAGE_ID_SETSAMPLEPOSITIONS_INVALIDARGS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDQUEUE	= ( D3D12_MESSAGE_ID_RESOLVESUBRESOURCEREGION_INVALID_RECT + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDLIST	= ( D3D12_MESSAGE_ID_CREATE_VIDEODECODECOMMANDQUEUE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDQUEUE	= ( D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDLIST + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDQUEUE	= ( D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSCOMMANDQUEUE + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDLIST	= ( D3D12_MESSAGE_ID_LIVE_VIDEODECODECOMMANDQUEUE + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDQUEUE	= ( D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDLIST + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDQUEUE	= ( D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSCOMMANDQUEUE + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDLIST	= ( D3D12_MESSAGE_ID_DESTROY_VIDEODECODECOMMANDQUEUE + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDQUEUE	= ( D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDLIST + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSOR	= ( D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSCOMMANDQUEUE + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSSTREAM	= ( D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSOR + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSOR	= ( D3D12_MESSAGE_ID_CREATE_VIDEOPROCESSSTREAM + 1 ) ,
-        D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSSTREAM	= ( D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSOR + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSOR	= ( D3D12_MESSAGE_ID_LIVE_VIDEOPROCESSSTREAM + 1 ) ,
-        D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSSTREAM	= ( D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSOR + 1 ) ,
-        D3D12_MESSAGE_ID_PROCESS_FRAME_INVALID_PARAMETERS	= ( D3D12_MESSAGE_ID_DESTROY_VIDEOPROCESSSTREAM + 1 ) ,
-        D3D12_MESSAGE_ID_COPY_INVALIDLAYOUT	= ( D3D12_MESSAGE_ID_PROCESS_FRAME_INVALID_PARAMETERS + 1 ) ,
-        D3D12_MESSAGE_ID_CREATE_CRYPTO_SESSION	= 1068,
-        D3D12_MESSAGE_ID_CREATE_CRYPTO_SESSION_POLICY	= 1069,
-        D3D12_MESSAGE_ID_CREATE_PROTECTED_RESOURCE_SESSION	= 1070,
-        D3D12_MESSAGE_ID_LIVE_CRYPTO_SESSION	= 1071,
-        D3D12_MESSAGE_ID_LIVE_CRYPTO_SESSION_POLICY	= 1072,
-        D3D12_MESSAGE_ID_LIVE_PROTECTED_RESOURCE_SESSION	= 1073,
-        D3D12_MESSAGE_ID_DESTROY_CRYPTO_SESSION	= 1074,
-        D3D12_MESSAGE_ID_DESTROY_CRYPTO_SESSION_POLICY	= 1075,
-        D3D12_MESSAGE_ID_DESTROY_PROTECTED_RESOURCE_SESSION	= 1076,
-        D3D12_MESSAGE_ID_PROTECTED_RESOURCE_SESSION_UNSUPPORTED	= 1077,
-        D3D12_MESSAGE_ID_FENCE_INVALIDOPERATION	= 1078,
-        D3D12_MESSAGE_ID_CREATEQUERY_HEAP_COPY_QUEUE_TIMESTAMPS_NOT_SUPPORTED	= 1079,
-        D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_DEFERRED	= 1080,
-        D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMFIRSTUSE	= 1081,
-        D3D12_MESSAGE_ID_SAMPLEPOSITIONS_MISMATCH_RECORDTIME_ASSUMEDFROMCLEAR	= 1082,
-        D3D12_MESSAGE_ID_CREATE_VIDEODECODERHEAP	= 1083,
-        D3D12_MESSAGE_ID_LIVE_VIDEODECODERHEAP	= 1084,
-        D3D12_MESSAGE_ID_DESTROY_VIDEODECODERHEAP	= 1085,
-        D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDARG_RETURN	= 1086,
-        D3D12_MESSAGE_ID_OPENEXISTINGHEAP_OUTOFMEMORY_RETURN	= 1087,
-        D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDADDRESS	= 1088,
-        D3D12_MESSAGE_ID_OPENEXISTINGHEAP_INVALIDHANDLE	= 1089,
-        D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_DEST	= 1090,
-        D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_MODE	= 1091,
-        D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_INVALID_ALIGNMENT	= 1092,
-        D3D12_MESSAGE_ID_WRITEBUFFERIMMEDIATE_NOT_SUPPORTED	= 1093,
-        D3D12_MESSAGE_ID_SETVIEWINSTANCEMASK_INVALIDARGS	= 1094,
-        D3D12_MESSAGE_ID_VIEW_INSTANCING_UNSUPPORTED	= 1095,
-        D3D12_MESSAGE_ID_VIEW_INSTANCING_INVALIDARGS	= 1096,
-        D3D12_MESSAGE_ID_COPYTEXTUREREGION_MISMATCH_DECODE_REFERENCE_ONLY_FLAG	= 1097,
-        D3D12_MESSAGE_ID_COPYRESOURCE_MISMATCH_DECODE_REFERENCE_ONLY_FLAG	= 1098,
-        D3D12_MESSAGE_ID_CREATE_VIDEO_DECODE_HEAP_CAPS_FAILURE	= 1099,
-        D3D12_MESSAGE_ID_CREATE_VIDEO_DECODE_HEAP_CAPS_UNSUPPORTED	= 1100,
-        D3D12_MESSAGE_ID_VIDEO_DECODE_SUPPORT_INVALID_INPUT	= 1101,
-        D3D12_MESSAGE_ID_CREATE_VIDEO_DECODER_UNSUPPORTED	= 1102,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_METADATA_ERROR	= 1103,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_VIEW_INSTANCING_VERTEX_SIZE_EXCEEDED	= 1104,
-        D3D12_MESSAGE_ID_CREATEGRAPHICSPIPELINESTATE_RUNTIME_INTERNAL_ERROR	= 1105,
-        D3D12_MESSAGE_ID_NO_VIDEO_API_SUPPORT	= 1106,
-        D3D12_MESSAGE_ID_VIDEO_PROCESS_SUPPORT_INVALID_INPUT	= 1107,
-        D3D12_MESSAGE_ID_CREATE_VIDEO_PROCESSOR_CAPS_FAILURE	= 1108,
-        D3D12_MESSAGE_ID_VIDEO_PROCESS_SUPPORT_UNSUPPORTED_FORMAT	= 1109,
-        D3D12_MESSAGE_ID_VIDEO_DECODE_FRAME_INVALID_ARGUMENT	= 1110,
-        D3D12_MESSAGE_ID_ENQUEUE_MAKE_RESIDENT_INVALID_FLAGS	= 1111,
-        D3D12_MESSAGE_ID_OPENEXISTINGHEAP_UNSUPPORTED	= 1112,
-        D3D12_MESSAGE_ID_VIDEO_PROCESS_FRAMES_INVALID_ARGUMENT	= 1113,
-        D3D12_MESSAGE_ID_VIDEO_DECODE_SUPPORT_UNSUPPORTED	= 1114,
-        D3D12_MESSAGE_ID_CREATE_COMMANDRECORDER	= 1115,
-        D3D12_MESSAGE_ID_LIVE_COMMANDRECORDER	= 1116,
-        D3D12_MESSAGE_ID_DESTROY_COMMANDRECORDER	= 1117,
-        D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_VIDEO_NOT_SUPPORTED	= 1118,
-        D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_INVALID_SUPPORT_FLAGS	= 1119,
-        D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_INVALID_FLAGS	= 1120,
-        D3D12_MESSAGE_ID_CREATE_COMMAND_RECORDER_MORE_RECORDERS_THAN_LOGICAL_PROCESSORS	= 1121,
-        D3D12_MESSAGE_ID_CREATE_COMMANDPOOL	= 1122,
-        D3D12_MESSAGE_ID_LIVE_COMMANDPOOL	= 1123,
-        D3D12_MESSAGE_ID_DESTROY_COMMANDPOOL	= 1124,
-        D3D12_MESSAGE_ID_CREATE_COMMAND_POOL_INVALID_FLAGS	= 1125,
-        D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_VIDEO_NOT_SUPPORTED	= 1126,
-        D3D12_MESSAGE_ID_COMMAND_RECORDER_SUPPORT_FLAGS_MISMATCH	= 1127,
-        D3D12_MESSAGE_ID_COMMAND_RECORDER_CONTENTION	= 1128,
-        D3D12_MESSAGE_ID_COMMAND_RECORDER_USAGE_WITH_CREATECOMMANDLIST_COMMAND_LIST	= 1129,
-        D3D12_MESSAGE_ID_COMMAND_ALLOCATOR_USAGE_WITH_CREATECOMMANDLIST1_COMMAND_LIST	= 1130,
-        D3D12_MESSAGE_ID_CANNOT_EXECUTE_EMPTY_COMMAND_LIST	= 1131,
-        D3D12_MESSAGE_ID_CANNOT_RESET_COMMAND_POOL_WITH_OPEN_COMMAND_LISTS	= 1132,
-        D3D12_MESSAGE_ID_CANNOT_USE_COMMAND_RECORDER_WITHOUT_CURRENT_TARGET	= 1133,
-        D3D12_MESSAGE_ID_CANNOT_CHANGE_COMMAND_RECORDER_TARGET_WHILE_RECORDING	= 1134,
-        D3D12_MESSAGE_ID_COMMAND_POOL_SYNC	= 1135,
-        D3D12_MESSAGE_ID_EVICT_UNDERFLOW	= 1136,
-        D3D12_MESSAGE_ID_CREATE_META_COMMAND	= 1137,
-        D3D12_MESSAGE_ID_LIVE_META_COMMAND	= 1138,
-        D3D12_MESSAGE_ID_DESTROY_META_COMMAND	= 1139,
-        D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALID_DST_RESOURCE	= 1140,
-        D3D12_MESSAGE_ID_COPYBUFFERREGION_INVALID_SRC_RESOURCE	= 1141,
-        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_DST_RESOURCE	= 1142,
-        D3D12_MESSAGE_ID_ATOMICCOPYBUFFER_INVALID_SRC_RESOURCE	= 1143,
-        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_NULL_BUFFER	= 1144,
-        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_NULL_RESOURCE_DESC	= 1145,
-        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_UNSUPPORTED	= 1146,
-        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_DIMENSION	= 1147,
-        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_FLAGS	= 1148,
-        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_BUFFER_OFFSET	= 1149,
-        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_DIMENSION	= 1150,
-        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_INVALID_RESOURCE_FLAGS	= 1151,
-        D3D12_MESSAGE_ID_CREATEPLACEDRESOURCEONBUFFER_OUTOFMEMORY_RETURN	= 1152,
-        D3D12_MESSAGE_ID_CANNOT_CREATE_GRAPHICS_AND_VIDEO_COMMAND_RECORDER	= 1153,
-        D3D12_MESSAGE_ID_UPDATETILEMAPPINGS_POSSIBLY_MISMATCHING_PROPERTIES	= 1154,
-        D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE	= 1155,
-        D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_INCOMPATIBLE_WITH_STRUCTURED_BUFFERS	= 1156,
-        D3D12_MESSAGE_ID_COMPUTE_ONLY_DEVICE_OPERATION_UNSUPPORTED	= 1157,
-        D3D12_MESSAGE_ID_BUILD_RAYTRACING_ACCELERATION_STRUCTURE_INVALID	= 1158,
-        D3D12_MESSAGE_ID_EMIT_RAYTRACING_ACCELERATION_STRUCTURE_POSTBUILD_INFO_INVALID	= 1159,
-        D3D12_MESSAGE_ID_COPY_RAYTRACING_ACCELERATION_STRUCTURE_INVALID	= 1160,
-        D3D12_MESSAGE_ID_DISPATCH_RAYS_INVALID	= 1161,
-        D3D12_MESSAGE_ID_GET_RAYTRACING_ACCELERATION_STRUCTURE_PREBUILD_INFO_INVALID	= 1162,
-        D3D12_MESSAGE_ID_CREATE_LIFETIMETRACKER	= 1163,
-        D3D12_MESSAGE_ID_LIVE_LIFETIMETRACKER	= 1164,
-        D3D12_MESSAGE_ID_DESTROY_LIFETIMETRACKER	= 1165,
-        D3D12_MESSAGE_ID_DESTROYOWNEDOBJECT_OBJECTNOTOWNED	= 1166,
-        D3D12_MESSAGE_ID_CREATE_TRACKEDWORKLOAD	= 1167,
-        D3D12_MESSAGE_ID_LIVE_TRACKEDWORKLOAD	= 1168,
-        D3D12_MESSAGE_ID_DESTROY_TRACKEDWORKLOAD	= 1169,
-        D3D12_MESSAGE_ID_RENDER_PASS_ERROR	= 1170,
-        D3D12_MESSAGE_ID_META_COMMAND_ID_INVALID	= 1171,
-        D3D12_MESSAGE_ID_META_COMMAND_UNSUPPORTED_PARAMS	= 1172,
-        D3D12_MESSAGE_ID_META_COMMAND_FAILED_ENUMERATION	= 1173,
-        D3D12_MESSAGE_ID_META_COMMAND_PARAMETER_SIZE_MISMATCH	= 1174,
-        D3D12_MESSAGE_ID_UNINITIALIZED_META_COMMAND	= 1175,
-        D3D12_MESSAGE_ID_META_COMMAND_INVALID_GPU_VIRTUAL_ADDRESS	= 1176,
-        D3D12_MESSAGE_ID_CREATE_VIDEOENCODECOMMANDLIST	= 1177,
-        D3D12_MESSAGE_ID_LIVE_VIDEOENCODECOMMANDLIST	= 1178,
-        D3D12_MESSAGE_ID_DESTROY_VIDEOENCODECOMMANDLIST	= 1179,
-        D3D12_MESSAGE_ID_CREATE_VIDEOENCODECOMMANDQUEUE	= 1180,
-        D3D12_MESSAGE_ID_LIVE_VIDEOENCODECOMMANDQUEUE	= 1181,
-        D3D12_MESSAGE_ID_DESTROY_VIDEOENCODECOMMANDQUEUE	= 1182,
-        D3D12_MESSAGE_ID_CREATE_VIDEOMOTIONESTIMATOR	= 1183,
-        D3D12_MESSAGE_ID_LIVE_VIDEOMOTIONESTIMATOR	= 1184,
-        D3D12_MESSAGE_ID_DESTROY_VIDEOMOTIONESTIMATOR	= 1185,
-        D3D12_MESSAGE_ID_CREATE_VIDEOMOTIONVECTORHEAP	= 1186,
-        D3D12_MESSAGE_ID_LIVE_VIDEOMOTIONVECTORHEAP	= 1187,
-        D3D12_MESSAGE_ID_DESTROY_VIDEOMOTIONVECTORHEAP	= 1188,
-        D3D12_MESSAGE_ID_MULTIPLE_TRACKED_WORKLOADS	= 1189,
-        D3D12_MESSAGE_ID_MULTIPLE_TRACKED_WORKLOAD_PAIRS	= 1190,
-        D3D12_MESSAGE_ID_OUT_OF_ORDER_TRACKED_WORKLOAD_PAIR	= 1191,
-        D3D12_MESSAGE_ID_CANNOT_ADD_TRACKED_WORKLOAD	= 1192,
-        D3D12_MESSAGE_ID_INCOMPLETE_TRACKED_WORKLOAD_PAIR	= 1193,
-        D3D12_MESSAGE_ID_CREATE_STATE_OBJECT_ERROR	= 1194,
-        D3D12_MESSAGE_ID_GET_SHADER_IDENTIFIER_ERROR	= 1195,
-        D3D12_MESSAGE_ID_GET_SHADER_STACK_SIZE_ERROR	= 1196,
-        D3D12_MESSAGE_ID_GET_PIPELINE_STACK_SIZE_ERROR	= 1197,
-        D3D12_MESSAGE_ID_SET_PIPELINE_STACK_SIZE_ERROR	= 1198,
-        D3D12_MESSAGE_ID_GET_SHADER_IDENTIFIER_SIZE_INVALID	= 1199,
-        D3D12_MESSAGE_ID_CHECK_DRIVER_MATCHING_IDENTIFIER_INVALID	= 1200,
-        D3D12_MESSAGE_ID_CHECK_DRIVER_MATCHING_IDENTIFIER_DRIVER_REPORTED_ISSUE	= 1201,
-        D3D12_MESSAGE_ID_RENDER_PASS_INVALID_RESOURCE_BARRIER	= 1202,
-        D3D12_MESSAGE_ID_RENDER_PASS_DISALLOWED_API_CALLED	= 1203,
-        D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_NEST_RENDER_PASSES	= 1204,
-        D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_END_WITHOUT_BEGIN	= 1205,
-        D3D12_MESSAGE_ID_RENDER_PASS_CANNOT_CLOSE_COMMAND_LIST	= 1206,
-        D3D12_MESSAGE_ID_RENDER_PASS_GPU_WORK_WHILE_SUSPENDED	= 1207,
-        D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_SUSPEND_RESUME	= 1208,
-        D3D12_MESSAGE_ID_RENDER_PASS_NO_PRIOR_SUSPEND_WITHIN_EXECUTECOMMANDLISTS	= 1209,
-        D3D12_MESSAGE_ID_RENDER_PASS_NO_SUBSEQUENT_RESUME_WITHIN_EXECUTECOMMANDLISTS	= 1210,
-        D3D12_MESSAGE_ID_TRACKED_WORKLOAD_COMMAND_QUEUE_MISMATCH	= 1211,
-        D3D12_MESSAGE_ID_TRACKED_WORKLOAD_NOT_SUPPORTED	= 1212,
-        D3D12_MESSAGE_ID_RENDER_PASS_MISMATCHING_NO_ACCESS	= 1213,
-        D3D12_MESSAGE_ID_RENDER_PASS_UNSUPPORTED_RESOLVE	= 1214,
-        D3D12_MESSAGE_ID_CLEARUNORDEREDACCESSVIEW_INVALID_RESOURCE_PTR	= 1215,
-        D3D12_MESSAGE_ID_WINDOWS7_FENCE_OUTOFORDER_SIGNAL	= 1216,
-        D3D12_MESSAGE_ID_WINDOWS7_FENCE_OUTOFORDER_WAIT	= 1217,
-        D3D12_MESSAGE_ID_VIDEO_CREATE_MOTION_ESTIMATOR_INVALID_ARGUMENT	= 1218,
-        D3D12_MESSAGE_ID_VIDEO_CREATE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT	= 1219,
-        D3D12_MESSAGE_ID_ESTIMATE_MOTION_INVALID_ARGUMENT	= 1220,
-        D3D12_MESSAGE_ID_RESOLVE_MOTION_VECTOR_HEAP_INVALID_ARGUMENT	= 1221,
-        D3D12_MESSAGE_ID_GETGPUVIRTUALADDRESS_INVALID_HEAP_TYPE	= 1222,
-        D3D12_MESSAGE_ID_SET_BACKGROUND_PROCESSING_MODE_INVALID_ARGUMENT	= 1223,
-        D3D12_MESSAGE_ID_CREATE_COMMAND_LIST_INVALID_COMMAND_LIST_TYPE_FOR_FEATURE_LEVEL	= 1224,
-        D3D12_MESSAGE_ID_CREATE_VIDEOEXTENSIONCOMMAND	= 1225,
-        D3D12_MESSAGE_ID_LIVE_VIDEOEXTENSIONCOMMAND	= 1226,
-        D3D12_MESSAGE_ID_DESTROY_VIDEOEXTENSIONCOMMAND	= 1227,
-        D3D12_MESSAGE_ID_INVALID_VIDEO_EXTENSION_COMMAND_ID	= 1228,
-        D3D12_MESSAGE_ID_VIDEO_EXTENSION_COMMAND_INVALID_ARGUMENT	= 1229,
-        D3D12_MESSAGE_ID_CREATE_ROOT_SIGNATURE_NOT_UNIQUE_IN_DXIL_LIBRARY	= 1230,
-        D3D12_MESSAGE_ID_VARIABLE_SHADING_RATE_NOT_ALLOWED_WITH_TIR	= 1231,
-        D3D12_MESSAGE_ID_GEOMETRY_SHADER_OUTPUTTING_BOTH_VIEWPORT_ARRAY_INDEX_AND_SHADING_RATE_NOT_SUPPORTED_ON_DEVICE	= 1232,
-        D3D12_MESSAGE_ID_RSSETSHADING_RATE_INVALID_SHADING_RATE	= 1233,
-        D3D12_MESSAGE_ID_RSSETSHADING_RATE_SHADING_RATE_NOT_PERMITTED_BY_CAP	= 1234,
-        D3D12_MESSAGE_ID_RSSETSHADING_RATE_INVALID_COMBINER	= 1235,
-        D3D12_MESSAGE_ID_RSSETSHADINGRATEIMAGE_REQUIRES_TIER_2	= 1236,
-        D3D12_MESSAGE_ID_RSSETSHADINGRATE_REQUIRES_TIER_1	= 1237,
-        D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_FORMAT	= 1238,
-        D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_ARRAY_SIZE	= 1239,
-        D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_MIP_LEVEL	= 1240,
-        D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_SAMPLE_COUNT	= 1241,
-        D3D12_MESSAGE_ID_SHADING_RATE_IMAGE_INCORRECT_SAMPLE_QUALITY	= 1242,
-        D3D12_MESSAGE_ID_NON_RETAIL_SHADER_MODEL_WONT_VALIDATE	= 1243,
-        D3D12_MESSAGE_ID_D3D12_MESSAGES_END	= ( D3D12_MESSAGE_ID_NON_RETAIL_SHADER_MODEL_WONT_VALIDATE + 1 ) 
-    } 	D3D12_MESSAGE_ID;
-
-static_assert(D3D12_MESSAGE_ID_GPU_BASED_VALIDATION_UNSUPPORTED == 1000, "Publicly released SDK D3D12_MESSAGE_ID enum values must not be changed. New enum values must be added to the end of the list.");
-static_assert(D3D12_MESSAGE_ID_COPY_INVALIDLAYOUT == 1067, "Publicly released SDK D3D12_MESSAGE_ID enum values must not be changed. New enum values must be added to the end of the list.");
-typedef struct D3D12_MESSAGE
-    {
-    D3D12_MESSAGE_CATEGORY Category;
-    D3D12_MESSAGE_SEVERITY Severity;
-    D3D12_MESSAGE_ID ID;
-    _Field_size_(DescriptionByteLength)  const char *pDescription;
-    SIZE_T DescriptionByteLength;
-    } 	D3D12_MESSAGE;
-
-typedef struct D3D12_INFO_QUEUE_FILTER_DESC
-    {
-    UINT NumCategories;
-    _Field_size_(NumCategories)  D3D12_MESSAGE_CATEGORY *pCategoryList;
-    UINT NumSeverities;
-    _Field_size_(NumSeverities)  D3D12_MESSAGE_SEVERITY *pSeverityList;
-    UINT NumIDs;
-    _Field_size_(NumIDs)  D3D12_MESSAGE_ID *pIDList;
-    } 	D3D12_INFO_QUEUE_FILTER_DESC;
-
-typedef struct D3D12_INFO_QUEUE_FILTER
-    {
-    D3D12_INFO_QUEUE_FILTER_DESC AllowList;
-    D3D12_INFO_QUEUE_FILTER_DESC DenyList;
-    } 	D3D12_INFO_QUEUE_FILTER;
-
-#define D3D12_INFO_QUEUE_DEFAULT_MESSAGE_COUNT_LIMIT 1024
-
-
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0012_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0012_v0_0_s_ifspec;
-
-#ifndef __ID3D12InfoQueue_INTERFACE_DEFINED__
-#define __ID3D12InfoQueue_INTERFACE_DEFINED__
-
-/* interface ID3D12InfoQueue */
-/* [unique][local][object][uuid] */ 
-
-
-EXTERN_C const IID IID_ID3D12InfoQueue;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("0742a90b-c387-483f-b946-30a7e4e61458")
-    ID3D12InfoQueue : public IUnknown
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE SetMessageCountLimit( 
-            _In_  UINT64 MessageCountLimit) = 0;
-        
-        virtual void STDMETHODCALLTYPE ClearStoredMessages( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetMessage( 
-            _In_  UINT64 MessageIndex,
-            _Out_writes_bytes_opt_(*pMessageByteLength)  D3D12_MESSAGE *pMessage,
-            _Inout_  SIZE_T *pMessageByteLength) = 0;
-        
-        virtual UINT64 STDMETHODCALLTYPE GetNumMessagesAllowedByStorageFilter( void) = 0;
-        
-        virtual UINT64 STDMETHODCALLTYPE GetNumMessagesDeniedByStorageFilter( void) = 0;
-        
-        virtual UINT64 STDMETHODCALLTYPE GetNumStoredMessages( void) = 0;
-        
-        virtual UINT64 STDMETHODCALLTYPE GetNumStoredMessagesAllowedByRetrievalFilter( void) = 0;
-        
-        virtual UINT64 STDMETHODCALLTYPE GetNumMessagesDiscardedByMessageCountLimit( void) = 0;
-        
-        virtual UINT64 STDMETHODCALLTYPE GetMessageCountLimit( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE AddStorageFilterEntries( 
-            _In_  D3D12_INFO_QUEUE_FILTER *pFilter) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetStorageFilter( 
-            _Out_writes_bytes_opt_(*pFilterByteLength)  D3D12_INFO_QUEUE_FILTER *pFilter,
-            _Inout_  SIZE_T *pFilterByteLength) = 0;
-        
-        virtual void STDMETHODCALLTYPE ClearStorageFilter( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE PushEmptyStorageFilter( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE PushCopyOfStorageFilter( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE PushStorageFilter( 
-            _In_  D3D12_INFO_QUEUE_FILTER *pFilter) = 0;
-        
-        virtual void STDMETHODCALLTYPE PopStorageFilter( void) = 0;
-        
-        virtual UINT STDMETHODCALLTYPE GetStorageFilterStackSize( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE AddRetrievalFilterEntries( 
-            _In_  D3D12_INFO_QUEUE_FILTER *pFilter) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetRetrievalFilter( 
-            _Out_writes_bytes_opt_(*pFilterByteLength)  D3D12_INFO_QUEUE_FILTER *pFilter,
-            _Inout_  SIZE_T *pFilterByteLength) = 0;
-        
-        virtual void STDMETHODCALLTYPE ClearRetrievalFilter( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE PushEmptyRetrievalFilter( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE PushCopyOfRetrievalFilter( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE PushRetrievalFilter( 
-            _In_  D3D12_INFO_QUEUE_FILTER *pFilter) = 0;
-        
-        virtual void STDMETHODCALLTYPE PopRetrievalFilter( void) = 0;
-        
-        virtual UINT STDMETHODCALLTYPE GetRetrievalFilterStackSize( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE AddMessage( 
-            _In_  D3D12_MESSAGE_CATEGORY Category,
-            _In_  D3D12_MESSAGE_SEVERITY Severity,
-            _In_  D3D12_MESSAGE_ID ID,
-            _In_  LPCSTR pDescription) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE AddApplicationMessage( 
-            _In_  D3D12_MESSAGE_SEVERITY Severity,
-            _In_  LPCSTR pDescription) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE SetBreakOnCategory( 
-            _In_  D3D12_MESSAGE_CATEGORY Category,
-            _In_  BOOL bEnable) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE SetBreakOnSeverity( 
-            _In_  D3D12_MESSAGE_SEVERITY Severity,
-            _In_  BOOL bEnable) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE SetBreakOnID( 
-            _In_  D3D12_MESSAGE_ID ID,
-            _In_  BOOL bEnable) = 0;
-        
-        virtual BOOL STDMETHODCALLTYPE GetBreakOnCategory( 
-            _In_  D3D12_MESSAGE_CATEGORY Category) = 0;
-        
-        virtual BOOL STDMETHODCALLTYPE GetBreakOnSeverity( 
-            _In_  D3D12_MESSAGE_SEVERITY Severity) = 0;
-        
-        virtual BOOL STDMETHODCALLTYPE GetBreakOnID( 
-            _In_  D3D12_MESSAGE_ID ID) = 0;
-        
-        virtual void STDMETHODCALLTYPE SetMuteDebugOutput( 
-            _In_  BOOL bMute) = 0;
-        
-        virtual BOOL STDMETHODCALLTYPE GetMuteDebugOutput( void) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct ID3D12InfoQueueVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            ID3D12InfoQueue * This,
-            REFIID riid,
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            ID3D12InfoQueue * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            ID3D12InfoQueue * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetMessageCountLimit )( 
-            ID3D12InfoQueue * This,
-            _In_  UINT64 MessageCountLimit);
-        
-        void ( STDMETHODCALLTYPE *ClearStoredMessages )( 
-            ID3D12InfoQueue * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetMessage )( 
-            ID3D12InfoQueue * This,
-            _In_  UINT64 MessageIndex,
-            _Out_writes_bytes_opt_(*pMessageByteLength)  D3D12_MESSAGE *pMessage,
-            _Inout_  SIZE_T *pMessageByteLength);
-        
-        UINT64 ( STDMETHODCALLTYPE *GetNumMessagesAllowedByStorageFilter )( 
-            ID3D12InfoQueue * This);
-        
-        UINT64 ( STDMETHODCALLTYPE *GetNumMessagesDeniedByStorageFilter )( 
-            ID3D12InfoQueue * This);
-        
-        UINT64 ( STDMETHODCALLTYPE *GetNumStoredMessages )( 
-            ID3D12InfoQueue * This);
-        
-        UINT64 ( STDMETHODCALLTYPE *GetNumStoredMessagesAllowedByRetrievalFilter )( 
-            ID3D12InfoQueue * This);
-        
-        UINT64 ( STDMETHODCALLTYPE *GetNumMessagesDiscardedByMessageCountLimit )( 
-            ID3D12InfoQueue * This);
-        
-        UINT64 ( STDMETHODCALLTYPE *GetMessageCountLimit )( 
-            ID3D12InfoQueue * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *AddStorageFilterEntries )( 
-            ID3D12InfoQueue * This,
-            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetStorageFilter )( 
-            ID3D12InfoQueue * This,
-            _Out_writes_bytes_opt_(*pFilterByteLength)  D3D12_INFO_QUEUE_FILTER *pFilter,
-            _Inout_  SIZE_T *pFilterByteLength);
-        
-        void ( STDMETHODCALLTYPE *ClearStorageFilter )( 
-            ID3D12InfoQueue * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *PushEmptyStorageFilter )( 
-            ID3D12InfoQueue * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *PushCopyOfStorageFilter )( 
-            ID3D12InfoQueue * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *PushStorageFilter )( 
-            ID3D12InfoQueue * This,
-            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
-        
-        void ( STDMETHODCALLTYPE *PopStorageFilter )( 
-            ID3D12InfoQueue * This);
-        
-        UINT ( STDMETHODCALLTYPE *GetStorageFilterStackSize )( 
-            ID3D12InfoQueue * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *AddRetrievalFilterEntries )( 
-            ID3D12InfoQueue * This,
-            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetRetrievalFilter )( 
-            ID3D12InfoQueue * This,
-            _Out_writes_bytes_opt_(*pFilterByteLength)  D3D12_INFO_QUEUE_FILTER *pFilter,
-            _Inout_  SIZE_T *pFilterByteLength);
-        
-        void ( STDMETHODCALLTYPE *ClearRetrievalFilter )( 
-            ID3D12InfoQueue * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *PushEmptyRetrievalFilter )( 
-            ID3D12InfoQueue * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *PushCopyOfRetrievalFilter )( 
-            ID3D12InfoQueue * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *PushRetrievalFilter )( 
-            ID3D12InfoQueue * This,
-            _In_  D3D12_INFO_QUEUE_FILTER *pFilter);
-        
-        void ( STDMETHODCALLTYPE *PopRetrievalFilter )( 
-            ID3D12InfoQueue * This);
-        
-        UINT ( STDMETHODCALLTYPE *GetRetrievalFilterStackSize )( 
-            ID3D12InfoQueue * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *AddMessage )( 
-            ID3D12InfoQueue * This,
-            _In_  D3D12_MESSAGE_CATEGORY Category,
-            _In_  D3D12_MESSAGE_SEVERITY Severity,
-            _In_  D3D12_MESSAGE_ID ID,
-            _In_  LPCSTR pDescription);
-        
-        HRESULT ( STDMETHODCALLTYPE *AddApplicationMessage )( 
-            ID3D12InfoQueue * This,
-            _In_  D3D12_MESSAGE_SEVERITY Severity,
-            _In_  LPCSTR pDescription);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetBreakOnCategory )( 
-            ID3D12InfoQueue * This,
-            _In_  D3D12_MESSAGE_CATEGORY Category,
-            _In_  BOOL bEnable);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetBreakOnSeverity )( 
-            ID3D12InfoQueue * This,
-            _In_  D3D12_MESSAGE_SEVERITY Severity,
-            _In_  BOOL bEnable);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetBreakOnID )( 
-            ID3D12InfoQueue * This,
-            _In_  D3D12_MESSAGE_ID ID,
-            _In_  BOOL bEnable);
-        
-        BOOL ( STDMETHODCALLTYPE *GetBreakOnCategory )( 
-            ID3D12InfoQueue * This,
-            _In_  D3D12_MESSAGE_CATEGORY Category);
-        
-        BOOL ( STDMETHODCALLTYPE *GetBreakOnSeverity )( 
-            ID3D12InfoQueue * This,
-            _In_  D3D12_MESSAGE_SEVERITY Severity);
-        
-        BOOL ( STDMETHODCALLTYPE *GetBreakOnID )( 
-            ID3D12InfoQueue * This,
-            _In_  D3D12_MESSAGE_ID ID);
-        
-        void ( STDMETHODCALLTYPE *SetMuteDebugOutput )( 
-            ID3D12InfoQueue * This,
-            _In_  BOOL bMute);
-        
-        BOOL ( STDMETHODCALLTYPE *GetMuteDebugOutput )( 
-            ID3D12InfoQueue * This);
-        
-        END_INTERFACE
-    } ID3D12InfoQueueVtbl;
-
-    interface ID3D12InfoQueue
-    {
-        CONST_VTBL struct ID3D12InfoQueueVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define ID3D12InfoQueue_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define ID3D12InfoQueue_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define ID3D12InfoQueue_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define ID3D12InfoQueue_SetMessageCountLimit(This,MessageCountLimit)	\
-    ( (This)->lpVtbl -> SetMessageCountLimit(This,MessageCountLimit) ) 
-
-#define ID3D12InfoQueue_ClearStoredMessages(This)	\
-    ( (This)->lpVtbl -> ClearStoredMessages(This) ) 
-
-#define ID3D12InfoQueue_GetMessage(This,MessageIndex,pMessage,pMessageByteLength)	\
-    ( (This)->lpVtbl -> GetMessage(This,MessageIndex,pMessage,pMessageByteLength) ) 
-
-#define ID3D12InfoQueue_GetNumMessagesAllowedByStorageFilter(This)	\
-    ( (This)->lpVtbl -> GetNumMessagesAllowedByStorageFilter(This) ) 
-
-#define ID3D12InfoQueue_GetNumMessagesDeniedByStorageFilter(This)	\
-    ( (This)->lpVtbl -> GetNumMessagesDeniedByStorageFilter(This) ) 
-
-#define ID3D12InfoQueue_GetNumStoredMessages(This)	\
-    ( (This)->lpVtbl -> GetNumStoredMessages(This) ) 
-
-#define ID3D12InfoQueue_GetNumStoredMessagesAllowedByRetrievalFilter(This)	\
-    ( (This)->lpVtbl -> GetNumStoredMessagesAllowedByRetrievalFilter(This) ) 
-
-#define ID3D12InfoQueue_GetNumMessagesDiscardedByMessageCountLimit(This)	\
-    ( (This)->lpVtbl -> GetNumMessagesDiscardedByMessageCountLimit(This) ) 
-
-#define ID3D12InfoQueue_GetMessageCountLimit(This)	\
-    ( (This)->lpVtbl -> GetMessageCountLimit(This) ) 
-
-#define ID3D12InfoQueue_AddStorageFilterEntries(This,pFilter)	\
-    ( (This)->lpVtbl -> AddStorageFilterEntries(This,pFilter) ) 
-
-#define ID3D12InfoQueue_GetStorageFilter(This,pFilter,pFilterByteLength)	\
-    ( (This)->lpVtbl -> GetStorageFilter(This,pFilter,pFilterByteLength) ) 
-
-#define ID3D12InfoQueue_ClearStorageFilter(This)	\
-    ( (This)->lpVtbl -> ClearStorageFilter(This) ) 
-
-#define ID3D12InfoQueue_PushEmptyStorageFilter(This)	\
-    ( (This)->lpVtbl -> PushEmptyStorageFilter(This) ) 
-
-#define ID3D12InfoQueue_PushCopyOfStorageFilter(This)	\
-    ( (This)->lpVtbl -> PushCopyOfStorageFilter(This) ) 
-
-#define ID3D12InfoQueue_PushStorageFilter(This,pFilter)	\
-    ( (This)->lpVtbl -> PushStorageFilter(This,pFilter) ) 
-
-#define ID3D12InfoQueue_PopStorageFilter(This)	\
-    ( (This)->lpVtbl -> PopStorageFilter(This) ) 
-
-#define ID3D12InfoQueue_GetStorageFilterStackSize(This)	\
-    ( (This)->lpVtbl -> GetStorageFilterStackSize(This) ) 
-
-#define ID3D12InfoQueue_AddRetrievalFilterEntries(This,pFilter)	\
-    ( (This)->lpVtbl -> AddRetrievalFilterEntries(This,pFilter) ) 
-
-#define ID3D12InfoQueue_GetRetrievalFilter(This,pFilter,pFilterByteLength)	\
-    ( (This)->lpVtbl -> GetRetrievalFilter(This,pFilter,pFilterByteLength) ) 
-
-#define ID3D12InfoQueue_ClearRetrievalFilter(This)	\
-    ( (This)->lpVtbl -> ClearRetrievalFilter(This) ) 
-
-#define ID3D12InfoQueue_PushEmptyRetrievalFilter(This)	\
-    ( (This)->lpVtbl -> PushEmptyRetrievalFilter(This) ) 
-
-#define ID3D12InfoQueue_PushCopyOfRetrievalFilter(This)	\
-    ( (This)->lpVtbl -> PushCopyOfRetrievalFilter(This) ) 
-
-#define ID3D12InfoQueue_PushRetrievalFilter(This,pFilter)	\
-    ( (This)->lpVtbl -> PushRetrievalFilter(This,pFilter) ) 
-
-#define ID3D12InfoQueue_PopRetrievalFilter(This)	\
-    ( (This)->lpVtbl -> PopRetrievalFilter(This) ) 
-
-#define ID3D12InfoQueue_GetRetrievalFilterStackSize(This)	\
-    ( (This)->lpVtbl -> GetRetrievalFilterStackSize(This) ) 
-
-#define ID3D12InfoQueue_AddMessage(This,Category,Severity,ID,pDescription)	\
-    ( (This)->lpVtbl -> AddMessage(This,Category,Severity,ID,pDescription) ) 
-
-#define ID3D12InfoQueue_AddApplicationMessage(This,Severity,pDescription)	\
-    ( (This)->lpVtbl -> AddApplicationMessage(This,Severity,pDescription) ) 
-
-#define ID3D12InfoQueue_SetBreakOnCategory(This,Category,bEnable)	\
-    ( (This)->lpVtbl -> SetBreakOnCategory(This,Category,bEnable) ) 
-
-#define ID3D12InfoQueue_SetBreakOnSeverity(This,Severity,bEnable)	\
-    ( (This)->lpVtbl -> SetBreakOnSeverity(This,Severity,bEnable) ) 
-
-#define ID3D12InfoQueue_SetBreakOnID(This,ID,bEnable)	\
-    ( (This)->lpVtbl -> SetBreakOnID(This,ID,bEnable) ) 
-
-#define ID3D12InfoQueue_GetBreakOnCategory(This,Category)	\
-    ( (This)->lpVtbl -> GetBreakOnCategory(This,Category) ) 
-
-#define ID3D12InfoQueue_GetBreakOnSeverity(This,Severity)	\
-    ( (This)->lpVtbl -> GetBreakOnSeverity(This,Severity) ) 
-
-#define ID3D12InfoQueue_GetBreakOnID(This,ID)	\
-    ( (This)->lpVtbl -> GetBreakOnID(This,ID) ) 
-
-#define ID3D12InfoQueue_SetMuteDebugOutput(This,bMute)	\
-    ( (This)->lpVtbl -> SetMuteDebugOutput(This,bMute) ) 
-
-#define ID3D12InfoQueue_GetMuteDebugOutput(This)	\
-    ( (This)->lpVtbl -> GetMuteDebugOutput(This) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __ID3D12InfoQueue_INTERFACE_DEFINED__ */
-
-
-/* interface __MIDL_itf_d3d12sdklayers_0000_0013 */
-/* [local] */ 
-
-DEFINE_GUID(IID_ID3D12Debug,0x344488b7,0x6846,0x474b,0xb9,0x89,0xf0,0x27,0x44,0x82,0x45,0xe0);
-DEFINE_GUID(IID_ID3D12Debug1,0xaffaa4ca,0x63fe,0x4d8e,0xb8,0xad,0x15,0x90,0x00,0xaf,0x43,0x04);
-DEFINE_GUID(IID_ID3D12Debug2,0x93a665c4,0xa3b2,0x4e5d,0xb6,0x92,0xa2,0x6a,0xe1,0x4e,0x33,0x74);
-DEFINE_GUID(IID_ID3D12Debug3,0x5cf4e58f,0xf671,0x4ff1,0xa5,0x42,0x36,0x86,0xe3,0xd1,0x53,0xd1);
-DEFINE_GUID(IID_ID3D12DebugDevice1,0xa9b71770,0xd099,0x4a65,0xa6,0x98,0x3d,0xee,0x10,0x02,0x0f,0x88);
-DEFINE_GUID(IID_ID3D12DebugDevice,0x3febd6dd,0x4973,0x4787,0x81,0x94,0xe4,0x5f,0x9e,0x28,0x92,0x3e);
-DEFINE_GUID(IID_ID3D12DebugDevice2,0x60eccbc1,0x378d,0x4df1,0x89,0x4c,0xf8,0xac,0x5c,0xe4,0xd7,0xdd);
-DEFINE_GUID(IID_ID3D12DebugCommandQueue,0x09e0bf36,0x54ac,0x484f,0x88,0x47,0x4b,0xae,0xea,0xb6,0x05,0x3a);
-DEFINE_GUID(IID_ID3D12DebugCommandList1,0x102ca951,0x311b,0x4b01,0xb1,0x1f,0xec,0xb8,0x3e,0x06,0x1b,0x37);
-DEFINE_GUID(IID_ID3D12DebugCommandList,0x09e0bf36,0x54ac,0x484f,0x88,0x47,0x4b,0xae,0xea,0xb6,0x05,0x3f);
-DEFINE_GUID(IID_ID3D12DebugCommandList2,0xaeb575cf,0x4e06,0x48be,0xba,0x3b,0xc4,0x50,0xfc,0x96,0x65,0x2e);
-DEFINE_GUID(IID_ID3D12SharingContract,0x0adf7d52,0x929c,0x4e61,0xad,0xdb,0xff,0xed,0x30,0xde,0x66,0xef);
-DEFINE_GUID(IID_ID3D12InfoQueue,0x0742a90b,0xc387,0x483f,0xb9,0x46,0x30,0xa7,0xe4,0xe6,0x14,0x58);
-
-
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0013_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_d3d12sdklayers_0000_0013_v0_0_s_ifspec;
-
-/* Additional Prototypes for ALL interfaces */
-
-/* end of Additional Prototypes */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-

3rdparty/dxsdk/include/d3d12video.h

@@ -1,3352 +0,0 @@
-/*-------------------------------------------------------------------------------------
- *
- * 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__ 475
-#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__ */
-
-
-#ifndef __ID3D12VideoMotionEstimator_FWD_DEFINED__
-#define __ID3D12VideoMotionEstimator_FWD_DEFINED__
-typedef interface ID3D12VideoMotionEstimator ID3D12VideoMotionEstimator;
-
-#endif 	/* __ID3D12VideoMotionEstimator_FWD_DEFINED__ */
-
-
-#ifndef __ID3D12VideoMotionVectorHeap_FWD_DEFINED__
-#define __ID3D12VideoMotionVectorHeap_FWD_DEFINED__
-typedef interface ID3D12VideoMotionVectorHeap ID3D12VideoMotionVectorHeap;
-
-#endif 	/* __ID3D12VideoMotionVectorHeap_FWD_DEFINED__ */
-
-
-#ifndef __ID3D12VideoDevice1_FWD_DEFINED__
-#define __ID3D12VideoDevice1_FWD_DEFINED__
-typedef interface ID3D12VideoDevice1 ID3D12VideoDevice1;
-
-#endif 	/* __ID3D12VideoDevice1_FWD_DEFINED__ */
-
-
-#ifndef __ID3D12VideoEncodeCommandList_FWD_DEFINED__
-#define __ID3D12VideoEncodeCommandList_FWD_DEFINED__
-typedef interface ID3D12VideoEncodeCommandList ID3D12VideoEncodeCommandList;
-
-#endif 	/* __ID3D12VideoEncodeCommandList_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] */ 
-
-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_FEATURE_AREA_SUPPORT	= 19,
-        D3D12_FEATURE_VIDEO_MOTION_ESTIMATOR	= 20,
-        D3D12_FEATURE_VIDEO_MOTION_ESTIMATOR_SIZE	= 21
-    } 	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] */ 
-
-typedef 
-enum D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE
-    {
-        D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_8X8	= 0,
-        D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_16X16	= 1
-    } 	D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE;
-
-typedef 
-enum D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS
-    {
-        D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAG_NONE	= 0,
-        D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAG_8X8	= ( 1 << D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_8X8 ) ,
-        D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAG_16X16	= ( 1 << D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_16X16 ) 
-    } 	D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS;
-
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS );
-typedef 
-enum D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION
-    {
-        D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_QUARTER_PEL	= 0
-    } 	D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION;
-
-typedef 
-enum D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS
-    {
-        D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAG_NONE	= 0,
-        D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAG_QUARTER_PEL	= ( 1 << D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_QUARTER_PEL ) 
-    } 	D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS;
-
-DEFINE_ENUM_FLAG_OPERATORS( D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS );
-typedef struct D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT
-    {
-    UINT NodeIndex;
-    BOOL VideoDecodeSupport;
-    BOOL VideoProcessSupport;
-    BOOL VideoEncodeSupport;
-    } 	D3D12_FEATURE_DATA_VIDEO_FEATURE_AREA_SUPPORT;
-
-typedef struct D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR
-    {
-    UINT NodeIndex;
-    DXGI_FORMAT InputFormat;
-    D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE_FLAGS BlockSizeFlags;
-    D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION_FLAGS PrecisionFlags;
-    D3D12_VIDEO_SIZE_RANGE SizeRange;
-    } 	D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR;
-
-typedef struct D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_SIZE
-    {
-    UINT NodeIndex;
-    DXGI_FORMAT InputFormat;
-    D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE BlockSize;
-    D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION Precision;
-    D3D12_VIDEO_SIZE_RANGE SizeRange;
-    BOOL Protected;
-    UINT64 MotionVectorHeapMemoryPoolL0Size;
-    UINT64 MotionVectorHeapMemoryPoolL1Size;
-    UINT64 MotionEstimatorMemoryPoolL0Size;
-    UINT64 MotionEstimatorMemoryPoolL1Size;
-    } 	D3D12_FEATURE_DATA_VIDEO_MOTION_ESTIMATOR_SIZE;
-
-typedef struct D3D12_VIDEO_MOTION_ESTIMATOR_DESC
-    {
-    UINT NodeMask;
-    DXGI_FORMAT InputFormat;
-    D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE BlockSize;
-    D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION Precision;
-    D3D12_VIDEO_SIZE_RANGE SizeRange;
-    } 	D3D12_VIDEO_MOTION_ESTIMATOR_DESC;
-
-
-
-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;
-
-#ifndef __ID3D12VideoMotionEstimator_INTERFACE_DEFINED__
-#define __ID3D12VideoMotionEstimator_INTERFACE_DEFINED__
-
-/* interface ID3D12VideoMotionEstimator */
-/* [unique][local][object][uuid] */ 
-
-
-EXTERN_C const IID IID_ID3D12VideoMotionEstimator;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("33FDAE0E-098B-428F-87BB-34B695DE08F8")
-    ID3D12VideoMotionEstimator : public ID3D12Pageable
-    {
-    public:
-        virtual D3D12_VIDEO_MOTION_ESTIMATOR_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( 
-            REFIID riid,
-            _COM_Outptr_opt_  void **ppProtectedSession) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct ID3D12VideoMotionEstimatorVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            ID3D12VideoMotionEstimator * This,
-            REFIID riid,
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            ID3D12VideoMotionEstimator * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            ID3D12VideoMotionEstimator * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
-            ID3D12VideoMotionEstimator * This,
-            _In_  REFGUID guid,
-            _Inout_  UINT *pDataSize,
-            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
-            ID3D12VideoMotionEstimator * This,
-            _In_  REFGUID guid,
-            _In_  UINT DataSize,
-            _In_reads_bytes_opt_( DataSize )  const void *pData);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
-            ID3D12VideoMotionEstimator * This,
-            _In_  REFGUID guid,
-            _In_opt_  const IUnknown *pData);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetName )( 
-            ID3D12VideoMotionEstimator * This,
-            _In_z_  LPCWSTR Name);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
-            ID3D12VideoMotionEstimator * This,
-            REFIID riid,
-            _COM_Outptr_opt_  void **ppvDevice);
-        
-        D3D12_VIDEO_MOTION_ESTIMATOR_DESC ( STDMETHODCALLTYPE *GetDesc )( 
-            ID3D12VideoMotionEstimator * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( 
-            ID3D12VideoMotionEstimator * This,
-            REFIID riid,
-            _COM_Outptr_opt_  void **ppProtectedSession);
-        
-        END_INTERFACE
-    } ID3D12VideoMotionEstimatorVtbl;
-
-    interface ID3D12VideoMotionEstimator
-    {
-        CONST_VTBL struct ID3D12VideoMotionEstimatorVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define ID3D12VideoMotionEstimator_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define ID3D12VideoMotionEstimator_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define ID3D12VideoMotionEstimator_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define ID3D12VideoMotionEstimator_GetPrivateData(This,guid,pDataSize,pData)	\
-    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
-
-#define ID3D12VideoMotionEstimator_SetPrivateData(This,guid,DataSize,pData)	\
-    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
-
-#define ID3D12VideoMotionEstimator_SetPrivateDataInterface(This,guid,pData)	\
-    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
-
-#define ID3D12VideoMotionEstimator_SetName(This,Name)	\
-    ( (This)->lpVtbl -> SetName(This,Name) ) 
-
-
-#define ID3D12VideoMotionEstimator_GetDevice(This,riid,ppvDevice)	\
-    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
-
-
-
-#define ID3D12VideoMotionEstimator_GetDesc(This)	\
-    ( (This)->lpVtbl -> GetDesc(This) ) 
-
-#define ID3D12VideoMotionEstimator_GetProtectedResourceSession(This,riid,ppProtectedSession)	\
-    ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-
-
-
-
-#endif 	/* __ID3D12VideoMotionEstimator_INTERFACE_DEFINED__ */
-
-
-/* interface __MIDL_itf_d3d12video_0000_0009 */
-/* [local] */ 
-
-typedef struct D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC
-    {
-    UINT NodeMask;
-    DXGI_FORMAT InputFormat;
-    D3D12_VIDEO_MOTION_ESTIMATOR_SEARCH_BLOCK_SIZE BlockSize;
-    D3D12_VIDEO_MOTION_ESTIMATOR_VECTOR_PRECISION Precision;
-    D3D12_VIDEO_SIZE_RANGE SizeRange;
-    } 	D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC;
-
-
-
-extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0009_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0009_v0_0_s_ifspec;
-
-#ifndef __ID3D12VideoMotionVectorHeap_INTERFACE_DEFINED__
-#define __ID3D12VideoMotionVectorHeap_INTERFACE_DEFINED__
-
-/* interface ID3D12VideoMotionVectorHeap */
-/* [unique][local][object][uuid] */ 
-
-
-EXTERN_C const IID IID_ID3D12VideoMotionVectorHeap;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("5BE17987-743A-4061-834B-23D22DAEA505")
-    ID3D12VideoMotionVectorHeap : public ID3D12Pageable
-    {
-    public:
-        virtual D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC STDMETHODCALLTYPE GetDesc( void) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE GetProtectedResourceSession( 
-            REFIID riid,
-            _COM_Outptr_opt_  void **ppProtectedSession) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct ID3D12VideoMotionVectorHeapVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            ID3D12VideoMotionVectorHeap * This,
-            REFIID riid,
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            ID3D12VideoMotionVectorHeap * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            ID3D12VideoMotionVectorHeap * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
-            ID3D12VideoMotionVectorHeap * This,
-            _In_  REFGUID guid,
-            _Inout_  UINT *pDataSize,
-            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
-            ID3D12VideoMotionVectorHeap * This,
-            _In_  REFGUID guid,
-            _In_  UINT DataSize,
-            _In_reads_bytes_opt_( DataSize )  const void *pData);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
-            ID3D12VideoMotionVectorHeap * This,
-            _In_  REFGUID guid,
-            _In_opt_  const IUnknown *pData);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetName )( 
-            ID3D12VideoMotionVectorHeap * This,
-            _In_z_  LPCWSTR Name);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
-            ID3D12VideoMotionVectorHeap * This,
-            REFIID riid,
-            _COM_Outptr_opt_  void **ppvDevice);
-        
-        D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC ( STDMETHODCALLTYPE *GetDesc )( 
-            ID3D12VideoMotionVectorHeap * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetProtectedResourceSession )( 
-            ID3D12VideoMotionVectorHeap * This,
-            REFIID riid,
-            _COM_Outptr_opt_  void **ppProtectedSession);
-        
-        END_INTERFACE
-    } ID3D12VideoMotionVectorHeapVtbl;
-
-    interface ID3D12VideoMotionVectorHeap
-    {
-        CONST_VTBL struct ID3D12VideoMotionVectorHeapVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define ID3D12VideoMotionVectorHeap_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define ID3D12VideoMotionVectorHeap_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define ID3D12VideoMotionVectorHeap_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define ID3D12VideoMotionVectorHeap_GetPrivateData(This,guid,pDataSize,pData)	\
-    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
-
-#define ID3D12VideoMotionVectorHeap_SetPrivateData(This,guid,DataSize,pData)	\
-    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
-
-#define ID3D12VideoMotionVectorHeap_SetPrivateDataInterface(This,guid,pData)	\
-    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
-
-#define ID3D12VideoMotionVectorHeap_SetName(This,Name)	\
-    ( (This)->lpVtbl -> SetName(This,Name) ) 
-
-
-#define ID3D12VideoMotionVectorHeap_GetDevice(This,riid,ppvDevice)	\
-    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
-
-
-
-#define ID3D12VideoMotionVectorHeap_GetDesc(This)	\
-    ( (This)->lpVtbl -> GetDesc(This) ) 
-
-#define ID3D12VideoMotionVectorHeap_GetProtectedResourceSession(This,riid,ppProtectedSession)	\
-    ( (This)->lpVtbl -> GetProtectedResourceSession(This,riid,ppProtectedSession) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-
-
-
-
-#endif 	/* __ID3D12VideoMotionVectorHeap_INTERFACE_DEFINED__ */
-
-
-#ifndef __ID3D12VideoDevice1_INTERFACE_DEFINED__
-#define __ID3D12VideoDevice1_INTERFACE_DEFINED__
-
-/* interface ID3D12VideoDevice1 */
-/* [unique][local][object][uuid] */ 
-
-
-EXTERN_C const IID IID_ID3D12VideoDevice1;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("981611AD-A144-4C83-9890-F30E26D658AB")
-    ID3D12VideoDevice1 : public ID3D12VideoDevice
-    {
-    public:
-        virtual HRESULT STDMETHODCALLTYPE CreateVideoMotionEstimator( 
-            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_DESC *pDesc,
-            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
-            _In_  REFIID riid,
-            _COM_Outptr_  void **ppVideoMotionEstimator) = 0;
-        
-        virtual HRESULT STDMETHODCALLTYPE CreateVideoMotionVectorHeap( 
-            _In_  const D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC *pDesc,
-            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
-            _In_  REFIID riid,
-            _COM_Outptr_  void **ppVideoMotionVectorHeap) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct ID3D12VideoDevice1Vtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            ID3D12VideoDevice1 * This,
-            REFIID riid,
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            ID3D12VideoDevice1 * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            ID3D12VideoDevice1 * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *CheckFeatureSupport )( 
-            ID3D12VideoDevice1 * This,
-            D3D12_FEATURE_VIDEO FeatureVideo,
-            _Inout_updates_bytes_(FeatureSupportDataSize)  void *pFeatureSupportData,
-            UINT FeatureSupportDataSize);
-        
-        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoder )( 
-            ID3D12VideoDevice1 * This,
-            _In_  const D3D12_VIDEO_DECODER_DESC *pDesc,
-            _In_  REFIID riid,
-            _COM_Outptr_  void **ppVideoDecoder);
-        
-        HRESULT ( STDMETHODCALLTYPE *CreateVideoDecoderHeap )( 
-            ID3D12VideoDevice1 * This,
-            _In_  const D3D12_VIDEO_DECODER_HEAP_DESC *pVideoDecoderHeapDesc,
-            _In_  REFIID riid,
-            _COM_Outptr_  void **ppVideoDecoderHeap);
-        
-        HRESULT ( STDMETHODCALLTYPE *CreateVideoProcessor )( 
-            ID3D12VideoDevice1 * 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);
-        
-        HRESULT ( STDMETHODCALLTYPE *CreateVideoMotionEstimator )( 
-            ID3D12VideoDevice1 * This,
-            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_DESC *pDesc,
-            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
-            _In_  REFIID riid,
-            _COM_Outptr_  void **ppVideoMotionEstimator);
-        
-        HRESULT ( STDMETHODCALLTYPE *CreateVideoMotionVectorHeap )( 
-            ID3D12VideoDevice1 * This,
-            _In_  const D3D12_VIDEO_MOTION_VECTOR_HEAP_DESC *pDesc,
-            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession,
-            _In_  REFIID riid,
-            _COM_Outptr_  void **ppVideoMotionVectorHeap);
-        
-        END_INTERFACE
-    } ID3D12VideoDevice1Vtbl;
-
-    interface ID3D12VideoDevice1
-    {
-        CONST_VTBL struct ID3D12VideoDevice1Vtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define ID3D12VideoDevice1_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define ID3D12VideoDevice1_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define ID3D12VideoDevice1_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define ID3D12VideoDevice1_CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize)	\
-    ( (This)->lpVtbl -> CheckFeatureSupport(This,FeatureVideo,pFeatureSupportData,FeatureSupportDataSize) ) 
-
-#define ID3D12VideoDevice1_CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder)	\
-    ( (This)->lpVtbl -> CreateVideoDecoder(This,pDesc,riid,ppVideoDecoder) ) 
-
-#define ID3D12VideoDevice1_CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap)	\
-    ( (This)->lpVtbl -> CreateVideoDecoderHeap(This,pVideoDecoderHeapDesc,riid,ppVideoDecoderHeap) ) 
-
-#define ID3D12VideoDevice1_CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor)	\
-    ( (This)->lpVtbl -> CreateVideoProcessor(This,NodeMask,pOutputStreamDesc,NumInputStreamDescs,pInputStreamDescs,riid,ppVideoProcessor) ) 
-
-
-#define ID3D12VideoDevice1_CreateVideoMotionEstimator(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionEstimator)	\
-    ( (This)->lpVtbl -> CreateVideoMotionEstimator(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionEstimator) ) 
-
-#define ID3D12VideoDevice1_CreateVideoMotionVectorHeap(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionVectorHeap)	\
-    ( (This)->lpVtbl -> CreateVideoMotionVectorHeap(This,pDesc,pProtectedResourceSession,riid,ppVideoMotionVectorHeap) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __ID3D12VideoDevice1_INTERFACE_DEFINED__ */
-
-
-/* interface __MIDL_itf_d3d12video_0000_0011 */
-/* [local] */ 
-
-typedef struct D3D12_RESOURCE_COORDINATE
-    {
-    UINT64 X;
-    UINT Y;
-    UINT Z;
-    UINT SubresourceIndex;
-    } 	D3D12_RESOURCE_COORDINATE;
-
-typedef struct D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT
-    {
-    ID3D12VideoMotionVectorHeap *pMotionVectorHeap;
-    } 	D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT;
-
-typedef struct D3D12_VIDEO_MOTION_ESTIMATOR_INPUT
-    {
-    ID3D12Resource *pInputTexture2D;
-    UINT InputSubresourceIndex;
-    ID3D12Resource *pReferenceTexture2D;
-    UINT ReferenceSubresourceIndex;
-    ID3D12VideoMotionVectorHeap *pHintMotionVectorHeap;
-    } 	D3D12_VIDEO_MOTION_ESTIMATOR_INPUT;
-
-typedef struct D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT
-    {
-    ID3D12Resource *pMotionVectorTexture2D;
-    D3D12_RESOURCE_COORDINATE MotionVectorCoordinate;
-    } 	D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT;
-
-typedef struct D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT
-    {
-    ID3D12VideoMotionVectorHeap *pMotionVectorHeap;
-    UINT PixelWidth;
-    UINT PixelHeight;
-    } 	D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT;
-
-
-
-extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0011_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0011_v0_0_s_ifspec;
-
-#ifndef __ID3D12VideoEncodeCommandList_INTERFACE_DEFINED__
-#define __ID3D12VideoEncodeCommandList_INTERFACE_DEFINED__
-
-/* interface ID3D12VideoEncodeCommandList */
-/* [unique][local][object][uuid] */ 
-
-
-EXTERN_C const IID IID_ID3D12VideoEncodeCommandList;
-
-#if defined(__cplusplus) && !defined(CINTERFACE)
-    
-    MIDL_INTERFACE("8455293A-0CBD-4831-9B39-FBDBAB724723")
-    ID3D12VideoEncodeCommandList : 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 EstimateMotion( 
-            _In_  ID3D12VideoMotionEstimator *pMotionEstimator,
-            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT *pOutputArguments,
-            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_INPUT *pInputArguments) = 0;
-        
-        virtual void STDMETHODCALLTYPE ResolveMotionVectorHeap( 
-            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT *pOutputArguments,
-            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT *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;
-        
-        virtual void STDMETHODCALLTYPE SetProtectedResourceSession( 
-            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession) = 0;
-        
-    };
-    
-    
-#else 	/* C style interface */
-
-    typedef struct ID3D12VideoEncodeCommandListVtbl
-    {
-        BEGIN_INTERFACE
-        
-        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
-            ID3D12VideoEncodeCommandList * This,
-            REFIID riid,
-            _COM_Outptr_  void **ppvObject);
-        
-        ULONG ( STDMETHODCALLTYPE *AddRef )( 
-            ID3D12VideoEncodeCommandList * This);
-        
-        ULONG ( STDMETHODCALLTYPE *Release )( 
-            ID3D12VideoEncodeCommandList * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetPrivateData )( 
-            ID3D12VideoEncodeCommandList * This,
-            _In_  REFGUID guid,
-            _Inout_  UINT *pDataSize,
-            _Out_writes_bytes_opt_( *pDataSize )  void *pData);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetPrivateData )( 
-            ID3D12VideoEncodeCommandList * This,
-            _In_  REFGUID guid,
-            _In_  UINT DataSize,
-            _In_reads_bytes_opt_( DataSize )  const void *pData);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetPrivateDataInterface )( 
-            ID3D12VideoEncodeCommandList * This,
-            _In_  REFGUID guid,
-            _In_opt_  const IUnknown *pData);
-        
-        HRESULT ( STDMETHODCALLTYPE *SetName )( 
-            ID3D12VideoEncodeCommandList * This,
-            _In_z_  LPCWSTR Name);
-        
-        HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
-            ID3D12VideoEncodeCommandList * This,
-            REFIID riid,
-            _COM_Outptr_opt_  void **ppvDevice);
-        
-        D3D12_COMMAND_LIST_TYPE ( STDMETHODCALLTYPE *GetType )( 
-            ID3D12VideoEncodeCommandList * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *Close )( 
-            ID3D12VideoEncodeCommandList * This);
-        
-        HRESULT ( STDMETHODCALLTYPE *Reset )( 
-            ID3D12VideoEncodeCommandList * This,
-            _In_  ID3D12CommandAllocator *pAllocator);
-        
-        void ( STDMETHODCALLTYPE *ClearState )( 
-            ID3D12VideoEncodeCommandList * This);
-        
-        void ( STDMETHODCALLTYPE *ResourceBarrier )( 
-            ID3D12VideoEncodeCommandList * This,
-            _In_  UINT NumBarriers,
-            _In_reads_(NumBarriers)  const D3D12_RESOURCE_BARRIER *pBarriers);
-        
-        void ( STDMETHODCALLTYPE *DiscardResource )( 
-            ID3D12VideoEncodeCommandList * This,
-            _In_  ID3D12Resource *pResource,
-            _In_opt_  const D3D12_DISCARD_REGION *pRegion);
-        
-        void ( STDMETHODCALLTYPE *BeginQuery )( 
-            ID3D12VideoEncodeCommandList * This,
-            _In_  ID3D12QueryHeap *pQueryHeap,
-            _In_  D3D12_QUERY_TYPE Type,
-            _In_  UINT Index);
-        
-        void ( STDMETHODCALLTYPE *EndQuery )( 
-            ID3D12VideoEncodeCommandList * This,
-            _In_  ID3D12QueryHeap *pQueryHeap,
-            _In_  D3D12_QUERY_TYPE Type,
-            _In_  UINT Index);
-        
-        void ( STDMETHODCALLTYPE *ResolveQueryData )( 
-            ID3D12VideoEncodeCommandList * This,
-            _In_  ID3D12QueryHeap *pQueryHeap,
-            _In_  D3D12_QUERY_TYPE Type,
-            _In_  UINT StartIndex,
-            _In_  UINT NumQueries,
-            _In_  ID3D12Resource *pDestinationBuffer,
-            _In_  UINT64 AlignedDestinationBufferOffset);
-        
-        void ( STDMETHODCALLTYPE *SetPredication )( 
-            ID3D12VideoEncodeCommandList * This,
-            _In_opt_  ID3D12Resource *pBuffer,
-            _In_  UINT64 AlignedBufferOffset,
-            _In_  D3D12_PREDICATION_OP Operation);
-        
-        void ( STDMETHODCALLTYPE *SetMarker )( 
-            ID3D12VideoEncodeCommandList * This,
-            UINT Metadata,
-            _In_reads_bytes_opt_(Size)  const void *pData,
-            UINT Size);
-        
-        void ( STDMETHODCALLTYPE *BeginEvent )( 
-            ID3D12VideoEncodeCommandList * This,
-            UINT Metadata,
-            _In_reads_bytes_opt_(Size)  const void *pData,
-            UINT Size);
-        
-        void ( STDMETHODCALLTYPE *EndEvent )( 
-            ID3D12VideoEncodeCommandList * This);
-        
-        void ( STDMETHODCALLTYPE *EstimateMotion )( 
-            ID3D12VideoEncodeCommandList * This,
-            _In_  ID3D12VideoMotionEstimator *pMotionEstimator,
-            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_OUTPUT *pOutputArguments,
-            _In_  const D3D12_VIDEO_MOTION_ESTIMATOR_INPUT *pInputArguments);
-        
-        void ( STDMETHODCALLTYPE *ResolveMotionVectorHeap )( 
-            ID3D12VideoEncodeCommandList * This,
-            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_OUTPUT *pOutputArguments,
-            const D3D12_RESOLVE_VIDEO_MOTION_VECTOR_HEAP_INPUT *pInputArguments);
-        
-        void ( STDMETHODCALLTYPE *WriteBufferImmediate )( 
-            ID3D12VideoEncodeCommandList * This,
-            UINT Count,
-            _In_reads_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_PARAMETER *pParams,
-            _In_reads_opt_(Count)  const D3D12_WRITEBUFFERIMMEDIATE_MODE *pModes);
-        
-        void ( STDMETHODCALLTYPE *SetProtectedResourceSession )( 
-            ID3D12VideoEncodeCommandList * This,
-            _In_opt_  ID3D12ProtectedResourceSession *pProtectedResourceSession);
-        
-        END_INTERFACE
-    } ID3D12VideoEncodeCommandListVtbl;
-
-    interface ID3D12VideoEncodeCommandList
-    {
-        CONST_VTBL struct ID3D12VideoEncodeCommandListVtbl *lpVtbl;
-    };
-
-    
-
-#ifdef COBJMACROS
-
-
-#define ID3D12VideoEncodeCommandList_QueryInterface(This,riid,ppvObject)	\
-    ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) 
-
-#define ID3D12VideoEncodeCommandList_AddRef(This)	\
-    ( (This)->lpVtbl -> AddRef(This) ) 
-
-#define ID3D12VideoEncodeCommandList_Release(This)	\
-    ( (This)->lpVtbl -> Release(This) ) 
-
-
-#define ID3D12VideoEncodeCommandList_GetPrivateData(This,guid,pDataSize,pData)	\
-    ( (This)->lpVtbl -> GetPrivateData(This,guid,pDataSize,pData) ) 
-
-#define ID3D12VideoEncodeCommandList_SetPrivateData(This,guid,DataSize,pData)	\
-    ( (This)->lpVtbl -> SetPrivateData(This,guid,DataSize,pData) ) 
-
-#define ID3D12VideoEncodeCommandList_SetPrivateDataInterface(This,guid,pData)	\
-    ( (This)->lpVtbl -> SetPrivateDataInterface(This,guid,pData) ) 
-
-#define ID3D12VideoEncodeCommandList_SetName(This,Name)	\
-    ( (This)->lpVtbl -> SetName(This,Name) ) 
-
-
-#define ID3D12VideoEncodeCommandList_GetDevice(This,riid,ppvDevice)	\
-    ( (This)->lpVtbl -> GetDevice(This,riid,ppvDevice) ) 
-
-
-#define ID3D12VideoEncodeCommandList_GetType(This)	\
-    ( (This)->lpVtbl -> GetType(This) ) 
-
-
-#define ID3D12VideoEncodeCommandList_Close(This)	\
-    ( (This)->lpVtbl -> Close(This) ) 
-
-#define ID3D12VideoEncodeCommandList_Reset(This,pAllocator)	\
-    ( (This)->lpVtbl -> Reset(This,pAllocator) ) 
-
-#define ID3D12VideoEncodeCommandList_ClearState(This)	\
-    ( (This)->lpVtbl -> ClearState(This) ) 
-
-#define ID3D12VideoEncodeCommandList_ResourceBarrier(This,NumBarriers,pBarriers)	\
-    ( (This)->lpVtbl -> ResourceBarrier(This,NumBarriers,pBarriers) ) 
-
-#define ID3D12VideoEncodeCommandList_DiscardResource(This,pResource,pRegion)	\
-    ( (This)->lpVtbl -> DiscardResource(This,pResource,pRegion) ) 
-
-#define ID3D12VideoEncodeCommandList_BeginQuery(This,pQueryHeap,Type,Index)	\
-    ( (This)->lpVtbl -> BeginQuery(This,pQueryHeap,Type,Index) ) 
-
-#define ID3D12VideoEncodeCommandList_EndQuery(This,pQueryHeap,Type,Index)	\
-    ( (This)->lpVtbl -> EndQuery(This,pQueryHeap,Type,Index) ) 
-
-#define ID3D12VideoEncodeCommandList_ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset)	\
-    ( (This)->lpVtbl -> ResolveQueryData(This,pQueryHeap,Type,StartIndex,NumQueries,pDestinationBuffer,AlignedDestinationBufferOffset) ) 
-
-#define ID3D12VideoEncodeCommandList_SetPredication(This,pBuffer,AlignedBufferOffset,Operation)	\
-    ( (This)->lpVtbl -> SetPredication(This,pBuffer,AlignedBufferOffset,Operation) ) 
-
-#define ID3D12VideoEncodeCommandList_SetMarker(This,Metadata,pData,Size)	\
-    ( (This)->lpVtbl -> SetMarker(This,Metadata,pData,Size) ) 
-
-#define ID3D12VideoEncodeCommandList_BeginEvent(This,Metadata,pData,Size)	\
-    ( (This)->lpVtbl -> BeginEvent(This,Metadata,pData,Size) ) 
-
-#define ID3D12VideoEncodeCommandList_EndEvent(This)	\
-    ( (This)->lpVtbl -> EndEvent(This) ) 
-
-#define ID3D12VideoEncodeCommandList_EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments)	\
-    ( (This)->lpVtbl -> EstimateMotion(This,pMotionEstimator,pOutputArguments,pInputArguments) ) 
-
-#define ID3D12VideoEncodeCommandList_ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments)	\
-    ( (This)->lpVtbl -> ResolveMotionVectorHeap(This,pOutputArguments,pInputArguments) ) 
-
-#define ID3D12VideoEncodeCommandList_WriteBufferImmediate(This,Count,pParams,pModes)	\
-    ( (This)->lpVtbl -> WriteBufferImmediate(This,Count,pParams,pModes) ) 
-
-#define ID3D12VideoEncodeCommandList_SetProtectedResourceSession(This,pProtectedResourceSession)	\
-    ( (This)->lpVtbl -> SetProtectedResourceSession(This,pProtectedResourceSession) ) 
-
-#endif /* COBJMACROS */
-
-
-#endif 	/* C style interface */
-
-
-
-
-#endif 	/* __ID3D12VideoEncodeCommandList_INTERFACE_DEFINED__ */
-
-
-/* interface __MIDL_itf_d3d12video_0000_0012 */
-/* [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);
-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);
-DEFINE_GUID(IID_ID3D12VideoMotionEstimator,0x33FDAE0E,0x098B,0x428F,0x87,0xBB,0x34,0xB6,0x95,0xDE,0x08,0xF8);
-DEFINE_GUID(IID_ID3D12VideoMotionVectorHeap,0x5BE17987,0x743A,0x4061,0x83,0x4B,0x23,0xD2,0x2D,0xAE,0xA5,0x05);
-DEFINE_GUID(IID_ID3D12VideoDevice1,0x981611AD,0xA144,0x4C83,0x98,0x90,0xF3,0x0E,0x26,0xD6,0x58,0xAB);
-DEFINE_GUID(IID_ID3D12VideoEncodeCommandList,0x8455293A,0x0CBD,0x4831,0x9B,0x39,0xFB,0xDB,0xAB,0x72,0x47,0x23);
-
-
-extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0012_v0_0_c_ifspec;
-extern RPC_IF_HANDLE __MIDL_itf_d3d12video_0000_0012_v0_0_s_ifspec;
-
-/* Additional Prototypes for ALL interfaces */
-
-/* end of Additional Prototypes */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-

3rdparty/dxsdk/include/dxgiformat.h

@@ -1,137 +0,0 @@
-//
-//    Copyright (C) Microsoft.  All rights reserved.
-//
-
-#ifndef __dxgiformat_h__
-#define __dxgiformat_h__
-
-#define DXGI_FORMAT_DEFINED 1
-
-typedef enum DXGI_FORMAT
-{
-    DXGI_FORMAT_UNKNOWN	                    = 0,
-    DXGI_FORMAT_R32G32B32A32_TYPELESS       = 1,
-    DXGI_FORMAT_R32G32B32A32_FLOAT          = 2,
-    DXGI_FORMAT_R32G32B32A32_UINT           = 3,
-    DXGI_FORMAT_R32G32B32A32_SINT           = 4,
-    DXGI_FORMAT_R32G32B32_TYPELESS          = 5,
-    DXGI_FORMAT_R32G32B32_FLOAT             = 6,
-    DXGI_FORMAT_R32G32B32_UINT              = 7,
-    DXGI_FORMAT_R32G32B32_SINT              = 8,
-    DXGI_FORMAT_R16G16B16A16_TYPELESS       = 9,
-    DXGI_FORMAT_R16G16B16A16_FLOAT          = 10,
-    DXGI_FORMAT_R16G16B16A16_UNORM          = 11,
-    DXGI_FORMAT_R16G16B16A16_UINT           = 12,
-    DXGI_FORMAT_R16G16B16A16_SNORM          = 13,
-    DXGI_FORMAT_R16G16B16A16_SINT           = 14,
-    DXGI_FORMAT_R32G32_TYPELESS             = 15,
-    DXGI_FORMAT_R32G32_FLOAT                = 16,
-    DXGI_FORMAT_R32G32_UINT                 = 17,
-    DXGI_FORMAT_R32G32_SINT                 = 18,
-    DXGI_FORMAT_R32G8X24_TYPELESS           = 19,
-    DXGI_FORMAT_D32_FLOAT_S8X24_UINT        = 20,
-    DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS    = 21,
-    DXGI_FORMAT_X32_TYPELESS_G8X24_UINT     = 22,
-    DXGI_FORMAT_R10G10B10A2_TYPELESS        = 23,
-    DXGI_FORMAT_R10G10B10A2_UNORM           = 24,
-    DXGI_FORMAT_R10G10B10A2_UINT            = 25,
-    DXGI_FORMAT_R11G11B10_FLOAT             = 26,
-    DXGI_FORMAT_R8G8B8A8_TYPELESS           = 27,
-    DXGI_FORMAT_R8G8B8A8_UNORM              = 28,
-    DXGI_FORMAT_R8G8B8A8_UNORM_SRGB         = 29,
-    DXGI_FORMAT_R8G8B8A8_UINT               = 30,
-    DXGI_FORMAT_R8G8B8A8_SNORM              = 31,
-    DXGI_FORMAT_R8G8B8A8_SINT               = 32,
-    DXGI_FORMAT_R16G16_TYPELESS             = 33,
-    DXGI_FORMAT_R16G16_FLOAT                = 34,
-    DXGI_FORMAT_R16G16_UNORM                = 35,
-    DXGI_FORMAT_R16G16_UINT                 = 36,
-    DXGI_FORMAT_R16G16_SNORM                = 37,
-    DXGI_FORMAT_R16G16_SINT                 = 38,
-    DXGI_FORMAT_R32_TYPELESS                = 39,
-    DXGI_FORMAT_D32_FLOAT                   = 40,
-    DXGI_FORMAT_R32_FLOAT                   = 41,
-    DXGI_FORMAT_R32_UINT                    = 42,
-    DXGI_FORMAT_R32_SINT                    = 43,
-    DXGI_FORMAT_R24G8_TYPELESS              = 44,
-    DXGI_FORMAT_D24_UNORM_S8_UINT           = 45,
-    DXGI_FORMAT_R24_UNORM_X8_TYPELESS       = 46,
-    DXGI_FORMAT_X24_TYPELESS_G8_UINT        = 47,
-    DXGI_FORMAT_R8G8_TYPELESS               = 48,
-    DXGI_FORMAT_R8G8_UNORM                  = 49,
-    DXGI_FORMAT_R8G8_UINT                   = 50,
-    DXGI_FORMAT_R8G8_SNORM                  = 51,
-    DXGI_FORMAT_R8G8_SINT                   = 52,
-    DXGI_FORMAT_R16_TYPELESS                = 53,
-    DXGI_FORMAT_R16_FLOAT                   = 54,
-    DXGI_FORMAT_D16_UNORM                   = 55,
-    DXGI_FORMAT_R16_UNORM                   = 56,
-    DXGI_FORMAT_R16_UINT                    = 57,
-    DXGI_FORMAT_R16_SNORM                   = 58,
-    DXGI_FORMAT_R16_SINT                    = 59,
-    DXGI_FORMAT_R8_TYPELESS                 = 60,
-    DXGI_FORMAT_R8_UNORM                    = 61,
-    DXGI_FORMAT_R8_UINT                     = 62,
-    DXGI_FORMAT_R8_SNORM                    = 63,
-    DXGI_FORMAT_R8_SINT                     = 64,
-    DXGI_FORMAT_A8_UNORM                    = 65,
-    DXGI_FORMAT_R1_UNORM                    = 66,
-    DXGI_FORMAT_R9G9B9E5_SHAREDEXP          = 67,
-    DXGI_FORMAT_R8G8_B8G8_UNORM             = 68,
-    DXGI_FORMAT_G8R8_G8B8_UNORM             = 69,
-    DXGI_FORMAT_BC1_TYPELESS                = 70,
-    DXGI_FORMAT_BC1_UNORM                   = 71,
-    DXGI_FORMAT_BC1_UNORM_SRGB              = 72,
-    DXGI_FORMAT_BC2_TYPELESS                = 73,
-    DXGI_FORMAT_BC2_UNORM                   = 74,
-    DXGI_FORMAT_BC2_UNORM_SRGB              = 75,
-    DXGI_FORMAT_BC3_TYPELESS                = 76,
-    DXGI_FORMAT_BC3_UNORM                   = 77,
-    DXGI_FORMAT_BC3_UNORM_SRGB              = 78,
-    DXGI_FORMAT_BC4_TYPELESS                = 79,
-    DXGI_FORMAT_BC4_UNORM                   = 80,
-    DXGI_FORMAT_BC4_SNORM                   = 81,
-    DXGI_FORMAT_BC5_TYPELESS                = 82,
-    DXGI_FORMAT_BC5_UNORM                   = 83,
-    DXGI_FORMAT_BC5_SNORM                   = 84,
-    DXGI_FORMAT_B5G6R5_UNORM                = 85,
-    DXGI_FORMAT_B5G5R5A1_UNORM              = 86,
-    DXGI_FORMAT_B8G8R8A8_UNORM              = 87,
-    DXGI_FORMAT_B8G8R8X8_UNORM              = 88,
-    DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM  = 89,
-    DXGI_FORMAT_B8G8R8A8_TYPELESS           = 90,
-    DXGI_FORMAT_B8G8R8A8_UNORM_SRGB         = 91,
-    DXGI_FORMAT_B8G8R8X8_TYPELESS           = 92,
-    DXGI_FORMAT_B8G8R8X8_UNORM_SRGB         = 93,
-    DXGI_FORMAT_BC6H_TYPELESS               = 94,
-    DXGI_FORMAT_BC6H_UF16                   = 95,
-    DXGI_FORMAT_BC6H_SF16                   = 96,
-    DXGI_FORMAT_BC7_TYPELESS                = 97,
-    DXGI_FORMAT_BC7_UNORM                   = 98,
-    DXGI_FORMAT_BC7_UNORM_SRGB              = 99,
-    DXGI_FORMAT_AYUV                        = 100,
-    DXGI_FORMAT_Y410                        = 101,
-    DXGI_FORMAT_Y416                        = 102,
-    DXGI_FORMAT_NV12                        = 103,
-    DXGI_FORMAT_P010                        = 104,
-    DXGI_FORMAT_P016                        = 105,
-    DXGI_FORMAT_420_OPAQUE                  = 106,
-    DXGI_FORMAT_YUY2                        = 107,
-    DXGI_FORMAT_Y210                        = 108,
-    DXGI_FORMAT_Y216                        = 109,
-    DXGI_FORMAT_NV11                        = 110,
-    DXGI_FORMAT_AI44                        = 111,
-    DXGI_FORMAT_IA44                        = 112,
-    DXGI_FORMAT_P8                          = 113,
-    DXGI_FORMAT_A8P8                        = 114,
-    DXGI_FORMAT_B4G4R4A4_UNORM              = 115,
-
-    DXGI_FORMAT_P208                        = 130,
-    DXGI_FORMAT_V208                        = 131,
-    DXGI_FORMAT_V408                        = 132,
-
-
-    DXGI_FORMAT_FORCE_UINT                  = 0xffffffff
-} DXGI_FORMAT;
-
-#endif // __dxgiformat_h__

scripts/bgfx.lua

@@ -109,7 +109,9 @@ function bgfxProjectBase(_kind, _defines)
 
 	configuration { "vs* or mingw*", "not durango" }
 		includedirs {
-			path.join(BGFX_DIR, "3rdparty/dxsdk/include"),
+			path.join(BGFX_DIR, "3rdparty/directx-headers/include/directx"),
+--			path.join(BGFX_DIR, "3rdparty/directx-headers/include"),
+--			path.join(BGFX_DIR, "3rdparty/directx-headers/include/wsl/stubs"),
 		}
 
 	configuration { "android*" }

src/renderer_d3d12.cpp

@@ -460,14 +460,13 @@ namespace bgfx { namespace d3d12
 
 	static inline D3D12_HEAP_PROPERTIES ID3D12DeviceGetCustomHeapProperties(ID3D12Device *device, UINT nodeMask, D3D12_HEAP_TYPE heapType)
 	{
-		// NOTICE: gcc trick for return struct
-		union {
-			D3D12_HEAP_PROPERTIES (STDMETHODCALLTYPE ID3D12Device::*w)(UINT, D3D12_HEAP_TYPE);
-			void (STDMETHODCALLTYPE ID3D12Device::*f)(D3D12_HEAP_PROPERTIES *, UINT, D3D12_HEAP_TYPE);
-		} conversion = { &ID3D12Device::GetCustomHeapProperties };
+#if BX_COMPILER_MSVC
+		return device->GetCustomHeapProperties(nodeMask, heapType);
+#else
 		D3D12_HEAP_PROPERTIES ret;
-		(device->*conversion.f)(&ret, nodeMask, heapType);
+		device->GetCustomHeapProperties(&ret, nodeMask, heapType);
 		return ret;
+#endif // BX_COMPILER_MSVC
 	}
 
 	static void initHeapProperties(ID3D12Device* _device, D3D12_HEAP_PROPERTIES& _properties)
@@ -509,7 +508,12 @@ namespace bgfx { namespace d3d12
 		{
 			void* ptr;
 			DX_CHECK(resource->Map(0, NULL, &ptr) );
-			D3D12_RESOURCE_ALLOCATION_INFO rai = _device->GetResourceAllocationInfo(1, 1, _resourceDesc);
+			D3D12_RESOURCE_ALLOCATION_INFO rai;
+#if BX_COMPILER_MSVC
+			rai = _device->GetResourceAllocationInfo(1, 1, _resourceDesc);
+#else
+			_device->GetResourceAllocationInfo(&rai, 1, 1, _resourceDesc);
+#endif // BX_COMPILER_MSVC
 			bx::memSet(ptr, 0, size_t(rai.SizeInBytes) );
 			resource->Unmap(0, NULL);
 		}
@@ -608,11 +612,7 @@ namespace bgfx { namespace d3d12
 		return _heap->GetCPUDescriptorHandleForHeapStart();
 #else
 		D3D12_CPU_DESCRIPTOR_HANDLE handle;
-		union {
-			D3D12_CPU_DESCRIPTOR_HANDLE (WINAPI ID3D12DescriptorHeap::*w)();
-			void (WINAPI ID3D12DescriptorHeap::*f)(D3D12_CPU_DESCRIPTOR_HANDLE *);
-		} conversion = { &ID3D12DescriptorHeap::GetCPUDescriptorHandleForHeapStart };
-		(_heap->*conversion.f)(&handle);
+		_heap->GetCPUDescriptorHandleForHeapStart(&handle);
 		return handle;
 #endif // BX_COMPILER_MSVC
 	}
@@ -623,11 +623,7 @@ namespace bgfx { namespace d3d12
 		return _heap->GetGPUDescriptorHandleForHeapStart();
 #else
 		D3D12_GPU_DESCRIPTOR_HANDLE handle;
-		union {
-			D3D12_GPU_DESCRIPTOR_HANDLE (WINAPI ID3D12DescriptorHeap::*w)();
-			void (WINAPI ID3D12DescriptorHeap::*f)(D3D12_GPU_DESCRIPTOR_HANDLE *);
-		} conversion = { &ID3D12DescriptorHeap::GetGPUDescriptorHandleForHeapStart };
-		(_heap->*conversion.f)(&handle);
+		_heap->GetGPUDescriptorHandleForHeapStart(&handle);
 		return handle;
 #endif // BX_COMPILER_MSVC
 	}
@@ -638,11 +634,7 @@ namespace bgfx { namespace d3d12
 		return _resource->GetDesc();
 #else
 		D3D12_RESOURCE_DESC desc;
-		union {
-			D3D12_RESOURCE_DESC (STDMETHODCALLTYPE ID3D12Resource::*w)();
-			void (STDMETHODCALLTYPE ID3D12Resource::*f)(D3D12_RESOURCE_DESC *);
-		} conversion = { &ID3D12Resource::GetDesc };
-		(_resource->*conversion.f)(&desc);
+		_resource->GetDesc(&desc);
 		return desc;
 #endif // BX_COMPILER_MSVC
 	}
@@ -5128,8 +5120,6 @@ namespace bgfx { namespace d3d12
 		box.right  = box.left + _rect.m_width;
 		box.bottom = box.top  + _rect.m_height;
 
-		uint32_t layer = 0;
-
 		if (TextureD3D12::Texture3D == m_type)
 		{
 			box.front = _z;
@@ -5137,7 +5127,6 @@ namespace bgfx { namespace d3d12
 		}
 		else
 		{
-			layer = _z * (TextureD3D12::TextureCube == m_type ? 6 : 1);
 			box.front = 0;
 			box.back  = 1;
 		}