/*

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

#define _THIS SDL_AudioDevice *_this

static SDL_AudioDriver current_audio;

static SDL_AudioDevice *open_devices[16];

/*

* 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_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

while (packet) {

SDL_AudioBufferQueue *next = packet->next;

SDL_free(packet);

packet = next;

}

}

/* NOTE: This assumes you'll hold the mixer lock before calling! */

static int

queue_audio_to_device(SDL_AudioDevice *device, const Uint8 *data, Uint32 len)

{

SDL_AudioBufferQueue *orighead;

SDL_AudioBufferQueue *origtail;

Uint32 origlen;

Uint32 datalen;

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;

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;

}

return 0;

}

/* NOTE: This assumes you'll hold the mixer lock before calling! */

static Uint32

dequeue_audio_from_device(SDL_AudioDevice *device, Uint8 *stream, Uint32 len)

{

SDL_AudioBufferQueue *packet;

Uint8 *ptr = stream;

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

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

const Uint32 cpy = SDL_min(len, avail);

SDL_assert(device->queued_bytes >= avail);

SDL_memcpy(ptr, packet->data + packet->startpos, cpy);

packet->startpos += cpy;

ptr += cpy;

device->queued_bytes -= cpy;

len -= cpy;

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

device->buffer_queue_head = packet->next;

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

packet->next = device->buffer_queue_pool;

device->buffer_queue_pool = packet;

}

}

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

if (device->buffer_queue_head == NULL) {

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

}

return (Uint32) (ptr - stream);

}

static void SDLCALL

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

{

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

SDL_AudioDevice *device = (SDL_AudioDevice *) userdata;

Uint32 written;

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

SDL_assert(!device->iscapture); /* this shouldn't ever happen, right?! */

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

written = dequeue_audio_from_device(device, stream, (Uint32) len);

stream += written;

len -= (int) written;

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

}

}

static void SDLCALL

SDL_BufferQueueFillCallback(void *userdata, Uint8 *stream, int len)

{

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

SDL_AudioDevice *device = (SDL_AudioDevice *) userdata;

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

SDL_assert(device->iscapture); /* this shouldn't ever happen, right?! */

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

/* note that if this needs to allocate more space and run out of memory,

we have no choice but to quietly drop the data and hope it works out

later, but you probably have bigger problems in this case anyhow. */

queue_audio_to_device(device, stream, (Uint32) len);

}

int

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

{

SDL_AudioDevice *device = get_audio_device(devid);

int rc = 0;

if (!device) {

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

} else if (device->iscapture) {

return SDL_SetError("This is a capture device, queueing not allowed");

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

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

}

if (len > 0) {

current_audio.impl.LockDevice(device);

rc = queue_audio_to_device(device, data, len);

current_audio.impl.UnlockDevice(device);

}

return rc;

}

Uint32

SDL_DequeueAudio(SDL_AudioDeviceID devid, void *data, Uint32 len)

{

SDL_AudioDevice *device = get_audio_device(devid);

Uint32 rc;

if ( (len == 0) || /* nothing to do? */

(!device) || /* called with bogus device id */

(!device->iscapture) || /* playback devices can't dequeue */

(device->spec.callback != SDL_BufferQueueFillCallback) ) { /* not set for queueing */

return 0; /* just report zero bytes dequeued. */

}

current_audio.impl.LockDevice(device);

rc = dequeue_audio_from_device(device, data, len);

current_audio.impl.UnlockDevice(device);

return rc;

}

Uint32

SDL_GetQueuedAudioSize(SDL_AudioDeviceID devid)

{

Uint32 retval = 0;

SDL_AudioDevice *device = get_audio_device(devid);

if (!device) {

return 0;

}

current_audio.impl.LockDevice(device);

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

current_audio.impl.UnlockDevice(device);

} else if (device->spec.callback == SDL_BufferQueueFillCallback) {

current_audio.impl.LockDevice(device);

retval = device->queued_bytes;

current_audio.impl.UnlockDevice(device);

}

return retval;

}

void

SDL_ClearQueuedAudio(SDL_AudioDeviceID devid)

{

SDL_AudioDevice *device = get_audio_device(devid);

SDL_AudioBufferQueue *packet;

if (!device) {

return; /* nothing to do. */

}

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

current_audio.impl.LockDevice(device);

/* merge the available pool and the current queue into one list. */

packet = device->buffer_queue_head;

if (packet) {

device->buffer_queue_tail->next = device->buffer_queue_pool;

} else {

packet = device->buffer_queue_pool;

}

/* Remove the queued packets from the device. */

device->buffer_queue_tail = NULL;

device->buffer_queue_head = NULL;

device->queued_bytes = 0;

device->buffer_queue_pool = packet;

/* Keep up to two packets in the pool to reduce future malloc pressure. */

if (packet) {

if (!packet->next) {

packet = NULL; /* one packet (the only one) for the pool. */

} else {

SDL_AudioBufferQueue *next = packet->next->next;

packet->next->next = NULL; /* two packets for the pool. */

packet = next; /* rest will be freed. */

}

}

current_audio.impl.UnlockDevice(device);

/* free any extra packets we didn't keep in the pool. */

free_audio_queue(packet);

}

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

current_audio.impl.FlushCapture(device); /* one snuck in! */

} else {

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

}