[PATCH] d3d11.idl: add the interfaces necessary to use the D3D11 video decoder
Steve Lhomme
robux4 at videolabs.io
Mon May 11 04:00:47 CDT 2015
From: Steve Lhomme <slhomme at 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;
--
2.4.0
More information about the wine-patches
mailing list