From dcb758035e39fabf7e2756554d9a4042d90cd5e5 Mon Sep 17 00:00:00 2001
From: Jacek Caban <jacek@codeweavers.com>
Date: Tue, 25 Aug 2015 17:06:40 +0200
Subject: Updated imported headers to current Wine version.


diff --git a/mingw-w64-headers/direct-x/include/d3d11.h b/mingw-w64-headers/direct-x/include/d3d11.h
index cc64c3f..57efdf7 100644
--- a/mingw-w64-headers/direct-x/include/d3d11.h
+++ b/mingw-w64-headers/direct-x/include/d3d11.h
@@ -167,6 +167,51 @@ typedef interface ID3D11VertexShader ID3D11VertexShader;
 typedef interface ID3D11DeviceContext ID3D11DeviceContext;
 #endif
 
+#ifndef __ID3D11AuthenticatedChannel_FWD_DEFINED__
+#define __ID3D11AuthenticatedChannel_FWD_DEFINED__
+typedef interface ID3D11AuthenticatedChannel ID3D11AuthenticatedChannel;
+#endif
+
+#ifndef __ID3D11CryptoSession_FWD_DEFINED__
+#define __ID3D11CryptoSession_FWD_DEFINED__
+typedef interface ID3D11CryptoSession ID3D11CryptoSession;
+#endif
+
+#ifndef __ID3D11VideoDecoder_FWD_DEFINED__
+#define __ID3D11VideoDecoder_FWD_DEFINED__
+typedef interface ID3D11VideoDecoder ID3D11VideoDecoder;
+#endif
+
+#ifndef __ID3D11VideoProcessorEnumerator_FWD_DEFINED__
+#define __ID3D11VideoProcessorEnumerator_FWD_DEFINED__
+typedef interface ID3D11VideoProcessorEnumerator ID3D11VideoProcessorEnumerator;
+#endif
+
+#ifndef __ID3D11VideoProcessor_FWD_DEFINED__
+#define __ID3D11VideoProcessor_FWD_DEFINED__
+typedef interface ID3D11VideoProcessor ID3D11VideoProcessor;
+#endif
+
+#ifndef __ID3D11VideoDecoderOutputView_FWD_DEFINED__
+#define __ID3D11VideoDecoderOutputView_FWD_DEFINED__
+typedef interface ID3D11VideoDecoderOutputView ID3D11VideoDecoderOutputView;
+#endif
+
+#ifndef __ID3D11VideoProcessorInputView_FWD_DEFINED__
+#define __ID3D11VideoProcessorInputView_FWD_DEFINED__
+typedef interface ID3D11VideoProcessorInputView ID3D11VideoProcessorInputView;
+#endif
+
+#ifndef __ID3D11VideoProcessorOutputView_FWD_DEFINED__
+#define __ID3D11VideoProcessorOutputView_FWD_DEFINED__
+typedef interface ID3D11VideoProcessorOutputView ID3D11VideoProcessorOutputView;
+#endif
+
+#ifndef __ID3D11VideoDevice_FWD_DEFINED__
+#define __ID3D11VideoDevice_FWD_DEFINED__
+typedef interface ID3D11VideoDevice ID3D11VideoDevice;
+#endif
+
 #ifndef __ID3D11Device_FWD_DEFINED__
 #define __ID3D11Device_FWD_DEFINED__
 typedef interface ID3D11Device ID3D11Device;
@@ -1296,6 +1341,151 @@ typedef struct D3D11_TEXTURE3D_DESC {
     UINT CPUAccessFlags;
     UINT MiscFlags;
 } D3D11_TEXTURE3D_DESC;
+typedef struct D3D11_VIDEO_DECODER_DESC {
+    GUID Guid;
+    UINT SampleWidth;
+    UINT SampleHeight;
+    DXGI_FORMAT OutputFormat;
+} D3D11_VIDEO_DECODER_DESC;
+typedef struct D3D11_VIDEO_DECODER_CONFIG {
+    GUID guidConfigBitstreamEncryption;
+    GUID guidConfigMBcontrolEncryption;
+    GUID guidConfigResidDiffEncryption;
+    UINT ConfigBitstreamRaw;
+    UINT ConfigMBcontrolRasterOrder;
+    UINT ConfigResidDiffHost;
+    UINT ConfigSpatialResid8;
+    UINT ConfigResid8Subtraction;
+    UINT ConfigSpatialHost8or9Clipping;
+    UINT ConfigSpatialResidInterleaved;
+    UINT ConfigIntraResidUnsigned;
+    UINT ConfigResidDiffAccelerator;
+    UINT ConfigHostInverseScan;
+    UINT ConfigSpecificIDCT;
+    UINT Config4GroupedCoefs;
+    USHORT ConfigMinRenderTargetBuffCount;
+    USHORT ConfigDecoderSpecific;
+} D3D11_VIDEO_DECODER_CONFIG;
+typedef enum D3D11_VIDEO_FRAME_FORMAT {
+    D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE = 0,
+    D3D11_VIDEO_FRAME_FORMAT_INTERLACED_TOP_FIELD_FIRST = 1,
+    D3D11_VIDEO_FRAME_FORMAT_INTERLACED_BOTTOM_FIELD_FIRST = 2
+} D3D11_VIDEO_FRAME_FORMAT;
+typedef enum D3D11_VIDEO_USAGE {
+    D3D11_VIDEO_USAGE_PLAYBACK_NORMAL = 0,
+    D3D11_VIDEO_USAGE_OPTIMAL_SPEED = 1,
+    D3D11_VIDEO_USAGE_OPTIMAL_QUALITY = 2
+} D3D11_VIDEO_USAGE;
+typedef struct D3D11_VIDEO_PROCESSOR_CONTENT_DESC {
+    D3D11_VIDEO_FRAME_FORMAT InputFrameFormat;
+    DXGI_RATIONAL InputFrameRate;
+    UINT InputWidth;
+    UINT InputHeight;
+    DXGI_RATIONAL OutputFrameRate;
+    UINT OutputWidth;
+    UINT OutputHeight;
+    D3D11_VIDEO_USAGE Usage;
+} D3D11_VIDEO_PROCESSOR_CONTENT_DESC;
+typedef struct D3D11_VIDEO_PROCESSOR_CAPS {
+    UINT DeviceCaps;
+    UINT FeatureCaps;
+    UINT FilterCaps;
+    UINT InputFormatCaps;
+    UINT AutoStreamCaps;
+    UINT StereoCaps;
+    UINT RateConversionCapsCount;
+    UINT MaxInputStreams;
+    UINT MaxStreamStates;
+} D3D11_VIDEO_PROCESSOR_CAPS;
+typedef struct D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS {
+    UINT PastFrames;
+    UINT FutureFrames;
+    UINT ProcessorCaps;
+    UINT ITelecineCaps;
+    UINT CustomRateCount;
+} D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS;
+typedef struct D3D11_VIDEO_PROCESSOR_CUSTOM_RATE {
+    DXGI_RATIONAL CustomRate;
+    UINT OutputFrames;
+    WINBOOL InputInterlaced;
+    UINT InputFramesOrFields;
+} D3D11_VIDEO_PROCESSOR_CUSTOM_RATE;
+typedef enum D3D11_VIDEO_PROCESSOR_FILTER {
+    D3D11_VIDEO_PROCESSOR_FILTER_BRIGHTNESS = 0,
+    D3D11_VIDEO_PROCESSOR_FILTER_CONTRAST = 1,
+    D3D11_VIDEO_PROCESSOR_FILTER_HUE = 2,
+    D3D11_VIDEO_PROCESSOR_FILTER_SATURATION = 3,
+    D3D11_VIDEO_PROCESSOR_FILTER_NOISE_REDUCTION = 4,
+    D3D11_VIDEO_PROCESSOR_FILTER_EDGE_ENHANCEMENT = 5,
+    D3D11_VIDEO_PROCESSOR_FILTER_ANAMORPHIC_SCALING = 6,
+    D3D11_VIDEO_PROCESSOR_FILTER_STEREO_ADJUSTMENT = 7
+} D3D11_VIDEO_PROCESSOR_FILTER;
+typedef struct D3D11_VIDEO_PROCESSOR_FILTER_RANGE {
+    int Minimum;
+    int Maximum;
+    int Default;
+    float Multiplier;
+} D3D11_VIDEO_PROCESSOR_FILTER_RANGE;
+typedef enum D3D11_AUTHENTICATED_CHANNEL_TYPE {
+    D3D11_AUTHENTICATED_CHANNEL_D3D11 = 1,
+    D3D11_AUTHENTICATED_CHANNEL_DRIVER_SOFTWARE = 2,
+    D3D11_AUTHENTICATED_CHANNEL_DRIVER_HARDWARE = 3
+} D3D11_AUTHENTICATED_CHANNEL_TYPE;
+typedef enum D3D11_VDOV_DIMENSION {
+    D3D11_VDOV_DIMENSION_UNKNOWN = 0,
+    D3D11_VDOV_DIMENSION_TEXTURE2D = 1
+} D3D11_VDOV_DIMENSION;
+typedef struct D3D11_TEX2D_VDOV {
+    UINT ArraySlice;
+} D3D11_TEX2D_VDOV;
+typedef struct D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC {
+    GUID DecodeProfile;
+    D3D11_VDOV_DIMENSION ViewDimension;
+    __C89_NAMELESS union {
+        D3D11_TEX2D_VDOV Texture2D;
+    } __C89_NAMELESSUNIONNAME;
+} D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC;
+typedef enum D3D11_VPIV_DIMENSION {
+    D3D11_VPIV_DIMENSION_UNKNOWN = 0,
+    D3D11_VPIV_DIMENSION_TEXTURE2D = 1
+} D3D11_VPIV_DIMENSION;
+typedef struct D3D11_TEX2D_VPIV {
+    UINT MipSlice;
+    UINT ArraySlice;
+} D3D11_TEX2D_VPIV;
+typedef struct D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC {
+    UINT FourCC;
+    D3D11_VPIV_DIMENSION ViewDimension;
+    __C89_NAMELESS union {
+        D3D11_TEX2D_VPIV Texture2D;
+    } __C89_NAMELESSUNIONNAME;
+} D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC;
+typedef enum D3D11_VPOV_DIMENSION {
+    D3D11_VPOV_DIMENSION_UNKNOWN = 0,
+    D3D11_VPOV_DIMENSION_TEXTURE2D = 1,
+    D3D11_VPOV_DIMENSION_TEXTURE2DARRAY = 2
+} D3D11_VPOV_DIMENSION;
+typedef struct D3D11_TEX2D_VPOV {
+    UINT MipSlice;
+} D3D11_TEX2D_VPOV;
+typedef struct D3D11_TEX2D_ARRAY_VPOV {
+    UINT MipSlice;
+    UINT FirstArraySlice;
+    UINT ArraySize;
+} D3D11_TEX2D_ARRAY_VPOV;
+typedef struct D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC {
+    D3D11_VPOV_DIMENSION ViewDimension;
+    __C89_NAMELESS union {
+        D3D11_TEX2D_VPOV Texture2D;
+        D3D11_TEX2D_ARRAY_VPOV Texture2DArray;
+    } __C89_NAMELESSUNIONNAME;
+} D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC;
+typedef struct D3D11_VIDEO_CONTENT_PROTECTION_CAPS {
+    UINT Caps;
+    UINT KeyExchangeTypeCount;
+    UINT BlockAlignmentSize;
+    ULONGLONG ProtectedMemorySize;
+} D3D11_VIDEO_CONTENT_PROTECTION_CAPS;
 #ifndef __ID3D11Device_FWD_DEFINED__
 #define __ID3D11Device_FWD_DEFINED__
 typedef interface ID3D11Device ID3D11Device;
@@ -7812,184 +8002,1959 @@ void __RPC_STUB ID3D11DeviceContext_FinishCommandList_Stub(
 #endif  /* __ID3D11DeviceContext_INTERFACE_DEFINED__ */
 
 /*****************************************************************************
- * ID3D11Device interface
+ * ID3D11AuthenticatedChannel interface
  */
-#ifndef __ID3D11Device_INTERFACE_DEFINED__
-#define __ID3D11Device_INTERFACE_DEFINED__
+#ifndef __ID3D11AuthenticatedChannel_INTERFACE_DEFINED__
+#define __ID3D11AuthenticatedChannel_INTERFACE_DEFINED__
 
-DEFINE_GUID(IID_ID3D11Device, 0xdb6f6ddb, 0xac77, 0x4e88, 0x82,0x53, 0x81,0x9d,0xf9,0xbb,0xf1,0x40);
+DEFINE_GUID(IID_ID3D11AuthenticatedChannel, 0x3015a308, 0xdcbd, 0x47aa, 0xa7,0x47, 0x19,0x24,0x86,0xd1,0x4d,0x4a);
 #if defined(__cplusplus) && !defined(CINTERFACE)
-MIDL_INTERFACE("db6f6ddb-ac77-4e88-8253-819df9bbf140")
-ID3D11Device : public IUnknown
+MIDL_INTERFACE("3015a308-dcbd-47aa-a747-192486d14d4a")
+ID3D11AuthenticatedChannel : public ID3D11DeviceChild
 {
-    virtual HRESULT STDMETHODCALLTYPE CreateBuffer(
-        const D3D11_BUFFER_DESC *pDesc,
-        const D3D11_SUBRESOURCE_DATA *pInitialData,
-        ID3D11Buffer **ppBuffer) = 0;
-
-    virtual HRESULT STDMETHODCALLTYPE CreateTexture1D(
-        const D3D11_TEXTURE1D_DESC *pDesc,
-        const D3D11_SUBRESOURCE_DATA *pInitialData,
-        ID3D11Texture1D **ppTexture1D) = 0;
+    virtual HRESULT STDMETHODCALLTYPE GetCertificateSize(
+        UINT *pCertificateSize) = 0;
 
-    virtual HRESULT STDMETHODCALLTYPE CreateTexture2D(
-        const D3D11_TEXTURE2D_DESC *pDesc,
-        const D3D11_SUBRESOURCE_DATA *pInitialData,
-        ID3D11Texture2D **ppTexture2D) = 0;
+    virtual HRESULT STDMETHODCALLTYPE GetCertificate(
+        UINT CertificateSize,
+        BYTE *pCertificate) = 0;
 
-    virtual HRESULT STDMETHODCALLTYPE CreateTexture3D(
-        const D3D11_TEXTURE3D_DESC *pDesc,
-        const D3D11_SUBRESOURCE_DATA *pInitialData,
-        ID3D11Texture3D **ppTexture3D) = 0;
+    virtual void STDMETHODCALLTYPE GetChannelHandle(
+        HANDLE *pChannelHandle) = 0;
 
-    virtual HRESULT STDMETHODCALLTYPE CreateShaderResourceView(
-        ID3D11Resource *pResource,
-        const D3D11_SHADER_RESOURCE_VIEW_DESC *pDesc,
-        ID3D11ShaderResourceView **ppSRView) = 0;
+};
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(ID3D11AuthenticatedChannel, 0x3015a308, 0xdcbd, 0x47aa, 0xa7,0x47, 0x19,0x24,0x86,0xd1,0x4d,0x4a)
+#endif
+#else
+typedef struct ID3D11AuthenticatedChannelVtbl {
+    BEGIN_INTERFACE
 
-    virtual HRESULT STDMETHODCALLTYPE CreateUnorderedAccessView(
-        ID3D11Resource *pResource,
-        const D3D11_UNORDERED_ACCESS_VIEW_DESC *pDesc,
-        ID3D11UnorderedAccessView **ppUAView) = 0;
+    /*** IUnknown methods ***/
+    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+        ID3D11AuthenticatedChannel* This,
+        REFIID riid,
+        void **ppvObject);
 
-    virtual HRESULT STDMETHODCALLTYPE CreateRenderTargetView(
-        ID3D11Resource *pResource,
-        const D3D11_RENDER_TARGET_VIEW_DESC *pDesc,
-        ID3D11RenderTargetView **ppRTView) = 0;
+    ULONG (STDMETHODCALLTYPE *AddRef)(
+        ID3D11AuthenticatedChannel* This);
 
-    virtual HRESULT STDMETHODCALLTYPE CreateDepthStencilView(
-        ID3D11Resource *pResource,
-        const D3D11_DEPTH_STENCIL_VIEW_DESC *pDesc,
-        ID3D11DepthStencilView **ppDepthStencilView) = 0;
+    ULONG (STDMETHODCALLTYPE *Release)(
+        ID3D11AuthenticatedChannel* This);
 
-    virtual HRESULT STDMETHODCALLTYPE CreateInputLayout(
-        const D3D11_INPUT_ELEMENT_DESC *pInputElementDescs,
-        UINT NumElements,
-        const void *pShaderBytecodeWithInputSignature,
-        SIZE_T BytecodeLength,
-        ID3D11InputLayout **ppInputLayout) = 0;
+    /*** ID3D11DeviceChild methods ***/
+    void (STDMETHODCALLTYPE *GetDevice)(
+        ID3D11AuthenticatedChannel* This,
+        ID3D11Device **ppDevice);
 
-    virtual HRESULT STDMETHODCALLTYPE CreateVertexShader(
-        const void *pShaderBytecode,
-        SIZE_T BytecodeLength,
-        ID3D11ClassLinkage *pClassLinkage,
-        ID3D11VertexShader **ppVertexShader) = 0;
+    HRESULT (STDMETHODCALLTYPE *GetPrivateData)(
+        ID3D11AuthenticatedChannel* This,
+        REFGUID guid,
+        UINT *pDataSize,
+        void *pData);
 
-    virtual HRESULT STDMETHODCALLTYPE CreateGeometryShader(
-        const void *pShaderBytecode,
-        SIZE_T BytecodeLength,
-        ID3D11ClassLinkage *pClassLinkage,
-        ID3D11GeometryShader **ppGeometryShader) = 0;
+    HRESULT (STDMETHODCALLTYPE *SetPrivateData)(
+        ID3D11AuthenticatedChannel* This,
+        REFGUID guid,
+        UINT DataSize,
+        const void *pData);
 
-    virtual HRESULT STDMETHODCALLTYPE CreateGeometryShaderWithStreamOutput(
-        const void *pShaderBytecode,
-        SIZE_T BytecodeLength,
-        const D3D11_SO_DECLARATION_ENTRY *pSODeclaration,
-        UINT NumEntries,
-        const UINT *pBufferStrides,
-        UINT NumStrides,
-        UINT RasterizedStream,
-        ID3D11ClassLinkage *pClassLinkage,
-        ID3D11GeometryShader **ppGeometryShader) = 0;
+    HRESULT (STDMETHODCALLTYPE *SetPrivateDataInterface)(
+        ID3D11AuthenticatedChannel* This,
+        REFGUID guid,
+        const IUnknown *pData);
 
-    virtual HRESULT STDMETHODCALLTYPE CreatePixelShader(
-        const void *pShaderBytecode,
-        SIZE_T BytecodeLength,
-        ID3D11ClassLinkage *pClassLinkage,
-        ID3D11PixelShader **ppPixelShader) = 0;
+    /*** ID3D11AuthenticatedChannel methods ***/
+    HRESULT (STDMETHODCALLTYPE *GetCertificateSize)(
+        ID3D11AuthenticatedChannel* This,
+        UINT *pCertificateSize);
 
-    virtual HRESULT STDMETHODCALLTYPE CreateHullShader(
-        const void *pShaderBytecode,
-        SIZE_T BytecodeLength,
-        ID3D11ClassLinkage *pClassLinkage,
-        ID3D11HullShader **ppHullShader) = 0;
+    HRESULT (STDMETHODCALLTYPE *GetCertificate)(
+        ID3D11AuthenticatedChannel* This,
+        UINT CertificateSize,
+        BYTE *pCertificate);
 
-    virtual HRESULT STDMETHODCALLTYPE CreateDomainShader(
-        const void *pShaderBytecode,
-        SIZE_T BytecodeLength,
-        ID3D11ClassLinkage *pClassLinkage,
-        ID3D11DomainShader **ppDomainShader) = 0;
+    void (STDMETHODCALLTYPE *GetChannelHandle)(
+        ID3D11AuthenticatedChannel* This,
+        HANDLE *pChannelHandle);
 
-    virtual HRESULT STDMETHODCALLTYPE CreateComputeShader(
-        const void *pShaderBytecode,
-        SIZE_T BytecodeLength,
-        ID3D11ClassLinkage *pClassLinkage,
-        ID3D11ComputeShader **ppComputeShader) = 0;
+    END_INTERFACE
+} ID3D11AuthenticatedChannelVtbl;
+interface ID3D11AuthenticatedChannel {
+    CONST_VTBL ID3D11AuthenticatedChannelVtbl* lpVtbl;
+};
 
-    virtual HRESULT STDMETHODCALLTYPE CreateClassLinkage(
-        ID3D11ClassLinkage **ppLinkage) = 0;
+#ifdef COBJMACROS
+#ifndef WIDL_C_INLINE_WRAPPERS
+/*** IUnknown methods ***/
+#define ID3D11AuthenticatedChannel_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ID3D11AuthenticatedChannel_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ID3D11AuthenticatedChannel_Release(This) (This)->lpVtbl->Release(This)
+/*** ID3D11DeviceChild methods ***/
+#define ID3D11AuthenticatedChannel_GetDevice(This,ppDevice) (This)->lpVtbl->GetDevice(This,ppDevice)
+#define ID3D11AuthenticatedChannel_GetPrivateData(This,guid,pDataSize,pData) (This)->lpVtbl->GetPrivateData(This,guid,pDataSize,pData)
+#define ID3D11AuthenticatedChannel_SetPrivateData(This,guid,DataSize,pData) (This)->lpVtbl->SetPrivateData(This,guid,DataSize,pData)
+#define ID3D11AuthenticatedChannel_SetPrivateDataInterface(This,guid,pData) (This)->lpVtbl->SetPrivateDataInterface(This,guid,pData)
+/*** ID3D11AuthenticatedChannel methods ***/
+#define ID3D11AuthenticatedChannel_GetCertificateSize(This,pCertificateSize) (This)->lpVtbl->GetCertificateSize(This,pCertificateSize)
+#define ID3D11AuthenticatedChannel_GetCertificate(This,CertificateSize,pCertificate) (This)->lpVtbl->GetCertificate(This,CertificateSize,pCertificate)
+#define ID3D11AuthenticatedChannel_GetChannelHandle(This,pChannelHandle) (This)->lpVtbl->GetChannelHandle(This,pChannelHandle)
+#else
+/*** IUnknown methods ***/
+static FORCEINLINE HRESULT ID3D11AuthenticatedChannel_QueryInterface(ID3D11AuthenticatedChannel* This,REFIID riid,void **ppvObject) {
+    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
+}
+static FORCEINLINE ULONG ID3D11AuthenticatedChannel_AddRef(ID3D11AuthenticatedChannel* This) {
+    return This->lpVtbl->AddRef(This);
+}
+static FORCEINLINE ULONG ID3D11AuthenticatedChannel_Release(ID3D11AuthenticatedChannel* This) {
+    return This->lpVtbl->Release(This);
+}
+/*** ID3D11DeviceChild methods ***/
+static FORCEINLINE void ID3D11AuthenticatedChannel_GetDevice(ID3D11AuthenticatedChannel* This,ID3D11Device **ppDevice) {
+    This->lpVtbl->GetDevice(This,ppDevice);
+}
+static FORCEINLINE HRESULT ID3D11AuthenticatedChannel_GetPrivateData(ID3D11AuthenticatedChannel* This,REFGUID guid,UINT *pDataSize,void *pData) {
+    return This->lpVtbl->GetPrivateData(This,guid,pDataSize,pData);
+}
+static FORCEINLINE HRESULT ID3D11AuthenticatedChannel_SetPrivateData(ID3D11AuthenticatedChannel* This,REFGUID guid,UINT DataSize,const void *pData) {
+    return This->lpVtbl->SetPrivateData(This,guid,DataSize,pData);
+}
+static FORCEINLINE HRESULT ID3D11AuthenticatedChannel_SetPrivateDataInterface(ID3D11AuthenticatedChannel* This,REFGUID guid,const IUnknown *pData) {
+    return This->lpVtbl->SetPrivateDataInterface(This,guid,pData);
+}
+/*** ID3D11AuthenticatedChannel methods ***/
+static FORCEINLINE HRESULT ID3D11AuthenticatedChannel_GetCertificateSize(ID3D11AuthenticatedChannel* This,UINT *pCertificateSize) {
+    return This->lpVtbl->GetCertificateSize(This,pCertificateSize);
+}
+static FORCEINLINE HRESULT ID3D11AuthenticatedChannel_GetCertificate(ID3D11AuthenticatedChannel* This,UINT CertificateSize,BYTE *pCertificate) {
+    return This->lpVtbl->GetCertificate(This,CertificateSize,pCertificate);
+}
+static FORCEINLINE void ID3D11AuthenticatedChannel_GetChannelHandle(ID3D11AuthenticatedChannel* This,HANDLE *pChannelHandle) {
+    This->lpVtbl->GetChannelHandle(This,pChannelHandle);
+}
+#endif
+#endif
 
-    virtual HRESULT STDMETHODCALLTYPE CreateBlendState(
-        const D3D11_BLEND_DESC *pBlendStateDesc,
-        ID3D11BlendState **ppBlendState) = 0;
+#endif
 
-    virtual HRESULT STDMETHODCALLTYPE CreateDepthStencilState(
-        const D3D11_DEPTH_STENCIL_DESC *pDepthStencilDesc,
-        ID3D11DepthStencilState **ppDepthStencilState) = 0;
+HRESULT STDMETHODCALLTYPE ID3D11AuthenticatedChannel_GetCertificateSize_Proxy(
+    ID3D11AuthenticatedChannel* This,
+    UINT *pCertificateSize);
+void __RPC_STUB ID3D11AuthenticatedChannel_GetCertificateSize_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11AuthenticatedChannel_GetCertificate_Proxy(
+    ID3D11AuthenticatedChannel* This,
+    UINT CertificateSize,
+    BYTE *pCertificate);
+void __RPC_STUB ID3D11AuthenticatedChannel_GetCertificate_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void STDMETHODCALLTYPE ID3D11AuthenticatedChannel_GetChannelHandle_Proxy(
+    ID3D11AuthenticatedChannel* This,
+    HANDLE *pChannelHandle);
+void __RPC_STUB ID3D11AuthenticatedChannel_GetChannelHandle_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
 
-    virtual HRESULT STDMETHODCALLTYPE CreateRasterizerState(
-        const D3D11_RASTERIZER_DESC *pRasterizerDesc,
-        ID3D11RasterizerState **ppRasterizerState) = 0;
+#endif  /* __ID3D11AuthenticatedChannel_INTERFACE_DEFINED__ */
 
-    virtual HRESULT STDMETHODCALLTYPE CreateSamplerState(
-        const D3D11_SAMPLER_DESC *pSamplerDesc,
-        ID3D11SamplerState **ppSamplerState) = 0;
+/*****************************************************************************
+ * ID3D11CryptoSession interface
+ */
+#ifndef __ID3D11CryptoSession_INTERFACE_DEFINED__
+#define __ID3D11CryptoSession_INTERFACE_DEFINED__
 
-    virtual HRESULT STDMETHODCALLTYPE CreateQuery(
-        const D3D11_QUERY_DESC *pQueryDesc,
-        ID3D11Query **ppQuery) = 0;
+DEFINE_GUID(IID_ID3D11CryptoSession, 0x9b32f9ad, 0xbdcc, 0x40a6, 0xa3,0x9d, 0xd5,0xc8,0x65,0x84,0x57,0x20);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+MIDL_INTERFACE("9b32f9ad-bdcc-40a6-a39d-d5c865845720")
+ID3D11CryptoSession : public ID3D11DeviceChild
+{
+    virtual void STDMETHODCALLTYPE GetCryptoType(
+        GUID *pCryptoType) = 0;
 
-    virtual HRESULT STDMETHODCALLTYPE CreatePredicate(
-        const D3D11_QUERY_DESC *pPredicateDesc,
-        ID3D11Predicate **ppPredicate) = 0;
+    virtual void STDMETHODCALLTYPE GetDecoderProfile(
+        GUID *pDecoderProfile) = 0;
 
-    virtual HRESULT STDMETHODCALLTYPE CreateCounter(
-        const D3D11_COUNTER_DESC *pCounterDesc,
-        ID3D11Counter **ppCounter) = 0;
+    virtual HRESULT STDMETHODCALLTYPE GetCertificateSize(
+        UINT *pCertificateSize) = 0;
 
-    virtual HRESULT STDMETHODCALLTYPE CreateDeferredContext(
-        UINT ContextFlags,
-        ID3D11DeviceContext **ppDeferredContext) = 0;
+    virtual HRESULT STDMETHODCALLTYPE GetCertificate(
+        UINT CertificateSize,
+        BYTE *pCertificate) = 0;
 
-    virtual HRESULT STDMETHODCALLTYPE OpenSharedResource(
-        HANDLE hResource,
-        REFIID ReturnedInterface,
-        void **ppResource) = 0;
+    virtual void STDMETHODCALLTYPE GetCryptoSessionHandle(
+        HANDLE *pCryptoSessionHandle) = 0;
 
-    virtual HRESULT STDMETHODCALLTYPE CheckFormatSupport(
-        DXGI_FORMAT Format,
-        UINT *pFormatSupport) = 0;
+};
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(ID3D11CryptoSession, 0x9b32f9ad, 0xbdcc, 0x40a6, 0xa3,0x9d, 0xd5,0xc8,0x65,0x84,0x57,0x20)
+#endif
+#else
+typedef struct ID3D11CryptoSessionVtbl {
+    BEGIN_INTERFACE
 
-    virtual HRESULT STDMETHODCALLTYPE CheckMultisampleQualityLevels(
-        DXGI_FORMAT Format,
-        UINT SampleCount,
-        UINT *pNumQualityLevels) = 0;
+    /*** IUnknown methods ***/
+    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+        ID3D11CryptoSession* This,
+        REFIID riid,
+        void **ppvObject);
 
-    virtual void STDMETHODCALLTYPE CheckCounterInfo(
-        D3D11_COUNTER_INFO *pCounterInfo) = 0;
+    ULONG (STDMETHODCALLTYPE *AddRef)(
+        ID3D11CryptoSession* This);
 
-    virtual HRESULT STDMETHODCALLTYPE CheckCounter(
-        const D3D11_COUNTER_DESC *pDesc,
-        D3D11_COUNTER_TYPE *pType,
-        UINT *pActiveCounters,
-        LPSTR szName,
-        UINT *pNameLength,
-        LPSTR szUnits,
-        UINT *pUnitsLength,
-        LPSTR szDescription,
-        UINT *pDescriptionLength) = 0;
+    ULONG (STDMETHODCALLTYPE *Release)(
+        ID3D11CryptoSession* This);
 
-    virtual HRESULT STDMETHODCALLTYPE CheckFeatureSupport(
-        D3D11_FEATURE Feature,
-        void *pFeatureSupportData,
-        UINT FeatureSupportDataSize) = 0;
+    /*** ID3D11DeviceChild methods ***/
+    void (STDMETHODCALLTYPE *GetDevice)(
+        ID3D11CryptoSession* This,
+        ID3D11Device **ppDevice);
 
-    virtual HRESULT STDMETHODCALLTYPE GetPrivateData(
+    HRESULT (STDMETHODCALLTYPE *GetPrivateData)(
+        ID3D11CryptoSession* This,
         REFGUID guid,
         UINT *pDataSize,
-        void *pData) = 0;
+        void *pData);
 
-    virtual HRESULT STDMETHODCALLTYPE SetPrivateData(
+    HRESULT (STDMETHODCALLTYPE *SetPrivateData)(
+        ID3D11CryptoSession* This,
+        REFGUID guid,
+        UINT DataSize,
+        const void *pData);
+
+    HRESULT (STDMETHODCALLTYPE *SetPrivateDataInterface)(
+        ID3D11CryptoSession* This,
+        REFGUID guid,
+        const IUnknown *pData);
+
+    /*** ID3D11CryptoSession methods ***/
+    void (STDMETHODCALLTYPE *GetCryptoType)(
+        ID3D11CryptoSession* This,
+        GUID *pCryptoType);
+
+    void (STDMETHODCALLTYPE *GetDecoderProfile)(
+        ID3D11CryptoSession* This,
+        GUID *pDecoderProfile);
+
+    HRESULT (STDMETHODCALLTYPE *GetCertificateSize)(
+        ID3D11CryptoSession* This,
+        UINT *pCertificateSize);
+
+    HRESULT (STDMETHODCALLTYPE *GetCertificate)(
+        ID3D11CryptoSession* This,
+        UINT CertificateSize,
+        BYTE *pCertificate);
+
+    void (STDMETHODCALLTYPE *GetCryptoSessionHandle)(
+        ID3D11CryptoSession* This,
+        HANDLE *pCryptoSessionHandle);
+
+    END_INTERFACE
+} ID3D11CryptoSessionVtbl;
+interface ID3D11CryptoSession {
+    CONST_VTBL ID3D11CryptoSessionVtbl* lpVtbl;
+};
+
+#ifdef COBJMACROS
+#ifndef WIDL_C_INLINE_WRAPPERS
+/*** IUnknown methods ***/
+#define ID3D11CryptoSession_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ID3D11CryptoSession_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ID3D11CryptoSession_Release(This) (This)->lpVtbl->Release(This)
+/*** ID3D11DeviceChild methods ***/
+#define ID3D11CryptoSession_GetDevice(This,ppDevice) (This)->lpVtbl->GetDevice(This,ppDevice)
+#define ID3D11CryptoSession_GetPrivateData(This,guid,pDataSize,pData) (This)->lpVtbl->GetPrivateData(This,guid,pDataSize,pData)
+#define ID3D11CryptoSession_SetPrivateData(This,guid,DataSize,pData) (This)->lpVtbl->SetPrivateData(This,guid,DataSize,pData)
+#define ID3D11CryptoSession_SetPrivateDataInterface(This,guid,pData) (This)->lpVtbl->SetPrivateDataInterface(This,guid,pData)
+/*** ID3D11CryptoSession methods ***/
+#define ID3D11CryptoSession_GetCryptoType(This,pCryptoType) (This)->lpVtbl->GetCryptoType(This,pCryptoType)
+#define ID3D11CryptoSession_GetDecoderProfile(This,pDecoderProfile) (This)->lpVtbl->GetDecoderProfile(This,pDecoderProfile)
+#define ID3D11CryptoSession_GetCertificateSize(This,pCertificateSize) (This)->lpVtbl->GetCertificateSize(This,pCertificateSize)
+#define ID3D11CryptoSession_GetCertificate(This,CertificateSize,pCertificate) (This)->lpVtbl->GetCertificate(This,CertificateSize,pCertificate)
+#define ID3D11CryptoSession_GetCryptoSessionHandle(This,pCryptoSessionHandle) (This)->lpVtbl->GetCryptoSessionHandle(This,pCryptoSessionHandle)
+#else
+/*** IUnknown methods ***/
+static FORCEINLINE HRESULT ID3D11CryptoSession_QueryInterface(ID3D11CryptoSession* This,REFIID riid,void **ppvObject) {
+    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
+}
+static FORCEINLINE ULONG ID3D11CryptoSession_AddRef(ID3D11CryptoSession* This) {
+    return This->lpVtbl->AddRef(This);
+}
+static FORCEINLINE ULONG ID3D11CryptoSession_Release(ID3D11CryptoSession* This) {
+    return This->lpVtbl->Release(This);
+}
+/*** ID3D11DeviceChild methods ***/
+static FORCEINLINE void ID3D11CryptoSession_GetDevice(ID3D11CryptoSession* This,ID3D11Device **ppDevice) {
+    This->lpVtbl->GetDevice(This,ppDevice);
+}
+static FORCEINLINE HRESULT ID3D11CryptoSession_GetPrivateData(ID3D11CryptoSession* This,REFGUID guid,UINT *pDataSize,void *pData) {
+    return This->lpVtbl->GetPrivateData(This,guid,pDataSize,pData);
+}
+static FORCEINLINE HRESULT ID3D11CryptoSession_SetPrivateData(ID3D11CryptoSession* This,REFGUID guid,UINT DataSize,const void *pData) {
+    return This->lpVtbl->SetPrivateData(This,guid,DataSize,pData);
+}
+static FORCEINLINE HRESULT ID3D11CryptoSession_SetPrivateDataInterface(ID3D11CryptoSession* This,REFGUID guid,const IUnknown *pData) {
+    return This->lpVtbl->SetPrivateDataInterface(This,guid,pData);
+}
+/*** ID3D11CryptoSession methods ***/
+static FORCEINLINE void ID3D11CryptoSession_GetCryptoType(ID3D11CryptoSession* This,GUID *pCryptoType) {
+    This->lpVtbl->GetCryptoType(This,pCryptoType);
+}
+static FORCEINLINE void ID3D11CryptoSession_GetDecoderProfile(ID3D11CryptoSession* This,GUID *pDecoderProfile) {
+    This->lpVtbl->GetDecoderProfile(This,pDecoderProfile);
+}
+static FORCEINLINE HRESULT ID3D11CryptoSession_GetCertificateSize(ID3D11CryptoSession* This,UINT *pCertificateSize) {
+    return This->lpVtbl->GetCertificateSize(This,pCertificateSize);
+}
+static FORCEINLINE HRESULT ID3D11CryptoSession_GetCertificate(ID3D11CryptoSession* This,UINT CertificateSize,BYTE *pCertificate) {
+    return This->lpVtbl->GetCertificate(This,CertificateSize,pCertificate);
+}
+static FORCEINLINE void ID3D11CryptoSession_GetCryptoSessionHandle(ID3D11CryptoSession* This,HANDLE *pCryptoSessionHandle) {
+    This->lpVtbl->GetCryptoSessionHandle(This,pCryptoSessionHandle);
+}
+#endif
+#endif
+
+#endif
+
+void STDMETHODCALLTYPE ID3D11CryptoSession_GetCryptoType_Proxy(
+    ID3D11CryptoSession* This,
+    GUID *pCryptoType);
+void __RPC_STUB ID3D11CryptoSession_GetCryptoType_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void STDMETHODCALLTYPE ID3D11CryptoSession_GetDecoderProfile_Proxy(
+    ID3D11CryptoSession* This,
+    GUID *pDecoderProfile);
+void __RPC_STUB ID3D11CryptoSession_GetDecoderProfile_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11CryptoSession_GetCertificateSize_Proxy(
+    ID3D11CryptoSession* This,
+    UINT *pCertificateSize);
+void __RPC_STUB ID3D11CryptoSession_GetCertificateSize_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11CryptoSession_GetCertificate_Proxy(
+    ID3D11CryptoSession* This,
+    UINT CertificateSize,
+    BYTE *pCertificate);
+void __RPC_STUB ID3D11CryptoSession_GetCertificate_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void STDMETHODCALLTYPE ID3D11CryptoSession_GetCryptoSessionHandle_Proxy(
+    ID3D11CryptoSession* This,
+    HANDLE *pCryptoSessionHandle);
+void __RPC_STUB ID3D11CryptoSession_GetCryptoSessionHandle_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+#endif  /* __ID3D11CryptoSession_INTERFACE_DEFINED__ */
+
+/*****************************************************************************
+ * ID3D11VideoDecoder interface
+ */
+#ifndef __ID3D11VideoDecoder_INTERFACE_DEFINED__
+#define __ID3D11VideoDecoder_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_ID3D11VideoDecoder, 0x3c9c5b51, 0x995d, 0x48d1, 0x9b,0x8d, 0xfa,0x5c,0xae,0xde,0xd6,0x5c);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+MIDL_INTERFACE("3c9c5b51-995d-48d1-9b8d-fa5caeded65c")
+ID3D11VideoDecoder : public ID3D11DeviceChild
+{
+    virtual HRESULT STDMETHODCALLTYPE GetCreationParameters(
+        D3D11_VIDEO_DECODER_DESC *pVideoDesc,
+        D3D11_VIDEO_DECODER_CONFIG *pConfig) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE GetDriverHandle(
+        HANDLE *pDriverHandle) = 0;
+
+};
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(ID3D11VideoDecoder, 0x3c9c5b51, 0x995d, 0x48d1, 0x9b,0x8d, 0xfa,0x5c,0xae,0xde,0xd6,0x5c)
+#endif
+#else
+typedef struct ID3D11VideoDecoderVtbl {
+    BEGIN_INTERFACE
+
+    /*** IUnknown methods ***/
+    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+        ID3D11VideoDecoder* This,
+        REFIID riid,
+        void **ppvObject);
+
+    ULONG (STDMETHODCALLTYPE *AddRef)(
+        ID3D11VideoDecoder* This);
+
+    ULONG (STDMETHODCALLTYPE *Release)(
+        ID3D11VideoDecoder* This);
+
+    /*** ID3D11DeviceChild methods ***/
+    void (STDMETHODCALLTYPE *GetDevice)(
+        ID3D11VideoDecoder* This,
+        ID3D11Device **ppDevice);
+
+    HRESULT (STDMETHODCALLTYPE *GetPrivateData)(
+        ID3D11VideoDecoder* This,
+        REFGUID guid,
+        UINT *pDataSize,
+        void *pData);
+
+    HRESULT (STDMETHODCALLTYPE *SetPrivateData)(
+        ID3D11VideoDecoder* This,
+        REFGUID guid,
+        UINT DataSize,
+        const void *pData);
+
+    HRESULT (STDMETHODCALLTYPE *SetPrivateDataInterface)(
+        ID3D11VideoDecoder* This,
+        REFGUID guid,
+        const IUnknown *pData);
+
+    /*** ID3D11VideoDecoder methods ***/
+    HRESULT (STDMETHODCALLTYPE *GetCreationParameters)(
+        ID3D11VideoDecoder* This,
+        D3D11_VIDEO_DECODER_DESC *pVideoDesc,
+        D3D11_VIDEO_DECODER_CONFIG *pConfig);
+
+    HRESULT (STDMETHODCALLTYPE *GetDriverHandle)(
+        ID3D11VideoDecoder* This,
+        HANDLE *pDriverHandle);
+
+    END_INTERFACE
+} ID3D11VideoDecoderVtbl;
+interface ID3D11VideoDecoder {
+    CONST_VTBL ID3D11VideoDecoderVtbl* lpVtbl;
+};
+
+#ifdef COBJMACROS
+#ifndef WIDL_C_INLINE_WRAPPERS
+/*** IUnknown methods ***/
+#define ID3D11VideoDecoder_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ID3D11VideoDecoder_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ID3D11VideoDecoder_Release(This) (This)->lpVtbl->Release(This)
+/*** ID3D11DeviceChild methods ***/
+#define ID3D11VideoDecoder_GetDevice(This,ppDevice) (This)->lpVtbl->GetDevice(This,ppDevice)
+#define ID3D11VideoDecoder_GetPrivateData(This,guid,pDataSize,pData) (This)->lpVtbl->GetPrivateData(This,guid,pDataSize,pData)
+#define ID3D11VideoDecoder_SetPrivateData(This,guid,DataSize,pData) (This)->lpVtbl->SetPrivateData(This,guid,DataSize,pData)
+#define ID3D11VideoDecoder_SetPrivateDataInterface(This,guid,pData) (This)->lpVtbl->SetPrivateDataInterface(This,guid,pData)
+/*** ID3D11VideoDecoder methods ***/
+#define ID3D11VideoDecoder_GetCreationParameters(This,pVideoDesc,pConfig) (This)->lpVtbl->GetCreationParameters(This,pVideoDesc,pConfig)
+#define ID3D11VideoDecoder_GetDriverHandle(This,pDriverHandle) (This)->lpVtbl->GetDriverHandle(This,pDriverHandle)
+#else
+/*** IUnknown methods ***/
+static FORCEINLINE HRESULT ID3D11VideoDecoder_QueryInterface(ID3D11VideoDecoder* This,REFIID riid,void **ppvObject) {
+    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
+}
+static FORCEINLINE ULONG ID3D11VideoDecoder_AddRef(ID3D11VideoDecoder* This) {
+    return This->lpVtbl->AddRef(This);
+}
+static FORCEINLINE ULONG ID3D11VideoDecoder_Release(ID3D11VideoDecoder* This) {
+    return This->lpVtbl->Release(This);
+}
+/*** ID3D11DeviceChild methods ***/
+static FORCEINLINE void ID3D11VideoDecoder_GetDevice(ID3D11VideoDecoder* This,ID3D11Device **ppDevice) {
+    This->lpVtbl->GetDevice(This,ppDevice);
+}
+static FORCEINLINE HRESULT ID3D11VideoDecoder_GetPrivateData(ID3D11VideoDecoder* This,REFGUID guid,UINT *pDataSize,void *pData) {
+    return This->lpVtbl->GetPrivateData(This,guid,pDataSize,pData);
+}
+static FORCEINLINE HRESULT ID3D11VideoDecoder_SetPrivateData(ID3D11VideoDecoder* This,REFGUID guid,UINT DataSize,const void *pData) {
+    return This->lpVtbl->SetPrivateData(This,guid,DataSize,pData);
+}
+static FORCEINLINE HRESULT ID3D11VideoDecoder_SetPrivateDataInterface(ID3D11VideoDecoder* This,REFGUID guid,const IUnknown *pData) {
+    return This->lpVtbl->SetPrivateDataInterface(This,guid,pData);
+}
+/*** ID3D11VideoDecoder methods ***/
+static FORCEINLINE HRESULT ID3D11VideoDecoder_GetCreationParameters(ID3D11VideoDecoder* This,D3D11_VIDEO_DECODER_DESC *pVideoDesc,D3D11_VIDEO_DECODER_CONFIG *pConfig) {
+    return This->lpVtbl->GetCreationParameters(This,pVideoDesc,pConfig);
+}
+static FORCEINLINE HRESULT ID3D11VideoDecoder_GetDriverHandle(ID3D11VideoDecoder* This,HANDLE *pDriverHandle) {
+    return This->lpVtbl->GetDriverHandle(This,pDriverHandle);
+}
+#endif
+#endif
+
+#endif
+
+HRESULT STDMETHODCALLTYPE ID3D11VideoDecoder_GetCreationParameters_Proxy(
+    ID3D11VideoDecoder* This,
+    D3D11_VIDEO_DECODER_DESC *pVideoDesc,
+    D3D11_VIDEO_DECODER_CONFIG *pConfig);
+void __RPC_STUB ID3D11VideoDecoder_GetCreationParameters_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoDecoder_GetDriverHandle_Proxy(
+    ID3D11VideoDecoder* This,
+    HANDLE *pDriverHandle);
+void __RPC_STUB ID3D11VideoDecoder_GetDriverHandle_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+#endif  /* __ID3D11VideoDecoder_INTERFACE_DEFINED__ */
+
+/*****************************************************************************
+ * ID3D11VideoProcessorEnumerator interface
+ */
+#ifndef __ID3D11VideoProcessorEnumerator_INTERFACE_DEFINED__
+#define __ID3D11VideoProcessorEnumerator_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_ID3D11VideoProcessorEnumerator, 0x31627037, 0x53ab, 0x4200, 0x90,0x61, 0x05,0xfa,0xa9,0xab,0x45,0xf9);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+MIDL_INTERFACE("31627037-53ab-4200-9061-05faa9ab45f9")
+ID3D11VideoProcessorEnumerator : public ID3D11DeviceChild
+{
+    virtual HRESULT STDMETHODCALLTYPE GetVideoProcessorContentDesc(
+        D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pContentDesc) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CheckVideoProcessorFormat(
+        DXGI_FORMAT Format,
+        UINT *pFlags) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE GetVideoProcessorCaps(
+        D3D11_VIDEO_PROCESSOR_CAPS *pCaps) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE GetVideoProcessorRateConversionCaps(
+        UINT TypeIndex,
+        D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS *pCaps) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE GetVideoProcessorCustomRate(
+        UINT TypeIndex,
+        UINT CustomRateIndex,
+        D3D11_VIDEO_PROCESSOR_CUSTOM_RATE *pRate) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE GetVideoProcessorFilterRange(
+        D3D11_VIDEO_PROCESSOR_FILTER Filter,
+        D3D11_VIDEO_PROCESSOR_FILTER_RANGE *pRange) = 0;
+
+};
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(ID3D11VideoProcessorEnumerator, 0x31627037, 0x53ab, 0x4200, 0x90,0x61, 0x05,0xfa,0xa9,0xab,0x45,0xf9)
+#endif
+#else
+typedef struct ID3D11VideoProcessorEnumeratorVtbl {
+    BEGIN_INTERFACE
+
+    /*** IUnknown methods ***/
+    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+        ID3D11VideoProcessorEnumerator* This,
+        REFIID riid,
+        void **ppvObject);
+
+    ULONG (STDMETHODCALLTYPE *AddRef)(
+        ID3D11VideoProcessorEnumerator* This);
+
+    ULONG (STDMETHODCALLTYPE *Release)(
+        ID3D11VideoProcessorEnumerator* This);
+
+    /*** ID3D11DeviceChild methods ***/
+    void (STDMETHODCALLTYPE *GetDevice)(
+        ID3D11VideoProcessorEnumerator* This,
+        ID3D11Device **ppDevice);
+
+    HRESULT (STDMETHODCALLTYPE *GetPrivateData)(
+        ID3D11VideoProcessorEnumerator* This,
+        REFGUID guid,
+        UINT *pDataSize,
+        void *pData);
+
+    HRESULT (STDMETHODCALLTYPE *SetPrivateData)(
+        ID3D11VideoProcessorEnumerator* This,
+        REFGUID guid,
+        UINT DataSize,
+        const void *pData);
+
+    HRESULT (STDMETHODCALLTYPE *SetPrivateDataInterface)(
+        ID3D11VideoProcessorEnumerator* This,
+        REFGUID guid,
+        const IUnknown *pData);
+
+    /*** ID3D11VideoProcessorEnumerator methods ***/
+    HRESULT (STDMETHODCALLTYPE *GetVideoProcessorContentDesc)(
+        ID3D11VideoProcessorEnumerator* This,
+        D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pContentDesc);
+
+    HRESULT (STDMETHODCALLTYPE *CheckVideoProcessorFormat)(
+        ID3D11VideoProcessorEnumerator* This,
+        DXGI_FORMAT Format,
+        UINT *pFlags);
+
+    HRESULT (STDMETHODCALLTYPE *GetVideoProcessorCaps)(
+        ID3D11VideoProcessorEnumerator* This,
+        D3D11_VIDEO_PROCESSOR_CAPS *pCaps);
+
+    HRESULT (STDMETHODCALLTYPE *GetVideoProcessorRateConversionCaps)(
+        ID3D11VideoProcessorEnumerator* This,
+        UINT TypeIndex,
+        D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS *pCaps);
+
+    HRESULT (STDMETHODCALLTYPE *GetVideoProcessorCustomRate)(
+        ID3D11VideoProcessorEnumerator* This,
+        UINT TypeIndex,
+        UINT CustomRateIndex,
+        D3D11_VIDEO_PROCESSOR_CUSTOM_RATE *pRate);
+
+    HRESULT (STDMETHODCALLTYPE *GetVideoProcessorFilterRange)(
+        ID3D11VideoProcessorEnumerator* This,
+        D3D11_VIDEO_PROCESSOR_FILTER Filter,
+        D3D11_VIDEO_PROCESSOR_FILTER_RANGE *pRange);
+
+    END_INTERFACE
+} ID3D11VideoProcessorEnumeratorVtbl;
+interface ID3D11VideoProcessorEnumerator {
+    CONST_VTBL ID3D11VideoProcessorEnumeratorVtbl* lpVtbl;
+};
+
+#ifdef COBJMACROS
+#ifndef WIDL_C_INLINE_WRAPPERS
+/*** IUnknown methods ***/
+#define ID3D11VideoProcessorEnumerator_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ID3D11VideoProcessorEnumerator_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ID3D11VideoProcessorEnumerator_Release(This) (This)->lpVtbl->Release(This)
+/*** ID3D11DeviceChild methods ***/
+#define ID3D11VideoProcessorEnumerator_GetDevice(This,ppDevice) (This)->lpVtbl->GetDevice(This,ppDevice)
+#define ID3D11VideoProcessorEnumerator_GetPrivateData(This,guid,pDataSize,pData) (This)->lpVtbl->GetPrivateData(This,guid,pDataSize,pData)
+#define ID3D11VideoProcessorEnumerator_SetPrivateData(This,guid,DataSize,pData) (This)->lpVtbl->SetPrivateData(This,guid,DataSize,pData)
+#define ID3D11VideoProcessorEnumerator_SetPrivateDataInterface(This,guid,pData) (This)->lpVtbl->SetPrivateDataInterface(This,guid,pData)
+/*** ID3D11VideoProcessorEnumerator methods ***/
+#define ID3D11VideoProcessorEnumerator_GetVideoProcessorContentDesc(This,pContentDesc) (This)->lpVtbl->GetVideoProcessorContentDesc(This,pContentDesc)
+#define ID3D11VideoProcessorEnumerator_CheckVideoProcessorFormat(This,Format,pFlags) (This)->lpVtbl->CheckVideoProcessorFormat(This,Format,pFlags)
+#define ID3D11VideoProcessorEnumerator_GetVideoProcessorCaps(This,pCaps) (This)->lpVtbl->GetVideoProcessorCaps(This,pCaps)
+#define ID3D11VideoProcessorEnumerator_GetVideoProcessorRateConversionCaps(This,TypeIndex,pCaps) (This)->lpVtbl->GetVideoProcessorRateConversionCaps(This,TypeIndex,pCaps)
+#define ID3D11VideoProcessorEnumerator_GetVideoProcessorCustomRate(This,TypeIndex,CustomRateIndex,pRate) (This)->lpVtbl->GetVideoProcessorCustomRate(This,TypeIndex,CustomRateIndex,pRate)
+#define ID3D11VideoProcessorEnumerator_GetVideoProcessorFilterRange(This,Filter,pRange) (This)->lpVtbl->GetVideoProcessorFilterRange(This,Filter,pRange)
+#else
+/*** IUnknown methods ***/
+static FORCEINLINE HRESULT ID3D11VideoProcessorEnumerator_QueryInterface(ID3D11VideoProcessorEnumerator* This,REFIID riid,void **ppvObject) {
+    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
+}
+static FORCEINLINE ULONG ID3D11VideoProcessorEnumerator_AddRef(ID3D11VideoProcessorEnumerator* This) {
+    return This->lpVtbl->AddRef(This);
+}
+static FORCEINLINE ULONG ID3D11VideoProcessorEnumerator_Release(ID3D11VideoProcessorEnumerator* This) {
+    return This->lpVtbl->Release(This);
+}
+/*** ID3D11DeviceChild methods ***/
+static FORCEINLINE void ID3D11VideoProcessorEnumerator_GetDevice(ID3D11VideoProcessorEnumerator* This,ID3D11Device **ppDevice) {
+    This->lpVtbl->GetDevice(This,ppDevice);
+}
+static FORCEINLINE HRESULT ID3D11VideoProcessorEnumerator_GetPrivateData(ID3D11VideoProcessorEnumerator* This,REFGUID guid,UINT *pDataSize,void *pData) {
+    return This->lpVtbl->GetPrivateData(This,guid,pDataSize,pData);
+}
+static FORCEINLINE HRESULT ID3D11VideoProcessorEnumerator_SetPrivateData(ID3D11VideoProcessorEnumerator* This,REFGUID guid,UINT DataSize,const void *pData) {
+    return This->lpVtbl->SetPrivateData(This,guid,DataSize,pData);
+}
+static FORCEINLINE HRESULT ID3D11VideoProcessorEnumerator_SetPrivateDataInterface(ID3D11VideoProcessorEnumerator* This,REFGUID guid,const IUnknown *pData) {
+    return This->lpVtbl->SetPrivateDataInterface(This,guid,pData);
+}
+/*** ID3D11VideoProcessorEnumerator methods ***/
+static FORCEINLINE HRESULT ID3D11VideoProcessorEnumerator_GetVideoProcessorContentDesc(ID3D11VideoProcessorEnumerator* This,D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pContentDesc) {
+    return This->lpVtbl->GetVideoProcessorContentDesc(This,pContentDesc);
+}
+static FORCEINLINE HRESULT ID3D11VideoProcessorEnumerator_CheckVideoProcessorFormat(ID3D11VideoProcessorEnumerator* This,DXGI_FORMAT Format,UINT *pFlags) {
+    return This->lpVtbl->CheckVideoProcessorFormat(This,Format,pFlags);
+}
+static FORCEINLINE HRESULT ID3D11VideoProcessorEnumerator_GetVideoProcessorCaps(ID3D11VideoProcessorEnumerator* This,D3D11_VIDEO_PROCESSOR_CAPS *pCaps) {
+    return This->lpVtbl->GetVideoProcessorCaps(This,pCaps);
+}
+static FORCEINLINE HRESULT ID3D11VideoProcessorEnumerator_GetVideoProcessorRateConversionCaps(ID3D11VideoProcessorEnumerator* This,UINT TypeIndex,D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS *pCaps) {
+    return This->lpVtbl->GetVideoProcessorRateConversionCaps(This,TypeIndex,pCaps);
+}
+static FORCEINLINE HRESULT ID3D11VideoProcessorEnumerator_GetVideoProcessorCustomRate(ID3D11VideoProcessorEnumerator* This,UINT TypeIndex,UINT CustomRateIndex,D3D11_VIDEO_PROCESSOR_CUSTOM_RATE *pRate) {
+    return This->lpVtbl->GetVideoProcessorCustomRate(This,TypeIndex,CustomRateIndex,pRate);
+}
+static FORCEINLINE HRESULT ID3D11VideoProcessorEnumerator_GetVideoProcessorFilterRange(ID3D11VideoProcessorEnumerator* This,D3D11_VIDEO_PROCESSOR_FILTER Filter,D3D11_VIDEO_PROCESSOR_FILTER_RANGE *pRange) {
+    return This->lpVtbl->GetVideoProcessorFilterRange(This,Filter,pRange);
+}
+#endif
+#endif
+
+#endif
+
+HRESULT STDMETHODCALLTYPE ID3D11VideoProcessorEnumerator_GetVideoProcessorContentDesc_Proxy(
+    ID3D11VideoProcessorEnumerator* This,
+    D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pContentDesc);
+void __RPC_STUB ID3D11VideoProcessorEnumerator_GetVideoProcessorContentDesc_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoProcessorEnumerator_CheckVideoProcessorFormat_Proxy(
+    ID3D11VideoProcessorEnumerator* This,
+    DXGI_FORMAT Format,
+    UINT *pFlags);
+void __RPC_STUB ID3D11VideoProcessorEnumerator_CheckVideoProcessorFormat_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoProcessorEnumerator_GetVideoProcessorCaps_Proxy(
+    ID3D11VideoProcessorEnumerator* This,
+    D3D11_VIDEO_PROCESSOR_CAPS *pCaps);
+void __RPC_STUB ID3D11VideoProcessorEnumerator_GetVideoProcessorCaps_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoProcessorEnumerator_GetVideoProcessorRateConversionCaps_Proxy(
+    ID3D11VideoProcessorEnumerator* This,
+    UINT TypeIndex,
+    D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS *pCaps);
+void __RPC_STUB ID3D11VideoProcessorEnumerator_GetVideoProcessorRateConversionCaps_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoProcessorEnumerator_GetVideoProcessorCustomRate_Proxy(
+    ID3D11VideoProcessorEnumerator* This,
+    UINT TypeIndex,
+    UINT CustomRateIndex,
+    D3D11_VIDEO_PROCESSOR_CUSTOM_RATE *pRate);
+void __RPC_STUB ID3D11VideoProcessorEnumerator_GetVideoProcessorCustomRate_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoProcessorEnumerator_GetVideoProcessorFilterRange_Proxy(
+    ID3D11VideoProcessorEnumerator* This,
+    D3D11_VIDEO_PROCESSOR_FILTER Filter,
+    D3D11_VIDEO_PROCESSOR_FILTER_RANGE *pRange);
+void __RPC_STUB ID3D11VideoProcessorEnumerator_GetVideoProcessorFilterRange_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+#endif  /* __ID3D11VideoProcessorEnumerator_INTERFACE_DEFINED__ */
+
+/*****************************************************************************
+ * ID3D11VideoProcessor interface
+ */
+#ifndef __ID3D11VideoProcessor_INTERFACE_DEFINED__
+#define __ID3D11VideoProcessor_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_ID3D11VideoProcessor, 0x1d7b0652, 0x185f, 0x41c6, 0x85,0xce, 0x0c,0x5b,0xe3,0xd4,0xae,0x6c);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+MIDL_INTERFACE("1d7b0652-185f-41c6-85ce-0c5be3d4ae6c")
+ID3D11VideoProcessor : public ID3D11DeviceChild
+{
+    virtual void STDMETHODCALLTYPE GetContentDesc(
+        D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pDesc) = 0;
+
+    virtual void STDMETHODCALLTYPE GetRateConversionCaps(
+        D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS *pCaps) = 0;
+
+};
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(ID3D11VideoProcessor, 0x1d7b0652, 0x185f, 0x41c6, 0x85,0xce, 0x0c,0x5b,0xe3,0xd4,0xae,0x6c)
+#endif
+#else
+typedef struct ID3D11VideoProcessorVtbl {
+    BEGIN_INTERFACE
+
+    /*** IUnknown methods ***/
+    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+        ID3D11VideoProcessor* This,
+        REFIID riid,
+        void **ppvObject);
+
+    ULONG (STDMETHODCALLTYPE *AddRef)(
+        ID3D11VideoProcessor* This);
+
+    ULONG (STDMETHODCALLTYPE *Release)(
+        ID3D11VideoProcessor* This);
+
+    /*** ID3D11DeviceChild methods ***/
+    void (STDMETHODCALLTYPE *GetDevice)(
+        ID3D11VideoProcessor* This,
+        ID3D11Device **ppDevice);
+
+    HRESULT (STDMETHODCALLTYPE *GetPrivateData)(
+        ID3D11VideoProcessor* This,
+        REFGUID guid,
+        UINT *pDataSize,
+        void *pData);
+
+    HRESULT (STDMETHODCALLTYPE *SetPrivateData)(
+        ID3D11VideoProcessor* This,
+        REFGUID guid,
+        UINT DataSize,
+        const void *pData);
+
+    HRESULT (STDMETHODCALLTYPE *SetPrivateDataInterface)(
+        ID3D11VideoProcessor* This,
+        REFGUID guid,
+        const IUnknown *pData);
+
+    /*** ID3D11VideoProcessor methods ***/
+    void (STDMETHODCALLTYPE *GetContentDesc)(
+        ID3D11VideoProcessor* This,
+        D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pDesc);
+
+    void (STDMETHODCALLTYPE *GetRateConversionCaps)(
+        ID3D11VideoProcessor* This,
+        D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS *pCaps);
+
+    END_INTERFACE
+} ID3D11VideoProcessorVtbl;
+interface ID3D11VideoProcessor {
+    CONST_VTBL ID3D11VideoProcessorVtbl* lpVtbl;
+};
+
+#ifdef COBJMACROS
+#ifndef WIDL_C_INLINE_WRAPPERS
+/*** IUnknown methods ***/
+#define ID3D11VideoProcessor_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ID3D11VideoProcessor_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ID3D11VideoProcessor_Release(This) (This)->lpVtbl->Release(This)
+/*** ID3D11DeviceChild methods ***/
+#define ID3D11VideoProcessor_GetDevice(This,ppDevice) (This)->lpVtbl->GetDevice(This,ppDevice)
+#define ID3D11VideoProcessor_GetPrivateData(This,guid,pDataSize,pData) (This)->lpVtbl->GetPrivateData(This,guid,pDataSize,pData)
+#define ID3D11VideoProcessor_SetPrivateData(This,guid,DataSize,pData) (This)->lpVtbl->SetPrivateData(This,guid,DataSize,pData)
+#define ID3D11VideoProcessor_SetPrivateDataInterface(This,guid,pData) (This)->lpVtbl->SetPrivateDataInterface(This,guid,pData)
+/*** ID3D11VideoProcessor methods ***/
+#define ID3D11VideoProcessor_GetContentDesc(This,pDesc) (This)->lpVtbl->GetContentDesc(This,pDesc)
+#define ID3D11VideoProcessor_GetRateConversionCaps(This,pCaps) (This)->lpVtbl->GetRateConversionCaps(This,pCaps)
+#else
+/*** IUnknown methods ***/
+static FORCEINLINE HRESULT ID3D11VideoProcessor_QueryInterface(ID3D11VideoProcessor* This,REFIID riid,void **ppvObject) {
+    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
+}
+static FORCEINLINE ULONG ID3D11VideoProcessor_AddRef(ID3D11VideoProcessor* This) {
+    return This->lpVtbl->AddRef(This);
+}
+static FORCEINLINE ULONG ID3D11VideoProcessor_Release(ID3D11VideoProcessor* This) {
+    return This->lpVtbl->Release(This);
+}
+/*** ID3D11DeviceChild methods ***/
+static FORCEINLINE void ID3D11VideoProcessor_GetDevice(ID3D11VideoProcessor* This,ID3D11Device **ppDevice) {
+    This->lpVtbl->GetDevice(This,ppDevice);
+}
+static FORCEINLINE HRESULT ID3D11VideoProcessor_GetPrivateData(ID3D11VideoProcessor* This,REFGUID guid,UINT *pDataSize,void *pData) {
+    return This->lpVtbl->GetPrivateData(This,guid,pDataSize,pData);
+}
+static FORCEINLINE HRESULT ID3D11VideoProcessor_SetPrivateData(ID3D11VideoProcessor* This,REFGUID guid,UINT DataSize,const void *pData) {
+    return This->lpVtbl->SetPrivateData(This,guid,DataSize,pData);
+}
+static FORCEINLINE HRESULT ID3D11VideoProcessor_SetPrivateDataInterface(ID3D11VideoProcessor* This,REFGUID guid,const IUnknown *pData) {
+    return This->lpVtbl->SetPrivateDataInterface(This,guid,pData);
+}
+/*** ID3D11VideoProcessor methods ***/
+static FORCEINLINE void ID3D11VideoProcessor_GetContentDesc(ID3D11VideoProcessor* This,D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pDesc) {
+    This->lpVtbl->GetContentDesc(This,pDesc);
+}
+static FORCEINLINE void ID3D11VideoProcessor_GetRateConversionCaps(ID3D11VideoProcessor* This,D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS *pCaps) {
+    This->lpVtbl->GetRateConversionCaps(This,pCaps);
+}
+#endif
+#endif
+
+#endif
+
+void STDMETHODCALLTYPE ID3D11VideoProcessor_GetContentDesc_Proxy(
+    ID3D11VideoProcessor* This,
+    D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pDesc);
+void __RPC_STUB ID3D11VideoProcessor_GetContentDesc_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+void STDMETHODCALLTYPE ID3D11VideoProcessor_GetRateConversionCaps_Proxy(
+    ID3D11VideoProcessor* This,
+    D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS *pCaps);
+void __RPC_STUB ID3D11VideoProcessor_GetRateConversionCaps_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+#endif  /* __ID3D11VideoProcessor_INTERFACE_DEFINED__ */
+
+/*****************************************************************************
+ * ID3D11VideoDecoderOutputView interface
+ */
+#ifndef __ID3D11VideoDecoderOutputView_INTERFACE_DEFINED__
+#define __ID3D11VideoDecoderOutputView_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_ID3D11VideoDecoderOutputView, 0xc2931aea, 0x2a85, 0x4f20, 0x86,0x0f, 0xfb,0xa1,0xfd,0x25,0x6e,0x18);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+MIDL_INTERFACE("c2931aea-2a85-4f20-860f-fba1fd256e18")
+ID3D11VideoDecoderOutputView : public ID3D11View
+{
+    virtual void STDMETHODCALLTYPE GetDesc(
+        D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC *pDesc) = 0;
+
+};
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(ID3D11VideoDecoderOutputView, 0xc2931aea, 0x2a85, 0x4f20, 0x86,0x0f, 0xfb,0xa1,0xfd,0x25,0x6e,0x18)
+#endif
+#else
+typedef struct ID3D11VideoDecoderOutputViewVtbl {
+    BEGIN_INTERFACE
+
+    /*** IUnknown methods ***/
+    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+        ID3D11VideoDecoderOutputView* This,
+        REFIID riid,
+        void **ppvObject);
+
+    ULONG (STDMETHODCALLTYPE *AddRef)(
+        ID3D11VideoDecoderOutputView* This);
+
+    ULONG (STDMETHODCALLTYPE *Release)(
+        ID3D11VideoDecoderOutputView* This);
+
+    /*** ID3D11DeviceChild methods ***/
+    void (STDMETHODCALLTYPE *GetDevice)(
+        ID3D11VideoDecoderOutputView* This,
+        ID3D11Device **ppDevice);
+
+    HRESULT (STDMETHODCALLTYPE *GetPrivateData)(
+        ID3D11VideoDecoderOutputView* This,
+        REFGUID guid,
+        UINT *pDataSize,
+        void *pData);
+
+    HRESULT (STDMETHODCALLTYPE *SetPrivateData)(
+        ID3D11VideoDecoderOutputView* This,
+        REFGUID guid,
+        UINT DataSize,
+        const void *pData);
+
+    HRESULT (STDMETHODCALLTYPE *SetPrivateDataInterface)(
+        ID3D11VideoDecoderOutputView* This,
+        REFGUID guid,
+        const IUnknown *pData);
+
+    /*** ID3D11View methods ***/
+    void (STDMETHODCALLTYPE *GetResource)(
+        ID3D11VideoDecoderOutputView* This,
+        ID3D11Resource **ppResource);
+
+    /*** ID3D11VideoDecoderOutputView methods ***/
+    void (STDMETHODCALLTYPE *GetDesc)(
+        ID3D11VideoDecoderOutputView* This,
+        D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC *pDesc);
+
+    END_INTERFACE
+} ID3D11VideoDecoderOutputViewVtbl;
+interface ID3D11VideoDecoderOutputView {
+    CONST_VTBL ID3D11VideoDecoderOutputViewVtbl* lpVtbl;
+};
+
+#ifdef COBJMACROS
+#ifndef WIDL_C_INLINE_WRAPPERS
+/*** IUnknown methods ***/
+#define ID3D11VideoDecoderOutputView_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ID3D11VideoDecoderOutputView_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ID3D11VideoDecoderOutputView_Release(This) (This)->lpVtbl->Release(This)
+/*** ID3D11DeviceChild methods ***/
+#define ID3D11VideoDecoderOutputView_GetDevice(This,ppDevice) (This)->lpVtbl->GetDevice(This,ppDevice)
+#define ID3D11VideoDecoderOutputView_GetPrivateData(This,guid,pDataSize,pData) (This)->lpVtbl->GetPrivateData(This,guid,pDataSize,pData)
+#define ID3D11VideoDecoderOutputView_SetPrivateData(This,guid,DataSize,pData) (This)->lpVtbl->SetPrivateData(This,guid,DataSize,pData)
+#define ID3D11VideoDecoderOutputView_SetPrivateDataInterface(This,guid,pData) (This)->lpVtbl->SetPrivateDataInterface(This,guid,pData)
+/*** ID3D11View methods ***/
+#define ID3D11VideoDecoderOutputView_GetResource(This,ppResource) (This)->lpVtbl->GetResource(This,ppResource)
+/*** ID3D11VideoDecoderOutputView methods ***/
+#define ID3D11VideoDecoderOutputView_GetDesc(This,pDesc) (This)->lpVtbl->GetDesc(This,pDesc)
+#else
+/*** IUnknown methods ***/
+static FORCEINLINE HRESULT ID3D11VideoDecoderOutputView_QueryInterface(ID3D11VideoDecoderOutputView* This,REFIID riid,void **ppvObject) {
+    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
+}
+static FORCEINLINE ULONG ID3D11VideoDecoderOutputView_AddRef(ID3D11VideoDecoderOutputView* This) {
+    return This->lpVtbl->AddRef(This);
+}
+static FORCEINLINE ULONG ID3D11VideoDecoderOutputView_Release(ID3D11VideoDecoderOutputView* This) {
+    return This->lpVtbl->Release(This);
+}
+/*** ID3D11DeviceChild methods ***/
+static FORCEINLINE void ID3D11VideoDecoderOutputView_GetDevice(ID3D11VideoDecoderOutputView* This,ID3D11Device **ppDevice) {
+    This->lpVtbl->GetDevice(This,ppDevice);
+}
+static FORCEINLINE HRESULT ID3D11VideoDecoderOutputView_GetPrivateData(ID3D11VideoDecoderOutputView* This,REFGUID guid,UINT *pDataSize,void *pData) {
+    return This->lpVtbl->GetPrivateData(This,guid,pDataSize,pData);
+}
+static FORCEINLINE HRESULT ID3D11VideoDecoderOutputView_SetPrivateData(ID3D11VideoDecoderOutputView* This,REFGUID guid,UINT DataSize,const void *pData) {
+    return This->lpVtbl->SetPrivateData(This,guid,DataSize,pData);
+}
+static FORCEINLINE HRESULT ID3D11VideoDecoderOutputView_SetPrivateDataInterface(ID3D11VideoDecoderOutputView* This,REFGUID guid,const IUnknown *pData) {
+    return This->lpVtbl->SetPrivateDataInterface(This,guid,pData);
+}
+/*** ID3D11View methods ***/
+static FORCEINLINE void ID3D11VideoDecoderOutputView_GetResource(ID3D11VideoDecoderOutputView* This,ID3D11Resource **ppResource) {
+    This->lpVtbl->GetResource(This,ppResource);
+}
+/*** ID3D11VideoDecoderOutputView methods ***/
+static FORCEINLINE void ID3D11VideoDecoderOutputView_GetDesc(ID3D11VideoDecoderOutputView* This,D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC *pDesc) {
+    This->lpVtbl->GetDesc(This,pDesc);
+}
+#endif
+#endif
+
+#endif
+
+void STDMETHODCALLTYPE ID3D11VideoDecoderOutputView_GetDesc_Proxy(
+    ID3D11VideoDecoderOutputView* This,
+    D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC *pDesc);
+void __RPC_STUB ID3D11VideoDecoderOutputView_GetDesc_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+#endif  /* __ID3D11VideoDecoderOutputView_INTERFACE_DEFINED__ */
+
+/*****************************************************************************
+ * ID3D11VideoProcessorInputView interface
+ */
+#ifndef __ID3D11VideoProcessorInputView_INTERFACE_DEFINED__
+#define __ID3D11VideoProcessorInputView_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_ID3D11VideoProcessorInputView, 0x11ec5a5f, 0x51dc, 0x4945, 0xab,0x34, 0x6e,0x8c,0x21,0x30,0x0e,0xa5);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+MIDL_INTERFACE("11ec5a5f-51dc-4945-ab34-6e8c21300ea5")
+ID3D11VideoProcessorInputView : public ID3D11View
+{
+    virtual void STDMETHODCALLTYPE GetDesc(
+        D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC *pDesc) = 0;
+
+};
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(ID3D11VideoProcessorInputView, 0x11ec5a5f, 0x51dc, 0x4945, 0xab,0x34, 0x6e,0x8c,0x21,0x30,0x0e,0xa5)
+#endif
+#else
+typedef struct ID3D11VideoProcessorInputViewVtbl {
+    BEGIN_INTERFACE
+
+    /*** IUnknown methods ***/
+    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+        ID3D11VideoProcessorInputView* This,
+        REFIID riid,
+        void **ppvObject);
+
+    ULONG (STDMETHODCALLTYPE *AddRef)(
+        ID3D11VideoProcessorInputView* This);
+
+    ULONG (STDMETHODCALLTYPE *Release)(
+        ID3D11VideoProcessorInputView* This);
+
+    /*** ID3D11DeviceChild methods ***/
+    void (STDMETHODCALLTYPE *GetDevice)(
+        ID3D11VideoProcessorInputView* This,
+        ID3D11Device **ppDevice);
+
+    HRESULT (STDMETHODCALLTYPE *GetPrivateData)(
+        ID3D11VideoProcessorInputView* This,
+        REFGUID guid,
+        UINT *pDataSize,
+        void *pData);
+
+    HRESULT (STDMETHODCALLTYPE *SetPrivateData)(
+        ID3D11VideoProcessorInputView* This,
+        REFGUID guid,
+        UINT DataSize,
+        const void *pData);
+
+    HRESULT (STDMETHODCALLTYPE *SetPrivateDataInterface)(
+        ID3D11VideoProcessorInputView* This,
+        REFGUID guid,
+        const IUnknown *pData);
+
+    /*** ID3D11View methods ***/
+    void (STDMETHODCALLTYPE *GetResource)(
+        ID3D11VideoProcessorInputView* This,
+        ID3D11Resource **ppResource);
+
+    /*** ID3D11VideoProcessorInputView methods ***/
+    void (STDMETHODCALLTYPE *GetDesc)(
+        ID3D11VideoProcessorInputView* This,
+        D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC *pDesc);
+
+    END_INTERFACE
+} ID3D11VideoProcessorInputViewVtbl;
+interface ID3D11VideoProcessorInputView {
+    CONST_VTBL ID3D11VideoProcessorInputViewVtbl* lpVtbl;
+};
+
+#ifdef COBJMACROS
+#ifndef WIDL_C_INLINE_WRAPPERS
+/*** IUnknown methods ***/
+#define ID3D11VideoProcessorInputView_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ID3D11VideoProcessorInputView_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ID3D11VideoProcessorInputView_Release(This) (This)->lpVtbl->Release(This)
+/*** ID3D11DeviceChild methods ***/
+#define ID3D11VideoProcessorInputView_GetDevice(This,ppDevice) (This)->lpVtbl->GetDevice(This,ppDevice)
+#define ID3D11VideoProcessorInputView_GetPrivateData(This,guid,pDataSize,pData) (This)->lpVtbl->GetPrivateData(This,guid,pDataSize,pData)
+#define ID3D11VideoProcessorInputView_SetPrivateData(This,guid,DataSize,pData) (This)->lpVtbl->SetPrivateData(This,guid,DataSize,pData)
+#define ID3D11VideoProcessorInputView_SetPrivateDataInterface(This,guid,pData) (This)->lpVtbl->SetPrivateDataInterface(This,guid,pData)
+/*** ID3D11View methods ***/
+#define ID3D11VideoProcessorInputView_GetResource(This,ppResource) (This)->lpVtbl->GetResource(This,ppResource)
+/*** ID3D11VideoProcessorInputView methods ***/
+#define ID3D11VideoProcessorInputView_GetDesc(This,pDesc) (This)->lpVtbl->GetDesc(This,pDesc)
+#else
+/*** IUnknown methods ***/
+static FORCEINLINE HRESULT ID3D11VideoProcessorInputView_QueryInterface(ID3D11VideoProcessorInputView* This,REFIID riid,void **ppvObject) {
+    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
+}
+static FORCEINLINE ULONG ID3D11VideoProcessorInputView_AddRef(ID3D11VideoProcessorInputView* This) {
+    return This->lpVtbl->AddRef(This);
+}
+static FORCEINLINE ULONG ID3D11VideoProcessorInputView_Release(ID3D11VideoProcessorInputView* This) {
+    return This->lpVtbl->Release(This);
+}
+/*** ID3D11DeviceChild methods ***/
+static FORCEINLINE void ID3D11VideoProcessorInputView_GetDevice(ID3D11VideoProcessorInputView* This,ID3D11Device **ppDevice) {
+    This->lpVtbl->GetDevice(This,ppDevice);
+}
+static FORCEINLINE HRESULT ID3D11VideoProcessorInputView_GetPrivateData(ID3D11VideoProcessorInputView* This,REFGUID guid,UINT *pDataSize,void *pData) {
+    return This->lpVtbl->GetPrivateData(This,guid,pDataSize,pData);
+}
+static FORCEINLINE HRESULT ID3D11VideoProcessorInputView_SetPrivateData(ID3D11VideoProcessorInputView* This,REFGUID guid,UINT DataSize,const void *pData) {
+    return This->lpVtbl->SetPrivateData(This,guid,DataSize,pData);
+}
+static FORCEINLINE HRESULT ID3D11VideoProcessorInputView_SetPrivateDataInterface(ID3D11VideoProcessorInputView* This,REFGUID guid,const IUnknown *pData) {
+    return This->lpVtbl->SetPrivateDataInterface(This,guid,pData);
+}
+/*** ID3D11View methods ***/
+static FORCEINLINE void ID3D11VideoProcessorInputView_GetResource(ID3D11VideoProcessorInputView* This,ID3D11Resource **ppResource) {
+    This->lpVtbl->GetResource(This,ppResource);
+}
+/*** ID3D11VideoProcessorInputView methods ***/
+static FORCEINLINE void ID3D11VideoProcessorInputView_GetDesc(ID3D11VideoProcessorInputView* This,D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC *pDesc) {
+    This->lpVtbl->GetDesc(This,pDesc);
+}
+#endif
+#endif
+
+#endif
+
+void STDMETHODCALLTYPE ID3D11VideoProcessorInputView_GetDesc_Proxy(
+    ID3D11VideoProcessorInputView* This,
+    D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC *pDesc);
+void __RPC_STUB ID3D11VideoProcessorInputView_GetDesc_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+#endif  /* __ID3D11VideoProcessorInputView_INTERFACE_DEFINED__ */
+
+/*****************************************************************************
+ * ID3D11VideoProcessorOutputView interface
+ */
+#ifndef __ID3D11VideoProcessorOutputView_INTERFACE_DEFINED__
+#define __ID3D11VideoProcessorOutputView_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_ID3D11VideoProcessorOutputView, 0xa048285e, 0x25a9, 0x4527, 0xbd,0x93, 0xd6,0x8b,0x68,0xc4,0x42,0x54);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+MIDL_INTERFACE("a048285e-25a9-4527-bd93-d68b68c44254")
+ID3D11VideoProcessorOutputView : public ID3D11View
+{
+    virtual void STDMETHODCALLTYPE GetDesc(
+        D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC *pDesc) = 0;
+
+};
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(ID3D11VideoProcessorOutputView, 0xa048285e, 0x25a9, 0x4527, 0xbd,0x93, 0xd6,0x8b,0x68,0xc4,0x42,0x54)
+#endif
+#else
+typedef struct ID3D11VideoProcessorOutputViewVtbl {
+    BEGIN_INTERFACE
+
+    /*** IUnknown methods ***/
+    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+        ID3D11VideoProcessorOutputView* This,
+        REFIID riid,
+        void **ppvObject);
+
+    ULONG (STDMETHODCALLTYPE *AddRef)(
+        ID3D11VideoProcessorOutputView* This);
+
+    ULONG (STDMETHODCALLTYPE *Release)(
+        ID3D11VideoProcessorOutputView* This);
+
+    /*** ID3D11DeviceChild methods ***/
+    void (STDMETHODCALLTYPE *GetDevice)(
+        ID3D11VideoProcessorOutputView* This,
+        ID3D11Device **ppDevice);
+
+    HRESULT (STDMETHODCALLTYPE *GetPrivateData)(
+        ID3D11VideoProcessorOutputView* This,
+        REFGUID guid,
+        UINT *pDataSize,
+        void *pData);
+
+    HRESULT (STDMETHODCALLTYPE *SetPrivateData)(
+        ID3D11VideoProcessorOutputView* This,
+        REFGUID guid,
+        UINT DataSize,
+        const void *pData);
+
+    HRESULT (STDMETHODCALLTYPE *SetPrivateDataInterface)(
+        ID3D11VideoProcessorOutputView* This,
+        REFGUID guid,
+        const IUnknown *pData);
+
+    /*** ID3D11View methods ***/
+    void (STDMETHODCALLTYPE *GetResource)(
+        ID3D11VideoProcessorOutputView* This,
+        ID3D11Resource **ppResource);
+
+    /*** ID3D11VideoProcessorOutputView methods ***/
+    void (STDMETHODCALLTYPE *GetDesc)(
+        ID3D11VideoProcessorOutputView* This,
+        D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC *pDesc);
+
+    END_INTERFACE
+} ID3D11VideoProcessorOutputViewVtbl;
+interface ID3D11VideoProcessorOutputView {
+    CONST_VTBL ID3D11VideoProcessorOutputViewVtbl* lpVtbl;
+};
+
+#ifdef COBJMACROS
+#ifndef WIDL_C_INLINE_WRAPPERS
+/*** IUnknown methods ***/
+#define ID3D11VideoProcessorOutputView_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ID3D11VideoProcessorOutputView_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ID3D11VideoProcessorOutputView_Release(This) (This)->lpVtbl->Release(This)
+/*** ID3D11DeviceChild methods ***/
+#define ID3D11VideoProcessorOutputView_GetDevice(This,ppDevice) (This)->lpVtbl->GetDevice(This,ppDevice)
+#define ID3D11VideoProcessorOutputView_GetPrivateData(This,guid,pDataSize,pData) (This)->lpVtbl->GetPrivateData(This,guid,pDataSize,pData)
+#define ID3D11VideoProcessorOutputView_SetPrivateData(This,guid,DataSize,pData) (This)->lpVtbl->SetPrivateData(This,guid,DataSize,pData)
+#define ID3D11VideoProcessorOutputView_SetPrivateDataInterface(This,guid,pData) (This)->lpVtbl->SetPrivateDataInterface(This,guid,pData)
+/*** ID3D11View methods ***/
+#define ID3D11VideoProcessorOutputView_GetResource(This,ppResource) (This)->lpVtbl->GetResource(This,ppResource)
+/*** ID3D11VideoProcessorOutputView methods ***/
+#define ID3D11VideoProcessorOutputView_GetDesc(This,pDesc) (This)->lpVtbl->GetDesc(This,pDesc)
+#else
+/*** IUnknown methods ***/
+static FORCEINLINE HRESULT ID3D11VideoProcessorOutputView_QueryInterface(ID3D11VideoProcessorOutputView* This,REFIID riid,void **ppvObject) {
+    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
+}
+static FORCEINLINE ULONG ID3D11VideoProcessorOutputView_AddRef(ID3D11VideoProcessorOutputView* This) {
+    return This->lpVtbl->AddRef(This);
+}
+static FORCEINLINE ULONG ID3D11VideoProcessorOutputView_Release(ID3D11VideoProcessorOutputView* This) {
+    return This->lpVtbl->Release(This);
+}
+/*** ID3D11DeviceChild methods ***/
+static FORCEINLINE void ID3D11VideoProcessorOutputView_GetDevice(ID3D11VideoProcessorOutputView* This,ID3D11Device **ppDevice) {
+    This->lpVtbl->GetDevice(This,ppDevice);
+}
+static FORCEINLINE HRESULT ID3D11VideoProcessorOutputView_GetPrivateData(ID3D11VideoProcessorOutputView* This,REFGUID guid,UINT *pDataSize,void *pData) {
+    return This->lpVtbl->GetPrivateData(This,guid,pDataSize,pData);
+}
+static FORCEINLINE HRESULT ID3D11VideoProcessorOutputView_SetPrivateData(ID3D11VideoProcessorOutputView* This,REFGUID guid,UINT DataSize,const void *pData) {
+    return This->lpVtbl->SetPrivateData(This,guid,DataSize,pData);
+}
+static FORCEINLINE HRESULT ID3D11VideoProcessorOutputView_SetPrivateDataInterface(ID3D11VideoProcessorOutputView* This,REFGUID guid,const IUnknown *pData) {
+    return This->lpVtbl->SetPrivateDataInterface(This,guid,pData);
+}
+/*** ID3D11View methods ***/
+static FORCEINLINE void ID3D11VideoProcessorOutputView_GetResource(ID3D11VideoProcessorOutputView* This,ID3D11Resource **ppResource) {
+    This->lpVtbl->GetResource(This,ppResource);
+}
+/*** ID3D11VideoProcessorOutputView methods ***/
+static FORCEINLINE void ID3D11VideoProcessorOutputView_GetDesc(ID3D11VideoProcessorOutputView* This,D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC *pDesc) {
+    This->lpVtbl->GetDesc(This,pDesc);
+}
+#endif
+#endif
+
+#endif
+
+void STDMETHODCALLTYPE ID3D11VideoProcessorOutputView_GetDesc_Proxy(
+    ID3D11VideoProcessorOutputView* This,
+    D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC *pDesc);
+void __RPC_STUB ID3D11VideoProcessorOutputView_GetDesc_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+#endif  /* __ID3D11VideoProcessorOutputView_INTERFACE_DEFINED__ */
+
+/*****************************************************************************
+ * ID3D11VideoDevice interface
+ */
+#ifndef __ID3D11VideoDevice_INTERFACE_DEFINED__
+#define __ID3D11VideoDevice_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_ID3D11VideoDevice, 0x10ec4d5b, 0x975a, 0x4689, 0xb9,0xe4, 0xd0,0xaa,0xc3,0x0f,0xe3,0x33);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+MIDL_INTERFACE("10ec4d5b-975a-4689-b9e4-d0aac30fe333")
+ID3D11VideoDevice : public IUnknown
+{
+    virtual HRESULT STDMETHODCALLTYPE CreateVideoDecoder(
+        const D3D11_VIDEO_DECODER_DESC *pVideoDesc,
+        const D3D11_VIDEO_DECODER_CONFIG *pConfig,
+        ID3D11VideoDecoder **ppDecoder) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateVideoProcessor(
+        ID3D11VideoProcessorEnumerator *pEnum,
+        UINT RateConversionIndex,
+        ID3D11VideoProcessor **ppVideoProcessor) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateAuthenticatedChannel(
+        D3D11_AUTHENTICATED_CHANNEL_TYPE ChannelType,
+        ID3D11AuthenticatedChannel **ppAuthenticatedChannel) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateCryptoSession(
+        const GUID *pCryptoType,
+        const GUID *pDecoderProfile,
+        const GUID *pKeyExchangeType,
+        ID3D11CryptoSession **ppCryptoSession) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateVideoDecoderOutputView(
+        ID3D11Resource *pResource,
+        const D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC *pDesc,
+        ID3D11VideoDecoderOutputView **ppVDOVView) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateVideoProcessorInputView(
+        ID3D11Resource *pResource,
+        ID3D11VideoProcessorEnumerator *pEnum,
+        const D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC *pDesc,
+        ID3D11VideoProcessorInputView **ppVPIView) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateVideoProcessorOutputView(
+        ID3D11Resource *pResource,
+        ID3D11VideoProcessorEnumerator *pEnum,
+        const D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC *pDesc,
+        ID3D11VideoProcessorOutputView **ppVPOView) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateVideoProcessorEnumerator(
+        const D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pDesc,
+        ID3D11VideoProcessorEnumerator **ppEnum) = 0;
+
+    virtual UINT STDMETHODCALLTYPE GetVideoDecoderProfileCount(
+        ) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE GetVideoDecoderProfile(
+        UINT Index,
+        GUID *pDecoderProfile) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CheckVideoDecoderFormat(
+        const GUID *pDecoderProfile,
+        DXGI_FORMAT Format,
+        WINBOOL *pSupported) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE GetVideoDecoderConfigCount(
+        const D3D11_VIDEO_DECODER_DESC *pDesc,
+        UINT *pCount) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE GetVideoDecoderConfig(
+        const D3D11_VIDEO_DECODER_DESC *pDesc,
+        UINT Index,
+        D3D11_VIDEO_DECODER_CONFIG *pConfig) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE GetContentProtectionCaps(
+        const GUID *pCryptoType,
+        const GUID *pDecoderProfile,
+        D3D11_VIDEO_CONTENT_PROTECTION_CAPS *pCaps) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CheckCryptoKeyExchange(
+        const GUID *pCryptoType,
+        const GUID *pDecoderProfile,
+        UINT Index,
+        GUID *pKeyExchangeType) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE SetPrivateData(
+        REFGUID guid,
+        UINT DataSize,
+        const void *pData) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE SetPrivateDataInterface(
+        REFGUID guid,
+        const IUnknown *pData) = 0;
+
+};
+#ifdef __CRT_UUID_DECL
+__CRT_UUID_DECL(ID3D11VideoDevice, 0x10ec4d5b, 0x975a, 0x4689, 0xb9,0xe4, 0xd0,0xaa,0xc3,0x0f,0xe3,0x33)
+#endif
+#else
+typedef struct ID3D11VideoDeviceVtbl {
+    BEGIN_INTERFACE
+
+    /*** IUnknown methods ***/
+    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+        ID3D11VideoDevice* This,
+        REFIID riid,
+        void **ppvObject);
+
+    ULONG (STDMETHODCALLTYPE *AddRef)(
+        ID3D11VideoDevice* This);
+
+    ULONG (STDMETHODCALLTYPE *Release)(
+        ID3D11VideoDevice* This);
+
+    /*** ID3D11VideoDevice methods ***/
+    HRESULT (STDMETHODCALLTYPE *CreateVideoDecoder)(
+        ID3D11VideoDevice* This,
+        const D3D11_VIDEO_DECODER_DESC *pVideoDesc,
+        const D3D11_VIDEO_DECODER_CONFIG *pConfig,
+        ID3D11VideoDecoder **ppDecoder);
+
+    HRESULT (STDMETHODCALLTYPE *CreateVideoProcessor)(
+        ID3D11VideoDevice* This,
+        ID3D11VideoProcessorEnumerator *pEnum,
+        UINT RateConversionIndex,
+        ID3D11VideoProcessor **ppVideoProcessor);
+
+    HRESULT (STDMETHODCALLTYPE *CreateAuthenticatedChannel)(
+        ID3D11VideoDevice* This,
+        D3D11_AUTHENTICATED_CHANNEL_TYPE ChannelType,
+        ID3D11AuthenticatedChannel **ppAuthenticatedChannel);
+
+    HRESULT (STDMETHODCALLTYPE *CreateCryptoSession)(
+        ID3D11VideoDevice* This,
+        const GUID *pCryptoType,
+        const GUID *pDecoderProfile,
+        const GUID *pKeyExchangeType,
+        ID3D11CryptoSession **ppCryptoSession);
+
+    HRESULT (STDMETHODCALLTYPE *CreateVideoDecoderOutputView)(
+        ID3D11VideoDevice* This,
+        ID3D11Resource *pResource,
+        const D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC *pDesc,
+        ID3D11VideoDecoderOutputView **ppVDOVView);
+
+    HRESULT (STDMETHODCALLTYPE *CreateVideoProcessorInputView)(
+        ID3D11VideoDevice* This,
+        ID3D11Resource *pResource,
+        ID3D11VideoProcessorEnumerator *pEnum,
+        const D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC *pDesc,
+        ID3D11VideoProcessorInputView **ppVPIView);
+
+    HRESULT (STDMETHODCALLTYPE *CreateVideoProcessorOutputView)(
+        ID3D11VideoDevice* This,
+        ID3D11Resource *pResource,
+        ID3D11VideoProcessorEnumerator *pEnum,
+        const D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC *pDesc,
+        ID3D11VideoProcessorOutputView **ppVPOView);
+
+    HRESULT (STDMETHODCALLTYPE *CreateVideoProcessorEnumerator)(
+        ID3D11VideoDevice* This,
+        const D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pDesc,
+        ID3D11VideoProcessorEnumerator **ppEnum);
+
+    UINT (STDMETHODCALLTYPE *GetVideoDecoderProfileCount)(
+        ID3D11VideoDevice* This);
+
+    HRESULT (STDMETHODCALLTYPE *GetVideoDecoderProfile)(
+        ID3D11VideoDevice* This,
+        UINT Index,
+        GUID *pDecoderProfile);
+
+    HRESULT (STDMETHODCALLTYPE *CheckVideoDecoderFormat)(
+        ID3D11VideoDevice* This,
+        const GUID *pDecoderProfile,
+        DXGI_FORMAT Format,
+        WINBOOL *pSupported);
+
+    HRESULT (STDMETHODCALLTYPE *GetVideoDecoderConfigCount)(
+        ID3D11VideoDevice* This,
+        const D3D11_VIDEO_DECODER_DESC *pDesc,
+        UINT *pCount);
+
+    HRESULT (STDMETHODCALLTYPE *GetVideoDecoderConfig)(
+        ID3D11VideoDevice* This,
+        const D3D11_VIDEO_DECODER_DESC *pDesc,
+        UINT Index,
+        D3D11_VIDEO_DECODER_CONFIG *pConfig);
+
+    HRESULT (STDMETHODCALLTYPE *GetContentProtectionCaps)(
+        ID3D11VideoDevice* This,
+        const GUID *pCryptoType,
+        const GUID *pDecoderProfile,
+        D3D11_VIDEO_CONTENT_PROTECTION_CAPS *pCaps);
+
+    HRESULT (STDMETHODCALLTYPE *CheckCryptoKeyExchange)(
+        ID3D11VideoDevice* This,
+        const GUID *pCryptoType,
+        const GUID *pDecoderProfile,
+        UINT Index,
+        GUID *pKeyExchangeType);
+
+    HRESULT (STDMETHODCALLTYPE *SetPrivateData)(
+        ID3D11VideoDevice* This,
+        REFGUID guid,
+        UINT DataSize,
+        const void *pData);
+
+    HRESULT (STDMETHODCALLTYPE *SetPrivateDataInterface)(
+        ID3D11VideoDevice* This,
+        REFGUID guid,
+        const IUnknown *pData);
+
+    END_INTERFACE
+} ID3D11VideoDeviceVtbl;
+interface ID3D11VideoDevice {
+    CONST_VTBL ID3D11VideoDeviceVtbl* lpVtbl;
+};
+
+#ifdef COBJMACROS
+#ifndef WIDL_C_INLINE_WRAPPERS
+/*** IUnknown methods ***/
+#define ID3D11VideoDevice_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ID3D11VideoDevice_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ID3D11VideoDevice_Release(This) (This)->lpVtbl->Release(This)
+/*** ID3D11VideoDevice methods ***/
+#define ID3D11VideoDevice_CreateVideoDecoder(This,pVideoDesc,pConfig,ppDecoder) (This)->lpVtbl->CreateVideoDecoder(This,pVideoDesc,pConfig,ppDecoder)
+#define ID3D11VideoDevice_CreateVideoProcessor(This,pEnum,RateConversionIndex,ppVideoProcessor) (This)->lpVtbl->CreateVideoProcessor(This,pEnum,RateConversionIndex,ppVideoProcessor)
+#define ID3D11VideoDevice_CreateAuthenticatedChannel(This,ChannelType,ppAuthenticatedChannel) (This)->lpVtbl->CreateAuthenticatedChannel(This,ChannelType,ppAuthenticatedChannel)
+#define ID3D11VideoDevice_CreateCryptoSession(This,pCryptoType,pDecoderProfile,pKeyExchangeType,ppCryptoSession) (This)->lpVtbl->CreateCryptoSession(This,pCryptoType,pDecoderProfile,pKeyExchangeType,ppCryptoSession)
+#define ID3D11VideoDevice_CreateVideoDecoderOutputView(This,pResource,pDesc,ppVDOVView) (This)->lpVtbl->CreateVideoDecoderOutputView(This,pResource,pDesc,ppVDOVView)
+#define ID3D11VideoDevice_CreateVideoProcessorInputView(This,pResource,pEnum,pDesc,ppVPIView) (This)->lpVtbl->CreateVideoProcessorInputView(This,pResource,pEnum,pDesc,ppVPIView)
+#define ID3D11VideoDevice_CreateVideoProcessorOutputView(This,pResource,pEnum,pDesc,ppVPOView) (This)->lpVtbl->CreateVideoProcessorOutputView(This,pResource,pEnum,pDesc,ppVPOView)
+#define ID3D11VideoDevice_CreateVideoProcessorEnumerator(This,pDesc,ppEnum) (This)->lpVtbl->CreateVideoProcessorEnumerator(This,pDesc,ppEnum)
+#define ID3D11VideoDevice_GetVideoDecoderProfileCount(This) (This)->lpVtbl->GetVideoDecoderProfileCount(This)
+#define ID3D11VideoDevice_GetVideoDecoderProfile(This,Index,pDecoderProfile) (This)->lpVtbl->GetVideoDecoderProfile(This,Index,pDecoderProfile)
+#define ID3D11VideoDevice_CheckVideoDecoderFormat(This,pDecoderProfile,Format,pSupported) (This)->lpVtbl->CheckVideoDecoderFormat(This,pDecoderProfile,Format,pSupported)
+#define ID3D11VideoDevice_GetVideoDecoderConfigCount(This,pDesc,pCount) (This)->lpVtbl->GetVideoDecoderConfigCount(This,pDesc,pCount)
+#define ID3D11VideoDevice_GetVideoDecoderConfig(This,pDesc,Index,pConfig) (This)->lpVtbl->GetVideoDecoderConfig(This,pDesc,Index,pConfig)
+#define ID3D11VideoDevice_GetContentProtectionCaps(This,pCryptoType,pDecoderProfile,pCaps) (This)->lpVtbl->GetContentProtectionCaps(This,pCryptoType,pDecoderProfile,pCaps)
+#define ID3D11VideoDevice_CheckCryptoKeyExchange(This,pCryptoType,pDecoderProfile,Index,pKeyExchangeType) (This)->lpVtbl->CheckCryptoKeyExchange(This,pCryptoType,pDecoderProfile,Index,pKeyExchangeType)
+#define ID3D11VideoDevice_SetPrivateData(This,guid,DataSize,pData) (This)->lpVtbl->SetPrivateData(This,guid,DataSize,pData)
+#define ID3D11VideoDevice_SetPrivateDataInterface(This,guid,pData) (This)->lpVtbl->SetPrivateDataInterface(This,guid,pData)
+#else
+/*** IUnknown methods ***/
+static FORCEINLINE HRESULT ID3D11VideoDevice_QueryInterface(ID3D11VideoDevice* This,REFIID riid,void **ppvObject) {
+    return This->lpVtbl->QueryInterface(This,riid,ppvObject);
+}
+static FORCEINLINE ULONG ID3D11VideoDevice_AddRef(ID3D11VideoDevice* This) {
+    return This->lpVtbl->AddRef(This);
+}
+static FORCEINLINE ULONG ID3D11VideoDevice_Release(ID3D11VideoDevice* This) {
+    return This->lpVtbl->Release(This);
+}
+/*** ID3D11VideoDevice methods ***/
+static FORCEINLINE HRESULT ID3D11VideoDevice_CreateVideoDecoder(ID3D11VideoDevice* This,const D3D11_VIDEO_DECODER_DESC *pVideoDesc,const D3D11_VIDEO_DECODER_CONFIG *pConfig,ID3D11VideoDecoder **ppDecoder) {
+    return This->lpVtbl->CreateVideoDecoder(This,pVideoDesc,pConfig,ppDecoder);
+}
+static FORCEINLINE HRESULT ID3D11VideoDevice_CreateVideoProcessor(ID3D11VideoDevice* This,ID3D11VideoProcessorEnumerator *pEnum,UINT RateConversionIndex,ID3D11VideoProcessor **ppVideoProcessor) {
+    return This->lpVtbl->CreateVideoProcessor(This,pEnum,RateConversionIndex,ppVideoProcessor);
+}
+static FORCEINLINE HRESULT ID3D11VideoDevice_CreateAuthenticatedChannel(ID3D11VideoDevice* This,D3D11_AUTHENTICATED_CHANNEL_TYPE ChannelType,ID3D11AuthenticatedChannel **ppAuthenticatedChannel) {
+    return This->lpVtbl->CreateAuthenticatedChannel(This,ChannelType,ppAuthenticatedChannel);
+}
+static FORCEINLINE HRESULT ID3D11VideoDevice_CreateCryptoSession(ID3D11VideoDevice* This,const GUID *pCryptoType,const GUID *pDecoderProfile,const GUID *pKeyExchangeType,ID3D11CryptoSession **ppCryptoSession) {
+    return This->lpVtbl->CreateCryptoSession(This,pCryptoType,pDecoderProfile,pKeyExchangeType,ppCryptoSession);
+}
+static FORCEINLINE HRESULT ID3D11VideoDevice_CreateVideoDecoderOutputView(ID3D11VideoDevice* This,ID3D11Resource *pResource,const D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC *pDesc,ID3D11VideoDecoderOutputView **ppVDOVView) {
+    return This->lpVtbl->CreateVideoDecoderOutputView(This,pResource,pDesc,ppVDOVView);
+}
+static FORCEINLINE HRESULT ID3D11VideoDevice_CreateVideoProcessorInputView(ID3D11VideoDevice* This,ID3D11Resource *pResource,ID3D11VideoProcessorEnumerator *pEnum,const D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC *pDesc,ID3D11VideoProcessorInputView **ppVPIView) {
+    return This->lpVtbl->CreateVideoProcessorInputView(This,pResource,pEnum,pDesc,ppVPIView);
+}
+static FORCEINLINE HRESULT ID3D11VideoDevice_CreateVideoProcessorOutputView(ID3D11VideoDevice* This,ID3D11Resource *pResource,ID3D11VideoProcessorEnumerator *pEnum,const D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC *pDesc,ID3D11VideoProcessorOutputView **ppVPOView) {
+    return This->lpVtbl->CreateVideoProcessorOutputView(This,pResource,pEnum,pDesc,ppVPOView);
+}
+static FORCEINLINE HRESULT ID3D11VideoDevice_CreateVideoProcessorEnumerator(ID3D11VideoDevice* This,const D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pDesc,ID3D11VideoProcessorEnumerator **ppEnum) {
+    return This->lpVtbl->CreateVideoProcessorEnumerator(This,pDesc,ppEnum);
+}
+static FORCEINLINE UINT ID3D11VideoDevice_GetVideoDecoderProfileCount(ID3D11VideoDevice* This) {
+    return This->lpVtbl->GetVideoDecoderProfileCount(This);
+}
+static FORCEINLINE HRESULT ID3D11VideoDevice_GetVideoDecoderProfile(ID3D11VideoDevice* This,UINT Index,GUID *pDecoderProfile) {
+    return This->lpVtbl->GetVideoDecoderProfile(This,Index,pDecoderProfile);
+}
+static FORCEINLINE HRESULT ID3D11VideoDevice_CheckVideoDecoderFormat(ID3D11VideoDevice* This,const GUID *pDecoderProfile,DXGI_FORMAT Format,WINBOOL *pSupported) {
+    return This->lpVtbl->CheckVideoDecoderFormat(This,pDecoderProfile,Format,pSupported);
+}
+static FORCEINLINE HRESULT ID3D11VideoDevice_GetVideoDecoderConfigCount(ID3D11VideoDevice* This,const D3D11_VIDEO_DECODER_DESC *pDesc,UINT *pCount) {
+    return This->lpVtbl->GetVideoDecoderConfigCount(This,pDesc,pCount);
+}
+static FORCEINLINE HRESULT ID3D11VideoDevice_GetVideoDecoderConfig(ID3D11VideoDevice* This,const D3D11_VIDEO_DECODER_DESC *pDesc,UINT Index,D3D11_VIDEO_DECODER_CONFIG *pConfig) {
+    return This->lpVtbl->GetVideoDecoderConfig(This,pDesc,Index,pConfig);
+}
+static FORCEINLINE HRESULT ID3D11VideoDevice_GetContentProtectionCaps(ID3D11VideoDevice* This,const GUID *pCryptoType,const GUID *pDecoderProfile,D3D11_VIDEO_CONTENT_PROTECTION_CAPS *pCaps) {
+    return This->lpVtbl->GetContentProtectionCaps(This,pCryptoType,pDecoderProfile,pCaps);
+}
+static FORCEINLINE HRESULT ID3D11VideoDevice_CheckCryptoKeyExchange(ID3D11VideoDevice* This,const GUID *pCryptoType,const GUID *pDecoderProfile,UINT Index,GUID *pKeyExchangeType) {
+    return This->lpVtbl->CheckCryptoKeyExchange(This,pCryptoType,pDecoderProfile,Index,pKeyExchangeType);
+}
+static FORCEINLINE HRESULT ID3D11VideoDevice_SetPrivateData(ID3D11VideoDevice* This,REFGUID guid,UINT DataSize,const void *pData) {
+    return This->lpVtbl->SetPrivateData(This,guid,DataSize,pData);
+}
+static FORCEINLINE HRESULT ID3D11VideoDevice_SetPrivateDataInterface(ID3D11VideoDevice* This,REFGUID guid,const IUnknown *pData) {
+    return This->lpVtbl->SetPrivateDataInterface(This,guid,pData);
+}
+#endif
+#endif
+
+#endif
+
+HRESULT STDMETHODCALLTYPE ID3D11VideoDevice_CreateVideoDecoder_Proxy(
+    ID3D11VideoDevice* This,
+    const D3D11_VIDEO_DECODER_DESC *pVideoDesc,
+    const D3D11_VIDEO_DECODER_CONFIG *pConfig,
+    ID3D11VideoDecoder **ppDecoder);
+void __RPC_STUB ID3D11VideoDevice_CreateVideoDecoder_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoDevice_CreateVideoProcessor_Proxy(
+    ID3D11VideoDevice* This,
+    ID3D11VideoProcessorEnumerator *pEnum,
+    UINT RateConversionIndex,
+    ID3D11VideoProcessor **ppVideoProcessor);
+void __RPC_STUB ID3D11VideoDevice_CreateVideoProcessor_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoDevice_CreateAuthenticatedChannel_Proxy(
+    ID3D11VideoDevice* This,
+    D3D11_AUTHENTICATED_CHANNEL_TYPE ChannelType,
+    ID3D11AuthenticatedChannel **ppAuthenticatedChannel);
+void __RPC_STUB ID3D11VideoDevice_CreateAuthenticatedChannel_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoDevice_CreateCryptoSession_Proxy(
+    ID3D11VideoDevice* This,
+    const GUID *pCryptoType,
+    const GUID *pDecoderProfile,
+    const GUID *pKeyExchangeType,
+    ID3D11CryptoSession **ppCryptoSession);
+void __RPC_STUB ID3D11VideoDevice_CreateCryptoSession_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoDevice_CreateVideoDecoderOutputView_Proxy(
+    ID3D11VideoDevice* This,
+    ID3D11Resource *pResource,
+    const D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC *pDesc,
+    ID3D11VideoDecoderOutputView **ppVDOVView);
+void __RPC_STUB ID3D11VideoDevice_CreateVideoDecoderOutputView_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoDevice_CreateVideoProcessorInputView_Proxy(
+    ID3D11VideoDevice* This,
+    ID3D11Resource *pResource,
+    ID3D11VideoProcessorEnumerator *pEnum,
+    const D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC *pDesc,
+    ID3D11VideoProcessorInputView **ppVPIView);
+void __RPC_STUB ID3D11VideoDevice_CreateVideoProcessorInputView_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoDevice_CreateVideoProcessorOutputView_Proxy(
+    ID3D11VideoDevice* This,
+    ID3D11Resource *pResource,
+    ID3D11VideoProcessorEnumerator *pEnum,
+    const D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC *pDesc,
+    ID3D11VideoProcessorOutputView **ppVPOView);
+void __RPC_STUB ID3D11VideoDevice_CreateVideoProcessorOutputView_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoDevice_CreateVideoProcessorEnumerator_Proxy(
+    ID3D11VideoDevice* This,
+    const D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pDesc,
+    ID3D11VideoProcessorEnumerator **ppEnum);
+void __RPC_STUB ID3D11VideoDevice_CreateVideoProcessorEnumerator_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+UINT STDMETHODCALLTYPE ID3D11VideoDevice_GetVideoDecoderProfileCount_Proxy(
+    ID3D11VideoDevice* This);
+void __RPC_STUB ID3D11VideoDevice_GetVideoDecoderProfileCount_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoDevice_GetVideoDecoderProfile_Proxy(
+    ID3D11VideoDevice* This,
+    UINT Index,
+    GUID *pDecoderProfile);
+void __RPC_STUB ID3D11VideoDevice_GetVideoDecoderProfile_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoDevice_CheckVideoDecoderFormat_Proxy(
+    ID3D11VideoDevice* This,
+    const GUID *pDecoderProfile,
+    DXGI_FORMAT Format,
+    WINBOOL *pSupported);
+void __RPC_STUB ID3D11VideoDevice_CheckVideoDecoderFormat_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoDevice_GetVideoDecoderConfigCount_Proxy(
+    ID3D11VideoDevice* This,
+    const D3D11_VIDEO_DECODER_DESC *pDesc,
+    UINT *pCount);
+void __RPC_STUB ID3D11VideoDevice_GetVideoDecoderConfigCount_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoDevice_GetVideoDecoderConfig_Proxy(
+    ID3D11VideoDevice* This,
+    const D3D11_VIDEO_DECODER_DESC *pDesc,
+    UINT Index,
+    D3D11_VIDEO_DECODER_CONFIG *pConfig);
+void __RPC_STUB ID3D11VideoDevice_GetVideoDecoderConfig_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoDevice_GetContentProtectionCaps_Proxy(
+    ID3D11VideoDevice* This,
+    const GUID *pCryptoType,
+    const GUID *pDecoderProfile,
+    D3D11_VIDEO_CONTENT_PROTECTION_CAPS *pCaps);
+void __RPC_STUB ID3D11VideoDevice_GetContentProtectionCaps_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoDevice_CheckCryptoKeyExchange_Proxy(
+    ID3D11VideoDevice* This,
+    const GUID *pCryptoType,
+    const GUID *pDecoderProfile,
+    UINT Index,
+    GUID *pKeyExchangeType);
+void __RPC_STUB ID3D11VideoDevice_CheckCryptoKeyExchange_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoDevice_SetPrivateData_Proxy(
+    ID3D11VideoDevice* This,
+    REFGUID guid,
+    UINT DataSize,
+    const void *pData);
+void __RPC_STUB ID3D11VideoDevice_SetPrivateData_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+HRESULT STDMETHODCALLTYPE ID3D11VideoDevice_SetPrivateDataInterface_Proxy(
+    ID3D11VideoDevice* This,
+    REFGUID guid,
+    const IUnknown *pData);
+void __RPC_STUB ID3D11VideoDevice_SetPrivateDataInterface_Stub(
+    IRpcStubBuffer* This,
+    IRpcChannelBuffer* pRpcChannelBuffer,
+    PRPC_MESSAGE pRpcMessage,
+    DWORD* pdwStubPhase);
+
+#endif  /* __ID3D11VideoDevice_INTERFACE_DEFINED__ */
+
+/*****************************************************************************
+ * ID3D11Device interface
+ */
+#ifndef __ID3D11Device_INTERFACE_DEFINED__
+#define __ID3D11Device_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_ID3D11Device, 0xdb6f6ddb, 0xac77, 0x4e88, 0x82,0x53, 0x81,0x9d,0xf9,0xbb,0xf1,0x40);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+MIDL_INTERFACE("db6f6ddb-ac77-4e88-8253-819df9bbf140")
+ID3D11Device : public IUnknown
+{
+    virtual HRESULT STDMETHODCALLTYPE CreateBuffer(
+        const D3D11_BUFFER_DESC *pDesc,
+        const D3D11_SUBRESOURCE_DATA *pInitialData,
+        ID3D11Buffer **ppBuffer) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateTexture1D(
+        const D3D11_TEXTURE1D_DESC *pDesc,
+        const D3D11_SUBRESOURCE_DATA *pInitialData,
+        ID3D11Texture1D **ppTexture1D) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateTexture2D(
+        const D3D11_TEXTURE2D_DESC *pDesc,
+        const D3D11_SUBRESOURCE_DATA *pInitialData,
+        ID3D11Texture2D **ppTexture2D) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateTexture3D(
+        const D3D11_TEXTURE3D_DESC *pDesc,
+        const D3D11_SUBRESOURCE_DATA *pInitialData,
+        ID3D11Texture3D **ppTexture3D) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateShaderResourceView(
+        ID3D11Resource *pResource,
+        const D3D11_SHADER_RESOURCE_VIEW_DESC *pDesc,
+        ID3D11ShaderResourceView **ppSRView) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateUnorderedAccessView(
+        ID3D11Resource *pResource,
+        const D3D11_UNORDERED_ACCESS_VIEW_DESC *pDesc,
+        ID3D11UnorderedAccessView **ppUAView) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateRenderTargetView(
+        ID3D11Resource *pResource,
+        const D3D11_RENDER_TARGET_VIEW_DESC *pDesc,
+        ID3D11RenderTargetView **ppRTView) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateDepthStencilView(
+        ID3D11Resource *pResource,
+        const D3D11_DEPTH_STENCIL_VIEW_DESC *pDesc,
+        ID3D11DepthStencilView **ppDepthStencilView) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateInputLayout(
+        const D3D11_INPUT_ELEMENT_DESC *pInputElementDescs,
+        UINT NumElements,
+        const void *pShaderBytecodeWithInputSignature,
+        SIZE_T BytecodeLength,
+        ID3D11InputLayout **ppInputLayout) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateVertexShader(
+        const void *pShaderBytecode,
+        SIZE_T BytecodeLength,
+        ID3D11ClassLinkage *pClassLinkage,
+        ID3D11VertexShader **ppVertexShader) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateGeometryShader(
+        const void *pShaderBytecode,
+        SIZE_T BytecodeLength,
+        ID3D11ClassLinkage *pClassLinkage,
+        ID3D11GeometryShader **ppGeometryShader) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateGeometryShaderWithStreamOutput(
+        const void *pShaderBytecode,
+        SIZE_T BytecodeLength,
+        const D3D11_SO_DECLARATION_ENTRY *pSODeclaration,
+        UINT NumEntries,
+        const UINT *pBufferStrides,
+        UINT NumStrides,
+        UINT RasterizedStream,
+        ID3D11ClassLinkage *pClassLinkage,
+        ID3D11GeometryShader **ppGeometryShader) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreatePixelShader(
+        const void *pShaderBytecode,
+        SIZE_T BytecodeLength,
+        ID3D11ClassLinkage *pClassLinkage,
+        ID3D11PixelShader **ppPixelShader) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateHullShader(
+        const void *pShaderBytecode,
+        SIZE_T BytecodeLength,
+        ID3D11ClassLinkage *pClassLinkage,
+        ID3D11HullShader **ppHullShader) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateDomainShader(
+        const void *pShaderBytecode,
+        SIZE_T BytecodeLength,
+        ID3D11ClassLinkage *pClassLinkage,
+        ID3D11DomainShader **ppDomainShader) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateComputeShader(
+        const void *pShaderBytecode,
+        SIZE_T BytecodeLength,
+        ID3D11ClassLinkage *pClassLinkage,
+        ID3D11ComputeShader **ppComputeShader) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateClassLinkage(
+        ID3D11ClassLinkage **ppLinkage) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateBlendState(
+        const D3D11_BLEND_DESC *pBlendStateDesc,
+        ID3D11BlendState **ppBlendState) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateDepthStencilState(
+        const D3D11_DEPTH_STENCIL_DESC *pDepthStencilDesc,
+        ID3D11DepthStencilState **ppDepthStencilState) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateRasterizerState(
+        const D3D11_RASTERIZER_DESC *pRasterizerDesc,
+        ID3D11RasterizerState **ppRasterizerState) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateSamplerState(
+        const D3D11_SAMPLER_DESC *pSamplerDesc,
+        ID3D11SamplerState **ppSamplerState) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateQuery(
+        const D3D11_QUERY_DESC *pQueryDesc,
+        ID3D11Query **ppQuery) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreatePredicate(
+        const D3D11_QUERY_DESC *pPredicateDesc,
+        ID3D11Predicate **ppPredicate) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateCounter(
+        const D3D11_COUNTER_DESC *pCounterDesc,
+        ID3D11Counter **ppCounter) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CreateDeferredContext(
+        UINT ContextFlags,
+        ID3D11DeviceContext **ppDeferredContext) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE OpenSharedResource(
+        HANDLE hResource,
+        REFIID ReturnedInterface,
+        void **ppResource) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CheckFormatSupport(
+        DXGI_FORMAT Format,
+        UINT *pFormatSupport) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CheckMultisampleQualityLevels(
+        DXGI_FORMAT Format,
+        UINT SampleCount,
+        UINT *pNumQualityLevels) = 0;
+
+    virtual void STDMETHODCALLTYPE CheckCounterInfo(
+        D3D11_COUNTER_INFO *pCounterInfo) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CheckCounter(
+        const D3D11_COUNTER_DESC *pDesc,
+        D3D11_COUNTER_TYPE *pType,
+        UINT *pActiveCounters,
+        LPSTR szName,
+        UINT *pNameLength,
+        LPSTR szUnits,
+        UINT *pUnitsLength,
+        LPSTR szDescription,
+        UINT *pDescriptionLength) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE CheckFeatureSupport(
+        D3D11_FEATURE Feature,
+        void *pFeatureSupportData,
+        UINT FeatureSupportDataSize) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE GetPrivateData(
+        REFGUID guid,
+        UINT *pDataSize,
+        void *pData) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE SetPrivateData(
         REFGUID guid,
         UINT DataSize,
         const void *pData) = 0;
@@ -8878,6 +10843,8 @@ HRESULT WINAPI D3D11CreateDevice(IDXGIAdapter*,D3D_DRIVER_TYPE,HMODULE,UINT,cons
 typedef HRESULT (WINAPI *PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN)(IDXGIAdapter*,D3D_DRIVER_TYPE,HMODULE,UINT,
     const D3D_FEATURE_LEVEL*,UINT,UINT,const DXGI_SWAP_CHAIN_DESC*,IDXGISwapChain**,ID3D11Device**,
     D3D_FEATURE_LEVEL*,ID3D11DeviceContext**);
+HRESULT __stdcall  D3D11CreateDeviceAndSwapChain(IDXGIAdapter *adapter,D3D_DRIVER_TYPE driver_type,HMODULE swrast,UINT flags,const D3D_FEATURE_LEVEL *feature_levels,UINT levels,UINT sdk_version,const DXGI_SWAP_CHAIN_DESC *swapchain_desc,IDXGISwapChain **swapchain,ID3D11Device **device,D3D_FEATURE_LEVEL *obtained_feature_level,ID3D11DeviceContext **immediate_context);
+
 /* Begin additional prototypes for all interfaces */
 
 
diff --git a/mingw-w64-headers/direct-x/include/d3d11.idl b/mingw-w64-headers/direct-x/include/d3d11.idl
index c187463..0815bfc 100644
--- a/mingw-w64-headers/direct-x/include/d3d11.idl
+++ b/mingw-w64-headers/direct-x/include/d3d11.idl
@@ -1218,6 +1218,195 @@ typedef struct D3D11_TEXTURE3D_DESC
     UINT MiscFlags;
 } D3D11_TEXTURE3D_DESC;
 
+typedef struct D3D11_VIDEO_DECODER_DESC
+{
+    GUID Guid;
+    UINT SampleWidth;
+    UINT SampleHeight;
+    DXGI_FORMAT OutputFormat;
+} D3D11_VIDEO_DECODER_DESC;
+
+typedef struct D3D11_VIDEO_DECODER_CONFIG
+{
+    GUID guidConfigBitstreamEncryption;
+    GUID guidConfigMBcontrolEncryption;
+    GUID guidConfigResidDiffEncryption;
+    UINT ConfigBitstreamRaw;
+    UINT ConfigMBcontrolRasterOrder;
+    UINT ConfigResidDiffHost;
+    UINT ConfigSpatialResid8;
+    UINT ConfigResid8Subtraction;
+    UINT ConfigSpatialHost8or9Clipping;
+    UINT ConfigSpatialResidInterleaved;
+    UINT ConfigIntraResidUnsigned;
+    UINT ConfigResidDiffAccelerator;
+    UINT ConfigHostInverseScan;
+    UINT ConfigSpecificIDCT;
+    UINT Config4GroupedCoefs;
+    USHORT ConfigMinRenderTargetBuffCount;
+    USHORT ConfigDecoderSpecific;
+} D3D11_VIDEO_DECODER_CONFIG;
+
+typedef enum D3D11_VIDEO_FRAME_FORMAT
+{
+    D3D11_VIDEO_FRAME_FORMAT_PROGRESSIVE                   = 0,
+    D3D11_VIDEO_FRAME_FORMAT_INTERLACED_TOP_FIELD_FIRST    = 1,
+    D3D11_VIDEO_FRAME_FORMAT_INTERLACED_BOTTOM_FIELD_FIRST = 2
+} D3D11_VIDEO_FRAME_FORMAT;
+
+typedef enum D3D11_VIDEO_USAGE
+{
+    D3D11_VIDEO_USAGE_PLAYBACK_NORMAL = 0,
+    D3D11_VIDEO_USAGE_OPTIMAL_SPEED   = 1,
+    D3D11_VIDEO_USAGE_OPTIMAL_QUALITY = 2
+} D3D11_VIDEO_USAGE;
+
+typedef struct D3D11_VIDEO_PROCESSOR_CONTENT_DESC
+{
+    D3D11_VIDEO_FRAME_FORMAT InputFrameFormat;
+    DXGI_RATIONAL InputFrameRate;
+    UINT InputWidth;
+    UINT InputHeight;
+    DXGI_RATIONAL OutputFrameRate;
+    UINT OutputWidth;
+    UINT OutputHeight;
+    D3D11_VIDEO_USAGE Usage;
+} D3D11_VIDEO_PROCESSOR_CONTENT_DESC;
+
+typedef struct D3D11_VIDEO_PROCESSOR_CAPS
+{
+    UINT DeviceCaps;
+    UINT FeatureCaps;
+    UINT FilterCaps;
+    UINT InputFormatCaps;
+    UINT AutoStreamCaps;
+    UINT StereoCaps;
+    UINT RateConversionCapsCount;
+    UINT MaxInputStreams;
+    UINT MaxStreamStates;
+} D3D11_VIDEO_PROCESSOR_CAPS;
+
+typedef struct D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS
+{
+    UINT PastFrames;
+    UINT FutureFrames;
+    UINT ProcessorCaps;
+    UINT ITelecineCaps;
+    UINT CustomRateCount;
+} D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS;
+
+typedef struct D3D11_VIDEO_PROCESSOR_CUSTOM_RATE
+{
+    DXGI_RATIONAL CustomRate;
+    UINT OutputFrames;
+    BOOL InputInterlaced;
+    UINT InputFramesOrFields;
+} D3D11_VIDEO_PROCESSOR_CUSTOM_RATE;
+
+typedef enum D3D11_VIDEO_PROCESSOR_FILTER
+{
+    D3D11_VIDEO_PROCESSOR_FILTER_BRIGHTNESS         = 0,
+    D3D11_VIDEO_PROCESSOR_FILTER_CONTRAST           = 1,
+    D3D11_VIDEO_PROCESSOR_FILTER_HUE                = 2,
+    D3D11_VIDEO_PROCESSOR_FILTER_SATURATION         = 3,
+    D3D11_VIDEO_PROCESSOR_FILTER_NOISE_REDUCTION    = 4,
+    D3D11_VIDEO_PROCESSOR_FILTER_EDGE_ENHANCEMENT   = 5,
+    D3D11_VIDEO_PROCESSOR_FILTER_ANAMORPHIC_SCALING = 6,
+    D3D11_VIDEO_PROCESSOR_FILTER_STEREO_ADJUSTMENT  = 7
+} D3D11_VIDEO_PROCESSOR_FILTER;
+
+typedef struct D3D11_VIDEO_PROCESSOR_FILTER_RANGE
+{
+    int Minimum;
+    int Maximum;
+    int Default;
+    float Multiplier;
+} D3D11_VIDEO_PROCESSOR_FILTER_RANGE;
+
+typedef enum D3D11_AUTHENTICATED_CHANNEL_TYPE
+{
+    D3D11_AUTHENTICATED_CHANNEL_D3D11           = 1,
+    D3D11_AUTHENTICATED_CHANNEL_DRIVER_SOFTWARE = 2,
+    D3D11_AUTHENTICATED_CHANNEL_DRIVER_HARDWARE = 3
+} D3D11_AUTHENTICATED_CHANNEL_TYPE;
+
+typedef enum D3D11_VDOV_DIMENSION
+{
+    D3D11_VDOV_DIMENSION_UNKNOWN   = 0,
+    D3D11_VDOV_DIMENSION_TEXTURE2D = 1
+} D3D11_VDOV_DIMENSION;
+
+typedef struct D3D11_TEX2D_VDOV
+{
+    UINT ArraySlice;
+} D3D11_TEX2D_VDOV;
+
+typedef struct D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC
+{
+    GUID DecodeProfile;
+    D3D11_VDOV_DIMENSION ViewDimension;
+    union {
+        D3D11_TEX2D_VDOV Texture2D;
+    };
+} D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC;
+
+typedef enum D3D11_VPIV_DIMENSION
+{
+    D3D11_VPIV_DIMENSION_UNKNOWN   = 0,
+    D3D11_VPIV_DIMENSION_TEXTURE2D = 1
+} D3D11_VPIV_DIMENSION;
+
+typedef struct D3D11_TEX2D_VPIV
+{
+    UINT MipSlice;
+    UINT ArraySlice;
+} D3D11_TEX2D_VPIV;
+
+typedef struct D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC
+{
+    UINT FourCC;
+    D3D11_VPIV_DIMENSION ViewDimension;
+    union {
+        D3D11_TEX2D_VPIV Texture2D;
+    };
+} D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC;
+
+typedef enum D3D11_VPOV_DIMENSION
+{
+    D3D11_VPOV_DIMENSION_UNKNOWN        = 0,
+    D3D11_VPOV_DIMENSION_TEXTURE2D      = 1,
+    D3D11_VPOV_DIMENSION_TEXTURE2DARRAY = 2
+} D3D11_VPOV_DIMENSION;
+
+typedef struct D3D11_TEX2D_VPOV
+{
+    UINT MipSlice;
+} D3D11_TEX2D_VPOV;
+
+typedef struct D3D11_TEX2D_ARRAY_VPOV
+{
+    UINT MipSlice;
+    UINT FirstArraySlice;
+    UINT ArraySize;
+} D3D11_TEX2D_ARRAY_VPOV;
+
+typedef struct D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC
+{
+    D3D11_VPOV_DIMENSION ViewDimension;
+    union {
+        D3D11_TEX2D_VPOV Texture2D;
+        D3D11_TEX2D_ARRAY_VPOV Texture2DArray;
+    };
+} D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC;
+
+typedef struct D3D11_VIDEO_CONTENT_PROTECTION_CAPS
+{
+    UINT Caps;
+    UINT KeyExchangeTypeCount;
+    UINT BlockAlignmentSize;
+    ULONGLONG ProtectedMemorySize;
+} D3D11_VIDEO_CONTENT_PROTECTION_CAPS;
+
 /* A couple forward declarations are needed */
 interface ID3D11Device;
 interface ID3D11ClassLinkage;
@@ -1969,6 +2158,210 @@ interface ID3D11DeviceContext : ID3D11DeviceChild
 
 [
     object,
+    uuid(3015a308-dcbd-47aa-a747-192486d14d4a),
+    local,
+    pointer_default(unique)
+]
+interface ID3D11AuthenticatedChannel : ID3D11DeviceChild
+{
+    HRESULT GetCertificateSize(
+        UINT *pCertificateSize);
+    HRESULT GetCertificate(
+        UINT CertificateSize,
+        BYTE *pCertificate);
+    void GetChannelHandle(
+        HANDLE *pChannelHandle);
+}
+
+[
+    object,
+    uuid(9b32f9ad-bdcc-40a6-a39d-d5c865845720),
+    local,
+    pointer_default(unique)
+]
+interface ID3D11CryptoSession : ID3D11DeviceChild
+{
+    void GetCryptoType(
+        GUID *pCryptoType);
+    void GetDecoderProfile(
+        GUID *pDecoderProfile);
+    HRESULT GetCertificateSize(
+        UINT *pCertificateSize);
+    HRESULT GetCertificate(
+        UINT CertificateSize,
+        BYTE *pCertificate);
+    void GetCryptoSessionHandle(
+        HANDLE *pCryptoSessionHandle);
+}
+
+[
+    object,
+    uuid(3c9c5b51-995d-48d1-9b8d-fa5caeded65c),
+    local,
+    pointer_default(unique)
+]
+interface ID3D11VideoDecoder : ID3D11DeviceChild
+{
+    HRESULT GetCreationParameters(
+        D3D11_VIDEO_DECODER_DESC *pVideoDesc,
+        D3D11_VIDEO_DECODER_CONFIG *pConfig);
+    HRESULT GetDriverHandle(
+        HANDLE *pDriverHandle);
+}
+
+[
+    object,
+    uuid(31627037-53ab-4200-9061-05faa9ab45f9),
+    local,
+    pointer_default(unique)
+]
+interface ID3D11VideoProcessorEnumerator : ID3D11DeviceChild
+{
+    HRESULT GetVideoProcessorContentDesc(
+        D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pContentDesc);
+    HRESULT CheckVideoProcessorFormat(
+        DXGI_FORMAT Format,
+        UINT *pFlags);
+    HRESULT GetVideoProcessorCaps(
+        D3D11_VIDEO_PROCESSOR_CAPS *pCaps);
+    HRESULT GetVideoProcessorRateConversionCaps(
+        UINT TypeIndex,
+        D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS *pCaps);
+    HRESULT GetVideoProcessorCustomRate(
+        UINT TypeIndex,
+        UINT CustomRateIndex,
+        D3D11_VIDEO_PROCESSOR_CUSTOM_RATE *pRate);
+    HRESULT GetVideoProcessorFilterRange(
+        D3D11_VIDEO_PROCESSOR_FILTER Filter,
+        D3D11_VIDEO_PROCESSOR_FILTER_RANGE *pRange);
+}
+
+[
+    object,
+    uuid(1d7b0652-185f-41c6-85ce-0c5be3d4ae6c),
+    local,
+    pointer_default(unique)
+]
+interface ID3D11VideoProcessor : ID3D11DeviceChild
+{
+    void GetContentDesc(
+        D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pDesc);
+    void GetRateConversionCaps(
+        D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS *pCaps);
+}
+
+[
+    object,
+    uuid(c2931aea-2a85-4f20-860f-fba1fd256e18),
+    local,
+    pointer_default(unique)
+]
+interface ID3D11VideoDecoderOutputView : ID3D11View
+{
+    void GetDesc(
+        D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC *pDesc);
+}
+
+[
+    object,
+    uuid(11ec5a5f-51dc-4945-ab34-6e8c21300ea5),
+    local,
+    pointer_default(unique)
+]
+interface ID3D11VideoProcessorInputView : ID3D11View
+{
+    void GetDesc(
+        D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC *pDesc);
+}
+
+[
+    object,
+    uuid(a048285e-25a9-4527-bd93-d68b68c44254),
+    local,
+    pointer_default(unique)
+]
+interface ID3D11VideoProcessorOutputView : ID3D11View
+{
+    void GetDesc(
+        D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC *pDesc);
+}
+
+[
+    object,
+    uuid(10ec4d5b-975a-4689-b9e4-d0aac30fe333),
+    local,
+    pointer_default(unique)
+]
+interface ID3D11VideoDevice : IUnknown
+{
+    HRESULT CreateVideoDecoder(
+        const D3D11_VIDEO_DECODER_DESC *pVideoDesc,
+        const D3D11_VIDEO_DECODER_CONFIG *pConfig,
+        ID3D11VideoDecoder **ppDecoder);
+    HRESULT CreateVideoProcessor(
+        ID3D11VideoProcessorEnumerator *pEnum,
+        UINT RateConversionIndex,
+        ID3D11VideoProcessor **ppVideoProcessor);
+    HRESULT CreateAuthenticatedChannel(
+        D3D11_AUTHENTICATED_CHANNEL_TYPE ChannelType,
+        ID3D11AuthenticatedChannel **ppAuthenticatedChannel);
+    HRESULT CreateCryptoSession(
+        const GUID *pCryptoType,
+        const GUID *pDecoderProfile,
+        const GUID *pKeyExchangeType,
+        ID3D11CryptoSession **ppCryptoSession);
+    HRESULT CreateVideoDecoderOutputView(
+        ID3D11Resource *pResource,
+        const D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC *pDesc,
+        ID3D11VideoDecoderOutputView **ppVDOVView);
+    HRESULT CreateVideoProcessorInputView(
+        ID3D11Resource *pResource,
+        ID3D11VideoProcessorEnumerator *pEnum,
+        const D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC *pDesc,
+        ID3D11VideoProcessorInputView **ppVPIView);
+    HRESULT CreateVideoProcessorOutputView(
+        ID3D11Resource *pResource,
+        ID3D11VideoProcessorEnumerator *pEnum,
+        const D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC *pDesc,
+        ID3D11VideoProcessorOutputView **ppVPOView);
+    HRESULT CreateVideoProcessorEnumerator(
+        const D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pDesc,
+        ID3D11VideoProcessorEnumerator **ppEnum);
+    UINT GetVideoDecoderProfileCount();
+    HRESULT GetVideoDecoderProfile(
+        UINT Index,
+        GUID *pDecoderProfile);
+    HRESULT CheckVideoDecoderFormat(
+        const GUID *pDecoderProfile,
+        DXGI_FORMAT Format,
+        BOOL *pSupported);
+    HRESULT GetVideoDecoderConfigCount(
+        const D3D11_VIDEO_DECODER_DESC *pDesc,
+        UINT *pCount);
+    HRESULT GetVideoDecoderConfig(
+        const D3D11_VIDEO_DECODER_DESC *pDesc,
+        UINT Index,
+        D3D11_VIDEO_DECODER_CONFIG *pConfig);
+    HRESULT GetContentProtectionCaps(
+        const GUID *pCryptoType,
+        const GUID *pDecoderProfile,
+        D3D11_VIDEO_CONTENT_PROTECTION_CAPS *pCaps);
+    HRESULT CheckCryptoKeyExchange(
+        const GUID *pCryptoType,
+        const GUID *pDecoderProfile,
+        UINT Index,
+        GUID *pKeyExchangeType);
+    HRESULT SetPrivateData(
+        REFGUID guid,
+        UINT DataSize,
+        const void *pData);
+    HRESULT SetPrivateDataInterface(
+        REFGUID guid,
+        const IUnknown *pData);
+}
+
+[
+    object,
     local,
     uuid(db6f6ddb-ac77-4e88-8253-819df9bbf140)
 ]
@@ -2157,3 +2550,8 @@ cpp_quote("    UINT,UINT,ID3D11Device**,D3D_FEATURE_LEVEL*,ID3D11DeviceContext**
 cpp_quote("typedef HRESULT (WINAPI *PFN_D3D11_CREATE_DEVICE_AND_SWAP_CHAIN)(IDXGIAdapter*,D3D_DRIVER_TYPE,HMODULE,UINT,")
 cpp_quote("    const D3D_FEATURE_LEVEL*,UINT,UINT,const DXGI_SWAP_CHAIN_DESC*,IDXGISwapChain**,ID3D11Device**,")
 cpp_quote("    D3D_FEATURE_LEVEL*,ID3D11DeviceContext**);")
+
+[local] HRESULT __stdcall D3D11CreateDeviceAndSwapChain(IDXGIAdapter *adapter, D3D_DRIVER_TYPE driver_type,
+        HMODULE swrast, UINT flags, const D3D_FEATURE_LEVEL *feature_levels, UINT levels, UINT sdk_version,
+        const DXGI_SWAP_CHAIN_DESC *swapchain_desc, IDXGISwapChain **swapchain, ID3D11Device **device,
+        D3D_FEATURE_LEVEL *obtained_feature_level, ID3D11DeviceContext **immediate_context);
diff --git a/mingw-w64-headers/direct-x/include/d3dcommon.h b/mingw-w64-headers/direct-x/include/d3dcommon.h
index 5c1e674..e48e3db 100644
--- a/mingw-w64-headers/direct-x/include/d3dcommon.h
+++ b/mingw-w64-headers/direct-x/include/d3dcommon.h
@@ -290,6 +290,17 @@ typedef enum _D3D_SHADER_VARIABLE_CLASS {
     D3D11_SVC_INTERFACE_POINTER = 7,
     D3D_SVC_FORCE_DWORD = 0x7fffffff
 } D3D_SHADER_VARIABLE_CLASS;
+typedef enum _D3D_SHADER_VARIABLE_FLAGS {
+    D3D_SVF_USERPACKED = 0x1,
+    D3D_SVF_USED = 0x2,
+    D3D_SVF_INTERFACE_POINTER = 0x4,
+    D3D_SVF_INTERFACE_PARAMETER = 0x8,
+    D3D10_SVF_USERPACKED = D3D_SVF_USERPACKED,
+    D3D10_SVF_USED = D3D_SVF_USED,
+    D3D11_SVF_INTERFACE_POINTER = D3D_SVF_INTERFACE_POINTER,
+    D3D11_SVF_INTERFACE_PARAMETER = D3D_SVF_INTERFACE_PARAMETER,
+    D3D_SVF_FORCE_DWORD = 0x7fffffff
+} D3D_SHADER_VARIABLE_FLAGS;
 typedef enum _D3D_SHADER_VARIABLE_TYPE {
     D3D_SVT_VOID = 0,
     D3D_SVT_BOOL = 1,
@@ -397,6 +408,20 @@ typedef enum _D3D_SHADER_VARIABLE_TYPE {
     D3D11_SVT_CONSUME_STRUCTURED_BUFFER = 51,
     D3D_SVT_FORCE_DWORD = 0x7fffffff
 } D3D_SHADER_VARIABLE_TYPE;
+typedef enum _D3D_SHADER_INPUT_FLAGS {
+    D3D_SIF_USERPACKED = 0x1,
+    D3D_SIF_COMPARISON_SAMPLER = 0x2,
+    D3D_SIF_TEXTURE_COMPONENT_0 = 0x4,
+    D3D_SIF_TEXTURE_COMPONENT_1 = 0x8,
+    D3D_SIF_TEXTURE_COMPONENTS = 0xc,
+    D3D_SIF_UNUSED = 0x10,
+    D3D10_SIF_USERPACKED = D3D_SIF_USERPACKED,
+    D3D10_SIF_COMPARISON_SAMPLER = D3D_SIF_COMPARISON_SAMPLER,
+    D3D10_SIF_TEXTURE_COMPONENT_0 = D3D_SIF_TEXTURE_COMPONENT_0,
+    D3D10_SIF_TEXTURE_COMPONENT_1 = D3D_SIF_TEXTURE_COMPONENT_1,
+    D3D10_SIF_TEXTURE_COMPONENTS = D3D_SIF_TEXTURE_COMPONENTS,
+    D3D_SIF_FORCE_DWORD = 0x7fffffff
+} D3D_SHADER_INPUT_FLAGS;
 typedef enum D3D_PRIMITIVE {
     D3D_PRIMITIVE_UNDEFINED = 0,
     D3D_PRIMITIVE_POINT = 1,
@@ -776,6 +801,11 @@ typedef enum _D3D_SHADER_INPUT_TYPE {
     D3D11_SIT_UAV_CONSUME_STRUCTURED = 10,
     D3D11_SIT_UAV_RWSTRUCTURED_WITH_COUNTER = 11
 } D3D_SHADER_INPUT_TYPE;
+typedef enum _D3D_SHADER_CBUFFER_FLAGS {
+    D3D_CBF_USERPACKED = 0x1,
+    D3D10_CBF_USERPACKED = D3D_CBF_USERPACKED,
+    D3D_CBF_FORCE_DWORD = 0x7fffffff
+} D3D_SHADER_CBUFFER_FLAGS;
 DEFINE_GUID(WKPDID_D3DDebugObjectName,0x429b8c22,0x9188,0x4b0c,0x87,0x42,0xac,0xb0,0xbf,0x85,0xc2,0x00);
 /* Begin additional prototypes for all interfaces */
 
diff --git a/mingw-w64-headers/direct-x/include/d3dcommon.idl b/mingw-w64-headers/direct-x/include/d3dcommon.idl
index f8fe203..c7e3b4d 100644
--- a/mingw-w64-headers/direct-x/include/d3dcommon.idl
+++ b/mingw-w64-headers/direct-x/include/d3dcommon.idl
@@ -126,6 +126,19 @@ typedef enum _D3D_SHADER_VARIABLE_CLASS
     D3D_SVC_FORCE_DWORD = 0x7fffffff,
 } D3D_SHADER_VARIABLE_CLASS;
 
+typedef enum _D3D_SHADER_VARIABLE_FLAGS
+{
+    D3D_SVF_USERPACKED            = 0x01,
+    D3D_SVF_USED                  = 0x02,
+    D3D_SVF_INTERFACE_POINTER     = 0x04,
+    D3D_SVF_INTERFACE_PARAMETER   = 0x08,
+    D3D10_SVF_USERPACKED          = D3D_SVF_USERPACKED,
+    D3D10_SVF_USED                = D3D_SVF_USED,
+    D3D11_SVF_INTERFACE_POINTER   = D3D_SVF_INTERFACE_POINTER,
+    D3D11_SVF_INTERFACE_PARAMETER = D3D_SVF_INTERFACE_PARAMETER,
+    D3D_SVF_FORCE_DWORD           = 0x7fffffff
+} D3D_SHADER_VARIABLE_FLAGS;
+
 typedef enum _D3D_SHADER_VARIABLE_TYPE
 {
     D3D_SVT_VOID,
@@ -235,6 +248,22 @@ typedef enum _D3D_SHADER_VARIABLE_TYPE
     D3D_SVT_FORCE_DWORD = 0x7fffffff,
 } D3D_SHADER_VARIABLE_TYPE;
 
+typedef enum _D3D_SHADER_INPUT_FLAGS
+{
+    D3D_SIF_USERPACKED            = 0x01,
+    D3D_SIF_COMPARISON_SAMPLER    = 0x02,
+    D3D_SIF_TEXTURE_COMPONENT_0   = 0x04,
+    D3D_SIF_TEXTURE_COMPONENT_1   = 0x08,
+    D3D_SIF_TEXTURE_COMPONENTS    = 0x0C,
+    D3D_SIF_UNUSED                = 0x10,
+    D3D10_SIF_USERPACKED          = D3D_SIF_USERPACKED,
+    D3D10_SIF_COMPARISON_SAMPLER  = D3D_SIF_COMPARISON_SAMPLER,
+    D3D10_SIF_TEXTURE_COMPONENT_0 = D3D_SIF_TEXTURE_COMPONENT_0,
+    D3D10_SIF_TEXTURE_COMPONENT_1 = D3D_SIF_TEXTURE_COMPONENT_1,
+    D3D10_SIF_TEXTURE_COMPONENTS  = D3D_SIF_TEXTURE_COMPONENTS,
+    D3D_SIF_FORCE_DWORD           = 0x7fffffff
+} D3D_SHADER_INPUT_FLAGS;
+
 typedef enum D3D_PRIMITIVE
 {
     D3D_PRIMITIVE_UNDEFINED,
@@ -636,4 +665,11 @@ typedef enum _D3D_SHADER_INPUT_TYPE
     D3D11_SIT_UAV_RWSTRUCTURED_WITH_COUNTER,
 } D3D_SHADER_INPUT_TYPE;
 
+typedef enum _D3D_SHADER_CBUFFER_FLAGS
+{
+    D3D_CBF_USERPACKED      = 0x01,
+    D3D10_CBF_USERPACKED    = D3D_CBF_USERPACKED,
+    D3D_CBF_FORCE_DWORD     = 0x7fffffff
+} D3D_SHADER_CBUFFER_FLAGS;
+
 cpp_quote("DEFINE_GUID(WKPDID_D3DDebugObjectName,0x429b8c22,0x9188,0x4b0c,0x87,0x42,0xac,0xb0,0xbf,0x85,0xc2,0x00);")
diff --git a/mingw-w64-headers/direct-x/include/d3drmobj.h b/mingw-w64-headers/direct-x/include/d3drmobj.h
index 4b0b092..ab4ad34 100644
--- a/mingw-w64-headers/direct-x/include/d3drmobj.h
+++ b/mingw-w64-headers/direct-x/include/d3drmobj.h
@@ -3285,7 +3285,7 @@ DECLARE_INTERFACE_(IDirect3DRMTexture, IDirect3DRMVisual)
 #define IDirect3DRMTexture_SetDecalOrigin(p,a,b)            (p)->SetDecalOrigin(a,b)
 #define IDirect3DRMTexture_SetDecalScale(p,a)               (p)->SetDecalScale(a)
 #define IDirect3DRMTexture_SetDecalTransparency(p,a)        (p)->SetDecalTransparency(a)
-#define IDirect3DRMTexture_SetDecalTransparencyColor(p,a)   (p)->SetDecalTransparentColor(a)
+#define IDirect3DRMTexture_SetDecalTransparentColor(p,a)    (p)->SetDecalTransparentColor(a)
 #define IDirect3DRMTexture_GetDecalSize(p,a,b)              (p)->GetDecalSize(a,b)
 #define IDirect3DRMTexture_GetDecalOrigin(p,a,b)            (p)->GetDecalOrigin(a,b)
 #define IDirect3DRMTexture_GetImage(p)                      (p)->GetImage()
@@ -3293,7 +3293,7 @@ DECLARE_INTERFACE_(IDirect3DRMTexture, IDirect3DRMVisual)
 #define IDirect3DRMTexture_GetColors(p)                     (p)->GetColors()
 #define IDirect3DRMTexture_GetDecalScale(p)                 (p)->GetDecalScale()
 #define IDirect3DRMTexture_GetDecalTransparency(p)          (p)->GetDecalTransparency()
-#define IDirect3DRMTexture_GetDecalTransparencyColor(p)     (p)->GetDecalTransparencyColor()
+#define IDirect3DRMTexture_GetDecalTransparentColor(p)      (p)->GetDecalTransparentColor()
 #endif
 
 /*****************************************************************************
@@ -3405,7 +3405,7 @@ DECLARE_INTERFACE_(IDirect3DRMTexture2, IDirect3DRMTexture)
 #define IDirect3DRMTexture2_SetDecalOrigin(p,a,b)            (p)->SetDecalOrigin(a,b)
 #define IDirect3DRMTexture2_SetDecalScale(p,a)               (p)->SetDecalScale(a)
 #define IDirect3DRMTexture2_SetDecalTransparency(p,a)        (p)->SetDecalTransparency(a)
-#define IDirect3DRMTexture2_SetDecalTransparencyColor(p,a)   (p)->SetDecalTransparentColor(a)
+#define IDirect3DRMTexture2_SetDecalTransparentColor(p,a)    (p)->SetDecalTransparentColor(a)
 #define IDirect3DRMTexture2_GetDecalSize(p,a,b)              (p)->GetDecalSize(a,b)
 #define IDirect3DRMTexture2_GetDecalOrigin(p,a,b)            (p)->GetDecalOrigin(a,b)
 #define IDirect3DRMTexture2_GetImage(p)                      (p)->GetImage()
@@ -3413,7 +3413,7 @@ DECLARE_INTERFACE_(IDirect3DRMTexture2, IDirect3DRMTexture)
 #define IDirect3DRMTexture2_GetColors(p)                     (p)->GetColors()
 #define IDirect3DRMTexture2_GetDecalScale(p)                 (p)->GetDecalScale()
 #define IDirect3DRMTexture2_GetDecalTransparency(p)          (p)->GetDecalTransparency()
-#define IDirect3DRMTexture2_GetDecalTransparencyColor(p)     (p)->GetDecalTransparencyColor()
+#define IDirect3DRMTexture2_GetDecalTransparentColor(p)      (p)->GetDecalTransparentColor()
 /*** IDirect3DRMTexture2 methods ***/
 #define IDirect3DRMTexture2_InitFromImage(p,a)               (p)->InitFromImage(a)
 #define IDirect3DRMTexture2_InitFromResource2(p,a,b,c)       (p)->InitFromResource2(a,b,c)
@@ -3495,7 +3495,7 @@ DECLARE_INTERFACE_(IDirect3DRMTexture3, IDirect3DRMVisual)
 #define IDirect3DRMTexture3_SetDecalOrigin(p,a,b)            (p)->lpVtbl->SetDecalOrigin(p,a,b)
 #define IDirect3DRMTexture3_SetDecalScale(p,a)               (p)->lpVtbl->SetDecalScale(p,a)
 #define IDirect3DRMTexture3_SetDecalTransparency(p,a)        (p)->lpVtbl->SetDecalTransparency(p,a)
-#define IDirect3DRMTexture3_SetDecalTransparencyColor(p,a)   (p)->lpVtbl->SetDecalTransparentColor(p,a)
+#define IDirect3DRMTexture3_SetDecalTransparentColor(p,a)    (p)->lpVtbl->SetDecalTransparentColor(p,a)
 #define IDirect3DRMTexture3_GetDecalSize(p,a,b)              (p)->lpVtbl->GetDecalSize(p,a,b)
 #define IDirect3DRMTexture3_GetDecalOrigin(p,a,b)            (p)->lpVtbl->GetDecalOrigin(p,a,b)
 #define IDirect3DRMTexture3_GetImage(p)                      (p)->lpVtbl->GetImage(p)
@@ -3503,7 +3503,7 @@ DECLARE_INTERFACE_(IDirect3DRMTexture3, IDirect3DRMVisual)
 #define IDirect3DRMTexture3_GetColors(p)                     (p)->lpVtbl->GetColors(p)
 #define IDirect3DRMTexture3_GetDecalScale(p)                 (p)->lpVtbl->GetDecalScale(p)
 #define IDirect3DRMTexture3_GetDecalTransparency(p)          (p)->lpVtbl->GetDecalTransparency(p)
-#define IDirect3DRMTexture3_GetDecalTransparencyColor(p)     (p)->lpVtbl->GetDecalTransparencyColor(p)
+#define IDirect3DRMTexture3_GetDecalTransparentColor(p)      (p)->lpVtbl->GetDecalTransparentColor(p)
 #define IDirect3DRMTexture3_InitFromImage(p,a)               (p)->lpVtbl->InitFromImage(p,a)
 #define IDirect3DRMTexture3_InitFromResource2(p,a,b,c)       (p)->lpVtbl->InitFromResource2(p,a,b,c)
 #define IDirect3DRMTexture3_GenerateMIPMap(p,a)              (p)->lpVtbl->GenerateMIPMap(p,a)
diff --git a/mingw-w64-headers/direct-x/include/d3dx9shader.h b/mingw-w64-headers/direct-x/include/d3dx9shader.h
index 6dd9f62..cd00a87 100644
--- a/mingw-w64-headers/direct-x/include/d3dx9shader.h
+++ b/mingw-w64-headers/direct-x/include/d3dx9shader.h
@@ -307,6 +307,43 @@ DECLARE_INTERFACE(ID3DXInclude)
 
 typedef struct ID3DXInclude *LPD3DXINCLUDE;
 
+typedef struct _D3DXFRAGMENT_DESC
+{
+    const char *Name;
+    DWORD Target;
+
+} D3DXFRAGMENT_DESC, *LPD3DXFRAGMENT_DESC;
+
+
+DEFINE_GUID(IID_ID3DXFragmentLinker, 0x1a2c0cc2, 0xe5b6, 0x4ebc, 0x9e, 0x8d, 0x39, 0xe, 0x5, 0x78, 0x11, 0xb6);
+
+#define INTERFACE ID3DXFragmentLinker
+DECLARE_INTERFACE_(ID3DXFragmentLinker, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ REFIID iid, void **ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+    STDMETHOD(GetDevice)(THIS_ struct IDirect3DDevice9 **device) PURE;
+    STDMETHOD_(UINT, GetNumberOfFragments)(THIS) PURE;
+
+    STDMETHOD_(D3DXHANDLE, GetFragmentHandleByIndex)(THIS_ UINT index) PURE;
+    STDMETHOD_(D3DXHANDLE, GetFragmentHandleByName)(THIS_ const char *name) PURE;
+    STDMETHOD(GetFragmentDesc)(THIS_ D3DXHANDLE name, D3DXFRAGMENT_DESC *frag_desc) PURE;
+
+    STDMETHOD(AddFragments)(THIS_ const DWORD *fragments) PURE;
+
+    STDMETHOD(GetAllFragments)(THIS_ ID3DXBuffer **buffer) PURE;
+    STDMETHOD(GetFragment)(THIS_ D3DXHANDLE name, ID3DXBuffer **buffer) PURE;
+
+    STDMETHOD(LinkShader)(THIS_ const char *profile, DWORD flags, const D3DXHANDLE *fragmenthandles, UINT fragments, ID3DXBuffer **buffer, ID3DXBuffer **errors) PURE;
+    STDMETHOD(LinkVertexShader)(THIS_ const char *profile, DWORD flags, const D3DXHANDLE *fragment_handles, UINT fragments, IDirect3DVertexShader9 **shader, ID3DXBuffer **errors) PURE;
+    STDMETHOD(LinkPixelShader)(THIS_ const char *profile, DWORD flags, const D3DXHANDLE *fragment_handles, UINT fragments, IDirect3DPixelShader9 **shader, ID3DXBuffer **errors) PURE;
+
+    STDMETHOD(ClearCache)(THIS) PURE;
+};
+#undef INTERFACE
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -379,6 +416,9 @@ HRESULT WINAPI D3DXGetShaderOutputSemantics(const DWORD *pFunction, D3DXSEMANTIC
 
 HRESULT WINAPI D3DXCreateTextureShader(const DWORD *pFunction, ID3DXTextureShader **ppTextureShader);
 
+HRESULT WINAPI D3DXCreateFragmentLinker(IDirect3DDevice9 *device, UINT size, ID3DXFragmentLinker **linker);
+HRESULT WINAPI D3DXCreateFragmentLinkerEx(IDirect3DDevice9 *device, UINT size, DWORD flags, ID3DXFragmentLinker **linker);
+
 #ifdef __cplusplus
 }
 #endif
