| /* |
| SDL - Simple DirectMedia Layer |
| Copyright (C) 1997-2006 Sam Lantinga |
| |
| This library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| This library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with this library; if not, write to the Free Software |
| Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| |
| Sam Lantinga |
| slouken@libsdl.org |
| */ |
| #include "SDL_config.h" |
| |
| /* Allow access to a raw mixing buffer */ |
| |
| #include "SDL_timer.h" |
| #include "SDL_audio.h" |
| #include "../SDL_audio_c.h" |
| #include "SDL_dx5audio.h" |
| |
| /* !!! FIXME: move this somewhere that other drivers can use it... */ |
| #if defined(_WIN32_WCE) |
| #define WINDOWS_OS_NAME "Windows CE/PocketPC" |
| #elif defined(WIN64) |
| #define WINDOWS_OS_NAME "Win64" |
| #else |
| #define WINDOWS_OS_NAME "Win32" |
| #endif |
| |
| /* DirectX function pointers for audio */ |
| static HINSTANCE DSoundDLL = NULL; |
| static HRESULT (WINAPI *DSoundCreate)(LPGUID,LPDIRECTSOUND*,LPUNKNOWN) = NULL; |
| |
| static void |
| DSOUND_Unload(void) |
| { |
| if (DSoundDLL != NULL) { |
| FreeLibrary(DSoundDLL); |
| } |
| |
| DSoundCreate = NULL; |
| DSoundDLL = NULL; |
| } |
| |
| |
| static int |
| DSOUND_Load(void) |
| { |
| int loaded = 0; |
| |
| DSOUND_Unload(); |
| |
| DSoundDLL = LoadLibrary(TEXT("DSOUND.DLL")); |
| if (DSoundDLL == NULL) { |
| SDL_SetError("DirectSound: failed to load DSOUND.DLL"); |
| } else { |
| /* Now make sure we have DirectX 5 or better... */ |
| /* (DirectSoundCaptureCreate was added in DX5) */ |
| if (!GetProcAddress(DSoundDLL, TEXT("DirectSoundCaptureCreate"))) { |
| SDL_SetError("DirectSound: System doesn't appear to have DX5."); |
| } else { |
| DSoundCreate = (void *) GetProcAddress(DSoundDLL, |
| TEXT("DirectSoundCreate")); |
| } |
| |
| if (!DSoundCreate) { |
| SDL_SetError("DirectSound: Failed to find DirectSoundCreate"); |
| } else { |
| loaded = 1; |
| } |
| } |
| |
| if (!loaded) { |
| DSOUND_Unload(); |
| } |
| |
| return loaded; |
| } |
| |
| |
| static void |
| SetDSerror(const char *function, int code) |
| { |
| static const char *error; |
| static char errbuf[1024]; |
| |
| errbuf[0] = 0; |
| switch (code) { |
| case E_NOINTERFACE: |
| error = "Unsupported interface -- Is DirectX 5.0 or later installed?"; |
| break; |
| case DSERR_ALLOCATED: |
| error = "Audio device in use"; |
| break; |
| case DSERR_BADFORMAT: |
| error = "Unsupported audio format"; |
| break; |
| case DSERR_BUFFERLOST: |
| error = "Mixing buffer was lost"; |
| break; |
| case DSERR_CONTROLUNAVAIL: |
| error = "Control requested is not available"; |
| break; |
| case DSERR_INVALIDCALL: |
| error = "Invalid call for the current state"; |
| break; |
| case DSERR_INVALIDPARAM: |
| error = "Invalid parameter"; |
| break; |
| case DSERR_NODRIVER: |
| error = "No audio device found"; |
| break; |
| case DSERR_OUTOFMEMORY: |
| error = "Out of memory"; |
| break; |
| case DSERR_PRIOLEVELNEEDED: |
| error = "Caller doesn't have priority"; |
| break; |
| case DSERR_UNSUPPORTED: |
| error = "Function not supported"; |
| break; |
| default: |
| SDL_snprintf(errbuf, SDL_arraysize(errbuf), |
| "%s: Unknown DirectSound error: 0x%x", function, code); |
| break; |
| } |
| if (!errbuf[0]) { |
| SDL_snprintf(errbuf, SDL_arraysize(errbuf), "%s: %s", function, |
| error); |
| } |
| SDL_SetError("%s", errbuf); |
| return; |
| } |
| |
| /* DirectSound needs to be associated with a window */ |
| static HWND mainwin = NULL; |
| /* */ |
| |
| void |
| DSOUND_SoundFocus(HWND hwnd) |
| { |
| /* !!! FIXME: probably broken with multi-window support in SDL 1.3 ... */ |
| mainwin = hwnd; |
| } |
| |
| static void |
| DSOUND_ThreadInit(_THIS) |
| { |
| SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_HIGHEST); |
| } |
| |
| static void |
| DSOUND_WaitDevice(_THIS) |
| { |
| DWORD status = 0; |
| DWORD cursor = 0; |
| DWORD junk = 0; |
| HRESULT result = DS_OK; |
| |
| /* Semi-busy wait, since we have no way of getting play notification |
| on a primary mixing buffer located in hardware (DirectX 5.0) |
| */ |
| result = IDirectSoundBuffer_GetCurrentPosition(this->hidden->mixbuf, |
| &junk, &cursor); |
| if (result != DS_OK) { |
| if (result == DSERR_BUFFERLOST) { |
| IDirectSoundBuffer_Restore(this->hidden->mixbuf); |
| } |
| #ifdef DEBUG_SOUND |
| SetDSerror("DirectSound GetCurrentPosition", result); |
| #endif |
| return; |
| } |
| |
| while ((cursor / this->hidden->mixlen) == this->hidden->lastchunk) { |
| /* FIXME: find out how much time is left and sleep that long */ |
| SDL_Delay(1); |
| |
| /* Try to restore a lost sound buffer */ |
| IDirectSoundBuffer_GetStatus(this->hidden->mixbuf, &status); |
| if ((status & DSBSTATUS_BUFFERLOST)) { |
| IDirectSoundBuffer_Restore(this->hidden->mixbuf); |
| IDirectSoundBuffer_GetStatus(this->hidden->mixbuf, &status); |
| if ((status & DSBSTATUS_BUFFERLOST)) { |
| break; |
| } |
| } |
| if (!(status & DSBSTATUS_PLAYING)) { |
| result = IDirectSoundBuffer_Play(this->hidden->mixbuf, 0, 0, |
| DSBPLAY_LOOPING); |
| if (result == DS_OK) { |
| continue; |
| } |
| #ifdef DEBUG_SOUND |
| SetDSerror("DirectSound Play", result); |
| #endif |
| return; |
| } |
| |
| /* Find out where we are playing */ |
| result = IDirectSoundBuffer_GetCurrentPosition(this->hidden->mixbuf, |
| &junk, &cursor); |
| if (result != DS_OK) { |
| SetDSerror("DirectSound GetCurrentPosition", result); |
| return; |
| } |
| } |
| } |
| |
| static void |
| DSOUND_PlayDevice(_THIS) |
| { |
| /* Unlock the buffer, allowing it to play */ |
| if (this->hidden->locked_buf) { |
| IDirectSoundBuffer_Unlock(this->hidden->mixbuf, |
| this->hidden->locked_buf, |
| this->hidden->mixlen, NULL, 0); |
| } |
| |
| } |
| |
| static Uint8 * |
| DSOUND_GetDeviceBuf(_THIS) |
| { |
| DWORD cursor = 0; |
| DWORD junk = 0; |
| HRESULT result = DS_OK; |
| DWORD rawlen = 0; |
| |
| /* Figure out which blocks to fill next */ |
| this->hidden->locked_buf = NULL; |
| result = IDirectSoundBuffer_GetCurrentPosition(this->hidden->mixbuf, |
| &junk, &cursor); |
| if (result == DSERR_BUFFERLOST) { |
| IDirectSoundBuffer_Restore(this->hidden->mixbuf); |
| result = IDirectSoundBuffer_GetCurrentPosition(this->hidden->mixbuf, |
| &junk, &cursor); |
| } |
| if (result != DS_OK) { |
| SetDSerror("DirectSound GetCurrentPosition", result); |
| return (NULL); |
| } |
| cursor /= this->hidden->mixlen; |
| #ifdef DEBUG_SOUND |
| /* Detect audio dropouts */ |
| { |
| DWORD spot = cursor; |
| if (spot < this->hidden->lastchunk) { |
| spot += this->hidden->num_buffers; |
| } |
| if (spot > this->hidden->lastchunk + 1) { |
| fprintf(stderr, "Audio dropout, missed %d fragments\n", |
| (spot - (this->hidden->lastchunk + 1))); |
| } |
| } |
| #endif |
| this->hidden->lastchunk = cursor; |
| cursor = (cursor + 1) % this->hidden->num_buffers; |
| cursor *= this->hidden->mixlen; |
| |
| /* Lock the audio buffer */ |
| result = IDirectSoundBuffer_Lock(this->hidden->mixbuf, cursor, |
| this->hidden->mixlen, |
| (LPVOID *) &this->hidden->locked_buf, |
| &rawlen, NULL, &junk, 0); |
| if (result == DSERR_BUFFERLOST) { |
| IDirectSoundBuffer_Restore(this->hidden->mixbuf); |
| result = IDirectSoundBuffer_Lock(this->hidden->mixbuf, cursor, |
| this->hidden->mixlen, |
| (LPVOID *) &this->hidden->locked_buf, |
| &rawlen, NULL, &junk, 0); |
| } |
| if (result != DS_OK) { |
| SetDSerror("DirectSound Lock", result); |
| return (NULL); |
| } |
| return (this->hidden->locked_buf); |
| } |
| |
| static void |
| DSOUND_WaitDone(_THIS) |
| { |
| Uint8 *stream = DSOUND_GetDeviceBuf(this); |
| |
| /* Wait for the playing chunk to finish */ |
| if (stream != NULL) { |
| SDL_memset(stream, this->spec.silence, this->hidden->mixlen); |
| DSOUND_PlayDevice(this); |
| } |
| DSOUND_WaitDevice(this); |
| |
| /* Stop the looping sound buffer */ |
| IDirectSoundBuffer_Stop(this->hidden->mixbuf); |
| } |
| |
| static void |
| DSOUND_CloseDevice(_THIS) |
| { |
| if (this->hidden != NULL) { |
| if (this->hidden->sound != NULL) { |
| if (this->hidden->mixbuf != NULL) { |
| /* Clean up the audio buffer */ |
| IDirectSoundBuffer_Release(this->hidden->mixbuf); |
| this->hidden->mixbuf = NULL; |
| } |
| IDirectSound_Release(this->hidden->sound); |
| this->hidden->sound = NULL; |
| } |
| |
| SDL_free(this->hidden); |
| this->hidden = NULL; |
| } |
| } |
| |
| /* This function tries to create a secondary audio buffer, and returns the |
| number of audio chunks available in the created buffer. |
| */ |
| static int |
| CreateSecondary(_THIS, HWND focus, WAVEFORMATEX *wavefmt) |
| { |
| LPDIRECTSOUND sndObj = this->hidden->sound; |
| LPDIRECTSOUNDBUFFER *sndbuf = this->hidden->mixbuf; |
| Uint32 chunksize = this->spec.size; |
| const int numchunks = 8; |
| HRESULT result = DS_OK; |
| DSBUFFERDESC format; |
| LPVOID pvAudioPtr1, pvAudioPtr2; |
| DWORD dwAudioBytes1, dwAudioBytes2; |
| |
| /* Try to set primary mixing privileges */ |
| if (focus) { |
| result = IDirectSound_SetCooperativeLevel(sndObj, |
| focus, DSSCL_PRIORITY); |
| } else { |
| result = IDirectSound_SetCooperativeLevel(sndObj, |
| GetDesktopWindow(), |
| DSSCL_NORMAL); |
| } |
| if (result != DS_OK) { |
| SetDSerror("DirectSound SetCooperativeLevel", result); |
| return (-1); |
| } |
| |
| /* Try to create the secondary buffer */ |
| SDL_memset(&format, 0, sizeof(format)); |
| format.dwSize = sizeof(format); |
| format.dwFlags = DSBCAPS_GETCURRENTPOSITION2; |
| if (!focus) { |
| format.dwFlags |= DSBCAPS_GLOBALFOCUS; |
| } else { |
| format.dwFlags |= DSBCAPS_STICKYFOCUS; |
| } |
| format.dwBufferBytes = numchunks * chunksize; |
| if ((format.dwBufferBytes < DSBSIZE_MIN) || |
| (format.dwBufferBytes > DSBSIZE_MAX)) { |
| SDL_SetError("Sound buffer size must be between %d and %d", |
| DSBSIZE_MIN / numchunks, DSBSIZE_MAX / numchunks); |
| return (-1); |
| } |
| format.dwReserved = 0; |
| format.lpwfxFormat = wavefmt; |
| result = IDirectSound_CreateSoundBuffer(sndObj, &format, sndbuf, NULL); |
| if (result != DS_OK) { |
| SetDSerror("DirectSound CreateSoundBuffer", result); |
| return (-1); |
| } |
| IDirectSoundBuffer_SetFormat(*sndbuf, wavefmt); |
| |
| /* Silence the initial audio buffer */ |
| result = IDirectSoundBuffer_Lock(*sndbuf, 0, format.dwBufferBytes, |
| (LPVOID *) & pvAudioPtr1, &dwAudioBytes1, |
| (LPVOID *) & pvAudioPtr2, &dwAudioBytes2, |
| DSBLOCK_ENTIREBUFFER); |
| if (result == DS_OK) { |
| SDL_memset(pvAudioPtr1, this->spec.silence, dwAudioBytes1); |
| IDirectSoundBuffer_Unlock(*sndbuf, |
| (LPVOID) pvAudioPtr1, dwAudioBytes1, |
| (LPVOID) pvAudioPtr2, dwAudioBytes2); |
| } |
| |
| /* We're ready to go */ |
| return (numchunks); |
| } |
| |
| static int |
| DSOUND_OpenDevice(_THIS, const char *devname, int iscapture) |
| { |
| HRESULT result; |
| WAVEFORMATEX waveformat; |
| int valid_format = 0; |
| SDL_AudioFormat test_format = SDL_FirstAudioFormat(this->spec.format); |
| |
| /* !!! FIXME: handle devname */ |
| /* !!! FIXME: handle iscapture */ |
| |
| /* Initialize all variables that we clean on shutdown */ |
| this->hidden = (struct SDL_PrivateAudioData *) |
| SDL_malloc((sizeof *this->hidden)); |
| if (this->hidden == NULL) { |
| SDL_OutOfMemory(); |
| return 0; |
| } |
| SDL_memset(this->hidden, 0, (sizeof *this->hidden)); |
| |
| while ((!valid_format) && (test_format)) { |
| switch (test_format) { |
| case AUDIO_U8: |
| case AUDIO_S16: |
| case AUDIO_S32: |
| this->spec.format = test_format; |
| valid_format = 1; |
| break; |
| } |
| test_format = SDL_NextAudioFormat(); |
| } |
| |
| if (!valid_format) { |
| DSOUND_CloseDevice(this); |
| SDL_SetError("DirectSound: Unsupported audio format"); |
| return 0; |
| } |
| |
| SDL_memset(&waveformat, 0, sizeof(waveformat)); |
| waveformat.wFormatTag = WAVE_FORMAT_PCM; |
| waveformat.wBitsPerSample = SDL_AUDIO_BITSIZE(this->spec.format); |
| waveformat.nChannels = this->spec.channels; |
| waveformat.nSamplesPerSec = this->spec.freq; |
| waveformat.nBlockAlign = |
| waveformat.nChannels * (waveformat.wBitsPerSample / 8); |
| waveformat.nAvgBytesPerSec = |
| waveformat.nSamplesPerSec * waveformat.nBlockAlign; |
| |
| /* Update the fragment size as size in bytes */ |
| SDL_CalculateAudioSpec(&this->spec); |
| |
| /* Open the audio device */ |
| result = DSoundCreate(NULL, &this->hidden->sound, NULL); |
| if (result != DS_OK) { |
| DSOUND_CloseDevice(this); |
| SetDSerror("DirectSoundCreate", result); |
| return 0; |
| } |
| |
| /* Create the audio buffer to which we write */ |
| this->hidden->num_buffers = CreateSecondary(this, mainwin, &waveformat); |
| if (this->hidden->num_buffers < 0) { |
| DSOUND_CloseDevice(this); |
| return 0; |
| } |
| |
| /* The buffer will auto-start playing in DSOUND_WaitDevice() */ |
| this->hidden->mixlen = this->spec.size; |
| |
| return 1; /* good to go. */ |
| } |
| |
| |
| static void |
| DSOUND_Deinitialize(void) |
| { |
| DSOUND_Unload(); |
| } |
| |
| |
| static int |
| DSOUND_Init(SDL_AudioDriverImpl *impl) |
| { |
| OSVERSIONINFO ver; |
| |
| /* |
| * Unfortunately, the sound drivers on NT have higher latencies than the |
| * audio buffers used by many SDL applications, so there are gaps in the |
| * audio - it sounds terrible. Punt for now. |
| */ |
| SDL_memset(&ver, '\0', sizeof (OSVERSIONINFO)); |
| ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); |
| GetVersionEx(&ver); |
| if (ver.dwPlatformId == VER_PLATFORM_WIN32_NT) |
| if (ver.dwMajorVersion <= 4) { |
| return 0; /* NT4.0 or earlier. Disable dsound support. */ |
| } |
| } |
| |
| if (!DSOUND_Load()) { |
| return 0; |
| } |
| |
| /* Set the function pointers */ |
| impl->OpenDevice = DSOUND_OpenDevice; |
| impl->PlayDevice = DSOUND_PlayDevice; |
| impl->WaitDevice = DSOUND_WaitDevice; |
| impl->WaitDone = DSOUND_WaitDone; |
| impl->ThreadInit = DSOUND_ThreadInit; |
| impl->GetDeviceBuf = DSOUND_GetDeviceBuf; |
| impl->CloseDevice = DSOUND_CloseDevice; |
| impl->Deinitialize = DSOUND_Deinitialize; |
| impl->OnlyHasDefaultOutputDevice = 1; /* !!! FIXME */ |
| |
| return 1; |
| } |
| |
| AudioBootStrap DSOUND_bootstrap = { |
| "dsound", WINDOWS_OS_NAME "DirectSound", DSOUND_Init, 0 |
| }; |
| |
| /* vi: set ts=4 sw=4 expandtab: */ |
