/*

SDL - Simple DirectMedia Layer

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

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;

}

}