ReactOS 0.4.15-dev-8207-gd73a838
interface.cpp
Go to the documentation of this file.
1/*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS WDM Streaming ActiveMovie Proxy
4 * FILE: dll/directx/ksproxy/interface.cpp
5 * PURPOSE: IKsInterfaceHandler interface
6 *
7 * PROGRAMMERS: Johannes Anderwald (johannes.anderwald@reactos.org)
8 */
9#include "precomp.h"
10
11const GUID IID_IKsObject = {0x423c13a2, 0x2070, 0x11d0, {0x9e, 0xf7, 0x00, 0xaa, 0x00, 0xa2, 0x16, 0xa1}};
12
13class CKsInterfaceHandler : public IKsInterfaceHandler
14{
15public:
17
19 {
21 return m_Ref;
22 }
24 {
26
27 if (!m_Ref)
28 {
29 delete this;
30 return 0;
31 }
32 return m_Ref;
33 }
34 HRESULT STDMETHODCALLTYPE KsSetPin(IKsPin *KsPin);
35 HRESULT STDMETHODCALLTYPE KsProcessMediaSamples(IKsDataTypeHandler *KsDataTypeHandler, IMediaSample** SampleList, PLONG SampleCount, KSIOOPERATION IoOperation, PKSSTREAM_SEGMENT *StreamSegment);
36 HRESULT STDMETHODCALLTYPE KsCompleteIo(PKSSTREAM_SEGMENT StreamSegment);
37
40
41protected:
44 IKsPinEx * m_Pin;
46};
47
48typedef struct
49{
50 KSSTREAM_SEGMENT StreamSegment;
52 IMediaSample * MediaSample[64];
53
58
59
63 IN REFIID refiid,
65{
66 if (IsEqualGUID(refiid, IID_IUnknown) ||
67 IsEqualGUID(refiid, IID_IKsInterfaceHandler))
68 {
69 *Output = PVOID(this);
70 reinterpret_cast<IUnknown*>(*Output)->AddRef();
71 return NOERROR;
72 }
73 return E_NOINTERFACE;
74}
75
79 IKsPin *KsPin)
80{
81 HRESULT hr;
82 IKsObject * KsObject;
83 IKsPinEx * Pin;
84
85 // get IKsPinEx interface
86 hr = KsPin->QueryInterface(IID_IKsPinEx, (void**)&Pin);
87 if (SUCCEEDED(hr))
88 {
89 // check if IKsObject is supported
90 hr = KsPin->QueryInterface(IID_IKsObject, (void**)&KsObject);
91
92 if (SUCCEEDED(hr))
93 {
94 // get pin handle
95 m_Handle = KsObject->KsGetObjectHandle();
96
97 // release IKsObject interface
98 KsObject->Release();
99
100 if (!m_Handle)
101 {
102 // expected a file handle
104 Pin->Release();
105 }
106 else
107 {
108 if (m_Pin)
109 {
110 // release old interface
111 m_Pin->Release();
112 }
113 m_Pin = Pin;
114 }
115 }
116 else
117 {
118 //release IKsPinEx interface
119 Pin->Release();
120 }
121 }
122#if 1
123 //DBG code
124 PIN_INFO PinInfo;
125 IPin * pPin;
126 if (SUCCEEDED(KsPin->QueryInterface(IID_IPin, (void**)&pPin)))
127 {
128 if (SUCCEEDED(pPin->QueryPinInfo(&PinInfo)))
129 {
130 if (PinInfo.pFilter)
131 PinInfo.pFilter->Release();
132
133 wcscpy(m_PinName, PinInfo.achName);
134 }
135 pPin->Release();
136 }
137#endif
138
139 // done
140 return hr;
141}
142
146 IKsDataTypeHandler *KsDataTypeHandler,
147 IMediaSample** SampleList,
148 PLONG SampleCount,
149 KSIOOPERATION IoOperation,
150 PKSSTREAM_SEGMENT *OutStreamSegment)
151{
152 PKSSTREAM_SEGMENT_EXT StreamSegment;
153 ULONG ExtendedSize, Index, BytesReturned;
154 HRESULT hr = S_OK;
155
156 // sanity check
157 assert(*SampleCount);
158
159 if (*SampleCount == 0 || *SampleCount < 0)
160 return E_FAIL;
161
162 // zero stream segment
163 *OutStreamSegment = NULL;
164
165 // allocate stream segment
167 if (!StreamSegment)
168 return E_OUTOFMEMORY;
169
170 // zero stream segment
171 ZeroMemory(StreamSegment, sizeof(KSSTREAM_SEGMENT_EXT));
172
173 //allocate event
174 StreamSegment->StreamSegment.CompletionEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
175
176 if (!StreamSegment->StreamSegment.CompletionEvent)
177 {
178 // failed to create event
179 CoTaskMemFree(StreamSegment);
181 }
182
183 // increase our own reference count
184 AddRef();
185
186 // setup stream segment
187 StreamSegment->StreamSegment.KsDataTypeHandler = KsDataTypeHandler;
188 StreamSegment->StreamSegment.KsInterfaceHandler = (IKsInterfaceHandler*)this;
189 StreamSegment->StreamSegment.IoOperation = IoOperation;
190 StreamSegment->Overlapped.hEvent = StreamSegment->StreamSegment.CompletionEvent;
191
192
193 // ge extension size
194 ExtendedSize = 0;
195 if (KsDataTypeHandler)
196 {
197 // query extension size
198 KsDataTypeHandler->KsQueryExtendedSize(&ExtendedSize);
199
200 if (ExtendedSize)
201 {
202 // increment reference count
203 KsDataTypeHandler->AddRef();
204 }
205 else
206 {
207 // no need for the datatype handler
208 StreamSegment->StreamSegment.KsDataTypeHandler = NULL;
209 }
210 }
211
212 StreamSegment->ExtendedSize = ExtendedSize;
213 StreamSegment->SampleCount = (ULONG)*SampleCount;
214
215 // calculate stream header size count
216 ULONG StreamHeaderSize = StreamSegment->SampleCount * (sizeof(KSSTREAM_HEADER) + ExtendedSize);
217
218 // allocate stream header
219 StreamSegment->StreamHeader = (PKSSTREAM_HEADER)CoTaskMemAlloc(StreamHeaderSize);
220 if (!StreamSegment->StreamHeader)
221 {
222 // not enough memory
223 CloseHandle(StreamSegment->StreamSegment.CompletionEvent);
224
225 if (StreamSegment->StreamSegment.KsDataTypeHandler)
226 StreamSegment->StreamSegment.KsDataTypeHandler->Release();
227
228 // free stream segment
229 CoTaskMemFree(StreamSegment);
230
231 //release our reference count
232 Release();
233 return E_OUTOFMEMORY;
234 }
235
236 // zero stream headers
237 ZeroMemory(StreamSegment->StreamHeader, StreamHeaderSize);
238
239 PKSSTREAM_HEADER CurStreamHeader = StreamSegment->StreamHeader;
240
241 // initialize all stream headers
242 for(Index = 0; Index < StreamSegment->SampleCount; Index++)
243 {
244 if (ExtendedSize)
245 {
246 // initialize extended size
247 hr = KsDataTypeHandler->KsPrepareIoOperation(SampleList[Index], (CurStreamHeader + 1), IoOperation);
248 // sanity check
249 assert(hr == NOERROR);
250 }
251
252 // query for IMediaSample2 interface
253 IMediaSample2 * MediaSample;
254 AM_SAMPLE2_PROPERTIES Properties;
255 ZeroMemory(&Properties, sizeof(AM_SAMPLE2_PROPERTIES));
256
257 hr = SampleList[Index]->QueryInterface(IID_IMediaSample2, (void**)&MediaSample);
258 if (SUCCEEDED(hr))
259 {
260 //get properties
261
262 hr = MediaSample->GetProperties(sizeof(AM_SAMPLE2_PROPERTIES), (BYTE*)&Properties);
263
264 //release IMediaSample2 interface
265 MediaSample->Release();
266 }
267 else
268 {
269 // get properties
270 hr = SampleList[Index]->GetPointer((BYTE**)&Properties.pbBuffer);
271 assert(hr == NOERROR);
272 hr = SampleList[Index]->GetTime(&Properties.tStart, &Properties.tStop);
273
274 Properties.cbBuffer = SampleList[Index]->GetSize();
275 assert(Properties.cbBuffer);
276
277 Properties.dwSampleFlags = 0;
278
279 if (SampleList[Index]->IsDiscontinuity() == S_OK)
281
282 if (SampleList[Index]->IsPreroll() == S_OK)
283 Properties.dwSampleFlags |= AM_SAMPLE_PREROLL;
284
285 if (SampleList[Index]->IsSyncPoint() == S_OK)
287 }
288#ifdef KSPROXY_TRACE
289 WCHAR Buffer[200];
290 swprintf(Buffer, L"CKsInterfaceHandler::KsProcessMediaSamples PinName %s BufferLength %lu Property Buffer %p ExtendedSize %u lActual %u dwSampleFlags %lx\n", m_PinName, Properties.cbBuffer, Properties.pbBuffer, ExtendedSize, Properties.lActual, Properties.dwSampleFlags);
292#endif
293
294 CurStreamHeader->Size = sizeof(KSSTREAM_HEADER) + ExtendedSize;
295 CurStreamHeader->PresentationTime.Denominator = 1;
296 CurStreamHeader->PresentationTime.Numerator = 1;
297 CurStreamHeader->FrameExtent = Properties.cbBuffer;
298 CurStreamHeader->Data = Properties.pbBuffer;
299
300 if (IoOperation == KsIoOperation_Write)
301 {
302 // set flags
303 CurStreamHeader->OptionsFlags = Properties.dwSampleFlags;
304 CurStreamHeader->DataUsed = Properties.lActual;
305 // increment reference count
306 SampleList[Index]->AddRef();
307 }
308
309 // store sample in stream segment
310 StreamSegment->MediaSample[Index] = SampleList[Index];
311
312 // move to next header
313 CurStreamHeader = (PKSSTREAM_HEADER)((ULONG_PTR)CurStreamHeader + CurStreamHeader->Size);
314 }
315
316 // submit to device
317 m_Pin->KsIncrementPendingIoCount();
318
320 IoOperation == KsIoOperation_Write ? IOCTL_KS_WRITE_STREAM : IOCTL_KS_READ_STREAM,
321 NULL, 0,
322 StreamSegment->StreamHeader,
323 StreamHeaderSize,
325 &StreamSegment->Overlapped))
326 {
327 // signal completion
328 SetEvent(StreamSegment->StreamSegment.CompletionEvent);
329 hr = S_OK;
330 *OutStreamSegment = (PKSSTREAM_SEGMENT)StreamSegment;
331 }
332 else
333 {
335 {
336 *OutStreamSegment = (PKSSTREAM_SEGMENT)StreamSegment;
337 hr = S_OK;
338 }
339 }
340 return hr;
341}
342
346 PKSSTREAM_SEGMENT InStreamSegment)
347{
348 PKSSTREAM_SEGMENT_EXT StreamSegment;
349 PKSSTREAM_HEADER CurStreamHeader;
351 BOOL bOverlapped;
352 ULONG Index;
353 HRESULT hr;
354 IMediaSample2 * MediaSample;
355 AM_SAMPLE2_PROPERTIES Properties;
357
358 // get private stream segment
359 StreamSegment = (PKSSTREAM_SEGMENT_EXT)InStreamSegment;
360
361 // get result
362 bOverlapped = GetOverlappedResult(m_Handle, &StreamSegment->Overlapped, &BytesReturned, FALSE);
363 dwError = GetLastError();
364
365 CurStreamHeader = StreamSegment->StreamHeader;
366
367 //iterate through all stream headers
368 for(Index = 0; Index < StreamSegment->SampleCount; Index++)
369 {
370 if (!bOverlapped)
371 {
372 // operation failed
373 m_Pin->KsNotifyError(StreamSegment->MediaSample[Index], MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, dwError));
374 }
375
376 // query IMediaSample2 interface
377 hr = StreamSegment->MediaSample[Index]->QueryInterface(IID_IMediaSample2, (void**)&MediaSample);
378 if (SUCCEEDED(hr))
379 {
380 // media sample properties
381 hr = MediaSample->GetProperties(sizeof(AM_SAMPLE2_PROPERTIES), (BYTE*)&Properties);
382 if (SUCCEEDED(hr))
383 {
384 //update media sample properties
385 Properties.dwTypeSpecificFlags = CurStreamHeader->TypeSpecificFlags;
386 Properties.dwSampleFlags |= (CurStreamHeader->OptionsFlags & KSSTREAM_HEADER_OPTIONSF_TIMEDISCONTINUITY);
387
388 MediaSample->SetProperties(sizeof(AM_SAMPLE2_PROPERTIES), (BYTE*)&Properties);
389 }
390 // release IMediaSample2 interface
391 MediaSample->Release();
392 }
393
394 // was an extended header used
395 if (StreamSegment->ExtendedSize)
396 {
397 // unprepare stream header extension
398 StreamSegment->StreamSegment.KsDataTypeHandler->KsCompleteIoOperation(StreamSegment->MediaSample[Index], (CurStreamHeader + 1), StreamSegment->StreamSegment.IoOperation, bOverlapped == FALSE);
399 }
400
401 Start = 0;
402 Stop = 0;
403 if (bOverlapped && StreamSegment->StreamSegment.IoOperation == KsIoOperation_Read)
404 {
405 // update common media sample details
407 StreamSegment->MediaSample[Index]->SetPreroll((CurStreamHeader->OptionsFlags & KSSTREAM_HEADER_OPTIONSF_PREROLL));
409
411 {
412 // use valid timestamp
413 Start = CurStreamHeader->PresentationTime.Time;
414
416 {
417 Stop = CurStreamHeader->PresentationTime.Time + CurStreamHeader->Duration;
418 }
419 }
420 }
421
422 // now set time
423 hr = StreamSegment->MediaSample[Index]->SetTime(&Start, &Stop);
424 if (FAILED(hr))
425 {
426 // use start time
427 StreamSegment->MediaSample[Index]->SetTime(&Start, &Start);
428 }
429
430 // set valid data length
431 StreamSegment->MediaSample[Index]->SetActualDataLength(CurStreamHeader->DataUsed);
432
433 if (StreamSegment->StreamSegment.IoOperation == KsIoOperation_Read)
434 {
435 if (bOverlapped)
436 {
437 // deliver sample
438 m_Pin->KsDeliver(StreamSegment->MediaSample[Index], CurStreamHeader->OptionsFlags);
439 }
440 }
441 else if (StreamSegment->StreamSegment.IoOperation == KsIoOperation_Write)
442 {
443 // release media sample reference
444 StreamSegment->MediaSample[Index]->Release();
445 }
446
447 CurStreamHeader = (PKSSTREAM_HEADER)((ULONG_PTR)CurStreamHeader + CurStreamHeader->Size);
448 }
449
450 // delete stream headers
451 CoTaskMemFree(StreamSegment->StreamHeader);
452
453 if (StreamSegment->StreamSegment.KsDataTypeHandler)
454 {
455 // release reference
456 StreamSegment->StreamSegment.KsDataTypeHandler->Release();
457 }
458
459 // decrement pending i/o count
460 m_Pin->KsDecrementPendingIoCount();
461
462 //notify of completion
463 m_Pin->KsMediaSamplesCompleted(InStreamSegment);
464
465 //destroy stream segment
466 CoTaskMemFree(StreamSegment);
467
468 //release reference to ourselves
469 Release();
470
471 // done
472 // Event handle is closed by caller
473 return S_OK;
474}
475
477WINAPI
479 IUnknown * pUnkOuter,
480 REFIID riid,
481 LPVOID * ppv)
482{
483#ifdef KSPROXY_TRACE
484 OutputDebugStringW(L"CKsInterfaceHandler_Constructor\n");
485#endif
486
488
489 if (!handler)
490 return E_OUTOFMEMORY;
491
492 if (FAILED(handler->QueryInterface(riid, ppv)))
493 {
494 /* not supported */
495 delete handler;
496 return E_NOINTERFACE;
497 }
498
499 return NOERROR;
500}
#define InterlockedIncrement
Definition: armddk.h:53
#define InterlockedDecrement
Definition: armddk.h:52
@ AM_SAMPLE_DATADISCONTINUITY
Definition: axcore.idl:439
@ AM_SAMPLE_PREROLL
Definition: axcore.idl:438
@ AM_SAMPLE_SPLICEPOINT
Definition: axcore.idl:437
#define STDMETHODIMP
Definition: basetyps.h:43
const GUID IID_IUnknown
#define STDMETHODCALLTYPE
Definition: bdasup.h:9
_In_ BOOLEAN Release
Definition: cdrom.h:920
Definition: bufpool.h:45
IKsPinEx * m_Pin
Definition: interface.cpp:44
HRESULT STDMETHODCALLTYPE KsCompleteIo(PKSSTREAM_SEGMENT StreamSegment)
Definition: interface.cpp:345
HRESULT STDMETHODCALLTYPE KsProcessMediaSamples(IKsDataTypeHandler *KsDataTypeHandler, IMediaSample **SampleList, PLONG SampleCount, KSIOOPERATION IoOperation, PKSSTREAM_SEGMENT *StreamSegment)
Definition: interface.cpp:145
STDMETHODIMP_(ULONG) Release()
Definition: interface.cpp:23
WCHAR m_PinName[129]
Definition: interface.cpp:45
STDMETHODIMP QueryInterface(REFIID InterfaceId, PVOID *Interface)
Definition: interface.cpp:62
STDMETHODIMP_(ULONG) AddRef()
Definition: interface.cpp:18
HRESULT STDMETHODCALLTYPE KsSetPin(IKsPin *KsPin)
Definition: interface.cpp:78
virtual ~CKsInterfaceHandler()
Definition: interface.cpp:39
#define ERROR_IO_PENDING
Definition: dderror.h:15
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define E_FAIL
Definition: ddrawi.h:102
#define ERROR_SUCCESS
Definition: deptool.c:10
BOOL WINAPI DeviceIoControl(IN HANDLE hDevice, IN DWORD dwIoControlCode, IN LPVOID lpInBuffer OPTIONAL, IN DWORD nInBufferSize OPTIONAL, OUT LPVOID lpOutBuffer OPTIONAL, IN DWORD nOutBufferSize OPTIONAL, OUT LPDWORD lpBytesReturned OPTIONAL, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: deviceio.c:136
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define CloseHandle
Definition: compat.h:739
UINT(* handler)(MSIPACKAGE *)
Definition: action.c:7482
#define swprintf
Definition: precomp.h:40
#define assert(x)
Definition: debug.h:53
#define MAKE_HRESULT(sev, fac, code)
Definition: dmerror.h:30
LONGLONG REFERENCE_TIME
Definition: dmusicks.h:9
IN PDCB IN VBO IN ULONG IN BOOLEAN Pin
Definition: fatprocs.h:427
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
LPVOID WINAPI CoTaskMemAlloc(SIZE_T size)
Definition: ifs.c:426
void WINAPI SHIM_OBJ_NAME() OutputDebugStringW(LPCWSTR lpOutputString)
Definition: ignoredbgout.c:23
REFIID riid
Definition: atlbase.h:39
REFIID LPVOID * ppv
Definition: atlbase.h:39
const GUID IID_IKsPinEx
Definition: input_pin.cpp:12
HRESULT GetProperties([in] DWORD cbProperties, [out, size_is(cbProperties)] BYTE *pbProperties)
HRESULT SetTime([in] REFERENCE_TIME *pTimeStart, [in] REFERENCE_TIME *pTimeEnd)
HRESULT GetTime([out] REFERENCE_TIME *pTimeStart, [out] REFERENCE_TIME *pTimeEnd)
HRESULT SetSyncPoint(BOOL bIsSyncPoint)
HRESULT SetDiscontinuity(BOOL bDiscontinuity)
long GetSize(void)
HRESULT SetActualDataLength(LONG length)
HRESULT GetPointer([out] BYTE **ppBuffer)
HRESULT SetPreroll(BOOL bIsPreroll)
Definition: axcore.idl:92
HRESULT QueryPinInfo([out] PIN_INFO *pInfo)
ULONG AddRef()
HRESULT QueryInterface([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
ULONG Release()
const GUID IID_IKsObject
Definition: interface.cpp:11
HRESULT WINAPI CKsInterfaceHandler_Constructor(IUnknown *pUnkOuter, REFIID riid, LPVOID *ppv)
Definition: interface.cpp:478
struct KSSTREAM_SEGMENT_EXT * PKSSTREAM_SEGMENT_EXT
nsrefcnt Release()
#define S_OK
Definition: intsafe.h:52
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define FAILED(hr)
Definition: intsafe.h:51
BOOL WINAPI GetOverlappedResult(IN HANDLE hFile, IN LPOVERLAPPED lpOverlapped, OUT LPDWORD lpNumberOfBytesTransferred, IN BOOL bWait)
Definition: iocompl.c:221
struct KSSTREAM_HEADER * PKSSTREAM_HEADER
#define KSSTREAM_HEADER_OPTIONSF_DURATIONVALID
Definition: ks.h:2756
#define KSSTREAM_HEADER_OPTIONSF_SPLICEPOINT
Definition: ks.h:2749
#define KSSTREAM_HEADER_OPTIONSF_DATADISCONTINUITY
Definition: ks.h:2751
#define IOCTL_KS_READ_STREAM
Definition: ks.h:142
#define KSSTREAM_HEADER_OPTIONSF_TIMEVALID
Definition: ks.h:2753
#define IOCTL_KS_WRITE_STREAM
Definition: ks.h:139
#define KSSTREAM_HEADER_OPTIONSF_TIMEDISCONTINUITY
Definition: ks.h:2754
#define KSSTREAM_HEADER_OPTIONSF_PREROLL
Definition: ks.h:2750
_In_opt_ PVOID _Out_ BOOLEAN * Stop
Definition: ldrtypes.h:241
static ULONG WINAPI AddRef(IStream *iface)
Definition: clist.c:90
#define L(x)
Definition: ntvdm.h:50
long LONG
Definition: pedump.c:60
const GUID IID_IPin
Definition: pincontrol.cpp:15
#define IsEqualGUID(rguid1, rguid2)
Definition: guiddef.h:147
#define REFIID
Definition: guiddef.h:118
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
@ Output
Definition: arc.h:85
HRESULT hr
Definition: shlfolder.c:183
ULONG FrameExtent
Definition: ks.h:2740
ULONG Size
Definition: ks.h:2736
KSTIME PresentationTime
Definition: ks.h:2738
PVOID Data
Definition: ks.h:2742
ULONG DataUsed
Definition: ks.h:2741
LONGLONG Duration
Definition: ks.h:2739
ULONG OptionsFlags
Definition: ks.h:2743
ULONG TypeSpecificFlags
Definition: ks.h:2737
IMediaSample * MediaSample[64]
Definition: interface.cpp:52
OVERLAPPED Overlapped
Definition: interface.cpp:51
PKSSTREAM_HEADER StreamHeader
Definition: interface.cpp:56
KSSTREAM_SEGMENT StreamSegment
Definition: interface.cpp:50
LONGLONG Time
Definition: ks.h:1834
ULONG Denominator
Definition: ks.h:1836
ULONG Numerator
Definition: ks.h:1835
HANDLE hEvent
Definition: winbase.h:820
REFERENCE_TIME tStop
Definition: axcore.idl:457
REFERENCE_TIME tStart
Definition: axcore.idl:456
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733
void * PVOID
Definition: typedefs.h:50
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define IN
Definition: typedefs.h:39
int32_t * PLONG
Definition: typedefs.h:58
uint32_t ULONG
Definition: typedefs.h:59
#define OUT
Definition: typedefs.h:40
@ Start
Definition: partlist.h:33
_In_ WDFCOLLECTION _In_ ULONG Index
_Must_inspect_result_ _In_ WDFDEVICE _In_ LPCGUID _Out_ PINTERFACE Interface
Definition: wdffdo.h:465
_Must_inspect_result_ _In_ WDFIOTARGET _In_opt_ WDFREQUEST _In_ ULONG _In_opt_ PWDF_MEMORY_DESCRIPTOR _In_opt_ PWDF_MEMORY_DESCRIPTOR _In_opt_ PWDF_REQUEST_SEND_OPTIONS _Out_opt_ PULONG_PTR BytesReturned
Definition: wdfiotarget.h:1052
#define ZeroMemory
Definition: winbase.h:1712
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
#define CreateEvent
Definition: winbase.h:3748
#define WINAPI
Definition: msvc.h:6
#define E_NOINTERFACE
Definition: winerror.h:2364
#define NOERROR
Definition: winerror.h:2354
#define SEVERITY_ERROR
Definition: winerror.h:65
#define E_UNEXPECTED
Definition: winerror.h:2456
#define FACILITY_WIN32
Definition: winerror.h:27
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned char BYTE
Definition: xxhash.c:193