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     ALint        lWaveBuffersCommitted;
  44     WAVEHDR      WaveBuffer[4];
  45
  46     union {
  47         HWAVEIN  In;
  48     } hWaveHandle;
  49
  50     RingBuffer   *pRing;
  51 } WinMMData;
  52
  53
  54 static ALCchar **CaptureDeviceList;
  55 static ALuint  NumCaptureDevices;
  56
  57 static void ProbeCaptureDevices(void)
  58 {
  59     ALuint i;
  60
  61     for(i = 0;i < NumCaptureDevices;i++)
  62         free(CaptureDeviceList[i]);
  63
  64     NumCaptureDevices = waveInGetNumDevs();
  65     CaptureDeviceList = realloc(CaptureDeviceList, sizeof(ALCchar*) * NumCaptureDevices);
  66     for(i = 0;i < NumCaptureDevices;i++)
  67     {
  68         WAVEINCAPS WaveInCaps;
  69
  70         CaptureDeviceList[i] = NULL;
  71         if(waveInGetDevCaps(i, &WaveInCaps, sizeof(WAVEINCAPS)) == MMSYSERR_NOERROR)
  72         {
  73             char name[1024];
  74             ALuint count, j;
  75
  76             count = 0;
  77             do {
  78                 if(count == 0)
  79                     snprintf(name, sizeof(name), "%s via WaveIn", WaveInCaps.szPname);
  80                 else
  81                     snprintf(name, sizeof(name), "%s #%d via WaveIn", WaveInCaps.szPname, count+1);
  82                 count++;
  83
  84                 for(j = 0;j < i;j++)
  85                 {
  86                     if(strcmp(name, CaptureDeviceList[j]) == 0)
  87                         break;
  88                 }
  89             } while(j != i);
  90
  91             CaptureDeviceList[i] = strdup(name);
  92         }
  93     }
  94 }
  95
  96
  97 /*
  98     WaveInProc
  99
 100     Posts a message to 'CaptureThreadProc' everytime a WaveIn Buffer is completed and
 101     returns to the application (with more data)
 102 */
 103 static void CALLBACK WaveInProc(HWAVEIN hDevice,UINT uMsg,DWORD_PTR dwInstance,DWORD_PTR dwParam1,DWORD_PTR dwParam2)
 104 {
 105     ALCdevice *pDevice = (ALCdevice*)dwInstance;
 106     WinMMData *pData = pDevice->ExtraData;
 107
 108     (void)hDevice;
 109     (void)dwParam2;
 110
 111     if(uMsg != WIM_DATA)
 112         return;
 113
 114     // Decrement number of buffers in use
 115     pData->lWaveBuffersCommitted--;
 116
 117     if(pData->bWaveShutdown == AL_FALSE)
 118     {
 119         // Notify Wave Processor Thread that a Wave Header has returned
 120         PostThreadMessage(pData->ulWaveThreadID,uMsg,0,dwParam1);
 121     }
 122     else
 123     {
 124         if(pData->lWaveBuffersCommitted == 0)
 125         {
 126             // Signal Wave Buffers Returned event
 127             if(pData->hWaveHdrEvent)
 128                 SetEvent(pData->hWaveHdrEvent);
 129
 130             // Post 'Quit' Message to WaveIn Processor Thread
 131             PostThreadMessage(pData->ulWaveThreadID,WM_QUIT,0,0);
 132         }
 133     }
 134 }
 135
 136 /*
 137     CaptureThreadProc
 138
 139     Used by "MMSYSTEM" Device.  Called when a WaveIn buffer had been filled with new
 140     audio data.
 141 */
 142 static DWORD WINAPI CaptureThreadProc(LPVOID lpParameter)
 143 {
 144     ALCdevice *pDevice = (ALCdevice*)lpParameter;
 145     WinMMData *pData = pDevice->ExtraData;
 146     LPWAVEHDR pWaveHdr;
 147     ALuint FrameSize;
 148     MSG msg;
 149
 150     FrameSize = aluFrameSizeFromFormat(pDevice->Format);
 151
 152     while(GetMessage(&msg, NULL, 0, 0))
 153     {
 154         if(msg.message != WIM_DATA || pData->bWaveShutdown)
 155             continue;
 156
 157         pWaveHdr = ((LPWAVEHDR)msg.lParam);
 158
 159         WriteRingBuffer(pData->pRing, (ALubyte*)pWaveHdr->lpData,
 160                         pWaveHdr->dwBytesRecorded/FrameSize);
 161
 162         // Send buffer back to capture more data
 163         waveInAddBuffer(pData->hWaveHandle.In,pWaveHdr,sizeof(WAVEHDR));
 164         pData->lWaveBuffersCommitted++;
 165     }
 166
 167     // Signal Wave Thread completed event
 168     if(pData->hWaveThreadEvent)
 169         SetEvent(pData->hWaveThreadEvent);
 170
 171     ExitThread(0);
 172
 173     return 0;
 174 }
 175
 176
 177 static ALCboolean WinMMOpenPlayback(ALCdevice *device, const ALCchar *deviceName)
 178 {
 179     (void)device;
 180     (void)deviceName;
 181     return ALC_FALSE;
 182 }
 183
 184 static void WinMMClosePlayback(ALCdevice *device)
 185 {
 186     (void)device;
 187 }
 188
 189 static ALCboolean WinMMOpenCapture(ALCdevice *pDevice, const ALCchar *deviceName)
 190 {
 191     WAVEFORMATEX wfexCaptureFormat;
 192     DWORD ulCapturedDataSize;
 193     WinMMData *pData = NULL;
 194     ALint lDeviceID = 0;
 195     ALbyte *BufferData;
 196     ALint lBufferSize;
 197     MMRESULT res;
 198     ALuint i;
 199
 200     if(!CaptureDeviceList)
 201         ProbeCaptureDevices();
 202
 203     // Find the Device ID matching the deviceName if valid
 204     if(deviceName)
 205     {
 206         for(i = 0;i < NumCaptureDevices;i++)
 207         {
 208             if(CaptureDeviceList[i] &&
 209                strcmp(deviceName, CaptureDeviceList[i]) == 0)
 210             {
 211                 lDeviceID = i;
 212                 break;
 213             }
 214         }
 215     }
 216     else
 217     {
 218         for(i = 0;i < NumCaptureDevices;i++)
 219         {
 220             if(CaptureDeviceList[i])
 221             {
 222                 lDeviceID = i;
 223                 break;
 224             }
 225         }
 226     }
 227     if(i == NumCaptureDevices)
 228         return ALC_FALSE;
 229
 230     pData = calloc(1, sizeof(*pData));
 231     if(!pData)
 232     {
 233         alcSetError(pDevice, ALC_OUT_OF_MEMORY);
 234         return ALC_FALSE;
 235     }
 236
 237     memset(&wfexCaptureFormat, 0, sizeof(WAVEFORMATEX));
 238     wfexCaptureFormat.wFormatTag = WAVE_FORMAT_PCM;
 239     wfexCaptureFormat.nChannels = aluChannelsFromFormat(pDevice->Format);
 240     wfexCaptureFormat.wBitsPerSample = aluBytesFromFormat(pDevice->Format) * 8;
 241     wfexCaptureFormat.nBlockAlign = wfexCaptureFormat.wBitsPerSample *
 242                                     wfexCaptureFormat.nChannels / 8;
 243     wfexCaptureFormat.nSamplesPerSec = pDevice->Frequency;
 244     wfexCaptureFormat.nAvgBytesPerSec = wfexCaptureFormat.nSamplesPerSec *
 245                                         wfexCaptureFormat.nBlockAlign;
 246     wfexCaptureFormat.cbSize = 0;
 247
 248     if((res=waveInOpen(&pData->hWaveHandle.In, lDeviceID, &wfexCaptureFormat, (DWORD_PTR)&WaveInProc, (DWORD_PTR)pDevice, CALLBACK_FUNCTION)) != MMSYSERR_NOERROR)
 249     {
 250         AL_PRINT("waveInOpen failed: %u\n", res);
 251         goto failure;
 252     }
 253
 254     pData->hWaveHdrEvent = CreateEvent(NULL, AL_TRUE, AL_FALSE, "WaveInAllHeadersReturned");
 255     pData->hWaveThreadEvent = CreateEvent(NULL, AL_TRUE, AL_FALSE, "WaveInThreadDestroyed");
 256     if(pData->hWaveHdrEvent == NULL || pData->hWaveThreadEvent == NULL)
 257     {
 258         AL_PRINT("CreateEvent failed: %lu\n", GetLastError());
 259         goto failure;
 260     }
 261
 262     // Allocate circular memory buffer for the captured audio
 263     ulCapturedDataSize = pDevice->UpdateSize*pDevice->NumUpdates;
 264
 265     // Make sure circular buffer is at least 100ms in size
 266     if(ulCapturedDataSize < (wfexCaptureFormat.nSamplesPerSec / 10))
 267         ulCapturedDataSize = wfexCaptureFormat.nSamplesPerSec / 10;
 268
 269     pData->pRing = CreateRingBuffer(wfexCaptureFormat.nBlockAlign, ulCapturedDataSize);
 270     if(!pData->pRing)
 271         goto failure;
 272
 273     pData->lWaveBuffersCommitted = 0;
 274
 275     // Create 4 Buffers of 50ms each
 276     lBufferSize = wfexCaptureFormat.nAvgBytesPerSec / 20;
 277     lBufferSize -= (lBufferSize % wfexCaptureFormat.nBlockAlign);
 278
 279     BufferData = calloc(4, lBufferSize);
 280     if(!BufferData)
 281         goto failure;
 282
 283     for(i = 0;i < 4;i++)
 284     {
 285         memset(&pData->WaveBuffer[i], 0, sizeof(WAVEHDR));
 286         pData->WaveBuffer[i].dwBufferLength = lBufferSize;
 287         pData->WaveBuffer[i].lpData = ((i==0) ? (LPSTR)BufferData :
 288                                        (pData->WaveBuffer[i-1].lpData +
 289                                         pData->WaveBuffer[i-1].dwBufferLength));
 290         pData->WaveBuffer[i].dwFlags = 0;
 291         pData->WaveBuffer[i].dwLoops = 0;
 292         waveInPrepareHeader(pData->hWaveHandle.In, &pData->WaveBuffer[i], sizeof(WAVEHDR));
 293         waveInAddBuffer(pData->hWaveHandle.In, &pData->WaveBuffer[i], sizeof(WAVEHDR));
 294         pData->lWaveBuffersCommitted++;
 295     }
 296
 297     pDevice->ExtraData = pData;
 298
 299     pData->hWaveThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)CaptureThreadProc, (LPVOID)pDevice, 0, &pData->ulWaveThreadID);
 300     if (pData->hWaveThread == NULL)
 301         goto failure;
 302
 303     pDevice->szDeviceName = strdup(CaptureDeviceList[lDeviceID]);
 304     return ALC_TRUE;
 305
 306 failure:
 307     if(pData->hWaveThread)
 308         CloseHandle(pData->hWaveThread);
 309
 310     for(i = 0;i < 4;i++)
 311     {
 312         if(pData->WaveBuffer[i].lpData)
 313         {
 314             waveInUnprepareHeader(pData->hWaveHandle.In, &pData->WaveBuffer[i], sizeof(WAVEHDR));
 315             if(i == 0)
 316                 free(pData->WaveBuffer[i].lpData);
 317         }
 318     }
 319
 320     if(pData->pRing)
 321         DestroyRingBuffer(pData->pRing);
 322
 323     if(pData->hWaveThreadEvent)
 324         CloseHandle(pData->hWaveThreadEvent);
 325     if(pData->hWaveHdrEvent)
 326         CloseHandle(pData->hWaveHdrEvent);
 327
 328     if(pData->hWaveHandle.In)
 329         waveInClose(pData->hWaveHandle.In);
 330
 331     free(pData);
 332     pDevice->ExtraData = NULL;
 333     return ALC_FALSE;
 334 }
 335
 336 static void WinMMCloseCapture(ALCdevice *pDevice)
 337 {
 338     WinMMData *pData = (WinMMData*)pDevice->ExtraData;
 339     int i;
 340
 341     // Call waveOutReset to shutdown wave device
 342     pData->bWaveShutdown = AL_TRUE;
 343     waveInReset(pData->hWaveHandle.In);
 344
 345     // Wait for signal that all Wave Buffers have returned
 346     WaitForSingleObjectEx(pData->hWaveHdrEvent, 5000, FALSE);
 347
 348     // Wait for signal that Wave Thread has been destroyed
 349     WaitForSingleObjectEx(pData->hWaveThreadEvent, 5000, FALSE);
 350
 351     CloseHandle(pData->hWaveThread);
 352     pData->hWaveThread = 0;
 353
 354     // Release the wave buffers
 355     for(i = 0;i < 4;i++)
 356     {
 357         waveInUnprepareHeader(pData->hWaveHandle.In, &pData->WaveBuffer[i], sizeof(WAVEHDR));
 358         if(i == 0)
 359             free(pData->WaveBuffer[i].lpData);
 360         pData->WaveBuffer[i].lpData = NULL;
 361     }
 362
 363     DestroyRingBuffer(pData->pRing);
 364     pData->pRing = NULL;
 365
 366     // Close the Wave device
 367     CloseHandle(pData->hWaveThreadEvent);
 368     pData->hWaveThreadEvent = 0;
 369
 370     CloseHandle(pData->hWaveHdrEvent);
 371     pData->hWaveHdrEvent = 0;
 372
 373     waveInClose(pData->hWaveHandle.In);
 374     pData->hWaveHandle.In = 0;
 375
 376     free(pData);
 377     pDevice->ExtraData = NULL;
 378 }
 379
 380 static void WinMMStartCapture(ALCdevice *pDevice)
 381 {
 382     WinMMData *pData = (WinMMData*)pDevice->ExtraData;
 383     waveInStart(pData->hWaveHandle.In);
 384 }
 385
 386 static void WinMMStopCapture(ALCdevice *pDevice)
 387 {
 388     WinMMData *pData = (WinMMData*)pDevice->ExtraData;
 389     waveInStop(pData->hWaveHandle.In);
 390 }
 391
 392 static ALCuint WinMMAvailableSamples(ALCdevice *pDevice)
 393 {
 394     WinMMData *pData = (WinMMData*)pDevice->ExtraData;
 395     return RingBufferSize(pData->pRing);
 396 }
 397
 398 static void WinMMCaptureSamples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
 399 {
 400     WinMMData *pData = (WinMMData*)pDevice->ExtraData;
 401
 402     if(WinMMAvailableSamples(pDevice) >= lSamples)
 403         ReadRingBuffer(pData->pRing, pBuffer, lSamples);
 404     else
 405         alcSetError(pDevice, ALC_INVALID_VALUE);
 406 }
 407
 408
 409 static BackendFuncs WinMMFuncs = {
 410     WinMMOpenPlayback,
 411     WinMMClosePlayback,
 412     NULL,
 413     NULL,
 414     WinMMOpenCapture,
 415     WinMMCloseCapture,
 416     WinMMStartCapture,
 417     WinMMStopCapture,
 418     WinMMCaptureSamples,
 419     WinMMAvailableSamples
 420 };
 421
 422 void alcWinMMInit(BackendFuncs *FuncList)
 423 {
 424     *FuncList = WinMMFuncs;
 425 }
 426
 427 void alcWinMMDeinit()
 428 {
 429     ALuint lLoop;
 430
 431     for(lLoop = 0; lLoop < NumCaptureDevices; lLoop++)
 432         free(CaptureDeviceList[lLoop]);
 433     free(CaptureDeviceList);
 434     CaptureDeviceList = NULL;
 435
 436     NumCaptureDevices = 0;
 437 }
 438
 439 void alcWinMMProbe(int type)
 440 {
 441     ALuint i;
 442
 443     if(type == CAPTURE_DEVICE_PROBE)
 444     {
 445         ProbeCaptureDevices();
 446         for(i = 0;i < NumCaptureDevices;i++)
 447         {
 448             if(CaptureDeviceList[i])
 449                 AppendCaptureDeviceList(CaptureDeviceList[i]);
 450         }
 451     }
 452 }