[ros-diffs] [greatlrd] 32243: add more struct, define, type and so. around 48% completed of this header now
greatlrd at svn.reactos.org
greatlrd at svn.reactos.org
Sat Feb 9 21:25:34 CET 2008
Author: greatlrd
Date: Sat Feb 9 23:25:33 2008
New Revision: 32243
URL: http://svn.reactos.org/svn/reactos?rev=32243&view=rev
Log:
add more struct, define, type and so.
around 48% completed of this header now
Modified:
branches/reactx/reactos/include/dxsdk/ks.h
Modified: branches/reactx/reactos/include/dxsdk/ks.h
URL: http://svn.reactos.org/svn/reactos/branches/reactx/reactos/include/dxsdk/ks.h?rev=32243&r1=32242&r2=32243&view=diff
==============================================================================
--- branches/reactx/reactos/include/dxsdk/ks.h (original)
+++ branches/reactx/reactos/include/dxsdk/ks.h Sat Feb 9 23:25:33 2008
@@ -271,6 +271,9 @@
#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)
+#if defined(_NTDDK_)
+ #define IOCTL_KS_HANDSHAKE CTL_CODE(FILE_DEVICE_KS, 0x007, METHOD_NEITHER, FILE_ANY_ACCESS)
+#endif
#define KSPRIORITY_LOW 0x00000001
#define KSPRIORITY_NORMAL 0x40000000
@@ -392,6 +395,11 @@
#define KSDATARANGE_REQUIRED_ATTRIBUTES (1 << KSDATARANGE_BIT_REQUIRED_ATTRIBUTES)
#define KSATTRIBUTE_REQUIRED 0x00000001
+#define KSRATE_NOPRESENTATIONSTART 0x00000001
+#define KSRATE_NOPRESENTATIONDURATION 0x00000002
+
+#define KSFRAMETIME_VARIABLESIZE 0x00000001
+
#if defined(_NTDDK_)
@@ -443,6 +451,7 @@
#define STATIC_REFERENCE_BUS_INTERFACE STATIC_KSMEDIUMSETID_Standard
#define REFERENCE_BUS_INTERFACE KSMEDIUMSETID_Standard
+
typedef enum
{
KsInvokeOnSuccess = 1,
@@ -490,6 +499,17 @@
KSPROPERTY_STREAMALLOCATOR_FUNCTIONTABLE,
KSPROPERTY_STREAMALLOCATOR_STATUS
} KSPROPERTY_STREAMALLOCATOR;
+
+ typedef enum
+ {
+ KSEVENTS_NONE,
+ KSEVENTS_SPINLOCK,
+ KSEVENTS_MUTEX,
+ KSEVENTS_FMUTEX,
+ KSEVENTS_FMUTEXUNSAFE,
+ KSEVENTS_INTERRUPT,
+ KSEVENTS_ERESOURCE
+ } KSEVENTS_LOCKTYPE;
#if !defined(__wtypes_h__)
enum VARENUM
@@ -1393,12 +1413,602 @@
#if defined(_NTDDK_)
-typedef NTSTATUS (*PFNKSINTERSECTHANDLER)(IN PIRP Irp, IN PKSP_PIN Pin, IN PKSDATARANGE DataRange, OUT PVOID Data OPTIONAL);
-typedef NTSTATUS (*PFNKSINTERSECTHANDLEREX)(IN PVOID Context, IN PIRP Irp,
- IN PKSP_PIN Pin, IN PKSDATARANGE DataRange,
- IN PKSDATARANGE MatchingDataRange, IN ULONG DataBufferSize,
- OUT PVOID Data OPTIONAL, OUT PULONG DataSize);
+ typedef NTSTATUS (*PFNKSINTERSECTHANDLER)(IN PIRP Irp, IN PKSP_PIN Pin, IN PKSDATARANGE DataRange, OUT PVOID Data OPTIONAL);
+ typedef NTSTATUS (*PFNKSINTERSECTHANDLEREX)(IN PVOID Context, IN PIRP Irp,
+ IN PKSP_PIN Pin, IN PKSDATARANGE DataRange,
+ IN PKSDATARANGE MatchingDataRange, IN ULONG DataBufferSize,
+ OUT PVOID Data OPTIONAL, OUT PULONG DataSize);
+
+ 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, *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\
+ }
+
+ typedef PVOID (*PFNKSDEFAULTALLOCATE)(IN PVOID Context);
+ typedef VOID (*PFNKSDEFAULTFREE)(IN PVOID Context, IN PVOID Buffer);
+ typedef NTSTATUS (*PFNKSINITIALIZEALLOCATOR)(IN PVOID InitialContext, IN PKSALLOCATOR_FRAMING AllocatorFraming, OUT PVOID* Context);
+ typedef VOID (*PFNKSDELETEALLOCATOR)(IN PVOID Context);
+
+ typedef struct
+ {
+ PFNALLOCATOR_ALLOCATEFRAME AllocateFrame;
+ PFNALLOCATOR_FREEFRAME FreeFrame;
+ } KSSTREAMALLOCATOR_FUNCTIONTABLE, *PKSSTREAMALLOCATOR_FUNCTIONTABLE;
+
+ typedef struct
+ {
+ PFNKSCLOCK_GETTIME GetTime;
+ PFNKSCLOCK_GETTIME GetPhysicalTime;
+ PFNKSCLOCK_CORRELATEDTIME GetCorrelatedTime;
+ PFNKSCLOCK_CORRELATEDTIME GetCorrelatedPhysicalTime;
+ } KSCLOCK_FUNCTIONTABLE, *PKSCLOCK_FUNCTIONTABLE;
+
#endif
+
+typedef struct
+{
+ ULONG RatioNumerator;
+ ULONG RatioDenominator;
+ ULONG RatioConstantMargin;
+} KS_COMPRESSION, *PKS_COMPRESSION;
+
+typedef struct
+{
+ KS_FRAMING_RANGE Range;
+ ULONG InPlaceWeight;
+ ULONG NotInPlaceWeight;
+} KS_FRAMING_RANGE_WEIGHTED, *PKS_FRAMING_RANGE_WEIGHTED;
+
+typedef struct
+{
+ ULONG MinFrameSize;
+ ULONG MaxFrameSize;
+ ULONG Stepping;
+} KS_FRAMING_RANGE, *PKS_FRAMING_RANGE;
+
+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;
+
+typedef struct
+{
+ KSPROPERTY Property;
+ KSRATE Rate;
+} KSRATE_CAPABILITY, *PKSRATE_CAPABILITY;
+
+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;
+
+typedef struct
+{
+ LONGLONG Time;
+ ULONG Numerator;
+ ULONG Denominator;
+} KSTIME, *PKSTIME;
+
+typedef struct {
+ ULONG Size;
+ ULONG TypeSpecificFlags;
+ KSTIME PresentationTime;
+ LONGLONG Duration;
+ ULONG FrameExtent;
+ ULONG DataUsed;
+ PVOID Data;
+ ULONG OptionsFlags;
+#if _WIN64
+ ULONG Reserved;
+#endif
+} KSSTREAM_HEADER, *PKSSTREAM_HEADER;
+
+typedef struct
+{
+ HANDLE QualityManager;
+ PVOID Context;
+} KSQUALITY_MANAGER, *PKSQUALITY_MANAGER;
+
+typedef struct
+{
+ LONGLONG Duration;
+ ULONG FrameFlags;
+ ULONG Reserved;
+} KSFRAMETIME, *PKSFRAMETIME;
+
+typedef struct
+{
+ LONGLONG PresentationStart;
+ LONGLONG Duration;
+ KSPIN_INTERFACE Interface;
+ LONG Rate;
+ ULONG Flags;
+} KSRATE, *PKSRATE;
+
+typedef struct
+{
+ LONGLONG Time;
+ LONGLONG SystemTime;
+} KSCORRELATED_TIME, *PKSCORRELATED_TIME;
+
+typedef struct
+{
+ LONGLONG Granularity;
+ LONGLONG Error;
+} KSRESOLUTION, *PKSRESOLUTION;
+
+
+
+#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 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 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 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)
+
+
+#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)))
+
+
+
+
+#if defined(_NTDDK_)
+
+ typedef NTSTATUS (*PFNALLOCATOR_ALLOCATEFRAME)(IN PFILE_OBJECT FileObject, PVOID *Frame);
+ typedef VOID (*PFNALLOCATOR_FREEFRAME)(IN PFILE_OBJECT FileObject, IN PVOID Frame);
+ typedef LONGLONG (FASTCALL *PFNKSCLOCK_GETTIME)(IN PFILE_OBJECT FileObject);
+ typedef LONGLONG (FASTCALL *PFNKSCLOCK_CORRELATEDTIME)(IN PFILE_OBJECT FileObject, OUT PLONGLONG SystemTime);
+ typedef BOOLEAN (*PFNKSSETTIMER)(IN PVOID Context, IN PKTIMER Timer, IN LARGE_INTEGER DueTime, IN PKDPC Dpc);
+ typedef BOOLEAN (*PFNKSCANCELTIMER)(IN PVOID Context, IN PKTIMER Timer);
+ typedef LONGLONG (FASTCALL *PFNKSCORRELATEDTIME)(IN PVOID Context, OUT PLONGLONG SystemTime);
+ typedef PVOID PKSDEFAULTCLOCK;
+ typedef NTSTATUS (*PFNKSCONTEXT_DISPATCH)(IN PVOID Context, IN PIRP Irp );
+ typedef NTSTATUS (*PFNKSHANDLER)(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data);
+ typedef NTSTATUS (*PFNKSALLOCATOR)(IN PIRP Irp, IN ULONG BufferSize, IN BOOLEAN InputOperation);
+ typedef BOOLEAN (*PFNKSFASTHANDLER)(IN PFILE_OBJECT FileObject, IN PKSIDENTIFIER Request, IN ULONG RequestLength,
+ IN OUT PVOID Data, IN ULONG DataLength, OUT PIO_STATUS_BLOCK IoStatus);
+
+
+
+ typedef 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;
+
+ typedef struct
+ {
+ ULONG PropertyId;
+ union
+ {
+ PFNKSHANDLER GetPropertyHandler;
+ BOOLEAN GetSupported;
+ };
+ ULONG MinProperty;
+ ULONG MinData;
+ union
+ {
+ PFNKSHANDLER SetPropertyHandler;
+ BOOLEAN SetSupported;
+ };
+ const KSPROPERTY_VALUES*Values;
+ ULONG RelationsCount;
+ const KSPROPERTY* Relations;
+ PFNKSHANDLER SupportHandler;
+ ULONG SerializedSize;
+ } KSPROPERTY_ITEM, *PKSPROPERTY_ITEM;
+
+ 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;
+
+ typedef struct
+ {
+ ULONG MethodId;
+ union
+ {
+ PFNKSHANDLER MethodHandler;
+ BOOLEAN MethodSupported;
+ };
+ ULONG MinMethod;
+ ULONG MinData;
+ PFNKSHANDLER SupportHandler;
+ ULONG Flags;
+ } KSMETHOD_ITEM, *PKSMETHOD_ITEM;
+
+ typedef struct
+ {
+ ULONG MethodId;
+ union
+ {
+ PFNKSFASTHANDLER MethodHandler;
+ BOOLEAN MethodSupported;
+ };
+ } KSFASTMETHOD_ITEM, *PKSFASTMETHOD_ITEM;
+
+ typedef struct
+ {
+ const GUID* Set;
+ ULONG MethodsCount;
+ const KSMETHOD_ITEM* MethodItem;
+ ULONG FastIoCount;
+ const KSFASTMETHOD_ITEM*FastIoTable;
+ } KSMETHOD_SET, *PKSMETHOD_SET;
+
+ typedef struct
+ {
+ ULONG EventId;
+ ULONG DataInput;
+ ULONG ExtraEntryData;
+ PFNKSADDEVENT AddHandler;
+ PFNKSREMOVEEVENT RemoveHandler;
+ PFNKSHANDLER SupportHandler;
+ } KSEVENT_ITEM, *PKSEVENT_ITEM;
+
+ 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;
+
+ 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;
+ } KSEVENT_ENTRY, *PKSEVENT_ENTRY;
+
+ typedef struct
+ {
+ PDRIVER_DISPATCH Create;
+ PVOID Context;
+ UNICODE_STRING ObjectClass;
+ PSECURITY_DESCRIPTOR SecurityDescriptor;
+ ULONG Flags;
+ } KSOBJECT_CREATE_ITEM, *PKSOBJECT_CREATE_ITEM;
+
+ 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;
+
+ typedef struct
+ {
+ INTERFACE Interface;
+ PFNREFERENCEDEVICEOBJECT ReferenceDeviceObject;
+ PFNDEREFERENCEDEVICEOBJECT DereferenceDeviceObject;
+ PFNQUERYREFERENCESTRING QueryReferenceString;
+ } BUS_INTERFACE_REFERENCE, *PBUS_INTERFACE_REFERENCE;
+
+ typedef struct
+ {
+ INTERFACE Interface;
+ PFNQUERYMEDIUMSLIST QueryMediumsList;
+ } BUS_INTERFACE_MEDIUMS, *PBUS_INTERFACE_MEDIUMS;
+
+ typedef NTSTATUS (*PFNKSADDEVENT)(IN PIRP Irp, IN PKSEVENTDATA EventData, IN struct _KSEVENT_ENTRY* EventEntry);
+ typedef VOID (*PFNKSREMOVEEVENT)(IN PFILE_OBJECT FileObject, IN struct _KSEVENT_ENTRY* EventEntry );
+ typedef VOID (*PFNKSITEMFREECALLBACK)( IN PKSOBJECT_CREATE_ITEM CreateItem );
+ typedef NTSTATUS (*PFNKSIRPLISTCALLBACK)( IN PIRP Irp, IN PVOID Context );
+ typedef VOID (*PFNREFERENCEDEVICEOBJECT)( IN PVOID Context );
+ typedef VOID (*PFNDEREFERENCEDEVICEOBJECT)( IN PVOID Context );
+ typedef NTSTATUS (*PFNQUERYREFERENCESTRING)( IN PVOID Context, IN OUT PWCHAR *String);
+ typedef NTSTATUS (*PFNQUERYMEDIUMSLIST)( IN PVOID Context, OUT ULONG* MediumsCount, OUT PKSPIN_MEDIUM* MediumList);
+
+
+ #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) }
+
+ #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), }
+
+ #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 }
+
+ #define DEFINE_KSFASTPROPERTY_ITEM(PropertyId, GetHandler, SetHandler) { PropertyId, (PFNKSFASTHANDLER)GetHandler, (PFNKSFASTHANDLER)SetHandler, 0 }
+ #define DEFINE_KSPROPERTY_SET(Set, PropertiesCount, PropertyItem, FastIoCount, FastIoTable) {Set, PropertiesCount, PropertyItem, FastIoCount, FastIoTable }
+ #define DEFINE_KSPROPERTY_SET_TABLE(tablename) const KSPROPERTY_SET tablename[] =
+
+ #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 }
+
+ #define DEFINE_KSFASTMETHOD_ITEM(MethodId, MethodHandler) { MethodId, (PFNKSFASTHANDLER)MethodHandler }
+ #define DEFINE_KSMETHOD_SET(Set, MethodsCount, MethodItem, FastIoCount, FastIoTable)\
+ { Set, MethodsCount, MethodItem, FastIoCount, FastIoTable }
+
+ #define DEFINE_KSMETHOD_SET_TABLE(tablename) const KSMETHOD_SET tablename[] =
+ #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 }
+
+ #define DEFINE_KSEVENT_SET(Set, EventsCount, EventItem) { Set, EventsCount, EventItem }
+ #define DEFINE_KSEVENT_SET_TABLE(tablename) const KSEVENT_SET tablename[] =
+ #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 }
+
+ #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])
+#endif // endif of NTDDK
+
+
+#if !defined( PACK_PRAGMAS_NOT_SUPPORTED )
+ #include <pshpack1.h>
+#endif
+
+typedef struct
+{
+ GUID PropertySet;
+ ULONG Count;
+} KSPROPERTY_SERIALHDR, *PKSPROPERTY_SERIALHDR;
+
+#if !defined( PACK_PRAGMAS_NOT_SUPPORTED )
+ #include <poppack.h>
+#endif
+
+typedef struct
+{
+ KSIDENTIFIER PropTypeSet;
+ ULONG Id;
+ ULONG PropertyLength;
+} KSPROPERTY_SERIAL, *PKSPROPERTY_SERIAL;
More information about the Ros-diffs
mailing list