gosu 1.4.4 → 1.4.5

data/dependencies/SDL/include/SDL_thread.h

@@ -35,7 +35,7 @@
 #include "SDL_atomic.h"
 #include "SDL_mutex.h"
 
-#if defined(__WIN32__)
+#if defined(__WIN32__) || defined(__GDK__)
 #include <process.h> /* _beginthreadex() and _endthreadex() */
 #endif
 #if defined(__OS2__) /* for _beginthread() and _endthread() */
@@ -88,7 +88,7 @@ typedef enum {
 typedef int (SDLCALL * SDL_ThreadFunction) (void *data);
 
 
-#if defined(__WIN32__)
+#if defined(__WIN32__) || defined(__GDK__)
 /**
  *  \file SDL_thread.h
  *
@@ -129,7 +129,7 @@ SDL_CreateThread(SDL_ThreadFunction fn, const char *name, void *data,
                  pfnSDL_CurrentEndThread pfnEndThread);
 
 extern DECLSPEC SDL_Thread *SDLCALL
-SDL_CreateThreadWithStackSize(int (SDLCALL * fn) (void *),
+SDL_CreateThreadWithStackSize(SDL_ThreadFunction fn,
                  const char *name, const size_t stacksize, void *data,
                  pfnSDL_CurrentBeginThread pfnBeginThread,
                  pfnSDL_CurrentEndThread pfnEndThread);

data/dependencies/SDL/include/SDL_touch.h

@@ -95,6 +95,14 @@ extern DECLSPEC int SDLCALL SDL_GetNumTouchDevices(void);
  */
 extern DECLSPEC SDL_TouchID SDLCALL SDL_GetTouchDevice(int index);
 
+/**
+ * Get the touch device name as reported from the driver or NULL if the index
+ * is invalid.
+ *
+ * \since This function is available since SDL 2.0.22.
+ */
+extern DECLSPEC const char* SDLCALL SDL_GetTouchName(int index);
+
 /**
  * Get the type of the given touch device.
  *

data/dependencies/SDL/include/SDL_version.h

@@ -58,8 +58,8 @@ typedef struct SDL_version
 /* Printable format: "%d.%d.%d", MAJOR, MINOR, PATCHLEVEL
 */
 #define SDL_MAJOR_VERSION   2
-#define SDL_MINOR_VERSION   0
-#define SDL_PATCHLEVEL      20
+#define SDL_MINOR_VERSION   26
+#define SDL_PATCHLEVEL      1
 
 /**
  * Macro to determine SDL version program was compiled against.
@@ -83,6 +83,8 @@ typedef struct SDL_version
     (x)->patch = SDL_PATCHLEVEL;                    \
 }
 
+/* TODO: Remove this whole block in SDL 3 */
+#if SDL_MAJOR_VERSION < 3
 /**
  *  This macro turns the version numbers into a numeric value:
  *  \verbatim
@@ -90,21 +92,35 @@ typedef struct SDL_version
     \endverbatim
  *
  *  This assumes that there will never be more than 100 patchlevels.
+ *
+ *  In versions higher than 2.9.0, the minor version overflows into
+ *  the thousands digit: for example, 2.23.0 is encoded as 4300,
+ *  and 2.255.99 would be encoded as 25799.
+ *  This macro will not be available in SDL 3.x.
  */
 #define SDL_VERSIONNUM(X, Y, Z)                     \
     ((X)*1000 + (Y)*100 + (Z))
 
 /**
  *  This is the version number macro for the current SDL version.
+ *
+ *  In versions higher than 2.9.0, the minor version overflows into
+ *  the thousands digit: for example, 2.23.0 is encoded as 4300.
+ *  This macro will not be available in SDL 3.x.
+ *
+ *  Deprecated, use SDL_VERSION_ATLEAST or SDL_VERSION instead.
  */
 #define SDL_COMPILEDVERSION \
     SDL_VERSIONNUM(SDL_MAJOR_VERSION, SDL_MINOR_VERSION, SDL_PATCHLEVEL)
+#endif /* SDL_MAJOR_VERSION < 3 */
 
 /**
  *  This macro will evaluate to true if compiled with SDL at least X.Y.Z.
  */
 #define SDL_VERSION_ATLEAST(X, Y, Z) \
-    (SDL_COMPILEDVERSION >= SDL_VERSIONNUM(X, Y, Z))
+    ((SDL_MAJOR_VERSION >= X) && \
+     (SDL_MAJOR_VERSION > X || SDL_MINOR_VERSION >= Y) && \
+     (SDL_MAJOR_VERSION > X || SDL_MINOR_VERSION > Y || SDL_PATCHLEVEL >= Z))
 
 /**
  * Get the version of SDL that is linked against your program.

data/dependencies/SDL/include/SDL_video.h

@@ -248,7 +248,8 @@ typedef enum
     SDL_GL_FRAMEBUFFER_SRGB_CAPABLE,
     SDL_GL_CONTEXT_RELEASE_BEHAVIOR,
     SDL_GL_CONTEXT_RESET_NOTIFICATION,
-    SDL_GL_CONTEXT_NO_ERROR
+    SDL_GL_CONTEXT_NO_ERROR,
+    SDL_GL_FLOATBUFFERS
 } SDL_GLattr;
 
 typedef enum
@@ -444,6 +445,15 @@ extern DECLSPEC int SDLCALL SDL_GetDisplayUsableBounds(int displayIndex, SDL_Rec
  * A failure of this function usually means that either no DPI information is
  * available or the `displayIndex` is out of range.
  *
+ * **WARNING**: This reports the DPI that the hardware reports, and it is not
+ * always reliable! It is almost always better to use SDL_GetWindowSize() to
+ * find the window size, which might be in logical points instead of pixels,
+ * and then SDL_GL_GetDrawableSize(), SDL_Vulkan_GetDrawableSize(),
+ * SDL_Metal_GetDrawableSize(), or SDL_GetRendererOutputSize(), and compare
+ * the two values to get an actual scaling value between the two. We will be
+ * rethinking how high-dpi details should be managed in SDL3 to make things
+ * more consistent, reliable, and clear.
+ *
  * \param displayIndex the index of the display from which DPI information
  *                     should be queried
  * \param ddpi a pointer filled in with the diagonal DPI of the display; may
@@ -587,6 +597,35 @@ extern DECLSPEC int SDLCALL SDL_GetCurrentDisplayMode(int displayIndex, SDL_Disp
  */
 extern DECLSPEC SDL_DisplayMode * SDLCALL SDL_GetClosestDisplayMode(int displayIndex, const SDL_DisplayMode * mode, SDL_DisplayMode * closest);
 
+/**
+ * Get the index of the display containing a point
+ *
+ * \param point the point to query
+ * \returns the index of the display containing the point or a negative error
+ *          code on failure; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.24.0.
+ *
+ * \sa SDL_GetDisplayBounds
+ * \sa SDL_GetNumVideoDisplays
+ */
+extern DECLSPEC int SDLCALL SDL_GetPointDisplayIndex(const SDL_Point * point);
+
+/**
+ * Get the index of the display primarily containing a rect
+ *
+ * \param rect the rect to query
+ * \returns the index of the display entirely containing the rect or closest
+ *          to the center of the rect on success or a negative error code on
+ *          failure; call SDL_GetError() for more information.
+ *
+ * \since This function is available since SDL 2.24.0.
+ *
+ * \sa SDL_GetDisplayBounds
+ * \sa SDL_GetNumVideoDisplays
+ */
+extern DECLSPEC int SDLCALL SDL_GetRectDisplayIndex(const SDL_Rect * rect);
+
 /**
  * Get the index of the display associated with a window.
  *
@@ -697,7 +736,10 @@ extern DECLSPEC Uint32 SDLCALL SDL_GetWindowPixelFormat(SDL_Window * window);
  * in pixels may differ from its size in screen coordinates on platforms with
  * high-DPI support (e.g. iOS and macOS). Use SDL_GetWindowSize() to query the
  * client area's size in screen coordinates, and SDL_GL_GetDrawableSize() or
- * SDL_GetRendererOutputSize() to query the drawable size in pixels.
+ * SDL_GetRendererOutputSize() to query the drawable size in pixels. Note that
+ * when this flag is set, the drawable size can vary after the window is
+ * created and should be queried after major window events such as when the
+ * window is resized or moved between displays.
  *
  * If the window is set fullscreen, the width and height parameters `w` and
  * `h` will not be used. However, invalid size parameters (e.g. too large) may
@@ -1004,6 +1046,27 @@ extern DECLSPEC int SDLCALL SDL_GetWindowBordersSize(SDL_Window * window,
                                                      int *top, int *left,
                                                      int *bottom, int *right);
 
+/**
+ * Get the size of a window in pixels.
+ *
+ * This may differ from SDL_GetWindowSize() if we're rendering to a high-DPI
+ * drawable, i.e. the window was created with `SDL_WINDOW_ALLOW_HIGHDPI` on a
+ * platform with high-DPI support (Apple calls this "Retina"), and not
+ * disabled by the `SDL_HINT_VIDEO_HIGHDPI_DISABLED` hint.
+ *
+ * \param window the window from which the drawable size should be queried
+ * \param w a pointer to variable for storing the width in pixels, may be NULL
+ * \param h a pointer to variable for storing the height in pixels, may be
+ *          NULL
+ *
+ * \since This function is available since SDL 2.26.0.
+ *
+ * \sa SDL_CreateWindow
+ * \sa SDL_GetWindowSize
+ */
+extern DECLSPEC void SDLCALL SDL_GetWindowSizeInPixels(SDL_Window * window,
+                                                       int *w, int *h);
+
 /**
  * Set the minimum size of a window's client area.
  *
@@ -1337,6 +1400,7 @@ extern DECLSPEC void SDLCALL SDL_SetWindowKeyboardGrab(SDL_Window * window,
  * Mouse grab confines the mouse cursor to the window.
  *
  * \param window The window for which the mouse grab mode should be set.
+ * \param grabbed This is SDL_TRUE to grab mouse, and SDL_FALSE to release.
  *
  * \since This function is available since SDL 2.0.16.
  *
@@ -1747,6 +1811,9 @@ extern DECLSPEC void SDLCALL SDL_EnableScreenSaver(void);
  * If you disable the screensaver, it is automatically re-enabled when SDL
  * quits.
  *
+ * The screensaver is disabled by default since SDL 2.0.2. Before SDL 2.0.2
+ * the screensaver was enabled by default.
+ *
  * \since This function is available since SDL 2.0.0.
  *
  * \sa SDL_EnableScreenSaver
@@ -2008,13 +2075,8 @@ extern DECLSPEC void SDLCALL SDL_GL_GetDrawableSize(SDL_Window * window, int *w,
  * retry the call with 1 for the interval.
  *
  * Adaptive vsync is implemented for some glX drivers with
- * GLX_EXT_swap_control_tear:
- *
- * https://www.opengl.org/registry/specs/EXT/glx_swap_control_tear.txt
- *
- * and for some Windows drivers with WGL_EXT_swap_control_tear:
- *
- * https://www.opengl.org/registry/specs/EXT/wgl_swap_control_tear.txt
+ * GLX_EXT_swap_control_tear, and for some Windows drivers with
+ * WGL_EXT_swap_control_tear.
  *
  * Read more on the Khronos wiki:
  * https://www.khronos.org/opengl/wiki/Swap_Interval#Adaptive_Vsync

data/dependencies/SDL/include/begin_code.h

@@ -34,7 +34,7 @@
 #define _begin_code_h
 
 #ifndef SDL_DEPRECATED
-#  if (__GNUC__ >= 4)  /* technically, this arrived in gcc 3.1, but oh well. */
+#  if defined(__GNUC__) && (__GNUC__ >= 4)  /* technically, this arrived in gcc 3.1, but oh well. */
 #    define SDL_DEPRECATED __attribute__((deprecated))
 #  else
 #    define SDL_DEPRECATED
@@ -51,7 +51,7 @@
 
 /* Some compilers use a special export keyword */
 #ifndef DECLSPEC
-# if defined(__WIN32__) || defined(__WINRT__) || defined(__CYGWIN__)
+# if defined(__WIN32__) || defined(__WINRT__) || defined(__CYGWIN__) || defined(__GDK__)
 #  ifdef DLL_EXPORT
 #   define DECLSPEC __declspec(dllexport)
 #  else
@@ -74,7 +74,7 @@
 
 /* By default SDL uses the C calling convention */
 #ifndef SDLCALL
-#if (defined(__WIN32__) || defined(__WINRT__)) && !defined(__GNUC__)
+#if (defined(__WIN32__) || defined(__WINRT__) || defined(__GDK__)) && !defined(__GNUC__)
 #define SDLCALL __cdecl
 #elif defined(__OS2__) || defined(__EMX__)
 #define SDLCALL _System
@@ -107,7 +107,7 @@
 #ifdef __BORLANDC__
 #pragma nopackwarning
 #endif
-#ifdef _M_X64
+#ifdef _WIN64
 /* Use 8-byte alignment on 64-bit architectures, so pointers are aligned */
 #pragma pack(push,8)
 #else

data/dependencies/SDL_sound/SDL_sound.c

@@ -217,12 +217,6 @@ void Sound_ClearError(void)
 } /* Sound_ClearError */
 
 
-static void SDLCALL free_errmsg(void *errmsg)
-{
-    SDL_free(errmsg);
-} /* free_errmsg */
-
-
 /*
  * This is declared in the internal header.
  */
@@ -245,7 +239,7 @@ void __Sound_SetError(const char *str)
         if (err == NULL)
             return;   /* uhh...? */
 
-        SDL_TLSSet(tlsid_errmsg, err, free_errmsg);
+        SDL_TLSSet(tlsid_errmsg, err, SDL_free);
     } /* if */
 
     err->error_available = SDL_TRUE;
@@ -288,7 +282,8 @@ static Sound_Sample *alloc_sample(SDL_RWops *rw, Sound_AudioInfo *desired,
     } /* if */
 
     SDL_assert(bufferSize > 0);
-    retval->buffer = SDL_calloc(1, bufferSize);  /* pure ugly. */
+
+    retval->buffer = __Sound_SIMDAlloc(bufferSize);
     if (!retval->buffer)
     {
         __Sound_SetError(ERR_OUT_OF_MEMORY);
@@ -296,6 +291,7 @@ static Sound_Sample *alloc_sample(SDL_RWops *rw, Sound_AudioInfo *desired,
         SDL_free(retval);
         return NULL;
     } /* if */
+    SDL_memset(retval->buffer, '\0', bufferSize);
     retval->buffer_size = bufferSize;
 
     if (desired != NULL)
@@ -362,7 +358,8 @@ static int init_sample(const Sound_DecoderFunctions *funcs,
 
     /* success; we've got a decoder! */
 
-    /* Now we need to set up the conversion buffer... */
+    /* Now we need to set up an audio stream for data conversion if necessary... */
+    internal->stream = NULL;
 
     if (_desired == NULL)
         SDL_memcpy(&desired, &sample->actual, sizeof (Sound_AudioInfo));
@@ -371,40 +368,32 @@ static int init_sample(const Sound_DecoderFunctions *funcs,
         desired.format = _desired->format ? _desired->format : sample->actual.format;
         desired.channels = _desired->channels ? _desired->channels : sample->actual.channels;
         desired.rate = _desired->rate ? _desired->rate : sample->actual.rate;
-    } /* else */
-
-    if (SDL_BuildAudioCVT(&internal->sdlcvt,
-                            sample->actual.format,
-                            sample->actual.channels,
-                            sample->actual.rate,
-                            desired.format,
-                            desired.channels,
-                            desired.rate) == -1)
-    {
-        __Sound_SetError(SDL_GetError());
-        funcs->close(sample);
-        SDL_RWseek(internal->rw, pos, RW_SEEK_SET);     /* set for next try... */
-        return 0;
-    } /* if */
 
-    if (internal->sdlcvt.len_mult > 1)
-    {
-        void *rc = SDL_realloc(sample->buffer, sample->buffer_size * internal->sdlcvt.len_mult);
-        if (rc == NULL)
+        if ( (sample->actual.format != desired.format) ||
+             (sample->actual.channels != desired.channels) ||
+             (sample->actual.rate != desired.rate) )
         {
-            funcs->close(sample);
-            SDL_RWseek(internal->rw, pos, RW_SEEK_SET); /* set for next try... */
-            return 0;
+            internal->stream = SDL_NewAudioStream(sample->actual.format,
+                                                  sample->actual.channels,
+                                                  sample->actual.rate,
+                                                  desired.format,
+                                                  desired.channels,
+                                                  desired.rate);
+
+            if (internal->stream == NULL)
+            {
+                __Sound_SetError(SDL_GetError());
+                funcs->close(sample);
+                SDL_RWseek(internal->rw, pos, RW_SEEK_SET);     /* set for next try... */
+                return 0;
+            } /* if */
         } /* if */
-
-        sample->buffer = rc;
-    } /* if */
+    } /* else */
 
         /* these pointers are all one and the same. */
     SDL_memcpy(&sample->desired, &desired, sizeof (Sound_AudioInfo));
-    internal->sdlcvt.buf = internal->buffer = sample->buffer;
-    internal->buffer_size = sample->buffer_size / internal->sdlcvt.len_mult;
-    internal->sdlcvt.len = internal->buffer_size;
+    internal->buffer = sample->buffer;
+    internal->buffer_size = sample->buffer_size;
 
     /* Prepend our new Sound_Sample to the sample_list... */
     SDL_LockMutex(samplelist_mutex);
@@ -425,7 +414,7 @@ static int init_sample(const Sound_DecoderFunctions *funcs,
             sample->actual.channels));
 
     SNDDBG(("On-the-fly conversion: %s.\n",
-            internal->sdlcvt.needed ? "ENABLED" : "DISABLED"));
+            (internal->stream != NULL) ? "ENABLED" : "DISABLED"));
 
     return 1;
 } /* init_sample */
@@ -494,9 +483,14 @@ Sound_Sample *Sound_NewSample(SDL_RWops *rw, const char *ext,
     } /* for */
 
     /* nothing could handle the sound data... */
-    SDL_free(retval->opaque);
-    if (retval->buffer != NULL)
-        SDL_free(retval->buffer);
+    /* !!! FIXME: can we just push this through Sound_FreeSample() ? */
+    if (retval->opaque != NULL)
+    {
+        SDL_FreeAudioStream(((Sound_SampleInternal *) retval->opaque)->stream);
+        SDL_free(retval->opaque);
+    } /* if */
+
+    __Sound_SIMDFree(retval->buffer);
     SDL_free(retval);
     SDL_RWclose(rw);
     __Sound_SetError(ERR_UNSUPPORTED_FORMAT);
@@ -592,14 +586,9 @@ void Sound_FreeSample(Sound_Sample *sample)
     if (internal->rw != NULL)  /* this condition is a "just in case" thing. */
         SDL_RWclose(internal->rw);
 
-    if ((internal->buffer != NULL) && (internal->buffer != sample->buffer))
-        SDL_free(internal->buffer);
-
+    SDL_FreeAudioStream(internal->stream);
     SDL_free(internal);
-
-    if (sample->buffer != NULL)
-        SDL_free(sample->buffer);
-
+    __Sound_SIMDFree(sample->buffer);
     SDL_free(sample);
 } /* Sound_FreeSample */
 
@@ -612,13 +601,11 @@ int Sound_SetBufferSize(Sound_Sample *sample, Uint32 newSize)
     BAIL_IF_MACRO(!initialized, ERR_NOT_INITIALIZED, 0);
     BAIL_IF_MACRO(sample == NULL, ERR_INVALID_ARGUMENT, 0);
     internal = ((Sound_SampleInternal *) sample->opaque);
-    newBuf = SDL_realloc(sample->buffer, newSize * internal->sdlcvt.len_mult);
+    newBuf = __Sound_SIMDRealloc(sample->buffer, newSize);
     BAIL_IF_MACRO(newBuf == NULL, ERR_OUT_OF_MEMORY, 0);
 
-    internal->sdlcvt.buf = internal->buffer = sample->buffer = newBuf;
-    sample->buffer_size = newSize;
-    internal->buffer_size = newSize / internal->sdlcvt.len_mult;
-    internal->sdlcvt.len = internal->buffer_size;
+    internal->buffer = sample->buffer = newBuf;
+    internal->buffer_size = sample->buffer_size = newSize;
 
     return 1;
 } /* Sound_SetBufferSize */
@@ -627,7 +614,7 @@ int Sound_SetBufferSize(Sound_Sample *sample, Uint32 newSize)
 Uint32 Sound_Decode(Sound_Sample *sample)
 {
     Sound_SampleInternal *internal = NULL;
-    Uint32 retval = 0;
+    int available;
 
         /* a boatload of sanity checks... */
     BAIL_IF_MACRO(!initialized, ERR_NOT_INITIALIZED, 0);
@@ -642,18 +629,80 @@ Uint32 Sound_Decode(Sound_Sample *sample)
     SDL_assert(internal->buffer != NULL);
     SDL_assert(internal->buffer_size > 0);
 
+    /* No AudioStream? No conversion. Decode right into the buffer and return it. */
+    if (!internal->stream)
+    {
         /* reset EAGAIN. Decoder can flip it back on if it needs to. */
-    sample->flags &= ~SOUND_SAMPLEFLAG_EAGAIN;
-    retval = internal->funcs->read(sample);
+        sample->flags &= ~SOUND_SAMPLEFLAG_EAGAIN;
+        return internal->funcs->read(sample);
+    } /* if */
 
-    if (retval > 0 && internal->sdlcvt.needed)
+    /* call into the decoder several times until we have enough data. */
+    while ((available = SDL_AudioStreamAvailable(internal->stream)) < internal->buffer_size)
     {
-        internal->sdlcvt.len = retval;
-        SDL_ConvertAudio(&internal->sdlcvt);
-        retval = internal->sdlcvt.len_cvt;
+        SDL_bool flush_stream = SDL_FALSE;
+        Uint32 br;
+
+        if (internal->pending_eof || internal->pending_error)
+            break;
+
+        /* reset EAGAIN. Decoder can flip it back on if it needs to. */
+        sample->flags &= ~SOUND_SAMPLEFLAG_EAGAIN;
+        br = internal->funcs->read(sample);
+
+        /* if the sample hit an error or EOF, note it, but don't let these flags
+           be set for the calling app until the stream is empty too. */
+        if (sample->flags & SOUND_SAMPLEFLAG_EOF)
+        {
+            sample->flags &= ~SOUND_SAMPLEFLAG_EOF;
+            internal->pending_eof = SDL_TRUE;
+            flush_stream = SDL_TRUE;
+        } /* if */
+
+        if (sample->flags & SOUND_SAMPLEFLAG_ERROR)
+        {
+            sample->flags &= ~SOUND_SAMPLEFLAG_ERROR;
+            internal->pending_error = SDL_TRUE;
+            flush_stream = SDL_TRUE;
+        } /* if */
+
+        if ((br > 0) && (SDL_AudioStreamPut(internal->stream, internal->buffer, (int) br) == -1))
+        {
+            __Sound_SetError(SDL_GetError());
+            sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+            return 0;  /* oh well. */
+        } /* if */
+
+        if (flush_stream)
+            SDL_AudioStreamFlush(internal->stream);
+    } /* while */
+
+    /* if we hit eof or error, drain the stream before reporting that. */
+    if (available > 0)
+    {
+        const int readlen = SDL_min(available, sample->buffer_size);
+        const int br = SDL_AudioStreamGet(internal->stream, sample->buffer, readlen);
+        if (br != readlen)
+        {
+            __Sound_SetError(SDL_GetError());
+            sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+            return 0;  /* oh well. */
+        } /* if */
+
+        SDL_assert(br > 0);
+        return (Uint32) br;
     } /* if */
 
-    return retval;
+    /* stream is empty, set final flags. */
+    if (internal->pending_eof)
+        sample->flags |= SOUND_SAMPLEFLAG_EOF;
+
+    if (internal->pending_error)
+        sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+
+    internal->pending_eof = internal->pending_error = SDL_FALSE;
+
+    return 0;
 } /* Sound_Decode */
 
 
@@ -673,7 +722,7 @@ Uint32 Sound_DecodeAll(Sound_Sample *sample)
             ((sample->flags & SOUND_SAMPLEFLAG_ERROR) == 0) )
     {
         Uint32 br = Sound_Decode(sample);
-        void *ptr = SDL_realloc(buf, newBufSize + br);
+        void *ptr = __Sound_SIMDRealloc(buf, newBufSize + br);
         if (ptr == NULL)
         {
             sample->flags |= SOUND_SAMPLEFLAG_ERROR;
@@ -687,18 +736,13 @@ Uint32 Sound_DecodeAll(Sound_Sample *sample)
         } /* else */
     } /* while */
 
-    if (buf == NULL)  /* ...in case first call to SDL_realloc() fails... */
+    if (buf == NULL)  /* ...in case first call to __Sound_SIMDRealloc() fails... */
         return sample->buffer_size;
 
-    if (internal->buffer != sample->buffer)
-        SDL_free(internal->buffer);
-
-    SDL_free(sample->buffer);
+    __Sound_SIMDFree(sample->buffer);
 
-    internal->sdlcvt.buf = internal->buffer = sample->buffer = buf;
-    sample->buffer_size = newBufSize;
-    internal->buffer_size = newBufSize / internal->sdlcvt.len_mult;
-    internal->sdlcvt.len = internal->buffer_size;
+    internal->buffer = sample->buffer = buf;
+    internal->buffer_size = sample->buffer_size = newBufSize;
 
     return newBufSize;
 } /* Sound_DecodeAll */
@@ -825,5 +869,100 @@ char *__Sound_strtokr(char *s1, const char *s2, char **ptr)
 }
 #endif
 
+
+/* This falls back to an included copy/paste of SDL's SIMDAlloc code if you aren't using a new enough SDL.
+   To keep this simple, the included copy assumes you need to align to 64 bytes, which is a little
+   wasteful but should work on everything from MMX to AVX-512. The real SDL checks the CPU at runtime
+   to decide what's available and aligns to smaller numbers if all you have is SSE, Altivec or NEON.
+   Not to mention this is just a second copy of the code that doesn't get attention...you should really
+   upgrade your SDL. Ideally this copy goes away at some point. */
+
+#define USE_REAL_SDL_SIMDALLOC SDL_VERSION_ATLEAST(2, 0, 14)
+
+void *__Sound_SIMDAlloc(const size_t len)
+{
+#if USE_REAL_SDL_SIMDALLOC
+    return SDL_SIMDAlloc(len);
+#else
+    const size_t alignment = 64;
+    const size_t padding = alignment - (len % alignment);
+    const size_t padded = (padding != alignment) ? (len + padding) : len;
+    Uint8 *retval = NULL;
+    Uint8 *ptr = (Uint8 *) SDL_malloc(padded + alignment + sizeof (void *));
+    if (ptr) {
+        /* store the actual allocated pointer right before our aligned pointer. */
+        retval = ptr + sizeof (void *);
+        retval += alignment - (((size_t) retval) % alignment);
+        *(((void **) retval) - 1) = ptr;
+    }
+    return retval;
+#endif
+}
+
+void *__Sound_SIMDRealloc(void *mem, const size_t len)
+{
+#if USE_REAL_SDL_SIMDALLOC
+    return SDL_SIMDRealloc(mem, len);
+#else
+    const size_t alignment = 64;
+    const size_t padding = alignment - (len % alignment);
+    const size_t padded = (padding != alignment) ? (len + padding) : len;
+    Uint8 *retval = (Uint8*) mem;
+    void *oldmem = mem;
+    size_t memdiff = 0, ptrdiff;
+    Uint8 *ptr;
+
+    if (mem) {
+        void **realptr = (void **) mem;
+        realptr--;
+        mem = *(((void **) mem) - 1);
+
+        /* Check the delta between the real pointer and user pointer */
+        memdiff = ((size_t) oldmem) - ((size_t) mem);
+    }
+
+    ptr = (Uint8 *) SDL_realloc(mem, padded + alignment + sizeof (void *));
+
+    if (ptr == NULL) {
+        return NULL; /* Out of memory, bail! */
+    }
+
+    /* Store the actual allocated pointer right before our aligned pointer. */
+    retval = ptr + sizeof (void *);
+    retval += alignment - (((size_t) retval) % alignment);
+
+    /* Make sure the delta is the same! */
+    if (mem) {
+        ptrdiff = ((size_t) retval) - ((size_t) ptr);
+        if (memdiff != ptrdiff) { /* Delta has changed, copy to new offset! */
+            oldmem = (void*) (((uintptr_t) ptr) + memdiff);
+
+            /* Even though the data past the old `len` is undefined, this is the
+             * only length value we have, and it guarantees that we copy all the
+             * previous memory anyhow.
+             */
+            SDL_memmove(retval, oldmem, len);
+        }
+    }
+
+    /* Actually store the allocated pointer, finally. */
+    *(((void **) retval) - 1) = ptr;
+    return retval;
+#endif
+}
+
+void __Sound_SIMDFree(void *ptr)
+{
+#if USE_REAL_SDL_SIMDALLOC
+    SDL_SIMDFree(ptr);
+#else
+    if (ptr) {
+        void **realptr = (void **) ptr;
+        realptr--;
+        SDL_free(*(((void **) ptr) - 1));
+    }
+#endif
+}
+
 /* end of SDL_sound.c ... */
 

data/dependencies/SDL_sound/SDL_sound.h

@@ -72,7 +72,7 @@ extern "C" {
 
 #define SOUND_VER_MAJOR 2
 #define SOUND_VER_MINOR 0
-#define SOUND_VER_PATCH 0
+#define SOUND_VER_PATCH 1
 #endif