diff --git a/src/audio/SDL_audio.c b/src/audio/SDL_audio.c
index 659628df4..372660ba1 100644
--- a/src/audio/SDL_audio.c
+++ b/src/audio/SDL_audio.c
@@ -286,10 +286,10 @@ SDL_UnlockAudio_Default(SDL_AudioDevice * audio)
     SDL_mutexV(audio->mixer_lock);
 }
 
-static Uint16
+static SDL_AudioFormat
 SDL_ParseAudioFormat(const char *string)
 {
-    Uint16 format = 0;
+    SDL_AudioFormat format = 0;
 
     switch (*string) {
     case 'U':
@@ -740,26 +740,34 @@ SDL_AudioQuit(void)
     }
 }
 
-#define NUM_FORMATS	6
+#define NUM_FORMATS 10
 static int format_idx;
 static int format_idx_sub;
-static Uint16 format_list[NUM_FORMATS][NUM_FORMATS] = {
+static SDL_AudioFormat format_list[NUM_FORMATS][NUM_FORMATS] = {
     {AUDIO_U8, AUDIO_S8, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB,
-     AUDIO_U16MSB},
+     AUDIO_U16MSB, AUDIO_S32LSB, AUDIO_S32MSB, AUDIO_F32LSB, AUDIO_F32MSB},
     {AUDIO_S8, AUDIO_U8, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB,
-     AUDIO_U16MSB},
-    {AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_U8,
-     AUDIO_S8},
-    {AUDIO_S16MSB, AUDIO_S16LSB, AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_U8,
-     AUDIO_S8},
-    {AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U8,
-     AUDIO_S8},
-    {AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_S16MSB, AUDIO_S16LSB, AUDIO_U8,
-     AUDIO_S8},
+     AUDIO_U16MSB, AUDIO_S32LSB, AUDIO_S32MSB, AUDIO_F32LSB, AUDIO_F32MSB},
+    {AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_S32LSB,
+     AUDIO_S32MSB, AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_U8, AUDIO_S8},
+    {AUDIO_S16MSB, AUDIO_S16LSB, AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_S32MSB,
+     AUDIO_S32LSB, AUDIO_F32MSB, AUDIO_F32LSB, AUDIO_U8, AUDIO_S8},
+    {AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_S32LSB,
+     AUDIO_S32MSB, AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_U8, AUDIO_S8},
+    {AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_S16MSB, AUDIO_S16LSB, AUDIO_S32MSB,
+     AUDIO_S32LSB, AUDIO_F32MSB, AUDIO_F32LSB, AUDIO_U8, AUDIO_S8},
+    {AUDIO_S32LSB, AUDIO_S32MSB, AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_S16LSB,
+     AUDIO_S16MSB, AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_U8, AUDIO_S8},
+    {AUDIO_S32MSB, AUDIO_S32LSB, AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_S16MSB,
+     AUDIO_S16LSB, AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_U8, AUDIO_S8},
+    {AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_S32LSB, AUDIO_S32MSB, AUDIO_U16LSB,
+     AUDIO_U16MSB, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U8, AUDIO_S8},
+    {AUDIO_F32MSB, AUDIO_F32LSB, AUDIO_S32MSB, AUDIO_S32LSB, AUDIO_U16MSB,
+     AUDIO_U16LSB, AUDIO_S16MSB, AUDIO_S16LSB, AUDIO_U8, AUDIO_S8},
 };
 
-Uint16
-SDL_FirstAudioFormat(Uint16 format)
+SDL_AudioFormat
+SDL_FirstAudioFormat(SDL_AudioFormat format)
 {
     for (format_idx = 0; format_idx < NUM_FORMATS; ++format_idx) {
         if (format_list[format_idx][0] == format) {
@@ -770,7 +778,7 @@ SDL_FirstAudioFormat(Uint16 format)
     return (SDL_NextAudioFormat());
 }
 
-Uint16
+SDL_AudioFormat
 SDL_NextAudioFormat(void)
 {
     if ((format_idx == NUM_FORMATS) || (format_idx_sub == NUM_FORMATS)) {
diff --git a/src/audio/SDL_audio_c.h b/src/audio/SDL_audio_c.h
index 3aa181204..f49fbd42d 100644
--- a/src/audio/SDL_audio_c.h
+++ b/src/audio/SDL_audio_c.h
@@ -24,12 +24,22 @@
 /* Functions and variables exported from SDL_audio.c for SDL_sysaudio.c */
 
 /* Functions to get a list of "close" audio formats */
-extern Uint16 SDL_FirstAudioFormat(Uint16 format);
-extern Uint16 SDL_NextAudioFormat(void);
+extern SDL_AudioFormat SDL_FirstAudioFormat(SDL_AudioFormat format);
+extern SDL_AudioFormat SDL_NextAudioFormat(void);
 
 /* Function to calculate the size and silence for a SDL_AudioSpec */
 extern void SDL_CalculateAudioSpec(SDL_AudioSpec * spec);
 
 /* The actual mixing thread function */
 extern int SDLCALL SDL_RunAudio(void *audiop);
+
+/* this is used internally to access some autogenerated code. */
+typedef struct
+{
+    SDL_AudioFormat src_fmt;
+    SDL_AudioFormat dst_fmt;
+    SDL_AudioFilter filter;
+} SDL_AudioTypeFilters;
+extern const SDL_AudioTypeFilters sdl_audio_type_filters[];
+
 /* vi: set ts=4 sw=4 expandtab: */
diff --git a/src/audio/SDL_audiocvt.c b/src/audio/SDL_audiocvt.c
index bf310e484..ba98a5051 100644
--- a/src/audio/SDL_audiocvt.c
+++ b/src/audio/SDL_audiocvt.c
@@ -24,11 +24,11 @@
 /* Functions for audio drivers to perform runtime conversion of audio format */
 
 #include "SDL_audio.h"
-
+#include "SDL_audio_c.h"
 
 /* Effectively mix right and left channels into a single channel */
-void SDLCALL
-SDL_ConvertMono(SDL_AudioCVT * cvt, Uint16 format)
+static void SDLCALL
+SDL_ConvertMono(SDL_AudioCVT * cvt, SDL_AudioFormat format)
 {
     int i;
     Sint32 sample;
@@ -36,8 +36,7 @@ SDL_ConvertMono(SDL_AudioCVT * cvt, Uint16 format)
 #ifdef DEBUG_CONVERT
     fprintf(stderr, "Converting to mono\n");
 #endif
-    switch (format & 0x8018) {
-
+    switch (format & (SDL_AUDIO_MASK_SIGNED|SDL_AUDIO_MASK_BITSIZE)) {
     case AUDIO_U8:
         {
             Uint8 *src, *dst;
@@ -84,7 +83,7 @@ SDL_ConvertMono(SDL_AudioCVT * cvt, Uint16 format)
 
             src = cvt->buf;
             dst = cvt->buf;
-            if ((format & 0x1000) == 0x1000) {
+            if (SDL_AUDIO_ISBIGENDIAN(format)) {
                 for (i = cvt->len_cvt / 4; i; --i) {
                     sample = (Uint16) ((src[0] << 8) | src[1]) +
                         (Uint16) ((src[2] << 8) | src[3]);
@@ -124,7 +123,7 @@ SDL_ConvertMono(SDL_AudioCVT * cvt, Uint16 format)
 
             src = cvt->buf;
             dst = cvt->buf;
-            if ((format & 0x1000) == 0x1000) {
+            if (SDL_AUDIO_ISBIGENDIAN(format)) {
                 for (i = cvt->len_cvt / 4; i; --i) {
                     sample = (Sint16) ((src[0] << 8) | src[1]) +
                         (Sint16) ((src[2] << 8) | src[3]);
@@ -163,127 +162,106 @@ SDL_ConvertMono(SDL_AudioCVT * cvt, Uint16 format)
             }
         }
         break;
+
+    case AUDIO_S32:
+        {
+            const Uint32 *src = (const Uint32 *) cvt->buf;
+            Uint32 *dst = (Uint32 *) cvt->buf;
+            if (SDL_AUDIO_ISBIGENDIAN(format)) {
+                for (i = cvt->len_cvt / 8; i; --i, src += 2) {
+                    const Sint64 added =
+                                    (((Sint64) (Sint32) SDL_SwapBE32(src[0])) +
+                                     ((Sint64) (Sint32) SDL_SwapBE32(src[1])));
+                    *(dst++) = SDL_SwapBE32((Uint32) ((Sint32) (added >> 1)));
+                }
+            } else {
+                for (i = cvt->len_cvt / 8; i; --i, src += 2) {
+                    const Sint64 added =
+                                    (((Sint64) (Sint32) SDL_SwapLE32(src[0])) +
+                                     ((Sint64) (Sint32) SDL_SwapLE32(src[1])));
+                    *(dst++) = SDL_SwapLE32((Uint32) ((Sint32) (added >> 1)));
+                }
+            }
+        }
+        break;
+
+    case AUDIO_F32:
+        {
+            /* !!! FIXME: this convert union is nasty. */
+            union { float f; Uint32 ui32; } f2i;
+            const Uint32 *src = (const Uint32 *) cvt->buf;
+            Uint32 *dst = (Uint32 *) cvt->buf;
+            if (SDL_AUDIO_ISBIGENDIAN(format)) {
+                for (i = cvt->len_cvt / 8; i; --i, src += 2) {
+                    float src1, src2;
+                    f2i.ui32 = SDL_SwapBE32(src[0]);
+                    src1 = f2i.f;
+                    f2i.ui32 = SDL_SwapBE32(src[1]);
+                    src2 = f2i.f;
+                    const double added = ((double) src1) + ((double) src2);
+                    f2i.f = (float) (added * 0.5);
+                    *(dst++) = SDL_SwapBE32(f2i.ui32);
+                }
+            } else {
+                for (i = cvt->len_cvt / 8; i; --i, src += 2) {
+                    float src1, src2;
+                    f2i.ui32 = SDL_SwapLE32(src[0]);
+                    src1 = f2i.f;
+                    f2i.ui32 = SDL_SwapLE32(src[1]);
+                    src2 = f2i.f;
+                    const double added = ((double) src1) + ((double) src2);
+                    f2i.f = (float) (added * 0.5);
+                    *(dst++) = SDL_SwapLE32(f2i.ui32);
+                }
+            }
+        }
+        break;
     }
+
     cvt->len_cvt /= 2;
     if (cvt->filters[++cvt->filter_index]) {
         cvt->filters[cvt->filter_index] (cvt, format);
     }
 }
 
+
 /* Discard top 4 channels */
-void SDLCALL
-SDL_ConvertStrip(SDL_AudioCVT * cvt, Uint16 format)
+static void SDLCALL
+SDL_ConvertStrip(SDL_AudioCVT * cvt, SDL_AudioFormat format)
 {
     int i;
-    Sint32 lsample, rsample;
 
 #ifdef DEBUG_CONVERT
-    fprintf(stderr, "Converting down to stereo\n");
+    fprintf(stderr, "Converting down from 6 channels to stereo\n");
 #endif
-    switch (format & 0x8018) {
 
-    case AUDIO_U8:
-        {
-            Uint8 *src, *dst;
-
-            src = cvt->buf;
-            dst = cvt->buf;
-            for (i = cvt->len_cvt / 6; i; --i) {
-                dst[0] = src[0];
-                dst[1] = src[1];
-                src += 6;
-                dst += 2;
-            }
-        }
-        break;
-
-    case AUDIO_S8:
-        {
-            Sint8 *src, *dst;
-
-            src = (Sint8 *) cvt->buf;
-            dst = (Sint8 *) cvt->buf;
-            for (i = cvt->len_cvt / 6; i; --i) {
-                dst[0] = src[0];
-                dst[1] = src[1];
-                src += 6;
-                dst += 2;
-            }
-        }
-        break;
-
-    case AUDIO_U16:
-        {
-            Uint8 *src, *dst;
-
-            src = cvt->buf;
-            dst = cvt->buf;
-            if ((format & 0x1000) == 0x1000) {
-                for (i = cvt->len_cvt / 12; i; --i) {
-                    lsample = (Uint16) ((src[0] << 8) | src[1]);
-                    rsample = (Uint16) ((src[2] << 8) | src[3]);
-                    dst[1] = (lsample & 0xFF);
-                    lsample >>= 8;
-                    dst[0] = (lsample & 0xFF);
-                    dst[3] = (rsample & 0xFF);
-                    rsample >>= 8;
-                    dst[2] = (rsample & 0xFF);
-                    src += 12;
-                    dst += 4;
-                }
-            } else {
-                for (i = cvt->len_cvt / 12; i; --i) {
-                    lsample = (Uint16) ((src[1] << 8) | src[0]);
-                    rsample = (Uint16) ((src[3] << 8) | src[2]);
-                    dst[0] = (lsample & 0xFF);
-                    lsample >>= 8;
-                    dst[1] = (lsample & 0xFF);
-                    dst[2] = (rsample & 0xFF);
-                    rsample >>= 8;
-                    dst[3] = (rsample & 0xFF);
-                    src += 12;
-                    dst += 4;
-                }
-            }
-        }
-        break;
-
-    case AUDIO_S16:
-        {
-            Uint8 *src, *dst;
-
-            src = cvt->buf;
-            dst = cvt->buf;
-            if ((format & 0x1000) == 0x1000) {
-                for (i = cvt->len_cvt / 12; i; --i) {
-                    lsample = (Sint16) ((src[0] << 8) | src[1]);
-                    rsample = (Sint16) ((src[2] << 8) | src[3]);
-                    dst[1] = (lsample & 0xFF);
-                    lsample >>= 8;
-                    dst[0] = (lsample & 0xFF);
-                    dst[3] = (rsample & 0xFF);
-                    rsample >>= 8;
-                    dst[2] = (rsample & 0xFF);
-                    src += 12;
-                    dst += 4;
-                }
-            } else {
-                for (i = cvt->len_cvt / 12; i; --i) {
-                    lsample = (Sint16) ((src[1] << 8) | src[0]);
-                    rsample = (Sint16) ((src[3] << 8) | src[2]);
-                    dst[0] = (lsample & 0xFF);
-                    lsample >>= 8;
-                    dst[1] = (lsample & 0xFF);
-                    dst[2] = (rsample & 0xFF);
-                    rsample >>= 8;
-                    dst[3] = (rsample & 0xFF);
-                    src += 12;
-                    dst += 4;
-                }
-            }
-        }
-        break;
+    #define strip_chans_6_to_2(type) \
+    { \
+        const type *src = (const type *) cvt->buf; \
+        type *dst = (type *) cvt->buf; \
+        for (i = cvt->len_cvt / (sizeof (type) * 6); i; --i) { \
+            dst[0] = src[0]; \
+            dst[1] = src[1]; \
+            src += 6; \
+            dst += 2; \
+        } \
     }
+
+    /* this function only cares about typesize, and data as a block of bits. */
+    switch (SDL_AUDIO_BITSIZE(format)) {
+        case 8:
+            strip_chans_6_to_2(Uint8);
+            break;
+        case 16:
+            strip_chans_6_to_2(Uint16);
+            break;
+        case 32:
+            strip_chans_6_to_2(Uint32);
+            break;
+    }
+
+    #undef strip_chans_6_to_2
+
     cvt->len_cvt /= 3;
     if (cvt->filters[++cvt->filter_index]) {
         cvt->filters[cvt->filter_index] (cvt, format);
@@ -292,157 +270,87 @@ SDL_ConvertStrip(SDL_AudioCVT * cvt, Uint16 format)
 
 
 /* Discard top 2 channels of 6 */
-void SDLCALL
-SDL_ConvertStrip_2(SDL_AudioCVT * cvt, Uint16 format)
+static void SDLCALL
+SDL_ConvertStrip_2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
 {
     int i;
-    Sint32 lsample, rsample;
 
 #ifdef DEBUG_CONVERT
     fprintf(stderr, "Converting 6 down to quad\n");
 #endif
-    switch (format & 0x8018) {
 
-    case AUDIO_U8:
-        {
-            Uint8 *src, *dst;
-
-            src = cvt->buf;
-            dst = cvt->buf;
-            for (i = cvt->len_cvt / 4; i; --i) {
-                dst[0] = src[0];
-                dst[1] = src[1];
-                src += 4;
-                dst += 2;
-            }
-        }
-        break;
-
-    case AUDIO_S8:
-        {
-            Sint8 *src, *dst;
-
-            src = (Sint8 *) cvt->buf;
-            dst = (Sint8 *) cvt->buf;
-            for (i = cvt->len_cvt / 4; i; --i) {
-                dst[0] = src[0];
-                dst[1] = src[1];
-                src += 4;
-                dst += 2;
-            }
-        }
-        break;
-
-    case AUDIO_U16:
-        {
-            Uint8 *src, *dst;
-
-            src = cvt->buf;
-            dst = cvt->buf;
-            if ((format & 0x1000) == 0x1000) {
-                for (i = cvt->len_cvt / 8; i; --i) {
-                    lsample = (Uint16) ((src[0] << 8) | src[1]);
-                    rsample = (Uint16) ((src[2] << 8) | src[3]);
-                    dst[1] = (lsample & 0xFF);
-                    lsample >>= 8;
-                    dst[0] = (lsample & 0xFF);
-                    dst[3] = (rsample & 0xFF);
-                    rsample >>= 8;
-                    dst[2] = (rsample & 0xFF);
-                    src += 8;
-                    dst += 4;
-                }
-            } else {
-                for (i = cvt->len_cvt / 8; i; --i) {
-                    lsample = (Uint16) ((src[1] << 8) | src[0]);
-                    rsample = (Uint16) ((src[3] << 8) | src[2]);
-                    dst[0] = (lsample & 0xFF);
-                    lsample >>= 8;
-                    dst[1] = (lsample & 0xFF);
-                    dst[2] = (rsample & 0xFF);
-                    rsample >>= 8;
-                    dst[3] = (rsample & 0xFF);
-                    src += 8;
-                    dst += 4;
-                }
-            }
-        }
-        break;
-
-    case AUDIO_S16:
-        {
-            Uint8 *src, *dst;
-
-            src = cvt->buf;
-            dst = cvt->buf;
-            if ((format & 0x1000) == 0x1000) {
-                for (i = cvt->len_cvt / 8; i; --i) {
-                    lsample = (Sint16) ((src[0] << 8) | src[1]);
-                    rsample = (Sint16) ((src[2] << 8) | src[3]);
-                    dst[1] = (lsample & 0xFF);
-                    lsample >>= 8;
-                    dst[0] = (lsample & 0xFF);
-                    dst[3] = (rsample & 0xFF);
-                    rsample >>= 8;
-                    dst[2] = (rsample & 0xFF);
-                    src += 8;
-                    dst += 4;
-                }
-            } else {
-                for (i = cvt->len_cvt / 8; i; --i) {
-                    lsample = (Sint16) ((src[1] << 8) | src[0]);
-                    rsample = (Sint16) ((src[3] << 8) | src[2]);
-                    dst[0] = (lsample & 0xFF);
-                    lsample >>= 8;
-                    dst[1] = (lsample & 0xFF);
-                    dst[2] = (rsample & 0xFF);
-                    rsample >>= 8;
-                    dst[3] = (rsample & 0xFF);
-                    src += 8;
-                    dst += 4;
-                }
-            }
-        }
-        break;
+    #define strip_chans_6_to_4(type) \
+    { \
+        const type *src = (const type *) cvt->buf; \
+        type *dst = (type *) cvt->buf; \
+        for (i = cvt->len_cvt / (sizeof (type) * 6); i; --i) { \
+            dst[0] = src[0]; \
+            dst[1] = src[1]; \
+            dst[2] = src[2]; \
+            dst[3] = src[3]; \
+            src += 6; \
+            dst += 4; \
+        } \
     }
-    cvt->len_cvt /= 2;
+
+    /* this function only cares about typesize, and data as a block of bits. */
+    switch (SDL_AUDIO_BITSIZE(format)) {
+        case 8:
+            strip_chans_6_to_4(Uint8);
+            break;
+        case 16:
+            strip_chans_6_to_4(Uint16);
+            break;
+        case 32:
+            strip_chans_6_to_4(Uint32);
+            break;
+    }
+
+    #undef strip_chans_6_to_4
+
+    cvt->len_cvt /= 6;
+    cvt->len_cvt *= 4;
     if (cvt->filters[++cvt->filter_index]) {
         cvt->filters[cvt->filter_index] (cvt, format);
     }
 }
 
 /* Duplicate a mono channel to both stereo channels */
-void SDLCALL
-SDL_ConvertStereo(SDL_AudioCVT * cvt, Uint16 format)
+static void SDLCALL
+SDL_ConvertStereo(SDL_AudioCVT * cvt, SDL_AudioFormat format)
 {
     int i;
 
 #ifdef DEBUG_CONVERT
     fprintf(stderr, "Converting to stereo\n");
 #endif
-    if ((format & 0xFF) == 16) {
-        Uint16 *src, *dst;
 
-        src = (Uint16 *) (cvt->buf + cvt->len_cvt);
-        dst = (Uint16 *) (cvt->buf + cvt->len_cvt * 2);
-        for (i = cvt->len_cvt / 2; i; --i) {
-            dst -= 2;
-            src -= 1;
-            dst[0] = src[0];
-            dst[1] = src[0];
-        }
-    } else {
-        Uint8 *src, *dst;
-
-        src = cvt->buf + cvt->len_cvt;
-        dst = cvt->buf + cvt->len_cvt * 2;
-        for (i = cvt->len_cvt; i; --i) {
-            dst -= 2;
-            src -= 1;
-            dst[0] = src[0];
-            dst[1] = src[0];
-        }
+    #define dup_chans_1_to_2(type) \
+    { \
+        const type *src = (const type *) (cvt->buf + cvt->len_cvt); \
+        type *dst = (type *) (cvt->buf + cvt->len_cvt * 2); \
+        for (i = cvt->len_cvt / 2; i; --i, --src) { \
+            const type val = *src; \
+            dst -= 2; \
+            dst[0] = dst[1] = val; \
+        } \
     }
+
+    /* this function only cares about typesize, and data as a block of bits. */
+    switch (SDL_AUDIO_BITSIZE(format)) {
+        case 8:
+            dup_chans_1_to_2(Uint8);
+            break;
+        case 16:
+            dup_chans_1_to_2(Uint16);
+            break;
+        case 32:
+            dup_chans_1_to_2(Uint32);
+            break;
+    }
+
+    #undef dup_chans_1_to_2
+
     cvt->len_cvt *= 2;
     if (cvt->filters[++cvt->filter_index]) {
         cvt->filters[cvt->filter_index] (cvt, format);
@@ -451,16 +359,16 @@ SDL_ConvertStereo(SDL_AudioCVT * cvt, Uint16 format)
 
 
 /* Duplicate a stereo channel to a pseudo-5.1 stream */
-void SDLCALL
-SDL_ConvertSurround(SDL_AudioCVT * cvt, Uint16 format)
+static void SDLCALL
+SDL_ConvertSurround(SDL_AudioCVT * cvt, SDL_AudioFormat format)
 {
     int i;
 
 #ifdef DEBUG_CONVERT
     fprintf(stderr, "Converting stereo to surround\n");
 #endif
-    switch (format & 0x8018) {
 
+    switch (format & (SDL_AUDIO_MASK_SIGNED|SDL_AUDIO_MASK_BITSIZE)) {
     case AUDIO_U8:
         {
             Uint8 *src, *dst, lf, rf, ce;
@@ -513,7 +421,7 @@ SDL_ConvertSurround(SDL_AudioCVT * cvt, Uint16 format)
             src = cvt->buf + cvt->len_cvt;
             dst = cvt->buf + cvt->len_cvt * 3;
 
-            if ((format & 0x1000) == 0x1000) {
+            if (SDL_AUDIO_ISBIGENDIAN(format)) {
                 for (i = cvt->len_cvt / 4; i; --i) {
                     dst -= 12;
                     src -= 4;
@@ -573,7 +481,7 @@ SDL_ConvertSurround(SDL_AudioCVT * cvt, Uint16 format)
             src = cvt->buf + cvt->len_cvt;
             dst = cvt->buf + cvt->len_cvt * 3;
 
-            if ((format & 0x1000) == 0x1000) {
+            if (SDL_AUDIO_ISBIGENDIAN(format)) {
                 for (i = cvt->len_cvt / 4; i; --i) {
                     dst -= 12;
                     src -= 4;
@@ -624,6 +532,96 @@ SDL_ConvertSurround(SDL_AudioCVT * cvt, Uint16 format)
             }
         }
         break;
+
+    case AUDIO_S32:
+        {
+            Sint32 lf, rf, ce;
+            const Uint32 *src = (const Uint32 *) cvt->buf + cvt->len_cvt;
+            Uint32 *dst = (Uint32 *) cvt->buf + cvt->len_cvt * 3;
+
+            if (SDL_AUDIO_ISBIGENDIAN(format)) {
+                for (i = cvt->len_cvt / 8; i; --i) {
+                    dst -= 6;
+                    src -= 2;
+                    lf = (Sint32) SDL_SwapBE32(src[0]);
+                    rf = (Sint32) SDL_SwapBE32(src[1]);
+                    ce = (lf / 2) + (rf / 2);
+                    dst[0] = SDL_SwapBE32((Uint32) lf);
+                    dst[1] = SDL_SwapBE32((Uint32) rf);
+                    dst[2] = SDL_SwapBE32((Uint32) (lf - ce));
+                    dst[3] = SDL_SwapBE32((Uint32) (rf - ce));
+                    dst[4] = SDL_SwapBE32((Uint32) ce);
+                    dst[5] = SDL_SwapBE32((Uint32) ce);
+                }
+            } else {
+                for (i = cvt->len_cvt / 8; i; --i) {
+                    dst -= 6;
+                    src -= 2;
+                    lf = (Sint32) SDL_SwapLE32(src[0]);
+                    rf = (Sint32) SDL_SwapLE32(src[1]);
+                    ce = (lf / 2) + (rf / 2);
+                    dst[0] = src[0];
+                    dst[1] = src[1];
+                    dst[2] = SDL_SwapLE32((Uint32) (lf - ce));
+                    dst[3] = SDL_SwapLE32((Uint32) (rf - ce));
+                    dst[4] = SDL_SwapLE32((Uint32) ce);
+                    dst[5] = SDL_SwapLE32((Uint32) ce);
+                }
+            }
+        }
+        break;
+
+    case AUDIO_F32:
+        {
+            union { float f; Uint32 ui32; } f2i;  /* !!! FIXME: lame. */
+            float lf, rf, ce;
+            const Uint32 *src = (const Uint32 *) cvt->buf + cvt->len_cvt;
+            Uint32 *dst = (Uint32 *) cvt->buf + cvt->len_cvt * 3;
+
+            if (SDL_AUDIO_ISBIGENDIAN(format)) {
+                for (i = cvt->len_cvt / 8; i; --i) {
+                    dst -= 6;
+                    src -= 2;
+                    f2i.ui32 = SDL_SwapBE32(src[0]);
+                    lf = f2i.f;
+                    f2i.ui32 = SDL_SwapBE32(src[1]);
+                    rf = f2i.f;
+                    ce = (lf * 0.5f) + (rf * 0.5f);
+                    dst[0] = src[0];
+                    dst[1] = src[1];
+                    f2i.f = (lf - ce);
+                    dst[2] = SDL_SwapBE32(f2i.ui32);
+                    f2i.f = (rf - ce);
+                    dst[3] = SDL_SwapBE32(f2i.ui32);
+                    f2i.f = ce;
+                    f2i.ui32 = SDL_SwapBE32(f2i.ui32);
+                    dst[4] = f2i.ui32;
+                    dst[5] = f2i.ui32;
+                }
+            } else {
+                for (i = cvt->len_cvt / 8; i; --i) {
+                    dst -= 6;
+                    src -= 2;
+                    f2i.ui32 = SDL_SwapLE32(src[0]);
+                    lf = f2i.f;
+                    f2i.ui32 = SDL_SwapLE32(src[1]);
+                    rf = f2i.f;
+                    ce = (lf * 0.5f) + (rf * 0.5f);
+                    dst[0] = src[0];
+                    dst[1] = src[1];
+                    f2i.f = (lf - ce);
+                    dst[2] = SDL_SwapLE32(f2i.ui32);
+                    f2i.f = (rf - ce);
+                    dst[3] = SDL_SwapLE32(f2i.ui32);
+                    f2i.f = ce;
+                    f2i.ui32 = SDL_SwapLE32(f2i.ui32);
+                    dst[4] = f2i.ui32;
+                    dst[5] = f2i.ui32;
+                }
+            }
+        }
+        break;
+
     }
     cvt->len_cvt *= 3;
     if (cvt->filters[++cvt->filter_index]) {
@@ -633,16 +631,16 @@ SDL_ConvertSurround(SDL_AudioCVT * cvt, Uint16 format)
 
 
 /* Duplicate a stereo channel to a pseudo-4.0 stream */
-void SDLCALL
-SDL_ConvertSurround_4(SDL_AudioCVT * cvt, Uint16 format)
+static void SDLCALL
+SDL_ConvertSurround_4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
 {
     int i;
 
 #ifdef DEBUG_CONVERT
     fprintf(stderr, "Converting stereo to quad\n");
 #endif
-    switch (format & 0x8018) {
 
+    switch (format & (SDL_AUDIO_MASK_SIGNED|SDL_AUDIO_MASK_BITSIZE)) {
     case AUDIO_U8:
         {
             Uint8 *src, *dst, lf, rf, ce;
@@ -691,7 +689,7 @@ SDL_ConvertSurround_4(SDL_AudioCVT * cvt, Uint16 format)
             src = cvt->buf + cvt->len_cvt;
             dst = cvt->buf + cvt->len_cvt * 2;
 
-            if ((format & 0x1000) == 0x1000) {
+            if (SDL_AUDIO_ISBIGENDIAN(format)) {
                 for (i = cvt->len_cvt / 4; i; --i) {
                     dst -= 8;
                     src -= 4;
@@ -741,7 +739,7 @@ SDL_ConvertSurround_4(SDL_AudioCVT * cvt, Uint16 format)
             src = cvt->buf + cvt->len_cvt;
             dst = cvt->buf + cvt->len_cvt * 2;
 
-            if ((format & 0x1000) == 0x1000) {
+            if (SDL_AUDIO_ISBIGENDIAN(format)) {
                 for (i = cvt->len_cvt / 4; i; --i) {
                     dst -= 8;
                     src -= 4;
@@ -782,6 +780,40 @@ SDL_ConvertSurround_4(SDL_AudioCVT * cvt, Uint16 format)
             }
         }
         break;
+
+    case AUDIO_S32:
+        {
+            const Uint32 *src = (const Uint32 *) (cvt->buf + cvt->len_cvt);
+            Uint32 *dst = (Uint32 *) (cvt->buf + cvt->len_cvt * 2);
+            Sint32 lf, rf, ce;
+
+            if (SDL_AUDIO_ISBIGENDIAN(format)) {
+                for (i = cvt->len_cvt / 8; i; --i) {
+                    dst -= 4;
+                    src -= 2;
+                    lf = (Sint32) SDL_SwapBE32(src[0]);
+                    rf = (Sint32) SDL_SwapBE32(src[1]);
+                    ce = (lf / 2) + (rf / 2);
+                    dst[0] = src[0];
+                    dst[1] = src[1];
+                    dst[2] = SDL_SwapBE32((Uint32) (lf - ce));
+                    dst[3] = SDL_SwapBE32((Uint32) (rf - ce));
+                }
+            } else {
+                for (i = cvt->len_cvt / 8; i; --i) {
+                    dst -= 4;
+                    src -= 2;
+                    lf = (Sint32) SDL_SwapLE32(src[0]);
+                    rf = (Sint32) SDL_SwapLE32(src[1]);
+                    ce = (lf / 2) + (rf / 2);
+                    dst[0] = src[0];
+                    dst[1] = src[1];
+                    dst[2] = SDL_SwapLE32((Uint32) (lf - ce));
+                    dst[3] = SDL_SwapLE32((Uint32) (rf - ce));
+                }
+            }
+        }
+        break;
     }
     cvt->len_cvt *= 2;
     if (cvt->filters[++cvt->filter_index]) {
@@ -789,169 +821,40 @@ SDL_ConvertSurround_4(SDL_AudioCVT * cvt, Uint16 format)
     }
 }
 
-
-/* Convert 8-bit to 16-bit - LSB */
-void SDLCALL
-SDL_Convert16LSB(SDL_AudioCVT * cvt, Uint16 format)
-{
-    int i;
-    Uint8 *src, *dst;
-
-#ifdef DEBUG_CONVERT
-    fprintf(stderr, "Converting to 16-bit LSB\n");
-#endif
-    src = cvt->buf + cvt->len_cvt;
-    dst = cvt->buf + cvt->len_cvt * 2;
-    for (i = cvt->len_cvt; i; --i) {
-        src -= 1;
-        dst -= 2;
-        dst[1] = *src;
-        dst[0] = 0;
-    }
-    format = ((format & ~0x0008) | AUDIO_U16LSB);
-    cvt->len_cvt *= 2;
-    if (cvt->filters[++cvt->filter_index]) {
-        cvt->filters[cvt->filter_index] (cvt, format);
-    }
-}
-
-/* Convert 8-bit to 16-bit - MSB */
-void SDLCALL
-SDL_Convert16MSB(SDL_AudioCVT * cvt, Uint16 format)
-{
-    int i;
-    Uint8 *src, *dst;
-
-#ifdef DEBUG_CONVERT
-    fprintf(stderr, "Converting to 16-bit MSB\n");
-#endif
-    src = cvt->buf + cvt->len_cvt;
-    dst = cvt->buf + cvt->len_cvt * 2;
-    for (i = cvt->len_cvt; i; --i) {
-        src -= 1;
-        dst -= 2;
-        dst[0] = *src;
-        dst[1] = 0;
-    }
-    format = ((format & ~0x0008) | AUDIO_U16MSB);
-    cvt->len_cvt *= 2;
-    if (cvt->filters[++cvt->filter_index]) {
-        cvt->filters[cvt->filter_index] (cvt, format);
-    }
-}
-
-/* Convert 16-bit to 8-bit */
-void SDLCALL
-SDL_Convert8(SDL_AudioCVT * cvt, Uint16 format)
-{
-    int i;
-    Uint8 *src, *dst;
-
-#ifdef DEBUG_CONVERT
-    fprintf(stderr, "Converting to 8-bit\n");
-#endif
-    src = cvt->buf;
-    dst = cvt->buf;
-    if ((format & 0x1000) != 0x1000) {  /* Little endian */
-        ++src;
-    }
-    for (i = cvt->len_cvt / 2; i; --i) {
-        *dst = *src;
-        src += 2;
-        dst += 1;
-    }
-    format = ((format & ~0x9010) | AUDIO_U8);
-    cvt->len_cvt /= 2;
-    if (cvt->filters[++cvt->filter_index]) {
-        cvt->filters[cvt->filter_index] (cvt, format);
-    }
-}
-
-/* Toggle signed/unsigned */
-void SDLCALL
-SDL_ConvertSign(SDL_AudioCVT * cvt, Uint16 format)
-{
-    int i;
-    Uint8 *data;
-
-#ifdef DEBUG_CONVERT
-    fprintf(stderr, "Converting audio signedness\n");
-#endif
-    data = cvt->buf;
-    if ((format & 0xFF) == 16) {
-        if ((format & 0x1000) != 0x1000) {      /* Little endian */
-            ++data;
-        }
-        for (i = cvt->len_cvt / 2; i; --i) {
-            *data ^= 0x80;
-            data += 2;
-        }
-    } else {
-        for (i = cvt->len_cvt; i; --i) {
-            *data++ ^= 0x80;
-        }
-    }
-    format = (format ^ 0x8000);
-    if (cvt->filters[++cvt->filter_index]) {
-        cvt->filters[cvt->filter_index] (cvt, format);
-    }
-}
-
-/* Toggle endianness */
-void SDLCALL
-SDL_ConvertEndian(SDL_AudioCVT * cvt, Uint16 format)
-{
-    int i;
-    Uint8 *data, tmp;
-
-#ifdef DEBUG_CONVERT
-    fprintf(stderr, "Converting audio endianness\n");
-#endif
-    data = cvt->buf;
-    for (i = cvt->len_cvt / 2; i; --i) {
-        tmp = data[0];
-        data[0] = data[1];
-        data[1] = tmp;
-        data += 2;
-    }
-    format = (format ^ 0x1000);
-    if (cvt->filters[++cvt->filter_index]) {
-        cvt->filters[cvt->filter_index] (cvt, format);
-    }
-}
-
 /* Convert rate up by multiple of 2 */
-void SDLCALL
-SDL_RateMUL2(SDL_AudioCVT * cvt, Uint16 format)
+static void SDLCALL
+SDL_RateMUL2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
 {
     int i;
-    Uint8 *src, *dst;
 
 #ifdef DEBUG_CONVERT
-    fprintf(stderr, "Converting audio rate * 2\n");
+    fprintf(stderr, "Converting audio rate * 2 (mono)\n");
 #endif
-    src = cvt->buf + cvt->len_cvt;
-    dst = cvt->buf + cvt->len_cvt * 2;
-    switch (format & 0xFF) {
+
+    #define mul2_mono(type) { \
+        const type *src = (const type *) (cvt->buf + cvt->len_cvt); \
+        type *dst = (type *) (cvt->buf + (cvt->len_cvt * 2)); \
+        for (i = cvt->len_cvt / sizeof (type); i; --i) { \
+            src--; \
+            dst[-1] = dst[-2] = src[0]; \
+            dst -= 2; \
+        } \
+    }
+
+    switch (SDL_AUDIO_BITSIZE(format)) {
     case 8:
-        for (i = cvt->len_cvt; i; --i) {
-            src -= 1;
-            dst -= 2;
-            dst[0] = src[0];
-            dst[1] = src[0];
-        }
+        mul2_mono(Uint8);
         break;
     case 16:
-        for (i = cvt->len_cvt / 2; i; --i) {
-            src -= 2;
-            dst -= 4;
-            dst[0] = src[0];
-            dst[1] = src[1];
-            dst[2] = src[0];
-            dst[3] = src[1];
-        }
+        mul2_mono(Uint16);
+        break;
+    case 32:
+        mul2_mono(Uint32);
         break;
     }
+
+    #undef mul2_mono
+
     cvt->len_cvt *= 2;
     if (cvt->filters[++cvt->filter_index]) {
         cvt->filters[cvt->filter_index] (cvt, format);
@@ -960,43 +863,44 @@ SDL_RateMUL2(SDL_AudioCVT * cvt, Uint16 format)
 
 
 /* Convert rate up by multiple of 2, for stereo */
-void SDLCALL
-SDL_RateMUL2_c2(SDL_AudioCVT * cvt, Uint16 format)
+static void SDLCALL
+SDL_RateMUL2_c2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
 {
     int i;
-    Uint8 *src, *dst;
 
 #ifdef DEBUG_CONVERT
-    fprintf(stderr, "Converting audio rate * 2\n");
+    fprintf(stderr, "Converting audio rate * 2 (stereo)\n");
 #endif
-    src = cvt->buf + cvt->len_cvt;
-    dst = cvt->buf + cvt->len_cvt * 2;
-    switch (format & 0xFF) {
+
+    #define mul2_stereo(type) { \
+        const type *src = (const type *) (cvt->buf + cvt->len_cvt); \
+        type *dst = (type *) (cvt->buf + (cvt->len_cvt * 2)); \
+        for (i = cvt->len_cvt / (sizeof (type) * 2); i; --i) { \
+            const type r = src[-1]; \
+            const type l = src[-2]; \
+            src -= 2; \
+            dst[-1] = r; \
+            dst[-2] = l; \
+            dst[-3] = r; \
+            dst[-4] = l; \
+            dst -= 4; \
+        } \
+    }
+
+    switch (SDL_AUDIO_BITSIZE(format)) {
     case 8:
-        for (i = cvt->len_cvt / 2; i; --i) {
-            src -= 2;
-            dst -= 4;
-            dst[0] = src[0];
-            dst[1] = src[1];
-            dst[2] = src[0];
-            dst[3] = src[1];
-        }
+        mul2_stereo(Uint8);
         break;
     case 16:
-        for (i = cvt->len_cvt / 4; i; --i) {
-            src -= 4;
-            dst -= 8;
-            dst[0] = src[0];
-            dst[1] = src[1];
-            dst[2] = src[2];
-            dst[3] = src[3];
-            dst[4] = src[0];
-            dst[5] = src[1];
-            dst[6] = src[2];
-            dst[7] = src[3];
-        }
+        mul2_stereo(Uint16);
+        break;
+    case 32:
+        mul2_stereo(Uint32);
         break;
     }
+
+    #undef mul2_stereo
+
     cvt->len_cvt *= 2;
     if (cvt->filters[++cvt->filter_index]) {
         cvt->filters[cvt->filter_index] (cvt, format);
@@ -1004,55 +908,50 @@ SDL_RateMUL2_c2(SDL_AudioCVT * cvt, Uint16 format)
 }
 
 /* Convert rate up by multiple of 2, for quad */
-void SDLCALL
-SDL_RateMUL2_c4(SDL_AudioCVT * cvt, Uint16 format)
+static void SDLCALL
+SDL_RateMUL2_c4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
 {
     int i;
-    Uint8 *src, *dst;
 
 #ifdef DEBUG_CONVERT
-    fprintf(stderr, "Converting audio rate * 2\n");
+    fprintf(stderr, "Converting audio rate * 2 (quad)\n");
 #endif
-    src = cvt->buf + cvt->len_cvt;
-    dst = cvt->buf + cvt->len_cvt * 2;
-    switch (format & 0xFF) {
+
+    #define mul2_quad(type) { \
+        const type *src = (const type *) (cvt->buf + cvt->len_cvt); \
+        type *dst = (type *) (cvt->buf + (cvt->len_cvt * 2)); \
+        for (i = cvt->len_cvt / (sizeof (type) * 4); i; --i) { \
+            const type c1 = src[-1]; \
+            const type c2 = src[-2]; \
+            const type c3 = src[-3]; \
+            const type c4 = src[-4]; \
+            src -= 4; \
+            dst[-1] = c1; \
+            dst[-2] = c2; \
+            dst[-3] = c3; \
+            dst[-4] = c4; \
+            dst[-5] = c1; \
+            dst[-6] = c2; \
+            dst[-7] = c3; \
+            dst[-8] = c4; \
+            dst -= 8; \
+        } \
+    }
+
+    switch (SDL_AUDIO_BITSIZE(format)) {
     case 8:
-        for (i = cvt->len_cvt / 4; i; --i) {
-            src -= 4;
-            dst -= 8;
-            dst[0] = src[0];
-            dst[1] = src[1];
-            dst[2] = src[2];
-            dst[3] = src[3];
-            dst[4] = src[0];
-            dst[5] = src[1];
-            dst[6] = src[2];
-            dst[7] = src[3];
-        }
+        mul2_quad(Uint8);
         break;
     case 16:
-        for (i = cvt->len_cvt / 8; i; --i) {
-            src -= 8;
-            dst -= 16;
-            dst[0] = src[0];
-            dst[1] = src[1];
-            dst[2] = src[2];
-            dst[3] = src[3];
-            dst[4] = src[4];
-            dst[5] = src[5];
-            dst[6] = src[6];
-            dst[7] = src[7];
-            dst[8] = src[0];
-            dst[9] = src[1];
-            dst[10] = src[2];
-            dst[11] = src[3];
-            dst[12] = src[4];
-            dst[13] = src[5];
-            dst[14] = src[6];
-            dst[15] = src[7];
-        }
+        mul2_quad(Uint16);
+        break;
+    case 32:
+        mul2_quad(Uint32);
         break;
     }
+
+    #undef mul2_quad
+
     cvt->len_cvt *= 2;
     if (cvt->filters[++cvt->filter_index]) {
         cvt->filters[cvt->filter_index] (cvt, format);
@@ -1061,67 +960,56 @@ SDL_RateMUL2_c4(SDL_AudioCVT * cvt, Uint16 format)
 
 
 /* Convert rate up by multiple of 2, for 5.1 */
-void SDLCALL
-SDL_RateMUL2_c6(SDL_AudioCVT * cvt, Uint16 format)
+static void SDLCALL
+SDL_RateMUL2_c6(SDL_AudioCVT * cvt, SDL_AudioFormat format)
 {
     int i;
-    Uint8 *src, *dst;
 
 #ifdef DEBUG_CONVERT
-    fprintf(stderr, "Converting audio rate * 2\n");
+    fprintf(stderr, "Converting audio rate * 2 (six channels)\n");
 #endif
-    src = cvt->buf + cvt->len_cvt;
-    dst = cvt->buf + cvt->len_cvt * 2;
-    switch (format & 0xFF) {
+
+    #define mul2_chansix(type) { \
+        const type *src = (const type *) (cvt->buf + cvt->len_cvt); \
+        type *dst = (type *) (cvt->buf + (cvt->len_cvt * 2)); \
+        for (i = cvt->len_cvt / (sizeof (type) * 6); i; --i) { \
+            const type c1 = src[-1]; \
+            const type c2 = src[-2]; \
+            const type c3 = src[-3]; \
+            const type c4 = src[-4]; \
+            const type c5 = src[-5]; \
+            const type c6 = src[-6]; \
+            src -= 6; \
+            dst[-1] = c1; \
+            dst[-2] = c2; \
+            dst[-3] = c3; \
+            dst[-4] = c4; \
+            dst[-5] = c5; \
+            dst[-6] = c6; \
+            dst[-7] = c1; \
+            dst[-8] = c2; \
+            dst[-9] = c3; \
+            dst[-10] = c4; \
+            dst[-11] = c5; \
+            dst[-12] = c6; \
+            dst -= 12; \
+        } \
+    }
+
+    switch (SDL_AUDIO_BITSIZE(format)) {
     case 8:
-        for (i = cvt->len_cvt / 6; i; --i) {
-            src -= 6;
-            dst -= 12;
-            dst[0] = src[0];
-            dst[1] = src[1];
-            dst[2] = src[2];
-            dst[3] = src[3];
-            dst[4] = src[4];
-            dst[5] = src[5];
-            dst[6] = src[0];
-            dst[7] = src[1];
-            dst[8] = src[2];
-            dst[9] = src[3];
-            dst[10] = src[4];
-            dst[11] = src[5];
-        }
+        mul2_chansix(Uint8);
         break;
     case 16:
-        for (i = cvt->len_cvt / 12; i; --i) {
-            src -= 12;
-            dst -= 24;
-            dst[0] = src[0];
-            dst[1] = src[1];
-            dst[2] = src[2];
-            dst[3] = src[3];
-            dst[4] = src[4];
-            dst[5] = src[5];
-            dst[6] = src[6];
-            dst[7] = src[7];
-            dst[8] = src[8];
-            dst[9] = src[9];
-            dst[10] = src[10];
-            dst[11] = src[11];
-            dst[12] = src[0];
-            dst[13] = src[1];
-            dst[14] = src[2];
-            dst[15] = src[3];
-            dst[16] = src[4];
-            dst[17] = src[5];
-            dst[18] = src[6];
-            dst[19] = src[7];
-            dst[20] = src[8];
-            dst[21] = src[9];
-            dst[22] = src[10];
-            dst[23] = src[11];
-        }
+        mul2_chansix(Uint16);
+        break;
+    case 32:
+        mul2_chansix(Uint32);
         break;
     }
+
+    #undef mul2_chansix
+
     cvt->len_cvt *= 2;
     if (cvt->filters[++cvt->filter_index]) {
         cvt->filters[cvt->filter_index] (cvt, format);
@@ -1129,34 +1017,39 @@ SDL_RateMUL2_c6(SDL_AudioCVT * cvt, Uint16 format)
 }
 
 /* Convert rate down by multiple of 2 */
-void SDLCALL
-SDL_RateDIV2(SDL_AudioCVT * cvt, Uint16 format)
+static void SDLCALL
+SDL_RateDIV2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
 {
     int i;
-    Uint8 *src, *dst;
 
 #ifdef DEBUG_CONVERT
-    fprintf(stderr, "Converting audio rate / 2\n");
+    fprintf(stderr, "Converting audio rate / 2 (mono)\n");
 #endif
-    src = cvt->buf;
-    dst = cvt->buf;
-    switch (format & 0xFF) {
+
+    #define div2_mono(type) { \
+        const type *src = (const type *) cvt->buf; \
+        type *dst = (type *) cvt->buf; \
+        for (i = cvt->len_cvt / (sizeof (type) * 2); i; --i) { \
+            dst[0] = src[0]; \
+            src += 2; \
+            dst++; \
+        } \
+    }
+
+    switch (SDL_AUDIO_BITSIZE(format)) {
     case 8:
-        for (i = cvt->len_cvt / 2; i; --i) {
-            dst[0] = src[0];
-            src += 2;
-            dst += 1;
-        }
+        div2_mono(Uint8);
         break;
     case 16:
-        for (i = cvt->len_cvt / 4; i; --i) {
-            dst[0] = src[0];
-            dst[1] = src[1];
-            src += 4;
-            dst += 2;
-        }
+        div2_mono(Uint16);
+        break;
+    case 32:
+        div2_mono(Uint32);
         break;
     }
+
+    #undef div2_mono
+
     cvt->len_cvt /= 2;
     if (cvt->filters[++cvt->filter_index]) {
         cvt->filters[cvt->filter_index] (cvt, format);
@@ -1165,37 +1058,40 @@ SDL_RateDIV2(SDL_AudioCVT * cvt, Uint16 format)
 
 
 /* Convert rate down by multiple of 2, for stereo */
-void SDLCALL
-SDL_RateDIV2_c2(SDL_AudioCVT * cvt, Uint16 format)
+static void SDLCALL
+SDL_RateDIV2_c2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
 {
     int i;
-    Uint8 *src, *dst;
 
 #ifdef DEBUG_CONVERT
-    fprintf(stderr, "Converting audio rate / 2\n");
+    fprintf(stderr, "Converting audio rate / 2 (stereo)\n");
 #endif
-    src = cvt->buf;
-    dst = cvt->buf;
-    switch (format & 0xFF) {
+
+    #define div2_stereo(type) { \
+        const type *src = (const type *) cvt->buf; \
+        type *dst = (type *) cvt->buf; \
+        for (i = cvt->len_cvt / (sizeof (type) * 4); i; --i) { \
+            dst[0] = src[0]; \
+            dst[1] = src[1]; \
+            src += 4; \
+            dst += 2; \
+        } \
+    }
+
+    switch (SDL_AUDIO_BITSIZE(format)) {
     case 8:
-        for (i = cvt->len_cvt / 4; i; --i) {
-            dst[0] = src[0];
-            dst[1] = src[1];
-            src += 4;
-            dst += 2;
-        }
+        div2_stereo(Uint8);
         break;
     case 16:
-        for (i = cvt->len_cvt / 8; i; --i) {
-            dst[0] = src[0];
-            dst[1] = src[1];
-            dst[2] = src[2];
-            dst[3] = src[3];
-            src += 8;
-            dst += 4;
-        }
+        div2_stereo(Uint16);
+        break;
+    case 32:
+        div2_stereo(Uint32);
         break;
     }
+
+    #undef div2_stereo
+
     cvt->len_cvt /= 2;
     if (cvt->filters[++cvt->filter_index]) {
         cvt->filters[cvt->filter_index] (cvt, format);
@@ -1204,43 +1100,42 @@ SDL_RateDIV2_c2(SDL_AudioCVT * cvt, Uint16 format)
 
 
 /* Convert rate down by multiple of 2, for quad */
-void SDLCALL
-SDL_RateDIV2_c4(SDL_AudioCVT * cvt, Uint16 format)
+static void SDLCALL
+SDL_RateDIV2_c4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
 {
     int i;
-    Uint8 *src, *dst;
 
 #ifdef DEBUG_CONVERT
-    fprintf(stderr, "Converting audio rate / 2\n");
+    fprintf(stderr, "Converting audio rate / 2 (quad)\n");
 #endif
-    src = cvt->buf;
-    dst = cvt->buf;
-    switch (format & 0xFF) {
+
+    #define div2_quad(type) { \
+        const type *src = (const type *) cvt->buf; \
+        type *dst = (type *) cvt->buf; \
+        for (i = cvt->len_cvt / (sizeof (type) * 8); i; --i) { \
+            dst[0] = src[0]; \
+            dst[1] = src[1]; \
+            dst[2] = src[2]; \
+            dst[3] = src[3]; \
+            src += 8; \
+            dst += 4; \
+        } \
+    }
+
+    switch (SDL_AUDIO_BITSIZE(format)) {
     case 8:
-        for (i = cvt->len_cvt / 8; i; --i) {
-            dst[0] = src[0];
-            dst[1] = src[1];
-            dst[2] = src[2];
-            dst[3] = src[3];
-            src += 8;
-            dst += 4;
-        }
+        div2_quad(Uint8);
         break;
     case 16:
-        for (i = cvt->len_cvt / 16; i; --i) {
-            dst[0] = src[0];
-            dst[1] = src[1];
-            dst[2] = src[2];
-            dst[3] = src[3];
-            dst[4] = src[4];
-            dst[5] = src[5];
-            dst[6] = src[6];
-            dst[7] = src[7];
-            src += 16;
-            dst += 8;
-        }
+        div2_quad(Uint16);
+        break;
+    case 32:
+        div2_quad(Uint32);
         break;
     }
+
+    #undef div2_quad
+
     cvt->len_cvt /= 2;
     if (cvt->filters[++cvt->filter_index]) {
         cvt->filters[cvt->filter_index] (cvt, format);
@@ -1248,49 +1143,44 @@ SDL_RateDIV2_c4(SDL_AudioCVT * cvt, Uint16 format)
 }
 
 /* Convert rate down by multiple of 2, for 5.1 */
-void SDLCALL
-SDL_RateDIV2_c6(SDL_AudioCVT * cvt, Uint16 format)
+static void SDLCALL
+SDL_RateDIV2_c6(SDL_AudioCVT * cvt, SDL_AudioFormat format)
 {
     int i;
-    Uint8 *src, *dst;
 
 #ifdef DEBUG_CONVERT
-    fprintf(stderr, "Converting audio rate / 2\n");
+    fprintf(stderr, "Converting audio rate / 2 (six channels)\n");
 #endif
-    src = cvt->buf;
-    dst = cvt->buf;
-    switch (format & 0xFF) {
+
+    #define div2_chansix(type) { \
+        const type *src = (const type *) cvt->buf; \
+        type *dst = (type *) cvt->buf; \
+        for (i = cvt->len_cvt / (sizeof (type) * 12); i; --i) { \
+            dst[0] = src[0]; \
+            dst[1] = src[1]; \
+            dst[2] = src[2]; \
+            dst[3] = src[3]; \
+            dst[4] = src[4]; \
+            dst[5] = src[5]; \
+            src += 12; \
+            dst += 6; \
+        } \
+    }
+
+    switch (SDL_AUDIO_BITSIZE(format)) {
     case 8:
-        for (i = cvt->len_cvt / 12; i; --i) {
-            dst[0] = src[0];
-            dst[1] = src[1];
-            dst[2] = src[2];
-            dst[3] = src[3];
-            dst[4] = src[4];
-            dst[5] = src[5];
-            src += 12;
-            dst += 6;
-        }
+        div2_chansix(Uint8);
         break;
     case 16:
-        for (i = cvt->len_cvt / 24; i; --i) {
-            dst[0] = src[0];
-            dst[1] = src[1];
-            dst[2] = src[2];
-            dst[3] = src[3];
-            dst[4] = src[4];
-            dst[5] = src[5];
-            dst[6] = src[6];
-            dst[7] = src[7];
-            dst[8] = src[8];
-            dst[9] = src[9];
-            dst[10] = src[10];
-            dst[11] = src[11];
-            src += 24;
-            dst += 12;
-        }
+        div2_chansix(Uint16);
+        break;
+    case 32:
+        div2_chansix(Uint32);
         break;
     }
+
+    #undef div_chansix
+
     cvt->len_cvt /= 2;
     if (cvt->filters[++cvt->filter_index]) {
         cvt->filters[cvt->filter_index] (cvt, format);
@@ -1298,8 +1188,8 @@ SDL_RateDIV2_c6(SDL_AudioCVT * cvt, Uint16 format)
 }
 
 /* Very slow rate conversion routine */
-void SDLCALL
-SDL_RateSLOW(SDL_AudioCVT * cvt, Uint16 format)
+static void SDLCALL
+SDL_RateSLOW(SDL_AudioCVT * cvt, SDL_AudioFormat format)
 {
     double ipos;
     int i, clen;
@@ -1309,7 +1199,7 @@ SDL_RateSLOW(SDL_AudioCVT * cvt, Uint16 format)
 #endif
     clen = (int) ((double) cvt->len_cvt / cvt->rate_incr);
     if (cvt->rate_incr > 1.0) {
-        switch (format & 0xFF) {
+        switch (SDL_AUDIO_BITSIZE(format)) {
         case 8:
             {
                 Uint8 *output;
@@ -1338,9 +1228,15 @@ SDL_RateSLOW(SDL_AudioCVT * cvt, Uint16 format)
                 }
             }
             break;
+
+        case 32:
+            {
+                /* !!! FIXME: need 32-bit converter here! */
+                fprintf(stderr, "FIXME: need 32-bit converter here!\n");
+            }
         }
     } else {
-        switch (format & 0xFF) {
+        switch (SDL_AUDIO_BITSIZE(format)) {
         case 8:
             {
                 Uint8 *output;
@@ -1369,8 +1265,15 @@ SDL_RateSLOW(SDL_AudioCVT * cvt, Uint16 format)
                 }
             }
             break;
+
+        case 32:
+            {
+                /* !!! FIXME: need 32-bit converter here! */
+                fprintf(stderr, "FIXME: need 32-bit converter here!\n");
+            }
         }
     }
+
     cvt->len_cvt = clen;
     if (cvt->filters[++cvt->filter_index]) {
         cvt->filters[cvt->filter_index] (cvt, format);
@@ -1397,57 +1300,106 @@ SDL_ConvertAudio(SDL_AudioCVT * cvt)
     return (0);
 }
 
-/* Creates a set of audio filters to convert from one format to another. 
-   Returns -1 if the format conversion is not supported, or 1 if the
-   audio filter is set up.
+
+static SDL_AudioFilter
+SDL_HandTunedTypeCVT(SDL_AudioFormat src_fmt, SDL_AudioFormat dst_fmt)
+{
+    /*
+     * Fill in any future conversions that are specialized to a
+     *  processor, platform, compiler, or library here.
+     */
+
+    return NULL;  /* no specialized converter code available. */
+}
+
+
+/*
+ * Find a converter between two data types. We try to select a hand-tuned
+ *  asm/vectorized/optimized function first, and then fallback to an
+ *  autogenerated function that is customized to convert between two
+ *  specific data types.
+ */
+static int
+SDL_BuildAudioTypeCVT(SDL_AudioCVT * cvt,
+                      SDL_AudioFormat src_fmt, SDL_AudioFormat dst_fmt)
+{
+    if (src_fmt != dst_fmt) {
+        const Uint16 src_bitsize = SDL_AUDIO_BITSIZE(src_fmt);
+        const Uint16 dst_bitsize = SDL_AUDIO_BITSIZE(dst_fmt);
+        SDL_AudioFilter filter = SDL_HandTunedTypeCVT(src_fmt, dst_fmt);
+
+        /* No hand-tuned converter? Try the autogenerated ones. */
+        if (filter == NULL) {
+            int i;
+            for (i = 0; sdl_audio_type_filters[i].filter != NULL; i++) {
+                const SDL_AudioTypeFilters *filt = &sdl_audio_type_filters[i];
+                if ((filt->src_fmt == src_fmt) && (filt->dst_fmt == dst_fmt)) {
+                    filter = filt->filter;
+                    break;
+                }
+            }
+
+            if (filter == NULL) {
+                return -1;  /* Still no matching converter?! */
+            }
+        }
+
+        /* Update (cvt) with filter details... */
+        cvt->filters[cvt->filter_index++] = filter;
+        if (src_bitsize < dst_bitsize) {
+            const int mult = (dst_bitsize / src_bitsize);
+            cvt->len_mult *= mult;
+            cvt->len_ratio *= mult;
+        } else if (src_bitsize > dst_bitsize) {
+            cvt->len_ratio /= (src_bitsize / dst_bitsize);
+        }
+
+        return 1;  /* added a converter. */
+    }
+
+    return 0;  /* no conversion necessary. */
+}
+
+
+
+/* Creates a set of audio filters to convert from one format to another.
+   Returns -1 if the format conversion is not supported, 0 if there's
+   no conversion needed, or 1 if the audio filter is set up.
 */
 
 int
 SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
-                  Uint16 src_format, Uint8 src_channels, int src_rate,
-                  Uint16 dst_format, Uint8 dst_channels, int dst_rate)
+                  SDL_AudioFormat src_fmt, Uint8 src_channels, int src_rate,
+                  SDL_AudioFormat dst_fmt, Uint8 dst_channels, int dst_rate)
 {
-/*printf("Build format %04x->%04x, channels %u->%u, rate %d->%d\n",
-		src_format, dst_format, src_channels, dst_channels, src_rate, dst_rate);*/
+    /* there are no unsigned types over 16 bits, so catch this upfront. */
+    if ((SDL_AUDIO_BITSIZE(src_fmt) > 16) && (!SDL_AUDIO_ISSIGNED(src_fmt))) {
+        return -1;
+    }
+    if ((SDL_AUDIO_BITSIZE(dst_fmt) > 16) && (!SDL_AUDIO_ISSIGNED(dst_fmt))) {
+        return -1;
+    }
+
+    #ifdef DEBUG_CONVERT
+    printf("Build format %04x->%04x, channels %u->%u, rate %d->%d\n",
+		    src_fmt, dst_fmt, src_channels, dst_channels, src_rate, dst_rate);
+    #endif
+
     /* Start off with no conversion necessary */
+
+    cvt->src_format = src_fmt;
+    cvt->dst_format = dst_fmt;
     cvt->needed = 0;
     cvt->filter_index = 0;
     cvt->filters[0] = NULL;
     cvt->len_mult = 1;
     cvt->len_ratio = 1.0;
 
-    /* First filter:  Endian conversion from src to dst */
-    if ((src_format & 0x1000) != (dst_format & 0x1000)
-        && ((src_format & 0xff) != 8)) {
-        cvt->filters[cvt->filter_index++] = SDL_ConvertEndian;
-    }
+    /* Convert data types, if necessary. Updates (cvt). */
+    if (SDL_BuildAudioTypeCVT(cvt, src_fmt, dst_fmt) == -1)
+        return -1;  /* shouldn't happen, but just in case... */
 
-    /* Second filter: Sign conversion -- signed/unsigned */
-    if ((src_format & 0x8000) != (dst_format & 0x8000)) {
-        cvt->filters[cvt->filter_index++] = SDL_ConvertSign;
-    }
-
-    /* Next filter:  Convert 16 bit <--> 8 bit PCM */
-    if ((src_format & 0xFF) != (dst_format & 0xFF)) {
-        switch (dst_format & 0x10FF) {
-        case AUDIO_U8:
-            cvt->filters[cvt->filter_index++] = SDL_Convert8;
-            cvt->len_ratio /= 2;
-            break;
-        case AUDIO_U16LSB:
-            cvt->filters[cvt->filter_index++] = SDL_Convert16LSB;
-            cvt->len_mult *= 2;
-            cvt->len_ratio *= 2;
-            break;
-        case AUDIO_U16MSB:
-            cvt->filters[cvt->filter_index++] = SDL_Convert16MSB;
-            cvt->len_mult *= 2;
-            cvt->len_ratio *= 2;
-            break;
-        }
-    }
-
-    /* Last filter:  Mono/Stereo conversion */
+    /* Channel conversion */
     if (src_channels != dst_channels) {
         if ((src_channels == 1) && (dst_channels > 1)) {
             cvt->filters[cvt->filter_index++] = SDL_ConvertStereo;
@@ -1504,7 +1456,7 @@ SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
         Uint32 hi_rate, lo_rate;
         int len_mult;
         double len_ratio;
-        void (SDLCALL * rate_cvt) (SDL_AudioCVT * cvt, Uint16 format);
+        SDL_AudioFilter rate_cvt = NULL;
 
         if (src_rate > dst_rate) {
             hi_rate = src_rate;
@@ -1583,8 +1535,8 @@ SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
     /* Set up the filter information */
     if (cvt->filter_index != 0) {
         cvt->needed = 1;
-        cvt->src_format = src_format;
-        cvt->dst_format = dst_format;
+        cvt->src_format = src_fmt;
+        cvt->dst_format = dst_fmt;
         cvt->len = 0;
         cvt->buf = NULL;
         cvt->filters[cvt->filter_index] = NULL;
diff --git a/src/audio/SDL_audiotypecvt.c b/src/audio/SDL_audiotypecvt.c
new file mode 100644
index 000000000..1b269e373
--- /dev/null
+++ b/src/audio/SDL_audiotypecvt.c
@@ -0,0 +1,2356 @@
+/* DO NOT EDIT THIS FILE! It is generated code. */
+/* Please modify SDL/src/audio/sdlgenaudiocvt.pl instead. */
+
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#include "SDL_config.h"
+#include "SDL_audio.h"
+#include "SDL_audio_c.h"
+
+/* Now the generated code... */
+
+#define DIVBY127 0.0078740157480315f
+#define DIVBY255 0.00392156862745098f
+#define DIVBY32767 3.05185094759972e-05f
+#define DIVBY65535 1.52590218966964e-05f
+#define DIVBY2147483647 4.6566128752458e-10f
+
+static void SDLCALL
+SDL_Convert_U8_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Sint8 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S8.\n");
+#endif
+
+    src = (const Uint8 *) cvt->buf;
+    dst = (Sint8 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, ++src, ++dst) {
+        const Sint8 val = ((*src) ^ 0x80);
+        *dst = ((Sint8) val);
+    }
+
+    format = AUDIO_S8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U8_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Uint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U8 to AUDIO_U16LSB.\n");
+#endif
+
+    src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
+    dst = (Uint16 *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
+        const Uint16 val = (((Uint16) *src) << 8);
+        *dst = SDL_SwapLE16(val);
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_U16LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U8_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Sint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S16LSB.\n");
+#endif
+
+    src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
+    dst = (Sint16 *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
+        const Sint16 val = (((Sint16) ((*src) ^ 0x80)) << 8);
+        *dst = ((Sint16) SDL_SwapLE16(val));
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_S16LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U8_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Uint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U8 to AUDIO_U16MSB.\n");
+#endif
+
+    src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
+    dst = (Uint16 *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
+        const Uint16 val = (((Uint16) *src) << 8);
+        *dst = SDL_SwapBE16(val);
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_U16MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U8_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Sint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S16MSB.\n");
+#endif
+
+    src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
+    dst = (Sint16 *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
+        const Sint16 val = (((Sint16) ((*src) ^ 0x80)) << 8);
+        *dst = ((Sint16) SDL_SwapBE16(val));
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_S16MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U8_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Sint32 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S32LSB.\n");
+#endif
+
+    src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
+    dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 4);
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
+        const Sint32 val = (((Sint32) ((*src) ^ 0x80)) << 24);
+        *dst = ((Sint32) SDL_SwapLE32(val));
+    }
+
+    cvt->len_cvt *= 4;
+    format = AUDIO_S32LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U8_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Sint32 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S32MSB.\n");
+#endif
+
+    src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
+    dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 4);
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
+        const Sint32 val = (((Sint32) ((*src) ^ 0x80)) << 24);
+        *dst = ((Sint32) SDL_SwapBE32(val));
+    }
+
+    cvt->len_cvt *= 4;
+    format = AUDIO_S32MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U8_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    float *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U8 to AUDIO_F32LSB.\n");
+#endif
+
+    src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
+    dst = (float *) (cvt->buf + cvt->len_cvt * 4);
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
+        const float val = (((float) *src) * DIVBY255);
+        *dst = SDL_SwapFloatLE(val);
+    }
+
+    cvt->len_cvt *= 4;
+    format = AUDIO_F32LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U8_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    float *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U8 to AUDIO_F32MSB.\n");
+#endif
+
+    src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
+    dst = (float *) (cvt->buf + cvt->len_cvt * 4);
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
+        const float val = (((float) *src) * DIVBY255);
+        *dst = SDL_SwapFloatBE(val);
+    }
+
+    cvt->len_cvt *= 4;
+    format = AUDIO_F32MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S8_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Uint8 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S8 to AUDIO_U8.\n");
+#endif
+
+    src = (const Uint8 *) cvt->buf;
+    dst = (Uint8 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, ++src, ++dst) {
+        const Uint8 val = ((((Sint8) *src)) ^ 0x80);
+        *dst = val;
+    }
+
+    format = AUDIO_U8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S8_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Uint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S8 to AUDIO_U16LSB.\n");
+#endif
+
+    src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
+    dst = (Uint16 *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
+        const Uint16 val = (((Uint16) ((((Sint8) *src)) ^ 0x80)) << 8);
+        *dst = SDL_SwapLE16(val);
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_U16LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S8_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Sint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S16LSB.\n");
+#endif
+
+    src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
+    dst = (Sint16 *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
+        const Sint16 val = (((Sint16) ((Sint8) *src)) << 8);
+        *dst = ((Sint16) SDL_SwapLE16(val));
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_S16LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S8_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Uint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S8 to AUDIO_U16MSB.\n");
+#endif
+
+    src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
+    dst = (Uint16 *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
+        const Uint16 val = (((Uint16) ((((Sint8) *src)) ^ 0x80)) << 8);
+        *dst = SDL_SwapBE16(val);
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_U16MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S8_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Sint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S16MSB.\n");
+#endif
+
+    src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
+    dst = (Sint16 *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
+        const Sint16 val = (((Sint16) ((Sint8) *src)) << 8);
+        *dst = ((Sint16) SDL_SwapBE16(val));
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_S16MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S8_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Sint32 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S32LSB.\n");
+#endif
+
+    src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
+    dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 4);
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
+        const Sint32 val = (((Sint32) ((Sint8) *src)) << 24);
+        *dst = ((Sint32) SDL_SwapLE32(val));
+    }
+
+    cvt->len_cvt *= 4;
+    format = AUDIO_S32LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S8_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Sint32 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S32MSB.\n");
+#endif
+
+    src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
+    dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 4);
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
+        const Sint32 val = (((Sint32) ((Sint8) *src)) << 24);
+        *dst = ((Sint32) SDL_SwapBE32(val));
+    }
+
+    cvt->len_cvt *= 4;
+    format = AUDIO_S32MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S8_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    float *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S8 to AUDIO_F32LSB.\n");
+#endif
+
+    src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
+    dst = (float *) (cvt->buf + cvt->len_cvt * 4);
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
+        const float val = (((float) ((Sint8) *src)) * DIVBY127);
+        *dst = SDL_SwapFloatLE(val);
+    }
+
+    cvt->len_cvt *= 4;
+    format = AUDIO_F32LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S8_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    float *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S8 to AUDIO_F32MSB.\n");
+#endif
+
+    src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
+    dst = (float *) (cvt->buf + cvt->len_cvt * 4);
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
+        const float val = (((float) ((Sint8) *src)) * DIVBY127);
+        *dst = SDL_SwapFloatBE(val);
+    }
+
+    cvt->len_cvt *= 4;
+    format = AUDIO_F32MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint8 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_U8.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Uint8 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Uint8 val = ((Uint8) (SDL_SwapLE16(*src) >> 8));
+        *dst = val;
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_U8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint8 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S8.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Sint8 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Sint8 val = ((Sint8) (((SDL_SwapLE16(*src)) ^ 0x8000) >> 8));
+        *dst = ((Sint8) val);
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_S8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16LSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S16LSB.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Sint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Sint16 val = ((SDL_SwapLE16(*src)) ^ 0x8000);
+        *dst = ((Sint16) SDL_SwapLE16(val));
+    }
+
+    format = AUDIO_S16LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_U16MSB.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Uint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Uint16 val = SDL_SwapLE16(*src);
+        *dst = SDL_SwapBE16(val);
+    }
+
+    format = AUDIO_U16MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S16MSB.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Sint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Sint16 val = ((SDL_SwapLE16(*src)) ^ 0x8000);
+        *dst = ((Sint16) SDL_SwapBE16(val));
+    }
+
+    format = AUDIO_S16MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16LSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint32 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S32LSB.\n");
+#endif
+
+    src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
+    dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const Sint32 val = (((Sint32) ((SDL_SwapLE16(*src)) ^ 0x8000)) << 16);
+        *dst = ((Sint32) SDL_SwapLE32(val));
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_S32LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint32 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S32MSB.\n");
+#endif
+
+    src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
+    dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const Sint32 val = (((Sint32) ((SDL_SwapLE16(*src)) ^ 0x8000)) << 16);
+        *dst = ((Sint32) SDL_SwapBE32(val));
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_S32MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16LSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    float *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_F32LSB.\n");
+#endif
+
+    src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
+    dst = (float *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const float val = (((float) SDL_SwapLE16(*src)) * DIVBY65535);
+        *dst = SDL_SwapFloatLE(val);
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_F32LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    float *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_F32MSB.\n");
+#endif
+
+    src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
+    dst = (float *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const float val = (((float) SDL_SwapLE16(*src)) * DIVBY65535);
+        *dst = SDL_SwapFloatBE(val);
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_F32MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint8 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_U8.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Uint8 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Uint8 val = ((Uint8) (((((Sint16) SDL_SwapLE16(*src))) ^ 0x8000) >> 8));
+        *dst = val;
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_U8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint8 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S8.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Sint8 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Sint8 val = ((Sint8) (((Sint16) SDL_SwapLE16(*src)) >> 8));
+        *dst = ((Sint8) val);
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_S8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16LSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_U16LSB.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Uint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Uint16 val = ((((Sint16) SDL_SwapLE16(*src))) ^ 0x8000);
+        *dst = SDL_SwapLE16(val);
+    }
+
+    format = AUDIO_U16LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_U16MSB.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Uint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Uint16 val = ((((Sint16) SDL_SwapLE16(*src))) ^ 0x8000);
+        *dst = SDL_SwapBE16(val);
+    }
+
+    format = AUDIO_U16MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S16MSB.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Sint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Sint16 val = ((Sint16) SDL_SwapLE16(*src));
+        *dst = ((Sint16) SDL_SwapBE16(val));
+    }
+
+    format = AUDIO_S16MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16LSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint32 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S32LSB.\n");
+#endif
+
+    src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
+    dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const Sint32 val = (((Sint32) ((Sint16) SDL_SwapLE16(*src))) << 16);
+        *dst = ((Sint32) SDL_SwapLE32(val));
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_S32LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint32 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S32MSB.\n");
+#endif
+
+    src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
+    dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const Sint32 val = (((Sint32) ((Sint16) SDL_SwapLE16(*src))) << 16);
+        *dst = ((Sint32) SDL_SwapBE32(val));
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_S32MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16LSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    float *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_F32LSB.\n");
+#endif
+
+    src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
+    dst = (float *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const float val = (((float) ((Sint16) SDL_SwapLE16(*src))) * DIVBY32767);
+        *dst = SDL_SwapFloatLE(val);
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_F32LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    float *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_F32MSB.\n");
+#endif
+
+    src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
+    dst = (float *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const float val = (((float) ((Sint16) SDL_SwapLE16(*src))) * DIVBY32767);
+        *dst = SDL_SwapFloatBE(val);
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_F32MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint8 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_U8.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Uint8 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Uint8 val = ((Uint8) (SDL_SwapBE16(*src) >> 8));
+        *dst = val;
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_U8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint8 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S8.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Sint8 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Sint8 val = ((Sint8) (((SDL_SwapBE16(*src)) ^ 0x8000) >> 8));
+        *dst = ((Sint8) val);
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_S8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_U16LSB.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Uint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Uint16 val = SDL_SwapBE16(*src);
+        *dst = SDL_SwapLE16(val);
+    }
+
+    format = AUDIO_U16LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S16LSB.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Sint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Sint16 val = ((SDL_SwapBE16(*src)) ^ 0x8000);
+        *dst = ((Sint16) SDL_SwapLE16(val));
+    }
+
+    format = AUDIO_S16LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16MSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S16MSB.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Sint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Sint16 val = ((SDL_SwapBE16(*src)) ^ 0x8000);
+        *dst = ((Sint16) SDL_SwapBE16(val));
+    }
+
+    format = AUDIO_S16MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint32 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S32LSB.\n");
+#endif
+
+    src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
+    dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const Sint32 val = (((Sint32) ((SDL_SwapBE16(*src)) ^ 0x8000)) << 16);
+        *dst = ((Sint32) SDL_SwapLE32(val));
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_S32LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16MSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint32 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S32MSB.\n");
+#endif
+
+    src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
+    dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const Sint32 val = (((Sint32) ((SDL_SwapBE16(*src)) ^ 0x8000)) << 16);
+        *dst = ((Sint32) SDL_SwapBE32(val));
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_S32MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    float *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_F32LSB.\n");
+#endif
+
+    src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
+    dst = (float *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const float val = (((float) SDL_SwapBE16(*src)) * DIVBY65535);
+        *dst = SDL_SwapFloatLE(val);
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_F32LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16MSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    float *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_F32MSB.\n");
+#endif
+
+    src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
+    dst = (float *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const float val = (((float) SDL_SwapBE16(*src)) * DIVBY65535);
+        *dst = SDL_SwapFloatBE(val);
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_F32MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint8 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_U8.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Uint8 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Uint8 val = ((Uint8) (((((Sint16) SDL_SwapBE16(*src))) ^ 0x8000) >> 8));
+        *dst = val;
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_U8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint8 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S8.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Sint8 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Sint8 val = ((Sint8) (((Sint16) SDL_SwapBE16(*src)) >> 8));
+        *dst = ((Sint8) val);
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_S8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_U16LSB.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Uint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Uint16 val = ((((Sint16) SDL_SwapBE16(*src))) ^ 0x8000);
+        *dst = SDL_SwapLE16(val);
+    }
+
+    format = AUDIO_U16LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S16LSB.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Sint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Sint16 val = ((Sint16) SDL_SwapBE16(*src));
+        *dst = ((Sint16) SDL_SwapLE16(val));
+    }
+
+    format = AUDIO_S16LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16MSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_U16MSB.\n");
+#endif
+
+    src = (const Uint16 *) cvt->buf;
+    dst = (Uint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
+        const Uint16 val = ((((Sint16) SDL_SwapBE16(*src))) ^ 0x8000);
+        *dst = SDL_SwapBE16(val);
+    }
+
+    format = AUDIO_U16MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint32 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S32LSB.\n");
+#endif
+
+    src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
+    dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const Sint32 val = (((Sint32) ((Sint16) SDL_SwapBE16(*src))) << 16);
+        *dst = ((Sint32) SDL_SwapLE32(val));
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_S32LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16MSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint32 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S32MSB.\n");
+#endif
+
+    src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
+    dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const Sint32 val = (((Sint32) ((Sint16) SDL_SwapBE16(*src))) << 16);
+        *dst = ((Sint32) SDL_SwapBE32(val));
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_S32MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    float *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_F32LSB.\n");
+#endif
+
+    src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
+    dst = (float *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const float val = (((float) ((Sint16) SDL_SwapBE16(*src))) * DIVBY32767);
+        *dst = SDL_SwapFloatLE(val);
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_F32LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16MSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    float *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_F32MSB.\n");
+#endif
+
+    src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
+    dst = (float *) (cvt->buf + cvt->len_cvt * 2);
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const float val = (((float) ((Sint16) SDL_SwapBE16(*src))) * DIVBY32767);
+        *dst = SDL_SwapFloatBE(val);
+    }
+
+    cvt->len_cvt *= 2;
+    format = AUDIO_F32MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Uint8 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_U8.\n");
+#endif
+
+    src = (const Uint32 *) cvt->buf;
+    dst = (Uint8 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
+        const Uint8 val = ((Uint8) (((((Sint32) SDL_SwapLE32(*src))) ^ 0x80000000) >> 24));
+        *dst = val;
+    }
+
+    cvt->len_cvt /= 4;
+    format = AUDIO_U8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Sint8 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S8.\n");
+#endif
+
+    src = (const Uint32 *) cvt->buf;
+    dst = (Sint8 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
+        const Sint8 val = ((Sint8) (((Sint32) SDL_SwapLE32(*src)) >> 24));
+        *dst = ((Sint8) val);
+    }
+
+    cvt->len_cvt /= 4;
+    format = AUDIO_S8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32LSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Uint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_U16LSB.\n");
+#endif
+
+    src = (const Uint32 *) cvt->buf;
+    dst = (Uint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
+        const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapLE32(*src))) ^ 0x80000000) >> 16));
+        *dst = SDL_SwapLE16(val);
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_U16LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32LSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Sint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S16LSB.\n");
+#endif
+
+    src = (const Uint32 *) cvt->buf;
+    dst = (Sint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
+        const Sint16 val = ((Sint16) (((Sint32) SDL_SwapLE32(*src)) >> 16));
+        *dst = ((Sint16) SDL_SwapLE16(val));
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_S16LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Uint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_U16MSB.\n");
+#endif
+
+    src = (const Uint32 *) cvt->buf;
+    dst = (Uint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
+        const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapLE32(*src))) ^ 0x80000000) >> 16));
+        *dst = SDL_SwapBE16(val);
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_U16MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Sint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S16MSB.\n");
+#endif
+
+    src = (const Uint32 *) cvt->buf;
+    dst = (Sint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
+        const Sint16 val = ((Sint16) (((Sint32) SDL_SwapLE32(*src)) >> 16));
+        *dst = ((Sint16) SDL_SwapBE16(val));
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_S16MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Sint32 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S32MSB.\n");
+#endif
+
+    src = (const Uint32 *) cvt->buf;
+    dst = (Sint32 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
+        const Sint32 val = ((Sint32) SDL_SwapLE32(*src));
+        *dst = ((Sint32) SDL_SwapBE32(val));
+    }
+
+    format = AUDIO_S32MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32LSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    float *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_F32LSB.\n");
+#endif
+
+    src = (const Uint32 *) cvt->buf;
+    dst = (float *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
+        const float val = (((float) ((Sint32) SDL_SwapLE32(*src))) * DIVBY2147483647);
+        *dst = SDL_SwapFloatLE(val);
+    }
+
+    format = AUDIO_F32LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    float *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_F32MSB.\n");
+#endif
+
+    src = (const Uint32 *) cvt->buf;
+    dst = (float *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
+        const float val = (((float) ((Sint32) SDL_SwapLE32(*src))) * DIVBY2147483647);
+        *dst = SDL_SwapFloatBE(val);
+    }
+
+    format = AUDIO_F32MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Uint8 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_U8.\n");
+#endif
+
+    src = (const Uint32 *) cvt->buf;
+    dst = (Uint8 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
+        const Uint8 val = ((Uint8) (((((Sint32) SDL_SwapBE32(*src))) ^ 0x80000000) >> 24));
+        *dst = val;
+    }
+
+    cvt->len_cvt /= 4;
+    format = AUDIO_U8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Sint8 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S8.\n");
+#endif
+
+    src = (const Uint32 *) cvt->buf;
+    dst = (Sint8 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
+        const Sint8 val = ((Sint8) (((Sint32) SDL_SwapBE32(*src)) >> 24));
+        *dst = ((Sint8) val);
+    }
+
+    cvt->len_cvt /= 4;
+    format = AUDIO_S8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Uint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_U16LSB.\n");
+#endif
+
+    src = (const Uint32 *) cvt->buf;
+    dst = (Uint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
+        const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapBE32(*src))) ^ 0x80000000) >> 16));
+        *dst = SDL_SwapLE16(val);
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_U16LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Sint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S16LSB.\n");
+#endif
+
+    src = (const Uint32 *) cvt->buf;
+    dst = (Sint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
+        const Sint16 val = ((Sint16) (((Sint32) SDL_SwapBE32(*src)) >> 16));
+        *dst = ((Sint16) SDL_SwapLE16(val));
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_S16LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32MSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Uint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_U16MSB.\n");
+#endif
+
+    src = (const Uint32 *) cvt->buf;
+    dst = (Uint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
+        const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapBE32(*src))) ^ 0x80000000) >> 16));
+        *dst = SDL_SwapBE16(val);
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_U16MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32MSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Sint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S16MSB.\n");
+#endif
+
+    src = (const Uint32 *) cvt->buf;
+    dst = (Sint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
+        const Sint16 val = ((Sint16) (((Sint32) SDL_SwapBE32(*src)) >> 16));
+        *dst = ((Sint16) SDL_SwapBE16(val));
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_S16MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Sint32 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S32LSB.\n");
+#endif
+
+    src = (const Uint32 *) cvt->buf;
+    dst = (Sint32 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
+        const Sint32 val = ((Sint32) SDL_SwapBE32(*src));
+        *dst = ((Sint32) SDL_SwapLE32(val));
+    }
+
+    format = AUDIO_S32LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    float *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_F32LSB.\n");
+#endif
+
+    src = (const Uint32 *) cvt->buf;
+    dst = (float *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
+        const float val = (((float) ((Sint32) SDL_SwapBE32(*src))) * DIVBY2147483647);
+        *dst = SDL_SwapFloatLE(val);
+    }
+
+    format = AUDIO_F32LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32MSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    float *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_F32MSB.\n");
+#endif
+
+    src = (const Uint32 *) cvt->buf;
+    dst = (float *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
+        const float val = (((float) ((Sint32) SDL_SwapBE32(*src))) * DIVBY2147483647);
+        *dst = SDL_SwapFloatBE(val);
+    }
+
+    format = AUDIO_F32MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Uint8 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_U8.\n");
+#endif
+
+    src = (const float *) cvt->buf;
+    dst = (Uint8 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
+        const Uint8 val = ((Uint8) (SDL_SwapFloatLE(*src) * 255.0f));
+        *dst = val;
+    }
+
+    cvt->len_cvt /= 4;
+    format = AUDIO_U8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint8 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S8.\n");
+#endif
+
+    src = (const float *) cvt->buf;
+    dst = (Sint8 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
+        const Sint8 val = ((Sint8) (SDL_SwapFloatLE(*src) * 127.0f));
+        *dst = ((Sint8) val);
+    }
+
+    cvt->len_cvt /= 4;
+    format = AUDIO_S8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32LSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Uint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_U16LSB.\n");
+#endif
+
+    src = (const float *) cvt->buf;
+    dst = (Uint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
+        const Uint16 val = ((Uint16) (SDL_SwapFloatLE(*src) * 65535.0f));
+        *dst = SDL_SwapLE16(val);
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_U16LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32LSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S16LSB.\n");
+#endif
+
+    src = (const float *) cvt->buf;
+    dst = (Sint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
+        const Sint16 val = ((Sint16) (SDL_SwapFloatLE(*src) * 32767.0f));
+        *dst = ((Sint16) SDL_SwapLE16(val));
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_S16LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Uint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_U16MSB.\n");
+#endif
+
+    src = (const float *) cvt->buf;
+    dst = (Uint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
+        const Uint16 val = ((Uint16) (SDL_SwapFloatLE(*src) * 65535.0f));
+        *dst = SDL_SwapBE16(val);
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_U16MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S16MSB.\n");
+#endif
+
+    src = (const float *) cvt->buf;
+    dst = (Sint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
+        const Sint16 val = ((Sint16) (SDL_SwapFloatLE(*src) * 32767.0f));
+        *dst = ((Sint16) SDL_SwapBE16(val));
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_S16MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32LSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint32 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S32LSB.\n");
+#endif
+
+    src = (const float *) cvt->buf;
+    dst = (Sint32 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
+        const Sint32 val = ((Sint32) (SDL_SwapFloatLE(*src) * 2147483647.0));
+        *dst = ((Sint32) SDL_SwapLE32(val));
+    }
+
+    format = AUDIO_S32LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint32 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S32MSB.\n");
+#endif
+
+    src = (const float *) cvt->buf;
+    dst = (Sint32 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
+        const Sint32 val = ((Sint32) (SDL_SwapFloatLE(*src) * 2147483647.0));
+        *dst = ((Sint32) SDL_SwapBE32(val));
+    }
+
+    format = AUDIO_S32MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    float *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_F32MSB.\n");
+#endif
+
+    src = (const float *) cvt->buf;
+    dst = (float *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
+        const float val = SDL_SwapFloatLE(*src);
+        *dst = SDL_SwapFloatBE(val);
+    }
+
+    format = AUDIO_F32MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Uint8 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_U8.\n");
+#endif
+
+    src = (const float *) cvt->buf;
+    dst = (Uint8 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
+        const Uint8 val = ((Uint8) (SDL_SwapFloatBE(*src) * 255.0f));
+        *dst = val;
+    }
+
+    cvt->len_cvt /= 4;
+    format = AUDIO_U8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint8 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S8.\n");
+#endif
+
+    src = (const float *) cvt->buf;
+    dst = (Sint8 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
+        const Sint8 val = ((Sint8) (SDL_SwapFloatBE(*src) * 127.0f));
+        *dst = ((Sint8) val);
+    }
+
+    cvt->len_cvt /= 4;
+    format = AUDIO_S8;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Uint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_U16LSB.\n");
+#endif
+
+    src = (const float *) cvt->buf;
+    dst = (Uint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
+        const Uint16 val = ((Uint16) (SDL_SwapFloatBE(*src) * 65535.0f));
+        *dst = SDL_SwapLE16(val);
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_U16LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S16LSB.\n");
+#endif
+
+    src = (const float *) cvt->buf;
+    dst = (Sint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
+        const Sint16 val = ((Sint16) (SDL_SwapFloatBE(*src) * 32767.0f));
+        *dst = ((Sint16) SDL_SwapLE16(val));
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_S16LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32MSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Uint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_U16MSB.\n");
+#endif
+
+    src = (const float *) cvt->buf;
+    dst = (Uint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
+        const Uint16 val = ((Uint16) (SDL_SwapFloatBE(*src) * 65535.0f));
+        *dst = SDL_SwapBE16(val);
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_U16MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32MSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint16 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S16MSB.\n");
+#endif
+
+    src = (const float *) cvt->buf;
+    dst = (Sint16 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
+        const Sint16 val = ((Sint16) (SDL_SwapFloatBE(*src) * 32767.0f));
+        *dst = ((Sint16) SDL_SwapBE16(val));
+    }
+
+    cvt->len_cvt /= 2;
+    format = AUDIO_S16MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint32 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S32LSB.\n");
+#endif
+
+    src = (const float *) cvt->buf;
+    dst = (Sint32 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
+        const Sint32 val = ((Sint32) (SDL_SwapFloatBE(*src) * 2147483647.0));
+        *dst = ((Sint32) SDL_SwapLE32(val));
+    }
+
+    format = AUDIO_S32LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32MSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint32 *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S32MSB.\n");
+#endif
+
+    src = (const float *) cvt->buf;
+    dst = (Sint32 *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
+        const Sint32 val = ((Sint32) (SDL_SwapFloatBE(*src) * 2147483647.0));
+        *dst = ((Sint32) SDL_SwapBE32(val));
+    }
+
+    format = AUDIO_S32MSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    float *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_F32LSB.\n");
+#endif
+
+    src = (const float *) cvt->buf;
+    dst = (float *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
+        const float val = SDL_SwapFloatBE(*src);
+        *dst = SDL_SwapFloatLE(val);
+    }
+
+    format = AUDIO_F32LSB;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+const SDL_AudioTypeFilters sdl_audio_type_filters[] =
+{
+    { AUDIO_U8, AUDIO_S8, SDL_Convert_U8_to_S8 },
+    { AUDIO_U8, AUDIO_U16LSB, SDL_Convert_U8_to_U16LSB },
+    { AUDIO_U8, AUDIO_S16LSB, SDL_Convert_U8_to_S16LSB },
+    { AUDIO_U8, AUDIO_U16MSB, SDL_Convert_U8_to_U16MSB },
+    { AUDIO_U8, AUDIO_S16MSB, SDL_Convert_U8_to_S16MSB },
+    { AUDIO_U8, AUDIO_S32LSB, SDL_Convert_U8_to_S32LSB },
+    { AUDIO_U8, AUDIO_S32MSB, SDL_Convert_U8_to_S32MSB },
+    { AUDIO_U8, AUDIO_F32LSB, SDL_Convert_U8_to_F32LSB },
+    { AUDIO_U8, AUDIO_F32MSB, SDL_Convert_U8_to_F32MSB },
+    { AUDIO_S8, AUDIO_U8, SDL_Convert_S8_to_U8 },
+    { AUDIO_S8, AUDIO_U16LSB, SDL_Convert_S8_to_U16LSB },
+    { AUDIO_S8, AUDIO_S16LSB, SDL_Convert_S8_to_S16LSB },
+    { AUDIO_S8, AUDIO_U16MSB, SDL_Convert_S8_to_U16MSB },
+    { AUDIO_S8, AUDIO_S16MSB, SDL_Convert_S8_to_S16MSB },
+    { AUDIO_S8, AUDIO_S32LSB, SDL_Convert_S8_to_S32LSB },
+    { AUDIO_S8, AUDIO_S32MSB, SDL_Convert_S8_to_S32MSB },
+    { AUDIO_S8, AUDIO_F32LSB, SDL_Convert_S8_to_F32LSB },
+    { AUDIO_S8, AUDIO_F32MSB, SDL_Convert_S8_to_F32MSB },
+    { AUDIO_U16LSB, AUDIO_U8, SDL_Convert_U16LSB_to_U8 },
+    { AUDIO_U16LSB, AUDIO_S8, SDL_Convert_U16LSB_to_S8 },
+    { AUDIO_U16LSB, AUDIO_S16LSB, SDL_Convert_U16LSB_to_S16LSB },
+    { AUDIO_U16LSB, AUDIO_U16MSB, SDL_Convert_U16LSB_to_U16MSB },
+    { AUDIO_U16LSB, AUDIO_S16MSB, SDL_Convert_U16LSB_to_S16MSB },
+    { AUDIO_U16LSB, AUDIO_S32LSB, SDL_Convert_U16LSB_to_S32LSB },
+    { AUDIO_U16LSB, AUDIO_S32MSB, SDL_Convert_U16LSB_to_S32MSB },
+    { AUDIO_U16LSB, AUDIO_F32LSB, SDL_Convert_U16LSB_to_F32LSB },
+    { AUDIO_U16LSB, AUDIO_F32MSB, SDL_Convert_U16LSB_to_F32MSB },
+    { AUDIO_S16LSB, AUDIO_U8, SDL_Convert_S16LSB_to_U8 },
+    { AUDIO_S16LSB, AUDIO_S8, SDL_Convert_S16LSB_to_S8 },
+    { AUDIO_S16LSB, AUDIO_U16LSB, SDL_Convert_S16LSB_to_U16LSB },
+    { AUDIO_S16LSB, AUDIO_U16MSB, SDL_Convert_S16LSB_to_U16MSB },
+    { AUDIO_S16LSB, AUDIO_S16MSB, SDL_Convert_S16LSB_to_S16MSB },
+    { AUDIO_S16LSB, AUDIO_S32LSB, SDL_Convert_S16LSB_to_S32LSB },
+    { AUDIO_S16LSB, AUDIO_S32MSB, SDL_Convert_S16LSB_to_S32MSB },
+    { AUDIO_S16LSB, AUDIO_F32LSB, SDL_Convert_S16LSB_to_F32LSB },
+    { AUDIO_S16LSB, AUDIO_F32MSB, SDL_Convert_S16LSB_to_F32MSB },
+    { AUDIO_U16MSB, AUDIO_U8, SDL_Convert_U16MSB_to_U8 },
+    { AUDIO_U16MSB, AUDIO_S8, SDL_Convert_U16MSB_to_S8 },
+    { AUDIO_U16MSB, AUDIO_U16LSB, SDL_Convert_U16MSB_to_U16LSB },
+    { AUDIO_U16MSB, AUDIO_S16LSB, SDL_Convert_U16MSB_to_S16LSB },
+    { AUDIO_U16MSB, AUDIO_S16MSB, SDL_Convert_U16MSB_to_S16MSB },
+    { AUDIO_U16MSB, AUDIO_S32LSB, SDL_Convert_U16MSB_to_S32LSB },
+    { AUDIO_U16MSB, AUDIO_S32MSB, SDL_Convert_U16MSB_to_S32MSB },
+    { AUDIO_U16MSB, AUDIO_F32LSB, SDL_Convert_U16MSB_to_F32LSB },
+    { AUDIO_U16MSB, AUDIO_F32MSB, SDL_Convert_U16MSB_to_F32MSB },
+    { AUDIO_S16MSB, AUDIO_U8, SDL_Convert_S16MSB_to_U8 },
+    { AUDIO_S16MSB, AUDIO_S8, SDL_Convert_S16MSB_to_S8 },
+    { AUDIO_S16MSB, AUDIO_U16LSB, SDL_Convert_S16MSB_to_U16LSB },
+    { AUDIO_S16MSB, AUDIO_S16LSB, SDL_Convert_S16MSB_to_S16LSB },
+    { AUDIO_S16MSB, AUDIO_U16MSB, SDL_Convert_S16MSB_to_U16MSB },
+    { AUDIO_S16MSB, AUDIO_S32LSB, SDL_Convert_S16MSB_to_S32LSB },
+    { AUDIO_S16MSB, AUDIO_S32MSB, SDL_Convert_S16MSB_to_S32MSB },
+    { AUDIO_S16MSB, AUDIO_F32LSB, SDL_Convert_S16MSB_to_F32LSB },
+    { AUDIO_S16MSB, AUDIO_F32MSB, SDL_Convert_S16MSB_to_F32MSB },
+    { AUDIO_S32LSB, AUDIO_U8, SDL_Convert_S32LSB_to_U8 },
+    { AUDIO_S32LSB, AUDIO_S8, SDL_Convert_S32LSB_to_S8 },
+    { AUDIO_S32LSB, AUDIO_U16LSB, SDL_Convert_S32LSB_to_U16LSB },
+    { AUDIO_S32LSB, AUDIO_S16LSB, SDL_Convert_S32LSB_to_S16LSB },
+    { AUDIO_S32LSB, AUDIO_U16MSB, SDL_Convert_S32LSB_to_U16MSB },
+    { AUDIO_S32LSB, AUDIO_S16MSB, SDL_Convert_S32LSB_to_S16MSB },
+    { AUDIO_S32LSB, AUDIO_S32MSB, SDL_Convert_S32LSB_to_S32MSB },
+    { AUDIO_S32LSB, AUDIO_F32LSB, SDL_Convert_S32LSB_to_F32LSB },
+    { AUDIO_S32LSB, AUDIO_F32MSB, SDL_Convert_S32LSB_to_F32MSB },
+    { AUDIO_S32MSB, AUDIO_U8, SDL_Convert_S32MSB_to_U8 },
+    { AUDIO_S32MSB, AUDIO_S8, SDL_Convert_S32MSB_to_S8 },
+    { AUDIO_S32MSB, AUDIO_U16LSB, SDL_Convert_S32MSB_to_U16LSB },
+    { AUDIO_S32MSB, AUDIO_S16LSB, SDL_Convert_S32MSB_to_S16LSB },
+    { AUDIO_S32MSB, AUDIO_U16MSB, SDL_Convert_S32MSB_to_U16MSB },
+    { AUDIO_S32MSB, AUDIO_S16MSB, SDL_Convert_S32MSB_to_S16MSB },
+    { AUDIO_S32MSB, AUDIO_S32LSB, SDL_Convert_S32MSB_to_S32LSB },
+    { AUDIO_S32MSB, AUDIO_F32LSB, SDL_Convert_S32MSB_to_F32LSB },
+    { AUDIO_S32MSB, AUDIO_F32MSB, SDL_Convert_S32MSB_to_F32MSB },
+    { AUDIO_F32LSB, AUDIO_U8, SDL_Convert_F32LSB_to_U8 },
+    { AUDIO_F32LSB, AUDIO_S8, SDL_Convert_F32LSB_to_S8 },
+    { AUDIO_F32LSB, AUDIO_U16LSB, SDL_Convert_F32LSB_to_U16LSB },
+    { AUDIO_F32LSB, AUDIO_S16LSB, SDL_Convert_F32LSB_to_S16LSB },
+    { AUDIO_F32LSB, AUDIO_U16MSB, SDL_Convert_F32LSB_to_U16MSB },
+    { AUDIO_F32LSB, AUDIO_S16MSB, SDL_Convert_F32LSB_to_S16MSB },
+    { AUDIO_F32LSB, AUDIO_S32LSB, SDL_Convert_F32LSB_to_S32LSB },
+    { AUDIO_F32LSB, AUDIO_S32MSB, SDL_Convert_F32LSB_to_S32MSB },
+    { AUDIO_F32LSB, AUDIO_F32MSB, SDL_Convert_F32LSB_to_F32MSB },
+    { AUDIO_F32MSB, AUDIO_U8, SDL_Convert_F32MSB_to_U8 },
+    { AUDIO_F32MSB, AUDIO_S8, SDL_Convert_F32MSB_to_S8 },
+    { AUDIO_F32MSB, AUDIO_U16LSB, SDL_Convert_F32MSB_to_U16LSB },
+    { AUDIO_F32MSB, AUDIO_S16LSB, SDL_Convert_F32MSB_to_S16LSB },
+    { AUDIO_F32MSB, AUDIO_U16MSB, SDL_Convert_F32MSB_to_U16MSB },
+    { AUDIO_F32MSB, AUDIO_S16MSB, SDL_Convert_F32MSB_to_S16MSB },
+    { AUDIO_F32MSB, AUDIO_S32LSB, SDL_Convert_F32MSB_to_S32LSB },
+    { AUDIO_F32MSB, AUDIO_S32MSB, SDL_Convert_F32MSB_to_S32MSB },
+    { AUDIO_F32MSB, AUDIO_F32LSB, SDL_Convert_F32MSB_to_F32LSB },
+};
+
+
diff --git a/src/audio/SDL_mixer.c b/src/audio/SDL_mixer.c
index a8dec88ff..b7e3c1ec8 100644
--- a/src/audio/SDL_mixer.c
+++ b/src/audio/SDL_mixer.c
@@ -92,22 +92,27 @@ static const Uint8 mix8[] = {
 void
 SDL_MixAudio(Uint8 * dst, const Uint8 * src, Uint32 len, int volume)
 {
-    Uint16 format;
-
-    if (volume == 0) {
-        return;
-    }
     /* Mix the user-level audio format */
     if (current_audio) {
+        SDL_AudioFormat format;
         if (current_audio->convert.needed) {
             format = current_audio->convert.src_format;
         } else {
             format = current_audio->spec.format;
         }
-    } else {
-        /* HACK HACK HACK */
-        format = AUDIO_S16;
+        SDL_MixAudioFormat(dst, src, format, len, volume);
     }
+}
+
+
+void
+SDL_MixAudioFormat(Uint8 * dst, const Uint8 * src, SDL_AudioFormat format,
+                   Uint32 len, int volume)
+{
+    if (volume == 0) {
+        return;
+    }
+
     switch (format) {
 
     case AUDIO_U8:
@@ -252,6 +257,134 @@ SDL_MixAudio(Uint8 * dst, const Uint8 * src, Uint32 len, int volume)
         }
         break;
 
+    case AUDIO_S32LSB:
+        {
+            const Uint32 *src32 = (Uint32 *) src;
+            Uint32 *dst32 = (Uint32 *) dst;
+            Sint32 src1, src2;
+            Sint64 dst_sample;
+            const Sint64 max_audioval = ((((Sint64)1) << (32 - 1)) - 1);
+            const Sint64 min_audioval = -(((Sint64)1) << (32 - 1));
+
+            len /= 4;
+            while (len--) {
+                src1 = (Sint32) SDL_SwapLE32(*src32);
+                src32++;
+                ADJUST_VOLUME(src1, volume);
+                src2 = (Sint32) SDL_SwapLE32(*dst32);
+                dst_sample = src1 + src2;
+                if (dst_sample > max_audioval) {
+                    dst_sample = max_audioval;
+                } else if (dst_sample < min_audioval) {
+                    dst_sample = min_audioval;
+                }
+                *(dst32++) = SDL_SwapLE32((Uint32) ((Sint32) dst_sample));
+            }
+        }
+        break;
+
+    case AUDIO_S32MSB:
+        {
+            const Uint32 *src32 = (Uint32 *) src;
+            Uint32 *dst32 = (Uint32 *) dst;
+            Sint32 src1, src2;
+            Sint64 dst_sample;
+            const Sint64 max_audioval = ((((Sint64)1) << (32 - 1)) - 1);
+            const Sint64 min_audioval = -(((Sint64)1) << (32 - 1));
+
+            len /= 4;
+            while (len--) {
+                src1 = (Sint32) SDL_SwapBE32(*src32);
+                src32++;
+                ADJUST_VOLUME(src1, volume);
+                src2 = (Sint32) SDL_SwapBE32(*dst32);
+                dst_sample = src1 + src2;
+                if (dst_sample > max_audioval) {
+                    dst_sample = max_audioval;
+                } else if (dst_sample < min_audioval) {
+                    dst_sample = min_audioval;
+                }
+                *(dst32++) = SDL_SwapBE32((Uint32) ((Sint32) dst_sample));
+            }
+        }
+        break;
+
+    case AUDIO_F32LSB:
+        {
+            const float fmaxvolume = 1.0f / ((float) SDL_MIX_MAXVOLUME);
+            const float fvolume = (float) volume;
+            const float *src32 = (float *) src;
+            float *dst32 = (float *) dst;
+            float src1, src2;
+            double dst_sample;
+            /* !!! FIXME: are these right? */
+            const double max_audioval = 3.40282347e+38F;
+            const double min_audioval = -3.40282347e+38F;
+
+            /* !!! FIXME: this is a little nasty. */
+            union { float f; Uint32 ui32; } cvt;
+
+            len /= 4;
+            while (len--) {
+                cvt.f = *(src32++);
+                cvt.ui32 = SDL_SwapLE32(cvt.ui32);
+                src1 = ((cvt.f * fvolume) * fmaxvolume);
+
+                cvt.f = *dst32;
+                cvt.ui32 = SDL_SwapLE32(cvt.ui32);
+                src2 = cvt.f;
+
+                dst_sample = src1 + src2;
+                if (dst_sample > max_audioval) {
+                    dst_sample = max_audioval;
+                } else if (dst_sample < min_audioval) {
+                    dst_sample = min_audioval;
+                }
+                cvt.f = ((float) dst_sample);
+                cvt.ui32 = SDL_SwapLE32(cvt.ui32);
+                *(dst32++) = cvt.f;
+            }
+        }
+        break;
+
+    case AUDIO_F32MSB:
+        {
+            const float fmaxvolume = 1.0f / ((float) SDL_MIX_MAXVOLUME);
+            const float fvolume = (float) volume;
+            const float *src32 = (float *) src;
+            float *dst32 = (float *) dst;
+            float src1, src2;
+            double dst_sample;
+            /* !!! FIXME: are these right? */
+            const double max_audioval = 3.40282347e+38F;
+            const double min_audioval = -3.40282347e+38F;
+
+            /* !!! FIXME: this is a little nasty. */
+            union { float f; Uint32 ui32; } cvt;
+
+            len /= 4;
+            while (len--) {
+                cvt.f = *(src32++);
+                cvt.ui32 = SDL_SwapBE32(cvt.ui32);
+                src1 = ((cvt.f * fvolume) * fmaxvolume);
+
+                cvt.f = *dst32;
+                cvt.ui32 = SDL_SwapBE32(cvt.ui32);
+                src2 = cvt.f;
+
+                dst_sample = src1 + src2;
+                if (dst_sample > max_audioval) {
+                    dst_sample = max_audioval;
+                } else if (dst_sample < min_audioval) {
+                    dst_sample = min_audioval;
+                }
+                cvt.f = ((float) dst_sample);
+                cvt.ui32 = SDL_SwapBE32(cvt.ui32);
+                *(dst32++) = cvt.f;
+            }
+        }
+        break;
+
     default:                   /* If this happens... FIXME! */
         SDL_SetError("SDL_MixAudio(): unknown audio format");
         return;
diff --git a/src/audio/alsa/SDL_alsa_audio.c b/src/audio/alsa/SDL_alsa_audio.c
index f0e4655bd..0c476afdb 100644
--- a/src/audio/alsa/SDL_alsa_audio.c
+++ b/src/audio/alsa/SDL_alsa_audio.c
@@ -483,7 +483,7 @@ ALSA_OpenAudio(_THIS, SDL_AudioSpec * spec)
     snd_pcm_sw_params_t *swparams;
     snd_pcm_format_t format;
     snd_pcm_uframes_t frames;
-    Uint16 test_format;
+    SDL_AudioFormat test_format;
 
     /* Open the audio device */
     /* Name of device should depend on # channels in spec */
diff --git a/src/audio/arts/SDL_artsaudio.c b/src/audio/arts/SDL_artsaudio.c
index e70252f69..038d4de60 100644
--- a/src/audio/arts/SDL_artsaudio.c
+++ b/src/audio/arts/SDL_artsaudio.c
@@ -274,7 +274,7 @@ static int
 ARTS_OpenAudio(_THIS, SDL_AudioSpec * spec)
 {
     int bits, frag_spec;
-    Uint16 test_format, format;
+    SDL_AudioFormat test_format, format;
 
     /* Reset the timer synchronization flag */
     frame_ticks = 0.0;
diff --git a/src/audio/bsd/SDL_bsdaudio.c b/src/audio/bsd/SDL_bsdaudio.c
index 89e1e14ad..762d0b27c 100644
--- a/src/audio/bsd/SDL_bsdaudio.c
+++ b/src/audio/bsd/SDL_bsdaudio.c
@@ -331,7 +331,7 @@ static int
 OBSD_OpenAudio(_THIS, SDL_AudioSpec * spec)
 {
     char audiodev[64];
-    Uint16 format;
+    SDL_AudioFormat format;
     audio_info_t info;
 
     AUDIO_INITINFO(&info);
diff --git a/src/audio/dma/SDL_dmaaudio.c b/src/audio/dma/SDL_dmaaudio.c
index 820d23b71..f1d08cc03 100644
--- a/src/audio/dma/SDL_dmaaudio.c
+++ b/src/audio/dma/SDL_dmaaudio.c
@@ -321,7 +321,7 @@ DMA_OpenAudio(_THIS, SDL_AudioSpec * spec)
     int format;
     int stereo;
     int value;
-    Uint16 test_format;
+    SDL_AudioFormat test_format;
     struct audio_buf_info info;
 
     /* Reset the timer synchronization flag */
diff --git a/src/audio/dsp/SDL_dspaudio.c b/src/audio/dsp/SDL_dspaudio.c
index b933b2956..7fd3f06a4 100644
--- a/src/audio/dsp/SDL_dspaudio.c
+++ b/src/audio/dsp/SDL_dspaudio.c
@@ -172,7 +172,7 @@ DSP_OpenAudio(_THIS, SDL_AudioSpec * spec)
     int format;
     int value;
     int frag_spec;
-    Uint16 test_format;
+    SDL_AudioFormat test_format;
 
     /* Open the audio device */
     audio_fd = SDL_OpenAudioPath(audiodev, sizeof(audiodev), OPEN_FLAGS, 0);
diff --git a/src/audio/nas/SDL_nasaudio.c b/src/audio/nas/SDL_nasaudio.c
index ba4cecf33..fca8df78a 100644
--- a/src/audio/nas/SDL_nasaudio.c
+++ b/src/audio/nas/SDL_nasaudio.c
@@ -237,7 +237,7 @@ NAS_OpenAudio(_THIS, SDL_AudioSpec * spec)
 {
     AuElement elms[3];
     int buffer_size;
-    Uint16 test_format, format;
+    SDL_AudioFormat test_format, format;
 
     this->hidden->mixbuf = NULL;
 
diff --git a/src/audio/nto/SDL_nto_audio.c b/src/audio/nto/SDL_nto_audio.c
index ee97f0cdb..568d186f2 100644
--- a/src/audio/nto/SDL_nto_audio.c
+++ b/src/audio/nto/SDL_nto_audio.c
@@ -348,7 +348,7 @@ NTO_OpenAudio(_THIS, SDL_AudioSpec * spec)
 {
     int rval;
     int format;
-    Uint16 test_format;
+    SDL_AudioFormat test_format;
     int found;
 
     audio_handle = NULL;
diff --git a/src/audio/paudio/SDL_paudio.c b/src/audio/paudio/SDL_paudio.c
index 5276426f4..81f26d9f6 100644
--- a/src/audio/paudio/SDL_paudio.c
+++ b/src/audio/paudio/SDL_paudio.c
@@ -244,7 +244,7 @@ Paud_OpenAudio(_THIS, SDL_AudioSpec * spec)
     char audiodev[1024];
     int format;
     int bytes_per_sample;
-    Uint16 test_format;
+    SDL_AudioFormat test_format;
     audio_init paud_init;
     audio_buffer paud_bufinfo;
     audio_status paud_status;
diff --git a/src/audio/sdlgenaudiocvt.pl b/src/audio/sdlgenaudiocvt.pl
new file mode 100755
index 000000000..f95afb95b
--- /dev/null
+++ b/src/audio/sdlgenaudiocvt.pl
@@ -0,0 +1,313 @@
+#!/usr/bin/perl -w
+
+use warnings;
+use strict;
+
+my @audiotypes = qw(
+    U8
+    S8
+    U16LSB
+    S16LSB
+    U16MSB
+    S16MSB
+    S32LSB
+    S32MSB
+    F32LSB
+    F32MSB
+);
+
+my %funcs;
+
+my $custom_converters = 0;
+
+
+sub outputHeader {
+    print <<EOF;
+/* DO NOT EDIT THIS FILE! It is generated code. */
+/* Please modify SDL/src/audio/sdlgenaudiocvt.pl instead. */
+
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2006 Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+    Sam Lantinga
+    slouken\@libsdl.org
+*/
+
+#include "SDL_config.h"
+#include "SDL_audio.h"
+#include "SDL_audio_c.h"
+
+/* Now the generated code... */
+
+EOF
+
+    my @vals = ( 127, 255, 32767, 65535, 2147483647 );
+    foreach (@vals) {
+        my $val = $_;
+        my $fval = 1.0 / $val;
+        print("#define DIVBY${val} ${fval}f\n");
+    }
+
+    print("\n");
+}
+
+
+sub splittype {
+    my $t = shift;
+    my ($signed, $size, $endian) = $t =~ /([USF])(\d+)([LM]SB|)/;
+    my $float = ($signed eq 'F') ? 1 : 0;
+    $signed = (($float) or ($signed eq 'S')) ? 1 : 0;
+    $endian = 'NONE' if ($endian eq '');
+
+    my $ctype = '';
+    if ($float) {
+        $ctype = (($size == 32) ? 'float' : 'double');
+    } else {
+        $ctype = (($signed) ? 'S' : 'U') . "int${size}";
+    }
+
+    return ($signed, $float, $size, $endian, $ctype);
+}
+
+sub getSwapFunc {
+    my ($size, $signed, $float, $endian, $val) = @_;
+    my $BEorLE = (($endian eq 'MSB') ? 'BE' : 'LE');
+    my $code = '';
+
+    if ($float) {
+        $code = "SDL_SwapFloat${BEorLE}($val)";
+    } else {
+        if ($size > 8) {
+            $code = "SDL_Swap${BEorLE}${size}($val)";
+        } else {
+            $code = $val;
+        }
+
+        if (($signed) and (!$float)) {
+            $code = "((Sint${size}) $code)";
+        }
+    }
+
+    return "${code}";
+}
+
+
+sub maxIntVal {
+    my ($signed, $size) = @_;
+    if ($signed) {
+        if ($size == 8) {
+            return 0x7F;
+        } elsif ($size == 16) {
+            return 0x7FFF;
+        } elsif ($size == 32) {
+            return 0x7FFFFFFF;
+        }
+    } else {
+        if ($size == 8) {
+            return 0xFF;
+        } elsif ($size == 16) {
+            return 0xFFFF;
+        } elsif ($size == 32) {
+            return 0xFFFFFFFF;
+        }
+    }
+
+    die("bug in script.\n");
+}
+
+sub getFloatToIntMult {
+    my ($signed, $size) = @_;
+    my $val = maxIntVal($signed, $size) . '.0';
+    $val .= 'f' if ($size < 32);
+    return $val;
+}
+
+sub getIntToFloatDivBy {
+    my ($signed, $size) = @_;
+    return 'DIVBY' . maxIntVal($signed, $size);
+}
+
+sub getSignFlipVal {
+    my $size = shift;
+    if ($size == 8) {
+        return '0x80';
+    } elsif ($size == 16) {
+        return '0x8000';
+    } elsif ($size == 32) {
+        return '0x80000000';
+    }
+
+    die("bug in script.\n");
+}
+
+sub buildCvtFunc {
+    my ($from, $to) = @_;
+    my ($fsigned, $ffloat, $fsize, $fendian, $fctype) = splittype($from);
+    my ($tsigned, $tfloat, $tsize, $tendian, $tctype) = splittype($to);
+    my $diffs = 0;
+    $diffs++ if ($fsize != $tsize);
+    $diffs++ if ($fsigned != $tsigned);
+    $diffs++ if ($ffloat != $tfloat);
+    $diffs++ if ($fendian ne $tendian);
+
+    return if ($diffs == 0);
+
+    my $hashid = "$from/$to";
+    if (1) { # !!! FIXME: if ($diffs > 1) {
+        my $sym = "SDL_Convert_${from}_to_${to}";
+        $funcs{$hashid} = $sym;
+        $custom_converters++;
+
+        # Always unsigned for ints, for possible byteswaps.
+        my $srctype = (($ffloat) ? 'float' : "Uint${fsize}");
+
+        print <<EOF;
+static void SDLCALL
+${sym}(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const $srctype *src;
+    $tctype *dst;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_${from} to AUDIO_${to}.\\n");
+#endif
+
+EOF
+
+        if ($fsize < $tsize) {
+            my $mult = $tsize / $fsize;
+            print <<EOF;
+    src = (const $srctype *) (cvt->buf + cvt->len_cvt);
+    dst = ($tctype *) (cvt->buf + cvt->len_cvt * $mult);
+    for (i = cvt->len_cvt / sizeof ($srctype); i; --i, --src, --dst) {
+EOF
+        } else {
+            print <<EOF;
+    src = (const $srctype *) cvt->buf;
+    dst = ($tctype *) cvt->buf;
+    for (i = cvt->len_cvt / sizeof ($srctype); i; --i, ++src, ++dst) {
+EOF
+        }
+
+        # Have to convert to/from float/int.
+        # !!! FIXME: cast through double for int32<->float?
+        my $code = getSwapFunc($fsize, $fsigned, $ffloat, $fendian, '*src');
+        if ($ffloat != $tfloat) {
+            if ($ffloat) {
+                my $mult = getFloatToIntMult($tsigned, $tsize);
+                $code = "(($tctype) ($code * $mult))";
+            } else {
+                # $divby will be the reciprocal, to avoid pipeline stalls
+                #  from floating point division...so multiply it.
+                my $divby = getIntToFloatDivBy($fsigned, $fsize);
+                $code = "(((float) $code) * $divby)";
+            }
+        } else {
+            # All integer conversions here.
+            if ($fsigned != $tsigned) {
+                my $signflipval = getSignFlipVal($fsize);
+                $code = "(($code) ^ $signflipval)";
+            }
+
+            my $shiftval = abs($fsize - $tsize);
+            if ($fsize < $tsize) {
+                $code = "((($tctype) $code) << $shiftval)";
+            } elsif ($fsize > $tsize) {
+                $code = "(($tctype) ($code >> $shiftval))";
+            }
+        }
+
+        my $swap = getSwapFunc($tsize, $tsigned, $tfloat, $tendian, 'val');
+
+        print <<EOF;
+        const $tctype val = $code;
+        *dst = ${swap};
+    }
+
+EOF
+
+        if ($fsize > $tsize) {
+            my $divby = $fsize / $tsize;
+            print("    cvt->len_cvt /= $divby;\n");
+        } elsif ($fsize < $tsize) {
+            my $mult = $tsize / $fsize;
+            print("    cvt->len_cvt *= $mult;\n");
+        }
+
+        print <<EOF;
+    format = AUDIO_$to;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+EOF
+
+    } else {
+        if ($fsigned != $tsigned) {
+            $funcs{$hashid} = 'SDL_ConvertSigned';
+        } elsif ($ffloat != $tfloat) {
+            $funcs{$hashid} = 'SDL_ConvertFloat';
+        } elsif ($fsize != $tsize) {
+            $funcs{$hashid} = 'SDL_ConvertSize';
+        } elsif ($fendian ne $tendian) {
+            $funcs{$hashid} = 'SDL_ConvertEndian';
+        } else {
+            die("error in script.\n");
+        }
+    }
+}
+
+outputHeader();
+
+foreach (@audiotypes) {
+    my $from = $_;
+    foreach (@audiotypes) {
+        my $to = $_;
+        buildCvtFunc($from, $to);
+    }
+}
+
+print <<EOF;
+const SDL_AudioTypeFilters sdl_audio_type_filters[] =
+{
+EOF
+
+foreach (@audiotypes) {
+    my $from = $_;
+    foreach (@audiotypes) {
+        my $to = $_;
+        if ($from ne $to) {
+            my $hashid = "$from/$to";
+            my $sym = $funcs{$hashid};
+            print("    { AUDIO_$from, AUDIO_$to, $sym },\n");
+        }
+    }
+}
+
+print <<EOF;
+};
+
+
+EOF
+
+exit 0;
+
+# end of sdlaudiocvt.pl ...
+
diff --git a/src/audio/sun/SDL_sunaudio.h b/src/audio/sun/SDL_sunaudio.h
index 7f33a2f32..1780ab1ce 100644
--- a/src/audio/sun/SDL_sunaudio.h
+++ b/src/audio/sun/SDL_sunaudio.h
@@ -34,7 +34,7 @@ struct SDL_PrivateAudioData
     /* The file descriptor for the audio device */
     int audio_fd;
 
-    Uint16 audio_fmt;           /* The app audio format */
+    SDL_AudioFormat audio_fmt;  /* The app audio format */
     Uint8 *mixbuf;              /* The app mixing buffer */
     int ulaw_only;              /* Flag -- does hardware only output U-law? */
     Uint8 *ulaw_buf;            /* The U-law mixing buffer */
diff --git a/src/audio/ums/SDL_umsaudio.c b/src/audio/ums/SDL_umsaudio.c
index c2524cf3a..df62126e7 100644
--- a/src/audio/ums/SDL_umsaudio.c
+++ b/src/audio/ums/SDL_umsaudio.c
@@ -250,7 +250,7 @@ UMS_OpenAudio(_THIS, SDL_AudioSpec * spec)
     long bitsPerSample;
     long samplesPerSec;
     long success;
-    Uint16 test_format;
+    SDL_AudioFormat test_format;
     int frag_spec;
     UMSAudioDevice_ReturnCode rc;