&Overlapped);
*/
-#ifndef KS_H
-#define KS_H
-
+#ifndef _KS_
#define _KS_
-#if __GNUC__ >=3
-#pragma GCC system_header
-#endif
-
#ifdef __cplusplus
extern "C" {
#endif
-/*
-Not sure if this is correct but it causes problems if not included. Can't
-seem to compile without this...
-*/
-#include "ntddk.h"
-
#ifdef BUILDING_KS
#define KSDDKAPI
#else
- #define KSDDKAPI DECLSPEC_IMPORT
+ #define KSDDKAPI //DECLSPEC_IMPORT /* TODO */
#endif
-/* TODO */
-#define KSDDKAPI
+#define KSFILTER_NODE ((ULONG)-1)
+#define KSALL_NODES ((ULONG)-1)
#define KSSTRING_Filter L"{9B365890-165F-11D0-A195-0020AFD156E4}"
#define KSSTRING_Pin L"{146F1A80-4791-11D0-A5D6-28DB04C10000}"
#define KSDATAFORMAT_BIT_ATTRIBUTES 1
#define KSDATAFORMAT_ATTRIBUTES (1 << KSDATAFORMAT_BIT_ATTRIBUTES)
+
+#if defined(_NTDDK_)
typedef PVOID PKSWORKER;
+#endif
+
+#ifndef SIZEOF_ARRAY
+ #define SIZEOF_ARRAY(a) (sizeof(a)/sizeof((a)[0]))
+#endif
/* ===============================================================
GUID definition helpers
#if defined(__cplusplus) && _MSC_VER >= 1100
#define DEFINE_GUIDSTRUCT(guid, name) struct __declspec(uuid(guid)) name
- #define DEFINE_GUIDNAMED(name) __uidof(struct name)
+ #define DEFINE_GUIDNAMED(name) __uuidof(struct name)
#else
#define DEFINE_GUIDSTRUCT(guid, name) DEFINE_GUIDEX(name)
#define DEFINE_GUIDNAMED(name) name
#define STATIC_GUID_NULL \
-0x00000000L, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+ 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 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 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)
+
/* ===============================================================
I/O Control Codes
*/
typedef KSIDENTIFIER KSPIN_INTERFACE, *PKSPIN_INTERFACE;
typedef KSIDENTIFIER KSPIN_MEDIUM, *PKSPIN_MEDIUM;
-typedef union
-{
+typedef union {
struct {
ULONG FormatSize;
ULONG Flags;
LONGLONG Alignment;
} KSDATAFORMAT, *PKSDATAFORMAT, KSDATARANGE, *PKSDATARANGE;
+
typedef struct
{
+ ULONG Size;
+ ULONG Flags;
+ GUID Attribute;
} KSATTRIBUTE, *PKSATTRIBUTE;
#if 0
#define KSINTERFACESETID_Media
-#define KSINTERFACESETID_Standard
#define KSINTERFACE_STANDARD_STREAMING
#define KSINTERFACE_STANDARD_LOOPED_STREAMING
#define KSINTERFACE_STANDARD_CONTROL
#endif
-typedef KSIDENTIFIER KSPIN_INTERFACE, *PKSPIN_INTERFACE;
-
#define STATIC_KSINTERFACESETID_Standard \
- 0x1A8766A0L, 0x62CE, 0x11CF, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+ 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)
#define KSINTERFACESETID_FileIo DEFINE_GUIDNAMED(KSINTERFACESETID_FileIo)
+
+
/* ===============================================================
Mediums
*/
#define KSMEDIUM_TYPE_ANYINSTANCE 0
#define STATIC_KSMEDIUMSETID_Standard \
- 0x4747B320L, 0x62CE, 0x11CF, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+ 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)
Clock Properties/Methods/Events
*/
-#define KSPROPSETID_Clock \
+#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)
typedef enum
{
KSPROPERTY_CLOCK_TIME,
KSPROPERTY_CLOCK_PHYSICALTIME,
- KSPROPERTY_CORRELATEDTIME,
- KSPROPERTY_CORRELATEDPHYSICALTIME,
+ KSPROPERTY_CLOCK_CORRELATEDTIME,
+ KSPROPERTY_CLOCK_CORRELATEDPHYSICALTIME,
KSPROPERTY_CLOCK_RESOLUTION,
KSPROPERTY_CLOCK_STATE,
+#if defined(_NTDDK_)
KSPROPERTY_CLOCK_FUNCTIONTABLE
+#endif // defined(_NTDDK_)
} KSPROPERTY_CLOCK;
-#define KSEVENTSETID_Clock \
+#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
{
Connection Properties/Methods/Events
*/
-#define KSPROPSETID_Connection \
- 0x1D58C920L, 0xAC9B, 0x11CF, 0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00
+#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_STARTAT
} KSPROPERTY_CONNECTION;
-#define KSEVENTSETID_Connection \
- 0x7f4bcbe0L, 0x9ea5, 0x11cf, 0xa5, 0xd6, 0x28, 0xdb, 0x04, 0xc1, 0x00, 0x00
+#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)
+
typedef enum
{
Properties/Methods/Events
*/
-#define KSPROPSETID_General \
- 0x1464EDA5L, 0x6A8F, 0x11D1, 0x9A, 0xA7, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96
+#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
{
Properties/Methods/Events
*/
-#define KSPROPSETID_MediaSeeking \
+#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
-{
+typedef enum {
KSPROPERTY_MEDIASEEKING_CAPABILITIES,
KSPROPERTY_MEDIASEEKING_FORMATS,
KSPROPERTY_MEDIASEEKING_TIMEFORMAT,
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)
/* ===============================================================
Pin
DEFINE_GUIDSTRUCT("8C134960-51AD-11CF-878A-94F801C10000", KSPROPSETID_Pin);
#define KSPROPSETID_Pin DEFINE_GUIDNAMED(KSPROPSETID_Pin)
+#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)
+
+
typedef enum
{
KSPROPERTY_PIN_CINSTANCES,
Properties/Methods/Events
*/
-#define KSPROPSETID_StreamAllocator \
+#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)
typedef enum
{
Properties/Methods/Events
*/
-#define KSPROPSETID_Topology \
+#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
-{
+typedef enum {
KSPROPERTY_TOPOLOGY_CATEGORIES,
+ KSPROPERTY_TOPOLOGY_NODES,
KSPROPERTY_TOPOLOGY_CONNECTIONS,
- KSPROPERTY_TOPOLOGY_NAME,
- KSPROPERTY_TOPOLOGY_NODES
+ KSPROPERTY_TOPOLOGY_NAME
} KSPROPERTY_TOPOLOGY;
-
-
/* ===============================================================
Property Sets for audio drivers - TODO
*/
-#define KSPROPSETID_AC3
+#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)
+
/*
KSPROPERTY_AC3_ALTERNATE_AUDIO
KSPROPERTY_AC3_BIT_STREAM_MODE
KSPROPERTY_AEC_STATUS
*/
-#define KSPROPSETID_Audio
/*
KSPROPERTY_AUDIO_3D_INTERFACE
KSPROPERTY_AUDIO_AGC
KSPROPERTY_SYNTH_DLS_WAVEFORMAT
*/
-/* #define KSPROPSETID_Sysaudio */
-/*
- KSPROPERTY_SYSAUDIO_COMPONENT_ID
- KSPROPERTY_SYSAUDIO_CREATE_VIRTUAL_SOURCE
- KSPROPERTY_SYSAUDIO_DEVICE_COUNT
- KSPROPERTY_SYSAUDIO_DEVICE_FRIENDLY_NAME
- KSPROPERTY_SYSAUDIO_DEVICE_INSTANCE
- KSPROPERTY_SYSAUDIO_DEVICE_INTERFACE_NAME
- KSPROPERTY_SYSAUDIO_INSTANCE_INFO
- KSPROPERTY_SYSAUDIO_SELECT_GRAPH
-*/
-
-#define KSPROPSETID_Sysaudio_Pin
-/*
- KSPROPERTY_SYSAUDIO_ATTACH_VIRTUAL_SOURCE
-*/
-
#define KSPROPSETID_TopologyNode
/*
KSPROPERTY_TOPOLOGYNODE_ENABLE
*/
-
-
-/* ===============================================================
- Event Sets for audio drivers - TODO
-*/
-#define KSEVENTSETID_AudioControlChange
-/*
- KSEVENT_CONTROL_CHANGE
-*/
-
-
-
/* ===============================================================
Node Types
*/
TODO ...
*/
+#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)
+
+
/* ===============================================================
KSMEMORY_TYPE_xxx
(values have been checked)
*/
+#ifndef _MSC_VER
+
+#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\
+}
+
+#else
+
+#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\
+}
+
+#endif
+
+
typedef enum
{
KsObjectTypeDevice,
KSSTATE_ACQUIRE,
KSSTATE_PAUSE,
KSSTATE_RUN
-} KSSTATE;
+} KSSTATE, *PKSSTATE;
typedef enum
{
{
KSPIN_DATAFLOW_IN = 1,
KSPIN_DATAFLOW_OUT
-} KSPIN_DATAFLOW;
+} KSPIN_DATAFLOW, *PKSPIN_DATAFLOW;
typedef enum
{
KSPIN_COMMUNICATION_SOURCE,
KSPIN_COMMUNICATION_BOTH,
KSPIN_COMMUNICATION_BRIDGE
-} KSPIN_COMMUNICATION;
+} KSPIN_COMMUNICATION, *PKSPIN_COMMUNICATION;
typedef enum
{
} KSCOMPLETION_INVOCATION;
-
+#if defined(_NTDDK_)
/* MOVE ME */
-typedef NTSTATUS (*PFNKSCONTEXT_DISPATCH)(
+typedef NTSTATUS (NTAPI *PFNKSCONTEXT_DISPATCH)(
IN PVOID Context,
IN PIRP Irp);
+#endif
+
+#if defined(_NTDDK_) && !defined(__wtypes_h__)
+enum VARENUM {
+ VT_EMPTY = 0,
+ VT_NULL = 1,
+ VT_I2 = 2,
+ VT_I4 = 3,
+ VT_R4 = 4,
+ VT_R8 = 5,
+ VT_CY = 6,
+ VT_DATE = 7,
+ VT_BSTR = 8,
+ VT_DISPATCH = 9,
+ VT_ERROR = 10,
+ VT_BOOL = 11,
+ VT_VARIANT = 12,
+ VT_UNKNOWN = 13,
+ VT_DECIMAL = 14,
+ VT_I1 = 16,
+ VT_UI1 = 17,
+ VT_UI2 = 18,
+ VT_UI4 = 19,
+ VT_I8 = 20,
+ VT_UI8 = 21,
+ VT_INT = 22,
+ VT_UINT = 23,
+ VT_VOID = 24,
+ VT_HRESULT = 25,
+ VT_PTR = 26,
+ VT_SAFEARRAY = 27,
+ VT_CARRAY = 28,
+ VT_USERDEFINED = 29,
+ VT_LPSTR = 30,
+ VT_LPWSTR = 31,
+ VT_FILETIME = 64,
+ VT_BLOB = 65,
+ VT_STREAM = 66,
+ VT_STORAGE = 67,
+ VT_STREAMED_OBJECT = 68,
+ VT_STORED_OBJECT = 69,
+ VT_BLOB_OBJECT = 70,
+ VT_CF = 71,
+ VT_CLSID = 72,
+ VT_VECTOR = 0x1000,
+ VT_ARRAY = 0x2000,
+ VT_BYREF = 0x4000,
+ VT_RESERVED = 0x8000,
+ VT_ILLEGAL = 0xffff,
+ VT_ILLEGALMASKED = 0xfff,
+ VT_TYPEMASK = 0xfff
+};
+#endif
+
+#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_SPECIFIER_WILDCARD STATIC_GUID_NULL
+#define KSDATAFORMAT_SPECIFIER_WILDCARD GUID_NULL
/* ===============================================================
Framing
typedef struct
{
-} KS_FRAMING_ITEM, *PKS_FRAMING_ITEM;
+ ULONG MinFrameSize;
+ ULONG MaxFrameSize;
+ ULONG Stepping;
+} KS_FRAMING_RANGE, *PKS_FRAMING_RANGE;
typedef struct
{
-} KS_FRAMING_RANGE, *PKS_FRAMING_RANGE;
+ KS_FRAMING_RANGE Range;
+ ULONG InPlaceWeight;
+ ULONG NotInPlaceWeight;
+} KS_FRAMING_RANGE_WEIGHTED, *PKS_FRAMING_RANGE_WEIGHTED;
typedef struct
{
- /* Obsolete */
-} KS_FRAMING_RANGE_WEIGHTED, *PKS_FRAMING_RANGE_WEIGHTED;
+ 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 RatioNumerator;
+ ULONG RatioDenominator;
+ ULONG RatioConstantMargin;
} KS_COMPRESSION, *PKS_COMPRESSION;
Dispatch Table
http://www.osronline.com/DDKx/stream/ks-struct_494j.htm
*/
-
+#if defined(_NTDDK_)
typedef struct
{
PDRIVER_DISPATCH DeviceIoControl;
PFAST_IO_WRITE FastWrite;
} KSDISPATCH_TABLE, *PKSDISPATCH_TABLE;
+
+#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
+VOID
+(NTAPI *PFNREFERENCEDEVICEOBJECT)(
+ IN PVOID Context
+ );
+
+typedef
+VOID
+(NTAPI *PFNDEREFERENCEDEVICEOBJECT)(
+ IN PVOID Context
+ );
+
+typedef
+NTSTATUS
+(NTAPI *PFNQUERYREFERENCESTRING)(
+ IN PVOID Context,
+ IN OUT PWCHAR *String
+ );
+
typedef struct
{
+ INTERFACE Interface;
+ PFNREFERENCEDEVICEOBJECT ReferenceDeviceObject;
+ PFNDEREFERENCEDEVICEOBJECT DereferenceDeviceObject;
+ PFNQUERYREFERENCESTRING QueryReferenceString;
} BUS_INTERFACE_REFERENCE, *PBUS_INTERFACE_REFERENCE;
+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;
+
+#endif
+
typedef struct
{
GUID Manufacturer;
ULONG Revision;
} KSCOMPONENTID, *PKSCOMPONENTID;
-typedef struct
-{
-} KSBUFFER_ITEM, *PKSBUFFER_ITEM;
-
/* ===============================================================
Properties
*/
typedef struct
{
-} KSPROPERTY_BOUNDS_LONG, *PKSPROPERTY_BOUNDS_LONG;
+ GUID PropertySet;
+ ULONG Count;
+} KSPROPERTY_SERIALHDR, *PKSPROPERTY_SERIALHDR;
typedef struct
{
-} KSPROPERTY_BOUNDS_LONGLONG, *PKSPROPERTY_BOUNDS_LONGLONG;
+ KSIDENTIFIER PropTypeSet;
+ ULONG Id;
+ ULONG PropertyLength;
+} KSPROPERTY_SERIAL, *PKSPROPERTY_SERIAL;
-typedef struct
+
+typedef union
{
-} KSPROPERTY_DESCRIPTION, *PKSPROPERTY_DESCRIPTION;
+ struct {
+ LONG SignedMinimum;
+ LONG SignedMaximum;
+
+#if defined( _KS_NO_ANONYMOUS_STRUCTURES_ )
+ }_SIGNED;
+#else
+ };
+#endif
-typedef struct
+ struct {
+ ULONG UnsignedMinimum;
+ ULONG UnsignedMaximum;
+#if defined( _KS_NO_ANONYMOUS_STRUCTURES_ )
+ }_UNSIGNED;
+#else
+ };
+#endif
+
+} KSPROPERTY_BOUNDS_LONG, *PKSPROPERTY_BOUNDS_LONG;
+
+typedef union
{
-} KSPROPERTY_ITEM, *PKSPROPERTY_ITEM;
+ struct {
+ LONGLONG SignedMinimum;
+ LONGLONG SignedMaximum;
+#if defined( _KS_NO_ANONYMOUS_STRUCTURES_ )
+ }_SIGNED64;
+#else
+ };
+#endif
+
+ struct {
+#if defined(_NTDDK_)
+ ULONGLONG UnsignedMinimum;
+ ULONGLONG UnsignedMaximum;
+#else
+ DWORDLONG UnsignedMinimum;
+ DWORDLONG UnsignedMaximum;
+#endif
+#if defined( _KS_NO_ANONYMOUS_STRUCTURES_ )
+ }_UNSIGNED64;
+#else
+ };
+#endif
+} KSPROPERTY_BOUNDS_LONGLONG, *PKSPROPERTY_BOUNDS_LONGLONG;
typedef struct
{
-} KSPROPERTY_MEDIAAVAILABLE, *PKSPROPERTY_MEDIAAVAILABLE;
+ ULONG AccessFlags;
+ ULONG DescriptionSize;
+ KSIDENTIFIER PropTypeSet;
+ ULONG MembersListCount;
+ ULONG Reserved;
+} KSPROPERTY_DESCRIPTION, *PKSPROPERTY_DESCRIPTION;
typedef struct
{
+ ULONG MembersFlags;
+ ULONG MembersSize;
+ ULONG MembersCount;
+ ULONG Flags;
} KSPROPERTY_MEMBERSHEADER, *PKSPROPERTY_MEMBERSHEADER;
-typedef struct
-{
+typedef struct {
+ KSPROPERTY_MEMBERSHEADER MembersHeader;
+ const VOID* Members;
} KSPROPERTY_MEMBERSLIST, *PKSPROPERTY_MEMBERSLIST;
-typedef struct
-{
-} KSPROPERTY_POSITIONS, *PKSPROPERTY_POSITIONS;
+typedef struct {
+ KSIDENTIFIER PropTypeSet;
+ ULONG MembersListCount;
+ const KSPROPERTY_MEMBERSLIST* MembersList;
+} KSPROPERTY_VALUES, *PKSPROPERTY_VALUES;
-typedef struct
-{
-} KSPROPERTY_SERIAL, *PKSPROPERTY_SERIAL;
+#if defined(_NTDDK_)
+typedef NTSTATUS (NTAPI *PFNKSHANDLER)(
+ IN PIRP Irp,
+ IN PKSIDENTIFIER Request,
+ IN OUT PVOID Data);
-typedef struct
+typedef struct
{
-} KSPROPERTY_SERIALHDR, *PKSPROPERTY_SERIALHDR;
+ ULONG PropertyId;
+ union
+ {
+ PFNKSHANDLER GetPropertyHandler;
+ BOOLEAN GetSupported;
+ };
+ ULONG MinProperty;
+ ULONG MinData;
+ union {
+ PFNKSHANDLER SetPropertyHandler;
+ BOOLEAN SetSupported;
+ };
+ const KSPROPERTY_VALUES * Values;
+ ULONG RelationsCount;
+ const KSPROPERTY * Relations;
+ PFNKSHANDLER SupportHandler;
+ ULONG SerializedSize;
+} KSPROPERTY_ITEM, *PKSPROPERTY_ITEM;
+
+
+typedef
+BOOLEAN
+(NTAPI *PFNKSFASTHANDLER)(
+ IN PFILE_OBJECT FileObject,
+ IN PKSIDENTIFIER Request,
+ IN ULONG RequestLength,
+ IN OUT PVOID Data,
+ IN ULONG DataLength,
+ OUT PIO_STATUS_BLOCK IoStatus
+ );
+
+typedef struct {
+ ULONG PropertyId;
+ union {
+ PFNKSFASTHANDLER GetPropertyHandler;
+ BOOLEAN GetSupported;
+ };
+ union {
+ PFNKSFASTHANDLER SetPropertyHandler;
+ BOOLEAN SetSupported;
+ };
+ ULONG Reserved;
+} KSFASTPROPERTY_ITEM, *PKSFASTPROPERTY_ITEM;
typedef struct
{
+ const GUID* Set;
+ ULONG PropertiesCount;
+ const KSPROPERTY_ITEM * PropertyItem;
+ ULONG FastIoCount;
+ const KSFASTPROPERTY_ITEM* FastIoTable;
} KSPROPERTY_SET, *PKSPROPERTY_SET;
+#endif
+
typedef struct
{
+ ULONG SteppingDelta;
+ ULONG Reserved;
+ KSPROPERTY_BOUNDS_LONG Bounds;
} KSPROPERTY_STEPPING_LONG, *PKSPROPERTY_STEPPING_LONG;
typedef struct
{
+#if defined(_NTDDK_)
+ ULONGLONG SteppingDelta;
+#else
+ DWORDLONG SteppingDelta;
+#endif
+ KSPROPERTY_BOUNDS_LONGLONG Bounds;
} KSPROPERTY_STEPPING_LONGLONG, *PKSPROPERTY_STEPPING_LONGLONG;
-typedef struct
-{
-} KSPROPERTY_VALUES, *PKSPROPERTY_VALUES;
-
-
/* ===============================================================
Allocator Framing
*/
typedef struct
{
+ union {
+ ULONG OptionsFlags;
+ ULONG RequirementsFlags;
+ };
+#if defined(_NTDDK_)
+ POOL_TYPE PoolType;
+#else
+ ULONG PoolType;
+#endif
+ ULONG Frames;
+ ULONG FrameSize;
+ ULONG FileAlignment;
+ ULONG Reserved;
} KSALLOCATOR_FRAMING, *PKSALLOCATOR_FRAMING;
typedef struct
{
+ ULONG CountItems;
+ ULONG PinFlags;
+ KS_COMPRESSION OutputCompression;
+ ULONG PinWeight;
+ KS_FRAMING_ITEM FramingItem[1];
} KSALLOCATOR_FRAMING_EX, *PKSALLOCATOR_FRAMING_EX;
+#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
/* ===============================================================
Quality
typedef struct
{
+ PVOID Context;
+ ULONG Proportion;
+ LONGLONG DeltaTime;
} KSQUALITY, *PKSQUALITY;
typedef struct
typedef struct
{
+ LONGLONG PresentationStart;
+ LONGLONG Duration;
+ KSPIN_INTERFACE Interface;
+ LONG Rate;
+ ULONG Flags;
} KSRATE, *PKSRATE;
typedef struct
{
+ KSPROPERTY Property;
+ KSRATE Rate;
} KSRATE_CAPABILITY, *PKSRATE_CAPABILITY;
typedef struct
typedef struct
{
+ ULONG NotificationType;
+ union {
+ struct {
+ HANDLE Event;
+ ULONG_PTR Reserved[2];
+ } EventHandle;
+ struct {
+ HANDLE Semaphore;
+ ULONG Reserved;
+ LONG Adjustment;
+ } SemaphoreHandle;
+#if defined(_NTDDK_)
+ struct {
+ PVOID Event;
+ KPRIORITY Increment;
+ ULONG_PTR Reserved;
+ } EventObject;
+ struct {
+ PVOID Semaphore;
+ KPRIORITY Increment;
+ LONG Adjustment;
+ } SemaphoreObject;
+ struct {
+ PKDPC Dpc;
+ ULONG ReferenceCount;
+ ULONG_PTR Reserved;
+ } Dpc;
+ struct {
+ PWORK_QUEUE_ITEM WorkQueueItem;
+ WORK_QUEUE_TYPE WorkQueueType;
+ ULONG_PTR Reserved;
+ } WorkItem;
+ struct {
+ PWORK_QUEUE_ITEM WorkQueueItem;
+ PKSWORKER KsWorkerObject;
+ ULONG_PTR Reserved;
+ } KsWorkItem;
+#endif
+ 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
+
+
+#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
+{
+ ULONG Size;
+ ULONG Flags;
+ union {
+ HANDLE ObjectHandle;
+ PVOID ObjectPointer;
+ };
+ PVOID Reserved;
+ KSEVENT Event;
+ KSEVENTDATA EventData;
} KSRELATIVEEVENT, *PKSRELATIVEEVENT;
+#define KSRELATIVEEVENT_FLAG_HANDLE 0x00000001
+#define KSRELATIVEEVENT_FLAG_POINTER 0x00000002
/* ===============================================================
Timing
*/
+
+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;
+
+
+
typedef struct
{
LONGLONG Time;
typedef struct
{
+ LONGLONG Time;
+ LONGLONG SystemTime;
} KSCORRELATED_TIME, *PKSCORRELATED_TIME;
typedef struct
{
- KSPROPERTY Property;
- GUID SourceFormat;
- GUID TargetFormat;
- LONGLONG Time;
-} KSP_TIMEFORMAT, *PKSP_TIMEFORMAT;
-
-typedef struct
-{
-} KSINTERVAL, *PKSINTERVAL;
-
-typedef struct
-{
+ LONGLONG Duration;
+ ULONG FrameFlags;
+ ULONG Reserved;
} KSFRAMETIME, *PKSFRAMETIME;
Clocks
*/
-typedef struct
-{
-} KSCLOCK, *PKSCLOCK, *PKSDEFAULTCLOCK; /* OK ? */
+typedef PVOID PKSDEFAULTCLOCK;
typedef struct
{
+ ULONG CreateFlags;
} KSCLOCK_CREATE, *PKSCLOCK_CREATE;
+#if defined(_NTDDK_)
+
+typedef
+LONGLONG
+(FASTCALL *PFNKSCLOCK_GETTIME)(
+ IN PFILE_OBJECT FileObject
+ );
+typedef
+LONGLONG
+(FASTCALL *PFNKSCLOCK_CORRELATEDTIME)(
+ IN PFILE_OBJECT FileObject,
+ OUT PLONGLONG SystemTime);
+
typedef struct
{
+ PFNKSCLOCK_GETTIME GetTime;
+ PFNKSCLOCK_GETTIME GetPhysicalTime;
+ PFNKSCLOCK_CORRELATEDTIME GetCorrelatedTime;
+ PFNKSCLOCK_CORRELATEDTIME GetCorrelatedPhysicalTime;
} KSCLOCK_FUNCTIONTABLE, *PKSCLOCK_FUNCTIONTABLE;
Objects ??? SORT ME!
*/
+#define KSCREATE_ITEM_SECURITYCHANGED 0x1
+#define KSCREATE_ITEM_WILDCARD 0x2
+#define KSCREATE_ITEM_NOPARAMETERS 0x4
+#define KSCREATE_ITEM_FREEONSTOP 0x8
+
typedef struct
{
-} KSOBJECT_CREATE, *PKSOBJECT_CREATE;
+ PDRIVER_DISPATCH Create;
+ PVOID Context;
+ UNICODE_STRING ObjectClass;
+ PSECURITY_DESCRIPTOR SecurityDescriptor;
+ ULONG Flags;
+} KSOBJECT_CREATE_ITEM, *PKSOBJECT_CREATE_ITEM;
typedef struct
{
-} KSOBJECT_CREATE_ITEM, *PKSOBJECT_CREATE_ITEM;
+ ULONG CreateItemsCount;
+ PKSOBJECT_CREATE_ITEM CreateItemsList;
+} KSOBJECT_CREATE, *PKSOBJECT_CREATE;
-typedef VOID (*PFNKSITEMFREECALLBACK)(
+typedef VOID (NTAPI *PFNKSITEMFREECALLBACK)(
IN PKSOBJECT_CREATE_ITEM CreateItem);
-typedef struct {
+#endif
+
+typedef struct
+{
ULONG Size;
ULONG Count;
} KSMULTIPLE_ITEM, *PKSMULTIPLE_ITEM;
typedef struct
{
+ KSEVENT Event;
+ PKSEVENTDATA EventData;
+ PVOID Reserved;
} KSQUERYBUFFER, *PKSQUERYBUFFER;
typedef struct
{
+ PVOID Context;
+ ULONG Status;
} KSERROR, *PKSERROR;
-typedef struct
-{
-} KSDPC_ITEM, *PKSDPC_ITEM;
-
-
/* ===============================================================
Methods
*/
+#if defined(_NTDDK_)
typedef struct
{
-} KSMETHOD_SET, *PKSMETHOD_SET;
-
-typedef struct
-{
+ ULONG MethodId;
+ union {
+ PFNKSHANDLER MethodHandler;
+ BOOLEAN MethodSupported;
+ };
+ ULONG MinMethod;
+ ULONG MinData;
+ PFNKSHANDLER SupportHandler;
+ ULONG Flags;
} KSMETHOD_ITEM, *PKSMETHOD_ITEM;
-typedef struct
-{
-} KSFASTMETHOD_ITEM, *PKSFASTMETHOD_ITEM;
+#ifndef _MSC_VER
+#define DEFINE_KSMETHOD_ITEM(MethodId, Flags,\
+ MethodHandler,\
+ MinMethod, MinData, SupportHandler)\
+{\
+ MethodId, {(PFNKSHANDLER)MethodHandler}, MinMethod, MinData,\
+ SupportHandler, Flags\
+}
-/* ===============================================================
- Nodes
-*/
+#else
+
+#define DEFINE_KSMETHOD_ITEM(MethodId, Flags,\
+ MethodHandler,\
+ MinMethod, MinData, SupportHandler)\
+{\
+ MethodId, (PFNKSHANDLER)MethodHandler, MinMethod, MinData,\
+ SupportHandler, Flags\
+}
+
+
+
+#endif
+
+
+typedef struct
+{
+ ULONG MethodId;
+ union {
+ PFNKSFASTHANDLER MethodHandler;
+ BOOLEAN MethodSupported;
+ };
+} KSFASTMETHOD_ITEM, *PKSFASTMETHOD_ITEM;
+
+#define DEFINE_KSFASTMETHOD_ITEM(MethodId, MethodHandler)\
+{\
+ MethodId, (PFNKSFASTHANDLER)MethodHandler\
+}
+
+
+typedef struct
+{
+ const GUID* Set;
+ ULONG MethodsCount;
+ const KSMETHOD_ITEM* MethodItem;
+ ULONG FastIoCount;
+ const KSFASTMETHOD_ITEM*FastIoTable;
+} KSMETHOD_SET, *PKSMETHOD_SET;
+
+
+#define DEFINE_KSMETHOD_SET(Set,\
+ MethodsCount,\
+ MethodItem,\
+ FastIoCount,\
+ FastIoTable)\
+{\
+ Set,\
+ MethodsCount,\
+ MethodItem,\
+ FastIoCount,\
+ FastIoTable\
+}
+
+#endif
+/* ===============================================================
+ Nodes
+*/
typedef struct
{
+ KSPROPERTY Property;
+ ULONG NodeId;
+ ULONG Reserved;
} KSP_NODE, *PKSP_NODE;
typedef struct
typedef struct
{
+ KSEVENT Event;
+ ULONG NodeId;
+ ULONG Reserved;
} KSE_NODE, *PKSE_NODE;
-typedef struct
-{
+typedef struct {
+ ULONG CreateFlags;
+ ULONG Node;
} KSNODE_CREATE, *PKSNODE_CREATE;
-/* ===============================================================
- Properties?
-*/
-
-typedef struct
-{
-} KSFASTPROPERTY_ITEM, *PKSFASTPROPERTY_ITEM;
-
-
/* ===============================================================
Events
*/
+typedef struct _KSEVENT_ENTRY KSEVENT_ENTRY, *PKSEVENT_ENTRY;
+#if defined(_NTDDK_)
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
-{
-} KSEVENT_SET, *PKSEVENT_SET;
+typedef NTSTATUS (NTAPI *PFNKSADDEVENT)(
+ IN PIRP Irp,
+ IN PKSEVENTDATA EventData,
+ IN struct _KSEVENT_ENTRY* EventEntry);
+
+typedef
+VOID
+(NTAPI *PFNKSREMOVEEVENT)(
+ IN PFILE_OBJECT FileObject,
+ IN struct _KSEVENT_ENTRY* EventEntry
+ );
typedef struct
{
+ ULONG EventId;
+ ULONG DataInput;
+ ULONG ExtraEntryData;
+ PFNKSADDEVENT AddHandler;
+ PFNKSREMOVEEVENT RemoveHandler;
+ PFNKSHANDLER SupportHandler;
} KSEVENT_ITEM, *PKSEVENT_ITEM;
-typedef struct _KSEVENT_ENTRY
-{
-} KSEVENT_ENTRY, *PKSEVENT_ENTRY;
-
typedef struct
{
-} KSEVENTDATA, *PKSEVENTDATA;
+ const GUID* Set;
+ ULONG EventsCount;
+ const KSEVENT_ITEM* EventItem;
+} KSEVENT_SET, *PKSEVENT_SET;
+struct _KSEVENT_ENTRY
+{
+ LIST_ENTRY ListEntry;
+ PVOID Object;
+ union {
+ PKSDPC_ITEM DpcItem;
+ PKSBUFFER_ITEM BufferItem;
+ };
+ PKSEVENTDATA EventData;
+ ULONG NotificationType;
+ const KSEVENT_SET* EventSet;
+ const KSEVENT_ITEM* EventItem;
+ PFILE_OBJECT FileObject;
+ ULONG SemaphoreAdjustment;
+ ULONG Reserved;
+ ULONG Flags;
+};
+#endif
/* ===============================================================
Pins
*/
+#if defined(_NTDDK_)
+
+typedef struct _KSPIN KSPIN, *PKSPIN;
+typedef struct _KSSTREAM_POINTER KSSTREAM_POINTER, *PKSSTREAM_POINTER;
+typedef struct _KSSTREAM_POINTER_OFFSET KSSTREAM_POINTER_OFFSET, *PKSSTREAM_POINTER_OFFSET;
+typedef struct _KSMAPPING KSMAPPING, *PKSMAPPING;
+typedef struct _KSPROCESSPIN KSPROCESSPIN, *PKSPROCESSPIN;
+
+#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
+NTSTATUS
+(NTAPI *PFNKSPINHANDSHAKE)(
+ IN PKSPIN Pin,
+ IN PKSHANDSHAKE In,
+ IN PKSHANDSHAKE Out
+ );
+
+typedef
+void
+(NTAPI *PFNKSPINPOWER)(
+ IN PKSPIN Pin,
+ IN DEVICE_POWER_STATE State
+ );
+
+typedef
+void
+(NTAPI *PFNKSPINFRAMERETURN)(
+ IN PKSPIN Pin,
+ IN PVOID Data OPTIONAL,
+ IN ULONG Size OPTIONAL,
+ IN PMDL Mdl OPTIONAL,
+ IN PVOID Context OPTIONAL,
+ IN NTSTATUS Status
+ );
+
+typedef
+void
+(NTAPI *PFNKSPINIRPCOMPLETION)(
+ IN PKSPIN Pin,
+ IN PIRP Irp
+ );
+
+typedef
+NTSTATUS
+(NTAPI *PFNKSPINIRP)(
+ IN PKSPIN Pin,
+ IN PIRP Irp
+ );
+
+typedef
+NTSTATUS
+(NTAPI *PFNKSPIN)(
+ IN PKSPIN Pin
+ );
+
+typedef
+void
+(NTAPI *PFNKSPINVOID)(
+ IN PKSPIN Pin
+ );
+
+typedef
+void
+(NTAPI *PFNKSSTREAMPOINTER)(
+ IN PKSSTREAM_POINTER StreamPointer
+ );
+
+typedef struct {
+ ULONG Count;
+ PKSATTRIBUTE* Attributes;
+} KSATTRIBUTE_LIST, *PKSATTRIBUTE_LIST;
+
+typedef
+NTSTATUS
+(NTAPI *PFNKSPINSETDATAFORMAT)(
+ IN PKSPIN Pin,
+ IN PKSDATAFORMAT OldFormat OPTIONAL,
+ IN PKSMULTIPLE_ITEM OldAttributeList OPTIONAL,
+ IN const KSDATARANGE* DataRange,
+ IN const KSATTRIBUTE_LIST* AttributeRange OPTIONAL
+ );
+
+typedef
+NTSTATUS
+(NTAPI *PFNKSPINSETDEVICESTATE)(
+ IN PKSPIN Pin,
+ IN KSSTATE ToState,
+ IN KSSTATE FromState
+ );
+
+typedef struct _KSCLOCK_DISPATCH KSCLOCK_DISPATCH, *PKSCLOCK_DISPATCH;
+typedef struct _KSALLOCATOR_DISPATCH KSALLOCATOR_DISPATCH, *PKSALLOCATOR_DISPATCH;
+
typedef struct
{
+ PFNKSPINIRP Create;
+ PFNKSPINIRP Close;
+ PFNKSPIN Process;
+ PFNKSPINVOID Reset;
+ PFNKSPINSETDATAFORMAT SetDataFormat;
+ PFNKSPINSETDEVICESTATE SetDeviceState;
+ PFNKSPIN Connect;
+ PFNKSPINVOID Disconnect;
+ const KSCLOCK_DISPATCH* Clock;
+ const KSALLOCATOR_DISPATCH* Allocator;
} KSPIN_DISPATCH, *PKSPIN_DISPATCH;
+typedef
+BOOLEAN
+(NTAPI *PFNKSPINSETTIMER)(
+ IN PKSPIN Pin,
+ IN PKTIMER Timer,
+ IN LARGE_INTEGER DueTime,
+ IN PKDPC Dpc
+ );
+
+typedef
+BOOLEAN
+(NTAPI *PFNKSPINCANCELTIMER)(
+ IN PKSPIN Pin,
+ IN PKTIMER Timer
+ );
+
+typedef
+LONGLONG
+(FASTCALL *PFNKSPINCORRELATEDTIME)(
+ IN PKSPIN Pin,
+ OUT PLONGLONG SystemTime
+ );
+
+typedef
+void
+(NTAPI *PFNKSPINRESOLUTION)(
+ IN PKSPIN Pin,
+ OUT PKSRESOLUTION Resolution
+ );
+
+struct _KSCLOCK_DISPATCH {
+ PFNKSPINSETTIMER SetTimer;
+ PFNKSPINCANCELTIMER CancelTimer;
+ PFNKSPINCORRELATEDTIME CorrelatedTime;
+ PFNKSPINRESOLUTION Resolution;
+};
+
+typedef
+NTSTATUS
+(NTAPI *PFNKSPININITIALIZEALLOCATOR)(
+ IN PKSPIN Pin,
+ IN PKSALLOCATOR_FRAMING AllocatorFraming,
+ OUT PVOID* Context
+ );
+
+typedef PVOID (NTAPI *PFNKSDELETEALLOCATOR)(
+ IN PVOID Context);
+
+typedef PVOID (NTAPI *PFNKSDEFAULTALLOCATE)(
+ IN PVOID Context);
+
+typedef PVOID (NTAPI *PFNKSDEFAULTFREE)(
+ IN PVOID Context,
+ IN PVOID Buffer);
+
+struct _KSALLOCATOR_DISPATCH {
+ PFNKSPININITIALIZEALLOCATOR InitializeAllocator;
+ PFNKSDELETEALLOCATOR DeleteAllocator;
+ PFNKSDEFAULTALLOCATE Allocate;
+ PFNKSDEFAULTFREE Free;
+};
+
typedef struct
{
+ ULONG PropertySetsCount;
+ ULONG PropertyItemSize;
+ const KSPROPERTY_SET* PropertySets;
+ ULONG MethodSetsCount;
+ ULONG MethodItemSize;
+ const KSMETHOD_SET* MethodSets;
+ ULONG EventSetsCount;
+ ULONG EventItemSize;
+ const KSEVENT_SET* EventSets;
+#if !defined(_WIN64)
+ PVOID Alignment;
+#endif
} KSAUTOMATION_TABLE, *PKSAUTOMATION_TABLE;
+
+
typedef struct
{
+ ULONG InterfacesCount;
+ const KSPIN_INTERFACE* Interfaces;
+ ULONG MediumsCount;
+ const KSPIN_MEDIUM* Mediums;
+ ULONG DataRangesCount;
+ const PKSDATARANGE* DataRanges;
+ KSPIN_DATAFLOW DataFlow;
+ KSPIN_COMMUNICATION Communication;
+ const GUID* Category;
+ const GUID* Name;
+ union {
+ LONGLONG Reserved;
+ struct {
+ ULONG ConstrainedDataRangesCount;
+ PKSDATARANGE* ConstrainedDataRanges;
+ };
+ };
} KSPIN_DESCRIPTOR, *PKSPIN_DESCRIPTOR;
-/* TODO */
-/* This is just to shut the compiler up so DON'T USE IT! */
-typedef void (*PFNKSINTERSECTHANDLER)(void);
-typedef void (*PFNKSINTERSECTHANDLEREX)(void);
+typedef
+NTSTATUS
+(NTAPI *PFNKSINTERSECTHANDLER)(
+ IN PIRP Irp,
+ IN PKSP_PIN Pin,
+ IN PKSDATARANGE DataRange,
+ OUT PVOID Data OPTIONAL
+ );
+
+typedef
+NTSTATUS
+(NTAPI *PFNKSINTERSECTHANDLEREX)(
+ IN PVOID Context,
+ IN PIRP Irp,
+ IN PKSP_PIN Pin,
+ IN PKSDATARANGE DataRange,
+ IN PKSDATARANGE MatchingDataRange,
+ IN ULONG DataBufferSize,
+ OUT PVOID Data OPTIONAL,
+ OUT PULONG DataSize
+ );
typedef struct
{
PFNKSINTERSECTHANDLEREX IntersectHandler;
} KSPIN_DESCRIPTOR_EX, *PKSPIN_DESCRIPTOR_EX;
-/* TODO */
-#define KSPIN_FLAG_DISPATCH_LEVEL_PROCESSING
-#define KSPIN_FLAG_CRITICAL_PROCESSING
-#define KSPIN_FLAG_HYPERCRITICAL_PROCESSING
-#define KSPIN_FLAG_ASYNCHRONOUS_PROCESSING
-#define KSPIN_FLAG_DO_NOT_INITIATE_PROCESSING
-#define KSPIN_FLAG_INITIATE_PROCESSING_ON_EVERY_ARRIVAL
-#define KSPIN_FLAG_FRAMES_NOT_REQUIRED_FOR_PROCESSING
-#define KSPIN_FLAG_ENFORCE_FIFO
-#define KSPIN_FLAG_GENERATE_MAPPINGS
-#define KSPIN_FLAG_DISTINCT_TRAILING_EDGE
-#define KSPIN_FLAG_PROCESS_IN_RUN_STATE_ONLY
-#define KSPIN_FLAG_SPLITTER
-#define KSPIN_FLAG_USE_STANDARD_TRANSPORT
-#define KSPIN_FLAG_DO_NOT_USE_STANDARD_TRANSPORT
-#define KSPIN_FLAG_FIXED_FORMAT
-#define KSPIN_FLAG_GENERATE_EOS_EVENTS
-#define KSPIN_FLAG_RENDERER
-#define KSPIN_FLAG_SOME_FRAMES_REQUIRED_FOR_PROCESSING
-#define KSPIN_FLAG_PROCESS_IF_ANY_IN_RUN_STATE
-#define KSPIN_FLAG_DENY_USERMODE_ACCESS
-#define KSPIN_FLAG_IMPLEMENT_CLOCK
+#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
+#if (NTDDI_VERSION >= NTDDI_WINXPSP2)
+#define KSFILTER_FLAG_DENY_USERMODE_ACCESS 0x80000000
+#endif
-typedef struct
+
+#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
+#if (NTDDI_VERSION >= NTDDI_WINXPSP2)
+#define KSPIN_FLAG_DENY_USERMODE_ACCESS 0x80000000
+#endif
+
+struct _KSPIN
{
const KSPIN_DESCRIPTOR_EX* Descriptor;
KSOBJECT_BAG Bag;
KSSTATE DeviceState;
KSRESET ResetState;
KSSTATE ClientState;
-} KSPIN, *PKSPIN;
+};
+
+#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)\
+}
+
+
+
+typedef
+void
+(NTAPI *PFNKSFREE)(
+ IN PVOID Data
+ );
+
+
+
+#define DEFINE_KSPROPERTY_TABLE(tablename)\
+ const KSPROPERTY_ITEM tablename[] =
+
+#endif
typedef struct
{
KSPRIORITY Priority;
} KSPIN_CONNECT, *PKSPIN_CONNECT;
-
/* ===============================================================
Topology
*/
} KSTOPOLOGY, *PKSTOPOLOGY;
+#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)\
+}
+
/* ===============================================================
??? SORT ME
*/
/* TODO */
typedef void* UNKNOWN;
-typedef PVOID (*PFNKSDEFAULTALLOCATE)(
- IN PVOID Context);
-
-typedef PVOID (*PFNKSDEFAULTFREE)(
- IN PVOID Context,
- IN PVOID Buffer);
-
-typedef PVOID (*PFNKSINITIALIZEALLOCATOR)(
+typedef PVOID (NTAPI *PFNKSINITIALIZEALLOCATOR)(
IN PVOID InitialContext,
IN PKSALLOCATOR_FRAMING AllocatorFraming,
OUT PVOID* Context);
-typedef PVOID (*PFNKSDELETEALLOCATOR)(
- IN PVOID Context);
-
-
-typedef NTSTATUS (*PFNKSALLOCATOR)(
+#if defined(_NTDDK_)
+typedef NTSTATUS (NTAPI *PFNKSALLOCATOR)(
IN PIRP Irp,
IN ULONG BufferSize,
- IN BOOL InputOperation);
-
-typedef NTSTATUS (*PFNKSHANDLER)(
- IN PIRP Irp,
- IN PKSIDENTIFIER Request,
- IN OUT PVOID Data);
+ IN BOOLEAN InputOperation);
-typedef BOOLEAN (*PFNKSFASTHANDLER)(
- IN PFILE_OBJECT FileObject,
- IN PKSIDENTIFIER UNALIGNED Request,
- IN ULONG RequestLength,
- IN OUT PVOID UNALIGNED Data,
- IN ULONG DataLength,
- OUT PIO_STATUS_BLOCK IoStatus);
-
-typedef NTSTATUS (*PFNKSADDEVENT)(
- IN PIRP Irp,
- IN PKSEVENTDATA EventData,
- IN struct _KSEVENT_ENTRY* EventEntry);
-
-typedef NTSTATUS (*PFNKINTERSECTHANDLEREX)(
+typedef NTSTATUS (NTAPI *PFNKINTERSECTHANDLEREX)(
IN PVOID Context,
IN PIRP Irp,
IN PKSP_PIN Pin,
OUT PVOID Data OPTIONAL,
OUT PULONG DataSize);
-typedef UNKNOWN PFNALLOCATORE_ALLOCATEFRAME;
-typedef UNKNOWN PFNALLOCATOR_FREEFRAME;
-/*
-typedef struct
-{
- PFNALLOCATOR_ALLOCATEFRAME AllocateFrame;
- PFNALLOCATOR_FREEFRAME FreeFrame;
-}
-*/
+typedef
+NTSTATUS
+(NTAPI *PFNALLOCATOR_ALLOCATEFRAME)(
+ IN PFILE_OBJECT FileObject,
+ PVOID *Frame
+ );
+
+typedef
+VOID
+(NTAPI *PFNALLOCATOR_FREEFRAME)(
+ IN PFILE_OBJECT FileObject,
+ IN PVOID Frame
+ );
+
+typedef struct {
+ PFNALLOCATOR_ALLOCATEFRAME AllocateFrame;
+ PFNALLOCATOR_FREEFRAME FreeFrame;
+} KSSTREAMALLOCATOR_FUNCTIONTABLE, *PKSSTREAMALLOCATOR_FUNCTIONTABLE;
+
+#endif
typedef struct
{
ULONG DataUsed;
PVOID Data;
ULONG OptionsFlags;
+#ifdef _WIN64
+ ULONG Reserved;
+#endif
} KSSTREAM_HEADER, *PKSSTREAM_HEADER;
-
+#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_BUFFEREDTRANSFER 0x00000400
+#define KSSTREAM_HEADER_OPTIONSF_VRAM_DATA_TRANSFER 0x00000800
+#define KSSTREAM_HEADER_OPTIONSF_LOOPEDDATA 0x80000000
/* ===============================================================
XP / DX8
*/
+#if defined(_NTDDK_)
+struct _KSMAPPING {
+ PHYSICAL_ADDRESS PhysicalAddress;
+ ULONG ByteCount;
+ ULONG Alignment;
+};
+#endif
-typedef struct
+typedef enum {
+ KSSTREAM_POINTER_STATE_UNLOCKED = 0,
+ KSSTREAM_POINTER_STATE_LOCKED
+} KSSTREAM_POINTER_STATE;
+
+typedef struct _KSGATE KSGATE, *PKSGATE;
+typedef struct _KSPROCESSPIN_INDEXENTRY KSPROCESSPIN_INDEXENTRY, *PKSPROCESSPIN_INDEXENTRY;
+
+struct _KSGATE {
+ LONG Count;
+ PKSGATE NextGate;
+};
+
+struct _KSSTREAM_POINTER_OFFSET
{
- /* TODO */
-} KSPROCESSPIN, *PKSPROCESSPIN;
+#if defined(_NTDDK_)
+ union {
+ PUCHAR Data;
+ PKSMAPPING Mappings;
+ };
+#else
+ PUCHAR Data;
+#endif
+#if !defined(_WIN64)
+ PVOID Alignment;
+#endif
+ ULONG Count;
+ ULONG Remaining;
+};
+#if defined(_NTDDK_)
+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;
+};
-typedef struct
+struct _KSPROCESSPIN_INDEXENTRY
{
PKSPROCESSPIN* Pins;
ULONG Count;
-} KSPROCESSPIN_INDEXENTRY, *PKSPROCESSPIN_INDEXENTRY;
-
+};
+#endif
/* ===============================================================
Device Dispatch
*/
+
+
+
#if defined(_NTDDK_)
-typedef struct
-{
- /* TODO */
-} KSDEVICE, *PKSDEVICE;
-typedef NTSTATUS (*PFNKSDEVICECREATE)(
+typedef struct _KSFILTER_DISPATCH KSFILTER_DISPATCH, *PKSFILTER_DISPATCH;
+typedef struct _KSDEVICE KSDEVICE, *PKSDEVICE;
+typedef struct _KSFILTER KSFILTER, *PKSFILTER;
+typedef struct _KSNODE_DESCRIPTOR KSNODE_DESCRIPTOR, *PKSNODE_DESCRIPTOR;
+typedef struct _KSFILTER_DESCRIPTOR KSFILTER_DESCRIPTOR, *PKSFILTER_DESCRIPTOR;
+typedef struct _KSDEVICE_DESCRIPTOR KSDEVICE_DESCRIPTOR, *PKSDEVICE_DESCRIPTOR;
+
+typedef NTSTATUS (NTAPI *PFNKSDEVICECREATE)(
IN PKSDEVICE Device);
-typedef NTSTATUS (*PFNKSDEVICEPNPSTART)(
+typedef NTSTATUS (NTAPI *PFNKSDEVICEPNPSTART)(
IN PKSDEVICE Device,
IN PIRP Irp,
IN PCM_RESOURCE_LIST TranslatedResourceList OPTIONAL,
IN PCM_RESOURCE_LIST UntranslatedResourceList OPTIONAL);
-typedef NTSTATUS (*PFNKSDEVICE)(
+typedef NTSTATUS (NTAPI *PFNKSDEVICE)(
IN PKSDEVICE Device);
-typedef NTSTATUS (*PFNKSDEVICEIRP)(
+typedef NTSTATUS (NTAPI *PFNKSDEVICEIRP)(
IN PKSDEVICE Device,
IN PIRP Irp);
-typedef VOID (*PFNKSDEVICEIRPVOID)(
+typedef VOID (NTAPI *PFNKSDEVICEIRPVOID)(
IN PKSDEVICE Device,
IN PIRP Irp);
-typedef NTSTATUS (*PFNKSDEVICEQUERYCAPABILITIES)(
+typedef NTSTATUS (NTAPI *PFNKSDEVICEQUERYCAPABILITIES)(
IN PKSDEVICE Device,
IN PIRP Irp,
IN OUT PDEVICE_CAPABILITIES Capabilities);
-typedef NTSTATUS (*PFNKSDEVICEQUERYPOWER)(
+typedef NTSTATUS (NTAPI *PFNKSDEVICEQUERYPOWER)(
IN PKSDEVICE Device,
IN PIRP Irp,
IN DEVICE_POWER_STATE DeviceTo,
IN SYSTEM_POWER_STATE SystemFrom,
IN POWER_ACTION Action);
-typedef VOID (*PFNKSDEVICESETPOWER)(
+typedef VOID (NTAPI *PFNKSDEVICESETPOWER)(
IN PKSDEVICE Device,
IN PIRP Irp,
IN DEVICE_POWER_STATE To,
IN DEVICE_POWER_STATE From);
-typedef struct _KSDEVICE_DISPATCH
-{
+typedef struct _KSDEVICE_DISPATCH {
PFNKSDEVICECREATE Add;
PFNKSDEVICEPNPSTART Start;
PFNKSDEVICE PostStart;
PFNKSDEVICEIRPVOID Remove;
PFNKSDEVICEQUERYCAPABILITIES QueryCapabilities;
PFNKSDEVICEIRPVOID SurpriseRemoval;
- PFNKSDEVICEQUERYPOWER Querypower;
+ PFNKSDEVICEQUERYPOWER QueryPower;
PFNKSDEVICESETPOWER SetPower;
-} KSDEVICE_DISPATCH, *PKSDEVICE_DISPATCH;
+ PFNKSDEVICEIRP QueryInterface;
+}KSDEVICE_DISPATCH, *PKSDEVICE_DISPATCH;
+
+#if (NTDDI_VERSION >= NTDDI_LONGHORN)
+#define KSDEVICE_DESCRIPTOR_VERSION_2 (0x110)
+#define MIN_DEV_VER_FOR_FLAGS (0x110)
+#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;
+};
#endif
/* ===============================================================
Filter Dispatch
*/
#if defined(_NTDDK_)
-typedef struct
+struct _KSFILTER
{
-} KSFILTER, *PKSFILTER;
+ const KSFILTER_DESCRIPTOR* Descriptor;
+ KSOBJECT_BAG Bag;
+ PVOID Context;
+};
+
+typedef
+void
+(NTAPI *PFNKSFILTERPOWER)(
+ IN PKSFILTER Filter,
+ IN DEVICE_POWER_STATE State
+ );
-typedef NTSTATUS (*PFNKSFILTERIRP)(
+typedef NTSTATUS (NTAPI *PFNKSFILTERIRP)(
IN PKSFILTER Filter,
IN PIRP Irp);
-typedef NTSTATUS (*PFNKSFILTERPROCESS)(
- IN PKSFILTER FIlter,
+typedef NTSTATUS (NTAPI *PFNKSFILTERPROCESS)(
+ IN PKSFILTER Filter,
IN PKSPROCESSPIN_INDEXENTRY ProcessPinsIndex);
-typedef NTSTATUS (*PFNKSFILTERVOID)(
+typedef NTSTATUS (NTAPI *PFNKSFILTERVOID)(
IN PKSFILTER Filter);
-typedef struct _KSFILTER_DISPATCH
+struct _KSFILTER_DISPATCH
{
PFNKSFILTERIRP Create;
PFNKSFILTERIRP Close;
PFNKSFILTERPROCESS Process;
PFNKSFILTERVOID Reset;
-} KSFILTER_DISPATCH, *PKSFILTER_DISPATCH;
+};
-typedef struct {
+struct _KSNODE_DESCRIPTOR
+{
const KSAUTOMATION_TABLE* AutomationTable;
const GUID* Type;
const GUID* Name;
-} KSNODE_DESCRIPTOR, *PKSNODE_DESCRIPTOR;
+};
-typedef struct {
+struct _KSFILTER_DESCRIPTOR
+{
const KSFILTER_DISPATCH* Dispatch;
const KSAUTOMATION_TABLE* AutomationTable;
ULONG Version;
ULONG ConnectionsCount;
const KSTOPOLOGY_CONNECTION* Connections;
const KSCOMPONENTID* ComponentId;
-} KSFILTER_DESCRIPTOR, *PKSFILTER_DESCRIPTOR;
+};
-typedef struct
+#define KSFILTER_DESCRIPTOR_VERSION ((ULONG)-1)
+
+struct _KSDEVICE_DESCRIPTOR
{
- const KSDEVICE_DISPATCH* Dispatch;
- ULONG FilterDescriptorsCount;
- const KSFILTER_DESCRIPTOR*const* FilterDescriptors;
-} KSDEVICE_DESCRIPTOR, *PKSDEVICE_DESCRIPTOR;
+ const KSDEVICE_DISPATCH* Dispatch;
+ ULONG FilterDescriptorsCount;
+ const KSFILTER_DESCRIPTOR*const* FilterDescriptors;
+ ULONG Version;
+ ULONG Flags;
+};
+
+struct _KSFILTERFACTORY {
+ const KSFILTER_DESCRIPTOR* FilterDescriptor;
+ KSOBJECT_BAG Bag;
+ PVOID Context;
+};
+
+#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
+
#endif
/* ===============================================================
Minidriver Callbacks
*/
#if defined(_NTDDK_)
-typedef NTSTATUS (*KStrMethodHandler)(
+typedef NTSTATUS (NTAPI *KStrMethodHandler)(
IN PIRP Irp,
IN PKSIDENTIFIER Request,
IN OUT PVOID Data);
-typedef NTSTATUS (*KStrSupportHandler)(
+typedef NTSTATUS (NTAPI *KStrSupportHandler)(
IN PIRP Irp,
IN PKSIDENTIFIER Request,
IN OUT PVOID Data);
Clock Functions
*/
#if defined(_NTDDK_)
-typedef BOOLEAN (*PFNKSSETTIMER)(
+typedef BOOLEAN (NTAPI *PFNKSSETTIMER)(
IN PVOID Context,
IN PKTIMER Timer,
IN LARGE_INTEGER DueTime,
IN PKDPC Dpc);
-typedef BOOLEAN (*PFNKSCANCELTIMER)(
+typedef BOOLEAN (NTAPI *PFNKSCANCELTIMER)(
IN PVOID Context,
IN PKTIMER Timer);
/* ===============================================================
Event Functions
*/
+
#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
+BOOLEAN
+(NTAPI *PFNKSGENERATEEVENTCALLBACK)(
+ IN PVOID Context,
+ IN PKSEVENT_ENTRY EventEntry
+ );
+
KSDDKAPI NTSTATUS NTAPI
KsGenerateEvent(
IN PKSEVENT_ENTRY EntryEvent);
+KSDDKAPI void NTAPI
+KsGenerateEvents(
+ IN PVOID Object,
+ IN const GUID* EventSet OPTIONAL,
+ IN ULONG EventId,
+ IN ULONG DataSize,
+ IN PVOID Data OPTIONAL,
+ IN PFNKSGENERATEEVENTCALLBACK CallBack OPTIONAL,
+ IN PVOID CallBackContext OPTIONAL
+ );
+
+
KSDDKAPI NTSTATUS NTAPI
KsEnableEventWithAllocator(
IN PIRP Irp,
IN OUT PLIST_ENTRY EventsList,
IN KSEVENTS_LOCKTYPE EVentsFlags,
IN PVOID EventsLock);
-#endif
/* ===============================================================
Topology Functions
KSDDKAPI NTSTATUS NTAPI
KsPinDataIntersection(
IN PIRP Irp,
- IN PKSPIN Pin,
+ IN PKSP_PIN Pin,
OUT PVOID Data,
IN ULONG DescriptorsCount,
IN const KSPIN_DESCRIPTOR* Descriptor,
IN PFNKSINTERSECTHANDLEREX IntersectHandler OPTIONAL,
IN PVOID HandlerContext OPTIONAL);
+KSDDKAPI PKSFILTER NTAPI
+KsPinGetParentFilter(
+ IN PKSPIN Pin
+ );
+
+KSDDKAPI PKSPIN NTAPI
+KsPinGetNextSiblingPin(
+ IN PKSPIN Pin
+ );
+
+
/* Does this belong here? */
KSDDKAPI NTSTATUS NTAPI
IRP Helper Functions
*/
-typedef NTSTATUS (*PFNKSIRPLISTCALLBACK)(
+typedef NTSTATUS (NTAPI *PFNKSIRPLISTCALLBACK)(
IN PIRP Irp,
IN PVOID Context);
KsAllocateObjectCreateItem(
IN KSDEVICE_HEADER Header,
IN PKSOBJECT_CREATE_ITEM CreateItem,
- IN BOOL AllocateEntry,
+ IN BOOLEAN AllocateEntry,
IN PFNKSITEMFREECALLBACK ItemFreeCallback OPTIONAL);
KSDDKAPI NTSTATUS NTAPI
KsAllocateObjectHeader(
- OUT PVOID Header,
+ OUT KSOBJECT_HEADER *Header,
IN ULONG ItemsCount,
IN PKSOBJECT_CREATE_ITEM ItemsList OPTIONAL,
IN PIRP Irp,
IN KPROCESSOR_MODE RequestorMode);
+KSDDKAPI NTSTATUS NTAPI
+ KsDefaultForwardIrp(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp);
+
/* ===============================================================
Worker Management Functions
*/
Misc. Helper Functions
*/
+KSDDKAPI PVOID NTAPI
+KsGetNextSibling(
+ IN PVOID Object);
+
+
KSDDKAPI NTSTATUS NTAPI
KsCacheMedium(
IN PUNICODE_STRING SymbolicLink,
IN PKSPIN_MEDIUM Medium,
- IN DWORD PinDirection);
+ IN ULONG PinDirection);
KSDDKAPI NTSTATUS NTAPI
KsDefaultDispatchPnp(
IN KSDEVICE_HEADER Header,
IN PVOID Context);
-VOID
+KSDDKAPI VOID NTAPI
KsNullDriverUnload(
IN PDRIVER_OBJECT DriverObject);
KsSynchronousIoControlDevice(
IN PFILE_OBJECT FileObject,
IN KPROCESSOR_MODE RequestorMode,
- IN DWORD IoControl,
+ IN ULONG IoControl,
IN PVOID InBuffer,
IN ULONG InSize,
OUT PVOID OutBuffer,
IN ULONG OUtSize,
OUT PULONG BytesReturned);
+KSDDKAPI
+PKSPIN
+NTAPI
+KsFilterGetFirstChildPin(
+ IN PKSFILTER Filter,
+ IN ULONG PinId
+ );
+
+KSDDKAPI
+PFILE_OBJECT
+NTAPI
+KsPinGetConnectedPinFileObject(
+ IN PKSPIN Pin
+ );
+
+#else
+
+#if !defined( KS_NO_CREATE_FUNCTIONS )
+
+KSDDKAPI
+DWORD
+WINAPI
+KsCreateAllocator(
+ IN HANDLE ConnectionHandle,
+ IN PKSALLOCATOR_FRAMING AllocatorFraming,
+ OUT PHANDLE AllocatorHandle
+ );
+
+KSDDKAPI
+DWORD
+NTAPI
+KsCreateClock(
+ IN HANDLE ConnectionHandle,
+ IN PKSCLOCK_CREATE ClockCreate,
+ OUT PHANDLE ClockHandle
+ );
+
+KSDDKAPI
+DWORD
+WINAPI
+KsCreatePin(
+ IN HANDLE FilterHandle,
+ IN PKSPIN_CONNECT Connect,
+ IN ACCESS_MASK DesiredAccess,
+ OUT PHANDLE ConnectionHandle
+ );
+
+KSDDKAPI
+DWORD
+WINAPI
+KsCreateTopologyNode(
+ IN HANDLE ParentHandle,
+ IN PKSNODE_CREATE NodeCreate,
+ IN ACCESS_MASK DesiredAccess,
+ OUT PHANDLE NodeHandle
+ );
+
+#endif
+
+#endif
/* ===============================================================
AVStream Functions (XP / DirectX 8)
*/
#if defined(_NTDDK_)
-KSDDKAPI NTSTATUS NTAPI
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsMergeAutomationTables(
+ OUT PKSAUTOMATION_TABLE* AutomationTableAB,
+ IN PKSAUTOMATION_TABLE AutomationTableA OPTIONAL,
+ IN PKSAUTOMATION_TABLE AutomationTableB OPTIONAL,
+ IN KSOBJECT_BAG Bag OPTIONAL
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
KsInitializeDriver(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPath,
IN const KSDEVICE_DESCRIPTOR *Descriptor OPTIONAL);
-#endif
-#if 0
-typedef void (*PFNKSFILTERFACTORYPOWER)(
+typedef struct _KSFILTERFACTORY KSFILTERFACTORY, *PKSFILTERFACTORY; //FIXME
+
+
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsInitializeDevice (
+ IN PDEVICE_OBJECT FunctionalDeviceObject,
+ IN PDEVICE_OBJECT PhysicalDeviceObject,
+ IN PDEVICE_OBJECT NextDeviceObject,
+ IN const KSDEVICE_DESCRIPTOR* Descriptor OPTIONAL);
+
+
+typedef void (NTAPI *PFNKSFILTERFACTORYPOWER)(
IN PKSFILTERFACTORY FilterFactory,
IN DEVICE_POWER_STATE State);
-KSDDKAPI NTSTATUS NTAPI
+KSDDKAPI
+NTSTATUS
+NTAPI
_KsEdit(
IN KSOBJECT_BAG ObjectBag,
IN OUT PVOID* PointerToPointerToItem,
IN ULONG OldSize,
IN ULONG Tag);
+KSDDKAPI
VOID
+NTAPI
KsAcquireControl(
- IN PVOID Object)
-{
-}
+ IN PVOID Object);
+KSDDKAPI
VOID
+NTAPI
KsAcquireDevice(
- IN PKSDEVICE Device)
-{
-}
+ IN PKSDEVICE Device);
+KSDDKAPI
NTSTATUS
+NTAPI
KsAddDevice(
IN PDRIVER_OBJECT DriverObject,
- IN PDEVICE_OBJECT PhysicalDeviceObject)
-{
-}
+ IN PDEVICE_OBJECT PhysicalDeviceObject);
+KSDDKAPI
VOID
+NTAPI
KsAddEvent(
IN PVOID Object,
- IN PKSEVENT_ENTRY EventEntry)
-{
-}
+ IN PKSEVENT_ENTRY EventEntry);
+KSDDKAPI
NTSTATUS
+NTAPI
KsAddItemToObjectBag(
IN KSOBJECT_BAG ObjectBag,
IN PVOID Item,
- IN PFNKSFREE Free OPTIONAL)
-{
-}
+ IN PFNKSFREE Free OPTIONAL);
+KSDDKAPI
+ULONG
+NTAPI
+KsRemoveItemFromObjectBag(
+ IN KSOBJECT_BAG ObjectBag,
+ IN PVOID Item,
+ IN BOOLEAN Free);
+
+KSDDKAPI
NTSTATUS
+NTAPI
KsAllocateObjectBag(
IN PKSDEVICE Device,
- OUT KSOBJECT_BAG* ObjectBag)
-{
-}
+ OUT KSOBJECT_BAG* ObjectBag);
+
+KSDDKAPI
+VOID
+NTAPI
+KsFreeObjectBag(
+ IN KSOBJECT_BAG ObjectBag
+ );
+KSDDKAPI
VOID
+NTAPI
KsCompletePendingRequest(
- IN PIRP Irp)
-{
-}
+ IN PIRP Irp);
+KSDDKAPI
NTSTATUS
+NTAPI
KsCopyObjectBagItems(
IN KSOBJECT_BAG ObjectBagDestination,
- IN KSOBJECT_BAG ObjectBagSource)
-{
-}
+ IN KSOBJECT_BAG ObjectBagSource);
+KSDDKAPI
NTSTATUS
+NTAPI
KsCreateDevice(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT PhysicalDeviceObject,
IN const KSDEVICE_DESCRIPTOR* Descriptor OPTIONAL,
IN ULONG ExtensionSize OPTIONAL,
- OUT PKSDEVICE* Device OPTIONAL)
-{
-}
+ OUT PKSDEVICE* Device OPTIONAL);
+KSDDKAPI
NTSTATUS
+NTAPI
KsCreateFilterFactory(
IN PDEVICE_OBJECT DeviceObject,
IN const KSFILTER_DESCRIPTOR* Descriptor,
IN ULONG CreateItemFlags,
IN PFNKSFILTERFACTORYPOWER SleepCallback OPTIONAL,
IN PFNKSFILTERFACTORYPOWER WakeCallback OPTIONAL,
- OUT PKFSFILTERFACTORY FilterFactory OPTIONAL)
-{
-}
+ OUT PKSFILTERFACTORY *FilterFactory OPTIONAL);
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsFilterFactoryUpdateCacheData(
+ IN PKSFILTERFACTORY FilterFactory,
+ IN const KSFILTER_DESCRIPTOR *FilterDescriptor OPTIONAL
+ );
+
+KSDDKAPI
+PKSPIN
+NTAPI
+KsGetPinFromIrp(
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+PKSFILTER
+NTAPI
+KsGetFilterFromIrp(
+ IN PIRP Irp
+ );
+
+KSDDKAPI
NTSTATUS
+NTAPI
KsDefaultAddEventHandler(
IN PIRP Irp,
IN PKSEVENTDATA EventData,
- IN OUT PKSEVENT_ENTRY EventEntry)
+ IN OUT PKSEVENT_ENTRY EventEntry);
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsDispatchQuerySecurity(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+NTSTATUS
+NTAPI
+KsDispatchSetSecurity(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp
+ );
+
+KSDDKAPI
+PVOID
+NTAPI
+KsGetParent(
+ IN PVOID Object
+ );
+
+
+static
+PKSFILTERFACTORY
+__inline
+KsFilterGetParentFilterFactory(
+ IN PKSFILTER Filter
+ )
{
+ return (PKSFILTERFACTORY) KsGetParent((PVOID) Filter);
}
-NTSTATUS
-KsDeleteFilterFactory(
- IN PKSFILTERFACTORY FilterFactory)
+static
+PKSDEVICE
+__inline
+KsFilterFactoryGetParentDevice(
+ IN PKSFILTERFACTORY FilterFactory
+ )
{
+ return (PKSDEVICE) KsGetParent((PVOID) FilterFactory);
}
+
+
+#define KsDeleteFilterFactory(FilterFactory) \
+ KsFreeObjectCreateItemsByContext( \
+ *(KSDEVICE_HEADER *)( \
+ KsFilterFactoryGetParentDevice(FilterFactory)->FunctionalDeviceObject-> \
+ DeviceExtension), \
+ FilterFactory)
+
+KSDDKAPI
ULONG
+NTAPI
KsDeviceGetBusData(
IN PKSDEVICE Device,
IN ULONG DataType,
IN PVOID Buffer,
IN ULONG Offset,
- IN ULONG Length)
-{
-}
+ IN ULONG Length);
+
+
+KSDDKAPI
+PVOID
+NTAPI
+KsGetFirstChild(
+ IN PVOID Object
+ );
+KSDDKAPI
PKSFILTERFACTORY
+NTAPI
KsDeviceGetFirstChildFilterFactory(
- IN PKSDEVICE Device)
-{
-}
+ IN PKSDEVICE Device);
+
+#if defined(_UNKNOWN_H_) || defined(__IUnknown_INTERFACE_DEFINED__)
+
+KSDDKAPI
+PUNKNOWN
+NTAPI
+KsGetOuterUnknown(
+ IN PVOID Object
+ );
+static
+__inline
PUNKNOWN
KsDeviceGetOuterUnknown(
IN PKSDEVICE Device)
{
+ return KsGetOuterUnknown((PVOID) Device);
}
+KSDDKAPI
+PUNKNOWN
+NTAPI
+KsDeviceRegisterAggregatedClientUnknown(
+ IN PKSDEVICE Device,
+ IN PUNKNOWN ClientUnknown);
+
+
+#endif
+
+#if defined(_UNKNOWN_H_) || defined(__IUnknown_INTERFACE_DEFINED__)
+
+typedef interface IKsReferenceClock* PIKSREFERENCECLOCK;
+
+#undef INTERFACE
+#define INTERFACE IKsReferenceClock
+DECLARE_INTERFACE_(IKsReferenceClock,IUnknown)
+{
+ DEFINE_ABSTRACT_UNKNOWN() // For C
+
+ STDMETHOD_(LONGLONG,GetTime)(THIS
+ ) PURE;
+ STDMETHOD_(LONGLONG,GetPhysicalTime)(THIS
+ ) PURE;
+ STDMETHOD_(LONGLONG,GetCorrelatedTime)(THIS_
+ OUT PLONGLONG SystemTime
+ ) PURE;
+ STDMETHOD_(LONGLONG,GetCorrelatedPhysicalTime)(THIS_
+ OUT PLONGLONG SystemTime
+ ) PURE;
+ STDMETHOD_(NTSTATUS, GetResolution)(THIS_
+ OUT PKSRESOLUTION Resolution
+ ) PURE;
+ STDMETHOD_(NTSTATUS, GetState)(THIS_
+ OUT PKSSTATE State
+ ) PURE;
+};
+
+#undef INTERFACE
+#define INTERFACE IKsControl
+
+DEFINE_GUID(IID_IKsControl, 0x28F54685L, 0x06FD, 0x11D2, 0xB2, 0x7A, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96);
+
+DECLARE_INTERFACE_(IKsControl,IUnknown)
+{
+ STDMETHOD_(NTSTATUS, QueryInterface)( THIS_
+ REFIID InterfaceId,
+ PVOID* Interface)PURE;
+
+ STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+
+ STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+ STDMETHOD_(NTSTATUS, KsProperty)(THIS_
+ IN PKSPROPERTY Property,
+ IN ULONG PropertyLength,
+ IN OUT PVOID PropertyData,
+ IN ULONG DataLength,
+ OUT ULONG* BytesReturned
+ ) PURE;
+ STDMETHOD_(NTSTATUS, KsMethod)(THIS_
+ IN PKSMETHOD Method,
+ IN ULONG MethodLength,
+ IN OUT PVOID MethodData,
+ IN ULONG DataLength,
+ OUT ULONG* BytesReturned
+ ) PURE;
+ STDMETHOD_(NTSTATUS, KsEvent)(THIS_
+ IN PKSEVENT Event OPTIONAL,
+ IN ULONG EventLength,
+ IN OUT PVOID EventData,
+ IN ULONG DataLength,
+ OUT ULONG* BytesReturned
+ ) PURE;
+};
+
+#undef INTERFACE
+typedef IKsControl* PIKSCONTROL;
+
+#endif
+
+KSDDKAPI
VOID
+NTAPI
KsDeviceRegisterAdapterObject(
IN PKSDEVICE Device,
IN PADAPTER_OBJECT AdapterObject,
IN ULONG MaxMappingByteCount,
- IN ULONG MappingTableStride)
-{
-}
-
-KSDDKAPI PUNKNOWN NTAPI
-KsDeviceRegisterAggregatedClientUnknown(
- IN PKSDEVICE Device,
- IN PUNKNOWN ClientUnknown);
+ IN ULONG MappingTableStride);
+KSDDKAPI
ULONG
+NTAPI
KsDeviceSetBusData(
IN PKSDEVICE Device,
IN ULONG DataType,
IN PVOID Buffer,
IN ULONG Offset,
- IN ULONG Length)
-{
-}
+ IN ULONG Length);
+
+
+KSDDKAPI
+VOID
+NTAPI
+KsReleaseControl(
+ IN PVOID Object
+ );
#define KsDiscard(object, pointer) \
KsRemoveItemFromObjectBag(object->Bag, pointer, TRUE)
-VOID
-KsFilterAcquireControl(
- IN PKSFILTER Filter)
-{
-}
+#define KsFilterAcquireControl(Filter) \
+ KsAcquireControl((PVOID) Filter);
+
+#define KsFilterReleaseControl(Filter) \
+ KsReleaseControl((PVOID) Filter);
+
+#define KsFilterAddEvent(Filter, EventEntry) \
+ KsAddEvent(Filter,EventEntry);
+KSDDKAPI
VOID
+NTAPI
KsFilterAcquireProcessingMutex(
IN PKSFILTER Filter);
-VOID
-KsFilterAddEvent(
- IN PKSFILTER Filter,
- IN PKSEVENT_ENTRY EventEntry)
-{
-}
-KSDDKAPI NTSTATUS NTAPI
+KSDDKAPI
+NTSTATUS
+NTAPI
KsFilterAddTopologyConnections(
IN PKSFILTER Filter,
IN ULONG NewConnectionsCount,
- IN const KSTOPOLOGY_CONNECTION* NewTopologyConnections);
+ IN const KSTOPOLOGY_CONNECTION *const NewTopologyConnections);
+KSDDKAPI
VOID
+NTAPI
KsFilterAttemptProcessing(
IN PKSFILTER Filter,
IN BOOLEAN Asynchronous);
-KSDDKAPI NTSTATUS NTAPI
+KSDDKAPI
+NTSTATUS
+NTAPI
KsFilterCreateNode(
IN PKSFILTER Filter,
- IN const KSNODE_DESCRIPTOR* NodeDescriptor,
+ IN const KSNODE_DESCRIPTOR *const NodeDescriptor,
OUT PULONG NodeID);
-KSDDKAPI NTSTATUS NTAPI
+KSDDKAPI
+NTSTATUS
+NTAPI
KsFilterCreatePinFactory(
IN PKSFILTER Filter,
- IN const KSPIN_DESCRIPTOR_EX* PinDescriptor,
+ IN const KSPIN_DESCRIPTOR_EX *const PinDescriptor,
OUT PULONG PinID);
-PKSDEVICE __inline
+KSDDKAPI
+PKSDEVICE
+__inline
KsFilterFactoryGetDevice(
IN PKSFILTERFACTORY FilterFactory);
projects / reactos.git / blobdiff