reactos/include/reactos/libs/sound/mmebuddy.h

   1 /*
   2  * PROJECT:     ReactOS Sound System "MME Buddy" Library
   3  * LICENSE:     GPL - See COPYING in the top level directory
   4  * FILE:        include/reactos/libs/sound/mmebuddy.h
   5  *
   6  * PURPOSE:     Header for the "MME Buddy" helper library (located in
   7  *              lib/drivers/sound/mmebuddy)
   8  *
   9  * PROGRAMMERS: Andrew Greenwood (silverblade@reactos.org)
  10  *
  11  * HISTORY:     4 July 2008 - Created
  12  *              31 Dec 2008 - Split off NT4-specific code into a separate library
  13  *
  14  * NOTES:       MME Buddy was the best name I could come up with...
  15  *              The structures etc. here should be treated as internal to the
  16  *              library so should not be directly accessed elsewhere. Perhaps they
  17  *              can be moved to an internal header?
  18 */
  19
  20 #ifndef ROS_AUDIO_MMEBUDDY_H
  21 #define ROS_AUDIO_MMEBUDDY_H
  22
  23 /*
  24     Hacky debug macro
  25 */
  26
  27 #define POPUP(...) \
  28     { \
  29         WCHAR dbg_popup_msg[1024], dbg_popup_title[256]; \
  30         wsprintf(dbg_popup_title, L"%hS(%d)", __FILE__, __LINE__); \
  31         wsprintf(dbg_popup_msg, __VA_ARGS__); \
  32         MessageBox(0, dbg_popup_msg, dbg_popup_title, MB_OK | MB_TASKMODAL); \
  33     }
  34
  35 #ifndef NDEBUG
  36     #define SND_ERR(...) \
  37         { \
  38             WCHAR dbg_popup_msg[1024]; \
  39             wsprintf(dbg_popup_msg, __VA_ARGS__); \
  40             OutputDebugString(dbg_popup_msg); \
  41         }
  42     #define SND_WARN(...) \
  43         { \
  44             WCHAR dbg_popup_msg[1024]; \
  45             wsprintf(dbg_popup_msg, __VA_ARGS__); \
  46             OutputDebugString(dbg_popup_msg); \
  47         }
  48     #define SND_TRACE(...) \
  49         { \
  50             WCHAR dbg_popup_msg[1024]; \
  51             wsprintf(dbg_popup_msg, __VA_ARGS__); \
  52             OutputDebugString(dbg_popup_msg); \
  53         }
  54
  55     #define SND_ASSERT(condition) \
  56         { \
  57             if ( ! ( condition ) ) \
  58             { \
  59                 SND_ERR(L"ASSERT FAILED: %hS File %hS Line %u\n", #condition, __FILE__, __LINE__); \
  60                 POPUP(L"ASSERT FAILED: %hS\n", #condition); \
  61                 ExitProcess(1); \
  62             } \
  63         }
  64
  65     #define DUMP_WAVEHDR_QUEUE(sound_device_instance) \
  66         { \
  67             PWAVEHDR CurrDumpHdr = sound_device_instance->HeadWaveHeader; \
  68             SND_TRACE(L"-- Current wave header list --\n"); \
  69             while ( CurrDumpHdr ) \
  70             { \
  71                 SND_TRACE(L"%x | %d bytes | flags: %x\n", CurrDumpHdr, \
  72                           CurrDumpHdr->dwBufferLength, \
  73                           CurrDumpHdr->dwFlags); \
  74                 CurrDumpHdr = CurrDumpHdr->lpNext; \
  75             } \
  76         }
  77
  78 #else
  79     #define SND_ERR(...) do {} while ( 0 )
  80     #define SND_WARN(...) do {} while ( 0 )
  81     #define SND_TRACE(...) do {} while ( 0 )
  82     #define SND_ASSERT(condition) do {(void)(condition);} while ( 0 )
  83     #define DUMP_WAVEHDR_QUEUE(condition) do {} while ( 0 )
  84 #endif
  85
  86 /*
  87     Some memory allocation helper macros
  88 */
  89
  90 #define AllocateStruct(thing) \
  91     (thing*) AllocateMemory(sizeof(thing))
  92
  93 #define StringLengthToBytes(chartype, string_length) \
  94     ( ( string_length + 1 ) * sizeof(chartype) )
  95
  96 #define AllocateWideString(string_length) \
  97     (PWSTR) AllocateMemory(StringLengthToBytes(WCHAR, string_length))
  98
  99 #define ZeroWideString(string) \
 100     ZeroMemory(string, StringLengthToBytes(WCHAR, wcslen(string)))
 101
 102 #define CopyWideString(dest, source) \
 103     CopyMemory(dest, source, StringLengthToBytes(WCHAR, wcslen(source)))
 104
 105
 106 /*
 107     Helps find the minimum/maximum of two values
 108 */
 109
 110 #define MinimumOf(value_a, value_b) \
 111     ( value_a < value_b ? value_a : value_b )
 112
 113 #define MaximumOf(value_a, value_b) \
 114     ( value_a > value_b ? value_a : value_b )
 115
 116
 117 /*
 118     Convert a device type into a zero-based array index
 119 */
 120
 121 #define SOUND_DEVICE_TYPE_TO_INDEX(x) \
 122     ( x - MIN_SOUND_DEVICE_TYPE )
 123
 124 #define INDEX_TO_SOUND_DEVICE_TYPE(x) \
 125     ( x + MIN_SOUND_DEVICE_TYPE )
 126
 127
 128 /*
 129     Validation
 130 */
 131
 132 #define IsValidSoundDeviceType IS_VALID_SOUND_DEVICE_TYPE
 133
 134 #define VALIDATE_MMSYS_PARAMETER(parameter_condition) \
 135     { \
 136         if ( ! (parameter_condition) ) \
 137         { \
 138             SND_ERR(L"FAILED parameter check: %hS at File %S Line %lu\n", #parameter_condition, __FILE__, __LINE__); \
 139             return MMSYSERR_INVALPARAM; \
 140         } \
 141     }
 142
 143 #define MMSUCCESS(result) \
 144     ( result == MMSYSERR_NOERROR )
 145
 146
 147 /*
 148     Types and Structures
 149 */
 150
 151 typedef UCHAR MMDEVICE_TYPE, *PMMDEVICE_TYPE;
 152 struct _SOUND_DEVICE;
 153 struct _SOUND_DEVICE_INSTANCE;
 154
 155
 156 #define DEFINE_GETCAPS_FUNCTYPE(func_typename, caps_type) \
 157     typedef MMRESULT (*func_typename)( \
 158         IN  struct _SOUND_DEVICE* SoundDevice, \
 159         IN  DWORD DeviceId, \
 160         OUT caps_type Capabilities, \
 161         IN  DWORD CapabilitiesSize);
 162
 163 /* This one is for those of us who don't care */
 164 DEFINE_GETCAPS_FUNCTYPE(MMGETCAPS_FUNC, PVOID);
 165
 166 /* These are for those of us that do */
 167 DEFINE_GETCAPS_FUNCTYPE(MMGETWAVEOUTCAPS_FUNC, LPWAVEOUTCAPS);
 168 DEFINE_GETCAPS_FUNCTYPE(MMGETWAVEINCAPS_FUNC,  LPWAVEINCAPS );
 169 DEFINE_GETCAPS_FUNCTYPE(MMGETMIDIOUTCAPS_FUNC, LPMIDIOUTCAPS);
 170 DEFINE_GETCAPS_FUNCTYPE(MMGETMIDIINCAPS_FUNC,  LPMIDIINCAPS );
 171
 172 struct _SOUND_DEVICE;
 173 struct _SOUND_DEVICE_INSTANCE;
 174
 175
 176 /*
 177     By extending the OVERLAPPED structure, it becomes possible to provide the
 178     I/O completion routines with additional information.
 179 */
 180
 181 typedef struct _SOUND_OVERLAPPED
 182 {
 183     OVERLAPPED Standard;
 184     struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance;
 185     PWAVEHDR Header;
 186     BOOL PerformCompletion;
 187
 188     LPOVERLAPPED_COMPLETION_ROUTINE OriginalCompletionRoutine;
 189     PVOID CompletionContext;
 190
 191 } SOUND_OVERLAPPED, *PSOUND_OVERLAPPED;
 192
 193 typedef MMRESULT (*WAVE_COMMIT_FUNC)(
 194     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 195     IN  PVOID OffsetPtr,
 196     IN  DWORD Bytes,
 197     IN  PSOUND_OVERLAPPED Overlap,
 198     IN  LPOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine);
 199
 200 typedef MMRESULT (*MMMIXERQUERY_FUNC) (
 201     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 202     IN DWORD DeviceId,
 203     IN UINT uMsg,
 204     IN LPVOID Parameter,
 205     IN DWORD Flags);
 206
 207 typedef MMRESULT (*MMWAVEQUERYFORMATSUPPORT_FUNC)(
 208     IN  struct _SOUND_DEVICE* Device,
 209     IN  PWAVEFORMATEX WaveFormat,
 210     IN  DWORD WaveFormatSize);
 211
 212 typedef MMRESULT (*MMWAVESETFORMAT_FUNC)(
 213     IN  struct _SOUND_DEVICE_INSTANCE* Instance,
 214     IN  DWORD DeviceId,
 215     IN  PWAVEFORMATEX WaveFormat,
 216     IN  DWORD WaveFormatSize);
 217
 218 typedef MMRESULT (*MMOPEN_FUNC)(
 219     IN  struct _SOUND_DEVICE* SoundDevice,
 220     OUT PVOID* Handle);
 221
 222 typedef MMRESULT (*MMCLOSE_FUNC)(
 223     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 224     IN  PVOID Handle);  /* not sure about this */
 225
 226 typedef MMRESULT (*MMWAVEHEADER_FUNC)(
 227     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 228     IN  PWAVEHDR WaveHeader);
 229
 230 typedef MMRESULT (*MMBUFFER_FUNC)(
 231     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 232     IN  PVOID Buffer,
 233     IN  DWORD Length);
 234
 235 typedef MMRESULT(*MMGETPOS_FUNC)(
 236     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 237     IN  MMTIME* Time);
 238
 239
 240 typedef MMRESULT(*MMSETSTATE_FUNC)(
 241     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 242     IN  BOOL bStart);
 243
 244
 245 typedef MMRESULT(*MMQUERYDEVICEINTERFACESTRING_FUNC)(
 246     IN  MMDEVICE_TYPE DeviceType,
 247     IN  DWORD DeviceId,
 248     IN  LPWSTR Interface,
 249     IN  DWORD  InterfaceLength,
 250     OUT  DWORD * InterfaceSize);
 251
 252 typedef MMRESULT(*MMRESETSTREAM_FUNC)(
 253     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 254     IN  MMDEVICE_TYPE DeviceType,
 255     IN  BOOLEAN bStartReset);
 256
 257 typedef struct _MMFUNCTION_TABLE
 258 {
 259     union
 260     {
 261         MMGETCAPS_FUNC              GetCapabilities;
 262         MMGETWAVEOUTCAPS_FUNC       GetWaveOutCapabilities;
 263         MMGETWAVEINCAPS_FUNC        GetWaveInCapabilities;
 264         MMGETMIDIOUTCAPS_FUNC       GetMidiOutCapabilities;
 265         MMGETMIDIINCAPS_FUNC        GetMidiInCapabilities;
 266     };
 267
 268     MMOPEN_FUNC                     Open;
 269     MMCLOSE_FUNC                    Close;
 270
 271     MMWAVEQUERYFORMATSUPPORT_FUNC   QueryWaveFormatSupport;
 272     MMWAVESETFORMAT_FUNC            SetWaveFormat;
 273
 274     MMMIXERQUERY_FUNC               QueryMixerInfo;
 275
 276     WAVE_COMMIT_FUNC                CommitWaveBuffer;
 277
 278     MMGETPOS_FUNC                   GetPos;
 279     MMSETSTATE_FUNC                 SetState;
 280     MMQUERYDEVICEINTERFACESTRING_FUNC     GetDeviceInterfaceString;
 281     MMRESETSTREAM_FUNC               ResetStream;
 282
 283     // Redundant
 284     //MMWAVEHEADER_FUNC               PrepareWaveHeader;
 285     //MMWAVEHEADER_FUNC               UnprepareWaveHeader;
 286     //MMWAVEHEADER_FUNC               WriteWaveHeader;
 287
 288     //MMWAVEHEADER_FUNC               SubmitWaveHeaderToDevice;
 289     //MMBUFFER_FUNC                   CompleteBuffer;
 290 } MMFUNCTION_TABLE, *PMMFUNCTION_TABLE;
 291
 292
 293
 294 typedef MMRESULT (*SOUND_THREAD_REQUEST_HANDLER)(
 295     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 296     IN  PVOID Parameter);
 297
 298 typedef struct _SOUND_THREAD
 299 {
 300     HANDLE Handle;
 301     BOOL Running;
 302
 303     struct
 304     {
 305         HANDLE Ready;
 306         HANDLE Request;
 307         HANDLE Done;
 308     } Events;
 309
 310     struct
 311     {
 312         SOUND_THREAD_REQUEST_HANDLER Handler;
 313         struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance;
 314         PVOID Parameter;
 315         MMRESULT Result;
 316     } Request;
 317 } SOUND_THREAD, *PSOUND_THREAD;
 318
 319 typedef struct _SOUND_DEVICE
 320 {
 321     struct _SOUND_DEVICE* Next;
 322     struct _SOUND_DEVICE_INSTANCE* HeadInstance;
 323     struct _SOUND_DEVICE_INSTANCE* TailInstance;
 324     MMDEVICE_TYPE Type;
 325     PVOID Identifier;       /* Path for NT4 drivers */
 326     /*PWSTR Path;*/
 327     MMFUNCTION_TABLE FunctionTable;
 328 } SOUND_DEVICE, *PSOUND_DEVICE;
 329
 330 typedef struct _SOUND_DEVICE_INSTANCE
 331 {
 332     struct _SOUND_DEVICE_INSTANCE* Next;
 333     struct _SOUND_DEVICE* Device;
 334     PVOID Handle;
 335     struct _SOUND_THREAD* Thread;
 336
 337     /* Stuff generously donated to us from WinMM */
 338     struct
 339     {
 340         HDRVR Handle;
 341         DWORD Flags;
 342         DWORD_PTR ClientCallback;
 343         DWORD_PTR ClientCallbackInstanceData;
 344     } WinMM;
 345
 346     /* DO NOT TOUCH THESE OUTSIDE OF THE SOUND THREAD */
 347
 348     union
 349     {
 350         PWAVEHDR HeadWaveHeader;
 351     };
 352
 353     union
 354     {
 355         PWAVEHDR TailWaveHeader;
 356     };
 357
 358     PWAVEHDR WaveLoopStart;
 359     //PWAVEHDR CurrentWaveHeader;
 360     DWORD OutstandingBuffers;
 361     DWORD LoopsRemaining;
 362     DWORD FrameSize;
 363     DWORD BufferCount;
 364     WAVEFORMATEX WaveFormatEx;
 365     HANDLE hNotifyEvent;
 366     HANDLE hStopEvent;
 367     HANDLE hResetEvent;
 368     BOOL ResetInProgress;
 369     BOOL bPaused;
 370 } SOUND_DEVICE_INSTANCE, *PSOUND_DEVICE_INSTANCE;
 371
 372 /* This lives in WAVEHDR.reserved */
 373 typedef struct _WAVEHDR_EXTENSION
 374 {
 375     DWORD BytesCommitted;
 376     DWORD BytesCompleted;
 377 } WAVEHDR_EXTENSION, *PWAVEHDR_EXTENSION;
 378
 379
 380 /*
 381     reentrancy.c
 382 */
 383
 384 MMRESULT
 385 InitEntrypointMutexes(VOID);
 386
 387 VOID
 388 CleanupEntrypointMutexes(VOID);
 389
 390 VOID
 391 AcquireEntrypointMutex(
 392     IN  MMDEVICE_TYPE DeviceType);
 393
 394 VOID
 395 ReleaseEntrypointMutex(
 396     IN  MMDEVICE_TYPE DeviceType);
 397
 398
 399 /*
 400     mme.c
 401 */
 402
 403 VOID
 404 NotifyMmeClient(
 405     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 406     IN  UINT Message,
 407     IN  DWORD_PTR Parameter);
 408
 409 MMRESULT
 410 MmeGetSoundDeviceCapabilities(
 411     IN  MMDEVICE_TYPE DeviceType,
 412     IN  DWORD DeviceId,
 413     IN  PVOID Capabilities,
 414     IN  DWORD CapabilitiesSize);
 415
 416 MMRESULT
 417 MmeOpenDevice(
 418     IN  MMDEVICE_TYPE DeviceType,
 419     IN  UINT DeviceId,
 420     IN  LPWAVEOPENDESC OpenParameters,
 421     IN  DWORD Flags,
 422     OUT DWORD_PTR* PrivateHandle);
 423
 424 MMRESULT
 425 MmeCloseDevice(
 426     IN  DWORD_PTR PrivateHandle);
 427
 428 MMRESULT
 429 MmeGetPosition(
 430     IN  MMDEVICE_TYPE DeviceType,
 431     IN  DWORD DeviceId,
 432     IN  DWORD_PTR PrivateHandle,
 433     IN  MMTIME* Time,
 434     IN  DWORD Size);
 435
 436 MMRESULT
 437 MmeGetDeviceInterfaceString(
 438     IN  MMDEVICE_TYPE DeviceType,
 439     IN  DWORD DeviceId,
 440     IN  LPWSTR Interface,
 441     IN  DWORD  InterfaceLength,
 442     OUT  DWORD * InterfaceSize);
 443
 444
 445 MMRESULT
 446 MmeSetState(
 447     IN  DWORD_PTR PrivateHandle,
 448     IN  BOOL bStart);
 449
 450
 451 #define MmePrepareWaveHeader(private_handle, header) \
 452     PrepareWaveHeader((PSOUND_DEVICE_INSTANCE)private_handle, (PWAVEHDR)header)
 453
 454 #define MmeUnprepareWaveHeader(private_handle, header) \
 455     UnprepareWaveHeader((PSOUND_DEVICE_INSTANCE)private_handle, (PWAVEHDR)header)
 456
 457 #define MmeWriteWaveHeader(private_handle, header) \
 458     WriteWaveHeader((PSOUND_DEVICE_INSTANCE)private_handle, (PWAVEHDR)header)
 459
 460 MMRESULT
 461 MmeResetWavePlayback(
 462     IN  DWORD_PTR PrivateHandle);
 463
 464
 465 /*
 466     capabilities.c
 467 */
 468
 469 MMRESULT
 470 GetSoundDeviceCapabilities(
 471     IN  PSOUND_DEVICE SoundDevice,
 472     IN  DWORD DeviceId,
 473     OUT PVOID Capabilities,
 474     IN  DWORD CapabilitiesSize);
 475
 476
 477 /*
 478     devicelist.c
 479 */
 480
 481 ULONG
 482 GetSoundDeviceCount(
 483     IN  MMDEVICE_TYPE DeviceType);
 484
 485 BOOLEAN
 486 IsValidSoundDevice(
 487     IN  PSOUND_DEVICE SoundDevice);
 488
 489 MMRESULT
 490 ListSoundDevice(
 491     IN  MMDEVICE_TYPE DeviceType,
 492     IN  PVOID Identifier OPTIONAL,
 493     OUT PSOUND_DEVICE* SoundDevice OPTIONAL);
 494
 495 MMRESULT
 496 UnlistSoundDevice(
 497     IN  MMDEVICE_TYPE DeviceType,
 498     IN  PSOUND_DEVICE SoundDevice);
 499
 500 MMRESULT
 501 UnlistSoundDevices(
 502     IN  MMDEVICE_TYPE DeviceType);
 503
 504 VOID
 505 UnlistAllSoundDevices(VOID);
 506
 507 MMRESULT
 508 GetSoundDevice(
 509     IN  MMDEVICE_TYPE DeviceType,
 510     IN  DWORD DeviceIndex,
 511     OUT PSOUND_DEVICE* Device);
 512
 513 MMRESULT
 514 GetSoundDeviceIdentifier(
 515     IN  PSOUND_DEVICE SoundDevice,
 516     OUT PVOID* Identifier);
 517
 518 MMRESULT
 519 GetSoundDeviceType(
 520     IN  PSOUND_DEVICE SoundDevice,
 521     OUT PMMDEVICE_TYPE DeviceType);
 522
 523
 524 /*
 525     functiontable.c
 526 */
 527
 528 MMRESULT
 529 SetSoundDeviceFunctionTable(
 530     IN  PSOUND_DEVICE SoundDevice,
 531     IN  PMMFUNCTION_TABLE FunctionTable);
 532
 533 MMRESULT
 534 GetSoundDeviceFunctionTable(
 535     IN  PSOUND_DEVICE SoundDevice,
 536     OUT PMMFUNCTION_TABLE* FunctionTable);
 537
 538
 539 /*
 540     deviceinstance.c
 541 */
 542
 543 BOOLEAN
 544 IsValidSoundDeviceInstance(
 545     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance);
 546
 547 MMRESULT
 548 CreateSoundDeviceInstance(
 549     IN  PSOUND_DEVICE SoundDevice,
 550     OUT PSOUND_DEVICE_INSTANCE* SoundDeviceInstance);
 551
 552 MMRESULT
 553 DestroySoundDeviceInstance(
 554     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance);
 555
 556 MMRESULT
 557 DestroyAllSoundDeviceInstances(
 558     IN  PSOUND_DEVICE SoundDevice);
 559
 560 MMRESULT
 561 GetSoundDeviceFromInstance(
 562     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 563     OUT PSOUND_DEVICE* SoundDevice);
 564
 565 MMRESULT
 566 GetSoundDeviceInstanceHandle(
 567     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 568     OUT PVOID* Handle);
 569
 570 MMRESULT
 571 SetSoundDeviceInstanceMmeData(
 572     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 573     IN  HDRVR MmeHandle,
 574     IN  DWORD_PTR ClientCallback,
 575     IN  DWORD_PTR ClientCallbackData,
 576     IN  DWORD Flags);
 577
 578
 579 /*
 580     thread.c
 581 */
 582
 583 MMRESULT
 584 CreateSoundThread(
 585     OUT PSOUND_THREAD* Thread);
 586
 587 MMRESULT
 588 DestroySoundThread(
 589     IN  PSOUND_THREAD Thread);
 590
 591 MMRESULT
 592 CallSoundThread(
 593     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 594     IN  SOUND_THREAD_REQUEST_HANDLER RequestHandler,
 595     IN  PVOID Parameter OPTIONAL);
 596
 597
 598 /*
 599     utility.c
 600 */
 601
 602 PVOID
 603 AllocateMemory(
 604     IN  UINT Size);
 605
 606 VOID
 607 FreeMemory(
 608     IN  PVOID Pointer);
 609
 610 UINT
 611 GetMemoryAllocationCount(VOID);
 612
 613 UINT
 614 GetDigitCount(
 615     IN  UINT Number);
 616
 617 MMRESULT
 618 Win32ErrorToMmResult(
 619     IN  UINT ErrorCode);
 620
 621 MMRESULT
 622 TranslateInternalMmResult(
 623     IN  MMRESULT Result);
 624
 625
 626 /*
 627     wave/format.c
 628 */
 629
 630 MMRESULT
 631 QueryWaveDeviceFormatSupport(
 632     IN  PSOUND_DEVICE SoundDevice,
 633     IN  LPWAVEFORMATEX Format,
 634     IN  DWORD FormatSize);
 635
 636 MMRESULT
 637 SetWaveDeviceFormat(
 638     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 639     IN  DWORD DeviceId,
 640     IN  LPWAVEFORMATEX Format,
 641     IN  DWORD FormatSize);
 642
 643
 644 /*
 645     wave/header.c
 646 */
 647
 648 MMRESULT
 649 EnqueueWaveHeader(
 650     PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 651     IN  PVOID Parameter);
 652
 653 VOID
 654 CompleteWaveHeader(
 655     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 656     IN  PWAVEHDR Header);
 657
 658 MMRESULT
 659 PrepareWaveHeader(
 660     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 661     IN  PWAVEHDR Header);
 662
 663 MMRESULT
 664 UnprepareWaveHeader(
 665     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 666     IN  PWAVEHDR Header);
 667
 668 MMRESULT
 669 WriteWaveHeader(
 670     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 671     IN  PWAVEHDR Header);
 672
 673
 674 /*
 675     wave/streaming.c
 676 */
 677
 678 VOID
 679 DoWaveStreaming(
 680     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance);
 681
 682 VOID CALLBACK
 683 CompleteIO(
 684     IN  DWORD dwErrorCode,
 685     IN  DWORD dwNumberOfBytesTransferred,
 686     IN  LPOVERLAPPED lpOverlapped);
 687
 688 MMRESULT
 689 CommitWaveHeaderToKernelDevice(
 690     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 691     IN  PWAVEHDR Header,
 692     IN  WAVE_COMMIT_FUNC CommitFunction);
 693
 694 MMRESULT
 695 WriteFileEx_Committer(
 696     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 697     IN  PVOID OffsetPtr,
 698     IN  DWORD Length,
 699     IN  PSOUND_OVERLAPPED Overlap,
 700     IN  LPOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine);
 701
 702 MMRESULT
 703 StopStreaming(
 704     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance);
 705
 706 VOID
 707 InitiateSoundStreaming(
 708     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance);
 709
 710 /*
 711     kernel.c
 712 */
 713
 714 MMRESULT
 715 OpenKernelSoundDeviceByName(
 716     IN  PWSTR DevicePath,
 717     IN  BOOLEAN ReadOnly,
 718     OUT PHANDLE Handle);
 719
 720 MMRESULT
 721 OpenKernelSoundDevice(
 722     IN  PSOUND_DEVICE SoundDevice,
 723     IN  BOOLEAN ReadOnly,
 724     OUT PHANDLE Handle);
 725
 726 MMRESULT
 727 CloseKernelSoundDevice(
 728     IN  HANDLE Handle);
 729
 730 MMRESULT
 731 SyncOverlappedDeviceIoControl(
 732     IN  HANDLE SoundDeviceInstance,
 733     IN  DWORD IoControlCode,
 734     IN  LPVOID InBuffer,
 735     IN  DWORD InBufferSize,
 736     OUT LPVOID OutBuffer,
 737     IN  DWORD OutBufferSize,
 738     OUT LPDWORD BytesTransferred OPTIONAL);
 739
 740
 741 #endif