1 // Licensed under the Apache License, Version 2.0
2 // <LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
3 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
4 // All files in the project carrying such notice may not be copied, modified, or distributed
5 // except according to those terms.
6 use ctypes::c_void;
7 use shared::basetsd::{UINT64, UINT8};
8 use shared::dxgiformat::DXGI_FORMAT;
9 use shared::dxgitype::{DXGI_COLOR_SPACE_TYPE, DXGI_RATIONAL};
10 use shared::guiddef::{GUID, REFIID};
11 use shared::minwindef::{BOOL, BYTE, DWORD, FLOAT, INT, UINT};
12 use um::d3d11::{
13     D3D11_BLEND, D3D11_BLEND_OP, D3D11_BOX, D3D11_CULL_MODE, D3D11_FILL_MODE, D3D11_RECT,
14     D3D11_VIDEO_DECODER_BUFFER_TYPE, D3D11_VIDEO_DECODER_CONFIG, D3D11_VIDEO_DECODER_DESC,
15     ID3D11BlendState, ID3D11BlendStateVtbl, ID3D11Buffer, ID3D11CryptoSession, ID3D11Device,
16     ID3D11DeviceChild, ID3D11DeviceChildVtbl, ID3D11DeviceContext, ID3D11DeviceContextVtbl,
17     ID3D11DeviceVtbl, ID3D11RasterizerState, ID3D11RasterizerStateVtbl, ID3D11Resource,
18     ID3D11VideoContext, ID3D11VideoContextVtbl, ID3D11VideoDecoder, ID3D11VideoDevice,
19     ID3D11VideoDeviceVtbl, ID3D11VideoProcessor, ID3D11VideoProcessorEnumerator,
20     ID3D11VideoProcessorEnumeratorVtbl, ID3D11View
21 };
22 use um::d3dcommon::D3D_FEATURE_LEVEL;
23 use um::unknwnbase::{IUnknown, IUnknownVtbl};
24 use um::winnt::{HANDLE, HRESULT, LPCWSTR};
25 DEFINE_GUID!{IID_ID3D11BlendState1,
26     0xcc86fabe, 0xda55, 0x401d, 0x85, 0xe7, 0xe3, 0xc9, 0xde, 0x28, 0x77, 0xe9}
27 DEFINE_GUID!{IID_ID3D11RasterizerState1,
28     0x1217d7a6, 0x5039, 0x418c, 0xb0, 0x42, 0x9c, 0xbe, 0x25, 0x6a, 0xfd, 0x6e}
29 DEFINE_GUID!{IID_ID3DDeviceContextState,
30     0x5c1e0d8a, 0x7c23, 0x48f9, 0x8c, 0x59, 0xa9, 0x29, 0x58, 0xce, 0xff, 0x11}
31 DEFINE_GUID!{IID_ID3D11DeviceContext1,
32     0xbb2c6faa, 0xb5fb, 0x4082, 0x8e, 0x6b, 0x38, 0x8b, 0x8c, 0xfa, 0x90, 0xe1}
33 DEFINE_GUID!{IID_ID3D11VideoContext1,
34     0xa7f026da, 0xa5f8, 0x4487, 0xa5, 0x64, 0x15, 0xe3, 0x43, 0x57, 0x65, 0x1e}
35 DEFINE_GUID!{IID_ID3D11VideoDevice1,
36     0x29da1d51, 0x1321, 0x4454, 0x80, 0x4b, 0xf5, 0xfc, 0x9f, 0x86, 0x1f, 0x0f}
37 DEFINE_GUID!{IID_ID3D11VideoProcessorEnumerator1,
38     0x465217f2, 0x5568, 0x43cf, 0xb5, 0xb9, 0xf6, 0x1d, 0x54, 0x53, 0x1c, 0xa1}
39 DEFINE_GUID!{IID_ID3D11Device1,
40     0xa04bfb29, 0x08ef, 0x43d6, 0xa4, 0x9c, 0xa9, 0xbd, 0xbd, 0xcb, 0xe6, 0x86}
41 DEFINE_GUID!{IID_ID3DUserDefinedAnnotation,
42     0xb2daad8b, 0x03d4, 0x4dbf, 0x95, 0xeb, 0x32, 0xab, 0x4b, 0x63, 0xd0, 0xab}
43 ENUM!{enum D3D11_COPY_FLAGS {
44     D3D11_COPY_NO_OVERWRITE = 0x00000001,
45     D3D11_COPY_DISCARD = 0x00000002,
46 }}
47 ENUM!{enum D3D11_LOGIC_OP {
48     D3D11_LOGIC_OP_CLEAR = 0,
49     D3D11_LOGIC_OP_SET = 1,
50     D3D11_LOGIC_OP_COPY = 2,
51     D3D11_LOGIC_OP_COPY_INVERTED = 3,
52     D3D11_LOGIC_OP_NOOP = 4,
53     D3D11_LOGIC_OP_INVERT = 5,
54     D3D11_LOGIC_OP_AND = 6,
55     D3D11_LOGIC_OP_NAND = 7,
56     D3D11_LOGIC_OP_OR = 8,
57     D3D11_LOGIC_OP_NOR = 9,
58     D3D11_LOGIC_OP_XOR = 10,
59     D3D11_LOGIC_OP_EQUIV = 11,
60     D3D11_LOGIC_OP_AND_REVERSE = 12,
61     D3D11_LOGIC_OP_AND_INVERTED = 13,
62     D3D11_LOGIC_OP_OR_REVERSE = 14,
63     D3D11_LOGIC_OP_OR_INVERTED = 15,
64 }}
65 STRUCT!{struct D3D11_RENDER_TARGET_BLEND_DESC1 {
66     BlendEnable: BOOL,
67     LogicOpEnable: BOOL,
68     SrcBlend: D3D11_BLEND,
69     DestBlend: D3D11_BLEND,
70     BlendOp: D3D11_BLEND_OP,
71     SrcBlendAlpha: D3D11_BLEND,
72     DestBlendAlpha: D3D11_BLEND,
73     BlendOpAlpha: D3D11_BLEND_OP,
74     LogicOp: D3D11_LOGIC_OP,
75     RenderTargetWriteMask: UINT8,
76 }}
77 STRUCT!{struct D3D11_BLEND_DESC1 {
78     AlphaToCoverageEnable: BOOL,
79     IndependentBlendEnable: BOOL,
80     RenderTarget: [D3D11_RENDER_TARGET_BLEND_DESC1; 8],
81 }}
82 RIDL!{#[uuid(0xcc86fabe, 0xda55, 0x401d, 0x85, 0xe7, 0xe3, 0xc9, 0xde, 0x28, 0x77, 0xe9)]
83 interface ID3D11BlendState1(ID3D11BlendState1Vtbl): ID3D11BlendState(ID3D11BlendStateVtbl) {
84     fn GetDesc1(
85         pDesc: *mut D3D11_BLEND_DESC1,
86     ) -> (),
87 }}
88 STRUCT!{struct D3D11_RASTERIZER_DESC1 {
89     FillMode: D3D11_FILL_MODE,
90     CullMode: D3D11_CULL_MODE,
91     FrontCounterClockwise: BOOL,
92     DepthBias: INT,
93     DepthBiasClamp: FLOAT,
94     SlopeScaledDepthBias: FLOAT,
95     DepthClipEnable: BOOL,
96     ScissorEnable: BOOL,
97     MultisampleEnable: BOOL,
98     AntialiasedLineEnable: BOOL,
99     ForcedSampleCount: UINT,
100 }}
101 RIDL!{#[uuid(0x1217d7a6, 0x5039, 0x418c, 0xb0, 0x42, 0x9c, 0xbe, 0x25, 0x6a, 0xfd, 0x6e)]
102 interface ID3D11RasterizerState1(ID3D11RasterizerState1Vtbl):
103     ID3D11RasterizerState(ID3D11RasterizerStateVtbl) {
104     fn GetDesc1(
105         pDesc: *mut D3D11_RASTERIZER_DESC1,
106     ) -> (),
107 }}
108 ENUM!{enum D3D11_1_CREATE_DEVICE_CONTEXT_STATE_FLAG {
109     D3D11_1_CREATE_DEVICE_CONTEXT_STATE_SINGLETHREADED = 0x1,
110 }}
111 RIDL!{#[uuid(0x5c1e0d8a, 0x7c23, 0x48f9, 0x8c, 0x59, 0xa9, 0x29, 0x58, 0xce, 0xff, 0x11)]
112 interface ID3DDeviceContextState(ID3DDeviceContextStateVtbl):
113     ID3D11DeviceChild(ID3D11DeviceChildVtbl) {}}
114 RIDL!{#[uuid(0xbb2c6faa, 0xb5fb, 0x4082, 0x8e, 0x6b, 0x38, 0x8b, 0x8c, 0xfa, 0x90, 0xe1)]
115 interface ID3D11DeviceContext1(ID3D11DeviceContext1Vtbl):
116     ID3D11DeviceContext(ID3D11DeviceContextVtbl) {
117     fn CopySubresourceRegion1(
118         pDstResource: *mut ID3D11Resource,
119         DstSubresource: UINT,
120         DstX: UINT,
121         DstY: UINT,
122         DstZ: UINT,
123         pSrcResource: *mut ID3D11Resource,
124         SrcSubresource: UINT,
125         pSrcBox: *const D3D11_BOX,
126         CopyFlags: UINT,
127     ) -> (),
128     fn UpdateSubresource1(
129         pDstResource: *mut ID3D11Resource,
130         DstSubresource: UINT,
131         pDstBox: *const D3D11_BOX,
132         pSrcData: *mut c_void,
133         SrcRowPitch: UINT,
134         SrcDepthPitch: UINT,
135         CopyFlags: UINT,
136     ) -> (),
137     fn DiscardResource(
138         pResource: *mut ID3D11Resource,
139     ) -> (),
140     fn DiscardView(
141         pResource: *mut ID3D11Resource,
142     ) -> (),
143     fn VSSetConstantBuffers1(
144         StartSlot: UINT,
145         NumBuffers: UINT,
146         ppConstantBuffers: *const *mut ID3D11Buffer,
147         pFirstConstant: *const UINT,
148         pNumConstants: *const UINT,
149     ) -> (),
150     fn HSSetConstantBuffers1(
151         StartSlot: UINT,
152         NumBuffers: UINT,
153         ppConstantBuffers: *const *mut ID3D11Buffer,
154         pFirstConstant: *const UINT,
155         pNumConstants: *const UINT,
156     ) -> (),
157     fn DSSetConstantBuffers1(
158         StartSlot: UINT,
159         NumBuffers: UINT,
160         ppConstantBuffers: *const *mut ID3D11Buffer,
161         pFirstConstant: *const UINT,
162         pNumConstants: *const UINT,
163     ) -> (),
164     fn GSSetConstantBuffers1(
165         StartSlot: UINT,
166         NumBuffers: UINT,
167         ppConstantBuffers: *const *mut ID3D11Buffer,
168         pFirstConstant: *const UINT,
169         pNumConstants: *const UINT,
170     ) -> (),
171     fn PSSetConstantBuffers1(
172         StartSlot: UINT,
173         NumBuffers: UINT,
174         ppConstantBuffers: *const *mut ID3D11Buffer,
175         pFirstConstant: *const UINT,
176         pNumConstants: *const UINT,
177     ) -> (),
178     fn CSSetConstantBuffers1(
179         StartSlot: UINT,
180         NumBuffers: UINT,
181         ppConstantBuffers: *const *mut ID3D11Buffer,
182         pFirstConstant: *const UINT,
183         pNumConstants: *const UINT,
184     ) -> (),
185     fn VSGetConstantBuffers1(
186         StartSlot: UINT,
187         NumBuffers: UINT,
188         ppConstantBuffers: *mut *mut ID3D11Buffer,
189         pFirstConstant: *mut UINT,
190         pNumConstants: *mut UINT,
191     ) -> (),
192     fn HSGetConstantBuffers1(
193         StartSlot: UINT,
194         NumBuffers: UINT,
195         ppConstantBuffers: *mut *mut ID3D11Buffer,
196         pFirstConstant: *mut UINT,
197         pNumConstants: *mut UINT,
198     ) -> (),
199     fn DSGetConstantBuffers1(
200         StartSlot: UINT,
201         NumBuffers: UINT,
202         ppConstantBuffers: *mut *mut ID3D11Buffer,
203         pFirstConstant: *mut UINT,
204         pNumConstants: *mut UINT,
205     ) -> (),
206     fn GSGetConstantBuffers1(
207         StartSlot: UINT,
208         NumBuffers: UINT,
209         ppConstantBuffers: *mut *mut ID3D11Buffer,
210         pFirstConstant: *mut UINT,
211         pNumConstants: *mut UINT,
212     ) -> (),
213     fn PSGetConstantBuffers1(
214         StartSlot: UINT,
215         NumBuffers: UINT,
216         ppConstantBuffers: *mut *mut ID3D11Buffer,
217         pFirstConstant: *mut UINT,
218         pNumConstants: *mut UINT,
219     ) -> (),
220     fn CSGetConstantBuffers1(
221         StartSlot: UINT,
222         NumBuffers: UINT,
223         ppConstantBuffers: *mut *mut ID3D11Buffer,
224         pFirstConstant: *mut UINT,
225         pNumConstants: *mut UINT,
226     ) -> (),
227     fn SwapDeviceContextState(
228         pState: *mut ID3DDeviceContextState,
229         ppPreviousState: *mut *mut ID3DDeviceContextState,
230     ) -> (),
231     fn ClearView(
232         pView: *mut ID3D11View,
233         Color: [FLOAT; 4],
234         pRect: *const D3D11_RECT,
235         NumRects: UINT,
236     ) -> (),
237     fn DiscardView1(
238         pResourceView: *mut ID3D11View,
239         pRects: *const D3D11_RECT,
240         NumRects: UINT,
241     ) -> (),
242 }}
243 STRUCT!{struct D3D11_VIDEO_DECODER_SUB_SAMPLE_MAPPING_BLOCK {
244     ClearSize: UINT,
245     EncryptedSize: UINT,
246 }}
247 STRUCT!{struct D3D11_VIDEO_DECODER_BUFFER_DESC1 {
248     BufferType: D3D11_VIDEO_DECODER_BUFFER_TYPE,
249     DataOffset: UINT,
250     DataSize: UINT,
251     pIV: *mut c_void,
252     IVSize: UINT,
253     pSubSampleMappingBlock: *mut D3D11_VIDEO_DECODER_SUB_SAMPLE_MAPPING_BLOCK,
254     SubSampleMappingCount: UINT,
255 }}
256 STRUCT!{struct D3D11_VIDEO_DECODER_BEGIN_FRAME_CRYPTO_SESSION {
257     pCryptoSession: *mut ID3D11CryptoSession,
258     BlobSize: UINT,
259     pBlob: *mut c_void,
260     pKeyInfoId: *mut GUID,
261     PrivateDataSize: UINT,
262     pPrivateData: *mut c_void,
263 }}
264 ENUM!{enum D3D11_VIDEO_DECODER_CAPS {
265     D3D11_VIDEO_DECODER_CAPS_DOWNSAMPLE = 0x1,
266     D3D11_VIDEO_DECODER_CAPS_NON_REAL_TIME = 0x02,
267     D3D11_VIDEO_DECODER_CAPS_DOWNSAMPLE_DYNAMIC = 0x04,
268     D3D11_VIDEO_DECODER_CAPS_DOWNSAMPLE_REQUIRED = 0x08,
269     D3D11_VIDEO_DECODER_CAPS_UNSUPPORTED = 0x10,
270 }}
271 ENUM!{enum D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINTS {
272     D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINT_MULTIPLANE_OVERLAY_ROTATION = 0x01,
273     D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINT_MULTIPLANE_OVERLAY_RESIZE = 0x02,
274     D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINT_MULTIPLANE_OVERLAY_COLOR_SPACE_CONVERSION = 0x04,
275     D3D11_VIDEO_PROCESSOR_BEHAVIOR_HINT_TRIPLE_BUFFER_OUTPUT = 0x08,
276 }}
277 STRUCT!{struct D3D11_VIDEO_PROCESSOR_STREAM_BEHAVIOR_HINT {
278     Enable: BOOL,
279     Width: UINT,
280     Height: UINT,
281     Format: DXGI_FORMAT,
282 }}
283 ENUM!{enum D3D11_CRYPTO_SESSION_STATUS {
284     D3D11_CRYPTO_SESSION_STATUS_OK = 0,
285     D3D11_CRYPTO_SESSION_STATUS_KEY_LOST = 1,
286     D3D11_CRYPTO_SESSION_STATUS_KEY_AND_CONTENT_LOST = 2,
287 }}
288 STRUCT!{struct D3D11_KEY_EXCHANGE_HW_PROTECTION_INPUT_DATA {
289     PrivateDataSize: UINT,
290     HWProtectionDataSize: UINT,
291     pbInput: [BYTE; 4],
292 }}
293 STRUCT!{struct D3D11_KEY_EXCHANGE_HW_PROTECTION_OUTPUT_DATA {
294     PrivateDataSize: UINT,
295     MaxHWProtectionDataSize: UINT,
296     HWProtectionDataSize: UINT,
297     TransportTime: UINT64,
298     ExecutionTime: UINT64,
299     pbOutput: [BYTE; 4],
300 }}
301 STRUCT!{struct D3D11_KEY_EXCHANGE_HW_PROTECTION_DATA {
302     HWProtectionFunctionID: UINT,
303     pInputData: *mut D3D11_KEY_EXCHANGE_HW_PROTECTION_INPUT_DATA,
304     pOutputData: *mut D3D11_KEY_EXCHANGE_HW_PROTECTION_OUTPUT_DATA,
305     Status: HRESULT,
306 }}
307 STRUCT!{struct D3D11_VIDEO_SAMPLE_DESC {
308     Width: UINT,
309     Height: UINT,
310     Format: DXGI_FORMAT,
311     ColorSpace: DXGI_COLOR_SPACE_TYPE,
312 }}
313 RIDL!{#[uuid(0xa7f026da, 0xa5f8, 0x4487, 0xa5, 0x64, 0x15, 0xe3, 0x43, 0x57, 0x65, 0x1e)]
314 interface ID3D11VideoContext1(ID3D11VideoContext1Vtbl):
315     ID3D11VideoContext(ID3D11VideoContextVtbl) {
316     fn SubmitDecoderBuffers1(
317         pDecoder: *mut ID3D11VideoDecoder,
318         NumBuffers: UINT,
319         pBufferDesc: *const D3D11_VIDEO_DECODER_BUFFER_DESC1,
320     ) -> HRESULT,
321     fn GetDataForNewHardwareKey(
322         pCryptoSession: *mut ID3D11CryptoSession,
323         PrivateInputSize: UINT,
324         pPrivateInputData: *const c_void,
325         pPrivateOutputData: *mut UINT64,
326     ) -> HRESULT,
327     fn CheckCryptoSessionStatus(
328         pCryptoSession: *mut ID3D11CryptoSession,
329         pStatus: *mut D3D11_CRYPTO_SESSION_STATUS,
330     ) -> HRESULT,
331     fn DecoderEnableDownsampling(
332         pDecoder: *mut ID3D11VideoDecoder,
333         InputColorSpace: DXGI_COLOR_SPACE_TYPE,
334         pOutputDesc: *const D3D11_VIDEO_SAMPLE_DESC,
335         ReferenceFrameCount: UINT,
336     ) -> HRESULT,
337     fn DecoderUpdateDownsampling(
338         pDecoder: *mut ID3D11VideoDecoder,
339         pOutputDesc: *const D3D11_VIDEO_SAMPLE_DESC,
340     ) -> HRESULT,
341     fn VideoProcessorSetOutputColorSpace1(
342         pVideoProcessor: *mut ID3D11VideoProcessor,
343         ColorSpace: DXGI_COLOR_SPACE_TYPE,
344     ) -> (),
345     fn VideoProcessorSetOutputShaderUsage(
346         pVideoProcessor: *mut ID3D11VideoProcessor,
347         ShaderUsage: BOOL,
348     ) -> (),
349     fn VideoProcessorGetOutputColorSpace1(
350         pVideoProcessor: *mut ID3D11VideoProcessor,
351         pColorSpace: *mut DXGI_COLOR_SPACE_TYPE,
352     ) -> (),
353     fn VideoProcessorGetOutputShaderUsage(
354         pVideoProcessor: *mut ID3D11VideoProcessor,
355         pShaderUsage: *mut BOOL,
356     ) -> (),
357     fn VideoProcessorSetStreamColorSpace1(
358         pVideoProcessor: *mut ID3D11VideoProcessor,
359         StreamIndex: UINT,
360         ColorSpace: DXGI_COLOR_SPACE_TYPE,
361     ) -> (),
362     fn VideoProcessorSetStreamMirror(
363         pVideoProcessor: *mut ID3D11VideoProcessor,
364         StreamIndex: UINT,
365         Enable: BOOL,
366         FlipHorizontal: BOOL,
367         FlipVertical: BOOL,
368     ) -> (),
369     fn VideoProcessorGetStreamColorSpace1(
370         pVideoProcessor: *mut ID3D11VideoProcessor,
371         StreamIndex: UINT,
372         pColorSpace: *mut DXGI_COLOR_SPACE_TYPE,
373     ) -> (),
374     fn VideoProcessorGetStreamMirror(
375         pVideoProcessor: *mut ID3D11VideoProcessor,
376         StreamIndex: UINT,
377         pEnable: *mut BOOL,
378         pFlipHorizontal: *mut BOOL,
379         pFlipVertical: *mut BOOL,
380     ) -> (),
381     fn VideoProcessorGetBehaviorHints(
382         pVideoProcessor: *mut ID3D11VideoProcessor,
383         OutputWidth: UINT,
384         OutputHeight: UINT,
385         OutputFormat: DXGI_FORMAT,
386         StreamCount: UINT,
387         pStreams: *const D3D11_VIDEO_PROCESSOR_STREAM_BEHAVIOR_HINT,
388         pBehaviorHints: *mut UINT,
389     ) -> (),
390 }}
391 RIDL!{#[uuid(0x29da1d51, 0x1321, 0x4454, 0x80, 0x4b, 0xf5, 0xfc, 0x9f, 0x86, 0x1f, 0x0f)]
392 interface ID3D11VideoDevice1(ID3D11VideoDevice1Vtbl): ID3D11VideoDevice(ID3D11VideoDeviceVtbl) {
393     fn GetCryptoSessionPrivateDataSize(
394         pCryptoType: *const GUID,
395         pDecoderProfile: *const GUID,
396         pKeyExchangeType: *const GUID,
397         pPrivateInputSize: *mut UINT,
398         pPrivateOutputSize: *mut UINT,
399     ) -> HRESULT,
400     fn GetVideoDecoderCaps(
401         pDecoderProfile: *const GUID,
402         SampleWidth: UINT,
403         SampleHeight: UINT,
404         pFrameRate: *const DXGI_RATIONAL,
405         BitRate: UINT,
406         pCryptoType: *const GUID,
407         pDecoderCaps: *mut UINT,
408     ) -> HRESULT,
409     fn CheckVideoDecoderDownsampling(
410         pInputDesc: *const D3D11_VIDEO_DECODER_DESC,
411         InputColorSpace: DXGI_COLOR_SPACE_TYPE,
412         pInputConfig: *const D3D11_VIDEO_DECODER_CONFIG,
413         pFrameRate: *const DXGI_RATIONAL,
414         pOutputDesc: *const D3D11_VIDEO_SAMPLE_DESC,
415         pSupported: *mut BOOL,
416         pRealTimeHint: *mut BOOL,
417     ) -> HRESULT,
418     fn RecommendVideoDecoderDownsampleParameters(
419         pInputDesc: *const D3D11_VIDEO_DECODER_DESC,
420         InputColorSpace: DXGI_COLOR_SPACE_TYPE,
421         pInputConfig: *const D3D11_VIDEO_DECODER_CONFIG,
422         pRecommendedOutputDesc: *mut D3D11_VIDEO_SAMPLE_DESC,
423     ) -> HRESULT,
424 }}
425 RIDL!{#[uuid(0x465217f2, 0x5568, 0x43cf, 0xb5, 0xb9, 0xf6, 0x1d, 0x54, 0x53, 0x1c, 0xa1)]
426 interface ID3D11VideoProcessorEnumerator1(ID3D11VideoProcessorEnumerator1Vtbl):
427     ID3D11VideoProcessorEnumerator(ID3D11VideoProcessorEnumeratorVtbl) {
428     fn CheckVideoProcessorFormatConversion(
429         InputFormat: DXGI_FORMAT,
430         InputCOlorSpace: DXGI_COLOR_SPACE_TYPE,
431         OutputFormat: DXGI_FORMAT,
432         OutputColorSpace: DXGI_COLOR_SPACE_TYPE,
433         pSupported: *mut BOOL,
434     ) -> HRESULT,
435 }}
436 RIDL!{#[uuid(0xa04bfb29, 0x08ef, 0x43d6, 0xa4, 0x9c, 0xa9, 0xbd, 0xbd, 0xcb, 0xe6, 0x86)]
437 interface ID3D11Device1(ID3D11Device1Vtbl): ID3D11Device(ID3D11DeviceVtbl) {
438     fn GetImmediateContext1(
439         ppImmediateContext: *mut *mut ID3D11DeviceContext1,
440     ) -> (),
441     fn CreateDeferredContext1(
442         ContextFlags: UINT,
443         ppDeferredContext: *mut *mut ID3D11DeviceContext1,
444     ) -> HRESULT,
445     fn CreateBlendState(
446         pBlendStateDesc: *const D3D11_BLEND_DESC1,
447         ppBlendState: *mut *mut ID3D11BlendState1,
448     ) -> HRESULT,
449     fn CreateRasterizerState(
450         pRasterizerDesc: *const D3D11_RASTERIZER_DESC1,
451         ppRasterizerState: *mut *mut ID3D11RasterizerState1,
452     ) -> HRESULT,
453     fn CreateDeviceContextState(
454         Flags: UINT,
455         pFeatureLevels: *const D3D_FEATURE_LEVEL,
456         FeatureLevels: UINT,
457         SDKVersion: UINT,
458         EmulatedInterface: REFIID,
459         pChosenFeatureLevel: *mut D3D_FEATURE_LEVEL,
460         ppContextState: *mut *mut ID3DDeviceContextState,
461     ) -> HRESULT,
462     fn OpenSharedResource1(
463         hResource: HANDLE,
464         returnedInterface: REFIID,
465         ppResource: *mut *mut c_void,
466     ) -> HRESULT,
467     fn OpenSharedResourceByName(
468         Name: LPCWSTR,
469         dwDesiredAccess: DWORD,
470         returnedInterface: REFIID,
471         ppResource: *mut *mut c_void,
472     ) -> HRESULT,
473 }}
474 RIDL!{#[uuid(0xb2daad8b, 0x03d4, 0x4dbf, 0x95, 0xeb, 0x32, 0xab, 0x4b, 0x63, 0xd0, 0xab)]
475 interface ID3DUserDefinedAnnotation(ID3DUserDefinedAnnotationVtbl): IUnknown(IUnknownVtbl) {
476     fn BeginEvent(
477         Name: LPCWSTR,
478     ) -> INT,
479     fn EndEvent() -> INT,
480     fn SetMarker(
481         Name: LPCWSTR,
482     ) -> (),
483     fn GetStatus() -> BOOL,
484 }}
485