-
Notifications
You must be signed in to change notification settings - Fork 0
/
Presenter.h
704 lines (622 loc) · 27.4 KB
/
Presenter.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
#pragma once
#include "Common.h"
#include "display.h"
namespace DX11VideoRenderer
{
class CPresenter :
public IMFVideoDisplayControl,
public IMFGetService,
private CBase
{
public:
CPresenter(void);
virtual ~CPresenter(void);
// IUnknown
STDMETHODIMP_(ULONG) AddRef(void);
STDMETHODIMP QueryInterface(REFIID iid, __RPC__deref_out _Result_nullonfailure_ void** ppv);
STDMETHODIMP_(ULONG) Release(void);
// IMFVideoDisplayControl
STDMETHODIMP GetAspectRatioMode(__RPC__out DWORD* pdwAspectRatioMode) { return E_NOTIMPL; }
STDMETHODIMP GetBorderColor(__RPC__out COLORREF* pClr) { return E_NOTIMPL; }
STDMETHODIMP GetCurrentImage(__RPC__inout BITMAPINFOHEADER* pBih, __RPC__deref_out_ecount_full_opt(*pcbDib) BYTE** pDib, __RPC__out DWORD* pcbDib, __RPC__inout_opt LONGLONG* pTimestamp) { return E_NOTIMPL; }
STDMETHODIMP GetFullscreen(__RPC__out BOOL* pfFullscreen);
STDMETHODIMP GetIdealVideoSize(__RPC__inout_opt SIZE* pszMin, __RPC__inout_opt SIZE* pszMax) { return E_NOTIMPL; }
STDMETHODIMP GetNativeVideoSize(__RPC__inout_opt SIZE* pszVideo, __RPC__inout_opt SIZE* pszARVideo) { return E_NOTIMPL; }
STDMETHODIMP GetRenderingPrefs(__RPC__out DWORD* pdwRenderFlags) { return E_NOTIMPL; }
STDMETHODIMP GetVideoPosition(__RPC__out MFVideoNormalizedRect* pnrcSource, __RPC__out LPRECT prcDest) { return E_NOTIMPL; }
STDMETHODIMP GetVideoWindow(__RPC__deref_out_opt HWND* phwndVideo) { return E_NOTIMPL; }
STDMETHODIMP RepaintVideo(void) { return E_NOTIMPL; }
STDMETHODIMP SetAspectRatioMode(DWORD dwAspectRatioMode) { return E_NOTIMPL; }
STDMETHODIMP SetBorderColor(COLORREF Clr) { return E_NOTIMPL; }
STDMETHODIMP SetFullscreen(BOOL fFullscreen);
STDMETHODIMP SetRenderingPrefs(DWORD dwRenderingPrefs) { return E_NOTIMPL; }
STDMETHODIMP SetVideoPosition(__RPC__in_opt const MFVideoNormalizedRect* pnrcSource, __RPC__in_opt const LPRECT prcDest) { return E_NOTIMPL; }
STDMETHODIMP SetVideoWindow(__RPC__in HWND hwndVideo);
// IMFGetService
STDMETHODIMP GetService(__RPC__in REFGUID guidService, __RPC__in REFIID riid, __RPC__deref_out_opt LPVOID* ppvObject);
BOOL CanProcessNextSample(void);
HRESULT Flush(void);
HRESULT GetMonitorRefreshRate(DWORD* pdwMonitorRefreshRate);
HRESULT IsMediaTypeSupported(IMFMediaType* pMediaType, DXGI_FORMAT dxgiFormat);
HRESULT PresentFrame(void);
HRESULT ProcessFrame(IMFMediaType* pCurrentType, IMFSample* pSample, UINT32* punInterlaceMode, BOOL* pbDeviceChanged, BOOL* pbProcessAgain, IMFSample** ppOutputSample = NULL);
HRESULT SetCurrentMediaType(IMFMediaType* pMediaType);
HRESULT Shutdown(void);
private:
void AspectRatioCorrectSize(
LPSIZE lpSizeImage, // size to be aspect ratio corrected
const SIZE& sizeAr, // aspect ratio of image
const SIZE& sizeOrig, // original image size
BOOL ScaleXorY // axis to correct in
);
void CheckDecodeSwitchRegKey(void);
HRESULT CheckDeviceState(BOOL* pbDeviceChanged);
BOOL CheckEmptyRect(RECT* pDst);
HRESULT CheckShutdown(void) const;
HRESULT CreateDCompDeviceAndVisual(void);
HRESULT CreateDXGIManagerAndDevice(D3D_DRIVER_TYPE DriverType=D3D_DRIVER_TYPE_HARDWARE);
HRESULT CreateXVP(void);
HRESULT FindBOBProcessorIndex(DWORD* pIndex);
HRESULT GetVideoDisplayArea(IMFMediaType* pType, MFVideoArea* pArea);
void LetterBoxDstRect(
LPRECT lprcLBDst, // output letterboxed rectangle
const RECT& rcSrc, // input source rectangle
const RECT& rcDst // input destination rectangle
);
void PixelAspectToPictureAspect(
int Width,
int Height,
int PixelAspectX,
int PixelAspectY,
int* pPictureAspectX,
int* pPictureAspectY
);
HRESULT ProcessFrameUsingD3D11( ID3D11Texture2D* pLeftTexture2D, ID3D11Texture2D* pRightTexture2D, UINT dwLeftViewIndex, UINT dwRightViewIndex, RECT rcDest, UINT32 unInterlaceMode, IMFSample** ppVideoOutFrame );
HRESULT ProcessFrameUsingXVP( IMFMediaType* pCurrentType, IMFSample* pVideoFrame, ID3D11Texture2D* pTexture2D, RECT rcDest, IMFSample** ppVideoOutFrame, BOOL* pbInputFrameUsed );
void ReduceToLowestTerms(
int NumeratorIn,
int DenominatorIn,
int* pNumeratorOut,
int* pDenominatorOut
);
HRESULT SetMonitor(UINT adapterID);
void SetVideoContextParameters(ID3D11VideoContext* pVideoContext, const RECT* pSRect, const RECT* pTRect, UINT32 unInterlaceMode);
HRESULT SetVideoMonitor(HWND hwndVideo);
HRESULT SetXVPOutputMediaType(IMFMediaType* pType, DXGI_FORMAT vpOutputFormat);
_Post_satisfies_(this->m_pSwapChain1 != NULL)
HRESULT UpdateDXGISwapChain(void);
void UpdateRectangles(RECT* pDst, RECT* pSrc);
long m_nRefCount; // reference count
CCritSec m_critSec; // critical section for thread safety
BOOL m_IsShutdown; // Flag to indicate if Shutdown() method was called.
IDXGIFactory2* m_pDXGIFactory2;
ID3D11Device* m_pD3D11Device;
ID3D11DeviceContext* m_pD3DImmediateContext;
IMFDXGIDeviceManager* m_pDXGIManager;
IDXGIOutput1* m_pDXGIOutput1;
IMFVideoSampleAllocatorEx* m_pSampleAllocatorEx;
IDCompositionDevice* m_pDCompDevice;
IDCompositionTarget* m_pHwndTarget;
IDCompositionVisual* m_pRootVisual;
BOOL m_bSoftwareDXVADeviceInUse;
HWND m_hwndVideo;
CMonitorArray* m_pMonitors;
CAMDDrawMonitorInfo* m_lpCurrMon;
UINT m_DeviceResetToken;
UINT m_ConnectionGUID;
UINT m_DXSWSwitch;
UINT m_useXVP;
UINT m_useDCompVisual;
UINT m_useDebugLayer;
ID3D11VideoDevice* m_pDX11VideoDevice;
ID3D11VideoProcessorEnumerator* m_pVideoProcessorEnum;
ID3D11VideoProcessor* m_pVideoProcessor;
IDXGISwapChain1* m_pSwapChain1;
BOOL m_bDeviceChanged;
BOOL m_bResize;
BOOL m_b3DVideo;
BOOL m_bStereoEnabled;
MFVideo3DFormat m_vp3DOutput;
BOOL m_bFullScreenState;
BOOL m_bCanProcessNextSample;
RECT m_displayRect;
UINT32 m_imageWidthInPixels;
UINT32 m_imageHeightInPixels;
UINT32 m_uiRealDisplayWidth;
UINT32 m_uiRealDisplayHeight;
RECT m_rcSrcApp;
RECT m_rcDstApp;
IMFTransform* m_pXVP;
IMFVideoProcessorControl* m_pXVPControl;
};
/////////////////////////////////////////////////////////////////////////////////////////////
// Wrapper class for D3D11 Device and D3D11 Video device used for DXVA to Software decode switch
class CPrivate_ID3D11VideoDevice : public ID3D11VideoDevice
{
private:
ID3D11VideoDevice* m_pReal;
ULONG m_cRef;
public:
CPrivate_ID3D11VideoDevice(ID3D11VideoDevice* pReal) :
m_pReal(pReal),
m_cRef(0)
{
}
virtual ~CPrivate_ID3D11VideoDevice(void)
{
}
STDMETHODIMP QueryInterface(
/* [in] */ REFIID riid,
/* [iid_is][out] */ __RPC__deref_out void __RPC_FAR* __RPC_FAR* ppvObject)
{
if (__uuidof(ID3D11VideoDevice) == riid)
{
this->AddRef();
*ppvObject = this;
return S_OK;
}
else
{
return m_pReal->QueryInterface(riid,ppvObject);
}
}
STDMETHODIMP_(ULONG) AddRef(void)
{
InterlockedIncrement(&m_cRef);
return m_pReal->AddRef();
}
STDMETHODIMP_(ULONG) Release(void)
{
ULONG ulVal = m_pReal->Release();
if (0 == InterlockedDecrement(&m_cRef))
{
}
return ulVal;
}
STDMETHODIMP CreateVideoDecoder(
_In_ const D3D11_VIDEO_DECODER_DESC* pVideoDesc,
_In_ const D3D11_VIDEO_DECODER_CONFIG* pConfig,
_Out_ ID3D11VideoDecoder** ppDecoder)
{
return E_FAIL;
}
STDMETHODIMP CreateVideoProcessor(
_In_ ID3D11VideoProcessorEnumerator* pEnum,
_In_ UINT RateConversionIndex,
_Out_ ID3D11VideoProcessor** ppVideoProcessor)
{
return m_pReal->CreateVideoProcessor(pEnum,RateConversionIndex,ppVideoProcessor);
}
STDMETHODIMP CreateAuthenticatedChannel(
_In_ D3D11_AUTHENTICATED_CHANNEL_TYPE ChannelType,
_Out_ ID3D11AuthenticatedChannel** ppAuthenticatedChannel)
{
return m_pReal->CreateAuthenticatedChannel(ChannelType,ppAuthenticatedChannel);
}
STDMETHODIMP CreateCryptoSession(
_In_ const GUID* pCryptoType,
_In_opt_ const GUID* pDecoderProfile,
_In_ const GUID* pKeyExchangeType,
_Outptr_ ID3D11CryptoSession** ppCryptoSession)
{
return m_pReal->CreateCryptoSession(pCryptoType,pDecoderProfile,pKeyExchangeType,ppCryptoSession);
}
STDMETHODIMP CreateVideoDecoderOutputView(
_In_ ID3D11Resource* pResource,
_In_ const D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC* pDesc,
_Out_opt_ ID3D11VideoDecoderOutputView** ppVDOVView)
{
return m_pReal->CreateVideoDecoderOutputView(pResource,pDesc,ppVDOVView);
}
STDMETHODIMP CreateVideoProcessorInputView(
_In_ ID3D11Resource* pResource,
_In_ ID3D11VideoProcessorEnumerator* pEnum,
_In_ const D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC* pDesc,
_Out_opt_ ID3D11VideoProcessorInputView** ppVPIView)
{
return m_pReal->CreateVideoProcessorInputView(pResource,pEnum,pDesc,ppVPIView);
}
STDMETHODIMP CreateVideoProcessorOutputView(
_In_ ID3D11Resource* pResource,
_In_ ID3D11VideoProcessorEnumerator* pEnum,
_In_ const D3D11_VIDEO_PROCESSOR_OUTPUT_VIEW_DESC* pDesc,
_Out_opt_ ID3D11VideoProcessorOutputView** ppVPOView)
{
return m_pReal->CreateVideoProcessorOutputView(pResource,pEnum,pDesc,ppVPOView);
}
STDMETHODIMP CreateVideoProcessorEnumerator(
_In_ const D3D11_VIDEO_PROCESSOR_CONTENT_DESC* pDesc,
_Out_ ID3D11VideoProcessorEnumerator** ppEnum)
{
return m_pReal->CreateVideoProcessorEnumerator(pDesc,ppEnum);
}
STDMETHODIMP_(UINT) GetVideoDecoderProfileCount(void)
{
return m_pReal->GetVideoDecoderProfileCount();
}
STDMETHODIMP GetVideoDecoderProfile(
_In_ UINT Index,
_Out_ GUID* pDecoderProfile)
{
return m_pReal->GetVideoDecoderProfile(Index,pDecoderProfile);
}
STDMETHODIMP CheckVideoDecoderFormat(
_In_ const GUID* pDecoderProfile,
_In_ DXGI_FORMAT Format,
_Out_ BOOL* pSupported)
{
return m_pReal->CheckVideoDecoderFormat(pDecoderProfile,Format,pSupported);
}
STDMETHODIMP GetVideoDecoderConfigCount(
_In_ const D3D11_VIDEO_DECODER_DESC* pDesc,
_Out_ UINT* pCount)
{
return m_pReal->GetVideoDecoderConfigCount(pDesc,pCount);
}
STDMETHODIMP GetVideoDecoderConfig(
_In_ const D3D11_VIDEO_DECODER_DESC* pDesc,
_In_ UINT Index,
_Out_ D3D11_VIDEO_DECODER_CONFIG* pConfig)
{
return m_pReal->GetVideoDecoderConfig(pDesc,Index,pConfig);
}
STDMETHODIMP GetContentProtectionCaps(
_In_opt_ const GUID* pCryptoType,
_In_opt_ const GUID* pDecoderProfile,
_Out_ D3D11_VIDEO_CONTENT_PROTECTION_CAPS* pCaps)
{
return m_pReal->GetContentProtectionCaps(pCryptoType,pDecoderProfile,pCaps);
}
STDMETHODIMP CheckCryptoKeyExchange(
_In_ const GUID* pCryptoType,
_In_opt_ const GUID* pDecoderProfile,
_In_ UINT Index,
_Out_ GUID* pKeyExchangeType)
{
return m_pReal->CheckCryptoKeyExchange(pCryptoType,pDecoderProfile,Index,pKeyExchangeType);
}
STDMETHODIMP SetPrivateData(
_In_ REFGUID guid,
_In_ UINT DataSize,
_In_reads_bytes_opt_(DataSize) const void* pData)
{
return m_pReal->SetPrivateData(guid,DataSize,pData);
}
STDMETHODIMP SetPrivateDataInterface(
_In_ REFGUID guid,
_In_opt_ const IUnknown* pData)
{
return m_pReal->SetPrivateDataInterface(guid,pData);
}
};
class CPrivate_ID3D11Device : public ID3D11Device
{
private:
ID3D11Device* m_pReal;
ULONG m_cRef;
CPrivate_ID3D11VideoDevice* m_pVideoDevice;
public:
CPrivate_ID3D11Device(ID3D11Device* pReal) :
m_pReal(pReal),
m_cRef(1),
m_pVideoDevice(NULL)
{
ID3D11VideoDevice* pDevice;
m_pReal->QueryInterface(__uuidof(ID3D11VideoDevice),(void**)&pDevice);
m_pVideoDevice = new CPrivate_ID3D11VideoDevice(pDevice);
if (pDevice != NULL)
{
pDevice->Release();
}
}
virtual ~CPrivate_ID3D11Device(void)
{
SafeDelete(m_pVideoDevice);
}
STDMETHODIMP QueryInterface(
/* [in] */ REFIID riid,
/* [iid_is][out] */ __RPC__deref_out void __RPC_FAR* __RPC_FAR* ppvObject)
{
if (__uuidof(ID3D11VideoDevice) == riid)
{
m_pVideoDevice->AddRef();
*ppvObject = m_pVideoDevice;
return S_OK;
}
else if (__uuidof(ID3D11Device) == riid)
{
this->AddRef();
*ppvObject = this;
return S_OK;
}
else
{
return m_pReal->QueryInterface(riid,ppvObject);
}
}
STDMETHODIMP_(ULONG) AddRef(void)
{
InterlockedIncrement(&m_cRef);
return m_pReal->AddRef();
}
STDMETHODIMP_(ULONG) Release(void)
{
ULONG ulVal = m_pReal->Release();
if (0 == InterlockedDecrement(&m_cRef))
{
delete this;
}
return ulVal;
}
STDMETHODIMP CreateBuffer(
_In_ const D3D11_BUFFER_DESC* pDesc,
_In_opt_ const D3D11_SUBRESOURCE_DATA* pInitialData,
_Out_opt_ ID3D11Buffer** ppBuffer)
{
return m_pReal->CreateBuffer(pDesc,pInitialData,ppBuffer);
}
STDMETHODIMP CreateTexture1D(
_In_ const D3D11_TEXTURE1D_DESC* pDesc,
_In_reads_opt_(pDesc->MipLevels * pDesc->ArraySize) const D3D11_SUBRESOURCE_DATA* pInitialData,
_Out_opt_ ID3D11Texture1D** ppTexture1D)
{
return m_pReal->CreateTexture1D(pDesc,pInitialData,ppTexture1D);
}
STDMETHODIMP CreateTexture2D(
_In_ const D3D11_TEXTURE2D_DESC* pDesc,
_In_reads_opt_(pDesc->MipLevels * pDesc->ArraySize) const D3D11_SUBRESOURCE_DATA* pInitialData,
_Out_opt_ ID3D11Texture2D** ppTexture2D)
{
return m_pReal->CreateTexture2D(pDesc,pInitialData,ppTexture2D);
}
STDMETHODIMP CreateTexture3D(
_In_ const D3D11_TEXTURE3D_DESC* pDesc,
_In_reads_opt_(pDesc->MipLevels) const D3D11_SUBRESOURCE_DATA* pInitialData,
_Out_opt_ ID3D11Texture3D** ppTexture3D)
{
return m_pReal->CreateTexture3D(pDesc,pInitialData,ppTexture3D);
}
STDMETHODIMP CreateShaderResourceView(
_In_ ID3D11Resource* pResource,
_In_opt_ const D3D11_SHADER_RESOURCE_VIEW_DESC* pDesc,
_Out_opt_ ID3D11ShaderResourceView** ppSRView)
{
return m_pReal->CreateShaderResourceView(pResource,pDesc,ppSRView);
}
STDMETHODIMP CreateUnorderedAccessView(
_In_ ID3D11Resource* pResource,
_In_opt_ const D3D11_UNORDERED_ACCESS_VIEW_DESC* pDesc,
_Out_opt_ ID3D11UnorderedAccessView** ppUAView)
{
return m_pReal->CreateUnorderedAccessView(pResource,pDesc,ppUAView);
}
STDMETHODIMP CreateRenderTargetView(
_In_ ID3D11Resource* pResource,
_In_opt_ const D3D11_RENDER_TARGET_VIEW_DESC* pDesc,
_Out_opt_ ID3D11RenderTargetView** ppRTView)
{
return m_pReal->CreateRenderTargetView(pResource,pDesc,ppRTView);
}
STDMETHODIMP CreateDepthStencilView(
_In_ ID3D11Resource* pResource,
_In_opt_ const D3D11_DEPTH_STENCIL_VIEW_DESC* pDesc,
_Out_opt_ ID3D11DepthStencilView** ppDepthStencilView)
{
return m_pReal->CreateDepthStencilView(pResource,pDesc,ppDepthStencilView);
}
STDMETHODIMP CreateInputLayout(
_In_reads_(NumElements) const D3D11_INPUT_ELEMENT_DESC* pInputElementDescs,
_In_range_( 0, D3D11_IA_VERTEX_INPUT_STRUCTURE_ELEMENT_COUNT ) UINT NumElements,
_In_ const void* pShaderBytecodeWithInputSignature,
_In_ SIZE_T BytecodeLength,
_Out_opt_ ID3D11InputLayout** ppInputLayout)
{
return m_pReal->CreateInputLayout(pInputElementDescs,NumElements,pShaderBytecodeWithInputSignature,BytecodeLength,ppInputLayout);
}
STDMETHODIMP CreateVertexShader(
_In_ const void* pShaderBytecode,
_In_ SIZE_T BytecodeLength,
_In_opt_ ID3D11ClassLinkage* pClassLinkage,
_Out_opt_ ID3D11VertexShader** ppVertexShader)
{
return m_pReal->CreateVertexShader(pShaderBytecode,BytecodeLength,pClassLinkage,ppVertexShader);
}
STDMETHODIMP CreateGeometryShader(
_In_ const void* pShaderBytecode,
_In_ SIZE_T BytecodeLength,
_In_opt_ ID3D11ClassLinkage* pClassLinkage,
_Out_opt_ ID3D11GeometryShader** ppGeometryShader)
{
return m_pReal->CreateGeometryShader(pShaderBytecode,BytecodeLength,pClassLinkage,ppGeometryShader);
}
STDMETHODIMP CreateGeometryShaderWithStreamOutput(
_In_ const void* pShaderBytecode,
_In_ SIZE_T BytecodeLength,
_In_reads_opt_(NumEntries) const D3D11_SO_DECLARATION_ENTRY* pSODeclaration,
_In_range_( 0, D3D11_SO_STREAM_COUNT * D3D11_SO_OUTPUT_COMPONENT_COUNT ) UINT NumEntries,
_In_reads_opt_(NumStrides) const UINT* pBufferStrides,
_In_range_( 0, D3D11_SO_BUFFER_SLOT_COUNT ) UINT NumStrides,
_In_ UINT RasterizedStream,
_In_opt_ ID3D11ClassLinkage* pClassLinkage,
_Out_opt_ ID3D11GeometryShader** ppGeometryShader)
{
return m_pReal->CreateGeometryShaderWithStreamOutput(pShaderBytecode,BytecodeLength,pSODeclaration,NumEntries,pBufferStrides,NumStrides,RasterizedStream,pClassLinkage,ppGeometryShader);
}
STDMETHODIMP CreatePixelShader(
_In_ const void* pShaderBytecode,
_In_ SIZE_T BytecodeLength,
_In_opt_ ID3D11ClassLinkage* pClassLinkage,
_Out_opt_ ID3D11PixelShader** ppPixelShader)
{
return m_pReal->CreatePixelShader(pShaderBytecode,BytecodeLength,pClassLinkage,ppPixelShader);
}
STDMETHODIMP CreateHullShader(
_In_ const void* pShaderBytecode,
_In_ SIZE_T BytecodeLength,
_In_opt_ ID3D11ClassLinkage* pClassLinkage,
_Out_opt_ ID3D11HullShader** ppHullShader)
{
return m_pReal->CreateHullShader(pShaderBytecode,BytecodeLength,pClassLinkage,ppHullShader);
}
STDMETHODIMP CreateDomainShader(
_In_ const void* pShaderBytecode,
_In_ SIZE_T BytecodeLength,
_In_opt_ ID3D11ClassLinkage* pClassLinkage,
_Out_opt_ ID3D11DomainShader** ppDomainShader)
{
return m_pReal->CreateDomainShader(pShaderBytecode,BytecodeLength,pClassLinkage,ppDomainShader);
}
STDMETHODIMP CreateComputeShader(
_In_ const void* pShaderBytecode,
_In_ SIZE_T BytecodeLength,
_In_opt_ ID3D11ClassLinkage* pClassLinkage,
_Out_opt_ ID3D11ComputeShader** ppComputeShader)
{
return m_pReal->CreateComputeShader(pShaderBytecode,BytecodeLength,pClassLinkage,ppComputeShader);
}
STDMETHODIMP CreateClassLinkage(
_Out_ ID3D11ClassLinkage** ppLinkage)
{
return m_pReal->CreateClassLinkage(ppLinkage);
}
STDMETHODIMP CreateBlendState(
_In_ const D3D11_BLEND_DESC* pBlendStateDesc,
_Out_opt_ ID3D11BlendState** ppBlendState)
{
return m_pReal->CreateBlendState(pBlendStateDesc,ppBlendState);
}
STDMETHODIMP CreateDepthStencilState(
_In_ const D3D11_DEPTH_STENCIL_DESC* pDepthStencilDesc,
_Out_opt_ ID3D11DepthStencilState** ppDepthStencilState)
{
return m_pReal->CreateDepthStencilState(pDepthStencilDesc,ppDepthStencilState);
}
STDMETHODIMP CreateRasterizerState(
_In_ const D3D11_RASTERIZER_DESC* pRasterizerDesc,
_Out_opt_ ID3D11RasterizerState** ppRasterizerState)
{
return m_pReal->CreateRasterizerState(pRasterizerDesc,ppRasterizerState);
}
STDMETHODIMP CreateSamplerState(
_In_ const D3D11_SAMPLER_DESC* pSamplerDesc,
_Out_opt_ ID3D11SamplerState** ppSamplerState)
{
return m_pReal->CreateSamplerState(pSamplerDesc,ppSamplerState);
}
STDMETHODIMP CreateQuery(
_In_ const D3D11_QUERY_DESC* pQueryDesc,
_Out_opt_ ID3D11Query** ppQuery)
{
return m_pReal->CreateQuery(pQueryDesc,ppQuery);
}
STDMETHODIMP CreatePredicate(
_In_ const D3D11_QUERY_DESC* pPredicateDesc,
_Out_opt_ ID3D11Predicate** ppPredicate)
{
return m_pReal->CreatePredicate(pPredicateDesc,ppPredicate);
}
STDMETHODIMP CreateCounter(
_In_ const D3D11_COUNTER_DESC* pCounterDesc,
_Out_opt_ ID3D11Counter** ppCounter)
{
return m_pReal->CreateCounter(pCounterDesc,ppCounter);
}
STDMETHODIMP CreateDeferredContext(
UINT ContextFlags,
_Out_opt_ ID3D11DeviceContext** ppDeferredContext)
{
return m_pReal->CreateDeferredContext(ContextFlags,ppDeferredContext);
}
STDMETHODIMP OpenSharedResource(
_In_ HANDLE hResource,
_In_ REFIID ReturnedInterface,
_Out_opt_ void** ppResource)
{
return m_pReal->OpenSharedResource(hResource,ReturnedInterface,ppResource);
}
STDMETHODIMP CheckFormatSupport(
_In_ DXGI_FORMAT Format,
_Out_ UINT* pFormatSupport)
{
return m_pReal->CheckFormatSupport(Format,pFormatSupport);
}
STDMETHODIMP CheckMultisampleQualityLevels(
_In_ DXGI_FORMAT Format,
_In_ UINT SampleCount,
_Out_ UINT* pNumQualityLevels)
{
return m_pReal->CheckMultisampleQualityLevels(Format,SampleCount,pNumQualityLevels);
}
STDMETHODIMP_(void) CheckCounterInfo(
_Out_ D3D11_COUNTER_INFO* pCounterInfo)
{
return m_pReal->CheckCounterInfo(pCounterInfo);
}
STDMETHODIMP CheckCounter(
_In_ const D3D11_COUNTER_DESC* pDesc,
_Out_ D3D11_COUNTER_TYPE* pType,
_Out_ UINT* pActiveCounters,
_Out_writes_opt_(*pNameLength) LPSTR szName,
_Inout_opt_ UINT* pNameLength,
_Out_writes_opt_(*pUnitsLength) LPSTR szUnits,
_Inout_opt_ UINT* pUnitsLength,
_Out_writes_opt_(*pDescriptionLength) LPSTR szDescription,
_Inout_opt_ UINT* pDescriptionLength)
{
return m_pReal->CheckCounter(pDesc,pType,pActiveCounters,szName,pNameLength,szUnits,pUnitsLength,szDescription,pDescriptionLength);
}
STDMETHODIMP CheckFeatureSupport(
D3D11_FEATURE Feature,
_Out_writes_bytes_(FeatureSupportDataSize) void* pFeatureSupportData,
UINT FeatureSupportDataSize)
{
return m_pReal->CheckFeatureSupport(Feature,pFeatureSupportData,FeatureSupportDataSize);
}
STDMETHODIMP GetPrivateData(
_In_ REFGUID guid,
_Inout_ UINT* pDataSize,
_Out_writes_bytes_opt_(*pDataSize) void* pData)
{
return m_pReal->GetPrivateData(guid,pDataSize,pData);
}
STDMETHODIMP SetPrivateData(
_In_ REFGUID guid,
_In_ UINT DataSize,
_In_reads_bytes_opt_(DataSize) const void* pData)
{
return m_pReal->SetPrivateData(guid,DataSize,pData);
}
STDMETHODIMP SetPrivateDataInterface(
_In_ REFGUID guid,
_In_opt_ const IUnknown* pData)
{
return m_pReal->SetPrivateDataInterface(guid,pData);
}
STDMETHODIMP_(D3D_FEATURE_LEVEL) GetFeatureLevel(void)
{
return m_pReal->GetFeatureLevel();
}
STDMETHODIMP_(UINT) GetCreationFlags(void)
{
return m_pReal->GetCreationFlags();
}
STDMETHODIMP GetDeviceRemovedReason(void)
{
return m_pReal->GetDeviceRemovedReason();
}
STDMETHODIMP_(void) GetImmediateContext(
_Out_ ID3D11DeviceContext** ppImmediateContext)
{
return m_pReal->GetImmediateContext(ppImmediateContext);
}
STDMETHODIMP SetExceptionMode(
UINT RaiseFlags)
{
return m_pReal->SetExceptionMode(RaiseFlags);
}
STDMETHODIMP_(UINT) GetExceptionMode(void)
{
return m_pReal->GetExceptionMode();
}
};
}