Alc/winmm.c

   1 /**
   2  * OpenAL cross platform audio library
   3  * Copyright (C) 1999-2007 by authors.
   4  * This library is free software; you can redistribute it and/or
   5  *  modify it under the terms of the GNU Library General Public
   6  *  License as published by the Free Software Foundation; either
   7  *  version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  *  License along with this library; if not, write to the
  16  *  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  *  Boston, MA  02111-1307, USA.
  18  * Or go to http://www.gnu.org/copyleft/lgpl.html
  19  */
  20
  21 #include "config.h"
  22
  23 #define _WIN32_WINNT 0x0500
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <memory.h>
  27
  28 #include <windows.h>
  29 #include <mmsystem.h>
  30
  31 #include "alMain.h"
  32 #include "AL/al.h"
  33 #include "AL/alc.h"
  34
  35
  36 typedef struct {
  37     // MMSYSTEM Device
  38     volatile ALboolean bWaveShutdown;
  39     HANDLE  hWaveHdrEvent;
  40     HANDLE  hWaveThreadEvent;
  41     HANDLE  hWaveThread;
  42     DWORD   ulWaveThreadID;
  43     LONG    lWaveBuffersCommitted;
  44     WAVEHDR WaveBuffer[4];
  45
  46     union {
  47         HWAVEIN  In;
  48         HWAVEOUT Out;
  49     } hWaveHandle;
  50
  51     ALsizei Frequency;
  52
  53     RingBuffer *pRing;
  54 } WinMMData;
  55
  56
  57 static const ALCchar woDefault[] = "WaveOut Default";
  58
  59 static ALCchar **PlaybackDeviceList;
  60 static ALuint  NumPlaybackDevices;
  61 static ALCchar **CaptureDeviceList;
  62 static ALuint  NumCaptureDevices;
  63
  64
  65 static void ProbePlaybackDevices(void)
  66 {
  67     ALuint i;
  68
  69     for(i = 0;i < NumPlaybackDevices;i++)
  70         free(PlaybackDeviceList[i]);
  71
  72     NumPlaybackDevices = waveOutGetNumDevs();
  73     PlaybackDeviceList = realloc(PlaybackDeviceList, sizeof(ALCchar*) * NumPlaybackDevices);
  74     for(i = 0;i < NumPlaybackDevices;i++)
  75     {
  76         WAVEOUTCAPS WaveCaps;
  77
  78         PlaybackDeviceList[i] = NULL;
  79         if(waveOutGetDevCaps(i, &WaveCaps, sizeof(WaveCaps)) == MMSYSERR_NOERROR)
  80         {
  81             char name[1024];
  82             ALuint count, j;
  83
  84             count = 0;
  85             do {
  86                 if(count == 0)
  87                     snprintf(name, sizeof(name), "%s via WaveOut", WaveCaps.szPname);
  88                 else
  89                     snprintf(name, sizeof(name), "%s #%d via WaveOut", WaveCaps.szPname, count+1);
  90                 count++;
  91
  92                 for(j = 0;j < i;j++)
  93                 {
  94                     if(strcmp(name, PlaybackDeviceList[j]) == 0)
  95                         break;
  96                 }
  97             } while(j != i);
  98
  99             PlaybackDeviceList[i] = strdup(name);
 100         }
 101     }
 102 }
 103
 104 static void ProbeCaptureDevices(void)
 105 {
 106     ALuint i;
 107
 108     for(i = 0;i < NumCaptureDevices;i++)
 109         free(CaptureDeviceList[i]);
 110
 111     NumCaptureDevices = waveInGetNumDevs();
 112     CaptureDeviceList = realloc(CaptureDeviceList, sizeof(ALCchar*) * NumCaptureDevices);
 113     for(i = 0;i < NumCaptureDevices;i++)
 114     {
 115         WAVEINCAPS WaveInCaps;
 116
 117         CaptureDeviceList[i] = NULL;
 118         if(waveInGetDevCaps(i, &WaveInCaps, sizeof(WAVEINCAPS)) == MMSYSERR_NOERROR)
 119         {
 120             char name[1024];
 121             ALuint count, j;
 122
 123             count = 0;
 124             do {
 125                 if(count == 0)
 126                     snprintf(name, sizeof(name), "%s via WaveIn", WaveInCaps.szPname);
 127                 else
 128                     snprintf(name, sizeof(name), "%s #%d via WaveIn", WaveInCaps.szPname, count+1);
 129                 count++;
 130
 131                 for(j = 0;j < i;j++)
 132                 {
 133                     if(strcmp(name, CaptureDeviceList[j]) == 0)
 134                         break;
 135                 }
 136             } while(j != i);
 137
 138             CaptureDeviceList[i] = strdup(name);
 139         }
 140     }
 141 }
 142
 143
 144 /*
 145     WaveOutProc
 146
 147     Posts a message to 'PlaybackThreadProc' everytime a WaveOut Buffer is completed and
 148     returns to the application (for more data)
 149 */
 150 static void CALLBACK WaveOutProc(HWAVEOUT hDevice,UINT uMsg,DWORD_PTR dwInstance,DWORD_PTR dwParam1,DWORD_PTR dwParam2)
 151 {
 152     ALCdevice *pDevice = (ALCdevice*)dwInstance;
 153     WinMMData *pData = pDevice->ExtraData;
 154
 155     (void)hDevice;
 156     (void)dwParam2;
 157
 158     if(uMsg != WOM_DONE)
 159         return;
 160
 161     // Decrement number of buffers in use
 162     InterlockedDecrement(&pData->lWaveBuffersCommitted);
 163
 164     if(pData->bWaveShutdown == AL_FALSE)
 165     {
 166         // Notify Wave Processor Thread that a Wave Header has returned
 167         PostThreadMessage(pData->ulWaveThreadID, uMsg, 0, dwParam1);
 168     }
 169     else
 170     {
 171         if(pData->lWaveBuffersCommitted == 0)
 172         {
 173             // Signal Wave Buffers Returned event
 174             if(pData->hWaveHdrEvent)
 175                 SetEvent(pData->hWaveHdrEvent);
 176
 177             // Post 'Quit' Message to WaveOut Processor Thread
 178             PostThreadMessage(pData->ulWaveThreadID, WM_QUIT, 0, 0);
 179         }
 180     }
 181 }
 182
 183 /*
 184     PlaybackThreadProc
 185
 186     Used by "MMSYSTEM" Device.  Called when a WaveOut buffer has used up its
 187     audio data.
 188 */
 189 static DWORD WINAPI PlaybackThreadProc(LPVOID lpParameter)
 190 {
 191     ALCdevice *pDevice = (ALCdevice*)lpParameter;
 192     WinMMData *pData = pDevice->ExtraData;
 193     LPWAVEHDR pWaveHdr;
 194     ALuint FrameSize;
 195     MSG msg;
 196
 197     FrameSize = FrameSizeFromDevFmt(pDevice->FmtChans, pDevice->FmtType);
 198
 199     while(GetMessage(&msg, NULL, 0, 0))
 200     {
 201         if(msg.message != WOM_DONE || pData->bWaveShutdown)
 202             continue;
 203
 204         pWaveHdr = ((LPWAVEHDR)msg.lParam);
 205
 206         aluMixData(pDevice, pWaveHdr->lpData, pWaveHdr->dwBufferLength/FrameSize);
 207
 208         // Send buffer back to play more data
 209         waveOutWrite(pData->hWaveHandle.Out, pWaveHdr, sizeof(WAVEHDR));
 210         InterlockedIncrement(&pData->lWaveBuffersCommitted);
 211     }
 212
 213     // Signal Wave Thread completed event
 214     if(pData->hWaveThreadEvent)
 215         SetEvent(pData->hWaveThreadEvent);
 216
 217     ExitThread(0);
 218
 219     return 0;
 220 }
 221
 222 /*
 223     WaveInProc
 224
 225     Posts a message to 'CaptureThreadProc' everytime a WaveIn Buffer is completed and
 226     returns to the application (with more data)
 227 */
 228 static void CALLBACK WaveInProc(HWAVEIN hDevice,UINT uMsg,DWORD_PTR dwInstance,DWORD_PTR dwParam1,DWORD_PTR dwParam2)
 229 {
 230     ALCdevice *pDevice = (ALCdevice*)dwInstance;
 231     WinMMData *pData = pDevice->ExtraData;
 232
 233     (void)hDevice;
 234     (void)dwParam2;
 235
 236     if(uMsg != WIM_DATA)
 237         return;
 238
 239     // Decrement number of buffers in use
 240     InterlockedDecrement(&pData->lWaveBuffersCommitted);
 241
 242     if(pData->bWaveShutdown == AL_FALSE)
 243     {
 244         // Notify Wave Processor Thread that a Wave Header has returned
 245         PostThreadMessage(pData->ulWaveThreadID,uMsg,0,dwParam1);
 246     }
 247     else
 248     {
 249         if(pData->lWaveBuffersCommitted == 0)
 250         {
 251             // Signal Wave Buffers Returned event
 252             if(pData->hWaveHdrEvent)
 253                 SetEvent(pData->hWaveHdrEvent);
 254
 255             // Post 'Quit' Message to WaveIn Processor Thread
 256             PostThreadMessage(pData->ulWaveThreadID,WM_QUIT,0,0);
 257         }
 258     }
 259 }
 260
 261 /*
 262     CaptureThreadProc
 263
 264     Used by "MMSYSTEM" Device.  Called when a WaveIn buffer had been filled with new
 265     audio data.
 266 */
 267 static DWORD WINAPI CaptureThreadProc(LPVOID lpParameter)
 268 {
 269     ALCdevice *pDevice = (ALCdevice*)lpParameter;
 270     WinMMData *pData = pDevice->ExtraData;
 271     LPWAVEHDR pWaveHdr;
 272     ALuint FrameSize;
 273     MSG msg;
 274
 275     FrameSize = FrameSizeFromDevFmt(pDevice->FmtChans, pDevice->FmtType);
 276
 277     while(GetMessage(&msg, NULL, 0, 0))
 278     {
 279         if(msg.message != WIM_DATA || pData->bWaveShutdown)
 280             continue;
 281
 282         pWaveHdr = ((LPWAVEHDR)msg.lParam);
 283
 284         WriteRingBuffer(pData->pRing, (ALubyte*)pWaveHdr->lpData,
 285                         pWaveHdr->dwBytesRecorded/FrameSize);
 286
 287         // Send buffer back to capture more data
 288         waveInAddBuffer(pData->hWaveHandle.In,pWaveHdr,sizeof(WAVEHDR));
 289         InterlockedIncrement(&pData->lWaveBuffersCommitted);
 290     }
 291
 292     // Signal Wave Thread completed event
 293     if(pData->hWaveThreadEvent)
 294         SetEvent(pData->hWaveThreadEvent);
 295
 296     ExitThread(0);
 297
 298     return 0;
 299 }
 300
 301
 302 static ALCboolean WinMMOpenPlayback(ALCdevice *pDevice, const ALCchar *deviceName)
 303 {
 304     WAVEFORMATEX wfexFormat;
 305     WinMMData *pData = NULL;
 306     UINT_PTR lDeviceID = 0;
 307     MMRESULT res;
 308     ALuint i = 0;
 309
 310     // Find the Device ID matching the deviceName if valid
 311     if(!deviceName || strcmp(deviceName, woDefault) == 0)
 312         lDeviceID = WAVE_MAPPER;
 313     else
 314     {
 315         if(!PlaybackDeviceList)
 316             ProbePlaybackDevices();
 317
 318         for(i = 0;i < NumPlaybackDevices;i++)
 319         {
 320             if(PlaybackDeviceList[i] &&
 321                strcmp(deviceName, PlaybackDeviceList[i]) == 0)
 322             {
 323                 lDeviceID = i;
 324                 break;
 325             }
 326         }
 327         if(i == NumPlaybackDevices)
 328             return ALC_FALSE;
 329     }
 330
 331     pData = calloc(1, sizeof(*pData));
 332     if(!pData)
 333     {
 334         alcSetError(pDevice, ALC_OUT_OF_MEMORY);
 335         return ALC_FALSE;
 336     }
 337     pDevice->ExtraData = pData;
 338
 339     if(pDevice->FmtChans != DevFmtMono)
 340         pDevice->FmtChans = DevFmtStereo;
 341     switch(pDevice->FmtType)
 342     {
 343         case DevFmtByte:
 344             pDevice->FmtType = DevFmtUByte;
 345             break;
 346         case DevFmtUShort:
 347         case DevFmtFloat:
 348             pDevice->FmtType = DevFmtShort;
 349             break;
 350         case DevFmtUByte:
 351         case DevFmtShort:
 352             break;
 353     }
 354
 355     memset(&wfexFormat, 0, sizeof(WAVEFORMATEX));
 356     wfexFormat.wFormatTag = WAVE_FORMAT_PCM;
 357     wfexFormat.nChannels = ChannelsFromDevFmt(pDevice->FmtChans);
 358     wfexFormat.wBitsPerSample = BytesFromDevFmt(pDevice->FmtType) * 8;
 359     wfexFormat.nBlockAlign = wfexFormat.wBitsPerSample *
 360                              wfexFormat.nChannels / 8;
 361     wfexFormat.nSamplesPerSec = pDevice->Frequency;
 362     wfexFormat.nAvgBytesPerSec = wfexFormat.nSamplesPerSec *
 363                                  wfexFormat.nBlockAlign;
 364     wfexFormat.cbSize = 0;
 365
 366     if((res=waveOutOpen(&pData->hWaveHandle.Out, lDeviceID, &wfexFormat, (DWORD_PTR)&WaveOutProc, (DWORD_PTR)pDevice, CALLBACK_FUNCTION)) != MMSYSERR_NOERROR)
 367     {
 368         AL_PRINT("waveInOpen failed: %u\n", res);
 369         goto failure;
 370     }
 371
 372     pData->hWaveHdrEvent = CreateEvent(NULL, AL_TRUE, AL_FALSE, "WaveOutAllHeadersReturned");
 373     pData->hWaveThreadEvent = CreateEvent(NULL, AL_TRUE, AL_FALSE, "WaveOutThreadDestroyed");
 374     if(pData->hWaveHdrEvent == NULL || pData->hWaveThreadEvent == NULL)
 375     {
 376         AL_PRINT("CreateEvent failed: %lu\n", GetLastError());
 377         goto failure;
 378     }
 379
 380     pData->Frequency = pDevice->Frequency;
 381
 382     pDevice->szDeviceName = strdup((lDeviceID==WAVE_MAPPER) ? woDefault :
 383                                    PlaybackDeviceList[lDeviceID]);
 384     return ALC_TRUE;
 385
 386 failure:
 387     if(pData->hWaveThreadEvent)
 388         CloseHandle(pData->hWaveThreadEvent);
 389     if(pData->hWaveHdrEvent)
 390         CloseHandle(pData->hWaveHdrEvent);
 391
 392     if(pData->hWaveHandle.Out)
 393         waveOutClose(pData->hWaveHandle.Out);
 394
 395     free(pData);
 396     pDevice->ExtraData = NULL;
 397     return ALC_FALSE;
 398 }
 399
 400 static void WinMMClosePlayback(ALCdevice *device)
 401 {
 402     WinMMData *pData = (WinMMData*)device->ExtraData;
 403
 404     // Close the Wave device
 405     CloseHandle(pData->hWaveThreadEvent);
 406     pData->hWaveThreadEvent = 0;
 407
 408     CloseHandle(pData->hWaveHdrEvent);
 409     pData->hWaveHdrEvent = 0;
 410
 411     waveInClose(pData->hWaveHandle.In);
 412     pData->hWaveHandle.In = 0;
 413
 414     free(pData);
 415     device->ExtraData = NULL;
 416 }
 417
 418 static ALCboolean WinMMResetPlayback(ALCdevice *device)
 419 {
 420     WinMMData *pData = (WinMMData*)device->ExtraData;
 421     ALbyte *BufferData;
 422     ALint lBufferSize;
 423     ALuint i;
 424
 425     pData->hWaveThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)PlaybackThreadProc, (LPVOID)device, 0, &pData->ulWaveThreadID);
 426     if(pData->hWaveThread == NULL)
 427         return ALC_FALSE;
 428
 429     device->UpdateSize = (ALuint)((ALuint64)device->UpdateSize *
 430                                   pData->Frequency / device->Frequency);
 431     device->Frequency = pData->Frequency;
 432
 433     pData->lWaveBuffersCommitted = 0;
 434
 435     // Create 4 Buffers
 436     lBufferSize  = device->UpdateSize*device->NumUpdates / 4;
 437     lBufferSize *= FrameSizeFromDevFmt(device->FmtChans, device->FmtType);
 438
 439     BufferData = calloc(4, lBufferSize);
 440     for(i = 0;i < 4;i++)
 441     {
 442         memset(&pData->WaveBuffer[i], 0, sizeof(WAVEHDR));
 443         pData->WaveBuffer[i].dwBufferLength = lBufferSize;
 444         pData->WaveBuffer[i].lpData = ((i==0) ? (LPSTR)BufferData :
 445                                        (pData->WaveBuffer[i-1].lpData +
 446                                         pData->WaveBuffer[i-1].dwBufferLength));
 447         waveOutPrepareHeader(pData->hWaveHandle.Out, &pData->WaveBuffer[i], sizeof(WAVEHDR));
 448         waveOutWrite(pData->hWaveHandle.Out, &pData->WaveBuffer[i], sizeof(WAVEHDR));
 449         InterlockedIncrement(&pData->lWaveBuffersCommitted);
 450     }
 451
 452     return ALC_TRUE;
 453 }
 454
 455 static void WinMMStopPlayback(ALCdevice *device)
 456 {
 457     WinMMData *pData = (WinMMData*)device->ExtraData;
 458     int i;
 459
 460     if(pData->hWaveThread == NULL)
 461         return;
 462
 463     // Set flag to stop processing headers
 464     pData->bWaveShutdown = AL_TRUE;
 465
 466     // Wait for signal that all Wave Buffers have returned
 467     WaitForSingleObjectEx(pData->hWaveHdrEvent, 5000, FALSE);
 468
 469     // Wait for signal that Wave Thread has been destroyed
 470     WaitForSingleObjectEx(pData->hWaveThreadEvent, 5000, FALSE);
 471
 472     CloseHandle(pData->hWaveThread);
 473     pData->hWaveThread = 0;
 474
 475     pData->bWaveShutdown = AL_FALSE;
 476
 477     // Release the wave buffers
 478     for(i = 0;i < 4;i++)
 479     {
 480         waveOutUnprepareHeader(pData->hWaveHandle.Out, &pData->WaveBuffer[i], sizeof(WAVEHDR));
 481         if(i == 0)
 482             free(pData->WaveBuffer[i].lpData);
 483         pData->WaveBuffer[i].lpData = NULL;
 484     }
 485 }
 486
 487
 488 static ALCboolean WinMMOpenCapture(ALCdevice *pDevice, const ALCchar *deviceName)
 489 {
 490     WAVEFORMATEX wfexCaptureFormat;
 491     DWORD ulCapturedDataSize;
 492     WinMMData *pData = NULL;
 493     ALint lDeviceID = 0;
 494     ALbyte *BufferData;
 495     ALint lBufferSize;
 496     MMRESULT res;
 497     ALuint i;
 498
 499     if(!CaptureDeviceList)
 500         ProbeCaptureDevices();
 501
 502     // Find the Device ID matching the deviceName if valid
 503     if(deviceName)
 504     {
 505         for(i = 0;i < NumCaptureDevices;i++)
 506         {
 507             if(CaptureDeviceList[i] &&
 508                strcmp(deviceName, CaptureDeviceList[i]) == 0)
 509             {
 510                 lDeviceID = i;
 511                 break;
 512             }
 513         }
 514     }
 515     else
 516     {
 517         for(i = 0;i < NumCaptureDevices;i++)
 518         {
 519             if(CaptureDeviceList[i])
 520             {
 521                 lDeviceID = i;
 522                 break;
 523             }
 524         }
 525     }
 526     if(i == NumCaptureDevices)
 527         return ALC_FALSE;
 528
 529     pData = calloc(1, sizeof(*pData));
 530     if(!pData)
 531     {
 532         alcSetError(pDevice, ALC_OUT_OF_MEMORY);
 533         return ALC_FALSE;
 534     }
 535     pDevice->ExtraData = pData;
 536
 537     if((pDevice->FmtChans != DevFmtMono && pDevice->FmtChans != DevFmtStereo) ||
 538        (pDevice->FmtType != DevFmtUByte && pDevice->FmtType != DevFmtShort))
 539     {
 540         alcSetError(pDevice, ALC_INVALID_ENUM);
 541         goto failure;
 542     }
 543
 544     memset(&wfexCaptureFormat, 0, sizeof(WAVEFORMATEX));
 545     wfexCaptureFormat.wFormatTag = WAVE_FORMAT_PCM;
 546     wfexCaptureFormat.nChannels = ChannelsFromDevFmt(pDevice->FmtChans);
 547     wfexCaptureFormat.wBitsPerSample = BytesFromDevFmt(pDevice->FmtType) * 8;
 548     wfexCaptureFormat.nBlockAlign = wfexCaptureFormat.wBitsPerSample *
 549                                     wfexCaptureFormat.nChannels / 8;
 550     wfexCaptureFormat.nSamplesPerSec = pDevice->Frequency;
 551     wfexCaptureFormat.nAvgBytesPerSec = wfexCaptureFormat.nSamplesPerSec *
 552                                         wfexCaptureFormat.nBlockAlign;
 553     wfexCaptureFormat.cbSize = 0;
 554
 555     if((res=waveInOpen(&pData->hWaveHandle.In, lDeviceID, &wfexCaptureFormat, (DWORD_PTR)&WaveInProc, (DWORD_PTR)pDevice, CALLBACK_FUNCTION)) != MMSYSERR_NOERROR)
 556     {
 557         AL_PRINT("waveInOpen failed: %u\n", res);
 558         goto failure;
 559     }
 560
 561     pData->hWaveHdrEvent = CreateEvent(NULL, AL_TRUE, AL_FALSE, "WaveInAllHeadersReturned");
 562     pData->hWaveThreadEvent = CreateEvent(NULL, AL_TRUE, AL_FALSE, "WaveInThreadDestroyed");
 563     if(pData->hWaveHdrEvent == NULL || pData->hWaveThreadEvent == NULL)
 564     {
 565         AL_PRINT("CreateEvent failed: %lu\n", GetLastError());
 566         goto failure;
 567     }
 568
 569     pData->Frequency = pDevice->Frequency;
 570
 571     // Allocate circular memory buffer for the captured audio
 572     ulCapturedDataSize = pDevice->UpdateSize*pDevice->NumUpdates;
 573
 574     // Make sure circular buffer is at least 100ms in size
 575     if(ulCapturedDataSize < (wfexCaptureFormat.nSamplesPerSec / 10))
 576         ulCapturedDataSize = wfexCaptureFormat.nSamplesPerSec / 10;
 577
 578     pData->pRing = CreateRingBuffer(wfexCaptureFormat.nBlockAlign, ulCapturedDataSize);
 579     if(!pData->pRing)
 580         goto failure;
 581
 582     pData->lWaveBuffersCommitted = 0;
 583
 584     // Create 4 Buffers of 50ms each
 585     lBufferSize = wfexCaptureFormat.nAvgBytesPerSec / 20;
 586     lBufferSize -= (lBufferSize % wfexCaptureFormat.nBlockAlign);
 587
 588     BufferData = calloc(4, lBufferSize);
 589     if(!BufferData)
 590         goto failure;
 591
 592     for(i = 0;i < 4;i++)
 593     {
 594         memset(&pData->WaveBuffer[i], 0, sizeof(WAVEHDR));
 595         pData->WaveBuffer[i].dwBufferLength = lBufferSize;
 596         pData->WaveBuffer[i].lpData = ((i==0) ? (LPSTR)BufferData :
 597                                        (pData->WaveBuffer[i-1].lpData +
 598                                         pData->WaveBuffer[i-1].dwBufferLength));
 599         pData->WaveBuffer[i].dwFlags = 0;
 600         pData->WaveBuffer[i].dwLoops = 0;
 601         waveInPrepareHeader(pData->hWaveHandle.In, &pData->WaveBuffer[i], sizeof(WAVEHDR));
 602         waveInAddBuffer(pData->hWaveHandle.In, &pData->WaveBuffer[i], sizeof(WAVEHDR));
 603         InterlockedIncrement(&pData->lWaveBuffersCommitted);
 604     }
 605
 606     pData->hWaveThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)CaptureThreadProc, (LPVOID)pDevice, 0, &pData->ulWaveThreadID);
 607     if (pData->hWaveThread == NULL)
 608         goto failure;
 609
 610     pDevice->szDeviceName = strdup(CaptureDeviceList[lDeviceID]);
 611     return ALC_TRUE;
 612
 613 failure:
 614     if(pData->hWaveThread)
 615         CloseHandle(pData->hWaveThread);
 616
 617     for(i = 0;i < 4;i++)
 618     {
 619         if(pData->WaveBuffer[i].lpData)
 620         {
 621             waveInUnprepareHeader(pData->hWaveHandle.In, &pData->WaveBuffer[i], sizeof(WAVEHDR));
 622             if(i == 0)
 623                 free(pData->WaveBuffer[i].lpData);
 624         }
 625     }
 626
 627     if(pData->pRing)
 628         DestroyRingBuffer(pData->pRing);
 629
 630     if(pData->hWaveThreadEvent)
 631         CloseHandle(pData->hWaveThreadEvent);
 632     if(pData->hWaveHdrEvent)
 633         CloseHandle(pData->hWaveHdrEvent);
 634
 635     if(pData->hWaveHandle.In)
 636         waveInClose(pData->hWaveHandle.In);
 637
 638     free(pData);
 639     pDevice->ExtraData = NULL;
 640     return ALC_FALSE;
 641 }
 642
 643 static void WinMMCloseCapture(ALCdevice *pDevice)
 644 {
 645     WinMMData *pData = (WinMMData*)pDevice->ExtraData;
 646     int i;
 647
 648     // Call waveOutReset to shutdown wave device
 649     pData->bWaveShutdown = AL_TRUE;
 650     waveInReset(pData->hWaveHandle.In);
 651
 652     // Wait for signal that all Wave Buffers have returned
 653     WaitForSingleObjectEx(pData->hWaveHdrEvent, 5000, FALSE);
 654
 655     // Wait for signal that Wave Thread has been destroyed
 656     WaitForSingleObjectEx(pData->hWaveThreadEvent, 5000, FALSE);
 657
 658     CloseHandle(pData->hWaveThread);
 659     pData->hWaveThread = 0;
 660
 661     // Release the wave buffers
 662     for(i = 0;i < 4;i++)
 663     {
 664         waveInUnprepareHeader(pData->hWaveHandle.In, &pData->WaveBuffer[i], sizeof(WAVEHDR));
 665         if(i == 0)
 666             free(pData->WaveBuffer[i].lpData);
 667         pData->WaveBuffer[i].lpData = NULL;
 668     }
 669
 670     DestroyRingBuffer(pData->pRing);
 671     pData->pRing = NULL;
 672
 673     // Close the Wave device
 674     CloseHandle(pData->hWaveThreadEvent);
 675     pData->hWaveThreadEvent = 0;
 676
 677     CloseHandle(pData->hWaveHdrEvent);
 678     pData->hWaveHdrEvent = 0;
 679
 680     waveInClose(pData->hWaveHandle.In);
 681     pData->hWaveHandle.In = 0;
 682
 683     free(pData);
 684     pDevice->ExtraData = NULL;
 685 }
 686
 687 static void WinMMStartCapture(ALCdevice *pDevice)
 688 {
 689     WinMMData *pData = (WinMMData*)pDevice->ExtraData;
 690     waveInStart(pData->hWaveHandle.In);
 691 }
 692
 693 static void WinMMStopCapture(ALCdevice *pDevice)
 694 {
 695     WinMMData *pData = (WinMMData*)pDevice->ExtraData;
 696     waveInStop(pData->hWaveHandle.In);
 697 }
 698
 699 static ALCuint WinMMAvailableSamples(ALCdevice *pDevice)
 700 {
 701     WinMMData *pData = (WinMMData*)pDevice->ExtraData;
 702     return RingBufferSize(pData->pRing);
 703 }
 704
 705 static void WinMMCaptureSamples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
 706 {
 707     WinMMData *pData = (WinMMData*)pDevice->ExtraData;
 708
 709     if(WinMMAvailableSamples(pDevice) >= lSamples)
 710         ReadRingBuffer(pData->pRing, pBuffer, lSamples);
 711     else
 712         alcSetError(pDevice, ALC_INVALID_VALUE);
 713 }
 714
 715
 716 static BackendFuncs WinMMFuncs = {
 717     WinMMOpenPlayback,
 718     WinMMClosePlayback,
 719     WinMMResetPlayback,
 720     WinMMStopPlayback,
 721     WinMMOpenCapture,
 722     WinMMCloseCapture,
 723     WinMMStartCapture,
 724     WinMMStopCapture,
 725     WinMMCaptureSamples,
 726     WinMMAvailableSamples
 727 };
 728
 729 void alcWinMMInit(BackendFuncs *FuncList)
 730 {
 731     *FuncList = WinMMFuncs;
 732 }
 733
 734 void alcWinMMDeinit()
 735 {
 736     ALuint lLoop;
 737
 738     for(lLoop = 0;lLoop < NumPlaybackDevices;lLoop++)
 739         free(PlaybackDeviceList[lLoop]);
 740     free(PlaybackDeviceList);
 741     PlaybackDeviceList = NULL;
 742
 743     NumPlaybackDevices = 0;
 744
 745
 746     for(lLoop = 0; lLoop < NumCaptureDevices; lLoop++)
 747         free(CaptureDeviceList[lLoop]);
 748     free(CaptureDeviceList);
 749     CaptureDeviceList = NULL;
 750
 751     NumCaptureDevices = 0;
 752 }
 753
 754 void alcWinMMProbe(int type)
 755 {
 756     ALuint i;
 757
 758     if(type == DEVICE_PROBE)
 759     {
 760         ProbePlaybackDevices();
 761         if(NumPlaybackDevices > 0)
 762             AppendDeviceList(woDefault);
 763     }
 764     else if(type == ALL_DEVICE_PROBE)
 765     {
 766         ProbePlaybackDevices();
 767         if(NumPlaybackDevices > 0)
 768             AppendAllDeviceList(woDefault);
 769         for(i = 0;i < NumPlaybackDevices;i++)
 770         {
 771             if(PlaybackDeviceList[i])
 772                 AppendAllDeviceList(PlaybackDeviceList[i]);
 773         }
 774     }
 775     else if(type == CAPTURE_DEVICE_PROBE)
 776     {
 777         ProbeCaptureDevices();
 778         for(i = 0;i < NumCaptureDevices;i++)
 779         {
 780             if(CaptureDeviceList[i])
 781                 AppendCaptureDeviceList(CaptureDeviceList[i]);
 782         }
 783     }
 784 }