/*

Simple DirectMedia Layer

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any damages

arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,

including commercial applications, and to alter it and redistribute it

freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not

claim that you wrote the original software. If you use this software

in a product, an acknowledgment in the product documentation would be

appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be

misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

*/

#include "../SDL_internal.h"

/* Allow access to a raw mixing buffer */

#include "SDL.h"

#include "SDL_audio.h"

#include "SDL_audio_c.h"

#include "SDL_audiomem.h"

#include "SDL_sysaudio.h"

#define _THIS SDL_AudioDevice *_this

static SDL_AudioDriver current_audio;

static SDL_AudioDevice *open_devices[16];

/* !!! FIXME: These are wordy and unlocalized... */

#define DEFAULT_OUTPUT_DEVNAME "System audio output device"

#define DEFAULT_INPUT_DEVNAME "System audio capture device"

/*

* Not all of these will be compiled and linked in, but it's convenient

* to have a complete list here and saves yet-another block of #ifdefs...

* Please see bootstrap[], below, for the actual #ifdef mess.

*/

extern AudioBootStrap BSD_AUDIO_bootstrap;

extern AudioBootStrap DSP_bootstrap;

extern AudioBootStrap ALSA_bootstrap;

extern AudioBootStrap PULSEAUDIO_bootstrap;

extern AudioBootStrap QSAAUDIO_bootstrap;

extern AudioBootStrap SUNAUDIO_bootstrap;

extern AudioBootStrap ARTS_bootstrap;

extern AudioBootStrap ESD_bootstrap;

extern AudioBootStrap NACLAUD_bootstrap;

extern AudioBootStrap NAS_bootstrap;

extern AudioBootStrap XAUDIO2_bootstrap;

extern AudioBootStrap DSOUND_bootstrap;

extern AudioBootStrap WINMM_bootstrap;

extern AudioBootStrap PAUDIO_bootstrap;

extern AudioBootStrap HAIKUAUDIO_bootstrap;

extern AudioBootStrap COREAUDIO_bootstrap;

extern AudioBootStrap SNDMGR_bootstrap;

extern AudioBootStrap DISKAUD_bootstrap;

extern AudioBootStrap DUMMYAUD_bootstrap;

extern AudioBootStrap DCAUD_bootstrap;

extern AudioBootStrap DART_bootstrap;

extern AudioBootStrap NDSAUD_bootstrap;

extern AudioBootStrap FUSIONSOUND_bootstrap;

extern AudioBootStrap ANDROIDAUD_bootstrap;

extern AudioBootStrap PSPAUD_bootstrap;

extern AudioBootStrap SNDIO_bootstrap;

extern AudioBootStrap EmscriptenAudio_bootstrap;

/* Available audio drivers */

static const AudioBootStrap *const bootstrap[] = {

#if SDL_AUDIO_DRIVER_PULSEAUDIO

&PULSEAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_ALSA

&ALSA_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_SNDIO

&SNDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_BSD

&BSD_AUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_OSS

&DSP_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_QSA

&QSAAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_SUNAUDIO

&SUNAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_ARTS

&ARTS_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_ESD

&ESD_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_NACL

#endif

#if SDL_AUDIO_DRIVER_NAS

&NAS_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_XAUDIO2

&XAUDIO2_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_DSOUND

&DSOUND_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_WINMM

&WINMM_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_PAUDIO

&PAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_HAIKU

&HAIKUAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_COREAUDIO

&COREAUDIO_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_DISK

&DISKAUD_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_DUMMY

&DUMMYAUD_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_FUSIONSOUND

&FUSIONSOUND_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_ANDROID

&ANDROIDAUD_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_PSP

&PSPAUD_bootstrap,

#endif

#if SDL_AUDIO_DRIVER_EMSCRIPTEN

&EmscriptenAudio_bootstrap,

#endif

NULL

};

static SDL_AudioDevice *

get_audio_device(SDL_AudioDeviceID id)

{

id--;

if ((id >= SDL_arraysize(open_devices)) || (open_devices[id] == NULL)) {

SDL_SetError("Invalid audio device ID");

return NULL;

}

return open_devices[id];

}

/* stubs for audio drivers that don't need a specific entry point... */

static void

SDL_AudioDetectDevices_Default(void)

{

/* you have to write your own implementation if these assertions fail. */

SDL_assert(current_audio.impl.OnlyHasDefaultOutputDevice);

SDL_assert(current_audio.impl.OnlyHasDefaultInputDevice || !current_audio.impl.HasCaptureSupport);

SDL_AddAudioDevice(SDL_FALSE, DEFAULT_OUTPUT_DEVNAME, (void *) ((size_t) 0x1));

if (current_audio.impl.HasCaptureSupport) {

SDL_AddAudioDevice(SDL_TRUE, DEFAULT_INPUT_DEVNAME, (void *) ((size_t) 0x2));

}

}

static void

SDL_AudioThreadInit_Default(_THIS)

{ /* no-op. */

}

static void

SDL_AudioWaitDevice_Default(_THIS)

{ /* no-op. */

}

static void

SDL_AudioPlayDevice_Default(_THIS)

{ /* no-op. */

}

static int

SDL_AudioGetPendingBytes_Default(_THIS)

{

return 0;

}

static Uint8 *

SDL_AudioGetDeviceBuf_Default(_THIS)

{

return NULL;

}

static void

SDL_AudioWaitDone_Default(_THIS)

{ /* no-op. */

}

static int

SDL_AudioCaptureFromDevice_Default(_THIS, void *buffer, int buflen)

{

return -1; /* just fail immediately. */

}

static void

SDL_AudioFlushCapture_Default(_THIS)

{ /* no-op. */

}

static void

SDL_AudioCloseDevice_Default(_THIS)

{ /* no-op. */

}

static void

SDL_AudioDeinitialize_Default(void)

{ /* no-op. */

}

static void

SDL_AudioFreeDeviceHandle_Default(void *handle)

{ /* no-op. */

}

static int

SDL_AudioOpenDevice_Default(_THIS, void *handle, const char *devname, int iscapture)

{

return SDL_Unsupported();

}

static SDL_INLINE SDL_bool

is_in_audio_device_thread(SDL_AudioDevice * device)

{

/* The device thread locks the same mutex, but not through the public API.

This check is in case the application, in the audio callback,

tries to lock the thread that we've already locked from the

device thread...just in case we only have non-recursive mutexes. */

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

return SDL_TRUE;

}

return SDL_FALSE;

}

static void

SDL_AudioLockDevice_Default(SDL_AudioDevice * device)

{

if (!is_in_audio_device_thread(device)) {

SDL_LockMutex(device->mixer_lock);

}

}

static void

SDL_AudioUnlockDevice_Default(SDL_AudioDevice * device)

{

if (!is_in_audio_device_thread(device)) {

SDL_UnlockMutex(device->mixer_lock);

}

}

static void

finalize_audio_entry_points(void)

{

/*

* Fill in stub functions for unused driver entry points. This lets us

* blindly call them without having to check for validity first.

*/

#define FILL_STUB(x) \

if (current_audio.impl.x == NULL) { \

current_audio.impl.x = SDL_Audio##x##_Default; \

}

FILL_STUB(DetectDevices);

FILL_STUB(OpenDevice);

FILL_STUB(ThreadInit);

FILL_STUB(WaitDevice);

FILL_STUB(PlayDevice);

FILL_STUB(GetPendingBytes);

FILL_STUB(GetDeviceBuf);

FILL_STUB(WaitDone);

FILL_STUB(CaptureFromDevice);

FILL_STUB(FlushCapture);

FILL_STUB(CloseDevice);

FILL_STUB(LockDevice);

FILL_STUB(UnlockDevice);

FILL_STUB(FreeDeviceHandle);

FILL_STUB(Deinitialize);

#undef FILL_STUB

}

/* device hotplug support... */

static int

add_audio_device(const char *name, void *handle, SDL_AudioDeviceItem **devices, int *devCount)

{

int retval = -1;

const size_t size = sizeof (SDL_AudioDeviceItem) + SDL_strlen(name) + 1;

SDL_AudioDeviceItem *item = (SDL_AudioDeviceItem *) SDL_malloc(size);

if (item == NULL) {

return -1;

}

SDL_assert(handle != NULL); /* we reserve NULL, audio backends can't use it. */

item->handle = handle;

SDL_strlcpy(item->name, name, size - sizeof (SDL_AudioDeviceItem));

SDL_LockMutex(current_audio.detectionLock);

item->next = *devices;

*devices = item;

retval = (*devCount)++;

SDL_UnlockMutex(current_audio.detectionLock);

return retval;

}

static SDL_INLINE int

add_capture_device(const char *name, void *handle)

{

return add_audio_device(name, handle, &current_audio.inputDevices, &current_audio.inputDeviceCount);

}

static SDL_INLINE int

add_output_device(const char *name, void *handle)

{

return add_audio_device(name, handle, &current_audio.outputDevices, &current_audio.outputDeviceCount);

}

static void

free_device_list(SDL_AudioDeviceItem **devices, int *devCount)

{

SDL_AudioDeviceItem *item, *next;

for (item = *devices; item != NULL; item = next) {

next = item->next;

if (item->handle != NULL) {

current_audio.impl.FreeDeviceHandle(item->handle);

}

SDL_free(item);

}

*devices = NULL;

*devCount = 0;

}

/* The audio backends call this when a new device is plugged in. */

void

SDL_AddAudioDevice(const int iscapture, const char *name, void *handle)

{

const int device_index = iscapture ? add_capture_device(name, handle) : add_output_device(name, handle);

if (device_index != -1) {

/* Post the event, if desired */

if (SDL_GetEventState(SDL_AUDIODEVICEADDED) == SDL_ENABLE) {

SDL_Event event;

SDL_zero(event);

event.adevice.type = SDL_AUDIODEVICEADDED;

event.adevice.which = device_index;

event.adevice.iscapture = iscapture;

SDL_PushEvent(&event);

}

}

}

/* The audio backends call this when a currently-opened device is lost. */

void SDL_OpenedAudioDeviceDisconnected(SDL_AudioDevice *device)

{

SDL_assert(get_audio_device(device->id) == device);

return;

}

/* Ends the audio callback and mark the device as STOPPED, but the

app still needs to close the device to free resources. */

current_audio.impl.LockDevice(device);

current_audio.impl.UnlockDevice(device);

/* Post the event, if desired */

if (SDL_GetEventState(SDL_AUDIODEVICEREMOVED) == SDL_ENABLE) {

SDL_Event event;

SDL_zero(event);

event.adevice.type = SDL_AUDIODEVICEREMOVED;

event.adevice.which = device->id;

event.adevice.iscapture = device->iscapture ? 1 : 0;

SDL_PushEvent(&event);

}

}

static void

mark_device_removed(void *handle, SDL_AudioDeviceItem *devices, SDL_bool *removedFlag)

{

SDL_AudioDeviceItem *item;

SDL_assert(handle != NULL);

for (item = devices; item != NULL; item = item->next) {

if (item->handle == handle) {

item->handle = NULL;

*removedFlag = SDL_TRUE;

return;

}

}

}

/* The audio backends call this when a device is removed from the system. */

void

SDL_RemoveAudioDevice(const int iscapture, void *handle)

{

SDL_LockMutex(current_audio.detectionLock);

if (iscapture) {

mark_device_removed(handle, current_audio.inputDevices, &current_audio.captureDevicesRemoved);

} else {

mark_device_removed(handle, current_audio.outputDevices, &current_audio.outputDevicesRemoved);

}

SDL_UnlockMutex(current_audio.detectionLock);

current_audio.impl.FreeDeviceHandle(handle);

}

/* buffer queueing support... */

/* this expects that you managed thread safety elsewhere. */

static void

free_audio_queue(SDL_AudioBufferQueue *buffer)

{

while (buffer) {

SDL_AudioBufferQueue *next = buffer->next;

SDL_free(buffer);

buffer = next;

}

}

static void SDLCALL

SDL_BufferQueueDrainCallback(void *userdata, Uint8 *stream, int _len)

{

/* this function always holds the mixer lock before being called. */

Uint32 len = (Uint32) _len;

SDL_AudioDevice *device = (SDL_AudioDevice *) userdata;

SDL_AudioBufferQueue *buffer;

SDL_assert(device != NULL); /* this shouldn't ever happen, right?! */

SDL_assert(_len >= 0); /* this shouldn't ever happen, right?! */

while ((len > 0) && ((buffer = device->buffer_queue_head) != NULL)) {

const Uint32 avail = buffer->datalen - buffer->startpos;

const Uint32 cpy = SDL_min(len, avail);

SDL_assert(device->queued_bytes >= avail);

SDL_memcpy(stream, buffer->data + buffer->startpos, cpy);

buffer->startpos += cpy;

stream += cpy;

device->queued_bytes -= cpy;

len -= cpy;

if (buffer->startpos == buffer->datalen) { /* packet is done, put it in the pool. */

device->buffer_queue_head = buffer->next;

SDL_assert((buffer->next != NULL) || (buffer == device->buffer_queue_tail));

buffer->next = device->buffer_queue_pool;

device->buffer_queue_pool = buffer;

}

}

SDL_assert((device->buffer_queue_head != NULL) == (device->queued_bytes != 0));

if (len > 0) { /* fill any remaining space in the stream with silence. */

SDL_assert(device->buffer_queue_head == NULL);

SDL_memset(stream, device->spec.silence, len);

}

if (device->buffer_queue_head == NULL) {

device->buffer_queue_tail = NULL; /* in case we drained the queue entirely. */

}

}

int

SDL_QueueAudio(SDL_AudioDeviceID devid, const void *_data, Uint32 len)

{

SDL_AudioDevice *device = get_audio_device(devid);

const Uint8 *data = (const Uint8 *) _data;

SDL_AudioBufferQueue *orighead;

SDL_AudioBufferQueue *origtail;

Uint32 origlen;

Uint32 datalen;

if (!device) {

return -1; /* get_audio_device() will have set the error state */

}

if (device->spec.callback != SDL_BufferQueueDrainCallback) {

return SDL_SetError("Audio device has a callback, queueing not allowed");

}

current_audio.impl.LockDevice(device);

orighead = device->buffer_queue_head;

origtail = device->buffer_queue_tail;

origlen = origtail ? origtail->datalen : 0;

while (len > 0) {

SDL_AudioBufferQueue *packet = device->buffer_queue_tail;

SDL_assert(!packet || (packet->datalen <= SDL_AUDIOBUFFERQUEUE_PACKETLEN));

if (!packet || (packet->datalen >= SDL_AUDIOBUFFERQUEUE_PACKETLEN)) {

/* tail packet missing or completely full; we need a new packet. */

packet = device->buffer_queue_pool;

if (packet != NULL) {

/* we have one available in the pool. */

device->buffer_queue_pool = packet->next;

} else {

/* Have to allocate a new one! */

packet = (SDL_AudioBufferQueue *) SDL_malloc(sizeof (SDL_AudioBufferQueue));

if (packet == NULL) {

/* uhoh, reset so we've queued nothing new, free what we can. */

if (!origtail) {

packet = device->buffer_queue_head; /* whole queue. */

} else {

packet = origtail->next; /* what we added to existing queue. */

origtail->next = NULL;

origtail->datalen = origlen;

}

device->buffer_queue_head = orighead;

device->buffer_queue_tail = origtail;

device->buffer_queue_pool = NULL;

current_audio.impl.UnlockDevice(device);

free_audio_queue(packet); /* give back what we can. */

return SDL_OutOfMemory();

}

}

packet->datalen = 0;

packet->startpos = 0;

packet->next = NULL;

SDL_assert((device->buffer_queue_head != NULL) == (device->queued_bytes != 0));

if (device->buffer_queue_tail == NULL) {

device->buffer_queue_head = packet;

} else {

device->buffer_queue_tail->next = packet;

}

device->buffer_queue_tail = packet;

}

datalen = SDL_min(len, SDL_AUDIOBUFFERQUEUE_PACKETLEN - packet->datalen);

SDL_memcpy(packet->data + packet->datalen, data, datalen);

data += datalen;

len -= datalen;

packet->datalen += datalen;

device->queued_bytes += datalen;

}

current_audio.impl.UnlockDevice(device);

return 0;

}

Uint32

SDL_GetQueuedAudioSize(SDL_AudioDeviceID devid)

{

Uint32 retval = 0;

SDL_AudioDevice *device = get_audio_device(devid);

/* Nothing to do unless we're set up for queueing. */

if (device && (device->spec.callback == SDL_BufferQueueDrainCallback)) {

current_audio.impl.LockDevice(device);

retval = device->queued_bytes + current_audio.impl.GetPendingBytes(device);

current_audio.impl.UnlockDevice(device);

}

return retval;

}

void

SDL_ClearQueuedAudio(SDL_AudioDeviceID devid)

{

SDL_AudioDevice *device = get_audio_device(devid);

SDL_AudioBufferQueue *buffer = NULL;

if (!device) {

return; /* nothing to do. */

}

/* Blank out the device and release the mutex. Free it afterwards. */

current_audio.impl.LockDevice(device);

buffer = device->buffer_queue_head;

device->buffer_queue_tail = NULL;

device->buffer_queue_head = NULL;

device->queued_bytes = 0;

current_audio.impl.UnlockDevice(device);

free_audio_queue(buffer);

}

/* The general mixing thread function */

SDL_RunAudio(void *devicep)

{

SDL_AudioDevice *device = (SDL_AudioDevice *) devicep;

const int silence = (int) device->spec.silence;

const Uint32 delay = ((device->spec.samples * 1000) / device->spec.freq);

const int stream_len = (device->convert.needed) ? device->convert.len : device->spec.size;

Uint8 *stream;

void *udata = device->spec.userdata;

void (SDLCALL *callback) (void *, Uint8 *, int) = device->spec.callback;

SDL_assert(!device->iscapture);

/* The audio mixing is always a high priority thread */

SDL_SetThreadPriority(SDL_THREAD_PRIORITY_HIGH);

/* Perform any thread setup */

device->threadid = SDL_ThreadID();

current_audio.impl.ThreadInit(device);

/* Loop, filling the audio buffers */

/* Fill the current buffer with sound */

if (device->convert.needed) {

stream = device->convert.buf;

stream = current_audio.impl.GetDeviceBuf(device);

} else {

/* if the device isn't enabled, we still write to the

fake_stream, so the app's callback will fire with

a regular frequency, in case they depend on that

for timing or progress. They can use hotplug

now to know if the device failed. */

stream = NULL;

}

if (stream == NULL) {

stream = device->fake_stream;

}

/* !!! FIXME: this should be LockDevice. */

SDL_LockMutex(device->mixer_lock);

SDL_memset(stream, silence, stream_len);

} else {

}

SDL_UnlockMutex(device->mixer_lock);

/* Convert the audio if necessary */

SDL_ConvertAudio(&device->convert);

stream = current_audio.impl.GetDeviceBuf(device);

if (stream == NULL) {

stream = device->fake_stream;

} else {

SDL_memcpy(stream, device->convert.buf,

device->convert.len_cvt);

}

}

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

if (stream == device->fake_stream) {

SDL_Delay(delay);

} else {

current_audio.impl.PlayDevice(device);

current_audio.impl.WaitDevice(device);

}

}

/* Wait for the audio to drain. */

current_audio.impl.WaitDone(device);

return 0;

}

/* The general capture thread function */

static int SDLCALL

SDL_CaptureAudio(void *devicep)

{

SDL_AudioDevice *device = (SDL_AudioDevice *) devicep;

const int silence = (int) device->spec.silence;

const Uint32 delay = ((device->spec.samples * 1000) / device->spec.freq);

const int stream_len = (device->convert.needed) ? device->convert.len : device->spec.size;

Uint8 *stream;

void *udata = device->spec.userdata;

void (SDLCALL *callback) (void *, Uint8 *, int) = device->spec.callback;

SDL_assert(device->iscapture);

/* The audio mixing is always a high priority thread */

SDL_SetThreadPriority(SDL_THREAD_PRIORITY_HIGH);

/* Perform any thread setup */

device->threadid = SDL_ThreadID();

current_audio.impl.ThreadInit(device);

/* Loop, filling the audio buffers */

while (!SDL_AtomicGet(&device->shutdown)) {

int still_need;

Uint8 *ptr;

if (!SDL_AtomicGet(&device->enabled) || SDL_AtomicGet(&device->paused)) {

SDL_Delay(delay); /* just so we don't cook the CPU. */

current_audio.impl.FlushCapture(device); /* dump anything pending. */

continue;

}

/* Fill the current buffer with sound */

still_need = stream_len;

if (device->convert.needed) {

ptr = stream = device->convert.buf;

} else {

/* just use the "fake" stream to hold data read from the device. */

ptr = stream = device->fake_stream;

}

/* We still read from the device when "paused" to keep the state sane,

and block when there isn't data so this thread isn't eating CPU.

But we don't process it further or call the app's callback. */

while (still_need > 0) {

const int rc = current_audio.impl.CaptureFromDevice(device, ptr, still_need);

SDL_assert(rc != 0); /* device should have blocked, failed, or returned data. */

SDL_assert(rc <= still_need); /* device should not overflow buffer. :) */

if (rc > 0) {

still_need -= rc;

ptr += rc;

} else { /* uhoh, device failed for some reason! */

SDL_OpenedAudioDeviceDisconnected(device);

break;

}

}

if (still_need > 0) {

/* Keep any data we already read, silence the rest. */

SDL_memset(ptr, silence, still_need);

}

if (device->convert.needed) {

SDL_ConvertAudio(&device->convert);

}

/* !!! FIXME: this should be LockDevice. */

SDL_LockMutex(device->mixer_lock);

if (!SDL_AtomicGet(&device->paused)) {

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

}

SDL_UnlockMutex(device->mixer_lock);

}

current_audio.impl.FlushCapture(device);

return 0;

}

static SDL_AudioFormat

SDL_ParseAudioFormat(const char *string)

{

#define CHECK_FMT_STRING(x) if (SDL_strcmp(string, #x) == 0) return AUDIO_##x

CHECK_FMT_STRING(U8);

CHECK_FMT_STRING(S8);

CHECK_FMT_STRING(U16LSB);

CHECK_FMT_STRING(S16LSB);

CHECK_FMT_STRING(U16MSB);

CHECK_FMT_STRING(S16MSB);

CHECK_FMT_STRING(U16SYS);

CHECK_FMT_STRING(S16SYS);

CHECK_FMT_STRING(U16);

CHECK_FMT_STRING(S16);

CHECK_FMT_STRING(S32LSB);

CHECK_FMT_STRING(S32MSB);

CHECK_FMT_STRING(S32SYS);

CHECK_FMT_STRING(S32);

CHECK_FMT_STRING(F32LSB);

CHECK_FMT_STRING(F32MSB);

CHECK_FMT_STRING(F32SYS);

CHECK_FMT_STRING(F32);

#undef CHECK_FMT_STRING

return 0;

}

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)

{

int i = 0;

int initialized = 0;

int tried_to_init = 0;

if (SDL_WasInit(SDL_INIT_AUDIO)) {

SDL_AudioQuit(); /* shutdown driver if already running. */

}

SDL_zero(current_audio);

SDL_zero(open_devices);

/* Select the proper audio driver */

if (driver_name == NULL) {

driver_name = SDL_getenv("SDL_AUDIODRIVER");

}

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

/* make sure we should even try this driver before doing so... */

const AudioBootStrap *backend = bootstrap[i];

if ((driver_name && (SDL_strncasecmp(backend->name, driver_name, SDL_strlen(driver_name)) != 0)) ||

(!driver_name && backend->demand_only)) {

continue;

}

tried_to_init = 1;

SDL_zero(current_audio);

current_audio.name = backend->name;

current_audio.desc = backend->desc;

initialized = backend->init(&current_audio.impl);

}

if (!initialized) {

/* specific drivers will set the error message if they fail... */

if (!tried_to_init) {

if (driver_name) {

SDL_SetError("Audio target '%s' not available", driver_name);

} else {

SDL_SetError("No available audio device");

}

}

SDL_zero(current_audio);

return -1; /* No driver was available, so fail. */

}

current_audio.detectionLock = SDL_CreateMutex();

finalize_audio_entry_points();

/* Make sure we have a list of devices available at startup. */

current_audio.impl.DetectDevices();

return 0;

}

/*

* Get the current audio driver name

*/

const char *

SDL_GetCurrentAudioDriver()

{

return current_audio.name;

}

/* Clean out devices that we've removed but had to keep around for stability. */

static void

clean_out_device_list(SDL_AudioDeviceItem **devices, int *devCount, SDL_bool *removedFlag)

{

SDL_AudioDeviceItem *item = *devices;

SDL_AudioDeviceItem *prev = NULL;

int total = 0;

while (item) {

SDL_AudioDeviceItem *next = item->next;

if (item->handle != NULL) {

total++;

prev = item;

} else {

if (prev) {

prev->next = next;

} else {

*devices = next;

}

SDL_free(item);

}

item = next;

}

*devCount = total;

*removedFlag = SDL_FALSE;

}

int

SDL_GetNumAudioDevices(int iscapture)

{

int retval = 0;

if (!SDL_WasInit(SDL_INIT_AUDIO)) {

return -1;

}

SDL_LockMutex(current_audio.detectionLock);

if (iscapture && current_audio.captureDevicesRemoved) {

clean_out_device_list(&current_audio.inputDevices, &current_audio.inputDeviceCount, &current_audio.captureDevicesRemoved);

}

if (!iscapture && current_audio.outputDevicesRemoved) {

clean_out_device_list(&current_audio.outputDevices, &current_audio.outputDeviceCount, &current_audio.outputDevicesRemoved);

current_audio.outputDevicesRemoved = SDL_FALSE;

}

retval = iscapture ? current_audio.inputDeviceCount : current_audio.outputDeviceCount;

SDL_UnlockMutex(current_audio.detectionLock);

return retval;

}

const char *

SDL_GetAudioDeviceName(int index, int iscapture)

{

const char *retval = NULL;

if (!SDL_WasInit(SDL_INIT_AUDIO)) {

SDL_SetError("Audio subsystem is not initialized");

return NULL;

}

if ((iscapture) && (!current_audio.impl.HasCaptureSupport)) {

SDL_SetError("No capture support");

return NULL;

}

if (index >= 0) {

SDL_AudioDeviceItem *item;

int i;

SDL_LockMutex(current_audio.detectionLock);

item = iscapture ? current_audio.inputDevices : current_audio.outputDevices;

i = iscapture ? current_audio.inputDeviceCount : current_audio.outputDeviceCount;

if (index < i) {

for (i--; i > index; i--, item = item->next) {

SDL_assert(item != NULL);

}

SDL_assert(item != NULL);

retval = item->name;

}

SDL_UnlockMutex(current_audio.detectionLock);

}

if (retval == NULL) {

SDL_SetError("No such device");

}

return retval;

}

static void

close_audio_device(SDL_AudioDevice * device)

{

if (device->thread != NULL) {

SDL_WaitThread(device->thread, NULL);

}

if (device->mixer_lock != NULL) {

SDL_DestroyMutex(device->mixer_lock);

}

SDL_FreeAudioMem(device->fake_stream);

if (device->convert.needed) {

SDL_FreeAudioMem(device->convert.buf);

}

if (device->opened) {

current_audio.impl.CloseDevice(device);

}

free_audio_queue(device->buffer_queue_head);

free_audio_queue(device->buffer_queue_pool);

SDL_FreeAudioMem(device);

}

/*

* Sanity check desired AudioSpec for SDL_OpenAudio() in (orig).

* Fills in a sanitized copy in (prepared).

* Returns non-zero if okay, zero on fatal parameters in (orig).

*/