| /* |
| SDL - Simple DirectMedia Layer |
| Copyright (C) 1997-2012 Sam Lantinga |
| |
| This library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Library General Public |
| License as published by the Free Software Foundation; either |
| version 2 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 |
| Library General Public License for more details. |
| |
| You should have received a copy of the GNU Library General Public |
| License along with this library; if not, write to the Free |
| Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| |
| Sam Lantinga |
| slouken@libsdl.org |
| */ |
| #include "SDL_config.h" |
| |
| /* Tru64 UNIX MME support */ |
| #include <mme_api.h> |
| |
| #include "SDL_timer.h" |
| #include "SDL_audio.h" |
| #include "../SDL_audio_c.h" |
| #include "SDL_mmeaudio.h" |
| |
| static BOOL inUse[NUM_BUFFERS]; |
| |
| /* Audio driver functions */ |
| static int MME_OpenAudio(_THIS, SDL_AudioSpec *spec); |
| static void MME_WaitAudio(_THIS); |
| static Uint8 *MME_GetAudioBuf(_THIS); |
| static void MME_PlayAudio(_THIS); |
| static void MME_WaitDone(_THIS); |
| static void MME_CloseAudio(_THIS); |
| |
| /* Audio driver bootstrap functions */ |
| static int Audio_Available(void) |
| { |
| return(1); |
| } |
| |
| static void Audio_DeleteDevice(SDL_AudioDevice *device) |
| { |
| if ( device ) { |
| if ( device->hidden ) { |
| SDL_free(device->hidden); |
| device->hidden = NULL; |
| } |
| SDL_free(device); |
| device = NULL; |
| } |
| } |
| |
| static SDL_AudioDevice *Audio_CreateDevice(int devindex) |
| { |
| SDL_AudioDevice *this; |
| |
| /* Initialize all variables that we clean on shutdown */ |
| this = SDL_malloc(sizeof(SDL_AudioDevice)); |
| if ( this ) { |
| SDL_memset(this, 0, (sizeof *this)); |
| this->hidden = SDL_malloc((sizeof *this->hidden)); |
| } |
| if ( (this == NULL) || (this->hidden == NULL) ) { |
| SDL_OutOfMemory(); |
| if ( this ) { |
| SDL_free(this); |
| } |
| return(0); |
| } |
| SDL_memset(this->hidden, 0, (sizeof *this->hidden)); |
| /* Set the function pointers */ |
| this->OpenAudio = MME_OpenAudio; |
| this->WaitAudio = MME_WaitAudio; |
| this->PlayAudio = MME_PlayAudio; |
| this->GetAudioBuf = MME_GetAudioBuf; |
| this->WaitDone = MME_WaitDone; |
| this->CloseAudio = MME_CloseAudio; |
| this->free = Audio_DeleteDevice; |
| |
| return this; |
| } |
| |
| AudioBootStrap MMEAUDIO_bootstrap = { |
| "waveout", "Tru64 MME WaveOut", |
| Audio_Available, Audio_CreateDevice |
| }; |
| |
| static void SetMMerror(char *function, MMRESULT code) |
| { |
| int len; |
| char errbuf[MAXERRORLENGTH]; |
| |
| SDL_snprintf(errbuf, SDL_arraysize(errbuf), "%s: ", function); |
| len = SDL_strlen(errbuf); |
| waveOutGetErrorText(code, errbuf+len, MAXERRORLENGTH-len); |
| SDL_SetError("%s",errbuf); |
| } |
| |
| static void CALLBACK MME_CALLBACK(HWAVEOUT hwo, |
| UINT uMsg, |
| DWORD dwInstance, |
| LPARAM dwParam1, |
| LPARAM dwParam2) |
| { |
| WAVEHDR *wp = (WAVEHDR *) dwParam1; |
| |
| if ( uMsg == WOM_DONE ) |
| inUse[wp->dwUser] = FALSE; |
| } |
| |
| static int MME_OpenAudio(_THIS, SDL_AudioSpec *spec) |
| { |
| MMRESULT result; |
| int i; |
| |
| mixbuf = NULL; |
| |
| /* Set basic WAVE format parameters */ |
| shm = mmeAllocMem(sizeof(*shm)); |
| if ( shm == NULL ) { |
| SDL_SetError("Out of memory: shm"); |
| return(-1); |
| } |
| shm->sound = 0; |
| shm->wFmt.wf.wFormatTag = WAVE_FORMAT_PCM; |
| |
| /* Determine the audio parameters from the AudioSpec */ |
| switch ( spec->format & 0xFF ) { |
| case 8: |
| /* Unsigned 8 bit audio data */ |
| spec->format = AUDIO_U8; |
| shm->wFmt.wBitsPerSample = 8; |
| break; |
| case 16: |
| /* Signed 16 bit audio data */ |
| spec->format = AUDIO_S16; |
| shm->wFmt.wBitsPerSample = 16; |
| break; |
| default: |
| SDL_SetError("Unsupported audio format"); |
| return(-1); |
| } |
| |
| shm->wFmt.wf.nChannels = spec->channels; |
| shm->wFmt.wf.nSamplesPerSec = spec->freq; |
| shm->wFmt.wf.nBlockAlign = |
| shm->wFmt.wf.nChannels * shm->wFmt.wBitsPerSample / 8; |
| shm->wFmt.wf.nAvgBytesPerSec = |
| shm->wFmt.wf.nSamplesPerSec * shm->wFmt.wf.nBlockAlign; |
| |
| /* Check the buffer size -- minimum of 1/4 second (word aligned) */ |
| if ( spec->samples < (spec->freq/4) ) |
| spec->samples = ((spec->freq/4)+3)&~3; |
| |
| /* Update the fragment size as size in bytes */ |
| SDL_CalculateAudioSpec(spec); |
| |
| /* Open the audio device */ |
| result = waveOutOpen(&(shm->sound), |
| WAVE_MAPPER, |
| &(shm->wFmt.wf), |
| MME_CALLBACK, |
| NULL, |
| (CALLBACK_FUNCTION|WAVE_OPEN_SHAREABLE)); |
| if ( result != MMSYSERR_NOERROR ) { |
| SetMMerror("waveOutOpen()", result); |
| return(-1); |
| } |
| |
| /* Create the sound buffers */ |
| mixbuf = (Uint8 *)mmeAllocBuffer(NUM_BUFFERS * (spec->size)); |
| if ( mixbuf == NULL ) { |
| SDL_SetError("Out of memory: mixbuf"); |
| return(-1); |
| } |
| |
| for (i = 0; i < NUM_BUFFERS; i++) { |
| shm->wHdr[i].lpData = &mixbuf[i * (spec->size)]; |
| shm->wHdr[i].dwBufferLength = spec->size; |
| shm->wHdr[i].dwFlags = 0; |
| shm->wHdr[i].dwUser = i; |
| shm->wHdr[i].dwLoops = 0; /* loop control counter */ |
| shm->wHdr[i].lpNext = NULL; /* reserved for driver */ |
| shm->wHdr[i].reserved = 0; |
| inUse[i] = FALSE; |
| } |
| next_buffer = 0; |
| return 0; |
| } |
| |
| static void MME_WaitAudio(_THIS) |
| { |
| while ( inUse[next_buffer] ) { |
| mmeWaitForCallbacks(); |
| mmeProcessCallbacks(); |
| } |
| } |
| |
| static Uint8 *MME_GetAudioBuf(_THIS) |
| { |
| Uint8 *retval; |
| |
| inUse[next_buffer] = TRUE; |
| retval = (Uint8 *)(shm->wHdr[next_buffer].lpData); |
| return retval; |
| } |
| |
| static void MME_PlayAudio(_THIS) |
| { |
| /* Queue it up */ |
| waveOutWrite(shm->sound, &(shm->wHdr[next_buffer]), sizeof(WAVEHDR)); |
| next_buffer = (next_buffer+1)%NUM_BUFFERS; |
| } |
| |
| static void MME_WaitDone(_THIS) |
| { |
| MMRESULT result; |
| int i; |
| |
| if ( shm->sound ) { |
| for (i = 0; i < NUM_BUFFERS; i++) |
| while ( inUse[i] ) { |
| mmeWaitForCallbacks(); |
| mmeProcessCallbacks(); |
| } |
| result = waveOutReset(shm->sound); |
| if ( result != MMSYSERR_NOERROR ) |
| SetMMerror("waveOutReset()", result); |
| mmeProcessCallbacks(); |
| } |
| } |
| |
| static void MME_CloseAudio(_THIS) |
| { |
| MMRESULT result; |
| |
| if ( mixbuf ) { |
| result = mmeFreeBuffer(mixbuf); |
| if (result != MMSYSERR_NOERROR ) |
| SetMMerror("mmeFreeBuffer", result); |
| mixbuf = NULL; |
| } |
| |
| if ( shm ) { |
| if ( shm->sound ) { |
| result = waveOutClose(shm->sound); |
| if (result != MMSYSERR_NOERROR ) |
| SetMMerror("waveOutClose()", result); |
| mmeProcessCallbacks(); |
| } |
| result = mmeFreeMem(shm); |
| if (result != MMSYSERR_NOERROR ) |
| SetMMerror("mmeFreeMem()", result); |
| shm = NULL; |
| } |
| } |
| |