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 #ifdef DEBUG_NT4
  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\n", #condition); \
  60                 POPUP(L"ASSERT FAILED: %hS\n", #condition); \
  61                 ExitProcess(1); \
  62             } \
  63         }
  64
  65 #else
  66     #define SND_ERR(...) while ( 0 ) do {}
  67     #define SND_WARN(...) while ( 0 ) do {}
  68     #define SND_TRACE(...) while ( 0 ) do {}
  69     #define SND_ASSERT(condition) while ( 0 ) do {}
  70 #endif
  71
  72 /*
  73     Some memory allocation helper macros
  74 */
  75
  76 #define AllocateStruct(thing) \
  77     (thing*) AllocateMemory(sizeof(thing))
  78
  79 #define StringLengthToBytes(chartype, string_length) \
  80     ( ( string_length + 1 ) * sizeof(chartype) )
  81
  82 #define AllocateWideString(string_length) \
  83     (PWSTR) AllocateMemory(StringLengthToBytes(WCHAR, string_length))
  84
  85 #define ZeroWideString(string) \
  86     ZeroMemory(string, StringLengthToBytes(WCHAR, wcslen(string)))
  87
  88 #define CopyWideString(dest, source) \
  89     CopyMemory(dest, source, StringLengthToBytes(WCHAR, wcslen(source)))
  90
  91
  92 /*
  93     Helps find the minimum/maximum of two values
  94 */
  95
  96 #define MinimumOf(value_a, value_b) \
  97     ( value_a < value_b ? value_a : value_b )
  98
  99 #define MaximumOf(value_a, value_b) \
 100     ( value_a > value_b ? value_a : value_b )
 101
 102
 103 /*
 104     Convert a device type into a zero-based array index
 105 */
 106
 107 #define SOUND_DEVICE_TYPE_TO_INDEX(x) \
 108     ( x - MIN_SOUND_DEVICE_TYPE )
 109
 110 #define INDEX_TO_SOUND_DEVICE_TYPE(x) \
 111     ( x + MIN_SOUND_DEVICE_TYPE )
 112
 113
 114 /*
 115     Validation
 116 */
 117
 118 #define IsValidSoundDeviceType IS_VALID_SOUND_DEVICE_TYPE
 119
 120 #define VALIDATE_MMSYS_PARAMETER(parameter_condition) \
 121     { \
 122         if ( ! (parameter_condition) ) \
 123         { \
 124             SND_ERR(L"FAILED parameter check: %hS\n", #parameter_condition); \
 125             return MMSYSERR_INVALPARAM; \
 126         } \
 127     }
 128
 129 #define MMSUCCESS(result) \
 130     ( result == MMSYSERR_NOERROR )
 131
 132
 133 /*
 134     Types and Structures
 135 */
 136
 137 typedef UCHAR MMDEVICE_TYPE, *PMMDEVICE_TYPE;
 138 struct _SOUND_DEVICE;
 139 struct _SOUND_DEVICE_INSTANCE;
 140
 141
 142 #define DEFINE_GETCAPS_FUNCTYPE(func_typename, caps_type) \
 143     typedef MMRESULT (*func_typename)( \
 144         IN  struct _SOUND_DEVICE* SoundDevice, \
 145         OUT caps_type Capabilities, \
 146         IN  DWORD CapabilitiesSize);
 147
 148 /* This one is for those of us who don't care */
 149 DEFINE_GETCAPS_FUNCTYPE(MMGETCAPS_FUNC, PVOID);
 150
 151 /* These are for those of us that do */
 152 DEFINE_GETCAPS_FUNCTYPE(MMGETWAVEOUTCAPS_FUNC, LPWAVEOUTCAPS);
 153 DEFINE_GETCAPS_FUNCTYPE(MMGETWAVEINCAPS_FUNC,  LPWAVEINCAPS );
 154 DEFINE_GETCAPS_FUNCTYPE(MMGETMIDIOUTCAPS_FUNC, LPMIDIOUTCAPS);
 155 DEFINE_GETCAPS_FUNCTYPE(MMGETMIDIINCAPS_FUNC,  LPMIDIINCAPS );
 156
 157 struct _SOUND_DEVICE;
 158 struct _SOUND_DEVICE_INSTANCE;
 159
 160 typedef MMRESULT (*MMWAVEQUERYFORMATSUPPORT_FUNC)(
 161     IN  struct _SOUND_DEVICE* Device,
 162     IN  PWAVEFORMATEX WaveFormat,
 163     IN  DWORD WaveFormatSize);
 164
 165 typedef MMRESULT (*MMWAVESETFORMAT_FUNC)(
 166     IN  struct _SOUND_DEVICE_INSTANCE* Instance,
 167     IN  PWAVEFORMATEX WaveFormat,
 168     IN  DWORD WaveFormatSize);
 169
 170 typedef MMRESULT (*MMOPEN_FUNC)(
 171     IN  struct _SOUND_DEVICE* SoundDevice,
 172     OUT PVOID* Handle);
 173
 174 typedef MMRESULT (*MMCLOSE_FUNC)(
 175     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 176     IN  PVOID Handle);  /* not sure about this */
 177
 178 typedef MMRESULT (*MMWAVEHEADER_FUNC)(
 179     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 180     IN  PWAVEHDR WaveHeader);
 181
 182 typedef struct _MMFUNCTION_TABLE
 183 {
 184     union
 185     {
 186         MMGETCAPS_FUNC              GetCapabilities;
 187         MMGETWAVEOUTCAPS_FUNC       GetWaveOutCapabilities;
 188         MMGETWAVEINCAPS_FUNC        GetWaveInCapabilities;
 189         MMGETMIDIOUTCAPS_FUNC       GetMidiOutCapabilities;
 190         MMGETMIDIINCAPS_FUNC        GetMidiInCapabilities;
 191     };
 192
 193     MMOPEN_FUNC                     Open;
 194     MMCLOSE_FUNC                    Close;
 195
 196     MMWAVEQUERYFORMATSUPPORT_FUNC   QueryWaveFormatSupport;
 197     MMWAVESETFORMAT_FUNC            SetWaveFormat;
 198
 199     MMWAVEHEADER_FUNC               PrepareWaveHeader;
 200     MMWAVEHEADER_FUNC               UnprepareWaveHeader;
 201     MMWAVEHEADER_FUNC               SubmitWaveHeader;
 202 } MMFUNCTION_TABLE, *PMMFUNCTION_TABLE;
 203
 204 typedef MMRESULT (*SOUND_THREAD_REQUEST_HANDLER)(
 205     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 206     IN  PVOID Parameter);
 207
 208 typedef struct _SOUND_THREAD
 209 {
 210     HANDLE Handle;
 211     BOOL Running;
 212
 213     struct
 214     {
 215         HANDLE Ready;
 216         HANDLE Request;
 217         HANDLE Done;
 218     } Events;
 219
 220     struct
 221     {
 222         SOUND_THREAD_REQUEST_HANDLER Handler;
 223         struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance;
 224         PVOID Parameter;
 225         MMRESULT Result;
 226     } Request;
 227 } SOUND_THREAD, *PSOUND_THREAD;
 228
 229 typedef struct _SOUND_DEVICE
 230 {
 231     struct _SOUND_DEVICE* Next;
 232     struct _SOUND_DEVICE_INSTANCE* HeadInstance;
 233     struct _SOUND_DEVICE_INSTANCE* TailInstance;
 234     MMDEVICE_TYPE Type;
 235     PVOID Identifier;       /* Path for NT4 drivers */
 236     /*PWSTR Path;*/
 237     MMFUNCTION_TABLE FunctionTable;
 238 } SOUND_DEVICE, *PSOUND_DEVICE;
 239
 240 typedef struct _SOUND_DEVICE_INSTANCE
 241 {
 242     struct _SOUND_DEVICE_INSTANCE* Next;
 243     struct _SOUND_DEVICE* Device;
 244     PVOID Handle;
 245     struct _SOUND_THREAD* Thread;
 246
 247     /* Stuff generously donated to us from WinMM */
 248     struct
 249     {
 250         HDRVR Handle;
 251         DWORD Flags;
 252         DWORD ClientCallback;
 253         DWORD ClientCallbackInstanceData;
 254     } WinMM;
 255 } SOUND_DEVICE_INSTANCE, *PSOUND_DEVICE_INSTANCE;
 256
 257 /*
 258     reentrancy.c
 259 */
 260
 261 MMRESULT
 262 InitEntrypointMutexes();
 263
 264 VOID
 265 CleanupEntrypointMutexes();
 266
 267 VOID
 268 AcquireEntrypointMutex(
 269     IN  MMDEVICE_TYPE DeviceType);
 270
 271 VOID
 272 ReleaseEntrypointMutex(
 273     IN  MMDEVICE_TYPE DeviceType);
 274
 275
 276 /*
 277     mme.c
 278 */
 279
 280 VOID
 281 NotifyMmeClient(
 282     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 283     IN  DWORD Message,
 284     IN  DWORD Parameter);
 285
 286 MMRESULT
 287 MmeGetSoundDeviceCapabilities(
 288     IN  MMDEVICE_TYPE DeviceType,
 289     IN  DWORD DeviceId,
 290     IN  PVOID Capabilities,
 291     IN  DWORD CapabilitiesSize);
 292
 293 MMRESULT
 294 MmeOpenWaveDevice(
 295     IN  MMDEVICE_TYPE DeviceType,
 296     IN  DWORD DeviceId,
 297     IN  LPWAVEOPENDESC OpenParameters,
 298     IN  DWORD Flags,
 299     OUT DWORD* PrivateHandle);
 300
 301 MMRESULT
 302 MmeCloseDevice(
 303     IN  DWORD PrivateHandle);
 304
 305 #define MmePrepareWaveHeader(private_handle, header) \
 306     PrepareWaveHeader((PSOUND_DEVICE_INSTANCE)private_handle, (PWAVEHDR)header)
 307
 308 #define MmeUnprepareWaveHeader(private_handle, header) \
 309     UnprepareWaveHeader((PSOUND_DEVICE_INSTANCE)private_handle, (PWAVEHDR)header)
 310
 311 #define MmeEnqueueWaveHeader(private_handle, header) \
 312     EnqueueWaveHeader((PSOUND_DEVICE_INSTANCE)private_handle, (PWAVEHDR)header)
 313
 314
 315 /*
 316     capabilities.c
 317 */
 318
 319 MMRESULT
 320 GetSoundDeviceCapabilities(
 321     IN  PSOUND_DEVICE SoundDevice,
 322     OUT PVOID Capabilities,
 323     IN  DWORD CapabilitiesSize);
 324
 325
 326 /*
 327     devicelist.c
 328 */
 329
 330 ULONG
 331 GetSoundDeviceCount(
 332     IN  MMDEVICE_TYPE DeviceType);
 333
 334 BOOLEAN
 335 IsValidSoundDevice(
 336     IN  PSOUND_DEVICE SoundDevice);
 337
 338 MMRESULT
 339 ListSoundDevice(
 340     IN  MMDEVICE_TYPE DeviceType,
 341     IN  PVOID Identifier OPTIONAL,
 342     OUT PSOUND_DEVICE* SoundDevice OPTIONAL);
 343
 344 MMRESULT
 345 UnlistSoundDevice(
 346     IN  MMDEVICE_TYPE DeviceType,
 347     IN  PSOUND_DEVICE SoundDevice);
 348
 349 MMRESULT
 350 UnlistSoundDevices(
 351     IN  MMDEVICE_TYPE DeviceType);
 352
 353 VOID
 354 UnlistAllSoundDevices();
 355
 356 MMRESULT
 357 GetSoundDevice(
 358     IN  MMDEVICE_TYPE DeviceType,
 359     IN  DWORD DeviceIndex,
 360     OUT PSOUND_DEVICE* Device);
 361
 362 MMRESULT
 363 GetSoundDeviceIdentifier(
 364     IN  PSOUND_DEVICE SoundDevice,
 365     OUT PVOID* Identifier);
 366
 367 MMRESULT
 368 GetSoundDeviceType(
 369     IN  PSOUND_DEVICE SoundDevice,
 370     OUT PMMDEVICE_TYPE DeviceType);
 371
 372
 373 /*
 374     functiontable.c
 375 */
 376
 377 MMRESULT
 378 SetSoundDeviceFunctionTable(
 379     IN  PSOUND_DEVICE SoundDevice,
 380     IN  PMMFUNCTION_TABLE FunctionTable);
 381
 382 MMRESULT
 383 GetSoundDeviceFunctionTable(
 384     IN  PSOUND_DEVICE SoundDevice,
 385     OUT PMMFUNCTION_TABLE* FunctionTable);
 386
 387
 388 /*
 389     deviceinstance.c
 390 */
 391
 392 BOOLEAN
 393 IsValidSoundDeviceInstance(
 394     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance);
 395
 396 MMRESULT
 397 CreateSoundDeviceInstance(
 398     IN  PSOUND_DEVICE SoundDevice,
 399     OUT PSOUND_DEVICE_INSTANCE* SoundDeviceInstance);
 400
 401 MMRESULT
 402 DestroySoundDeviceInstance(
 403     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance);
 404
 405 MMRESULT
 406 DestroyAllSoundDeviceInstances(
 407     IN  PSOUND_DEVICE SoundDevice);
 408
 409 MMRESULT
 410 GetSoundDeviceFromInstance(
 411     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 412     OUT PSOUND_DEVICE* SoundDevice);
 413
 414 MMRESULT
 415 GetSoundDeviceInstanceHandle(
 416     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 417     OUT PVOID* Handle);
 418
 419 MMRESULT
 420 SetSoundDeviceInstanceMmeData(
 421     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 422     IN  HDRVR MmeHandle,
 423     IN  DWORD ClientCallback,
 424     IN  DWORD ClientCallbackData,
 425     IN  DWORD Flags);
 426
 427
 428 /*
 429     thread.c
 430 */
 431
 432 MMRESULT
 433 CreateSoundThread(
 434     OUT PSOUND_THREAD* Thread);
 435
 436 MMRESULT
 437 DestroySoundThread(
 438     IN  PSOUND_THREAD Thread);
 439
 440 MMRESULT
 441 CallSoundThread(
 442     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 443     IN  SOUND_THREAD_REQUEST_HANDLER RequestHandler,
 444     IN  PVOID Parameter OPTIONAL);
 445
 446
 447 /*
 448     utility.c
 449 */
 450
 451 PVOID
 452 AllocateMemory(
 453     IN  UINT Size);
 454
 455 VOID
 456 FreeMemory(
 457     IN  PVOID Pointer);
 458
 459 UINT
 460 GetMemoryAllocationCount();
 461
 462 UINT
 463 GetDigitCount(
 464     IN  UINT Number);
 465
 466 MMRESULT
 467 Win32ErrorToMmResult(
 468     IN  UINT ErrorCode);
 469
 470 MMRESULT
 471 TranslateInternalMmResult(
 472     IN  MMRESULT Result);
 473
 474
 475 /*
 476     wave/format.c
 477 */
 478
 479 MMRESULT
 480 QueryWaveDeviceFormatSupport(
 481     IN  PSOUND_DEVICE SoundDevice,
 482     IN  LPWAVEFORMATEX Format,
 483     IN  DWORD FormatSize);
 484
 485 MMRESULT
 486 SetWaveDeviceFormat(
 487     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 488     IN  LPWAVEFORMATEX Format,
 489     IN  DWORD FormatSize);
 490
 491
 492 /*
 493     wave/header.c
 494 */
 495
 496 MMRESULT
 497 PrepareWaveHeader(
 498     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 499     IN  PWAVEHDR Header);
 500
 501 MMRESULT
 502 UnprepareWaveHeader(
 503     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 504     IN  PWAVEHDR Header);
 505
 506 MMRESULT
 507 EnqueueWaveHeader(
 508     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 509     IN  PWAVEHDR Header);
 510
 511
 512 /*
 513     kernel.c
 514 */
 515
 516 #if 0
 517 #define QueryDevice(h, ctl, o, o_size, xfer, ovl) \
 518     Win32ErrorToMmResult( \
 519         DeviceIoControl(h, ctl, NULL, 0, o, o_size, xfer, ovl) != 0 \
 520         ? ERROR_SUCCESS : GetLastError() \
 521     )
 522
 523 #define ControlDevice(h, ctl, i, i_size, xfer, ovl) \
 524     Win32ErrorToMmResult( \
 525         DeviceIoControl(h, ctl, i, i_size, NULL, 0, xfer, ovl) != 0 \
 526         ? ERROR_SUCCESS : GetLastError() \
 527     )
 528
 529 #define QuerySoundDevice(sd, ctl, o, o_size, xfer) \
 530     SoundDeviceIoControl(sd, ctl, NULL, 0, o, o_size, xfer)
 531
 532 #define ControlSoundDevice(sd, ctl, i, i_size, xfer) \
 533     SoundDeviceIoControl(sd, ctl, i, i_size, NULL, 0, xfer)
 534 #endif
 535
 536 MMRESULT
 537 OpenKernelSoundDeviceByName(
 538     IN  PWSTR DevicePath,
 539     IN  BOOLEAN ReadOnly,
 540     OUT PHANDLE Handle);
 541
 542 MMRESULT
 543 OpenKernelSoundDevice(
 544     IN  PSOUND_DEVICE SoundDevice,
 545     IN  BOOLEAN ReadOnly,
 546     OUT PHANDLE Handle);
 547
 548 MMRESULT
 549 CloseKernelSoundDevice(
 550     IN  HANDLE Handle);
 551
 552 MMRESULT
 553 SyncOverlappedDeviceIoControl(
 554     IN  HANDLE SoundDeviceInstance,
 555     IN  DWORD IoControlCode,
 556     IN  LPVOID InBuffer,
 557     IN  DWORD InBufferSize,
 558     OUT LPVOID OutBuffer,
 559     IN  DWORD OutBufferSize,
 560     OUT LPDWORD BytesTransferred OPTIONAL);
 561
 562
 563 #if 0
 564
 565 typedef UCHAR MMDEVICE_TYPE, *PMMDEVICE_TYPE;
 566
 567 struct _SOUND_DEVICE;
 568 struct _SOUND_DEVICE_INSTANCE;
 569
 570
 571 /*
 572     Rather than pass caps structures around as a PVOID, this can be
 573     used instead.
 574 */
 575
 576 typedef union _UNIVERSAL_CAPS
 577 {
 578     WAVEOUTCAPS WaveOut;
 579     WAVEINCAPS WaveIn;
 580     MIDIOUTCAPS MidiOut;
 581     MIDIINCAPS MidiIn;
 582 } UNIVERSAL_CAPS, *PUNIVERSAL_CAPS;
 583
 584
 585
 586 /* New sound thread code */
 587
 588 typedef MMRESULT (*SOUND_THREAD_REQUEST_HANDLER)(
 589     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 590     IN  OPTIONAL PVOID Parameter);
 591
 592 typedef struct _SOUND_THREAD_REQUEST
 593 {
 594     /* The sound device instance this request relates to */
 595     struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance;
 596     /* What function to call */
 597     SOUND_THREAD_REQUEST_HANDLER RequestHandler;
 598     /* Caller-defined parameter */
 599     PVOID Parameter;
 600     /* This will contain the return code of the request function */
 601     MMRESULT ReturnValue;
 602 } SOUND_THREAD_REQUEST, *PSOUND_THREAD_REQUEST;
 603
 604 typedef VOID (*SOUND_THREAD_IO_COMPLETION_HANDLER)(
 605     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 606     IN  PVOID Parameter OPTIONAL,
 607     IN  DWORD BytesWritten);
 608
 609 typedef struct _SOUND_THREAD_COMPLETED_IO
 610 {
 611     struct _SOUND_THREAD_COMPLETED_IO* Previous;
 612     struct _SOUND_THREAD_COMPLETED_IO* Next;
 613
 614     struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance;
 615     SOUND_THREAD_IO_COMPLETION_HANDLER CompletionHandler;
 616     PVOID Parameter;
 617     DWORD BytesTransferred;
 618 } SOUND_THREAD_COMPLETED_IO, *PSOUND_THREAD_COMPLETED_IO;
 619
 620 typedef struct _SOUND_THREAD_OVERLAPPED
 621 {
 622     OVERLAPPED General;
 623
 624     /* Pointer to structure to fill with completion data */
 625     PSOUND_THREAD_COMPLETED_IO CompletionData;
 626 } SOUND_THREAD_OVERLAPPED, *PSOUND_THREAD_OVERLAPPED;
 627
 628 /*
 629     Audio device function table
 630 */
 631
 632 typedef MMRESULT (*MMCREATEINSTANCE_FUNC)(
 633     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance);
 634
 635 typedef VOID (*MMDESTROYINSTANCE_FUNC)(
 636     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance);
 637
 638 typedef MMRESULT (*MMGETCAPS_FUNC)(
 639     IN  struct _SOUND_DEVICE* Device,
 640     OUT PUNIVERSAL_CAPS Capabilities);
 641
 642 typedef MMRESULT (*MMWAVEQUERYFORMAT_FUNC)(
 643     IN  struct _SOUND_DEVICE* Device,
 644     IN  PWAVEFORMATEX WaveFormat,
 645     IN  DWORD WaveFormatSize);
 646
 647 typedef MMRESULT (*MMWAVESETFORMAT_FUNC)(
 648     IN  struct _SOUND_DEVICE_INSTANCE* Instance,
 649     IN  PWAVEFORMATEX WaveFormat,
 650     IN  DWORD WaveFormatSize);
 651
 652 typedef MMRESULT (*MMWAVEQUEUEBUFFER_FUNC)(
 653     IN  struct _SOUND_DEVICE_INSTANCE* Instance,
 654     IN  PWAVEHDR WaveHeader);
 655
 656 typedef MMRESULT (*MMGETWAVESTATE_FUNC)(
 657     IN  struct _SOUND_DEVICE_INSTANCE* Instance,
 658     OUT PULONG State);
 659
 660 typedef MMRESULT (*MMSETWAVESTATE_FUNC)(
 661     IN  struct _SOUND_DEVICE_INSTANCE* Instance);
 662
 663 typedef struct _MMFUNCTION_TABLE
 664 {
 665     MMCREATEINSTANCE_FUNC   Constructor;
 666     MMDESTROYINSTANCE_FUNC  Destructor;
 667     MMGETCAPS_FUNC          GetCapabilities;
 668
 669     MMWAVEQUERYFORMAT_FUNC  QueryWaveFormat;
 670     MMWAVESETFORMAT_FUNC    SetWaveFormat;
 671     MMWAVEQUEUEBUFFER_FUNC  QueueWaveBuffer;
 672
 673     MMGETWAVESTATE_FUNC     GetWaveDeviceState;
 674     MMSETWAVESTATE_FUNC     PauseWaveDevice;
 675     MMSETWAVESTATE_FUNC     RestartWaveDevice;
 676     MMSETWAVESTATE_FUNC     ResetWaveDevice;
 677     MMSETWAVESTATE_FUNC     BreakWaveDeviceLoop;
 678 } MMFUNCTION_TABLE, *PMMFUNCTION_TABLE;
 679
 680
 681 /*
 682     Represents an audio device
 683 */
 684
 685 #define SOUND_DEVICE_TAG "SndD"
 686
 687 typedef struct _SOUND_DEVICE
 688 {
 689     struct _SOUND_DEVICE* Next;
 690     struct _SOUND_DEVICE_INSTANCE* FirstInstance;
 691     UCHAR DeviceType;
 692     LPWSTR DevicePath;
 693     MMFUNCTION_TABLE Functions;
 694 } SOUND_DEVICE, *PSOUND_DEVICE;
 695
 696
 697 /*
 698     Represents an individual instance of an audio device
 699 */
 700
 701 #define WAVE_STREAM_INFO_TAG "WavS"
 702
 703 typedef struct _WAVE_STREAM_INFO
 704 {
 705     /* Buffer queue head and tail */
 706     PWAVEHDR BufferQueueHead;
 707     PWAVEHDR BufferQueueTail;
 708     /* The buffer currently being processed */
 709     PWAVEHDR CurrentBuffer;
 710     /* How far into the current buffer we've gone */
 711     DWORD BufferOffset;
 712     /* How many I/O operations have been submitted */
 713     DWORD BuffersOutstanding;
 714     /* Looping */
 715     PWAVEHDR LoopHead;
 716     DWORD LoopsRemaining;
 717 } WAVE_STREAM_INFO, *PWAVE_STREAM_INFO;
 718
 719
 720 #define SOUND_DEVICE_INSTANCE_TAG "SndI"
 721
 722 typedef struct _SOUND_DEVICE_INSTANCE
 723 {
 724     struct _SOUND_DEVICE_INSTANCE* Next;
 725     PSOUND_DEVICE Device;
 726
 727     /* The currently opened handle to the device */
 728     HANDLE Handle;
 729 /*    PSOUND_THREAD Thread;*/
 730
 731
 732     /* Device-specific parameters */
 733     union
 734     {
 735         WAVE_STREAM_INFO Wave;
 736     } Streaming;
 737 } SOUND_DEVICE_INSTANCE, *PSOUND_DEVICE_INSTANCE;
 738
 739 #endif
 740
 741 #endif