reactos/dll/win32/wdmaud.drv/legacy.c

   1 /*
   2  * PROJECT:     ReactOS Sound System
   3  * LICENSE:     GPL - See COPYING in the top level directory
   4  * FILE:        dll/win32/wdmaud.drv/wdmaud.c
   5  *
   6  * PURPOSE:     WDM Audio Driver (User-mode part)
   7  * PROGRAMMERS: Andrew Greenwood (silverblade@reactos.org)
   8                 Johannes Anderwald
   9  *
  10  * NOTES:       Looking for wodMessage & co? You won't find them here. Try
  11  *              the MME Buddy library, which is where these routines are
  12  *              actually implemented.
  13  *
  14  */
  15
  16 #include "wdmaud.h"
  17
  18 #include <stdio.h>
  19
  20 #define KERNEL_DEVICE_NAME      L"\\\\.\\wdmaud"
  21
  22 HANDLE KernelHandle = INVALID_HANDLE_VALUE;
  23 DWORD OpenCount = 0;
  24
  25 DWORD
  26 WINAPI
  27 MixerEventThreadRoutine(
  28     LPVOID Parameter)
  29 {
  30     HANDLE WaitObjects[2];
  31     DWORD dwResult;
  32     MMRESULT Result;
  33     WDMAUD_DEVICE_INFO DeviceInfo;
  34     PSOUND_DEVICE_INSTANCE Instance = (PSOUND_DEVICE_INSTANCE)Parameter;
  35
  36     /* setup wait objects */
  37     WaitObjects[0] = Instance->hNotifyEvent;
  38     WaitObjects[1] = Instance->hStopEvent;
  39
  40     /* zero device info */
  41     ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
  42
  43     DeviceInfo.hDevice = Instance->Handle;
  44     DeviceInfo.DeviceType = MIXER_DEVICE_TYPE;
  45
  46     do
  47     {
  48         dwResult = WaitForMultipleObjects(2, WaitObjects, FALSE, INFINITE);
  49
  50         if (dwResult == WAIT_OBJECT_0 + 1)
  51         {
  52             /* stop event was signalled */
  53             break;
  54         }
  55
  56         do
  57         {
  58             Result = SyncOverlappedDeviceIoControl(KernelHandle,
  59                                                    IOCTL_GET_MIXER_EVENT,
  60                                                    (LPVOID) &DeviceInfo,
  61                                                    sizeof(WDMAUD_DEVICE_INFO),
  62                                                    (LPVOID) &DeviceInfo,
  63                                                    sizeof(WDMAUD_DEVICE_INFO),
  64                                                    NULL);
  65
  66             if (Result == MMSYSERR_NOERROR)
  67             {
  68                 DriverCallback(Instance->WinMM.ClientCallback,
  69                                HIWORD(Instance->WinMM.Flags),
  70                                Instance->WinMM.Handle,
  71                                DeviceInfo.u.MixerEvent.NotificationType,
  72                                Instance->WinMM.ClientCallbackInstanceData,
  73                                (DWORD_PTR)DeviceInfo.u.MixerEvent.Value,
  74                                0);
  75             }
  76         }while(Result == MMSYSERR_NOERROR);
  77     }while(TRUE);
  78
  79     /* done */
  80     return 0;
  81 }
  82
  83 MMRESULT
  84 WdmAudCleanupByLegacy()
  85 {
  86     if (KernelHandle != INVALID_HANDLE_VALUE)
  87     {
  88         CloseHandle(KernelHandle);
  89         KernelHandle = INVALID_HANDLE_VALUE;
  90     }
  91
  92     return MMSYSERR_NOERROR;
  93 }
  94
  95 MMRESULT
  96 WdmAudGetNumWdmDevsByLegacy(
  97     IN  MMDEVICE_TYPE DeviceType,
  98     OUT DWORD* DeviceCount)
  99 {
 100     MMRESULT Result;
 101     WDMAUD_DEVICE_INFO DeviceInfo;
 102
 103     VALIDATE_MMSYS_PARAMETER( KernelHandle != INVALID_HANDLE_VALUE );
 104     VALIDATE_MMSYS_PARAMETER( IS_VALID_SOUND_DEVICE_TYPE(DeviceType) );
 105     VALIDATE_MMSYS_PARAMETER( DeviceCount );
 106
 107     ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
 108     DeviceInfo.DeviceType = DeviceType;
 109
 110     Result = SyncOverlappedDeviceIoControl(KernelHandle,
 111                                            IOCTL_GETNUMDEVS_TYPE,
 112                                            (LPVOID) &DeviceInfo,
 113                                            sizeof(WDMAUD_DEVICE_INFO),
 114                                            (LPVOID) &DeviceInfo,
 115                                            sizeof(WDMAUD_DEVICE_INFO),
 116                                            NULL);
 117
 118     if ( ! MMSUCCESS( Result ) )
 119     {
 120         SND_ERR(L"Call to IOCTL_GETNUMDEVS_TYPE failed\n");
 121         *DeviceCount = 0;
 122         return TranslateInternalMmResult(Result);
 123     }
 124
 125     *DeviceCount = DeviceInfo.DeviceCount;
 126
 127     return MMSYSERR_NOERROR;
 128 }
 129
 130 MMRESULT
 131 WdmAudGetCapabilitiesByLegacy(
 132     IN  PSOUND_DEVICE SoundDevice,
 133     IN  DWORD DeviceId,
 134     OUT PVOID Capabilities,
 135     IN  DWORD CapabilitiesSize)
 136 {
 137     MMRESULT Result;
 138     MMDEVICE_TYPE DeviceType;
 139     WDMAUD_DEVICE_INFO DeviceInfo;
 140
 141     SND_ASSERT( SoundDevice );
 142     SND_ASSERT( Capabilities );
 143
 144     Result = GetSoundDeviceType(SoundDevice, &DeviceType);
 145     SND_ASSERT( Result == MMSYSERR_NOERROR );
 146
 147     if ( ! MMSUCCESS(Result) )
 148         return Result;
 149
 150     SND_TRACE(L"WDMAUD - GetWdmDeviceCapabilities DeviceType %u DeviceId %u\n", DeviceType, DeviceId);
 151
 152     ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
 153     DeviceInfo.DeviceType = DeviceType;
 154     DeviceInfo.DeviceIndex = DeviceId;
 155
 156     Result = SyncOverlappedDeviceIoControl(KernelHandle,
 157                                            IOCTL_GETCAPABILITIES,
 158                                            (LPVOID) &DeviceInfo,
 159                                            sizeof(WDMAUD_DEVICE_INFO),
 160                                            (LPVOID) &DeviceInfo,
 161                                            sizeof(WDMAUD_DEVICE_INFO),
 162                                            NULL);
 163
 164     if ( ! MMSUCCESS(Result) )
 165     {
 166         return TranslateInternalMmResult(Result);
 167     }
 168
 169     /* This is pretty much a big hack right now */
 170     switch ( DeviceType )
 171     {
 172         case MIXER_DEVICE_TYPE:
 173         {
 174             LPMIXERCAPSW MixerCaps = (LPMIXERCAPSW) Capabilities;
 175
 176             DeviceInfo.u.MixCaps.szPname[MAXPNAMELEN-1] = L'\0';
 177             CopyWideString(MixerCaps->szPname, DeviceInfo.u.MixCaps.szPname);
 178
 179             MixerCaps->cDestinations = DeviceInfo.u.MixCaps.cDestinations;
 180             MixerCaps->fdwSupport = DeviceInfo.u.MixCaps.fdwSupport;
 181             MixerCaps->vDriverVersion = DeviceInfo.u.MixCaps.vDriverVersion;
 182             MixerCaps->wMid = DeviceInfo.u.MixCaps.wMid;
 183             MixerCaps->wPid = DeviceInfo.u.MixCaps.wPid;
 184             break;
 185         }
 186         case WAVE_OUT_DEVICE_TYPE :
 187         {
 188             LPWAVEOUTCAPSW WaveOutCaps = (LPWAVEOUTCAPSW) Capabilities;
 189
 190             DeviceInfo.u.WaveOutCaps.szPname[MAXPNAMELEN-1] = L'\0';
 191             WaveOutCaps->wMid = DeviceInfo.u.WaveOutCaps.wMid;
 192             WaveOutCaps->wPid = DeviceInfo.u.WaveOutCaps.wPid;
 193
 194             WaveOutCaps->vDriverVersion = DeviceInfo.u.WaveOutCaps.vDriverVersion;
 195             CopyWideString(WaveOutCaps->szPname, DeviceInfo.u.WaveOutCaps.szPname);
 196
 197             WaveOutCaps->dwFormats = DeviceInfo.u.WaveOutCaps.dwFormats;
 198             WaveOutCaps->wChannels = DeviceInfo.u.WaveOutCaps.wChannels;
 199             WaveOutCaps->dwSupport = DeviceInfo.u.WaveOutCaps.dwSupport;
 200             break;
 201         }
 202         case WAVE_IN_DEVICE_TYPE :
 203         {
 204             LPWAVEINCAPSW WaveInCaps = (LPWAVEINCAPSW) Capabilities;
 205
 206             DeviceInfo.u.WaveInCaps.szPname[MAXPNAMELEN-1] = L'\0';
 207
 208             WaveInCaps->wMid = DeviceInfo.u.WaveInCaps.wMid;
 209             WaveInCaps->wPid = DeviceInfo.u.WaveInCaps.wPid;
 210
 211             WaveInCaps->vDriverVersion = DeviceInfo.u.WaveInCaps.vDriverVersion;
 212             CopyWideString(WaveInCaps->szPname, DeviceInfo.u.WaveInCaps.szPname);
 213
 214             WaveInCaps->dwFormats = DeviceInfo.u.WaveInCaps.dwFormats;
 215             WaveInCaps->wChannels = DeviceInfo.u.WaveInCaps.wChannels;
 216             WaveInCaps->wReserved1 = 0;
 217             break;
 218         }
 219         case MIDI_IN_DEVICE_TYPE :
 220         {
 221             LPMIDIINCAPSW MidiInCaps = (LPMIDIINCAPSW)Capabilities;
 222
 223             DeviceInfo.u.MidiInCaps.szPname[MAXPNAMELEN-1] = L'\0';
 224
 225             MidiInCaps->vDriverVersion = DeviceInfo.u.MidiInCaps.vDriverVersion;
 226             MidiInCaps->wMid = DeviceInfo.u.MidiInCaps.wMid;
 227             MidiInCaps->wPid = DeviceInfo.u.MidiInCaps.wPid;
 228             MidiInCaps->dwSupport = DeviceInfo.u.MidiInCaps.dwSupport;
 229
 230             CopyWideString(MidiInCaps->szPname, DeviceInfo.u.MidiInCaps.szPname);
 231             break;
 232         }
 233         case MIDI_OUT_DEVICE_TYPE :
 234         {
 235             LPMIDIOUTCAPSW MidiOutCaps = (LPMIDIOUTCAPSW)Capabilities;
 236
 237             DeviceInfo.u.MidiOutCaps.szPname[MAXPNAMELEN-1] = L'\0';
 238
 239             MidiOutCaps->vDriverVersion = DeviceInfo.u.MidiOutCaps.vDriverVersion;
 240             MidiOutCaps->wMid = DeviceInfo.u.MidiOutCaps.wMid;
 241             MidiOutCaps->wPid = DeviceInfo.u.MidiOutCaps.wPid;
 242             MidiOutCaps->dwSupport = DeviceInfo.u.MidiOutCaps.dwSupport;
 243
 244             CopyWideString(MidiOutCaps->szPname, DeviceInfo.u.MidiOutCaps.szPname);
 245             break;
 246         }
 247     }
 248
 249     return MMSYSERR_NOERROR;
 250 }
 251
 252 MMRESULT
 253 WdmAudOpenSoundDeviceByLegacy()
 254 {
 255     /* Only open this if it's not already open */
 256     if ( KernelHandle == INVALID_HANDLE_VALUE )
 257     {
 258         SND_TRACE(L"Opening wdmaud device\n");
 259         KernelHandle = CreateFileW(KERNEL_DEVICE_NAME,
 260                                   GENERIC_READ | GENERIC_WRITE,
 261                                   0,
 262                                   NULL,
 263                                   OPEN_EXISTING,
 264                                   FILE_FLAG_OVERLAPPED,
 265                                   NULL);
 266     }
 267
 268     if ( KernelHandle == INVALID_HANDLE_VALUE )
 269         return MMSYSERR_ERROR;
 270
 271     ++ OpenCount;
 272
 273     return MMSYSERR_NOERROR;
 274 }
 275
 276 MMRESULT
 277 WdmAudCloseSoundDeviceByLegacy(
 278     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 279     IN  PVOID Handle)
 280 {
 281     WDMAUD_DEVICE_INFO DeviceInfo;
 282     MMRESULT Result;
 283     MMDEVICE_TYPE DeviceType;
 284     PSOUND_DEVICE SoundDevice;
 285
 286     Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
 287
 288     if ( ! MMSUCCESS(Result) )
 289     {
 290         return TranslateInternalMmResult(Result);
 291     }
 292
 293     if ( OpenCount == 0 )
 294     {
 295         return MMSYSERR_NOERROR;
 296     }
 297
 298     SND_ASSERT( KernelHandle != INVALID_HANDLE_VALUE );
 299
 300     Result = GetSoundDeviceType(SoundDevice, &DeviceType);
 301     SND_ASSERT( Result == MMSYSERR_NOERROR );
 302
 303     if (SoundDeviceInstance->Handle != (PVOID)KernelHandle)
 304     {
 305         ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
 306
 307         DeviceInfo.DeviceType = DeviceType;
 308         DeviceInfo.hDevice = SoundDeviceInstance->Handle;
 309
 310          /* First stop the stream */
 311          if (DeviceType != MIXER_DEVICE_TYPE)
 312          {
 313              DeviceInfo.u.State = KSSTATE_PAUSE;
 314              SyncOverlappedDeviceIoControl(KernelHandle,
 315                                            IOCTL_SETDEVICE_STATE,
 316                                            (LPVOID) &DeviceInfo,
 317                                            sizeof(WDMAUD_DEVICE_INFO),
 318                                            (LPVOID) &DeviceInfo,
 319                                             sizeof(WDMAUD_DEVICE_INFO),
 320                                             NULL);
 321
 322              DeviceInfo.u.State = KSSTATE_ACQUIRE;
 323              SyncOverlappedDeviceIoControl(KernelHandle,
 324                                            IOCTL_SETDEVICE_STATE,
 325                                            (LPVOID) &DeviceInfo,
 326                                            sizeof(WDMAUD_DEVICE_INFO),
 327                                            (LPVOID) &DeviceInfo,
 328                                             sizeof(WDMAUD_DEVICE_INFO),
 329                                             NULL);
 330
 331
 332              DeviceInfo.u.State = KSSTATE_STOP;
 333              SyncOverlappedDeviceIoControl(KernelHandle,
 334                                            IOCTL_SETDEVICE_STATE,
 335                                            (LPVOID) &DeviceInfo,
 336                                            sizeof(WDMAUD_DEVICE_INFO),
 337                                            (LPVOID) &DeviceInfo,
 338                                             sizeof(WDMAUD_DEVICE_INFO),
 339                                             NULL);
 340         }
 341
 342         SyncOverlappedDeviceIoControl(KernelHandle,
 343                                       IOCTL_CLOSE_WDMAUD,
 344                                       (LPVOID) &DeviceInfo,
 345                                       sizeof(WDMAUD_DEVICE_INFO),
 346                                       (LPVOID) &DeviceInfo,
 347                                       sizeof(WDMAUD_DEVICE_INFO),
 348                                       NULL);
 349     }
 350
 351     if (DeviceType == MIXER_DEVICE_TYPE)
 352     {
 353         SetEvent(SoundDeviceInstance->hStopEvent);
 354         CloseHandle(SoundDeviceInstance->hStopEvent);
 355         CloseHandle(SoundDeviceInstance->hNotifyEvent);
 356     }
 357
 358     --OpenCount;
 359
 360     if ( OpenCount < 1 )
 361     {
 362         CloseHandle(KernelHandle);
 363         KernelHandle = INVALID_HANDLE_VALUE;
 364     }
 365
 366     return MMSYSERR_NOERROR;
 367 }
 368
 369 MMRESULT
 370 WdmAudSetMixerDeviceFormatByLegacy(
 371     IN  PSOUND_DEVICE_INSTANCE Instance,
 372     IN  DWORD DeviceId,
 373     IN  PWAVEFORMATEX WaveFormat,
 374     IN  DWORD WaveFormatSize)
 375 {
 376     MMRESULT Result;
 377     WDMAUD_DEVICE_INFO DeviceInfo;
 378     HANDLE hThread;
 379
 380     Instance->hNotifyEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
 381     if ( ! Instance->hNotifyEvent )
 382         return MMSYSERR_NOMEM;
 383
 384     if (Instance->Handle != NULL)
 385     {
 386         /* device is already open */
 387         return MMSYSERR_NOERROR;
 388     }
 389
 390     Instance->hStopEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
 391     if ( ! Instance->hStopEvent )
 392         return MMSYSERR_NOMEM;
 393
 394     ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
 395     DeviceInfo.DeviceType = MIXER_DEVICE_TYPE;
 396     DeviceInfo.DeviceIndex = DeviceId;
 397     DeviceInfo.u.hNotifyEvent = Instance->hNotifyEvent;
 398
 399     Result = SyncOverlappedDeviceIoControl(KernelHandle,
 400                                            IOCTL_OPEN_WDMAUD,
 401                                            (LPVOID) &DeviceInfo,
 402                                            sizeof(WDMAUD_DEVICE_INFO),
 403                                            (LPVOID) &DeviceInfo,
 404                                            sizeof(WDMAUD_DEVICE_INFO),
 405                                            NULL);
 406
 407     if ( ! MMSUCCESS(Result) )
 408     {
 409         CloseHandle(Instance->hNotifyEvent);
 410         CloseHandle(Instance->hStopEvent);
 411         return TranslateInternalMmResult(Result);
 412     }
 413
 414     hThread = CreateThread(NULL, 0, MixerEventThreadRoutine, (LPVOID)Instance, 0, NULL);
 415     if (  hThread )
 416     {
 417         CloseHandle(hThread);
 418     }
 419
 420     /* Store sound device handle instance handle */
 421     Instance->Handle = (PVOID)DeviceInfo.hDevice;
 422
 423     return MMSYSERR_NOERROR;
 424 }
 425
 426 MMRESULT
 427 WdmAudSetWaveDeviceFormatByLegacy(
 428     IN  PSOUND_DEVICE_INSTANCE Instance,
 429     IN  DWORD DeviceId,
 430     IN  PWAVEFORMATEX WaveFormat,
 431     IN  DWORD WaveFormatSize)
 432 {
 433     MMRESULT Result;
 434     PSOUND_DEVICE SoundDevice;
 435     PVOID Identifier;
 436     WDMAUD_DEVICE_INFO DeviceInfo;
 437     MMDEVICE_TYPE DeviceType;
 438
 439     Result = GetSoundDeviceFromInstance(Instance, &SoundDevice);
 440
 441     if ( ! MMSUCCESS(Result) )
 442     {
 443         return TranslateInternalMmResult(Result);
 444     }
 445
 446     Result = GetSoundDeviceIdentifier(SoundDevice, &Identifier);
 447
 448     if ( ! MMSUCCESS(Result) )
 449     {
 450         return TranslateInternalMmResult(Result);
 451     }
 452
 453     if (Instance->Handle != NULL)
 454     {
 455         /* device is already open */
 456         return MMSYSERR_NOERROR;
 457     }
 458
 459     Result = GetSoundDeviceType(SoundDevice, &DeviceType);
 460
 461     SND_ASSERT( Result == MMSYSERR_NOERROR );
 462
 463     ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
 464     DeviceInfo.DeviceType = DeviceType;
 465     DeviceInfo.DeviceIndex = DeviceId;
 466     DeviceInfo.u.WaveFormatEx.cbSize = sizeof(WAVEFORMATEX); //WaveFormat->cbSize;
 467     DeviceInfo.u.WaveFormatEx.wFormatTag = WaveFormat->wFormatTag;
 468 #ifdef USERMODE_MIXER
 469     DeviceInfo.u.WaveFormatEx.nChannels = 2;
 470     DeviceInfo.u.WaveFormatEx.nSamplesPerSec = 44100;
 471     DeviceInfo.u.WaveFormatEx.nBlockAlign = 4;
 472     DeviceInfo.u.WaveFormatEx.nAvgBytesPerSec = 176400;
 473     DeviceInfo.u.WaveFormatEx.wBitsPerSample = 16;
 474 #else
 475     DeviceInfo.u.WaveFormatEx.nChannels = WaveFormat->nChannels;
 476     DeviceInfo.u.WaveFormatEx.nSamplesPerSec = WaveFormat->nSamplesPerSec;
 477     DeviceInfo.u.WaveFormatEx.nBlockAlign = WaveFormat->nBlockAlign;
 478     DeviceInfo.u.WaveFormatEx.nAvgBytesPerSec = WaveFormat->nAvgBytesPerSec;
 479     DeviceInfo.u.WaveFormatEx.wBitsPerSample = WaveFormat->wBitsPerSample;
 480 #endif
 481
 482     Result = SyncOverlappedDeviceIoControl(KernelHandle,
 483                                            IOCTL_OPEN_WDMAUD,
 484                                            (LPVOID) &DeviceInfo,
 485                                            sizeof(WDMAUD_DEVICE_INFO),
 486                                            (LPVOID) &DeviceInfo,
 487                                            sizeof(WDMAUD_DEVICE_INFO),
 488                                            NULL);
 489
 490     if ( ! MMSUCCESS(Result) )
 491     {
 492         return TranslateInternalMmResult(Result);
 493     }
 494
 495     /* Store format */
 496     Instance->WaveFormatEx.cbSize = WaveFormat->cbSize;
 497     Instance->WaveFormatEx.wFormatTag = WaveFormat->wFormatTag;
 498     Instance->WaveFormatEx.nChannels = WaveFormat->nChannels;
 499     Instance->WaveFormatEx.nSamplesPerSec = WaveFormat->nSamplesPerSec;
 500     Instance->WaveFormatEx.nBlockAlign = WaveFormat->nBlockAlign;
 501     Instance->WaveFormatEx.nAvgBytesPerSec = WaveFormat->nAvgBytesPerSec;
 502     Instance->WaveFormatEx.wBitsPerSample = WaveFormat->wBitsPerSample;
 503
 504     /* Store sound device handle instance handle */
 505     Instance->Handle = (PVOID)DeviceInfo.hDevice;
 506
 507     /* Now determine framing requirements */
 508     Result = SyncOverlappedDeviceIoControl(KernelHandle,
 509                                            IOCTL_GETFRAMESIZE,
 510                                            (LPVOID) &DeviceInfo,
 511                                            sizeof(WDMAUD_DEVICE_INFO),
 512                                            (LPVOID) &DeviceInfo,
 513                                            sizeof(WDMAUD_DEVICE_INFO),
 514                                            NULL);
 515
 516     if ( MMSUCCESS(Result) )
 517     {
 518         if (DeviceInfo.u.FrameSize)
 519         {
 520             Instance->FrameSize = DeviceInfo.u.FrameSize * 2;
 521             Instance->BufferCount = WaveFormat->nAvgBytesPerSec / Instance->FrameSize;
 522             SND_TRACE(L"FrameSize %u BufferCount %u\n", Instance->FrameSize, Instance->BufferCount);
 523         }
 524     }
 525     else
 526     {
 527         // use a default of 100 buffers
 528         Instance->BufferCount = 100;
 529     }
 530
 531     /* Now acquire resources */
 532     DeviceInfo.u.State = KSSTATE_ACQUIRE;
 533     SyncOverlappedDeviceIoControl(KernelHandle, IOCTL_SETDEVICE_STATE, (LPVOID) &DeviceInfo, sizeof(WDMAUD_DEVICE_INFO), (LPVOID) &DeviceInfo, sizeof(WDMAUD_DEVICE_INFO), NULL);
 534
 535     /* pause the pin */
 536     DeviceInfo.u.State = KSSTATE_PAUSE;
 537     SyncOverlappedDeviceIoControl(KernelHandle, IOCTL_SETDEVICE_STATE, (LPVOID) &DeviceInfo, sizeof(WDMAUD_DEVICE_INFO), (LPVOID) &DeviceInfo, sizeof(WDMAUD_DEVICE_INFO), NULL);
 538
 539     /* start the pin */
 540     DeviceInfo.u.State = KSSTATE_RUN;
 541     SyncOverlappedDeviceIoControl(KernelHandle, IOCTL_SETDEVICE_STATE, (LPVOID) &DeviceInfo, sizeof(WDMAUD_DEVICE_INFO), (LPVOID) &DeviceInfo, sizeof(WDMAUD_DEVICE_INFO), NULL);
 542
 543
 544     return MMSYSERR_NOERROR;
 545 }
 546
 547 VOID
 548 CALLBACK
 549 LegacyCompletionRoutine(
 550     IN  DWORD dwErrorCode,
 551     IN  DWORD dwNumberOfBytesTransferred,
 552     IN  LPOVERLAPPED lpOverlapped)
 553 {
 554     PSOUND_OVERLAPPED Overlap;
 555     PWDMAUD_DEVICE_INFO DeviceInfo;
 556
 557     Overlap = (PSOUND_OVERLAPPED)lpOverlapped;
 558     DeviceInfo = (PWDMAUD_DEVICE_INFO)Overlap->CompletionContext;
 559
 560     /* Call mmebuddy overlap routine */
 561     Overlap->OriginalCompletionRoutine(dwErrorCode, DeviceInfo->Header.DataUsed, lpOverlapped);
 562
 563     HeapFree(GetProcessHeap(), 0, DeviceInfo);
 564 }
 565
 566 MMRESULT
 567 WdmAudCommitWaveBufferByLegacy(
 568     IN  PSOUND_DEVICE_INSTANCE SoundDeviceInstance,
 569     IN  PVOID OffsetPtr,
 570     IN  DWORD Length,
 571     IN  PSOUND_OVERLAPPED Overlap,
 572     IN  LPOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine)
 573 {
 574     HANDLE Handle;
 575     MMRESULT Result;
 576     PWDMAUD_DEVICE_INFO DeviceInfo;
 577     PSOUND_DEVICE SoundDevice;
 578     MMDEVICE_TYPE DeviceType;
 579     BOOL Ret;
 580
 581     VALIDATE_MMSYS_PARAMETER( SoundDeviceInstance );
 582     VALIDATE_MMSYS_PARAMETER( OffsetPtr );
 583     VALIDATE_MMSYS_PARAMETER( Overlap );
 584     VALIDATE_MMSYS_PARAMETER( CompletionRoutine );
 585
 586     GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
 587     SND_ASSERT(Handle);
 588
 589     Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
 590
 591     if ( ! MMSUCCESS(Result) )
 592     {
 593         return TranslateInternalMmResult(Result);
 594     }
 595
 596     Result = GetSoundDeviceType(SoundDevice, &DeviceType);
 597     SND_ASSERT( Result == MMSYSERR_NOERROR );
 598
 599     DeviceInfo = (PWDMAUD_DEVICE_INFO)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WDMAUD_DEVICE_INFO));
 600     if (!DeviceInfo)
 601     {
 602         // no memory
 603         return MMSYSERR_NOMEM;
 604     }
 605
 606     DeviceInfo->Header.FrameExtent = Length;
 607     if (DeviceType == WAVE_OUT_DEVICE_TYPE)
 608     {
 609         DeviceInfo->Header.DataUsed = Length;
 610     }
 611     DeviceInfo->Header.Data = OffsetPtr;
 612     DeviceInfo->Header.Size = sizeof(WDMAUD_DEVICE_INFO);
 613     DeviceInfo->Header.PresentationTime.Numerator = 1;
 614     DeviceInfo->Header.PresentationTime.Denominator = 1;
 615     DeviceInfo->hDevice = Handle;
 616     DeviceInfo->DeviceType = DeviceType;
 617
 618
 619     // create completion event
 620     Overlap->Standard.hEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
 621     if (Overlap->Standard.hEvent == NULL)
 622     {
 623         // no memory
 624         return MMSYSERR_NOMEM;
 625     }
 626
 627     Overlap->OriginalCompletionRoutine = CompletionRoutine;
 628     Overlap->CompletionContext = (PVOID)DeviceInfo;
 629
 630     if (DeviceType == WAVE_OUT_DEVICE_TYPE)
 631     {
 632         Ret = WriteFileEx(KernelHandle, DeviceInfo, sizeof(WDMAUD_DEVICE_INFO), (LPOVERLAPPED)Overlap, LegacyCompletionRoutine);
 633         if (Ret)
 634             WaitForSingleObjectEx (KernelHandle, INFINITE, TRUE);
 635     }
 636     else if (DeviceType == WAVE_IN_DEVICE_TYPE)
 637     {
 638         Ret = ReadFileEx(KernelHandle, DeviceInfo, sizeof(WDMAUD_DEVICE_INFO), (LPOVERLAPPED)Overlap, LegacyCompletionRoutine);
 639         if (Ret)
 640             WaitForSingleObjectEx (KernelHandle, INFINITE, TRUE);
 641     }
 642
 643     // close event handle
 644     CloseHandle(Overlap->Standard.hEvent);
 645
 646     return MMSYSERR_NOERROR;
 647 }
 648
 649
 650
 651 MMRESULT
 652 WdmAudSetWaveStateByLegacy(
 653     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 654     IN BOOL bStart)
 655 {
 656     MMRESULT Result;
 657     PSOUND_DEVICE SoundDevice;
 658     WDMAUD_DEVICE_INFO DeviceInfo;
 659     MMDEVICE_TYPE DeviceType;
 660     HANDLE Handle;
 661
 662     Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
 663
 664     if ( ! MMSUCCESS(Result) )
 665     {
 666         return TranslateInternalMmResult(Result);
 667     }
 668
 669     Result = GetSoundDeviceType(SoundDevice, &DeviceType);
 670     SND_ASSERT( Result == MMSYSERR_NOERROR );
 671
 672     Result = GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
 673     SND_ASSERT( Result == MMSYSERR_NOERROR );
 674
 675     ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
 676     DeviceInfo.hDevice = Handle;
 677     DeviceInfo.DeviceType = DeviceType;
 678
 679     if (bStart)
 680         DeviceInfo.u.State = KSSTATE_RUN;
 681     else
 682         DeviceInfo.u.State = KSSTATE_PAUSE;
 683     Result = SyncOverlappedDeviceIoControl(KernelHandle,
 684                                            IOCTL_SETDEVICE_STATE,
 685                                            (LPVOID) &DeviceInfo,
 686                                            sizeof(WDMAUD_DEVICE_INFO),
 687                                            (LPVOID) &DeviceInfo,
 688                                            sizeof(WDMAUD_DEVICE_INFO),
 689                                            NULL);
 690
 691     return Result;
 692 }
 693
 694 MMRESULT
 695 WdmAudGetDeviceInterfaceStringByLegacy(
 696     IN  MMDEVICE_TYPE DeviceType,
 697     IN  DWORD DeviceId,
 698     IN  LPWSTR Interface,
 699     IN  DWORD  InterfaceLength,
 700     OUT  DWORD * InterfaceSize)
 701 {
 702     WDMAUD_DEVICE_INFO DeviceInfo;
 703     MMRESULT Result;
 704
 705     ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
 706     DeviceInfo.DeviceType = DeviceType;
 707     DeviceInfo.DeviceIndex = DeviceId;
 708
 709
 710     Result = SyncOverlappedDeviceIoControl(KernelHandle,
 711                                            IOCTL_QUERYDEVICEINTERFACESTRING,
 712                                            (LPVOID) &DeviceInfo,
 713                                            sizeof(WDMAUD_DEVICE_INFO),
 714                                            (LPVOID) &DeviceInfo,
 715                                            sizeof(WDMAUD_DEVICE_INFO),
 716                                            NULL);
 717
 718
 719     if ( ! MMSUCCESS(Result) )
 720     {
 721         return TranslateInternalMmResult(Result);
 722     }
 723
 724
 725     if (!Interface)
 726     {
 727         SND_ASSERT(InterfaceSize);
 728
 729         *InterfaceSize = DeviceInfo.u.Interface.DeviceInterfaceStringSize;
 730         return MMSYSERR_NOERROR;
 731     }
 732
 733     if (InterfaceLength < DeviceInfo.u.Interface.DeviceInterfaceStringSize)
 734     {
 735         /* buffer is too small */
 736         return MMSYSERR_MOREDATA;
 737     }
 738
 739     DeviceInfo.u.Interface.DeviceInterfaceStringSize = InterfaceLength;
 740     DeviceInfo.u.Interface.DeviceInterfaceString = Interface;
 741
 742     Result = SyncOverlappedDeviceIoControl(KernelHandle,
 743                                            IOCTL_QUERYDEVICEINTERFACESTRING,
 744                                            (LPVOID) &DeviceInfo,
 745                                            sizeof(WDMAUD_DEVICE_INFO),
 746                                            (LPVOID) &DeviceInfo,
 747                                            sizeof(WDMAUD_DEVICE_INFO),
 748                                            NULL);
 749
 750     if (  MMSUCCESS(Result) && InterfaceLength > 2)
 751     {
 752         Interface[1] = L'\\';
 753         Interface[InterfaceLength-1] = L'\0';
 754     }
 755
 756     return Result;
 757 }
 758
 759 MMRESULT
 760 WdmAudGetWavePositionByLegacy(
 761     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 762     IN  MMTIME* Time)
 763 {
 764     MMRESULT Result;
 765     PSOUND_DEVICE SoundDevice;
 766     WDMAUD_DEVICE_INFO DeviceInfo;
 767     MMDEVICE_TYPE DeviceType;
 768     HANDLE Handle;
 769
 770     Result = GetSoundDeviceFromInstance(SoundDeviceInstance, &SoundDevice);
 771
 772     if ( ! MMSUCCESS(Result) )
 773     {
 774         return TranslateInternalMmResult(Result);
 775     }
 776
 777     Result = GetSoundDeviceType(SoundDevice, &DeviceType);
 778     SND_ASSERT( Result == MMSYSERR_NOERROR );
 779
 780     Result = GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
 781     SND_ASSERT( Result == MMSYSERR_NOERROR );
 782
 783     ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
 784     DeviceInfo.hDevice = Handle;
 785     DeviceInfo.DeviceType = DeviceType;
 786
 787     Result = SyncOverlappedDeviceIoControl(KernelHandle,
 788                                            IOCTL_OPEN_WDMAUD,
 789                                            (LPVOID) &DeviceInfo,
 790                                            sizeof(WDMAUD_DEVICE_INFO),
 791                                            (LPVOID) &DeviceInfo,
 792                                            sizeof(WDMAUD_DEVICE_INFO),
 793                                            NULL);
 794
 795     if ( ! MMSUCCESS(Result) )
 796     {
 797         return TranslateInternalMmResult(Result);
 798     }
 799
 800     Time->wType = TIME_BYTES;
 801     Time->u.cb = (DWORD)DeviceInfo.u.Position;
 802
 803     return MMSYSERR_NOERROR;
 804 }
 805
 806
 807 MMRESULT
 808 WdmAudResetStreamByLegacy(
 809     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 810     IN  MMDEVICE_TYPE DeviceType,
 811     IN  BOOLEAN bStartReset)
 812 {
 813     MMRESULT Result;
 814     HANDLE Handle;
 815     WDMAUD_DEVICE_INFO DeviceInfo;
 816
 817     Result = GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
 818     SND_ASSERT( Result == MMSYSERR_NOERROR );
 819
 820     ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
 821     DeviceInfo.hDevice = Handle;
 822     DeviceInfo.DeviceType = DeviceType;
 823     DeviceInfo.u.ResetStream = (bStartReset ? KSRESET_BEGIN : KSRESET_END);
 824
 825     Result = SyncOverlappedDeviceIoControl(KernelHandle,
 826                                            IOCTL_RESET_STREAM,
 827                                            (LPVOID) &DeviceInfo,
 828                                            sizeof(WDMAUD_DEVICE_INFO),
 829                                            (LPVOID) &DeviceInfo,
 830                                            sizeof(WDMAUD_DEVICE_INFO),
 831                                            NULL);
 832     return Result;
 833 }
 834
 835 MMRESULT
 836 WdmAudQueryMixerInfoByLegacy(
 837     IN  struct _SOUND_DEVICE_INSTANCE* SoundDeviceInstance,
 838     IN DWORD DeviceId,
 839     IN UINT uMsg,
 840     IN LPVOID Parameter,
 841     IN DWORD Flags)
 842 {
 843     MMRESULT Result;
 844     WDMAUD_DEVICE_INFO DeviceInfo;
 845     HANDLE Handle;
 846     DWORD IoControlCode;
 847     LPMIXERLINEW MixLine;
 848     LPMIXERLINECONTROLSW MixControls;
 849     LPMIXERCONTROLDETAILS MixDetails;
 850
 851     SND_TRACE(L"uMsg %x Flags %x\n", uMsg, Flags);
 852
 853     Result = GetSoundDeviceInstanceHandle(SoundDeviceInstance, &Handle);
 854     SND_ASSERT( Result == MMSYSERR_NOERROR );
 855
 856     ZeroMemory(&DeviceInfo, sizeof(WDMAUD_DEVICE_INFO));
 857     DeviceInfo.hDevice = Handle;
 858     DeviceInfo.DeviceIndex = DeviceId;
 859     DeviceInfo.DeviceType = MIXER_DEVICE_TYPE;
 860     DeviceInfo.Flags = Flags;
 861
 862     MixLine = (LPMIXERLINEW)Parameter;
 863     MixControls = (LPMIXERLINECONTROLSW)Parameter;
 864     MixDetails = (LPMIXERCONTROLDETAILS)Parameter;
 865
 866     switch(uMsg)
 867     {
 868         case MXDM_GETLINEINFO:
 869             RtlCopyMemory(&DeviceInfo.u.MixLine, MixLine, sizeof(MIXERLINEW));
 870             IoControlCode = IOCTL_GETLINEINFO;
 871             break;
 872         case MXDM_GETLINECONTROLS:
 873             RtlCopyMemory(&DeviceInfo.u.MixControls, MixControls, sizeof(MIXERLINECONTROLSW));
 874             IoControlCode = IOCTL_GETLINECONTROLS;
 875             break;
 876        case MXDM_SETCONTROLDETAILS:
 877             RtlCopyMemory(&DeviceInfo.u.MixDetails, MixDetails, sizeof(MIXERCONTROLDETAILS));
 878             IoControlCode = IOCTL_SETCONTROLDETAILS;
 879             break;
 880        case MXDM_GETCONTROLDETAILS:
 881             RtlCopyMemory(&DeviceInfo.u.MixDetails, MixDetails, sizeof(MIXERCONTROLDETAILS));
 882             IoControlCode = IOCTL_GETCONTROLDETAILS;
 883             break;
 884        default:
 885            SND_ASSERT(0);
 886            return MMSYSERR_NOTSUPPORTED;
 887     }
 888
 889     Result = SyncOverlappedDeviceIoControl(KernelHandle,
 890                                            IoControlCode,
 891                                            (LPVOID) &DeviceInfo,
 892                                            sizeof(WDMAUD_DEVICE_INFO),
 893                                            (LPVOID) &DeviceInfo,
 894                                            sizeof(WDMAUD_DEVICE_INFO),
 895                                            NULL);
 896
 897     if ( ! MMSUCCESS(Result) )
 898     {
 899         return Result;
 900     }
 901
 902     switch(uMsg)
 903     {
 904         case MXDM_GETLINEINFO:
 905         {
 906             RtlCopyMemory(MixLine, &DeviceInfo.u.MixLine, sizeof(MIXERLINEW));
 907             break;
 908         }
 909     }
 910
 911     return Result;
 912 }