/*

     SDL - Simple DirectMedia Layer

     Copyright (C) 1997-2004 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

 */

 /* Tru64 UNIX MME support */

 #include <mme_api.h>

 #include "SDL_stdlib.h"

 #include "SDL_string.h"

 #include "SDL_audio.h"

 #include "SDL_mutex.h"

 #include "SDL_timer.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;

     }

 }