|
|
@@ -20,15 +20,14 @@
|
|
|
*/
|
|
|
#include "SDL_internal.h"
|
|
|
|
|
|
-/* Allow access to a raw mixing buffer */
|
|
|
-
|
|
|
#include "SDL_audio_c.h"
|
|
|
#include "SDL_sysaudio.h"
|
|
|
#include "../thread/SDL_systhread.h"
|
|
|
#include "../SDL_utils_c.h"
|
|
|
|
|
|
+extern void Android_JNI_AudioSetThreadPriority(int, int); /* we need this on Android in the audio device threads. */
|
|
|
+
|
|
|
static SDL_AudioDriver current_audio;
|
|
|
-static SDL_AudioDevice *open_devices[16];
|
|
|
|
|
|
/* Available audio drivers */
|
|
|
static const AudioBootStrap *const bootstrap[] = {
|
|
|
@@ -101,71 +100,274 @@ static const AudioBootStrap *const bootstrap[] = {
|
|
|
NULL
|
|
|
};
|
|
|
|
|
|
-static SDL_AudioDevice *get_audio_device(SDL_AudioDeviceID id)
|
|
|
+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;
|
|
|
+}
|
|
|
+
|
|
|
+const char *SDL_GetCurrentAudioDriver(void)
|
|
|
+{
|
|
|
+ return current_audio.name;
|
|
|
+}
|
|
|
+
|
|
|
+/* device management and hotplug... */
|
|
|
+
|
|
|
+
|
|
|
+/* SDL_AudioDevice, in SDL3, represents a piece of hardware, whether it is in use or not, so these objects exist as long as
|
|
|
+ the system-level device is available.
|
|
|
+
|
|
|
+ Devices get destroyed for three reasons:
|
|
|
+ - They were lost to the system (a USB cable is kicked out, etc).
|
|
|
+ - They failed for some other unlikely reason at the API level (which is _also_ probably a USB cable being kicked out).
|
|
|
+ - We are shutting down, so all allocated resources are being freed.
|
|
|
+
|
|
|
+ They are _not_ destroyed because we are done using them (when we "close" a playing device).
|
|
|
+*/
|
|
|
+static void CloseAudioDevice(SDL_AudioDevice *device);
|
|
|
+
|
|
|
+
|
|
|
+/* this must not be called while `device` is still in a device list, or while a device's audio thread is still running (except if the thread calls this while shutting down). */
|
|
|
+static void DestroyAudioDevice(SDL_AudioDevice *device)
|
|
|
+{
|
|
|
+ SDL_AudioStream *stream;
|
|
|
+ SDL_AudioStream *next;
|
|
|
+
|
|
|
+ if (!device) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (SDL_AtomicGet(&device->refcount) > 0) {
|
|
|
+ SDL_AtomicSet(&device->refcount, 0); /* it's going down NOW. */
|
|
|
+ CloseAudioDevice(device);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* unbind any still-bound streams... */
|
|
|
+ SDL_LockMutex(device->lock);
|
|
|
+ for (stream = device->bound_streams; stream != NULL; stream = next) {
|
|
|
+ SDL_LockMutex(stream->lock);
|
|
|
+ next = stream->next_binding;
|
|
|
+ stream->next_binding = NULL;
|
|
|
+ stream->prev_binding = NULL;
|
|
|
+ stream->bound_device = NULL;
|
|
|
+ SDL_UnlockMutex(stream->lock);
|
|
|
+ }
|
|
|
+ SDL_UnlockMutex(device->lock);
|
|
|
+
|
|
|
+ current_audio.impl.FreeDeviceHandle(device->handle);
|
|
|
+
|
|
|
+ SDL_DestroyMutex(device->lock);
|
|
|
+ SDL_free(device->work_buffer);
|
|
|
+ SDL_free(device->name);
|
|
|
+ SDL_free(device);
|
|
|
+}
|
|
|
+
|
|
|
+static SDL_AudioDevice *CreateAudioDevice(const char *name, SDL_bool iscapture, SDL_AudioFormat fmt, int channels, int freq, void *handle, SDL_AudioDevice **devices, SDL_AtomicInt *device_count)
|
|
|
{
|
|
|
- id--;
|
|
|
- if ((id >= SDL_arraysize(open_devices)) || (open_devices[id] == NULL)) {
|
|
|
- SDL_SetError("Invalid audio device ID");
|
|
|
+ SDL_AudioDevice *device;
|
|
|
+
|
|
|
+ SDL_assert(name != NULL);
|
|
|
+
|
|
|
+ if (SDL_AtomicGet(¤t_audio.shutting_down)) {
|
|
|
+ return NULL; /* we're shutting down, don't add any devices that are hotplugged at the last possible moment. */
|
|
|
+ }
|
|
|
+
|
|
|
+ device = (SDL_AudioDevice *)SDL_calloc(1, sizeof(SDL_AudioDevice));
|
|
|
+ if (!device) {
|
|
|
+ SDL_OutOfMemory();
|
|
|
+ return NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ device->name = SDL_strdup(name);
|
|
|
+ if (!device->name) {
|
|
|
+ SDL_free(device);
|
|
|
+ SDL_OutOfMemory();
|
|
|
+ return NULL;
|
|
|
+ }
|
|
|
+
|
|
|
+ device->lock = SDL_CreateMutex();
|
|
|
+ if (!device->lock) {
|
|
|
+ SDL_free(device->name);
|
|
|
+ SDL_free(device);
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
- return open_devices[id];
|
|
|
+ SDL_AtomicSet(&device->shutdown, 0);
|
|
|
+ SDL_AtomicSet(&device->condemned, 0);
|
|
|
+ device->iscapture = iscapture;
|
|
|
+ device->format = device->default_format = fmt;
|
|
|
+ device->channels = device->default_channels = channels;
|
|
|
+ device->freq = device->default_freq = freq;
|
|
|
+ device->silence_value = SDL_GetSilenceValueForFormat(device->format);
|
|
|
+ device->handle = handle;
|
|
|
+ device->prev = NULL;
|
|
|
+
|
|
|
+ /* Assign an instance id! Start at 2, in case there are things from the SDL2 era that still think 1 is a special value. */
|
|
|
+ /* There's no reasonable scenario where this rolls over, but just in case, we wrap it in a loop. */
|
|
|
+ /* Also, make sure capture instance IDs are even, and output IDs are odd, so we know what kind of device it is from just the ID. */
|
|
|
+ do {
|
|
|
+ device->instance_id = (SDL_AudioDeviceID) (SDL_AtomicIncRef(¤t_audio.last_device_instance_id) + 1);
|
|
|
+ } while ( ((iscapture && (device->instance_id & 1)) || (!iscapture && ((device->instance_id & 1) == 0))) || (device->instance_id < 2) );
|
|
|
+
|
|
|
+ SDL_LockRWLockForWriting(current_audio.device_list_lock);
|
|
|
+ device->next = *devices;
|
|
|
+ *devices = device;
|
|
|
+ SDL_AtomicIncRef(device_count);
|
|
|
+ SDL_UnlockRWLock(current_audio.device_list_lock);
|
|
|
+
|
|
|
+ return device;
|
|
|
+}
|
|
|
+
|
|
|
+static SDL_AudioDevice *CreateAudioCaptureDevice(const char *name, SDL_AudioFormat fmt, int channels, int freq, void *handle)
|
|
|
+{
|
|
|
+ SDL_assert(current_audio.impl.HasCaptureSupport);
|
|
|
+ return CreateAudioDevice(name, SDL_TRUE, fmt, channels, freq, handle, ¤t_audio.capture_devices, ¤t_audio.capture_device_count);
|
|
|
+}
|
|
|
+
|
|
|
+static SDL_AudioDevice *CreateAudioOutputDevice(const char *name, SDL_AudioFormat fmt, int channels, int freq, void *handle)
|
|
|
+{
|
|
|
+ return CreateAudioDevice(name, SDL_FALSE, fmt, channels, freq, handle, ¤t_audio.output_devices, ¤t_audio.output_device_count);
|
|
|
}
|
|
|
|
|
|
-int get_max_num_audio_dev(void)
|
|
|
+/* The audio backends call this when a new device is plugged in. */
|
|
|
+SDL_AudioDevice *SDL_AddAudioDevice(const SDL_bool iscapture, const char *name, SDL_AudioFormat fmt, int channels, int freq, void *handle)
|
|
|
{
|
|
|
- return SDL_arraysize(open_devices);
|
|
|
+ SDL_AudioDevice *device;
|
|
|
+
|
|
|
+ if (fmt == 0) {
|
|
|
+ fmt = DEFAULT_AUDIO_FORMAT;
|
|
|
+ }
|
|
|
+ if (channels == 0) {
|
|
|
+ channels = DEFAULT_AUDIO_CHANNELS;
|
|
|
+ }
|
|
|
+ if (freq == 0) {
|
|
|
+ freq = DEFAULT_AUDIO_FREQUENCY;
|
|
|
+ }
|
|
|
+
|
|
|
+ device = iscapture ? CreateAudioCaptureDevice(name, fmt, channels, freq, handle) : CreateAudioOutputDevice(name, fmt, channels, freq, handle);
|
|
|
+ if (device) {
|
|
|
+ /* Post the event, if desired */
|
|
|
+ if (SDL_EventEnabled(SDL_EVENT_AUDIO_DEVICE_ADDED)) {
|
|
|
+ SDL_Event event;
|
|
|
+ event.type = SDL_EVENT_AUDIO_DEVICE_ADDED;
|
|
|
+ event.common.timestamp = 0;
|
|
|
+ event.adevice.which = device->instance_id;
|
|
|
+ event.adevice.iscapture = iscapture;
|
|
|
+ SDL_PushEvent(&event);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return device;
|
|
|
}
|
|
|
|
|
|
-SDL_AudioDevice *get_audio_dev(SDL_AudioDeviceID id)
|
|
|
+/* Called when a device is removed from the system, or it fails unexpectedly, from any thread, possibly even the audio device's thread. */
|
|
|
+void SDL_AudioDeviceDisconnected(SDL_AudioDevice *device)
|
|
|
{
|
|
|
- return open_devices[id];
|
|
|
+ SDL_bool was_live = SDL_FALSE;
|
|
|
+ SDL_bool should_destroy = SDL_TRUE;
|
|
|
+
|
|
|
+ if (!device) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ /* take it out of the device list. */
|
|
|
+ SDL_LockRWLockForWriting(current_audio.device_list_lock);
|
|
|
+ SDL_LockMutex(device->lock); /* make sure nothing else is messing with the device before continuing. */
|
|
|
+ if (device == current_audio.output_devices) {
|
|
|
+ SDL_assert(device->prev == NULL);
|
|
|
+ current_audio.output_devices = device->next;
|
|
|
+ was_live = SDL_TRUE;
|
|
|
+ } else if (device == current_audio.capture_devices) {
|
|
|
+ SDL_assert(device->prev == NULL);
|
|
|
+ current_audio.capture_devices = device->next;
|
|
|
+ was_live = SDL_TRUE;
|
|
|
+ }
|
|
|
+ if (device->prev != NULL) {
|
|
|
+ device->prev->next = device->next;
|
|
|
+ was_live = SDL_TRUE;
|
|
|
+ }
|
|
|
+ if (device->next != NULL) {
|
|
|
+ device->next->prev = device->prev;
|
|
|
+ was_live = SDL_TRUE;
|
|
|
+ }
|
|
|
+ SDL_UnlockRWLock(current_audio.device_list_lock);
|
|
|
+
|
|
|
+ /* now device is not in the list, and we own it, so no one should be able to find it again, except the audio thread, which holds a pointer! */
|
|
|
+ SDL_AtomicSet(&device->condemned, 1);
|
|
|
+ SDL_AtomicSet(&device->shutdown, 1); /* tell audio thread to terminate. */
|
|
|
+ if (device->thread) {
|
|
|
+ should_destroy = SDL_FALSE; /* if there's an audio thread, don't free until thread is terminating. */
|
|
|
+ }
|
|
|
+ SDL_UnlockMutex(device->lock);
|
|
|
+
|
|
|
+ /* Post the event, if we haven't tried to before and if it's desired */
|
|
|
+ if (was_live && SDL_EventEnabled(SDL_EVENT_AUDIO_DEVICE_REMOVED)) {
|
|
|
+ SDL_Event event;
|
|
|
+ event.type = SDL_EVENT_AUDIO_DEVICE_REMOVED;
|
|
|
+ event.common.timestamp = 0;
|
|
|
+ event.adevice.which = device->instance_id;
|
|
|
+ event.adevice.iscapture = device->iscapture ? 1 : 0;
|
|
|
+ SDL_PushEvent(&event);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (should_destroy) {
|
|
|
+ DestroyAudioDevice(device);
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
+
|
|
|
/* 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.OnlyHasDefaultCaptureDevice || !current_audio.impl.HasCaptureSupport);
|
|
|
|
|
|
- SDL_AddAudioDevice(SDL_FALSE, DEFAULT_OUTPUT_DEVNAME, NULL, (void *)((size_t)0x1));
|
|
|
+ SDL_AddAudioDevice(SDL_FALSE, DEFAULT_OUTPUT_DEVNAME, 0, 0, 0, (void *)((size_t)0x1));
|
|
|
if (current_audio.impl.HasCaptureSupport) {
|
|
|
- SDL_AddAudioDevice(SDL_TRUE, DEFAULT_INPUT_DEVNAME, NULL, (void *)((size_t)0x2));
|
|
|
+ SDL_AddAudioDevice(SDL_TRUE, DEFAULT_INPUT_DEVNAME, 0, 0, 0, (void *)((size_t)0x2));
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-static void SDL_AudioThreadInit_Default(SDL_AudioDevice *_this)
|
|
|
+static void SDL_AudioThreadInit_Default(SDL_AudioDevice *device)
|
|
|
{ /* no-op. */
|
|
|
}
|
|
|
|
|
|
-static void SDL_AudioThreadDeinit_Default(SDL_AudioDevice *_this)
|
|
|
+static void SDL_AudioThreadDeinit_Default(SDL_AudioDevice *device)
|
|
|
{ /* no-op. */
|
|
|
}
|
|
|
|
|
|
-static void SDL_AudioWaitDevice_Default(SDL_AudioDevice *_this)
|
|
|
+static void SDL_AudioWaitDevice_Default(SDL_AudioDevice *device)
|
|
|
{ /* no-op. */
|
|
|
}
|
|
|
|
|
|
-static void SDL_AudioPlayDevice_Default(SDL_AudioDevice *_this)
|
|
|
+static void SDL_AudioPlayDevice_Default(SDL_AudioDevice *device, int buffer_size)
|
|
|
{ /* no-op. */
|
|
|
}
|
|
|
|
|
|
-static Uint8 *SDL_AudioGetDeviceBuf_Default(SDL_AudioDevice *_this)
|
|
|
+static Uint8 *SDL_AudioGetDeviceBuf_Default(SDL_AudioDevice *device, int *buffer_size)
|
|
|
{
|
|
|
+ *buffer_size = 0;
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
-static int SDL_AudioCaptureFromDevice_Default(SDL_AudioDevice *_this, void *buffer, int buflen)
|
|
|
+static int SDL_AudioCaptureFromDevice_Default(SDL_AudioDevice *device, void *buffer, int buflen)
|
|
|
{
|
|
|
return -1; /* just fail immediately. */
|
|
|
}
|
|
|
|
|
|
-static void SDL_AudioFlushCapture_Default(SDL_AudioDevice *_this)
|
|
|
+static void SDL_AudioFlushCapture_Default(SDL_AudioDevice *device)
|
|
|
{ /* no-op. */
|
|
|
}
|
|
|
|
|
|
-static void SDL_AudioCloseDevice_Default(SDL_AudioDevice *_this)
|
|
|
+static void SDL_AudioCloseDevice_Default(SDL_AudioDevice *device)
|
|
|
{ /* no-op. */
|
|
|
}
|
|
|
|
|
|
@@ -177,32 +379,15 @@ static void SDL_AudioFreeDeviceHandle_Default(void *handle)
|
|
|
{ /* no-op. */
|
|
|
}
|
|
|
|
|
|
-static int SDL_AudioOpenDevice_Default(SDL_AudioDevice *_this, const char *devname)
|
|
|
+static int SDL_AudioOpenDevice_Default(SDL_AudioDevice *device)
|
|
|
{
|
|
|
return SDL_Unsupported();
|
|
|
}
|
|
|
|
|
|
-static void SDL_AudioLockDevice_Default(SDL_AudioDevice *device)
|
|
|
-{
|
|
|
- SDL_LockMutex(device->mixer_lock);
|
|
|
-}
|
|
|
-
|
|
|
-static void SDL_AudioUnlockDevice_Default(SDL_AudioDevice *device)
|
|
|
-{
|
|
|
- SDL_UnlockMutex(device->mixer_lock);
|
|
|
-}
|
|
|
-
|
|
|
-static void finish_audio_entry_points_init(void)
|
|
|
+/* Fill in stub functions for unused driver entry points. This lets us blindly call them without having to check for validity first. */
|
|
|
+static void CompleteAudioEntryPoints(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; \
|
|
|
- }
|
|
|
+ #define FILL_STUB(x) if (!current_audio.impl.x) { current_audio.impl.x = SDL_Audio##x##_Default; }
|
|
|
FILL_STUB(DetectDevices);
|
|
|
FILL_STUB(OpenDevice);
|
|
|
FILL_STUB(ThreadInit);
|
|
|
@@ -213,1283 +398,865 @@ static void finish_audio_entry_points_init(void)
|
|
|
FILL_STUB(CaptureFromDevice);
|
|
|
FILL_STUB(FlushCapture);
|
|
|
FILL_STUB(CloseDevice);
|
|
|
- FILL_STUB(LockDevice);
|
|
|
- FILL_STUB(UnlockDevice);
|
|
|
FILL_STUB(FreeDeviceHandle);
|
|
|
FILL_STUB(Deinitialize);
|
|
|
-#undef FILL_STUB
|
|
|
+ #undef FILL_STUB
|
|
|
}
|
|
|
|
|
|
-/* device hotplug support... */
|
|
|
-
|
|
|
-static int add_audio_device(const char *name, SDL_AudioSpec *spec, void *handle, SDL_AudioDeviceItem **devices, int *devCount)
|
|
|
+/* !!! FIXME: the video subsystem does SDL_VideoInit, not SDL_InitVideo. Make this match. */
|
|
|
+int SDL_InitAudio(const char *driver_name)
|
|
|
{
|
|
|
- int retval = -1;
|
|
|
- SDL_AudioDeviceItem *item;
|
|
|
- const SDL_AudioDeviceItem *i;
|
|
|
- int dupenum = 0;
|
|
|
-
|
|
|
- SDL_assert(handle != NULL); /* we reserve NULL, audio backends can't use it. */
|
|
|
- SDL_assert(name != NULL);
|
|
|
+ SDL_RWLock *device_list_lock = NULL;
|
|
|
+ SDL_bool initialized = SDL_FALSE;
|
|
|
+ SDL_bool tried_to_init = SDL_FALSE;
|
|
|
+ int i;
|
|
|
|
|
|
- item = (SDL_AudioDeviceItem *)SDL_malloc(sizeof(SDL_AudioDeviceItem));
|
|
|
- if (!item) {
|
|
|
- return SDL_OutOfMemory();
|
|
|
+ if (SDL_GetCurrentAudioDriver()) {
|
|
|
+ SDL_QuitAudio(); /* shutdown driver if already running. */
|
|
|
}
|
|
|
|
|
|
- item->original_name = SDL_strdup(name);
|
|
|
- if (!item->original_name) {
|
|
|
- SDL_free(item);
|
|
|
- return SDL_OutOfMemory();
|
|
|
- }
|
|
|
+ SDL_ChooseAudioConverters();
|
|
|
|
|
|
- item->dupenum = 0;
|
|
|
- item->name = item->original_name;
|
|
|
- if (spec != NULL) {
|
|
|
- SDL_copyp(&item->spec, spec);
|
|
|
- } else {
|
|
|
- SDL_zero(item->spec);
|
|
|
+ device_list_lock = SDL_CreateRWLock(); /* create this early, so if it fails we don't have to tear down the whole audio subsystem. */
|
|
|
+ if (!device_list_lock) {
|
|
|
+ return -1;
|
|
|
}
|
|
|
- item->handle = handle;
|
|
|
-
|
|
|
- SDL_LockMutex(current_audio.detectionLock);
|
|
|
|
|
|
- for (i = *devices; i != NULL; i = i->next) {
|
|
|
- if (SDL_strcmp(name, i->original_name) == 0) {
|
|
|
- dupenum = i->dupenum + 1;
|
|
|
- break; /* stop at the highest-numbered dupe. */
|
|
|
- }
|
|
|
+ /* Select the proper audio driver */
|
|
|
+ if (driver_name == NULL) {
|
|
|
+ driver_name = SDL_GetHint(SDL_HINT_AUDIO_DRIVER);
|
|
|
}
|
|
|
|
|
|
- if (dupenum) {
|
|
|
- const size_t len = SDL_strlen(name) + 16;
|
|
|
- char *replacement = (char *)SDL_malloc(len);
|
|
|
- if (!replacement) {
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
- SDL_free(item->original_name);
|
|
|
- SDL_free(item);
|
|
|
+ if (driver_name != NULL && *driver_name != 0) {
|
|
|
+ char *driver_name_copy = SDL_strdup(driver_name);
|
|
|
+ const char *driver_attempt = driver_name_copy;
|
|
|
+
|
|
|
+ if (driver_name_copy == NULL) {
|
|
|
+ SDL_DestroyRWLock(device_list_lock);
|
|
|
return SDL_OutOfMemory();
|
|
|
}
|
|
|
|
|
|
- (void)SDL_snprintf(replacement, len, "%s (%d)", name, dupenum + 1);
|
|
|
- item->dupenum = dupenum;
|
|
|
- item->name = replacement;
|
|
|
- }
|
|
|
-
|
|
|
- item->next = *devices;
|
|
|
- *devices = item;
|
|
|
- retval = (*devCount)++; /* !!! FIXME: this should be an atomic increment */
|
|
|
+ while (driver_attempt != NULL && *driver_attempt != 0 && !initialized) {
|
|
|
+ char *driver_attempt_end = SDL_strchr(driver_attempt, ',');
|
|
|
+ if (driver_attempt_end != NULL) {
|
|
|
+ *driver_attempt_end = '\0';
|
|
|
+ }
|
|
|
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
+ /* SDL 1.2 uses the name "dsound", so we'll support both. */
|
|
|
+ if (SDL_strcmp(driver_attempt, "dsound") == 0) {
|
|
|
+ driver_attempt = "directsound";
|
|
|
+ } else if (SDL_strcmp(driver_attempt, "pulse") == 0) { /* likewise, "pulse" was renamed to "pulseaudio" */
|
|
|
+ driver_attempt = "pulseaudio";
|
|
|
+ }
|
|
|
|
|
|
- return retval;
|
|
|
-}
|
|
|
+ for (i = 0; bootstrap[i]; ++i) {
|
|
|
+ if (SDL_strcasecmp(bootstrap[i]->name, driver_attempt) == 0) {
|
|
|
+ tried_to_init = SDL_TRUE;
|
|
|
+ SDL_zero(current_audio);
|
|
|
+ SDL_AtomicSet(¤t_audio.last_device_instance_id, 2); /* start past 1 because of SDL2's legacy interface. */
|
|
|
+ current_audio.device_list_lock = device_list_lock;
|
|
|
+ if (bootstrap[i]->init(¤t_audio.impl)) {
|
|
|
+ current_audio.name = bootstrap[i]->name;
|
|
|
+ current_audio.desc = bootstrap[i]->desc;
|
|
|
+ initialized = SDL_TRUE;
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
|
|
|
-static SDL_INLINE int add_capture_device(const char *name, SDL_AudioSpec *spec, void *handle)
|
|
|
-{
|
|
|
- SDL_assert(current_audio.impl.HasCaptureSupport);
|
|
|
- return add_audio_device(name, spec, handle, ¤t_audio.inputDevices, ¤t_audio.inputDeviceCount);
|
|
|
-}
|
|
|
+ driver_attempt = (driver_attempt_end != NULL) ? (driver_attempt_end + 1) : NULL;
|
|
|
+ }
|
|
|
|
|
|
-static SDL_INLINE int add_output_device(const char *name, SDL_AudioSpec *spec, void *handle)
|
|
|
-{
|
|
|
- return add_audio_device(name, spec, handle, ¤t_audio.outputDevices, ¤t_audio.outputDeviceCount);
|
|
|
-}
|
|
|
+ SDL_free(driver_name_copy);
|
|
|
+ } else {
|
|
|
+ for (i = 0; (!initialized) && (bootstrap[i]); ++i) {
|
|
|
+ if (bootstrap[i]->demand_only) {
|
|
|
+ continue;
|
|
|
+ }
|
|
|
|
|
|
-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);
|
|
|
- }
|
|
|
- /* these two pointers are the same if not a duplicate devname */
|
|
|
- if (item->name != item->original_name) {
|
|
|
- SDL_free(item->name);
|
|
|
+ tried_to_init = SDL_TRUE;
|
|
|
+ SDL_zero(current_audio);
|
|
|
+ SDL_AtomicSet(¤t_audio.last_device_instance_id, 2); /* start past 1 because of SDL2's legacy interface. */
|
|
|
+ current_audio.device_list_lock = device_list_lock;
|
|
|
+ if (bootstrap[i]->init(¤t_audio.impl)) {
|
|
|
+ current_audio.name = bootstrap[i]->name;
|
|
|
+ current_audio.desc = bootstrap[i]->desc;
|
|
|
+ initialized = SDL_TRUE;
|
|
|
+ }
|
|
|
}
|
|
|
- SDL_free(item->original_name);
|
|
|
- SDL_free(item);
|
|
|
}
|
|
|
- *devices = NULL;
|
|
|
- *devCount = 0;
|
|
|
-}
|
|
|
|
|
|
-/* The audio backends call this when a new device is plugged in. */
|
|
|
-void SDL_AddAudioDevice(const SDL_bool iscapture, const char *name, SDL_AudioSpec *spec, void *handle)
|
|
|
-{
|
|
|
- const int device_index = iscapture ? add_capture_device(name, spec, handle) : add_output_device(name, spec, handle);
|
|
|
- if (device_index != -1) {
|
|
|
- /* Post the event, if desired */
|
|
|
- if (SDL_EventEnabled(SDL_EVENT_AUDIO_DEVICE_ADDED)) {
|
|
|
- SDL_Event event;
|
|
|
- event.type = SDL_EVENT_AUDIO_DEVICE_ADDED;
|
|
|
- event.common.timestamp = 0;
|
|
|
- event.adevice.which = device_index;
|
|
|
- event.adevice.iscapture = iscapture;
|
|
|
- SDL_PushEvent(&event);
|
|
|
+ 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");
|
|
|
+ }
|
|
|
}
|
|
|
- }
|
|
|
-}
|
|
|
|
|
|
-/* 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);
|
|
|
-
|
|
|
- if (!SDL_AtomicGet(&device->enabled)) {
|
|
|
- return; /* don't report disconnects more than once. */
|
|
|
+ SDL_zero(current_audio);
|
|
|
+ SDL_DestroyRWLock(device_list_lock);
|
|
|
+ return -1; /* No driver was available, so fail. */
|
|
|
}
|
|
|
|
|
|
- if (SDL_AtomicGet(&device->shutdown)) {
|
|
|
- return; /* don't report disconnect if we're trying to close device. */
|
|
|
- }
|
|
|
+ CompleteAudioEntryPoints();
|
|
|
|
|
|
- /* 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);
|
|
|
- SDL_AtomicSet(&device->enabled, 0);
|
|
|
- current_audio.impl.UnlockDevice(device);
|
|
|
+ /* Make sure we have a list of devices available at startup. */
|
|
|
+ current_audio.impl.DetectDevices();
|
|
|
|
|
|
- /* Post the event, if desired */
|
|
|
- if (SDL_EventEnabled(SDL_EVENT_AUDIO_DEVICE_REMOVED)) {
|
|
|
- SDL_Event event;
|
|
|
- event.type = SDL_EVENT_AUDIO_DEVICE_REMOVED;
|
|
|
- event.common.timestamp = 0;
|
|
|
- event.adevice.which = device->id;
|
|
|
- event.adevice.iscapture = device->iscapture ? 1 : 0;
|
|
|
- SDL_PushEvent(&event);
|
|
|
- }
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
-static void mark_device_removed(void *handle, SDL_AudioDeviceItem *devices, SDL_bool *removedFlag)
|
|
|
+void SDL_QuitAudio(void)
|
|
|
{
|
|
|
- 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;
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
+ SDL_AudioDevice *devices = NULL;
|
|
|
+ SDL_AudioDevice *i;
|
|
|
|
|
|
-/* The audio backends call this when a device is removed from the system. */
|
|
|
-void SDL_RemoveAudioDevice(const SDL_bool iscapture, void *handle)
|
|
|
-{
|
|
|
- int device_index;
|
|
|
- SDL_AudioDevice *device = NULL;
|
|
|
- SDL_bool device_was_opened = SDL_FALSE;
|
|
|
+ if (!current_audio.name) { /* not initialized?! */
|
|
|
+ return;
|
|
|
+ }
|
|
|
|
|
|
- SDL_LockMutex(current_audio.detectionLock);
|
|
|
- if (iscapture) {
|
|
|
- mark_device_removed(handle, current_audio.inputDevices, ¤t_audio.captureDevicesRemoved);
|
|
|
- } else {
|
|
|
- mark_device_removed(handle, current_audio.outputDevices, ¤t_audio.outputDevicesRemoved);
|
|
|
+ /* merge device lists so we don't have to duplicate work below. */
|
|
|
+ SDL_LockRWLockForWriting(current_audio.device_list_lock);
|
|
|
+ SDL_AtomicSet(¤t_audio.shutting_down, 1);
|
|
|
+ for (i = current_audio.output_devices; i != NULL; i = i->next) {
|
|
|
+ devices = i;
|
|
|
}
|
|
|
- for (device_index = 0; device_index < SDL_arraysize(open_devices); device_index++) {
|
|
|
- device = open_devices[device_index];
|
|
|
- if (device != NULL && device->handle == handle) {
|
|
|
- device_was_opened = SDL_TRUE;
|
|
|
- SDL_OpenedAudioDeviceDisconnected(device);
|
|
|
- break;
|
|
|
+ if (!devices) {
|
|
|
+ devices = current_audio.capture_devices;
|
|
|
+ } else {
|
|
|
+ SDL_assert(devices->next == NULL);
|
|
|
+ devices->next = current_audio.capture_devices;
|
|
|
+ devices = current_audio.output_devices;
|
|
|
+ }
|
|
|
+ current_audio.output_devices = NULL;
|
|
|
+ current_audio.capture_devices = NULL;
|
|
|
+ SDL_UnlockRWLock(current_audio.device_list_lock);
|
|
|
+
|
|
|
+ /* mark all devices for shutdown so all threads can begin to terminate. */
|
|
|
+ for (i = devices; i != NULL; i = i->next) {
|
|
|
+ SDL_AtomicSet(&i->shutdown, 1);
|
|
|
+ }
|
|
|
+
|
|
|
+ /* now wait on any audio threads. */
|
|
|
+ for (i = devices; i != NULL; i = i->next) {
|
|
|
+ if (i->thread) {
|
|
|
+ SDL_assert(!SDL_AtomicGet(&i->condemned)); /* these shouldn't have been in the device list still, and thread should have detached. */
|
|
|
+ SDL_WaitThread(i->thread, NULL);
|
|
|
+ i->thread = NULL;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- /* Devices that aren't opened, as of 2.24.0, will post an
|
|
|
- SDL_EVENT_AUDIO_DEVICE_REMOVED event with the `which` field set to zero.
|
|
|
- Apps can use this to decide if they need to refresh a list of
|
|
|
- available devices instead of closing an opened one.
|
|
|
- Note that opened devices will send the non-zero event in
|
|
|
- SDL_OpenedAudioDeviceDisconnected(). */
|
|
|
- if (!device_was_opened) {
|
|
|
- if (SDL_EventEnabled(SDL_EVENT_AUDIO_DEVICE_REMOVED)) {
|
|
|
- SDL_Event event;
|
|
|
- event.type = SDL_EVENT_AUDIO_DEVICE_REMOVED;
|
|
|
- event.common.timestamp = 0;
|
|
|
- event.adevice.which = 0;
|
|
|
- event.adevice.iscapture = iscapture ? 1 : 0;
|
|
|
- SDL_PushEvent(&event);
|
|
|
- }
|
|
|
+ while (devices) {
|
|
|
+ i = devices->next;
|
|
|
+ DestroyAudioDevice(devices);
|
|
|
+ devices = i;
|
|
|
}
|
|
|
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
+ /* Free the driver data */
|
|
|
+ current_audio.impl.Deinitialize();
|
|
|
+
|
|
|
+ SDL_DestroyRWLock(current_audio.device_list_lock);
|
|
|
|
|
|
- current_audio.impl.FreeDeviceHandle(handle);
|
|
|
+ SDL_zero(current_audio);
|
|
|
}
|
|
|
|
|
|
-/* buffer queueing support... */
|
|
|
-
|
|
|
-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;
|
|
|
- size_t dequeued;
|
|
|
|
|
|
- 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?! */
|
|
|
|
|
|
- dequeued = SDL_ReadFromDataQueue(device->buffer_queue, stream, len);
|
|
|
- stream += dequeued;
|
|
|
- len -= (int)dequeued;
|
|
|
|
|
|
- if (len > 0) { /* fill any remaining space in the stream with silence. */
|
|
|
- SDL_assert(SDL_GetDataQueueSize(device->buffer_queue) == 0);
|
|
|
- SDL_memset(stream, device->callbackspec.silence, len);
|
|
|
- }
|
|
|
-}
|
|
|
+/* Output device thread. This is split into chunks, so backends that need to control this directly can use the pieces they need without duplicating effort. */
|
|
|
|
|
|
-static void SDLCALL SDL_BufferQueueFillCallback(void *userdata, Uint8 *stream, int len)
|
|
|
+void SDL_OutputAudioThreadSetup(SDL_AudioDevice *device)
|
|
|
{
|
|
|
- /* this function always holds the mixer lock before being called. */
|
|
|
- SDL_AudioDevice *device = (SDL_AudioDevice *)userdata;
|
|
|
+ SDL_assert(!device->iscapture);
|
|
|
|
|
|
- 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?! */
|
|
|
+ /* The audio mixing is always a high priority thread */
|
|
|
+#ifdef SDL_AUDIO_DRIVER_ANDROID
|
|
|
+ Android_JNI_AudioSetThreadPriority(SDL_FALSE, device->id);
|
|
|
+#else
|
|
|
+ SDL_SetThreadPriority(SDL_THREAD_PRIORITY_TIME_CRITICAL);
|
|
|
+#endif
|
|
|
|
|
|
- /* 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. */
|
|
|
- SDL_WriteToDataQueue(device->buffer_queue, stream, len);
|
|
|
+ /* Perform any thread setup */
|
|
|
+ current_audio.impl.ThreadInit(device);
|
|
|
}
|
|
|
|
|
|
-int SDL_QueueAudio(SDL_AudioDeviceID devid, const void *data, Uint32 len)
|
|
|
+SDL_bool SDL_OutputAudioThreadIterate(SDL_AudioDevice *device)
|
|
|
{
|
|
|
- SDL_AudioDevice *device = get_audio_device(devid);
|
|
|
- int rc = 0;
|
|
|
+ SDL_bool retval = SDL_TRUE;
|
|
|
+ SDL_AudioStream *stream;
|
|
|
+ int buffer_size = device->buffer_size;
|
|
|
+ Uint8 *mix_buffer;
|
|
|
|
|
|
- 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->callbackspec.callback != SDL_BufferQueueDrainCallback) {
|
|
|
- return SDL_SetError("Audio device has a callback, queueing not allowed");
|
|
|
- }
|
|
|
+ SDL_assert(!device->iscapture);
|
|
|
+
|
|
|
+ SDL_LockMutex(device->lock);
|
|
|
|
|
|
- if (len > 0) {
|
|
|
- current_audio.impl.LockDevice(device);
|
|
|
- rc = SDL_WriteToDataQueue(device->buffer_queue, data, len);
|
|
|
- current_audio.impl.UnlockDevice(device);
|
|
|
+ if (SDL_AtomicGet(&device->shutdown)) {
|
|
|
+ SDL_UnlockMutex(device->lock);
|
|
|
+ return SDL_FALSE; /* we're done, shut it down. */
|
|
|
}
|
|
|
|
|
|
- return rc;
|
|
|
-}
|
|
|
+ mix_buffer = current_audio.impl.GetDeviceBuf(device, &buffer_size);
|
|
|
+ if (!mix_buffer) {
|
|
|
+ retval = SDL_FALSE;
|
|
|
+ } else {
|
|
|
+ SDL_assert(buffer_size <= device->buffer_size); /* you can ask for less, but not more. */
|
|
|
+ SDL_memset(mix_buffer, device->silence_value, buffer_size); /* start with silence. */
|
|
|
+ for (stream = device->bound_streams; stream != NULL; stream = stream->next_binding) {
|
|
|
+ /* this will hold a lock on `stream` while getting. We don't explicitly lock the streams for iterating here because the binding linked list can only change while the device lock is held. */
|
|
|
+ /* (we _do_ lock the stream during binding/unbinding to make sure that two threads can't try to bind the same stream to different devices at the same time, though.) */
|
|
|
+ const int br = SDL_GetAudioStreamData(stream, device->work_buffer, buffer_size);
|
|
|
+ if (br < 0) {
|
|
|
+ /* oh crud, we probably ran out of memory. This is possibly an overreaction to kill the audio device, but it's likely the whole thing is going down in a moment anyhow. */
|
|
|
+ retval = SDL_FALSE;
|
|
|
+ break;
|
|
|
+ } else if (br > 0) { /* it's okay if we get less than requested, we mix what we have. */
|
|
|
+ if (SDL_MixAudioFormat(mix_buffer, device->work_buffer, device->format, br, SDL_MIX_MAXVOLUME) < 0) { /* !!! FIXME: allow streams to specify gain? */
|
|
|
+ SDL_assert(!"We probably ended up with some totally unexpected audio format here");
|
|
|
+ retval = SDL_FALSE; /* uh...? */
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ /* !!! FIXME: have PlayDevice return a value and do disconnects in here with it. */
|
|
|
+ current_audio.impl.PlayDevice(device, buffer_size); /* this SHOULD NOT BLOCK, as we are holding a lock right now. Block in WaitDevice! */
|
|
|
+ }
|
|
|
|
|
|
-Uint32 SDL_DequeueAudio(SDL_AudioDeviceID devid, void *data, Uint32 len)
|
|
|
-{
|
|
|
- SDL_AudioDevice *device = get_audio_device(devid);
|
|
|
- Uint32 rc;
|
|
|
+ SDL_UnlockMutex(device->lock);
|
|
|
|
|
|
- if ((len == 0) || /* nothing to do? */
|
|
|
- (!device) || /* called with bogus device id */
|
|
|
- (!device->iscapture) || /* playback devices can't dequeue */
|
|
|
- (device->callbackspec.callback != SDL_BufferQueueFillCallback)) { /* not set for queueing */
|
|
|
- return 0; /* just report zero bytes dequeued. */
|
|
|
+ if (!retval) {
|
|
|
+ SDL_AudioDeviceDisconnected(device); /* doh. */
|
|
|
}
|
|
|
|
|
|
- current_audio.impl.LockDevice(device);
|
|
|
- rc = (Uint32)SDL_ReadFromDataQueue(device->buffer_queue, data, len);
|
|
|
- current_audio.impl.UnlockDevice(device);
|
|
|
- return rc;
|
|
|
+ return retval;
|
|
|
}
|
|
|
|
|
|
-Uint32 SDL_GetQueuedAudioSize(SDL_AudioDeviceID devid)
|
|
|
+void SDL_OutputAudioThreadShutdown(SDL_AudioDevice *device)
|
|
|
{
|
|
|
- Uint32 retval = 0;
|
|
|
- SDL_AudioDevice *device = get_audio_device(devid);
|
|
|
-
|
|
|
- if (!device) {
|
|
|
- return 0;
|
|
|
+ const int samples = (device->buffer_size / (SDL_AUDIO_BITSIZE(device->format) / 8)) / device->channels;
|
|
|
+ SDL_assert(!device->iscapture);
|
|
|
+ /* Wait for the audio to drain. */ /* !!! FIXME: don't bother waiting if device is lost. */
|
|
|
+ SDL_Delay(((samples * 1000) / device->freq) * 2);
|
|
|
+ current_audio.impl.ThreadDeinit(device);
|
|
|
+ if (SDL_AtomicGet(&device->condemned)) {
|
|
|
+ SDL_DetachThread(device->thread); /* no one is waiting for us, just detach ourselves. */
|
|
|
+ device->thread = NULL;
|
|
|
+ DestroyAudioDevice(device);
|
|
|
}
|
|
|
+}
|
|
|
|
|
|
- /* Nothing to do unless we're set up for queueing. */
|
|
|
- if (device->callbackspec.callback == SDL_BufferQueueDrainCallback ||
|
|
|
- device->callbackspec.callback == SDL_BufferQueueFillCallback) {
|
|
|
- current_audio.impl.LockDevice(device);
|
|
|
- retval = (Uint32)SDL_GetDataQueueSize(device->buffer_queue);
|
|
|
- current_audio.impl.UnlockDevice(device);
|
|
|
- }
|
|
|
+/* thread entry point */
|
|
|
+static int SDLCALL OutputAudioThread(void *devicep)
|
|
|
+{
|
|
|
+ SDL_AudioDevice *device = (SDL_AudioDevice *)devicep;
|
|
|
+ SDL_assert(device != NULL);
|
|
|
+ SDL_assert(!device->iscapture);
|
|
|
+ SDL_OutputAudioThreadSetup(device);
|
|
|
+ do {
|
|
|
+ current_audio.impl.WaitDevice(device);
|
|
|
+ } while (SDL_OutputAudioThreadIterate(device));
|
|
|
|
|
|
- return retval;
|
|
|
+ SDL_OutputAudioThreadShutdown(device);
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
-int SDL_ClearQueuedAudio(SDL_AudioDeviceID devid)
|
|
|
-{
|
|
|
- SDL_AudioDevice *device = get_audio_device(devid);
|
|
|
- if (!device) {
|
|
|
- return SDL_InvalidParamError("devid");
|
|
|
- }
|
|
|
|
|
|
- /* Blank out the device and release the mutex. Free it afterwards. */
|
|
|
- current_audio.impl.LockDevice(device);
|
|
|
|
|
|
- /* Keep up to two packets in the pool to reduce future memory allocation pressure. */
|
|
|
- SDL_ClearDataQueue(device->buffer_queue, SDL_AUDIOBUFFERQUEUE_PACKETLEN * 2);
|
|
|
+/* Capture device thread. This is split into chunks, so backends that need to control this directly can use the pieces they need without duplicating effort. */
|
|
|
|
|
|
- current_audio.impl.UnlockDevice(device);
|
|
|
- return 0;
|
|
|
-}
|
|
|
-
|
|
|
-#ifdef SDL_AUDIO_DRIVER_ANDROID
|
|
|
-extern void Android_JNI_AudioSetThreadPriority(int, int);
|
|
|
-#endif
|
|
|
-
|
|
|
-/* The general mixing thread function */
|
|
|
-static int SDLCALL SDL_RunAudio(void *devicep)
|
|
|
+void SDL_CaptureAudioThreadSetup(SDL_AudioDevice *device)
|
|
|
{
|
|
|
- SDL_AudioDevice *device = (SDL_AudioDevice *)devicep;
|
|
|
- void *udata = device->callbackspec.userdata;
|
|
|
- SDL_AudioCallback callback = device->callbackspec.callback;
|
|
|
- int data_len = 0;
|
|
|
- Uint8 *data;
|
|
|
-
|
|
|
- SDL_assert(!device->iscapture);
|
|
|
+ SDL_assert(device->iscapture);
|
|
|
|
|
|
+ /* The audio mixing is always a high priority thread */
|
|
|
#ifdef SDL_AUDIO_DRIVER_ANDROID
|
|
|
- {
|
|
|
- /* Set thread priority to THREAD_PRIORITY_AUDIO */
|
|
|
- Android_JNI_AudioSetThreadPriority(device->iscapture, device->id);
|
|
|
- }
|
|
|
+ Android_JNI_AudioSetThreadPriority(SDL_TRUE, device->id);
|
|
|
#else
|
|
|
- /* The audio mixing is always a high priority thread */
|
|
|
- SDL_SetThreadPriority(SDL_THREAD_PRIORITY_TIME_CRITICAL);
|
|
|
+ SDL_SetThreadPriority(SDL_THREAD_PRIORITY_HIGH);
|
|
|
#endif
|
|
|
|
|
|
/* Perform any thread setup */
|
|
|
- device->threadid = SDL_ThreadID();
|
|
|
current_audio.impl.ThreadInit(device);
|
|
|
-
|
|
|
- /* Loop, filling the audio buffers */
|
|
|
- while (!SDL_AtomicGet(&device->shutdown)) {
|
|
|
- data_len = device->callbackspec.size;
|
|
|
-
|
|
|
- /* Fill the current buffer with sound */
|
|
|
- if (!device->stream && SDL_AtomicGet(&device->enabled)) {
|
|
|
- SDL_assert((Uint32)data_len == device->spec.size);
|
|
|
- data = current_audio.impl.GetDeviceBuf(device);
|
|
|
- } else {
|
|
|
- /* if the device isn't enabled, we still write to the
|
|
|
- work_buffer, 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.
|
|
|
- Streaming playback uses work_buffer, too. */
|
|
|
- data = NULL;
|
|
|
- }
|
|
|
-
|
|
|
- if (data == NULL) {
|
|
|
- data = device->work_buffer;
|
|
|
- }
|
|
|
-
|
|
|
- /* !!! FIXME: this should be LockDevice. */
|
|
|
- SDL_LockMutex(device->mixer_lock);
|
|
|
- if (SDL_AtomicGet(&device->paused)) {
|
|
|
- SDL_memset(data, device->callbackspec.silence, data_len);
|
|
|
- } else {
|
|
|
- callback(udata, data, data_len);
|
|
|
- }
|
|
|
- SDL_UnlockMutex(device->mixer_lock);
|
|
|
-
|
|
|
- if (device->stream) {
|
|
|
- /* Stream available audio to device, converting/resampling. */
|
|
|
- /* if this fails...oh well. We'll play silence here. */
|
|
|
- SDL_PutAudioStreamData(device->stream, data, data_len);
|
|
|
-
|
|
|
- while (SDL_GetAudioStreamAvailable(device->stream) >= ((int)device->spec.size)) {
|
|
|
- int got;
|
|
|
- data = SDL_AtomicGet(&device->enabled) ? current_audio.impl.GetDeviceBuf(device) : NULL;
|
|
|
- got = SDL_GetAudioStreamData(device->stream, data ? data : device->work_buffer, device->spec.size);
|
|
|
- SDL_assert((got <= 0) || ((Uint32)got == device->spec.size));
|
|
|
-
|
|
|
- if (data == NULL) { /* device is having issues... */
|
|
|
- const Uint32 delay = ((device->spec.samples * 1000) / device->spec.freq);
|
|
|
- SDL_Delay(delay); /* wait for as long as this buffer would have played. Maybe device recovers later? */
|
|
|
- } else {
|
|
|
- if ((Uint32)got != device->spec.size) {
|
|
|
- SDL_memset(data, device->spec.silence, device->spec.size);
|
|
|
- }
|
|
|
- current_audio.impl.PlayDevice(device);
|
|
|
- current_audio.impl.WaitDevice(device);
|
|
|
- }
|
|
|
- }
|
|
|
- } else if (data == device->work_buffer) {
|
|
|
- /* nothing to do; pause like we queued a buffer to play. */
|
|
|
- const Uint32 delay = ((device->spec.samples * 1000) / device->spec.freq);
|
|
|
- SDL_Delay(delay);
|
|
|
- } else { /* writing directly to the device. */
|
|
|
- /* queue this buffer and wait for it to finish playing. */
|
|
|
- current_audio.impl.PlayDevice(device);
|
|
|
- current_audio.impl.WaitDevice(device);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /* Wait for the audio to drain. */
|
|
|
- SDL_Delay(((device->spec.samples * 1000) / device->spec.freq) * 2);
|
|
|
-
|
|
|
- current_audio.impl.ThreadDeinit(device);
|
|
|
-
|
|
|
- return 0;
|
|
|
}
|
|
|
|
|
|
-/* !!! FIXME: this needs to deal with device spec changes. */
|
|
|
-/* The general capture thread function */
|
|
|
-static int SDLCALL SDL_CaptureAudio(void *devicep)
|
|
|
+SDL_bool SDL_CaptureAudioThreadIterate(SDL_AudioDevice *device)
|
|
|
{
|
|
|
- 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 data_len = device->spec.size;
|
|
|
- Uint8 *data;
|
|
|
- void *udata = device->callbackspec.userdata;
|
|
|
- SDL_AudioCallback callback = device->callbackspec.callback;
|
|
|
+ SDL_bool retval = SDL_TRUE;
|
|
|
|
|
|
SDL_assert(device->iscapture);
|
|
|
|
|
|
-#ifdef SDL_AUDIO_DRIVER_ANDROID
|
|
|
- {
|
|
|
- /* Set thread priority to THREAD_PRIORITY_AUDIO */
|
|
|
- Android_JNI_AudioSetThreadPriority(device->iscapture, device->id);
|
|
|
- }
|
|
|
-#else
|
|
|
- /* The audio mixing is always a high priority thread */
|
|
|
- SDL_SetThreadPriority(SDL_THREAD_PRIORITY_HIGH);
|
|
|
-#endif
|
|
|
-
|
|
|
- /* 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->paused)) {
|
|
|
- SDL_Delay(delay); /* just so we don't cook the CPU. */
|
|
|
- if (device->stream) {
|
|
|
- SDL_ClearAudioStream(device->stream);
|
|
|
- }
|
|
|
- current_audio.impl.FlushCapture(device); /* dump anything pending. */
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- /* Fill the current buffer with sound */
|
|
|
- still_need = data_len;
|
|
|
+ SDL_LockMutex(device->lock);
|
|
|
|
|
|
- /* Use the work_buffer to hold data read from the device. */
|
|
|
- data = device->work_buffer;
|
|
|
- SDL_assert(data != NULL);
|
|
|
-
|
|
|
- ptr = data;
|
|
|
-
|
|
|
- /* 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. */
|
|
|
-
|
|
|
- if (!SDL_AtomicGet(&device->enabled)) {
|
|
|
- SDL_Delay(delay); /* try to keep callback firing at normal pace. */
|
|
|
- } else {
|
|
|
- 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);
|
|
|
+ if (SDL_AtomicGet(&device->shutdown)) {
|
|
|
+ retval = SDL_FALSE; /* we're done, shut it down. */
|
|
|
+ } else if (device->bound_streams == NULL) {
|
|
|
+ current_audio.impl.FlushCapture(device); /* nothing wants data, dump anything pending. */
|
|
|
+ } else {
|
|
|
+ const int rc = current_audio.impl.CaptureFromDevice(device, device->work_buffer, device->buffer_size);
|
|
|
+ if (rc < 0) { /* uhoh, device failed for some reason! */
|
|
|
+ retval = SDL_FALSE;
|
|
|
+ } else if (rc > 0) { /* queue the new data to each bound stream. */
|
|
|
+ SDL_AudioStream *stream;
|
|
|
+ for (stream = device->bound_streams; stream != NULL; stream = stream->next_binding) {
|
|
|
+ /* this will hold a lock on `stream` while putting. We don't explicitly lock the streams for iterating here because the binding linked list can only change while the device lock is held. */
|
|
|
+ /* (we _do_ lock the stream during binding/unbinding to make sure that two threads can't try to bind the same stream to different devices at the same time, though.) */
|
|
|
+ if (SDL_PutAudioStreamData(stream, device->work_buffer, rc) < 0) {
|
|
|
+ /* oh crud, we probably ran out of memory. This is possibly an overreaction to kill the audio device, but it's likely the whole thing is going down in a moment anyhow. */
|
|
|
+ retval = SDL_FALSE;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
-
|
|
|
- if (still_need > 0) {
|
|
|
- /* Keep any data we already read, silence the rest. */
|
|
|
- SDL_memset(ptr, silence, still_need);
|
|
|
- }
|
|
|
-
|
|
|
- if (device->stream) {
|
|
|
- /* if this fails...oh well. */
|
|
|
- SDL_PutAudioStreamData(device->stream, data, data_len);
|
|
|
-
|
|
|
- while (SDL_GetAudioStreamAvailable(device->stream) >= ((int)device->callbackspec.size)) {
|
|
|
- const int got = SDL_GetAudioStreamData(device->stream, device->work_buffer, device->callbackspec.size);
|
|
|
- SDL_assert((got < 0) || ((Uint32)got == device->callbackspec.size));
|
|
|
- if ((Uint32)got != device->callbackspec.size) {
|
|
|
- SDL_memset(device->work_buffer, device->spec.silence, device->callbackspec.size);
|
|
|
- }
|
|
|
-
|
|
|
- /* !!! FIXME: this should be LockDevice. */
|
|
|
- SDL_LockMutex(device->mixer_lock);
|
|
|
- if (!SDL_AtomicGet(&device->paused)) {
|
|
|
- callback(udata, device->work_buffer, device->callbackspec.size);
|
|
|
- }
|
|
|
- SDL_UnlockMutex(device->mixer_lock);
|
|
|
- }
|
|
|
- } else { /* feeding user callback directly without streaming. */
|
|
|
- /* !!! FIXME: this should be LockDevice. */
|
|
|
- SDL_LockMutex(device->mixer_lock);
|
|
|
- if (!SDL_AtomicGet(&device->paused)) {
|
|
|
- callback(udata, data, device->callbackspec.size);
|
|
|
- }
|
|
|
- SDL_UnlockMutex(device->mixer_lock);
|
|
|
- }
|
|
|
}
|
|
|
|
|
|
- current_audio.impl.FlushCapture(device);
|
|
|
+ SDL_UnlockMutex(device->lock);
|
|
|
|
|
|
- current_audio.impl.ThreadDeinit(device);
|
|
|
+ if (!retval) {
|
|
|
+ SDL_AudioDeviceDisconnected(device); /* doh. */
|
|
|
+ }
|
|
|
|
|
|
- return 0;
|
|
|
+ return retval;
|
|
|
}
|
|
|
|
|
|
-static SDL_AudioFormat SDL_ParseAudioFormat(const char *string)
|
|
|
+void SDL_CaptureAudioThreadShutdown(SDL_AudioDevice *device)
|
|
|
{
|
|
|
-#define CHECK_FMT_STRING(x) \
|
|
|
- if (SDL_strcmp(string, #x) == 0) \
|
|
|
- return SDL_AUDIO_##x
|
|
|
- CHECK_FMT_STRING(U8);
|
|
|
- CHECK_FMT_STRING(S8);
|
|
|
- CHECK_FMT_STRING(S16LSB);
|
|
|
- CHECK_FMT_STRING(S16MSB);
|
|
|
- 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;
|
|
|
+ SDL_assert(device->iscapture);
|
|
|
+ current_audio.impl.FlushCapture(device);
|
|
|
+ current_audio.impl.ThreadDeinit(device);
|
|
|
+ if (SDL_AtomicGet(&device->condemned)) {
|
|
|
+ DestroyAudioDevice(device);
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
-int SDL_GetNumAudioDrivers(void)
|
|
|
+/* thread entry point */
|
|
|
+static int SDLCALL CaptureAudioThread(void *devicep)
|
|
|
{
|
|
|
- return SDL_arraysize(bootstrap) - 1;
|
|
|
+ SDL_AudioDevice *device = (SDL_AudioDevice *)devicep;
|
|
|
+ SDL_assert(device != NULL);
|
|
|
+ SDL_assert(device->iscapture);
|
|
|
+ SDL_CaptureAudioThreadSetup(device);
|
|
|
+ while (SDL_CaptureAudioThreadIterate(device)) { /* spin, CaptureAudioThreadIterate will block if necessary. !!! FIXME: maybe this is bad. */ }
|
|
|
+ SDL_CaptureAudioThreadShutdown(device);
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
-const char *SDL_GetAudioDriver(int index)
|
|
|
-{
|
|
|
- if (index >= 0 && index < SDL_GetNumAudioDrivers()) {
|
|
|
- return bootstrap[index]->name;
|
|
|
- }
|
|
|
- return NULL;
|
|
|
-}
|
|
|
|
|
|
-int SDL_InitAudio(const char *driver_name)
|
|
|
+static SDL_AudioDeviceID *GetAudioDevices(int *reqcount, SDL_AudioDevice **devices, SDL_AtomicInt *device_count)
|
|
|
{
|
|
|
- int i;
|
|
|
- SDL_bool initialized = SDL_FALSE, tried_to_init = SDL_FALSE;
|
|
|
-
|
|
|
- if (SDL_GetCurrentAudioDriver()) {
|
|
|
- SDL_QuitAudio(); /* shutdown driver if already running. */
|
|
|
- }
|
|
|
+ SDL_AudioDeviceID *retval = NULL;
|
|
|
+ int num_devices = 0;
|
|
|
|
|
|
- SDL_zeroa(open_devices);
|
|
|
-
|
|
|
- /* Select the proper audio driver */
|
|
|
- if (driver_name == NULL) {
|
|
|
- driver_name = SDL_GetHint(SDL_HINT_AUDIO_DRIVER);
|
|
|
+ if (!SDL_GetCurrentAudioDriver()) {
|
|
|
+ SDL_SetError("Audio subsystem is not initialized");
|
|
|
+ return NULL;
|
|
|
}
|
|
|
|
|
|
- if (driver_name != NULL && *driver_name != 0) {
|
|
|
- const char *driver_attempt = driver_name;
|
|
|
- while (driver_attempt != NULL && *driver_attempt != 0 && !initialized) {
|
|
|
- const char *driver_attempt_end = SDL_strchr(driver_attempt, ',');
|
|
|
- size_t driver_attempt_len = (driver_attempt_end != NULL) ? (driver_attempt_end - driver_attempt)
|
|
|
- : SDL_strlen(driver_attempt);
|
|
|
-#ifdef SDL_AUDIO_DRIVER_DSOUND
|
|
|
- /* SDL 1.2 uses the name "dsound", so we'll support both. */
|
|
|
- if (driver_attempt_len == SDL_strlen("dsound") &&
|
|
|
- (SDL_strncasecmp(driver_attempt, "dsound", driver_attempt_len) == 0)) {
|
|
|
- driver_attempt = "directsound";
|
|
|
- driver_attempt_len = SDL_strlen("directsound");
|
|
|
- }
|
|
|
-#endif
|
|
|
-
|
|
|
-#ifdef SDL_AUDIO_DRIVER_PULSEAUDIO
|
|
|
- /* SDL 1.2 uses the name "pulse", so we'll support both. */
|
|
|
- if (driver_attempt_len == SDL_strlen("pulse") &&
|
|
|
- (SDL_strncasecmp(driver_attempt, "pulse", driver_attempt_len) == 0)) {
|
|
|
- driver_attempt = "pulseaudio";
|
|
|
- driver_attempt_len = SDL_strlen("pulseaudio");
|
|
|
- }
|
|
|
-#endif
|
|
|
-
|
|
|
- for (i = 0; bootstrap[i]; ++i) {
|
|
|
- if ((driver_attempt_len == SDL_strlen(bootstrap[i]->name)) &&
|
|
|
- (SDL_strncasecmp(bootstrap[i]->name, driver_attempt, driver_attempt_len) == 0)) {
|
|
|
- tried_to_init = SDL_TRUE;
|
|
|
- SDL_zero(current_audio);
|
|
|
- current_audio.name = bootstrap[i]->name;
|
|
|
- current_audio.desc = bootstrap[i]->desc;
|
|
|
- initialized = bootstrap[i]->init(¤t_audio.impl);
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- driver_attempt = (driver_attempt_end != NULL) ? (driver_attempt_end + 1) : NULL;
|
|
|
- }
|
|
|
+ SDL_LockRWLockForReading(current_audio.device_list_lock);
|
|
|
+ num_devices = SDL_AtomicGet(device_count);
|
|
|
+ retval = (SDL_AudioDeviceID *) SDL_malloc((num_devices + 1) * sizeof (SDL_AudioDeviceID));
|
|
|
+ if (retval == NULL) {
|
|
|
+ num_devices = 0;
|
|
|
+ SDL_OutOfMemory();
|
|
|
} else {
|
|
|
- for (i = 0; (!initialized) && (bootstrap[i]); ++i) {
|
|
|
- if (bootstrap[i]->demand_only) {
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- tried_to_init = SDL_TRUE;
|
|
|
- SDL_zero(current_audio);
|
|
|
- current_audio.name = bootstrap[i]->name;
|
|
|
- current_audio.desc = bootstrap[i]->desc;
|
|
|
- initialized = bootstrap[i]->init(¤t_audio.impl);
|
|
|
+ const SDL_AudioDevice *dev = *devices;
|
|
|
+ int i;
|
|
|
+ for (i = 0; i < num_devices; i++) {
|
|
|
+ SDL_assert(dev != NULL);
|
|
|
+ SDL_assert(!SDL_AtomicGet((SDL_AtomicInt *) &dev->condemned)); /* shouldn't be in the list if pending deletion. */
|
|
|
+ retval[i] = dev->instance_id;
|
|
|
+ dev = dev->next;
|
|
|
}
|
|
|
+ SDL_assert(dev == NULL); /* did the whole list? */
|
|
|
+ retval[num_devices] = 0; /* null-terminated. */
|
|
|
}
|
|
|
+ SDL_UnlockRWLock(current_audio.device_list_lock);
|
|
|
|
|
|
- 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. */
|
|
|
+ if (reqcount != NULL) {
|
|
|
+ *reqcount = num_devices;
|
|
|
}
|
|
|
|
|
|
- current_audio.detectionLock = SDL_CreateMutex();
|
|
|
-
|
|
|
- finish_audio_entry_points_init();
|
|
|
-
|
|
|
- /* Make sure we have a list of devices available at startup. */
|
|
|
- current_audio.impl.DetectDevices();
|
|
|
-
|
|
|
- return 0;
|
|
|
+ return retval;
|
|
|
}
|
|
|
|
|
|
-/*
|
|
|
- * Get the current audio driver name
|
|
|
- */
|
|
|
-const char *SDL_GetCurrentAudioDriver(void)
|
|
|
+SDL_AudioDeviceID *SDL_GetAudioOutputDevices(int *count)
|
|
|
{
|
|
|
- return current_audio.name;
|
|
|
+ return GetAudioDevices(count, ¤t_audio.output_devices, ¤t_audio.output_device_count);
|
|
|
}
|
|
|
|
|
|
-/* 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_AudioDeviceID *SDL_GetAudioCaptureDevices(int *count)
|
|
|
{
|
|
|
- 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;
|
|
|
- }
|
|
|
- /* these two pointers are the same if not a duplicate devname */
|
|
|
- if (item->name != item->original_name) {
|
|
|
- SDL_free(item->name);
|
|
|
- }
|
|
|
- SDL_free(item->original_name);
|
|
|
- SDL_free(item);
|
|
|
- }
|
|
|
- item = next;
|
|
|
- }
|
|
|
-
|
|
|
- *devCount = total;
|
|
|
- *removedFlag = SDL_FALSE;
|
|
|
+ return GetAudioDevices(count, ¤t_audio.capture_devices, ¤t_audio.capture_device_count);
|
|
|
}
|
|
|
|
|
|
-int SDL_GetNumAudioDevices(int iscapture)
|
|
|
+
|
|
|
+/* this finds the device object associated with `devid` and locks it for use. */
|
|
|
+static SDL_AudioDevice *ObtainAudioDevice(SDL_AudioDeviceID devid)
|
|
|
{
|
|
|
- int retval = 0;
|
|
|
+ /* capture instance ids are even and output devices are odd, so we know which list to iterate from the devid. */
|
|
|
+ const SDL_bool iscapture = (devid & 1) ? SDL_FALSE : SDL_TRUE;
|
|
|
+ SDL_AudioDevice *dev = NULL;
|
|
|
|
|
|
if (!SDL_GetCurrentAudioDriver()) {
|
|
|
- return -1;
|
|
|
+ SDL_SetError("Audio subsystem is not initialized");
|
|
|
+ return NULL;
|
|
|
}
|
|
|
|
|
|
- SDL_LockMutex(current_audio.detectionLock);
|
|
|
- if (iscapture && current_audio.captureDevicesRemoved) {
|
|
|
- clean_out_device_list(¤t_audio.inputDevices, ¤t_audio.inputDeviceCount, ¤t_audio.captureDevicesRemoved);
|
|
|
- }
|
|
|
+ SDL_LockRWLockForReading(current_audio.device_list_lock);
|
|
|
|
|
|
- if (!iscapture && current_audio.outputDevicesRemoved) {
|
|
|
- clean_out_device_list(¤t_audio.outputDevices, ¤t_audio.outputDeviceCount, ¤t_audio.outputDevicesRemoved);
|
|
|
+ for (dev = iscapture ? current_audio.capture_devices : current_audio.output_devices; dev != NULL; dev = dev->next) {
|
|
|
+ if (dev->instance_id == devid) { /* found it? */
|
|
|
+ SDL_LockMutex(dev->lock); /* caller must unlock. */
|
|
|
+ SDL_assert(!SDL_AtomicGet(&dev->condemned)); /* shouldn't be in the list if pending deletion. */
|
|
|
+ break;
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
- retval = iscapture ? current_audio.inputDeviceCount : current_audio.outputDeviceCount;
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
+ SDL_UnlockRWLock(current_audio.device_list_lock);
|
|
|
|
|
|
- return retval;
|
|
|
+ if (!dev) {
|
|
|
+ SDL_SetError("Invalid audio device instance ID");
|
|
|
+ }
|
|
|
+
|
|
|
+ return dev;
|
|
|
}
|
|
|
|
|
|
-const char *SDL_GetAudioDeviceName(int index, int iscapture)
|
|
|
+SDL_AudioDevice *SDL_ObtainAudioDeviceByHandle(void *handle)
|
|
|
{
|
|
|
- SDL_AudioDeviceItem *item;
|
|
|
- int i;
|
|
|
- const char *retval;
|
|
|
+ SDL_AudioDevice *dev = NULL;
|
|
|
|
|
|
if (!SDL_GetCurrentAudioDriver()) {
|
|
|
SDL_SetError("Audio subsystem is not initialized");
|
|
|
return NULL;
|
|
|
}
|
|
|
|
|
|
- SDL_LockMutex(current_audio.detectionLock);
|
|
|
- item = iscapture ? current_audio.inputDevices : current_audio.outputDevices;
|
|
|
- i = iscapture ? current_audio.inputDeviceCount : current_audio.outputDeviceCount;
|
|
|
- if (index >= 0 && index < i) {
|
|
|
- for (i--; i > index; i--, item = item->next) {
|
|
|
- SDL_assert(item != NULL);
|
|
|
+ SDL_LockRWLockForReading(current_audio.device_list_lock);
|
|
|
+
|
|
|
+ for (dev = current_audio.output_devices; dev != NULL; dev = dev->next) {
|
|
|
+ if (dev->handle == handle) { /* found it? */
|
|
|
+ SDL_LockMutex(dev->lock); /* caller must unlock. */
|
|
|
+ SDL_assert(!SDL_AtomicGet(&dev->condemned)); /* shouldn't be in the list if pending deletion. */
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (!dev) {
|
|
|
+ for (dev = current_audio.capture_devices; dev != NULL; dev = dev->next) {
|
|
|
+ if (dev->handle == handle) { /* found it? */
|
|
|
+ SDL_LockMutex(dev->lock); /* caller must unlock. */
|
|
|
+ SDL_assert(!SDL_AtomicGet(&dev->condemned)); /* shouldn't be in the list if pending deletion. */
|
|
|
+ break;
|
|
|
+ }
|
|
|
}
|
|
|
- SDL_assert(item != NULL);
|
|
|
- retval = item->name;
|
|
|
- } else {
|
|
|
- SDL_InvalidParamError("index");
|
|
|
- retval = NULL;
|
|
|
}
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
|
|
|
- return retval;
|
|
|
+ SDL_UnlockRWLock(current_audio.device_list_lock);
|
|
|
+
|
|
|
+ if (!dev) {
|
|
|
+ SDL_SetError("Device handle not found");
|
|
|
+ }
|
|
|
+
|
|
|
+ return dev;
|
|
|
}
|
|
|
|
|
|
-int SDL_GetAudioDeviceSpec(int index, int iscapture, SDL_AudioSpec *spec)
|
|
|
+char *SDL_GetAudioDeviceName(SDL_AudioDeviceID devid)
|
|
|
{
|
|
|
- SDL_AudioDeviceItem *item;
|
|
|
- int i, retval;
|
|
|
-
|
|
|
- if (spec == NULL) {
|
|
|
- return SDL_InvalidParamError("spec");
|
|
|
+ char *retval;
|
|
|
+ SDL_AudioDevice *device = ObtainAudioDevice(devid);
|
|
|
+ if (!device) {
|
|
|
+ return NULL;
|
|
|
}
|
|
|
|
|
|
- if (!SDL_GetCurrentAudioDriver()) {
|
|
|
- return SDL_SetError("Audio subsystem is not initialized");
|
|
|
+ retval = SDL_strdup(device->name);
|
|
|
+ if (!retval) {
|
|
|
+ SDL_OutOfMemory();
|
|
|
}
|
|
|
|
|
|
- SDL_LockMutex(current_audio.detectionLock);
|
|
|
- item = iscapture ? current_audio.inputDevices : current_audio.outputDevices;
|
|
|
- i = iscapture ? current_audio.inputDeviceCount : current_audio.outputDeviceCount;
|
|
|
- if (index >= 0 && index < i) {
|
|
|
- for (i--; i > index; i--, item = item->next) {
|
|
|
- SDL_assert(item != NULL);
|
|
|
- }
|
|
|
- SDL_assert(item != NULL);
|
|
|
- SDL_copyp(spec, &item->spec);
|
|
|
- retval = 0;
|
|
|
- } else {
|
|
|
- retval = SDL_InvalidParamError("index");
|
|
|
- }
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
+ SDL_UnlockMutex(device->lock);
|
|
|
|
|
|
return retval;
|
|
|
}
|
|
|
|
|
|
-int SDL_GetDefaultAudioInfo(char **name, SDL_AudioSpec *spec, int iscapture)
|
|
|
+int SDL_GetAudioDeviceFormat(SDL_AudioDeviceID devid, SDL_AudioFormat *fmt, int *channels, int *freq)
|
|
|
{
|
|
|
- if (spec == NULL) {
|
|
|
- return SDL_InvalidParamError("spec");
|
|
|
+ SDL_AudioDevice *device = ObtainAudioDevice(devid);
|
|
|
+ if (!device) {
|
|
|
+ return -1;
|
|
|
}
|
|
|
|
|
|
- if (!SDL_GetCurrentAudioDriver()) {
|
|
|
- return SDL_SetError("Audio subsystem is not initialized");
|
|
|
+ if (fmt) {
|
|
|
+ *fmt = device->format;
|
|
|
}
|
|
|
-
|
|
|
- if (current_audio.impl.GetDefaultAudioInfo == NULL) {
|
|
|
- return SDL_Unsupported();
|
|
|
+ if (channels) {
|
|
|
+ *channels = device->channels;
|
|
|
}
|
|
|
- return current_audio.impl.GetDefaultAudioInfo(name, spec, iscapture);
|
|
|
-}
|
|
|
-
|
|
|
-static void close_audio_device(SDL_AudioDevice *device)
|
|
|
-{
|
|
|
- if (!device) {
|
|
|
- return;
|
|
|
+ if (freq) {
|
|
|
+ *freq = device->freq;
|
|
|
}
|
|
|
|
|
|
- /* make sure the device is paused before we do anything else, so the
|
|
|
- audio callback definitely won't fire again. */
|
|
|
- current_audio.impl.LockDevice(device);
|
|
|
- SDL_AtomicSet(&device->paused, 1);
|
|
|
- SDL_AtomicSet(&device->shutdown, 1);
|
|
|
- SDL_AtomicSet(&device->enabled, 0);
|
|
|
- current_audio.impl.UnlockDevice(device);
|
|
|
+ SDL_UnlockMutex(device->lock);
|
|
|
+
|
|
|
+ return 0;
|
|
|
+}
|
|
|
|
|
|
+/* this expects the device lock to be held. */
|
|
|
+static void CloseAudioDevice(SDL_AudioDevice *device)
|
|
|
+{
|
|
|
if (device->thread != NULL) {
|
|
|
+ SDL_AtomicSet(&device->shutdown, 1);
|
|
|
SDL_WaitThread(device->thread, NULL);
|
|
|
- }
|
|
|
- if (device->mixer_lock != NULL) {
|
|
|
- SDL_DestroyMutex(device->mixer_lock);
|
|
|
+ device->thread = NULL;
|
|
|
+ SDL_AtomicSet(&device->shutdown, 0);
|
|
|
}
|
|
|
|
|
|
- SDL_free(device->work_buffer);
|
|
|
- SDL_DestroyAudioStream(device->stream);
|
|
|
+ current_audio.impl.CloseDevice(device);
|
|
|
|
|
|
- if (device->id > 0) {
|
|
|
- SDL_AudioDevice *opendev = open_devices[device->id - 1];
|
|
|
- SDL_assert((opendev == device) || (opendev == NULL));
|
|
|
- if (opendev == device) {
|
|
|
- open_devices[device->id - 1] = NULL;
|
|
|
- }
|
|
|
+ if (device->work_buffer) {
|
|
|
+ SDL_aligned_free(device->work_buffer);
|
|
|
+ device->work_buffer = NULL;
|
|
|
}
|
|
|
|
|
|
- if (device->hidden != NULL) {
|
|
|
- current_audio.impl.CloseDevice(device);
|
|
|
- }
|
|
|
-
|
|
|
- SDL_DestroyDataQueue(device->buffer_queue);
|
|
|
+ device->format = device->default_format;
|
|
|
+ device->channels = device->default_channels;
|
|
|
+ device->freq = device->default_freq;
|
|
|
+ device->sample_frames = 0;
|
|
|
+ device->silence_value = SDL_GetSilenceValueForFormat(device->format);
|
|
|
+}
|
|
|
|
|
|
- SDL_free(device);
|
|
|
+void SDL_CloseAudioDevice(SDL_AudioDeviceID devid)
|
|
|
+{
|
|
|
+ SDL_AudioDevice *device = ObtainAudioDevice(devid);
|
|
|
+ if (device) { /* if NULL, maybe it was already lost? */
|
|
|
+ if (SDL_AtomicDecRef(&device->refcount)) {
|
|
|
+ SDL_UnlockMutex(device->lock); /* can't hold the lock or the audio thread will deadlock while we WaitThread it. */
|
|
|
+ CloseAudioDevice(device);
|
|
|
+ } else {
|
|
|
+ if (SDL_AtomicGet(&device->refcount) < 0) {
|
|
|
+ SDL_AtomicSet(&device->refcount, 0); /* something closed more than it should, force this back to zero. Best we can do. */
|
|
|
+ }
|
|
|
+ SDL_UnlockMutex(device->lock); /* can't hold the lock or the audio thread will deadlock while we WaitThread it. */
|
|
|
+ }
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
-static Uint16 GetDefaultSamplesFromFreq(int freq)
|
|
|
+
|
|
|
+static SDL_AudioFormat ParseAudioFormatString(const char *string)
|
|
|
{
|
|
|
- /* Pick a default of ~46 ms at desired frequency */
|
|
|
- /* !!! FIXME: remove this when the non-Po2 resampling is in. */
|
|
|
- const Uint16 max_sample = (Uint16)((freq / 1000) * 46);
|
|
|
- Uint16 current_sample = 1;
|
|
|
- while (current_sample < max_sample) {
|
|
|
- current_sample *= 2;
|
|
|
+ if (string) {
|
|
|
+#define CHECK_FMT_STRING(x) \
|
|
|
+ if (SDL_strcmp(string, #x) == 0) \
|
|
|
+ return SDL_AUDIO_##x
|
|
|
+ CHECK_FMT_STRING(U8);
|
|
|
+ CHECK_FMT_STRING(S8);
|
|
|
+ CHECK_FMT_STRING(S16LSB);
|
|
|
+ CHECK_FMT_STRING(S16MSB);
|
|
|
+ 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 current_sample;
|
|
|
+ return 0;
|
|
|
}
|
|
|
|
|
|
-/*
|
|
|
- * 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).
|
|
|
- */
|
|
|
-static int prepare_audiospec(const SDL_AudioSpec *orig, SDL_AudioSpec *prepared)
|
|
|
+static void PrepareAudioFormat(SDL_AudioFormat *fmt, int *channels, int *freq)
|
|
|
{
|
|
|
- SDL_copyp(prepared, orig);
|
|
|
+ const char *env;
|
|
|
|
|
|
- if (orig->freq == 0) {
|
|
|
- static const int DEFAULT_FREQ = 22050;
|
|
|
- const char *env = SDL_getenv("SDL_AUDIO_FREQUENCY");
|
|
|
+ if (*freq == 0) {
|
|
|
+ *freq = DEFAULT_AUDIO_FREQUENCY;
|
|
|
+ env = SDL_getenv("SDL_AUDIO_FREQUENCY");
|
|
|
if (env != NULL) {
|
|
|
- int freq = SDL_atoi(env);
|
|
|
- prepared->freq = freq != 0 ? freq : DEFAULT_FREQ;
|
|
|
- } else {
|
|
|
- prepared->freq = DEFAULT_FREQ;
|
|
|
+ const int val = SDL_atoi(env);
|
|
|
+ if (val > 0) {
|
|
|
+ *freq = val;
|
|
|
+ }
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- if (orig->format == 0) {
|
|
|
- const char *env = SDL_getenv("SDL_AUDIO_FORMAT");
|
|
|
+ if (*channels == 0) {
|
|
|
+ *channels = DEFAULT_AUDIO_CHANNELS;
|
|
|
+ env = SDL_getenv("SDL_AUDIO_CHANNELS");
|
|
|
if (env != NULL) {
|
|
|
- const SDL_AudioFormat format = SDL_ParseAudioFormat(env);
|
|
|
- prepared->format = format != 0 ? format : SDL_AUDIO_S16;
|
|
|
- } else {
|
|
|
- prepared->format = SDL_AUDIO_S16;
|
|
|
+ const int val = SDL_atoi(env);
|
|
|
+ if (val > 0) {
|
|
|
+ *channels = val;
|
|
|
+ }
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- if (orig->channels == 0) {
|
|
|
- const char *env = SDL_getenv("SDL_AUDIO_CHANNELS");
|
|
|
- if (env != NULL) {
|
|
|
- Uint8 channels = (Uint8)SDL_atoi(env);
|
|
|
- prepared->channels = channels != 0 ? channels : 2;
|
|
|
- } else {
|
|
|
- prepared->channels = 2;
|
|
|
- }
|
|
|
- } else if (orig->channels > 8) {
|
|
|
- SDL_SetError("Unsupported number of audio channels.");
|
|
|
- return 0;
|
|
|
+ if (*fmt == 0) {
|
|
|
+ const SDL_AudioFormat val = ParseAudioFormatString(SDL_getenv("SDL_AUDIO_FORMAT"));
|
|
|
+ *fmt = (val != 0) ? val : DEFAULT_AUDIO_FORMAT;
|
|
|
}
|
|
|
+}
|
|
|
|
|
|
- if (orig->samples == 0) {
|
|
|
- const char *env = SDL_getenv("SDL_AUDIO_SAMPLES");
|
|
|
- if (env != NULL) {
|
|
|
- Uint16 samples = (Uint16)SDL_atoi(env);
|
|
|
- prepared->samples = samples != 0 ? samples : GetDefaultSamplesFromFreq(prepared->freq);
|
|
|
- } else {
|
|
|
- prepared->samples = GetDefaultSamplesFromFreq(prepared->freq);
|
|
|
- }
|
|
|
+static int GetDefaultSampleFramesFromFreq(int freq)
|
|
|
+{
|
|
|
+ /* Pick the closest power-of-two to ~46 ms at desired frequency */
|
|
|
+ const int max_sample = ((freq / 1000) * 46);
|
|
|
+ int current_sample = 1;
|
|
|
+ while (current_sample < max_sample) {
|
|
|
+ current_sample *= 2;
|
|
|
}
|
|
|
-
|
|
|
- /* Calculate the silence and size of the audio specification */
|
|
|
- SDL_CalculateAudioSpec(prepared);
|
|
|
-
|
|
|
- return 1;
|
|
|
+ return current_sample;
|
|
|
}
|
|
|
|
|
|
-static SDL_AudioDeviceID open_audio_device(const char *devname, int iscapture,
|
|
|
- const SDL_AudioSpec *desired, SDL_AudioSpec *obtained,
|
|
|
- int allowed_changes, int min_id)
|
|
|
+void SDL_UpdatedAudioDeviceFormat(SDL_AudioDevice *device)
|
|
|
{
|
|
|
- const SDL_bool is_internal_thread = (desired->callback == NULL);
|
|
|
- SDL_AudioDeviceID id = 0;
|
|
|
- SDL_AudioSpec _obtained;
|
|
|
- SDL_AudioDevice *device;
|
|
|
- SDL_bool build_stream;
|
|
|
- void *handle = NULL;
|
|
|
- int i = 0;
|
|
|
+ device->silence_value = SDL_GetSilenceValueForFormat(device->format);
|
|
|
+ device->buffer_size = device->sample_frames * (SDL_AUDIO_BITSIZE(device->format) / 8) * device->channels;
|
|
|
+}
|
|
|
|
|
|
- if (!SDL_GetCurrentAudioDriver()) {
|
|
|
- SDL_SetError("Audio subsystem is not initialized");
|
|
|
- return 0;
|
|
|
+/* this expects the device lock to be held. */
|
|
|
+static int OpenAudioDevice(SDL_AudioDevice *device, SDL_AudioFormat fmt, int channels, int freq)
|
|
|
+{
|
|
|
+ SDL_assert(SDL_AtomicGet(&device->refcount) == 1);
|
|
|
+
|
|
|
+ PrepareAudioFormat(&fmt, &channels, &freq);
|
|
|
+
|
|
|
+ /* we allow the device format to change if it's better than the current settings (by various definitions of "better"). This prevents
|
|
|
+ something low quality, like an old game using S8/8000Hz audio, from ruining a music thing playing at CD quality that tries to open later.
|
|
|
+ (or some VoIP library that opens for mono output ruining your surround-sound game because it got there first). */
|
|
|
+ /* These are just requests! The backend may change any of these values during OpenDevice method! */
|
|
|
+ device->format = (SDL_AUDIO_BITSIZE(device->default_format) >= SDL_AUDIO_BITSIZE(fmt)) ? device->default_format : fmt;
|
|
|
+ device->freq = SDL_max(device->default_freq, freq);
|
|
|
+ device->channels = SDL_max(device->default_channels, channels);
|
|
|
+ device->sample_frames = GetDefaultSampleFramesFromFreq(device->freq);
|
|
|
+ SDL_UpdatedAudioDeviceFormat(device); /* start this off sane. */
|
|
|
+
|
|
|
+ if (current_audio.impl.OpenDevice(device) < 0) {
|
|
|
+ CloseAudioDevice(device); /* clean up anything the backend left half-initialized. */
|
|
|
+ return -1;
|
|
|
}
|
|
|
|
|
|
- if (iscapture && !current_audio.impl.HasCaptureSupport) {
|
|
|
- SDL_SetError("No capture support");
|
|
|
- return 0;
|
|
|
- }
|
|
|
+ SDL_UpdatedAudioDeviceFormat(device); /* in case the backend changed things and forgot to call this. */
|
|
|
|
|
|
- SDL_LockMutex(current_audio.detectionLock);
|
|
|
- /* Find an available device ID... */
|
|
|
- for (id = min_id - 1; id < SDL_arraysize(open_devices); id++) {
|
|
|
- if (open_devices[id] == NULL) {
|
|
|
- break;
|
|
|
- }
|
|
|
+ /* Allocate a scratch audio buffer */
|
|
|
+ device->work_buffer = (Uint8 *)SDL_aligned_alloc(SDL_SIMDGetAlignment(), device->buffer_size);
|
|
|
+ if (device->work_buffer == NULL) {
|
|
|
+ CloseAudioDevice(device);
|
|
|
+ return SDL_OutOfMemory();
|
|
|
}
|
|
|
|
|
|
- if (id == SDL_arraysize(open_devices)) {
|
|
|
- SDL_SetError("Too many open audio devices");
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
- return 0;
|
|
|
- }
|
|
|
+ /* Start the audio thread if necessary */
|
|
|
+ if (!current_audio.impl.ProvidesOwnCallbackThread) {
|
|
|
+ const size_t stacksize = 64 * 1024; /* We only need a little space, so make the stack tiny. We may adjust this as necessary later. */
|
|
|
+ char threadname[64];
|
|
|
|
|
|
- if (!obtained) {
|
|
|
- obtained = &_obtained;
|
|
|
- }
|
|
|
- if (!prepare_audiospec(desired, obtained)) {
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
- return 0;
|
|
|
- }
|
|
|
+ (void)SDL_snprintf(threadname, sizeof(threadname), "SDLAudio%c%d", (device->iscapture) ? 'C' : 'P', (int) device->instance_id);
|
|
|
+ device->thread = SDL_CreateThreadInternal(device->iscapture ? CaptureAudioThread : OutputAudioThread, threadname, stacksize, device);
|
|
|
|
|
|
- /* If app doesn't care about a specific device, let the user override. */
|
|
|
- if (devname == NULL) {
|
|
|
- devname = SDL_getenv("SDL_AUDIO_DEVICE_NAME");
|
|
|
+ if (device->thread == NULL) {
|
|
|
+ CloseAudioDevice(device);
|
|
|
+ return SDL_SetError("Couldn't create audio thread");
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
- /*
|
|
|
- * Catch device names at the high level for the simple case...
|
|
|
- * This lets us have a basic "device enumeration" for systems that
|
|
|
- * don't have multiple devices, but makes sure the device name is
|
|
|
- * always NULL when it hits the low level.
|
|
|
- *
|
|
|
- * Also make sure that the simple case prevents multiple simultaneous
|
|
|
- * opens of the default system device.
|
|
|
- */
|
|
|
-
|
|
|
- if ((iscapture) && (current_audio.impl.OnlyHasDefaultCaptureDevice)) {
|
|
|
- if ((devname) && (SDL_strcmp(devname, DEFAULT_INPUT_DEVNAME) != 0)) {
|
|
|
- SDL_SetError("No such device");
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
- return 0;
|
|
|
- }
|
|
|
- devname = NULL;
|
|
|
+ return 0;
|
|
|
+}
|
|
|
|
|
|
- for (i = 0; i < SDL_arraysize(open_devices); i++) {
|
|
|
- if ((open_devices[i]) && (open_devices[i]->iscapture)) {
|
|
|
- SDL_SetError("Audio device already open");
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
- return 0;
|
|
|
- }
|
|
|
- }
|
|
|
- } else if ((!iscapture) && (current_audio.impl.OnlyHasDefaultOutputDevice)) {
|
|
|
- if ((devname) && (SDL_strcmp(devname, DEFAULT_OUTPUT_DEVNAME) != 0)) {
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
- SDL_SetError("No such device");
|
|
|
- return 0;
|
|
|
- }
|
|
|
- devname = NULL;
|
|
|
+SDL_AudioDeviceID SDL_OpenAudioDevice(SDL_AudioDeviceID devid, SDL_AudioFormat fmt, int channels, int freq)
|
|
|
+{
|
|
|
+ SDL_AudioDevice *device = ObtainAudioDevice(devid); /* !!! FIXME: need to choose default device for devid==0 */
|
|
|
+ int retval = 0;
|
|
|
|
|
|
- for (i = 0; i < SDL_arraysize(open_devices); i++) {
|
|
|
- if ((open_devices[i]) && (!open_devices[i]->iscapture)) {
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
- SDL_SetError("Audio device already open");
|
|
|
- return 0;
|
|
|
- }
|
|
|
- }
|
|
|
- } else if (devname != NULL) {
|
|
|
- /* if the app specifies an exact string, we can pass the backend
|
|
|
- an actual device handle thingey, which saves them the effort of
|
|
|
- figuring out what device this was (such as, reenumerating
|
|
|
- everything again to find the matching human-readable name).
|
|
|
- It might still need to open a device based on the string for,
|
|
|
- say, a network audio server, but this optimizes some cases. */
|
|
|
- SDL_AudioDeviceItem *item;
|
|
|
- for (item = iscapture ? current_audio.inputDevices : current_audio.outputDevices; item; item = item->next) {
|
|
|
- if ((item->handle != NULL) && (SDL_strcmp(item->name, devname) == 0)) {
|
|
|
- handle = item->handle;
|
|
|
- break;
|
|
|
+ if (device) {
|
|
|
+ retval = device->instance_id;
|
|
|
+ if (SDL_AtomicIncRef(&device->refcount) == 0) {
|
|
|
+ if (OpenAudioDevice(device, fmt, channels, freq) == -1) {
|
|
|
+ retval = 0;
|
|
|
}
|
|
|
}
|
|
|
+ SDL_UnlockMutex(device->lock);
|
|
|
}
|
|
|
|
|
|
- if (!current_audio.impl.AllowsArbitraryDeviceNames) {
|
|
|
- /* has to be in our device list, or the default device. */
|
|
|
- if ((handle == NULL) && (devname != NULL)) {
|
|
|
- SDL_SetError("No such device.");
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
- return 0;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- device = (SDL_AudioDevice *)SDL_calloc(1, sizeof(SDL_AudioDevice));
|
|
|
- if (device == NULL) {
|
|
|
- SDL_OutOfMemory();
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
- return 0;
|
|
|
- }
|
|
|
- device->id = id + 1;
|
|
|
- device->spec = *obtained;
|
|
|
- device->iscapture = iscapture ? SDL_TRUE : SDL_FALSE;
|
|
|
- device->handle = handle;
|
|
|
+ return retval;
|
|
|
+}
|
|
|
|
|
|
- SDL_AtomicSet(&device->shutdown, 0); /* just in case. */
|
|
|
- SDL_AtomicSet(&device->paused, 1);
|
|
|
- SDL_AtomicSet(&device->enabled, 1);
|
|
|
-
|
|
|
- /* Create a mutex for locking the sound buffers */
|
|
|
- if (current_audio.impl.LockDevice == SDL_AudioLockDevice_Default) {
|
|
|
- device->mixer_lock = SDL_CreateMutex();
|
|
|
- if (device->mixer_lock == NULL) {
|
|
|
- close_audio_device(device);
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
- SDL_SetError("Couldn't create mixer lock");
|
|
|
- return 0;
|
|
|
- }
|
|
|
- }
|
|
|
+int SDL_BindAudioStreams(SDL_AudioDeviceID devid, SDL_AudioStream **streams, int num_streams)
|
|
|
+{
|
|
|
+ SDL_AudioDevice *device;
|
|
|
+ int retval = 0;
|
|
|
+ int i;
|
|
|
|
|
|
- /* For backends that require a power-of-two value for spec.samples, take the
|
|
|
- * value we got from 'desired' and round up to the nearest value
|
|
|
- */
|
|
|
- if (!current_audio.impl.SupportsNonPow2Samples && device->spec.samples > 0) {
|
|
|
- int samples = SDL_powerof2(device->spec.samples);
|
|
|
- if (samples <= SDL_MAX_UINT16) {
|
|
|
- device->spec.samples = (Uint16)samples;
|
|
|
+ if (num_streams == 0) {
|
|
|
+ return 0; /* nothing to do */
|
|
|
+ } else if (num_streams < 0) {
|
|
|
+ return SDL_InvalidParamError("num_streams");
|
|
|
+ } else if (streams == NULL) {
|
|
|
+ return SDL_InvalidParamError("streams");
|
|
|
+ } else if ((device = ObtainAudioDevice(devid)) == NULL) {
|
|
|
+ return -1; /* ObtainAudioDevice set the error message. */
|
|
|
+ } else if (SDL_AtomicGet(&device->refcount) == 0) {
|
|
|
+ SDL_UnlockMutex(device->lock);
|
|
|
+ return SDL_SetError("Device is not opened");
|
|
|
+ }
|
|
|
+
|
|
|
+ SDL_assert(!device->bound_streams || (device->bound_streams->prev_binding == NULL));
|
|
|
+
|
|
|
+ /* lock all the streams upfront, so we can verify they aren't bound elsewhere and add them all in one block, as this is intended to add everything or nothing. */
|
|
|
+ for (i = 0; i < num_streams; i++) {
|
|
|
+ SDL_AudioStream *stream = streams[i];
|
|
|
+ if (stream == NULL) {
|
|
|
+ retval = SDL_SetError("Stream #%d is NULL", i);
|
|
|
} else {
|
|
|
- SDL_SetError("Couldn't hold sample count %d\n", samples);
|
|
|
- return 0;
|
|
|
+ SDL_LockMutex(stream->lock);
|
|
|
+ SDL_assert((stream->bound_device == NULL) == ((stream->prev_binding == NULL) || (stream->next_binding == NULL)));
|
|
|
+ if (stream->bound_device) {
|
|
|
+ retval = SDL_SetError("Stream #%d is already bound to a device", i);
|
|
|
+ }
|
|
|
}
|
|
|
- }
|
|
|
-
|
|
|
- if (current_audio.impl.OpenDevice(device, devname) < 0) {
|
|
|
- close_audio_device(device);
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
- return 0;
|
|
|
- }
|
|
|
-
|
|
|
- /* if your target really doesn't need it, set it to 0x1 or something. */
|
|
|
- /* otherwise, close_audio_device() won't call impl.CloseDevice(). */
|
|
|
- SDL_assert(device->hidden != NULL);
|
|
|
|
|
|
- /* See if we need to do any conversion */
|
|
|
- build_stream = SDL_FALSE;
|
|
|
- if (obtained->freq != device->spec.freq) {
|
|
|
- if (allowed_changes & SDL_AUDIO_ALLOW_FREQUENCY_CHANGE) {
|
|
|
- obtained->freq = device->spec.freq;
|
|
|
- } else {
|
|
|
- build_stream = SDL_TRUE;
|
|
|
- }
|
|
|
- }
|
|
|
- if (obtained->format != device->spec.format) {
|
|
|
- if (allowed_changes & SDL_AUDIO_ALLOW_FORMAT_CHANGE) {
|
|
|
- obtained->format = device->spec.format;
|
|
|
- } else {
|
|
|
- build_stream = SDL_TRUE;
|
|
|
- }
|
|
|
- }
|
|
|
- if (obtained->channels != device->spec.channels) {
|
|
|
- if (allowed_changes & SDL_AUDIO_ALLOW_CHANNELS_CHANGE) {
|
|
|
- obtained->channels = device->spec.channels;
|
|
|
- } else {
|
|
|
- build_stream = SDL_TRUE;
|
|
|
- }
|
|
|
- }
|
|
|
- if (device->spec.samples != obtained->samples) {
|
|
|
- if (allowed_changes & SDL_AUDIO_ALLOW_SAMPLES_CHANGE) {
|
|
|
- obtained->samples = device->spec.samples;
|
|
|
- } else {
|
|
|
- build_stream = SDL_TRUE;
|
|
|
+ if (retval != 0) {
|
|
|
+ int j;
|
|
|
+ for (j = 0; j <= i; j++) {
|
|
|
+ SDL_UnlockMutex(streams[j]->lock);
|
|
|
+ }
|
|
|
+ break;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- SDL_CalculateAudioSpec(obtained); /* recalc after possible changes. */
|
|
|
-
|
|
|
- device->callbackspec = *obtained;
|
|
|
+ if (retval == 0) {
|
|
|
+ /* Now that everything is verified, chain everything together. */
|
|
|
+ for (i = 0; i < num_streams; i++) {
|
|
|
+ SDL_AudioStream *stream = streams[i];
|
|
|
+ SDL_AudioFormat src_format, dst_format;
|
|
|
+ int src_channels, dst_channels;
|
|
|
+ int src_rate, dst_rate;
|
|
|
|
|
|
- if (build_stream) {
|
|
|
- if (iscapture) {
|
|
|
- device->stream = SDL_CreateAudioStream(device->spec.format,
|
|
|
- device->spec.channels, device->spec.freq,
|
|
|
- obtained->format, obtained->channels, obtained->freq);
|
|
|
- } else {
|
|
|
- device->stream = SDL_CreateAudioStream(obtained->format, obtained->channels,
|
|
|
- obtained->freq, device->spec.format,
|
|
|
- device->spec.channels, device->spec.freq);
|
|
|
- }
|
|
|
+ /* set the proper end of the stream to the device's format. */
|
|
|
+ SDL_GetAudioStreamFormat(stream, &src_format, &src_channels, &src_rate, &dst_format, &dst_channels, &dst_rate);
|
|
|
+ if (device->iscapture) {
|
|
|
+ SDL_SetAudioStreamFormat(stream, device->format, device->channels, device->freq, dst_format, dst_channels, dst_rate);
|
|
|
+ } else {
|
|
|
+ SDL_SetAudioStreamFormat(stream, src_format, src_channels, src_rate, device->format, device->channels, device->freq);
|
|
|
+ }
|
|
|
|
|
|
- if (!device->stream) {
|
|
|
- close_audio_device(device);
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
- return 0;
|
|
|
- }
|
|
|
- }
|
|
|
+ stream->bound_device = device;
|
|
|
+ stream->prev_binding = NULL;
|
|
|
+ stream->next_binding = device->bound_streams;
|
|
|
+ if (device->bound_streams) {
|
|
|
+ device->bound_streams->prev_binding = stream;
|
|
|
+ }
|
|
|
+ device->bound_streams = stream;
|
|
|
|
|
|
- if (device->spec.callback == NULL) { /* use buffer queueing? */
|
|
|
- /* pool a few packets to start. Enough for two callbacks. */
|
|
|
- device->buffer_queue = SDL_CreateDataQueue(SDL_AUDIOBUFFERQUEUE_PACKETLEN, obtained->size * 2);
|
|
|
- if (!device->buffer_queue) {
|
|
|
- close_audio_device(device);
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
- SDL_SetError("Couldn't create audio buffer queue");
|
|
|
- return 0;
|
|
|
+ SDL_UnlockMutex(stream->lock);
|
|
|
}
|
|
|
- device->callbackspec.callback = iscapture ? SDL_BufferQueueFillCallback : SDL_BufferQueueDrainCallback;
|
|
|
- device->callbackspec.userdata = device;
|
|
|
- }
|
|
|
-
|
|
|
- /* Allocate a scratch audio buffer */
|
|
|
- device->work_buffer_len = build_stream ? device->callbackspec.size : 0;
|
|
|
- if (device->spec.size > device->work_buffer_len) {
|
|
|
- device->work_buffer_len = device->spec.size;
|
|
|
- }
|
|
|
- SDL_assert(device->work_buffer_len > 0);
|
|
|
-
|
|
|
- device->work_buffer = (Uint8 *)SDL_malloc(device->work_buffer_len);
|
|
|
- if (device->work_buffer == NULL) {
|
|
|
- close_audio_device(device);
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
- SDL_OutOfMemory();
|
|
|
- return 0;
|
|
|
}
|
|
|
|
|
|
- open_devices[id] = device; /* add it to our list of open devices. */
|
|
|
+ SDL_UnlockMutex(device->lock);
|
|
|
|
|
|
- /* Start the audio thread if necessary */
|
|
|
- if (!current_audio.impl.ProvidesOwnCallbackThread) {
|
|
|
- /* Start the audio thread */
|
|
|
- /* !!! FIXME: we don't force the audio thread stack size here if it calls into user code, but maybe we should? */
|
|
|
- /* buffer queueing callback only needs a few bytes, so make the stack tiny. */
|
|
|
- const size_t stacksize = is_internal_thread ? 64 * 1024 : 0;
|
|
|
- char threadname[64];
|
|
|
-
|
|
|
- (void)SDL_snprintf(threadname, sizeof(threadname), "SDLAudio%c%" SDL_PRIu32, (iscapture) ? 'C' : 'P', device->id);
|
|
|
- device->thread = SDL_CreateThreadInternal(iscapture ? SDL_CaptureAudio : SDL_RunAudio, threadname, stacksize, device);
|
|
|
-
|
|
|
- if (device->thread == NULL) {
|
|
|
- close_audio_device(device);
|
|
|
- SDL_SetError("Couldn't create audio thread");
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
- return 0;
|
|
|
- }
|
|
|
- }
|
|
|
- SDL_UnlockMutex(current_audio.detectionLock);
|
|
|
-
|
|
|
- return device->id;
|
|
|
+ return retval;
|
|
|
}
|
|
|
|
|
|
-SDL_AudioDeviceID SDL_OpenAudioDevice(const char *device, int iscapture,
|
|
|
- const SDL_AudioSpec *desired, SDL_AudioSpec *obtained,
|
|
|
- int allowed_changes)
|
|
|
+int SDL_BindAudioStream(SDL_AudioDeviceID devid, SDL_AudioStream *stream)
|
|
|
{
|
|
|
- return open_audio_device(device, iscapture, desired, obtained,
|
|
|
- allowed_changes, 2);
|
|
|
+ return SDL_BindAudioStreams(devid, &stream, 1);
|
|
|
}
|
|
|
|
|
|
-SDL_AudioStatus SDL_GetAudioDeviceStatus(SDL_AudioDeviceID devid)
|
|
|
+void SDL_UnbindAudioStreams(SDL_AudioStream **streams, int num_streams)
|
|
|
{
|
|
|
- SDL_AudioDevice *device = get_audio_device(devid);
|
|
|
- SDL_AudioStatus status = SDL_AUDIO_STOPPED;
|
|
|
- if (device && SDL_AtomicGet(&device->enabled)) {
|
|
|
- if (SDL_AtomicGet(&device->paused)) {
|
|
|
- status = SDL_AUDIO_PAUSED;
|
|
|
- } else {
|
|
|
- status = SDL_AUDIO_PLAYING;
|
|
|
+ int i;
|
|
|
+
|
|
|
+ /* to prevent deadlock when holding both locks, we _must_ lock the device first, and the stream second, as that is the order the audio thread will do it.
|
|
|
+ But this means we have an unlikely, pathological case where a stream could change its binding between when we lookup its bound device and when we lock everything,
|
|
|
+ so we double-check here. */
|
|
|
+ for (i = 0; i < num_streams; i++) {
|
|
|
+ SDL_AudioStream *stream = streams[i];
|
|
|
+ if (!stream) {
|
|
|
+ continue; /* nothing to do, it's a NULL stream. */
|
|
|
}
|
|
|
- }
|
|
|
- return status;
|
|
|
-}
|
|
|
|
|
|
-int SDL_PauseAudioDevice(SDL_AudioDeviceID devid)
|
|
|
-{
|
|
|
- SDL_AudioDevice *device = get_audio_device(devid);
|
|
|
- if (!device) {
|
|
|
- return SDL_InvalidParamError("devid");
|
|
|
- }
|
|
|
- current_audio.impl.LockDevice(device);
|
|
|
- SDL_AtomicSet(&device->paused, 1);
|
|
|
- current_audio.impl.UnlockDevice(device);
|
|
|
- return 0;
|
|
|
-}
|
|
|
+ while (SDL_TRUE) {
|
|
|
+ SDL_AudioDevice *bounddev;
|
|
|
|
|
|
-int SDL_PlayAudioDevice(SDL_AudioDeviceID devid)
|
|
|
-{
|
|
|
- SDL_AudioDevice *device = get_audio_device(devid);
|
|
|
- if (!device) {
|
|
|
- return SDL_InvalidParamError("devid");
|
|
|
+ SDL_LockMutex(stream->lock); /* lock to check this and then release it, in case the device isn't locked yet. */
|
|
|
+ bounddev = stream->bound_device;
|
|
|
+ SDL_UnlockMutex(stream->lock);
|
|
|
+
|
|
|
+ /* lock in correct order. */
|
|
|
+ if (bounddev) {
|
|
|
+ SDL_LockMutex(bounddev->lock); /* this requires recursive mutexes, since we're likely locking the same device multiple times. */
|
|
|
+ }
|
|
|
+ SDL_LockMutex(stream->lock);
|
|
|
+
|
|
|
+ if (bounddev == stream->bound_device) {
|
|
|
+ break; /* the binding didn't change in the small window where it could, so we're good. */
|
|
|
+ } else {
|
|
|
+ SDL_UnlockMutex(stream->lock); /* it changed bindings! Try again. */
|
|
|
+ if (bounddev) {
|
|
|
+ SDL_UnlockMutex(bounddev->lock);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
}
|
|
|
- current_audio.impl.LockDevice(device);
|
|
|
- SDL_AtomicSet(&device->paused, 0);
|
|
|
- current_audio.impl.UnlockDevice(device);
|
|
|
- return 0;
|
|
|
-}
|
|
|
|
|
|
-int SDL_LockAudioDevice(SDL_AudioDeviceID devid)
|
|
|
-{
|
|
|
- /* Obtain a lock on the mixing buffers */
|
|
|
- SDL_AudioDevice *device = get_audio_device(devid);
|
|
|
- if (!device) {
|
|
|
- return SDL_InvalidParamError("devid");
|
|
|
+ /* everything is locked, start unbinding streams. */
|
|
|
+ for (i = 0; i < num_streams; i++) {
|
|
|
+ SDL_AudioStream *stream = streams[i];
|
|
|
+ if (stream && stream->bound_device) {
|
|
|
+ if (stream->bound_device->bound_streams == stream) {
|
|
|
+ SDL_assert(stream->prev_binding == NULL);
|
|
|
+ stream->bound_device->bound_streams = stream->next_binding;
|
|
|
+ }
|
|
|
+ if (stream->prev_binding) {
|
|
|
+ stream->prev_binding->next_binding = stream->next_binding;
|
|
|
+ }
|
|
|
+ if (stream->next_binding) {
|
|
|
+ stream->next_binding->prev_binding = stream->prev_binding;
|
|
|
+ }
|
|
|
+ stream->prev_binding = stream->next_binding = NULL;
|
|
|
+ }
|
|
|
}
|
|
|
- current_audio.impl.LockDevice(device);
|
|
|
- return 0;
|
|
|
-}
|
|
|
|
|
|
-void SDL_UnlockAudioDevice(SDL_AudioDeviceID devid)
|
|
|
-{
|
|
|
- /* Obtain a lock on the mixing buffers */
|
|
|
- SDL_AudioDevice *device = get_audio_device(devid);
|
|
|
- if (!device) {
|
|
|
- return;
|
|
|
+ /* Finalize and unlock everything. */
|
|
|
+ for (i = 0; i < num_streams; i++) {
|
|
|
+ SDL_AudioStream *stream = streams[i];
|
|
|
+ if (stream && stream->bound_device) {
|
|
|
+ SDL_AudioDevice *dev = stream->bound_device;
|
|
|
+ stream->bound_device = NULL;
|
|
|
+ SDL_UnlockMutex(stream->lock);
|
|
|
+ if (dev) {
|
|
|
+ SDL_UnlockMutex(dev->lock);
|
|
|
+ }
|
|
|
+ }
|
|
|
}
|
|
|
- current_audio.impl.UnlockDevice(device);
|
|
|
}
|
|
|
|
|
|
-void SDL_CloseAudioDevice(SDL_AudioDeviceID devid)
|
|
|
+void SDL_UnbindAudioStream(SDL_AudioStream *stream)
|
|
|
{
|
|
|
- SDL_AudioDevice *device = get_audio_device(devid);
|
|
|
- if (!device) {
|
|
|
- return;
|
|
|
- }
|
|
|
- close_audio_device(device);
|
|
|
+ SDL_UnbindAudioStreams(&stream, 1);
|
|
|
}
|
|
|
|
|
|
-void SDL_QuitAudio(void)
|
|
|
-{
|
|
|
- SDL_AudioDeviceID i;
|
|
|
|
|
|
- if (!current_audio.name) { /* not initialized?! */
|
|
|
- return;
|
|
|
- }
|
|
|
+SDL_AudioStream *SDL_CreateAndBindAudioStream(SDL_AudioDeviceID devid, SDL_AudioFormat fmt, int channels, int freq)
|
|
|
+{
|
|
|
+ SDL_AudioStream *stream = NULL;
|
|
|
+ SDL_AudioDevice *device = ObtainAudioDevice(devid);
|
|
|
+ if (device) {
|
|
|
+ const SDL_bool iscapture = (devid & 1) ? SDL_FALSE : SDL_TRUE; /* capture instance ids are even and output devices are odd */
|
|
|
+ if (iscapture) {
|
|
|
+ stream = SDL_CreateAudioStream(device->format, device->channels, device->freq, fmt, channels, freq);
|
|
|
+ } else {
|
|
|
+ stream = SDL_CreateAudioStream(fmt, channels, freq, device->format, device->channels, device->freq);
|
|
|
+ }
|
|
|
|
|
|
- for (i = 0; i < SDL_arraysize(open_devices); i++) {
|
|
|
- close_audio_device(open_devices[i]);
|
|
|
+ if (stream) {
|
|
|
+ if (SDL_BindAudioStream(devid, stream) == -1) {
|
|
|
+ SDL_DestroyAudioStream(stream);
|
|
|
+ stream = NULL;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ SDL_UnlockMutex(device->lock);
|
|
|
}
|
|
|
-
|
|
|
- free_device_list(¤t_audio.outputDevices, ¤t_audio.outputDeviceCount);
|
|
|
- free_device_list(¤t_audio.inputDevices, ¤t_audio.inputDeviceCount);
|
|
|
-
|
|
|
- /* Free the driver data */
|
|
|
- current_audio.impl.Deinitialize();
|
|
|
-
|
|
|
- SDL_DestroyMutex(current_audio.detectionLock);
|
|
|
-
|
|
|
- SDL_zero(current_audio);
|
|
|
- SDL_zeroa(open_devices);
|
|
|
+ return stream;
|
|
|
}
|
|
|
|
|
|
#define NUM_FORMATS 8
|
|
|
@@ -1515,69 +1282,8 @@ const SDL_AudioFormat *SDL_ClosestAudioFormats(SDL_AudioFormat format)
|
|
|
return &format_list[0][NUM_FORMATS]; /* not found; return what looks like a list with only a zero in it. */
|
|
|
}
|
|
|
|
|
|
-Uint8 SDL_GetSilenceValueForFormat(const SDL_AudioFormat format)
|
|
|
+int SDL_GetSilenceValueForFormat(SDL_AudioFormat format)
|
|
|
{
|
|
|
return (format == SDL_AUDIO_U8) ? 0x80 : 0x00;
|
|
|
}
|
|
|
|
|
|
-void SDL_CalculateAudioSpec(SDL_AudioSpec *spec)
|
|
|
-{
|
|
|
- spec->silence = SDL_GetSilenceValueForFormat(spec->format);
|
|
|
- spec->size = SDL_AUDIO_BITSIZE(spec->format) / 8;
|
|
|
- spec->size *= spec->channels;
|
|
|
- spec->size *= spec->samples;
|
|
|
-}
|
|
|
-
|
|
|
-/* !!! FIXME: move this to SDL_audiocvt.c */
|
|
|
-int SDL_ConvertAudioSamples(SDL_AudioFormat src_format, Uint8 src_channels, int src_rate, const Uint8 *src_data, int src_len,
|
|
|
- SDL_AudioFormat dst_format, Uint8 dst_channels, int dst_rate, Uint8 **dst_data, int *dst_len)
|
|
|
-{
|
|
|
- int ret = -1;
|
|
|
- SDL_AudioStream *stream = NULL;
|
|
|
- Uint8 *dst = NULL;
|
|
|
- int dstlen = 0;
|
|
|
-
|
|
|
- if (dst_data) {
|
|
|
- *dst_data = NULL;
|
|
|
- }
|
|
|
-
|
|
|
- if (dst_len) {
|
|
|
- *dst_len = 0;
|
|
|
- }
|
|
|
-
|
|
|
- if (src_data == NULL) {
|
|
|
- return SDL_InvalidParamError("src_data");
|
|
|
- } else if (src_len < 0) {
|
|
|
- return SDL_InvalidParamError("src_len");
|
|
|
- } else if (dst_data == NULL) {
|
|
|
- return SDL_InvalidParamError("dst_data");
|
|
|
- } else if (dst_len == NULL) {
|
|
|
- return SDL_InvalidParamError("dst_len");
|
|
|
- }
|
|
|
-
|
|
|
- stream = SDL_CreateAudioStream(src_format, src_channels, src_rate, dst_format, dst_channels, dst_rate);
|
|
|
- if (stream != NULL) {
|
|
|
- if ((SDL_PutAudioStreamData(stream, src_data, src_len) == 0) && (SDL_FlushAudioStream(stream) == 0)) {
|
|
|
- dstlen = SDL_GetAudioStreamAvailable(stream);
|
|
|
- if (dstlen >= 0) {
|
|
|
- dst = (Uint8 *)SDL_malloc(dstlen);
|
|
|
- if (!dst) {
|
|
|
- SDL_OutOfMemory();
|
|
|
- } else {
|
|
|
- ret = (SDL_GetAudioStreamData(stream, dst, dstlen) >= 0) ? 0 : -1;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (ret == -1) {
|
|
|
- SDL_free(dst);
|
|
|
- } else {
|
|
|
- *dst_data = dst;
|
|
|
- *dst_len = dstlen;
|
|
|
- }
|
|
|
-
|
|
|
- SDL_DestroyAudioStream(stream);
|
|
|
- return ret;
|
|
|
-}
|
|
|
-
|
Ryan C. Gordon