diff options
author | sanine <sanine.not@pm.me> | 2022-08-25 14:54:53 -0500 |
---|---|---|
committer | sanine <sanine.not@pm.me> | 2022-08-25 14:54:53 -0500 |
commit | 37c97e345d12f95dde44e1d1a4c2f2aadd4615bc (patch) | |
tree | e1bb25bc855883062bdd7847ff2c04290f71c840 /portaudio/src/hostapi/wasapi/mingw-include/ks.h | |
parent | 5634c7b04da619669f2f29f6798c03982be05180 (diff) |
add initial structure
Diffstat (limited to 'portaudio/src/hostapi/wasapi/mingw-include/ks.h')
-rw-r--r-- | portaudio/src/hostapi/wasapi/mingw-include/ks.h | 3666 |
1 files changed, 3666 insertions, 0 deletions
diff --git a/portaudio/src/hostapi/wasapi/mingw-include/ks.h b/portaudio/src/hostapi/wasapi/mingw-include/ks.h new file mode 100644 index 0000000..2261e6c --- /dev/null +++ b/portaudio/src/hostapi/wasapi/mingw-include/ks.h @@ -0,0 +1,3666 @@ +/** + * This file has no copyright assigned and is placed in the Public Domain. + * This file is part of the w64 mingw-runtime package. + * No warranty is given; refer to the file DISCLAIMER.PD within this package. + */ +#ifndef _KS_ +#define _KS_ + +#if __GNUC__ >= 3 +#pragma GCC system_header +#endif + +#ifndef __MINGW_EXTENSION +#if defined(__GNUC__) || defined(__GNUG__) +#define __MINGW_EXTENSION __extension__ +#else +#define __MINGW_EXTENSION +#endif +#endif + +#ifdef __TCS__ +#define _KS_NO_ANONYMOUS_STRUCTURES_ 1 +#endif + +#ifdef _KS_NO_ANONYMOUS_STRUCTURES_ +#define _KS_ANON_STRUCT(X) struct X +#else +#define _KS_ANON_STRUCT(X) __MINGW_EXTENSION struct +#endif + +#ifndef _NTRTL_ +#ifndef DEFINE_GUIDEX +#define DEFINE_GUIDEX(name) EXTERN_C const CDECL GUID name +#endif +#ifndef STATICGUIDOF +#define STATICGUIDOF(guid) STATIC_##guid +#endif +#endif /* _NTRTL_ */ + +#ifndef SIZEOF_ARRAY +#define SIZEOF_ARRAY(ar) (sizeof(ar)/sizeof((ar)[0])) +#endif + +#define DEFINE_GUIDSTRUCT(g,n) DEFINE_GUIDEX(n) +#define DEFINE_GUIDNAMED(n) n + +#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 { + __MINGW_EXTENSION union { + _KS_ANON_STRUCT(_IDENTIFIER) + { + 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) + +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 { + _KS_ANON_STRUCT(_SIGNED) + { + LONG SignedMinimum; + LONG SignedMaximum; + }; + _KS_ANON_STRUCT(_UNSIGNED) + { + ULONG UnsignedMinimum; + ULONG UnsignedMaximum; + }; +} KSPROPERTY_BOUNDS_LONG,*PKSPROPERTY_BOUNDS_LONG; + +typedef union { + _KS_ANON_STRUCT(_SIGNED64) + { + LONGLONG SignedMinimum; + LONGLONG SignedMaximum; + }; + _KS_ANON_STRUCT(_UNSIGNED64) + { + DWORDLONG UnsignedMinimum; + DWORDLONG UnsignedMaximum; + }; +} KSPROPERTY_BOUNDS_LONGLONG,*PKSPROPERTY_BOUNDS_LONGLONG; + +typedef struct { + ULONG SteppingDelta; + ULONG Reserved; + KSPROPERTY_BOUNDS_LONG Bounds; +} KSPROPERTY_STEPPING_LONG,*PKSPROPERTY_STEPPING_LONG; + +typedef struct { + DWORDLONG SteppingDelta; + KSPROPERTY_BOUNDS_LONGLONG Bounds; +} KSPROPERTY_STEPPING_LONGLONG,*PKSPROPERTY_STEPPING_LONGLONG; + +#if defined(_NTDDK_) +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; + __MINGW_EXTENSION 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; +#endif /* _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 +#endif /* _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; + __MINGW_EXTENSION 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) \ +} + +#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) + +#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; + +#define STATIC_KSTIME_FORMAT_NONE STATIC_GUID_NULL +#define KSTIME_FORMAT_NONE GUID_NULL + +#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) + +#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) + +#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) + +#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) + +#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) + +#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) + +typedef union { + __MINGW_EXTENSION struct { + ULONG FormatSize; + ULONG Flags; + ULONG SampleSize; + ULONG Reserved; + GUID MajorFormat; + GUID SubFormat; + GUID Specifier; + }; + LONGLONG Alignment; +} KSDATAFORMAT,*PKSDATAFORMAT,KSDATARANGE,*PKSDATARANGE; + +#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) ( PIRP Irp, PKSP_PIN Pin, + PKSDATARANGE DataRange, + PVOID Data); +typedef NTSTATUS (*PFNKSINTERSECTHANDLEREX)(PVOID Context, PIRP Irp, + PKSP_PIN Pin, + PKSDATARANGE DataRange, + PKSDATARANGE MatchingDataRange, + ULONG DataBufferSize, + PVOID Data, + 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; + __MINGW_EXTENSION union { + LONGLONG Reserved; + __MINGW_EXTENSION 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 /* _NTDDK_ */ + +#define STATIC_KSDATAFORMAT_TYPE_WILDCARD STATIC_GUID_NULL +#define KSDATAFORMAT_TYPE_WILDCARD GUID_NULL + +#define STATIC_KSDATAFORMAT_SUBTYPE_WILDCARD STATIC_GUID_NULL +#define KSDATAFORMAT_SUBTYPE_WILDCARD GUID_NULL + +#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) + +#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) + +#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) + +#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 + +#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 +#define KSALLOCATOR_FLAG_NO_FRAME_INTEGRITY 0x00000100 +#define KSALLOCATOR_FLAG_MULTIPLE_OUTPUT 0x00000200 +#define KSALLOCATOR_FLAG_CYCLE 0x00000400 +#define KSALLOCATOR_FLAG_ALLOCATOR_EXISTS 0x00000800 +#define KSALLOCATOR_FLAG_INDEPENDENT_RANGES 0x00001000 +#define KSALLOCATOR_FLAG_ATTENTION_STEPPING 0x00002000 + +typedef struct { + __MINGW_EXTENSION union { + ULONG OptionsFlags; + ULONG RequirementsFlags; + }; +#if defined(_NTDDK_) + POOL_TYPE PoolType; +#else + ULONG PoolType; +#endif /* _NTDDK_ */ + ULONG Frames; + ULONG FrameSize; + ULONG FileAlignment; + ULONG Reserved; +} KSALLOCATOR_FRAMING,*PKSALLOCATOR_FRAMING; + +#if defined(_NTDDK_) +typedef PVOID (*PFNKSDEFAULTALLOCATE)(PVOID Context); +typedef VOID (*PFNKSDEFAULTFREE)(PVOID Context, PVOID Buffer); +typedef NTSTATUS (*PFNKSINITIALIZEALLOCATOR)(PVOID InitialContext, + PKSALLOCATOR_FRAMING AllocatorFraming, + PVOID* Context); +typedef VOID (*PFNKSDELETEALLOCATOR) (PVOID Context); +#endif /* _NTDDK_ */ + +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; + ULONG RatioDenominator; + ULONG RatioConstantMargin; +} KS_COMPRESSION,*PKS_COMPRESSION; + +typedef struct { + GUID MemoryType; + GUID BusType; + ULONG MemoryFlags; + ULONG BusFlags; + ULONG Flags; + ULONG Frames; + ULONG FileAlignment; + ULONG MemoryTypeWeight; + KS_FRAMING_RANGE PhysicalRange; + KS_FRAMING_RANGE_WEIGHTED FramingRange; +} KS_FRAMING_ITEM,*PKS_FRAMING_ITEM; + +typedef struct { + ULONG CountItems; + ULONG PinFlags; + KS_COMPRESSION OutputCompression; + ULONG PinWeight; + KS_FRAMING_ITEM FramingItem[1]; +} KSALLOCATOR_FRAMING_EX,*PKSALLOCATOR_FRAMING_EX; + +#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) + +#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) + +#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); \ +} + +#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) (PFILE_OBJECT FileObject, + PVOID *Frame); +typedef VOID (*PFNALLOCATOR_FREEFRAME) (PFILE_OBJECT FileObject, PVOID Frame); + +typedef struct { + PFNALLOCATOR_ALLOCATEFRAME AllocateFrame; + PFNALLOCATOR_FREEFRAME FreeFrame; +} KSSTREAMALLOCATOR_FUNCTIONTABLE, *PKSSTREAMALLOCATOR_FUNCTIONTABLE; +#endif /* _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; +#ifdef _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) + +#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 /* _NTDDK_ */ +} KSPROPERTY_CLOCK; + +#if defined(_NTDDK_) +typedef LONGLONG (FASTCALL *PFNKSCLOCK_GETTIME)(PFILE_OBJECT FileObject); +typedef LONGLONG (FASTCALL *PFNKSCLOCK_CORRELATEDTIME)(PFILE_OBJECT FileObject, + PLONGLONG SystemTime); + +typedef struct { + PFNKSCLOCK_GETTIME GetTime; + PFNKSCLOCK_GETTIME GetPhysicalTime; + PFNKSCLOCK_CORRELATEDTIME GetCorrelatedTime; + PFNKSCLOCK_CORRELATEDTIME GetCorrelatedPhysicalTime; +} KSCLOCK_FUNCTIONTABLE, *PKSCLOCK_FUNCTIONTABLE; + +typedef BOOLEAN (*PFNKSSETTIMER)(PVOID Context, PKTIMER Timer, + LARGE_INTEGER DueTime, PKDPC Dpc); +typedef BOOLEAN (*PFNKSCANCELTIMER) (PVOID Context, PKTIMER Timer); +typedef LONGLONG (FASTCALL *PFNKSCORRELATEDTIME)(PVOID Context, + 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 /* _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)(PVOID Context, PIRP Irp); +typedef NTSTATUS (*PFNKSHANDLER)(PIRP Irp, PKSIDENTIFIER Request, PVOID Data); +typedef BOOLEAN (*PFNKSFASTHANDLER)(PFILE_OBJECT FileObject, + PKSIDENTIFIER Request, + ULONG RequestLength, PVOID Data, + ULONG DataLength, + PIO_STATUS_BLOCK IoStatus); +typedef NTSTATUS (*PFNKSALLOCATOR) (PIRP Irp, ULONG BufferSize, + 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; + __MINGW_EXTENSION union { + PFNKSHANDLER GetPropertyHandler; + BOOLEAN GetSupported; + }; + ULONG MinProperty; + ULONG MinData; + __MINGW_EXTENSION 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; + __MINGW_EXTENSION union { + PFNKSFASTHANDLER GetPropertyHandler; + BOOLEAN GetSupported; + }; + __MINGW_EXTENSION 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; + __MINGW_EXTENSION 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; + __MINGW_EXTENSION 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)(PIRP Irp, PKSEVENTDATA EventData, + struct _KSEVENT_ENTRY* EventEntry); +typedef VOID (*PFNKSREMOVEEVENT)(PFILE_OBJECT FileObject, + 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; + __MINGW_EXTENSION 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)(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)(PIRP Irp, PVOID Context); +typedef VOID (*PFNREFERENCEDEVICEOBJECT)(PVOID Context); +typedef VOID (*PFNDEREFERENCEDEVICEOBJECT)(PVOID Context); +typedef NTSTATUS (*PFNQUERYREFERENCESTRING)(PVOID Context, PWCHAR *String); + +#define BUS_INTERFACE_REFERENCE_VERSION 0x100 + +typedef struct { + INTERFACE Interface; + + 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 + +#endif /* _NTDDK_ */ + +#ifndef PACK_PRAGMAS_NOT_SUPPORTED +#include <pshpack1.h> +#endif + +typedef struct { + GUID PropertySet; + ULONG Count; +} KSPROPERTY_SERIALHDR,*PKSPROPERTY_SERIALHDR; + +#ifndef 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; +}; + +typedef PVOID KSOBJECT_BAG; + + +typedef BOOLEAN (*PFNKSGENERATEEVENTCALLBACK)(PVOID Context, + PKSEVENT_ENTRY EventEntry); + +typedef NTSTATUS (*PFNKSDEVICECREATE)(PKSDEVICE Device); + +typedef NTSTATUS (*PFNKSDEVICEPNPSTART)(PKSDEVICE Device,PIRP Irp, + PCM_RESOURCE_LIST TranslatedResourceList, + PCM_RESOURCE_LIST UntranslatedResourceList); + +typedef NTSTATUS (*PFNKSDEVICE)(PKSDEVICE Device); + +typedef NTSTATUS (*PFNKSDEVICEIRP)(PKSDEVICE Device,PIRP Irp); + +typedef void (*PFNKSDEVICEIRPVOID)(PKSDEVICE Device,PIRP Irp); + +typedef NTSTATUS (*PFNKSDEVICEQUERYCAPABILITIES)(PKSDEVICE Device,PIRP Irp, + PDEVICE_CAPABILITIES Capabilities); + +typedef NTSTATUS (*PFNKSDEVICEQUERYPOWER)(PKSDEVICE Device,PIRP Irp, + DEVICE_POWER_STATE DeviceTo, + DEVICE_POWER_STATE DeviceFrom, + SYSTEM_POWER_STATE SystemTo, + SYSTEM_POWER_STATE SystemFrom, + POWER_ACTION Action); + +typedef void (*PFNKSDEVICESETPOWER)(PKSDEVICE Device,PIRP Irp, + DEVICE_POWER_STATE To, + DEVICE_POWER_STATE From); + +typedef NTSTATUS (*PFNKSFILTERFACTORYVOID)(PKSFILTERFACTORY FilterFactory); + +typedef void (*PFNKSFILTERFACTORYPOWER)(PKSFILTERFACTORY FilterFactory, + DEVICE_POWER_STATE State); + +typedef NTSTATUS (*PFNKSFILTERIRP)(PKSFILTER Filter,PIRP Irp); + +typedef NTSTATUS (*PFNKSFILTERPROCESS)(PKSFILTER Filter, + PKSPROCESSPIN_INDEXENTRY Index); + +typedef NTSTATUS (*PFNKSFILTERVOID)(PKSFILTER Filter); + +typedef void (*PFNKSFILTERPOWER)(PKSFILTER Filter,DEVICE_POWER_STATE State); + +typedef NTSTATUS (*PFNKSPINIRP)(PKSPIN Pin,PIRP Irp); + +typedef NTSTATUS (*PFNKSPINSETDEVICESTATE)(PKSPIN Pin,KSSTATE ToState, + KSSTATE FromState); + +typedef NTSTATUS (*PFNKSPINSETDATAFORMAT)(PKSPIN Pin,PKSDATAFORMAT OldFormat, + PKSMULTIPLE_ITEM OldAttributeList, + const KSDATARANGE *DataRange, + const KSATTRIBUTE_LIST *AttributeRange); + +typedef NTSTATUS (*PFNKSPINHANDSHAKE)(PKSPIN Pin,PKSHANDSHAKE In, + PKSHANDSHAKE Out); + +typedef NTSTATUS (*PFNKSPIN)(PKSPIN Pin); + +typedef void (*PFNKSPINVOID)(PKSPIN Pin); + +typedef void (*PFNKSPINPOWER)(PKSPIN Pin,DEVICE_POWER_STATE State); + +typedef BOOLEAN (*PFNKSPINSETTIMER)(PKSPIN Pin,PKTIMER Timer, + LARGE_INTEGER DueTime,PKDPC Dpc); + +typedef BOOLEAN (*PFNKSPINCANCELTIMER)(PKSPIN Pin,PKTIMER Timer); + +typedef LONGLONG (FASTCALL *PFNKSPINCORRELATEDTIME)(PKSPIN Pin, + PLONGLONG SystemTime); + +typedef void (*PFNKSPINRESOLUTION)(PKSPIN Pin,PKSRESOLUTION Resolution); + +typedef NTSTATUS (*PFNKSPININITIALIZEALLOCATOR)(PKSPIN Pin, + PKSALLOCATOR_FRAMING AllocatorFraming, + PVOID *Context); + +typedef void (*PFNKSSTREAMPOINTER)(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; +#ifndef _WIN64 + PVOID Alignment; +#endif +}; + +#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; +}; + +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; +}; + +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; +#ifndef _WIN64 + PVOID Alignment; +#endif +}; + +#ifndef _WIN64 +#define DEFINE_NODE_DESCRIPTOR(automation,type,name) \ + { (automation), (type), (name), NULL } +#else +#define DEFINE_NODE_DESCRIPTOR(automation,type,name) \ + { (automation), (type), (name) } +#endif + +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_) + __MINGW_EXTENSION union { + PUCHAR Data; + PKSMAPPING Mappings; + }; +#else + PUCHAR Data; +#endif /* _NTDDK_ */ +#ifndef _WIN64 + PVOID Alignment; +#endif + 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)(PVOID Data); + +typedef void (*PFNKSPINFRAMERETURN)(PKSPIN Pin,PVOID Data,ULONG Size,PMDL Mdl, + PVOID Context,NTSTATUS Status); + +typedef void (*PFNKSPINIRPCOMPLETION)(PKSPIN Pin,PIRP Irp); + + +#if defined(_UNKNOWN_H_) || defined(__IUnknown_INTERFACE_DEFINED__) +#ifndef _IKsControl_ +#define _IKsControl_ + +typedef struct IKsControl *PIKSCONTROL; + +#ifndef 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 + +#undef INTERFACE +#define INTERFACE IKsControl +DECLARE_INTERFACE_(IKsControl,IUnknown) +{ + DEFINE_ABSTRACT_UNKNOWN() + STDMETHOD_(NTSTATUS,KsProperty)(THIS_ + PKSPROPERTY Property, + ULONG PropertyLength, + PVOID PropertyData, + ULONG DataLength, + ULONG *BytesReturned + ) PURE; + STDMETHOD_(NTSTATUS,KsMethod) (THIS_ + PKSMETHOD Method, + ULONG MethodLength, + PVOID MethodData, + ULONG DataLength, + ULONG *BytesReturned + ) PURE; + STDMETHOD_(NTSTATUS,KsEvent) (THIS_ + PKSEVENT Event, + ULONG EventLength, + PVOID EventData, + ULONG DataLength, + ULONG *BytesReturned + ) PURE; +}; +typedef struct IKsReferenceClock *PIKSREFERENCECLOCK; + +#undef INTERFACE +#define INTERFACE IKsReferenceClock +DECLARE_INTERFACE_(IKsReferenceClock,IUnknown) +{ + DEFINE_ABSTRACT_UNKNOWN() + STDMETHOD_(LONGLONG,GetTime) (THIS) PURE; + STDMETHOD_(LONGLONG,GetPhysicalTime) (THIS) PURE; + STDMETHOD_(LONGLONG,GetCorrelatedTime)(THIS_ + PLONGLONG SystemTime + ) PURE; + STDMETHOD_(LONGLONG,GetCorrelatedPhysicalTime)(THIS_ + PLONGLONG SystemTime + ) PURE; + STDMETHOD_(NTSTATUS,GetResolution) (THIS_ + PKSRESOLUTION Resolution + ) PURE; + STDMETHOD_(NTSTATUS,GetState) (THIS_ + PKSSTATE State + ) PURE; +}; +#undef INTERFACE + +#define INTERFACE IKsDeviceFunctions +DECLARE_INTERFACE_(IKsDeviceFunctions,IUnknown) +{ + DEFINE_ABSTRACT_UNKNOWN() + STDMETHOD_(NTSTATUS,RegisterAdapterObjectEx) (THIS_ + PADAPTER_OBJECT AdapterObject, + PDEVICE_DESCRIPTION DeviceDescription, + ULONG NumberOfMapRegisters, + ULONG MaxMappingsByteCount, + ULONG MappingTableStride + ) 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); +#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); +#define STATIC_IID_IKsDeviceFunctions \ + 0xe234f2e2,0xbd69,0x4f8c,0xb3,0xf2,0x7c,0xd7,0x9e,0xd4,0x66,0xbd +DEFINE_GUID(IID_IKsDeviceFunctions, + 0xe234f2e2,0xbd69,0x4f8c,0xb3,0xf2,0x7c,0xd7,0x9e,0xd4,0x66,0xbd); +#endif /* _IKsControl_ */ +#endif /* defined(_UNKNOWN_H_) || defined(__IUnknown_INTERFACE_DEFINED__) */ + +#endif /* _NTDDK_ */ + + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef _KSDDK_ +#define KSDDKAPI +#else +#define KSDDKAPI DECLSPEC_IMPORT +#endif + +#if defined(_NTDDK_) + +KSDDKAPI NTSTATUS NTAPI KsEnableEvent + (PIRP Irp, ULONG EventSetsCount, const KSEVENT_SET *EventSet, + PLIST_ENTRY EventsList, KSEVENTS_LOCKTYPE EventsFlags, + PVOID EventsLock); + +KSDDKAPI NTSTATUS NTAPI KsEnableEventWithAllocator + (PIRP Irp, ULONG EventSetsCount, const KSEVENT_SET *EventSet, + PLIST_ENTRY EventsList, KSEVENTS_LOCKTYPE EventsFlags, + PVOID EventsLock, PFNKSALLOCATOR Allocator, ULONG EventItemSize); + +KSDDKAPI NTSTATUS NTAPI KsDisableEvent + (PIRP Irp, PLIST_ENTRY EventsList, KSEVENTS_LOCKTYPE EventsFlags, + PVOID EventsLock); + +KSDDKAPI VOID NTAPI KsDiscardEvent (PKSEVENT_ENTRY EventEntry); + +KSDDKAPI VOID NTAPI KsFreeEventList + (PFILE_OBJECT FileObject, PLIST_ENTRY EventsList, + KSEVENTS_LOCKTYPE EventsFlags, PVOID EventsLock); + +KSDDKAPI NTSTATUS NTAPI KsGenerateEvent (PKSEVENT_ENTRY EventEntry); + +KSDDKAPI NTSTATUS NTAPI KsGenerateDataEvent + (PKSEVENT_ENTRY EventEntry, ULONG DataSize, PVOID Data); + +KSDDKAPI VOID NTAPI KsGenerateEventList + (GUID *Set, ULONG EventId, PLIST_ENTRY EventsList, + KSEVENTS_LOCKTYPE EventsFlags, PVOID EventsLock); + +KSDDKAPI NTSTATUS NTAPI KsPropertyHandler + (PIRP Irp, ULONG PropertySetsCount, + const KSPROPERTY_SET *PropertySet); + +KSDDKAPI NTSTATUS NTAPI KsPropertyHandlerWithAllocator + (PIRP Irp, ULONG PropertySetsCount, + const KSPROPERTY_SET *PropertySet, PFNKSALLOCATOR Allocator, + ULONG PropertyItemSize); + +KSDDKAPI BOOLEAN NTAPI KsFastPropertyHandler + (PFILE_OBJECT FileObject, PKSPROPERTY Property, + ULONG PropertyLength, PVOID Data, ULONG DataLength, + PIO_STATUS_BLOCK IoStatus, ULONG PropertySetsCount, + const KSPROPERTY_SET *PropertySet); + +KSDDKAPI NTSTATUS NTAPI KsMethodHandler + (PIRP Irp, ULONG MethodSetsCount, + const KSMETHOD_SET *MethodSet); + +KSDDKAPI NTSTATUS NTAPI KsMethodHandlerWithAllocator + (PIRP Irp, ULONG MethodSetsCount, + const KSMETHOD_SET *MethodSet, PFNKSALLOCATOR Allocator, + ULONG MethodItemSize); + +KSDDKAPI BOOLEAN NTAPI KsFastMethodHandler + (PFILE_OBJECT FileObject, PKSMETHOD Method, ULONG MethodLength, + PVOID Data, ULONG DataLength, PIO_STATUS_BLOCK IoStatus, + ULONG MethodSetsCount, const KSMETHOD_SET *MethodSet); + +KSDDKAPI NTSTATUS NTAPI KsCreateDefaultAllocator (PIRP Irp); + +KSDDKAPI NTSTATUS NTAPI KsCreateDefaultAllocatorEx + (PIRP Irp, PVOID InitializeContext, + PFNKSDEFAULTALLOCATE DefaultAllocate, + PFNKSDEFAULTFREE DefaultFree, + PFNKSINITIALIZEALLOCATOR InitializeAllocator, + PFNKSDELETEALLOCATOR DeleteAllocator); + +KSDDKAPI NTSTATUS NTAPI KsCreateAllocator + (HANDLE ConnectionHandle, PKSALLOCATOR_FRAMING AllocatorFraming, + PHANDLE AllocatorHandle); + +KSDDKAPI NTSTATUS NTAPI KsValidateAllocatorCreateRequest + (PIRP Irp, PKSALLOCATOR_FRAMING *AllocatorFraming); + +KSDDKAPI NTSTATUS NTAPI KsValidateAllocatorFramingEx + (PKSALLOCATOR_FRAMING_EX Framing, ULONG BufferSize, + const KSALLOCATOR_FRAMING_EX *PinFraming); + +KSDDKAPI NTSTATUS NTAPI KsAllocateDefaultClock (PKSDEFAULTCLOCK *DefaultClock); + +KSDDKAPI NTSTATUS NTAPI KsAllocateDefaultClockEx + (PKSDEFAULTCLOCK *DefaultClock, PVOID Context, + PFNKSSETTIMER SetTimer, PFNKSCANCELTIMER CancelTimer, + PFNKSCORRELATEDTIME CorrelatedTime, + const KSRESOLUTION *Resolution, ULONG Flags); + +KSDDKAPI VOID NTAPI KsFreeDefaultClock (PKSDEFAULTCLOCK DefaultClock); +KSDDKAPI NTSTATUS NTAPI KsCreateDefaultClock (PIRP Irp, PKSDEFAULTCLOCK DefaultClock); + +KSDDKAPI NTSTATUS NTAPI KsCreateClock + (HANDLE ConnectionHandle, PKSCLOCK_CREATE ClockCreate, + PHANDLE ClockHandle); + +KSDDKAPI NTSTATUS NTAPI KsValidateClockCreateRequest + (PIRP Irp, PKSCLOCK_CREATE *ClockCreate); + +KSDDKAPI KSSTATE NTAPI KsGetDefaultClockState (PKSDEFAULTCLOCK DefaultClock); +KSDDKAPI VOID NTAPI KsSetDefaultClockState(PKSDEFAULTCLOCK DefaultClock, KSSTATE State); +KSDDKAPI LONGLONG NTAPI KsGetDefaultClockTime (PKSDEFAULTCLOCK DefaultClock); +KSDDKAPI VOID NTAPI KsSetDefaultClockTime(PKSDEFAULTCLOCK DefaultClock, LONGLONG Time); + +KSDDKAPI NTSTATUS NTAPI KsCreatePin + (HANDLE FilterHandle, PKSPIN_CONNECT Connect, + ACCESS_MASK DesiredAccess, PHANDLE ConnectionHandle); + +KSDDKAPI NTSTATUS NTAPI KsValidateConnectRequest + (PIRP Irp, ULONG DescriptorsCount, + const KSPIN_DESCRIPTOR *Descriptor, PKSPIN_CONNECT *Connect); + +KSDDKAPI NTSTATUS NTAPI KsPinPropertyHandler + (PIRP Irp, PKSPROPERTY Property, PVOID Data, + ULONG DescriptorsCount, const KSPIN_DESCRIPTOR *Descriptor); + +KSDDKAPI NTSTATUS NTAPI KsPinDataIntersection + (PIRP Irp, PKSP_PIN Pin, PVOID Data, ULONG DescriptorsCount, + const KSPIN_DESCRIPTOR *Descriptor, + PFNKSINTERSECTHANDLER IntersectHandler); + +KSDDKAPI NTSTATUS NTAPI KsPinDataIntersectionEx + (PIRP Irp, PKSP_PIN Pin, PVOID Data, ULONG DescriptorsCount, + const KSPIN_DESCRIPTOR *Descriptor, ULONG DescriptorSize, + PFNKSINTERSECTHANDLEREX IntersectHandler, PVOID HandlerContext); + +KSDDKAPI NTSTATUS NTAPI KsHandleSizedListQuery + (PIRP Irp, ULONG DataItemsCount, ULONG DataItemSize, + const VOID *DataItems); + +#ifndef MAKEINTRESOURCE +#define MAKEINTRESOURCE(r) ((ULONG_PTR) (USHORT) r) +#endif +#ifndef RT_STRING +#define RT_STRING MAKEINTRESOURCE(6) +#define RT_RCDATA MAKEINTRESOURCE(10) +#endif + +KSDDKAPI NTSTATUS NTAPI KsLoadResource + (PVOID ImageBase, POOL_TYPE PoolType, ULONG_PTR ResourceName, + ULONG ResourceType, PVOID *Resource, PULONG ResourceSize); + +KSDDKAPI NTSTATUS NTAPI KsGetImageNameAndResourceId + (HANDLE RegKey, PUNICODE_STRING ImageName, PULONG_PTR ResourceId, + PULONG ValueType); + +KSDDKAPI NTSTATUS NTAPI KsMapModuleName + (PDEVICE_OBJECT PhysicalDeviceObject, PUNICODE_STRING ModuleName, + PUNICODE_STRING ImageName, PULONG_PTR ResourceId, + PULONG ValueType); + +KSDDKAPI NTSTATUS NTAPI KsReferenceBusObject (KSDEVICE_HEADER Header); +KSDDKAPI VOID NTAPI KsDereferenceBusObject (KSDEVICE_HEADER Header); +KSDDKAPI NTSTATUS NTAPI KsDispatchQuerySecurity (PDEVICE_OBJECT DeviceObject, PIRP Irp); +KSDDKAPI NTSTATUS NTAPI KsDispatchSetSecurity (PDEVICE_OBJECT DeviceObject, PIRP Irp); +KSDDKAPI NTSTATUS NTAPI KsDispatchSpecificProperty (PIRP Irp, PFNKSHANDLER Handler); +KSDDKAPI NTSTATUS NTAPI KsDispatchSpecificMethod (PIRP Irp, PFNKSHANDLER Handler); + +KSDDKAPI NTSTATUS NTAPI KsReadFile + (PFILE_OBJECT FileObject, PKEVENT Event, PVOID PortContext, + PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer, ULONG Length, + ULONG Key, KPROCESSOR_MODE RequestorMode); + +KSDDKAPI NTSTATUS NTAPI KsWriteFile + (PFILE_OBJECT FileObject, PKEVENT Event, PVOID PortContext, + PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer, ULONG Length, + ULONG Key, KPROCESSOR_MODE RequestorMode); + +KSDDKAPI NTSTATUS NTAPI KsQueryInformationFile + (PFILE_OBJECT FileObject, PVOID FileInformation, ULONG Length, + FILE_INFORMATION_CLASS FileInformationClass); + +KSDDKAPI NTSTATUS NTAPI KsSetInformationFile + (PFILE_OBJECT FileObject, PVOID FileInformation, ULONG Length, + FILE_INFORMATION_CLASS FileInformationClass); + +KSDDKAPI NTSTATUS NTAPI KsStreamIo + (PFILE_OBJECT FileObject, PKEVENT Event, PVOID PortContext, + PIO_COMPLETION_ROUTINE CompletionRoutine, PVOID CompletionContext, + KSCOMPLETION_INVOCATION CompletionInvocationFlags, + PIO_STATUS_BLOCK IoStatusBlock, PVOID StreamHeaders, ULONG Length, + ULONG Flags, KPROCESSOR_MODE RequestorMode); + +KSDDKAPI NTSTATUS NTAPI KsProbeStreamIrp(PIRP Irp, ULONG ProbeFlags, ULONG HeaderSize); +KSDDKAPI NTSTATUS NTAPI KsAllocateExtraData(PIRP Irp, ULONG ExtraSize, PVOID *ExtraBuffer); +KSDDKAPI VOID NTAPI KsNullDriverUnload (PDRIVER_OBJECT DriverObject); + +KSDDKAPI NTSTATUS NTAPI KsSetMajorFunctionHandler + (PDRIVER_OBJECT DriverObject, ULONG MajorFunction); + +KSDDKAPI NTSTATUS NTAPI KsDispatchInvalidDeviceRequest + (PDEVICE_OBJECT DeviceObject, PIRP Irp); + +KSDDKAPI NTSTATUS NTAPI KsDefaultDeviceIoCompletion + (PDEVICE_OBJECT DeviceObject, PIRP Irp); + +KSDDKAPI NTSTATUS NTAPI KsDispatchIrp(PDEVICE_OBJECT DeviceObject, PIRP Irp); + +KSDDKAPI BOOLEAN NTAPI KsDispatchFastIoDeviceControlFailure + (PFILE_OBJECT FileObject, BOOLEAN Wait, PVOID InputBuffer, + ULONG InputBufferLength, PVOID OutputBuffer, + ULONG OutputBufferLength, ULONG IoControlCode, + PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject); + +KSDDKAPI BOOLEAN NTAPI KsDispatchFastReadFailure + (PFILE_OBJECT FileObject, PLARGE_INTEGER FileOffset, + ULONG Length, BOOLEAN Wait, ULONG LockKey, PVOID Buffer, + PIO_STATUS_BLOCK IoStatus, PDEVICE_OBJECT DeviceObject); + +#define KsDispatchFastWriteFailure KsDispatchFastReadFailure + +KSDDKAPI VOID NTAPI KsCancelRoutine(PDEVICE_OBJECT DeviceObject, PIRP Irp); +KSDDKAPI VOID NTAPI KsCancelIo(PLIST_ENTRY QueueHead, PKSPIN_LOCK SpinLock); +KSDDKAPI VOID NTAPI KsReleaseIrpOnCancelableQueue(PIRP Irp, PDRIVER_CANCEL DriverCancel); + +KSDDKAPI PIRP NTAPI KsRemoveIrpFromCancelableQueue + (PLIST_ENTRY QueueHead, PKSPIN_LOCK SpinLock, + KSLIST_ENTRY_LOCATION ListLocation, + KSIRP_REMOVAL_OPERATION RemovalOperation); + +KSDDKAPI NTSTATUS NTAPI KsMoveIrpsOnCancelableQueue + (PLIST_ENTRY SourceList, PKSPIN_LOCK SourceLock, + PLIST_ENTRY DestinationList, PKSPIN_LOCK DestinationLock, + KSLIST_ENTRY_LOCATION ListLocation, + PFNKSIRPLISTCALLBACK ListCallback, PVOID Context); + +KSDDKAPI VOID NTAPI KsRemoveSpecificIrpFromCancelableQueue (PIRP Irp); + +KSDDKAPI VOID NTAPI KsAddIrpToCancelableQueue + (PLIST_ENTRY QueueHead, PKSPIN_LOCK SpinLock, PIRP Irp, + KSLIST_ENTRY_LOCATION ListLocation, PDRIVER_CANCEL DriverCancel); + +KSDDKAPI NTSTATUS NTAPI KsAcquireResetValue(PIRP Irp, KSRESET *ResetValue); + +KSDDKAPI NTSTATUS NTAPI KsTopologyPropertyHandler + (PIRP Irp, PKSPROPERTY Property, PVOID Data, + const KSTOPOLOGY *Topology); + +KSDDKAPI VOID NTAPI KsAcquireDeviceSecurityLock(KSDEVICE_HEADER Header, BOOLEAN Exclusive); +KSDDKAPI VOID NTAPI KsReleaseDeviceSecurityLock (KSDEVICE_HEADER Header); +KSDDKAPI NTSTATUS NTAPI KsDefaultDispatchPnp(PDEVICE_OBJECT DeviceObject, PIRP Irp); +KSDDKAPI NTSTATUS NTAPI KsDefaultDispatchPower(PDEVICE_OBJECT DeviceObject, PIRP Irp); +KSDDKAPI NTSTATUS NTAPI KsDefaultForwardIrp(PDEVICE_OBJECT DeviceObject, PIRP Irp); + +KSDDKAPI VOID NTAPI KsSetDevicePnpAndBaseObject + (KSDEVICE_HEADER Header, PDEVICE_OBJECT PnpDeviceObject, + PDEVICE_OBJECT BaseObject); + +KSDDKAPI PDEVICE_OBJECT NTAPI KsQueryDevicePnpObject (KSDEVICE_HEADER Header); +KSDDKAPI ACCESS_MASK NTAPI KsQueryObjectAccessMask (KSOBJECT_HEADER Header); + +KSDDKAPI VOID NTAPI KsRecalculateStackDepth + (KSDEVICE_HEADER Header, BOOLEAN ReuseStackLocation); + +KSDDKAPI VOID NTAPI KsSetTargetState + (KSOBJECT_HEADER Header, KSTARGET_STATE TargetState); + +KSDDKAPI VOID NTAPI KsSetTargetDeviceObject + (KSOBJECT_HEADER Header, PDEVICE_OBJECT TargetDevice); + +KSDDKAPI VOID NTAPI KsSetPowerDispatch + (KSOBJECT_HEADER Header, PFNKSCONTEXT_DISPATCH PowerDispatch, + PVOID PowerContext); + +KSDDKAPI PKSOBJECT_CREATE_ITEM NTAPI KsQueryObjectCreateItem (KSOBJECT_HEADER Header); + +KSDDKAPI NTSTATUS NTAPI KsAllocateDeviceHeader + (KSDEVICE_HEADER *Header, ULONG ItemsCount, + PKSOBJECT_CREATE_ITEM ItemsList); + +KSDDKAPI VOID NTAPI KsFreeDeviceHeader (KSDEVICE_HEADER Header); + +KSDDKAPI NTSTATUS NTAPI KsAllocateObjectHeader + (KSOBJECT_HEADER *Header, ULONG ItemsCount, + PKSOBJECT_CREATE_ITEM ItemsList, PIRP Irp, + const KSDISPATCH_TABLE *Table); + +KSDDKAPI VOID NTAPI KsFreeObjectHeader (KSOBJECT_HEADER Header); + +KSDDKAPI NTSTATUS NTAPI KsAddObjectCreateItemToDeviceHeader + (KSDEVICE_HEADER Header, PDRIVER_DISPATCH Create, PVOID Context, + PWSTR ObjectClass, PSECURITY_DESCRIPTOR SecurityDescriptor); + +KSDDKAPI NTSTATUS NTAPI KsAddObjectCreateItemToObjectHeader + (KSOBJECT_HEADER Header, PDRIVER_DISPATCH Create, PVOID Context, + PWSTR ObjectClass, PSECURITY_DESCRIPTOR SecurityDescriptor); + +KSDDKAPI NTSTATUS NTAPI KsAllocateObjectCreateItem + (KSDEVICE_HEADER Header, PKSOBJECT_CREATE_ITEM CreateItem, + BOOLEAN AllocateEntry, PFNKSITEMFREECALLBACK ItemFreeCallback); + +KSDDKAPI NTSTATUS NTAPI KsFreeObjectCreateItem + (KSDEVICE_HEADER Header, PUNICODE_STRING CreateItem); + +KSDDKAPI NTSTATUS NTAPI KsFreeObjectCreateItemsByContext + (KSDEVICE_HEADER Header, PVOID Context); + +KSDDKAPI NTSTATUS NTAPI KsCreateDefaultSecurity + (PSECURITY_DESCRIPTOR ParentSecurity, + PSECURITY_DESCRIPTOR *DefaultSecurity); + +KSDDKAPI NTSTATUS NTAPI KsForwardIrp + (PIRP Irp, PFILE_OBJECT FileObject, BOOLEAN ReuseStackLocation); + +KSDDKAPI NTSTATUS NTAPI KsForwardAndCatchIrp + (PDEVICE_OBJECT DeviceObject, PIRP Irp, PFILE_OBJECT FileObject, + KSSTACK_USE StackUse); + +KSDDKAPI NTSTATUS NTAPI KsSynchronousIoControlDevice + (PFILE_OBJECT FileObject, KPROCESSOR_MODE RequestorMode, + ULONG IoControl, PVOID InBuffer, ULONG InSize, PVOID OutBuffer, + ULONG OutSize, PULONG BytesReturned); + +KSDDKAPI NTSTATUS NTAPI KsUnserializeObjectPropertiesFromRegistry + (PFILE_OBJECT FileObject, HANDLE ParentKey, + PUNICODE_STRING RegistryPath); + +KSDDKAPI NTSTATUS NTAPI KsCacheMedium + (PUNICODE_STRING SymbolicLink, PKSPIN_MEDIUM Medium, + ULONG PinDirection); + +KSDDKAPI NTSTATUS NTAPI KsRegisterWorker + (WORK_QUEUE_TYPE WorkQueueType, PKSWORKER *Worker); + +KSDDKAPI NTSTATUS NTAPI KsRegisterCountedWorker + (WORK_QUEUE_TYPE WorkQueueType, PWORK_QUEUE_ITEM CountedWorkItem, + PKSWORKER *Worker); + +KSDDKAPI VOID NTAPI KsUnregisterWorker (PKSWORKER Worker); +KSDDKAPI NTSTATUS NTAPI KsQueueWorkItem(PKSWORKER Worker, PWORK_QUEUE_ITEM WorkItem); +KSDDKAPI ULONG NTAPI KsIncrementCountedWorker (PKSWORKER Worker); +KSDDKAPI ULONG NTAPI KsDecrementCountedWorker (PKSWORKER Worker); + +KSDDKAPI NTSTATUS NTAPI KsCreateTopologyNode + (HANDLE ParentHandle, PKSNODE_CREATE NodeCreate, + ACCESS_MASK DesiredAccess, PHANDLE NodeHandle); + +KSDDKAPI NTSTATUS NTAPI KsValidateTopologyNodeCreateRequest + (PIRP Irp, PKSTOPOLOGY Topology, PKSNODE_CREATE *NodeCreate); + +KSDDKAPI NTSTATUS NTAPI KsMergeAutomationTables + (PKSAUTOMATION_TABLE *AutomationTableAB, + PKSAUTOMATION_TABLE AutomationTableA, + PKSAUTOMATION_TABLE AutomationTableB, + KSOBJECT_BAG Bag); + +KSDDKAPI NTSTATUS NTAPI KsInitializeDriver + (PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPathName, + const KSDEVICE_DESCRIPTOR *Descriptor); + +KSDDKAPI NTSTATUS NTAPI KsAddDevice + (PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObject); + +KSDDKAPI NTSTATUS NTAPI KsCreateDevice + (PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObject, + const KSDEVICE_DESCRIPTOR *Descriptor, ULONG ExtensionSize, + PKSDEVICE *Device); + +KSDDKAPI NTSTATUS NTAPI KsInitializeDevice + (PDEVICE_OBJECT FunctionalDeviceObject, + PDEVICE_OBJECT PhysicalDeviceObject, + PDEVICE_OBJECT NextDeviceObject, + const KSDEVICE_DESCRIPTOR *Descriptor); + +KSDDKAPI void NTAPI KsTerminateDevice (PDEVICE_OBJECT DeviceObject); +KSDDKAPI PKSDEVICE NTAPI KsGetDeviceForDeviceObject (PDEVICE_OBJECT FunctionalDeviceObject); +KSDDKAPI void NTAPI KsAcquireDevice (PKSDEVICE Device); +KSDDKAPI void NTAPI KsReleaseDevice (PKSDEVICE Device); + +KSDDKAPI void NTAPI KsDeviceRegisterAdapterObject + (PKSDEVICE Device, PADAPTER_OBJECT AdapterObject, + ULONG MaxMappingsByteCount, ULONG MappingTableStride); + +KSDDKAPI ULONG NTAPI KsDeviceGetBusData + (PKSDEVICE Device, ULONG DataType, PVOID Buffer, ULONG Offset, + ULONG Length); + +KSDDKAPI ULONG NTAPI KsDeviceSetBusData + (PKSDEVICE Device, ULONG DataType, PVOID Buffer, ULONG Offset, + ULONG Length); + +KSDDKAPI NTSTATUS NTAPI KsCreateFilterFactory + (PDEVICE_OBJECT DeviceObject, const KSFILTER_DESCRIPTOR *Descriptor, + PWSTR RefString, PSECURITY_DESCRIPTOR SecurityDescriptor, + ULONG CreateItemFlags, PFNKSFILTERFACTORYPOWER SleepCallback, + PFNKSFILTERFACTORYPOWER WakeCallback, + PKSFILTERFACTORY *FilterFactory); + +#define KsDeleteFilterFactory(FilterFactory) \ + KsFreeObjectCreateItemsByContext( *(KSDEVICE_HEADER *)( \ + KsFilterFactoryGetParentDevice(FilterFactory)->FunctionalDeviceObject->DeviceExtension),\ + FilterFactory) + +KSDDKAPI NTSTATUS NTAPI KsFilterFactoryUpdateCacheData + (PKSFILTERFACTORY FilterFactory, + const KSFILTER_DESCRIPTOR *FilterDescriptor); + +KSDDKAPI NTSTATUS NTAPI KsFilterFactoryAddCreateItem + (PKSFILTERFACTORY FilterFactory, PWSTR RefString, + PSECURITY_DESCRIPTOR SecurityDescriptor, ULONG CreateItemFlags); + +KSDDKAPI NTSTATUS NTAPI KsFilterFactorySetDeviceClassesState + (PKSFILTERFACTORY FilterFactory, BOOLEAN NewState); + +KSDDKAPI PUNICODE_STRING NTAPI KsFilterFactoryGetSymbolicLink + (PKSFILTERFACTORY FilterFactory); + +KSDDKAPI void NTAPI KsAddEvent(PVOID Object, PKSEVENT_ENTRY EventEntry); + +void __forceinline KsFilterAddEvent (PKSFILTER Filter, PKSEVENT_ENTRY EventEntry) +{ + KsAddEvent(Filter, EventEntry); +} + +void __forceinline KsPinAddEvent (PKSPIN Pin, PKSEVENT_ENTRY EventEntry) +{ + KsAddEvent(Pin, EventEntry); +} + +KSDDKAPI NTSTATUS NTAPI KsDefaultAddEventHandler + (PIRP Irp, PKSEVENTDATA EventData, PKSEVENT_ENTRY EventEntry); + +KSDDKAPI void NTAPI KsGenerateEvents + (PVOID Object, const GUID *EventSet, ULONG EventId, + ULONG DataSize, PVOID Data, PFNKSGENERATEEVENTCALLBACK CallBack, + PVOID CallBackContext); + +void __forceinline KsFilterGenerateEvents + (PKSFILTER Filter, const GUID *EventSet, ULONG EventId, + ULONG DataSize, PVOID Data, PFNKSGENERATEEVENTCALLBACK CallBack, + PVOID CallBackContext) +{ + KsGenerateEvents(Filter, EventSet, EventId, DataSize, Data, CallBack, + CallBackContext); +} + +void __forceinline KsPinGenerateEvents + (PKSPIN Pin, const GUID *EventSet, ULONG EventId, + ULONG DataSize, PVOID Data, PFNKSGENERATEEVENTCALLBACK CallBack, + PVOID CallBackContext) +{ + 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 + (PKSPIN Pin, PLONG InputDataBytes, PLONG OutputBufferBytes); + +KSDDKAPI PKSSTREAM_POINTER NTAPI KsPinGetLeadingEdgeStreamPointer + (PKSPIN Pin, KSSTREAM_POINTER_STATE State); + +KSDDKAPI PKSSTREAM_POINTER NTAPI KsPinGetTrailingEdgeStreamPointer + (PKSPIN Pin, KSSTREAM_POINTER_STATE State); + +KSDDKAPI NTSTATUS NTAPI KsStreamPointerSetStatusCode + (PKSSTREAM_POINTER StreamPointer, NTSTATUS Status); + +KSDDKAPI NTSTATUS NTAPI KsStreamPointerLock (PKSSTREAM_POINTER StreamPointer); +KSDDKAPI void NTAPI KsStreamPointerUnlock(PKSSTREAM_POINTER StreamPointer, BOOLEAN Eject); + +KSDDKAPI void NTAPI KsStreamPointerAdvanceOffsetsAndUnlock + (PKSSTREAM_POINTER StreamPointer, ULONG InUsed, ULONG OutUsed, + BOOLEAN Eject); + +KSDDKAPI void NTAPI KsStreamPointerDelete (PKSSTREAM_POINTER StreamPointer); + +KSDDKAPI NTSTATUS NTAPI KsStreamPointerClone + (PKSSTREAM_POINTER StreamPointer, PFNKSSTREAMPOINTER CancelCallback, + ULONG ContextSize, PKSSTREAM_POINTER *CloneStreamPointer); + +KSDDKAPI NTSTATUS NTAPI KsStreamPointerAdvanceOffsets + (PKSSTREAM_POINTER StreamPointer, ULONG InUsed, ULONG OutUsed, + BOOLEAN Eject); + +KSDDKAPI NTSTATUS NTAPI KsStreamPointerAdvance (PKSSTREAM_POINTER StreamPointer); +KSDDKAPI PMDL NTAPI KsStreamPointerGetMdl (PKSSTREAM_POINTER StreamPointer); + +KSDDKAPI PIRP NTAPI KsStreamPointerGetIrp + (PKSSTREAM_POINTER StreamPointer, PBOOLEAN FirstFrameInIrp, + PBOOLEAN LastFrameInIrp); + +KSDDKAPI void NTAPI KsStreamPointerScheduleTimeout + (PKSSTREAM_POINTER StreamPointer, PFNKSSTREAMPOINTER Callback, + ULONGLONG Interval); + +KSDDKAPI void NTAPI KsStreamPointerCancelTimeout (PKSSTREAM_POINTER StreamPointer); +KSDDKAPI PKSSTREAM_POINTER NTAPI KsPinGetFirstCloneStreamPointer (PKSPIN Pin); + +KSDDKAPI PKSSTREAM_POINTER NTAPI KsStreamPointerGetNextClone + (PKSSTREAM_POINTER StreamPointer); + +KSDDKAPI NTSTATUS NTAPI KsPinHandshake(PKSPIN Pin, PKSHANDSHAKE In, PKSHANDSHAKE Out); +KSDDKAPI void NTAPI KsCompletePendingRequest (PIRP Irp); +KSDDKAPI KSOBJECTTYPE NTAPI KsGetObjectTypeFromIrp (PIRP Irp); +KSDDKAPI PVOID NTAPI KsGetObjectFromFileObject (PFILE_OBJECT FileObject); +KSDDKAPI KSOBJECTTYPE NTAPI KsGetObjectTypeFromFileObject (PFILE_OBJECT FileObject); + +PKSFILTER __forceinline KsGetFilterFromFileObject (PFILE_OBJECT FileObject) +{ + return (PKSFILTER) KsGetObjectFromFileObject(FileObject); +} + +PKSPIN __forceinline KsGetPinFromFileObject (PFILE_OBJECT FileObject) +{ + return (PKSPIN) KsGetObjectFromFileObject(FileObject); +} + +KSDDKAPI PKSGATE NTAPI KsFilterGetAndGate (PKSFILTER Filter); +KSDDKAPI void NTAPI KsFilterAcquireProcessingMutex (PKSFILTER Filter); +KSDDKAPI void NTAPI KsFilterReleaseProcessingMutex (PKSFILTER Filter); +KSDDKAPI void NTAPI KsFilterAttemptProcessing(PKSFILTER Filter, BOOLEAN Asynchronous); +KSDDKAPI PKSGATE NTAPI KsPinGetAndGate(PKSPIN Pin); +KSDDKAPI void NTAPI KsPinAttachAndGate(PKSPIN Pin, PKSGATE AndGate); +KSDDKAPI void NTAPI KsPinAttachOrGate (PKSPIN Pin, PKSGATE OrGate); +KSDDKAPI void NTAPI KsPinAcquireProcessingMutex (PKSPIN Pin); +KSDDKAPI void NTAPI KsPinReleaseProcessingMutex (PKSPIN Pin); +KSDDKAPI BOOLEAN NTAPI KsProcessPinUpdate (PKSPROCESSPIN ProcessPin); + +KSDDKAPI void NTAPI KsPinGetCopyRelationships + (PKSPIN Pin, PKSPIN *CopySource, PKSPIN *DelegateBranch); + +KSDDKAPI void NTAPI KsPinAttemptProcessing(PKSPIN Pin, BOOLEAN Asynchronous); +KSDDKAPI PVOID NTAPI KsGetParent (PVOID Object); + +PKSDEVICE __forceinline KsFilterFactoryGetParentDevice (PKSFILTERFACTORY FilterFactory) +{ + return (PKSDEVICE) KsGetParent((PVOID) FilterFactory); +} + +PKSFILTERFACTORY __forceinline KsFilterGetParentFilterFactory (PKSFILTER Filter) +{ + return (PKSFILTERFACTORY) KsGetParent((PVOID) Filter); +} + +KSDDKAPI PKSFILTER NTAPI KsPinGetParentFilter (PKSPIN Pin); +KSDDKAPI PVOID NTAPI KsGetFirstChild (PVOID Object); + +PKSFILTERFACTORY __forceinline KsDeviceGetFirstChildFilterFactory (PKSDEVICE Device) +{ + return (PKSFILTERFACTORY) KsGetFirstChild((PVOID) Device); +} + +PKSFILTER __forceinline KsFilterFactoryGetFirstChildFilter (PKSFILTERFACTORY FilterFactory) +{ + return (PKSFILTER) KsGetFirstChild((PVOID) FilterFactory); +} + +KSDDKAPI ULONG NTAPI KsFilterGetChildPinCount(PKSFILTER Filter, ULONG PinId); +KSDDKAPI PKSPIN NTAPI KsFilterGetFirstChildPin(PKSFILTER Filter, ULONG PinId); +KSDDKAPI PVOID NTAPI KsGetNextSibling (PVOID Object); +KSDDKAPI PKSPIN NTAPI KsPinGetNextSiblingPin (PKSPIN Pin); + +PKSFILTERFACTORY __forceinline KsFilterFactoryGetNextSiblingFilterFactory + (PKSFILTERFACTORY FilterFactory) +{ + return (PKSFILTERFACTORY) KsGetNextSibling((PVOID) FilterFactory); +} + +PKSFILTER __forceinline KsFilterGetNextSiblingFilter (PKSFILTER Filter) +{ + return (PKSFILTER) KsGetNextSibling((PVOID) Filter); +} + +KSDDKAPI PKSDEVICE NTAPI KsGetDevice (PVOID Object); + +PKSDEVICE __forceinline KsFilterFactoryGetDevice (PKSFILTERFACTORY FilterFactory) +{ + return KsGetDevice((PVOID) FilterFactory); +} + +PKSDEVICE __forceinline KsFilterGetDevice (PKSFILTER Filter) +{ + return KsGetDevice((PVOID) Filter); +} + +PKSDEVICE __forceinline KsPinGetDevice (PKSPIN Pin) +{ + return KsGetDevice((PVOID) Pin); +} + +KSDDKAPI PKSFILTER NTAPI KsGetFilterFromIrp (PIRP Irp); +KSDDKAPI PKSPIN NTAPI KsGetPinFromIrp (PIRP Irp); +KSDDKAPI ULONG NTAPI KsGetNodeIdFromIrp (PIRP Irp); +KSDDKAPI void NTAPI KsAcquireControl (PVOID Object); +KSDDKAPI void NTAPI KsReleaseControl (PVOID Object); + +void __forceinline KsFilterAcquireControl (PKSFILTER Filter) +{ + KsAcquireControl((PVOID) Filter); +} + +void __forceinline KsFilterReleaseControl (PKSFILTER Filter) +{ + KsReleaseControl((PVOID) Filter); +} + +void __forceinline KsPinAcquireControl (PKSPIN Pin) +{ + KsAcquireControl((PVOID) Pin); +} + +void __forceinline KsPinReleaseControl (PKSPIN Pin) +{ + KsReleaseControl((PVOID) Pin); +} + +KSDDKAPI NTSTATUS NTAPI KsAddItemToObjectBag + (KSOBJECT_BAG ObjectBag, PVOID Item, PFNKSFREE Free); + +KSDDKAPI ULONG NTAPI KsRemoveItemFromObjectBag + (KSOBJECT_BAG ObjectBag, PVOID Item, BOOLEAN Free); + +#define KsDiscard(Object,Pointer) \ + KsRemoveItemFromObjectBag((Object)->Bag, (PVOID)(Pointer), TRUE) + +KSDDKAPI NTSTATUS NTAPI KsAllocateObjectBag(PKSDEVICE Device, KSOBJECT_BAG *ObjectBag); +KSDDKAPI void NTAPI KsFreeObjectBag (KSOBJECT_BAG ObjectBag); + +KSDDKAPI NTSTATUS NTAPI KsCopyObjectBagItems + (KSOBJECT_BAG ObjectBagDestination, KSOBJECT_BAG ObjectBagSource); + +KSDDKAPI NTSTATUS NTAPI _KsEdit + (KSOBJECT_BAG ObjectBag, PVOID *PointerToPointerToItem, + ULONG NewSize, ULONG OldSize, 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 + (PDEVICE_OBJECT DeviceObject, const GUID *InterfaceClassGUID, + ULONG PinCount, WINBOOL *PinDirection, KSPIN_MEDIUM *MediumList, + GUID *CategoryList); + +KSDDKAPI NTSTATUS NTAPI KsFilterCreatePinFactory + (PKSFILTER Filter, const KSPIN_DESCRIPTOR_EX *const PinDescriptor, + PULONG PinID); + +KSDDKAPI NTSTATUS NTAPI KsFilterCreateNode + (PKSFILTER Filter, const KSNODE_DESCRIPTOR *const NodeDescriptor, + PULONG NodeID); + +KSDDKAPI NTSTATUS NTAPI KsFilterAddTopologyConnections + (PKSFILTER Filter, ULONG NewConnectionsCount, + const KSTOPOLOGY_CONNECTION *const NewTopologyConnections); + +KSDDKAPI NTSTATUS NTAPI KsPinGetConnectedPinInterface + (PKSPIN Pin, const GUID *InterfaceId, PVOID *Interface); + +KSDDKAPI PFILE_OBJECT NTAPI KsPinGetConnectedPinFileObject (PKSPIN Pin); +KSDDKAPI PDEVICE_OBJECT NTAPI KsPinGetConnectedPinDeviceObject (PKSPIN Pin); + +KSDDKAPI NTSTATUS NTAPI KsPinGetConnectedFilterInterface + (PKSPIN Pin, const GUID *InterfaceId, PVOID *Interface); + +#if defined(_UNKNOWN_H_) || defined(__IUnknown_INTERFACE_DEFINED__) +KSDDKAPI NTSTATUS NTAPI KsPinGetReferenceClockInterface + (PKSPIN Pin, PIKSREFERENCECLOCK *Interface); +#endif /* defined(_UNKNOWN_H_) || defined(__IUnknown_INTERFACE_DEFINED__) */ + +KSDDKAPI VOID NTAPI KsPinSetPinClockTime(PKSPIN Pin, LONGLONG Time); + +KSDDKAPI NTSTATUS NTAPI KsPinSubmitFrame + (PKSPIN Pin, PVOID Data, ULONG Size, + PKSSTREAM_HEADER StreamHeader, PVOID Context); + +KSDDKAPI NTSTATUS NTAPI KsPinSubmitFrameMdl + (PKSPIN Pin, PMDL Mdl, PKSSTREAM_HEADER StreamHeader, + PVOID Context); + +KSDDKAPI void NTAPI KsPinRegisterFrameReturnCallback + (PKSPIN Pin, PFNKSPINFRAMERETURN FrameReturn); + +KSDDKAPI void NTAPI KsPinRegisterIrpCompletionCallback + (PKSPIN Pin, PFNKSPINIRPCOMPLETION IrpCompletion); + +KSDDKAPI void NTAPI KsPinRegisterHandshakeCallback + (PKSPIN Pin, PFNKSPINHANDSHAKE Handshake); + +KSDDKAPI void NTAPI KsFilterRegisterPowerCallbacks + (PKSFILTER Filter, PFNKSFILTERPOWER Sleep, PFNKSFILTERPOWER Wake); + +KSDDKAPI void NTAPI KsPinRegisterPowerCallbacks + (PKSPIN Pin, PFNKSPINPOWER Sleep, PFNKSPINPOWER Wake); + +#if defined(_UNKNOWN_H_) || defined(__IUnknown_INTERFACE_DEFINED__) +KSDDKAPI PUNKNOWN NTAPI KsRegisterAggregatedClientUnknown + (PVOID Object, PUNKNOWN ClientUnknown); + +KSDDKAPI PUNKNOWN NTAPI KsGetOuterUnknown (PVOID Object); + +PUNKNOWN __forceinline KsDeviceRegisterAggregatedClientUnknown + (PKSDEVICE Device, PUNKNOWN ClientUnknown) +{ + return KsRegisterAggregatedClientUnknown((PVOID)Device, ClientUnknown); +} + +PUNKNOWN __forceinline KsDeviceGetOuterUnknown (PKSDEVICE Device) +{ + return KsGetOuterUnknown((PVOID) Device); +} + +PUNKNOWN __forceinline KsFilterFactoryRegisterAggregatedClientUnknown + (PKSFILTERFACTORY FilterFactory, PUNKNOWN ClientUnknown) +{ + return KsRegisterAggregatedClientUnknown((PVOID)FilterFactory, ClientUnknown); +} + +PUNKNOWN __forceinline KsFilterFactoryGetOuterUnknown (PKSFILTERFACTORY FilterFactory) +{ + return KsGetOuterUnknown((PVOID)FilterFactory); +} + +PUNKNOWN __forceinline KsFilterRegisterAggregatedClientUnknown + (PKSFILTER Filter, PUNKNOWN ClientUnknown) +{ + return KsRegisterAggregatedClientUnknown((PVOID)Filter, ClientUnknown); +} + +PUNKNOWN __forceinline KsFilterGetOuterUnknown (PKSFILTER Filter) +{ + return KsGetOuterUnknown((PVOID)Filter); +} + +PUNKNOWN __forceinline KsPinRegisterAggregatedClientUnknown + (PKSPIN Pin, PUNKNOWN ClientUnknown) +{ + return KsRegisterAggregatedClientUnknown((PVOID)Pin, ClientUnknown); +} + +PUNKNOWN __forceinline KsPinGetOuterUnknown (PKSPIN Pin) +{ + return KsGetOuterUnknown((PVOID)Pin); +} +#endif /* defined(_UNKNOWN_H_) || defined(__IUnknown_INTERFACE_DEFINED__) */ + +#else /* _NTDDK_ */ + +#ifndef KS_NO_CREATE_FUNCTIONS +KSDDKAPI DWORD WINAPI KsCreateAllocator(HANDLE ConnectionHandle,PKSALLOCATOR_FRAMING AllocatorFraming,PHANDLE AllocatorHandle); +KSDDKAPI DWORD NTAPI KsCreateClock(HANDLE ConnectionHandle,PKSCLOCK_CREATE ClockCreate,PHANDLE ClockHandle); +KSDDKAPI DWORD WINAPI KsCreatePin(HANDLE FilterHandle,PKSPIN_CONNECT Connect,ACCESS_MASK DesiredAccess,PHANDLE ConnectionHandle); +KSDDKAPI DWORD WINAPI KsCreateTopologyNode(HANDLE ParentHandle,PKSNODE_CREATE NodeCreate,ACCESS_MASK DesiredAccess,PHANDLE NodeHandle); +#endif + +#endif /* _NTDDK_ */ + +#ifdef __cplusplus +} +#endif + +#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_ */ + |