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 <stdlib.h>
  22 #include <stdio.h>
  23 #include <memory.h>
  24
  25 #include <windows.h>
  26 #include <mmsystem.h>
  27
  28 #include "alMain.h"
  29 #include "AL/al.h"
  30 #include "AL/alc.h"
  31
  32
  33 typedef struct {
  34     // MMSYSTEM Capture Device
  35     ALboolean        bWaveInShutdown;
  36     HANDLE           hWaveInHdrEvent;
  37     HANDLE           hWaveInThreadEvent;
  38     HANDLE           hWaveInThread;
  39     DWORD            ulWaveInThreadID;
  40     ALint            lWaveInBuffersCommitted;
  41     HWAVEIN          hWaveInHandle;
  42     WAVEHDR          WaveInBuffer[4];
  43     ALCchar          *pCapturedSampleData;
  44     ALuint           ulCapturedDataSize;
  45     ALuint           ulReadCapturedDataPos;
  46     ALuint           ulWriteCapturedDataPos;
  47 } WinMMData;
  48
  49
  50 static ALCchar *CaptureDeviceList[16];
  51
  52 /*
  53     WaveInProc
  54
  55     Posts a message to 'CaptureThreadProc' everytime a WaveIn Buffer is completed and
  56     returns to the application (with more data)
  57 */
  58 static void CALLBACK WaveInProc(HWAVEIN hDevice,UINT uMsg,DWORD_PTR dwInstance,DWORD_PTR dwParam1,DWORD_PTR dwParam2)
  59 {
  60     ALCdevice *pDevice = (ALCdevice *)dwInstance;
  61     WinMMData *pData = pDevice->ExtraData;
  62
  63     (void)hDevice;
  64     (void)dwParam2;
  65
  66     if ((uMsg==WIM_DATA) && (pDevice))
  67     {
  68         // Decrement number of buffers in use
  69         pData->lWaveInBuffersCommitted--;
  70
  71         if (pData->bWaveInShutdown == AL_FALSE)
  72         {
  73             // Notify Wave Processor Thread that a Wave Header has returned
  74             PostThreadMessage(pData->ulWaveInThreadID,uMsg,0,dwParam1);
  75         }
  76         else
  77         {
  78             if (pData->lWaveInBuffersCommitted == 0)
  79             {
  80                 // Signal Wave Buffers Returned event
  81                 if (pData->hWaveInHdrEvent)
  82                     SetEvent(pData->hWaveInHdrEvent);
  83
  84                 // Post 'Quit' Message to WaveIn Processor Thread
  85                 PostThreadMessage(pData->ulWaveInThreadID,WM_QUIT,0,0);
  86             }
  87         }
  88     }
  89 }
  90
  91 /*
  92     CaptureThreadProc
  93
  94     Used by "MMSYSTEM" Device.  Called when a WaveIn buffer had been filled with new
  95     audio data.
  96 */
  97 DWORD WINAPI CaptureThreadProc(LPVOID lpParameter)
  98 {
  99     ALCdevice *pDevice = (ALCdevice*)lpParameter;
 100     WinMMData *pData = pDevice->ExtraData;
 101     ALuint ulOffset, ulMaxSize, ulSection;
 102     LPWAVEHDR pWaveHdr;
 103     MSG msg;
 104
 105     while (GetMessage(&msg, NULL, 0, 0))
 106     {
 107         if ((msg.message==WIM_DATA)&&(!pData->bWaveInShutdown))
 108         {
 109             SuspendContext(NULL);
 110
 111             pWaveHdr = ((LPWAVEHDR)msg.lParam);
 112
 113             // Calculate offset in local buffer to write data to
 114             ulOffset = pData->ulWriteCapturedDataPos % pData->ulCapturedDataSize;
 115
 116             if ((ulOffset + pWaveHdr->dwBytesRecorded) > pData->ulCapturedDataSize)
 117             {
 118                 ulSection = pData->ulCapturedDataSize - ulOffset;
 119                 memcpy(pData->pCapturedSampleData + ulOffset, pWaveHdr->lpData, ulSection);
 120                 memcpy(pData->pCapturedSampleData, pWaveHdr->lpData + ulSection, pWaveHdr->dwBytesRecorded - ulSection);
 121             }
 122             else
 123             {
 124                 memcpy(pData->pCapturedSampleData + ulOffset, pWaveHdr->lpData, pWaveHdr->dwBytesRecorded);
 125             }
 126
 127             pData->ulWriteCapturedDataPos += pWaveHdr->dwBytesRecorded;
 128
 129             if (pData->ulWriteCapturedDataPos > (pData->ulReadCapturedDataPos + pData->ulCapturedDataSize))
 130             {
 131                 // Application has not read enough audio data from the capture buffer so data has been
 132                 // overwritten.  Reset ReadPosition.
 133                 pData->ulReadCapturedDataPos = pData->ulWriteCapturedDataPos - pData->ulCapturedDataSize;
 134             }
 135
 136             // To prevent an over-flow prevent the offset values from getting too large
 137             ulMaxSize = pData->ulCapturedDataSize << 4;
 138             if ((pData->ulReadCapturedDataPos > ulMaxSize) && (pData->ulWriteCapturedDataPos > ulMaxSize))
 139             {
 140                 pData->ulReadCapturedDataPos -= ulMaxSize;
 141                 pData->ulWriteCapturedDataPos -= ulMaxSize;
 142             }
 143
 144             // Send buffer back to capture more data
 145             waveInAddBuffer(pData->hWaveInHandle,pWaveHdr,sizeof(WAVEHDR));
 146             pData->lWaveInBuffersCommitted++;
 147
 148             ProcessContext(NULL);
 149         }
 150     }
 151
 152     // Signal Wave Thread completed event
 153     if (pData->hWaveInThreadEvent)
 154         SetEvent(pData->hWaveInThreadEvent);
 155
 156     ExitThread(0);
 157
 158     return 0;
 159 }
 160
 161
 162 static ALCboolean WinMMOpenPlayback(ALCdevice *device, const ALCchar *deviceName)
 163 {
 164     (void)device;
 165     (void)deviceName;
 166     return ALC_FALSE;
 167 }
 168
 169 static void WinMMClosePlayback(ALCdevice *device)
 170 {
 171     (void)device;
 172 }
 173
 174
 175 static ALCboolean WinMMOpenCapture(ALCdevice *pDevice, const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
 176 {
 177     WAVEFORMATEX wfexCaptureFormat;
 178     WinMMData *pData = NULL;
 179     ALint lDeviceID = 0;
 180     ALint lBufferSize;
 181     ALint i;
 182
 183     (void)format;
 184
 185     // Find the Device ID matching the deviceName if valid
 186     if (deviceName)
 187     {
 188         for(i = 0;CaptureDeviceList[i];i++)
 189         {
 190             if (!strcmp(deviceName, CaptureDeviceList[i]))
 191             {
 192                 lDeviceID = i;
 193                 break;
 194             }
 195         }
 196         if(!CaptureDeviceList[i])
 197             return ALC_FALSE;
 198     }
 199
 200     pData = calloc(1, sizeof(*pData));
 201     if(!pData)
 202     {
 203         SetALCError(ALC_OUT_OF_MEMORY);
 204         return ALC_FALSE;
 205     }
 206
 207     memset(&wfexCaptureFormat, 0, sizeof(WAVEFORMATEX));
 208     wfexCaptureFormat.wFormatTag = WAVE_FORMAT_PCM;
 209     wfexCaptureFormat.nChannels = pDevice->Channels;
 210     wfexCaptureFormat.wBitsPerSample = pDevice->FrameSize / pDevice->Channels * 8;
 211     wfexCaptureFormat.nBlockAlign = pDevice->FrameSize;
 212     wfexCaptureFormat.nSamplesPerSec = frequency;
 213     wfexCaptureFormat.nAvgBytesPerSec = wfexCaptureFormat.nSamplesPerSec *
 214                                         pDevice->FrameSize;
 215     wfexCaptureFormat.cbSize = 0;
 216
 217     if (waveInOpen(&pData->hWaveInHandle, lDeviceID, &wfexCaptureFormat, (DWORD_PTR)&WaveInProc, (DWORD_PTR)pDevice, CALLBACK_FUNCTION) != MMSYSERR_NOERROR)
 218         goto failure;
 219
 220     pData->hWaveInHdrEvent = CreateEvent(NULL, AL_TRUE, AL_FALSE, "WaveInAllHeadersReturned");
 221     if (pData->hWaveInHdrEvent == NULL)
 222         goto failure;
 223
 224     pData->hWaveInThreadEvent = CreateEvent(NULL, AL_TRUE, AL_FALSE, "WaveInThreadDestroyed");
 225     if (pData->hWaveInThreadEvent == NULL)
 226         goto failure;
 227
 228     pData->hWaveInThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)CaptureThreadProc, (LPVOID)pDevice, 0, &pData->ulWaveInThreadID);
 229     if (pData->hWaveInThread == NULL)
 230         goto failure;
 231
 232     // Allocate circular memory buffer for the captured audio
 233     pData->ulCapturedDataSize = SampleSize * wfexCaptureFormat.nBlockAlign;
 234
 235     // Make sure circular buffer is at least 100ms in size (and an exact multiple of
 236     // the block alignment
 237     if (pData->ulCapturedDataSize < (wfexCaptureFormat.nAvgBytesPerSec / 10))
 238     {
 239         pData->ulCapturedDataSize = wfexCaptureFormat.nAvgBytesPerSec / 10;
 240         pData->ulCapturedDataSize -= (pData->ulCapturedDataSize % wfexCaptureFormat.nBlockAlign);
 241     }
 242
 243     pData->pCapturedSampleData = (ALCchar*)malloc(pData->ulCapturedDataSize);
 244     pData->lWaveInBuffersCommitted=0;
 245
 246     // Create 4 Buffers of 50ms each
 247     lBufferSize = wfexCaptureFormat.nAvgBytesPerSec / 20;
 248     lBufferSize -= (lBufferSize % wfexCaptureFormat.nBlockAlign);
 249
 250     for (i=0;i<4;i++)
 251     {
 252         memset(&pData->WaveInBuffer[i], 0, sizeof(WAVEHDR));
 253         pData->WaveInBuffer[i].dwBufferLength = lBufferSize;
 254         pData->WaveInBuffer[i].lpData = calloc(1,pData->WaveInBuffer[i].dwBufferLength);
 255         pData->WaveInBuffer[i].dwFlags = 0;
 256         pData->WaveInBuffer[i].dwLoops = 0;
 257         waveInPrepareHeader(pData->hWaveInHandle, &pData->WaveInBuffer[i], sizeof(WAVEHDR));
 258         waveInAddBuffer(pData->hWaveInHandle, &pData->WaveInBuffer[i], sizeof(WAVEHDR));
 259         pData->lWaveInBuffersCommitted++;
 260     }
 261
 262     pData->ulReadCapturedDataPos = 0;
 263     pData->ulWriteCapturedDataPos = 0;
 264
 265     strcpy(pDevice->szDeviceName, CaptureDeviceList[lDeviceID]);
 266
 267     pDevice->ExtraData = pData;
 268     return ALC_TRUE;
 269
 270 failure:
 271     if (pData->hWaveInThreadEvent)
 272         CloseHandle(pData->hWaveInThreadEvent);
 273     if (pData->hWaveInHdrEvent)
 274         CloseHandle(pData->hWaveInHdrEvent);
 275     if (pData->hWaveInHandle)
 276         waveInClose(pData->hWaveInHandle);
 277
 278     free(pData);
 279     return ALC_FALSE;
 280 }
 281
 282 static void WinMMCloseCapture(ALCdevice *pDevice)
 283 {
 284     WinMMData *pData = (WinMMData*)pDevice->ExtraData;
 285     int i;
 286
 287     // Call waveOutReset to shutdown wave device
 288     pData->bWaveInShutdown = AL_TRUE;
 289     waveInReset(pData->hWaveInHandle);
 290
 291     // Wait for signal that all Wave Buffers have returned
 292     WaitForSingleObjectEx(pData->hWaveInHdrEvent, 5000, FALSE);
 293
 294     // Wait for signal that Wave Thread has been destroyed
 295     WaitForSingleObjectEx(pData->hWaveInThreadEvent, 5000, FALSE);
 296
 297     // Release the wave buffers
 298     for (i=0;i<4;i++)
 299     {
 300         waveInUnprepareHeader(pData->hWaveInHandle, &pData->WaveInBuffer[i], sizeof(WAVEHDR));
 301         free(pData->WaveInBuffer[i].lpData);
 302     }
 303
 304     // Free Audio Buffer data
 305     free(pData->pCapturedSampleData);
 306     pData->pCapturedSampleData = NULL;
 307
 308     // Close the Wave device
 309     waveInClose(pData->hWaveInHandle);
 310     pData->hWaveInHandle = 0;
 311
 312     CloseHandle(pData->hWaveInThread);
 313     pData->hWaveInThread = 0;
 314
 315     if (pData->hWaveInHdrEvent)
 316     {
 317         CloseHandle(pData->hWaveInHdrEvent);
 318         pData->hWaveInHdrEvent = 0;
 319     }
 320
 321     if (pData->hWaveInThreadEvent)
 322     {
 323         CloseHandle(pData->hWaveInThreadEvent);
 324         pData->hWaveInThreadEvent = 0;
 325     }
 326
 327     free(pData);
 328     pDevice->ExtraData = NULL;
 329 }
 330
 331 static void WinMMStartCapture(ALCdevice *pDevice)
 332 {
 333     WinMMData *pData = (WinMMData*)pDevice->ExtraData;
 334     waveInStart(pData->hWaveInHandle);
 335 }
 336
 337 static void WinMMStopCapture(ALCdevice *pDevice)
 338 {
 339     WinMMData *pData = (WinMMData*)pDevice->ExtraData;
 340     waveInStop(pData->hWaveInHandle);
 341 }
 342
 343 static void WinMMCaptureSamples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
 344 {
 345     WinMMData *pData = (WinMMData*)pDevice->ExtraData;
 346     ALuint ulSamples = (unsigned long)lSamples;
 347     ALuint ulBytes, ulBytesToCopy;
 348     ALuint ulCapturedSamples;
 349     ALuint ulReadOffset;
 350
 351     // Check that we have the requested numbers of Samples
 352     ulCapturedSamples = (pData->ulWriteCapturedDataPos - pData->ulReadCapturedDataPos) / pDevice->FrameSize;
 353     if(ulSamples > ulCapturedSamples)
 354     {
 355         SetALCError(ALC_INVALID_VALUE);
 356         return;
 357     }
 358
 359     ulBytes = ulSamples * pDevice->FrameSize;
 360
 361     // Get Read Offset
 362     ulReadOffset = (pData->ulReadCapturedDataPos % pData->ulCapturedDataSize);
 363
 364     // Check for wrap-around condition
 365     if ((ulReadOffset + ulBytes) > pData->ulCapturedDataSize)
 366     {
 367         // Copy data from last Read position to end of data
 368         ulBytesToCopy = pData->ulCapturedDataSize - ulReadOffset;
 369         memcpy(pBuffer, pData->pCapturedSampleData + ulReadOffset, ulBytesToCopy);
 370
 371         // Copy rest of the data from the start of the captured data
 372         memcpy(((char *)pBuffer) + ulBytesToCopy, pData->pCapturedSampleData, ulBytes - ulBytesToCopy);
 373     }
 374     else
 375     {
 376         // Copy data from the read position in the captured data
 377         memcpy(pBuffer, pData->pCapturedSampleData + ulReadOffset, ulBytes);
 378     }
 379
 380     // Update Read Position
 381     pData->ulReadCapturedDataPos += ulBytes;
 382 }
 383
 384 static ALCuint WinMMAvailableSamples(ALCdevice *pDevice)
 385 {
 386     WinMMData *pData = (WinMMData*)pDevice->ExtraData;
 387     ALCuint lCapturedBytes = (pData->ulWriteCapturedDataPos - pData->ulReadCapturedDataPos);
 388     return lCapturedBytes / pDevice->FrameSize;
 389 }
 390
 391
 392 BackendFuncs WinMMFuncs = {
 393     WinMMOpenPlayback,
 394     WinMMClosePlayback,
 395     WinMMOpenCapture,
 396     WinMMCloseCapture,
 397     WinMMStartCapture,
 398     WinMMStopCapture,
 399     WinMMCaptureSamples,
 400     WinMMAvailableSamples
 401 };
 402
 403 void alcWinMMInit(BackendFuncs *FuncList)
 404 {
 405     ALint lNumDevs;
 406     ALint lLoop;
 407
 408     *FuncList = WinMMFuncs;
 409
 410     lNumDevs = waveInGetNumDevs();
 411     for (lLoop = 0; lLoop < lNumDevs; lLoop++)
 412     {
 413         WAVEINCAPS WaveInCaps;
 414         if(waveInGetDevCaps(lLoop, &WaveInCaps, sizeof(WAVEINCAPS)) == MMSYSERR_NOERROR)
 415         {
 416             char name[128];
 417             snprintf(name, sizeof(name), "WaveIn on %s", WaveInCaps.szPname);
 418             CaptureDeviceList[lLoop] = AppendCaptureDeviceList(name);
 419         }
 420     }
 421 }