# HG changeset patch
# User Ryan C. Gordon <icculus@icculus.org>
# Date 1156421446 0
# Node ID 3b4ce57c621535d6ef9829f5d48e31fb912a5147
# Parent  3f21778e7433376973805ece0fa1200f9e96512c
First shot at new audio data types (int32 and float32).

Notable changes:
 - Converters between types are autogenerated. Instead of making multiple
   passes over the data with seperate filters for endianess, size, signedness,
   etc, converting between data types is always one specialized filter. This
   simplifies SDL_BuildAudioCVT(), which otherwise had a million edge cases
   with the new types, and makes the actually conversions more CPU cache
   friendly. Left a stub for adding specific optimized versions of these
   routines (SSE/MMX/Altivec, assembler, etc)
 - Autogenerated converters are built by SDL/src/audio/sdlgenaudiocvt.pl. This
   does not need to be run unless tweaking the code, and thus doesn't need
   integration into the build system.
 - Went through all the drivers and tried to weed out all the "Uint16"
   references that are better specified with the new SDL_AudioFormat typedef.
 - Cleaned out a bunch of hardcoded bitwise magic numbers and replaced them
   with new SDL_AUDIO_* macros.
 - Added initial float32 and int32 support code. Theoretically, existing
   drivers will push these through converters to get the data they want to
   feed to the hardware.

Still TODO:
 - Optimize and debug new converters.
 - Update the CoreAudio backend to accept float32 data directly.
 - Other backends, too?
 - SDL_LoadWAV() needs to be updated to support int32 and float32 .wav files
   (both of which exist and can be generated by 'sox' for testing purposes).
 - Update the mixer to handle new datatypes.
 - Optionally update SDL_sound and SDL_mixer, etc.

diff -r 3f21778e7433 -r 3b4ce57c6215 src/audio/SDL_audio.c
--- a/src/audio/SDL_audio.c	Thu Aug 10 15:15:06 2006 +0000
+++ b/src/audio/SDL_audio.c	Thu Aug 24 12:10:46 2006 +0000
@@ -286,10 +286,10 @@
     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 @@
     }
 }
 
-#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 @@
     return (SDL_NextAudioFormat());
 }
 
-Uint16
+SDL_AudioFormat
 SDL_NextAudioFormat(void)
 {
     if ((format_idx == NUM_FORMATS) || (format_idx_sub == NUM_FORMATS)) {
diff -r 3f21778e7433 -r 3b4ce57c6215 src/audio/SDL_audio_c.h
--- a/src/audio/SDL_audio_c.h	Thu Aug 10 15:15:06 2006 +0000
+++ b/src/audio/SDL_audio_c.h	Thu Aug 24 12:10:46 2006 +0000
@@ -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 -r 3f21778e7433 -r 3b4ce57c6215 src/audio/SDL_audiocvt.c
--- a/src/audio/SDL_audiocvt.c	Thu Aug 10 15:15:06 2006 +0000
+++ b/src/audio/SDL_audiocvt.c	Thu Aug 24 12:10:46 2006 +0000
@@ -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 @@
 #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 @@
 
             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 @@
 
             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 @@
             }
         }
         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;
+    #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; \
+        } \
+    }
 
-            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;
+    /* 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;
+    }
 
-    case AUDIO_S16:
-        {
-            Uint8 *src, *dst;
+    #undef strip_chans_6_to_2
 
-            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;
-    }
     cvt->len_cvt /= 3;
     if (cvt->filters[++cvt->filter_index]) {
         cvt->filters[cvt->filter_index] (cvt, format);
@@ -292,157 +270,87 @@
 
 
 /* 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;
+    #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; \
+        } \
+    }
 
-            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;
+    /* 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;
+    }
 
-    case AUDIO_S16:
-        {
-            Uint8 *src, *dst;
+    #undef strip_chans_6_to_4
 
-            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;
-    }
-    cvt->len_cvt /= 2;
+    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;
+
+    #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; \
+        } \
+    }
 
-        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;
+    /* 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;
+    }
 
-        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];
-        }
-    }
+    #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 @@
 
 
 /* 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 @@
             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 @@
             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 @@
             }
         }
         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 @@
 
 
 /* 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 @@
             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 @@
             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,218 +780,38 @@
             }
         }
         break;
-    }
-    cvt->len_cvt *= 2;
-    if (cvt->filters[++cvt->filter_index]) {
-        cvt->filters[cvt->filter_index] (cvt, 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;
+    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;
 
-#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)
-{
-    int i;
-    Uint8 *src, *dst;
-
-#ifdef DEBUG_CONVERT
-    fprintf(stderr, "Converting audio rate * 2\n");
-#endif
-    src = cvt->buf + cvt->len_cvt;
-    dst = cvt->buf + cvt->len_cvt * 2;
-    switch (format & 0xFF) {
-    case 8:
-        for (i = cvt->len_cvt; i; --i) {
-            src -= 1;
-            dst -= 2;
-            dst[0] = src[0];
-            dst[1] = src[0];
-        }
-        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];
-        }
-        break;
-    }
-    cvt->len_cvt *= 2;
-    if (cvt->filters[++cvt->filter_index]) {
-        cvt->filters[cvt->filter_index] (cvt, format);
-    }
-}
-
-
-/* Convert rate up by multiple of 2, for stereo */
-void SDLCALL
-SDL_RateMUL2_c2(SDL_AudioCVT * cvt, Uint16 format)
-{
-    int i;
-    Uint8 *src, *dst;
-
-#ifdef DEBUG_CONVERT
-    fprintf(stderr, "Converting audio rate * 2\n");
-#endif
-    src = cvt->buf + cvt->len_cvt;
-    dst = cvt->buf + cvt->len_cvt * 2;
-    switch (format & 0xFF) {
-    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];
-        }
-        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];
+            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;
     }
@@ -1003,56 +821,137 @@
     }
 }
 
-/* Convert rate up by multiple of 2, for quad */
-void SDLCALL
-SDL_RateMUL2_c4(SDL_AudioCVT * cvt, Uint16 format)
+/* Convert rate up by multiple of 2 */
+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 (mono)\n");
+#endif
+
+    #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:
+        mul2_mono(Uint8);
+        break;
+    case 16:
+        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);
+    }
+}
+
+
+/* Convert rate up by multiple of 2, for stereo */
+static void SDLCALL
+SDL_RateMUL2_c2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
 
 #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 / 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(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_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);
+    }
+}
+
+/* Convert rate up by multiple of 2, for quad */
+static void SDLCALL
+SDL_RateMUL2_c4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting audio rate * 2 (quad)\n");
+#endif
+
+    #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:
+        mul2_quad(Uint8);
+        break;
+    case 16:
+        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 @@
 
 
 /* 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 @@
 }
 
 /* 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 @@
 
 
 /* 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 @@
 
 
 /* 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 @@
 }
 
 /* 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 @@
 }
 
 /* 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 @@
 #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 @@
                 }
             }
             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 @@
                 }
             }
             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 @@
     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;
-    }
-
-    /* Second filter: Sign conversion -- signed/unsigned */
-    if ((src_format & 0x8000) != (dst_format & 0x8000)) {
-        cvt->filters[cvt->filter_index++] = SDL_ConvertSign;
-    }
+    /* 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... */
 
-    /* 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 @@
         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 @@
     /* 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 -r 3f21778e7433 -r 3b4ce57c6215 src/audio/SDL_audiotypecvt.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/audio/SDL_audiotypecvt.c	Thu Aug 24 12:10:46 2006 +0000
@@ -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 -r 3f21778e7433 -r 3b4ce57c6215 src/audio/SDL_mixer.c
--- a/src/audio/SDL_mixer.c	Thu Aug 10 15:15:06 2006 +0000
+++ b/src/audio/SDL_mixer.c	Thu Aug 24 12:10:46 2006 +0000
@@ -92,22 +92,27 @@
 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 @@
         }
         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 -r 3f21778e7433 -r 3b4ce57c6215 src/audio/alsa/SDL_alsa_audio.c
--- a/src/audio/alsa/SDL_alsa_audio.c	Thu Aug 10 15:15:06 2006 +0000
+++ b/src/audio/alsa/SDL_alsa_audio.c	Thu Aug 24 12:10:46 2006 +0000
@@ -483,7 +483,7 @@
     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 -r 3f21778e7433 -r 3b4ce57c6215 src/audio/arts/SDL_artsaudio.c
--- a/src/audio/arts/SDL_artsaudio.c	Thu Aug 10 15:15:06 2006 +0000
+++ b/src/audio/arts/SDL_artsaudio.c	Thu Aug 24 12:10:46 2006 +0000
@@ -274,7 +274,7 @@
 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 -r 3f21778e7433 -r 3b4ce57c6215 src/audio/bsd/SDL_bsdaudio.c
--- a/src/audio/bsd/SDL_bsdaudio.c	Thu Aug 10 15:15:06 2006 +0000
+++ b/src/audio/bsd/SDL_bsdaudio.c	Thu Aug 24 12:10:46 2006 +0000
@@ -331,7 +331,7 @@
 OBSD_OpenAudio(_THIS, SDL_AudioSpec * spec)
 {
     char audiodev[64];
-    Uint16 format;
+    SDL_AudioFormat format;
     audio_info_t info;
 
     AUDIO_INITINFO(&info);
diff -r 3f21778e7433 -r 3b4ce57c6215 src/audio/dma/SDL_dmaaudio.c
--- a/src/audio/dma/SDL_dmaaudio.c	Thu Aug 10 15:15:06 2006 +0000
+++ b/src/audio/dma/SDL_dmaaudio.c	Thu Aug 24 12:10:46 2006 +0000
@@ -321,7 +321,7 @@
     int format;
     int stereo;
     int value;
-    Uint16 test_format;
+    SDL_AudioFormat test_format;
     struct audio_buf_info info;
 
     /* Reset the timer synchronization flag */
diff -r 3f21778e7433 -r 3b4ce57c6215 src/audio/dsp/SDL_dspaudio.c
--- a/src/audio/dsp/SDL_dspaudio.c	Thu Aug 10 15:15:06 2006 +0000
+++ b/src/audio/dsp/SDL_dspaudio.c	Thu Aug 24 12:10:46 2006 +0000
@@ -172,7 +172,7 @@
     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 -r 3f21778e7433 -r 3b4ce57c6215 src/audio/nas/SDL_nasaudio.c
--- a/src/audio/nas/SDL_nasaudio.c	Thu Aug 10 15:15:06 2006 +0000
+++ b/src/audio/nas/SDL_nasaudio.c	Thu Aug 24 12:10:46 2006 +0000
@@ -237,7 +237,7 @@
 {
     AuElement elms[3];
     int buffer_size;
-    Uint16 test_format, format;
+    SDL_AudioFormat test_format, format;
 
     this->hidden->mixbuf = NULL;
 
diff -r 3f21778e7433 -r 3b4ce57c6215 src/audio/nto/SDL_nto_audio.c
--- a/src/audio/nto/SDL_nto_audio.c	Thu Aug 10 15:15:06 2006 +0000
+++ b/src/audio/nto/SDL_nto_audio.c	Thu Aug 24 12:10:46 2006 +0000
@@ -348,7 +348,7 @@
 {
     int rval;
     int format;
-    Uint16 test_format;
+    SDL_AudioFormat test_format;
     int found;
 
     audio_handle = NULL;
diff -r 3f21778e7433 -r 3b4ce57c6215 src/audio/paudio/SDL_paudio.c
--- a/src/audio/paudio/SDL_paudio.c	Thu Aug 10 15:15:06 2006 +0000
+++ b/src/audio/paudio/SDL_paudio.c	Thu Aug 24 12:10:46 2006 +0000
@@ -244,7 +244,7 @@
     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 -r 3f21778e7433 -r 3b4ce57c6215 src/audio/sdlgenaudiocvt.pl
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/audio/sdlgenaudiocvt.pl	Thu Aug 24 12:10:46 2006 +0000
@@ -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 -r 3f21778e7433 -r 3b4ce57c6215 src/audio/sun/SDL_sunaudio.h
--- a/src/audio/sun/SDL_sunaudio.h	Thu Aug 10 15:15:06 2006 +0000
+++ b/src/audio/sun/SDL_sunaudio.h	Thu Aug 24 12:10:46 2006 +0000
@@ -34,7 +34,7 @@
     /* 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 -r 3f21778e7433 -r 3b4ce57c6215 src/audio/ums/SDL_umsaudio.c
--- a/src/audio/ums/SDL_umsaudio.c	Thu Aug 10 15:15:06 2006 +0000
+++ b/src/audio/ums/SDL_umsaudio.c	Thu Aug 24 12:10:46 2006 +0000
@@ -250,7 +250,7 @@
     long bitsPerSample;
     long samplesPerSec;
     long success;
-    Uint16 test_format;
+    SDL_AudioFormat test_format;
     int frag_spec;
     UMSAudioDevice_ReturnCode rc;