path: root/3rdparty/portaudio/src/hostapi/wasapi/mingw-include/ks.h

/**
 * 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_ */