Alc/dsound.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 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <memory.h>
  26
  27 #include <windows.h>
  28 #include <mmsystem.h>
  29 #include <dsound.h>
  30
  31 #include "alMain.h"
  32 #include "AL/al.h"
  33 #include "AL/alc.h"
  34
  35 #ifndef DSSPEAKER_7POINT1
  36 #define DSSPEAKER_7POINT1       7
  37 #endif
  38
  39 typedef struct {
  40     // DirectSound Playback Device
  41     LPDIRECTSOUND          lpDS;
  42     LPDIRECTSOUNDBUFFER    DSpbuffer;
  43     LPDIRECTSOUNDBUFFER    DSsbuffer;
  44
  45     int killNow;
  46     ALvoid *thread;
  47 } DSoundData;
  48
  49
  50 static ALCchar *DeviceList[16];
  51
  52
  53 static ALuint DSoundProc(ALvoid *ptr)
  54 {
  55     ALCdevice *pDevice = (ALCdevice*)ptr;
  56     DSoundData *pData = (DSoundData*)pDevice->ExtraData;
  57     DWORD LastCursor = 0;
  58     DWORD PlayCursor;
  59     VOID *WritePtr1, *WritePtr2;
  60     DWORD WriteCnt1,  WriteCnt2;
  61     DWORD BufferSize;
  62     DWORD avail;
  63     HRESULT err;
  64
  65     BufferSize = pDevice->UpdateFreq*pDevice->FrameSize;
  66
  67     while(!pData->killNow)
  68     {
  69         // Get current play and write cursors
  70         IDirectSoundBuffer_GetCurrentPosition(pData->DSsbuffer, &PlayCursor, NULL);
  71         avail = (PlayCursor-LastCursor+BufferSize) % BufferSize;
  72
  73         if(avail == 0)
  74         {
  75             Sleep(1);
  76             continue;
  77         }
  78
  79         // Lock output buffer
  80         WriteCnt1 = 0;
  81         WriteCnt2 = 0;
  82         err = IDirectSoundBuffer_Lock(pData->DSsbuffer, LastCursor, avail, &WritePtr1, &WriteCnt1, &WritePtr2, &WriteCnt2, 0);
  83
  84         // If the buffer is lost, restore it, play and lock
  85         if(err == DSERR_BUFFERLOST)
  86         {
  87             err = IDirectSoundBuffer_Restore(pData->DSsbuffer);
  88             if(SUCCEEDED(err))
  89                 err = IDirectSoundBuffer_Play(pData->DSsbuffer, 0, 0, DSBPLAY_LOOPING);
  90             if(SUCCEEDED(err))
  91                 err = IDirectSoundBuffer_Lock(pData->DSsbuffer, LastCursor, avail, &WritePtr1, &WriteCnt1, &WritePtr2, &WriteCnt2, 0);
  92         }
  93
  94         // Successfully locked the output buffer
  95         if(SUCCEEDED(err))
  96         {
  97             // If we have an active context, mix data directly into output buffer otherwise fill with silence
  98             SuspendContext(NULL);
  99             aluMixData(pDevice->Context, WritePtr1, WriteCnt1, pDevice->Format);
 100             aluMixData(pDevice->Context, WritePtr2, WriteCnt2, pDevice->Format);
 101             ProcessContext(NULL);
 102
 103             // Unlock output buffer only when successfully locked
 104             IDirectSoundBuffer_Unlock(pData->DSsbuffer, WritePtr1, WriteCnt1, WritePtr2, WriteCnt2);
 105         }
 106         else
 107             AL_PRINT("Buffer lock error: %#lx\n", err);
 108
 109         // Update old write cursor location
 110         LastCursor += WriteCnt1+WriteCnt2;
 111         LastCursor %= BufferSize;
 112     }
 113
 114     return 0;
 115 }
 116
 117 static ALCboolean DSoundOpenPlayback(ALCdevice *device, const ALCchar *deviceName)
 118 {
 119     DSBUFFERDESC DSBDescription;
 120     DSoundData *pData = NULL;
 121     WAVEFORMATEX OutputType;
 122     DWORD speakers;
 123     HRESULT hr;
 124
 125     if(deviceName)
 126     {
 127         int i;
 128         for(i = 0;DeviceList[i];i++)
 129         {
 130             if(strcmp(deviceName, DeviceList[i]) == 0)
 131             {
 132                 device->szDeviceName = DeviceList[i];
 133                 break;
 134             }
 135         }
 136         if(!DeviceList[i])
 137             return ALC_FALSE;
 138     }
 139     else
 140         device->szDeviceName = DeviceList[0];
 141
 142     memset(&OutputType, 0, sizeof(WAVEFORMATEX));
 143
 144     //Initialise requested device
 145
 146     pData = calloc(1, sizeof(DSoundData));
 147     if(!pData)
 148     {
 149         SetALCError(ALC_OUT_OF_MEMORY);
 150         return ALC_FALSE;
 151     }
 152
 153     //Init COM
 154     CoInitialize(NULL);
 155
 156     //DirectSound Init code
 157     hr = CoCreateInstance(&CLSID_DirectSound, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectSound, (LPVOID*)&pData->lpDS);
 158     if(SUCCEEDED(hr))
 159         hr = IDirectSound_Initialize(pData->lpDS, NULL);
 160     if(SUCCEEDED(hr))
 161         hr = IDirectSound_SetCooperativeLevel(pData->lpDS, GetForegroundWindow(), DSSCL_PRIORITY);
 162
 163     if(SUCCEEDED(hr))
 164         hr = IDirectSound_GetSpeakerConfig(pData->lpDS, &speakers);
 165     if(SUCCEEDED(hr))
 166     {
 167         speakers = DSSPEAKER_CONFIG(speakers);
 168         if(speakers == DSSPEAKER_MONO)
 169         {
 170             if(aluBytesFromFormat(device->Format) == 1)
 171                 device->Format = AL_FORMAT_MONO8;
 172             else
 173                 device->Format = AL_FORMAT_MONO16;
 174         }
 175         else if(speakers == DSSPEAKER_STEREO)
 176         {
 177             if(aluBytesFromFormat(device->Format) == 1)
 178                 device->Format = AL_FORMAT_STEREO8;
 179             else
 180                 device->Format = AL_FORMAT_STEREO16;
 181         }
 182         else if(speakers == DSSPEAKER_QUAD)
 183         {
 184             if(aluBytesFromFormat(device->Format) == 1)
 185                 device->Format = AL_FORMAT_QUAD8;
 186             else
 187                 device->Format = AL_FORMAT_QUAD16;
 188         }
 189         else if(speakers == DSSPEAKER_5POINT1)
 190         {
 191             if(aluBytesFromFormat(device->Format) == 1)
 192                 device->Format = AL_FORMAT_51CHN8;
 193             else
 194                 device->Format = AL_FORMAT_51CHN16;
 195         }
 196         else if(speakers == DSSPEAKER_7POINT1)
 197         {
 198             if(aluBytesFromFormat(device->Format) == 1)
 199                 device->Format = AL_FORMAT_71CHN8;
 200             else
 201                 device->Format = AL_FORMAT_71CHN16;
 202         }
 203         device->FrameSize = aluBytesFromFormat(device->Format) *
 204                             aluChannelsFromFormat(device->Format);
 205
 206         OutputType.wFormatTag = WAVE_FORMAT_PCM;
 207         OutputType.nChannels = aluChannelsFromFormat(device->Format);
 208         OutputType.wBitsPerSample = aluBytesFromFormat(device->Format) * 8;
 209         OutputType.nBlockAlign = OutputType.nChannels*OutputType.wBitsPerSample/8;
 210         OutputType.nSamplesPerSec = device->Frequency;
 211         OutputType.nAvgBytesPerSec = OutputType.nSamplesPerSec*OutputType.nBlockAlign;
 212         OutputType.cbSize = 0;
 213     }
 214
 215     if(SUCCEEDED(hr))
 216     {
 217         memset(&DSBDescription,0,sizeof(DSBUFFERDESC));
 218         DSBDescription.dwSize=sizeof(DSBUFFERDESC);
 219         DSBDescription.dwFlags=DSBCAPS_PRIMARYBUFFER;
 220         hr = IDirectSound_CreateSoundBuffer(pData->lpDS, &DSBDescription, &pData->DSpbuffer, NULL);
 221     }
 222     if(SUCCEEDED(hr))
 223         hr = IDirectSoundBuffer_SetFormat(pData->DSpbuffer,&OutputType);
 224
 225     if(SUCCEEDED(hr))
 226     {
 227         memset(&DSBDescription,0,sizeof(DSBUFFERDESC));
 228         DSBDescription.dwSize=sizeof(DSBUFFERDESC);
 229         DSBDescription.dwFlags=DSBCAPS_GLOBALFOCUS|DSBCAPS_GETCURRENTPOSITION2;
 230         DSBDescription.dwBufferBytes=device->UpdateFreq * device->FrameSize;
 231         DSBDescription.lpwfxFormat=&OutputType;
 232         hr = IDirectSound_CreateSoundBuffer(pData->lpDS, &DSBDescription, &pData->DSsbuffer, NULL);
 233     }
 234
 235     if(SUCCEEDED(hr))
 236         hr = IDirectSoundBuffer_Play(pData->DSsbuffer, 0, 0, DSBPLAY_LOOPING);
 237
 238     device->ExtraData = pData;
 239     pData->thread = StartThread(DSoundProc, device);
 240     if(!pData->thread)
 241         hr = E_FAIL;
 242
 243     if(FAILED(hr))
 244     {
 245         if (pData->DSsbuffer)
 246             IDirectSoundBuffer_Release(pData->DSsbuffer);
 247         if (pData->DSpbuffer)
 248             IDirectSoundBuffer_Release(pData->DSpbuffer);
 249         if (pData->lpDS)
 250             IDirectSound_Release(pData->lpDS);
 251
 252         free(pData);
 253         return ALC_FALSE;
 254     }
 255
 256     return ALC_TRUE;
 257 }
 258
 259 static void DSoundClosePlayback(ALCdevice *device)
 260 {
 261     DSoundData *pData = device->ExtraData;
 262
 263     pData->killNow = 1;
 264     StopThread(pData->thread);
 265
 266     IDirectSoundBuffer_Release(pData->DSsbuffer);
 267     IDirectSoundBuffer_Release(pData->DSpbuffer);
 268     IDirectSound_Release(pData->lpDS);
 269
 270     //Deinit COM
 271     CoUninitialize();
 272
 273     free(pData);
 274     device->ExtraData = NULL;
 275 }
 276
 277
 278 static ALCboolean DSoundOpenCapture(ALCdevice *pDevice, const ALCchar *deviceName, ALCuint frequency, ALCenum format, ALCsizei SampleSize)
 279 {
 280     (void)pDevice;
 281     (void)deviceName;
 282     (void)frequency;
 283     (void)format;
 284     (void)SampleSize;
 285     return ALC_FALSE;
 286 }
 287
 288 static void DSoundCloseCapture(ALCdevice *pDevice)
 289 {
 290     (void)pDevice;
 291 }
 292
 293 static void DSoundStartCapture(ALCdevice *pDevice)
 294 {
 295     (void)pDevice;
 296 }
 297
 298 static void DSoundStopCapture(ALCdevice *pDevice)
 299 {
 300     (void)pDevice;
 301 }
 302
 303 static void DSoundCaptureSamples(ALCdevice *pDevice, ALCvoid *pBuffer, ALCuint lSamples)
 304 {
 305     (void)pDevice;
 306     (void)pBuffer;
 307     (void)lSamples;
 308 }
 309
 310 static ALCuint DSoundAvailableSamples(ALCdevice *pDevice)
 311 {
 312     (void)pDevice;
 313     return 0;
 314 }
 315
 316
 317 BackendFuncs DSoundFuncs = {
 318     DSoundOpenPlayback,
 319     DSoundClosePlayback,
 320     DSoundOpenCapture,
 321     DSoundCloseCapture,
 322     DSoundStartCapture,
 323     DSoundStopCapture,
 324     DSoundCaptureSamples,
 325     DSoundAvailableSamples
 326 };
 327
 328 void alcDSoundInit(BackendFuncs *FuncList)
 329 {
 330     *FuncList = DSoundFuncs;
 331
 332     DeviceList[0] = AppendDeviceList("DirectSound Software");
 333     AppendAllDeviceList(DeviceList[0]);
 334 }