reactos/include/ddk/strmini.h

   1 #ifndef _STREAM_H
   2 #define _STREAM_H
   3
   4 #include <ntddk.h>
   5 #include <windef.h>
   6 #include <ks.h>
   7
   8 #define STREAMAPI __stdcall
   9 #define STREAM_SYSTEM_TIME_MASK   ((STREAM_SYSTEM_TIME)0x00000001FFFFFFFF)
  10
  11 typedef enum
  12 {
  13     DebugLevelFatal = 0,
  14     DebugLevelError,
  15     DebugLevelWarning,
  16     DebugLevelInfo,
  17     DebugLevelTrace,
  18     DebugLevelVerbose,
  19     DebugLevelMaximum
  20 }STREAM_DEBUG_LEVEL;
  21
  22
  23 #if DBG
  24
  25 #define DebugPrint(x) StreamClassDebugPrint x
  26 #define DEBUG_BREAKPOINT() DbgBreakPoint()
  27 #define DEBUG_ASSERT(exp) \
  28             if ( !(exp) ) { \
  29                 StreamClassDebugAssert( __FILE__, __LINE__, #exp, exp); \
  30             }
  31 #else
  32
  33 #define DebugPrint(x)
  34 #define DEBUG_BREAKPOINT()
  35 #define DEBUG_ASSERT(exp)
  36
  37 #endif
  38
  39 typedef PHYSICAL_ADDRESS STREAM_PHYSICAL_ADDRESS, *PSTREAM_PHYSICAL_ADDRESS;
  40 typedef unsigned __int64 STREAM_SYSTEM_TIME, *PSTREAM_SYSTEM_TIME;
  41 typedef unsigned __int64 STREAM_TIMESTAMP, *PSTREAM_TIMESTAMP;
  42
  43 typedef enum
  44 {
  45     TIME_GET_STREAM_TIME,
  46     TIME_READ_ONBOARD_CLOCK,
  47     TIME_SET_ONBOARD_CLOCK
  48 }TIME_FUNCTION;
  49
  50 typedef struct _HW_TIME_CONTEXT
  51 {
  52     struct _HW_DEVICE_EXTENSION *HwDeviceExtension;
  53     struct _HW_STREAM_OBJECT *HwStreamObject;
  54     TIME_FUNCTION Function;
  55     ULONGLONG Time;
  56     ULONGLONG SystemTime;
  57 }HW_TIME_CONTEXT, *PHW_TIME_CONTEXT;
  58
  59 typedef struct _HW_EVENT_DESCRIPTOR
  60 {
  61     BOOLEAN Enable;
  62     PKSEVENT_ENTRY EventEntry;
  63     PKSEVENTDATA EventData;
  64     union
  65     {
  66         struct _HW_STREAM_OBJECT * StreamObject;
  67         struct _HW_DEVICE_EXTENSION *DeviceExtension;
  68     };
  69     ULONG EnableEventSetIndex;
  70     PVOID HwInstanceExtension;
  71     ULONG Reserved;
  72 } HW_EVENT_DESCRIPTOR, *PHW_EVENT_DESCRIPTOR;
  73
  74 struct _HW_STREAM_REQUEST_BLOCK;
  75
  76 typedef VOID (STREAMAPI * PHW_RECEIVE_STREAM_DATA_SRB) (IN struct _HW_STREAM_REQUEST_BLOCK * SRB);
  77 typedef VOID (STREAMAPI * PHW_RECEIVE_STREAM_CONTROL_SRB) (IN struct _HW_STREAM_REQUEST_BLOCK  * SRB);
  78 typedef NTSTATUS (STREAMAPI * PHW_EVENT_ROUTINE) (IN PHW_EVENT_DESCRIPTOR EventDescriptor);
  79 typedef VOID (STREAMAPI * PHW_CLOCK_FUNCTION) (IN PHW_TIME_CONTEXT HwTimeContext);
  80
  81 typedef struct _HW_CLOCK_OBJECT
  82 {
  83     PHW_CLOCK_FUNCTION HwClockFunction;
  84     ULONG    ClockSupportFlags;
  85     ULONG Reserved[2];
  86 } HW_CLOCK_OBJECT, *PHW_CLOCK_OBJECT;
  87
  88 #define CLOCK_SUPPORT_CAN_SET_ONBOARD_CLOCK 0x1
  89 #define CLOCK_SUPPORT_CAN_READ_ONBOARD_CLOCK 0x2
  90 #define CLOCK_SUPPORT_CAN_RETURN_STREAM_TIME 0x4
  91
  92 typedef struct _HW_STREAM_OBJECT
  93 {
  94     ULONG           SizeOfThisPacket;
  95     ULONG           StreamNumber;
  96     PVOID           HwStreamExtension;
  97     PHW_RECEIVE_STREAM_DATA_SRB ReceiveDataPacket;
  98     PHW_RECEIVE_STREAM_CONTROL_SRB ReceiveControlPacket;
  99     HW_CLOCK_OBJECT HwClockObject;
 100     BOOLEAN         Dma;
 101     BOOLEAN         Pio;
 102     PVOID           HwDeviceExtension;
 103     ULONG    StreamHeaderMediaSpecific;
 104     ULONG    StreamHeaderWorkspace;
 105     BOOLEAN Allocator;
 106     PHW_EVENT_ROUTINE HwEventRoutine;
 107     ULONG Reserved[2];
 108 } HW_STREAM_OBJECT, *PHW_STREAM_OBJECT;
 109
 110 typedef struct _HW_STREAM_HEADER
 111 {
 112     ULONG           NumberOfStreams;
 113     ULONG SizeOfHwStreamInformation;
 114     ULONG           NumDevPropArrayEntries;
 115     PKSPROPERTY_SET DevicePropertiesArray;
 116     ULONG           NumDevEventArrayEntries;
 117     PKSEVENT_SET DeviceEventsArray;
 118     PKSTOPOLOGY Topology;
 119     PHW_EVENT_ROUTINE DeviceEventRoutine;
 120     LONG            NumDevMethodArrayEntries;
 121     PKSMETHOD_SET   DeviceMethodsArray;
 122 }HW_STREAM_HEADER, *PHW_STREAM_HEADER;
 123
 124 typedef struct _HW_STREAM_INFORMATION
 125 {
 126     ULONG           NumberOfPossibleInstances;
 127     KSPIN_DATAFLOW  DataFlow;
 128     BOOLEAN         DataAccessible;
 129     ULONG           NumberOfFormatArrayEntries;
 130     PKSDATAFORMAT*  StreamFormatsArray;
 131     PVOID           ClassReserved[4];
 132     ULONG           NumStreamPropArrayEntries;
 133     PKSPROPERTY_SET StreamPropertiesArray;
 134     ULONG           NumStreamEventArrayEntries;
 135     PKSEVENT_SET StreamEventsArray;
 136     GUID*                   Category;
 137     GUID*                   Name;
 138     ULONG                   MediumsCount;
 139     const KSPIN_MEDIUM*     Mediums;
 140     BOOLEAN         BridgeStream;
 141     ULONG Reserved[2];
 142 }HW_STREAM_INFORMATION, *PHW_STREAM_INFORMATION;
 143
 144
 145 typedef struct _HW_STREAM_DESCRIPTOR
 146 {
 147     HW_STREAM_HEADER StreamHeader;
 148     HW_STREAM_INFORMATION StreamInfo;
 149 } HW_STREAM_DESCRIPTOR, *PHW_STREAM_DESCRIPTOR;
 150
 151 typedef struct _STREAM_TIME_REFERENCE
 152 {
 153     STREAM_TIMESTAMP CurrentOnboardClockValue;
 154     LARGE_INTEGER   OnboardClockFrequency;
 155     LARGE_INTEGER   CurrentSystemTime;
 156     ULONG Reserved[2];
 157 }STREAM_TIME_REFERENCE, *PSTREAM_TIME_REFERENCE;
 158
 159 typedef struct _STREAM_DATA_INTERSECT_INFO
 160 {
 161     ULONG StreamNumber;
 162     PKSDATARANGE DataRange;
 163     PVOID   DataFormatBuffer;
 164     ULONG  SizeOfDataFormatBuffer;
 165
 166 }STREAM_DATA_INTERSECT_INFO, *PSTREAM_DATA_INTERSECT_INFO;
 167
 168 typedef struct _STREAM_PROPERTY_DESCRIPTOR
 169 {
 170     PKSPROPERTY     Property;
 171     ULONG           PropertySetID;
 172     PVOID           PropertyInfo;
 173     ULONG           PropertyInputSize;
 174     ULONG           PropertyOutputSize;
 175 }STREAM_PROPERTY_DESCRIPTOR, *PSTREAM_PROPERTY_DESCRIPTOR;
 176
 177 typedef struct _STREAM_METHOD_DESCRIPTOR
 178 {
 179     ULONG               MethodSetID;
 180     PKSMETHOD           Method;
 181     PVOID               MethodInfo;
 182     LONG                MethodInputSize;
 183     LONG                MethodOutputSize;
 184 } STREAM_METHOD_DESCRIPTOR, *PSTREAM_METHOD_DESCRIPTOR;
 185
 186 #define STREAM_REQUEST_BLOCK_SIZE sizeof(STREAM_REQUEST_BLOCK)
 187
 188 typedef enum _SRB_COMMAND
 189 {
 190     SRB_READ_DATA,
 191     SRB_WRITE_DATA,
 192     SRB_GET_STREAM_STATE,
 193     SRB_SET_STREAM_STATE,
 194     SRB_SET_STREAM_PROPERTY,
 195     SRB_GET_STREAM_PROPERTY,
 196     SRB_OPEN_MASTER_CLOCK,
 197
 198     SRB_INDICATE_MASTER_CLOCK,
 199     SRB_UNKNOWN_STREAM_COMMAND,
 200     SRB_SET_STREAM_RATE,
 201     SRB_PROPOSE_DATA_FORMAT,
 202     SRB_CLOSE_MASTER_CLOCK,
 203     SRB_PROPOSE_STREAM_RATE,
 204     SRB_SET_DATA_FORMAT,
 205     SRB_GET_DATA_FORMAT,
 206     SRB_BEGIN_FLUSH,
 207     SRB_END_FLUSH,
 208
 209     SRB_GET_STREAM_INFO = 0x100,
 210     SRB_OPEN_STREAM,
 211     SRB_CLOSE_STREAM,
 212     SRB_OPEN_DEVICE_INSTANCE,
 213     SRB_CLOSE_DEVICE_INSTANCE,
 214     SRB_GET_DEVICE_PROPERTY,
 215     SRB_SET_DEVICE_PROPERTY,
 216     SRB_INITIALIZE_DEVICE,
 217     SRB_CHANGE_POWER_STATE,
 218     SRB_UNINITIALIZE_DEVICE,
 219     SRB_UNKNOWN_DEVICE_COMMAND,
 220     SRB_PAGING_OUT_DRIVER,
 221     SRB_GET_DATA_INTERSECTION,
 222     SRB_INITIALIZATION_COMPLETE,
 223     SRB_SURPRISE_REMOVAL
 224
 225 #if (NTDDI_VERSION >= NTDDI_WINXP)
 226
 227     ,SRB_DEVICE_METHOD
 228     ,SRB_STREAM_METHOD
 229
 230 #if ( (NTDDI_VERSION >= NTDDI_WINXPSP2) && (NTDDI_VERSION < NTDDI_WS03) ) || (NTDDI_VERSION >= NTDDI_WS03SP1)
 231
 232     ,SRB_NOTIFY_IDLE_STATE
 233
 234 #endif
 235
 236 #endif
 237
 238 }SRB_COMMAND;
 239
 240 typedef struct
 241 {
 242     PHYSICAL_ADDRESS    PhysicalAddress;
 243     ULONG               Length;
 244 } KSSCATTER_GATHER, *PKSSCATTER_GATHER;
 245
 246
 247 typedef struct _HW_STREAM_REQUEST_BLOCK
 248 {
 249     ULONG           SizeOfThisPacket;
 250     SRB_COMMAND     Command;
 251     NTSTATUS        Status;
 252     PHW_STREAM_OBJECT StreamObject;
 253     PVOID           HwDeviceExtension;
 254     PVOID           SRBExtension;
 255
 256     union _CommandData
 257         {
 258         PKSSTREAM_HEADER DataBufferArray;
 259         PHW_STREAM_DESCRIPTOR StreamBuffer;
 260         KSSTATE         StreamState;
 261         PSTREAM_TIME_REFERENCE TimeReference;
 262         PSTREAM_PROPERTY_DESCRIPTOR PropertyInfo;
 263         PKSDATAFORMAT   OpenFormat;
 264         struct _PORT_CONFIGURATION_INFORMATION *ConfigInfo;
 265         HANDLE          MasterClockHandle;
 266         DEVICE_POWER_STATE DeviceState;
 267         PSTREAM_DATA_INTERSECT_INFO IntersectInfo;
 268
 269 #if (NTDDI_VERSION >= NTDDI_WINXP)
 270         PVOID   MethodInfo;
 271         LONG    FilterTypeIndex;
 272 #if ( (NTDDI_VERSION >= NTDDI_WINXPSP2) && (NTDDI_VERSION < NTDDI_WS03) ) || (NTDDI_VERSION >= NTDDI_WS03SP1)
 273         BOOLEAN Idle;
 274 #endif
 275 #endif
 276
 277     }CommandData;
 278
 279     ULONG NumberOfBuffers;
 280     ULONG           TimeoutCounter;
 281     ULONG           TimeoutOriginal;
 282     struct _HW_STREAM_REQUEST_BLOCK *NextSRB;
 283
 284     PIRP            Irp;
 285     ULONG           Flags;
 286     PVOID       HwInstanceExtension;
 287
 288     union
 289         {
 290         ULONG           NumberOfBytesToTransfer;
 291         ULONG           ActualBytesTransferred;
 292     };
 293
 294     PKSSCATTER_GATHER ScatterGatherBuffer;
 295     ULONG           NumberOfPhysicalPages;
 296     ULONG           NumberOfScatterGatherElements;
 297     ULONG Reserved[1];
 298
 299 }HW_STREAM_REQUEST_BLOCK, *PHW_STREAM_REQUEST_BLOCK;
 300
 301 #define SRB_HW_FLAGS_DATA_TRANSFER  0x01
 302 #define SRB_HW_FLAGS_STREAM_REQUEST 0x2
 303
 304 typedef enum
 305 {
 306     PerRequestExtension,
 307     DmaBuffer,
 308     SRBDataBuffer
 309 }STREAM_BUFFER_TYPE;
 310
 311 typedef struct _ACCESS_RANGE
 312 {
 313     STREAM_PHYSICAL_ADDRESS RangeStart;
 314     ULONG           RangeLength;
 315     BOOLEAN         RangeInMemory;
 316     ULONG           Reserved;
 317 }ACCESS_RANGE, *PACCESS_RANGE;
 318
 319 typedef struct _PORT_CONFIGURATION_INFORMATION
 320 {
 321     ULONG           SizeOfThisPacket;
 322     PVOID           HwDeviceExtension;
 323     PDEVICE_OBJECT  ClassDeviceObject;
 324     PDEVICE_OBJECT  PhysicalDeviceObject;
 325     ULONG           SystemIoBusNumber;
 326     INTERFACE_TYPE  AdapterInterfaceType;
 327     ULONG           BusInterruptLevel;
 328     ULONG           BusInterruptVector;
 329     KINTERRUPT_MODE InterruptMode;
 330     ULONG           DmaChannel;
 331     ULONG           NumberOfAccessRanges;
 332     PACCESS_RANGE   AccessRanges;
 333     ULONG           StreamDescriptorSize;
 334     PIRP            Irp;
 335     PKINTERRUPT  InterruptObject;
 336     PADAPTER_OBJECT  DmaAdapterObject;
 337     PDEVICE_OBJECT  RealPhysicalDeviceObject;
 338     ULONG Reserved[1];
 339 }PORT_CONFIGURATION_INFORMATION, *PPORT_CONFIGURATION_INFORMATION;
 340
 341 typedef VOID (STREAMAPI * PHW_RECEIVE_DEVICE_SRB) (IN PHW_STREAM_REQUEST_BLOCK SRB);
 342 typedef VOID (STREAMAPI * PHW_CANCEL_SRB) (IN PHW_STREAM_REQUEST_BLOCK SRB);
 343 typedef VOID (STREAMAPI * PHW_REQUEST_TIMEOUT_HANDLER) (IN PHW_STREAM_REQUEST_BLOCK SRB);
 344 typedef BOOLEAN (STREAMAPI * PHW_INTERRUPT) (IN PVOID DeviceExtension);
 345 typedef VOID (STREAMAPI * PHW_TIMER_ROUTINE) (IN PVOID Context);
 346 typedef VOID (STREAMAPI * PHW_PRIORITY_ROUTINE) (IN PVOID Context);
 347 typedef VOID (STREAMAPI * PHW_QUERY_CLOCK_ROUTINE) (IN PHW_TIME_CONTEXT TimeContext);
 348 typedef BOOLEAN (STREAMAPI * PHW_RESET_ADAPTER) (IN PVOID DeviceExtension);
 349
 350 typedef enum _STREAM_MINIDRIVER_STREAM_NOTIFICATION_TYPE
 351 {
 352     ReadyForNextStreamDataRequest,
 353     ReadyForNextStreamControlRequest,
 354     HardwareStarved,
 355     StreamRequestComplete,
 356     SignalMultipleStreamEvents,
 357     SignalStreamEvent,
 358     DeleteStreamEvent,
 359     StreamNotificationMaximum
 360 }STREAM_MINIDRIVER_STREAM_NOTIFICATION_TYPE, *PSTREAM_MINIDRIVER_STREAM_NOTIFICATION_TYPE;
 361
 362 typedef enum _STREAM_MINIDRIVER_DEVICE_NOTIFICATION_TYPE
 363 {
 364     ReadyForNextDeviceRequest,
 365     DeviceRequestComplete,
 366     SignalMultipleDeviceEvents,
 367     SignalDeviceEvent,
 368     DeleteDeviceEvent,
 369 #if (NTDDI_VERSION >= NTDDI_WINXP)
 370     SignalMultipleDeviceInstanceEvents,
 371 #endif
 372     DeviceNotificationMaximum
 373 } STREAM_MINIDRIVER_DEVICE_NOTIFICATION_TYPE, *PSTREAM_MINIDRIVER_DEVICE_NOTIFICATION_TYPE;
 374
 375 #define STREAM_CLASS_VERSION_20 0x0200
 376
 377 typedef struct _HW_INITIALIZATION_DATA {
 378 #if (NTDDI_VERSION >= NTDDI_WINXP)
 379     union
 380         {
 381         ULONG           HwInitializationDataSize;
 382         struct
 383                 {
 384             USHORT      SizeOfThisPacket;
 385             USHORT      StreamClassVersion;
 386         };
 387     };
 388 #else
 389     ULONG           HwInitializationDataSize;
 390 #endif
 391
 392     PHW_INTERRUPT   HwInterrupt;
 393     PHW_RECEIVE_DEVICE_SRB HwReceivePacket;
 394     PHW_CANCEL_SRB  HwCancelPacket;
 395     PHW_REQUEST_TIMEOUT_HANDLER HwRequestTimeoutHandler;
 396     ULONG           DeviceExtensionSize;
 397     ULONG           PerRequestExtensionSize;
 398     ULONG           PerStreamExtensionSize;
 399     ULONG           FilterInstanceExtensionSize;
 400     BOOLEAN         BusMasterDMA;
 401     BOOLEAN         Dma24BitAddresses;
 402     ULONG           BufferAlignment;
 403     BOOLEAN         TurnOffSynchronization;
 404     ULONG           DmaBufferSize;
 405
 406 #if (NTDDI_VERSION >= NTDDI_WINXP)
 407     ULONG                       NumNameExtensions;
 408     PWCHAR                      *NameExtensionArray;
 409 #else
 410     ULONG Reserved[2];
 411 #endif
 412 } HW_INITIALIZATION_DATA, *PHW_INITIALIZATION_DATA;
 413
 414 typedef enum _STREAM_PRIORITY
 415 {
 416     High,
 417     Dispatch,
 418     Low,
 419     LowToHigh
 420 }STREAM_PRIORITY, *PSTREAM_PRIORITY;
 421
 422
 423 VOID
 424 StreamClassAbortOutstandingRequests(
 425     IN PVOID HwDeviceExtension,
 426     IN PHW_STREAM_OBJECT HwStreamObject,
 427     IN NTSTATUS Status
 428 );
 429
 430 VOID
 431 STREAMAPI
 432 StreamClassCallAtNewPriority(
 433     IN PHW_STREAM_OBJECT  StreamObject,
 434     IN PVOID  HwDeviceExtension,
 435     IN STREAM_PRIORITY  Priority,
 436     IN PHW_PRIORITY_ROUTINE  PriorityRoutine,
 437     IN PVOID  Context
 438     );
 439
 440 VOID
 441 STREAMAPI
 442 StreamClassCompleteRequestAndMarkQueueReady(
 443     IN PHW_STREAM_REQUEST_BLOCK Srb
 444 );
 445
 446 VOID
 447 STREAMAPI
 448 StreamClassDebugAssert(
 449     IN PCHAR File,
 450     IN ULONG Line,
 451     IN PCHAR AssertText,
 452     IN ULONG AssertValue
 453 );
 454
 455 VOID
 456 __cdecl
 457 StreamClassDebugPrint(
 458     IN STREAM_DEBUG_LEVEL DebugPrintLevel,
 459     IN PCCHAR DebugMessage,
 460     ...
 461 );
 462
 463 VOID
 464 __cdecl
 465 StreamClassDeviceNotification(
 466     IN STREAM_MINIDRIVER_DEVICE_NOTIFICATION_TYPE NotificationType,
 467     IN PVOID HwDeviceExtension,
 468     IN PHW_STREAM_REQUEST_BLOCK  pSrb,
 469     IN PKSEVENT_ENTRY  EventEntry,
 470     IN GUID  *EventSet,
 471     IN ULONG  EventId
 472 );
 473
 474 VOID
 475 STREAMAPI
 476 StreamClassFilterReenumerateStreams(
 477     IN PVOID HwInstanceExtension,
 478     IN ULONG StreamDescriptorSize
 479 );
 480
 481 PVOID
 482 STREAMAPI
 483 StreamClassGetDmaBuffer(
 484     IN PVOID HwDeviceExtension
 485 );
 486
 487
 488 PKSEVENT_ENTRY
 489 StreamClassGetNextEvent(
 490     IN PVOID HwInstanceExtension_OR_HwDeviceExtension,
 491     IN PHW_STREAM_OBJECT HwStreamObject,
 492     IN GUID * EventGuid,
 493     IN ULONG EventItem,
 494     IN PKSEVENT_ENTRY CurrentEvent
 495 );
 496
 497 STREAM_PHYSICAL_ADDRESS
 498 STREAMAPI
 499 StreamClassGetPhysicalAddress(
 500     IN PVOID HwDeviceExtension,
 501     IN PHW_STREAM_REQUEST_BLOCK HwSRB,
 502     IN PVOID VirtualAddress,
 503     IN STREAM_BUFFER_TYPE Type,
 504     IN ULONG * Length
 505 );
 506
 507 VOID
 508 StreamClassQueryMasterClock(
 509     IN PHW_STREAM_OBJECT HwStreamObject,
 510     IN HANDLE MasterClockHandle,
 511     IN TIME_FUNCTION TimeFunction,
 512     IN PHW_QUERY_CLOCK_ROUTINE ClockCallbackRoutine
 513 );
 514
 515 VOID
 516 STREAMAPI
 517 StreamClassQueryMasterClockSync(
 518     IN HANDLE MasterClockHandle,
 519     IN PHW_TIME_CONTEXT TimeContext
 520 );
 521
 522 BOOLEAN
 523 STREAMAPI
 524 StreamClassReadWriteConfig(
 525     IN PVOID HwDeviceExtension,
 526     IN BOOLEAN Read,
 527     IN PVOID Buffer,
 528     IN ULONG Offset,
 529     IN ULONG Length
 530 );
 531
 532 VOID
 533 STREAMAPI
 534 StreamClassReenumerateStreams(
 535     IN PVOID HwDeviceExtension,
 536     IN ULONG StreamDescriptorSize
 537 );
 538
 539 NTSTATUS
 540 STREAMAPI
 541 StreamClassRegisterAdapter(
 542     IN PVOID Argument1,
 543     IN PVOID Argument2,
 544     IN PHW_INITIALIZATION_DATA HwInitializationData
 545 );
 546
 547 #define StreamClassRegisterMinidriver StreamClassRegisterAdapter
 548
 549 NTSTATUS
 550 StreamClassRegisterFilterWithNoKSPins(
 551     IN PDEVICE_OBJECT   DeviceObject,
 552     IN const GUID     * InterfaceClassGUID,
 553     IN ULONG            PinCount,
 554     IN BOOLEAN * PinDirection,
 555     IN KSPIN_MEDIUM * MediumList,
 556     IN GUID * CategoryList
 557 );
 558
 559 VOID
 560 STREAMAPI
 561 StreamClassScheduleTimer(
 562     IN PHW_STREAM_OBJECT StreamObject,
 563     IN PVOID HwDeviceExtension,
 564     IN ULONG NumberOfMicroseconds,
 565     IN PHW_TIMER_ROUTINE TimerRoutine,
 566     IN PVOID Context
 567 );
 568
 569 VOID
 570 __cdecl
 571 StreamClassStreamNotification(
 572     IN STREAM_MINIDRIVER_STREAM_NOTIFICATION_TYPE NotificationType,
 573     IN PHW_STREAM_OBJECT StreamObject,
 574     IN ...
 575 );
 576
 577 #endif