/*

SDL - Simple DirectMedia Layer

This library is free software; you can redistribute it and/or

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

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

/* Allow access to a raw mixing buffer */

#include "SDL.h"

#include "SDL_audio_c.h"

#include "SDL_audiomem.h"

#include "SDL_sysaudio.h"

#define INCL_DOSPROCESS

#include <os2.h>

#endif

/* Available audio drivers */

static AudioBootStrap *bootstrap[] = {

&DSP_bootstrap,

&DMA_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_BAUDIO

&MINTAUDIO_GSXB_bootstrap,

&MINTAUDIO_MCSN_bootstrap,

&MINTAUDIO_STFA_bootstrap,

&MINTAUDIO_XBIOS_bootstrap,

&MINTAUDIO_DMA8_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_DART

};

SDL_AudioDevice *current_audio = NULL;

/* Various local functions */

int SDL_AudioInit(const char *driver_name);

void SDL_AudioQuit(void);

static int audio_configured = 0;

#endif

/* The general mixing thread function */

int SDLCALL

SDL_RunAudio(void *audiop)

SDL_AudioDevice *audio = (SDL_AudioDevice *) audiop;

Uint8 *stream;

int stream_len;

void *udata;

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

int silence;

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

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

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

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

return (-1);

}

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

/* 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;

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;

}

SDL_mutexV(audio->mixer_lock);

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

#endif

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

the audio will be continuous all the time! */

printf

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

SDL_ThreadID());

DosSetPriority(PRTYS_THREAD, PRTYC_TIMECRITICAL, 0, 0);

} else {

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;

}

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 an audio buffer to become available */

if (stream == audio->fake_stream) {

SDL_Delay((audio->spec.samples * 1000) / audio->spec.freq);

} else {

audio->WaitAudio(audio);

}

}

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

if (audio->WaitDone) {

audio->WaitDone(audio);

}

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

audio_configured = 0;

#endif

#ifdef __OS2__

#ifdef DEBUG_BUILD

}

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);

}

static Uint16

SDL_ParseAudioFormat(const char *string)

Uint16 format = 0;

switch (*string) {

case 'U':

++string;

format |= 0x0000;

break;

case 'S':

++string;

format |= 0x8000;

break;

default:

return 0;

}

switch (SDL_atoi(string)) {

case 8:

string += 1;

format |= 8;

break;

case 16:

string += 2;

format |= 16;

if (SDL_strcmp(string, "LSB") == 0

) {

format |= 0x0000;

}

if (SDL_strcmp(string, "MSB") == 0

|| SDL_strcmp(string, "SYS") == 0

#endif

) {

format |= 0x1000;

}

break;

default:

return 0;

}

return format;

}

int

SDL_GetNumAudioDrivers(void)

return (SDL_arraysize(bootstrap) - 1);

}

const char *

SDL_GetAudioDriver(int index)

{

if (index >= 0 && index < SDL_GetNumAudioDrivers()) {

return (bootstrap[index]->name);

}

return (NULL);

}

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 ((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) {

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;

}

if (esd_no_spawn == NULL) {

unsetenv("ESD_NO_SPAWN");

}

}

}

}

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) {

if (driver_name) {

SDL_SetError("%s not available", driver_name);

} else {

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);

}

/*

* Get the current audio driver name

*/

const char *

SDL_GetCurrentAudioDriver()

if (current_audio) {

return current_audio->name;

}

return (NULL);

}

int

SDL_OpenAudio(SDL_AudioSpec * desired, SDL_AudioSpec * obtained)

SDL_AudioDevice *audio;

const char *env;

/* 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->freq == 0) {

env = SDL_getenv("SDL_AUDIO_FREQUENCY");

if (env) {

desired->freq = SDL_atoi(env);

}

}

if (desired->freq == 0) {

/* Pick some default audio frequency */

desired->freq = 22050;

}

if (desired->format == 0) {

env = SDL_getenv("SDL_AUDIO_FORMAT");

if (env) {

desired->format = SDL_ParseAudioFormat(env);

}

}

if (desired->format == 0) {

/* Pick some default audio format */

desired->format = AUDIO_S16;

}

if (desired->channels == 0) {

env = SDL_getenv("SDL_AUDIO_CHANNELS");

if (env) {

}

}

if (desired->channels == 0) {

/* Pick a default number of channels */

desired->channels = 2;

}

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 (desired->samples == 0) {

env = SDL_getenv("SDL_AUDIO_SAMPLES");

if (env) {

}

}

if (desired->samples == 0) {

/* Pick a default of ~46 ms at desired frequency */

int samples = (desired->freq / 1000) * 46;

int power2 = 1;

while (power2 < samples) {

power2 *= 2;

}

desired->samples = power2;

}

if (desired->callback == NULL) {

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

return (-1);

}

/* 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);

}

/* 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;

/* AmigaOS opens audio inside the main loop */

if (!audio->opened) {

SDL_CloseAudio();

return (-1);

}

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;

audio->convert.buf =

(Uint8 *) SDL_AllocAudioMem(audio->convert.len *

audio->convert.len_mult);

if (audio->convert.buf == NULL) {

SDL_CloseAudio();

SDL_OutOfMemory();

return (-1);

}

}

}

/* Start the audio thread if necessary */

switch (audio->opened) {

case 1:

/* Start the audio thread */

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

#endif

if (audio->thread == NULL) {

SDL_CloseAudio();

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

return (-1);

}

break;

default:

/* The audio is now playing */

break;

}

SDL_mutexV(audio->mixer_lock);

D(bug("SDL_OpenAudio USCITA...\n"));

#endif