[greatlrd] 32243: add more struct, define, type and so. around 48% completed of this header now
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.... ============================================================================== --- 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;
-
greatlrd＠svn.reactos.org