audio: First shot at the SDL3 audio subsystem redesign!

This is a work in progress! (and this commit will probably get
force-pushed over at some point).

CMakeLists.txt

@@ -353,6 +353,12 @@ set_option(SDL_CLANG_TIDY          "Run clang-tidy static analysis" OFF)
 
 set(SDL_VENDOR_INFO "" CACHE STRING "Vendor name and/or version to add to SDL_REVISION")
 
+set(SDL_OSS OFF)
+set(SDL_ALSA OFF)
+set(SDL_JACK OFF)
+set(SDL_PIPEWIRE OFF)
+set(SDL_SNDIO OFF)
+
 cmake_dependent_option(SDL_SHARED "Build a shared version of the library" ${SDL_SHARED_DEFAULT} ${SDL_SHARED_AVAILABLE} OFF)
 option(SDL_STATIC "Build a static version of the library" ${SDL_STATIC_DEFAULT})
 option(SDL_TEST_LIBRARY   "Build the SDL3_test library" ON)

docs/README-migration.md

@@ -53,13 +53,100 @@ The following structures have been renamed:
 
 ## SDL_audio.h
 
+The audio subsystem in SDL3 is dramatically different than SDL2. There is no longer an audio callback; instead you bind SDL_AudioStreams to devices.
+
+The SDL 1.2 audio compatibility API has also been removed, as it was a simplified version of the audio callback interface.
+
+If your app depends on the callback method, you can use the single-header library at https://github.com/libsdl-org/SDL3_audio_callback (to be written!) to simulate it on top of SDL3's new API.
+
+In SDL2, you might have done something like this to play audio:
+
+```c
+    void SDLCALL MyAudioCallback(void *userdata, Uint8 * stream, int len)
+    {
+        /* calculate a little more audio here, maybe using `userdata`, write it to `stream` */
+    }
+
+    /* ...somewhere near startup... */
+    SDL_AudioSpec my_desired_audio_format;
+    SDL_zero(my_desired_audio_format);
+    my_desired_audio_format.format = AUDIO_S16;
+    my_desired_audio_format.channels = 2;
+    my_desired_audio_format.freq = 44100;
+    my_desired_audio_format.samples = 1024;
+    my_desired_audio_format.callback = MyAudioCallback;
+    my_desired_audio_format.userdata = &my_audio_callback_user_data;
+    SDL_AudioDeviceID my_audio_device = SDL_OpenAudioDevice(NULL, 0, &my_desired_audio_format, NULL, 0);
+    SDL_PauseAudioDevice(my_audio_device, 0);
+```
+
+in SDL3:
+
+```c
+    /* ...somewhere near startup... */
+    my_desired_audio_format.callback = MyAudioCallback;  /* etc */
+    SDL_AudioDeviceID my_audio_device = SDL_OpenAudioDevice(0, SDL_AUDIO_S16, 2, 44100);
+    SDL_AudioSteam *stream = SDL_CreateAndBindAudioStream(my_audio_device, SDL_AUDIO_S16, 2, 44100);
+
+    /* ...in your main loop... */
+    /* calculate a little more audio into `buf`, add it to `stream` */
+    SDL_PutAudioStreamData(stream, buf, buflen);
+```
+
 SDL_AudioInit() and SDL_AudioQuit() have been removed. Instead you can call SDL_InitSubSystem() and SDL_QuitSubSystem() with SDL_INIT_AUDIO, which will properly refcount the subsystems. You can choose a specific audio driver using SDL_AUDIO_DRIVER hint.
 
-SDL_PauseAudioDevice() is only used to pause audio playback. Use SDL_PlayAudioDevice() to start playing audio.
+The `SDL_AUDIO_ALLOW_*` symbols have been removed; now one may request the format they desire from the audio device, but ultimately SDL_AudioStream will manage the difference. One can use SDL_GetAudioDeviceFormat() to see what the final format is, if any "allowed" changes should be accomodated by the app.
+
+SDL_AudioDeviceID no longer represents an open audio device's handle, it's now the device's instance ID that the device owns as long as it exists on the system. The separation between device instances and device indexes is gone.
+
+Devices are opened by device instance ID, and a new handle is not generated by the open operation; instead, opens of the same device instance are reference counted. This allows any device to be opened multiple times, possibly by unrelated pieces of code.
+
+Devices are not opened by an arbitrary string name anymore, but by device instance ID (or 0 to request a reasonable default, like a NULL string in SDL2). In SDL2, the string was used to open both a standard list of system devices, but also allowed for arbitrary devices, such as hostnames of network sound servers. In SDL3, many of the backends that supported arbitrary device names are obsolete and have been removed; of those that remain, arbitrary devices will be opened with a device ID of 0 and an SDL_hint, so specific end-users can set an environment variable to fit their needs and apps don't have to concern themselves with it.
+
+Many functions that would accept a device index and an `iscapture` parameter now just take an SDL_AudioDeviceID, as they are unique across all devices, instead of separate indices into output and capture device lists.
+
+Rather than iterating over audio devices using a device index, there is a new function, SDL_GetAudioDevices(), to get the current list of devices, and new functions to get information about devices from their instance ID:
+
+```c
+{
+    if (SDL_InitSubSystem(SDL_INIT_AUDIO) == 0) {
+        int i, num_devices;
+        SDL_AudioDeviceID *devices = SDL_GetAudioDevices(/*iscapture=*/SDL_FALSE, &num_devices);
+        if (devices) {
+            for (i = 0; i < num_devices; ++i) {
+                SDL_AudioDeviceID instance_id = devices[i];
+                char *name = SDL_GetAudioDeviceName(instance_id);
+                SDL_Log("AudioDevice %" SDL_PRIu32 ": %s\n", instance_id, name);
+                SDL_free(name);
+            }
+            SDL_free(devices);
+        }
+        SDL_QuitSubSystem(SDL_INIT_AUDIO);
+    }
+}
+```
+
+SDL_LockAudioDevice() and SDL_UnlockAudioDevice() have been removed, since there is no callback in another thread to protect. Internally, SDL's audio subsystem and SDL_AudioStream maintain their own locks internally, so audio streams are safe to use from any thread.
+
+SDL_PauseAudioDevice() has been removed; unbinding an audio stream from a device with SDL_UnbindAudioStream() will leave the stream still containing any unconsumed data, effectively pausing it until rebound with SDL_BindAudioStream() again. Devices act like they are "paused" after open, like SDL2, until a stream is bound to it.
+
+SDL_GetAudioDeviceStatus() has been removed; there is no more concept of "pausing" a device, just whether streams are bound, so please keep track of your audio streams!
+
+SDL_QueueAudio(), SDL_DequeueAudio, and SDL_ClearQueuedAudio and SDL_GetQueuedAudioSize() have been removed; an SDL_AudioStream bound to a device provides the exact same functionality.
+
+APIs that use channel counts used to use a Uint8 for the channel; now they use int.
+
+SDL_AudioSpec has been removed; things that used it have simply started taking separate arguments for format, channel, and sample rate. SDL_GetSilenceValueForFormat() can provide the information from the SDL_AudioSpec's `silence` field. The other SDL_AudioSpec fields aren't relevant anymore.
+
+SDL_GetAudioDeviceSpec() is removed; use SDL_GetAudioDeviceFormat() instead.
+
+SDL_MixAudio() has been removed, as it relied on legacy SDL 1.2 quirks; SDL_MixAudioFormat() remains and offers the same functionality.
+
+SDL_AudioInit() and SDL_AudioQuit() have been removed. Instead you can call SDL_InitSubSystem() and SDL_QuitSubSystem() with SDL_INIT_AUDIO, which will properly refcount the subsystems. You can choose a specific audio driver using SDL_AUDIO_DRIVER hint.
 
 SDL_FreeWAV has been removed and calls can be replaced with SDL_free.
 
-SDL_AudioCVT interface is removed, SDL_AudioStream interface or SDL_ConvertAudioSamples() helper function can be used.
+SDL_AudioCVT interface has been removed, the SDL_AudioStream interface (for audio supplied in pieces) or the new SDL_ConvertAudioSamples() function (for converting a complete audio buffer in one call) can be used instead.
 
 Code that used to look like this:
 ```c
@@ -103,6 +190,8 @@ If you need to convert U16 audio data to a still-supported format at runtime, th
     }
 ```
 
+All remaining `AUDIO_*` symbols have been renamed to `SDL_AUDIO_*` for API consistency, but othewise are identical in value and usage.
+
 In SDL2, SDL_AudioStream would convert/resample audio data during input (via SDL_AudioStreamPut). In SDL3, it does this work when requesting audio (via SDL_GetAudioStreamData, which would have been SDL_AudioStreamPut in SDL2. The way you use an AudioStream is roughly the same, just be aware that the workload moved to a different phase.
 In SDL2, SDL_AudioStreamAvailable() returns 0 if passed a NULL stream. In SDL3, the equivalent SDL_GetAudioStreamAvailable() call returns -1 and sets an error string, which matches other audiostream APIs' behavior.
 
@@ -118,17 +207,25 @@ The following functions have been renamed:
 
 
 The following functions have been removed:
+* SDL_GetNumAudioDevices()
+* SDL_GetAudioDeviceSpec()
 * SDL_ConvertAudio()
 * SDL_BuildAudioCVT()
 * SDL_OpenAudio()
 * SDL_CloseAudio()
 * SDL_PauseAudio()
+* SDL_PauseAudioDevice
 * SDL_GetAudioStatus()
+* SDL_GetAudioDeviceStatus()
 * SDL_LockAudio()
+* SDL_LockAudioDevice()
 * SDL_UnlockAudio()
+* SDL_UnlockAudioDevice()
 * SDL_MixAudio()
-
-Use the SDL_AudioDevice functions instead.
+* SDL_QueueAudio()
+* SDL_DequeueAudio()
+* SDL_ClearAudioQueue()
+* SDL_GetQueuedAudioSize()
 
 The following symbols have been renamed:
 * AUDIO_F32 => SDL_AUDIO_F32

include/SDL3/SDL_test_common.h

@@ -97,7 +97,9 @@ typedef struct
 
     /* Audio info */
     const char *audiodriver;
-    SDL_AudioSpec audiospec;
+    SDL_AudioFormat audio_format;
+    int audio_channels;
+    int audio_freq;
     SDL_AudioDeviceID audio_id;
 
     /* GL settings */

src/audio/SDL_audio_c.h

@@ -22,59 +22,8 @@
 #ifndef SDL_audio_c_h_
 #define SDL_audio_c_h_
 
-#include "SDL_internal.h"
+/* !!! FIXME: remove this header and have things just include SDL_sysaudio.h directly. */
 
-#define DEBUG_AUDIOSTREAM 0
-#define DEBUG_AUDIO_CONVERT 0
-
-#if DEBUG_AUDIO_CONVERT
-#define LOG_DEBUG_AUDIO_CONVERT(from, to) SDL_Log("SDL_AUDIO_CONVERT: Converting %s to %s.\n", from, to);
-#else
-#define LOG_DEBUG_AUDIO_CONVERT(from, to)
-#endif
-
-/* Functions and variables exported from SDL_audio.c for SDL_sysaudio.c */
-
-/* Function to get a list of audio formats, ordered most similar to `format` to least, 0-terminated. Don't free results. */
-const SDL_AudioFormat *SDL_ClosestAudioFormats(SDL_AudioFormat format);
-
-/* Function to calculate the size and silence for a SDL_AudioSpec */
-extern Uint8 SDL_GetSilenceValueForFormat(const SDL_AudioFormat format);
-extern void SDL_CalculateAudioSpec(SDL_AudioSpec *spec);
-
-/* Must be called at least once before using converters (SDL_CreateAudioStream will call it). */
-extern void SDL_ChooseAudioConverters(void);
-
-/* These pointers get set during SDL_ChooseAudioConverters() to various SIMD implementations. */
-extern void (*SDL_Convert_S8_to_F32)(float *dst, const Sint8 *src, int num_samples);
-extern void (*SDL_Convert_U8_to_F32)(float *dst, const Uint8 *src, int num_samples);
-extern void (*SDL_Convert_S16_to_F32)(float *dst, const Sint16 *src, int num_samples);
-extern void (*SDL_Convert_S32_to_F32)(float *dst, const Sint32 *src, int num_samples);
-extern void (*SDL_Convert_F32_to_S8)(Sint8 *dst, const float *src, int num_samples);
-extern void (*SDL_Convert_F32_to_U8)(Uint8 *dst, const float *src, int num_samples);
-extern void (*SDL_Convert_F32_to_S16)(Sint16 *dst, const float *src, int num_samples);
-extern void (*SDL_Convert_F32_to_S32)(Sint32 *dst, const float *src, int num_samples);
-
-/**
- * Use this function to initialize a particular audio driver.
- *
- * This function is used internally, and should not be used unless you have a
- * specific need to designate the audio driver you want to use. You should
- * normally use SDL_Init() or SDL_InitSubSystem().
- *
- * \param driver_name the name of the desired audio driver
- * \returns 0 on success or a negative error code on failure; call
- *          SDL_GetError() for more information.
- */
-extern int SDL_InitAudio(const char *driver_name);
-
-/**
- * Use this function to shut down audio if you initialized it with SDL_InitAudio().
- *
- * This function is used internally, and should not be used unless you have a
- * specific need to specify the audio driver you want to use. You should
- * normally use SDL_Quit() or SDL_QuitSubSystem().
- */
-extern void SDL_QuitAudio(void);
+#include "SDL_sysaudio.h"
 
 #endif /* SDL_audio_c_h_ */

src/audio/SDL_audiocvt.c

@@ -434,49 +434,6 @@ static void ConvertAudio(int num_frames, const void *src, SDL_AudioFormat src_fo
     SDL_assert(src == dst);  /* if we got here, we _had_ to have done _something_. Otherwise, we should have memcpy'd! */
 }
 
-struct SDL_AudioStream
-{
-    SDL_DataQueue *queue;
-    SDL_Mutex *lock;  /* this is just a copy of `queue`'s mutex. We share a lock. */
-
-    Uint8 *work_buffer;    /* used for scratch space during data conversion/resampling. */
-    Uint8 *history_buffer;  /* history for left padding and future sample rate changes. */
-    Uint8 *future_buffer;  /* stuff that left the queue for the right padding and will be next read's data. */
-    float *left_padding;  /* left padding for resampling. */
-    float *right_padding;  /* right padding for resampling. */
-
-    SDL_bool flushed;
-
-    size_t work_buffer_allocation;
-    size_t history_buffer_allocation;
-    size_t future_buffer_allocation;
-    size_t resampler_padding_allocation;
-
-    int resampler_padding_frames;
-    int history_buffer_frames;
-    int future_buffer_filled_frames;
-
-    int max_sample_frame_size;
-
-    int src_sample_frame_size;
-    SDL_AudioFormat src_format;
-    int src_channels;
-    int src_rate;
-
-    int dst_sample_frame_size;
-    SDL_AudioFormat dst_format;
-    int dst_channels;
-    int dst_rate;
-
-    int pre_resample_channels;
-    int packetlen;
-};
-
-static int GetMemsetSilenceValue(const SDL_AudioFormat fmt)
-{
-    return (fmt == SDL_AUDIO_U8) ? 0x80 : 0x00;
-}
-
 /* figure out the largest thing we might need for ConvertAudio, which might grow data in-place. */
 static int CalculateMaxSampleFrameSize(SDL_AudioFormat src_format, int src_channels, SDL_AudioFormat dst_format, int dst_channels)
 {
@@ -560,7 +517,7 @@ static int SetAudioStreamFormat(SDL_AudioStream *stream, SDL_AudioFormat src_for
     if (stream->future_buffer) {
         ConvertAudio(stream->future_buffer_filled_frames, stream->future_buffer, stream->src_format, stream->src_channels, future_buffer, src_format, src_channels);
     } else if (future_buffer != NULL) {
-        SDL_memset(future_buffer, GetMemsetSilenceValue(src_format), future_buffer_allocation);
+        SDL_memset(future_buffer, SDL_GetSilenceValueForFormat(src_format), future_buffer_allocation);
     }
 
     if (stream->history_buffer) {
@@ -568,10 +525,10 @@ static int SetAudioStreamFormat(SDL_AudioStream *stream, SDL_AudioFormat src_for
             ConvertAudio(history_buffer_frames, stream->history_buffer, stream->src_format, stream->src_channels, history_buffer, src_format, src_channels);
         } else {
             ConvertAudio(prev_history_buffer_frames, stream->history_buffer, stream->src_format, stream->src_channels, history_buffer + ((history_buffer_frames - prev_history_buffer_frames) * src_sample_frame_size), src_format, src_channels);
-            SDL_memset(history_buffer, GetMemsetSilenceValue(src_format), (history_buffer_frames - prev_history_buffer_frames) * src_sample_frame_size);  /* silence oldest history samples. */
+            SDL_memset(history_buffer, SDL_GetSilenceValueForFormat(src_format), (history_buffer_frames - prev_history_buffer_frames) * src_sample_frame_size);  /* silence oldest history samples. */
         }
     } else if (history_buffer != NULL) {
-        SDL_memset(history_buffer, GetMemsetSilenceValue(src_format), history_buffer_allocation);
+        SDL_memset(history_buffer, SDL_GetSilenceValueForFormat(src_format), history_buffer_allocation);
     }
 
     if (future_buffer != stream->future_buffer) {
@@ -612,6 +569,8 @@ SDL_AudioStream *SDL_CreateAudioStream(SDL_AudioFormat src_format,
     int packetlen = 4096; /* !!! FIXME: good enough for now. */
     SDL_AudioStream *retval;
 
+    /* !!! FIXME: fail if audio isn't initialized? */
+
     if (!SDL_IsSupportedChannelCount(src_channels)) {
         SDL_InvalidParamError("src_channels");
         return NULL;
@@ -917,7 +876,7 @@ static int GetAudioStreamDataInternal(SDL_AudioStream *stream, void *buf, int le
         stream->future_buffer_filled_frames = future_buffer_filled_frames;
         if (br < cpy) {  /* we couldn't fill the future buffer with enough padding! */
             if (stream->flushed) {  /* that's okay, we're flushing, just silence the still-needed padding. */
-                SDL_memset(future_buffer + (future_buffer_filled_frames * src_sample_frame_size), GetMemsetSilenceValue(src_format), cpy - br);
+                SDL_memset(future_buffer + (future_buffer_filled_frames * src_sample_frame_size), SDL_GetSilenceValueForFormat(src_format), cpy - br);
             } else {  /* Drastic measures: steal from the work buffer! */
                 const int stealcpyframes = SDL_min(workbuf_frames, cpyframes - brframes);
                 const int stealcpy = stealcpyframes * src_sample_frame_size;
@@ -1100,7 +1059,7 @@ int SDL_ClearAudioStream(SDL_AudioStream *stream)
 
     SDL_LockMutex(stream->lock);
     SDL_ClearDataQueue(stream->queue, (size_t)stream->packetlen * 2);
-    SDL_memset(stream->history_buffer, GetMemsetSilenceValue(stream->src_format), stream->history_buffer_frames * stream->src_channels * sizeof (float));
+    SDL_memset(stream->history_buffer, SDL_GetSilenceValueForFormat(stream->src_format), stream->history_buffer_frames * stream->src_channels * sizeof (float));
     stream->future_buffer_filled_frames = 0;
     stream->flushed = SDL_FALSE;
     SDL_UnlockMutex(stream->lock);
@@ -1110,6 +1069,7 @@ int SDL_ClearAudioStream(SDL_AudioStream *stream)
 void SDL_DestroyAudioStream(SDL_AudioStream *stream)
 {
     if (stream) {
+        SDL_UnbindAudioStream(stream);
         /* do not destroy stream->lock! it's a copy of `stream->queue`'s mutex, so destroying the queue will handle it. */
         SDL_DestroyDataQueue(stream->queue);
         SDL_aligned_free(stream->work_buffer);
@@ -1120,3 +1080,56 @@ void SDL_DestroyAudioStream(SDL_AudioStream *stream)
         SDL_free(stream);
     }
 }
+
+int SDL_ConvertAudioSamples(SDL_AudioFormat src_format, int src_channels, int src_rate, const Uint8 *src_data, int src_len,
+                            SDL_AudioFormat dst_format, int 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;
+}
+

src/audio/SDL_audiodev.c

@@ -63,7 +63,7 @@ static void test_device(const int iscapture, const char *fname, int flags, int (
                  * information,  making this information inaccessible at
                  * enumeration time
                  */
-                SDL_AddAudioDevice(iscapture, fname, NULL, (void *)(uintptr_t)dummyhandle);
+                SDL_AddAudioDevice(iscapture, fname, 0, 0, 0, (void *)(uintptr_t)dummyhandle, );
             }
         }
     }

src/audio/SDL_sysaudio.h

@@ -24,60 +24,90 @@
 #define SDL_sysaudio_h_
 
 #include "../SDL_dataqueue.h"
-#include "./SDL_audio_c.h"
+
+#define DEBUG_AUDIOSTREAM 0
+#define DEBUG_AUDIO_CONVERT 0
+
+#if DEBUG_AUDIO_CONVERT
+#define LOG_DEBUG_AUDIO_CONVERT(from, to) SDL_Log("SDL_AUDIO_CONVERT: Converting %s to %s.\n", from, to);
+#else
+#define LOG_DEBUG_AUDIO_CONVERT(from, to)
+#endif
+
+/* These pointers get set during SDL_ChooseAudioConverters() to various SIMD implementations. */
+extern void (*SDL_Convert_S8_to_F32)(float *dst, const Sint8 *src, int num_samples);
+extern void (*SDL_Convert_U8_to_F32)(float *dst, const Uint8 *src, int num_samples);
+extern void (*SDL_Convert_S16_to_F32)(float *dst, const Sint16 *src, int num_samples);
+extern void (*SDL_Convert_S32_to_F32)(float *dst, const Sint32 *src, int num_samples);
+extern void (*SDL_Convert_F32_to_S8)(Sint8 *dst, const float *src, int num_samples);
+extern void (*SDL_Convert_F32_to_U8)(Uint8 *dst, const float *src, int num_samples);
+extern void (*SDL_Convert_F32_to_S16)(Sint16 *dst, const float *src, int num_samples);
+extern void (*SDL_Convert_F32_to_S32)(Sint32 *dst, const float *src, int num_samples);
+
 
 /* !!! FIXME: These are wordy and unlocalized... */
 #define DEFAULT_OUTPUT_DEVNAME "System audio output device"
 #define DEFAULT_INPUT_DEVNAME  "System audio capture device"
 
+/* these are used when no better specifics are known. We default to CD audio quality. */
+#define DEFAULT_AUDIO_FORMAT SDL_AUDIO_S16
+#define DEFAULT_AUDIO_CHANNELS 2
+#define DEFAULT_AUDIO_FREQUENCY 44100
+
+
 /* The SDL audio driver */
 typedef struct SDL_AudioDevice SDL_AudioDevice;
 
+/* Used by src/SDL.c to initialize a particular audio driver. */
+extern int SDL_InitAudio(const char *driver_name);
+
+/* Used by src/SDL.c to shut down previously-initialized audio. */
+extern void SDL_QuitAudio(void);
+
+/* Function to get a list of audio formats, ordered most similar to `format` to least, 0-terminated. Don't free results. */
+const SDL_AudioFormat *SDL_ClosestAudioFormats(SDL_AudioFormat format);
+
+/* Must be called at least once before using converters (SDL_CreateAudioStream will call it !!! FIXME but probably shouldn't). */
+extern void SDL_ChooseAudioConverters(void);
+
 /* Audio targets should call this as devices are added to the system (such as
    a USB headset being plugged in), and should also be called for
    for every device found during DetectDevices(). */
-extern void SDL_AddAudioDevice(const SDL_bool iscapture, const char *name, SDL_AudioSpec *spec, void *handle);
-
-/* Audio targets should call this as devices are removed, so SDL can update
-   its list of available devices. */
-extern void SDL_RemoveAudioDevice(const SDL_bool iscapture, void *handle);
-
-/* Audio targets should call this if an opened audio device is lost while
-   being used. This can happen due to i/o errors, or a device being unplugged,
-   etc. If the device is totally gone, please also call SDL_RemoveAudioDevice()
-   as appropriate so SDL's list of devices is accurate. */
-extern void SDL_OpenedAudioDeviceDisconnected(SDL_AudioDevice *device);
-
-/* This is the size of a packet when using SDL_QueueAudio(). We allocate
-   these as necessary and pool them, under the assumption that we'll
-   eventually end up with a handful that keep recycling, meeting whatever
-   the app needs. We keep packing data tightly as more arrives to avoid
-   wasting space, and if we get a giant block of data, we'll split them
-   into multiple packets behind the scenes. My expectation is that most
-   apps will have 2-3 of these in the pool. 8k should cover most needs, but
-   if this is crippling for some embedded system, we can #ifdef this.
-   The system preallocates enough packets for 2 callbacks' worth of data. */
-#define SDL_AUDIOBUFFERQUEUE_PACKETLEN (8 * 1024)
+extern SDL_AudioDevice *SDL_AddAudioDevice(const SDL_bool iscapture, const char *name, SDL_AudioFormat fmt, int channels, int freq, void *handle);
+
+/* Audio targets should call this if an opened audio device is lost.
+   This can happen due to i/o errors, or a device being unplugged, etc. */
+extern void SDL_AudioDeviceDisconnected(SDL_AudioDevice *device);
+
+/* Find the SDL_AudioDevice associated with the handle supplied to SDL_AddAudioDevice. NULL if not found. Locks the device! You must unlock!! */
+extern SDL_AudioDevice *SDL_ObtainAudioDeviceByHandle(void *handle);
+
+/* Backends should call this if they change the device format, channels, freq, or sample_frames to keep other state correct. */
+extern void SDL_UpdatedAudioDeviceFormat(SDL_AudioDevice *device);
+
+
+/* These functions are the heart of the audio threads. Backends can call them directly if they aren't using the SDL-provided thread. */
+extern void SDL_OutputAudioThreadSetup(SDL_AudioDevice *device);
+extern SDL_bool SDL_OutputAudioThreadIterate(SDL_AudioDevice *device);
+extern void SDL_OutputAudioThreadShutdown(SDL_AudioDevice *device);
+extern void SDL_CaptureAudioThreadSetup(SDL_AudioDevice *device);
+extern SDL_bool SDL_CaptureAudioThreadIterate(SDL_AudioDevice *device);
+extern void SDL_CaptureAudioThreadShutdown(SDL_AudioDevice *device);
 
 typedef struct SDL_AudioDriverImpl
 {
     void (*DetectDevices)(void);
-    int (*OpenDevice)(SDL_AudioDevice *_this, const char *devname);
-    void (*ThreadInit)(SDL_AudioDevice *_this);   /* Called by audio thread at start */
-    void (*ThreadDeinit)(SDL_AudioDevice *_this); /* Called by audio thread at end */
-    void (*WaitDevice)(SDL_AudioDevice *_this);
-    void (*PlayDevice)(SDL_AudioDevice *_this);
-    Uint8 *(*GetDeviceBuf)(SDL_AudioDevice *_this);
-    int (*CaptureFromDevice)(SDL_AudioDevice *_this, void *buffer, int buflen);
-    void (*FlushCapture)(SDL_AudioDevice *_this);
-    void (*CloseDevice)(SDL_AudioDevice *_this);
-    void (*LockDevice)(SDL_AudioDevice *_this);
-    void (*UnlockDevice)(SDL_AudioDevice *_this);
+    int (*OpenDevice)(SDL_AudioDevice *device);
+    void (*ThreadInit)(SDL_AudioDevice *device);   /* Called by audio thread at start */
+    void (*ThreadDeinit)(SDL_AudioDevice *device); /* Called by audio thread at end */
+    void (*WaitDevice)(SDL_AudioDevice *device);
+    void (*PlayDevice)(SDL_AudioDevice *device, int buffer_size);
+    Uint8 *(*GetDeviceBuf)(SDL_AudioDevice *device, int *buffer_size);
+    int (*CaptureFromDevice)(SDL_AudioDevice *device, void *buffer, int buflen);
+    void (*FlushCapture)(SDL_AudioDevice *device);
+    void (*CloseDevice)(SDL_AudioDevice *device);
     void (*FreeDeviceHandle)(void *handle); /**< SDL is done with handle from SDL_AddAudioDevice() */
     void (*Deinitialize)(void);
-    int (*GetDefaultAudioInfo)(char **name, SDL_AudioSpec *spec, int iscapture);
-
-    /* !!! FIXME: add pause(), so we can optimize instead of mixing silence. */
 
     /* Some flags to push duplicate code into the core and reduce #ifdefs. */
     SDL_bool ProvidesOwnCallbackThread;
@@ -88,81 +118,120 @@ typedef struct SDL_AudioDriverImpl
     SDL_bool SupportsNonPow2Samples;
 } SDL_AudioDriverImpl;
 
-typedef struct SDL_AudioDeviceItem
+typedef struct SDL_AudioDriver
 {
-    void *handle;
-    char *name;
-    char *original_name;
-    SDL_AudioSpec spec;
-    int dupenum;
-    struct SDL_AudioDeviceItem *next;
-} SDL_AudioDeviceItem;
+    const char *name;  /* The name of this audio driver */
+    const char *desc;  /* The description of this audio driver */
+    SDL_AudioDriverImpl impl; /* the backend's interface */
+    SDL_RWLock *device_list_lock;  /* A mutex for device detection */
+    SDL_AudioDevice *output_devices;  /* the list of currently-available audio output devices. */
+    SDL_AudioDevice *capture_devices;  /* the list of currently-available audio capture devices. */
+    SDL_AtomicInt output_device_count;
+    SDL_AtomicInt capture_device_count;
+    SDL_AtomicInt last_device_instance_id;  /* increments on each device add to provide unique instance IDs */
+    SDL_AtomicInt shutting_down;  /* non-zero during SDL_Quit, so we known not to accept any last-minute device hotplugs. */
+} SDL_AudioDriver;
 
-typedef struct SDL_AudioDriver
+struct SDL_AudioStream
 {
-    /* * * */
-    /* The name of this audio driver */
-    const char *name;
+    SDL_DataQueue *queue;
+    SDL_Mutex *lock;  /* this is just a copy of `queue`'s mutex. We share a lock. */
 
-    /* * * */
-    /* The description of this audio driver */
-    const char *desc;
+    Uint8 *work_buffer;    /* used for scratch space during data conversion/resampling. */
+    Uint8 *history_buffer;  /* history for left padding and future sample rate changes. */
+    Uint8 *future_buffer;  /* stuff that left the queue for the right padding and will be next read's data. */
+    float *left_padding;  /* left padding for resampling. */
+    float *right_padding;  /* right padding for resampling. */
 
-    SDL_AudioDriverImpl impl;
+    SDL_bool flushed;
 
-    /* A mutex for device detection */
-    SDL_Mutex *detectionLock;
-    SDL_bool captureDevicesRemoved;
-    SDL_bool outputDevicesRemoved;
-    int outputDeviceCount;
-    int inputDeviceCount;
-    SDL_AudioDeviceItem *outputDevices;
-    SDL_AudioDeviceItem *inputDevices;
-} SDL_AudioDriver;
+    size_t work_buffer_allocation;
+    size_t history_buffer_allocation;
+    size_t future_buffer_allocation;
+    size_t resampler_padding_allocation;
+
+    int resampler_padding_frames;
+    int history_buffer_frames;
+    int future_buffer_filled_frames;
+
+    int max_sample_frame_size;
+
+    int src_sample_frame_size;
+    SDL_AudioFormat src_format;
+    int src_channels;
+    int src_rate;
+
+    int dst_sample_frame_size;
+    SDL_AudioFormat dst_format;
+    int dst_channels;
+    int dst_rate;
+
+    int pre_resample_channels;
+    int packetlen;
+
+    SDL_AudioDevice *bound_device;
+    SDL_AudioStream *next_binding;
+    SDL_AudioStream *prev_binding;
+};
 
-/* Define the SDL audio driver structure */
 struct SDL_AudioDevice
 {
-    /* * * */
-    /* Data common to all devices */
-    SDL_AudioDeviceID id;
+    /* A mutex for locking access to this struct */
+    SDL_Mutex *lock;
+
+    /* human-readable name of the device. ("SoundBlaster Pro 16") */
+    char *name;
+
+    /* the unique instance ID of this device. */
+    SDL_AudioDeviceID instance_id;
+
+    /* a way for the backend to identify this device _when not opened_ */
+    void *handle;
 
     /* The device's current audio specification */
-    SDL_AudioSpec spec;
+    SDL_AudioFormat format;
+    int freq;
+    int channels;
+    Uint32 buffer_size;
 
-    /* The callback's expected audio specification (converted vs device's spec). */
-    SDL_AudioSpec callbackspec;
+    /* The device's default audio specification */
+    SDL_AudioFormat default_format;
+    int default_freq;
+    int default_channels;
 
-    /* Stream that converts and resamples. NULL if not needed. */
-    SDL_AudioStream *stream;
+    /* Number of sample frames the devices wants per-buffer. */
+    int sample_frames;
 
-    /* Current state flags */
-    SDL_AtomicInt shutdown; /* true if we are signaling the play thread to end. */
-    SDL_AtomicInt enabled;  /* true if device is functioning and connected. */
-    SDL_AtomicInt paused;
-    SDL_bool iscapture;
+    /* Value to use for SDL_memset to silence a buffer in this device's format */
+    int silence_value;
 
-    /* Scratch buffer used in the bridge between SDL and the user callback. */
-    Uint8 *work_buffer;
+    /* non-zero if we are signaling the audio thread to end. */
+    SDL_AtomicInt shutdown;
 
-    /* Size, in bytes, of work_buffer. */
-    Uint32 work_buffer_len;
+    /* non-zero if we want the device to be destroyed (so audio thread knows to do it on termination). */
+    SDL_AtomicInt condemned;
 
-    /* A mutex for locking the mixing buffers */
-    SDL_Mutex *mixer_lock;
+    /* SDL_TRUE if this is a capture device instead of an output device */
+    SDL_bool iscapture;
+
+    /* Scratch buffer used for mixing. */
+    Uint8 *work_buffer;
 
     /* A thread to feed the audio device */
     SDL_Thread *thread;
-    SDL_threadID threadid;
-
-    /* Queued buffers (if app not using callback). */
-    SDL_DataQueue *buffer_queue;
 
-    /* * * */
     /* Data private to this driver */
     struct SDL_PrivateAudioData *hidden;
 
-    void *handle;
+    /* Each device open increases the refcount. We actually close the system device when this hits zero again. */
+    SDL_AtomicInt refcount;
+
+    /* double-linked list of all audio streams currently bound to this device. */
+    SDL_AudioStream *bound_streams;
+
+    /* double-linked list of all devices. */
+    struct SDL_AudioDevice *prev;
+    struct SDL_AudioDevice *next;
 };
 
 typedef struct AudioBootStrap
@@ -170,7 +239,7 @@ typedef struct AudioBootStrap
     const char *name;
     const char *desc;
     SDL_bool (*init)(SDL_AudioDriverImpl *impl);
-    SDL_bool demand_only; /* 1==request explicitly, or it won't be available. */
+    SDL_bool demand_only; /* if SDL_TRUE: request explicitly, or it won't be available. */
 } AudioBootStrap;
 
 /* Not all of these are available in a given build. Use #ifdefs, etc. */
@@ -188,8 +257,8 @@ extern AudioBootStrap HAIKUAUDIO_bootstrap;
 extern AudioBootStrap COREAUDIO_bootstrap;
 extern AudioBootStrap DISKAUDIO_bootstrap;
 extern AudioBootStrap DUMMYAUDIO_bootstrap;
-extern AudioBootStrap aaudio_bootstrap;
-extern AudioBootStrap openslES_bootstrap;
+extern AudioBootStrap aaudio_bootstrap;   /* !!! FIXME: capitalize this to match the others */
+extern AudioBootStrap openslES_bootstrap;  /* !!! FIXME: capitalize this to match the others */
 extern AudioBootStrap ANDROIDAUDIO_bootstrap;
 extern AudioBootStrap PS2AUDIO_bootstrap;
 extern AudioBootStrap PSPAUDIO_bootstrap;

src/audio/SDL_wave.c

@@ -1241,7 +1241,7 @@ static int LAW_Decode(WaveFile *file, Uint8 **audio_buf, Uint32 *audio_len)
 
     dst = (Sint16 *)src;
 
-    /* Work backwards, since we're expanding in-place. SDL_AudioSpec.format will
+    /* Work backwards, since we're expanding in-place. `format` will
      * inform the caller about the byte order.
      */
     i = sample_count;
@@ -1667,15 +1667,13 @@ static int WaveCheckFormat(WaveFile *file, size_t datalength)
 
     if (format->channels == 0) {
         return SDL_SetError("Invalid number of channels");
-    } else if (format->channels > 255) {
-        /* Limit given by SDL_AudioSpec.channels. */
-        return SDL_SetError("Number of channels exceeds limit of 255");
+    } else if (format->channels > INT_MAX) {
+        return SDL_SetError("Number of channels exceeds limit of %d", INT_MAX);
     }
 
     if (format->frequency == 0) {
         return SDL_SetError("Invalid sample rate");
     } else if (format->frequency > INT_MAX) {
-        /* Limit given by SDL_AudioSpec.freq. */
         return SDL_SetError("Sample rate exceeds limit of %d", INT_MAX);
     }
 
@@ -1766,7 +1764,7 @@ static int WaveCheckFormat(WaveFile *file, size_t datalength)
     return 0;
 }
 
-static int WaveLoad(SDL_RWops *src, WaveFile *file, SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len)
+static int WaveLoad(SDL_RWops *src, WaveFile *file, SDL_AudioFormat *fmt, int *channels, int *freq, Uint8 **audio_buf, Uint32 *audio_len)
 {
     int result;
     Uint32 chunkcount = 0;
@@ -2025,13 +2023,11 @@ static int WaveLoad(SDL_RWops *src, WaveFile *file, SDL_AudioSpec *spec, Uint8 *
         break;
     }
 
-    /* Setting up the SDL_AudioSpec. All unsupported formats were filtered out
+    /* Setting up the specs. All unsupported formats were filtered out
      * by checks earlier in this function.
      */
-    SDL_zerop(spec);
-    spec->freq = format->frequency;
-    spec->channels = (Uint8)format->channels;
-    spec->samples = 4096; /* Good default buffer size */
+    *freq = format->frequency;
+    *channels = (Uint8)format->channels;
 
     switch (format->encoding) {
     case MS_ADPCM_CODE:
@@ -2039,22 +2035,22 @@ static int WaveLoad(SDL_RWops *src, WaveFile *file, SDL_AudioSpec *spec, Uint8 *
     case ALAW_CODE:
     case MULAW_CODE:
         /* These can be easily stored in the byte order of the system. */
-        spec->format = SDL_AUDIO_S16SYS;
+        *fmt = SDL_AUDIO_S16SYS;
         break;
     case IEEE_FLOAT_CODE:
-        spec->format = SDL_AUDIO_F32LSB;
+        *fmt = SDL_AUDIO_F32LSB;
         break;
     case PCM_CODE:
         switch (format->bitspersample) {
         case 8:
-            spec->format = SDL_AUDIO_U8;
+            *fmt = SDL_AUDIO_U8;
             break;
         case 16:
-            spec->format = SDL_AUDIO_S16LSB;
+            *fmt = SDL_AUDIO_S16LSB;
             break;
         case 24: /* Has been shifted to 32 bits. */
         case 32:
-            spec->format = SDL_AUDIO_S32LSB;
+            *fmt = SDL_AUDIO_S32LSB;
             break;
         default:
             /* Just in case something unexpected happened in the checks. */
@@ -2063,8 +2059,6 @@ static int WaveLoad(SDL_RWops *src, WaveFile *file, SDL_AudioSpec *spec, Uint8 *
         break;
     }
 
-    spec->silence = SDL_GetSilenceValueForFormat(spec->format);
-
     /* Report the end position back to the cleanup code. */
     if (RIFFlengthknown) {
         chunk->position = RIFFend;
@@ -2075,39 +2069,37 @@ static int WaveLoad(SDL_RWops *src, WaveFile *file, SDL_AudioSpec *spec, Uint8 *
     return 0;
 }
 
-SDL_AudioSpec *SDL_LoadWAV_RW(SDL_RWops *src, SDL_bool freesrc, SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len)
+int SDL_LoadWAV_RW(SDL_RWops *src, int freesrc, SDL_AudioFormat *fmt, int *channels, int *freq, Uint8 **audio_buf, Uint32 *audio_len)
 {
     int result = -1;
     WaveFile file;
 
-    SDL_zero(file);
-
     /* Make sure we are passed a valid data source */
     if (src == NULL) {
-        /* Error may come from RWops. */
-        goto done;
-    } else if (spec == NULL) {
-        SDL_InvalidParamError("spec");
-        goto done;
+        return -1;  /* Error may come from RWops. */
+    } else if (fmt == NULL) {
+        return SDL_InvalidParamError("fmt");
+    } else if (channels == NULL) {
+        return SDL_InvalidParamError("channels");
+    } else if (freq == NULL) {
+        return SDL_InvalidParamError("freq");
     } else if (audio_buf == NULL) {
-        SDL_InvalidParamError("audio_buf");
-        goto done;
+        return SDL_InvalidParamError("audio_buf");
     } else if (audio_len == NULL) {
-        SDL_InvalidParamError("audio_len");
-        goto done;
+        return SDL_InvalidParamError("audio_len");
     }
 
     *audio_buf = NULL;
     *audio_len = 0;
 
+    SDL_zero(file);
     file.riffhint = WaveGetRiffSizeHint();
     file.trunchint = WaveGetTruncationHint();
     file.facthint = WaveGetFactChunkHint();
 
-    result = WaveLoad(src, &file, spec, audio_buf, audio_len);
+    result = WaveLoad(src, &file, fmt, channels, freq, audio_buf, audio_len);
     if (result < 0) {
         SDL_free(*audio_buf);
-        spec = NULL;
         audio_buf = NULL;
         audio_len = 0;
     }
@@ -2119,13 +2111,5 @@ SDL_AudioSpec *SDL_LoadWAV_RW(SDL_RWops *src, SDL_bool freesrc, SDL_AudioSpec *s
     WaveFreeChunkData(&file.chunk);
     SDL_free(file.decoderdata);
 
-done:
-    if (freesrc && src) {
-        SDL_RWclose(src);
-    }
-    if (result == 0) {
-        return spec;
-    } else {
-        return NULL;
-    }
+    return result;
 }

src/audio/disk/SDL_diskaudio.c

@@ -24,10 +24,6 @@
 
 /* Output raw audio data to a file. */
 
-#ifdef HAVE_STDIO_H
-#include <stdio.h>
-#endif
-
 #include "../SDL_audio_c.h"
 #include "SDL_diskaudio.h"
 
@@ -40,34 +36,34 @@
 #define DISKENVR_IODELAY    "SDL_DISKAUDIODELAY"
 
 /* This function waits until it is possible to write a full sound buffer */
-static void DISKAUDIO_WaitDevice(SDL_AudioDevice *_this)
+static void DISKAUDIO_WaitDevice(SDL_AudioDevice *device)
 {
-    SDL_Delay(_this->hidden->io_delay);
+    SDL_Delay(device->hidden->io_delay);
 }
 
-static void DISKAUDIO_PlayDevice(SDL_AudioDevice *_this)
+static void DISKAUDIO_PlayDevice(SDL_AudioDevice *device, int buffer_size)
 {
-    const Sint64 written = SDL_RWwrite(_this->hidden->io,
-                                       _this->hidden->mixbuf,
-                                       _this->spec.size);
+    const Sint64 written = SDL_RWwrite(device->hidden->io,
+                                       device->hidden->mixbuf,
+                                       buffer_size);
 
     /* If we couldn't write, assume fatal error for now */
-    if (written != _this->spec.size) {
-        SDL_OpenedAudioDeviceDisconnected(_this);
+    if (written != buffer_size) {
+        SDL_AudioDeviceDisconnected(device);
     }
 #ifdef DEBUG_AUDIO
-    fprintf(stderr, "Wrote %d bytes of audio data\n", (int) written);
+    SDL_Log("DISKAUDIO: Wrote %d bytes of audio data", (int) written);
 #endif
 }
 
-static Uint8 *DISKAUDIO_GetDeviceBuf(SDL_AudioDevice *_this)
+static Uint8 *DISKAUDIO_GetDeviceBuf(SDL_AudioDevice *device, int *buffer_size)
 {
-    return _this->hidden->mixbuf;
+    return device->hidden->mixbuf;
 }
 
-static int DISKAUDIO_CaptureFromDevice(SDL_AudioDevice *_this, void *buffer, int buflen)
+static int DISKAUDIO_CaptureFromDevice(SDL_AudioDevice *device, void *buffer, int buflen)
 {
-    struct SDL_PrivateAudioData *h = _this->hidden;
+    struct SDL_PrivateAudioData *h = device->hidden;
     const int origbuflen = buflen;
 
     SDL_Delay(h->io_delay);
@@ -83,70 +79,66 @@ static int DISKAUDIO_CaptureFromDevice(SDL_AudioDevice *_this, void *buffer, int
     }
 
     /* if we ran out of file, just write silence. */
-    SDL_memset(buffer, _this->spec.silence, buflen);
+    SDL_memset(buffer, device->silence_value, buflen);
 
     return origbuflen;
 }
 
-static void DISKAUDIO_FlushCapture(SDL_AudioDevice *_this)
+static void DISKAUDIO_FlushCapture(SDL_AudioDevice *device)
 {
     /* no op...we don't advance the file pointer or anything. */
 }
 
-static void DISKAUDIO_CloseDevice(SDL_AudioDevice *_this)
+static void DISKAUDIO_CloseDevice(SDL_AudioDevice *device)
 {
-    if (_this->hidden->io != NULL) {
-        SDL_RWclose(_this->hidden->io);
+    if (device->hidden->io != NULL) {
+        SDL_RWclose(device->hidden->io);
     }
-    SDL_free(_this->hidden->mixbuf);
-    SDL_free(_this->hidden);
+    SDL_free(device->hidden->mixbuf);
+    SDL_free(device->hidden);
 }
 
-static const char *get_filename(const SDL_bool iscapture, const char *devname)
+static const char *get_filename(const SDL_bool iscapture)
 {
+    const char *devname = SDL_getenv(iscapture ? DISKENVR_INFILE : DISKENVR_OUTFILE);
     if (devname == NULL) {
-        devname = SDL_getenv(iscapture ? DISKENVR_INFILE : DISKENVR_OUTFILE);
-        if (devname == NULL) {
-            devname = iscapture ? DISKDEFAULT_INFILE : DISKDEFAULT_OUTFILE;
-        }
+        devname = iscapture ? DISKDEFAULT_INFILE : DISKDEFAULT_OUTFILE;
     }
     return devname;
 }
 
-static int DISKAUDIO_OpenDevice(SDL_AudioDevice *_this, const char *devname)
+static int DISKAUDIO_OpenDevice(SDL_AudioDevice *device)
 {
-    void *handle = _this->handle;
-    /* handle != NULL means "user specified the placeholder name on the fake detected device list" */
-    SDL_bool iscapture = _this->iscapture;
-    const char *fname = get_filename(iscapture, handle ? NULL : devname);
+    SDL_bool iscapture = device->iscapture;
+    const char *fname = get_filename(iscapture);
     const char *envr = SDL_getenv(DISKENVR_IODELAY);
 
-    _this->hidden = (struct SDL_PrivateAudioData *)
-        SDL_malloc(sizeof(*_this->hidden));
-    if (_this->hidden == NULL) {
+    device->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc(sizeof(*device->hidden));
+    if (device->hidden == NULL) {
         return SDL_OutOfMemory();
     }
-    SDL_zerop(_this->hidden);
+    SDL_zerop(device->hidden);
 
     if (envr != NULL) {
-        _this->hidden->io_delay = SDL_atoi(envr);
+        device->hidden->io_delay = SDL_atoi(envr);
     } else {
-        _this->hidden->io_delay = ((_this->spec.samples * 1000) / _this->spec.freq);
+        device->hidden->io_delay = ((device->sample_frames * 1000) / device->freq);
     }
 
-    /* Open the audio device */
-    _this->hidden->io = SDL_RWFromFile(fname, iscapture ? "rb" : "wb");
-    if (_this->hidden->io == NULL) {
+    /* Open the "audio device" */
+    device->hidden->io = SDL_RWFromFile(fname, iscapture ? "rb" : "wb");
+    if (device->hidden->io == NULL) {
         return -1;
     }
 
     /* Allocate mixing buffer */
     if (!iscapture) {
-        _this->hidden->mixbuf = (Uint8 *)SDL_malloc(_this->spec.size);
-        if (_this->hidden->mixbuf == NULL) {
+        device->hidden->mixbuf = (Uint8 *)SDL_malloc(device->buffer_size);
+        if (device->hidden->mixbuf == NULL) {
             return SDL_OutOfMemory();
         }
-        SDL_memset(_this->hidden->mixbuf, _this->spec.silence, _this->spec.size);
+        SDL_memset(device->hidden->mixbuf, device->silence_value, device->buffer_size);
     }
 
     SDL_LogCritical(SDL_LOG_CATEGORY_AUDIO,
@@ -161,8 +153,8 @@ static int DISKAUDIO_OpenDevice(SDL_AudioDevice *_this, const char *devname)
 
 static void DISKAUDIO_DetectDevices(void)
 {
-    SDL_AddAudioDevice(SDL_FALSE, DEFAULT_OUTPUT_DEVNAME, NULL, (void *)0x1);
-    SDL_AddAudioDevice(SDL_TRUE, DEFAULT_INPUT_DEVNAME, NULL, (void *)0x2);
+    SDL_AddAudioDevice(SDL_FALSE, DEFAULT_OUTPUT_DEVNAME, 0, 0, 0, (void *)0x1);
+    SDL_AddAudioDevice(SDL_TRUE, DEFAULT_INPUT_DEVNAME, 0, 0, 0, (void *)0x2);
 }
 
 static SDL_bool DISKAUDIO_Init(SDL_AudioDriverImpl *impl)

src/audio/dummy/SDL_dummyaudio.c

@@ -25,20 +25,35 @@
 #include "../SDL_audio_c.h"
 #include "SDL_dummyaudio.h"
 
-static int DUMMYAUDIO_OpenDevice(SDL_AudioDevice *_this, const char *devname)
+/* !!! FIXME: add a dummy WaitDevice to simulate real audio better? */
+
+static int DUMMYAUDIO_OpenDevice(SDL_AudioDevice *device)
+{
+    device->hidden = (struct SDL_PrivateAudioData *) SDL_malloc(device->buffer_size);
+    if (!device->hidden) {
+        return SDL_OutOfMemory();
+    }
+    return 0; /* don't change reported device format. */
+}
+
+static void DUMMYAUDIO_CloseDevice(SDL_AudioDevice *device)
 {
-    _this->hidden = (void *)0x1; /* just something non-NULL */
+    SDL_free(device->hidden);
+    device->hidden = NULL;
+}
 
-    return 0; /* always succeeds. */
+static Uint8 *DUMMYAUDIO_GetDeviceBuf(SDL_AudioDevice *device, int *buffer_size)
+{
+    return (Uint8 *) device->hidden;
 }
 
-static int DUMMYAUDIO_CaptureFromDevice(SDL_AudioDevice *_this, void *buffer, int buflen)
+static int DUMMYAUDIO_CaptureFromDevice(SDL_AudioDevice *device, void *buffer, int buflen)
 {
     /* Delay to make this sort of simulate real audio input. */
-    SDL_Delay((_this->spec.samples * 1000) / _this->spec.freq);
+    SDL_Delay((device->sample_frames * 1000) / device->freq);
 
     /* always return a full buffer of silence. */
-    SDL_memset(buffer, _this->spec.silence, buflen);
+    SDL_memset(buffer, device->silence_value, buflen);
     return buflen;
 }
 
@@ -46,6 +61,8 @@ static SDL_bool DUMMYAUDIO_Init(SDL_AudioDriverImpl *impl)
 {
     /* Set the function pointers */
     impl->OpenDevice = DUMMYAUDIO_OpenDevice;
+    impl->CloseDevice = DUMMYAUDIO_CloseDevice;
+    impl->GetDeviceBuf = DUMMYAUDIO_GetDeviceBuf;
     impl->CaptureFromDevice = DUMMYAUDIO_CaptureFromDevice;
 
     impl->OnlyHasDefaultOutputDevice = SDL_TRUE;

src/audio/dummy/SDL_dummyaudio.h

@@ -25,6 +25,8 @@
 
 #include "../SDL_sysaudio.h"
 
+/* !!! FIXME: none of this is actually used. Dump this whole file. */
+
 struct SDL_PrivateAudioData
 {
     /* The file descriptor for the audio device */

src/audio/pulseaudio/SDL_pulseaudio.c

@@ -359,12 +359,6 @@ failed:
     return -1;
 }
 
-/* This function waits until it is possible to write a full sound buffer */
-static void PULSEAUDIO_WaitDevice(SDL_AudioDevice *_this)
-{
-    /* this is a no-op; we wait in PULSEAUDIO_PlayDevice now. */
-}
-
 static void WriteCallback(pa_stream *p, size_t nbytes, void *userdata)
 {
     struct SDL_PrivateAudioData *h = (struct SDL_PrivateAudioData *)userdata;
@@ -373,50 +367,58 @@ static void WriteCallback(pa_stream *p, size_t nbytes, void *userdata)
     PULSEAUDIO_pa_threaded_mainloop_signal(pulseaudio_threaded_mainloop, 0);
 }
 
-static void PULSEAUDIO_PlayDevice(SDL_AudioDevice *_this)
+/* This function waits until it is possible to write a full sound buffer */
+static void PULSEAUDIO_WaitDevice(SDL_AudioDevice *device)
 {
-    struct SDL_PrivateAudioData *h = _this->hidden;
-    int available = h->mixlen;
-    int written = 0;
-    int cpy;
+    struct SDL_PrivateAudioData *h = device->hidden;
 
     /*printf("PULSEAUDIO PLAYDEVICE START! mixlen=%d\n", available);*/
 
     PULSEAUDIO_pa_threaded_mainloop_lock(pulseaudio_threaded_mainloop);
 
-    while (SDL_AtomicGet(&_this->enabled) && (available > 0)) {
-        cpy = SDL_min(h->bytes_requested, available);
-        if (cpy) {
-            if (PULSEAUDIO_pa_stream_write(h->stream, h->mixbuf + written, cpy, NULL, 0LL, PA_SEEK_RELATIVE) < 0) {
-                SDL_OpenedAudioDeviceDisconnected(_this);
-                break;
-            }
-            /*printf("PULSEAUDIO FEED! nbytes=%u\n", (unsigned int) cpy);*/
-            h->bytes_requested -= cpy;
-            written += cpy;
-            available -= cpy;
-        }
-
-        if (available > 0) {
-            /* let WriteCallback fire if necessary. */
-            /*printf("PULSEAUDIO WAIT IN PLAYDEVICE!\n");*/
-            PULSEAUDIO_pa_threaded_mainloop_wait(pulseaudio_threaded_mainloop);
+    while (!SDL_AtomicGet(&device->shutdown) && (h->bytes_requested < (device->buffer_size / 2))) {
+        /*printf("PULSEAUDIO WAIT IN WAITDEVICE!\n");*/
+        PULSEAUDIO_pa_threaded_mainloop_wait(pulseaudio_threaded_mainloop);
 
-            if ((PULSEAUDIO_pa_context_get_state(pulseaudio_context) != PA_CONTEXT_READY) || (PULSEAUDIO_pa_stream_get_state(h->stream) != PA_STREAM_READY)) {
-                /*printf("PULSEAUDIO DEVICE FAILURE IN PLAYDEVICE!\n");*/
-                SDL_OpenedAudioDeviceDisconnected(_this);
-                break;
-            }
+        if ((PULSEAUDIO_pa_context_get_state(pulseaudio_context) != PA_CONTEXT_READY) || (PULSEAUDIO_pa_stream_get_state(h->stream) != PA_STREAM_READY)) {
+            /*printf("PULSEAUDIO DEVICE FAILURE IN WAITDEVICE!\n");*/
+            SDL_AudioDeviceDisconnected(device);
+            break;
         }
     }
+    PULSEAUDIO_pa_threaded_mainloop_unlock(pulseaudio_threaded_mainloop);
+}
+
+static void PULSEAUDIO_PlayDevice(SDL_AudioDevice *device, int buffer_size)
+{
+    struct SDL_PrivateAudioData *h = device->hidden;
+    const int available = buffer_size;
+    int rc;
+
+    /*printf("PULSEAUDIO PLAYDEVICE START! mixlen=%d\n", available);*/
 
+    SDL_assert(h->bytes_requested >= available);
+
+    PULSEAUDIO_pa_threaded_mainloop_lock(pulseaudio_threaded_mainloop);
+    rc = PULSEAUDIO_pa_stream_write(h->stream, h->mixbuf, available, NULL, 0LL, PA_SEEK_RELATIVE);
     PULSEAUDIO_pa_threaded_mainloop_unlock(pulseaudio_threaded_mainloop);
+
+    if (rc < 0) {
+        SDL_AudioDeviceDisconnected(device);
+        return;
+    }
+
+    /*printf("PULSEAUDIO FEED! nbytes=%u\n", (unsigned int) available);*/
+    h->bytes_requested -= available;
+
     /*printf("PULSEAUDIO PLAYDEVICE END! written=%d\n", written);*/
 }
 
-static Uint8 *PULSEAUDIO_GetDeviceBuf(SDL_AudioDevice *_this)
+static Uint8 *PULSEAUDIO_GetDeviceBuf(SDL_AudioDevice *device, int *buffer_size)
 {
-    return _this->hidden->mixbuf;
+    struct SDL_PrivateAudioData *h = device->hidden;
+    *buffer_size = SDL_min(*buffer_size, h->bytes_requested);
+    return device->hidden->mixbuf;
 }
 
 static void ReadCallback(pa_stream *p, size_t nbytes, void *userdata)
@@ -425,16 +427,16 @@ static void ReadCallback(pa_stream *p, size_t nbytes, void *userdata)
     PULSEAUDIO_pa_threaded_mainloop_signal(pulseaudio_threaded_mainloop, 0);  /* the capture code queries what it needs, we just need to signal to end any wait */
 }
 
-static int PULSEAUDIO_CaptureFromDevice(SDL_AudioDevice *_this, void *buffer, int buflen)
+static int PULSEAUDIO_CaptureFromDevice(SDL_AudioDevice *device, void *buffer, int buflen)
 {
-    struct SDL_PrivateAudioData *h = _this->hidden;
+    struct SDL_PrivateAudioData *h = device->hidden;
     const void *data = NULL;
     size_t nbytes = 0;
     int retval = 0;
 
     PULSEAUDIO_pa_threaded_mainloop_lock(pulseaudio_threaded_mainloop);
 
-    while (SDL_AtomicGet(&_this->enabled)) {
+    while (!SDL_AtomicGet(&device->shutdown)) {
         if (h->capturebuf != NULL) {
             const int cpy = SDL_min(buflen, h->capturelen);
             SDL_memcpy(buffer, h->capturebuf, cpy);
@@ -449,17 +451,17 @@ static int PULSEAUDIO_CaptureFromDevice(SDL_AudioDevice *_this, void *buffer, in
             break;
         }
 
-        while (SDL_AtomicGet(&_this->enabled) && (PULSEAUDIO_pa_stream_readable_size(h->stream) == 0)) {
+        while (!SDL_AtomicGet(&device->shutdown) && (PULSEAUDIO_pa_stream_readable_size(h->stream) == 0)) {
             PULSEAUDIO_pa_threaded_mainloop_wait(pulseaudio_threaded_mainloop);
             if ((PULSEAUDIO_pa_context_get_state(pulseaudio_context) != PA_CONTEXT_READY) || (PULSEAUDIO_pa_stream_get_state(h->stream) != PA_STREAM_READY)) {
                 /*printf("PULSEAUDIO DEVICE FAILURE IN CAPTUREFROMDEVICE!\n");*/
-                SDL_OpenedAudioDeviceDisconnected(_this);
+                SDL_AudioDeviceDisconnected(device);
                 retval = -1;
                 break;
             }
         }
 
-        if ((retval == -1) || !SDL_AtomicGet(&_this->enabled)) {  /* in case this happened while we were blocking. */
+        if ((retval == -1) || SDL_AtomicGet(&device->shutdown)) {  /* in case this happened while we were blocking. */
             retval = -1;
             break;
         }
@@ -483,9 +485,9 @@ static int PULSEAUDIO_CaptureFromDevice(SDL_AudioDevice *_this, void *buffer, in
     return retval;
 }
 
-static void PULSEAUDIO_FlushCapture(SDL_AudioDevice *_this)
+static void PULSEAUDIO_FlushCapture(SDL_AudioDevice *device)
 {
-    struct SDL_PrivateAudioData *h = _this->hidden;
+    struct SDL_PrivateAudioData *h = device->hidden;
     const void *data = NULL;
     size_t nbytes = 0;
 
@@ -497,11 +499,11 @@ static void PULSEAUDIO_FlushCapture(SDL_AudioDevice *_this)
         h->capturelen = 0;
     }
 
-    while (SDL_AtomicGet(&_this->enabled) && (PULSEAUDIO_pa_stream_readable_size(h->stream) > 0)) {
+    while (!SDL_AtomicGet(&device->shutdown) && (PULSEAUDIO_pa_stream_readable_size(h->stream) > 0)) {
         PULSEAUDIO_pa_threaded_mainloop_wait(pulseaudio_threaded_mainloop);
         if ((PULSEAUDIO_pa_context_get_state(pulseaudio_context) != PA_CONTEXT_READY) || (PULSEAUDIO_pa_stream_get_state(h->stream) != PA_STREAM_READY)) {
             /*printf("PULSEAUDIO DEVICE FAILURE IN FLUSHCAPTURE!\n");*/
-            SDL_OpenedAudioDeviceDisconnected(_this);
+            SDL_AudioDeviceDisconnected(device);
             break;
         }
 
@@ -515,22 +517,22 @@ static void PULSEAUDIO_FlushCapture(SDL_AudioDevice *_this)
     PULSEAUDIO_pa_threaded_mainloop_unlock(pulseaudio_threaded_mainloop);
 }
 
-static void PULSEAUDIO_CloseDevice(SDL_AudioDevice *_this)
+static void PULSEAUDIO_CloseDevice(SDL_AudioDevice *device)
 {
     PULSEAUDIO_pa_threaded_mainloop_lock(pulseaudio_threaded_mainloop);
 
-    if (_this->hidden->stream) {
-        if (_this->hidden->capturebuf != NULL) {
-            PULSEAUDIO_pa_stream_drop(_this->hidden->stream);
+    if (device->hidden->stream) {
+        if (device->hidden->capturebuf != NULL) {
+            PULSEAUDIO_pa_stream_drop(device->hidden->stream);
         }
-        PULSEAUDIO_pa_stream_disconnect(_this->hidden->stream);
-        PULSEAUDIO_pa_stream_unref(_this->hidden->stream);
+        PULSEAUDIO_pa_stream_disconnect(device->hidden->stream);
+        PULSEAUDIO_pa_stream_unref(device->hidden->stream);
     }
     PULSEAUDIO_pa_threaded_mainloop_unlock(pulseaudio_threaded_mainloop);
 
-    SDL_free(_this->hidden->mixbuf);
-    SDL_free(_this->hidden->device_name);
-    SDL_free(_this->hidden);
+    SDL_free(device->hidden->mixbuf);
+    SDL_free(device->hidden->device_name);
+    SDL_free(device->hidden);
 }
 
 static void SinkDeviceNameCallback(pa_context *c, const pa_sink_info *i, int is_last, void *data)
@@ -573,8 +575,9 @@ static void PulseStreamStateChangeCallback(pa_stream *stream, void *userdata)
     PULSEAUDIO_pa_threaded_mainloop_signal(pulseaudio_threaded_mainloop, 0);  /* just signal any waiting code, it can look up the details. */
 }
 
-static int PULSEAUDIO_OpenDevice(SDL_AudioDevice *_this, const char *devname)
+static int PULSEAUDIO_OpenDevice(SDL_AudioDevice *device)
 {
+    const SDL_bool iscapture = device->iscapture;
     struct SDL_PrivateAudioData *h = NULL;
     SDL_AudioFormat test_format;
     const SDL_AudioFormat *closefmts;
@@ -582,7 +585,6 @@ static int PULSEAUDIO_OpenDevice(SDL_AudioDevice *_this, const char *devname)
     pa_buffer_attr paattr;
     pa_channel_map pacmap;
     pa_stream_flags_t flags = 0;
-    SDL_bool iscapture = _this->iscapture;
     int format = PA_SAMPLE_INVALID;
     int retval = 0;
 
@@ -590,14 +592,14 @@ static int PULSEAUDIO_OpenDevice(SDL_AudioDevice *_this, const char *devname)
     SDL_assert(pulseaudio_context != NULL);
 
     /* Initialize all variables that we clean on shutdown */
-    h = _this->hidden = (struct SDL_PrivateAudioData *)SDL_malloc(sizeof(*_this->hidden));
-    if (_this->hidden == NULL) {
+    h = device->hidden = (struct SDL_PrivateAudioData *)SDL_malloc(sizeof(*device->hidden));
+    if (device->hidden == NULL) {
         return SDL_OutOfMemory();
     }
-    SDL_zerop(_this->hidden);
+    SDL_zerop(device->hidden);
 
     /* Try for a closest match on audio format */
-    closefmts = SDL_ClosestAudioFormats(_this->spec.format);
+    closefmts = SDL_ClosestAudioFormats(device->format);
     while ((test_format = *(closefmts++)) != 0) {
 #ifdef DEBUG_AUDIO
         fprintf(stderr, "Trying format 0x%4.4x\n", test_format);
@@ -632,27 +634,27 @@ static int PULSEAUDIO_OpenDevice(SDL_AudioDevice *_this, const char *devname)
     if (!test_format) {
         return SDL_SetError("pulseaudio: Unsupported audio format");
     }
-    _this->spec.format = test_format;
+    device->format = test_format;
     paspec.format = format;
 
     /* Calculate the final parameters for this audio specification */
-    SDL_CalculateAudioSpec(&_this->spec);
+    SDL_UpdatedAudioDeviceFormat(device);
 
     /* Allocate mixing buffer */
     if (!iscapture) {
-        h->mixlen = _this->spec.size;
+        h->mixlen = device->buffer_size;
         h->mixbuf = (Uint8 *)SDL_malloc(h->mixlen);
         if (h->mixbuf == NULL) {
             return SDL_OutOfMemory();
         }
-        SDL_memset(h->mixbuf, _this->spec.silence, _this->spec.size);
+        SDL_memset(h->mixbuf, device->silence_value, device->buffer_size);
     }
 
-    paspec.channels = _this->spec.channels;
-    paspec.rate = _this->spec.freq;
+    paspec.channels = device->channels;
+    paspec.rate = device->freq;
 
     /* Reduced prebuffering compared to the defaults. */
-    paattr.fragsize = _this->spec.size;
+    paattr.fragsize = device->buffer_size;
     paattr.tlength = h->mixlen;
     paattr.prebuf = -1;
     paattr.maxlength = -1;
@@ -661,14 +663,13 @@ static int PULSEAUDIO_OpenDevice(SDL_AudioDevice *_this, const char *devname)
 
     PULSEAUDIO_pa_threaded_mainloop_lock(pulseaudio_threaded_mainloop);
 
-    if (!FindDeviceName(h, iscapture, _this->handle)) {
+    if (!FindDeviceName(h, iscapture, device->handle)) {
         retval = SDL_SetError("Requested PulseAudio sink/source missing?");
     } else {
         const char *name = SDL_GetHint(SDL_HINT_AUDIO_DEVICE_STREAM_NAME);
         /* The SDL ALSA output hints us that we use Windows' channel mapping */
         /* https://bugzilla.libsdl.org/show_bug.cgi?id=110 */
-        PULSEAUDIO_pa_channel_map_init_auto(&pacmap, _this->spec.channels,
-                                            PA_CHANNEL_MAP_WAVEEX);
+        PULSEAUDIO_pa_channel_map_init_auto(&pacmap, device->channels, PA_CHANNEL_MAP_WAVEEX);
 
         h->stream = PULSEAUDIO_pa_stream_new(
             pulseaudio_context,
@@ -747,26 +748,18 @@ static SDL_AudioFormat PulseFormatToSDLFormat(pa_sample_format_t format)
 /* This is called when PulseAudio adds an output ("sink") device. */
 static void SinkInfoCallback(pa_context *c, const pa_sink_info *i, int is_last, void *data)
 {
-    SDL_AudioSpec spec;
-    SDL_bool add = (SDL_bool)((intptr_t)data);
     if (i) {
-        spec.freq = i->sample_spec.rate;
-        spec.channels = i->sample_spec.channels;
-        spec.format = PulseFormatToSDLFormat(i->sample_spec.format);
-        spec.silence = 0;
-        spec.samples = 0;
-        spec.size = 0;
-        spec.callback = NULL;
-        spec.userdata = NULL;
+        const SDL_bool add = (SDL_bool)((intptr_t)data);
+        const SDL_AudioFormat fmt = PulseFormatToSDLFormat(i->sample_spec.format);
+        const int channels = i->sample_spec.channels;
+        const int freq = i->sample_spec.rate;
 
         if (add) {
-            SDL_AddAudioDevice(SDL_FALSE, i->description, &spec, (void *)((intptr_t)i->index + 1));
+            SDL_AddAudioDevice(SDL_FALSE, i->description, fmt, channels, freq, (void *)((intptr_t)i->index + 1));
         }
 
         if (default_sink_path != NULL && SDL_strcmp(i->name, default_sink_path) == 0) {
-            if (default_sink_name != NULL) {
-                SDL_free(default_sink_name);
-            }
+            SDL_free(default_sink_name);
             default_sink_name = SDL_strdup(i->description);
         }
     }
@@ -776,30 +769,20 @@ static void SinkInfoCallback(pa_context *c, const pa_sink_info *i, int is_last,
 /* This is called when PulseAudio adds a capture ("source") device. */
 static void SourceInfoCallback(pa_context *c, const pa_source_info *i, int is_last, void *data)
 {
-    SDL_AudioSpec spec;
-    SDL_bool add = (SDL_bool)((intptr_t)data);
-    if (i) {
-        /* Maybe skip "monitor" sources. These are just output from other sinks. */
-        if (include_monitors || (i->monitor_of_sink == PA_INVALID_INDEX)) {
-            spec.freq = i->sample_spec.rate;
-            spec.channels = i->sample_spec.channels;
-            spec.format = PulseFormatToSDLFormat(i->sample_spec.format);
-            spec.silence = 0;
-            spec.samples = 0;
-            spec.size = 0;
-            spec.callback = NULL;
-            spec.userdata = NULL;
-
-            if (add) {
-                SDL_AddAudioDevice(SDL_TRUE, i->description, &spec, (void *)((intptr_t)i->index + 1));
-            }
+    /* Maybe skip "monitor" sources. These are just output from other sinks. */
+    if (i && (include_monitors || (i->monitor_of_sink == PA_INVALID_INDEX))) {
+        const SDL_bool add = (SDL_bool)((intptr_t)data);
+        const SDL_AudioFormat fmt = PulseFormatToSDLFormat(i->sample_spec.format);
+        const int channels = i->sample_spec.channels;
+        const int freq = i->sample_spec.rate;
 
-            if (default_source_path != NULL && SDL_strcmp(i->name, default_source_path) == 0) {
-                if (default_source_name != NULL) {
-                    SDL_free(default_source_name);
-                }
-                default_source_name = SDL_strdup(i->description);
-            }
+        if (add) {
+            SDL_AddAudioDevice(SDL_TRUE, i->description, fmt, channels, freq, (void *)((intptr_t)i->index + 1));
+        }
+
+        if (default_source_path != NULL && SDL_strcmp(i->name, default_source_path) == 0) {
+            SDL_free(default_source_name);
+            default_source_name = SDL_strdup(i->description);
         }
     }
     PULSEAUDIO_pa_threaded_mainloop_signal(pulseaudio_threaded_mainloop, 0);
@@ -839,7 +822,11 @@ static void HotplugCallback(pa_context *c, pa_subscription_event_type_t t, uint3
             PULSEAUDIO_pa_operation_unref(PULSEAUDIO_pa_context_get_source_info_by_index(pulseaudio_context, idx, SourceInfoCallback, (void *)((intptr_t)added)));
         } else if (removed && (sink || source)) {
             /* removes we can handle just with the device index. */
-            SDL_RemoveAudioDevice(source != 0, (void *)((intptr_t)idx + 1));
+            SDL_AudioDevice *device = SDL_ObtainAudioDeviceByHandle((void *)((intptr_t)idx + 1));  /* !!! FIXME: maybe just have a "disconnect by handle" function instead. */
+            if (device) {
+                SDL_UnlockMutex(device->lock);  /* AudioDeviceDisconnected will relock and verify it's still in the list, but in case this is destroyed, unlock now. */
+                SDL_AudioDeviceDisconnected(device);
+            }
         }
     }
     PULSEAUDIO_pa_threaded_mainloop_signal(pulseaudio_threaded_mainloop, 0);
@@ -893,6 +880,7 @@ static void PULSEAUDIO_DetectDevices(void)
     SDL_DestroySemaphore(ready_sem);
 }
 
+#if 0
 static int PULSEAUDIO_GetDefaultAudioInfo(char **name, SDL_AudioSpec *spec, int iscapture)
 {
     int i;
@@ -923,6 +911,7 @@ static int PULSEAUDIO_GetDefaultAudioInfo(char **name, SDL_AudioSpec *spec, int
     }
     return SDL_SetError("Could not find default PulseAudio device");
 }
+#endif
 
 static void PULSEAUDIO_Deinitialize(void)
 {
@@ -970,7 +959,9 @@ static SDL_bool PULSEAUDIO_Init(SDL_AudioDriverImpl *impl)
     impl->Deinitialize = PULSEAUDIO_Deinitialize;
     impl->CaptureFromDevice = PULSEAUDIO_CaptureFromDevice;
     impl->FlushCapture = PULSEAUDIO_FlushCapture;
+    #if 0
     impl->GetDefaultAudioInfo = PULSEAUDIO_GetDefaultAudioInfo;
+    #endif
 
     impl->HasCaptureSupport = SDL_TRUE;
     impl->SupportsNonPow2Samples = SDL_TRUE;

src/dynapi/SDL_dynapi.sym

@@ -35,12 +35,9 @@ SDL3_0.0.0 {
     SDL_BroadcastCondition;
     SDL_CaptureMouse;
     SDL_CleanupTLS;
-    SDL_ClearAudioStream;
     SDL_ClearComposition;
     SDL_ClearError;
     SDL_ClearHints;
-    SDL_ClearQueuedAudio;
-    SDL_CloseAudioDevice;
     SDL_CloseGamepad;
     SDL_CloseJoystick;
     SDL_CloseSensor;
@@ -50,7 +47,6 @@ SDL3_0.0.0 {
     SDL_ConvertPixels;
     SDL_ConvertSurface;
     SDL_ConvertSurfaceFormat;
-    SDL_CreateAudioStream;
     SDL_CreateColorCursor;
     SDL_CreateCondition;
     SDL_CreateCursor;
@@ -82,8 +78,6 @@ SDL3_0.0.0 {
     SDL_DelHintCallback;
     SDL_Delay;
     SDL_DelayNS;
-    SDL_DequeueAudio;
-    SDL_DestroyAudioStream;
     SDL_DestroyCondition;
     SDL_DestroyCursor;
     SDL_DestroyMutex;
@@ -114,7 +108,6 @@ SDL3_0.0.0 {
     SDL_FillSurfaceRects;
     SDL_FilterEvents;
     SDL_FlashWindow;
-    SDL_FlushAudioStream;
     SDL_FlushEvent;
     SDL_FlushEvents;
     SDL_GDKGetTaskQueue;
@@ -150,27 +143,18 @@ SDL3_0.0.0 {
     SDL_GetAndroidSDKVersion;
     SDL_GetAssertionHandler;
     SDL_GetAssertionReport;
-    SDL_GetAudioDeviceName;
-    SDL_GetAudioDeviceSpec;
-    SDL_GetAudioDeviceStatus;
-    SDL_GetAudioDriver;
-    SDL_GetAudioStreamAvailable;
-    SDL_GetAudioStreamData;
-    SDL_GetAudioStreamFormat;
     SDL_GetBasePath;
     SDL_GetCPUCacheLineSize;
     SDL_GetCPUCount;
     SDL_GetClipboardData;
     SDL_GetClipboardText;
     SDL_GetClosestFullscreenDisplayMode;
-    SDL_GetCurrentAudioDriver;
     SDL_GetCurrentDisplayMode;
     SDL_GetCurrentDisplayOrientation;
     SDL_GetCurrentRenderOutputSize;
     SDL_GetCurrentVideoDriver;
     SDL_GetCursor;
     SDL_GetDefaultAssertionHandler;
-    SDL_GetDefaultAudioInfo;
     SDL_GetDefaultCursor;
     SDL_GetDesktopDisplayMode;
     SDL_GetDisplayBounds;
@@ -267,8 +251,6 @@ SDL3_0.0.0 {
     SDL_GetMouseState;
     SDL_GetNaturalDisplayOrientation;
     SDL_GetNumAllocations;
-    SDL_GetNumAudioDevices;
-    SDL_GetNumAudioDrivers;
     SDL_GetNumGamepadMappings;
     SDL_GetNumGamepadTouchpadFingers;
     SDL_GetNumGamepadTouchpads;
@@ -291,7 +273,6 @@ SDL3_0.0.0 {
     SDL_GetPreferredLocales;
     SDL_GetPrimaryDisplay;
     SDL_GetPrimarySelectionText;
-    SDL_GetQueuedAudioSize;
     SDL_GetRGB;
     SDL_GetRGBA;
     SDL_GetRectAndLineIntersection;
@@ -461,8 +442,6 @@ SDL3_0.0.0 {
     SDL_LoadFile_RW;
     SDL_LoadFunction;
     SDL_LoadObject;
-    SDL_LoadWAV_RW;
-    SDL_LockAudioDevice;
     SDL_LockJoysticks;
     SDL_LockMutex;
     SDL_LockRWLockForReading;
@@ -494,7 +473,6 @@ SDL3_0.0.0 {
     SDL_Metal_DestroyView;
     SDL_Metal_GetLayer;
     SDL_MinimizeWindow;
-    SDL_MixAudioFormat;
     SDL_MouseIsHaptic;
     SDL_NumHaptics;
     SDL_OnApplicationDidBecomeActive;
@@ -504,12 +482,10 @@ SDL3_0.0.0 {
     SDL_OnApplicationWillEnterForeground;
     SDL_OnApplicationWillResignActive;
     SDL_OnApplicationWillTerminate;
-    SDL_OpenAudioDevice;
     SDL_OpenGamepad;
     SDL_OpenJoystick;
     SDL_OpenSensor;
     SDL_OpenURL;
-    SDL_PauseAudioDevice;
     SDL_PeepEvents;
     SDL_PlayAudioDevice;
     SDL_PollEvent;
@@ -517,9 +493,7 @@ SDL3_0.0.0 {
     SDL_PremultiplyAlpha;
     SDL_PumpEvents;
     SDL_PushEvent;
-    SDL_PutAudioStreamData;
     SDL_QueryTexture;
-    SDL_QueueAudio;
     SDL_Quit;
     SDL_QuitSubSystem;
     SDL_RWFromConstMem;
@@ -672,7 +646,6 @@ SDL3_0.0.0 {
     SDL_TryLockRWLockForWriting;
     SDL_TryWaitSemaphore;
     SDL_UnloadObject;
-    SDL_UnlockAudioDevice;
     SDL_UnlockJoysticks;
     SDL_UnlockMutex;
     SDL_UnlockRWLock;
@@ -879,6 +852,33 @@ SDL3_0.0.0 {
     SDL_strnlen;
     SDL_AddGamepadMappingsFromFile;
     SDL_ReloadGamepadMappings;
+    SDL_GetNumAudioDrivers;
+    SDL_GetAudioDriver;
+    SDL_GetCurrentAudioDriver;
+    SDL_GetAudioOutputDevices;
+    SDL_GetAudioCaptureDevices;
+    SDL_GetAudioDeviceName;
+    SDL_GetAudioDeviceFormat;
+    SDL_OpenAudioDevice;
+    SDL_CloseAudioDevice;
+    SDL_BindAudioStreams;
+    SDL_BindAudioStream;
+    SDL_UnbindAudioStreams;
+    SDL_UnbindAudioStream;
+    SDL_CreateAudioStream;
+    SDL_GetAudioStreamFormat;
+    SDL_SetAudioStreamFormat;
+    SDL_PutAudioStreamData;
+    SDL_GetAudioStreamData;
+    SDL_GetAudioStreamAvailable;
+    SDL_FlushAudioStream;
+    SDL_ClearAudioStream;
+    SDL_DestroyAudioStream;
+    SDL_CreateAndBindAudioStream;
+    SDL_LoadWAV_RW;
+    SDL_MixAudioFormat;
+    SDL_ConvertAudioSamples;
+    SDL_GetSilenceValueForFormat;
     # extra symbols go here (don't modify this line)
   local: *;
 };

src/dynapi/SDL_dynapi_overrides.h

@@ -59,12 +59,9 @@
 #define SDL_BroadcastCondition SDL_BroadcastCondition_REAL
 #define SDL_CaptureMouse SDL_CaptureMouse_REAL
 #define SDL_CleanupTLS SDL_CleanupTLS_REAL
-#define SDL_ClearAudioStream SDL_ClearAudioStream_REAL
 #define SDL_ClearComposition SDL_ClearComposition_REAL
 #define SDL_ClearError SDL_ClearError_REAL
 #define SDL_ClearHints SDL_ClearHints_REAL
-#define SDL_ClearQueuedAudio SDL_ClearQueuedAudio_REAL
-#define SDL_CloseAudioDevice SDL_CloseAudioDevice_REAL
 #define SDL_CloseGamepad SDL_CloseGamepad_REAL
 #define SDL_CloseJoystick SDL_CloseJoystick_REAL
 #define SDL_CloseSensor SDL_CloseSensor_REAL
@@ -74,7 +71,6 @@
 #define SDL_ConvertPixels SDL_ConvertPixels_REAL
 #define SDL_ConvertSurface SDL_ConvertSurface_REAL
 #define SDL_ConvertSurfaceFormat SDL_ConvertSurfaceFormat_REAL
-#define SDL_CreateAudioStream SDL_CreateAudioStream_REAL
 #define SDL_CreateColorCursor SDL_CreateColorCursor_REAL
 #define SDL_CreateCondition SDL_CreateCondition_REAL
 #define SDL_CreateCursor SDL_CreateCursor_REAL
@@ -106,8 +102,6 @@
 #define SDL_DelHintCallback SDL_DelHintCallback_REAL
 #define SDL_Delay SDL_Delay_REAL
 #define SDL_DelayNS SDL_DelayNS_REAL
-#define SDL_DequeueAudio SDL_DequeueAudio_REAL
-#define SDL_DestroyAudioStream SDL_DestroyAudioStream_REAL
 #define SDL_DestroyCondition SDL_DestroyCondition_REAL
 #define SDL_DestroyCursor SDL_DestroyCursor_REAL
 #define SDL_DestroyMutex SDL_DestroyMutex_REAL
@@ -138,7 +132,6 @@
 #define SDL_FillSurfaceRects SDL_FillSurfaceRects_REAL
 #define SDL_FilterEvents SDL_FilterEvents_REAL
 #define SDL_FlashWindow SDL_FlashWindow_REAL
-#define SDL_FlushAudioStream SDL_FlushAudioStream_REAL
 #define SDL_FlushEvent SDL_FlushEvent_REAL
 #define SDL_FlushEvents SDL_FlushEvents_REAL
 #define SDL_GDKGetTaskQueue SDL_GDKGetTaskQueue_REAL
@@ -174,27 +167,18 @@
 #define SDL_GetAndroidSDKVersion    SDL_GetAndroidSDKVersion_REAL
 #define SDL_GetAssertionHandler SDL_GetAssertionHandler_REAL
 #define SDL_GetAssertionReport SDL_GetAssertionReport_REAL
-#define SDL_GetAudioDeviceName SDL_GetAudioDeviceName_REAL
-#define SDL_GetAudioDeviceSpec SDL_GetAudioDeviceSpec_REAL
-#define SDL_GetAudioDeviceStatus SDL_GetAudioDeviceStatus_REAL
-#define SDL_GetAudioDriver SDL_GetAudioDriver_REAL
-#define SDL_GetAudioStreamAvailable SDL_GetAudioStreamAvailable_REAL
-#define SDL_GetAudioStreamData SDL_GetAudioStreamData_REAL
-#define SDL_GetAudioStreamFormat SDL_GetAudioStreamFormat_REAL
 #define SDL_GetBasePath SDL_GetBasePath_REAL
 #define SDL_GetCPUCacheLineSize SDL_GetCPUCacheLineSize_REAL
 #define SDL_GetCPUCount SDL_GetCPUCount_REAL
 #define SDL_GetClipboardData SDL_GetClipboardData_REAL
 #define SDL_GetClipboardText SDL_GetClipboardText_REAL
 #define SDL_GetClosestFullscreenDisplayMode SDL_GetClosestFullscreenDisplayMode_REAL
-#define SDL_GetCurrentAudioDriver SDL_GetCurrentAudioDriver_REAL
 #define SDL_GetCurrentDisplayMode SDL_GetCurrentDisplayMode_REAL
 #define SDL_GetCurrentDisplayOrientation SDL_GetCurrentDisplayOrientation_REAL
 #define SDL_GetCurrentRenderOutputSize SDL_GetCurrentRenderOutputSize_REAL
 #define SDL_GetCurrentVideoDriver SDL_GetCurrentVideoDriver_REAL
 #define SDL_GetCursor SDL_GetCursor_REAL
 #define SDL_GetDefaultAssertionHandler SDL_GetDefaultAssertionHandler_REAL
-#define SDL_GetDefaultAudioInfo SDL_GetDefaultAudioInfo_REAL
 #define SDL_GetDefaultCursor SDL_GetDefaultCursor_REAL
 #define SDL_GetDesktopDisplayMode SDL_GetDesktopDisplayMode_REAL
 #define SDL_GetDisplayBounds SDL_GetDisplayBounds_REAL
@@ -291,8 +275,6 @@
 #define SDL_GetMouseState SDL_GetMouseState_REAL
 #define SDL_GetNaturalDisplayOrientation SDL_GetNaturalDisplayOrientation_REAL
 #define SDL_GetNumAllocations SDL_GetNumAllocations_REAL
-#define SDL_GetNumAudioDevices SDL_GetNumAudioDevices_REAL
-#define SDL_GetNumAudioDrivers SDL_GetNumAudioDrivers_REAL
 #define SDL_GetNumGamepadMappings SDL_GetNumGamepadMappings_REAL
 #define SDL_GetNumGamepadTouchpadFingers SDL_GetNumGamepadTouchpadFingers_REAL
 #define SDL_GetNumGamepadTouchpads SDL_GetNumGamepadTouchpads_REAL
@@ -315,7 +297,6 @@
 #define SDL_GetPreferredLocales SDL_GetPreferredLocales_REAL
 #define SDL_GetPrimaryDisplay SDL_GetPrimaryDisplay_REAL
 #define SDL_GetPrimarySelectionText SDL_GetPrimarySelectionText_REAL
-#define SDL_GetQueuedAudioSize SDL_GetQueuedAudioSize_REAL
 #define SDL_GetRGB SDL_GetRGB_REAL
 #define SDL_GetRGBA SDL_GetRGBA_REAL
 #define SDL_GetRectAndLineIntersection SDL_GetRectAndLineIntersection_REAL
@@ -485,8 +466,6 @@
 #define SDL_LoadFile_RW SDL_LoadFile_RW_REAL
 #define SDL_LoadFunction SDL_LoadFunction_REAL
 #define SDL_LoadObject SDL_LoadObject_REAL
-#define SDL_LoadWAV_RW SDL_LoadWAV_RW_REAL
-#define SDL_LockAudioDevice SDL_LockAudioDevice_REAL
 #define SDL_LockJoysticks SDL_LockJoysticks_REAL
 #define SDL_LockMutex SDL_LockMutex_REAL
 #define SDL_LockRWLockForReading SDL_LockRWLockForReading_REAL
@@ -518,7 +497,6 @@
 #define SDL_Metal_DestroyView SDL_Metal_DestroyView_REAL
 #define SDL_Metal_GetLayer SDL_Metal_GetLayer_REAL
 #define SDL_MinimizeWindow SDL_MinimizeWindow_REAL
-#define SDL_MixAudioFormat SDL_MixAudioFormat_REAL
 #define SDL_MouseIsHaptic SDL_MouseIsHaptic_REAL
 #define SDL_NumHaptics SDL_NumHaptics_REAL
 #define SDL_OnApplicationDidBecomeActive SDL_OnApplicationDidBecomeActive_REAL
@@ -528,12 +506,10 @@
 #define SDL_OnApplicationWillEnterForeground SDL_OnApplicationWillEnterForeground_REAL
 #define SDL_OnApplicationWillResignActive SDL_OnApplicationWillResignActive_REAL
 #define SDL_OnApplicationWillTerminate SDL_OnApplicationWillTerminate_REAL
-#define SDL_OpenAudioDevice SDL_OpenAudioDevice_REAL
 #define SDL_OpenGamepad SDL_OpenGamepad_REAL
 #define SDL_OpenJoystick SDL_OpenJoystick_REAL
 #define SDL_OpenSensor SDL_OpenSensor_REAL
 #define SDL_OpenURL SDL_OpenURL_REAL
-#define SDL_PauseAudioDevice SDL_PauseAudioDevice_REAL
 #define SDL_PeepEvents SDL_PeepEvents_REAL
 #define SDL_PlayAudioDevice SDL_PlayAudioDevice_REAL
 #define SDL_PollEvent SDL_PollEvent_REAL
@@ -541,9 +517,7 @@
 #define SDL_PremultiplyAlpha SDL_PremultiplyAlpha_REAL
 #define SDL_PumpEvents SDL_PumpEvents_REAL
 #define SDL_PushEvent SDL_PushEvent_REAL
-#define SDL_PutAudioStreamData SDL_PutAudioStreamData_REAL
 #define SDL_QueryTexture SDL_QueryTexture_REAL
-#define SDL_QueueAudio SDL_QueueAudio_REAL
 #define SDL_Quit SDL_Quit_REAL
 #define SDL_QuitSubSystem SDL_QuitSubSystem_REAL
 #define SDL_RWFromConstMem SDL_RWFromConstMem_REAL
@@ -696,7 +670,6 @@
 #define SDL_TryLockRWLockForWriting SDL_TryLockRWLockForWriting_REAL
 #define SDL_TryWaitSemaphore SDL_TryWaitSemaphore_REAL
 #define SDL_UnloadObject SDL_UnloadObject_REAL
-#define SDL_UnlockAudioDevice SDL_UnlockAudioDevice_REAL
 #define SDL_UnlockJoysticks SDL_UnlockJoysticks_REAL
 #define SDL_UnlockMutex SDL_UnlockMutex_REAL
 #define SDL_UnlockRWLock SDL_UnlockRWLock_REAL
@@ -905,3 +878,30 @@
 #define SDL_strnlen SDL_strnlen_REAL
 #define SDL_AddGamepadMappingsFromFile SDL_AddGamepadMappingsFromFile_REAL
 #define SDL_ReloadGamepadMappings SDL_ReloadGamepadMappings_REAL
+#define SDL_GetNumAudioDrivers SDL_GetNumAudioDrivers_REAL
+#define SDL_GetAudioDriver SDL_GetAudioDriver_REAL
+#define SDL_GetCurrentAudioDriver SDL_GetCurrentAudioDriver_REAL
+#define SDL_GetAudioOutputDevices SDL_GetAudioOutputDevices_REAL
+#define SDL_GetAudioCaptureDevices SDL_GetAudioCaptureDevices_REAL
+#define SDL_GetAudioDeviceName SDL_GetAudioDeviceName_REAL
+#define SDL_GetAudioDeviceFormat SDL_GetAudioDeviceFormat_REAL
+#define SDL_OpenAudioDevice SDL_OpenAudioDevice_REAL
+#define SDL_CloseAudioDevice SDL_CloseAudioDevice_REAL
+#define SDL_BindAudioStreams SDL_BindAudioStreams_REAL
+#define SDL_BindAudioStream SDL_BindAudioStream_REAL
+#define SDL_UnbindAudioStreams SDL_UnbindAudioStreams_REAL
+#define SDL_UnbindAudioStream SDL_UnbindAudioStream_REAL
+#define SDL_CreateAudioStream SDL_CreateAudioStream_REAL
+#define SDL_GetAudioStreamFormat SDL_GetAudioStreamFormat_REAL
+#define SDL_SetAudioStreamFormat SDL_SetAudioStreamFormat_REAL
+#define SDL_PutAudioStreamData SDL_PutAudioStreamData_REAL
+#define SDL_GetAudioStreamData SDL_GetAudioStreamData_REAL
+#define SDL_GetAudioStreamAvailable SDL_GetAudioStreamAvailable_REAL
+#define SDL_FlushAudioStream SDL_FlushAudioStream_REAL
+#define SDL_ClearAudioStream SDL_ClearAudioStream_REAL
+#define SDL_DestroyAudioStream SDL_DestroyAudioStream_REAL
+#define SDL_CreateAndBindAudioStream SDL_CreateAndBindAudioStream_REAL
+#define SDL_LoadWAV_RW SDL_LoadWAV_RW_REAL
+#define SDL_MixAudioFormat SDL_MixAudioFormat_REAL
+#define SDL_ConvertAudioSamples SDL_ConvertAudioSamples_REAL
+#define SDL_GetSilenceValueForFormat SDL_GetSilenceValueForFormat_REAL

src/dynapi/SDL_dynapi_procs.h

@@ -141,12 +141,9 @@ SDL_DYNAPI_PROC(int,SDL_BlitSurfaceUncheckedScaled,(SDL_Surface *a, const SDL_Re
 SDL_DYNAPI_PROC(int,SDL_BroadcastCondition,(SDL_Condition *a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_CaptureMouse,(SDL_bool a),(a),return)
 SDL_DYNAPI_PROC(void,SDL_CleanupTLS,(void),(),)
-SDL_DYNAPI_PROC(int,SDL_ClearAudioStream,(SDL_AudioStream *a),(a),return)
 SDL_DYNAPI_PROC(void,SDL_ClearComposition,(void),(),)
 SDL_DYNAPI_PROC(void,SDL_ClearError,(void),(),)
 SDL_DYNAPI_PROC(void,SDL_ClearHints,(void),(),)
-SDL_DYNAPI_PROC(int,SDL_ClearQueuedAudio,(SDL_AudioDeviceID a),(a),return)
-SDL_DYNAPI_PROC(void,SDL_CloseAudioDevice,(SDL_AudioDeviceID a),(a),)
 SDL_DYNAPI_PROC(void,SDL_CloseGamepad,(SDL_Gamepad *a),(a),)
 SDL_DYNAPI_PROC(void,SDL_CloseJoystick,(SDL_Joystick *a),(a),)
 SDL_DYNAPI_PROC(void,SDL_CloseSensor,(SDL_Sensor *a),(a),)
@@ -156,7 +153,6 @@ SDL_DYNAPI_PROC(int,SDL_ConvertEventToRenderCoordinates,(SDL_Renderer *a, SDL_Ev
 SDL_DYNAPI_PROC(int,SDL_ConvertPixels,(int a, int b, Uint32 c, const void *d, int e, Uint32 f, void *g, int h),(a,b,c,d,e,f,g,h),return)
 SDL_DYNAPI_PROC(SDL_Surface*,SDL_ConvertSurface,(SDL_Surface *a, const SDL_PixelFormat *b),(a,b),return)
 SDL_DYNAPI_PROC(SDL_Surface*,SDL_ConvertSurfaceFormat,(SDL_Surface *a, Uint32 b),(a,b),return)
-SDL_DYNAPI_PROC(SDL_AudioStream*,SDL_CreateAudioStream,(SDL_AudioFormat a, int b, int c, SDL_AudioFormat d, int e, int f),(a,b,c,d,e,f),return)
 SDL_DYNAPI_PROC(SDL_Cursor*,SDL_CreateColorCursor,(SDL_Surface *a, int b, int c),(a,b,c),return)
 SDL_DYNAPI_PROC(SDL_Condition*,SDL_CreateCondition,(void),(),return)
 SDL_DYNAPI_PROC(SDL_Cursor*,SDL_CreateCursor,(const Uint8 *a, const Uint8 *b, int c, int d, int e, int f),(a,b,c,d,e,f),return)
@@ -185,8 +181,6 @@ SDL_DYNAPI_PROC(void,SDL_DelEventWatch,(SDL_EventFilter a, void *b),(a,b),)
 SDL_DYNAPI_PROC(void,SDL_DelHintCallback,(const char *a, SDL_HintCallback b, void *c),(a,b,c),)
 SDL_DYNAPI_PROC(void,SDL_Delay,(Uint32 a),(a),)
 SDL_DYNAPI_PROC(void,SDL_DelayNS,(Uint64 a),(a),)
-SDL_DYNAPI_PROC(Uint32,SDL_DequeueAudio,(SDL_AudioDeviceID a, void *b, Uint32 c),(a,b,c),return)
-SDL_DYNAPI_PROC(void,SDL_DestroyAudioStream,(SDL_AudioStream *a),(a),)
 SDL_DYNAPI_PROC(void,SDL_DestroyCondition,(SDL_Condition *a),(a),)
 SDL_DYNAPI_PROC(void,SDL_DestroyCursor,(SDL_Cursor *a),(a),)
 SDL_DYNAPI_PROC(void,SDL_DestroyMutex,(SDL_Mutex *a),(a),)
@@ -216,7 +210,6 @@ SDL_DYNAPI_PROC(int,SDL_FillSurfaceRect,(SDL_Surface *a, const SDL_Rect *b, Uint
 SDL_DYNAPI_PROC(int,SDL_FillSurfaceRects,(SDL_Surface *a, const SDL_Rect *b, int c, Uint32 d),(a,b,c,d),return)
 SDL_DYNAPI_PROC(void,SDL_FilterEvents,(SDL_EventFilter a, void *b),(a,b),)
 SDL_DYNAPI_PROC(int,SDL_FlashWindow,(SDL_Window *a, SDL_FlashOperation b),(a,b),return)
-SDL_DYNAPI_PROC(int,SDL_FlushAudioStream,(SDL_AudioStream *a),(a),return)
 SDL_DYNAPI_PROC(void,SDL_FlushEvent,(Uint32 a),(a),)
 SDL_DYNAPI_PROC(void,SDL_FlushEvents,(Uint32 a, Uint32 b),(a,b),)
 SDL_DYNAPI_PROC(int,SDL_GL_BindTexture,(SDL_Texture *a, float *b, float *c),(a,b,c),return)
@@ -249,27 +242,18 @@ SDL_DYNAPI_PROC(SDL_bool,SDL_GamepadHasSensor,(SDL_Gamepad *a, SDL_SensorType b)
 SDL_DYNAPI_PROC(SDL_bool,SDL_GamepadSensorEnabled,(SDL_Gamepad *a, SDL_SensorType b),(a,b),return)
 SDL_DYNAPI_PROC(SDL_AssertionHandler,SDL_GetAssertionHandler,(void **a),(a),return)
 SDL_DYNAPI_PROC(const SDL_AssertData*,SDL_GetAssertionReport,(void),(),return)
-SDL_DYNAPI_PROC(const char*,SDL_GetAudioDeviceName,(int a, int b),(a,b),return)
-SDL_DYNAPI_PROC(int,SDL_GetAudioDeviceSpec,(int a, int b, SDL_AudioSpec *c),(a,b,c),return)
-SDL_DYNAPI_PROC(SDL_AudioStatus,SDL_GetAudioDeviceStatus,(SDL_AudioDeviceID a),(a),return)
-SDL_DYNAPI_PROC(const char*,SDL_GetAudioDriver,(int a),(a),return)
-SDL_DYNAPI_PROC(int,SDL_GetAudioStreamAvailable,(SDL_AudioStream *a),(a),return)
-SDL_DYNAPI_PROC(int,SDL_GetAudioStreamData,(SDL_AudioStream *a, void *b, int c),(a,b,c),return)
-SDL_DYNAPI_PROC(int,SDL_GetAudioStreamFormat,(SDL_AudioStream *a, SDL_AudioFormat *b, int *c, int *d, SDL_AudioFormat *e, int *f, int *g),(a,b,c,d,e,f,g),return)
 SDL_DYNAPI_PROC(char*,SDL_GetBasePath,(void),(),return)
 SDL_DYNAPI_PROC(int,SDL_GetCPUCacheLineSize,(void),(),return)
 SDL_DYNAPI_PROC(int,SDL_GetCPUCount,(void),(),return)
 SDL_DYNAPI_PROC(void*,SDL_GetClipboardData,(const char *a, size_t *b),(a,b),return)
 SDL_DYNAPI_PROC(char*,SDL_GetClipboardText,(void),(),return)
 SDL_DYNAPI_PROC(const SDL_DisplayMode*,SDL_GetClosestFullscreenDisplayMode,(SDL_DisplayID a, int b, int c, float d, SDL_bool e),(a,b,c,d,e),return)
-SDL_DYNAPI_PROC(const char*,SDL_GetCurrentAudioDriver,(void),(),return)
 SDL_DYNAPI_PROC(const SDL_DisplayMode*,SDL_GetCurrentDisplayMode,(SDL_DisplayID a),(a),return)
 SDL_DYNAPI_PROC(SDL_DisplayOrientation,SDL_GetCurrentDisplayOrientation,(SDL_DisplayID a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_GetCurrentRenderOutputSize,(SDL_Renderer *a, int *b, int *c),(a,b,c),return)
 SDL_DYNAPI_PROC(const char*,SDL_GetCurrentVideoDriver,(void),(),return)
 SDL_DYNAPI_PROC(SDL_Cursor*,SDL_GetCursor,(void),(),return)
 SDL_DYNAPI_PROC(SDL_AssertionHandler,SDL_GetDefaultAssertionHandler,(void),(),return)
-SDL_DYNAPI_PROC(int,SDL_GetDefaultAudioInfo,(char **a, SDL_AudioSpec *b, int c),(a,b,c),return)
 SDL_DYNAPI_PROC(SDL_Cursor*,SDL_GetDefaultCursor,(void),(),return)
 SDL_DYNAPI_PROC(const SDL_DisplayMode*,SDL_GetDesktopDisplayMode,(SDL_DisplayID a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_GetDisplayBounds,(SDL_DisplayID a, SDL_Rect *b),(a,b),return)
@@ -366,8 +350,6 @@ SDL_DYNAPI_PROC(SDL_Window*,SDL_GetMouseFocus,(void),(),return)
 SDL_DYNAPI_PROC(Uint32,SDL_GetMouseState,(float *a, float *b),(a,b),return)
 SDL_DYNAPI_PROC(SDL_DisplayOrientation,SDL_GetNaturalDisplayOrientation,(SDL_DisplayID a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_GetNumAllocations,(void),(),return)
-SDL_DYNAPI_PROC(int,SDL_GetNumAudioDevices,(int a),(a),return)
-SDL_DYNAPI_PROC(int,SDL_GetNumAudioDrivers,(void),(),return)
 SDL_DYNAPI_PROC(int,SDL_GetNumGamepadMappings,(void),(),return)
 SDL_DYNAPI_PROC(int,SDL_GetNumGamepadTouchpadFingers,(SDL_Gamepad *a, int b),(a,b),return)
 SDL_DYNAPI_PROC(int,SDL_GetNumGamepadTouchpads,(SDL_Gamepad *a),(a),return)
@@ -390,7 +372,6 @@ SDL_DYNAPI_PROC(char*,SDL_GetPrefPath,(const char *a, const char *b),(a,b),retur
 SDL_DYNAPI_PROC(SDL_Locale*,SDL_GetPreferredLocales,(void),(),return)
 SDL_DYNAPI_PROC(SDL_DisplayID,SDL_GetPrimaryDisplay,(void),(),return)
 SDL_DYNAPI_PROC(char*,SDL_GetPrimarySelectionText,(void),(),return)
-SDL_DYNAPI_PROC(Uint32,SDL_GetQueuedAudioSize,(SDL_AudioDeviceID a),(a),return)
 SDL_DYNAPI_PROC(void,SDL_GetRGB,(Uint32 a, const SDL_PixelFormat *b, Uint8 *c, Uint8 *d, Uint8 *e),(a,b,c,d,e),)
 SDL_DYNAPI_PROC(void,SDL_GetRGBA,(Uint32 a, const SDL_PixelFormat *b, Uint8 *c, Uint8 *d, Uint8 *e, Uint8 *f),(a,b,c,d,e,f),)
 SDL_DYNAPI_PROC(SDL_bool,SDL_GetRectAndLineIntersection,(const SDL_Rect *a, int *b, int *c, int *d, int *e),(a,b,c,d,e),return)
@@ -553,8 +534,6 @@ SDL_DYNAPI_PROC(void*,SDL_LoadFile,(const char *a, size_t *b),(a,b),return)
 SDL_DYNAPI_PROC(void*,SDL_LoadFile_RW,(SDL_RWops *a, size_t *b, SDL_bool c),(a,b,c),return)
 SDL_DYNAPI_PROC(SDL_FunctionPointer,SDL_LoadFunction,(void *a, const char *b),(a,b),return)
 SDL_DYNAPI_PROC(void*,SDL_LoadObject,(const char *a),(a),return)
-SDL_DYNAPI_PROC(SDL_AudioSpec*,SDL_LoadWAV_RW,(SDL_RWops *a, SDL_bool b, SDL_AudioSpec *c, Uint8 **d, Uint32 *e),(a,b,c,d,e),return)
-SDL_DYNAPI_PROC(int,SDL_LockAudioDevice,(SDL_AudioDeviceID a),(a),return)
 SDL_DYNAPI_PROC(void,SDL_LockJoysticks,(void),(),)
 SDL_DYNAPI_PROC(int,SDL_LockMutex,(SDL_Mutex *a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_LockRWLockForReading,(SDL_RWLock *a),(a),return)
@@ -578,7 +557,6 @@ SDL_DYNAPI_PROC(SDL_MetalView,SDL_Metal_CreateView,(SDL_Window *a),(a),return)
 SDL_DYNAPI_PROC(void,SDL_Metal_DestroyView,(SDL_MetalView a),(a),)
 SDL_DYNAPI_PROC(void*,SDL_Metal_GetLayer,(SDL_MetalView a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_MinimizeWindow,(SDL_Window *a),(a),return)
-SDL_DYNAPI_PROC(int,SDL_MixAudioFormat,(Uint8 *a, const Uint8 *b, SDL_AudioFormat c, Uint32 d, int e),(a,b,c,d,e),return)
 SDL_DYNAPI_PROC(int,SDL_MouseIsHaptic,(void),(),return)
 SDL_DYNAPI_PROC(int,SDL_NumHaptics,(void),(),return)
 SDL_DYNAPI_PROC(void,SDL_OnApplicationDidBecomeActive,(void),(),)
@@ -587,12 +565,10 @@ SDL_DYNAPI_PROC(void,SDL_OnApplicationDidReceiveMemoryWarning,(void),(),)
 SDL_DYNAPI_PROC(void,SDL_OnApplicationWillEnterForeground,(void),(),)
 SDL_DYNAPI_PROC(void,SDL_OnApplicationWillResignActive,(void),(),)
 SDL_DYNAPI_PROC(void,SDL_OnApplicationWillTerminate,(void),(),)
-SDL_DYNAPI_PROC(SDL_AudioDeviceID,SDL_OpenAudioDevice,(const char *a, int b, const SDL_AudioSpec *c, SDL_AudioSpec *d, int e),(a,b,c,d,e),return)
 SDL_DYNAPI_PROC(SDL_Gamepad*,SDL_OpenGamepad,(SDL_JoystickID a),(a),return)
 SDL_DYNAPI_PROC(SDL_Joystick*,SDL_OpenJoystick,(SDL_JoystickID a),(a),return)
 SDL_DYNAPI_PROC(SDL_Sensor*,SDL_OpenSensor,(SDL_SensorID a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_OpenURL,(const char *a),(a),return)
-SDL_DYNAPI_PROC(int,SDL_PauseAudioDevice,(SDL_AudioDeviceID a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_PeepEvents,(SDL_Event *a, int b, SDL_eventaction c, Uint32 d, Uint32 e),(a,b,c,d,e),return)
 SDL_DYNAPI_PROC(int,SDL_PlayAudioDevice,(SDL_AudioDeviceID a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_PollEvent,(SDL_Event *a),(a),return)
@@ -600,9 +576,7 @@ SDL_DYNAPI_PROC(int,SDL_PostSemaphore,(SDL_Semaphore *a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_PremultiplyAlpha,(int a, int b, Uint32 c, const void *d, int e, Uint32 f, void *g, int h),(a,b,c,d,e,f,g,h),return)
 SDL_DYNAPI_PROC(void,SDL_PumpEvents,(void),(),)
 SDL_DYNAPI_PROC(int,SDL_PushEvent,(SDL_Event *a),(a),return)
-SDL_DYNAPI_PROC(int,SDL_PutAudioStreamData,(SDL_AudioStream *a, const void *b, int c),(a,b,c),return)
 SDL_DYNAPI_PROC(int,SDL_QueryTexture,(SDL_Texture *a, Uint32 *b, int *c, int *d, int *e),(a,b,c,d,e),return)
-SDL_DYNAPI_PROC(int,SDL_QueueAudio,(SDL_AudioDeviceID a, const void *b, Uint32 c),(a,b,c),return)
 SDL_DYNAPI_PROC(void,SDL_Quit,(void),(),)
 SDL_DYNAPI_PROC(void,SDL_QuitSubSystem,(Uint32 a),(a),)
 SDL_DYNAPI_PROC(SDL_RWops*,SDL_RWFromConstMem,(const void *a, size_t b),(a,b),return)
@@ -751,7 +725,6 @@ SDL_DYNAPI_PROC(int,SDL_TryLockRWLockForReading,(SDL_RWLock *a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_TryLockRWLockForWriting,(SDL_RWLock *a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_TryWaitSemaphore,(SDL_Semaphore *a),(a),return)
 SDL_DYNAPI_PROC(void,SDL_UnloadObject,(void *a),(a),)
-SDL_DYNAPI_PROC(void,SDL_UnlockAudioDevice,(SDL_AudioDeviceID a),(a),)
 SDL_DYNAPI_PROC(void,SDL_UnlockJoysticks,(void),(),)
 SDL_DYNAPI_PROC(int,SDL_UnlockMutex,(SDL_Mutex *a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_UnlockRWLock,(SDL_RWLock *a),(a),return)
@@ -950,3 +923,30 @@ SDL_DYNAPI_PROC(size_t,SDL_wcsnlen,(const wchar_t *a, size_t b),(a,b),return)
 SDL_DYNAPI_PROC(size_t,SDL_strnlen,(const char *a, size_t b),(a,b),return)
 SDL_DYNAPI_PROC(int,SDL_AddGamepadMappingsFromFile,(const char *a),(a),return)
 SDL_DYNAPI_PROC(int,SDL_ReloadGamepadMappings,(void),(),return)
+SDL_DYNAPI_PROC(int,SDL_GetNumAudioDrivers,(void),(),return)
+SDL_DYNAPI_PROC(const char*,SDL_GetAudioDriver,(int a),(a),return)
+SDL_DYNAPI_PROC(const char*,SDL_GetCurrentAudioDriver,(void),(),return)
+SDL_DYNAPI_PROC(SDL_AudioDeviceID*,SDL_GetAudioOutputDevices,(int *a),(a),return)
+SDL_DYNAPI_PROC(SDL_AudioDeviceID*,SDL_GetAudioCaptureDevices,(int *a),(a),return)
+SDL_DYNAPI_PROC(char*,SDL_GetAudioDeviceName,(SDL_AudioDeviceID a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_GetAudioDeviceFormat,(SDL_AudioDeviceID a, SDL_AudioFormat *b, int *c, int *d),(a,b,c,d),return)
+SDL_DYNAPI_PROC(SDL_AudioDeviceID,SDL_OpenAudioDevice,(SDL_AudioDeviceID a, SDL_AudioFormat b, int c, int d),(a,b,c,d),return)
+SDL_DYNAPI_PROC(void,SDL_CloseAudioDevice,(SDL_AudioDeviceID a),(a),)
+SDL_DYNAPI_PROC(int,SDL_BindAudioStreams,(SDL_AudioDeviceID a, SDL_AudioStream **b, int c),(a,b,c),return)
+SDL_DYNAPI_PROC(int,SDL_BindAudioStream,(SDL_AudioDeviceID a, SDL_AudioStream *b),(a,b),return)
+SDL_DYNAPI_PROC(void,SDL_UnbindAudioStreams,(SDL_AudioStream **a, int b),(a,b),)
+SDL_DYNAPI_PROC(void,SDL_UnbindAudioStream,(SDL_AudioStream *a),(a),)
+SDL_DYNAPI_PROC(SDL_AudioStream*,SDL_CreateAudioStream,(SDL_AudioFormat a, int b, int c, SDL_AudioFormat d, int e, int f),(a,b,c,d,e,f),return)
+SDL_DYNAPI_PROC(int,SDL_GetAudioStreamFormat,(SDL_AudioStream *a, SDL_AudioFormat *b, int *c, int *d, SDL_AudioFormat *e, int *f, int *g),(a,b,c,d,e,f,g),return)
+SDL_DYNAPI_PROC(int,SDL_SetAudioStreamFormat,(SDL_AudioStream *a, SDL_AudioFormat b, int c, int d, SDL_AudioFormat e, int f, int g),(a,b,c,d,e,f,g),return)
+SDL_DYNAPI_PROC(int,SDL_PutAudioStreamData,(SDL_AudioStream *a, const void *b, int c),(a,b,c),return)
+SDL_DYNAPI_PROC(int,SDL_GetAudioStreamData,(SDL_AudioStream *a, void *b, int c),(a,b,c),return)
+SDL_DYNAPI_PROC(int,SDL_GetAudioStreamAvailable,(SDL_AudioStream *a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_FlushAudioStream,(SDL_AudioStream *a),(a),return)
+SDL_DYNAPI_PROC(int,SDL_ClearAudioStream,(SDL_AudioStream *a),(a),return)
+SDL_DYNAPI_PROC(void,SDL_DestroyAudioStream,(SDL_AudioStream *a),(a),)
+SDL_DYNAPI_PROC(SDL_AudioStream*,SDL_CreateAndBindAudioStream,(SDL_AudioDeviceID a, SDL_AudioFormat b, int c, int d),(a,b,c,d),return)
+SDL_DYNAPI_PROC(int,SDL_LoadWAV_RW,(SDL_RWops *a, int b, SDL_AudioFormat *c, int *d, int *e, Uint8 **f, Uint32 *g),(a,b,c,d,e,f,g),return)
+SDL_DYNAPI_PROC(int,SDL_MixAudioFormat,(Uint8 *a, const Uint8 *b, SDL_AudioFormat c, Uint32 d, int e),(a,b,c,d,e),return)
+SDL_DYNAPI_PROC(int,SDL_ConvertAudioSamples,(SDL_AudioFormat a, int b, int c, const Uint8 *d, int e, SDL_AudioFormat f, int g, int h, Uint8 **i, int *j),(a,b,c,d,e,f,g,h,i,j),return)
+SDL_DYNAPI_PROC(int,SDL_GetSilenceValueForFormat,(SDL_AudioFormat a),(a),return)

src/test/SDL_test_common.c

@@ -117,10 +117,9 @@ SDLTest_CommonState *SDLTest_CommonCreateState(char **argv, Uint32 flags)
     state->logical_presentation = SDL_LOGICAL_PRESENTATION_DISABLED;
     state->logical_scale_mode = SDL_SCALEMODE_LINEAR;
     state->num_windows = 1;
-    state->audiospec.freq = 22050;
-    state->audiospec.format = SDL_AUDIO_S16;
-    state->audiospec.channels = 2;
-    state->audiospec.samples = 2048;
+    state->audio_freq = 22050;
+    state->audio_format = SDL_AUDIO_S16;
+    state->audio_channels = 2;
 
     /* Set some very sane GL defaults */
     state->gl_red_size = 8;
@@ -604,7 +603,7 @@ int SDLTest_CommonArg(SDLTest_CommonState *state, int index)
             if (!argv[index]) {
                 return -1;
             }
-            state->audiospec.freq = SDL_atoi(argv[index]);
+            state->audio_freq = SDL_atoi(argv[index]);
             return 2;
         }
         if (SDL_strcasecmp(argv[index], "--format") == 0) {
@@ -613,23 +612,23 @@ int SDLTest_CommonArg(SDLTest_CommonState *state, int index)
                 return -1;
             }
             if (SDL_strcasecmp(argv[index], "U8") == 0) {
-                state->audiospec.format = SDL_AUDIO_U8;
+                state->audio_format = SDL_AUDIO_U8;
                 return 2;
             }
             if (SDL_strcasecmp(argv[index], "S8") == 0) {
-                state->audiospec.format = SDL_AUDIO_S8;
+                state->audio_format = SDL_AUDIO_S8;
                 return 2;
             }
             if (SDL_strcasecmp(argv[index], "S16") == 0) {
-                state->audiospec.format = SDL_AUDIO_S16;
+                state->audio_format = SDL_AUDIO_S16;
                 return 2;
             }
             if (SDL_strcasecmp(argv[index], "S16LE") == 0) {
-                state->audiospec.format = SDL_AUDIO_S16LSB;
+                state->audio_format = SDL_AUDIO_S16LSB;
                 return 2;
             }
             if (SDL_strcasecmp(argv[index], "S16BE") == 0) {
-                state->audiospec.format = SDL_AUDIO_S16MSB;
+                state->audio_format = SDL_AUDIO_S16MSB;
                 return 2;
             }
 
@@ -642,15 +641,7 @@ int SDLTest_CommonArg(SDLTest_CommonState *state, int index)
             if (!argv[index]) {
                 return -1;
             }
-            state->audiospec.channels = (Uint8) SDL_atoi(argv[index]);
-            return 2;
-        }
-        if (SDL_strcasecmp(argv[index], "--samples") == 0) {
-            ++index;
-            if (!argv[index]) {
-                return -1;
-            }
-            state->audiospec.samples = (Uint16) SDL_atoi(argv[index]);
+            state->audio_channels = (Uint8) SDL_atoi(argv[index]);
             return 2;
         }
     }
@@ -1452,7 +1443,7 @@ SDL_bool SDLTest_CommonInit(SDLTest_CommonState *state)
                     SDL_GetCurrentAudioDriver());
         }
 
-        state->audio_id = SDL_OpenAudioDevice(NULL, 0, &state->audiospec, NULL, 0);
+        state->audio_id = SDL_OpenAudioDevice(0, state->audio_format, state->audio_channels, state->audio_freq);
         if (!state->audio_id) {
             SDL_Log("Couldn't open audio: %s\n", SDL_GetError());
             return SDL_FALSE;

test/loopwave.c

@@ -28,13 +28,15 @@
 
 static struct
 {
-    SDL_AudioSpec spec;
+    SDL_AudioFormat fmt;
+    int channels;
+    int freq;
     Uint8 *sound;    /* Pointer to wave data */
     Uint32 soundlen; /* Length of wave data */
-    int soundpos;    /* Current play position */
 } wave;
 
 static SDL_AudioDeviceID device;
+static SDL_AudioStream *stream;
 
 /* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
 static void
@@ -51,6 +53,8 @@ static void
 close_audio(void)
 {
     if (device != 0) {
+        SDL_DestroyAudioStream(stream);
+        stream = NULL;
         SDL_CloseAudioDevice(device);
         device = 0;
     }
@@ -59,16 +63,21 @@ close_audio(void)
 static void
 open_audio(void)
 {
-    /* Initialize fillerup() variables */
-    device = SDL_OpenAudioDevice(NULL, SDL_FALSE, &wave.spec, NULL, 0);
+    SDL_AudioDeviceID *devices = SDL_GetAudioOutputDevices(NULL);
+    device = devices ? SDL_OpenAudioDevice(devices[0], wave.fmt, wave.channels, wave.freq) : 0;
+    SDL_free(devices);
     if (!device) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't open audio: %s\n", SDL_GetError());
         SDL_free(wave.sound);
         quit(2);
     }
-
-    /* Let the audio run */
-    SDL_PlayAudioDevice(device);
+    stream = SDL_CreateAndBindAudioStream(device, wave.fmt, wave.channels, wave.freq);
+    if (!stream) {
+        SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create audio stream: %s\n", SDL_GetError());
+        SDL_CloseAudioDevice(device);
+        SDL_free(wave.sound);
+        quit(2);
+    }
 }
 
 #ifndef __EMSCRIPTEN__
@@ -79,36 +88,24 @@ static void reopen_audio(void)
 }
 #endif
 
-static void SDLCALL
-fillerup(void *unused, Uint8 *stream, int len)
+
+static int done = 0;
+
+static void fillerup(void)
 {
-    Uint8 *waveptr;
-    int waveleft;
-
-    /* Set up the pointers */
-    waveptr = wave.sound + wave.soundpos;
-    waveleft = wave.soundlen - wave.soundpos;
-
-    /* Go! */
-    while (waveleft <= len) {
-        SDL_memcpy(stream, waveptr, waveleft);
-        stream += waveleft;
-        len -= waveleft;
-        waveptr = wave.sound;
-        waveleft = wave.soundlen;
-        wave.soundpos = 0;
+    if (SDL_GetAudioStreamAvailable(stream) < (wave.soundlen / 2)) {
+        SDL_PutAudioStreamData(stream, wave.sound, wave.soundlen);
     }
-    SDL_memcpy(stream, waveptr, len);
-    wave.soundpos += len;
 }
 
-static int done = 0;
 
 #ifdef __EMSCRIPTEN__
 static void loop(void)
 {
     if (done || (SDL_GetAudioDeviceStatus(device) != SDL_AUDIO_PLAYING)) {
         emscripten_cancel_main_loop();
+    } else {
+        fillerup();
     }
 }
 #endif
@@ -162,13 +159,11 @@ int main(int argc, char *argv[])
     }
 
     /* Load the wave file into memory */
-    if (SDL_LoadWAV(filename, &wave.spec, &wave.sound, &wave.soundlen) == NULL) {
+    if (SDL_LoadWAV(filename, &wave.fmt, &wave.channels, &wave.freq, &wave.sound, &wave.soundlen) == -1) {
         SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't load %s: %s\n", filename, SDL_GetError());
         quit(1);
     }
 
-    wave.spec.callback = fillerup;
-
     /* Show the list of available drivers */
     SDL_Log("Available audio drivers:");
     for (i = 0; i < SDL_GetNumAudioDrivers(); ++i) {
@@ -196,6 +191,8 @@ int main(int argc, char *argv[])
                 reopen_audio();
             }
         }
+
+        fillerup();
         SDL_Delay(100);
     }
 #endif