summaryrefslogtreecommitdiffstats
path: root/sdk/dx8sdk/Include/ks.h
diff options
context:
space:
mode:
authorFire_Head <Fire-Head@users.noreply.github.com>2020-08-03 00:03:24 +0200
committerGitHub <noreply@github.com>2020-08-03 00:03:24 +0200
commit4b614333c6778ae49cef688f6ef691dd58384d13 (patch)
treeced50966eaaf373f8733547046baf2bdc558662d /sdk/dx8sdk/Include/ks.h
parentcleanup (diff)
parentMove sdk and eax (diff)
downloadre3-4b614333c6778ae49cef688f6ef691dd58384d13.tar
re3-4b614333c6778ae49cef688f6ef691dd58384d13.tar.gz
re3-4b614333c6778ae49cef688f6ef691dd58384d13.tar.bz2
re3-4b614333c6778ae49cef688f6ef691dd58384d13.tar.lz
re3-4b614333c6778ae49cef688f6ef691dd58384d13.tar.xz
re3-4b614333c6778ae49cef688f6ef691dd58384d13.tar.zst
re3-4b614333c6778ae49cef688f6ef691dd58384d13.zip
Diffstat (limited to 'sdk/dx8sdk/Include/ks.h')
-rw-r--r--sdk/dx8sdk/Include/ks.h5698
1 files changed, 5698 insertions, 0 deletions
diff --git a/sdk/dx8sdk/Include/ks.h b/sdk/dx8sdk/Include/ks.h
new file mode 100644
index 00000000..4f766b9f
--- /dev/null
+++ b/sdk/dx8sdk/Include/ks.h
@@ -0,0 +1,5698 @@
+/*++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Module Name:
+
+ ks.h
+
+Abstract:
+
+ Windows Driver Model/Connection and Streaming Architecture (WDM-CSA)
+ core definitions.
+
+--*/
+
+#if !defined(_KS_)
+#define _KS_
+
+#if defined(__TCS__)
+#define _KS_NO_ANONYMOUS_STRUCTURES_ 1
+#endif
+
+#if !defined(_NTRTL_)
+ #ifndef DEFINE_GUIDEX
+ #define DEFINE_GUIDEX(name) EXTERN_C const CDECL GUID name
+ #endif // !defined(DEFINE_GUIDEX)
+
+ #ifndef STATICGUIDOF
+ #define STATICGUIDOF(guid) STATIC_##guid
+ #endif // !defined(STATICGUIDOF)
+#endif // !defined(_NTRTL_)
+
+#ifndef SIZEOF_ARRAY
+ #define SIZEOF_ARRAY(ar) (sizeof(ar)/sizeof((ar)[0]))
+#endif // !defined(SIZEOF_ARRAY)
+
+#if defined(__cplusplus) && _MSC_VER >= 1100
+#define DEFINE_GUIDSTRUCT(g, n) struct __declspec(uuid(g)) n
+#define DEFINE_GUIDNAMED(n) __uuidof(struct n)
+#else // !defined(__cplusplus)
+#define DEFINE_GUIDSTRUCT(g, n) DEFINE_GUIDEX(n)
+#define DEFINE_GUIDNAMED(n) n
+#endif // !defined(__cplusplus)
+
+//===========================================================================
+
+#define STATIC_GUID_NULL \
+ 0x00000000L, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+
+DEFINE_GUIDSTRUCT("00000000-0000-0000-0000-000000000000", GUID_NULL);
+#define GUID_NULL DEFINE_GUIDNAMED(GUID_NULL)
+
+//===========================================================================
+
+#define IOCTL_KS_PROPERTY CTL_CODE(FILE_DEVICE_KS, 0x000, METHOD_NEITHER, FILE_ANY_ACCESS)
+#define IOCTL_KS_ENABLE_EVENT CTL_CODE(FILE_DEVICE_KS, 0x001, METHOD_NEITHER, FILE_ANY_ACCESS)
+#define IOCTL_KS_DISABLE_EVENT CTL_CODE(FILE_DEVICE_KS, 0x002, METHOD_NEITHER, FILE_ANY_ACCESS)
+#define IOCTL_KS_METHOD CTL_CODE(FILE_DEVICE_KS, 0x003, METHOD_NEITHER, FILE_ANY_ACCESS)
+#define IOCTL_KS_WRITE_STREAM CTL_CODE(FILE_DEVICE_KS, 0x004, METHOD_NEITHER, FILE_WRITE_ACCESS)
+#define IOCTL_KS_READ_STREAM CTL_CODE(FILE_DEVICE_KS, 0x005, METHOD_NEITHER, FILE_READ_ACCESS)
+#define IOCTL_KS_RESET_STATE CTL_CODE(FILE_DEVICE_KS, 0x006, METHOD_NEITHER, FILE_ANY_ACCESS)
+
+//===========================================================================
+
+typedef enum {
+ KSRESET_BEGIN,
+ KSRESET_END
+} KSRESET;
+
+typedef enum {
+ KSSTATE_STOP,
+ KSSTATE_ACQUIRE,
+ KSSTATE_PAUSE,
+ KSSTATE_RUN
+} KSSTATE, *PKSSTATE;
+
+#define KSPRIORITY_LOW 0x00000001
+#define KSPRIORITY_NORMAL 0x40000000
+#define KSPRIORITY_HIGH 0x80000000
+#define KSPRIORITY_EXCLUSIVE 0xFFFFFFFF
+
+typedef struct {
+ ULONG PriorityClass;
+ ULONG PrioritySubClass;
+} KSPRIORITY, *PKSPRIORITY;
+
+typedef struct {
+ union {
+#if defined( _KS_NO_ANONYMOUS_STRUCTURES_ )
+ struct _IDENTIFIER {
+#else
+ struct {
+#endif
+ GUID Set;
+ ULONG Id;
+ ULONG Flags;
+ };
+ LONGLONG Alignment;
+ };
+} KSIDENTIFIER, *PKSIDENTIFIER;
+
+typedef KSIDENTIFIER KSPROPERTY, *PKSPROPERTY, KSMETHOD, *PKSMETHOD, KSEVENT, *PKSEVENT;
+
+#define KSMETHOD_TYPE_NONE 0x00000000
+#define KSMETHOD_TYPE_READ 0x00000001
+#define KSMETHOD_TYPE_WRITE 0x00000002
+#define KSMETHOD_TYPE_MODIFY 0x00000003
+#define KSMETHOD_TYPE_SOURCE 0x00000004
+
+#define KSMETHOD_TYPE_SEND 0x00000001
+#define KSMETHOD_TYPE_SETSUPPORT 0x00000100
+#define KSMETHOD_TYPE_BASICSUPPORT 0x00000200
+
+#define KSMETHOD_TYPE_TOPOLOGY 0x10000000
+
+#define KSPROPERTY_TYPE_GET 0x00000001
+#define KSPROPERTY_TYPE_SET 0x00000002
+#define KSPROPERTY_TYPE_SETSUPPORT 0x00000100
+#define KSPROPERTY_TYPE_BASICSUPPORT 0x00000200
+#define KSPROPERTY_TYPE_RELATIONS 0x00000400
+#define KSPROPERTY_TYPE_SERIALIZESET 0x00000800
+#define KSPROPERTY_TYPE_UNSERIALIZESET 0x00001000
+#define KSPROPERTY_TYPE_SERIALIZERAW 0x00002000
+#define KSPROPERTY_TYPE_UNSERIALIZERAW 0x00004000
+#define KSPROPERTY_TYPE_SERIALIZESIZE 0x00008000
+#define KSPROPERTY_TYPE_DEFAULTVALUES 0x00010000
+
+#define KSPROPERTY_TYPE_TOPOLOGY 0x10000000
+
+typedef struct {
+ KSPROPERTY Property;
+ ULONG NodeId;
+ ULONG Reserved;
+} KSP_NODE, *PKSP_NODE;
+
+typedef struct {
+ KSMETHOD Method;
+ ULONG NodeId;
+ ULONG Reserved;
+} KSM_NODE, *PKSM_NODE;
+
+typedef struct {
+ KSEVENT Event;
+ ULONG NodeId;
+ ULONG Reserved;
+} KSE_NODE, *PKSE_NODE;
+
+#define STATIC_KSPROPTYPESETID_General \
+ 0x97E99BA0L, 0xBDEA, 0x11CF, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("97E99BA0-BDEA-11CF-A5D6-28DB04C10000", KSPROPTYPESETID_General);
+#define KSPROPTYPESETID_General DEFINE_GUIDNAMED(KSPROPTYPESETID_General)
+
+#if defined(_NTDDK_) && !defined(__wtypes_h__)
+enum VARENUM {
+ VT_EMPTY = 0,
+ VT_NULL = 1,
+ VT_I2 = 2,
+ VT_I4 = 3,
+ VT_R4 = 4,
+ VT_R8 = 5,
+ VT_CY = 6,
+ VT_DATE = 7,
+ VT_BSTR = 8,
+ VT_DISPATCH = 9,
+ VT_ERROR = 10,
+ VT_BOOL = 11,
+ VT_VARIANT = 12,
+ VT_UNKNOWN = 13,
+ VT_DECIMAL = 14,
+ VT_I1 = 16,
+ VT_UI1 = 17,
+ VT_UI2 = 18,
+ VT_UI4 = 19,
+ VT_I8 = 20,
+ VT_UI8 = 21,
+ VT_INT = 22,
+ VT_UINT = 23,
+ VT_VOID = 24,
+ VT_HRESULT = 25,
+ VT_PTR = 26,
+ VT_SAFEARRAY = 27,
+ VT_CARRAY = 28,
+ VT_USERDEFINED = 29,
+ VT_LPSTR = 30,
+ VT_LPWSTR = 31,
+ VT_FILETIME = 64,
+ VT_BLOB = 65,
+ VT_STREAM = 66,
+ VT_STORAGE = 67,
+ VT_STREAMED_OBJECT = 68,
+ VT_STORED_OBJECT = 69,
+ VT_BLOB_OBJECT = 70,
+ VT_CF = 71,
+ VT_CLSID = 72,
+ VT_VECTOR = 0x1000,
+ VT_ARRAY = 0x2000,
+ VT_BYREF = 0x4000,
+ VT_RESERVED = 0x8000,
+ VT_ILLEGAL = 0xffff,
+ VT_ILLEGALMASKED = 0xfff,
+ VT_TYPEMASK = 0xfff
+};
+#endif // _NTDDK_ && !__wtypes_h__
+
+typedef struct {
+ ULONG Size;
+ ULONG Count;
+} KSMULTIPLE_ITEM, *PKSMULTIPLE_ITEM;
+
+typedef struct {
+ ULONG AccessFlags;
+ ULONG DescriptionSize;
+ KSIDENTIFIER PropTypeSet;
+ ULONG MembersListCount;
+ ULONG Reserved;
+} KSPROPERTY_DESCRIPTION, *PKSPROPERTY_DESCRIPTION;
+
+#define KSPROPERTY_MEMBER_RANGES 0x00000001
+#define KSPROPERTY_MEMBER_STEPPEDRANGES 0x00000002
+#define KSPROPERTY_MEMBER_VALUES 0x00000003
+
+#define KSPROPERTY_MEMBER_FLAG_DEFAULT 0x00000001
+#define KSPROPERTY_MEMBER_FLAG_BASICSUPPORT_MULTICHANNEL 0x00000002
+#define KSPROPERTY_MEMBER_FLAG_BASICSUPPORT_UNIFORM 0x00000004
+
+typedef struct {
+ ULONG MembersFlags;
+ ULONG MembersSize;
+ ULONG MembersCount;
+ ULONG Flags;
+} KSPROPERTY_MEMBERSHEADER, *PKSPROPERTY_MEMBERSHEADER;
+
+typedef union {
+#if defined( _KS_NO_ANONYMOUS_STRUCTURES_ )
+ struct _SIGNED {
+#else
+ struct {
+#endif
+ LONG SignedMinimum;
+ LONG SignedMaximum;
+ };
+#if defined( _KS_NO_ANONYMOUS_STRUCTURES_ )
+ struct _UNSIGNED {
+#else
+ struct {
+#endif
+ ULONG UnsignedMinimum;
+ ULONG UnsignedMaximum;
+ };
+} KSPROPERTY_BOUNDS_LONG, *PKSPROPERTY_BOUNDS_LONG;
+
+typedef union {
+#if defined( _KS_NO_ANONYMOUS_STRUCTURES_ )
+ struct _SIGNED64 {
+#else
+ struct {
+#endif
+ LONGLONG SignedMinimum;
+ LONGLONG SignedMaximum;
+ };
+#if defined( _KS_NO_ANONYMOUS_STRUCTURES_ )
+ struct _UNSIGNED64 {
+#else
+ struct {
+#endif
+#if defined(_NTDDK_)
+ ULONGLONG UnsignedMinimum;
+ ULONGLONG UnsignedMaximum;
+#else // !_NTDDK_
+ DWORDLONG UnsignedMinimum;
+ DWORDLONG UnsignedMaximum;
+#endif // !_NTDDK_
+ };
+} KSPROPERTY_BOUNDS_LONGLONG, *PKSPROPERTY_BOUNDS_LONGLONG;
+
+typedef struct {
+ ULONG SteppingDelta;
+ ULONG Reserved;
+ KSPROPERTY_BOUNDS_LONG Bounds;
+} KSPROPERTY_STEPPING_LONG, *PKSPROPERTY_STEPPING_LONG;
+
+typedef struct {
+#if defined(_NTDDK_)
+ ULONGLONG SteppingDelta;
+#else // !_NTDDK_
+ DWORDLONG SteppingDelta;
+#endif // !_NTDDK_
+ KSPROPERTY_BOUNDS_LONGLONG Bounds;
+} KSPROPERTY_STEPPING_LONGLONG, *PKSPROPERTY_STEPPING_LONGLONG;
+
+//===========================================================================
+
+#if defined(_NTDDK_)
+//
+// Structure forward declarations.
+//
+typedef struct _KSDEVICE_DESCRIPTOR
+KSDEVICE_DESCRIPTOR, *PKSDEVICE_DESCRIPTOR;
+typedef struct _KSDEVICE_DISPATCH
+KSDEVICE_DISPATCH, *PKSDEVICE_DISPATCH;
+typedef struct _KSDEVICE
+KSDEVICE, *PKSDEVICE;
+typedef struct _KSFILTERFACTORY
+KSFILTERFACTORY, *PKSFILTERFACTORY;
+typedef struct _KSFILTER_DESCRIPTOR
+KSFILTER_DESCRIPTOR, *PKSFILTER_DESCRIPTOR;
+typedef struct _KSFILTER_DISPATCH
+KSFILTER_DISPATCH, *PKSFILTER_DISPATCH;
+typedef struct _KSFILTER
+KSFILTER, *PKSFILTER;
+typedef struct _KSPIN_DESCRIPTOR_EX
+KSPIN_DESCRIPTOR_EX, *PKSPIN_DESCRIPTOR_EX;
+typedef struct _KSPIN_DISPATCH
+KSPIN_DISPATCH, *PKSPIN_DISPATCH;
+typedef struct _KSCLOCK_DISPATCH
+KSCLOCK_DISPATCH, *PKSCLOCK_DISPATCH;
+typedef struct _KSALLOCATOR_DISPATCH
+KSALLOCATOR_DISPATCH, *PKSALLOCATOR_DISPATCH;
+typedef struct _KSPIN
+KSPIN, *PKSPIN;
+typedef struct _KSNODE_DESCRIPTOR
+KSNODE_DESCRIPTOR, *PKSNODE_DESCRIPTOR;
+typedef struct _KSSTREAM_POINTER_OFFSET
+KSSTREAM_POINTER_OFFSET, *PKSSTREAM_POINTER_OFFSET;
+typedef struct _KSSTREAM_POINTER
+KSSTREAM_POINTER, *PKSSTREAM_POINTER;
+typedef struct _KSMAPPING
+KSMAPPING, *PKSMAPPING;
+typedef struct _KSPROCESSPIN
+KSPROCESSPIN, *PKSPROCESSPIN;
+typedef struct _KSPROCESSPIN_INDEXENTRY
+KSPROCESSPIN_INDEXENTRY, *PKSPROCESSPIN_INDEXENTRY;
+#endif // _NTDDK_
+
+typedef PVOID PKSWORKER;
+
+typedef struct {
+ ULONG NotificationType;
+ union {
+ struct {
+ HANDLE Event;
+ ULONG_PTR Reserved[2];
+ } EventHandle;
+ struct {
+ HANDLE Semaphore;
+ ULONG Reserved;
+ LONG Adjustment;
+ } SemaphoreHandle;
+#if defined(_NTDDK_)
+ struct {
+ PVOID Event;
+ KPRIORITY Increment;
+ ULONG_PTR Reserved;
+ } EventObject;
+ struct {
+ PVOID Semaphore;
+ KPRIORITY Increment;
+ LONG Adjustment;
+ } SemaphoreObject;
+ struct {
+ PKDPC Dpc;
+ ULONG ReferenceCount;
+ ULONG_PTR Reserved;
+ } Dpc;
+ struct {
+ PWORK_QUEUE_ITEM WorkQueueItem;
+ WORK_QUEUE_TYPE WorkQueueType;
+ ULONG_PTR Reserved;
+ } WorkItem;
+ struct {
+ PWORK_QUEUE_ITEM WorkQueueItem;
+ PKSWORKER KsWorkerObject;
+ ULONG_PTR Reserved;
+ } KsWorkItem;
+// @@BEGIN_DDKSPLIT
+ struct {
+ PKSFILTER Filter;
+ ULONG_PTR Reserved[2];
+ } KsFilterProcessing;
+ struct {
+ PKSPIN Pin;
+ ULONG_PTR Reserved[2];
+ } KsPinProcessing;
+// @@END_DDKSPLIT
+#endif // defined(_NTDDK_)
+ struct {
+ PVOID Unused;
+ LONG_PTR Alignment[2];
+ } Alignment;
+ };
+} KSEVENTDATA, *PKSEVENTDATA;
+
+#define KSEVENTF_EVENT_HANDLE 0x00000001
+#define KSEVENTF_SEMAPHORE_HANDLE 0x00000002
+#if defined(_NTDDK_)
+#define KSEVENTF_EVENT_OBJECT 0x00000004
+#define KSEVENTF_SEMAPHORE_OBJECT 0x00000008
+#define KSEVENTF_DPC 0x00000010
+#define KSEVENTF_WORKITEM 0x00000020
+#define KSEVENTF_KSWORKITEM 0x00000080
+// @@BEGIN_DDKSPLIT
+#define KSEVENTF_KSFILTERPROCESSING 0x00000100
+#define KSEVENTF_KSPINPROCESSING 0x00000200
+// @@END_DDKSPLIT
+#endif // defined(_NTDDK_)
+
+#define KSEVENT_TYPE_ENABLE 0x00000001
+#define KSEVENT_TYPE_ONESHOT 0x00000002
+#define KSEVENT_TYPE_ENABLEBUFFERED 0x00000004
+#define KSEVENT_TYPE_SETSUPPORT 0x00000100
+#define KSEVENT_TYPE_BASICSUPPORT 0x00000200
+#define KSEVENT_TYPE_QUERYBUFFER 0x00000400
+
+#define KSEVENT_TYPE_TOPOLOGY 0x10000000
+
+typedef struct {
+ KSEVENT Event;
+ PKSEVENTDATA EventData;
+ PVOID Reserved;
+} KSQUERYBUFFER, *PKSQUERYBUFFER;
+
+typedef struct {
+ ULONG Size;
+ ULONG Flags;
+ union {
+ HANDLE ObjectHandle;
+ PVOID ObjectPointer;
+ };
+ PVOID Reserved;
+ KSEVENT Event;
+ KSEVENTDATA EventData;
+} KSRELATIVEEVENT;
+
+#define KSRELATIVEEVENT_FLAG_HANDLE 0x00000001
+#define KSRELATIVEEVENT_FLAG_POINTER 0x00000002
+
+//===========================================================================
+
+typedef struct {
+ KSEVENTDATA EventData;
+ LONGLONG MarkTime;
+} KSEVENT_TIME_MARK, *PKSEVENT_TIME_MARK;
+
+typedef struct {
+ KSEVENTDATA EventData;
+ LONGLONG TimeBase;
+ LONGLONG Interval;
+} KSEVENT_TIME_INTERVAL, *PKSEVENT_TIME_INTERVAL;
+
+typedef struct {
+ LONGLONG TimeBase;
+ LONGLONG Interval;
+} KSINTERVAL, *PKSINTERVAL;
+
+//===========================================================================
+
+#define STATIC_KSPROPSETID_General\
+ 0x1464EDA5L, 0x6A8F, 0x11D1, 0x9A, 0xA7, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
+DEFINE_GUIDSTRUCT("1464EDA5-6A8F-11D1-9AA7-00A0C9223196", KSPROPSETID_General);
+#define KSPROPSETID_General DEFINE_GUIDNAMED(KSPROPSETID_General)
+
+typedef enum {
+ KSPROPERTY_GENERAL_COMPONENTID
+} KSPROPERTY_GENERAL;
+
+typedef struct {
+ GUID Manufacturer;
+ GUID Product;
+ GUID Component;
+ GUID Name;
+ ULONG Version;
+ ULONG Revision;
+} KSCOMPONENTID, *PKSCOMPONENTID;
+
+#define DEFINE_KSPROPERTY_ITEM_GENERAL_COMPONENTID(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_GENERAL_COMPONENTID,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KSCOMPONENTID),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define STATIC_KSMETHODSETID_StreamIo\
+ 0x65D003CAL, 0x1523, 0x11D2, 0xB2, 0x7A, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
+DEFINE_GUIDSTRUCT("65D003CA-1523-11D2-B27A-00A0C9223196", KSMETHODSETID_StreamIo);
+#define KSMETHODSETID_StreamIo DEFINE_GUIDNAMED(KSMETHODSETID_StreamIo)
+
+typedef enum {
+ KSMETHOD_STREAMIO_READ,
+ KSMETHOD_STREAMIO_WRITE
+} KSMETHOD_STREAMIO;
+
+#define DEFINE_KSMETHOD_ITEM_STREAMIO_READ(Handler)\
+ DEFINE_KSMETHOD_ITEM(\
+ KSMETHOD_STREAMIO_READ,\
+ KSMETHOD_TYPE_WRITE,\
+ (Handler),\
+ sizeof(KSMETHOD),\
+ 0,\
+ NULL)
+
+#define DEFINE_KSMETHOD_ITEM_STREAMIO_WRITE(Handler)\
+ DEFINE_KSMETHOD_ITEM(\
+ KSMETHOD_STREAMIO_WRITE,\
+ KSMETHOD_TYPE_READ,\
+ (Handler),\
+ sizeof(KSMETHOD),\
+ 0,\
+ NULL)
+
+#define STATIC_KSPROPSETID_MediaSeeking\
+ 0xEE904F0CL, 0xD09B, 0x11D0, 0xAB, 0xE9, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
+DEFINE_GUIDSTRUCT("EE904F0C-D09B-11D0-ABE9-00A0C9223196", KSPROPSETID_MediaSeeking);
+#define KSPROPSETID_MediaSeeking DEFINE_GUIDNAMED(KSPROPSETID_MediaSeeking)
+
+typedef enum {
+ KSPROPERTY_MEDIASEEKING_CAPABILITIES,
+ KSPROPERTY_MEDIASEEKING_FORMATS,
+ KSPROPERTY_MEDIASEEKING_TIMEFORMAT,
+ KSPROPERTY_MEDIASEEKING_POSITION,
+ KSPROPERTY_MEDIASEEKING_STOPPOSITION,
+ KSPROPERTY_MEDIASEEKING_POSITIONS,
+ KSPROPERTY_MEDIASEEKING_DURATION,
+ KSPROPERTY_MEDIASEEKING_AVAILABLE,
+ KSPROPERTY_MEDIASEEKING_PREROLL,
+ KSPROPERTY_MEDIASEEKING_CONVERTTIMEFORMAT
+} KSPROPERTY_MEDIASEEKING;
+
+typedef enum {
+ KS_SEEKING_NoPositioning,
+ KS_SEEKING_AbsolutePositioning,
+ KS_SEEKING_RelativePositioning,
+ KS_SEEKING_IncrementalPositioning,
+ KS_SEEKING_PositioningBitsMask = 0x3,
+ KS_SEEKING_SeekToKeyFrame,
+ KS_SEEKING_ReturnTime = 0x8
+} KS_SEEKING_FLAGS;
+
+typedef enum {
+ KS_SEEKING_CanSeekAbsolute = 0x1,
+ KS_SEEKING_CanSeekForwards = 0x2,
+ KS_SEEKING_CanSeekBackwards = 0x4,
+ KS_SEEKING_CanGetCurrentPos = 0x8,
+ KS_SEEKING_CanGetStopPos = 0x10,
+ KS_SEEKING_CanGetDuration = 0x20,
+ KS_SEEKING_CanPlayBackwards = 0x40
+} KS_SEEKING_CAPABILITIES;
+
+typedef struct {
+ LONGLONG Current;
+ LONGLONG Stop;
+ KS_SEEKING_FLAGS CurrentFlags;
+ KS_SEEKING_FLAGS StopFlags;
+} KSPROPERTY_POSITIONS, *PKSPROPERTY_POSITIONS;
+
+typedef struct {
+ LONGLONG Earliest;
+ LONGLONG Latest;
+} KSPROPERTY_MEDIAAVAILABLE, *PKSPROPERTY_MEDIAAVAILABLE;
+
+typedef struct {
+ KSPROPERTY Property;
+ GUID SourceFormat;
+ GUID TargetFormat;
+ LONGLONG Time;
+} KSP_TIMEFORMAT, *PKSP_TIMEFORMAT;
+
+#define DEFINE_KSPROPERTY_ITEM_MEDIASEEKING_CAPABILITIES(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_MEDIASEEKING_CAPABILITIES,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KS_SEEKING_CAPABILITIES),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_MEDIASEEKING_FORMATS(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_MEDIASEEKING_FORMATS,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ 0,\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_MEDIASEEKING_TIMEFORMAT(GetHandler, SetHandler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_MEDIASEEKING_TIMEFORMAT,\
+ (GetHandler),\
+ sizeof(KSPROPERTY),\
+ sizeof(GUID),\
+ (SetHandler),\
+ NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_MEDIASEEKING_POSITION(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_MEDIASEEKING_POSITION,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(LONGLONG),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_MEDIASEEKING_STOPPOSITION(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_MEDIASEEKING_STOPPOSITION,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(LONGLONG),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_MEDIASEEKING_POSITIONS(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_MEDIASEEKING_POSITIONS,\
+ NULL,\
+ sizeof(KSPROPERTY),\
+ sizeof(KSPROPERTY_POSITIONS),\
+ (Handler),\
+ NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_MEDIASEEKING_DURATION(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_MEDIASEEKING_DURATION,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(LONGLONG),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_MEDIASEEKING_AVAILABLE(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_MEDIASEEKING_AVAILABLE,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KSPROPERTY_MEDIAAVAILABLE),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_MEDIASEEKING_PREROLL(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_MEDIASEEKING_PREROLL,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(LONGLONG),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_MEDIASEEKING_CONVERTTIMEFORMAT(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_MEDIASEEKING_CONVERTTIMEFORMAT,\
+ (Handler),\
+ sizeof(KSP_TIMEFORMAT),\
+ sizeof(LONGLONG),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+//===========================================================================
+
+#define STATIC_KSPROPSETID_Topology\
+ 0x720D4AC0L, 0x7533, 0x11D0, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("720D4AC0-7533-11D0-A5D6-28DB04C10000", KSPROPSETID_Topology);
+#define KSPROPSETID_Topology DEFINE_GUIDNAMED(KSPROPSETID_Topology)
+
+typedef enum {
+ KSPROPERTY_TOPOLOGY_CATEGORIES,
+ KSPROPERTY_TOPOLOGY_NODES,
+ KSPROPERTY_TOPOLOGY_CONNECTIONS,
+ KSPROPERTY_TOPOLOGY_NAME
+} KSPROPERTY_TOPOLOGY;
+
+#define DEFINE_KSPROPERTY_ITEM_TOPOLOGY_CATEGORIES(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_TOPOLOGY_CATEGORIES,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ 0,\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_TOPOLOGY_NODES(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_TOPOLOGY_NODES,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ 0,\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_TOPOLOGY_CONNECTIONS(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_TOPOLOGY_CONNECTIONS,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ 0,\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_TOPOLOGY_NAME(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_TOPOLOGY_NAME,\
+ (Handler),\
+ sizeof(KSP_NODE),\
+ 0,\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_TOPOLOGYSET(TopologySet, Handler)\
+DEFINE_KSPROPERTY_TABLE(TopologySet) {\
+ DEFINE_KSPROPERTY_ITEM_TOPOLOGY_CATEGORIES(Handler),\
+ DEFINE_KSPROPERTY_ITEM_TOPOLOGY_NODES(Handler),\
+ DEFINE_KSPROPERTY_ITEM_TOPOLOGY_CONNECTIONS(Handler),\
+ DEFINE_KSPROPERTY_ITEM_TOPOLOGY_NAME(Handler)\
+}
+
+//=============================================================================
+
+//
+// properties used by graph manager to talk to particular filters
+//
+#if defined(_NTDDK_)
+
+#define STATIC_KSPROPSETID_GM \
+ 0xAF627536L, 0xE719, 0x11D2, 0x8A, 0x1D, 0x00, 0x60, 0x97, 0xD2, 0xDF, 0x5D
+DEFINE_GUIDSTRUCT("AF627536-E719-11D2-8A1D-006097D2DF5D", KSPROPSETID_GM);
+#define KSPROPSETID_GM DEFINE_GUIDNAMED(KSPROPSETID_GM)
+
+typedef VOID (*PFNKSGRAPHMANAGER_NOTIFY)(IN PFILE_OBJECT GraphManager,
+ IN ULONG EventId,
+ IN PVOID Filter,
+ IN PVOID Pin,
+ IN PVOID Frame,
+ IN ULONG Duration);
+
+typedef struct KSGRAPHMANAGER_FUNCTIONTABLE {
+ PFNKSGRAPHMANAGER_NOTIFY NotifyEvent;
+} KSGRAPHMANAGER_FUNCTIONTABLE, PKSGRAPHMANAGER_FUNCTIONTABLE;
+
+typedef struct _KSPROPERTY_GRAPHMANAGER_INTERFACE {
+ PFILE_OBJECT GraphManager;
+ KSGRAPHMANAGER_FUNCTIONTABLE FunctionTable;
+} KSPROPERTY_GRAPHMANAGER_INTERFACE, *PKSPROPERTY_GRAPHMANAGER_INTERFACE;
+
+
+//
+// Commands
+//
+typedef enum {
+ KSPROPERTY_GM_GRAPHMANAGER,
+ KSPROPERTY_GM_TIMESTAMP_CLOCK,
+ KSPROPERTY_GM_RATEMATCH,
+ KSPROPERTY_GM_RENDER_CLOCK,
+} KSPROPERTY_GM;
+
+#endif
+
+//===========================================================================
+
+
+#define STATIC_KSCATEGORY_BRIDGE \
+ 0x085AFF00L, 0x62CE, 0x11CF, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("085AFF00-62CE-11CF-A5D6-28DB04C10000", KSCATEGORY_BRIDGE);
+#define KSCATEGORY_BRIDGE DEFINE_GUIDNAMED(KSCATEGORY_BRIDGE)
+
+#define STATIC_KSCATEGORY_CAPTURE \
+ 0x65E8773DL, 0x8F56, 0x11D0, 0xA3, 0xB9, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
+DEFINE_GUIDSTRUCT("65E8773D-8F56-11D0-A3B9-00A0C9223196", KSCATEGORY_CAPTURE);
+#define KSCATEGORY_CAPTURE DEFINE_GUIDNAMED(KSCATEGORY_CAPTURE)
+
+#define STATIC_KSCATEGORY_RENDER \
+ 0x65E8773EL, 0x8F56, 0x11D0, 0xA3, 0xB9, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
+DEFINE_GUIDSTRUCT("65E8773E-8F56-11D0-A3B9-00A0C9223196", KSCATEGORY_RENDER);
+#define KSCATEGORY_RENDER DEFINE_GUIDNAMED(KSCATEGORY_RENDER)
+
+#define STATIC_KSCATEGORY_MIXER \
+ 0xAD809C00L, 0x7B88, 0x11D0, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("AD809C00-7B88-11D0-A5D6-28DB04C10000", KSCATEGORY_MIXER);
+#define KSCATEGORY_MIXER DEFINE_GUIDNAMED(KSCATEGORY_MIXER)
+
+#define STATIC_KSCATEGORY_SPLITTER \
+ 0x0A4252A0L, 0x7E70, 0x11D0, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("0A4252A0-7E70-11D0-A5D6-28DB04C10000", KSCATEGORY_SPLITTER);
+#define KSCATEGORY_SPLITTER DEFINE_GUIDNAMED(KSCATEGORY_SPLITTER)
+
+#define STATIC_KSCATEGORY_DATACOMPRESSOR \
+ 0x1E84C900L, 0x7E70, 0x11D0, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("1E84C900-7E70-11D0-A5D6-28DB04C10000", KSCATEGORY_DATACOMPRESSOR);
+#define KSCATEGORY_DATACOMPRESSOR DEFINE_GUIDNAMED(KSCATEGORY_DATACOMPRESSOR)
+
+#define STATIC_KSCATEGORY_DATADECOMPRESSOR \
+ 0x2721AE20L, 0x7E70, 0x11D0, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("2721AE20-7E70-11D0-A5D6-28DB04C10000", KSCATEGORY_DATADECOMPRESSOR);
+#define KSCATEGORY_DATADECOMPRESSOR DEFINE_GUIDNAMED(KSCATEGORY_DATADECOMPRESSOR)
+
+#define STATIC_KSCATEGORY_DATATRANSFORM \
+ 0x2EB07EA0L, 0x7E70, 0x11D0, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("2EB07EA0-7E70-11D0-A5D6-28DB04C10000", KSCATEGORY_DATATRANSFORM);
+#define KSCATEGORY_DATATRANSFORM DEFINE_GUIDNAMED(KSCATEGORY_DATATRANSFORM)
+
+#define STATIC_KSCATEGORY_COMMUNICATIONSTRANSFORM \
+ 0xCF1DDA2CL, 0x9743, 0x11D0, 0xA3, 0xEE, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
+DEFINE_GUIDSTRUCT("CF1DDA2C-9743-11D0-A3EE-00A0C9223196", KSCATEGORY_COMMUNICATIONSTRANSFORM);
+#define KSCATEGORY_COMMUNICATIONSTRANSFORM DEFINE_GUIDNAMED(KSCATEGORY_COMMUNICATIONSTRANSFORM)
+
+#define STATIC_KSCATEGORY_INTERFACETRANSFORM \
+ 0xCF1DDA2DL, 0x9743, 0x11D0, 0xA3, 0xEE, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
+DEFINE_GUIDSTRUCT("CF1DDA2D-9743-11D0-A3EE-00A0C9223196", KSCATEGORY_INTERFACETRANSFORM);
+#define KSCATEGORY_INTERFACETRANSFORM DEFINE_GUIDNAMED(KSCATEGORY_INTERFACETRANSFORM)
+
+#define STATIC_KSCATEGORY_MEDIUMTRANSFORM \
+ 0xCF1DDA2EL, 0x9743, 0x11D0, 0xA3, 0xEE, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
+DEFINE_GUIDSTRUCT("CF1DDA2E-9743-11D0-A3EE-00A0C9223196", KSCATEGORY_MEDIUMTRANSFORM);
+#define KSCATEGORY_MEDIUMTRANSFORM DEFINE_GUIDNAMED(KSCATEGORY_MEDIUMTRANSFORM)
+
+#define STATIC_KSCATEGORY_FILESYSTEM \
+ 0x760FED5EL, 0x9357, 0x11D0, 0xA3, 0xCC, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
+DEFINE_GUIDSTRUCT("760FED5E-9357-11D0-A3CC-00A0C9223196", KSCATEGORY_FILESYSTEM);
+#define KSCATEGORY_FILESYSTEM DEFINE_GUIDNAMED(KSCATEGORY_FILESYSTEM)
+
+// KSNAME_Clock
+#define STATIC_KSCATEGORY_CLOCK \
+ 0x53172480L, 0x4791, 0x11D0, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("53172480-4791-11D0-A5D6-28DB04C10000", KSCATEGORY_CLOCK);
+#define KSCATEGORY_CLOCK DEFINE_GUIDNAMED(KSCATEGORY_CLOCK)
+
+#define STATIC_KSCATEGORY_PROXY \
+ 0x97EBAACAL, 0x95BD, 0x11D0, 0xA3, 0xEA, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
+DEFINE_GUIDSTRUCT("97EBAACA-95BD-11D0-A3EA-00A0C9223196", KSCATEGORY_PROXY);
+#define KSCATEGORY_PROXY DEFINE_GUIDNAMED(KSCATEGORY_PROXY)
+
+#define STATIC_KSCATEGORY_QUALITY \
+ 0x97EBAACBL, 0x95BD, 0x11D0, 0xA3, 0xEA, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
+DEFINE_GUIDSTRUCT("97EBAACB-95BD-11D0-A3EA-00A0C9223196", KSCATEGORY_QUALITY);
+#define KSCATEGORY_QUALITY DEFINE_GUIDNAMED(KSCATEGORY_QUALITY)
+
+typedef struct {
+ ULONG FromNode;
+ ULONG FromNodePin;
+ ULONG ToNode;
+ ULONG ToNodePin;
+} KSTOPOLOGY_CONNECTION, *PKSTOPOLOGY_CONNECTION;
+
+typedef struct {
+ ULONG CategoriesCount;
+ const GUID* Categories;
+ ULONG TopologyNodesCount;
+ const GUID* TopologyNodes;
+ ULONG TopologyConnectionsCount;
+ const KSTOPOLOGY_CONNECTION* TopologyConnections;
+ const GUID* TopologyNodesNames;
+ ULONG Reserved;
+} KSTOPOLOGY, *PKSTOPOLOGY;
+
+#define KSFILTER_NODE ((ULONG)-1)
+#define KSALL_NODES ((ULONG)-1)
+
+typedef struct {
+ ULONG CreateFlags;
+ ULONG Node;
+} KSNODE_CREATE, *PKSNODE_CREATE;
+
+//===========================================================================
+
+// TIME_FORMAT_NONE
+#define STATIC_KSTIME_FORMAT_NONE STATIC_GUID_NULL
+#define KSTIME_FORMAT_NONE GUID_NULL
+
+// TIME_FORMAT_FRAME
+#define STATIC_KSTIME_FORMAT_FRAME\
+ 0x7b785570L, 0x8c82, 0x11cf, 0xbc, 0x0c, 0x00, 0xaa, 0x00, 0xac, 0x74, 0xf6
+DEFINE_GUIDSTRUCT("7b785570-8c82-11cf-bc0c-00aa00ac74f6", KSTIME_FORMAT_FRAME);
+#define KSTIME_FORMAT_FRAME DEFINE_GUIDNAMED(KSTIME_FORMAT_FRAME)
+
+// TIME_FORMAT_BYTE
+#define STATIC_KSTIME_FORMAT_BYTE\
+ 0x7b785571L, 0x8c82, 0x11cf, 0xbc, 0x0c, 0x00, 0xaa, 0x00, 0xac, 0x74, 0xf6
+DEFINE_GUIDSTRUCT("7b785571-8c82-11cf-bc0c-00aa00ac74f6", KSTIME_FORMAT_BYTE);
+#define KSTIME_FORMAT_BYTE DEFINE_GUIDNAMED(KSTIME_FORMAT_BYTE)
+
+// TIME_FORMAT_SAMPLE
+#define STATIC_KSTIME_FORMAT_SAMPLE\
+ 0x7b785572L, 0x8c82, 0x11cf, 0xbc, 0x0c, 0x00, 0xaa, 0x00, 0xac, 0x74, 0xf6
+DEFINE_GUIDSTRUCT("7b785572-8c82-11cf-bc0c-00aa00ac74f6", KSTIME_FORMAT_SAMPLE);
+#define KSTIME_FORMAT_SAMPLE DEFINE_GUIDNAMED(KSTIME_FORMAT_SAMPLE)
+
+// TIME_FORMAT_FIELD
+#define STATIC_KSTIME_FORMAT_FIELD\
+ 0x7b785573L, 0x8c82, 0x11cf, 0xbc, 0x0c, 0x00, 0xaa, 0x00, 0xac, 0x74, 0xf6
+DEFINE_GUIDSTRUCT("7b785573-8c82-11cf-bc0c-00aa00ac74f6", KSTIME_FORMAT_FIELD);
+#define KSTIME_FORMAT_FIELD DEFINE_GUIDNAMED(KSTIME_FORMAT_FIELD)
+
+// TIME_FORMAT_MEDIA_TIME
+#define STATIC_KSTIME_FORMAT_MEDIA_TIME\
+ 0x7b785574L, 0x8c82, 0x11cf, 0xbc, 0x0c, 0x00, 0xaa, 0x00, 0xac, 0x74, 0xf6
+DEFINE_GUIDSTRUCT("7b785574-8c82-11cf-bc0c-00aa00ac74f6", KSTIME_FORMAT_MEDIA_TIME);
+#define KSTIME_FORMAT_MEDIA_TIME DEFINE_GUIDNAMED(KSTIME_FORMAT_MEDIA_TIME)
+
+//===========================================================================
+
+typedef KSIDENTIFIER KSPIN_INTERFACE, *PKSPIN_INTERFACE;
+
+#define STATIC_KSINTERFACESETID_Standard \
+ 0x1A8766A0L, 0x62CE, 0x11CF, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("1A8766A0-62CE-11CF-A5D6-28DB04C10000", KSINTERFACESETID_Standard);
+#define KSINTERFACESETID_Standard DEFINE_GUIDNAMED(KSINTERFACESETID_Standard)
+
+typedef enum {
+ KSINTERFACE_STANDARD_STREAMING,
+ KSINTERFACE_STANDARD_LOOPED_STREAMING,
+ KSINTERFACE_STANDARD_CONTROL
+} KSINTERFACE_STANDARD;
+
+#define STATIC_KSINTERFACESETID_FileIo \
+ 0x8C6F932CL, 0xE771, 0x11D0, 0xB8, 0xFF, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
+DEFINE_GUIDSTRUCT("8C6F932C-E771-11D0-B8FF-00A0C9223196", KSINTERFACESETID_FileIo);
+#define KSINTERFACESETID_FileIo DEFINE_GUIDNAMED(KSINTERFACESETID_FileIo)
+
+typedef enum {
+ KSINTERFACE_FILEIO_STREAMING
+} KSINTERFACE_FILEIO;
+
+//===========================================================================
+
+#define KSMEDIUM_TYPE_ANYINSTANCE 0
+
+#define STATIC_KSMEDIUMSETID_Standard \
+ 0x4747B320L, 0x62CE, 0x11CF, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("4747B320-62CE-11CF-A5D6-28DB04C10000", KSMEDIUMSETID_Standard);
+#define KSMEDIUMSETID_Standard DEFINE_GUIDNAMED(KSMEDIUMSETID_Standard)
+
+//For compatibility only
+#define KSMEDIUM_STANDARD_DEVIO KSMEDIUM_TYPE_ANYINSTANCE
+
+//===========================================================================
+
+#define STATIC_KSPROPSETID_Pin\
+ 0x8C134960L, 0x51AD, 0x11CF, 0x87, 0x8A, 0x94, 0xF8, 0x01, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("8C134960-51AD-11CF-878A-94F801C10000", KSPROPSETID_Pin);
+#define KSPROPSETID_Pin DEFINE_GUIDNAMED(KSPROPSETID_Pin)
+
+typedef enum {
+ KSPROPERTY_PIN_CINSTANCES,
+ KSPROPERTY_PIN_CTYPES,
+ KSPROPERTY_PIN_DATAFLOW,
+ KSPROPERTY_PIN_DATARANGES,
+ KSPROPERTY_PIN_DATAINTERSECTION,
+ KSPROPERTY_PIN_INTERFACES,
+ KSPROPERTY_PIN_MEDIUMS,
+ KSPROPERTY_PIN_COMMUNICATION,
+ KSPROPERTY_PIN_GLOBALCINSTANCES,
+ KSPROPERTY_PIN_NECESSARYINSTANCES,
+ KSPROPERTY_PIN_PHYSICALCONNECTION,
+ KSPROPERTY_PIN_CATEGORY,
+ KSPROPERTY_PIN_NAME,
+ KSPROPERTY_PIN_CONSTRAINEDDATARANGES,
+ KSPROPERTY_PIN_PROPOSEDATAFORMAT
+} KSPROPERTY_PIN;
+
+typedef struct {
+ KSPROPERTY Property;
+ ULONG PinId;
+ ULONG Reserved;
+} KSP_PIN, *PKSP_PIN;
+
+#define KSINSTANCE_INDETERMINATE ((ULONG)-1)
+
+typedef struct {
+ ULONG PossibleCount;
+ ULONG CurrentCount;
+} KSPIN_CINSTANCES, *PKSPIN_CINSTANCES;
+
+typedef enum {
+ KSPIN_DATAFLOW_IN = 1,
+ KSPIN_DATAFLOW_OUT
+} KSPIN_DATAFLOW, *PKSPIN_DATAFLOW;
+
+#define KSDATAFORMAT_BIT_TEMPORAL_COMPRESSION 0
+#define KSDATAFORMAT_TEMPORAL_COMPRESSION (1 << KSDATAFORMAT_BIT_TEMPORAL_COMPRESSION)
+#define KSDATAFORMAT_BIT_ATTRIBUTES 1
+#define KSDATAFORMAT_ATTRIBUTES (1 << KSDATAFORMAT_BIT_ATTRIBUTES)
+
+#define KSDATARANGE_BIT_ATTRIBUTES 1
+#define KSDATARANGE_ATTRIBUTES (1 << KSDATARANGE_BIT_ATTRIBUTES)
+#define KSDATARANGE_BIT_REQUIRED_ATTRIBUTES 2
+#define KSDATARANGE_REQUIRED_ATTRIBUTES (1 << KSDATARANGE_BIT_REQUIRED_ATTRIBUTES)
+
+#if !defined( _MSC_VER )
+typedef struct {
+ ULONG FormatSize;
+ ULONG Flags;
+ ULONG SampleSize;
+ ULONG Reserved;
+ GUID MajorFormat;
+ GUID SubFormat;
+ GUID Specifier;
+} KSDATAFORMAT, *PKSDATAFORMAT, KSDATARANGE, *PKSDATARANGE;
+#else
+typedef union {
+ struct {
+ ULONG FormatSize;
+ ULONG Flags;
+ ULONG SampleSize;
+ ULONG Reserved;
+ GUID MajorFormat;
+ GUID SubFormat;
+ GUID Specifier;
+ };
+ LONGLONG Alignment;
+} KSDATAFORMAT, *PKSDATAFORMAT, KSDATARANGE, *PKSDATARANGE;
+#endif
+
+#define KSATTRIBUTE_REQUIRED 0x00000001
+
+typedef struct {
+ ULONG Size;
+ ULONG Flags;
+ GUID Attribute;
+} KSATTRIBUTE, *PKSATTRIBUTE;
+
+#if defined(_NTDDK_)
+typedef struct {
+ ULONG Count;
+ PKSATTRIBUTE* Attributes;
+} KSATTRIBUTE_LIST, *PKSATTRIBUTE_LIST;
+#endif // _NTDDK_
+
+typedef enum {
+ KSPIN_COMMUNICATION_NONE,
+ KSPIN_COMMUNICATION_SINK,
+ KSPIN_COMMUNICATION_SOURCE,
+ KSPIN_COMMUNICATION_BOTH,
+ KSPIN_COMMUNICATION_BRIDGE
+} KSPIN_COMMUNICATION, *PKSPIN_COMMUNICATION;
+
+typedef KSIDENTIFIER KSPIN_MEDIUM, *PKSPIN_MEDIUM;
+
+typedef struct {
+ KSPIN_INTERFACE Interface;
+ KSPIN_MEDIUM Medium;
+ ULONG PinId;
+ HANDLE PinToHandle;
+ KSPRIORITY Priority;
+} KSPIN_CONNECT, *PKSPIN_CONNECT;
+
+typedef struct {
+ ULONG Size;
+ ULONG Pin;
+ WCHAR SymbolicLinkName[1];
+} KSPIN_PHYSICALCONNECTION, *PKSPIN_PHYSICALCONNECTION;
+
+#if defined(_NTDDK_)
+typedef
+NTSTATUS
+(*PFNKSINTERSECTHANDLER)(
+ IN PIRP Irp,
+ IN PKSP_PIN Pin,
+ IN PKSDATARANGE DataRange,
+ OUT PVOID Data OPTIONAL
+ );
+typedef
+NTSTATUS
+(*PFNKSINTERSECTHANDLEREX)(
+ IN PVOID Context,
+ IN PIRP Irp,
+ IN PKSP_PIN Pin,
+ IN PKSDATARANGE DataRange,
+ IN PKSDATARANGE MatchingDataRange,
+ IN ULONG DataBufferSize,
+ OUT PVOID Data OPTIONAL,
+ OUT PULONG DataSize
+ );
+#endif // _NTDDK_
+
+#define DEFINE_KSPIN_INTERFACE_TABLE(tablename)\
+ const KSPIN_INTERFACE tablename[] =
+
+#define DEFINE_KSPIN_INTERFACE_ITEM(guid, interface)\
+ {\
+ STATICGUIDOF(guid),\
+ (interface),\
+ 0\
+ }
+
+#define DEFINE_KSPIN_MEDIUM_TABLE( tablename )\
+ const KSPIN_MEDIUM tablename[] =
+
+#define DEFINE_KSPIN_MEDIUM_ITEM(guid, medium)\
+ DEFINE_KSPIN_INTERFACE_ITEM(guid, medium)
+
+#define DEFINE_KSPROPERTY_ITEM_PIN_CINSTANCES(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_PIN_CINSTANCES,\
+ (Handler),\
+ sizeof(KSP_PIN),\
+ sizeof(KSPIN_CINSTANCES),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_PIN_CTYPES(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_PIN_CTYPES,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(ULONG),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_PIN_DATAFLOW(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_PIN_DATAFLOW,\
+ (Handler),\
+ sizeof(KSP_PIN),\
+ sizeof(KSPIN_DATAFLOW),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_PIN_DATARANGES(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_PIN_DATARANGES,\
+ (Handler),\
+ sizeof(KSP_PIN),\
+ 0,\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_PIN_DATAINTERSECTION(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_PIN_DATAINTERSECTION,\
+ (Handler),\
+ sizeof(KSP_PIN) + sizeof(KSMULTIPLE_ITEM),\
+ 0,\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_PIN_INTERFACES(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_PIN_INTERFACES,\
+ (Handler),\
+ sizeof(KSP_PIN),\
+ 0,\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_PIN_MEDIUMS(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_PIN_MEDIUMS,\
+ (Handler),\
+ sizeof(KSP_PIN),\
+ 0,\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_PIN_COMMUNICATION(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_PIN_COMMUNICATION,\
+ (Handler),\
+ sizeof(KSP_PIN),\
+ sizeof(KSPIN_COMMUNICATION),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_PIN_GLOBALCINSTANCES(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_PIN_GLOBALCINSTANCES,\
+ (Handler),\
+ sizeof(KSP_PIN),\
+ sizeof(KSPIN_CINSTANCES),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_PIN_NECESSARYINSTANCES(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_PIN_NECESSARYINSTANCES,\
+ (Handler),\
+ sizeof(KSP_PIN),\
+ sizeof(ULONG),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_PIN_PHYSICALCONNECTION(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_PIN_PHYSICALCONNECTION,\
+ (Handler),\
+ sizeof(KSP_PIN),\
+ 0,\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_PIN_CATEGORY(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_PIN_CATEGORY,\
+ (Handler),\
+ sizeof(KSP_PIN),\
+ sizeof(GUID),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_PIN_NAME(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_PIN_NAME,\
+ (Handler),\
+ sizeof(KSP_PIN),\
+ 0,\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_PIN_CONSTRAINEDDATARANGES(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_PIN_CONSTRAINEDDATARANGES,\
+ (Handler),\
+ sizeof(KSP_PIN),\
+ 0,\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_PIN_PROPOSEDATAFORMAT(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_PIN_PROPOSEDATAFORMAT,\
+ NULL,\
+ sizeof(KSP_PIN),\
+ sizeof(KSDATAFORMAT),\
+ (Handler), NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_PINSET(PinSet,\
+ PropGeneral, PropInstances, PropIntersection)\
+DEFINE_KSPROPERTY_TABLE(PinSet) {\
+ DEFINE_KSPROPERTY_ITEM_PIN_CINSTANCES(PropInstances),\
+ DEFINE_KSPROPERTY_ITEM_PIN_CTYPES(PropGeneral),\
+ DEFINE_KSPROPERTY_ITEM_PIN_DATAFLOW(PropGeneral),\
+ DEFINE_KSPROPERTY_ITEM_PIN_DATARANGES(PropGeneral),\
+ DEFINE_KSPROPERTY_ITEM_PIN_DATAINTERSECTION(PropIntersection),\
+ DEFINE_KSPROPERTY_ITEM_PIN_INTERFACES(PropGeneral),\
+ DEFINE_KSPROPERTY_ITEM_PIN_MEDIUMS(PropGeneral),\
+ DEFINE_KSPROPERTY_ITEM_PIN_COMMUNICATION(PropGeneral),\
+ DEFINE_KSPROPERTY_ITEM_PIN_CATEGORY(PropGeneral),\
+ DEFINE_KSPROPERTY_ITEM_PIN_NAME(PropGeneral)\
+}
+
+#define DEFINE_KSPROPERTY_PINSETCONSTRAINED(PinSet,\
+ PropGeneral, PropInstances, PropIntersection)\
+DEFINE_KSPROPERTY_TABLE(PinSet) {\
+ DEFINE_KSPROPERTY_ITEM_PIN_CINSTANCES(PropInstances),\
+ DEFINE_KSPROPERTY_ITEM_PIN_CTYPES(PropGeneral),\
+ DEFINE_KSPROPERTY_ITEM_PIN_DATAFLOW(PropGeneral),\
+ DEFINE_KSPROPERTY_ITEM_PIN_DATARANGES(PropGeneral),\
+ DEFINE_KSPROPERTY_ITEM_PIN_DATAINTERSECTION(PropIntersection),\
+ DEFINE_KSPROPERTY_ITEM_PIN_INTERFACES(PropGeneral),\
+ DEFINE_KSPROPERTY_ITEM_PIN_MEDIUMS(PropGeneral),\
+ DEFINE_KSPROPERTY_ITEM_PIN_COMMUNICATION(PropGeneral),\
+ DEFINE_KSPROPERTY_ITEM_PIN_CATEGORY(PropGeneral),\
+ DEFINE_KSPROPERTY_ITEM_PIN_NAME(PropGeneral),\
+ DEFINE_KSPROPERTY_ITEM_PIN_CONSTRAINEDDATARANGES(PropGeneral)\
+}
+
+#define STATIC_KSNAME_Filter\
+ 0x9b365890L, 0x165f, 0x11d0, 0xa1, 0x95, 0x00, 0x20, 0xaf, 0xd1, 0x56, 0xe4
+DEFINE_GUIDSTRUCT("9b365890-165f-11d0-a195-0020afd156e4", KSNAME_Filter);
+#define KSNAME_Filter DEFINE_GUIDNAMED(KSNAME_Filter)
+
+#define KSSTRING_Filter L"{9B365890-165F-11D0-A195-0020AFD156E4}"
+
+#define STATIC_KSNAME_Pin\
+ 0x146F1A80L, 0x4791, 0x11D0, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("146F1A80-4791-11D0-A5D6-28DB04C10000", KSNAME_Pin);
+#define KSNAME_Pin DEFINE_GUIDNAMED(KSNAME_Pin)
+
+#define KSSTRING_Pin L"{146F1A80-4791-11D0-A5D6-28DB04C10000}"
+
+#define STATIC_KSNAME_Clock\
+ 0x53172480L, 0x4791, 0x11D0, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("53172480-4791-11D0-A5D6-28DB04C10000", KSNAME_Clock);
+#define KSNAME_Clock DEFINE_GUIDNAMED(KSNAME_Clock)
+
+#define KSSTRING_Clock L"{53172480-4791-11D0-A5D6-28DB04C10000}"
+
+#define STATIC_KSNAME_Allocator\
+ 0x642F5D00L, 0x4791, 0x11D0, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("642F5D00-4791-11D0-A5D6-28DB04C10000", KSNAME_Allocator);
+#define KSNAME_Allocator DEFINE_GUIDNAMED(KSNAME_Allocator)
+
+#define KSSTRING_Allocator L"{642F5D00-4791-11D0-A5D6-28DB04C10000}"
+
+#define KSSTRING_AllocatorEx L"{091BB63B-603F-11D1-B067-00A0C9062802}"
+
+#define STATIC_KSNAME_TopologyNode\
+ 0x0621061AL, 0xEE75, 0x11D0, 0xB9, 0x15, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
+DEFINE_GUIDSTRUCT("0621061A-EE75-11D0-B915-00A0C9223196", KSNAME_TopologyNode);
+#define KSNAME_TopologyNode DEFINE_GUIDNAMED(KSNAME_TopologyNode)
+
+#define KSSTRING_TopologyNode L"{0621061A-EE75-11D0-B915-00A0C9223196}"
+
+#if defined(_NTDDK_)
+
+typedef struct {
+ ULONG InterfacesCount;
+ const KSPIN_INTERFACE* Interfaces;
+ ULONG MediumsCount;
+ const KSPIN_MEDIUM* Mediums;
+ ULONG DataRangesCount;
+ const PKSDATARANGE* DataRanges;
+ KSPIN_DATAFLOW DataFlow;
+ KSPIN_COMMUNICATION Communication;
+ const GUID* Category;
+ const GUID* Name;
+ union {
+ LONGLONG Reserved;
+ struct {
+ ULONG ConstrainedDataRangesCount;
+ PKSDATARANGE* ConstrainedDataRanges;
+ };
+ };
+} KSPIN_DESCRIPTOR, *PKSPIN_DESCRIPTOR;
+typedef const KSPIN_DESCRIPTOR *PCKSPIN_DESCRIPTOR;
+
+#define DEFINE_KSPIN_DESCRIPTOR_TABLE(tablename)\
+ const KSPIN_DESCRIPTOR tablename[] =
+
+#define DEFINE_KSPIN_DESCRIPTOR_ITEM(\
+ InterfacesCount, Interfaces,\
+ MediumsCount, Mediums,\
+ DataRangesCount, DataRanges,\
+ DataFlow, Communication)\
+{\
+ InterfacesCount, Interfaces, MediumsCount, Mediums,\
+ DataRangesCount, DataRanges, DataFlow, Communication,\
+ NULL, NULL, 0\
+}
+#define DEFINE_KSPIN_DESCRIPTOR_ITEMEX(\
+ InterfacesCount, Interfaces,\
+ MediumsCount, Mediums,\
+ DataRangesCount, DataRanges,\
+ DataFlow, Communication,\
+ Category, Name)\
+{\
+ InterfacesCount, Interfaces, MediumsCount, Mediums,\
+ DataRangesCount, DataRanges, DataFlow, Communication,\
+ Category, Name, 0\
+}
+
+#endif // defined(_NTDDK_)
+
+//===========================================================================
+
+// MEDIATYPE_NULL
+#define STATIC_KSDATAFORMAT_TYPE_WILDCARD STATIC_GUID_NULL
+#define KSDATAFORMAT_TYPE_WILDCARD GUID_NULL
+
+// MEDIASUBTYPE_NULL
+#define STATIC_KSDATAFORMAT_SUBTYPE_WILDCARD STATIC_GUID_NULL
+#define KSDATAFORMAT_SUBTYPE_WILDCARD GUID_NULL
+
+// MEDIATYPE_Stream
+#define STATIC_KSDATAFORMAT_TYPE_STREAM\
+ 0xE436EB83L, 0x524F, 0x11CE, 0x9F, 0x53, 0x00, 0x20, 0xAF, 0x0B, 0xA7, 0x70
+DEFINE_GUIDSTRUCT("E436EB83-524F-11CE-9F53-0020AF0BA770", KSDATAFORMAT_TYPE_STREAM);
+#define KSDATAFORMAT_TYPE_STREAM DEFINE_GUIDNAMED(KSDATAFORMAT_TYPE_STREAM)
+
+// MEDIASUBTYPE_None
+#define STATIC_KSDATAFORMAT_SUBTYPE_NONE\
+ 0xE436EB8EL, 0x524F, 0x11CE, 0x9F, 0x53, 0x00, 0x20, 0xAF, 0x0B, 0xA7, 0x70
+DEFINE_GUIDSTRUCT("E436EB8E-524F-11CE-9F53-0020AF0BA770", KSDATAFORMAT_SUBTYPE_NONE);
+#define KSDATAFORMAT_SUBTYPE_NONE DEFINE_GUIDNAMED(KSDATAFORMAT_SUBTYPE_NONE)
+
+#define STATIC_KSDATAFORMAT_SPECIFIER_WILDCARD STATIC_GUID_NULL
+#define KSDATAFORMAT_SPECIFIER_WILDCARD GUID_NULL
+
+#define STATIC_KSDATAFORMAT_SPECIFIER_FILENAME\
+ 0xAA797B40L, 0xE974, 0x11CF, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("AA797B40-E974-11CF-A5D6-28DB04C10000", KSDATAFORMAT_SPECIFIER_FILENAME);
+#define KSDATAFORMAT_SPECIFIER_FILENAME DEFINE_GUIDNAMED(KSDATAFORMAT_SPECIFIER_FILENAME)
+
+#define STATIC_KSDATAFORMAT_SPECIFIER_FILEHANDLE\
+ 0x65E8773CL, 0x8F56, 0x11D0, 0xA3, 0xB9, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
+DEFINE_GUIDSTRUCT("65E8773C-8F56-11D0-A3B9-00A0C9223196", KSDATAFORMAT_SPECIFIER_FILEHANDLE);
+#define KSDATAFORMAT_SPECIFIER_FILEHANDLE DEFINE_GUIDNAMED(KSDATAFORMAT_SPECIFIER_FILEHANDLE)
+
+// FORMAT_None
+#define STATIC_KSDATAFORMAT_SPECIFIER_NONE\
+ 0x0F6417D6L, 0xC318, 0x11D0, 0xA4, 0x3F, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
+DEFINE_GUIDSTRUCT("0F6417D6-C318-11D0-A43F-00A0C9223196", KSDATAFORMAT_SPECIFIER_NONE);
+#define KSDATAFORMAT_SPECIFIER_NONE DEFINE_GUIDNAMED(KSDATAFORMAT_SPECIFIER_NONE)
+
+//===========================================================================
+
+#define STATIC_KSPROPSETID_Quality \
+ 0xD16AD380L, 0xAC1A, 0x11CF, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("D16AD380-AC1A-11CF-A5D6-28DB04C10000", KSPROPSETID_Quality);
+#define KSPROPSETID_Quality DEFINE_GUIDNAMED(KSPROPSETID_Quality)
+
+typedef enum {
+ KSPROPERTY_QUALITY_REPORT,
+ KSPROPERTY_QUALITY_ERROR
+} KSPROPERTY_QUALITY;
+
+#define DEFINE_KSPROPERTY_ITEM_QUALITY_REPORT(GetHandler, SetHandler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_QUALITY_REPORT,\
+ (GetHandler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KSQUALITY),\
+ (SetHandler),\
+ NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_QUALITY_ERROR(GetHandler, SetHandler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_QUALITY_ERROR,\
+ (GetHandler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KSERROR),\
+ (SetHandler),\
+ NULL, 0, NULL, NULL, 0)
+
+//===========================================================================
+
+#define STATIC_KSPROPSETID_Connection \
+ 0x1D58C920L, 0xAC9B, 0x11CF, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("1D58C920-AC9B-11CF-A5D6-28DB04C10000", KSPROPSETID_Connection);
+#define KSPROPSETID_Connection DEFINE_GUIDNAMED(KSPROPSETID_Connection)
+
+typedef enum {
+ KSPROPERTY_CONNECTION_STATE,
+ KSPROPERTY_CONNECTION_PRIORITY,
+ KSPROPERTY_CONNECTION_DATAFORMAT,
+ KSPROPERTY_CONNECTION_ALLOCATORFRAMING,
+ KSPROPERTY_CONNECTION_PROPOSEDATAFORMAT,
+ KSPROPERTY_CONNECTION_ACQUIREORDERING,
+ KSPROPERTY_CONNECTION_ALLOCATORFRAMING_EX,
+ KSPROPERTY_CONNECTION_STARTAT
+} KSPROPERTY_CONNECTION;
+
+#define DEFINE_KSPROPERTY_ITEM_CONNECTION_STATE(GetHandler, SetHandler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_CONNECTION_STATE,\
+ (GetHandler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KSSTATE),\
+ (SetHandler),\
+ NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_CONNECTION_PRIORITY(GetHandler, SetHandler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_CONNECTION_PRIORITY,\
+ (GetHandler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KSPRIORITY),\
+ (SetHandler),\
+ NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_CONNECTION_DATAFORMAT(GetHandler, SetHandler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_CONNECTION_DATAFORMAT,\
+ (GetHandler),\
+ sizeof(KSPROPERTY),\
+ 0,\
+ (SetHandler),\
+ NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_CONNECTION_ALLOCATORFRAMING(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_CONNECTION_ALLOCATORFRAMING,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KSALLOCATOR_FRAMING),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_CONNECTION_ALLOCATORFRAMING_EX(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_CONNECTION_ALLOCATORFRAMING_EX,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ 0,\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_CONNECTION_PROPOSEDATAFORMAT(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_CONNECTION_PROPOSEDATAFORMAT,\
+ NULL,\
+ sizeof(KSPROPERTY),\
+ sizeof(KSDATAFORMAT),\
+ (Handler),\
+ NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_CONNECTION_ACQUIREORDERING(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_CONNECTION_ACQUIREORDERING,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(int),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_CONNECTION_STARTAT(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_CONNECTION_STARTAT,\
+ NULL,\
+ sizeof(KSPROPERTY),\
+ sizeof(KSRELATIVEEVENT),\
+ (Handler),\
+ NULL, 0, NULL, NULL, 0)
+
+//===========================================================================
+//
+// pins flags
+//
+#define KSALLOCATOR_REQUIREMENTF_INPLACE_MODIFIER 0x00000001
+#define KSALLOCATOR_REQUIREMENTF_SYSTEM_MEMORY 0x00000002
+#define KSALLOCATOR_REQUIREMENTF_FRAME_INTEGRITY 0x00000004
+#define KSALLOCATOR_REQUIREMENTF_MUST_ALLOCATE 0x00000008
+#define KSALLOCATOR_REQUIREMENTF_PREFERENCES_ONLY 0x80000000
+
+#define KSALLOCATOR_OPTIONF_COMPATIBLE 0x00000001
+#define KSALLOCATOR_OPTIONF_SYSTEM_MEMORY 0x00000002
+#define KSALLOCATOR_OPTIONF_VALID 0x00000003
+//
+// pins extended framing flags
+//
+#define KSALLOCATOR_FLAG_PARTIAL_READ_SUPPORT 0x00000010
+#define KSALLOCATOR_FLAG_DEVICE_SPECIFIC 0x00000020
+#define KSALLOCATOR_FLAG_CAN_ALLOCATE 0x00000040
+#define KSALLOCATOR_FLAG_INSIST_ON_FRAMESIZE_RATIO 0x00000080
+//
+// allocator pipes flags
+//
+// there is at least one data modification in a pipe
+#define KSALLOCATOR_FLAG_NO_FRAME_INTEGRITY 0x00000100
+#define KSALLOCATOR_FLAG_MULTIPLE_OUTPUT 0x00000200
+#define KSALLOCATOR_FLAG_CYCLE 0x00000400
+#define KSALLOCATOR_FLAG_ALLOCATOR_EXISTS 0x00000800
+// there is no framing dependency between neighbouring pipes.
+#define KSALLOCATOR_FLAG_INDEPENDENT_RANGES 0x00001000
+#define KSALLOCATOR_FLAG_ATTENTION_STEPPING 0x00002000
+
+
+//
+// old Framing structure
+//
+typedef struct {
+ union {
+ ULONG OptionsFlags; // allocator options (create)
+ ULONG RequirementsFlags; // allocation requirements (query)
+ };
+#if defined(_NTDDK_)
+ POOL_TYPE PoolType;
+#else // !_NTDDK_
+ ULONG PoolType;
+#endif // !_NTDDK_
+ ULONG Frames; // total number of allowable outstanding frames
+ ULONG FrameSize; // total size of frame
+ ULONG FileAlignment;
+ ULONG Reserved;
+} KSALLOCATOR_FRAMING, *PKSALLOCATOR_FRAMING;
+
+#if defined(_NTDDK_)
+typedef
+PVOID
+(*PFNKSDEFAULTALLOCATE)(
+ IN PVOID Context
+ );
+
+typedef
+VOID
+(*PFNKSDEFAULTFREE)(
+ IN PVOID Context,
+ IN PVOID Buffer
+ );
+
+typedef
+NTSTATUS
+(*PFNKSINITIALIZEALLOCATOR)(
+ IN PVOID InitialContext,
+ IN PKSALLOCATOR_FRAMING AllocatorFraming,
+ OUT PVOID* Context
+ );
+
+typedef
+VOID
+(*PFNKSDELETEALLOCATOR)(
+ IN PVOID Context
+ );
+#endif // !_NTDDK_
+
+//
+// new Framing structure, eventually will replace KSALLOCATOR_FRAMING.
+//
+typedef struct {
+ ULONG MinFrameSize;
+ ULONG MaxFrameSize;
+ ULONG Stepping;
+} KS_FRAMING_RANGE, *PKS_FRAMING_RANGE;
+
+
+typedef struct {
+ KS_FRAMING_RANGE Range;
+ ULONG InPlaceWeight;
+ ULONG NotInPlaceWeight;
+} KS_FRAMING_RANGE_WEIGHTED, *PKS_FRAMING_RANGE_WEIGHTED;
+
+
+typedef struct {
+ ULONG RatioNumerator; // compression/expansion ratio
+ ULONG RatioDenominator;
+ ULONG RatioConstantMargin;
+} KS_COMPRESSION, *PKS_COMPRESSION;
+
+
+//
+// Memory Types and Buses are repeated in each entry.
+// Easiest to use but takes a little more memory than the varsize layout Pin\Memories\Buses\Ranges.
+//
+typedef struct {
+ GUID MemoryType;
+ GUID BusType;
+ ULONG MemoryFlags;
+ ULONG BusFlags;
+ ULONG Flags;
+ ULONG Frames; // total number of allowable outstanding frames
+ ULONG FileAlignment;
+ ULONG MemoryTypeWeight; // this memory type Weight pin-wide
+ KS_FRAMING_RANGE PhysicalRange;
+ KS_FRAMING_RANGE_WEIGHTED FramingRange;
+} KS_FRAMING_ITEM, *PKS_FRAMING_ITEM;
+
+
+typedef struct {
+ ULONG CountItems; // count of FramingItem-s below.
+ ULONG PinFlags;
+ KS_COMPRESSION OutputCompression;
+ ULONG PinWeight; // this pin framing's Weight graph-wide
+ KS_FRAMING_ITEM FramingItem[1];
+} KSALLOCATOR_FRAMING_EX, *PKSALLOCATOR_FRAMING_EX;
+
+
+
+//
+// define memory type GUIDs
+//
+#define KSMEMORY_TYPE_WILDCARD GUID_NULL
+#define STATIC_KSMEMORY_TYPE_WILDCARD STATIC_GUID_NULL
+
+#define KSMEMORY_TYPE_DONT_CARE GUID_NULL
+#define STATIC_KSMEMORY_TYPE_DONT_CARE STATIC_GUID_NULL
+
+#define KS_TYPE_DONT_CARE GUID_NULL
+#define STATIC_KS_TYPE_DONT_CARE STATIC_GUID_NULL
+
+#define STATIC_KSMEMORY_TYPE_SYSTEM \
+ 0x091bb638L, 0x603f, 0x11d1, 0xb0, 0x67, 0x00, 0xa0, 0xc9, 0x06, 0x28, 0x02
+DEFINE_GUIDSTRUCT("091bb638-603f-11d1-b067-00a0c9062802", KSMEMORY_TYPE_SYSTEM);
+#define KSMEMORY_TYPE_SYSTEM DEFINE_GUIDNAMED(KSMEMORY_TYPE_SYSTEM)
+
+#define STATIC_KSMEMORY_TYPE_USER \
+ 0x8cb0fc28L, 0x7893, 0x11d1, 0xb0, 0x69, 0x00, 0xa0, 0xc9, 0x06, 0x28, 0x02
+DEFINE_GUIDSTRUCT("8cb0fc28-7893-11d1-b069-00a0c9062802", KSMEMORY_TYPE_USER);
+#define KSMEMORY_TYPE_USER DEFINE_GUIDNAMED(KSMEMORY_TYPE_USER)
+
+#define STATIC_KSMEMORY_TYPE_KERNEL_PAGED \
+ 0xd833f8f8L, 0x7894, 0x11d1, 0xb0, 0x69, 0x00, 0xa0, 0xc9, 0x06, 0x28, 0x02
+DEFINE_GUIDSTRUCT("d833f8f8-7894-11d1-b069-00a0c9062802", KSMEMORY_TYPE_KERNEL_PAGED);
+#define KSMEMORY_TYPE_KERNEL_PAGED DEFINE_GUIDNAMED(KSMEMORY_TYPE_KERNEL_PAGED)
+
+#define STATIC_KSMEMORY_TYPE_KERNEL_NONPAGED \
+ 0x4a6d5fc4L, 0x7895, 0x11d1, 0xb0, 0x69, 0x00, 0xa0, 0xc9, 0x06, 0x28, 0x02
+DEFINE_GUIDSTRUCT("4a6d5fc4-7895-11d1-b069-00a0c9062802", KSMEMORY_TYPE_KERNEL_NONPAGED);
+#define KSMEMORY_TYPE_KERNEL_NONPAGED DEFINE_GUIDNAMED(KSMEMORY_TYPE_KERNEL_NONPAGED)
+
+// old KS clients did not specify the device memory type
+#define STATIC_KSMEMORY_TYPE_DEVICE_UNKNOWN \
+ 0x091bb639L, 0x603f, 0x11d1, 0xb0, 0x67, 0x00, 0xa0, 0xc9, 0x06, 0x28, 0x02
+DEFINE_GUIDSTRUCT("091bb639-603f-11d1-b067-00a0c9062802", KSMEMORY_TYPE_DEVICE_UNKNOWN);
+#define KSMEMORY_TYPE_DEVICE_UNKNOWN DEFINE_GUIDNAMED(KSMEMORY_TYPE_DEVICE_UNKNOWN)
+
+//
+// Helper framing macros.
+//
+#define DECLARE_SIMPLE_FRAMING_EX(FramingExName, MemoryType, Flags, Frames, Alignment, MinFrameSize, MaxFrameSize) \
+ const KSALLOCATOR_FRAMING_EX FramingExName = \
+ {\
+ 1, \
+ 0, \
+ {\
+ 1, \
+ 1, \
+ 0 \
+ }, \
+ 0, \
+ {\
+ {\
+ MemoryType, \
+ STATIC_KS_TYPE_DONT_CARE, \
+ 0, \
+ 0, \
+ Flags, \
+ Frames, \
+ Alignment, \
+ 0, \
+ {\
+ 0, \
+ (ULONG)-1, \
+ 1 \
+ }, \
+ {\
+ {\
+ MinFrameSize, \
+ MaxFrameSize, \
+ 1 \
+ }, \
+ 0, \
+ 0 \
+ }\
+ }\
+ }\
+ }
+
+#define SetDefaultKsCompression(KsCompressionPointer) \
+{\
+ KsCompressionPointer->RatioNumerator = 1;\
+ KsCompressionPointer->RatioDenominator = 1;\
+ KsCompressionPointer->RatioConstantMargin = 0;\
+}
+
+#define SetDontCareKsFramingRange(KsFramingRangePointer) \
+{\
+ KsFramingRangePointer->MinFrameSize = 0;\
+ KsFramingRangePointer->MaxFrameSize = (ULONG) -1;\
+ KsFramingRangePointer->Stepping = 1;\
+}
+
+#define SetKsFramingRange(KsFramingRangePointer, P_MinFrameSize, P_MaxFrameSize) \
+{\
+ KsFramingRangePointer->MinFrameSize = P_MinFrameSize;\
+ KsFramingRangePointer->MaxFrameSize = P_MaxFrameSize;\
+ KsFramingRangePointer->Stepping = 1;\
+}
+
+#define SetKsFramingRangeWeighted(KsFramingRangeWeightedPointer, P_MinFrameSize, P_MaxFrameSize) \
+{\
+ KS_FRAMING_RANGE *KsFramingRange = &KsFramingRangeWeightedPointer->Range;\
+ SetKsFramingRange(KsFramingRange, P_MinFrameSize, P_MaxFrameSize);\
+ KsFramingRangeWeightedPointer->InPlaceWeight = 0;\
+ KsFramingRangeWeightedPointer->NotInPlaceWeight = 0;\
+}
+
+#define INITIALIZE_SIMPLE_FRAMING_EX(FramingExPointer, P_MemoryType, P_Flags, P_Frames, P_Alignment, P_MinFrameSize, P_MaxFrameSize) \
+{\
+ KS_COMPRESSION *KsCompression = &FramingExPointer->OutputCompression;\
+ KS_FRAMING_RANGE *KsFramingRange = &FramingExPointer->FramingItem[0].PhysicalRange;\
+ KS_FRAMING_RANGE_WEIGHTED *KsFramingRangeWeighted = &FramingExPointer->FramingItem[0].FramingRange;\
+ FramingExPointer->CountItems = 1;\
+ FramingExPointer->PinFlags = 0;\
+ SetDefaultKsCompression(KsCompression);\
+ FramingExPointer->PinWeight = 0;\
+ FramingExPointer->FramingItem[0].MemoryType = P_MemoryType;\
+ FramingExPointer->FramingItem[0].BusType = KS_TYPE_DONT_CARE;\
+ FramingExPointer->FramingItem[0].MemoryFlags = 0;\
+ FramingExPointer->FramingItem[0].BusFlags = 0;\
+ FramingExPointer->FramingItem[0].Flags = P_Flags;\
+ FramingExPointer->FramingItem[0].Frames = P_Frames;\
+ FramingExPointer->FramingItem[0].FileAlignment = P_Alignment;\
+ FramingExPointer->FramingItem[0].MemoryTypeWeight = 0;\
+ SetDontCareKsFramingRange(KsFramingRange);\
+ SetKsFramingRangeWeighted(KsFramingRangeWeighted, P_MinFrameSize, P_MaxFrameSize);\
+}
+
+
+
+// KSEVENTSETID_StreamAllocator: {75D95571-073C-11d0-A161-0020AFD156E4}
+
+#define STATIC_KSEVENTSETID_StreamAllocator\
+ 0x75d95571L, 0x073c, 0x11d0, 0xa1, 0x61, 0x00, 0x20, 0xaf, 0xd1, 0x56, 0xe4
+DEFINE_GUIDSTRUCT("75d95571-073c-11d0-a161-0020afd156e4", KSEVENTSETID_StreamAllocator);
+#define KSEVENTSETID_StreamAllocator DEFINE_GUIDNAMED(KSEVENTSETID_StreamAllocator)
+
+typedef enum {
+ KSEVENT_STREAMALLOCATOR_INTERNAL_FREEFRAME,
+ KSEVENT_STREAMALLOCATOR_FREEFRAME
+} KSEVENT_STREAMALLOCATOR;
+
+#define STATIC_KSMETHODSETID_StreamAllocator\
+ 0xcf6e4341L, 0xec87, 0x11cf, 0xa1, 0x30, 0x00, 0x20, 0xaf, 0xd1, 0x56, 0xe4
+DEFINE_GUIDSTRUCT("cf6e4341-ec87-11cf-a130-0020afd156e4", KSMETHODSETID_StreamAllocator);
+#define KSMETHODSETID_StreamAllocator DEFINE_GUIDNAMED(KSMETHODSETID_StreamAllocator)
+
+typedef enum {
+ KSMETHOD_STREAMALLOCATOR_ALLOC,
+ KSMETHOD_STREAMALLOCATOR_FREE
+} KSMETHOD_STREAMALLOCATOR;
+
+#define DEFINE_KSMETHOD_ITEM_STREAMALLOCATOR_ALLOC(Handler)\
+ DEFINE_KSMETHOD_ITEM(\
+ KSMETHOD_STREAMALLOCATOR_ALLOC,\
+ KSMETHOD_TYPE_WRITE,\
+ (Handler),\
+ sizeof(KSMETHOD),\
+ sizeof(PVOID),\
+ NULL)
+
+#define DEFINE_KSMETHOD_ITEM_STREAMALLOCATOR_FREE(Handler)\
+ DEFINE_KSMETHOD_ITEM(\
+ KSMETHOD_STREAMALLOCATOR_FREE,\
+ KSMETHOD_TYPE_READ,\
+ (Handler),\
+ sizeof(KSMETHOD),\
+ sizeof(PVOID),\
+ NULL)
+
+#define DEFINE_KSMETHOD_ALLOCATORSET(AllocatorSet, MethodAlloc, MethodFree)\
+DEFINE_KSMETHOD_TABLE(AllocatorSet) {\
+ DEFINE_KSMETHOD_ITEM_STREAMALLOCATOR_ALLOC(MethodAlloc),\
+ DEFINE_KSMETHOD_ITEM_STREAMALLOCATOR_FREE(MethodFree)\
+}
+
+#define STATIC_KSPROPSETID_StreamAllocator\
+ 0xcf6e4342L, 0xec87, 0x11cf, 0xa1, 0x30, 0x00, 0x20, 0xaf, 0xd1, 0x56, 0xe4
+DEFINE_GUIDSTRUCT("cf6e4342-ec87-11cf-a130-0020afd156e4", KSPROPSETID_StreamAllocator);
+#define KSPROPSETID_StreamAllocator DEFINE_GUIDNAMED(KSPROPSETID_StreamAllocator)
+
+#if defined(_NTDDK_)
+typedef enum {
+ KSPROPERTY_STREAMALLOCATOR_FUNCTIONTABLE,
+ KSPROPERTY_STREAMALLOCATOR_STATUS
+} KSPROPERTY_STREAMALLOCATOR;
+
+#define DEFINE_KSPROPERTY_ITEM_STREAMALLOCATOR_FUNCTIONTABLE(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_STREAMALLOCATOR_FUNCTIONTABLE,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KSSTREAMALLOCATOR_FUNCTIONTABLE),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_STREAMALLOCATOR_STATUS(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_STREAMALLOCATOR_STATUS,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KSSTREAMALLOCATOR_STATUS),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ALLOCATORSET(AllocatorSet, PropFunctionTable, PropStatus)\
+DEFINE_KSPROPERTY_TABLE(AllocatorSet) {\
+ DEFINE_KSPROPERTY_ITEM_STREAMALLOCATOR_STATUS(PropStatus),\
+ DEFINE_KSPROPERTY_ITEM_STREAMALLOCATOR_FUNCTIONTABLE(PropFunctionTable)\
+}
+
+typedef
+NTSTATUS
+(*PFNALLOCATOR_ALLOCATEFRAME)(
+ IN PFILE_OBJECT FileObject,
+ PVOID *Frame
+ );
+
+typedef
+VOID
+(*PFNALLOCATOR_FREEFRAME)(
+ IN PFILE_OBJECT FileObject,
+ IN PVOID Frame
+ );
+
+typedef struct {
+ PFNALLOCATOR_ALLOCATEFRAME AllocateFrame;
+ PFNALLOCATOR_FREEFRAME FreeFrame;
+} KSSTREAMALLOCATOR_FUNCTIONTABLE, *PKSSTREAMALLOCATOR_FUNCTIONTABLE;
+#endif // defined(_NTDDK_)
+
+typedef struct {
+ KSALLOCATOR_FRAMING Framing;
+ ULONG AllocatedFrames;
+ ULONG Reserved;
+} KSSTREAMALLOCATOR_STATUS, *PKSSTREAMALLOCATOR_STATUS;
+
+typedef struct {
+ KSALLOCATOR_FRAMING_EX Framing;
+ ULONG AllocatedFrames;
+ ULONG Reserved;
+} KSSTREAMALLOCATOR_STATUS_EX, *PKSSTREAMALLOCATOR_STATUS_EX;
+
+
+#define KSSTREAM_HEADER_OPTIONSF_SPLICEPOINT 0x00000001
+#define KSSTREAM_HEADER_OPTIONSF_PREROLL 0x00000002
+#define KSSTREAM_HEADER_OPTIONSF_DATADISCONTINUITY 0x00000004
+#define KSSTREAM_HEADER_OPTIONSF_TYPECHANGED 0x00000008
+#define KSSTREAM_HEADER_OPTIONSF_TIMEVALID 0x00000010
+#define KSSTREAM_HEADER_OPTIONSF_TIMEDISCONTINUITY 0x00000040
+#define KSSTREAM_HEADER_OPTIONSF_FLUSHONPAUSE 0x00000080
+#define KSSTREAM_HEADER_OPTIONSF_DURATIONVALID 0x00000100
+#define KSSTREAM_HEADER_OPTIONSF_ENDOFSTREAM 0x00000200
+#define KSSTREAM_HEADER_OPTIONSF_LOOPEDDATA 0x80000000
+
+typedef struct {
+ LONGLONG Time;
+ ULONG Numerator;
+ ULONG Denominator;
+} KSTIME, *PKSTIME;
+
+typedef struct {
+ ULONG Size;
+ ULONG TypeSpecificFlags;
+ KSTIME PresentationTime;
+ LONGLONG Duration;
+ ULONG FrameExtent;
+ ULONG DataUsed;
+ PVOID Data;
+ ULONG OptionsFlags;
+#if _WIN64
+ ULONG Reserved;
+#endif
+} KSSTREAM_HEADER, *PKSSTREAM_HEADER;
+
+#define STATIC_KSPROPSETID_StreamInterface\
+ 0x1fdd8ee1L, 0x9cd3, 0x11d0, 0x82, 0xaa, 0x00, 0x00, 0xf8, 0x22, 0xfe, 0x8a
+DEFINE_GUIDSTRUCT("1fdd8ee1-9cd3-11d0-82aa-0000f822fe8a", KSPROPSETID_StreamInterface);
+#define KSPROPSETID_StreamInterface DEFINE_GUIDNAMED(KSPROPSETID_StreamInterface)
+
+typedef enum {
+ KSPROPERTY_STREAMINTERFACE_HEADERSIZE
+} KSPROPERTY_STREAMINTERFACE;
+
+#define DEFINE_KSPROPERTY_ITEM_STREAMINTERFACE_HEADERSIZE( GetHandler )\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_STREAMINTERFACE_HEADERSIZE,\
+ (GetHandler),\
+ sizeof(KSPROPERTY),\
+ sizeof(ULONG),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_STREAMINTERFACESET(StreamInterfaceSet,\
+ HeaderSizeHandler)\
+DEFINE_KSPROPERTY_TABLE(StreamInterfaceSet) {\
+ DEFINE_KSPROPERTY_ITEM_STREAMINTERFACE_HEADERSIZE( HeaderSizeHandler )\
+}
+
+#define STATIC_KSPROPSETID_Stream\
+ 0x65aaba60L, 0x98ae, 0x11cf, 0xa1, 0x0d, 0x00, 0x20, 0xaf, 0xd1, 0x56, 0xe4
+DEFINE_GUIDSTRUCT("65aaba60-98ae-11cf-a10d-0020afd156e4", KSPROPSETID_Stream);
+#define KSPROPSETID_Stream DEFINE_GUIDNAMED(KSPROPSETID_Stream)
+
+typedef enum {
+ KSPROPERTY_STREAM_ALLOCATOR,
+ KSPROPERTY_STREAM_QUALITY,
+ KSPROPERTY_STREAM_DEGRADATION,
+ KSPROPERTY_STREAM_MASTERCLOCK,
+ KSPROPERTY_STREAM_TIMEFORMAT,
+ KSPROPERTY_STREAM_PRESENTATIONTIME,
+ KSPROPERTY_STREAM_PRESENTATIONEXTENT,
+ KSPROPERTY_STREAM_FRAMETIME,
+ KSPROPERTY_STREAM_RATECAPABILITY,
+ KSPROPERTY_STREAM_RATE,
+ KSPROPERTY_STREAM_PIPE_ID
+} KSPROPERTY_STREAM;
+
+#define DEFINE_KSPROPERTY_ITEM_STREAM_ALLOCATOR(GetHandler, SetHandler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_STREAM_ALLOCATOR,\
+ (GetHandler),\
+ sizeof(KSPROPERTY),\
+ sizeof(HANDLE),\
+ (SetHandler),\
+ NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_STREAM_QUALITY(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_STREAM_QUALITY,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KSQUALITY_MANAGER),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_STREAM_DEGRADATION(GetHandler, SetHandler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_STREAM_DEGRADATION,\
+ (GetHandler),\
+ sizeof(KSPROPERTY),\
+ 0,\
+ (SetHandler),\
+ NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_STREAM_MASTERCLOCK(GetHandler, SetHandler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_STREAM_MASTERCLOCK,\
+ (GetHandler),\
+ sizeof(KSPROPERTY),\
+ sizeof(HANDLE),\
+ (SetHandler),\
+ NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_STREAM_TIMEFORMAT(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_STREAM_TIMEFORMAT,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(GUID),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_STREAM_PRESENTATIONTIME(GetHandler, SetHandler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_STREAM_PRESENTATIONTIME,\
+ (GetHandler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KSTIME),\
+ (SetHandler),\
+ NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_STREAM_PRESENTATIONEXTENT(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_STREAM_PRESENTATIONEXTENT,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(LONGLONG),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_STREAM_FRAMETIME(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_STREAM_FRAMETIME,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KSFRAMETIME),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_STREAM_RATECAPABILITY(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_STREAM_RATECAPABILITY,\
+ (Handler),\
+ sizeof(KSRATE_CAPABILITY),\
+ sizeof(KSRATE),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_STREAM_RATE(GetHandler, SetHandler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_STREAM_RATE,\
+ (GetHandler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KSRATE),\
+ (SetHandler),\
+ NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_STREAM_PIPE_ID(GetHandler, SetHandler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_STREAM_PIPE_ID,\
+ (GetHandler),\
+ sizeof(KSPROPERTY),\
+ sizeof(HANDLE),\
+ (SetHandler),\
+ NULL, 0, NULL, NULL, 0)
+
+typedef struct {
+ HANDLE QualityManager;
+ PVOID Context;
+} KSQUALITY_MANAGER, *PKSQUALITY_MANAGER;
+
+typedef struct {
+ LONGLONG Duration;
+ ULONG FrameFlags;
+ ULONG Reserved;
+} KSFRAMETIME, *PKSFRAMETIME;
+
+#define KSFRAMETIME_VARIABLESIZE 0x00000001
+
+typedef struct {
+ LONGLONG PresentationStart;
+ LONGLONG Duration;
+ KSPIN_INTERFACE Interface;
+ LONG Rate;
+ ULONG Flags;
+} KSRATE, *PKSRATE;
+
+#define KSRATE_NOPRESENTATIONSTART 0x00000001
+#define KSRATE_NOPRESENTATIONDURATION 0x00000002
+
+typedef struct {
+ KSPROPERTY Property;
+ KSRATE Rate;
+} KSRATE_CAPABILITY, *PKSRATE_CAPABILITY;
+
+#define STATIC_KSPROPSETID_Clock \
+ 0xDF12A4C0L, 0xAC17, 0x11CF, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("DF12A4C0-AC17-11CF-A5D6-28DB04C10000", KSPROPSETID_Clock);
+#define KSPROPSETID_Clock DEFINE_GUIDNAMED(KSPROPSETID_Clock)
+
+//
+// Performs a x*y/z operation on 64 bit quantities by splitting the operation. The equation
+// is simplified with respect to adding in the remainder for the upper 32 bits.
+//
+// (xh * 10000000 / Frequency) * 2^32 + ((((xh * 10000000) % Frequency) * 2^32 + (xl * 10000000)) / Frequency)
+//
+#define NANOSECONDS 10000000
+#define KSCONVERT_PERFORMANCE_TIME(Frequency, PerformanceTime) \
+ ((((ULONGLONG)(ULONG)(PerformanceTime).HighPart * NANOSECONDS / (Frequency)) << 32) + \
+ ((((((ULONGLONG)(ULONG)(PerformanceTime).HighPart * NANOSECONDS) % (Frequency)) << 32) + \
+ ((ULONGLONG)(PerformanceTime).LowPart * NANOSECONDS)) / (Frequency)))
+
+typedef struct {
+ ULONG CreateFlags;
+} KSCLOCK_CREATE, *PKSCLOCK_CREATE;
+
+typedef struct {
+ LONGLONG Time;
+ LONGLONG SystemTime;
+} KSCORRELATED_TIME, *PKSCORRELATED_TIME;
+
+typedef struct {
+ LONGLONG Granularity;
+ LONGLONG Error;
+} KSRESOLUTION, *PKSRESOLUTION;
+
+typedef enum {
+ KSPROPERTY_CLOCK_TIME,
+ KSPROPERTY_CLOCK_PHYSICALTIME,
+ KSPROPERTY_CLOCK_CORRELATEDTIME,
+ KSPROPERTY_CLOCK_CORRELATEDPHYSICALTIME,
+ KSPROPERTY_CLOCK_RESOLUTION,
+ KSPROPERTY_CLOCK_STATE,
+#if defined(_NTDDK_)
+ KSPROPERTY_CLOCK_FUNCTIONTABLE
+#endif // defined(_NTDDK_)
+} KSPROPERTY_CLOCK;
+
+#if defined(_NTDDK_)
+
+typedef
+LONGLONG
+(FASTCALL *PFNKSCLOCK_GETTIME)(
+ IN PFILE_OBJECT FileObject
+ );
+typedef
+LONGLONG
+(FASTCALL *PFNKSCLOCK_CORRELATEDTIME)(
+ IN PFILE_OBJECT FileObject,
+ OUT PLONGLONG SystemTime);
+
+typedef struct {
+ PFNKSCLOCK_GETTIME GetTime;
+ PFNKSCLOCK_GETTIME GetPhysicalTime;
+ PFNKSCLOCK_CORRELATEDTIME GetCorrelatedTime;
+ PFNKSCLOCK_CORRELATEDTIME GetCorrelatedPhysicalTime;
+} KSCLOCK_FUNCTIONTABLE, *PKSCLOCK_FUNCTIONTABLE;
+
+typedef
+BOOLEAN
+(*PFNKSSETTIMER)(
+ IN PVOID Context,
+ IN PKTIMER Timer,
+ IN LARGE_INTEGER DueTime,
+ IN PKDPC Dpc
+ );
+
+typedef
+BOOLEAN
+(*PFNKSCANCELTIMER)(
+ IN PVOID Context,
+ IN PKTIMER Timer
+ );
+
+typedef
+LONGLONG
+(FASTCALL *PFNKSCORRELATEDTIME)(
+ IN PVOID Context,
+ OUT PLONGLONG SystemTime);
+
+typedef PVOID PKSDEFAULTCLOCK;
+
+#define DEFINE_KSPROPERTY_ITEM_CLOCK_TIME(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_CLOCK_TIME,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(LONGLONG),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_CLOCK_PHYSICALTIME(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_CLOCK_PHYSICALTIME,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(LONGLONG),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_CLOCK_CORRELATEDTIME(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_CLOCK_CORRELATEDTIME,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KSCORRELATED_TIME),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_CLOCK_CORRELATEDPHYSICALTIME(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_CLOCK_CORRELATEDPHYSICALTIME,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KSCORRELATED_TIME),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_CLOCK_RESOLUTION(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_CLOCK_RESOLUTION,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KSRESOLUTION),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_CLOCK_STATE(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_CLOCK_STATE,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KSSTATE),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_ITEM_CLOCK_FUNCTIONTABLE(Handler)\
+ DEFINE_KSPROPERTY_ITEM(\
+ KSPROPERTY_CLOCK_FUNCTIONTABLE,\
+ (Handler),\
+ sizeof(KSPROPERTY),\
+ sizeof(KSCLOCK_FUNCTIONTABLE),\
+ NULL, NULL, 0, NULL, NULL, 0)
+
+#define DEFINE_KSPROPERTY_CLOCKSET(ClockSet,\
+ PropTime, PropPhysicalTime,\
+ PropCorrelatedTime, PropCorrelatedPhysicalTime,\
+ PropResolution, PropState, PropFunctionTable)\
+DEFINE_KSPROPERTY_TABLE(ClockSet) {\
+ DEFINE_KSPROPERTY_ITEM_CLOCK_TIME(PropTime),\
+ DEFINE_KSPROPERTY_ITEM_CLOCK_PHYSICALTIME(PropPhysicalTime),\
+ DEFINE_KSPROPERTY_ITEM_CLOCK_CORRELATEDTIME(PropCorrelatedTime),\
+ DEFINE_KSPROPERTY_ITEM_CLOCK_CORRELATEDPHYSICALTIME(PropCorrelatedPhysicalTime),\
+ DEFINE_KSPROPERTY_ITEM_CLOCK_RESOLUTION(PropResolution),\
+ DEFINE_KSPROPERTY_ITEM_CLOCK_STATE(PropState),\
+ DEFINE_KSPROPERTY_ITEM_CLOCK_FUNCTIONTABLE(PropFunctionTable),\
+}
+
+#endif // defined(_NTDDK_)
+
+#define STATIC_KSEVENTSETID_Clock \
+ 0x364D8E20L, 0x62C7, 0x11CF, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("364D8E20-62C7-11CF-A5D6-28DB04C10000", KSEVENTSETID_Clock);
+#define KSEVENTSETID_Clock DEFINE_GUIDNAMED(KSEVENTSETID_Clock)
+
+typedef enum {
+ KSEVENT_CLOCK_INTERVAL_MARK,
+ KSEVENT_CLOCK_POSITION_MARK
+} KSEVENT_CLOCK_POSITION;
+
+#define STATIC_KSEVENTSETID_Connection\
+ 0x7f4bcbe0L, 0x9ea5, 0x11cf, 0xa5, 0xd6, 0x28, 0xdb, 0x04, 0xc1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("7f4bcbe0-9ea5-11cf-a5d6-28db04c10000", KSEVENTSETID_Connection);
+#define KSEVENTSETID_Connection DEFINE_GUIDNAMED(KSEVENTSETID_Connection)
+
+typedef enum {
+ KSEVENT_CONNECTION_POSITIONUPDATE,
+ KSEVENT_CONNECTION_DATADISCONTINUITY,
+ KSEVENT_CONNECTION_TIMEDISCONTINUITY,
+ KSEVENT_CONNECTION_PRIORITY,
+ KSEVENT_CONNECTION_ENDOFSTREAM
+} KSEVENT_CONNECTION;
+
+typedef struct {
+ PVOID Context;
+ ULONG Proportion;
+ LONGLONG DeltaTime;
+} KSQUALITY, *PKSQUALITY;
+
+typedef struct {
+ PVOID Context;
+ ULONG Status;
+} KSERROR, *PKSERROR;
+
+typedef KSIDENTIFIER KSDEGRADE, *PKSDEGRADE;
+
+#define STATIC_KSDEGRADESETID_Standard\
+ 0x9F564180L, 0x704C, 0x11D0, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+DEFINE_GUIDSTRUCT("9F564180-704C-11D0-A5D6-28DB04C10000", KSDEGRADESETID_Standard);
+#define KSDEGRADESETID_Standard DEFINE_GUIDNAMED(KSDEGRADESETID_Standard)
+
+typedef enum {
+ KSDEGRADE_STANDARD_SAMPLE,
+ KSDEGRADE_STANDARD_QUALITY,
+ KSDEGRADE_STANDARD_COMPUTATION,
+ KSDEGRADE_STANDARD_SKIP
+} KSDEGRADE_STANDARD;
+
+#if defined(_NTDDK_)
+
+#define KSPROBE_STREAMREAD 0x00000000
+#define KSPROBE_STREAMWRITE 0x00000001
+#define KSPROBE_ALLOCATEMDL 0x00000010
+#define KSPROBE_PROBEANDLOCK 0x00000020
+#define KSPROBE_SYSTEMADDRESS 0x00000040
+#define KSPROBE_MODIFY 0x00000200
+#define KSPROBE_STREAMWRITEMODIFY (KSPROBE_MODIFY | KSPROBE_STREAMWRITE)
+#define KSPROBE_ALLOWFORMATCHANGE 0x00000080
+
+#define KSSTREAM_READ KSPROBE_STREAMREAD
+#define KSSTREAM_WRITE KSPROBE_STREAMWRITE
+#define KSSTREAM_PAGED_DATA 0x00000000
+#define KSSTREAM_NONPAGED_DATA 0x00000100
+#define KSSTREAM_SYNCHRONOUS 0x00001000
+#define KSSTREAM_FAILUREEXCEPTION 0x00002000
+
+typedef
+NTSTATUS
+(*PFNKSCONTEXT_DISPATCH)(
+ IN PVOID Context,
+ IN PIRP Irp
+ );
+
+typedef
+NTSTATUS
+(*PFNKSHANDLER)(
+ IN PIRP Irp,
+ IN PKSIDENTIFIER Request,
+ IN OUT PVOID Data
+ );
+
+typedef
+BOOLEAN
+(*PFNKSFASTHANDLER)(
+ IN PFILE_OBJECT FileObject,
+ IN PKSIDENTIFIER Request,
+ IN ULONG RequestLength,
+ IN OUT PVOID Data,
+ IN ULONG DataLength,
+ OUT PIO_STATUS_BLOCK IoStatus
+ );
+
+typedef
+NTSTATUS
+(*PFNKSALLOCATOR)(
+ IN PIRP Irp,
+ IN ULONG BufferSize,
+ IN BOOLEAN InputOperation
+ );
+
+typedef struct {
+ KSPROPERTY_MEMBERSHEADER MembersHeader;
+ const VOID* Members;
+} KSPROPERTY_MEMBERSLIST, *PKSPROPERTY_MEMBERSLIST;
+
+typedef struct {
+ KSIDENTIFIER PropTypeSet;
+ ULONG MembersListCount;
+ const KSPROPERTY_MEMBERSLIST* MembersList;
+} KSPROPERTY_VALUES, *PKSPROPERTY_VALUES;
+
+#define DEFINE_KSPROPERTY_TABLE(tablename)\
+ const KSPROPERTY_ITEM tablename[] =
+
+#define DEFINE_KSPROPERTY_ITEM(PropertyId, GetHandler,\
+ MinProperty,\
+ MinData,\
+ SetHandler,\
+ Values, RelationsCount, Relations, SupportHandler,\
+ SerializedSize)\
+{\
+ PropertyId, (PFNKSHANDLER)GetHandler, MinProperty, MinData,\
+ (PFNKSHANDLER)SetHandler,\
+ (PKSPROPERTY_VALUES)Values, RelationsCount, (PKSPROPERTY)Relations,\
+ (PFNKSHANDLER)SupportHandler, (ULONG)SerializedSize\
+}
+
+typedef struct {
+ ULONG PropertyId;
+ union {
+ PFNKSHANDLER GetPropertyHandler;
+ BOOLEAN GetSupported;
+ };
+ ULONG MinProperty;
+ ULONG MinData;
+ union {
+ PFNKSHANDLER SetPropertyHandler;
+ BOOLEAN SetSupported;
+ };
+ const KSPROPERTY_VALUES*Values;
+ ULONG RelationsCount;
+ const KSPROPERTY* Relations;
+ PFNKSHANDLER SupportHandler;
+ ULONG SerializedSize;
+} KSPROPERTY_ITEM, *PKSPROPERTY_ITEM;
+
+#define DEFINE_KSFASTPROPERTY_ITEM(PropertyId, GetHandler, SetHandler)\
+{\
+ PropertyId, (PFNKSFASTHANDLER)GetHandler, (PFNKSFASTHANDLER)SetHandler, 0\
+}
+
+typedef struct {
+ ULONG PropertyId;
+ union {
+ PFNKSFASTHANDLER GetPropertyHandler;
+ BOOLEAN GetSupported;
+ };
+ union {
+ PFNKSFASTHANDLER SetPropertyHandler;
+ BOOLEAN SetSupported;
+ };
+ ULONG Reserved;
+} KSFASTPROPERTY_ITEM, *PKSFASTPROPERTY_ITEM;
+
+#define DEFINE_KSPROPERTY_SET(Set,\
+ PropertiesCount,\
+ PropertyItem,\
+ FastIoCount,\
+ FastIoTable)\
+{\
+ Set,\
+ PropertiesCount,\
+ PropertyItem,\
+ FastIoCount,\
+ FastIoTable\
+}
+
+#define DEFINE_KSPROPERTY_SET_TABLE(tablename)\
+ const KSPROPERTY_SET tablename[] =
+
+typedef struct {
+ const GUID* Set;
+ ULONG PropertiesCount;
+ const KSPROPERTY_ITEM* PropertyItem;
+ ULONG FastIoCount;
+ const KSFASTPROPERTY_ITEM* FastIoTable;
+} KSPROPERTY_SET, *PKSPROPERTY_SET;
+
+#define DEFINE_KSMETHOD_TABLE(tablename)\
+ const KSMETHOD_ITEM tablename[] =
+
+#define DEFINE_KSMETHOD_ITEM(MethodId, Flags,\
+ MethodHandler,\
+ MinMethod, MinData, SupportHandler)\
+{\
+ MethodId, (PFNKSHANDLER)MethodHandler, MinMethod, MinData,\
+ SupportHandler, Flags\
+}
+
+typedef struct {
+ ULONG MethodId;
+ union {
+ PFNKSHANDLER MethodHandler;
+ BOOLEAN MethodSupported;
+ };
+ ULONG MinMethod;
+ ULONG MinData;
+ PFNKSHANDLER SupportHandler;
+ ULONG Flags;
+} KSMETHOD_ITEM, *PKSMETHOD_ITEM;
+
+#define DEFINE_KSFASTMETHOD_ITEM(MethodId, MethodHandler)\
+{\
+ MethodId, (PFNKSFASTHANDLER)MethodHandler\
+}
+
+typedef struct {
+ ULONG MethodId;
+ union {
+ PFNKSFASTHANDLER MethodHandler;
+ BOOLEAN MethodSupported;
+ };
+} KSFASTMETHOD_ITEM, *PKSFASTMETHOD_ITEM;
+
+#define DEFINE_KSMETHOD_SET(Set,\
+ MethodsCount,\
+ MethodItem,\
+ FastIoCount,\
+ FastIoTable)\
+{\
+ Set,\
+ MethodsCount,\
+ MethodItem,\
+ FastIoCount,\
+ FastIoTable\
+}
+
+#define DEFINE_KSMETHOD_SET_TABLE(tablename)\
+ const KSMETHOD_SET tablename[] =
+
+typedef struct {
+ const GUID* Set;
+ ULONG MethodsCount;
+ const KSMETHOD_ITEM* MethodItem;
+ ULONG FastIoCount;
+ const KSFASTMETHOD_ITEM*FastIoTable;
+} KSMETHOD_SET, *PKSMETHOD_SET;
+
+typedef struct _KSEVENT_ENTRY
+KSEVENT_ENTRY, *PKSEVENT_ENTRY;
+
+typedef
+NTSTATUS
+(*PFNKSADDEVENT)(
+ IN PIRP Irp,
+ IN PKSEVENTDATA EventData,
+ IN struct _KSEVENT_ENTRY* EventEntry
+ );
+
+typedef
+VOID
+(*PFNKSREMOVEEVENT)(
+ IN PFILE_OBJECT FileObject,
+ IN struct _KSEVENT_ENTRY* EventEntry
+ );
+
+#define DEFINE_KSEVENT_TABLE(tablename)\
+ const KSEVENT_ITEM tablename[] =
+
+#define DEFINE_KSEVENT_ITEM(EventId, DataInput, ExtraEntryData,\
+ AddHandler, RemoveHandler, SupportHandler)\
+{\
+ EventId,\
+ DataInput,\
+ ExtraEntryData,\
+ AddHandler,\
+ RemoveHandler,\
+ SupportHandler\
+}
+
+typedef struct {
+ ULONG EventId;
+ ULONG DataInput;
+ ULONG ExtraEntryData;
+ PFNKSADDEVENT AddHandler;
+ PFNKSREMOVEEVENT RemoveHandler;
+ PFNKSHANDLER SupportHandler;
+} KSEVENT_ITEM, *PKSEVENT_ITEM;
+
+#define DEFINE_KSEVENT_SET(Set,\
+ EventsCount,\
+ EventItem)\
+{\
+ Set, EventsCount, EventItem\
+}
+
+#define DEFINE_KSEVENT_SET_TABLE(tablename)\
+ const KSEVENT_SET tablename[] =
+
+typedef struct {
+ const GUID* Set;
+ ULONG EventsCount;
+ const KSEVENT_ITEM* EventItem;
+} KSEVENT_SET, *PKSEVENT_SET;
+
+typedef struct {
+ KDPC Dpc;
+ ULONG ReferenceCount;
+ KSPIN_LOCK AccessLock;
+} KSDPC_ITEM, *PKSDPC_ITEM;
+
+typedef struct {
+ KSDPC_ITEM DpcItem;
+ LIST_ENTRY BufferList;
+} KSBUFFER_ITEM, *PKSBUFFER_ITEM;
+
+#define KSEVENT_ENTRY_DELETED 1
+#define KSEVENT_ENTRY_ONESHOT 2
+#define KSEVENT_ENTRY_BUFFERED 4
+
+struct _KSEVENT_ENTRY {
+ LIST_ENTRY ListEntry;
+ PVOID Object;
+ union {
+ PKSDPC_ITEM DpcItem;
+ PKSBUFFER_ITEM BufferItem;
+ };
+ PKSEVENTDATA EventData;
+ ULONG NotificationType;
+ const KSEVENT_SET* EventSet;
+ const KSEVENT_ITEM* EventItem;
+ PFILE_OBJECT FileObject;
+ ULONG SemaphoreAdjustment;
+ ULONG Reserved;
+ ULONG Flags;
+};
+
+typedef enum {
+ KSEVENTS_NONE,
+ KSEVENTS_SPINLOCK,
+ KSEVENTS_MUTEX,
+ KSEVENTS_FMUTEX,
+ KSEVENTS_FMUTEXUNSAFE,
+ KSEVENTS_INTERRUPT,
+ KSEVENTS_ERESOURCE
+} KSEVENTS_LOCKTYPE;
+
+#define KSDISPATCH_FASTIO 0x80000000
+
+typedef struct {
+ PDRIVER_DISPATCH Create;
+ PVOID Context;
+ UNICODE_STRING ObjectClass;
+ PSECURITY_DESCRIPTOR SecurityDescriptor;
+ ULONG Flags;
+} KSOBJECT_CREATE_ITEM, *PKSOBJECT_CREATE_ITEM;
+
+typedef
+VOID
+(*PFNKSITEMFREECALLBACK)(
+ IN PKSOBJECT_CREATE_ITEM CreateItem
+ );
+
+#define KSCREATE_ITEM_SECURITYCHANGED 0x00000001
+#define KSCREATE_ITEM_WILDCARD 0x00000002
+#define KSCREATE_ITEM_NOPARAMETERS 0x00000004
+#define KSCREATE_ITEM_FREEONSTOP 0x00000008
+
+#define DEFINE_KSCREATE_DISPATCH_TABLE( tablename )\
+ KSOBJECT_CREATE_ITEM tablename[] =
+
+#define DEFINE_KSCREATE_ITEM(DispatchCreate, TypeName, Context)\
+{\
+ (DispatchCreate),\
+ (PVOID)(Context),\
+ {\
+ sizeof(TypeName) - sizeof(UNICODE_NULL),\
+ sizeof(TypeName),\
+ (PWCHAR)(TypeName)\
+ },\
+ NULL, 0\
+}
+
+#define DEFINE_KSCREATE_ITEMEX(DispatchCreate, TypeName, Context, Flags)\
+{\
+ (DispatchCreate),\
+ (PVOID)(Context),\
+ {\
+ sizeof(TypeName) - sizeof(UNICODE_NULL),\
+ sizeof(TypeName),\
+ (PWCHAR)(TypeName)\
+ },\
+ NULL, (Flags)\
+}
+
+#define DEFINE_KSCREATE_ITEMNULL( DispatchCreate, Context )\
+{\
+ DispatchCreate,\
+ Context,\
+ {\
+ 0,\
+ 0,\
+ NULL,\
+ },\
+ NULL, 0\
+}
+
+typedef struct {
+ ULONG CreateItemsCount;
+ PKSOBJECT_CREATE_ITEM CreateItemsList;
+} KSOBJECT_CREATE, *PKSOBJECT_CREATE;
+
+typedef struct {
+ PDRIVER_DISPATCH DeviceIoControl;
+ PDRIVER_DISPATCH Read;
+ PDRIVER_DISPATCH Write;
+ PDRIVER_DISPATCH Flush;
+ PDRIVER_DISPATCH Close;
+ PDRIVER_DISPATCH QuerySecurity;
+ PDRIVER_DISPATCH SetSecurity;
+ PFAST_IO_DEVICE_CONTROL FastDeviceIoControl;
+ PFAST_IO_READ FastRead;
+ PFAST_IO_WRITE FastWrite;
+} KSDISPATCH_TABLE, *PKSDISPATCH_TABLE;
+
+#define DEFINE_KSDISPATCH_TABLE( tablename, DeviceIoControl, Read, Write,\
+ Flush, Close, QuerySecurity, SetSecurity,\
+ FastDeviceIoControl, FastRead, FastWrite )\
+ const KSDISPATCH_TABLE tablename = \
+ {\
+ DeviceIoControl, \
+ Read, \
+ Write, \
+ Flush, \
+ Close, \
+ QuerySecurity, \
+ SetSecurity, \
+ FastDeviceIoControl, \
+ FastRead, \
+ FastWrite, \
+ }
+
+#define KSCREATE_ITEM_IRP_STORAGE(Irp) (*(PKSOBJECT_CREATE_ITEM*)&(Irp)->Tail.Overlay.DriverContext[0])
+#define KSEVENT_SET_IRP_STORAGE(Irp) (*(const KSEVENT_SET**)&(Irp)->Tail.Overlay.DriverContext[0])
+#define KSEVENT_ITEM_IRP_STORAGE(Irp) (*(const KSEVENT_ITEM**)&(Irp)->Tail.Overlay.DriverContext[3])
+#define KSEVENT_ENTRY_IRP_STORAGE(Irp) (*(PKSEVENT_ENTRY*)&(Irp)->Tail.Overlay.DriverContext[0])
+#define KSMETHOD_SET_IRP_STORAGE(Irp) (*(const KSMETHOD_SET**)&(Irp)->Tail.Overlay.DriverContext[0])
+#define KSMETHOD_ITEM_IRP_STORAGE(Irp) (*(const KSMETHOD_ITEM**)&(Irp)->Tail.Overlay.DriverContext[3])
+#define KSMETHOD_TYPE_IRP_STORAGE(Irp) (*(ULONG_PTR*)(&(Irp)->Tail.Overlay.DriverContext[2]))
+#define KSQUEUE_SPINLOCK_IRP_STORAGE(Irp) (*(PKSPIN_LOCK*)&(Irp)->Tail.Overlay.DriverContext[1])
+#define KSPROPERTY_SET_IRP_STORAGE(Irp) (*(const KSPROPERTY_SET**)&(Irp)->Tail.Overlay.DriverContext[0])
+#define KSPROPERTY_ITEM_IRP_STORAGE(Irp) (*(const KSPROPERTY_ITEM**)&(Irp)->Tail.Overlay.DriverContext[3])
+#define KSPROPERTY_ATTRIBUTES_IRP_STORAGE(Irp) (*(PKSATTRIBUTE_LIST*)&(Irp)->Tail.Overlay.DriverContext[2])
+
+typedef PVOID KSDEVICE_HEADER, KSOBJECT_HEADER;
+
+typedef enum {
+ KsInvokeOnSuccess = 1,
+ KsInvokeOnError = 2,
+ KsInvokeOnCancel = 4
+} KSCOMPLETION_INVOCATION;
+
+typedef enum {
+ KsListEntryTail,
+ KsListEntryHead
+} KSLIST_ENTRY_LOCATION;
+
+typedef enum {
+ KsAcquireOnly,
+ KsAcquireAndRemove,
+ KsAcquireOnlySingleItem,
+ KsAcquireAndRemoveOnlySingleItem
+} KSIRP_REMOVAL_OPERATION;
+
+typedef enum {
+ KsStackCopyToNewLocation,
+ KsStackReuseCurrentLocation,
+ KsStackUseNewLocation
+} KSSTACK_USE;
+
+typedef enum {
+ KSTARGET_STATE_DISABLED,
+ KSTARGET_STATE_ENABLED
+} KSTARGET_STATE;
+
+typedef
+NTSTATUS
+(*PFNKSIRPLISTCALLBACK)(
+ IN PIRP Irp,
+ IN PVOID Context
+ );
+
+typedef
+VOID
+(*PFNREFERENCEDEVICEOBJECT)(
+ IN PVOID Context
+ );
+
+typedef
+VOID
+(*PFNDEREFERENCEDEVICEOBJECT)(
+ IN PVOID Context
+ );
+
+typedef
+NTSTATUS
+(*PFNQUERYREFERENCESTRING)(
+ IN PVOID Context,
+ IN OUT PWCHAR *String
+ );
+
+#define BUS_INTERFACE_REFERENCE_VERSION 0x100
+
+typedef struct {
+ //
+ // Standard interface header
+ //
+
+ INTERFACE Interface;
+
+ //
+ // Standard bus interfaces
+ //
+
+ PFNREFERENCEDEVICEOBJECT ReferenceDeviceObject;
+ PFNDEREFERENCEDEVICEOBJECT DereferenceDeviceObject;
+ PFNQUERYREFERENCESTRING QueryReferenceString;
+
+} BUS_INTERFACE_REFERENCE, *PBUS_INTERFACE_REFERENCE;
+
+#define STATIC_REFERENCE_BUS_INTERFACE STATIC_KSMEDIUMSETID_Standard
+#define REFERENCE_BUS_INTERFACE KSMEDIUMSETID_Standard
+
+typedef
+NTSTATUS
+(*PFNQUERYMEDIUMSLIST)(
+ IN PVOID Context,
+ OUT ULONG* MediumsCount,
+ OUT PKSPIN_MEDIUM* MediumList
+ );
+
+typedef struct {
+ //
+ // Standard interface header
+ //
+
+ INTERFACE Interface;
+
+ //
+ // Interface definition
+ //
+
+ PFNQUERYMEDIUMSLIST QueryMediumsList;
+
+} BUS_INTERFACE_MEDIUMS, *PBUS_INTERFACE_MEDIUMS;
+
+#define STATIC_GUID_BUS_INTERFACE_MEDIUMS \
+ 0x4EC35C3EL, 0x201B, 0x11D2, 0x87, 0x45, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
+DEFINE_GUIDSTRUCT("4EC35C3E-201B-11D2-8745-00A0C9223196", GUID_BUS_INTERFACE_MEDIUMS);
+#define GUID_BUS_INTERFACE_MEDIUMS DEFINE_GUIDNAMED(GUID_BUS_INTERFACE_MEDIUMS)
+
+#endif // defined(_NTDDK_)
+
+#if !defined( PACK_PRAGMAS_NOT_SUPPORTED )
+#include <pshpack1.h>
+#endif
+
+typedef struct {
+ GUID PropertySet;
+ ULONG Count;
+} KSPROPERTY_SERIALHDR, *PKSPROPERTY_SERIALHDR;
+
+#if !defined( PACK_PRAGMAS_NOT_SUPPORTED )
+#include <poppack.h>
+#endif
+
+typedef struct {
+ KSIDENTIFIER PropTypeSet;
+ ULONG Id;
+ ULONG PropertyLength;
+} KSPROPERTY_SERIAL, *PKSPROPERTY_SERIAL;
+
+#if defined(_NTDDK_)
+
+#define IOCTL_KS_HANDSHAKE CTL_CODE(FILE_DEVICE_KS, 0x007, METHOD_NEITHER, FILE_ANY_ACCESS)
+
+typedef struct {
+ GUID ProtocolId;
+ PVOID Argument1;
+ PVOID Argument2;
+} KSHANDSHAKE, *PKSHANDSHAKE;
+
+typedef struct _KSGATE
+KSGATE, *PKSGATE;
+
+struct _KSGATE {
+ LONG Count;
+ PKSGATE NextGate;
+};
+
+#ifndef _NTOS_
+
+void __inline
+KsGateTurnInputOn(
+ IN PKSGATE Gate OPTIONAL
+ )
+{
+ while (Gate && (InterlockedIncrement(&Gate->Count) == 1)) {
+ Gate = Gate->NextGate;
+ }
+}
+
+void __inline
+KsGateTurnInputOff(
+ IN PKSGATE Gate OPTIONAL
+ )
+{
+ while (Gate && (InterlockedDecrement(&Gate->Count) == 0)) {
+ Gate = Gate->NextGate;
+ }
+}
+
+BOOLEAN __inline
+KsGateGetStateUnsafe(
+ IN PKSGATE Gate
+ )
+{
+ ASSERT(Gate);
+ return((BOOLEAN)(Gate->Count > 0));
+}
+
+BOOLEAN __inline
+KsGateCaptureThreshold(
+ IN PKSGATE Gate
+ )
+{
+ BOOLEAN captured;
+
+ ASSERT(Gate);
+
+ captured = (BOOLEAN)(InterlockedCompareExchange(&Gate->Count,0,1) == 1);
+
+ //
+ // If we made a transition, it must be propagated.
+ //
+ if (captured) {
+ KsGateTurnInputOff(Gate->NextGate);
+ }
+
+ //
+ // We return whatever the state was prior to the compare/exchange. If
+ // the state was on, the state is now off.
+ //
+ return captured;
+}
+
+void __inline
+KsGateInitialize(
+ IN PKSGATE Gate,
+ IN LONG InitialCount,
+ IN PKSGATE NextGate OPTIONAL,
+ IN BOOLEAN StateToPropagate // IN BOOLEAN NextGateIsAnOrGate
+ )
+{
+ ASSERT(Gate);
+ Gate->Count = InitialCount;
+ Gate->NextGate = NextGate;
+
+ if (NextGate) {
+ if (InitialCount > 0) {
+ if (StateToPropagate) {
+ KsGateTurnInputOn(NextGate);
+ }
+ } else {
+ if (! StateToPropagate) {
+ KsGateTurnInputOff(NextGate);
+ }
+ }
+ }
+}
+
+void __inline
+KsGateInitializeAnd(
+ IN PKSGATE AndGate,
+ IN PKSGATE NextOrGate OPTIONAL
+ )
+{
+ KsGateInitialize(AndGate,1,NextOrGate,TRUE);
+}
+
+void __inline
+KsGateInitializeOr(
+ IN PKSGATE OrGate,
+ IN PKSGATE NextAndGate OPTIONAL
+ )
+{
+ KsGateInitialize(OrGate,0,NextAndGate,FALSE);
+}
+
+void __inline KsGateAddOnInputToAnd(IN PKSGATE AndGate) { UNREFERENCED_PARAMETER (AndGate); }
+void __inline KsGateAddOffInputToAnd(IN PKSGATE AndGate) { KsGateTurnInputOff(AndGate); }
+void __inline KsGateRemoveOnInputFromAnd(IN PKSGATE AndGate) { UNREFERENCED_PARAMETER (AndGate); }
+void __inline KsGateRemoveOffInputFromAnd(IN PKSGATE AndGate) { KsGateTurnInputOn(AndGate); }
+
+void __inline KsGateAddOnInputToOr(IN PKSGATE OrGate) { KsGateTurnInputOn(OrGate); }
+void __inline KsGateAddOffInputToOr(IN PKSGATE OrGate) { UNREFERENCED_PARAMETER (OrGate); }
+void __inline KsGateRemoveOnInputFromOr(IN PKSGATE OrGate) { KsGateTurnInputOff(OrGate); }
+void __inline KsGateRemoveOffInputFromOr(IN PKSGATE OrGate) { UNREFERENCED_PARAMETER (OrGate); }
+
+void __inline
+KsGateTerminateAnd(
+ IN PKSGATE AndGate
+ )
+{
+ ASSERT(AndGate);
+ if (KsGateGetStateUnsafe(AndGate)) {
+ KsGateRemoveOnInputFromOr(AndGate->NextGate);
+ } else {
+ KsGateRemoveOffInputFromOr(AndGate->NextGate);
+ }
+}
+
+void __inline
+KsGateTerminateOr(
+ IN PKSGATE OrGate
+ )
+{
+ ASSERT(OrGate);
+ if (KsGateGetStateUnsafe(OrGate)) {
+ KsGateRemoveOnInputFromAnd(OrGate->NextGate);
+ } else {
+ KsGateRemoveOffInputFromAnd(OrGate->NextGate);
+ }
+}
+
+#endif // !_NTOS_
+
+typedef PVOID KSOBJECT_BAG;
+
+typedef
+BOOLEAN
+(*PFNKSGENERATEEVENTCALLBACK)(
+ IN PVOID Context,
+ IN PKSEVENT_ENTRY EventEntry
+ );
+
+typedef
+NTSTATUS
+(*PFNKSDEVICECREATE)(
+ IN PKSDEVICE Device
+ );
+typedef
+NTSTATUS
+(*PFNKSDEVICEPNPSTART)(
+ IN PKSDEVICE Device,
+ IN PIRP Irp,
+ IN PCM_RESOURCE_LIST TranslatedResourceList OPTIONAL,
+ IN PCM_RESOURCE_LIST UntranslatedResourceList OPTIONAL
+ );
+typedef
+NTSTATUS
+(*PFNKSDEVICE)(
+ IN PKSDEVICE Device
+ );
+typedef
+NTSTATUS
+(*PFNKSDEVICEIRP)(
+ IN PKSDEVICE Device,
+ IN PIRP Irp
+ );
+typedef
+void
+(*PFNKSDEVICEIRPVOID)(
+ IN PKSDEVICE Device,
+ IN PIRP Irp
+ );
+typedef
+NTSTATUS
+(*PFNKSDEVICEQUERYCAPABILITIES)(
+ IN PKSDEVICE Device,
+ IN PIRP Irp,
+ IN OUT PDEVICE_CAPABILITIES Capabilities
+ );
+typedef
+NTSTATUS
+(*PFNKSDEVICEQUERYPOWER)(
+ IN PKSDEVICE Device,
+ IN PIRP Irp,
+ IN DEVICE_POWER_STATE DeviceTo,
+ IN DEVICE_POWER_STATE DeviceFrom,
+ IN SYSTEM_POWER_STATE SystemTo,
+ IN SYSTEM_POWER_STATE SystemFrom,
+ IN POWER_ACTION Action
+ );
+typedef
+void
+(*PFNKSDEVICESETPOWER)(
+ IN PKSDEVICE Device,
+ IN PIRP Irp,
+ IN DEVICE_POWER_STATE To,
+ IN DEVICE_POWER_STATE From
+ );
+typedef
+NTSTATUS
+(*PFNKSFILTERFACTORYVOID)(
+ IN PKSFILTERFACTORY FilterFactory
+ );
+typedef
+void
+(*PFNKSFILTERFACTORYPOWER)(
+ IN PKSFILTERFACTORY FilterFactory,
+ IN DEVICE_POWER_STATE State
+ );
+typedef
+NTSTATUS
+(*PFNKSFILTERIRP)(
+ IN PKSFILTER Filter,
+ IN PIRP Irp
+ );
+typedef
+NTSTATUS
+(*PFNKSFILTERPROCESS)(
+ IN PKSFILTER Filter,
+ IN PKSPROCESSPIN_INDEXENTRY Index
+ );
+typedef
+NTSTATUS
+(*PFNKSFILTERVOID)(
+ IN PKSFILTER Filter
+ );
+typedef
+void
+(*PFNKSFILTERPOWER)(
+ IN PKSFILTER Filter,
+ IN DEVICE_POWER_STATE State
+ );
+typedef
+NTSTATUS
+(*PFNKSPINIRP)(
+ IN PKSPIN Pin,
+ IN PIRP Irp
+ );
+typedef
+NTSTATUS
+(*PFNKSPINSETDEVICESTATE)(
+ IN PKSPIN Pin,
+ IN KSSTATE ToState,
+ IN KSSTATE FromState
+ );
+typedef
+NTSTATUS
+(*PFNKSPINSETDATAFORMAT)(
+ IN PKSPIN Pin,
+ IN PKSDATAFORMAT OldFormat OPTIONAL,
+ IN PKSMULTIPLE_ITEM OldAttributeList OPTIONAL,
+ IN const KSDATARANGE* DataRange,
+ IN const KSATTRIBUTE_LIST* AttributeRange OPTIONAL
+ );
+typedef
+NTSTATUS
+(*PFNKSPINHANDSHAKE)(
+ IN PKSPIN Pin,
+ IN PKSHANDSHAKE In,
+ IN PKSHANDSHAKE Out
+ );
+typedef
+NTSTATUS
+(*PFNKSPIN)(
+ IN PKSPIN Pin
+ );
+typedef
+void
+(*PFNKSPINVOID)(
+ IN PKSPIN Pin
+ );
+typedef
+void
+(*PFNKSPINPOWER)(
+ IN PKSPIN Pin,
+ IN DEVICE_POWER_STATE State
+ );
+typedef
+BOOLEAN
+(*PFNKSPINSETTIMER)(
+ IN PKSPIN Pin,
+ IN PKTIMER Timer,
+ IN LARGE_INTEGER DueTime,
+ IN PKDPC Dpc
+ );
+typedef
+BOOLEAN
+(*PFNKSPINCANCELTIMER)(
+ IN PKSPIN Pin,
+ IN PKTIMER Timer
+ );
+typedef
+LONGLONG
+(FASTCALL *PFNKSPINCORRELATEDTIME)(
+ IN PKSPIN Pin,
+ OUT PLONGLONG SystemTime
+ );
+typedef
+void
+(*PFNKSPINRESOLUTION)(
+ IN PKSPIN Pin,
+ OUT PKSRESOLUTION Resolution
+ );
+typedef
+NTSTATUS
+(*PFNKSPININITIALIZEALLOCATOR)(
+ IN PKSPIN Pin,
+ IN PKSALLOCATOR_FRAMING AllocatorFraming,
+ OUT PVOID* Context
+ );
+typedef
+void
+(*PFNKSSTREAMPOINTER)(
+ IN PKSSTREAM_POINTER StreamPointer
+ );
+
+typedef struct KSAUTOMATION_TABLE_
+KSAUTOMATION_TABLE, *PKSAUTOMATION_TABLE;
+struct KSAUTOMATION_TABLE_ {
+ ULONG PropertySetsCount;
+ ULONG PropertyItemSize;
+ const KSPROPERTY_SET* PropertySets;
+ ULONG MethodSetsCount;
+ ULONG MethodItemSize;
+ const KSMETHOD_SET* MethodSets;
+ ULONG EventSetsCount;
+ ULONG EventItemSize;
+ const KSEVENT_SET* EventSets;
+#if !defined(_WIN64)
+ PVOID Alignment;
+#endif // !defined(_WIN64)
+};
+
+#define DEFINE_KSAUTOMATION_TABLE(table)\
+ const KSAUTOMATION_TABLE table =
+
+#define DEFINE_KSAUTOMATION_PROPERTIES(table)\
+ SIZEOF_ARRAY(table),\
+ sizeof(KSPROPERTY_ITEM),\
+ table
+
+#define DEFINE_KSAUTOMATION_METHODS(table)\
+ SIZEOF_ARRAY(table),\
+ sizeof(KSMETHOD_ITEM),\
+ table
+
+#define DEFINE_KSAUTOMATION_EVENTS(table)\
+ SIZEOF_ARRAY(table),\
+ sizeof(KSEVENT_ITEM),\
+ table
+
+#define DEFINE_KSAUTOMATION_PROPERTIES_NULL\
+ 0,\
+ sizeof(KSPROPERTY_ITEM),\
+ NULL
+
+#define DEFINE_KSAUTOMATION_METHODS_NULL\
+ 0,\
+ sizeof(KSMETHOD_ITEM),\
+ NULL
+
+#define DEFINE_KSAUTOMATION_EVENTS_NULL\
+ 0,\
+ sizeof(KSEVENT_ITEM),\
+ NULL
+
+#define MIN_DEV_VER_FOR_QI (0x100)
+
+struct _KSDEVICE_DISPATCH {
+ PFNKSDEVICECREATE Add;
+ PFNKSDEVICEPNPSTART Start;
+ PFNKSDEVICE PostStart;
+ PFNKSDEVICEIRP QueryStop;
+ PFNKSDEVICEIRPVOID CancelStop;
+ PFNKSDEVICEIRPVOID Stop;
+ PFNKSDEVICEIRP QueryRemove;
+ PFNKSDEVICEIRPVOID CancelRemove;
+ PFNKSDEVICEIRPVOID Remove;
+ PFNKSDEVICEQUERYCAPABILITIES QueryCapabilities;
+ PFNKSDEVICEIRPVOID SurpriseRemoval;
+ PFNKSDEVICEQUERYPOWER QueryPower;
+ PFNKSDEVICESETPOWER SetPower;
+ PFNKSDEVICEIRP QueryInterface; // added in version 0x100
+};
+
+struct _KSFILTER_DISPATCH {
+ PFNKSFILTERIRP Create;
+ PFNKSFILTERIRP Close;
+ PFNKSFILTERPROCESS Process;
+ PFNKSFILTERVOID Reset;
+};
+
+struct _KSPIN_DISPATCH {
+ PFNKSPINIRP Create;
+ PFNKSPINIRP Close;
+ PFNKSPIN Process;
+ PFNKSPINVOID Reset;
+ PFNKSPINSETDATAFORMAT SetDataFormat;
+ PFNKSPINSETDEVICESTATE SetDeviceState;
+ PFNKSPIN Connect;
+ PFNKSPINVOID Disconnect;
+ const KSCLOCK_DISPATCH* Clock;
+ const KSALLOCATOR_DISPATCH* Allocator;
+};
+
+struct _KSCLOCK_DISPATCH {
+ PFNKSPINSETTIMER SetTimer;
+ PFNKSPINCANCELTIMER CancelTimer;
+ PFNKSPINCORRELATEDTIME CorrelatedTime;
+ PFNKSPINRESOLUTION Resolution;
+};
+
+struct _KSALLOCATOR_DISPATCH {
+ PFNKSPININITIALIZEALLOCATOR InitializeAllocator;
+ PFNKSDELETEALLOCATOR DeleteAllocator;
+ PFNKSDEFAULTALLOCATE Allocate;
+ PFNKSDEFAULTFREE Free;
+};
+
+#define KSDEVICE_DESCRIPTOR_VERSION (0x100)
+
+struct _KSDEVICE_DESCRIPTOR {
+ const KSDEVICE_DISPATCH* Dispatch;
+ ULONG FilterDescriptorsCount;
+ const KSFILTER_DESCRIPTOR*const* FilterDescriptors;
+ ULONG Version; // this is 0 for pre-version 100 driver
+ //#if !defined(_WIN64)
+ //PVOID Alignment;
+ //#endif //!defined(_WIN64)
+};
+
+struct _KSFILTER_DESCRIPTOR {
+ const KSFILTER_DISPATCH* Dispatch;
+ const KSAUTOMATION_TABLE* AutomationTable;
+ ULONG Version;
+#define KSFILTER_DESCRIPTOR_VERSION ((ULONG)-1)
+ ULONG Flags;
+#define KSFILTER_FLAG_DISPATCH_LEVEL_PROCESSING 0x00000001
+#define KSFILTER_FLAG_CRITICAL_PROCESSING 0x00000002
+#define KSFILTER_FLAG_HYPERCRITICAL_PROCESSING 0x00000004
+#define KSFILTER_FLAG_RECEIVE_ZERO_LENGTH_SAMPLES 0x00000008
+#define KSFILTER_FLAG_DENY_USERMODE_ACCESS 0x80000000
+ const GUID* ReferenceGuid;
+ ULONG PinDescriptorsCount;
+ ULONG PinDescriptorSize;
+ const KSPIN_DESCRIPTOR_EX* PinDescriptors;
+ ULONG CategoriesCount;
+ const GUID* Categories;
+ ULONG NodeDescriptorsCount;
+ ULONG NodeDescriptorSize;
+ const KSNODE_DESCRIPTOR* NodeDescriptors;
+ ULONG ConnectionsCount;
+ const KSTOPOLOGY_CONNECTION* Connections;
+ const KSCOMPONENTID* ComponentId;
+};
+
+#define DEFINE_KSFILTER_DESCRIPTOR(descriptor)\
+ const KSFILTER_DESCRIPTOR descriptor =
+
+#define DEFINE_KSFILTER_PIN_DESCRIPTORS(table)\
+ SIZEOF_ARRAY(table),\
+ sizeof(table[0]),\
+ table
+
+#define DEFINE_KSFILTER_CATEGORIES(table)\
+ SIZEOF_ARRAY(table),\
+ table
+
+#define DEFINE_KSFILTER_CATEGORY(category)\
+ 1,\
+ &(category)
+
+#define DEFINE_KSFILTER_CATEGORIES_NULL\
+ 0,\
+ NULL
+
+#define DEFINE_KSFILTER_NODE_DESCRIPTORS(table)\
+ SIZEOF_ARRAY(table),\
+ sizeof(table[0]),\
+ table
+
+#define DEFINE_KSFILTER_NODE_DESCRIPTORS_NULL\
+ 0,\
+ sizeof(KSNODE_DESCRIPTOR),\
+ NULL
+
+#define DEFINE_KSFILTER_CONNECTIONS(table)\
+ SIZEOF_ARRAY(table),\
+ table
+
+#define DEFINE_KSFILTER_DEFAULT_CONNECTIONS\
+ 0,\
+ NULL
+
+#define DEFINE_KSFILTER_DESCRIPTOR_TABLE(table)\
+ const KSFILTER_DESCRIPTOR*const table[] =
+
+struct _KSPIN_DESCRIPTOR_EX {
+ const KSPIN_DISPATCH* Dispatch;
+ const KSAUTOMATION_TABLE* AutomationTable;
+ KSPIN_DESCRIPTOR PinDescriptor;
+ ULONG Flags;
+#define KSPIN_FLAG_DISPATCH_LEVEL_PROCESSING KSFILTER_FLAG_DISPATCH_LEVEL_PROCESSING
+#define KSPIN_FLAG_CRITICAL_PROCESSING KSFILTER_FLAG_CRITICAL_PROCESSING
+#define KSPIN_FLAG_HYPERCRITICAL_PROCESSING KSFILTER_FLAG_HYPERCRITICAL_PROCESSING
+#define KSPIN_FLAG_ASYNCHRONOUS_PROCESSING 0x00000008
+#define KSPIN_FLAG_DO_NOT_INITIATE_PROCESSING 0x00000010
+#define KSPIN_FLAG_INITIATE_PROCESSING_ON_EVERY_ARRIVAL 0x00000020
+#define KSPIN_FLAG_FRAMES_NOT_REQUIRED_FOR_PROCESSING 0x00000040
+#define KSPIN_FLAG_ENFORCE_FIFO 0x00000080
+
+#define KSPIN_FLAG_GENERATE_MAPPINGS 0x00000100
+#define KSPIN_FLAG_DISTINCT_TRAILING_EDGE 0x00000200
+
+#define KSPIN_FLAG_PROCESS_IN_RUN_STATE_ONLY 0x00010000
+#define KSPIN_FLAG_SPLITTER 0x00020000
+#define KSPIN_FLAG_USE_STANDARD_TRANSPORT 0x00040000
+#define KSPIN_FLAG_DO_NOT_USE_STANDARD_TRANSPORT 0x00080000
+#define KSPIN_FLAG_FIXED_FORMAT 0x00100000
+#define KSPIN_FLAG_GENERATE_EOS_EVENTS 0x00200000
+#define KSPIN_FLAG_RENDERER (KSPIN_FLAG_PROCESS_IN_RUN_STATE_ONLY|KSPIN_FLAG_GENERATE_EOS_EVENTS)
+#define KSPIN_FLAG_IMPLEMENT_CLOCK 0x00400000
+#define KSPIN_FLAG_SOME_FRAMES_REQUIRED_FOR_PROCESSING 0x00800000
+#define KSPIN_FLAG_PROCESS_IF_ANY_IN_RUN_STATE 0x01000000
+#define KSPIN_FLAG_DENY_USERMODE_ACCESS 0x80000000
+ ULONG InstancesPossible;
+ ULONG InstancesNecessary;
+ const KSALLOCATOR_FRAMING_EX* AllocatorFraming;
+ PFNKSINTERSECTHANDLEREX IntersectHandler;
+};
+
+#define DEFINE_KSPIN_DEFAULT_INTERFACES\
+ 0,\
+ NULL
+
+#define DEFINE_KSPIN_DEFAULT_MEDIUMS\
+ 0,\
+ NULL
+
+struct _KSNODE_DESCRIPTOR {
+ const KSAUTOMATION_TABLE* AutomationTable;
+ const GUID* Type;
+ const GUID* Name;
+#if !defined(_WIN64)
+ PVOID Alignment;
+#endif // !defined(_WIN64)
+};
+
+#if !defined(_WIN64)
+#define DEFINE_NODE_DESCRIPTOR(automation,type,name) \
+ { (automation), (type), (name), NULL }
+#else // !defined(_WIN64)
+#define DEFINE_NODE_DESCRIPTOR(automation,type,name) \
+ { (automation), (type), (name) }
+#endif // !defined(_WIN64)
+
+struct _KSDEVICE {
+ const KSDEVICE_DESCRIPTOR* Descriptor;
+ KSOBJECT_BAG Bag;
+ PVOID Context;
+ PDEVICE_OBJECT FunctionalDeviceObject;
+ PDEVICE_OBJECT PhysicalDeviceObject;
+ PDEVICE_OBJECT NextDeviceObject;
+ BOOLEAN Started;
+ SYSTEM_POWER_STATE SystemPowerState;
+ DEVICE_POWER_STATE DevicePowerState;
+};
+
+struct _KSFILTERFACTORY {
+ const KSFILTER_DESCRIPTOR* FilterDescriptor;
+ KSOBJECT_BAG Bag;
+ PVOID Context;
+};
+
+struct _KSFILTER {
+ const KSFILTER_DESCRIPTOR* Descriptor;
+ KSOBJECT_BAG Bag;
+ PVOID Context;
+};
+
+struct _KSPIN {
+ const KSPIN_DESCRIPTOR_EX* Descriptor;
+ KSOBJECT_BAG Bag;
+ PVOID Context;
+ ULONG Id;
+ KSPIN_COMMUNICATION Communication;
+ BOOLEAN ConnectionIsExternal;
+ KSPIN_INTERFACE ConnectionInterface;
+ KSPIN_MEDIUM ConnectionMedium;
+ KSPRIORITY ConnectionPriority;
+ PKSDATAFORMAT ConnectionFormat;
+ PKSMULTIPLE_ITEM AttributeList;
+ ULONG StreamHeaderSize;
+ KSPIN_DATAFLOW DataFlow;
+ KSSTATE DeviceState;
+ KSRESET ResetState;
+ KSSTATE ClientState;
+};
+
+struct _KSMAPPING {
+ PHYSICAL_ADDRESS PhysicalAddress;
+ ULONG ByteCount;
+ ULONG Alignment;
+};
+
+struct _KSSTREAM_POINTER_OFFSET
+{
+#if defined(_NTDDK_)
+ union {
+ PUCHAR Data;
+ PKSMAPPING Mappings;
+ };
+#else // !defined(_NTDDK_)
+ PUCHAR Data;
+#endif // !defined(_NTDDK_)
+#if !defined(_WIN64)
+ PVOID Alignment;
+#endif // !defined(_WIN64)
+ ULONG Count;
+ ULONG Remaining;
+};
+
+struct _KSSTREAM_POINTER
+{
+ PVOID Context;
+ PKSPIN Pin;
+ PKSSTREAM_HEADER StreamHeader;
+ PKSSTREAM_POINTER_OFFSET Offset;
+ KSSTREAM_POINTER_OFFSET OffsetIn;
+ KSSTREAM_POINTER_OFFSET OffsetOut;
+};
+
+struct _KSPROCESSPIN {
+ PKSPIN Pin;
+ PKSSTREAM_POINTER StreamPointer;
+ PKSPROCESSPIN InPlaceCounterpart;
+ PKSPROCESSPIN DelegateBranch;
+ PKSPROCESSPIN CopySource;
+ PVOID Data;
+ ULONG BytesAvailable;
+ ULONG BytesUsed;
+ ULONG Flags;
+ BOOLEAN Terminate;
+};
+
+struct _KSPROCESSPIN_INDEXENTRY {
+ PKSPROCESSPIN *Pins;
+ ULONG Count;
+};
+
+typedef enum {
+ KsObjectTypeDevice,
+ KsObjectTypeFilterFactory,
+ KsObjectTypeFilter,
+ KsObjectTypePin
+} KSOBJECTTYPE;
+
+typedef
+void
+(*PFNKSFREE)(
+ IN PVOID Data
+ );
+
+typedef
+void
+(*PFNKSPINFRAMERETURN)(
+ IN PKSPIN Pin,
+ IN PVOID Data OPTIONAL,
+ IN ULONG Size OPTIONAL,
+ IN PMDL Mdl OPTIONAL,
+ IN PVOID Context OPTIONAL,
+ IN NTSTATUS Status
+ );
+
+typedef
+void
+(*PFNKSPINIRPCOMPLETION)(
+ IN PKSPIN Pin,
+ IN PIRP Irp
+ );
+
+#if defined(_UNKNOWN_H_) || defined(__IUnknown_INTERFACE_DEFINED__)
+#if !defined(_IKsControl_)
+#define _IKsControl_
+
+typedef interface IKsControl* PIKSCONTROL;
+
+#if !defined(DEFINE_ABSTRACT_UNKNOWN)
+
+#define DEFINE_ABSTRACT_UNKNOWN() \
+ STDMETHOD_(NTSTATUS, QueryInterface)(THIS_ \
+ REFIID InterfaceId, \
+ PVOID* Interface \
+ ) PURE; \
+ STDMETHOD_(ULONG,AddRef)(THIS) PURE; \
+ STDMETHOD_(ULONG,Release)(THIS) PURE;
+
+#endif //!defined(DEFINE_ABSTRACT_UNKNOWN)
+
+#undef INTERFACE
+#define INTERFACE IKsControl
+DECLARE_INTERFACE_(IKsControl,IUnknown)
+{
+ DEFINE_ABSTRACT_UNKNOWN() // For C
+
+ STDMETHOD_(NTSTATUS, KsProperty)(THIS_
+ IN PKSPROPERTY Property,
+ IN ULONG PropertyLength,
+ IN OUT PVOID PropertyData,
+ IN ULONG DataLength,
+ OUT ULONG* BytesReturned
+ ) PURE;
+ STDMETHOD_(NTSTATUS, KsMethod)(THIS_
+ IN PKSMETHOD Method,
+ IN ULONG MethodLength,
+ IN OUT PVOID MethodData,
+ IN ULONG DataLength,
+ OUT ULONG* BytesReturned
+ ) PURE;
+ STDMETHOD_(NTSTATUS, KsEvent)(THIS_
+ IN PKSEVENT Event OPTIONAL,
+ IN ULONG EventLength,
+ IN OUT PVOID EventData,
+ IN ULONG DataLength,
+ OUT ULONG* BytesReturned
+ ) PURE;
+};
+
+typedef interface IKsReferenceClock* PIKSREFERENCECLOCK;
+
+#undef INTERFACE
+#define INTERFACE IKsReferenceClock
+DECLARE_INTERFACE_(IKsReferenceClock,IUnknown)
+{
+ DEFINE_ABSTRACT_UNKNOWN() // For C
+
+ STDMETHOD_(LONGLONG,GetTime)(THIS
+ ) PURE;
+ STDMETHOD_(LONGLONG,GetPhysicalTime)(THIS
+ ) PURE;
+ STDMETHOD_(LONGLONG,GetCorrelatedTime)(THIS_
+ OUT PLONGLONG SystemTime
+ ) PURE;
+ STDMETHOD_(LONGLONG,GetCorrelatedPhysicalTime)(THIS_
+ OUT PLONGLONG SystemTime
+ ) PURE;
+ STDMETHOD_(NTSTATUS, GetResolution)(THIS_
+ OUT PKSRESOLUTION Resolution
+ ) PURE;
+ STDMETHOD_(NTSTATUS, GetState)(THIS_
+ OUT PKSSTATE State
+ ) PURE;
+};
+#undef INTERFACE
+
+#define STATIC_IID_IKsControl \
+0x28F54685L, 0x06FD, 0x11D2, 0xB2, 0x7A, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
+DEFINE_GUID(IID_IKsControl,
+0x28F54685L, 0x06FD, 0x11D2, 0xB2, 0x7A, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96);
+#if defined(__cplusplus) && _MSC_VER >= 1100
+struct __declspec(uuid("28F54685-06FD-11D2-B27A-00A0C9223196")) IKsControl;
+#endif
+
+#define STATIC_IID_IKsFastClock \
+0xc9902485, 0xc180, 0x11d2, 0x84, 0x73, 0xd4, 0x23, 0x94, 0x45, 0x9e, 0x5e
+DEFINE_GUID(IID_IKsFastClock,
+0xc9902485, 0xc180, 0x11d2, 0x84, 0x73, 0xd4, 0x23, 0x94, 0x45, 0x9e, 0x5e);
+#if defined(__cplusplus) && _MSC_VER >= 1100
+struct __declspec(uuid("C9902485-C180-11d2-8473-D42394459E5E")) IKsFastClock;
+#endif
+
+#endif // !defined(_IKsControl_)
+#endif // defined(_UNKNOWN_H_) || defined(__IUnknown_INTERFACE_DEFINED__)
+
+#endif // defined(_NTDDK_)
+
+//===========================================================================
+
+#if defined(__cplusplus)
+extern "C" {
+#endif // defined(__cplusplus)
+
+//
+// exported prototypes
+//
+
+#ifdef _KSDDK_
+#define KSDDKAPI
+#else // !_KSDDK_
+#define KSDDKAPI DECLSPEC_IMPORT
+#endif // _KSDDK_
+
+#if defined(_NTDDK_)
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsEnableEvent(
+ IN PIRP Irp,
+ IN ULONG EventSetsCount,
+ IN const KSEVENT_SET* EventSet,
+ IN OUT PLIST_ENTRY EventsList OPTIONAL,
+ IN KSEVENTS_LOCKTYPE EventsFlags OPTIONAL,
+ IN PVOID EventsLock OPTIONAL
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsEnableEventWithAllocator(
+ IN PIRP Irp,
+ IN ULONG EventSetsCount,
+ IN const KSEVENT_SET* EventSet,
+ IN OUT PLIST_ENTRY EventsList OPTIONAL,
+ IN KSEVENTS_LOCKTYPE EventsFlags OPTIONAL,
+ IN PVOID EventsLock OPTIONAL,
+ IN PFNKSALLOCATOR Allocator OPTIONAL,
+ IN ULONG EventItemSize OPTIONAL
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsDisableEvent(
+ IN PIRP Irp,
+ IN OUT PLIST_ENTRY EventsList,
+ IN KSEVENTS_LOCKTYPE EventsFlags,
+ IN PVOID EventsLock
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsDiscardEvent(
+ IN PKSEVENT_ENTRY EventEntry
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsFreeEventList(
+ IN PFILE_OBJECT FileObject,
+ IN OUT PLIST_ENTRY EventsList,
+ IN KSEVENTS_LOCKTYPE EventsFlags,
+ IN PVOID EventsLock
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsGenerateEvent(
+ IN PKSEVENT_ENTRY EventEntry
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsGenerateDataEvent(
+ IN PKSEVENT_ENTRY EventEntry,
+ IN ULONG DataSize,
+ IN PVOID Data
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsGenerateEventList(
+ IN GUID* Set OPTIONAL,
+ IN ULONG EventId,
+ IN PLIST_ENTRY EventsList,
+ IN KSEVENTS_LOCKTYPE EventsFlags,
+ IN PVOID EventsLock
+ );
+
+// property.c:
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsPropertyHandler(
+ IN PIRP Irp,
+ IN ULONG PropertySetsCount,
+ IN const KSPROPERTY_SET* PropertySet
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsPropertyHandlerWithAllocator(
+ IN PIRP Irp,
+ IN ULONG PropertySetsCount,
+ IN const KSPROPERTY_SET* PropertySet,
+ IN PFNKSALLOCATOR Allocator OPTIONAL,
+ IN ULONG PropertyItemSize OPTIONAL
+ );
+
+KSDDKAPI
+BOOLEAN
+NTAPI
+KsFastPropertyHandler(
+ IN PFILE_OBJECT FileObject,
+ IN PKSPROPERTY Property,
+ IN ULONG PropertyLength,
+ IN OUT PVOID Data,
+ IN ULONG DataLength,
+ OUT PIO_STATUS_BLOCK IoStatus,
+ IN ULONG PropertySetsCount,
+ IN const KSPROPERTY_SET* PropertySet
+ );
+
+// method.c:
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsMethodHandler(
+ IN PIRP Irp,
+ IN ULONG MethodSetsCount,
+ IN const KSMETHOD_SET* MethodSet
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsMethodHandlerWithAllocator(
+ IN PIRP Irp,
+ IN ULONG MethodSetsCount,
+ IN const KSMETHOD_SET* MethodSet,
+ IN PFNKSALLOCATOR Allocator OPTIONAL,
+ IN ULONG MethodItemSize OPTIONAL
+ );
+
+KSDDKAPI
+BOOLEAN
+NTAPI
+KsFastMethodHandler(
+ IN PFILE_OBJECT FileObject,
+ IN PKSMETHOD Method,
+ IN ULONG MethodLength,
+ IN OUT PVOID Data,
+ IN ULONG DataLength,
+ OUT PIO_STATUS_BLOCK IoStatus,
+ IN ULONG MethodSetsCount,
+ IN const KSMETHOD_SET* MethodSet
+ );
+
+// alloc.c:
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsCreateDefaultAllocator(
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsCreateDefaultAllocatorEx(
+ IN PIRP Irp,
+ IN PVOID InitializeContext OPTIONAL,
+ IN PFNKSDEFAULTALLOCATE DefaultAllocate OPTIONAL,
+ IN PFNKSDEFAULTFREE DefaultFree OPTIONAL,
+ IN PFNKSINITIALIZEALLOCATOR InitializeAllocator OPTIONAL,
+ IN PFNKSDELETEALLOCATOR DeleteAllocator OPTIONAL
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsCreateAllocator(
+ IN HANDLE ConnectionHandle,
+ IN PKSALLOCATOR_FRAMING AllocatorFraming,
+ OUT PHANDLE AllocatorHandle
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsValidateAllocatorCreateRequest(
+ IN PIRP Irp,
+ OUT PKSALLOCATOR_FRAMING* AllocatorFraming
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsValidateAllocatorFramingEx(
+ IN PKSALLOCATOR_FRAMING_EX Framing,
+ IN ULONG BufferSize,
+ IN const KSALLOCATOR_FRAMING_EX *PinFraming
+ );
+
+// clock.c:
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsAllocateDefaultClock(
+ OUT PKSDEFAULTCLOCK* DefaultClock
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsAllocateDefaultClockEx(
+ OUT PKSDEFAULTCLOCK* DefaultClock,
+ IN PVOID Context OPTIONAL,
+ IN PFNKSSETTIMER SetTimer OPTIONAL,
+ IN PFNKSCANCELTIMER CancelTimer OPTIONAL,
+ IN PFNKSCORRELATEDTIME CorrelatedTime OPTIONAL,
+ IN const KSRESOLUTION* Resolution OPTIONAL,
+ IN ULONG Flags
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsFreeDefaultClock(
+ IN PKSDEFAULTCLOCK DefaultClock
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsCreateDefaultClock(
+ IN PIRP Irp,
+ IN PKSDEFAULTCLOCK DefaultClock
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsCreateClock(
+ IN HANDLE ConnectionHandle,
+ IN PKSCLOCK_CREATE ClockCreate,
+ OUT PHANDLE ClockHandle
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsValidateClockCreateRequest(
+ IN PIRP Irp,
+ OUT PKSCLOCK_CREATE* ClockCreate
+ );
+
+KSDDKAPI
+KSSTATE
+NTAPI
+KsGetDefaultClockState(
+ IN PKSDEFAULTCLOCK DefaultClock
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsSetDefaultClockState(
+ IN PKSDEFAULTCLOCK DefaultClock,
+ IN KSSTATE State
+ );
+
+KSDDKAPI
+LONGLONG
+NTAPI
+KsGetDefaultClockTime(
+ IN PKSDEFAULTCLOCK DefaultClock
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsSetDefaultClockTime(
+ IN PKSDEFAULTCLOCK DefaultClock,
+ IN LONGLONG Time
+ );
+
+// connect.c:
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsCreatePin(
+ IN HANDLE FilterHandle,
+ IN PKSPIN_CONNECT Connect,
+ IN ACCESS_MASK DesiredAccess,
+ OUT PHANDLE ConnectionHandle
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsValidateConnectRequest(
+ IN PIRP Irp,
+ IN ULONG DescriptorsCount,
+ IN const KSPIN_DESCRIPTOR* Descriptor,
+ OUT PKSPIN_CONNECT* Connect
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsPinPropertyHandler(
+ IN PIRP Irp,
+ IN PKSPROPERTY Property,
+ IN OUT PVOID Data,
+ IN ULONG DescriptorsCount,
+ IN const KSPIN_DESCRIPTOR* Descriptor
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsPinDataIntersection(
+ IN PIRP Irp,
+ IN PKSP_PIN Pin,
+ OUT PVOID Data OPTIONAL,
+ IN ULONG DescriptorsCount,
+ IN const KSPIN_DESCRIPTOR* Descriptor,
+ IN PFNKSINTERSECTHANDLER IntersectHandler
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsPinDataIntersectionEx(
+ IN PIRP Irp,
+ IN PKSP_PIN Pin,
+ OUT PVOID Data,
+ IN ULONG DescriptorsCount,
+ IN const KSPIN_DESCRIPTOR* Descriptor,
+ IN ULONG DescriptorSize,
+ IN PFNKSINTERSECTHANDLEREX IntersectHandler OPTIONAL,
+ IN PVOID HandlerContext OPTIONAL
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsHandleSizedListQuery(
+ IN PIRP Irp,
+ IN ULONG DataItemsCount,
+ IN ULONG DataItemSize,
+ IN const VOID* DataItems
+ );
+
+// image.c:
+
+#if (!defined( MAKEINTRESOURCE ))
+#define MAKEINTRESOURCE( res ) ((ULONG_PTR) (USHORT) res)
+#endif
+
+#if (!defined( RT_STRING ))
+#define RT_STRING MAKEINTRESOURCE( 6 )
+#define RT_RCDATA MAKEINTRESOURCE( 10 )
+#endif
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsLoadResource(
+ IN PVOID ImageBase,
+ IN POOL_TYPE PoolType,
+ IN ULONG_PTR ResourceName,
+ IN ULONG ResourceType,
+ OUT PVOID *Resource,
+ OUT PULONG ResourceSize
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsGetImageNameAndResourceId(
+ IN HANDLE RegKey,
+ OUT PUNICODE_STRING ImageName,
+ OUT PULONG_PTR ResourceId,
+ OUT PULONG ValueType
+);
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsMapModuleName(
+ IN PDEVICE_OBJECT PhysicalDeviceObject,
+ IN PUNICODE_STRING ModuleName,
+ OUT PUNICODE_STRING ImageName,
+ OUT PULONG_PTR ResourceId,
+ OUT PULONG ValueType
+ );
+
+// irp.c:
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsReferenceBusObject(
+ IN KSDEVICE_HEADER Header
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsDereferenceBusObject(
+ IN KSDEVICE_HEADER Header
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsDispatchQuerySecurity(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsDispatchSetSecurity(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsDispatchSpecificProperty(
+ IN PIRP Irp,
+ IN PFNKSHANDLER Handler
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsDispatchSpecificMethod(
+ IN PIRP Irp,
+ IN PFNKSHANDLER Handler
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsReadFile(
+ IN PFILE_OBJECT FileObject,
+ IN PKEVENT Event OPTIONAL,
+ IN PVOID PortContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ OUT PVOID Buffer,
+ IN ULONG Length,
+ IN ULONG Key OPTIONAL,
+ IN KPROCESSOR_MODE RequestorMode
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsWriteFile(
+ IN PFILE_OBJECT FileObject,
+ IN PKEVENT Event OPTIONAL,
+ IN PVOID PortContext OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN PVOID Buffer,
+ IN ULONG Length,
+ IN ULONG Key OPTIONAL,
+ IN KPROCESSOR_MODE RequestorMode
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsQueryInformationFile(
+ IN PFILE_OBJECT FileObject,
+ OUT PVOID FileInformation,
+ IN ULONG Length,
+ IN FILE_INFORMATION_CLASS FileInformationClass
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsSetInformationFile(
+ IN PFILE_OBJECT FileObject,
+ IN PVOID FileInformation,
+ IN ULONG Length,
+ IN FILE_INFORMATION_CLASS FileInformationClass
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsStreamIo(
+ IN PFILE_OBJECT FileObject,
+ IN PKEVENT Event OPTIONAL,
+ IN PVOID PortContext OPTIONAL,
+ IN PIO_COMPLETION_ROUTINE CompletionRoutine OPTIONAL,
+ IN PVOID CompletionContext OPTIONAL,
+ IN KSCOMPLETION_INVOCATION CompletionInvocationFlags OPTIONAL,
+ OUT PIO_STATUS_BLOCK IoStatusBlock,
+ IN OUT PVOID StreamHeaders,
+ IN ULONG Length,
+ IN ULONG Flags,
+ IN KPROCESSOR_MODE RequestorMode
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsProbeStreamIrp(
+ IN OUT PIRP Irp,
+ IN ULONG ProbeFlags,
+ IN ULONG HeaderSize OPTIONAL
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsAllocateExtraData(
+ IN OUT PIRP Irp,
+ IN ULONG ExtraSize,
+ OUT PVOID* ExtraBuffer
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsNullDriverUnload(
+ IN PDRIVER_OBJECT DriverObject
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsSetMajorFunctionHandler(
+ IN PDRIVER_OBJECT DriverObject,
+ IN ULONG MajorFunction
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsDispatchInvalidDeviceRequest(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsDefaultDeviceIoCompletion(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsDispatchIrp(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+BOOLEAN
+NTAPI
+KsDispatchFastIoDeviceControlFailure(
+ IN PFILE_OBJECT FileObject,
+ IN BOOLEAN Wait,
+ IN PVOID InputBuffer OPTIONAL,
+ IN ULONG InputBufferLength,
+ OUT PVOID OutputBuffer OPTIONAL,
+ IN ULONG OutputBufferLength,
+ IN ULONG IoControlCode,
+ OUT PIO_STATUS_BLOCK IoStatus,
+ IN PDEVICE_OBJECT DeviceObject
+ );
+
+KSDDKAPI
+BOOLEAN
+NTAPI
+KsDispatchFastReadFailure(
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ IN ULONG LockKey,
+ OUT PVOID Buffer,
+ OUT PIO_STATUS_BLOCK IoStatus,
+ IN PDEVICE_OBJECT DeviceObject
+ );
+
+#define KsDispatchFastWriteFailure KsDispatchFastReadFailure
+
+KSDDKAPI
+VOID
+NTAPI
+KsCancelRoutine(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsCancelIo(
+ IN OUT PLIST_ENTRY QueueHead,
+ IN PKSPIN_LOCK SpinLock
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsReleaseIrpOnCancelableQueue(
+ IN PIRP Irp,
+ IN PDRIVER_CANCEL DriverCancel OPTIONAL
+ );
+
+KSDDKAPI
+PIRP
+NTAPI
+KsRemoveIrpFromCancelableQueue(
+ IN OUT PLIST_ENTRY QueueHead,
+ IN PKSPIN_LOCK SpinLock,
+ IN KSLIST_ENTRY_LOCATION ListLocation,
+ IN KSIRP_REMOVAL_OPERATION RemovalOperation
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsMoveIrpsOnCancelableQueue(
+ IN OUT PLIST_ENTRY SourceList,
+ IN PKSPIN_LOCK SourceLock,
+ IN OUT PLIST_ENTRY DestinationList,
+ IN PKSPIN_LOCK DestinationLock OPTIONAL,
+ IN KSLIST_ENTRY_LOCATION ListLocation,
+ IN PFNKSIRPLISTCALLBACK ListCallback,
+ IN PVOID Context
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsRemoveSpecificIrpFromCancelableQueue(
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsAddIrpToCancelableQueue(
+ IN OUT PLIST_ENTRY QueueHead,
+ IN PKSPIN_LOCK SpinLock,
+ IN PIRP Irp,
+ IN KSLIST_ENTRY_LOCATION ListLocation,
+ IN PDRIVER_CANCEL DriverCancel OPTIONAL
+ );
+
+// api.c:
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsAcquireResetValue(
+ IN PIRP Irp,
+ OUT KSRESET* ResetValue
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsTopologyPropertyHandler(
+ IN PIRP Irp,
+ IN PKSPROPERTY Property,
+ IN OUT PVOID Data,
+ IN const KSTOPOLOGY* Topology
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsAcquireDeviceSecurityLock(
+ IN KSDEVICE_HEADER Header,
+ IN BOOLEAN Exclusive
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsReleaseDeviceSecurityLock(
+ IN KSDEVICE_HEADER Header
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsDefaultDispatchPnp(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsDefaultDispatchPower(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsDefaultForwardIrp(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsSetDevicePnpAndBaseObject(
+ IN KSDEVICE_HEADER Header,
+ IN PDEVICE_OBJECT PnpDeviceObject,
+ IN PDEVICE_OBJECT BaseObject
+ );
+
+KSDDKAPI
+PDEVICE_OBJECT
+NTAPI
+KsQueryDevicePnpObject(
+ IN KSDEVICE_HEADER Header
+ );
+
+KSDDKAPI
+ACCESS_MASK
+NTAPI
+KsQueryObjectAccessMask(
+ IN KSOBJECT_HEADER Header
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsRecalculateStackDepth(
+ IN KSDEVICE_HEADER Header,
+ IN BOOLEAN ReuseStackLocation
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsSetTargetState(
+ IN KSOBJECT_HEADER Header,
+ IN KSTARGET_STATE TargetState
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsSetTargetDeviceObject(
+ IN KSOBJECT_HEADER Header,
+ IN PDEVICE_OBJECT TargetDevice OPTIONAL
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsSetPowerDispatch(
+ IN KSOBJECT_HEADER Header,
+ IN PFNKSCONTEXT_DISPATCH PowerDispatch OPTIONAL,
+ IN PVOID PowerContext OPTIONAL
+ );
+
+KSDDKAPI
+PKSOBJECT_CREATE_ITEM
+NTAPI
+KsQueryObjectCreateItem(
+ IN KSOBJECT_HEADER Header
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsAllocateDeviceHeader(
+ OUT KSDEVICE_HEADER* Header,
+ IN ULONG ItemsCount,
+ IN PKSOBJECT_CREATE_ITEM ItemsList OPTIONAL
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsFreeDeviceHeader(
+ IN KSDEVICE_HEADER Header
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsAllocateObjectHeader(
+ OUT KSOBJECT_HEADER* Header,
+ IN ULONG ItemsCount,
+ IN PKSOBJECT_CREATE_ITEM ItemsList OPTIONAL,
+ IN PIRP Irp,
+ IN const KSDISPATCH_TABLE* Table
+ );
+
+KSDDKAPI
+VOID
+NTAPI
+KsFreeObjectHeader(
+ IN KSOBJECT_HEADER Header
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsAddObjectCreateItemToDeviceHeader(
+ IN KSDEVICE_HEADER Header,
+ IN PDRIVER_DISPATCH Create,
+ IN PVOID Context,
+ IN PWCHAR ObjectClass,
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor OPTIONAL
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsAddObjectCreateItemToObjectHeader(
+ IN KSOBJECT_HEADER Header,
+ IN PDRIVER_DISPATCH Create,
+ IN PVOID Context,
+ IN PWCHAR ObjectClass,
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor OPTIONAL
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsAllocateObjectCreateItem(
+ IN KSDEVICE_HEADER Header,
+ IN PKSOBJECT_CREATE_ITEM CreateItem,
+ IN BOOLEAN AllocateEntry,
+ IN PFNKSITEMFREECALLBACK ItemFreeCallback OPTIONAL
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsFreeObjectCreateItem(
+ IN KSDEVICE_HEADER Header,
+ IN PUNICODE_STRING CreateItem
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsFreeObjectCreateItemsByContext(
+ IN KSDEVICE_HEADER Header,
+ IN PVOID Context
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsCreateDefaultSecurity(
+ IN PSECURITY_DESCRIPTOR ParentSecurity OPTIONAL,
+ OUT PSECURITY_DESCRIPTOR* DefaultSecurity
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsForwardIrp(
+ IN PIRP Irp,
+ IN PFILE_OBJECT FileObject,
+ IN BOOLEAN ReuseStackLocation
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsForwardAndCatchIrp(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp,
+ IN PFILE_OBJECT FileObject,
+ IN KSSTACK_USE StackUse
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsSynchronousIoControlDevice(
+ IN PFILE_OBJECT FileObject,
+ IN KPROCESSOR_MODE RequestorMode,
+ IN ULONG IoControl,
+ IN PVOID InBuffer,
+ IN ULONG InSize,
+ OUT PVOID OutBuffer,
+ IN ULONG OutSize,
+ OUT PULONG BytesReturned
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsUnserializeObjectPropertiesFromRegistry(
+ IN PFILE_OBJECT FileObject,
+ IN HANDLE ParentKey OPTIONAL,
+ IN PUNICODE_STRING RegistryPath OPTIONAL
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsCacheMedium(
+ IN PUNICODE_STRING SymbolicLink,
+ IN PKSPIN_MEDIUM Medium,
+ IN ULONG PinDirection
+ );
+
+// thread.c:
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsRegisterWorker(
+ IN WORK_QUEUE_TYPE WorkQueueType,
+ OUT PKSWORKER* Worker
+ );
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsRegisterCountedWorker(
+ IN WORK_QUEUE_TYPE WorkQueueType,
+ IN PWORK_QUEUE_ITEM CountedWorkItem,
+ OUT PKSWORKER* Worker
+ );
+KSDDKAPI
+VOID
+NTAPI
+KsUnregisterWorker(
+ IN PKSWORKER Worker
+ );
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsQueueWorkItem(
+ IN PKSWORKER Worker,
+ IN PWORK_QUEUE_ITEM WorkItem
+ );
+KSDDKAPI
+ULONG
+NTAPI
+KsIncrementCountedWorker(
+ IN PKSWORKER Worker
+ );
+KSDDKAPI
+ULONG
+NTAPI
+KsDecrementCountedWorker(
+ IN PKSWORKER Worker
+ );
+
+// topology.c:
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsCreateTopologyNode(
+ IN HANDLE ParentHandle,
+ IN PKSNODE_CREATE NodeCreate,
+ IN ACCESS_MASK DesiredAccess,
+ OUT PHANDLE NodeHandle
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsValidateTopologyNodeCreateRequest(
+ IN PIRP Irp,
+ IN PKSTOPOLOGY Topology,
+ OUT PKSNODE_CREATE* NodeCreate
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsMergeAutomationTables(
+ OUT PKSAUTOMATION_TABLE* AutomationTableAB,
+ IN PKSAUTOMATION_TABLE AutomationTableA OPTIONAL,
+ IN PKSAUTOMATION_TABLE AutomationTableB OPTIONAL,
+ IN KSOBJECT_BAG Bag OPTIONAL
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsInitializeDriver(
+ IN PDRIVER_OBJECT DriverObject,
+ IN PUNICODE_STRING RegistryPathName,
+ IN const KSDEVICE_DESCRIPTOR* Descriptor OPTIONAL
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsAddDevice(
+ IN PDRIVER_OBJECT DriverObject,
+ IN PDEVICE_OBJECT PhysicalDeviceObject
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsCreateDevice(
+ IN PDRIVER_OBJECT DriverObject,
+ IN PDEVICE_OBJECT PhysicalDeviceObject,
+ IN const KSDEVICE_DESCRIPTOR* Descriptor OPTIONAL,
+ IN ULONG ExtensionSize OPTIONAL,
+ OUT PKSDEVICE* Device OPTIONAL
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsInitializeDevice(
+ IN PDEVICE_OBJECT FunctionalDeviceObject,
+ IN PDEVICE_OBJECT PhysicalDeviceObject,
+ IN PDEVICE_OBJECT NextDeviceObject,
+ IN const KSDEVICE_DESCRIPTOR* Descriptor OPTIONAL
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsTerminateDevice(
+ IN PDEVICE_OBJECT DeviceObject
+ );
+
+KSDDKAPI
+PKSDEVICE
+NTAPI
+KsGetDeviceForDeviceObject(
+ IN PDEVICE_OBJECT FunctionalDeviceObject
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsAcquireDevice(
+ IN PKSDEVICE Device
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsReleaseDevice(
+ IN PKSDEVICE Device
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsDeviceRegisterAdapterObject(
+ IN PKSDEVICE Device,
+ IN PADAPTER_OBJECT AdapterObject,
+ IN ULONG MaxMappingsByteCount,
+ IN ULONG MappingTableStride
+ );
+
+KSDDKAPI
+ULONG
+NTAPI
+KsDeviceGetBusData(
+ IN PKSDEVICE Device,
+ IN ULONG DataType,
+ IN PVOID Buffer,
+ IN ULONG Offset,
+ IN ULONG Length
+ );
+
+KSDDKAPI
+ULONG
+NTAPI
+KsDeviceSetBusData(
+ IN PKSDEVICE Device,
+ IN ULONG DataType,
+ IN PVOID Buffer,
+ IN ULONG Offset,
+ IN ULONG Length
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsCreateFilterFactory(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN const KSFILTER_DESCRIPTOR* Descriptor,
+ IN PWCHAR RefString OPTIONAL,
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor OPTIONAL,
+ IN ULONG CreateItemFlags,
+ IN PFNKSFILTERFACTORYPOWER SleepCallback OPTIONAL,
+ IN PFNKSFILTERFACTORYPOWER WakeCallback OPTIONAL,
+ OUT PKSFILTERFACTORY* FilterFactory OPTIONAL
+ );
+
+#define KsDeleteFilterFactory(FilterFactory) \
+ KsFreeObjectCreateItemsByContext(\
+ *(KSDEVICE_HEADER *)(\
+ KsFilterFactoryGetParentDevice(FilterFactory)->FunctionalDeviceObject->\
+ DeviceExtension),\
+ FilterFactory)
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsFilterFactoryUpdateCacheData(
+ IN PKSFILTERFACTORY FilterFactory,
+ IN const KSFILTER_DESCRIPTOR *FilterDescriptor OPTIONAL
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsFilterFactoryAddCreateItem(
+ IN PKSFILTERFACTORY FilterFactory,
+ IN PWCHAR RefString,
+ IN PSECURITY_DESCRIPTOR SecurityDescriptor OPTIONAL,
+ IN ULONG CreateItemFlags
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsFilterFactorySetDeviceClassesState(
+ IN PKSFILTERFACTORY FilterFactory,
+ IN BOOLEAN NewState
+ );
+
+KSDDKAPI
+PUNICODE_STRING
+NTAPI
+KsFilterFactoryGetSymbolicLink(
+ IN PKSFILTERFACTORY FilterFactory
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsAddEvent(
+ IN PVOID Object,
+ IN PKSEVENT_ENTRY EventEntry
+ );
+
+void _inline
+KsFilterAddEvent(
+ IN PKSFILTER Filter,
+ IN PKSEVENT_ENTRY EventEntry
+ )
+{
+ KsAddEvent(Filter,EventEntry);
+}
+
+void _inline
+KsPinAddEvent(
+ IN PKSPIN Pin,
+ IN PKSEVENT_ENTRY EventEntry
+ )
+{
+ KsAddEvent(Pin,EventEntry);
+}
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsDefaultAddEventHandler(
+ IN PIRP Irp,
+ IN PKSEVENTDATA EventData,
+ IN OUT PKSEVENT_ENTRY EventEntry
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsGenerateEvents(
+ IN PVOID Object,
+ IN const GUID* EventSet OPTIONAL,
+ IN ULONG EventId,
+ IN ULONG DataSize,
+ IN PVOID Data OPTIONAL,
+ IN PFNKSGENERATEEVENTCALLBACK CallBack OPTIONAL,
+ IN PVOID CallBackContext OPTIONAL
+ );
+
+void _inline
+KsFilterGenerateEvents(
+ IN PKSFILTER Filter,
+ IN const GUID* EventSet OPTIONAL,
+ IN ULONG EventId,
+ IN ULONG DataSize,
+ IN PVOID Data OPTIONAL,
+ IN PFNKSGENERATEEVENTCALLBACK CallBack OPTIONAL,
+ IN PVOID CallBackContext OPTIONAL
+ )
+{
+ KsGenerateEvents(
+ Filter,
+ EventSet,
+ EventId,
+ DataSize,
+ Data,
+ CallBack,
+ CallBackContext);
+}
+
+void _inline
+KsPinGenerateEvents(
+ IN PKSPIN Pin,
+ IN const GUID* EventSet OPTIONAL,
+ IN ULONG EventId,
+ IN ULONG DataSize,
+ IN PVOID Data OPTIONAL,
+ IN PFNKSGENERATEEVENTCALLBACK CallBack OPTIONAL,
+ IN PVOID CallBackContext OPTIONAL
+ )
+{
+ KsGenerateEvents(
+ Pin,
+ EventSet,
+ EventId,
+ DataSize,
+ Data,
+ CallBack,
+ CallBackContext);
+}
+
+typedef enum {
+ KSSTREAM_POINTER_STATE_UNLOCKED = 0,
+ KSSTREAM_POINTER_STATE_LOCKED
+} KSSTREAM_POINTER_STATE;
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsPinGetAvailableByteCount(
+ IN PKSPIN Pin,
+ OUT PLONG InputDataBytes OPTIONAL,
+ OUT PLONG OutputBufferBytes OPTIONAL
+ );
+
+KSDDKAPI
+PKSSTREAM_POINTER
+NTAPI
+KsPinGetLeadingEdgeStreamPointer(
+ IN PKSPIN Pin,
+ IN KSSTREAM_POINTER_STATE State
+ );
+
+KSDDKAPI
+PKSSTREAM_POINTER
+NTAPI
+KsPinGetTrailingEdgeStreamPointer(
+ IN PKSPIN Pin,
+ IN KSSTREAM_POINTER_STATE State
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsStreamPointerSetStatusCode(
+ IN PKSSTREAM_POINTER StreamPointer,
+ IN NTSTATUS Status
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsStreamPointerLock(
+ IN PKSSTREAM_POINTER StreamPointer
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsStreamPointerUnlock(
+ IN PKSSTREAM_POINTER StreamPointer,
+ IN BOOLEAN Eject
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsStreamPointerAdvanceOffsetsAndUnlock(
+ IN PKSSTREAM_POINTER StreamPointer,
+ IN ULONG InUsed,
+ IN ULONG OutUsed,
+ IN BOOLEAN Eject
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsStreamPointerDelete(
+ IN PKSSTREAM_POINTER StreamPointer
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsStreamPointerClone(
+ IN PKSSTREAM_POINTER StreamPointer,
+ IN PFNKSSTREAMPOINTER CancelCallback OPTIONAL,
+ IN ULONG ContextSize,
+ OUT PKSSTREAM_POINTER* CloneStreamPointer
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsStreamPointerAdvanceOffsets(
+ IN PKSSTREAM_POINTER StreamPointer,
+ IN ULONG InUsed,
+ IN ULONG OutUsed,
+ IN BOOLEAN Eject
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsStreamPointerAdvance(
+ IN PKSSTREAM_POINTER StreamPointer
+ );
+
+KSDDKAPI
+PMDL
+NTAPI
+KsStreamPointerGetMdl(
+ IN PKSSTREAM_POINTER StreamPointer
+ );
+
+KSDDKAPI
+PIRP
+NTAPI
+KsStreamPointerGetIrp(
+ IN PKSSTREAM_POINTER StreamPointer,
+ OUT PBOOLEAN FirstFrameInIrp OPTIONAL,
+ OUT PBOOLEAN LastFrameInIrp OPTIONAL
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsStreamPointerScheduleTimeout(
+ IN PKSSTREAM_POINTER StreamPointer,
+ IN PFNKSSTREAMPOINTER Callback,
+ IN ULONGLONG Interval
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsStreamPointerCancelTimeout(
+ IN PKSSTREAM_POINTER StreamPointer
+ );
+
+KSDDKAPI
+PKSSTREAM_POINTER
+NTAPI
+KsPinGetFirstCloneStreamPointer(
+ IN PKSPIN Pin
+ );
+
+KSDDKAPI
+PKSSTREAM_POINTER
+NTAPI
+KsStreamPointerGetNextClone(
+ IN PKSSTREAM_POINTER StreamPointer
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsPinHandshake(
+ IN PKSPIN Pin,
+ IN PKSHANDSHAKE In,
+ OUT PKSHANDSHAKE Out
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsCompletePendingRequest(
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+KSOBJECTTYPE
+NTAPI
+KsGetObjectTypeFromIrp(
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+PVOID
+NTAPI
+KsGetObjectFromFileObject(
+ IN PFILE_OBJECT FileObject
+ );
+
+KSDDKAPI
+KSOBJECTTYPE
+NTAPI
+KsGetObjectTypeFromFileObject(
+ IN PFILE_OBJECT FileObject
+ );
+
+PKSFILTER __inline
+KsGetFilterFromFileObject(
+ IN PFILE_OBJECT FileObject
+ )
+{
+ return (PKSFILTER) KsGetObjectFromFileObject(FileObject);
+}
+
+PKSPIN __inline
+KsGetPinFromFileObject(
+ IN PFILE_OBJECT FileObject
+ )
+{
+ return (PKSPIN) KsGetObjectFromFileObject(FileObject);
+}
+
+KSDDKAPI
+PKSGATE
+NTAPI
+KsFilterGetAndGate(
+ IN PKSFILTER Filter
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsFilterAcquireProcessingMutex(
+ IN PKSFILTER Filter
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsFilterReleaseProcessingMutex(
+ IN PKSFILTER Filter
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsFilterAttemptProcessing(
+ IN PKSFILTER Filter,
+ IN BOOLEAN Asynchronous
+ );
+
+KSDDKAPI
+PKSGATE
+NTAPI
+KsPinGetAndGate(
+ IN PKSPIN Pin
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsPinAttachAndGate(
+ IN PKSPIN Pin,
+ IN PKSGATE AndGate OPTIONAL
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsPinAttachOrGate(
+ IN PKSPIN Pin,
+ IN PKSGATE OrGate OPTIONAL
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsPinAcquireProcessingMutex(
+ IN PKSPIN Pin
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsPinReleaseProcessingMutex(
+ IN PKSPIN Pin
+ );
+
+KSDDKAPI
+BOOLEAN
+NTAPI
+KsProcessPinUpdate(
+ IN PKSPROCESSPIN ProcessPin
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsPinGetCopyRelationships(
+ IN PKSPIN Pin,
+ OUT PKSPIN* CopySource,
+ OUT PKSPIN* DelegateBranch
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsPinAttemptProcessing(
+ IN PKSPIN Pin,
+ IN BOOLEAN Asynchronous
+ );
+
+KSDDKAPI
+PVOID
+NTAPI
+KsGetParent(
+ IN PVOID Object
+ );
+
+PKSDEVICE __inline
+KsFilterFactoryGetParentDevice(
+ IN PKSFILTERFACTORY FilterFactory
+ )
+{
+ return (PKSDEVICE) KsGetParent((PVOID) FilterFactory);
+}
+
+PKSFILTERFACTORY __inline
+KsFilterGetParentFilterFactory(
+ IN PKSFILTER Filter
+ )
+{
+ return (PKSFILTERFACTORY) KsGetParent((PVOID) Filter);
+}
+
+KSDDKAPI
+PKSFILTER
+NTAPI
+KsPinGetParentFilter(
+ IN PKSPIN Pin
+ );
+
+KSDDKAPI
+PVOID
+NTAPI
+KsGetFirstChild(
+ IN PVOID Object
+ );
+
+PKSFILTERFACTORY __inline
+KsDeviceGetFirstChildFilterFactory(
+ IN PKSDEVICE Device
+ )
+{
+ return (PKSFILTERFACTORY) KsGetFirstChild((PVOID) Device);
+}
+
+PKSFILTER __inline
+KsFilterFactoryGetFirstChildFilter(
+ IN PKSFILTERFACTORY FilterFactory
+ )
+{
+ return (PKSFILTER) KsGetFirstChild((PVOID) FilterFactory);
+}
+
+KSDDKAPI
+ULONG
+NTAPI
+KsFilterGetChildPinCount(
+ IN PKSFILTER Filter,
+ IN ULONG PinId
+ );
+
+KSDDKAPI
+PKSPIN
+NTAPI
+KsFilterGetFirstChildPin(
+ IN PKSFILTER Filter,
+ IN ULONG PinId
+ );
+
+KSDDKAPI
+PVOID
+NTAPI
+KsGetNextSibling(
+ IN PVOID Object
+ );
+
+KSDDKAPI
+PKSPIN
+NTAPI
+KsPinGetNextSiblingPin(
+ IN PKSPIN Pin
+ );
+
+PKSFILTERFACTORY __inline
+KsFilterFactoryGetNextSiblingFilterFactory(
+ IN PKSFILTERFACTORY FilterFactory
+ )
+{
+ return (PKSFILTERFACTORY) KsGetNextSibling((PVOID) FilterFactory);
+}
+
+PKSFILTER __inline
+KsFilterGetNextSiblingFilter(
+ IN PKSFILTER Filter
+ )
+{
+ return (PKSFILTER) KsGetNextSibling((PVOID) Filter);
+}
+
+
+KSDDKAPI
+PKSDEVICE
+NTAPI
+KsGetDevice(
+ IN PVOID Object
+ );
+
+PKSDEVICE __inline
+KsFilterFactoryGetDevice(
+ IN PKSFILTERFACTORY FilterFactory
+ )
+{
+ return KsGetDevice((PVOID) FilterFactory);
+}
+
+PKSDEVICE __inline
+KsFilterGetDevice(
+ IN PKSFILTER Filter
+ )
+{
+ return KsGetDevice((PVOID) Filter);
+}
+
+PKSDEVICE __inline
+KsPinGetDevice(
+ IN PKSPIN Pin
+ )
+{
+ return KsGetDevice((PVOID) Pin);
+}
+
+KSDDKAPI
+PKSFILTER
+NTAPI
+KsGetFilterFromIrp(
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+PKSPIN
+NTAPI
+KsGetPinFromIrp(
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+ULONG
+NTAPI
+KsGetNodeIdFromIrp(
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsAcquireControl(
+ IN PVOID Object
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsReleaseControl(
+ IN PVOID Object
+ );
+
+void __inline
+KsFilterAcquireControl(
+ IN PKSFILTER Filter
+ )
+{
+ KsAcquireControl((PVOID) Filter);
+}
+
+void __inline
+KsFilterReleaseControl(
+ IN PKSFILTER Filter
+ )
+{
+ KsReleaseControl((PVOID) Filter);
+}
+
+void __inline
+KsPinAcquireControl(
+ IN PKSPIN Pin
+ )
+{
+ KsAcquireControl((PVOID) Pin);
+}
+
+void __inline
+KsPinReleaseControl(
+ IN PKSPIN Pin
+ )
+{
+ KsReleaseControl((PVOID) Pin);
+}
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsAddItemToObjectBag(
+ IN KSOBJECT_BAG ObjectBag,
+ IN PVOID Item,
+ IN PFNKSFREE Free OPTIONAL
+ );
+
+KSDDKAPI
+ULONG
+NTAPI
+KsRemoveItemFromObjectBag(
+ IN KSOBJECT_BAG ObjectBag,
+ IN PVOID Item,
+ IN BOOLEAN Free
+ );
+
+#define KsDiscard(Object,Pointer)\
+ KsRemoveItemFromObjectBag(\
+ (Object)->Bag,\
+ (PVOID)(Pointer),\
+ TRUE)
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsAllocateObjectBag(
+ IN PKSDEVICE Device,
+ OUT KSOBJECT_BAG* ObjectBag
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsFreeObjectBag(
+ IN KSOBJECT_BAG ObjectBag
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsCopyObjectBagItems(
+ IN KSOBJECT_BAG ObjectBagDestination,
+ IN KSOBJECT_BAG ObjectBagSource
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+_KsEdit(
+ IN KSOBJECT_BAG ObjectBag,
+ IN OUT PVOID* PointerToPointerToItem,
+ IN ULONG NewSize,
+ IN ULONG OldSize,
+ IN ULONG Tag
+ );
+
+#define KsEdit(Object,PointerToPointer,Tag)\
+ _KsEdit(\
+ (Object)->Bag,\
+ (PVOID*)(PointerToPointer),\
+ sizeof(**(PointerToPointer)),\
+ sizeof(**(PointerToPointer)),\
+ (Tag))
+#define KsEditSized(Object,PointerToPointer,NewSize,OldSize,Tag)\
+ _KsEdit((Object)->Bag,(PVOID*)(PointerToPointer),(NewSize),(OldSize),(Tag))
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsRegisterFilterWithNoKSPins(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN const GUID * InterfaceClassGUID,
+ IN ULONG PinCount,
+ IN BOOL * PinDirection,
+ IN KSPIN_MEDIUM * MediumList,
+ IN OPTIONAL GUID * CategoryList
+);
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsFilterCreatePinFactory (
+ IN PKSFILTER Filter,
+ IN const KSPIN_DESCRIPTOR_EX *const PinDescriptor,
+ OUT PULONG PinID
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsFilterCreateNode (
+ IN PKSFILTER Filter,
+ IN const KSNODE_DESCRIPTOR *const NodeDescriptor,
+ OUT PULONG NodeID
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsFilterAddTopologyConnections (
+ IN PKSFILTER Filter,
+ IN ULONG NewConnectionsCount,
+ IN const KSTOPOLOGY_CONNECTION *const NewTopologyConnections
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsPinGetConnectedPinInterface(
+ IN PKSPIN Pin,
+ IN const GUID* InterfaceId,
+ OUT PVOID* Interface
+ );
+
+KSDDKAPI
+PFILE_OBJECT
+NTAPI
+KsPinGetConnectedPinFileObject(
+ IN PKSPIN Pin
+ );
+
+KSDDKAPI
+PDEVICE_OBJECT
+NTAPI
+KsPinGetConnectedPinDeviceObject(
+ IN PKSPIN Pin
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsPinGetConnectedFilterInterface(
+ IN PKSPIN Pin,
+ IN const GUID* InterfaceId,
+ OUT PVOID* Interface
+ );
+
+#if defined(_UNKNOWN_H_) || defined(__IUnknown_INTERFACE_DEFINED__)
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsPinGetReferenceClockInterface(
+ IN PKSPIN Pin,
+ OUT PIKSREFERENCECLOCK* Interface
+ );
+
+#endif //defined(_UNKNOWN_H_) || defined(__IUnknown_INTERFACE_DEFINED__)
+
+KSDDKAPI
+VOID
+NTAPI
+KsPinSetPinClockTime(
+ IN PKSPIN Pin,
+ IN LONGLONG Time
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsPinSubmitFrame(
+ IN PKSPIN Pin,
+ IN PVOID Data OPTIONAL,
+ IN ULONG Size OPTIONAL,
+ IN PKSSTREAM_HEADER StreamHeader OPTIONAL,
+ IN PVOID Context OPTIONAL
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsPinSubmitFrameMdl(
+ IN PKSPIN Pin,
+ IN PMDL Mdl OPTIONAL,
+ IN PKSSTREAM_HEADER StreamHeader OPTIONAL,
+ IN PVOID Context OPTIONAL
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsPinRegisterFrameReturnCallback(
+ IN PKSPIN Pin,
+ IN PFNKSPINFRAMERETURN FrameReturn
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsPinRegisterIrpCompletionCallback(
+ IN PKSPIN Pin,
+ IN PFNKSPINIRPCOMPLETION IrpCompletion
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsPinRegisterHandshakeCallback(
+ IN PKSPIN Pin,
+ IN PFNKSPINHANDSHAKE Handshake
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsFilterRegisterPowerCallbacks(
+ IN PKSFILTER Filter,
+ IN PFNKSFILTERPOWER Sleep OPTIONAL,
+ IN PFNKSFILTERPOWER Wake OPTIONAL
+ );
+
+KSDDKAPI
+void
+NTAPI
+KsPinRegisterPowerCallbacks(
+ IN PKSPIN Pin,
+ IN PFNKSPINPOWER Sleep OPTIONAL,
+ IN PFNKSPINPOWER Wake OPTIONAL
+ );
+
+#if defined(_UNKNOWN_H_) || defined(__IUnknown_INTERFACE_DEFINED__)
+
+KSDDKAPI
+PUNKNOWN
+NTAPI
+KsRegisterAggregatedClientUnknown(
+ IN PVOID Object,
+ IN PUNKNOWN ClientUnknown
+ );
+
+KSDDKAPI
+PUNKNOWN
+NTAPI
+KsGetOuterUnknown(
+ IN PVOID Object
+ );
+
+PUNKNOWN __inline
+KsDeviceRegisterAggregatedClientUnknown(
+ IN PKSDEVICE Device,
+ IN PUNKNOWN ClientUnknown
+ )
+{
+ return KsRegisterAggregatedClientUnknown((PVOID) Device,ClientUnknown);
+}
+
+PUNKNOWN __inline
+KsDeviceGetOuterUnknown(
+ IN PKSDEVICE Device
+ )
+{
+ return KsGetOuterUnknown((PVOID) Device);
+}
+
+PUNKNOWN __inline
+KsFilterFactoryRegisterAggregatedClientUnknown(
+ IN PKSFILTERFACTORY FilterFactory,
+ IN PUNKNOWN ClientUnknown
+ )
+{
+ return KsRegisterAggregatedClientUnknown((PVOID) FilterFactory,ClientUnknown);
+}
+
+PUNKNOWN __inline
+KsFilterFactoryGetOuterUnknown(
+ IN PKSFILTERFACTORY FilterFactory
+ )
+{
+ return KsGetOuterUnknown((PVOID) FilterFactory);
+}
+
+PUNKNOWN __inline
+KsFilterRegisterAggregatedClientUnknown(
+ IN PKSFILTER Filter,
+ IN PUNKNOWN ClientUnknown
+ )
+{
+ return KsRegisterAggregatedClientUnknown((PVOID) Filter,ClientUnknown);
+}
+
+PUNKNOWN __inline
+KsFilterGetOuterUnknown(
+ IN PKSFILTER Filter
+ )
+{
+ return KsGetOuterUnknown((PVOID) Filter);
+}
+
+PUNKNOWN __inline
+KsPinRegisterAggregatedClientUnknown(
+ IN PKSPIN Pin,
+ IN PUNKNOWN ClientUnknown
+ )
+{
+ return KsRegisterAggregatedClientUnknown((PVOID) Pin,ClientUnknown);
+}
+
+PUNKNOWN __inline
+KsPinGetOuterUnknown(
+ IN PKSPIN Pin
+ )
+{
+ return KsGetOuterUnknown((PVOID) Pin);
+}
+
+#endif // defined(_UNKNOWN_H_) || defined(__IUnknown_INTERFACE_DEFINED__)
+
+#else // !defined(_NTDDK_)
+
+#if !defined( KS_NO_CREATE_FUNCTIONS )
+
+KSDDKAPI
+DWORD
+WINAPI
+KsCreateAllocator(
+ IN HANDLE ConnectionHandle,
+ IN PKSALLOCATOR_FRAMING AllocatorFraming,
+ OUT PHANDLE AllocatorHandle
+ );
+
+KSDDKAPI
+DWORD
+NTAPI
+KsCreateClock(
+ IN HANDLE ConnectionHandle,
+ IN PKSCLOCK_CREATE ClockCreate,
+ OUT PHANDLE ClockHandle
+ );
+
+KSDDKAPI
+DWORD
+WINAPI
+KsCreatePin(
+ IN HANDLE FilterHandle,
+ IN PKSPIN_CONNECT Connect,
+ IN ACCESS_MASK DesiredAccess,
+ OUT PHANDLE ConnectionHandle
+ );
+
+KSDDKAPI
+DWORD
+WINAPI
+KsCreateTopologyNode(
+ IN HANDLE ParentHandle,
+ IN PKSNODE_CREATE NodeCreate,
+ IN ACCESS_MASK DesiredAccess,
+ OUT PHANDLE NodeHandle
+ );
+
+#endif
+
+#endif // !defined(_NTDDK_)
+
+#if defined(__cplusplus)
+}
+#endif // defined(__cplusplus)
+
+
+#define DENY_USERMODE_ACCESS( pIrp, CompleteRequest ) \
+if ( pIrp->RequestorMode != KernelMode ) { \
+ pIrp->IoStatus.Information = 0; \
+ pIrp->IoStatus.Status = STATUS_INVALID_DEVICE_REQUEST; \
+ if ( CompleteRequest ) IoCompleteRequest ( pIrp, IO_NO_INCREMENT ); \
+ return STATUS_INVALID_DEVICE_REQUEST; \
+}
+
+
+#endif // !_KS_
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-09 03:03:55 +0100