New subject: [PATCH] d3d11.idl: add the interfaces necessary to use the D3D11 video decoder

11 May 2015

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

This patch still shows plenty of signs that it was copypasted from Microsoft's headers.

Am 2015-05-11 um 11:00 schrieb Steve Lhomme:
...
From: Steve Lhomme <slhomme(a)matroska.org>
---
 include/d3d11.idl | 878 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 870 insertions(+), 8 deletions(-)

diff --git a/include/d3d11.idl b/include/d3d11.idl
index 3726d32..70afbd5 100644
--- a/include/d3d11.idl
+++ b/include/d3d11.idl
@@ -2125,16 +2125,878 @@ interface ID3D11Device : IUnknown
     UINT GetExceptionMode();
 }
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_MOCOMP_NOFGT, 0x1b81be64, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_MOCOMP_FGT,   0x1b81be65, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_IDCT_NOFGT,   0x1b81be66, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_IDCT_FGT,     0x1b81be67, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_VLD_NOFGT,    0x1b81be68, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_VLD_FGT,      0x1b81be69, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_VLD_WITHFMOASO_NOFGT,  0xd5f04ff9, 0x3418, 0x45d8, 0x95, 0x61, 0x32, 0xa7, 0x6a, 0xae, 0x2d, 0xdd);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_VLD_STEREO_PROGRESSIVE_NOFGT, 0xd79be8da, 0x0cf1, 0x4c81, 0xb8, 0x2a, 0x69, 0xa4, 0xe2, 0x36, 0xf4, 0x3d);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_VLD_STEREO_NOFGT,             0xf9aaccbb, 0xc2b6, 0x4cfc, 0x87, 0x79, 0x57, 0x07, 0xb1, 0x76, 0x05, 0x52);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_H264_VLD_MULTIVIEW_NOFGT,          0x705b9d82, 0x76cf, 0x49d6, 0xb7, 0xe6, 0xac, 0x88, 0x72, 0xdb, 0x01, 0x3c);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_WMV8_POSTPROC,     0x1b81be80, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_WMV8_MOCOMP,       0x1b81be81, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_WMV9_POSTPROC,     0x1b81be90, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_WMV9_MOCOMP,       0x1b81be91, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_WMV9_IDCT,         0x1b81be94, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_VC1_POSTPROC,      0x1b81beA0, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_VC1_MOCOMP,        0x1b81beA1, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_VC1_IDCT,          0x1b81beA2, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_VC1_VLD,           0x1b81beA3, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_VC1_D2010,         0x1b81beA4, 0xa0c7, 0x11d3, 0xb9, 0x84, 0x00, 0xc0, 0x4f, 0x2e, 0x73, 0xc5);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG4PT2_VLD_SIMPLE,           0xefd64d74, 0xc9e8, 0x41d7, 0xa5, 0xe9, 0xe9, 0xb0, 0xe3, 0x9f, 0xa3, 0x19);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG4PT2_VLD_ADVSIMPLE_NOGMC,  0xed418a9f, 0x010d, 0x4eda, 0x9a, 0xe3, 0x9a, 0x65, 0x35, 0x8d, 0x8d, 0x2e);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG4PT2_VLD_ADVSIMPLE_GMC,    0xab998b5b, 0x4258, 0x44a9, 0x9f, 0xeb, 0x94, 0xe5, 0x97, 0xa6, 0xba, 0xae);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_HEVC_VLD_MAIN,     0x5b11d51b, 0x2f4c, 0x4452, 0xbc, 0xc3, 0x09, 0xf2, 0xa1, 0x16, 0x0c, 0xc0);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_HEVC_VLD_MAIN10,   0x107af0e0, 0xef1a, 0x4d19, 0xab, 0xa8, 0x67, 0xa1, 0x63, 0x07, 0x3d, 0x13);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG2_MOCOMP,      0xe6a9f44b, 0x61b0, 0x4563, 0x9e, 0xa4, 0x63, 0xd2, 0xa3, 0xc6, 0xfe, 0x66);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG2_IDCT,        0xbf22ad00, 0x03ea, 0x4690, 0x80, 0x77, 0x47, 0x33, 0x46, 0x20, 0x9b, 0x7e);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG2_VLD,         0xee27417f, 0x5e28, 0x4e65, 0xbe, 0xea, 0x1d, 0x26, 0xb5, 0x08, 0xad, 0xc9);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG1_VLD,         0x6f3ec719, 0x3735, 0x42cc, 0x80, 0x63, 0x65, 0xcc, 0x3c, 0xb3, 0x66, 0x16);")
+cpp_quote("DEFINE_GUID(D3D11_DECODER_PROFILE_MPEG2and1_VLD,     0x86695f12, 0x340e, 0x4f04, 0x9f, 0xd3, 0x92, 0x53, 0xdd, 0x32, 0x74, 0x60);")
+
+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_DECODER_BUFFER_TYPE
+{
+    D3D11_VIDEO_DECODER_BUFFER_PICTURE_PARAMETERS          = 0,
+    D3D11_VIDEO_DECODER_BUFFER_MACROBLOCK_CONTROL          = 1,
+    D3D11_VIDEO_DECODER_BUFFER_RESIDUAL_DIFFERENCE         = 2,
+    D3D11_VIDEO_DECODER_BUFFER_DEBLOCKING_CONTROL          = 3,
+    D3D11_VIDEO_DECODER_BUFFER_INVERSE_QUANTIZATION_MATRIX = 4,
+    D3D11_VIDEO_DECODER_BUFFER_SLICE_CONTROL               = 5,
+    D3D11_VIDEO_DECODER_BUFFER_BITSTREAM                   = 6,
+    D3D11_VIDEO_DECODER_BUFFER_MOTION_VECTOR               = 7,
+    D3D11_VIDEO_DECODER_BUFFER_FILM_GRAIN                  = 8
+} D3D11_VIDEO_DECODER_BUFFER_TYPE;
+
+typedef struct D3D11_ENCRYPTED_BLOCK_INFO
+{
+    UINT NumEncryptedBytesAtBeginning;    
+    UINT NumBytesInSkipPattern;
+    UINT NumBytesInEncryptPattern;
+} D3D11_ENCRYPTED_BLOCK_INFO;
+
+typedef struct D3D11_VIDEO_DECODER_BUFFER_DESC
+{
+    D3D11_VIDEO_DECODER_BUFFER_TYPE BufferType;
+    UINT BufferIndex;
+    UINT DataOffset;
+    UINT DataSize;
+    UINT FirstMBaddress;
+    UINT NumMBsInBuffer;
+    UINT Width;
+    UINT Height;
+    UINT Stride;
+    UINT ReservedBits;
+    void *pIV;
+    UINT IVSize;
+    BOOL PartialEncryption;
+    D3D11_ENCRYPTED_BLOCK_INFO EncryptedBlockInfo;
+} D3D11_VIDEO_DECODER_BUFFER_DESC;
+
+typedef struct D3D11_VIDEO_DECODER_EXTENSION
+{
+    UINT Function;
+    void *pPrivateInputData;
+    UINT PrivateInputDataSize;
+    void *pPrivateOutputData;
+    UINT PrivateOutputDataSize;
+    UINT ResourceCount;
+    ID3D11Resource **ppResourceList;
+} D3D11_VIDEO_DECODER_EXTENSION;
+
+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_CONTENT_PROTECTION_CAPS
+{
+    UINT      Caps;
+    UINT      KeyExchangeTypeCount;
+    UINT      BlockAlignmentSize;
+    ULONGLONG ProtectedMemorySize;
+} D3D11_VIDEO_CONTENT_PROTECTION_CAPS;
+
+typedef struct D3D11_VIDEO_PROCESSOR_FILTER_RANGE 
+{
+  int   Minimum;
+  int   Maximum;
+  int   Default;
+  float Multiplier;
+} D3D11_VIDEO_PROCESSOR_FILTER_RANGE;
+
+typedef struct D3D11_VIDEO_COLOR_RGBA 
+{
+    float R;
+    float G;
+    float B;
+    float A;
+} D3D11_VIDEO_COLOR_RGBA;
+
+typedef struct D3D11_VIDEO_COLOR_YCbCrA 
+{
+    float Y;
+    float Cb;
+    float Cr;
+    float A;
+} D3D11_VIDEO_COLOR_YCbCrA;
+
+typedef struct D3D11_VIDEO_COLOR 
+{
+    union
+    {
+        D3D11_VIDEO_COLOR_YCbCrA YCbCr;
+        D3D11_VIDEO_COLOR_RGBA RGBA;
+    };
+} D3D11_VIDEO_COLOR;
+
+typedef struct D3D11_VIDEO_PROCESSOR_COLOR_SPACE 
+{
+    UINT Usage  :1;
+    UINT RGB_Range  :1;
+    UINT YCbCr_Matrix  :1;
+    UINT YCbCr_xvYCC  :1;
+    UINT Nominal_Range :2;
+    UINT Reserved : 26;
+} D3D11_VIDEO_PROCESSOR_COLOR_SPACE;
+
+typedef enum D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE 
+{
+    D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_OPAQUE        = 0,
+    D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_BACKGROUND    = 1,
+    D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_DESTINATION   = 2,
+    D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE_SOURCE_STREAM = 3 
+} D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE;
+
+typedef enum D3D11_VIDEO_PROCESSOR_OUTPUT_RATE 
+{
+    D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_NORMAL   = 0,
+    D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_HALF     = 1,
+    D3D11_VIDEO_PROCESSOR_OUTPUT_RATE_CUSTOM   = 2 
+} D3D11_VIDEO_PROCESSOR_OUTPUT_RATE;
+
+typedef enum D3D11_VIDEO_PROCESSOR_STEREO_FORMAT
+{
+    D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO               = 0,
+    D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_HORIZONTAL         = 1,
+    D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_VERTICAL           = 2,
+    D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_SEPARATE           = 3,
+    D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_MONO_OFFSET        = 4,
+    D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_ROW_INTERLEAVED    = 5,
+    D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_COLUMN_INTERLEAVED = 6,
+    D3D11_VIDEO_PROCESSOR_STEREO_FORMAT_CHECKERBOARD       = 7
+} D3D11_VIDEO_PROCESSOR_STEREO_FORMAT;
+
+typedef enum D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE
+{
+    D3D11_VIDEO_PROCESSOR_STEREO_FLIP_NONE   = 0,
+    D3D11_VIDEO_PROCESSOR_STEREO_FLIP_FRAME0 = 1,
+    D3D11_VIDEO_PROCESSOR_STEREO_FLIP_FRAME1 = 2
+} D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE;
+
+typedef enum D3D11_VIDEO_PROCESSOR_ROTATION 
+{
+    D3D11_VIDEO_PROCESSOR_ROTATION_IDENTITY = 0,
+    D3D11_VIDEO_PROCESSOR_ROTATION_90       = 1,
+    D3D11_VIDEO_PROCESSOR_ROTATION_180      = 2,
+    D3D11_VIDEO_PROCESSOR_ROTATION_270      = 3
+} D3D11_VIDEO_PROCESSOR_ROTATION;
+
+[
+    object,
+    local,
+    uuid(3c9c5b51-995d-48d1-9b8d-fa5caeded65c)
+]
+interface ID3D11VideoDecoder : ID3D11DeviceChild
+{
+    HRESULT GetCreationParameters( 
+        [out] D3D11_VIDEO_DECODER_DESC *pVideoDesc,
+        [out] D3D11_VIDEO_DECODER_CONFIG *pConfig);
+    HRESULT GetDriverHandle( 
+        [out] HANDLE *pDriverHandle);
+}
+
+[
+    object,
+    local,
+    uuid(1d7b0652-185f-41c6-85ce-0c5be3d4ae6c)
+]
+interface ID3D11VideoProcessor : ID3D11DeviceChild
+{
+    void GetContentDesc( 
+        [out] D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pDesc);
+    void GetRateConversionCaps(
+        [out] D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS *pCaps);
+}
+
+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;
+
+[
+    object,
+    local,
+    uuid(a048285e-25a9-4527-bd93-d68b68c44254)
+]
+interface ID3D11VideoProcessorOutputView : ID3D11View
+{
+    void GetDesc( [out] D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC *pDesc);
+}
+
+[
+    object,
+    local,
+    uuid(9b32f9ad-bdcc-40a6-a39d-d5c865845720)
+]
+interface ID3D11CryptoSession : ID3D11DeviceChild
+{
+    void GetCryptoType(
+        [out] GUID *pCryptoType);
+    void GetDecoderProfile(
+        [out] GUID *pDecoderProfile);
+    HRESULT GetCertificateSize( 
+        [out] UINT *pCertificateSize);
+    HRESULT GetCertificate(
+        [in] UINT CertificateSize, 
+        [out] BYTE *pCertificate);
+    void GetCryptoSessionHandle(
+        [out] HANDLE *pCryptoSessionHandle);
+}
+
+#define D3D11_OMAC_SIZE    16
+
+typedef struct D3D11_OMAC
+{
+    BYTE Omac[D3D11_OMAC_SIZE];
+} D3D11_OMAC;
+
+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 struct D3D11_AUTHENTICATED_CONFIGURE_OUTPUT
+{
+    D3D11_OMAC                          omac;  
+    GUID                                ConfigureType;          
+    HANDLE                              hChannel;
+    UINT                                SequenceNumber;     
+    HRESULT                             ReturnCode;
+} D3D11_AUTHENTICATED_CONFIGURE_OUTPUT;
+
+[
+    object,
+    local,
+    uuid(3015a308-dcbd-47aa-a747-192486d14d4a)
+]
+interface ID3D11AuthenticatedChannel : ID3D11DeviceChild
+{
+    HRESULT GetCertificateSize( 
+        [out] UINT *pCertificateSize);
+    HRESULT GetCertificate(
+        [in] UINT CertificateSize, 
+        [out] BYTE *pCertificate);
+    void GetChannelHandle(
+        [out] HANDLE *pChannelHandle); 
+}
+
+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;
+
+[
+    object,
+    local,
+    uuid(11ec5a5f-51dc-4945-ab34-6e8c21300ea5)
+]
+interface ID3D11VideoProcessorInputView : ID3D11View
+{
+    void GetDesc( [out] D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC *pDesc);
+}
+
+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;
+
+[
+    object,
+    local,
+    uuid(c2931aea-2a85-4f20-860f-fba1fd256e18)
+]
+interface ID3D11VideoDecoderOutputView : ID3D11View
+{
+    void GetDesc( [out] D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC *pDesc);
+}
+
+typedef struct D3D11_VIDEO_PROCESSOR_STREAM
+{
+    BOOL Enable;
+    UINT OutputIndex;
+    UINT InputFrameOrField;
+    UINT PastFrames;
+    UINT FutureFrames;
+    ID3D11VideoProcessorInputView **ppPastSurfaces;
+    ID3D11VideoProcessorInputView *pInputSurface;
+    ID3D11VideoProcessorInputView **ppFutureSurfaces;
+    ID3D11VideoProcessorInputView **ppPastSurfacesRight;
+    ID3D11VideoProcessorInputView *pInputSurfaceRight;
+    ID3D11VideoProcessorInputView **ppFutureSurfacesRight;
+} D3D11_VIDEO_PROCESSOR_STREAM;
+
+[
+    object,
+    local,
+    uuid(61f21c45-3c0e-4a74-9cea-67100d9ad5e4)
+]
+interface ID3D11VideoContext : ID3D11DeviceChild
+{
+    HRESULT GetDecoderBuffer( 
+        [in] ID3D11VideoDecoder *pDecoder,
+        [in] D3D11_VIDEO_DECODER_BUFFER_TYPE Type,
+        [out] UINT *pBufferSize,
+        [out] void **ppBuffer);
+    HRESULT ReleaseDecoderBuffer( 
+        [in] ID3D11VideoDecoder *pDecoder,
+        [in] D3D11_VIDEO_DECODER_BUFFER_TYPE Type);
+    HRESULT DecoderBeginFrame(
+        [in] ID3D11VideoDecoder *pDecoder,
+        [in] ID3D11VideoDecoderOutputView *pView,
+        [in] UINT ContentKeySize,
+        [in] const void *pContentKey);
+    HRESULT DecoderEndFrame( 
+        [in] ID3D11VideoDecoder *pDecoder);
+    HRESULT SubmitDecoderBuffers( 
+        [in] ID3D11VideoDecoder *pDecoder,
+        [in] UINT NumBuffers, 
+        [in] const D3D11_VIDEO_DECODER_BUFFER_DESC *pBufferDesc);
+    HRESULT DecoderExtension( 
+        [in] ID3D11VideoDecoder *pDecoder,
+        [in] const D3D11_VIDEO_DECODER_EXTENSION *pExtensionData);
+    void VideoProcessorSetOutputTargetRect( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] BOOL Enable,
+        [in] const RECT *pRect);
+    void VideoProcessorSetOutputBackgroundColor( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] BOOL YCbCr,
+        [in] const D3D11_VIDEO_COLOR *pColor);
+    void VideoProcessorSetOutputColorSpace( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] const D3D11_VIDEO_PROCESSOR_COLOR_SPACE *pColorSpace);
+    void VideoProcessorSetOutputAlphaFillMode( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE AlphaFillMode,
+        [in] UINT StreamIndex);
+    void VideoProcessorSetOutputConstriction( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] BOOL Enable,
+        [in] SIZE Size);
+    void VideoProcessorSetOutputStereoMode( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] BOOL Enable);
+    HRESULT VideoProcessorSetOutputExtension( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] const GUID *pExtensionGuid,
+        [in] UINT DataSize,
+        [in] void *pData);
+    void VideoProcessorGetOutputTargetRect( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [out] BOOL *Enabled,
+        [out] RECT *pRect);
+    void VideoProcessorGetOutputBackgroundColor( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [out] BOOL *pYCbCr,
+        [out] D3D11_VIDEO_COLOR *pColor);
+    void VideoProcessorGetOutputColorSpace( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [out] D3D11_VIDEO_PROCESSOR_COLOR_SPACE *pColorSpace);
+    void VideoProcessorGetOutputAlphaFillMode( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [out] D3D11_VIDEO_PROCESSOR_ALPHA_FILL_MODE *pAlphaFillMode,
+        [out] UINT *pStreamIndex);
+    void VideoProcessorGetOutputConstriction( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [out] BOOL *pEnabled,
+        [out] SIZE *pSize);
+    void VideoProcessorGetOutputStereoMode( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [out] BOOL *pEnabled);
+    HRESULT VideoProcessorGetOutputExtension( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] const GUID *pExtensionGuid,
+        [in] UINT DataSize,
+        [out] void *pData);
+    void VideoProcessorSetStreamFrameFormat( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [in] D3D11_VIDEO_FRAME_FORMAT FrameFormat);
+    void VideoProcessorSetStreamColorSpace( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [in] const D3D11_VIDEO_PROCESSOR_COLOR_SPACE *pColorSpace);
+    void VideoProcessorSetStreamOutputRate( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [in] D3D11_VIDEO_PROCESSOR_OUTPUT_RATE OutputRate,
+        [in] BOOL RepeatFrame,
+        [in] const DXGI_RATIONAL *pCustomRate);
+    void VideoProcessorSetStreamSourceRect( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [in] BOOL Enable,
+        [in] const RECT *pRect);
+    void VideoProcessorSetStreamDestRect( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [in] BOOL Enable,
+        [in] const RECT *pRect);
+    void VideoProcessorSetStreamAlpha( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [in] BOOL Enable,
+        [in] FLOAT Alpha);
+    void VideoProcessorSetStreamPalette( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [in] UINT Count,
+        [in] const UINT *pEntries);
+    void VideoProcessorSetStreamPixelAspectRatio( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [in] BOOL Enable,
+        [in] const DXGI_RATIONAL *pSourceAspectRatio,
+        [in] const DXGI_RATIONAL *pDestinationAspectRatio);
+    void VideoProcessorSetStreamLumaKey(
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [in] BOOL Enable,
+        [in] FLOAT Lower,
+        [in] FLOAT Upper);
+    void VideoProcessorSetStreamStereoFormat(
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [in] BOOL Enable,
+        [in] D3D11_VIDEO_PROCESSOR_STEREO_FORMAT Format,
+        [in] BOOL LeftViewFrame0,
+        [in] BOOL BaseViewFrame0,
+        [in] D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE FlipMode,
+        [in] int MonoOffset);
+    void VideoProcessorSetStreamAutoProcessingMode( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [in] BOOL Enable);
+    void VideoProcessorSetStreamFilter( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [in] D3D11_VIDEO_PROCESSOR_FILTER Filter,
+        [in] BOOL Enable,
+        [in] int Level);
+    HRESULT VideoProcessorSetStreamExtension( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [in] const GUID *pExtensionGuid,
+        [in] UINT DataSize,
+        [in] void *pData);
+    void VideoProcessorGetStreamFrameFormat( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [out] D3D11_VIDEO_FRAME_FORMAT *pFrameFormat);
+    void VideoProcessorGetStreamColorSpace( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [out] D3D11_VIDEO_PROCESSOR_COLOR_SPACE *pColorSpace);
+    void VideoProcessorGetStreamOutputRate( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [out] D3D11_VIDEO_PROCESSOR_OUTPUT_RATE *pOutputRate,
+        [out] BOOL *pRepeatFrame,
+        [out] DXGI_RATIONAL *pCustomRate);
+    void VideoProcessorGetStreamSourceRect( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [out] BOOL *pEnabled,
+        [out] RECT *pRect);
+    void VideoProcessorGetStreamDestRect( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [out] BOOL *pEnabled,
+        [out] RECT *pRect);
+    void VideoProcessorGetStreamAlpha( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [out] BOOL *pEnabled,
+        [out] FLOAT *pAlpha);
+    void VideoProcessorGetStreamPalette( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [in] UINT Count,
+        [out] UINT *pEntries);
+    void VideoProcessorGetStreamPixelAspectRatio( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [out] BOOL *pEnabled,
+        [out] DXGI_RATIONAL *pSourceAspectRatio,
+        [out] DXGI_RATIONAL *pDestinationAspectRatio);
+    void VideoProcessorGetStreamLumaKey(
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [out] BOOL *pEnabled,
+        [out] FLOAT *pLower,
+        [out] FLOAT *pUpper);
+    void VideoProcessorGetStreamStereoFormat(
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [out] BOOL *pEnable,
+        [out] D3D11_VIDEO_PROCESSOR_STEREO_FORMAT *pFormat,
+        [out] BOOL *pLeftViewFrame0,
+        [out] BOOL *pBaseViewFrame0,
+        [out] D3D11_VIDEO_PROCESSOR_STEREO_FLIP_MODE *pFlipMode,
+        [out] int *MonoOffset);
+    void VideoProcessorGetStreamAutoProcessingMode( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [out] BOOL *pEnabled);
+    void VideoProcessorGetStreamFilter( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [in] D3D11_VIDEO_PROCESSOR_FILTER Filter,
+        [out] BOOL *pEnabled,
+        [out] int *pLevel);
+    HRESULT VideoProcessorGetStreamExtension( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [in] const GUID *pExtensionGuid,
+        [in] UINT DataSize,
+        [out] void *pData);
+    HRESULT VideoProcessorBlt(
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] ID3D11VideoProcessorOutputView *pView,
+        [in] UINT OutputFrame,
+        [in] UINT StreamCount,
+        [in] const D3D11_VIDEO_PROCESSOR_STREAM *pStreams);
+    HRESULT NegotiateCryptoSessionKeyExchange(
+        [in] ID3D11CryptoSession *pCryptoSession, 
+        [in] UINT DataSize, 
+        [in,out] void *pData);
+    void EncryptionBlt( 
+        [in] ID3D11CryptoSession *pCryptoSession, 
+        [in] ID3D11Texture2D *pSrcSurface,
+        [in] ID3D11Texture2D *pDstSurface,
+        [in] UINT IVSize,
+        [in,out] void *pIV);
+    void DecryptionBlt( 
+        [in] ID3D11CryptoSession *pCryptoSession, 
+        [in] ID3D11Texture2D *pSrcSurface,
+        [in] ID3D11Texture2D *pDstSurface,
+        [in] D3D11_ENCRYPTED_BLOCK_INFO *pEncryptedBlockInfo,
+        [in] UINT ContentKeySize,
+        [in] const void *pContentKey,
+        [in] UINT IVSize,
+        [in,out] void *pIV);
+    void StartSessionKeyRefresh( 
+        [in] ID3D11CryptoSession *pCryptoSession, 
+        [in] UINT RandomNumberSize, 
+        [out] void *pRandomNumber);
+    void FinishSessionKeyRefresh(
+        [in] ID3D11CryptoSession *pCryptoSession);
+    HRESULT GetEncryptionBltKey( 
+        [in] ID3D11CryptoSession *pCryptoSession, 
+        [in] UINT KeySize, 
+        [out] void *pReadbackKey);
+    HRESULT NegotiateAuthenticatedChannelKeyExchange(
+        [in] ID3D11AuthenticatedChannel *pChannel, 
+        [in] UINT DataSize, 
+        [in,out] void *pData);
+    HRESULT QueryAuthenticatedChannel(
+        [in] ID3D11AuthenticatedChannel *pChannel, 
+        [in] UINT InputSize, 
+        [in] const void *pInput,
+        [in] UINT OutputSize,
+        [out] void *pOutput);
+    HRESULT ConfigureAuthenticatedChannel( 
+        [in] ID3D11AuthenticatedChannel *pChannel, 
+        [in] UINT InputSize,
+        [in] const void *pInput,
+        [out] D3D11_AUTHENTICATED_CONFIGURE_OUTPUT *pOutput);
+    void VideoProcessorSetStreamRotation( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [in] BOOL Enable,
+        [in] D3D11_VIDEO_PROCESSOR_ROTATION Rotation);
+    void VideoProcessorGetStreamRotation( 
+        [in] ID3D11VideoProcessor *pVideoProcessor,
+        [in] UINT StreamIndex,
+        [out] BOOL *pEnable,
+        [out] D3D11_VIDEO_PROCESSOR_ROTATION *pRotation);
+}
+
+[
+    object,
+    local,
+    uuid(31627037-53ab-4200-9061-05faa9ab45f9)
+]
+interface ID3D11VideoProcessorEnumerator : ID3D11DeviceChild
+{
+    HRESULT GetVideoProcessorContentDesc(
+        [out] D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pContentDesc);
+    HRESULT CheckVideoProcessorFormat(
+        [in] DXGI_FORMAT Format,
+        [out] UINT *pFlags);
+    HRESULT GetVideoProcessorCaps(
+        [out] D3D11_VIDEO_PROCESSOR_CAPS *pCaps);
+    HRESULT GetVideoProcessorRateConversionCaps(
+        [in] UINT TypeIndex,
+        [out] D3D11_VIDEO_PROCESSOR_RATE_CONVERSION_CAPS *pCaps);
+    HRESULT GetVideoProcessorCustomRate(
+        [in] UINT TypeIndex,
+        [in] UINT CustomRateIndex,
+        [out] D3D11_VIDEO_PROCESSOR_CUSTOM_RATE *pRate);
+    HRESULT GetVideoProcessorFilterRange(
+        [in] D3D11_VIDEO_PROCESSOR_FILTER Filter,
+        [out] D3D11_VIDEO_PROCESSOR_FILTER_RANGE *pRange);
+}
+
+[
+    object,
+    local,
+    uuid(10ec4d5b-975a-4689-b9e4-d0aac30fe333)
+]
+interface ID3D11VideoDevice : IUnknown
+{
+    HRESULT CreateVideoDecoder( 
+        [in] const D3D11_VIDEO_DECODER_DESC *pVideoDesc,
+        [in] const D3D11_VIDEO_DECODER_CONFIG *pConfig,
+        [out] ID3D11VideoDecoder **ppDecoder);
+    HRESULT CreateVideoProcessor( 
+        [in] ID3D11VideoProcessorEnumerator *pEnum,
+        [in] UINT RateConversionIndex,
+        [out] ID3D11VideoProcessor **ppVideoProcessor);
+    HRESULT CreateAuthenticatedChannel( 
+        [in] D3D11_AUTHENTICATED_CHANNEL_TYPE ChannelType,
+        [out] ID3D11AuthenticatedChannel **ppAuthenticatedChannel);
+    HRESULT CreateCryptoSession( 
+        [in] const GUID *pCryptoType,
+        [in] const GUID *pDecoderProfile,
+        [in] const GUID *pKeyExchangeType,
+        [out] ID3D11CryptoSession **ppCryptoSession);
+    HRESULT CreateVideoDecoderOutputView(
+        [in] ID3D11Resource *pResource,
+        [in] const D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC *pDesc,
+        [out] ID3D11VideoDecoderOutputView **ppVDOVView);
+    HRESULT CreateVideoProcessorInputView(
+        [in] ID3D11Resource *pResource,
+        [in] ID3D11VideoProcessorEnumerator *pEnum,
+        [in] const D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC *pDesc,
+        [out] ID3D11VideoProcessorInputView **ppVPIView);
+    HRESULT CreateVideoProcessorOutputView(
+        [in] ID3D11Resource *pResource,
+        [in] ID3D11VideoProcessorEnumerator *pEnum,
+        [in] const D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC *pDesc,
+        [out] ID3D11VideoProcessorOutputView **ppVPOView);
+    HRESULT CreateVideoProcessorEnumerator(
+        [in] const D3D11_VIDEO_PROCESSOR_CONTENT_DESC *pDesc,
+        [out] ID3D11VideoProcessorEnumerator **ppEnum);
+    UINT GetVideoDecoderProfileCount(void);
+    HRESULT GetVideoDecoderProfile(
+        [in] UINT Index,
+        [out] GUID *pDecoderProfile);
+    HRESULT CheckVideoDecoderFormat(
+        [in] const GUID *pDecoderProfile,
+        [in] DXGI_FORMAT Format,
+        [out] BOOL *pSupported);
+    HRESULT GetVideoDecoderConfigCount(
+        [in] const D3D11_VIDEO_DECODER_DESC *pDesc,
+        [out] UINT *pCount);
+    HRESULT GetVideoDecoderConfig(
+        [in] const D3D11_VIDEO_DECODER_DESC *pDesc,
+        [in] UINT Index,
+        [out] D3D11_VIDEO_DECODER_CONFIG *pConfig);
+    HRESULT GetContentProtectionCaps( 
+        [in] const GUID *pCryptoType,
+        [in] const GUID *pDecoderProfile,
+        [out] D3D11_VIDEO_CONTENT_PROTECTION_CAPS *pCaps);
+    HRESULT CheckCryptoKeyExchange(
+        [in] const GUID *pCryptoType,
+        [in] const GUID *pDecoderProfile,
+        [in] UINT Index,
+        [out] GUID *pKeyExchangeType);
+    HRESULT SetPrivateData(
+        [in] REFGUID guid,
+        [in] UINT DataSize,
+        [in] const void *pData);
+    HRESULT SetPrivateDataInterface(
+        [in] REFGUID guid,
+        [in] const IUnknown *pData);
+}
+
 typedef enum D3D11_CREATE_DEVICE_FLAG {
-    D3D11_CREATE_DEVICE_SINGLETHREADED  = 0x0001,
-    D3D11_CREATE_DEVICE_DEBUG           = 0x0002,
-    D3D11_CREATE_DEVICE_SWITCH_TO_REF   = 0x0004,
-    D3D11_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS = 0x0008,
-    D3D11_CREATE_DEVICE_BGRA_SUPPORT    = 0x0020,
-    D3D11_CREATE_DEVICE_DEBUGGABLE      = 0x0040,
+    D3D11_CREATE_DEVICE_SINGLETHREADED                                = 0x0001,
+    D3D11_CREATE_DEVICE_DEBUG                                         = 0x0002,
+    D3D11_CREATE_DEVICE_SWITCH_TO_REF                                 = 0x0004,
+    D3D11_CREATE_DEVICE_PREVENT_INTERNAL_THREADING_OPTIMIZATIONS      = 0x0008,
+    D3D11_CREATE_DEVICE_BGRA_SUPPORT                                  = 0x0020,
+    D3D11_CREATE_DEVICE_DEBUGGABLE                                    = 0x0040,
     D3D11_CREATE_DEVICE_PREVENT_ALTERING_LAYER_SETTINGS_FROM_REGISTRY = 0x0080,
-    D3D11_CREATE_DEVICE_DISABLE_GPU_TIMEOUT = 0x0100,
-    D3D11_CREATE_DEVICE_VIDEO_SUPPORT   = 0x0800
+    D3D11_CREATE_DEVICE_DISABLE_GPU_TIMEOUT                           = 0x0100,
+    D3D11_CREATE_DEVICE_VIDEO_SUPPORT                                 = 0x0800
 } D3D11_CREATE_DEVICE_FLAG;
const UINT D3D11_SDK_VERSION = 7;
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v2

iQIcBAEBAgAGBQJVUHHsAAoJEN0/YqbEcdMwt5IP/RQUorEad9xeKijd+ylUAZNH
k9W6EpbcMUcwd8bWEE95XQadiG+NQ/IpQDrVAanqX8yW5rA9ldfVZmX5AzgQDY1b
2+z6DZ41S8AqUQFkjakJmlAJu9KAEh+jbDFEl5742ZRu0XARF1cQkJ8tDuNKOmUY
dPetkbiPVNoP3wbfTr5PaQD5Ti4IgzkoPXP2ZEnLw//BGbqvj8zODN3KEEPrXW4X
Vx9lGihijOiSbCs225sBCA9gV5qGdtAZaDRaYBhcBhssL79/zfe+IhRgSlFDfN9G
DVu7MhCbJpC4ZhMiJq7XwywBFDFmRKRJ6ppOi5luUHOuowooG1OV71j+zkiTcId0
xkKiwz7hvRn634rbP8MO7jShVGJczYJRCECNYa8UcIz1IFJm/jas1lj3fNt0mZlw
DWzOv5MxvNVyI61IgQs2kgJhOjKmya62Wsz1f7W4TFWazMg2/QKN4K97P2GH3B4L
sypDv7Zgszds4kZDnihVzbJY115XlrbEEjyC2/wTzLr07ThwaFQGs1xlOkIYFiJY
GrRdouYJlfGmg1vCV7BOgNkeQrOdEXWOgmD9lw3cDWqnBMvabVBPYWPUGk62yzNQ
F9o0hktsMOAN+eHqD1kH5EcZX5qICIb+ys0SWWpROAkfnS3cbJfdBHeNYiRAFMfZ
TVNEg78wDgXDA8MmxhAQ
=efTb
-----END PGP SIGNATURE-----

    

Re: [PATCH] d3d11.idl: add the interfaces necessary to use the D3D11 video decoder

Stefan Dösinger

Steve Lhomme

tags

participants (2)