/*

    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.h"

#include "SDL_audio_c.h"

#include "SDL_audiomem.h"

#include "SDL_sysaudio.h"

#ifdef __OS2__

/* We'll need the DosSetPriority() API! */

#define INCL_DOSPROCESS

#include <os2.h>

#endif

/* Available audio drivers */

static AudioBootStrap *bootstrap[] = {

#if SDL_AUDIO_DRIVER_OPENBSD

	&OPENBSD_AUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_OSS

	&DSP_bootstrap,

	&DMA_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_ALSA

	&ALSA_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_QNXNTO

	&QNXNTOAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_SUNAUDIO

	&SUNAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_DMEDIA

	&DMEDIA_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_ARTS

	&ARTS_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_ESD

	&ESD_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_NAS

	&NAS_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_DSOUND

	&DSOUND_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_WAVEOUT

	&WAVEOUT_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_PAUD

	&Paud_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_BAUDIO

	&BAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_COREAUDIO

	&COREAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_SNDMGR

	&SNDMGR_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_AHI

	&AHI_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_MINT

	&MINTAUDIO_GSXB_bootstrap,

	&MINTAUDIO_MCSN_bootstrap,

	&MINTAUDIO_STFA_bootstrap,

	&MINTAUDIO_XBIOS_bootstrap,

	&MINTAUDIO_DMA8_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_DISK

	&DISKAUD_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_DUMMY

	&DUMMYAUD_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_DC

	&DCAUD_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_MMEAUDIO

	&MMEAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_DART

	&DART_bootstrap,

#endif

	NULL

};

SDL_AudioDevice *current_audio = NULL;

/* Various local functions */

int SDL_AudioInit(const char *driver_name);

void SDL_AudioQuit(void);

#if SDL_AUDIO_DRIVER_AHI

static int audio_configured = 0;

#endif

/* The general mixing thread function */

int SDL_RunAudio(void *audiop)

{

	SDL_AudioDevice *audio = (SDL_AudioDevice *)audiop;

	Uint8 *stream;

	int    stream_len;

	void  *udata;

	void (*fill)(void *userdata,Uint8 *stream, int len);

	int    silence;

#if SDL_AUDIO_DRIVER_AHI

	int started = 0;

/* AmigaOS NEEDS that the audio driver is opened in the thread that uses it! */

	D(bug("Task audio started audio struct:<%lx>...\n",audiop));

	D(bug("Before Openaudio..."));

	if(audio->OpenAudio(audio, &audio->spec)==-1)

	{

		D(bug("Open audio failed...\n"));

		return(-1);

	}

	D(bug("OpenAudio...OK\n"));

#endif

	/* Perform any thread setup */

	if ( audio->ThreadInit ) {

		audio->ThreadInit(audio);

	}

	audio->threadid = SDL_ThreadID();

	/* Set up the mixing function */

	fill  = audio->spec.callback;

	udata = audio->spec.userdata;

#if SDL_AUDIO_DRIVER_AHI

	audio_configured = 1;

	D(bug("Audio configured... Checking for conversion\n"));

	SDL_mutexP(audio->mixer_lock);

	D(bug("Semaphore obtained...\n"));

#endif

	if ( audio->convert.needed ) {

		if ( audio->convert.src_format == AUDIO_U8 ) {

			silence = 0x80;

		} else {

			silence = 0;

		}

		stream_len = audio->convert.len;

	} else {

		silence = audio->spec.silence;

		stream_len = audio->spec.size;

	}

#if SDL_AUDIO_DRIVER_AHI

	SDL_mutexV(audio->mixer_lock);

	D(bug("Entering audio loop...\n"));

#endif

#ifdef __OS2__

        /* Increase the priority of this thread to make sure that

           the audio will be continuous all the time! */

#ifdef USE_DOSSETPRIORITY

        if (SDL_getenv("SDL_USE_TIMECRITICAL_AUDIO"))

        {

#ifdef DEBUG_BUILD

          printf("[SDL_RunAudio] : Setting priority to TimeCritical+0! (TID%d)\n", SDL_ThreadID());

#endif

          DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, 0, 0);

        }

        else

        {

#ifdef DEBUG_BUILD

          printf("[SDL_RunAudio] : Setting priority to ForegroundServer+0! (TID%d)\n", SDL_ThreadID());

#endif

          DosSetPriority(PRTYS_THREAD, PRTYC_FOREGROUNDSERVER, 0, 0);

        }

#endif

#endif

	/* Loop, filling the audio buffers */

	while ( audio->enabled ) {

		/* Fill the current buffer with sound */

		if ( audio->convert.needed ) {

			if ( audio->convert.buf ) {

				stream = audio->convert.buf;

			} else {

				continue;

			}

		} else {

			stream = audio->GetAudioBuf(audio);

			if ( stream == NULL ) {

				stream = audio->fake_stream;

			}

		}

		SDL_memset(stream, silence, stream_len);

		if ( ! audio->paused ) {

			SDL_mutexP(audio->mixer_lock);

			(*fill)(udata, stream, stream_len);

			SDL_mutexV(audio->mixer_lock);

		}

		/* Convert the audio if necessary */

		if ( audio->convert.needed ) {

			SDL_ConvertAudio(&audio->convert);

			stream = audio->GetAudioBuf(audio);

			if ( stream == NULL ) {

				stream = audio->fake_stream;

			}

			SDL_memcpy(stream, audio->convert.buf,

			               audio->convert.len_cvt);

		}

		/* Ready current buffer for play and change current buffer */

		if ( stream != audio->fake_stream ) {

			audio->PlayAudio(audio);

		}

	}

	/* Wait for the audio to drain.. */

	if ( audio->WaitDone ) {

		audio->WaitDone(audio);

	}

#if SDL_AUDIO_DRIVER_AHI

	D(bug("WaitAudio...Done\n"));

	audio->CloseAudio(audio);

	D(bug("CloseAudio..Done, subtask exiting...\n"));

	audio_configured = 0;

#endif

#ifdef __OS2__

#ifdef DEBUG_BUILD

        printf("[SDL_RunAudio] : Task exiting. (TID%d)\n", SDL_ThreadID());

#endif

#endif

	return(0);

}

static void SDL_LockAudio_Default(SDL_AudioDevice *audio)

{

	if ( audio->thread && (SDL_ThreadID() == audio->threadid) ) {

		return;

	}

	SDL_mutexP(audio->mixer_lock);

}

static void SDL_UnlockAudio_Default(SDL_AudioDevice *audio)

{

	if ( audio->thread && (SDL_ThreadID() == audio->threadid) ) {

		return;

	}

	SDL_mutexV(audio->mixer_lock);

}

int SDL_AudioInit(const char *driver_name)

{

	SDL_AudioDevice *audio;

	int i = 0, idx;

	/* Check to make sure we don't overwrite 'current_audio' */

	if ( current_audio != NULL ) {

		SDL_AudioQuit();

	}

	/* Select the proper audio driver */

	audio = NULL;

	idx = 0;

#if SDL_AUDIO_DRIVER_ESD

	if ( (driver_name == NULL) && (SDL_getenv("ESPEAKER") != NULL) ) {

		/* Ahem, we know that if ESPEAKER is set, user probably wants

		   to use ESD, but don't start it if it's not already running.

		   This probably isn't the place to do this, but... Shh! :)

		 */

		for ( i=0; bootstrap[i]; ++i ) {

			if ( SDL_strcmp(bootstrap[i]->name, "esd") == 0 ) {

#ifdef HAVE_PUTENV

				const char *esd_no_spawn;

				/* Don't start ESD if it's not running */

				esd_no_spawn = getenv("ESD_NO_SPAWN");

				if ( esd_no_spawn == NULL ) {

					putenv("ESD_NO_SPAWN=1");

				}

#endif

				if ( bootstrap[i]->available() ) {

					audio = bootstrap[i]->create(0);

					break;

				}

#ifdef HAVE_UNSETENV

				if ( esd_no_spawn == NULL ) {

					unsetenv("ESD_NO_SPAWN");

				}

#endif

			}

		}

	}

#endif /* SDL_AUDIO_DRIVER_ESD */

	if ( audio == NULL ) {

		if ( driver_name != NULL ) {

#if 0	/* This will be replaced with a better driver selection API */

			if ( SDL_strrchr(driver_name, ':') != NULL ) {

				idx = atoi(SDL_strrchr(driver_name, ':')+1);

			}

#endif

			for ( i=0; bootstrap[i]; ++i ) {

				if (SDL_strncmp(bootstrap[i]->name, driver_name,

				            SDL_strlen(bootstrap[i]->name)) == 0) {

					if ( bootstrap[i]->available() ) {

						audio=bootstrap[i]->create(idx);

						break;

					}

				}

			}

		} else {

			for ( i=0; bootstrap[i]; ++i ) {

				if ( bootstrap[i]->available() ) {

					audio = bootstrap[i]->create(idx);

					if ( audio != NULL ) {

						break;

					}

				}

			}

		}

		if ( audio == NULL ) {

			SDL_SetError("No available audio device");

#if 0 /* Don't fail SDL_Init() if audio isn't available.

         SDL_OpenAudio() will handle it at that point.  *sigh*

       */

			return(-1);

#endif

		}

	}

	current_audio = audio;

	if ( current_audio ) {

		current_audio->name = bootstrap[i]->name;

		if ( !current_audio->LockAudio && !current_audio->UnlockAudio ) {

			current_audio->LockAudio = SDL_LockAudio_Default;

			current_audio->UnlockAudio = SDL_UnlockAudio_Default;

		}

	}

	return(0);

}

char *SDL_AudioDriverName(char *namebuf, int maxlen)

{

	if ( current_audio != NULL ) {

		SDL_strlcpy(namebuf, current_audio->name, maxlen);

		return(namebuf);

	}

	return(NULL);

}

int SDL_OpenAudio(SDL_AudioSpec *desired, SDL_AudioSpec *obtained)

{

	SDL_AudioDevice *audio;

	/* Start up the audio driver, if necessary */

	if ( ! current_audio ) {

		if ( (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) ||

		     (current_audio == NULL) ) {

			return(-1);

		}

	}

	audio = current_audio;

	if (audio->opened) {

		SDL_SetError("Audio device is already opened");

		return(-1);

	}

	/* Verify some parameters */

	if ( desired->callback == NULL ) {

		SDL_SetError("SDL_OpenAudio() passed a NULL callback");

		return(-1);

	}

	switch ( desired->channels ) {

	    case 1:	/* Mono */

	    case 2:	/* Stereo */

	    case 4:	/* surround */

	    case 6:	/* surround with center and lfe */

		break;

	    default:

		SDL_SetError("1 (mono) and 2 (stereo) channels supported");

		return(-1);

	}

#if defined(__MACOS__) || (defined(__RISCOS__) && SDL_THREADS_DISABLED)

	/* FIXME: Need to implement PPC interrupt asm for SDL_LockAudio() */

#else

#if defined(__MINT__) && SDL_THREADS_DISABLED

	/* Uses interrupt driven audio, without thread */

#else

	/* Create a semaphore for locking the sound buffers */

	audio->mixer_lock = SDL_CreateMutex();

	if ( audio->mixer_lock == NULL ) {

		SDL_SetError("Couldn't create mixer lock");

		SDL_CloseAudio();

		return(-1);

	}

#endif /* __MINT__ */

#endif /* __MACOS__ */

	/* Calculate the silence and size of the audio specification */

	SDL_CalculateAudioSpec(desired);

	/* Open the audio subsystem */

	SDL_memcpy(&audio->spec, desired, sizeof(audio->spec));

	audio->convert.needed = 0;

	audio->enabled = 1;

	audio->paused  = 1;

#if !SDL_AUDIO_DRIVER_AHI

/* AmigaOS opens audio inside the main loop */

	audio->opened = audio->OpenAudio(audio, &audio->spec)+1;

	if ( ! audio->opened ) {

		SDL_CloseAudio();

		return(-1);

	}

#else

	D(bug("Locking semaphore..."));

	SDL_mutexP(audio->mixer_lock);

	audio->thread = SDL_CreateThread(SDL_RunAudio, audio);

	D(bug("Created thread...\n"));

	if ( audio->thread == NULL ) {

		SDL_mutexV(audio->mixer_lock);

		SDL_CloseAudio();

		SDL_SetError("Couldn't create audio thread");

		return(-1);

	}

	while(!audio_configured)

		SDL_Delay(100);

#endif

	/* If the audio driver changes the buffer size, accept it */

	if ( audio->spec.samples != desired->samples ) {

		desired->samples = audio->spec.samples;

		SDL_CalculateAudioSpec(desired);

	}

	/* Allocate a fake audio memory buffer */

	audio->fake_stream = SDL_AllocAudioMem(audio->spec.size);

	if ( audio->fake_stream == NULL ) {

		SDL_CloseAudio();

		SDL_OutOfMemory();

		return(-1);

	}

	/* See if we need to do any conversion */

	if ( obtained != NULL ) {

		SDL_memcpy(obtained, &audio->spec, sizeof(audio->spec));

	} else if ( desired->freq != audio->spec.freq ||

                    desired->format != audio->spec.format ||

	            desired->channels != audio->spec.channels ) {

		/* Build an audio conversion block */

		if ( SDL_BuildAudioCVT(&audio->convert,

			desired->format, desired->channels,

					desired->freq,

			audio->spec.format, audio->spec.channels,

					audio->spec.freq) < 0 ) {

			SDL_CloseAudio();

			return(-1);

		}

		if ( audio->convert.needed ) {

			audio->convert.len = desired->size;