-Reverted some changes to make the code build again on Tiger.

-Removed x86_64 from Deployment configuration.
-macosx: Use SDL for sound plugin, removed Carbon backend.
-(MaddTheSane)Fixed memory leaks (Patch #8427).

git-svn-id: https://pcsxr.svn.codeplex.com/svn/pcsxr@63548 e17a0e51-4ae3-4d35-97c3-1a29b211df97

50 files changed, 30876 insertions, 0 deletions

diff --git a/macosx/plugins/Common/SDL/include/SDL.h b/macosx/plugins/Common/SDL/include/SDL.h
new file mode 100644
index 00000000..e5689323
--- /dev/null
+++ b/macosx/plugins/Common/SDL/include/SDL.h
@@ -0,0 +1,158 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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
+*/
+// 7/31/2010 Wei Mingzhi
+// Removed everything unrated to Mac OS X Joystick support
+
+/**
+ *  \file SDL.h
+ *  
+ *  Main include header for the SDL library
+ */
+
+/**
+ *  \mainpage Simple DirectMedia Layer (SDL)
+ *  
+ *  http://www.libsdl.org/
+ *  
+ *  \section intro_sec Introduction
+ *  
+ *  This is the Simple DirectMedia Layer, a general API that provides low
+ *  level access to audio, keyboard, mouse, joystick, 3D hardware via OpenGL,
+ *  and 2D framebuffer across multiple platforms.
+ *  
+ *  The current version supports Windows, Windows CE, Mac OS X, Linux,
+ *  FreeBSD, NetBSD, OpenBSD, BSD/OS, Solaris, and QNX. The code contains
+ *  support for other operating systems but those are not officially supported. 
+ *  
+ *  SDL is written in C, but works with C++ natively, and has bindings to
+ *  several other languages, including Ada, C#, Eiffel, Erlang, Euphoria,
+ *  Guile, Haskell, Java, Lisp, Lua, ML, Objective C, Pascal, Perl, PHP,
+ *  Pike, Pliant, Python, Ruby, and Smalltalk.
+ *  
+ *  This library is distributed under GNU LGPL version 2, which can be
+ *  found in the file  "COPYING".  This license allows you to use SDL
+ *  freely in commercial programs as long as you link with the dynamic
+ *  library.
+ *  
+ *  The best way to learn how to use SDL is to check out the header files in
+ *  the "include" subdirectory and the programs in the "test" subdirectory.
+ *  The header files and test programs are well commented and always up to date.
+ *  More documentation is available in HTML format in "docs/index.html", and
+ *  a documentation wiki is available online at:
+ *  	http://www.libsdl.org/cgi/docwiki.cgi
+ *  
+ *  The test programs in the "test" subdirectory are in the public domain.
+ *  
+ *  Frequently asked questions are answered online:
+ *  	http://www.libsdl.org/faq.php
+ *  
+ *  If you need help with the library, or just want to discuss SDL related
+ *  issues, you can join the developers mailing list:
+ *  	http://www.libsdl.org/mailing-list.php
+ *  
+ *  Enjoy!
+ *  	Sam Lantinga				(slouken@libsdl.org)
+ */
+
+#ifndef _SDL_H
+#define _SDL_H
+
+#include "SDL_main.h"
+#include "SDL_stdinc.h"
+#include "SDL_endian.h"
+#include "SDL_error.h"
+#include "SDL_audio.h"
+#include "SDL_mutex.h"
+#include "SDL_rwops.h"
+#include "SDL_thread.h"
+
+#ifndef SDL_IGNORE
+#define SDL_IGNORE 0
+#endif
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+extern "C" {
+/* *INDENT-ON* */
+#endif
+
+/* As of version 0.5, SDL is loaded dynamically into the application */
+
+/**
+ *  \name SDL_INIT_*
+ *  
+ *  These are the flags which may be passed to SDL_Init().  You should
+ *  specify the subsystems which you will be using in your application.
+ */
+/*@{*/
+#define SDL_INIT_AUDIO          0x00000010
+#define SDL_INIT_JOYSTICK       0x00000200
+#define SDL_INIT_HAPTIC         0x00001000
+#define SDL_INIT_NOPARACHUTE    0x00100000      /**< Don't catch fatal signals */
+#define SDL_INIT_EVERYTHING     0x0000FFFF
+/*@}*/
+
+/**
+ *  This function loads the SDL dynamically linked library and initializes 
+ *  the subsystems specified by \c flags (and those satisfying dependencies).
+ *  Unless the ::SDL_INIT_NOPARACHUTE flag is set, it will install cleanup
+ *  signal handlers for some commonly ignored fatal signals (like SIGSEGV).
+ */
+extern DECLSPEC int SDLCALL SDL_Init(Uint32 flags);
+
+/**
+ *  This function initializes specific SDL subsystems
+ */
+extern DECLSPEC int SDLCALL SDL_InitSubSystem(Uint32 flags);
+
+/**
+ *  This function cleans up specific SDL subsystems
+ */
+extern DECLSPEC void SDLCALL SDL_QuitSubSystem(Uint32 flags);
+
+/**
+ *  This function returns mask of the specified subsystems which have
+ *  been initialized.
+ *  
+ *  If \c flags is 0, it returns a mask of all initialized subsystems.
+ */
+extern DECLSPEC Uint32 SDLCALL SDL_WasInit(Uint32 flags);
+
+/**
+ *  This function cleans up all initialized subsystems and unloads the
+ *  dynamically linked library.  You should call it upon all exit conditions.
+ */
+extern DECLSPEC void SDLCALL SDL_Quit(void);
+
+void SDL_Delay(Uint32 ms);
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+}
+/* *INDENT-ON* */
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_H */
diff --git a/macosx/plugins/Common/SDL/include/SDL_audio.h b/macosx/plugins/Common/SDL/include/SDL_audio.h
new file mode 100644
index 00000000..fc55c521
--- /dev/null
+++ b/macosx/plugins/Common/SDL/include/SDL_audio.h
@@ -0,0 +1,510 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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
+*/
+
+/**
+ *  \file SDL_audio.h
+ *  
+ *  Access to the raw audio mixing buffer for the SDL library.
+ */
+
+#ifndef _SDL_audio_h
+#define _SDL_audio_h
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+#include "SDL_endian.h"
+#include "SDL_mutex.h"
+#include "SDL_thread.h"
+#include "SDL_rwops.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+extern "C" {
+/* *INDENT-ON* */
+#endif
+
+/**
+ *  \brief Audio format flags.
+ *  
+ *  These are what the 16 bits in SDL_AudioFormat currently mean...
+ *  (Unspecified bits are always zero).
+ *  
+ *  \verbatim
+    ++-----------------------sample is signed if set
+    ||
+    ||       ++-----------sample is bigendian if set
+    ||       ||
+    ||       ||          ++---sample is float if set
+    ||       ||          ||
+    ||       ||          || +---sample bit size---+
+    ||       ||          || |                     |
+    15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00
+    \endverbatim
+ *  
+ *  There are macros in SDL 1.3 and later to query these bits.
+ */
+typedef Uint16 SDL_AudioFormat;
+
+/**
+ *  \name Audio flags
+ */
+/*@{*/
+
+#define SDL_AUDIO_MASK_BITSIZE       (0xFF)
+#define SDL_AUDIO_MASK_DATATYPE      (1<<8)
+#define SDL_AUDIO_MASK_ENDIAN        (1<<12)
+#define SDL_AUDIO_MASK_SIGNED        (1<<15)
+#define SDL_AUDIO_BITSIZE(x)         (x & SDL_AUDIO_MASK_BITSIZE)
+#define SDL_AUDIO_ISFLOAT(x)         (x & SDL_AUDIO_MASK_DATATYPE)
+#define SDL_AUDIO_ISBIGENDIAN(x)     (x & SDL_AUDIO_MASK_ENDIAN)
+#define SDL_AUDIO_ISSIGNED(x)        (x & SDL_AUDIO_MASK_SIGNED)
+#define SDL_AUDIO_ISINT(x)           (!SDL_AUDIO_ISFLOAT(x))
+#define SDL_AUDIO_ISLITTLEENDIAN(x)  (!SDL_AUDIO_ISBIGENDIAN(x))
+#define SDL_AUDIO_ISUNSIGNED(x)      (!SDL_AUDIO_ISSIGNED(x))
+
+/** 
+ *  \name Audio format flags
+ *
+ *  Defaults to LSB byte order.
+ */
+/*@{*/
+#define AUDIO_U8	0x0008  /**< Unsigned 8-bit samples */
+#define AUDIO_S8	0x8008  /**< Signed 8-bit samples */
+#define AUDIO_U16LSB	0x0010  /**< Unsigned 16-bit samples */
+#define AUDIO_S16LSB	0x8010  /**< Signed 16-bit samples */
+#define AUDIO_U16MSB	0x1010  /**< As above, but big-endian byte order */
+#define AUDIO_S16MSB	0x9010  /**< As above, but big-endian byte order */
+#define AUDIO_U16	AUDIO_U16LSB
+#define AUDIO_S16	AUDIO_S16LSB
+/*@}*/
+
+/**
+ *  \name int32 support
+ *  
+ *  New to SDL 1.3.
+ */
+/*@{*/
+#define AUDIO_S32LSB	0x8020  /**< 32-bit integer samples */
+#define AUDIO_S32MSB	0x9020  /**< As above, but big-endian byte order */
+#define AUDIO_S32	AUDIO_S32LSB
+/*@}*/
+
+/**
+ *  \name float32 support
+ *  
+ *  New to SDL 1.3.
+ */
+/*@{*/
+#define AUDIO_F32LSB	0x8120  /**< 32-bit floating point samples */
+#define AUDIO_F32MSB	0x9120  /**< As above, but big-endian byte order */
+#define AUDIO_F32	AUDIO_F32LSB
+/*@}*/
+
+/**
+ *  \name Native audio byte ordering
+ */
+/*@{*/
+#if SDL_BYTEORDER == SDL_LIL_ENDIAN
+#define AUDIO_U16SYS	AUDIO_U16LSB
+#define AUDIO_S16SYS	AUDIO_S16LSB
+#define AUDIO_S32SYS	AUDIO_S32LSB
+#define AUDIO_F32SYS	AUDIO_F32LSB
+#else
+#define AUDIO_U16SYS	AUDIO_U16MSB
+#define AUDIO_S16SYS	AUDIO_S16MSB
+#define AUDIO_S32SYS	AUDIO_S32MSB
+#define AUDIO_F32SYS	AUDIO_F32MSB
+#endif
+/*@}*/
+
+/** 
+ *  \name Allow change flags
+ *  
+ *  Which audio format changes are allowed when opening a device.
+ */
+/*@{*/
+#define SDL_AUDIO_ALLOW_FREQUENCY_CHANGE    0x00000001
+#define SDL_AUDIO_ALLOW_FORMAT_CHANGE       0x00000002
+#define SDL_AUDIO_ALLOW_CHANNELS_CHANGE     0x00000004
+#define SDL_AUDIO_ALLOW_ANY_CHANGE          (SDL_AUDIO_ALLOW_FREQUENCY_CHANGE|SDL_AUDIO_ALLOW_FORMAT_CHANGE|SDL_AUDIO_ALLOW_CHANNELS_CHANGE)
+/*@}*/
+
+/*@}*//*Audio flags*/
+
+/**
+ *  This function is called when the audio device needs more data.
+ *
+ *  \param userdata An application-specific parameter saved in
+ *                  the SDL_AudioSpec structure
+ *  \param stream A pointer to the audio data buffer.
+ *  \param len    The length of that buffer in bytes.
+ *
+ *  Once the callback returns, the buffer will no longer be valid.
+ *  Stereo samples are stored in a LRLRLR ordering.
+ */
+typedef void (SDLCALL * SDL_AudioCallback) (void *userdata, Uint8 * stream,
+                                            int len);
+
+/**
+ *  The calculated values in this structure are calculated by SDL_OpenAudio().
+ */
+typedef struct SDL_AudioSpec
+{
+    int freq;                   /**< DSP frequency -- samples per second */
+    SDL_AudioFormat format;     /**< Audio data format */
+    Uint8 channels;             /**< Number of channels: 1 mono, 2 stereo */
+    Uint8 silence;              /**< Audio buffer silence value (calculated) */
+    Uint16 samples;             /**< Audio buffer size in samples (power of 2) */
+    Uint16 padding;             /**< Necessary for some compile environments */
+    Uint32 size;                /**< Audio buffer size in bytes (calculated) */
+    SDL_AudioCallback callback;
+    void *userdata;
+} SDL_AudioSpec;
+
+
+struct SDL_AudioCVT;
+typedef void (SDLCALL * SDL_AudioFilter) (struct SDL_AudioCVT * cvt,
+                                          SDL_AudioFormat format);
+
+/**
+ *  A structure to hold a set of audio conversion filters and buffers.
+ */
+typedef struct SDL_AudioCVT
+{
+    int needed;                 /**< Set to 1 if conversion possible */
+    SDL_AudioFormat src_format; /**< Source audio format */
+    SDL_AudioFormat dst_format; /**< Target audio format */
+    double rate_incr;           /**< Rate conversion increment */
+    Uint8 *buf;                 /**< Buffer to hold entire audio data */
+    int len;                    /**< Length of original audio buffer */
+    int len_cvt;                /**< Length of converted audio buffer */
+    int len_mult;               /**< buffer must be len*len_mult big */
+    double len_ratio;           /**< Given len, final size is len*len_ratio */
+    SDL_AudioFilter filters[10];        /**< Filter list */
+    int filter_index;           /**< Current audio conversion function */
+} SDL_AudioCVT;
+
+
+/* Function prototypes */
+
+/**
+ *  \name Driver discovery functions
+ *  
+ *  These functions return the list of built in audio drivers, in the
+ *  order that they are normally initialized by default.
+ */
+/*@{*/
+extern DECLSPEC int SDLCALL SDL_GetNumAudioDrivers(void);
+extern DECLSPEC const char *SDLCALL SDL_GetAudioDriver(int index);
+/*@}*/
+
+/**
+ *  \name Initialization and cleanup
+ *  
+ *  \internal These functions are used internally, and should not be used unless
+ *            you have a specific need to specify the audio driver you want to 
+ *            use.  You should normally use SDL_Init() or SDL_InitSubSystem().
+ */
+/*@{*/
+extern DECLSPEC int SDLCALL SDL_AudioInit(const char *driver_name);
+extern DECLSPEC void SDLCALL SDL_AudioQuit(void);
+/*@}*/
+
+/**
+ *  This function returns the name of the current audio driver, or NULL
+ *  if no driver has been initialized.
+ */
+extern DECLSPEC const char *SDLCALL SDL_GetCurrentAudioDriver(void);
+
+/**
+ *  This function opens the audio device with the desired parameters, and
+ *  returns 0 if successful, placing the actual hardware parameters in the
+ *  structure pointed to by \c obtained.  If \c obtained is NULL, the audio
+ *  data passed to the callback function will be guaranteed to be in the
+ *  requested format, and will be automatically converted to the hardware
+ *  audio format if necessary.  This function returns -1 if it failed 
+ *  to open the audio device, or couldn't set up the audio thread.
+ *  
+ *  When filling in the desired audio spec structure,
+ *    - \c desired->freq should be the desired audio frequency in samples-per-
+ *      second.
+ *    - \c desired->format should be the desired audio format.
+ *    - \c desired->samples is the desired size of the audio buffer, in 
+ *      samples.  This number should be a power of two, and may be adjusted by 
+ *      the audio driver to a value more suitable for the hardware.  Good values
+ *      seem to range between 512 and 8096 inclusive, depending on the 
+ *      application and CPU speed.  Smaller values yield faster response time, 
+ *      but can lead to underflow if the application is doing heavy processing 
+ *      and cannot fill the audio buffer in time.  A stereo sample consists of 
+ *      both right and left channels in LR ordering.
+ *      Note that the number of samples is directly related to time by the
+ *      following formula:  \code ms = (samples*1000)/freq \endcode
+ *    - \c desired->size is the size in bytes of the audio buffer, and is
+ *      calculated by SDL_OpenAudio().
+ *    - \c desired->silence is the value used to set the buffer to silence,
+ *      and is calculated by SDL_OpenAudio().
+ *    - \c desired->callback should be set to a function that will be called
+ *      when the audio device is ready for more data.  It is passed a pointer
+ *      to the audio buffer, and the length in bytes of the audio buffer.
+ *      This function usually runs in a separate thread, and so you should
+ *      protect data structures that it accesses by calling SDL_LockAudio()
+ *      and SDL_UnlockAudio() in your code.
+ *    - \c desired->userdata is passed as the first parameter to your callback
+ *      function.
+ *  
+ *  The audio device starts out playing silence when it's opened, and should
+ *  be enabled for playing by calling \c SDL_PauseAudio(0) when you are ready
+ *  for your audio callback function to be called.  Since the audio driver
+ *  may modify the requested size of the audio buffer, you should allocate
+ *  any local mixing buffers after you open the audio device.
+ */
+extern DECLSPEC int SDLCALL SDL_OpenAudio(SDL_AudioSpec * desired,
+                                          SDL_AudioSpec * obtained);
+
+/**
+ *  SDL Audio Device IDs.
+ *  
+ *  A successful call to SDL_OpenAudio() is always device id 1, and legacy
+ *  SDL audio APIs assume you want this device ID. SDL_OpenAudioDevice() calls
+ *  always returns devices >= 2 on success. The legacy calls are good both
+ *  for backwards compatibility and when you don't care about multiple,
+ *  specific, or capture devices.
+ */
+typedef Uint32 SDL_AudioDeviceID;
+
+/**
+ *  Get the number of available devices exposed by the current driver.
+ *  Only valid after a successfully initializing the audio subsystem.
+ *  Returns -1 if an explicit list of devices can't be determined; this is
+ *  not an error. For example, if SDL is set up to talk to a remote audio
+ *  server, it can't list every one available on the Internet, but it will
+ *  still allow a specific host to be specified to SDL_OpenAudioDevice().
+ *  
+ *  In many common cases, when this function returns a value <= 0, it can still
+ *  successfully open the default device (NULL for first argument of
+ *  SDL_OpenAudioDevice()).
+ */
+extern DECLSPEC int SDLCALL SDL_GetNumAudioDevices(int iscapture);
+
+/**
+ *  Get the human-readable name of a specific audio device.
+ *  Must be a value between 0 and (number of audio devices-1).
+ *  Only valid after a successfully initializing the audio subsystem.
+ *  The values returned by this function reflect the latest call to
+ *  SDL_GetNumAudioDevices(); recall that function to redetect available
+ *  hardware.
+ *  
+ *  The string returned by this function is UTF-8 encoded, read-only, and
+ *  managed internally. You are not to free it. If you need to keep the
+ *  string for any length of time, you should make your own copy of it, as it
+ *  will be invalid next time any of several other SDL functions is called.
+ */
+extern DECLSPEC const char *SDLCALL SDL_GetAudioDeviceName(int index,
+                                                           int iscapture);
+
+
+/**
+ *  Open a specific audio device. Passing in a device name of NULL requests
+ *  the most reasonable default (and is equivalent to calling SDL_OpenAudio()).
+ *  
+ *  The device name is a UTF-8 string reported by SDL_GetAudioDeviceName(), but
+ *  some drivers allow arbitrary and driver-specific strings, such as a
+ *  hostname/IP address for a remote audio server, or a filename in the
+ *  diskaudio driver.
+ *  
+ *  \return 0 on error, a valid device ID that is >= 2 on success.
+ *  
+ *  SDL_OpenAudio(), unlike this function, always acts on device ID 1.
+ */
+extern DECLSPEC SDL_AudioDeviceID SDLCALL SDL_OpenAudioDevice(const char
+                                                              *device,
+                                                              int iscapture,
+                                                              const
+                                                              SDL_AudioSpec *
+                                                              desired,
+                                                              SDL_AudioSpec *
+                                                              obtained,
+                                                              int
+                                                              allowed_changes);
+
+
+
+/**
+ *  \name Audio state
+ *  
+ *  Get the current audio state.
+ */
+/*@{*/
+typedef enum
+{
+    SDL_AUDIO_STOPPED = 0,
+    SDL_AUDIO_PLAYING,
+    SDL_AUDIO_PAUSED
+} SDL_AudioStatus;
+extern DECLSPEC SDL_AudioStatus SDLCALL SDL_GetAudioStatus(void);
+
+extern DECLSPEC SDL_AudioStatus SDLCALL
+SDL_GetAudioDeviceStatus(SDL_AudioDeviceID dev);
+/*@}*//*Audio State*/
+
+/**
+ *  \name Pause audio functions
+ *  
+ *  These functions pause and unpause the audio callback processing.
+ *  They should be called with a parameter of 0 after opening the audio
+ *  device to start playing sound.  This is so you can safely initialize
+ *  data for your callback function after opening the audio device.
+ *  Silence will be written to the audio device during the pause.
+ */
+/*@{*/
+extern DECLSPEC void SDLCALL SDL_PauseAudio(int pause_on);
+extern DECLSPEC void SDLCALL SDL_PauseAudioDevice(SDL_AudioDeviceID dev,
+                                                  int pause_on);
+/*@}*//*Pause audio functions*/
+
+/**
+ *  This function loads a WAVE from the data source, automatically freeing
+ *  that source if \c freesrc is non-zero.  For example, to load a WAVE file,
+ *  you could do:
+ *  \code
+ *  	SDL_LoadWAV_RW(SDL_RWFromFile("sample.wav", "rb"), 1, ...);
+ *  \endcode
+ *
+ *  If this function succeeds, it returns the given SDL_AudioSpec,
+ *  filled with the audio data format of the wave data, and sets
+ *  \c *audio_buf to a malloc()'d buffer containing the audio data,
+ *  and sets \c *audio_len to the length of that audio buffer, in bytes.
+ *  You need to free the audio buffer with SDL_FreeWAV() when you are 
+ *  done with it.
+ *
+ *  This function returns NULL and sets the SDL error message if the 
+ *  wave file cannot be opened, uses an unknown data format, or is 
+ *  corrupt.  Currently raw and MS-ADPCM WAVE files are supported.
+ */
+extern DECLSPEC SDL_AudioSpec *SDLCALL SDL_LoadWAV_RW(SDL_RWops * src,
+                                                      int freesrc,
+                                                      SDL_AudioSpec * spec,
+                                                      Uint8 ** audio_buf,
+                                                      Uint32 * audio_len);
+
+/** 
+ *  Loads a WAV from a file.
+ *  Compatibility convenience function.
+ */
+#define SDL_LoadWAV(file, spec, audio_buf, audio_len) \
+	SDL_LoadWAV_RW(SDL_RWFromFile(file, "rb"),1, spec,audio_buf,audio_len)
+
+/**
+ *  This function frees data previously allocated with SDL_LoadWAV_RW()
+ */
+extern DECLSPEC void SDLCALL SDL_FreeWAV(Uint8 * audio_buf);
+
+/**
+ *  This function takes a source format and rate and a destination format
+ *  and rate, and initializes the \c cvt structure with information needed
+ *  by SDL_ConvertAudio() to convert a buffer of audio data from one format
+ *  to the other.
+ *  
+ *  \return -1 if the format conversion is not supported, 0 if there's
+ *  no conversion needed, or 1 if the audio filter is set up.
+ */
+extern DECLSPEC int SDLCALL SDL_BuildAudioCVT(SDL_AudioCVT * cvt,
+                                              SDL_AudioFormat src_format,
+                                              Uint8 src_channels,
+                                              int src_rate,
+                                              SDL_AudioFormat dst_format,
+                                              Uint8 dst_channels,
+                                              int dst_rate);
+
+/**
+ *  Once you have initialized the \c cvt structure using SDL_BuildAudioCVT(),
+ *  created an audio buffer \c cvt->buf, and filled it with \c cvt->len bytes of
+ *  audio data in the source format, this function will convert it in-place
+ *  to the desired format.
+ *  
+ *  The data conversion may expand the size of the audio data, so the buffer
+ *  \c cvt->buf should be allocated after the \c cvt structure is initialized by
+ *  SDL_BuildAudioCVT(), and should be \c cvt->len*cvt->len_mult bytes long.
+ */
+extern DECLSPEC int SDLCALL SDL_ConvertAudio(SDL_AudioCVT * cvt);
+
+#define SDL_MIX_MAXVOLUME 128
+/**
+ *  This takes two audio buffers of the playing audio format and mixes
+ *  them, performing addition, volume adjustment, and overflow clipping.
+ *  The volume ranges from 0 - 128, and should be set to ::SDL_MIX_MAXVOLUME
+ *  for full audio volume.  Note this does not change hardware volume.
+ *  This is provided for convenience -- you can mix your own audio data.
+ */
+extern DECLSPEC void SDLCALL SDL_MixAudio(Uint8 * dst, const Uint8 * src,
+                                          Uint32 len, int volume);
+
+/**
+ *  This works like SDL_MixAudio(), but you specify the audio format instead of
+ *  using the format of audio device 1. Thus it can be used when no audio
+ *  device is open at all.
+ */
+extern DECLSPEC void SDLCALL SDL_MixAudioFormat(Uint8 * dst,
+                                                const Uint8 * src,
+                                                SDL_AudioFormat format,
+                                                Uint32 len, int volume);
+
+/**
+ *  \name Audio lock functions
+ *  
+ *  The lock manipulated by these functions protects the callback function.
+ *  During a SDL_LockAudio()/SDL_UnlockAudio() pair, you can be guaranteed that 
+ *  the callback function is not running.  Do not call these from the callback
+ *  function or you will cause deadlock.
+ */
+/*@{*/
+extern DECLSPEC void SDLCALL SDL_LockAudio(void);
+extern DECLSPEC void SDLCALL SDL_LockAudioDevice(SDL_AudioDeviceID dev);
+extern DECLSPEC void SDLCALL SDL_UnlockAudio(void);
+extern DECLSPEC void SDLCALL SDL_UnlockAudioDevice(SDL_AudioDeviceID dev);
+/*@}*//*Audio lock functions*/
+
+/**
+ *  This function shuts down audio processing and closes the audio device.
+ */
+extern DECLSPEC void SDLCALL SDL_CloseAudio(void);
+extern DECLSPEC void SDLCALL SDL_CloseAudioDevice(SDL_AudioDeviceID dev);
+
+/**
+ * \return 1 if audio device is still functioning, zero if not, -1 on error.
+ */
+extern DECLSPEC int SDLCALL SDL_AudioDeviceConnected(SDL_AudioDeviceID dev);
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+}
+/* *INDENT-ON* */
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_audio_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/include/SDL_config.h b/macosx/plugins/Common/SDL/include/SDL_config.h
new file mode 100644
index 00000000..990166c2
--- /dev/null
+++ b/macosx/plugins/Common/SDL/include/SDL_config.h
@@ -0,0 +1,313 @@
+/* include/SDL_config.h.  Generated from SDL_config.h.in by configure.  */
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2009 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
+*/
+
+#ifndef _SDL_config_h
+#define _SDL_config_h
+
+/**
+ *  \file SDL_config.h.in
+ *
+ *  This is a set of defines to configure the SDL features
+ */
+
+/* General platform specific identifiers */
+#include "SDL_platform.h"
+
+/* Make sure that this isn't included by Visual C++ */
+#ifdef _MSC_VER
+#error You should copy include/SDL_config.h.default to include/SDL_config.h
+#endif
+
+/* C language features */
+/* #undef const */
+/* #undef inline */
+/* #undef volatile */
+
+/* C datatypes */
+#if !defined(_STDINT_H_) && (!defined(HAVE_STDINT_H) || !_HAVE_STDINT_H)
+/* #undef size_t */
+/* #undef int8_t */
+/* #undef uint8_t */
+/* #undef int16_t */
+/* #undef uint16_t */
+/* #undef int32_t */
+/* #undef uint32_t */
+/* #undef int64_t */
+/* #undef uint64_t */
+/* #undef uintptr_t */
+#endif /* !_STDINT_H_ && !HAVE_STDINT_H */
+
+#define SIZEOF_VOIDP 4
+#define SDL_HAS_64BIT_TYPE 1
+
+/* Comment this if you want to build without any C library requirements */
+#define HAVE_LIBC 1
+#if HAVE_LIBC
+
+/* Useful headers */
+#define HAVE_ALLOCA_H 1
+#define HAVE_SYS_TYPES_H 1
+#define HAVE_STDIO_H 1
+#define STDC_HEADERS 1
+#define HAVE_STDLIB_H 1
+#define HAVE_STDARG_H 1
+/* #undef HAVE_MALLOC_H */
+#define HAVE_MEMORY_H 1
+#define HAVE_STRING_H 1
+#define HAVE_STRINGS_H 1
+#define HAVE_INTTYPES_H 1
+#define HAVE_STDINT_H 1
+#define HAVE_CTYPE_H 1
+#define HAVE_MATH_H 1
+#define HAVE_ICONV_H 1
+#define HAVE_SIGNAL_H 1
+/* #undef HAVE_ALTIVEC_H */
+
+/* C library functions */
+#define HAVE_MALLOC 1
+#define HAVE_CALLOC 1
+#define HAVE_REALLOC 1
+#define HAVE_FREE 1
+#define HAVE_ALLOCA 1
+#ifndef _WIN32 /* Don't use C runtime versions of these on Windows */
+#define HAVE_GETENV 1
+#define HAVE_SETENV 1
+#define HAVE_PUTENV 1
+#define HAVE_UNSETENV 1
+#endif
+#define HAVE_QSORT 1
+#define HAVE_ABS 1
+#define HAVE_BCOPY 1
+#define HAVE_MEMSET 1
+#define HAVE_MEMCPY 1
+#define HAVE_MEMMOVE 1
+#define HAVE_MEMCMP 1
+#define HAVE_STRLEN 1
+#define HAVE_STRLCPY 1
+#define HAVE_STRLCAT 1
+#define HAVE_STRDUP 1
+/* #undef HAVE__STRREV */
+/* #undef HAVE__STRUPR */
+/* #undef HAVE__STRLWR */
+/* #undef HAVE_INDEX */
+/* #undef HAVE_RINDEX */
+#define HAVE_STRCHR 1
+#define HAVE_STRRCHR 1
+#define HAVE_STRSTR 1
+/* #undef HAVE_ITOA */
+/* #undef HAVE__LTOA */
+/* #undef HAVE__UITOA */
+/* #undef HAVE__ULTOA */
+#define HAVE_STRTOL 1
+#define HAVE_STRTOUL 1
+/* #undef HAVE__I64TOA */
+/* #undef HAVE__UI64TOA */
+#define HAVE_STRTOLL 1
+#define HAVE_STRTOULL 1
+#define HAVE_STRTOD 1
+#define HAVE_ATOI 1
+#define HAVE_ATOF 1
+#define HAVE_STRCMP 1
+#define HAVE_STRNCMP 1
+/* #undef HAVE__STRICMP */
+#define HAVE_STRCASECMP 1
+/* #undef HAVE__STRNICMP */
+#define HAVE_STRNCASECMP 1
+#define HAVE_SSCANF 1
+#define HAVE_SNPRINTF 1
+#define HAVE_VSNPRINTF 1
+#define HAVE_M_PI 
+#define HAVE_CEIL 1
+#define HAVE_COPYSIGN 1
+#define HAVE_COS 1
+#define HAVE_COSF 1
+#define HAVE_FABS 1
+#define HAVE_FLOOR 1
+#define HAVE_LOG 1
+#define HAVE_POW 1
+#define HAVE_SCALBN 1
+#define HAVE_SIN 1
+#define HAVE_SINF 1
+#define HAVE_SQRT 1
+#define HAVE_SIGACTION 1
+#define HAVE_SETJMP 1
+#define HAVE_NANOSLEEP 1
+#define HAVE_SYSCONF 1
+#define HAVE_SYSCTLBYNAME 1
+/* #undef HAVE_CLOCK_GETTIME */
+/* #undef HAVE_GETPAGESIZE */
+#define HAVE_MPROTECT 1
+
+#else
+/* We may need some replacement for stdarg.h here */
+#include <stdarg.h>
+#endif /* HAVE_LIBC */
+
+/* SDL internal assertion support */
+/* #undef SDL_DEFAULT_ASSERT_LEVEL */
+
+/* Allow disabling of core subsystems */
+/* #undef SDL_AUDIO_DISABLED 1 */
+#define SDL_CPUINFO_DISABLED 1
+#define SDL_EVENTS_DISABLED 1
+/* #undef SDL_FILE_DISABLED 1 */
+/* #undef SDL_JOYSTICK_DISABLED */
+/* #undef SDL_HAPTIC_DISABLED */
+#define SDL_LOADSO_DISABLED 1
+/* #undef SDL_THREADS_DISABLED 1 */
+#define SDL_TIMERS_DISABLED 1
+#define SDL_VIDEO_DISABLED 1
+#define SDL_POWER_DISABLED 1
+
+/* Enable various audio drivers */
+/* #undef SDL_AUDIO_DRIVER_ALSA */
+/* #undef SDL_AUDIO_DRIVER_ALSA_DYNAMIC */
+/* #undef SDL_AUDIO_DRIVER_ARTS */
+/* #undef SDL_AUDIO_DRIVER_ARTS_DYNAMIC */
+/* #undef SDL_AUDIO_DRIVER_PULSEAUDIO */
+/* #undef SDL_AUDIO_DRIVER_PULSEAUDIO_DYNAMIC */
+/* #undef SDL_AUDIO_DRIVER_BEOSAUDIO */
+/* #undef SDL_AUDIO_DRIVER_BSD */
+/* #undef SDL_AUDIO_DRIVER_COREAUDIO */
+/* #undef SDL_AUDIO_DRIVER_DISK */
+/* #undef SDL_AUDIO_DRIVER_DUMMY */
+/* #undef SDL_AUDIO_DRIVER_DMEDIA */
+/* #undef SDL_AUDIO_DRIVER_DSOUND */
+/* #undef SDL_AUDIO_DRIVER_ESD */
+/* #undef SDL_AUDIO_DRIVER_ESD_DYNAMIC */
+/* #undef SDL_AUDIO_DRIVER_MMEAUDIO */
+/* #undef SDL_AUDIO_DRIVER_NAS */
+/* #undef SDL_AUDIO_DRIVER_NAS_DYNAMIC */
+/* #undef SDL_AUDIO_DRIVER_NDS */
+/* #undef SDL_AUDIO_DRIVER_OSS */
+/* #undef SDL_AUDIO_DRIVER_OSS_SOUNDCARD_H */
+/* #undef SDL_AUDIO_DRIVER_PAUDIO */
+/* #undef SDL_AUDIO_DRIVER_QSA */
+/* #undef SDL_AUDIO_DRIVER_SUNAUDIO */
+/* #undef SDL_AUDIO_DRIVER_WINWAVEOUT */
+/* #undef SDL_AUDIO_DRIVER_FUSIONSOUND */
+/* #undef SDL_AUDIO_DRIVER_FUSIONSOUND_DYNAMIC */
+
+/* Enable various input drivers */
+/* #undef SDL_INPUT_LINUXEV */
+/* #undef SDL_INPUT_TSLIB */
+/* #undef SDL_JOYSTICK_BEOS */
+/* #undef SDL_JOYSTICK_DINPUT */
+/* #undef SDL_JOYSTICK_DUMMY */
+#define SDL_JOYSTICK_IOKIT 1
+/* #undef SDL_JOYSTICK_LINUX */
+/* #undef SDL_JOYSTICK_NDS */
+/* #undef SDL_JOYSTICK_RISCOS */
+/* #undef SDL_JOYSTICK_WINMM */
+/* #undef SDL_JOYSTICK_USBHID */
+/* #undef SDL_JOYSTICK_USBHID_MACHINE_JOYSTICK_H */
+/* #undef SDL_HAPTIC_DUMMY */
+/* #undef SDL_HAPTIC_LINUX */
+#define SDL_HAPTIC_IOKIT 1
+/* #undef SDL_HAPTIC_DINPUT */
+
+/* Enable various shared object loading systems */
+/* #undef SDL_LOADSO_BEOS */
+/* #undef SDL_LOADSO_DLCOMPAT */
+/* #undef SDL_LOADSO_DLOPEN */
+/* #undef SDL_LOADSO_DUMMY */
+/* #undef SDL_LOADSO_LDG */
+/* #undef SDL_LOADSO_WIN32 */
+
+/* Enable various threading systems */
+/* #undef SDL_THREAD_BEOS */
+/* #undef SDL_THREAD_NDS */
+/* #undef SDL_THREAD_PTHREAD */
+/* #undef SDL_THREAD_PTHREAD_RECURSIVE_MUTEX */
+/* #undef SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP */
+/* #undef SDL_THREAD_SPROC */
+/* #undef SDL_THREAD_WIN32 */
+
+/* Enable various timer systems */
+/* #undef SDL_TIMER_BEOS */
+/* #undef SDL_TIMER_DUMMY */
+/* #undef SDL_TIMER_NDS */
+/* #undef SDL_TIMER_RISCOS */
+/* #undef SDL_TIMER_UNIX */
+/* #undef SDL_TIMER_WIN32 */
+/* #undef SDL_TIMER_WINCE */
+
+/* Enable various video drivers */
+/* #undef SDL_VIDEO_DRIVER_BWINDOW */
+/* #undef SDL_VIDEO_DRIVER_COCOA */
+/* #undef SDL_VIDEO_DRIVER_DIRECTFB */
+/* #undef SDL_VIDEO_DRIVER_DIRECTFB_DYNAMIC */
+#define SDL_VIDEO_DRIVER_DUMMY 1
+/* #undef SDL_VIDEO_DRIVER_FBCON */
+/* #undef SDL_VIDEO_DRIVER_NDS */
+/* #undef SDL_VIDEO_DRIVER_PHOTON */
+/* #undef SDL_VIDEO_DRIVER_QNXGF */
+/* #undef SDL_VIDEO_DRIVER_PS3 */
+/* #undef SDL_VIDEO_DRIVER_RISCOS */
+/* #undef SDL_VIDEO_DRIVER_SVGALIB */
+/* #undef SDL_VIDEO_DRIVER_WIN32 */
+/* #undef SDL_VIDEO_DRIVER_X11 */
+/* #undef SDL_VIDEO_DRIVER_X11_DYNAMIC */
+/* #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT */
+/* #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR */
+/* #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XRENDER */
+/* #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XINPUT */
+/* #undef SDL_VIDEO_DRIVER_X11_DYNAMIC_XSS */
+/* #undef SDL_VIDEO_DRIVER_X11_VIDMODE */
+/* #undef SDL_VIDEO_DRIVER_X11_XINERAMA */
+/* #undef SDL_VIDEO_DRIVER_X11_XRANDR */
+/* #undef SDL_VIDEO_DRIVER_X11_XINPUT */
+/* #undef SDL_VIDEO_DRIVER_X11_SCRNSAVER */
+/* #undef SDL_VIDEO_DRIVER_X11_XV */
+
+/* #undef SDL_VIDEO_RENDER_D3D */
+/* #undef SDL_VIDEO_RENDER_GDI */
+/* #undef SDL_VIDEO_RENDER_OGL */
+/* #undef SDL_VIDEO_RENDER_OGL_ES */
+/* #undef SDL_VIDEO_RENDER_X11 */
+/* #undef SDL_VIDEO_RENDER_GAPI */
+/* #undef SDL_VIDEO_RENDER_DDRAW */
+
+/* Enable OpenGL support */
+/* #undef SDL_VIDEO_OPENGL */
+/* #undef SDL_VIDEO_OPENGL_ES */
+/* #undef SDL_VIDEO_OPENGL_BGL */
+/* #undef SDL_VIDEO_OPENGL_CGL */
+/* #undef SDL_VIDEO_OPENGL_GLX */
+/* #undef SDL_VIDEO_OPENGL_WGL */
+/* #undef SDL_VIDEO_OPENGL_OSMESA */
+/* #undef SDL_VIDEO_OPENGL_OSMESA_DYNAMIC */
+
+/* Enable system power support */
+/* #undef SDL_POWER_LINUX */
+/* #undef SDL_POWER_WINDOWS */
+/* #undef SDL_POWER_MACOSX */
+/* #undef SDL_POWER_BEOS */
+/* #undef SDL_POWER_NINTENDODS */
+/* #undef SDL_POWER_HARDWIRED */
+
+/* Enable assembly routines */
+/* #undef SDL_ASSEMBLY_ROUTINES */
+/* #undef SDL_ALTIVEC_BLITTERS */
+
+#endif /* _SDL_config_h */
diff --git a/macosx/plugins/Common/SDL/include/SDL_endian.h b/macosx/plugins/Common/SDL/include/SDL_endian.h
new file mode 100644
index 00000000..de69e32d
--- /dev/null
+++ b/macosx/plugins/Common/SDL/include/SDL_endian.h
@@ -0,0 +1,258 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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
+*/
+
+/**
+ *  \file SDL_endian.h
+ *  
+ *  Functions for reading and writing endian-specific values
+ */
+
+#ifndef _SDL_endian_h
+#define _SDL_endian_h
+
+#include "SDL_stdinc.h"
+
+/**
+ *  \name The two types of endianness
+ */
+/*@{*/
+#define SDL_LIL_ENDIAN	1234
+#define SDL_BIG_ENDIAN	4321
+/*@}*/
+
+#ifndef SDL_BYTEORDER           /* Not defined in SDL_config.h? */
+#ifdef __linux__
+#include <endian.h>
+#define SDL_BYTEORDER  __BYTE_ORDER
+#else /* __linux __ */
+#if defined(__hppa__) || \
+    defined(__m68k__) || defined(mc68000) || defined(_M_M68K) || \
+    (defined(__MIPS__) && defined(__MISPEB__)) || \
+    defined(__ppc__) || defined(__POWERPC__) || defined(_M_PPC) || \
+    defined(__sparc__)
+#define SDL_BYTEORDER	SDL_BIG_ENDIAN
+#else
+#define SDL_BYTEORDER	SDL_LIL_ENDIAN
+#endif
+#endif /* __linux __ */
+#endif /* !SDL_BYTEORDER */
+
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+extern "C" {
+/* *INDENT-ON* */
+#endif
+
+/**
+ *  \file SDL_endian.h
+ *  
+ *  Uses inline functions for compilers that support them, and static
+ *  functions for those that do not.  Because these functions become
+ *  static for compilers that do not support inline functions, this
+ *  header should only be included in files that actually use them.
+ */
+#if defined(__GNUC__) && defined(__i386__) && \
+   !(__GNUC__ == 2 && __GNUC_MINOR__ == 95 /* broken gcc version */)
+static __inline__ Uint16
+SDL_Swap16(Uint16 x)
+{
+  __asm__("xchgb %b0,%h0": "=q"(x):"0"(x));
+    return x;
+}
+#elif defined(__GNUC__) && defined(__x86_64__)
+static __inline__ Uint16
+SDL_Swap16(Uint16 x)
+{
+  __asm__("xchgb %b0,%h0": "=Q"(x):"0"(x));
+    return x;
+}
+#elif defined(__GNUC__) && (defined(__powerpc__) || defined(__ppc__))
+static __inline__ Uint16
+SDL_Swap16(Uint16 x)
+{
+    Uint16 result;
+
+  __asm__("rlwimi %0,%2,8,16,23": "=&r"(result):"0"(x >> 8), "r"(x));
+    return result;
+}
+#elif defined(__GNUC__) && (defined(__M68000__) || defined(__M68020__)) && !defined(__mcoldfire__)
+static __inline__ Uint16
+SDL_Swap16(Uint16 x)
+{
+  __asm__("rorw #8,%0": "=d"(x): "0"(x):"cc");
+    return x;
+}
+#else
+static __inline__ Uint16
+SDL_Swap16(Uint16 x)
+{
+    return SDL_static_cast(Uint16, ((x << 8) | (x >> 8)));
+}
+#endif
+
+#if defined(__GNUC__) && defined(__i386__)
+static __inline__ Uint32
+SDL_Swap32(Uint32 x)
+{
+  __asm__("bswap %0": "=r"(x):"0"(x));
+    return x;
+}
+#elif defined(__GNUC__) && defined(__x86_64__)
+static __inline__ Uint32
+SDL_Swap32(Uint32 x)
+{
+  __asm__("bswapl %0": "=r"(x):"0"(x));
+    return x;
+}
+#elif defined(__GNUC__) && (defined(__powerpc__) || defined(__ppc__))
+static __inline__ Uint32
+SDL_Swap32(Uint32 x)
+{
+    Uint32 result;
+
+  __asm__("rlwimi %0,%2,24,16,23": "=&r"(result):"0"(x >> 24), "r"(x));
+  __asm__("rlwimi %0,%2,8,8,15": "=&r"(result):"0"(result), "r"(x));
+  __asm__("rlwimi %0,%2,24,0,7": "=&r"(result):"0"(result), "r"(x));
+    return result;
+}
+#elif defined(__GNUC__) && (defined(__M68000__) || defined(__M68020__)) && !defined(__mcoldfire__)
+static __inline__ Uint32
+SDL_Swap32(Uint32 x)
+{
+  __asm__("rorw #8,%0\n\tswap %0\n\trorw #8,%0": "=d"(x): "0"(x):"cc");
+    return x;
+}
+#else
+static __inline__ Uint32
+SDL_Swap32(Uint32 x)
+{
+    return SDL_static_cast(Uint32, ((x << 24) | ((x << 8) & 0x00FF0000) |
+                                    ((x >> 8) & 0x0000FF00) | (x >> 24)));
+}
+#endif
+
+#ifdef SDL_HAS_64BIT_TYPE
+#if defined(__GNUC__) && defined(__i386__)
+static __inline__ Uint64
+SDL_Swap64(Uint64 x)
+{
+    union
+    {
+        struct
+        {
+            Uint32 a, b;
+        } s;
+        Uint64 u;
+    } v;
+    v.u = x;
+  __asm__("bswapl %0 ; bswapl %1 ; xchgl %0,%1": "=r"(v.s.a), "=r"(v.s.b):"0"(v.s.a),
+            "1"(v.s.
+                b));
+    return v.u;
+}
+#elif defined(__GNUC__) && defined(__x86_64__)
+static __inline__ Uint64
+SDL_Swap64(Uint64 x)
+{
+  __asm__("bswapq %0": "=r"(x):"0"(x));
+    return x;
+}
+#else
+static __inline__ Uint64
+SDL_Swap64(Uint64 x)
+{
+    Uint32 hi, lo;
+
+    /* Separate into high and low 32-bit values and swap them */
+    lo = SDL_static_cast(Uint32, x & 0xFFFFFFFF);
+    x >>= 32;
+    hi = SDL_static_cast(Uint32, x & 0xFFFFFFFF);
+    x = SDL_Swap32(lo);
+    x <<= 32;
+    x |= SDL_Swap32(hi);
+    return (x);
+}
+#endif
+#else
+/**
+ *  This is mainly to keep compilers from complaining in SDL code.
+ *  If there is no real 64-bit datatype, then compilers will complain about
+ *  the fake 64-bit datatype that SDL provides when it compiles user code.
+ */
+#define SDL_Swap64(X)	(X)
+#endif /* SDL_HAS_64BIT_TYPE */
+
+
+static __inline__ float
+SDL_SwapFloat(float x)
+{
+    union
+    {
+        float f;
+        Uint32 ui32;
+    } swapper;
+    swapper.f = x;
+    swapper.ui32 = SDL_Swap32(swapper.ui32);
+    return swapper.f;
+}
+
+
+/**
+ *  \name Swap to native
+ *  Byteswap item from the specified endianness to the native endianness.
+ */
+/*@{*/
+#if SDL_BYTEORDER == SDL_LIL_ENDIAN
+#define SDL_SwapLE16(X)	(X)
+#define SDL_SwapLE32(X)	(X)
+#define SDL_SwapLE64(X)	(X)
+#define SDL_SwapFloatLE(X)	(X)
+#define SDL_SwapBE16(X)	SDL_Swap16(X)
+#define SDL_SwapBE32(X)	SDL_Swap32(X)
+#define SDL_SwapBE64(X)	SDL_Swap64(X)
+#define SDL_SwapFloatBE(X)	SDL_SwapFloat(X)
+#else
+#define SDL_SwapLE16(X)	SDL_Swap16(X)
+#define SDL_SwapLE32(X)	SDL_Swap32(X)
+#define SDL_SwapLE64(X)	SDL_Swap64(X)
+#define SDL_SwapFloatLE(X)	SDL_SwapFloat(X)
+#define SDL_SwapBE16(X)	(X)
+#define SDL_SwapBE32(X)	(X)
+#define SDL_SwapBE64(X)	(X)
+#define SDL_SwapFloatBE(X)	(X)
+#endif
+/*@}*//*Swap to native*/
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+}
+/* *INDENT-ON* */
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_endian_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/include/SDL_error.h b/macosx/plugins/Common/SDL/include/SDL_error.h
new file mode 100644
index 00000000..a4a90d0e
--- /dev/null
+++ b/macosx/plugins/Common/SDL/include/SDL_error.h
@@ -0,0 +1,78 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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
+*/
+
+/**
+ *  \file SDL_error.h
+ *  
+ *  Simple error message routines for SDL.
+ */
+
+#ifndef _SDL_error_h
+#define _SDL_error_h
+
+#include "SDL_stdinc.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+extern "C" {
+/* *INDENT-ON* */
+#endif
+
+/* Public functions */
+extern DECLSPEC void SDLCALL SDL_SetError(const char *fmt, ...);
+extern DECLSPEC char *SDLCALL SDL_GetError(void);
+extern DECLSPEC void SDLCALL SDL_ClearError(void);
+
+/**
+ *  \name Internal error functions
+ *  
+ *  \internal 
+ *  Private error message function - used internally.
+ */
+/*@{*/
+#define SDL_OutOfMemory()	SDL_Error(SDL_ENOMEM)
+#define SDL_Unsupported()	SDL_Error(SDL_UNSUPPORTED)
+typedef enum
+{
+    SDL_ENOMEM,
+    SDL_EFREAD,
+    SDL_EFWRITE,
+    SDL_EFSEEK,
+    SDL_UNSUPPORTED,
+    SDL_LASTERROR
+} SDL_errorcode;
+extern DECLSPEC void SDLCALL SDL_Error(SDL_errorcode code);
+/*@}*//*Internal error functions*/
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+}
+/* *INDENT-ON* */
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_error_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/include/SDL_haptic.h b/macosx/plugins/Common/SDL/include/SDL_haptic.h
new file mode 100644
index 00000000..52f33f15
--- /dev/null
+++ b/macosx/plugins/Common/SDL/include/SDL_haptic.h
@@ -0,0 +1,1123 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 2008 Edgar Simo
+
+    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
+*/
+
+/**
+ *  \file SDL_haptic.h
+ *  
+ *  \brief The SDL Haptic subsystem allows you to control haptic (force feedback)
+ *         devices.
+ *  
+ *  The basic usage is as follows:
+ *   - Initialize the Subsystem (::SDL_INIT_HAPTIC).
+ *   - Open a Haptic Device.
+ *    - SDL_HapticOpen() to open from index.
+ *    - SDL_HapticOpenFromJoystick() to open from an existing joystick.
+ *   - Create an effect (::SDL_HapticEffect).
+ *   - Upload the effect with SDL_HapticNewEffect().
+ *   - Run the effect with SDL_HapticRunEffect().
+ *   - (optional) Free the effect with SDL_HapticDestroyEffect().
+ *   - Close the haptic device with SDL_HapticClose().
+ *
+ * \par Example:
+ * \code
+ * int test_haptic( SDL_Joystick * joystick ) {
+ *    SDL_Haptic *haptic;
+ *    SDL_HapticEffect effect;
+ *    int effect_id;
+ *
+ *    // Open the device
+ *    haptic = SDL_HapticOpenFromJoystick( joystick );
+ *    if (haptic == NULL) return -1; // Most likely joystick isn't haptic
+ *
+ *    // See if it can do sine waves
+ *    if ((SDL_HapticQuery(haptic) & SDL_HAPTIC_SINE)==0) {
+ *       SDL_HapticClose(haptic); // No sine effect
+ *       return -1;
+ *    }
+ *
+ *    // Create the effect
+ *    memset( &effect, 0, sizeof(SDL_HapticEffect) ); // 0 is safe default
+ *    effect.type = SDL_HAPTIC_SINE;
+ *    effect.periodic.direction.type = SDL_HAPTIC_POLAR; // Polar coordinates
+ *    effect.periodic.direction.dir[0] = 18000; // Force comes from south
+ *    effect.periodic.period = 1000; // 1000 ms
+ *    effect.periodic.magnitude = 20000; // 20000/32767 strength
+ *    effect.periodic.length = 5000; // 5 seconds long
+ *    effect.periodic.attack_length = 1000; // Takes 1 second to get max strength
+ *    effect.periodic.fade_length = 1000; // Takes 1 second to fade away
+ *
+ *    // Upload the effect
+ *    effect_id = SDL_HapticNewEffect( haptic, &effect );
+ *
+ *    // Test the effect
+ *    SDL_HapticRunEffect( haptic, effect_id, 1 );
+ *    SDL_Delay( 5000); // Wait for the effect to finish
+ *
+ *    // We destroy the effect, although closing the device also does this
+ *    SDL_HapticDestroyEffect( haptic, effect_id );
+ *
+ *    // Close the device
+ *    SDL_HapticClose(haptic);
+ *
+ *    return 0; // Success
+ * }
+ * \endcode
+ * \author Edgar Simo Serra
+ */
+
+#ifndef _SDL_haptic_h
+#define _SDL_haptic_h
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+#include "SDL_joystick.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+extern "C" {
+   /* *INDENT-ON* */                                                         
+#endif /* __cplusplus */
+
+/**
+ *  \typedef SDL_Haptic
+ *  
+ *  \brief The haptic structure used to identify an SDL haptic.
+ *  
+ *  \sa SDL_HapticOpen
+ *  \sa SDL_HapticOpenFromJoystick
+ *  \sa SDL_HapticClose
+ */
+struct _SDL_Haptic;
+typedef struct _SDL_Haptic SDL_Haptic;
+
+
+/**
+ *  \name Haptic features
+ *  
+ *  Different haptic features a device can have.
+ */
+/*@{*/
+
+/**
+ *  \name Haptic effects
+ */
+/*@{*/
+
+/**
+ *  \brief Constant effect supported.
+ *
+ *  Constant haptic effect.
+ *  
+ *  \sa SDL_HapticCondition
+ */
+#define SDL_HAPTIC_CONSTANT   (1<<0)
+
+/**
+ *  \brief Sine wave effect supported.
+ *  
+ *  Periodic haptic effect that simulates sine waves.
+ *  
+ *  \sa SDL_HapticPeriodic
+ */
+#define SDL_HAPTIC_SINE       (1<<1)
+
+/**
+ *  \brief Square wave effect supported.
+ *  
+ *  Periodic haptic effect that simulates square waves.
+ * 
+ *  \sa SDL_HapticPeriodic
+ */
+#define SDL_HAPTIC_SQUARE     (1<<2)
+
+/**
+ *  \brief Triangle wave effect supported.
+ *  
+ *  Periodic haptic effect that simulates triangular waves.
+ *  
+ *  \sa SDL_HapticPeriodic
+ */
+#define SDL_HAPTIC_TRIANGLE   (1<<3)
+
+/**
+ *  \brief Sawtoothup wave effect supported.
+ *  
+ *  Periodic haptic effect that simulates saw tooth up waves.
+ *  
+ *  \sa SDL_HapticPeriodic
+ */
+#define SDL_HAPTIC_SAWTOOTHUP (1<<4)
+
+/**
+ *  \brief Sawtoothdown wave effect supported.
+ *  
+ *  Periodic haptic effect that simulates saw tooth down waves.
+ *  
+ *  \sa SDL_HapticPeriodic
+ */
+#define SDL_HAPTIC_SAWTOOTHDOWN (1<<5)
+
+/**
+ *  \brief Ramp effect supported.
+ *  
+ *  Ramp haptic effect.
+ *  
+ *  \sa SDL_HapticRamp
+ */
+#define SDL_HAPTIC_RAMP       (1<<6)
+
+/**
+ *  \brief Spring effect supported - uses axes position.
+ *  
+ *  Condition haptic effect that simulates a spring.  Effect is based on the
+ *  axes position.
+ *
+ *  \sa SDL_HapticCondition
+ */
+#define SDL_HAPTIC_SPRING     (1<<7)
+
+/**
+ *  \brief Damper effect supported - uses axes velocity.
+ *  
+ *  Condition haptic effect that simulates dampening.  Effect is based on the
+ *  axes velocity.
+ *  
+ *  \sa SDL_HapticCondition
+ */
+#define SDL_HAPTIC_DAMPER     (1<<8)
+
+/**
+ *  \brief Inertia effect supported - uses axes acceleration.
+ *  
+ *  Condition haptic effect that simulates inertia.  Effect is based on the axes
+ *  acceleration.
+ *
+ *  \sa SDL_HapticCondition
+ */
+#define SDL_HAPTIC_INERTIA    (1<<9)
+
+/**
+ *  \brief Friction effect supported - uses axes movement.
+ *  
+ *  Condition haptic effect that simulates friction.  Effect is based on the 
+ *  axes movement.
+ *  
+ *  \sa SDL_HapticCondition
+ */
+#define SDL_HAPTIC_FRICTION   (1<<10)
+
+/**
+ *  \brief Custom effect is supported.
+ *  
+ *  User defined custom haptic effect.
+ */
+#define SDL_HAPTIC_CUSTOM     (1<<11)
+
+/*@}*//*Haptic effects*/
+
+/* These last few are features the device has, not effects */
+
+/**
+ *  \brief Device can set global gain.
+ *  
+ *  Device supports setting the global gain.
+ *  
+ *  \sa SDL_HapticSetGain
+ */
+#define SDL_HAPTIC_GAIN       (1<<12)
+
+/**
+ *  \brief Device can set autocenter.
+ *  
+ *  Device supports setting autocenter.
+ *  
+ *  \sa SDL_HapticSetAutocenter
+ */
+#define SDL_HAPTIC_AUTOCENTER (1<<13)
+
+/**
+ *  \brief Device can be queried for effect status.
+ *  
+ *  Device can be queried for effect status.
+ *  
+ *  \sa SDL_HapticGetEffectStatus
+ */
+#define SDL_HAPTIC_STATUS     (1<<14)
+
+/**
+ *  \brief Device can be paused.
+ *  
+ *  \sa SDL_HapticPause
+ *  \sa SDL_HapticUnpause
+ */
+#define SDL_HAPTIC_PAUSE      (1<<15)
+
+
+/**
+ * \name Direction encodings
+ */
+/*@{*/
+
+/**
+ *  \brief Uses polar coordinates for the direction.
+ *  
+ *  \sa SDL_HapticDirection
+ */
+#define SDL_HAPTIC_POLAR      0
+
+/**
+ *  \brief Uses cartesian coordinates for the direction.
+ *  
+ *  \sa SDL_HapticDirection
+ */
+#define SDL_HAPTIC_CARTESIAN  1
+
+/**
+ *  \brief Uses spherical coordinates for the direction.
+ *  
+ *  \sa SDL_HapticDirection
+ */
+#define SDL_HAPTIC_SPHERICAL  2
+
+/*@}*//*Direction encodings*/
+
+/*@}*//*Haptic features*/
+
+/*
+ * Misc defines.
+ */
+
+/**
+ * \brief Used to play a device an infinite number of times.
+ *
+ * \sa SDL_HapticRunEffect
+ */
+#define SDL_HAPTIC_INFINITY   4294967295U
+
+
+/**
+ *  \brief Structure that represents a haptic direction.
+ *  
+ *  Directions can be specified by:
+ *   - ::SDL_HAPTIC_POLAR : Specified by polar coordinates.
+ *   - ::SDL_HAPTIC_CARTESIAN : Specified by cartesian coordinates.
+ *   - ::SDL_HAPTIC_SPHERICAL : Specified by spherical coordinates.
+ *
+ *  Cardinal directions of the haptic device are relative to the positioning
+ *  of the device.  North is considered to be away from the user.
+ *
+ *  The following diagram represents the cardinal directions:
+ *  \verbatim
+                 .--.
+                 |__| .-------.
+                 |=.| |.-----.|
+                 |--| ||     ||
+                 |  | |'-----'|
+                 |__|~')_____('
+                   [ COMPUTER ]
+    
+    
+                     North (0,-1)
+                         ^
+                         |
+                         |
+    (1,0)  West <----[ HAPTIC ]----> East (-1,0)
+                         |
+                         |
+                         v
+                      South (0,1)
+    
+    
+                      [ USER ]
+                        \|||/
+                        (o o)
+                  ---ooO-(_)-Ooo---
+    \endverbatim
+ *  
+ *  If type is ::SDL_HAPTIC_POLAR, direction is encoded by hundredths of a 
+ *  degree starting north and turning clockwise.  ::SDL_HAPTIC_POLAR only uses
+ *  the first \c dir parameter.  The cardinal directions would be:
+ *   - North: 0 (0 degrees)
+ *   - East: 9000 (90 degrees)
+ *   - South: 18000 (180 degrees)
+ *   - West: 27000 (270 degrees)
+ *  
+ *  If type is ::SDL_HAPTIC_CARTESIAN, direction is encoded by three positions
+ *  (X axis, Y axis and Z axis (with 3 axes)).  ::SDL_HAPTIC_CARTESIAN uses
+ *  the first three \c dir parameters.  The cardinal directions would be:
+ *   - North:  0,-1, 0
+ *   - East:  -1, 0, 0
+ *   - South:  0, 1, 0
+ *   - West:   1, 0, 0
+ *  
+ *  The Z axis represents the height of the effect if supported, otherwise
+ *  it's unused.  In cartesian encoding (1, 2) would be the same as (2, 4), you
+ *  can use any multiple you want, only the direction matters.
+ *  
+ *  If type is ::SDL_HAPTIC_SPHERICAL, direction is encoded by two rotations.
+ *  The first two \c dir parameters are used.  The \c dir parameters are as 
+ *  follows (all values are in hundredths of degrees):
+ *   - Degrees from (1, 0) rotated towards (0, 1).
+ *   - Degrees towards (0, 0, 1) (device needs at least 3 axes).
+ *
+ *
+ *  Example of force coming from the south with all encodings (force coming
+ *  from the south means the user will have to pull the stick to counteract):
+ *  \code
+ *  SDL_HapticDirection direction;
+ *  
+ *  // Cartesian directions
+ *  direction.type = SDL_HAPTIC_CARTESIAN; // Using cartesian direction encoding.
+ *  direction.dir[0] = 0; // X position
+ *  direction.dir[1] = 1; // Y position
+ *  // Assuming the device has 2 axes, we don't need to specify third parameter.
+ *  
+ *  // Polar directions
+ *  direction.type = SDL_HAPTIC_POLAR; // We'll be using polar direction encoding.
+ *  direction.dir[0] = 18000; // Polar only uses first parameter
+ *  
+ *  // Spherical coordinates
+ *  direction.type = SDL_HAPTIC_SPHERICAL; // Spherical encoding
+ *  direction.dir[0] = 9000; // Since we only have two axes we don't need more parameters.
+ *  \endcode
+ *
+ *  \sa SDL_HAPTIC_POLAR
+ *  \sa SDL_HAPTIC_CARTESIAN
+ *  \sa SDL_HAPTIC_SPHERICAL
+ *  \sa SDL_HapticEffect
+ *  \sa SDL_HapticNumAxes
+ */
+typedef struct SDL_HapticDirection
+{
+    Uint8 type;         /**< The type of encoding. */
+    Sint32 dir[3];      /**< The encoded direction. */
+} SDL_HapticDirection;
+
+
+/**
+ *  \brief A structure containing a template for a Constant effect.
+ *  
+ *  The struct is exclusive to the ::SDL_HAPTIC_CONSTANT effect.
+ *  
+ *  A constant effect applies a constant force in the specified direction
+ *  to the joystick.
+ *  
+ *  \sa SDL_HAPTIC_CONSTANT
+ *  \sa SDL_HapticEffect
+ */
+typedef struct SDL_HapticConstant
+{
+    /* Header */
+    Uint16 type;            /**< ::SDL_HAPTIC_CONSTANT */
+    SDL_HapticDirection direction;  /**< Direction of the effect. */
+
+    /* Replay */
+    Uint32 length;          /**< Duration of the effect. */
+    Uint16 delay;           /**< Delay before starting the effect. */
+
+    /* Trigger */
+    Uint16 button;          /**< Button that triggers the effect. */
+    Uint16 interval;        /**< How soon it can be triggered again after button. */
+
+    /* Constant */
+    Sint16 level;           /**< Strength of the constant effect. */
+
+    /* Envelope */
+    Uint16 attack_length;   /**< Duration of the attack. */
+    Uint16 attack_level;    /**< Level at the start of the attack. */
+    Uint16 fade_length;     /**< Duration of the fade. */
+    Uint16 fade_level;      /**< Level at the end of the fade. */
+} SDL_HapticConstant;
+
+/**
+ *  \brief A structure containing a template for a Periodic effect.
+ *  
+ *  The struct handles the following effects:
+ *   - ::SDL_HAPTIC_SINE
+ *   - ::SDL_HAPTIC_SQUARE
+ *   - ::SDL_HAPTIC_TRIANGLE
+ *   - ::SDL_HAPTIC_SAWTOOTHUP
+ *   - ::SDL_HAPTIC_SAWTOOTHDOWN
+ *  
+ *  A periodic effect consists in a wave-shaped effect that repeats itself
+ *  over time.  The type determines the shape of the wave and the parameters
+ *  determine the dimensions of the wave.
+ *  
+ *  Phase is given by hundredth of a cyle meaning that giving the phase a value
+ *  of 9000 will displace it 25% of it's period.  Here are sample values:
+ *   -     0: No phase displacement.
+ *   -  9000: Displaced 25% of it's period.
+ *   - 18000: Displaced 50% of it's period.
+ *   - 27000: Displaced 75% of it's period.
+ *   - 36000: Displaced 100% of it's period, same as 0, but 0 is preffered.
+ *
+ *  Examples:
+ *  \verbatim
+    SDL_HAPTIC_SINE
+      __      __      __      __
+     /  \    /  \    /  \    /
+    /    \__/    \__/    \__/
+    
+    SDL_HAPTIC_SQUARE
+     __    __    __    __    __
+    |  |  |  |  |  |  |  |  |  |
+    |  |__|  |__|  |__|  |__|  |
+    
+    SDL_HAPTIC_TRIANGLE
+      /\    /\    /\    /\    /\
+     /  \  /  \  /  \  /  \  /
+    /    \/    \/    \/    \/
+    
+    SDL_HAPTIC_SAWTOOTHUP
+      /|  /|  /|  /|  /|  /|  /|
+     / | / | / | / | / | / | / |
+    /  |/  |/  |/  |/  |/  |/  |
+    
+    SDL_HAPTIC_SAWTOOTHDOWN
+    \  |\  |\  |\  |\  |\  |\  |
+     \ | \ | \ | \ | \ | \ | \ |
+      \|  \|  \|  \|  \|  \|  \|
+    \endverbatim
+ *  
+ *  \sa SDL_HAPTIC_SINE
+ *  \sa SDL_HAPTIC_SQUARE
+ *  \sa SDL_HAPTIC_TRIANGLE
+ *  \sa SDL_HAPTIC_SAWTOOTHUP
+ *  \sa SDL_HAPTIC_SAWTOOTHDOWN
+ *  \sa SDL_HapticEffect
+ */
+typedef struct SDL_HapticPeriodic
+{
+    /* Header */
+    Uint16 type;        /**< ::SDL_HAPTIC_SINE, ::SDL_HAPTIC_SQUARE,
+                             ::SDL_HAPTIC_TRIANGLE, ::SDL_HAPTIC_SAWTOOTHUP or
+                             ::SDL_HAPTIC_SAWTOOTHDOWN */
+    SDL_HapticDirection direction;  /**< Direction of the effect. */
+
+    /* Replay */
+    Uint32 length;      /**< Duration of the effect. */
+    Uint16 delay;       /**< Delay before starting the effect. */
+
+    /* Trigger */
+    Uint16 button;      /**< Button that triggers the effect. */
+    Uint16 interval;    /**< How soon it can be triggered again after button. */
+
+    /* Periodic */
+    Uint16 period;      /**< Period of the wave. */
+    Sint16 magnitude;   /**< Peak value. */
+    Sint16 offset;      /**< Mean value of the wave. */
+    Uint16 phase;       /**< Horizontal shift given by hundredth of a cycle. */
+
+    /* Envelope */
+    Uint16 attack_length;   /**< Duration of the attack. */
+    Uint16 attack_level;    /**< Level at the start of the attack. */
+    Uint16 fade_length; /**< Duration of the fade. */
+    Uint16 fade_level;  /**< Level at the end of the fade. */
+} SDL_HapticPeriodic;
+
+/**
+ *  \brief A structure containing a template for a Condition effect.
+ *  
+ *  The struct handles the following effects:
+ *   - ::SDL_HAPTIC_SPRING: Effect based on axes position.
+ *   - ::SDL_HAPTIC_DAMPER: Effect based on axes velocity.
+ *   - ::SDL_HAPTIC_INERTIA: Effect based on axes acceleration.
+ *   - ::SDL_HAPTIC_FRICTION: Effect based on axes movement.
+ *  
+ *  Direction is handled by condition internals instead of a direction member.
+ *  The condition effect specific members have three parameters.  The first
+ *  refers to the X axis, the second refers to the Y axis and the third
+ *  refers to the Z axis.  The right terms refer to the positive side of the
+ *  axis and the left terms refer to the negative side of the axis.  Please 
+ *  refer to the ::SDL_HapticDirection diagram for which side is positive and
+ *  which is negative.
+ *  
+ *  \sa SDL_HapticDirection
+ *  \sa SDL_HAPTIC_SPRING
+ *  \sa SDL_HAPTIC_DAMPER
+ *  \sa SDL_HAPTIC_INERTIA
+ *  \sa SDL_HAPTIC_FRICTION
+ *  \sa SDL_HapticEffect
+ */
+typedef struct SDL_HapticCondition
+{
+    /* Header */
+    Uint16 type;            /**< ::SDL_HAPTIC_SPRING, ::SDL_HAPTIC_DAMPER,
+                                 ::SDL_HAPTIC_INERTIA or ::SDL_HAPTIC_FRICTION */
+    SDL_HapticDirection direction;  /**< Direction of the effect - Not used ATM. */
+
+    /* Replay */
+    Uint32 length;          /**< Duration of the effect. */
+    Uint16 delay;           /**< Delay before starting the effect. */
+
+    /* Trigger */
+    Uint16 button;          /**< Button that triggers the effect. */
+    Uint16 interval;        /**< How soon it can be triggered again after button. */
+
+    /* Condition */
+    Uint16 right_sat[3];    /**< Level when joystick is to the positive side. */
+    Uint16 left_sat[3];     /**< Level when joystick is to the negative side. */
+    Sint16 right_coeff[3];  /**< How fast to increase the force towards the positive side. */
+    Sint16 left_coeff[3];   /**< How fast to increase the force towards the negative side. */
+    Uint16 deadband[3];     /**< Size of the dead zone. */
+    Sint16 center[3];       /**< Position of the dead zone. */
+} SDL_HapticCondition;
+
+/**
+ *  \brief A structure containing a template for a Ramp effect.
+ *  
+ *  This struct is exclusively for the ::SDL_HAPTIC_RAMP effect.
+ *  
+ *  The ramp effect starts at start strength and ends at end strength.
+ *  It augments in linear fashion.  If you use attack and fade with a ramp
+ *  they effects get added to the ramp effect making the effect become
+ *  quadratic instead of linear.
+ *  
+ *  \sa SDL_HAPTIC_RAMP
+ *  \sa SDL_HapticEffect
+ */
+typedef struct SDL_HapticRamp
+{
+    /* Header */
+    Uint16 type;            /**< ::SDL_HAPTIC_RAMP */
+    SDL_HapticDirection direction;  /**< Direction of the effect. */
+
+    /* Replay */
+    Uint32 length;          /**< Duration of the effect. */
+    Uint16 delay;           /**< Delay before starting the effect. */
+
+    /* Trigger */
+    Uint16 button;          /**< Button that triggers the effect. */
+    Uint16 interval;        /**< How soon it can be triggered again after button. */
+
+    /* Ramp */
+    Sint16 start;           /**< Beginning strength level. */
+    Sint16 end;             /**< Ending strength level. */
+
+    /* Envelope */
+    Uint16 attack_length;   /**< Duration of the attack. */
+    Uint16 attack_level;    /**< Level at the start of the attack. */
+    Uint16 fade_length;     /**< Duration of the fade. */
+    Uint16 fade_level;      /**< Level at the end of the fade. */
+} SDL_HapticRamp;
+
+/**
+ *  \brief A structure containing a template for the ::SDL_HAPTIC_CUSTOM effect.
+ *  
+ *  A custom force feedback effect is much like a periodic effect, where the
+ *  application can define it's exact shape.  You will have to allocate the
+ *  data yourself.  Data should consist of channels * samples Uint16 samples.
+ *  
+ *  If channels is one, the effect is rotated using the defined direction.
+ *  Otherwise it uses the samples in data for the different axes.
+ *  
+ *  \sa SDL_HAPTIC_CUSTOM
+ *  \sa SDL_HapticEffect
+ */
+typedef struct SDL_HapticCustom
+{
+    /* Header */
+    Uint16 type;            /**< ::SDL_HAPTIC_CUSTOM */
+    SDL_HapticDirection direction;  /**< Direction of the effect. */
+
+    /* Replay */
+    Uint32 length;          /**< Duration of the effect. */
+    Uint16 delay;           /**< Delay before starting the effect. */
+
+    /* Trigger */
+    Uint16 button;          /**< Button that triggers the effect. */
+    Uint16 interval;        /**< How soon it can be triggered again after button. */
+
+    /* Custom */
+    Uint8 channels;         /**< Axes to use, minimum of one. */
+    Uint16 period;          /**< Sample periods. */
+    Uint16 samples;         /**< Amount of samples. */
+    Uint16 *data;           /**< Should contain channels*samples items. */
+
+    /* Envelope */
+    Uint16 attack_length;   /**< Duration of the attack. */
+    Uint16 attack_level;    /**< Level at the start of the attack. */
+    Uint16 fade_length;     /**< Duration of the fade. */
+    Uint16 fade_level;      /**< Level at the end of the fade. */
+} SDL_HapticCustom;
+
+/**
+ *  \brief The generic template for any haptic effect.
+ *  
+ *  All values max at 32767 (0x7FFF).  Signed values also can be negative.
+ *  Time values unless specified otherwise are in milliseconds.
+ *  
+ *  You can also pass ::SDL_HAPTIC_INFINITY to length instead of a 0-32767 
+ *  value.  Neither delay, interval, attack_length nor fade_length support 
+ *  ::SDL_HAPTIC_INFINITY.  Fade will also not be used since effect never ends.
+ *  
+ *  Additionally, the ::SDL_HAPTIC_RAMP effect does not support a duration of
+ *  ::SDL_HAPTIC_INFINITY.
+ *  
+ *  Button triggers may not be supported on all devices, it is advised to not
+ *  use them if possible.  Buttons start at index 1 instead of index 0 like
+ *  they joystick.
+ *  
+ *  If both attack_length and fade_level are 0, the envelope is not used,
+ *  otherwise both values are used.
+ *  
+ *  Common parts:
+ *  \code
+ *  // Replay - All effects have this
+ *  Uint32 length;        // Duration of effect (ms).
+ *  Uint16 delay;         // Delay before starting effect.
+ *  
+ *  // Trigger - All effects have this
+ *  Uint16 button;        // Button that triggers effect.
+ *  Uint16 interval;      // How soon before effect can be triggered again.
+ *  
+ *  // Envelope - All effects except condition effects have this
+ *  Uint16 attack_length; // Duration of the attack (ms).
+ *  Uint16 attack_level;  // Level at the start of the attack.
+ *  Uint16 fade_length;   // Duration of the fade out (ms).
+ *  Uint16 fade_level;    // Level at the end of the fade.
+ *  \endcode
+ *
+ *
+ *  Here we have an example of a constant effect evolution in time:
+ *  \verbatim
+    Strength
+    ^
+    |
+    |    effect level -->  _________________
+    |                     /                 \
+    |                    /                   \
+    |                   /                     \
+    |                  /                       \ 
+    | attack_level --> |                        \
+    |                  |                        |  <---  fade_level
+    |
+    +--------------------------------------------------> Time
+                       [--]                 [---]
+                       attack_length        fade_length
+    
+    [------------------][-----------------------]
+    delay               length
+    \endverbatim
+ *  
+ *  Note either the attack_level or the fade_level may be above the actual
+ *  effect level.
+ *
+ *  \sa SDL_HapticConstant
+ *  \sa SDL_HapticPeriodic
+ *  \sa SDL_HapticCondition
+ *  \sa SDL_HapticRamp
+ *  \sa SDL_HapticCustom
+ */
+typedef union SDL_HapticEffect
+{
+    /* Common for all force feedback effects */
+    Uint16 type;                    /**< Effect type. */
+    SDL_HapticConstant constant;    /**< Constant effect. */
+    SDL_HapticPeriodic periodic;    /**< Periodic effect. */
+    SDL_HapticCondition condition;  /**< Condition effect. */
+    SDL_HapticRamp ramp;            /**< Ramp effect. */
+    SDL_HapticCustom custom;        /**< Custom effect. */
+} SDL_HapticEffect;
+
+
+/* Function prototypes */
+/**
+ *  \brief Count the number of joysticks attached to the system.
+ *  
+ *  \return Number of haptic devices detected on the system.
+ */
+extern DECLSPEC int SDLCALL SDL_NumHaptics(void);
+
+/**
+ *  \brief Get the implementation dependent name of a Haptic device.
+ *  
+ *  This can be called before any joysticks are opened.
+ *  If no name can be found, this function returns NULL.
+ *  
+ *  \param device_index Index of the device to get it's name.
+ *  \return Name of the device or NULL on error.
+ *
+ *  \sa SDL_NumHaptics
+ */
+extern DECLSPEC const char *SDLCALL SDL_HapticName(int device_index);
+
+/**
+ *  \brief Opens a Haptic device for usage.
+ *  
+ *  The index passed as an argument refers to the N'th Haptic device on this 
+ *  system.
+ *
+ *  When opening a haptic device, it's gain will be set to maximum and
+ *  autocenter will be disabled.  To modify these values use
+ *  SDL_HapticSetGain() and SDL_HapticSetAutocenter().
+ *
+ *  \param device_index Index of the device to open.
+ *  \return Device identifier or NULL on error.
+ *
+ *  \sa SDL_HapticIndex
+ *  \sa SDL_HapticOpenFromMouse
+ *  \sa SDL_HapticOpenFromJoystick
+ *  \sa SDL_HapticClose
+ *  \sa SDL_HapticSetGain
+ *  \sa SDL_HapticSetAutocenter
+ *  \sa SDL_HapticPause
+ *  \sa SDL_HapticStopAll
+ */
+extern DECLSPEC SDL_Haptic *SDLCALL SDL_HapticOpen(int device_index);
+
+/**
+ *  \brief Checks if the haptic device at index has been opened.
+ *  
+ *  \param device_index Index to check to see if it has been opened.
+ *  \return 1 if it has been opened or 0 if it hasn't.
+ *  
+ *  \sa SDL_HapticOpen
+ *  \sa SDL_HapticIndex
+ */
+extern DECLSPEC int SDLCALL SDL_HapticOpened(int device_index);
+
+/**
+ *  \brief Gets the index of a haptic device.
+ *  
+ *  \param haptic Haptic device to get the index of.
+ *  \return The index of the haptic device or -1 on error.
+ *  
+ *  \sa SDL_HapticOpen
+ *  \sa SDL_HapticOpened
+ */
+extern DECLSPEC int SDLCALL SDL_HapticIndex(SDL_Haptic * haptic);
+
+/**
+ *  \brief Gets whether or not the current mouse has haptic capabilities.
+ *  
+ *  \return SDL_TRUE if the mouse is haptic, SDL_FALSE if it isn't.
+ *  
+ *  \sa SDL_HapticOpenFromMouse
+ */
+extern DECLSPEC int SDLCALL SDL_MouseIsHaptic(void);
+
+/**
+ *  \brief Tries to open a haptic device from the current mouse.
+ *  
+ *  \return The haptic device identifier or NULL on error.
+ *  
+ *  \sa SDL_MouseIsHaptic
+ *  \sa SDL_HapticOpen
+ */
+extern DECLSPEC SDL_Haptic *SDLCALL SDL_HapticOpenFromMouse(void);
+
+/**
+ *  \brief Checks to see if a joystick has haptic features.
+ *  
+ *  \param joystick Joystick to test for haptic capabilities.
+ *  \return 1 if the joystick is haptic, 0 if it isn't
+ *          or -1 if an error ocurred.
+ *  
+ *  \sa SDL_HapticOpenFromJoystick
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickIsHaptic(SDL_Joystick * joystick);
+
+/**
+ *  \brief Opens a Haptic device for usage from a Joystick device.
+ *  
+ *  You must still close the haptic device seperately.  It will not be closed 
+ *  with the joystick.
+ *  
+ *  When opening from a joystick you should first close the haptic device before
+ *  closing the joystick device.  If not, on some implementations the haptic
+ *  device will also get unallocated and you'll be unable to use force feedback
+ *  on that device.
+ *  
+ *  \param joystick Joystick to create a haptic device from.
+ *  \return A valid haptic device identifier on success or NULL on error.
+ *  
+ *  \sa SDL_HapticOpen
+ *  \sa SDL_HapticClose
+ */
+extern DECLSPEC SDL_Haptic *SDLCALL SDL_HapticOpenFromJoystick(SDL_Joystick *
+                                                               joystick);
+
+/**
+ *  \brief Closes a Haptic device previously opened with SDL_HapticOpen().
+ *  
+ *  \param haptic Haptic device to close.
+ */
+extern DECLSPEC void SDLCALL SDL_HapticClose(SDL_Haptic * haptic);
+
+/**
+ *  \brief Returns the number of effects a haptic device can store.
+ *  
+ *  On some platforms this isn't fully supported, and therefore is an
+ *  aproximation.  Always check to see if your created effect was actually
+ *  created and do not rely solely on SDL_HapticNumEffects().
+ *  
+ *  \param haptic The haptic device to query effect max.
+ *  \return The number of effects the haptic device can store or
+ *          -1 on error.
+ *  
+ *  \sa SDL_HapticNumEffectsPlaying
+ *  \sa SDL_HapticQuery
+ */
+extern DECLSPEC int SDLCALL SDL_HapticNumEffects(SDL_Haptic * haptic);
+
+/**
+ *  \brief Returns the number of effects a haptic device can play at the same 
+ *         time.
+ *  
+ *  This is not supported on all platforms, but will always return a value.  
+ *  Added here for the sake of completness.
+ *  
+ *  \param haptic The haptic device to query maximum playing effects.
+ *  \return The number of effects the haptic device can play at the same time
+ *          or -1 on error.
+ *
+ *  \sa SDL_HapticNumEffects
+ *  \sa SDL_HapticQuery
+ */
+extern DECLSPEC int SDLCALL SDL_HapticNumEffectsPlaying(SDL_Haptic * haptic);
+
+/**
+ *  \brief Gets the haptic devices supported features in bitwise matter.
+ *  
+ *  Example: 
+ *  \code
+ *  if (SDL_HapticQueryEffects(haptic) & SDL_HAPTIC_CONSTANT) {
+ *      printf("We have constant haptic effect!");
+ *  }
+ *  \endcode
+ *  
+ *  \param haptic The haptic device to query.
+ *  \return Haptic features in bitwise manner (OR'd).
+ *  
+ *  \sa SDL_HapticNumEffects
+ *  \sa SDL_HapticEffectSupported
+ */
+extern DECLSPEC unsigned int SDLCALL SDL_HapticQuery(SDL_Haptic * haptic);
+
+
+/**
+ *  \brief Gets the number of haptic axes the device has.
+ *  
+ *  \sa SDL_HapticDirection
+ */
+extern DECLSPEC int SDLCALL SDL_HapticNumAxes(SDL_Haptic * haptic);
+
+/**
+ *  \brief Checks to see if effect is supported by haptic.
+ *  
+ *  \param haptic Haptic device to check on.
+ *  \param effect Effect to check to see if it is supported.
+ *  \return 1 if effect is supported, 0 if it isn't or -1 on error.
+ *  
+ *  \sa SDL_HapticQuery
+ *  \sa SDL_HapticNewEffect
+ */
+extern DECLSPEC int SDLCALL SDL_HapticEffectSupported(SDL_Haptic * haptic,
+                                                      SDL_HapticEffect *
+                                                      effect);
+
+/**
+ *  \brief Creates a new haptic effect on the device.
+ *  
+ *  \param haptic Haptic device to create the effect on.
+ *  \param effect Properties of the effect to create.
+ *  \return The id of the effect on success or -1 on error.
+ *  
+ *  \sa SDL_HapticUpdateEffect
+ *  \sa SDL_HapticRunEffect
+ *  \sa SDL_HapticDestroyEffect
+ */
+extern DECLSPEC int SDLCALL SDL_HapticNewEffect(SDL_Haptic * haptic,
+                                                SDL_HapticEffect * effect);
+
+/**
+ *  \brief Updates the properties of an effect.
+ *  
+ *  Can be used dynamically, although behaviour when dynamically changing
+ *  direction may be strange.  Specifically the effect may reupload itself
+ *  and start playing from the start.  You cannot change the type either when
+ *  running SDL_HapticUpdateEffect().
+ *  
+ *  \param haptic Haptic device that has the effect.
+ *  \param effect Effect to update.
+ *  \param data New effect properties to use.
+ *  \return The id of the effect on success or -1 on error.
+ *  
+ *  \sa SDL_HapticNewEffect
+ *  \sa SDL_HapticRunEffect
+ *  \sa SDL_HapticDestroyEffect
+ */
+extern DECLSPEC int SDLCALL SDL_HapticUpdateEffect(SDL_Haptic * haptic,
+                                                   int effect,
+                                                   SDL_HapticEffect * data);
+
+/**
+ *  \brief Runs the haptic effect on it's assosciated haptic device.
+ *  
+ *  If iterations are ::SDL_HAPTIC_INFINITY, it'll run the effect over and over
+ *  repeating the envelope (attack and fade) every time.  If you only want the
+ *  effect to last forever, set ::SDL_HAPTIC_INFINITY in the effect's length
+ *  parameter.
+ *  
+ *  \param haptic Haptic device to run the effect on.
+ *  \param effect Identifier of the haptic effect to run.
+ *  \param iterations Number of iterations to run the effect. Use
+ *         ::SDL_HAPTIC_INFINITY for infinity.
+ *  \return 0 on success or -1 on error.
+ *  
+ *  \sa SDL_HapticStopEffect
+ *  \sa SDL_HapticDestroyEffect
+ *  \sa SDL_HapticGetEffectStatus
+ */
+extern DECLSPEC int SDLCALL SDL_HapticRunEffect(SDL_Haptic * haptic,
+                                                int effect,
+                                                Uint32 iterations);
+
+/**
+ *  \brief Stops the haptic effect on it's assosciated haptic device.
+ *  
+ *  \param haptic Haptic device to stop the effect on.
+ *  \param effect Identifier of the effect to stop.
+ *  \return 0 on success or -1 on error.
+ *  
+ *  \sa SDL_HapticRunEffect
+ *  \sa SDL_HapticDestroyEffect
+ */
+extern DECLSPEC int SDLCALL SDL_HapticStopEffect(SDL_Haptic * haptic,
+                                                 int effect);
+
+/**
+ *  \brief Destroys a haptic effect on the device.
+ *  
+ *  This will stop the effect if it's running.  Effects are automatically 
+ *  destroyed when the device is closed.
+ *  
+ *  \param haptic Device to destroy the effect on.
+ *  \param effect Identifier of the effect to destroy.
+ *  
+ *  \sa SDL_HapticNewEffect
+ */
+extern DECLSPEC void SDLCALL SDL_HapticDestroyEffect(SDL_Haptic * haptic,
+                                                     int effect);
+
+/**
+ *  \brief Gets the status of the current effect on the haptic device.
+ *  
+ *  Device must support the ::SDL_HAPTIC_STATUS feature.
+ *  
+ *  \param haptic Haptic device to query the effect status on.
+ *  \param effect Identifier of the effect to query it's status.
+ *  \return 0 if it isn't playing, ::SDL_HAPTIC_PLAYING if it is playing
+ *          or -1 on error.
+ *  
+ *  \sa SDL_HapticRunEffect
+ *  \sa SDL_HapticStopEffect
+ */
+extern DECLSPEC int SDLCALL SDL_HapticGetEffectStatus(SDL_Haptic * haptic,
+                                                      int effect);
+
+/**
+ *  \brief Sets the global gain of the device.
+ *  
+ *  Device must support the ::SDL_HAPTIC_GAIN feature.
+ *  
+ *  The user may specify the maxmimum gain by setting the environment variable
+ *  ::SDL_HAPTIC_GAIN_MAX which should be between 0 and 100.  All calls to
+ *  SDL_HapticSetGain() will scale linearly using ::SDL_HAPTIC_GAIN_MAX as the
+ *  maximum.
+ *  
+ *  \param haptic Haptic device to set the gain on.
+ *  \param gain Value to set the gain to, should be between 0 and 100.
+ *  \return 0 on success or -1 on error.
+ *  
+ *  \sa SDL_HapticQuery
+ */
+extern DECLSPEC int SDLCALL SDL_HapticSetGain(SDL_Haptic * haptic, int gain);
+
+/**
+ *  \brief Sets the global autocenter of the device.
+ *  
+ *  Autocenter should be between 0 and 100.  Setting it to 0 will disable 
+ *  autocentering.
+ *
+ *  Device must support the ::SDL_HAPTIC_AUTOCENTER feature.
+ *
+ *  \param haptic Haptic device to set autocentering on.
+ *  \param autocenter Value to set autocenter to, 0 disables autocentering.
+ *  \return 0 on success or -1 on error.
+ *  
+ *  \sa SDL_HapticQuery
+ */
+extern DECLSPEC int SDLCALL SDL_HapticSetAutocenter(SDL_Haptic * haptic,
+                                                    int autocenter);
+
+/**
+ *  \brief Pauses a haptic device.
+ *  
+ *  Device must support the ::SDL_HAPTIC_PAUSE feature.  Call 
+ *  SDL_HapticUnpause() to resume playback.
+ *  
+ *  Do not modify the effects nor add new ones while the device is paused.
+ *  That can cause all sorts of weird errors.
+ *  
+ *  \param haptic Haptic device to pause.
+ *  \return 0 on success or -1 on error.
+ *  
+ *  \sa SDL_HapticUnpause
+ */
+extern DECLSPEC int SDLCALL SDL_HapticPause(SDL_Haptic * haptic);
+
+/**
+ *  \brief Unpauses a haptic device.
+ *  
+ *  Call to unpause after SDL_HapticPause().
+ *  
+ *  \param haptic Haptic device to pause.
+ *  \return 0 on success or -1 on error.
+ *  
+ *  \sa SDL_HapticPause
+ */
+extern DECLSPEC int SDLCALL SDL_HapticUnpause(SDL_Haptic * haptic);
+
+/**
+ *  \brief Stops all the currently playing effects on a haptic device.
+ *  
+ *  \param haptic Haptic device to stop.
+ *  \return 0 on success or -1 on error.
+ */
+extern DECLSPEC int SDLCALL SDL_HapticStopAll(SDL_Haptic * haptic);
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+}
+/* *INDENT-ON* */
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_haptic_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/include/SDL_joystick.h b/macosx/plugins/Common/SDL/include/SDL_joystick.h
new file mode 100644
index 00000000..2e70862f
--- /dev/null
+++ b/macosx/plugins/Common/SDL/include/SDL_joystick.h
@@ -0,0 +1,209 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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
+*/
+
+/**
+ *  \file SDL_joystick.h
+ *  
+ *  Include file for SDL joystick event handling
+ */
+
+#ifndef _SDL_joystick_h
+#define _SDL_joystick_h
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+extern "C" {
+/* *INDENT-ON* */
+#endif
+
+/**
+ *  \file SDL_joystick.h
+ *
+ *  In order to use these functions, SDL_Init() must have been called
+ *  with the ::SDL_INIT_JOYSTICK flag.  This causes SDL to scan the system
+ *  for joysticks, and load appropriate drivers.
+ */
+
+/* The joystick structure used to identify an SDL joystick */
+struct _SDL_Joystick;
+typedef struct _SDL_Joystick SDL_Joystick;
+
+
+/* Function prototypes */
+/**
+ *  Count the number of joysticks attached to the system
+ */
+extern DECLSPEC int SDLCALL SDL_NumJoysticks(void);
+
+/**
+ *  Get the implementation dependent name of a joystick.
+ *  This can be called before any joysticks are opened.
+ *  If no name can be found, this function returns NULL.
+ */
+extern DECLSPEC const char *SDLCALL SDL_JoystickName(int device_index);
+
+/**
+ *  Open a joystick for use.  
+ *  The index passed as an argument refers tothe N'th joystick on the system.  
+ *  This index is the value which will identify this joystick in future joystick
+ *  events.
+ *  
+ *  \return A joystick identifier, or NULL if an error occurred.
+ */
+extern DECLSPEC SDL_Joystick *SDLCALL SDL_JoystickOpen(int device_index);
+
+/**
+ *  Returns 1 if the joystick has been opened, or 0 if it has not.
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickOpened(int device_index);
+
+/**
+ *  Get the device index of an opened joystick.
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickIndex(SDL_Joystick * joystick);
+
+/**
+ *  Get the number of general axis controls on a joystick.
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickNumAxes(SDL_Joystick * joystick);
+
+/**
+ *  Get the number of trackballs on a joystick.
+ *  
+ *  Joystick trackballs have only relative motion events associated
+ *  with them and their state cannot be polled.
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickNumBalls(SDL_Joystick * joystick);
+
+/**
+ *  Get the number of POV hats on a joystick.
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickNumHats(SDL_Joystick * joystick);
+
+/**
+ *  Get the number of buttons on a joystick.
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickNumButtons(SDL_Joystick * joystick);
+
+/**
+ *  Update the current state of the open joysticks.
+ *  
+ *  This is called automatically by the event loop if any joystick
+ *  events are enabled.
+ */
+extern DECLSPEC void SDLCALL SDL_JoystickUpdate(void);
+
+/**
+ *  Enable/disable joystick event polling.
+ *  
+ *  If joystick events are disabled, you must call SDL_JoystickUpdate()
+ *  yourself and check the state of the joystick when you want joystick
+ *  information.
+ *  
+ *  The state can be one of ::SDL_QUERY, ::SDL_ENABLE or ::SDL_IGNORE.
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickEventState(int state);
+
+/**
+ *  Get the current state of an axis control on a joystick.
+ *  
+ *  The state is a value ranging from -32768 to 32767.
+ *  
+ *  The axis indices start at index 0.
+ */
+extern DECLSPEC Sint16 SDLCALL SDL_JoystickGetAxis(SDL_Joystick * joystick,
+                                                   int axis);
+
+/**
+ *  \name Hat positions
+ */
+/*@{*/
+#define SDL_HAT_CENTERED	0x00
+#define SDL_HAT_UP		0x01
+#define SDL_HAT_RIGHT		0x02
+#define SDL_HAT_DOWN		0x04
+#define SDL_HAT_LEFT		0x08
+#define SDL_HAT_RIGHTUP		(SDL_HAT_RIGHT|SDL_HAT_UP)
+#define SDL_HAT_RIGHTDOWN	(SDL_HAT_RIGHT|SDL_HAT_DOWN)
+#define SDL_HAT_LEFTUP		(SDL_HAT_LEFT|SDL_HAT_UP)
+#define SDL_HAT_LEFTDOWN	(SDL_HAT_LEFT|SDL_HAT_DOWN)
+/*@}*/
+
+/**
+ *  Get the current state of a POV hat on a joystick.
+ *
+ *  The hat indices start at index 0.
+ *  
+ *  \return The return value is one of the following positions:
+ *           - ::SDL_HAT_CENTERED
+ *           - ::SDL_HAT_UP
+ *           - ::SDL_HAT_RIGHT
+ *           - ::SDL_HAT_DOWN
+ *           - ::SDL_HAT_LEFT
+ *           - ::SDL_HAT_RIGHTUP
+ *           - ::SDL_HAT_RIGHTDOWN
+ *           - ::SDL_HAT_LEFTUP
+ *           - ::SDL_HAT_LEFTDOWN
+ */
+extern DECLSPEC Uint8 SDLCALL SDL_JoystickGetHat(SDL_Joystick * joystick,
+                                                 int hat);
+
+/**
+ *  Get the ball axis change since the last poll.
+ *  
+ *  \return 0, or -1 if you passed it invalid parameters.
+ *  
+ *  The ball indices start at index 0.
+ */
+extern DECLSPEC int SDLCALL SDL_JoystickGetBall(SDL_Joystick * joystick,
+                                                int ball, int *dx, int *dy);
+
+/**
+ *  Get the current state of a button on a joystick.
+ *  
+ *  The button indices start at index 0.
+ */
+extern DECLSPEC Uint8 SDLCALL SDL_JoystickGetButton(SDL_Joystick * joystick,
+                                                    int button);
+
+/**
+ *  Close a joystick previously opened with SDL_JoystickOpen().
+ */
+extern DECLSPEC void SDLCALL SDL_JoystickClose(SDL_Joystick * joystick);
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+}
+/* *INDENT-ON* */
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_joystick_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/include/SDL_main.h b/macosx/plugins/Common/SDL/include/SDL_main.h
new file mode 100644
index 00000000..803aa0fb
--- /dev/null
+++ b/macosx/plugins/Common/SDL/include/SDL_main.h
@@ -0,0 +1,96 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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
+*/
+
+#ifndef _SDL_main_h
+#define _SDL_main_h
+
+#include "SDL_stdinc.h"
+
+/**
+ *  \file SDL_main.h
+ *  
+ *  Redefine main() on some platforms so that it is called by SDL.
+ */
+
+#if defined(__WIN32__) || \
+    (defined(__MWERKS__) && !defined(__BEOS__)) || \
+    defined(__SYMBIAN32__) || defined(__IPHONEOS__)
+
+#ifdef __cplusplus
+#define C_LINKAGE	"C"
+#else
+#define C_LINKAGE
+#endif /* __cplusplus */
+
+/**
+ *  \file SDL_main.h
+ *
+ *  The application's main() function must be called with C linkage,
+ *  and should be declared like this:
+ *  \code
+ *  #ifdef __cplusplus
+ *  extern "C"
+ *  #endif
+ *  int main(int argc, char *argv[])
+ *  {
+ *  }
+ *  \endcode
+ */
+
+#define main	SDL_main
+
+/**
+ *  The prototype for the application's main() function
+ */
+extern C_LINKAGE int SDL_main(int argc, char *argv[]);
+
+
+/* From the SDL library code -- needed for registering the app on Win32 */
+#ifdef __WIN32__
+
+#include "begin_code.h"
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+extern "C" {
+/* *INDENT-ON* */
+#endif
+
+/**
+ *  This can be called to set the application class at startup
+ */
+extern DECLSPEC int SDLCALL SDL_RegisterApp(char *name, Uint32 style,
+                                            void *hInst);
+extern DECLSPEC void SDLCALL SDL_UnregisterApp(void);
+
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+}
+/* *INDENT-ON* */
+#endif
+#include "close_code.h"
+#endif
+
+#endif /* Need to redefine main()? */
+
+#endif /* _SDL_main_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/include/SDL_mutex.h b/macosx/plugins/Common/SDL/include/SDL_mutex.h
new file mode 100644
index 00000000..e066f944
--- /dev/null
+++ b/macosx/plugins/Common/SDL/include/SDL_mutex.h
@@ -0,0 +1,223 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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
+*/
+
+#ifndef _SDL_mutex_h
+#define _SDL_mutex_h
+
+/**
+ *  \file SDL_mutex.h
+ *  
+ *  Functions to provide thread synchronization primitives.
+ */
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+extern "C" {
+/* *INDENT-ON* */
+#endif
+
+/**
+ *  Synchronization functions which can time out return this value
+ *  if they time out.
+ */
+#define SDL_MUTEX_TIMEDOUT	1
+
+/**
+ *  This is the timeout value which corresponds to never time out.
+ */
+#define SDL_MUTEX_MAXWAIT	(~(Uint32)0)
+
+
+/**
+ *  \name Mutex functions
+ */
+/*@{*/
+
+/* The SDL mutex structure, defined in SDL_mutex.c */
+struct SDL_mutex;
+typedef struct SDL_mutex SDL_mutex;
+
+/**
+ *  Create a mutex, initialized unlocked.
+ */
+extern DECLSPEC SDL_mutex *SDLCALL SDL_CreateMutex(void);
+
+/**
+ *  Lock the mutex.
+ *  
+ *  \return 0, or -1 on error.
+ */
+#define SDL_LockMutex(m)	SDL_mutexP(m)
+extern DECLSPEC int SDLCALL SDL_mutexP(SDL_mutex * mutex);
+
+/**
+ *  Unlock the mutex.
+ *  
+ *  \return 0, or -1 on error.
+ *  
+ *  \warning It is an error to unlock a mutex that has not been locked by
+ *           the current thread, and doing so results in undefined behavior.
+ */
+#define SDL_UnlockMutex(m)	SDL_mutexV(m)
+extern DECLSPEC int SDLCALL SDL_mutexV(SDL_mutex * mutex);
+
+/** 
+ *  Destroy a mutex.
+ */
+extern DECLSPEC void SDLCALL SDL_DestroyMutex(SDL_mutex * mutex);
+
+/*@}*//*Mutex functions*/
+
+
+/**
+ *  \name Semaphore functions
+ */
+/*@{*/
+
+/* The SDL semaphore structure, defined in SDL_sem.c */
+struct SDL_semaphore;
+typedef struct SDL_semaphore SDL_sem;
+
+/**
+ *  Create a semaphore, initialized with value, returns NULL on failure.
+ */
+extern DECLSPEC SDL_sem *SDLCALL SDL_CreateSemaphore(Uint32 initial_value);
+
+/**
+ *  Destroy a semaphore.
+ */
+extern DECLSPEC void SDLCALL SDL_DestroySemaphore(SDL_sem * sem);
+
+/**
+ *  This function suspends the calling thread until the semaphore pointed 
+ *  to by \c sem has a positive count. It then atomically decreases the 
+ *  semaphore count.
+ */
+extern DECLSPEC int SDLCALL SDL_SemWait(SDL_sem * sem);
+
+/**
+ *  Non-blocking variant of SDL_SemWait().
+ *  
+ *  \return 0 if the wait succeeds, ::SDL_MUTEX_TIMEDOUT if the wait would 
+ *          block, and -1 on error.
+ */
+extern DECLSPEC int SDLCALL SDL_SemTryWait(SDL_sem * sem);
+
+/**
+ *  Variant of SDL_SemWait() with a timeout in milliseconds.
+ *  
+ *  \return 0 if the wait succeeds, ::SDL_MUTEX_TIMEDOUT if the wait does not 
+ *          succeed in the allotted time, and -1 on error.
+ *  
+ *  \warning On some platforms this function is implemented by looping with a 
+ *           delay of 1 ms, and so should be avoided if possible.
+ */
+extern DECLSPEC int SDLCALL SDL_SemWaitTimeout(SDL_sem * sem, Uint32 ms);
+
+/**
+ *  Atomically increases the semaphore's count (not blocking).
+ *  
+ *  \return 0, or -1 on error.
+ */
+extern DECLSPEC int SDLCALL SDL_SemPost(SDL_sem * sem);
+
+/**
+ *  Returns the current count of the semaphore.
+ */
+extern DECLSPEC Uint32 SDLCALL SDL_SemValue(SDL_sem * sem);
+
+/*@}*//*Semaphore functions*/
+
+
+/**
+ *  \name Condition variable functions
+ */
+/*@{*/
+
+/* The SDL condition variable structure, defined in SDL_cond.c */
+struct SDL_cond;
+typedef struct SDL_cond SDL_cond;
+
+/**
+ *  Create a condition variable.
+ */
+extern DECLSPEC SDL_cond *SDLCALL SDL_CreateCond(void);
+
+/**
+ *  Destroy a condition variable.
+ */
+extern DECLSPEC void SDLCALL SDL_DestroyCond(SDL_cond * cond);
+
+/**
+ *  Restart one of the threads that are waiting on the condition variable.
+ *  
+ *  \return 0 or -1 on error.
+ */
+extern DECLSPEC int SDLCALL SDL_CondSignal(SDL_cond * cond);
+
+/**
+ *  Restart all threads that are waiting on the condition variable.
+ *  \return 0 or -1 on error.
+ */
+extern DECLSPEC int SDLCALL SDL_CondBroadcast(SDL_cond * cond);
+
+/**
+ *  Wait on the condition variable, unlocking the provided mutex.
+ *  
+ *  \warning The mutex must be locked before entering this function!
+ *  
+ *  The mutex is re-locked once the condition variable is signaled.
+ *  
+ *  \return 0 when it is signaled, or -1 on error.
+ */
+extern DECLSPEC int SDLCALL SDL_CondWait(SDL_cond * cond, SDL_mutex * mutex);
+
+/**
+ *  Waits for at most \c ms milliseconds, and returns 0 if the condition
+ *  variable is signaled, ::SDL_MUTEX_TIMEDOUT if the condition is not
+ *  signaled in the allotted time, and -1 on error.
+ *
+ *  \warning On some platforms this function is implemented by looping with a 
+ *           delay of 1 ms, and so should be avoided if possible.
+ */
+extern DECLSPEC int SDLCALL SDL_CondWaitTimeout(SDL_cond * cond,
+                                                SDL_mutex * mutex, Uint32 ms);
+
+/*@}*//*Condition variable functions*/
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+}
+/* *INDENT-ON* */
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_mutex_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/include/SDL_platform.h b/macosx/plugins/Common/SDL/include/SDL_platform.h
new file mode 100644
index 00000000..f9429bde
--- /dev/null
+++ b/macosx/plugins/Common/SDL/include/SDL_platform.h
@@ -0,0 +1,154 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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
+*/
+
+/**
+ *  \file SDL_platform.h
+ *  
+ *  Try to get a standard set of platform defines.
+ */
+
+#ifndef _SDL_platform_h
+#define _SDL_platform_h
+
+#if defined(_AIX)
+#undef __AIX__
+#define __AIX__		1
+#endif
+#if defined(__BEOS__)
+#undef __BEOS__
+#define __BEOS__	1
+#endif
+#if defined(__HAIKU__)
+#undef __HAIKU__
+#define __HAIKU__	1
+#endif
+#if defined(bsdi) || defined(__bsdi) || defined(__bsdi__)
+#undef __BSDI__
+#define __BSDI__	1
+#endif
+#if defined(_arch_dreamcast)
+#undef __DREAMCAST__
+#define __DREAMCAST__	1
+#endif
+#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
+#undef __FREEBSD__
+#define __FREEBSD__	1
+#endif
+#if defined(hpux) || defined(__hpux) || defined(__hpux__)
+#undef __HPUX__
+#define __HPUX__	1
+#endif
+#if defined(sgi) || defined(__sgi) || defined(__sgi__) || defined(_SGI_SOURCE)
+#undef __IRIX__
+#define __IRIX__	1
+#endif
+#if defined(linux) || defined(__linux) || defined(__linux__)
+#undef __LINUX__
+#define __LINUX__	1
+#endif
+
+#if defined(__APPLE__)
+/* lets us know what version of Mac OS X we're compiling on */
+#include "AvailabilityMacros.h"
+#ifdef MAC_OS_X_VERSION_10_3
+#include "TargetConditionals.h" /* this header is in 10.3 or later */
+#if TARGET_OS_IPHONE
+/* if compiling for iPhone */
+#undef __IPHONEOS__
+#define __IPHONEOS__ 1
+#undef __MACOSX__
+#else
+/* if not compiling for iPhone */
+#undef __MACOSX__
+#define __MACOSX__	1
+#endif /* TARGET_OS_IPHONE */
+#else
+/* if earlier verion of Mac OS X than version 10.3 */
+#undef __MACOSX__
+#define __MACOSX__	1
+#endif
+
+#endif /* defined(__APPLE__) */
+
+#if defined(__NetBSD__)
+#undef __NETBSD__
+#define __NETBSD__	1
+#endif
+#if defined(__OpenBSD__)
+#undef __OPENBSD__
+#define __OPENBSD__	1
+#endif
+#if defined(__OS2__)
+#undef __OS2__
+#define __OS2__		1
+#endif
+#if defined(osf) || defined(__osf) || defined(__osf__) || defined(_OSF_SOURCE)
+#undef __OSF__
+#define __OSF__		1
+#endif
+#if defined(__QNXNTO__)
+#undef __QNXNTO__
+#define __QNXNTO__	1
+#endif
+#if defined(riscos) || defined(__riscos) || defined(__riscos__)
+#undef __RISCOS__
+#define __RISCOS__	1
+#endif
+#if defined(__SVR4)
+#undef __SOLARIS__
+#define __SOLARIS__	1
+#endif
+#if defined(WIN32) || defined(_WIN32)
+#undef __WIN32__
+#define __WIN32__	1
+#endif
+
+#if defined(__NDS__)
+#undef __NINTENDODS__
+#define __NINTENDODS__	1
+#endif
+
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+extern "C" {
+/* *INDENT-ON* */
+#endif
+
+/**
+ *  \brief Gets the name of the platform.
+ */
+extern DECLSPEC const char * SDLCALL SDL_GetPlatform (void);
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+}
+/* *INDENT-ON* */
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_platform_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/include/SDL_rwops.h b/macosx/plugins/Common/SDL/include/SDL_rwops.h
new file mode 100644
index 00000000..b4dfa81f
--- /dev/null
+++ b/macosx/plugins/Common/SDL/include/SDL_rwops.h
@@ -0,0 +1,206 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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
+*/
+
+/**
+ *  \file SDL_rwops.h
+ *  
+ *  This file provides a general interface for SDL to read and write
+ *  data sources.  It can easily be extended to files, memory, etc.
+ */
+
+#ifndef _SDL_rwops_h
+#define _SDL_rwops_h
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+extern "C" {
+/* *INDENT-ON* */
+#endif
+
+/**
+ * This is the read/write operation structure -- very basic.
+ */
+typedef struct SDL_RWops
+{
+    /**
+     *  Seek to \c offset relative to \c whence, one of stdio's whence values:
+     *  RW_SEEK_SET, RW_SEEK_CUR, RW_SEEK_END
+     *  
+     *  \return the final offset in the data source.
+     */
+    long (SDLCALL * seek) (struct SDL_RWops * context, long offset,
+                           int whence);
+
+    /**
+     *  Read up to \c maxnum objects each of size \c size from the data
+     *  source to the area pointed at by \c ptr.
+     *  
+     *  \return the number of objects read, or 0 at error or end of file.
+     */
+    size_t(SDLCALL * read) (struct SDL_RWops * context, void *ptr,
+                            size_t size, size_t maxnum);
+
+    /**
+     *  Write exactly \c num objects each of size \c size from the area
+     *  pointed at by \c ptr to data source.
+     *  
+     *  \return the number of objects written, or 0 at error or end of file.
+     */
+    size_t(SDLCALL * write) (struct SDL_RWops * context, const void *ptr,
+                             size_t size, size_t num);
+
+    /**
+     *  Close and free an allocated SDL_RWops structure.
+     *  
+     *  \return 0 if successful or -1 on write error when flushing data.
+     */
+    int (SDLCALL * close) (struct SDL_RWops * context);
+
+    Uint32 type;
+    union
+    {
+#ifdef __WIN32__
+        struct
+        {
+            SDL_bool append;
+            void *h;
+            struct
+            {
+                void *data;
+                size_t size;
+                size_t left;
+            } buffer;
+        } win32io;
+#endif
+#ifdef HAVE_STDIO_H
+        struct
+        {
+            SDL_bool autoclose;
+            FILE *fp;
+        } stdio;
+#endif
+        struct
+        {
+            Uint8 *base;
+            Uint8 *here;
+            Uint8 *stop;
+        } mem;
+        struct
+        {
+            void *data1;
+        } unknown;
+    } hidden;
+
+} SDL_RWops;
+
+
+/**
+ *  \name RWFrom functions
+ *  
+ *  Functions to create SDL_RWops structures from various data sources.
+ */
+/*@{*/
+
+extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromFile(const char *file,
+                                                  const char *mode);
+
+#ifdef HAVE_STDIO_H
+extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromFP(FILE * fp,
+                                                SDL_bool autoclose);
+#else
+extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromFP(void * fp,
+                                                SDL_bool autoclose);
+#endif
+
+extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromMem(void *mem, int size);
+extern DECLSPEC SDL_RWops *SDLCALL SDL_RWFromConstMem(const void *mem,
+                                                      int size);
+
+/*@}*//*RWFrom functions*/
+
+
+extern DECLSPEC SDL_RWops *SDLCALL SDL_AllocRW(void);
+extern DECLSPEC void SDLCALL SDL_FreeRW(SDL_RWops * area);
+
+#define RW_SEEK_SET	0       /**< Seek from the beginning of data */
+#define RW_SEEK_CUR	1       /**< Seek relative to current read point */
+#define RW_SEEK_END	2       /**< Seek relative to the end of data */
+
+/**
+ *  \name Read/write macros
+ *  
+ *  Macros to easily read and write from an SDL_RWops structure.
+ */
+/*@{*/
+#define SDL_RWseek(ctx, offset, whence)	(ctx)->seek(ctx, offset, whence)
+#define SDL_RWtell(ctx)			(ctx)->seek(ctx, 0, RW_SEEK_CUR)
+#define SDL_RWread(ctx, ptr, size, n)	(ctx)->read(ctx, ptr, size, n)
+#define SDL_RWwrite(ctx, ptr, size, n)	(ctx)->write(ctx, ptr, size, n)
+#define SDL_RWclose(ctx)		(ctx)->close(ctx)
+/*@}*//*Read/write macros*/
+
+
+/** 
+ *  \name Read endian functions
+ *  
+ *  Read an item of the specified endianness and return in native format.
+ */
+/*@{*/
+extern DECLSPEC Uint16 SDLCALL SDL_ReadLE16(SDL_RWops * src);
+extern DECLSPEC Uint16 SDLCALL SDL_ReadBE16(SDL_RWops * src);
+extern DECLSPEC Uint32 SDLCALL SDL_ReadLE32(SDL_RWops * src);
+extern DECLSPEC Uint32 SDLCALL SDL_ReadBE32(SDL_RWops * src);
+extern DECLSPEC Uint64 SDLCALL SDL_ReadLE64(SDL_RWops * src);
+extern DECLSPEC Uint64 SDLCALL SDL_ReadBE64(SDL_RWops * src);
+/*@}*//*Read endian functions*/
+
+/** 
+ *  \name Write endian functions
+ *  
+ *  Write an item of native format to the specified endianness.
+ */
+/*@{*/
+extern DECLSPEC size_t SDLCALL SDL_WriteLE16(SDL_RWops * dst, Uint16 value);
+extern DECLSPEC size_t SDLCALL SDL_WriteBE16(SDL_RWops * dst, Uint16 value);
+extern DECLSPEC size_t SDLCALL SDL_WriteLE32(SDL_RWops * dst, Uint32 value);
+extern DECLSPEC size_t SDLCALL SDL_WriteBE32(SDL_RWops * dst, Uint32 value);
+extern DECLSPEC size_t SDLCALL SDL_WriteLE64(SDL_RWops * dst, Uint64 value);
+extern DECLSPEC size_t SDLCALL SDL_WriteBE64(SDL_RWops * dst, Uint64 value);
+/*@}*//*Write endian functions*/
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+}
+/* *INDENT-ON* */
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_rwops_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/include/SDL_stdinc.h b/macosx/plugins/Common/SDL/include/SDL_stdinc.h
new file mode 100644
index 00000000..ba1e5b5b
--- /dev/null
+++ b/macosx/plugins/Common/SDL/include/SDL_stdinc.h
@@ -0,0 +1,792 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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
+*/
+
+/**
+ *  \file SDL_stdinc.h
+ *  
+ *  This is a general header that includes C language support.
+ */
+
+#ifndef _SDL_stdinc_h
+#define _SDL_stdinc_h
+
+#include "SDL_config.h"
+
+
+#ifdef HAVE_SYS_TYPES_H
+#include <sys/types.h>
+#endif
+#ifdef HAVE_STDIO_H
+#include <stdio.h>
+#endif
+#if defined(STDC_HEADERS)
+# include <stdlib.h>
+# include <stddef.h>
+# include <stdarg.h>
+#else
+# if defined(HAVE_STDLIB_H)
+#  include <stdlib.h>
+# elif defined(HAVE_MALLOC_H)
+#  include <malloc.h>
+# endif
+# if defined(HAVE_STDDEF_H)
+#  include <stddef.h>
+# endif
+# if defined(HAVE_STDARG_H)
+#  include <stdarg.h>
+# endif
+#endif
+#ifdef HAVE_STRING_H
+# if !defined(STDC_HEADERS) && defined(HAVE_MEMORY_H)
+#  include <memory.h>
+# endif
+# include <string.h>
+#endif
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#if defined(HAVE_INTTYPES_H)
+# include <inttypes.h>
+#elif defined(HAVE_STDINT_H)
+# include <stdint.h>
+#endif
+#ifdef HAVE_CTYPE_H
+# include <ctype.h>
+#endif
+#ifdef HAVE_MATH_H
+# include <math.h>
+#endif
+#if defined(HAVE_ICONV) && defined(HAVE_ICONV_H)
+# include <iconv.h>
+#endif
+
+/**
+ *  The number of elements in an array.
+ */
+#define SDL_arraysize(array)	(sizeof(array)/sizeof(array[0]))
+#define SDL_TABLESIZE(table)	SDL_arraysize(table)
+
+/**
+ *  \name Cast operators
+ *  
+ *  Use proper C++ casts when compiled as C++ to be compatible with the option
+ *  -Wold-style-cast of GCC (and -Werror=old-style-cast in GCC 4.2 and above).
+ */
+/*@{*/
+#ifdef __cplusplus
+#define SDL_reinterpret_cast(type, expression) reinterpret_cast<type>(expression)
+#define SDL_static_cast(type, expression) static_cast<type>(expression)
+#else
+#define SDL_reinterpret_cast(type, expression) ((type)(expression))
+#define SDL_static_cast(type, expression) ((type)(expression))
+#endif
+/*@}*//*Cast operators*/
+
+/* Define a four character code as a Uint32 */
+#define SDL_FOURCC(A, B, C, D) \
+    ((SDL_static_cast(Uint32, SDL_static_cast(Uint8, (A))) << 0) | \
+     (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (B))) << 8) | \
+     (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (C))) << 16) | \
+     (SDL_static_cast(Uint32, SDL_static_cast(Uint8, (D))) << 24))
+
+/**
+ *  \name Basic data types
+ */
+/*@{*/
+
+typedef enum
+{
+    SDL_FALSE = 0,
+    SDL_TRUE = 1
+} SDL_bool;
+
+/**
+ * \brief A signed 8-bit integer type.
+ */
+typedef int8_t Sint8;
+/**
+ * \brief An unsigned 8-bit integer type.
+ */
+typedef uint8_t Uint8;
+/**
+ * \brief A signed 16-bit integer type.
+ */
+typedef int16_t Sint16;
+/**
+ * \brief An unsigned 16-bit integer type.
+ */
+typedef uint16_t Uint16;
+/**
+ * \brief A signed 32-bit integer type.
+ */
+typedef int32_t Sint32;
+/**
+ * \brief An unsigned 32-bit integer type.
+ */
+typedef uint32_t Uint32;
+
+#ifdef SDL_HAS_64BIT_TYPE
+/**
+ * \brief A signed 64-bit integer type.
+ * \warning On platforms without any sort of 64-bit datatype, this is equivalent to Sint32!
+ */
+typedef int64_t Sint64;
+/**
+ * \brief An unsigned 64-bit integer type.
+ * \warning On platforms without any sort of 64-bit datatype, this is equivalent to Uint32!
+ */
+typedef uint64_t Uint64;
+#else
+/* This is really just a hack to prevent the compiler from complaining */
+typedef Sint32 Sint64;
+typedef Uint32 Uint64;
+#endif
+
+/*@}*//*Basic data types*/
+
+
+#define SDL_COMPILE_TIME_ASSERT(name, x)               \
+       typedef int SDL_dummy_ ## name[(x) * 2 - 1]
+/** \cond */
+#ifndef DOXYGEN_SHOULD_IGNORE_THIS
+SDL_COMPILE_TIME_ASSERT(uint8, sizeof(Uint8) == 1);
+SDL_COMPILE_TIME_ASSERT(sint8, sizeof(Sint8) == 1);
+SDL_COMPILE_TIME_ASSERT(uint16, sizeof(Uint16) == 2);
+SDL_COMPILE_TIME_ASSERT(sint16, sizeof(Sint16) == 2);
+SDL_COMPILE_TIME_ASSERT(uint32, sizeof(Uint32) == 4);
+SDL_COMPILE_TIME_ASSERT(sint32, sizeof(Sint32) == 4);
+#ifndef __NINTENDODS__          /* TODO: figure out why the following happens:
+                                   include/SDL_stdinc.h:150: error: size of array 'SDL_dummy_uint64' is negative
+                                   include/SDL_stdinc.h:151: error: size of array 'SDL_dummy_sint64' is negative */
+SDL_COMPILE_TIME_ASSERT(uint64, sizeof(Uint64) == 8);
+SDL_COMPILE_TIME_ASSERT(sint64, sizeof(Sint64) == 8);
+#endif
+#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
+/** \endcond */
+
+/* Check to make sure enums are the size of ints, for structure packing.
+   For both Watcom C/C++ and Borland C/C++ the compiler option that makes
+   enums having the size of an int must be enabled.
+   This is "-b" for Borland C/C++ and "-ei" for Watcom C/C++ (v11).
+*/
+/* Enable enums always int in CodeWarrior (for MPW use "-enum int") */
+#ifdef __MWERKS__
+#pragma enumsalwaysint on
+#endif
+
+/** \cond */
+#ifndef DOXYGEN_SHOULD_IGNORE_THIS
+#ifndef __NINTENDODS__          /* TODO: include/SDL_stdinc.h:174: error: size of array 'SDL_dummy_enum' is negative */
+typedef enum
+{
+    DUMMY_ENUM_VALUE
+} SDL_DUMMY_ENUM;
+
+SDL_COMPILE_TIME_ASSERT(enum, sizeof(SDL_DUMMY_ENUM) == sizeof(int));
+#endif
+#endif /* DOXYGEN_SHOULD_IGNORE_THIS */
+/** \endcond */
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+extern "C" {
+/* *INDENT-ON* */
+#endif
+
+#ifdef HAVE_MALLOC
+#define SDL_malloc	malloc
+#else
+extern DECLSPEC void *SDLCALL SDL_malloc(size_t size);
+#endif
+
+#ifdef HAVE_CALLOC
+#define SDL_calloc	calloc
+#else
+extern DECLSPEC void *SDLCALL SDL_calloc(size_t nmemb, size_t size);
+#endif
+
+#ifdef HAVE_REALLOC
+#define SDL_realloc	realloc
+#else
+extern DECLSPEC void *SDLCALL SDL_realloc(void *mem, size_t size);
+#endif
+
+#ifdef HAVE_FREE
+#define SDL_free	free
+#else
+extern DECLSPEC void SDLCALL SDL_free(void *mem);
+#endif
+
+#if defined(HAVE_ALLOCA) && !defined(alloca)
+# if defined(HAVE_ALLOCA_H)
+#  include <alloca.h>
+# elif defined(__GNUC__)
+#  define alloca __builtin_alloca
+# elif defined(_MSC_VER)
+#  include <malloc.h>
+#  define alloca _alloca
+# elif defined(__WATCOMC__)
+#  include <malloc.h>
+# elif defined(__BORLANDC__)
+#  include <malloc.h>
+# elif defined(__DMC__)
+#  include <stdlib.h>
+# elif defined(__AIX__)
+#pragma alloca
+# elif defined(__MRC__)
+void *alloca(unsigned);
+# else
+char *alloca();
+# endif
+#endif
+#ifdef HAVE_ALLOCA
+#define SDL_stack_alloc(type, count)    (type*)alloca(sizeof(type)*(count))
+#define SDL_stack_free(data)
+#else
+#define SDL_stack_alloc(type, count)    (type*)SDL_malloc(sizeof(type)*(count))
+#define SDL_stack_free(data)            SDL_free(data)
+#endif
+
+#ifdef HAVE_GETENV
+#define SDL_getenv	getenv
+#else
+extern DECLSPEC char *SDLCALL SDL_getenv(const char *name);
+#endif
+
+/* SDL_putenv() has moved to SDL_compat. */
+#ifdef HAVE_SETENV
+#define SDL_setenv	setenv
+#else
+extern DECLSPEC int SDLCALL SDL_setenv(const char *name, const char *value,
+                                       int overwrite);
+#endif
+
+#ifdef HAVE_QSORT
+#define SDL_qsort	qsort
+#else
+extern DECLSPEC void SDLCALL SDL_qsort(void *base, size_t nmemb, size_t size,
+                                       int (*compare) (const void *,
+                                                       const void *));
+#endif
+
+#ifdef HAVE_ABS
+#define SDL_abs		abs
+#else
+#define SDL_abs(X)	((X) < 0 ? -(X) : (X))
+#endif
+
+#define SDL_min(x, y)	(((x) < (y)) ? (x) : (y))
+#define SDL_max(x, y)	(((x) > (y)) ? (x) : (y))
+
+#ifdef HAVE_CTYPE_H
+#define SDL_isdigit(X)  isdigit(X)
+#define SDL_isspace(X)  isspace(X)
+#define SDL_toupper(X)  toupper(X)
+#define SDL_tolower(X)  tolower(X)
+#else
+#define SDL_isdigit(X)  (((X) >= '0') && ((X) <= '9'))
+#define SDL_isspace(X)  (((X) == ' ') || ((X) == '\t') || ((X) == '\r') || ((X) == '\n'))
+#define SDL_toupper(X)  (((X) >= 'a') && ((X) <= 'z') ? ('A'+((X)-'a')) : (X))
+#define SDL_tolower(X)  (((X) >= 'A') && ((X) <= 'Z') ? ('a'+((X)-'A')) : (X))
+#endif
+
+#ifdef HAVE_MEMSET
+#define SDL_memset      memset
+#else
+extern DECLSPEC void *SDLCALL SDL_memset(void *dst, int c, size_t len);
+#endif
+#define SDL_zero(x)	SDL_memset(&(x), 0, sizeof((x)))
+#define SDL_zerop(x)	SDL_memset((x), 0, sizeof(*(x)))
+
+#if defined(__GNUC__) && defined(i386)
+#define SDL_memset4(dst, val, len)				\
+do {								\
+	int u0, u1, u2;						\
+	__asm__ __volatile__ (					\
+		"cld\n\t"					\
+		"rep ; stosl\n\t"				\
+		: "=&D" (u0), "=&a" (u1), "=&c" (u2)		\
+		: "0" (dst), "1" (val), "2" (SDL_static_cast(Uint32, len))	\
+		: "memory" );					\
+} while(0)
+#endif
+#ifndef SDL_memset4
+#define SDL_memset4(dst, val, len)		\
+do {						\
+	unsigned _count = (len);		\
+	unsigned _n = (_count + 3) / 4;		\
+	Uint32 *_p = SDL_static_cast(Uint32 *, dst);		\
+	Uint32 _val = (val);			\
+	if (len == 0) break;			\
+        switch (_count % 4) {			\
+        case 0: do {    *_p++ = _val;		\
+        case 3:         *_p++ = _val;		\
+        case 2:         *_p++ = _val;		\
+        case 1:         *_p++ = _val;		\
+		} while ( --_n );		\
+	}					\
+} while(0)
+#endif
+
+/* We can count on memcpy existing on Mac OS X and being well-tuned. */
+#if defined(__MACH__) && defined(__APPLE__)
+#define SDL_memcpy(dst, src, len) memcpy(dst, src, len)
+#elif defined(__GNUC__) && defined(i386)
+#define SDL_memcpy(dst, src, len)					  \
+do {									  \
+	int u0, u1, u2;						  	  \
+	__asm__ __volatile__ (						  \
+		"cld\n\t"						  \
+		"rep ; movsl\n\t"					  \
+		"testb $2,%b4\n\t"					  \
+		"je 1f\n\t"						  \
+		"movsw\n"						  \
+		"1:\ttestb $1,%b4\n\t"					  \
+		"je 2f\n\t"						  \
+		"movsb\n"						  \
+		"2:"							  \
+		: "=&c" (u0), "=&D" (u1), "=&S" (u2)			  \
+		: "0" (SDL_static_cast(unsigned, len)/4), "q" (len), "1" (dst),"2" (src) \
+		: "memory" );						  \
+} while(0)
+#endif
+#ifndef SDL_memcpy
+#ifdef HAVE_MEMCPY
+#define SDL_memcpy      memcpy
+#elif defined(HAVE_BCOPY)
+#define SDL_memcpy(d, s, n)	bcopy((s), (d), (n))
+#else
+extern DECLSPEC void *SDLCALL SDL_memcpy(void *dst, const void *src,
+                                         size_t len);
+#endif
+#endif
+
+/* We can count on memcpy existing on Mac OS X and being well-tuned. */
+#if defined(__MACH__) && defined(__APPLE__)
+#define SDL_memcpy4(dst, src, len) memcpy(dst, src, (len)*4)
+#elif defined(__GNUC__) && defined(i386)
+#define SDL_memcpy4(dst, src, len)				\
+do {								\
+	int ecx, edi, esi;					\
+	__asm__ __volatile__ (					\
+		"cld\n\t"					\
+		"rep ; movsl"					\
+		: "=&c" (ecx), "=&D" (edi), "=&S" (esi)		\
+		: "0" (SDL_static_cast(unsigned, len)), "1" (dst), "2" (src)	\
+		: "memory" );					\
+} while(0)
+#endif
+#ifndef SDL_memcpy4
+#define SDL_memcpy4(dst, src, len)	SDL_memcpy(dst, src, (len) << 2)
+#endif
+
+#if defined(__GNUC__) && defined(i386)
+#define SDL_revcpy(dst, src, len)			\
+do {							\
+	int u0, u1, u2;					\
+	char *dstp = SDL_static_cast(char *, dst);			\
+	char *srcp = SDL_static_cast(char *, src);			\
+	int n = (len);					\
+	if ( n >= 4 ) {					\
+	__asm__ __volatile__ (				\
+		"std\n\t"				\
+		"rep ; movsl\n\t"			\
+		"cld\n\t"				\
+		: "=&c" (u0), "=&D" (u1), "=&S" (u2)	\
+		: "0" (n >> 2),				\
+		  "1" (dstp+(n-4)), "2" (srcp+(n-4))	\
+		: "memory" );				\
+	}						\
+	switch (n & 3) {				\
+		case 3: dstp[2] = srcp[2];		\
+		case 2: dstp[1] = srcp[1];		\
+		case 1: dstp[0] = srcp[0];		\
+			break;				\
+		default:				\
+			break;				\
+	}						\
+} while(0)
+#endif
+#ifndef SDL_revcpy
+extern DECLSPEC void *SDLCALL SDL_revcpy(void *dst, const void *src,
+                                         size_t len);
+#endif
+
+#ifdef HAVE_MEMMOVE
+#define SDL_memmove     memmove
+#elif defined(HAVE_BCOPY)
+#define SDL_memmove(d, s, n)	bcopy((s), (d), (n))
+#else
+#define SDL_memmove(dst, src, len)			\
+do {							\
+	if ( dst < src ) {				\
+		SDL_memcpy(dst, src, len);		\
+	} else {					\
+		SDL_revcpy(dst, src, len);		\
+	}						\
+} while(0)
+#endif
+
+#ifdef HAVE_MEMCMP
+#define SDL_memcmp      memcmp
+#else
+extern DECLSPEC int SDLCALL SDL_memcmp(const void *s1, const void *s2,
+                                       size_t len);
+#endif
+
+#ifdef HAVE_STRLEN
+#define SDL_strlen      strlen
+#else
+extern DECLSPEC size_t SDLCALL SDL_strlen(const char *string);
+#endif
+
+#ifdef HAVE_WCSLEN
+#define SDL_wcslen      wcslen
+#else
+#if !defined(wchar_t) && defined(__NINTENDODS__)
+#define wchar_t short           /* TODO: figure out why libnds doesn't have this */
+#endif
+extern DECLSPEC size_t SDLCALL SDL_wcslen(const wchar_t * string);
+#endif
+
+#ifdef HAVE_STRLCPY
+#define SDL_strlcpy     strlcpy
+#else
+extern DECLSPEC size_t SDLCALL SDL_strlcpy(char *dst, const char *src,
+                                           size_t maxlen);
+#endif
+
+#ifdef HAVE_STRLCAT
+#define SDL_strlcat    strlcat
+#else
+extern DECLSPEC size_t SDLCALL SDL_strlcat(char *dst, const char *src,
+                                           size_t maxlen);
+#endif
+
+#ifdef HAVE_STRDUP
+#define SDL_strdup     strdup
+#else
+extern DECLSPEC char *SDLCALL SDL_strdup(const char *string);
+#endif
+
+#ifdef HAVE__STRREV
+#define SDL_strrev      _strrev
+#else
+extern DECLSPEC char *SDLCALL SDL_strrev(char *string);
+#endif
+
+#ifdef HAVE__STRUPR
+#define SDL_strupr      _strupr
+#else
+extern DECLSPEC char *SDLCALL SDL_strupr(char *string);
+#endif
+
+#ifdef HAVE__STRLWR
+#define SDL_strlwr      _strlwr
+#else
+extern DECLSPEC char *SDLCALL SDL_strlwr(char *string);
+#endif
+
+#ifdef HAVE_STRCHR
+#define SDL_strchr      strchr
+#elif defined(HAVE_INDEX)
+#define SDL_strchr      index
+#else
+extern DECLSPEC char *SDLCALL SDL_strchr(const char *string, int c);
+#endif
+
+#ifdef HAVE_STRRCHR
+#define SDL_strrchr     strrchr
+#elif defined(HAVE_RINDEX)
+#define SDL_strrchr     rindex
+#else
+extern DECLSPEC char *SDLCALL SDL_strrchr(const char *string, int c);
+#endif
+
+#ifdef HAVE_STRSTR
+#define SDL_strstr      strstr
+#else
+extern DECLSPEC char *SDLCALL SDL_strstr(const char *haystack,
+                                         const char *needle);
+#endif
+
+#ifdef HAVE_ITOA
+#define SDL_itoa        itoa
+#else
+#define SDL_itoa(value, string, radix)	SDL_ltoa((long)value, string, radix)
+#endif
+
+#ifdef HAVE__LTOA
+#define SDL_ltoa        _ltoa
+#else
+extern DECLSPEC char *SDLCALL SDL_ltoa(long value, char *string, int radix);
+#endif
+
+#ifdef HAVE__UITOA
+#define SDL_uitoa       _uitoa
+#else
+#define SDL_uitoa(value, string, radix)	SDL_ultoa((long)value, string, radix)
+#endif
+
+#ifdef HAVE__ULTOA
+#define SDL_ultoa       _ultoa
+#else
+extern DECLSPEC char *SDLCALL SDL_ultoa(unsigned long value, char *string,
+                                        int radix);
+#endif
+
+#ifdef HAVE_STRTOL
+#define SDL_strtol      strtol
+#else
+extern DECLSPEC long SDLCALL SDL_strtol(const char *string, char **endp,
+                                        int base);
+#endif
+
+#ifdef HAVE_STRTOUL
+#define SDL_strtoul      strtoul
+#else
+extern DECLSPEC unsigned long SDLCALL SDL_strtoul(const char *string,
+                                                  char **endp, int base);
+#endif
+
+#ifdef SDL_HAS_64BIT_TYPE
+
+#ifdef HAVE__I64TOA
+#define SDL_lltoa       _i64toa
+#else
+extern DECLSPEC char *SDLCALL SDL_lltoa(Sint64 value, char *string,
+                                        int radix);
+#endif
+
+#ifdef HAVE__UI64TOA
+#define SDL_ulltoa      _ui64toa
+#else
+extern DECLSPEC char *SDLCALL SDL_ulltoa(Uint64 value, char *string,
+                                         int radix);
+#endif
+
+#ifdef HAVE_STRTOLL
+#define SDL_strtoll     strtoll
+#else
+extern DECLSPEC Sint64 SDLCALL SDL_strtoll(const char *string, char **endp,
+                                           int base);
+#endif
+
+#ifdef HAVE_STRTOULL
+#define SDL_strtoull     strtoull
+#else
+extern DECLSPEC Uint64 SDLCALL SDL_strtoull(const char *string, char **endp,
+                                            int base);
+#endif
+
+#endif /* SDL_HAS_64BIT_TYPE */
+
+#ifdef HAVE_STRTOD
+#define SDL_strtod      strtod
+#else
+extern DECLSPEC double SDLCALL SDL_strtod(const char *string, char **endp);
+#endif
+
+#ifdef HAVE_ATOI
+#define SDL_atoi        atoi
+#else
+#define SDL_atoi(X)     SDL_strtol(X, NULL, 0)
+#endif
+
+#ifdef HAVE_ATOF
+#define SDL_atof        atof
+#else
+#define SDL_atof(X)     SDL_strtod(X, NULL)
+#endif
+
+#ifdef HAVE_STRCMP
+#define SDL_strcmp      strcmp
+#else
+extern DECLSPEC int SDLCALL SDL_strcmp(const char *str1, const char *str2);
+#endif
+
+#ifdef HAVE_STRNCMP
+#define SDL_strncmp     strncmp
+#else
+extern DECLSPEC int SDLCALL SDL_strncmp(const char *str1, const char *str2,
+                                        size_t maxlen);
+#endif
+
+#ifdef HAVE_STRCASECMP
+#define SDL_strcasecmp  strcasecmp
+#elif defined(HAVE__STRICMP)
+#define SDL_strcasecmp  _stricmp
+#else
+extern DECLSPEC int SDLCALL SDL_strcasecmp(const char *str1,
+                                           const char *str2);
+#endif
+
+#ifdef HAVE_STRNCASECMP
+#define SDL_strncasecmp strncasecmp
+#elif defined(HAVE__STRNICMP)
+#define SDL_strncasecmp _strnicmp
+#else
+extern DECLSPEC int SDLCALL SDL_strncasecmp(const char *str1,
+                                            const char *str2, size_t maxlen);
+#endif
+
+#ifdef HAVE_SSCANF
+#define SDL_sscanf      sscanf
+#else
+extern DECLSPEC int SDLCALL SDL_sscanf(const char *text, const char *fmt,
+                                       ...);
+#endif
+
+#ifdef HAVE_SNPRINTF
+#define SDL_snprintf    snprintf
+#else
+extern DECLSPEC int SDLCALL SDL_snprintf(char *text, size_t maxlen,
+                                         const char *fmt, ...);
+#endif
+
+#ifdef HAVE_VSNPRINTF
+#define SDL_vsnprintf   vsnprintf
+#else
+extern DECLSPEC int SDLCALL SDL_vsnprintf(char *text, size_t maxlen,
+                                          const char *fmt, va_list ap);
+#endif
+
+#ifndef HAVE_M_PI
+#define M_PI    3.14159265358979323846264338327950288   /* pi */
+#endif
+
+#ifdef HAVE_CEIL
+#define SDL_ceil        ceil
+#else
+#define SDL_ceil(x)     ((double)(int)((x)+0.5))
+#endif
+
+#ifdef HAVE_COPYSIGN
+#define SDL_copysign    copysign
+#else
+extern DECLSPEC double SDLCALL SDL_copysign(double x, double y);
+#endif
+
+#ifdef HAVE_COS
+#define SDL_cos         cos
+#else
+extern DECLSPEC double SDLCALL SDL_cos(double x);
+#endif
+
+#ifdef HAVE_COSF
+#define SDL_cosf        cosf
+#else
+#define SDL_cosf(x) (float)SDL_cos((double)x)
+#endif
+
+#ifdef HAVE_FABS
+#define SDL_fabs        fabs
+#else
+extern DECLSPEC double SDLCALL SDL_fabs(double x);
+#endif
+
+#ifdef HAVE_FLOOR
+#define SDL_floor       floor
+#else
+extern DECLSPEC double SDLCALL SDL_floor(double x);
+#endif
+
+#ifdef HAVE_LOG
+#define SDL_log         log
+#else
+extern DECLSPEC double SDLCALL SDL_log(double x);
+#endif
+
+#ifdef HAVE_POW
+#define SDL_pow         pow
+#else
+extern DECLSPEC double SDLCALL SDL_pow(double x, double y);
+#endif
+
+#ifdef HAVE_SCALBN
+#define SDL_scalbn      scalbn
+#else
+extern DECLSPEC double SDLCALL SDL_scalbn(double x, int n);
+#endif
+
+#ifdef HAVE_SIN
+#define SDL_sin         sin
+#else
+extern DECLSPEC double SDLCALL SDL_sin(double x);
+#endif
+
+#ifdef HAVE_SINF
+#define SDL_sinf        sinf
+#else
+#define SDL_sinf(x) (float)SDL_sin((double)x)
+#endif
+
+#ifdef HAVE_SQRT
+#define SDL_sqrt        sqrt
+#else
+extern DECLSPEC double SDLCALL SDL_sqrt(double x);
+#endif
+
+/* The SDL implementation of iconv() returns these error codes */
+#define SDL_ICONV_ERROR		(size_t)-1
+#define SDL_ICONV_E2BIG		(size_t)-2
+#define SDL_ICONV_EILSEQ	(size_t)-3
+#define SDL_ICONV_EINVAL	(size_t)-4
+
+#if defined(HAVE_ICONV) && defined(HAVE_ICONV_H)
+#define SDL_iconv_t     iconv_t
+#define SDL_iconv_open  iconv_open
+#define SDL_iconv_close iconv_close
+#else
+typedef struct _SDL_iconv_t *SDL_iconv_t;
+extern DECLSPEC SDL_iconv_t SDLCALL SDL_iconv_open(const char *tocode,
+                                                   const char *fromcode);
+extern DECLSPEC int SDLCALL SDL_iconv_close(SDL_iconv_t cd);
+#endif
+extern DECLSPEC size_t SDLCALL SDL_iconv(SDL_iconv_t cd, const char **inbuf,
+                                         size_t * inbytesleft, char **outbuf,
+                                         size_t * outbytesleft);
+/**
+ *  This function converts a string between encodings in one pass, returning a
+ *  string that must be freed with SDL_free() or NULL on error.
+ */
+extern DECLSPEC char *SDLCALL SDL_iconv_string(const char *tocode,
+                                               const char *fromcode,
+                                               const char *inbuf,
+                                               size_t inbytesleft);
+#define SDL_iconv_utf8_locale(S)	SDL_iconv_string("", "UTF-8", S, SDL_strlen(S)+1)
+#define SDL_iconv_utf8_ucs2(S)		(Uint16 *)SDL_iconv_string("UCS-2", "UTF-8", S, SDL_strlen(S)+1)
+#define SDL_iconv_utf8_ucs4(S)		(Uint32 *)SDL_iconv_string("UCS-4", "UTF-8", S, SDL_strlen(S)+1)
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+}
+/* *INDENT-ON* */
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_stdinc_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/include/SDL_thread.h b/macosx/plugins/Common/SDL/include/SDL_thread.h
new file mode 100644
index 00000000..1c8a76a2
--- /dev/null
+++ b/macosx/plugins/Common/SDL/include/SDL_thread.h
@@ -0,0 +1,168 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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
+*/
+
+#ifndef _SDL_thread_h
+#define _SDL_thread_h
+
+/**
+ *  \file SDL_thread.h
+ *  
+ *  Header for the SDL thread management routines.
+ */
+
+#include "SDL_stdinc.h"
+#include "SDL_error.h"
+
+/* Thread synchronization primitives */
+#include "SDL_mutex.h"
+
+#include "begin_code.h"
+/* Set up for C function definitions, even when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+extern "C" {
+/* *INDENT-ON* */
+#endif
+
+/* The SDL thread structure, defined in SDL_thread.c */
+struct SDL_Thread;
+typedef struct SDL_Thread SDL_Thread;
+
+/* The SDL thread ID */
+typedef unsigned long SDL_threadID;
+
+/* The function passed to SDL_CreateThread()
+   It is passed a void* user context parameter and returns an int.
+ */
+typedef int (SDLCALL * SDL_ThreadFunction) (void *data);
+
+#if defined(__WIN32__) && !defined(HAVE_LIBC)
+/**
+ *  \file SDL_thread.h
+ *  
+ *  We compile SDL into a DLL. This means, that it's the DLL which
+ *  creates a new thread for the calling process with the SDL_CreateThread()
+ *  API. There is a problem with this, that only the RTL of the SDL.DLL will
+ *  be initialized for those threads, and not the RTL of the calling 
+ *  application!
+ *  
+ *  To solve this, we make a little hack here.
+ *  
+ *  We'll always use the caller's _beginthread() and _endthread() APIs to
+ *  start a new thread. This way, if it's the SDL.DLL which uses this API,
+ *  then the RTL of SDL.DLL will be used to create the new thread, and if it's
+ *  the application, then the RTL of the application will be used.
+ *  
+ *  So, in short:
+ *  Always use the _beginthread() and _endthread() of the calling runtime 
+ *  library!
+ */
+#define SDL_PASSED_BEGINTHREAD_ENDTHREAD
+#ifndef _WIN32_WCE
+#include <process.h>            /* This has _beginthread() and _endthread() defined! */
+#endif
+
+#ifdef __GNUC__
+typedef unsigned long (__cdecl * pfnSDL_CurrentBeginThread) (void *, unsigned,
+                                                             unsigned
+                                                             (__stdcall *
+                                                              func) (void *),
+                                                             void *arg,
+                                                             unsigned,
+                                                             unsigned
+                                                             *threadID);
+typedef void (__cdecl * pfnSDL_CurrentEndThread) (unsigned code);
+#else
+typedef uintptr_t(__cdecl * pfnSDL_CurrentBeginThread) (void *, unsigned,
+                                                        unsigned (__stdcall *
+                                                                  func) (void
+                                                                         *),
+                                                        void *arg, unsigned,
+                                                        unsigned *threadID);
+typedef void (__cdecl * pfnSDL_CurrentEndThread) (unsigned code);
+#endif
+
+/**
+ *  Create a thread.
+ */
+extern DECLSPEC SDL_Thread *SDLCALL
+SDL_CreateThread(SDL_ThreadFunction fn, void *data,
+                 pfnSDL_CurrentBeginThread pfnBeginThread,
+                 pfnSDL_CurrentEndThread pfnEndThread);
+
+#if defined(_WIN32_WCE)
+
+/**
+ *  Create a thread.
+ */
+#define SDL_CreateThread(fn, data) SDL_CreateThread(fn, data, NULL, NULL)
+
+#else
+
+/**
+ *  Create a thread.
+ */
+#define SDL_CreateThread(fn, data) SDL_CreateThread(fn, data, _beginthreadex, _endthreadex)
+
+#endif
+#else
+
+/**
+ *  Create a thread.
+ */
+extern DECLSPEC SDL_Thread *SDLCALL
+SDL_CreateThread(SDL_ThreadFunction fn, void *data);
+
+#endif
+
+/**
+ *  Get the thread identifier for the current thread.
+ */
+extern DECLSPEC SDL_threadID SDLCALL SDL_ThreadID(void);
+
+/**
+ *  Get the thread identifier for the specified thread.
+ *  
+ *  Equivalent to SDL_ThreadID() if the specified thread is NULL.
+ */
+extern DECLSPEC SDL_threadID SDLCALL SDL_GetThreadID(SDL_Thread * thread);
+
+/**
+ *  Wait for a thread to finish.
+ *  
+ *  The return code for the thread function is placed in the area
+ *  pointed to by \c status, if \c status is not NULL.
+ */
+extern DECLSPEC void SDLCALL SDL_WaitThread(SDL_Thread * thread, int *status);
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+/* *INDENT-OFF* */
+}
+/* *INDENT-ON* */
+#endif
+#include "close_code.h"
+
+#endif /* _SDL_thread_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/include/begin_code.h b/macosx/plugins/Common/SDL/include/begin_code.h
new file mode 100644
index 00000000..395dc7c6
--- /dev/null
+++ b/macosx/plugins/Common/SDL/include/begin_code.h
@@ -0,0 +1,136 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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
+*/
+
+/**
+ *  \file begin_code.h
+ *
+ *  This file sets things up for C dynamic library function definitions,
+ *  static inlined functions, and structures aligned at 4-byte alignment.
+ *  If you don't like ugly C preprocessor code, don't look at this file. :)
+ */
+
+/* This shouldn't be nested -- included it around code only. */
+#ifdef _begin_code_h
+#error Nested inclusion of begin_code.h
+#endif
+#define _begin_code_h
+
+/* Some compilers use a special export keyword */
+#ifndef DECLSPEC
+# if defined(__BEOS__) || defined(__HAIKU__)
+#  if defined(__GNUC__)
+#   define DECLSPEC	__declspec(dllexport)
+#  else
+#   define DECLSPEC	__declspec(export)
+#  endif
+# elif defined(__WIN32__)
+#  ifdef __BORLANDC__
+#   ifdef BUILD_SDL
+#    define DECLSPEC
+#   else
+#    define DECLSPEC	__declspec(dllimport)
+#   endif
+#  else
+#   define DECLSPEC	__declspec(dllexport)
+#  endif
+# else
+#  if defined(__GNUC__) && __GNUC__ >= 4
+#   define DECLSPEC	__attribute__ ((visibility("default")))
+#  else
+#   define DECLSPEC
+#  endif
+# endif
+#endif
+
+/* By default SDL uses the C calling convention */
+#ifndef SDLCALL
+#if defined(__WIN32__) && !defined(__GNUC__)
+#define SDLCALL __cdecl
+#else
+#define SDLCALL
+#endif
+#endif /* SDLCALL */
+
+/* Removed DECLSPEC on Symbian OS because SDL cannot be a DLL in EPOC */
+#ifdef __SYMBIAN32__
+#undef DECLSPEC
+#define DECLSPEC
+#endif /* __SYMBIAN32__ */
+
+/* Force structure packing at 4 byte alignment.
+   This is necessary if the header is included in code which has structure
+   packing set to an alternate value, say for loading structures from disk.
+   The packing is reset to the previous value in close_code.h
+ */
+#if defined(_MSC_VER) || defined(__MWERKS__) || defined(__BORLANDC__)
+#ifdef _MSC_VER
+#pragma warning(disable: 4103)
+#endif
+#ifdef __BORLANDC__
+#pragma nopackwarning
+#endif
+#pragma pack(push,4)
+#endif /* Compiler needs structure packing set */
+
+/* Set up compiler-specific options for inlining functions */
+#ifndef SDL_INLINE_OKAY
+#ifdef __GNUC__
+#define SDL_INLINE_OKAY
+#else
+/* Add any special compiler-specific cases here */
+#if defined(_MSC_VER) || defined(__BORLANDC__) || \
+    defined(__DMC__) || defined(__SC__) || \
+    defined(__WATCOMC__) || defined(__LCC__) || \
+    defined(__DECC)
+#ifndef __inline__
+#define __inline__	__inline
+#endif
+#define SDL_INLINE_OKAY
+#else
+#if !defined(__MRC__) && !defined(_SGI_SOURCE)
+#ifndef __inline__
+#define __inline__ inline
+#endif
+#define SDL_INLINE_OKAY
+#endif /* Not a funky compiler */
+#endif /* Visual C++ */
+#endif /* GNU C */
+#endif /* SDL_INLINE_OKAY */
+
+/* If inlining isn't supported, remove "__inline__", turning static
+   inlined functions into static functions (resulting in code bloat
+   in all files which include the offending header files)
+*/
+#ifndef SDL_INLINE_OKAY
+#define __inline__
+#endif
+
+/* Apparently this is needed by several Windows compilers */
+#if !defined(__MACH__)
+#ifndef NULL
+#ifdef __cplusplus
+#define NULL 0
+#else
+#define NULL ((void *)0)
+#endif
+#endif /* NULL */
+#endif /* ! Mac OS X - breaks precompiled headers */
diff --git a/macosx/plugins/Common/SDL/include/close_code.h b/macosx/plugins/Common/SDL/include/close_code.h
new file mode 100644
index 00000000..4b4e8a49
--- /dev/null
+++ b/macosx/plugins/Common/SDL/include/close_code.h
@@ -0,0 +1,38 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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
+*/
+
+/**
+ *  \file close_code.h
+ *  
+ *  This file reverses the effects of begin_code.h and should be included
+ *  after you finish any function and structure declarations in your headers
+ */
+
+#undef _begin_code_h
+
+/* Reset structure packing at previous byte alignment */
+#if defined(_MSC_VER) || defined(__MWERKS__) || defined(__WATCOMC__)  || defined(__BORLANDC__)
+#ifdef __BORLANDC__
+#pragma nopackwarning
+#endif
+#pragma pack(pop)
+#endif /* Compiler needs structure packing set */
diff --git a/macosx/plugins/Common/SDL/src/SDL.c b/macosx/plugins/Common/SDL/src/SDL.c
new file mode 100644
index 00000000..8347ef8a
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/SDL.c
@@ -0,0 +1,168 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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 <time.h>
+#include <errno.h>
+
+/* Initialization code for SDL */
+
+#include "SDL.h"
+#include "haptic/SDL_haptic_c.h"
+#include "joystick/SDL_joystick_c.h"
+
+/* The initialized subsystems */
+static Uint32 SDL_initialized = 0;
+
+int
+SDL_InitSubSystem(Uint32 flags)
+{
+#ifndef SDL_JOYSTICK_DISABLED
+    /* Initialize the joystick subsystem */
+    if ((flags & SDL_INIT_JOYSTICK) && !(SDL_initialized & SDL_INIT_JOYSTICK)) {
+        if (SDL_JoystickInit() < 0) {
+            return (-1);
+        }
+        SDL_initialized |= SDL_INIT_JOYSTICK;
+    }
+
+    /* Initialize the haptic subsystem */
+    if ((flags & SDL_INIT_HAPTIC) && !(SDL_initialized & SDL_INIT_HAPTIC)) {
+        if (SDL_HapticInit() < 0) {
+            return (-1);
+        }
+        SDL_initialized |= SDL_INIT_HAPTIC;
+    }
+#endif
+
+#ifndef SDL_AUDIO_DISABLED
+    /* Initialize the audio subsystem */
+    if ((flags & SDL_INIT_AUDIO) && !(SDL_initialized & SDL_INIT_AUDIO)) {
+        if (SDL_AudioInit(NULL) < 0) {
+            return (-1);
+        }
+        SDL_initialized |= SDL_INIT_AUDIO;
+    }
+#endif
+
+    return (0);
+}
+
+int
+SDL_Init(Uint32 flags)
+{
+    /* Clear the error message */
+    SDL_ClearError();
+
+    /* Initialize the desired subsystems */
+    if (SDL_InitSubSystem(flags) < 0) {
+        return (-1);
+    }
+
+    return (0);
+}
+
+void
+SDL_QuitSubSystem(Uint32 flags)
+{
+#ifndef SDL_JOYSTICK_DISABLED
+    /* Shut down requested initialized subsystems */
+    if ((flags & SDL_initialized & SDL_INIT_JOYSTICK)) {
+        SDL_JoystickQuit();
+        SDL_initialized &= ~SDL_INIT_JOYSTICK;
+    }
+
+    if ((flags & SDL_initialized & SDL_INIT_HAPTIC)) {
+        SDL_HapticQuit();
+        SDL_initialized &= ~SDL_INIT_HAPTIC;
+    }
+#endif
+
+#ifndef SDL_AUDIO_DISABLED
+    if ((flags & SDL_initialized & SDL_INIT_AUDIO)) {
+        SDL_AudioQuit();
+        SDL_initialized &= ~SDL_INIT_AUDIO;
+    }
+#endif
+}
+
+Uint32
+SDL_WasInit(Uint32 flags)
+{
+    if (!flags) {
+        flags = SDL_INIT_EVERYTHING;
+    }
+    return (SDL_initialized & flags);
+}
+
+void
+SDL_Quit(void)
+{
+    /* Quit all subsystems */
+    SDL_QuitSubSystem(SDL_INIT_EVERYTHING);
+}
+
+
+void
+SDL_Delay(Uint32 ms)
+{
+    int was_error;
+
+#if HAVE_NANOSLEEP
+    struct timespec elapsed, tv;
+#else
+    struct timeval tv;
+    Uint32 then, now, elapsed;
+#endif
+
+    /* Set the timeout interval */
+#if HAVE_NANOSLEEP
+    elapsed.tv_sec = ms / 1000;
+    elapsed.tv_nsec = (ms % 1000) * 1000000;
+#else
+    then = SDL_GetTicks();
+#endif
+    do {
+        errno = 0;
+
+#if HAVE_NANOSLEEP
+        tv.tv_sec = elapsed.tv_sec;
+        tv.tv_nsec = elapsed.tv_nsec;
+        was_error = nanosleep(&tv, &elapsed);
+#else
+        /* Calculate the time interval left (in case of interrupt) */
+        now = SDL_GetTicks();
+        elapsed = (now - then);
+        then = now;
+        if (elapsed >= ms) {
+            break;
+        }
+        ms -= elapsed;
+        tv.tv_sec = ms / 1000;
+        tv.tv_usec = (ms % 1000) * 1000;
+
+        was_error = select(0, NULL, NULL, NULL, &tv);
+#endif /* HAVE_NANOSLEEP */
+    } while (was_error && (errno == EINTR));
+}
+
diff --git a/macosx/plugins/Common/SDL/src/SDL_error.c b/macosx/plugins/Common/SDL/src/SDL_error.c
new file mode 100644
index 00000000..55d183a5
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/SDL_error.c
@@ -0,0 +1,259 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+/* Simple error handling in SDL */
+
+#include "SDL_error.h"
+#include "SDL_error_c.h"
+
+/* Routine to get the thread-specific error variable */
+#if SDL_THREADS_DISABLED
+/* !!! FIXME: what does this comment mean? Victim of Search and Replace? */
+/* The  SDL_arraysize(The ),default (non-thread-safe) global error variable */
+static SDL_error SDL_global_error;
+#define SDL_GetErrBuf()	(&SDL_global_error)
+#else
+extern SDL_error *SDL_GetErrBuf(void);
+#endif /* SDL_THREADS_DISABLED */
+
+#define SDL_ERRBUFIZE	1024
+
+/* Private functions */
+
+static const char *
+SDL_LookupString(const char *key)
+{
+    /* FIXME: Add code to lookup key in language string hash-table */
+    return key;
+}
+
+/* Public functions */
+
+void
+SDL_SetError(const char *fmt, ...)
+{
+    va_list ap;
+    SDL_error *error;
+
+    /* Copy in the key, mark error as valid */
+    error = SDL_GetErrBuf();
+    error->error = 1;
+    SDL_strlcpy((char *) error->key, fmt, sizeof(error->key));
+
+    va_start(ap, fmt);
+    error->argc = 0;
+    while (*fmt) {
+        if (*fmt++ == '%') {
+            while (*fmt == '.' || (*fmt >= '0' && *fmt <= '9')) {
+                ++fmt;
+            }
+            switch (*fmt++) {
+            case 0:            /* Malformed format string.. */
+                --fmt;
+                break;
+            case 'c':
+            case 'i':
+            case 'd':
+            case 'u':
+            case 'o':
+            case 'x':
+            case 'X':
+                error->args[error->argc++].value_i = va_arg(ap, int);
+                break;
+            case 'f':
+                error->args[error->argc++].value_f = va_arg(ap, double);
+                break;
+            case 'p':
+                error->args[error->argc++].value_ptr = va_arg(ap, void *);
+                break;
+            case 's':
+                {
+                    int i = error->argc;
+                    const char *str = va_arg(ap, const char *);
+                    if (str == NULL)
+                        str = "(null)";
+                    SDL_strlcpy((char *) error->args[i].buf, str,
+                                ERR_MAX_STRLEN);
+                    error->argc++;
+                }
+                break;
+            default:
+                break;
+            }
+            if (error->argc >= ERR_MAX_ARGS) {
+                break;
+            }
+        }
+    }
+    va_end(ap);
+
+    /* If we are in debug mode, print out an error message */
+#ifdef DEBUG_ERROR
+    fprintf(stderr, "SDL_SetError: %s\n", SDL_GetError());
+#endif
+}
+
+/* This function has a bit more overhead than most error functions
+   so that it supports internationalization and thread-safe errors.
+*/
+static char *
+SDL_GetErrorMsg(char *errstr, unsigned int maxlen)
+{
+    SDL_error *error;
+
+    /* Clear the error string */
+    *errstr = '\0';
+    --maxlen;
+
+    /* Get the thread-safe error, and print it out */
+    error = SDL_GetErrBuf();
+    if (error->error) {
+        const char *fmt;
+        char *msg = errstr;
+        int len;
+        int argi;
+
+        fmt = SDL_LookupString(error->key);
+        argi = 0;
+        while (*fmt && (maxlen > 0)) {
+            if (*fmt == '%') {
+                char tmp[32], *spot = tmp;
+                *spot++ = *fmt++;
+                while ((*fmt == '.' || (*fmt >= '0' && *fmt <= '9'))
+                       && spot < (tmp + SDL_arraysize(tmp) - 2)) {
+                    *spot++ = *fmt++;
+                }
+                *spot++ = *fmt++;
+                *spot++ = '\0';
+                switch (spot[-2]) {
+                case '%':
+                    *msg++ = '%';
+                    maxlen -= 1;
+                    break;
+                case 'c':
+                case 'i':
+                case 'd':
+                case 'u':
+                case 'o':
+                case 'x':
+                case 'X':
+                    len =
+                        SDL_snprintf(msg, maxlen, tmp,
+                                     error->args[argi++].value_i);
+                    msg += len;
+                    maxlen -= len;
+                    break;
+                case 'f':
+                    len =
+                        SDL_snprintf(msg, maxlen, tmp,
+                                     error->args[argi++].value_f);
+                    msg += len;
+                    maxlen -= len;
+                    break;
+                case 'p':
+                    len =
+                        SDL_snprintf(msg, maxlen, tmp,
+                                     error->args[argi++].value_ptr);
+                    msg += len;
+                    maxlen -= len;
+                    break;
+                case 's':
+                    len =
+                        SDL_snprintf(msg, maxlen, tmp,
+                                     SDL_LookupString(error->args[argi++].
+                                                      buf));
+                    msg += len;
+                    maxlen -= len;
+                    break;
+                }
+            } else {
+                *msg++ = *fmt++;
+                maxlen -= 1;
+            }
+        }
+        *msg = 0;               /* NULL terminate the string */
+    }
+    return (errstr);
+}
+
+/* Available for backwards compatibility */
+char *
+SDL_GetError(void)
+{
+    static char errmsg[SDL_ERRBUFIZE];
+
+    return ((char *) SDL_GetErrorMsg(errmsg, SDL_ERRBUFIZE));
+}
+
+void
+SDL_ClearError(void)
+{
+    SDL_error *error;
+
+    error = SDL_GetErrBuf();
+    error->error = 0;
+}
+
+/* Very common errors go here */
+void
+SDL_Error(SDL_errorcode code)
+{
+    switch (code) {
+    case SDL_ENOMEM:
+        SDL_SetError("Out of memory");
+        break;
+    case SDL_EFREAD:
+        SDL_SetError("Error reading from datastream");
+        break;
+    case SDL_EFWRITE:
+        SDL_SetError("Error writing to datastream");
+        break;
+    case SDL_EFSEEK:
+        SDL_SetError("Error seeking in datastream");
+        break;
+    case SDL_UNSUPPORTED:
+        SDL_SetError("That operation is not supported");
+        break;
+    default:
+        SDL_SetError("Unknown SDL error");
+        break;
+    }
+}
+
+#ifdef TEST_ERROR
+int
+main(int argc, char *argv[])
+{
+    char buffer[BUFSIZ + 1];
+
+    SDL_SetError("Hi there!");
+    printf("Error 1: %s\n", SDL_GetError());
+    SDL_ClearError();
+    SDL_memset(buffer, '1', BUFSIZ);
+    buffer[BUFSIZ] = 0;
+    SDL_SetError("This is the error: %s (%f)", buffer, 1.0);
+    printf("Error 2: %s\n", SDL_GetError());
+    exit(0);
+}
+#endif
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/SDL_error_c.h b/macosx/plugins/Common/SDL/src/SDL_error_c.h
new file mode 100644
index 00000000..54501f5f
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/SDL_error_c.h
@@ -0,0 +1,62 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+/* This file defines a structure that carries language-independent
+   error messages
+*/
+
+#ifndef _SDL_error_c_h
+#define _SDL_error_c_h
+
+#define ERR_MAX_STRLEN	128
+#define ERR_MAX_ARGS	5
+
+typedef struct SDL_error
+{
+    /* This is a numeric value corresponding to the current error */
+    int error;
+
+    /* This is a key used to index into a language hashtable containing
+       internationalized versions of the SDL error messages.  If the key
+       is not in the hashtable, or no hashtable is available, the key is
+       used directly as an error message format string.
+     */
+    char key[ERR_MAX_STRLEN];
+
+    /* These are the arguments for the error functions */
+    int argc;
+    union
+    {
+        void *value_ptr;
+#if 0                           /* What is a character anyway?  (UNICODE issues) */
+        unsigned char value_c;
+#endif
+        int value_i;
+        double value_f;
+        char buf[ERR_MAX_STRLEN];
+    } args[ERR_MAX_ARGS];
+} SDL_error;
+
+#endif /* _SDL_error_c_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/audio/SDL_audio.c b/macosx/plugins/Common/SDL/src/audio/SDL_audio.c
new file mode 100644
index 00000000..bd0a5430
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/audio/SDL_audio.c
@@ -0,0 +1,1121 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+/* Allow access to a raw mixing buffer */
+
+#include "SDL.h"
+#include "SDL_audio.h"
+#include "SDL_audio_c.h"
+#include "SDL_audiomem.h"
+#include "SDL_sysaudio.h"
+
+#define _THIS SDL_AudioDevice *_this
+
+static SDL_AudioDriver current_audio;
+static SDL_AudioDevice *open_devices[16];
+
+/* !!! FIXME: These are wordy and unlocalized... */
+#define DEFAULT_OUTPUT_DEVNAME "System audio output device"
+#define DEFAULT_INPUT_DEVNAME "System audio capture device"
+
+
+/*
+ * Not all of these will be compiled and linked in, but it's convenient
+ *  to have a complete list here and saves yet-another block of #ifdefs...
+ *  Please see bootstrap[], below, for the actual #ifdef mess.
+ */
+
+extern AudioBootStrap COREAUDIO_bootstrap;
+
+/* Available audio drivers */
+static const AudioBootStrap *const bootstrap[] = {
+    &COREAUDIO_bootstrap, NULL
+};
+
+static SDL_AudioDevice *
+get_audio_device(SDL_AudioDeviceID id)
+{
+    id--;
+    if ((id >= SDL_arraysize(open_devices)) || (open_devices[id] == NULL)) {
+        SDL_SetError("Invalid audio device ID");
+        return NULL;
+    }
+
+    return open_devices[id];
+}
+
+
+/* stubs for audio drivers that don't need a specific entry point... */
+static int
+SDL_AudioDetectDevices_Default(int iscapture)
+{
+    return -1;
+}
+
+static void
+SDL_AudioThreadInit_Default(_THIS)
+{                               /* no-op. */
+}
+
+static void
+SDL_AudioWaitDevice_Default(_THIS)
+{                               /* no-op. */
+}
+
+static void
+SDL_AudioPlayDevice_Default(_THIS)
+{                               /* no-op. */
+}
+
+static Uint8 *
+SDL_AudioGetDeviceBuf_Default(_THIS)
+{
+    return NULL;
+}
+
+static void
+SDL_AudioWaitDone_Default(_THIS)
+{                               /* no-op. */
+}
+
+static void
+SDL_AudioCloseDevice_Default(_THIS)
+{                               /* no-op. */
+}
+
+static void
+SDL_AudioDeinitialize_Default(void)
+{                               /* no-op. */
+}
+
+static int
+SDL_AudioOpenDevice_Default(_THIS, const char *devname, int iscapture)
+{
+    return 0;
+}
+
+static const char *
+SDL_AudioGetDeviceName_Default(int index, int iscapture)
+{
+    SDL_SetError("No such device");
+    return NULL;
+}
+
+static void
+SDL_AudioLockDevice_Default(SDL_AudioDevice * device)
+{
+    if (device->thread && (SDL_ThreadID() == device->threadid)) {
+        return;
+    }
+    SDL_mutexP(device->mixer_lock);
+}
+
+static void
+SDL_AudioUnlockDevice_Default(SDL_AudioDevice * device)
+{
+    if (device->thread && (SDL_ThreadID() == device->threadid)) {
+        return;
+    }
+    SDL_mutexV(device->mixer_lock);
+}
+
+
+static void
+finalize_audio_entry_points(void)
+{
+    /*
+     * Fill in stub functions for unused driver entry points. This lets us
+     *  blindly call them without having to check for validity first.
+     */
+
+#define FILL_STUB(x) \
+        if (current_audio.impl.x == NULL) { \
+            current_audio.impl.x = SDL_Audio##x##_Default; \
+        }
+    FILL_STUB(DetectDevices);
+    FILL_STUB(GetDeviceName);
+    FILL_STUB(OpenDevice);
+    FILL_STUB(ThreadInit);
+    FILL_STUB(WaitDevice);
+    FILL_STUB(PlayDevice);
+    FILL_STUB(GetDeviceBuf);
+    FILL_STUB(WaitDone);
+    FILL_STUB(CloseDevice);
+    FILL_STUB(LockDevice);
+    FILL_STUB(UnlockDevice);
+    FILL_STUB(Deinitialize);
+#undef FILL_STUB
+}
+
+/* Streaming functions (for when the input and output buffer sizes are different) */
+/* Write [length] bytes from buf into the streamer */
+static void
+SDL_StreamWrite(SDL_AudioStreamer * stream, Uint8 * buf, int length)
+{
+    int i;
+
+    for (i = 0; i < length; ++i) {
+        stream->buffer[stream->write_pos] = buf[i];
+        ++stream->write_pos;
+    }
+}
+
+/* Read [length] bytes out of the streamer into buf */
+static void
+SDL_StreamRead(SDL_AudioStreamer * stream, Uint8 * buf, int length)
+{
+    int i;
+
+    for (i = 0; i < length; ++i) {
+        buf[i] = stream->buffer[stream->read_pos];
+        ++stream->read_pos;
+    }
+}
+
+static int
+SDL_StreamLength(SDL_AudioStreamer * stream)
+{
+    return (stream->write_pos - stream->read_pos) % stream->max_len;
+}
+
+/* Initialize the stream by allocating the buffer and setting the read/write heads to the beginning */
+#if 0
+static int
+SDL_StreamInit(SDL_AudioStreamer * stream, int max_len, Uint8 silence)
+{
+    /* First try to allocate the buffer */
+    stream->buffer = (Uint8 *) SDL_malloc(max_len);
+    if (stream->buffer == NULL) {
+        return -1;
+    }
+
+    stream->max_len = max_len;
+    stream->read_pos = 0;
+    stream->write_pos = 0;
+
+    /* Zero out the buffer */
+    SDL_memset(stream->buffer, silence, max_len);
+
+    return 0;
+}
+#endif
+
+/* Deinitialize the stream simply by freeing the buffer */
+static void
+SDL_StreamDeinit(SDL_AudioStreamer * stream)
+{
+    if (stream->buffer != NULL) {
+        SDL_free(stream->buffer);
+    }
+}
+
+/* The general mixing thread function */
+int SDLCALL
+SDL_RunAudio(void *devicep)
+{
+    SDL_AudioDevice *device = (SDL_AudioDevice *) devicep;
+    Uint8 *stream;
+    int stream_len;
+    void *udata;
+    void (SDLCALL * fill) (void *userdata, Uint8 * stream, int len);
+    int silence;
+    Uint32 delay;
+
+    /* For streaming when the buffer sizes don't match up */
+    Uint8 *istream;
+    int istream_len = 0;
+
+    /* Perform any thread setup */
+    device->threadid = SDL_ThreadID();
+    current_audio.impl.ThreadInit(device);
+
+    /* Set up the mixing function */
+    fill = device->spec.callback;
+    udata = device->spec.userdata;
+
+    /* By default do not stream */
+    device->use_streamer = 0;
+
+    if (device->convert.needed) {
+        if (device->convert.src_format == AUDIO_U8) {
+            silence = 0x80;
+        } else {
+            silence = 0;
+        }
+
+#if 0                           /* !!! FIXME: I took len_div out of the structure. Use rate_incr instead? */
+        /* If the result of the conversion alters the length, i.e. resampling is being used, use the streamer */
+        if (device->convert.len_mult != 1 || device->convert.len_div != 1) {
+            /* The streamer's maximum length should be twice whichever is larger: spec.size or len_cvt */
+            stream_max_len = 2 * device->spec.size;
+            if (device->convert.len_mult > device->convert.len_div) {
+                stream_max_len *= device->convert.len_mult;
+                stream_max_len /= device->convert.len_div;
+            }
+            if (SDL_StreamInit(&device->streamer, stream_max_len, silence) <
+                0)
+                return -1;
+            device->use_streamer = 1;
+
+            /* istream_len should be the length of what we grab from the callback and feed to conversion,
+               so that we get close to spec_size. I.e. we want device.spec_size = istream_len * u / d
+             */
+            istream_len =
+                device->spec.size * device->convert.len_div /
+                device->convert.len_mult;
+        }
+#endif
+
+        /* stream_len = device->convert.len; */
+        stream_len = device->spec.size;
+    } else {
+        silence = device->spec.silence;
+        stream_len = device->spec.size;
+    }
+
+    /* Calculate the delay while paused */
+    delay = ((device->spec.samples * 1000) / device->spec.freq);
+
+    /* Determine if the streamer is necessary here */
+    if (device->use_streamer == 1) {
+        /* This code is almost the same as the old code. The difference is, instead of reading
+           directly from the callback into "stream", then converting and sending the audio off,
+           we go: callback -> "istream" -> (conversion) -> streamer -> stream -> device.
+           However, reading and writing with streamer are done separately:
+           - We only call the callback and write to the streamer when the streamer does not
+           contain enough samples to output to the device.
+           - We only read from the streamer and tell the device to play when the streamer
+           does have enough samples to output.
+           This allows us to perform resampling in the conversion step, where the output of the
+           resampling process can be any number. We will have to see what a good size for the
+           stream's maximum length is, but I suspect 2*max(len_cvt, stream_len) is a good figure.
+         */
+        while (device->enabled) {
+
+            if (device->paused) {
+                SDL_Delay(delay);
+                continue;
+            }
+
+            /* Only read in audio if the streamer doesn't have enough already (if it does not have enough samples to output) */
+            if (SDL_StreamLength(&device->streamer) < stream_len) {
+                /* Set up istream */
+                if (device->convert.needed) {
+                    if (device->convert.buf) {
+                        istream = device->convert.buf;
+                    } else {
+                        continue;
+                    }
+                } else {
+/* FIXME: Ryan, this is probably wrong.  I imagine we don't want to get
+ * a device buffer both here and below in the stream output.
+ */
+                    istream = current_audio.impl.GetDeviceBuf(device);
+                    if (istream == NULL) {
+                        istream = device->fake_stream;
+                    }
+                }
+
+                /* Read from the callback into the _input_ stream */
+                SDL_mutexP(device->mixer_lock);
+                (*fill) (udata, istream, istream_len);
+                SDL_mutexV(device->mixer_lock);
+
+                /* Convert the audio if necessary and write to the streamer */
+                if (device->convert.needed) {
+                    SDL_ConvertAudio(&device->convert);
+                    if (istream == NULL) {
+                        istream = device->fake_stream;
+                    }
+                    /*SDL_memcpy(istream, device->convert.buf, device->convert.len_cvt); */
+                    SDL_StreamWrite(&device->streamer, device->convert.buf,
+                                    device->convert.len_cvt);
+                } else {
+                    SDL_StreamWrite(&device->streamer, istream, istream_len);
+                }
+            }
+
+            /* Only output audio if the streamer has enough to output */
+            if (SDL_StreamLength(&device->streamer) >= stream_len) {
+                /* Set up the output stream */
+                if (device->convert.needed) {
+                    if (device->convert.buf) {
+                        stream = device->convert.buf;
+                    } else {
+                        continue;
+                    }
+                } else {
+                    stream = current_audio.impl.GetDeviceBuf(device);
+                    if (stream == NULL) {
+                        stream = device->fake_stream;
+                    }
+                }
+
+                /* Now read from the streamer */
+                SDL_StreamRead(&device->streamer, stream, stream_len);
+
+                /* Ready current buffer for play and change current buffer */
+                if (stream != device->fake_stream) {
+                    current_audio.impl.PlayDevice(device);
+                    /* Wait for an audio buffer to become available */
+                    current_audio.impl.WaitDevice(device);
+                } else {
+                    SDL_Delay(delay);
+                }
+            }
+
+        }
+    } else {
+        /* Otherwise, do not use the streamer. This is the old code. */
+
+        /* Loop, filling the audio buffers */
+        while (device->enabled) {
+
+            if (device->paused) {
+                SDL_Delay(delay);
+                continue;
+            }
+
+            /* Fill the current buffer with sound */
+            if (device->convert.needed) {
+                if (device->convert.buf) {
+                    stream = device->convert.buf;
+                } else {
+                    continue;
+                }
+            } else {
+                stream = current_audio.impl.GetDeviceBuf(device);
+                if (stream == NULL) {
+                    stream = device->fake_stream;
+                }
+            }
+
+            SDL_mutexP(device->mixer_lock);
+            (*fill) (udata, stream, stream_len);
+            SDL_mutexV(device->mixer_lock);
+
+            /* Convert the audio if necessary */
+            if (device->convert.needed) {
+                SDL_ConvertAudio(&device->convert);
+                stream = current_audio.impl.GetDeviceBuf(device);
+                if (stream == NULL) {
+                    stream = device->fake_stream;
+                }
+                SDL_memcpy(stream, device->convert.buf,
+                           device->convert.len_cvt);
+            }
+
+            /* Ready current buffer for play and change current buffer */
+            if (stream != device->fake_stream) {
+                current_audio.impl.PlayDevice(device);
+                /* Wait for an audio buffer to become available */
+                current_audio.impl.WaitDevice(device);
+            } else {
+                SDL_Delay(delay);
+            }
+        }
+    }
+
+    /* Wait for the audio to drain.. */
+    current_audio.impl.WaitDone(device);
+
+    /* If necessary, deinit the streamer */
+    if (device->use_streamer == 1)
+        SDL_StreamDeinit(&device->streamer);
+
+    return (0);
+}
+
+
+static SDL_AudioFormat
+SDL_ParseAudioFormat(const char *string)
+{
+#define CHECK_FMT_STRING(x) if (SDL_strcmp(string, #x) == 0) return AUDIO_##x
+    CHECK_FMT_STRING(U8);
+    CHECK_FMT_STRING(S8);
+    CHECK_FMT_STRING(U16LSB);
+    CHECK_FMT_STRING(S16LSB);
+    CHECK_FMT_STRING(U16MSB);
+    CHECK_FMT_STRING(S16MSB);
+    CHECK_FMT_STRING(U16SYS);
+    CHECK_FMT_STRING(S16SYS);
+    CHECK_FMT_STRING(U16);
+    CHECK_FMT_STRING(S16);
+    CHECK_FMT_STRING(S32LSB);
+    CHECK_FMT_STRING(S32MSB);
+    CHECK_FMT_STRING(S32SYS);
+    CHECK_FMT_STRING(S32);
+    CHECK_FMT_STRING(F32LSB);
+    CHECK_FMT_STRING(F32MSB);
+    CHECK_FMT_STRING(F32SYS);
+    CHECK_FMT_STRING(F32);
+#undef CHECK_FMT_STRING
+    return 0;
+}
+
+int
+SDL_GetNumAudioDrivers(void)
+{
+    return (SDL_arraysize(bootstrap) - 1);
+}
+
+const char *
+SDL_GetAudioDriver(int index)
+{
+    if (index >= 0 && index < SDL_GetNumAudioDrivers()) {
+        return (bootstrap[index]->name);
+    }
+    return (NULL);
+}
+
+int
+SDL_AudioInit(const char *driver_name)
+{
+    int i = 0;
+    int initialized = 0;
+    int tried_to_init = 0;
+
+    if (SDL_WasInit(SDL_INIT_AUDIO)) {
+        SDL_AudioQuit();        /* shutdown driver if already running. */
+    }
+
+    SDL_memset(&current_audio, '\0', sizeof(current_audio));
+    SDL_memset(open_devices, '\0', sizeof(open_devices));
+
+    /* Select the proper audio driver */
+    if (driver_name == NULL) {
+        driver_name = SDL_getenv("SDL_AUDIODRIVER");
+    }
+
+    for (i = 0; (!initialized) && (bootstrap[i]); ++i) {
+        /* make sure we should even try this driver before doing so... */
+        const AudioBootStrap *backend = bootstrap[i];
+        if (((driver_name) && (SDL_strcasecmp(backend->name, driver_name))) ||
+            ((!driver_name) && (backend->demand_only))) {
+            continue;
+        }
+
+        tried_to_init = 1;
+        SDL_memset(&current_audio, 0, sizeof(current_audio));
+        current_audio.name = backend->name;
+        current_audio.desc = backend->desc;
+        initialized = backend->init(&current_audio.impl);
+    }
+
+    if (!initialized) {
+        /* specific drivers will set the error message if they fail... */
+        if (!tried_to_init) {
+            if (driver_name) {
+                SDL_SetError("Audio target '%s' not available", driver_name);
+            } else {
+                SDL_SetError("No available audio device");
+            }
+        }
+
+        SDL_memset(&current_audio, 0, sizeof(current_audio));
+        return (-1);            /* No driver was available, so fail. */
+    }
+
+    finalize_audio_entry_points();
+
+    return (0);
+}
+
+/*
+ * Get the current audio driver name
+ */
+const char *
+SDL_GetCurrentAudioDriver()
+{
+    return current_audio.name;
+}
+
+
+int
+SDL_GetNumAudioDevices(int iscapture)
+{
+    if (!SDL_WasInit(SDL_INIT_AUDIO)) {
+        return -1;
+    }
+    if ((iscapture) && (!current_audio.impl.HasCaptureSupport)) {
+        return 0;
+    }
+
+    if ((iscapture) && (current_audio.impl.OnlyHasDefaultInputDevice)) {
+        return 1;
+    }
+
+    if ((!iscapture) && (current_audio.impl.OnlyHasDefaultOutputDevice)) {
+        return 1;
+    }
+
+    return current_audio.impl.DetectDevices(iscapture);
+}
+
+
+const char *
+SDL_GetAudioDeviceName(int index, int iscapture)
+{
+    if (!SDL_WasInit(SDL_INIT_AUDIO)) {
+        SDL_SetError("Audio subsystem is not initialized");
+        return NULL;
+    }
+
+    if ((iscapture) && (!current_audio.impl.HasCaptureSupport)) {
+        SDL_SetError("No capture support");
+        return NULL;
+    }
+
+    if (index < 0) {
+        SDL_SetError("No such device");
+        return NULL;
+    }
+
+    if ((iscapture) && (current_audio.impl.OnlyHasDefaultInputDevice)) {
+        return DEFAULT_INPUT_DEVNAME;
+    }
+
+    if ((!iscapture) && (current_audio.impl.OnlyHasDefaultOutputDevice)) {
+        return DEFAULT_OUTPUT_DEVNAME;
+    }
+
+    return current_audio.impl.GetDeviceName(index, iscapture);
+}
+
+
+static void
+close_audio_device(SDL_AudioDevice * device)
+{
+    device->enabled = 0;
+    if (device->thread != NULL) {
+        SDL_WaitThread(device->thread, NULL);
+    }
+    if (device->mixer_lock != NULL) {
+        SDL_DestroyMutex(device->mixer_lock);
+    }
+    if (device->fake_stream != NULL) {
+        SDL_FreeAudioMem(device->fake_stream);
+    }
+    if (device->convert.needed) {
+        SDL_FreeAudioMem(device->convert.buf);
+    }
+    if (device->opened) {
+        current_audio.impl.CloseDevice(device);
+        device->opened = 0;
+    }
+    SDL_FreeAudioMem(device);
+}
+
+
+/*
+ * Sanity check desired AudioSpec for SDL_OpenAudio() in (orig).
+ *  Fills in a sanitized copy in (prepared).
+ *  Returns non-zero if okay, zero on fatal parameters in (orig).
+ */
+static int
+prepare_audiospec(const SDL_AudioSpec * orig, SDL_AudioSpec * prepared)
+{
+    SDL_memcpy(prepared, orig, sizeof(SDL_AudioSpec));
+
+    if (orig->callback == NULL) {
+        SDL_SetError("SDL_OpenAudio() passed a NULL callback");
+        return 0;
+    }
+
+    if (orig->freq == 0) {
+        const char *env = SDL_getenv("SDL_AUDIO_FREQUENCY");
+        if ((!env) || ((prepared->freq = SDL_atoi(env)) == 0)) {
+            prepared->freq = 22050;     /* a reasonable default */
+        }
+    }
+
+    if (orig->format == 0) {
+        const char *env = SDL_getenv("SDL_AUDIO_FORMAT");
+        if ((!env) || ((prepared->format = SDL_ParseAudioFormat(env)) == 0)) {
+            prepared->format = AUDIO_S16;       /* a reasonable default */
+        }
+    }
+
+    switch (orig->channels) {
+    case 0:{
+            const char *env = SDL_getenv("SDL_AUDIO_CHANNELS");
+            if ((!env) || ((prepared->channels = (Uint8) SDL_atoi(env)) == 0)) {
+                prepared->channels = 2; /* a reasonable default */
+            }
+            break;
+        }
+    case 1:                    /* Mono */
+    case 2:                    /* Stereo */
+    case 4:                    /* surround */
+    case 6:                    /* surround with center and lfe */
+        break;
+    default:
+        SDL_SetError("Unsupported number of audio channels.");
+        return 0;
+    }
+
+    if (orig->samples == 0) {
+        const char *env = SDL_getenv("SDL_AUDIO_SAMPLES");
+        if ((!env) || ((prepared->samples = (Uint16) SDL_atoi(env)) == 0)) {
+            /* Pick a default of ~46 ms at desired frequency */
+            /* !!! FIXME: remove this when the non-Po2 resampling is in. */
+            const int samples = (prepared->freq / 1000) * 46;
+            int power2 = 1;
+            while (power2 < samples) {
+                power2 *= 2;
+            }
+            prepared->samples = power2;
+        }
+    }
+
+    /* Calculate the silence and size of the audio specification */
+    SDL_CalculateAudioSpec(prepared);
+
+    return 1;
+}
+
+
+static SDL_AudioDeviceID
+open_audio_device(const char *devname, int iscapture,
+                  const SDL_AudioSpec * desired, SDL_AudioSpec * obtained,
+                  int allowed_changes, int min_id)
+{
+    SDL_AudioDeviceID id = 0;
+    SDL_AudioSpec _obtained;
+    SDL_AudioDevice *device;
+    SDL_bool build_cvt;
+    int i = 0;
+
+    if (!SDL_WasInit(SDL_INIT_AUDIO)) {
+        SDL_SetError("Audio subsystem is not initialized");
+        return 0;
+    }
+
+    if ((iscapture) && (!current_audio.impl.HasCaptureSupport)) {
+        SDL_SetError("No capture support");
+        return 0;
+    }
+
+    if (!obtained) {
+        obtained = &_obtained;
+    }
+    if (!prepare_audiospec(desired, obtained)) {
+        return 0;
+    }
+
+    /* If app doesn't care about a specific device, let the user override. */
+    if (devname == NULL) {
+        devname = SDL_getenv("SDL_AUDIO_DEVICE_NAME");
+    }
+
+    /*
+     * Catch device names at the high level for the simple case...
+     * This lets us have a basic "device enumeration" for systems that
+     *  don't have multiple devices, but makes sure the device name is
+     *  always NULL when it hits the low level.
+     *
+     * Also make sure that the simple case prevents multiple simultaneous
+     *  opens of the default system device.
+     */
+
+    if ((iscapture) && (current_audio.impl.OnlyHasDefaultInputDevice)) {
+        if ((devname) && (SDL_strcmp(devname, DEFAULT_INPUT_DEVNAME) != 0)) {
+            SDL_SetError("No such device");
+            return 0;
+        }
+        devname = NULL;
+
+        for (i = 0; i < SDL_arraysize(open_devices); i++) {
+            if ((open_devices[i]) && (open_devices[i]->iscapture)) {
+                SDL_SetError("Audio device already open");
+                return 0;
+            }
+        }
+    }
+
+    if ((!iscapture) && (current_audio.impl.OnlyHasDefaultOutputDevice)) {
+        if ((devname) && (SDL_strcmp(devname, DEFAULT_OUTPUT_DEVNAME) != 0)) {
+            SDL_SetError("No such device");
+            return 0;
+        }
+        devname = NULL;
+
+        for (i = 0; i < SDL_arraysize(open_devices); i++) {
+            if ((open_devices[i]) && (!open_devices[i]->iscapture)) {
+                SDL_SetError("Audio device already open");
+                return 0;
+            }
+        }
+    }
+
+    device = (SDL_AudioDevice *) SDL_AllocAudioMem(sizeof(SDL_AudioDevice));
+    if (device == NULL) {
+        SDL_OutOfMemory();
+        return 0;
+    }
+    SDL_memset(device, '\0', sizeof(SDL_AudioDevice));
+    device->spec = *obtained;
+    device->enabled = 1;
+    device->paused = 1;
+    device->iscapture = iscapture;
+
+    /* Create a semaphore for locking the sound buffers */
+    if (!current_audio.impl.SkipMixerLock) {
+        device->mixer_lock = SDL_CreateMutex();
+        if (device->mixer_lock == NULL) {
+            close_audio_device(device);
+            SDL_SetError("Couldn't create mixer lock");
+            return 0;
+        }
+    }
+
+    if (!current_audio.impl.OpenDevice(device, devname, iscapture)) {
+        close_audio_device(device);
+        return 0;
+    }
+    device->opened = 1;
+
+    /* Allocate a fake audio memory buffer */
+    device->fake_stream = (Uint8 *)SDL_AllocAudioMem(device->spec.size);
+    if (device->fake_stream == NULL) {
+        close_audio_device(device);
+        SDL_OutOfMemory();
+        return 0;
+    }
+
+    /* If the audio driver changes the buffer size, accept it */
+    if (device->spec.samples != obtained->samples) {
+        obtained->samples = device->spec.samples;
+        SDL_CalculateAudioSpec(obtained);
+    }
+
+    /* See if we need to do any conversion */
+    build_cvt = SDL_FALSE;
+    if (obtained->freq != device->spec.freq) {
+        if (allowed_changes & SDL_AUDIO_ALLOW_FREQUENCY_CHANGE) {
+            obtained->freq = device->spec.freq;
+        } else {
+            build_cvt = SDL_TRUE;
+        }
+    }
+    if (obtained->format != device->spec.format) {
+        if (allowed_changes & SDL_AUDIO_ALLOW_FORMAT_CHANGE) {
+            obtained->format = device->spec.format;
+        } else {
+            build_cvt = SDL_TRUE;
+        }
+    }
+    if (obtained->channels != device->spec.channels) {
+        if (allowed_changes & SDL_AUDIO_ALLOW_CHANNELS_CHANGE) {
+            obtained->channels = device->spec.channels;
+        } else {
+            build_cvt = SDL_TRUE;
+        }
+    }
+    if (build_cvt) {
+        /* Build an audio conversion block */
+        if (SDL_BuildAudioCVT(&device->convert,
+                              obtained->format, obtained->channels,
+                              obtained->freq,
+                              device->spec.format, device->spec.channels,
+                              device->spec.freq) < 0) {
+            close_audio_device(device);
+            return 0;
+        }
+        if (device->convert.needed) {
+            device->convert.len = (int) (((double) obtained->size) /
+                                         device->convert.len_ratio);
+
+            device->convert.buf =
+                (Uint8 *) SDL_AllocAudioMem(device->convert.len *
+                                            device->convert.len_mult);
+            if (device->convert.buf == NULL) {
+                close_audio_device(device);
+                SDL_OutOfMemory();
+                return 0;
+            }
+        }
+    }
+
+    /* Find an available device ID and store the structure... */
+    for (id = min_id - 1; id < SDL_arraysize(open_devices); id++) {
+        if (open_devices[id] == NULL) {
+            open_devices[id] = device;
+            break;
+        }
+    }
+
+    if (id == SDL_arraysize(open_devices)) {
+        SDL_SetError("Too many open audio devices");
+        close_audio_device(device);
+        return 0;
+    }
+
+    /* Start the audio thread if necessary */
+    if (!current_audio.impl.ProvidesOwnCallbackThread) {
+        /* Start the audio thread */
+/* !!! FIXME: this is nasty. */
+#if (defined(__WIN32__) && !defined(_WIN32_WCE)) && !defined(HAVE_LIBC)
+#undef SDL_CreateThread
+        device->thread = SDL_CreateThread(SDL_RunAudio, device, NULL, NULL);
+#else
+        device->thread = SDL_CreateThread(SDL_RunAudio, device);
+#endif
+        if (device->thread == NULL) {
+            SDL_CloseAudioDevice(id + 1);
+            SDL_SetError("Couldn't create audio thread");
+            return 0;
+        }
+    }
+
+    return id + 1;
+}
+
+
+int
+SDL_OpenAudio(SDL_AudioSpec * desired, SDL_AudioSpec * obtained)
+{
+    SDL_AudioDeviceID id = 0;
+
+    /* Start up the audio driver, if necessary. This is legacy behaviour! */
+    if (!SDL_WasInit(SDL_INIT_AUDIO)) {
+        if (SDL_InitSubSystem(SDL_INIT_AUDIO) < 0) {
+            return (-1);
+        }
+    }
+
+    /* SDL_OpenAudio() is legacy and can only act on Device ID #1. */
+    if (open_devices[0] != NULL) {
+        SDL_SetError("Audio device is already opened");
+        return (-1);
+    }
+
+    if (obtained) {
+        id = open_audio_device(NULL, 0, desired, obtained,
+                               SDL_AUDIO_ALLOW_ANY_CHANGE, 1);
+    } else {
+        id = open_audio_device(NULL, 0, desired, desired, 0, 1);
+    }
+    if (id > 1) {               /* this should never happen in theory... */
+        SDL_CloseAudioDevice(id);
+        SDL_SetError("Internal error"); /* MUST be Device ID #1! */
+        return (-1);
+    }
+
+    return ((id == 0) ? -1 : 0);
+}
+
+SDL_AudioDeviceID
+SDL_OpenAudioDevice(const char *device, int iscapture,
+                    const SDL_AudioSpec * desired, SDL_AudioSpec * obtained,
+                    int allowed_changes)
+{
+    return open_audio_device(device, iscapture, desired, obtained,
+                             allowed_changes, 2);
+}
+
+SDL_AudioStatus
+SDL_GetAudioDeviceStatus(SDL_AudioDeviceID devid)
+{
+    SDL_AudioDevice *device = get_audio_device(devid);
+    SDL_AudioStatus status = SDL_AUDIO_STOPPED;
+    if (device && device->enabled) {
+        if (device->paused) {
+            status = SDL_AUDIO_PAUSED;
+        } else {
+            status = SDL_AUDIO_PLAYING;
+        }
+    }
+    return (status);
+}
+
+
+SDL_AudioStatus
+SDL_GetAudioStatus(void)
+{
+    return SDL_GetAudioDeviceStatus(1);
+}
+
+void
+SDL_PauseAudioDevice(SDL_AudioDeviceID devid, int pause_on)
+{
+    SDL_AudioDevice *device = get_audio_device(devid);
+    if (device) {
+        device->paused = pause_on;
+    }
+}
+
+void
+SDL_PauseAudio(int pause_on)
+{
+    SDL_PauseAudioDevice(1, pause_on);
+}
+
+
+void
+SDL_LockAudioDevice(SDL_AudioDeviceID devid)
+{
+    /* Obtain a lock on the mixing buffers */
+    SDL_AudioDevice *device = get_audio_device(devid);
+    if (device) {
+        current_audio.impl.LockDevice(device);
+    }
+}
+
+void
+SDL_LockAudio(void)
+{
+    SDL_LockAudioDevice(1);
+}
+
+void
+SDL_UnlockAudioDevice(SDL_AudioDeviceID devid)
+{
+    /* Obtain a lock on the mixing buffers */
+    SDL_AudioDevice *device = get_audio_device(devid);
+    if (device) {
+        current_audio.impl.UnlockDevice(device);
+    }
+}
+
+void
+SDL_UnlockAudio(void)
+{
+    SDL_UnlockAudioDevice(1);
+}
+
+void
+SDL_CloseAudioDevice(SDL_AudioDeviceID devid)
+{
+    SDL_AudioDevice *device = get_audio_device(devid);
+    if (device) {
+        close_audio_device(device);
+        open_devices[devid - 1] = NULL;
+    }
+}
+
+void
+SDL_CloseAudio(void)
+{
+    SDL_CloseAudioDevice(1);
+}
+
+void
+SDL_AudioQuit(void)
+{
+    SDL_AudioDeviceID i;
+    for (i = 0; i < SDL_arraysize(open_devices); i++) {
+        SDL_CloseAudioDevice(i);
+    }
+
+    /* Free the driver data */
+    current_audio.impl.Deinitialize();
+    SDL_memset(&current_audio, '\0', sizeof(current_audio));
+    SDL_memset(open_devices, '\0', sizeof(open_devices));
+}
+
+#define NUM_FORMATS 10
+static int format_idx;
+static int format_idx_sub;
+static SDL_AudioFormat format_list[NUM_FORMATS][NUM_FORMATS] = {
+    {AUDIO_U8, AUDIO_S8, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB,
+     AUDIO_U16MSB, AUDIO_S32LSB, AUDIO_S32MSB, AUDIO_F32LSB, AUDIO_F32MSB},
+    {AUDIO_S8, AUDIO_U8, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_U16LSB,
+     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_F32LSB, AUDIO_F32MSB, AUDIO_S16LSB,
+     AUDIO_S16MSB, AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_U8, AUDIO_S8},
+    {AUDIO_S32MSB, AUDIO_S32LSB, AUDIO_F32MSB, AUDIO_F32LSB, AUDIO_S16MSB,
+     AUDIO_S16LSB, AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_U8, AUDIO_S8},
+    {AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_S32LSB, AUDIO_S32MSB, AUDIO_S16LSB,
+     AUDIO_S16MSB, AUDIO_U16LSB, AUDIO_U16MSB, AUDIO_U8, AUDIO_S8},
+    {AUDIO_F32MSB, AUDIO_F32LSB, AUDIO_S32MSB, AUDIO_S32LSB, AUDIO_S16MSB,
+     AUDIO_S16LSB, AUDIO_U16MSB, AUDIO_U16LSB, AUDIO_U8, AUDIO_S8},
+};
+
+SDL_AudioFormat
+SDL_FirstAudioFormat(SDL_AudioFormat format)
+{
+    for (format_idx = 0; format_idx < NUM_FORMATS; ++format_idx) {
+        if (format_list[format_idx][0] == format) {
+            break;
+        }
+    }
+    format_idx_sub = 0;
+    return (SDL_NextAudioFormat());
+}
+
+SDL_AudioFormat
+SDL_NextAudioFormat(void)
+{
+    if ((format_idx == NUM_FORMATS) || (format_idx_sub == NUM_FORMATS)) {
+        return (0);
+    }
+    return (format_list[format_idx][format_idx_sub++]);
+}
+
+void
+SDL_CalculateAudioSpec(SDL_AudioSpec * spec)
+{
+    switch (spec->format) {
+    case AUDIO_U8:
+        spec->silence = 0x80;
+        break;
+    default:
+        spec->silence = 0x00;
+        break;
+    }
+    spec->size = SDL_AUDIO_BITSIZE(spec->format) / 8;
+    spec->size *= spec->channels;
+    spec->size *= spec->samples;
+}
+
+
+/*
+ * Moved here from SDL_mixer.c, since it relies on internals of an opened
+ *  audio device (and is deprecated, by the way!).
+ */
+void
+SDL_MixAudio(Uint8 * dst, const Uint8 * src, Uint32 len, int volume)
+{
+    /* Mix the user-level audio format */
+    SDL_AudioDevice *device = get_audio_device(1);
+    if (device != NULL) {
+        SDL_AudioFormat format;
+        if (device->convert.needed) {
+            format = device->convert.src_format;
+        } else {
+            format = device->spec.format;
+        }
+        SDL_MixAudioFormat(dst, src, format, len, volume);
+    }
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/audio/SDL_audio_c.h b/macosx/plugins/Common/SDL/src/audio/SDL_audio_c.h
new file mode 100644
index 00000000..df88025f
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/audio/SDL_audio_c.h
@@ -0,0 +1,56 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+/* Functions and variables exported from SDL_audio.c for SDL_sysaudio.c */
+
+/* Functions to get a list of "close" audio formats */
+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[];
+
+/* this is used internally to access some autogenerated code. */
+typedef struct
+{
+    SDL_AudioFormat fmt;
+    int channels;
+    int upsample;
+    int multiple;
+    SDL_AudioFilter filter;
+} SDL_AudioRateFilters;
+extern const SDL_AudioRateFilters sdl_audio_rate_filters[];
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/audio/SDL_audiocvt.c b/macosx/plugins/Common/SDL/src/audio/SDL_audiocvt.c
new file mode 100644
index 00000000..3af35f13
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/audio/SDL_audiocvt.c
@@ -0,0 +1,1080 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+/* Functions for audio drivers to perform runtime conversion of audio format */
+
+#include "SDL_audio.h"
+#include "SDL_audio_c.h"
+
+/* #define DEBUG_CONVERT */
+
+/* !!! FIXME */
+#ifndef assert
+#define assert(x)
+#endif
+
+/* Effectively mix right and left channels into a single channel */
+static void SDLCALL
+SDL_ConvertMono(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    Sint32 sample;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting to mono\n");
+#endif
+    switch (format & (SDL_AUDIO_MASK_SIGNED | SDL_AUDIO_MASK_BITSIZE)) {
+    case AUDIO_U8:
+        {
+            Uint8 *src, *dst;
+
+            src = cvt->buf;
+            dst = cvt->buf;
+            for (i = cvt->len_cvt / 2; i; --i) {
+                sample = src[0] + src[1];
+                *dst = (Uint8) (sample / 2);
+                src += 2;
+                dst += 1;
+            }
+        }
+        break;
+
+    case AUDIO_S8:
+        {
+            Sint8 *src, *dst;
+
+            src = (Sint8 *) cvt->buf;
+            dst = (Sint8 *) cvt->buf;
+            for (i = cvt->len_cvt / 2; i; --i) {
+                sample = src[0] + src[1];
+                *dst = (Sint8) (sample / 2);
+                src += 2;
+                dst += 1;
+            }
+        }
+        break;
+
+    case AUDIO_U16:
+        {
+            Uint8 *src, *dst;
+
+            src = cvt->buf;
+            dst = cvt->buf;
+            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]);
+                    sample /= 2;
+                    dst[1] = (sample & 0xFF);
+                    sample >>= 8;
+                    dst[0] = (sample & 0xFF);
+                    src += 4;
+                    dst += 2;
+                }
+            } else {
+                for (i = cvt->len_cvt / 4; i; --i) {
+                    sample = (Uint16) ((src[1] << 8) | src[0]) +
+                        (Uint16) ((src[3] << 8) | src[2]);
+                    sample /= 2;
+                    dst[0] = (sample & 0xFF);
+                    sample >>= 8;
+                    dst[1] = (sample & 0xFF);
+                    src += 4;
+                    dst += 2;
+                }
+            }
+        }
+        break;
+
+    case AUDIO_S16:
+        {
+            Uint8 *src, *dst;
+
+            src = cvt->buf;
+            dst = cvt->buf;
+            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]);
+                    sample /= 2;
+                    dst[1] = (sample & 0xFF);
+                    sample >>= 8;
+                    dst[0] = (sample & 0xFF);
+                    src += 4;
+                    dst += 2;
+                }
+            } else {
+                for (i = cvt->len_cvt / 4; i; --i) {
+                    sample = (Sint16) ((src[1] << 8) | src[0]) +
+                        (Sint16) ((src[3] << 8) | src[2]);
+                    sample /= 2;
+                    dst[0] = (sample & 0xFF);
+                    sample >>= 8;
+                    dst[1] = (sample & 0xFF);
+                    src += 4;
+                    dst += 2;
+                }
+            }
+        }
+        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 / 2)));
+                }
+            } 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 / 2)));
+                }
+            }
+        }
+        break;
+
+    case AUDIO_F32:
+        {
+            const float *src = (const float *) cvt->buf;
+            float *dst = (float *) cvt->buf;
+            if (SDL_AUDIO_ISBIGENDIAN(format)) {
+                for (i = cvt->len_cvt / 8; i; --i, src += 2) {
+                    const float src1 = SDL_SwapFloatBE(src[0]);
+                    const float src2 = SDL_SwapFloatBE(src[1]);
+                    const double added = ((double) src1) + ((double) src2);
+                    const float halved = (float) (added * 0.5);
+                    *(dst++) = SDL_SwapFloatBE(halved);
+                }
+            } else {
+                for (i = cvt->len_cvt / 8; i; --i, src += 2) {
+                    const float src1 = SDL_SwapFloatLE(src[0]);
+                    const float src2 = SDL_SwapFloatLE(src[1]);
+                    const double added = ((double) src1) + ((double) src2);
+                    const float halved = (float) (added * 0.5);
+                    *(dst++) = SDL_SwapFloatLE(halved);
+                }
+            }
+        }
+        break;
+    }
+
+    cvt->len_cvt /= 2;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+
+/* Discard top 4 channels */
+static void SDLCALL
+SDL_ConvertStrip(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting down from 6 channels to stereo\n");
+#endif
+
+#define strip_chans_6_to_2(type) \
+    { \
+        const type *src = (const type *) cvt->buf; \
+        type *dst = (type *) cvt->buf; \
+        for (i = cvt->len_cvt / (sizeof (type) * 6); i; --i) { \
+            dst[0] = src[0]; \
+            dst[1] = src[1]; \
+            src += 6; \
+            dst += 2; \
+        } \
+    }
+
+    /* this function only cares about typesize, and data as a block of bits. */
+    switch (SDL_AUDIO_BITSIZE(format)) {
+    case 8:
+        strip_chans_6_to_2(Uint8);
+        break;
+    case 16:
+        strip_chans_6_to_2(Uint16);
+        break;
+    case 32:
+        strip_chans_6_to_2(Uint32);
+        break;
+    }
+
+#undef strip_chans_6_to_2
+
+    cvt->len_cvt /= 3;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+
+/* Discard top 2 channels of 6 */
+static void SDLCALL
+SDL_ConvertStrip_2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting 6 down to quad\n");
+#endif
+
+#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; \
+        } \
+    }
+
+    /* this function only cares about typesize, and data as a block of bits. */
+    switch (SDL_AUDIO_BITSIZE(format)) {
+    case 8:
+        strip_chans_6_to_4(Uint8);
+        break;
+    case 16:
+        strip_chans_6_to_4(Uint16);
+        break;
+    case 32:
+        strip_chans_6_to_4(Uint32);
+        break;
+    }
+
+#undef strip_chans_6_to_4
+
+    cvt->len_cvt /= 6;
+    cvt->len_cvt *= 4;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+/* Duplicate a mono channel to both stereo channels */
+static void SDLCALL
+SDL_ConvertStereo(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+
+#ifdef DEBUG_CONVERT
+    fprintf(stderr, "Converting to stereo\n");
+#endif
+
+#define dup_chans_1_to_2(type) \
+    { \
+        const type *src = (const type *) (cvt->buf + cvt->len_cvt); \
+        type *dst = (type *) (cvt->buf + cvt->len_cvt * 2); \
+        for (i = cvt->len_cvt / 2; i; --i, --src) { \
+            const type val = *src; \
+            dst -= 2; \
+            dst[0] = dst[1] = val; \
+        } \
+    }
+
+    /* this function only cares about typesize, and data as a block of bits. */
+    switch (SDL_AUDIO_BITSIZE(format)) {
+    case 8:
+        dup_chans_1_to_2(Uint8);
+        break;
+    case 16:
+        dup_chans_1_to_2(Uint16);
+        break;
+    case 32:
+        dup_chans_1_to_2(Uint32);
+        break;
+    }
+
+#undef dup_chans_1_to_2
+
+    cvt->len_cvt *= 2;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+
+/* Duplicate a stereo channel to a pseudo-5.1 stream */
+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 & (SDL_AUDIO_MASK_SIGNED | SDL_AUDIO_MASK_BITSIZE)) {
+    case AUDIO_U8:
+        {
+            Uint8 *src, *dst, lf, rf, ce;
+
+            src = (Uint8 *) (cvt->buf + cvt->len_cvt);
+            dst = (Uint8 *) (cvt->buf + cvt->len_cvt * 3);
+            for (i = cvt->len_cvt; i; --i) {
+                dst -= 6;
+                src -= 2;
+                lf = src[0];
+                rf = src[1];
+                ce = (lf / 2) + (rf / 2);
+                dst[0] = lf;
+                dst[1] = rf;
+                dst[2] = lf - ce;
+                dst[3] = rf - ce;
+                dst[4] = ce;
+                dst[5] = ce;
+            }
+        }
+        break;
+
+    case AUDIO_S8:
+        {
+            Sint8 *src, *dst, lf, rf, ce;
+
+            src = (Sint8 *) cvt->buf + cvt->len_cvt;
+            dst = (Sint8 *) cvt->buf + cvt->len_cvt * 3;
+            for (i = cvt->len_cvt; i; --i) {
+                dst -= 6;
+                src -= 2;
+                lf = src[0];
+                rf = src[1];
+                ce = (lf / 2) + (rf / 2);
+                dst[0] = lf;
+                dst[1] = rf;
+                dst[2] = lf - ce;
+                dst[3] = rf - ce;
+                dst[4] = ce;
+                dst[5] = ce;
+            }
+        }
+        break;
+
+    case AUDIO_U16:
+        {
+            Uint8 *src, *dst;
+            Uint16 lf, rf, ce, lr, rr;
+
+            src = cvt->buf + cvt->len_cvt;
+            dst = cvt->buf + cvt->len_cvt * 3;
+
+            if (SDL_AUDIO_ISBIGENDIAN(format)) {
+                for (i = cvt->len_cvt / 4; i; --i) {
+                    dst -= 12;
+                    src -= 4;
+                    lf = (Uint16) ((src[0] << 8) | src[1]);
+                    rf = (Uint16) ((src[2] << 8) | src[3]);
+                    ce = (lf / 2) + (rf / 2);
+                    rr = lf - ce;
+                    lr = rf - ce;
+                    dst[1] = (lf & 0xFF);
+                    dst[0] = ((lf >> 8) & 0xFF);
+                    dst[3] = (rf & 0xFF);
+                    dst[2] = ((rf >> 8) & 0xFF);
+
+                    dst[1 + 4] = (lr & 0xFF);
+                    dst[0 + 4] = ((lr >> 8) & 0xFF);
+                    dst[3 + 4] = (rr & 0xFF);
+                    dst[2 + 4] = ((rr >> 8) & 0xFF);
+
+                    dst[1 + 8] = (ce & 0xFF);
+                    dst[0 + 8] = ((ce >> 8) & 0xFF);
+                    dst[3 + 8] = (ce & 0xFF);
+                    dst[2 + 8] = ((ce >> 8) & 0xFF);
+                }
+            } else {
+                for (i = cvt->len_cvt / 4; i; --i) {
+                    dst -= 12;
+                    src -= 4;
+                    lf = (Uint16) ((src[1] << 8) | src[0]);
+                    rf = (Uint16) ((src[3] << 8) | src[2]);
+                    ce = (lf / 2) + (rf / 2);
+                    rr = lf - ce;
+                    lr = rf - ce;
+                    dst[0] = (lf & 0xFF);
+                    dst[1] = ((lf >> 8) & 0xFF);
+                    dst[2] = (rf & 0xFF);
+                    dst[3] = ((rf >> 8) & 0xFF);
+
+                    dst[0 + 4] = (lr & 0xFF);
+                    dst[1 + 4] = ((lr >> 8) & 0xFF);
+                    dst[2 + 4] = (rr & 0xFF);
+                    dst[3 + 4] = ((rr >> 8) & 0xFF);
+
+                    dst[0 + 8] = (ce & 0xFF);
+                    dst[1 + 8] = ((ce >> 8) & 0xFF);
+                    dst[2 + 8] = (ce & 0xFF);
+                    dst[3 + 8] = ((ce >> 8) & 0xFF);
+                }
+            }
+        }
+        break;
+
+    case AUDIO_S16:
+        {
+            Uint8 *src, *dst;
+            Sint16 lf, rf, ce, lr, rr;
+
+            src = cvt->buf + cvt->len_cvt;
+            dst = cvt->buf + cvt->len_cvt * 3;
+
+            if (SDL_AUDIO_ISBIGENDIAN(format)) {
+                for (i = cvt->len_cvt / 4; i; --i) {
+                    dst -= 12;
+                    src -= 4;
+                    lf = (Sint16) ((src[0] << 8) | src[1]);
+                    rf = (Sint16) ((src[2] << 8) | src[3]);
+                    ce = (lf / 2) + (rf / 2);
+                    rr = lf - ce;
+                    lr = rf - ce;
+                    dst[1] = (lf & 0xFF);
+                    dst[0] = ((lf >> 8) & 0xFF);
+                    dst[3] = (rf & 0xFF);
+                    dst[2] = ((rf >> 8) & 0xFF);
+
+                    dst[1 + 4] = (lr & 0xFF);
+                    dst[0 + 4] = ((lr >> 8) & 0xFF);
+                    dst[3 + 4] = (rr & 0xFF);
+                    dst[2 + 4] = ((rr >> 8) & 0xFF);
+
+                    dst[1 + 8] = (ce & 0xFF);
+                    dst[0 + 8] = ((ce >> 8) & 0xFF);
+                    dst[3 + 8] = (ce & 0xFF);
+                    dst[2 + 8] = ((ce >> 8) & 0xFF);
+                }
+            } else {
+                for (i = cvt->len_cvt / 4; i; --i) {
+                    dst -= 12;
+                    src -= 4;
+                    lf = (Sint16) ((src[1] << 8) | src[0]);
+                    rf = (Sint16) ((src[3] << 8) | src[2]);
+                    ce = (lf / 2) + (rf / 2);
+                    rr = lf - ce;
+                    lr = rf - ce;
+                    dst[0] = (lf & 0xFF);
+                    dst[1] = ((lf >> 8) & 0xFF);
+                    dst[2] = (rf & 0xFF);
+                    dst[3] = ((rf >> 8) & 0xFF);
+
+                    dst[0 + 4] = (lr & 0xFF);
+                    dst[1 + 4] = ((lr >> 8) & 0xFF);
+                    dst[2 + 4] = (rr & 0xFF);
+                    dst[3 + 4] = ((rr >> 8) & 0xFF);
+
+                    dst[0 + 8] = (ce & 0xFF);
+                    dst[1 + 8] = ((ce >> 8) & 0xFF);
+                    dst[2 + 8] = (ce & 0xFF);
+                    dst[3 + 8] = ((ce >> 8) & 0xFF);
+                }
+            }
+        }
+        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:
+        {
+            float lf, rf, ce;
+            const float *src = (const float *) cvt->buf + cvt->len_cvt;
+            float *dst = (float *) cvt->buf + cvt->len_cvt * 3;
+
+            if (SDL_AUDIO_ISBIGENDIAN(format)) {
+                for (i = cvt->len_cvt / 8; i; --i) {
+                    dst -= 6;
+                    src -= 2;
+                    lf = SDL_SwapFloatBE(src[0]);
+                    rf = SDL_SwapFloatBE(src[1]);
+                    ce = (lf * 0.5f) + (rf * 0.5f);
+                    dst[0] = src[0];
+                    dst[1] = src[1];
+                    dst[2] = SDL_SwapFloatBE(lf - ce);
+                    dst[3] = SDL_SwapFloatBE(rf - ce);
+                    dst[4] = dst[5] = SDL_SwapFloatBE(ce);
+                }
+            } else {
+                for (i = cvt->len_cvt / 8; i; --i) {
+                    dst -= 6;
+                    src -= 2;
+                    lf = SDL_SwapFloatLE(src[0]);
+                    rf = SDL_SwapFloatLE(src[1]);
+                    ce = (lf * 0.5f) + (rf * 0.5f);
+                    dst[0] = src[0];
+                    dst[1] = src[1];
+                    dst[2] = SDL_SwapFloatLE(lf - ce);
+                    dst[3] = SDL_SwapFloatLE(rf - ce);
+                    dst[4] = dst[5] = SDL_SwapFloatLE(ce);
+                }
+            }
+        }
+        break;
+
+    }
+    cvt->len_cvt *= 3;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+
+/* Duplicate a stereo channel to a pseudo-4.0 stream */
+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 & (SDL_AUDIO_MASK_SIGNED | SDL_AUDIO_MASK_BITSIZE)) {
+    case AUDIO_U8:
+        {
+            Uint8 *src, *dst, lf, rf, ce;
+
+            src = (Uint8 *) (cvt->buf + cvt->len_cvt);
+            dst = (Uint8 *) (cvt->buf + cvt->len_cvt * 2);
+            for (i = cvt->len_cvt; i; --i) {
+                dst -= 4;
+                src -= 2;
+                lf = src[0];
+                rf = src[1];
+                ce = (lf / 2) + (rf / 2);
+                dst[0] = lf;
+                dst[1] = rf;
+                dst[2] = lf - ce;
+                dst[3] = rf - ce;
+            }
+        }
+        break;
+
+    case AUDIO_S8:
+        {
+            Sint8 *src, *dst, lf, rf, ce;
+
+            src = (Sint8 *) cvt->buf + cvt->len_cvt;
+            dst = (Sint8 *) cvt->buf + cvt->len_cvt * 2;
+            for (i = cvt->len_cvt; i; --i) {
+                dst -= 4;
+                src -= 2;
+                lf = src[0];
+                rf = src[1];
+                ce = (lf / 2) + (rf / 2);
+                dst[0] = lf;
+                dst[1] = rf;
+                dst[2] = lf - ce;
+                dst[3] = rf - ce;
+            }
+        }
+        break;
+
+    case AUDIO_U16:
+        {
+            Uint8 *src, *dst;
+            Uint16 lf, rf, ce, lr, rr;
+
+            src = cvt->buf + cvt->len_cvt;
+            dst = cvt->buf + cvt->len_cvt * 2;
+
+            if (SDL_AUDIO_ISBIGENDIAN(format)) {
+                for (i = cvt->len_cvt / 4; i; --i) {
+                    dst -= 8;
+                    src -= 4;
+                    lf = (Uint16) ((src[0] << 8) | src[1]);
+                    rf = (Uint16) ((src[2] << 8) | src[3]);
+                    ce = (lf / 2) + (rf / 2);
+                    rr = lf - ce;
+                    lr = rf - ce;
+                    dst[1] = (lf & 0xFF);
+                    dst[0] = ((lf >> 8) & 0xFF);
+                    dst[3] = (rf & 0xFF);
+                    dst[2] = ((rf >> 8) & 0xFF);
+
+                    dst[1 + 4] = (lr & 0xFF);
+                    dst[0 + 4] = ((lr >> 8) & 0xFF);
+                    dst[3 + 4] = (rr & 0xFF);
+                    dst[2 + 4] = ((rr >> 8) & 0xFF);
+                }
+            } else {
+                for (i = cvt->len_cvt / 4; i; --i) {
+                    dst -= 8;
+                    src -= 4;
+                    lf = (Uint16) ((src[1] << 8) | src[0]);
+                    rf = (Uint16) ((src[3] << 8) | src[2]);
+                    ce = (lf / 2) + (rf / 2);
+                    rr = lf - ce;
+                    lr = rf - ce;
+                    dst[0] = (lf & 0xFF);
+                    dst[1] = ((lf >> 8) & 0xFF);
+                    dst[2] = (rf & 0xFF);
+                    dst[3] = ((rf >> 8) & 0xFF);
+
+                    dst[0 + 4] = (lr & 0xFF);
+                    dst[1 + 4] = ((lr >> 8) & 0xFF);
+                    dst[2 + 4] = (rr & 0xFF);
+                    dst[3 + 4] = ((rr >> 8) & 0xFF);
+                }
+            }
+        }
+        break;
+
+    case AUDIO_S16:
+        {
+            Uint8 *src, *dst;
+            Sint16 lf, rf, ce, lr, rr;
+
+            src = cvt->buf + cvt->len_cvt;
+            dst = cvt->buf + cvt->len_cvt * 2;
+
+            if (SDL_AUDIO_ISBIGENDIAN(format)) {
+                for (i = cvt->len_cvt / 4; i; --i) {
+                    dst -= 8;
+                    src -= 4;
+                    lf = (Sint16) ((src[0] << 8) | src[1]);
+                    rf = (Sint16) ((src[2] << 8) | src[3]);
+                    ce = (lf / 2) + (rf / 2);
+                    rr = lf - ce;
+                    lr = rf - ce;
+                    dst[1] = (lf & 0xFF);
+                    dst[0] = ((lf >> 8) & 0xFF);
+                    dst[3] = (rf & 0xFF);
+                    dst[2] = ((rf >> 8) & 0xFF);
+
+                    dst[1 + 4] = (lr & 0xFF);
+                    dst[0 + 4] = ((lr >> 8) & 0xFF);
+                    dst[3 + 4] = (rr & 0xFF);
+                    dst[2 + 4] = ((rr >> 8) & 0xFF);
+                }
+            } else {
+                for (i = cvt->len_cvt / 4; i; --i) {
+                    dst -= 8;
+                    src -= 4;
+                    lf = (Sint16) ((src[1] << 8) | src[0]);
+                    rf = (Sint16) ((src[3] << 8) | src[2]);
+                    ce = (lf / 2) + (rf / 2);
+                    rr = lf - ce;
+                    lr = rf - ce;
+                    dst[0] = (lf & 0xFF);
+                    dst[1] = ((lf >> 8) & 0xFF);
+                    dst[2] = (rf & 0xFF);
+                    dst[3] = ((rf >> 8) & 0xFF);
+
+                    dst[0 + 4] = (lr & 0xFF);
+                    dst[1 + 4] = ((lr >> 8) & 0xFF);
+                    dst[2 + 4] = (rr & 0xFF);
+                    dst[3 + 4] = ((rr >> 8) & 0xFF);
+                }
+            }
+        }
+        break;
+
+    case AUDIO_S32:
+        {
+            const Uint32 *src = (const Uint32 *) (cvt->buf + cvt->len_cvt);
+            Uint32 *dst = (Uint32 *) (cvt->buf + cvt->len_cvt * 2);
+            Sint32 lf, rf, ce;
+
+            if (SDL_AUDIO_ISBIGENDIAN(format)) {
+                for (i = cvt->len_cvt / 8; i; --i) {
+                    dst -= 4;
+                    src -= 2;
+                    lf = (Sint32) SDL_SwapBE32(src[0]);
+                    rf = (Sint32) SDL_SwapBE32(src[1]);
+                    ce = (lf / 2) + (rf / 2);
+                    dst[0] = src[0];
+                    dst[1] = src[1];
+                    dst[2] = SDL_SwapBE32((Uint32) (lf - ce));
+                    dst[3] = SDL_SwapBE32((Uint32) (rf - ce));
+                }
+            } else {
+                for (i = cvt->len_cvt / 8; i; --i) {
+                    dst -= 4;
+                    src -= 2;
+                    lf = (Sint32) SDL_SwapLE32(src[0]);
+                    rf = (Sint32) SDL_SwapLE32(src[1]);
+                    ce = (lf / 2) + (rf / 2);
+                    dst[0] = src[0];
+                    dst[1] = src[1];
+                    dst[2] = SDL_SwapLE32((Uint32) (lf - ce));
+                    dst[3] = SDL_SwapLE32((Uint32) (rf - ce));
+                }
+            }
+        }
+        break;
+    }
+    cvt->len_cvt *= 2;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+
+int
+SDL_ConvertAudio(SDL_AudioCVT * cvt)
+{
+    /* !!! FIXME: (cvt) should be const; stack-copy it here. */
+    /* !!! FIXME: (actually, we can't...len_cvt needs to be updated. Grr.) */
+
+    /* Make sure there's data to convert */
+    if (cvt->buf == NULL) {
+        SDL_SetError("No buffer allocated for conversion");
+        return (-1);
+    }
+    /* Return okay if no conversion is necessary */
+    cvt->len_cvt = cvt->len;
+    if (cvt->filters[0] == NULL) {
+        return (0);
+    }
+
+    /* Set up the conversion and go! */
+    cvt->filter_index = 0;
+    cvt->filters[0] (cvt, cvt->src_format);
+    return (0);
+}
+
+
+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) {
+                SDL_SetError("No conversion available for these formats");
+                return -1;
+            }
+        }
+
+        /* 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. */
+}
+
+
+static SDL_AudioFilter
+SDL_HandTunedResampleCVT(SDL_AudioCVT * cvt, int dst_channels,
+                         int src_rate, int dst_rate)
+{
+    /*
+     * Fill in any future conversions that are specialized to a
+     *  processor, platform, compiler, or library here.
+     */
+
+    return NULL;                /* no specialized converter code available. */
+}
+
+static int
+SDL_FindFrequencyMultiple(const int src_rate, const int dst_rate)
+{
+    int retval = 0;
+
+    /* If we only built with the arbitrary resamplers, ignore multiples. */
+#if !LESS_RESAMPLERS
+    int lo, hi;
+    int div;
+
+    assert(src_rate != 0);
+    assert(dst_rate != 0);
+    assert(src_rate != dst_rate);
+
+    if (src_rate < dst_rate) {
+        lo = src_rate;
+        hi = dst_rate;
+    } else {
+        lo = dst_rate;
+        hi = src_rate;
+    }
+
+    /* zero means "not a supported multiple" ... we only do 2x and 4x. */
+    if ((hi % lo) != 0)
+        return 0;               /* not a multiple. */
+
+    div = hi / lo;
+    retval = ((div == 2) || (div == 4)) ? div : 0;
+#endif
+
+    return retval;
+}
+
+static int
+SDL_BuildAudioResampleCVT(SDL_AudioCVT * cvt, int dst_channels,
+                          int src_rate, int dst_rate)
+{
+    if (src_rate != dst_rate) {
+        SDL_AudioFilter filter = SDL_HandTunedResampleCVT(cvt, dst_channels,
+                                                          src_rate, dst_rate);
+
+        /* No hand-tuned converter? Try the autogenerated ones. */
+        if (filter == NULL) {
+            int i;
+            const int upsample = (src_rate < dst_rate) ? 1 : 0;
+            const int multiple =
+                SDL_FindFrequencyMultiple(src_rate, dst_rate);
+
+            for (i = 0; sdl_audio_rate_filters[i].filter != NULL; i++) {
+                const SDL_AudioRateFilters *filt = &sdl_audio_rate_filters[i];
+                if ((filt->fmt == cvt->dst_format) &&
+                    (filt->channels == dst_channels) &&
+                    (filt->upsample == upsample) &&
+                    (filt->multiple == multiple)) {
+                    filter = filt->filter;
+                    break;
+                }
+            }
+
+            if (filter == NULL) {
+                SDL_SetError("No conversion available for these rates");
+                return -1;
+            }
+        }
+
+        /* Update (cvt) with filter details... */
+        cvt->filters[cvt->filter_index++] = filter;
+        if (src_rate < dst_rate) {
+            const double mult = ((double) dst_rate) / ((double) src_rate);
+            cvt->len_mult *= (int) SDL_ceil(mult);
+            cvt->len_ratio *= mult;
+        } else {
+            cvt->len_ratio /= ((double) src_rate) / ((double) dst_rate);
+        }
+
+        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,
+                  SDL_AudioFormat src_fmt, Uint8 src_channels, int src_rate,
+                  SDL_AudioFormat dst_fmt, Uint8 dst_channels, int dst_rate)
+{
+    /*
+     * !!! FIXME: reorder filters based on which grow/shrink the buffer.
+     * !!! FIXME: ideally, we should do everything that shrinks the buffer
+     * !!! FIXME: first, so we don't have to process as many bytes in a given
+     * !!! FIXME: filter and abuse the CPU cache less. This might not be as
+     * !!! FIXME: good in practice as it sounds in theory, though.
+     */
+
+    /* there are no unsigned types over 16 bits, so catch this up front. */
+    if ((SDL_AUDIO_BITSIZE(src_fmt) > 16) && (!SDL_AUDIO_ISSIGNED(src_fmt))) {
+        SDL_SetError("Invalid source format");
+        return -1;
+    }
+    if ((SDL_AUDIO_BITSIZE(dst_fmt) > 16) && (!SDL_AUDIO_ISSIGNED(dst_fmt))) {
+        SDL_SetError("Invalid destination format");
+        return -1;
+    }
+
+    /* prevent possible divisions by zero, etc. */
+    if ((src_rate == 0) || (dst_rate == 0)) {
+        SDL_SetError("Source or destination rate is zero");
+        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 */
+    SDL_zerop(cvt);
+    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;
+    cvt->rate_incr = ((double) dst_rate) / ((double) src_rate);
+
+    /* 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... */
+    }
+
+    /* Channel conversion */
+    if (src_channels != dst_channels) {
+        if ((src_channels == 1) && (dst_channels > 1)) {
+            cvt->filters[cvt->filter_index++] = SDL_ConvertStereo;
+            cvt->len_mult *= 2;
+            src_channels = 2;
+            cvt->len_ratio *= 2;
+        }
+        if ((src_channels == 2) && (dst_channels == 6)) {
+            cvt->filters[cvt->filter_index++] = SDL_ConvertSurround;
+            src_channels = 6;
+            cvt->len_mult *= 3;
+            cvt->len_ratio *= 3;
+        }
+        if ((src_channels == 2) && (dst_channels == 4)) {
+            cvt->filters[cvt->filter_index++] = SDL_ConvertSurround_4;
+            src_channels = 4;
+            cvt->len_mult *= 2;
+            cvt->len_ratio *= 2;
+        }
+        while ((src_channels * 2) <= dst_channels) {
+            cvt->filters[cvt->filter_index++] = SDL_ConvertStereo;
+            cvt->len_mult *= 2;
+            src_channels *= 2;
+            cvt->len_ratio *= 2;
+        }
+        if ((src_channels == 6) && (dst_channels <= 2)) {
+            cvt->filters[cvt->filter_index++] = SDL_ConvertStrip;
+            src_channels = 2;
+            cvt->len_ratio /= 3;
+        }
+        if ((src_channels == 6) && (dst_channels == 4)) {
+            cvt->filters[cvt->filter_index++] = SDL_ConvertStrip_2;
+            src_channels = 4;
+            cvt->len_ratio /= 2;
+        }
+        /* This assumes that 4 channel audio is in the format:
+           Left {front/back} + Right {front/back}
+           so converting to L/R stereo works properly.
+         */
+        while (((src_channels % 2) == 0) &&
+               ((src_channels / 2) >= dst_channels)) {
+            cvt->filters[cvt->filter_index++] = SDL_ConvertMono;
+            src_channels /= 2;
+            cvt->len_ratio /= 2;
+        }
+        if (src_channels != dst_channels) {
+            /* Uh oh.. */ ;
+        }
+    }
+
+    /* Do rate conversion, if necessary. Updates (cvt). */
+    if (SDL_BuildAudioResampleCVT(cvt, dst_channels, src_rate, dst_rate) ==
+        -1) {
+        return -1;              /* shouldn't happen, but just in case... */
+    }
+
+    /* Set up the filter information */
+    if (cvt->filter_index != 0) {
+        cvt->needed = 1;
+        cvt->src_format = src_fmt;
+        cvt->dst_format = dst_fmt;
+        cvt->len = 0;
+        cvt->buf = NULL;
+        cvt->filters[cvt->filter_index] = NULL;
+    }
+    return (cvt->needed);
+}
+
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/audio/SDL_audiomem.h b/macosx/plugins/Common/SDL/src/audio/SDL_audiomem.h
new file mode 100644
index 00000000..a539259e
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/audio/SDL_audiomem.h
@@ -0,0 +1,26 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+#define SDL_AllocAudioMem	SDL_malloc
+#define SDL_FreeAudioMem	SDL_free
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/audio/SDL_audiotypecvt.c b/macosx/plugins/Common/SDL/src/audio/SDL_audiotypecvt.c
new file mode 100644
index 00000000..30f26152
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/audio/SDL_audiotypecvt.c
@@ -0,0 +1,16216 @@
+/* DO NOT EDIT!  This file is generated by sdlgenaudiocvt.pl */
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+#ifndef DEBUG_CONVERT
+#define DEBUG_CONVERT 0
+#endif
+
+
+/* If you can guarantee your data and need space, you can eliminate code... */
+
+/* Just build the arbitrary resamplers if you're saving code space. */
+#ifndef LESS_RESAMPLERS
+#define LESS_RESAMPLERS 1
+#endif
+
+/* Don't build any resamplers if you're REALLY saving code space. */
+#ifndef NO_RESAMPLERS
+#define NO_RESAMPLERS 0
+#endif
+
+/* Don't build any type converters if you're saving code space. */
+#ifndef NO_CONVERTERS
+#define NO_CONVERTERS 0
+#endif
+
+
+/* *INDENT-OFF* */
+
+#define DIVBY127 0.0078740157480315f
+#define DIVBY32767 3.05185094759972e-05f
+#define DIVBY2147483647 4.6566128752458e-10f
+
+#if !NO_CONVERTERS
+
+static void SDLCALL
+SDL_Convert_U8_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Sint8 *dst;
+
+#if 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);
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S8);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U8_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Uint16 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U8 to AUDIO_U16LSB.\n");
+#endif
+
+    src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Uint16 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U16LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U8_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Sint16 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S16LSB.\n");
+#endif
+
+    src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Sint16 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S16LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U8_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Uint16 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U8 to AUDIO_U16MSB.\n");
+#endif
+
+    src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Uint16 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U16MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U8_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Sint16 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S16MSB.\n");
+#endif
+
+    src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Sint16 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S16MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U8_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Sint32 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S32LSB.\n");
+#endif
+
+    src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 4)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S32LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U8_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Sint32 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S32MSB.\n");
+#endif
+
+    src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 4)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S32MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U8_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    float *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U8 to AUDIO_F32LSB.\n");
+#endif
+
+    src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((float *) (cvt->buf + cvt->len_cvt * 4)) - 1;
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
+        const float val = ((((float) *src) * DIVBY127) - 1.0f);
+        *dst = SDL_SwapFloatLE(val);
+    }
+
+    cvt->len_cvt *= 4;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_F32LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U8_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    float *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U8 to AUDIO_F32MSB.\n");
+#endif
+
+    src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((float *) (cvt->buf + cvt->len_cvt * 4)) - 1;
+    for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
+        const float val = ((((float) *src) * DIVBY127) - 1.0f);
+        *dst = SDL_SwapFloatBE(val);
+    }
+
+    cvt->len_cvt *= 4;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_F32MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S8_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Uint8 *dst;
+
+#if 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;
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U8);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S8_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Uint16 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S8 to AUDIO_U16LSB.\n");
+#endif
+
+    src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Uint16 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U16LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S8_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Sint16 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S16LSB.\n");
+#endif
+
+    src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Sint16 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S16LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S8_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Uint16 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S8 to AUDIO_U16MSB.\n");
+#endif
+
+    src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Uint16 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U16MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S8_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Sint16 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S16MSB.\n");
+#endif
+
+    src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Sint16 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S16MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S8_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Sint32 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S32LSB.\n");
+#endif
+
+    src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 4)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S32LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S8_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    Sint32 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S32MSB.\n");
+#endif
+
+    src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 4)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S32MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S8_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    float *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S8 to AUDIO_F32LSB.\n");
+#endif
+
+    src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((float *) (cvt->buf + cvt->len_cvt * 4)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_F32LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S8_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint8 *src;
+    float *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S8 to AUDIO_F32MSB.\n");
+#endif
+
+    src = ((const Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((float *) (cvt->buf + cvt->len_cvt * 4)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_F32MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint8 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U8);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint8 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S8);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16LSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint16 *dst;
+
+#if 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));
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S16LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint16 *dst;
+
+#if 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);
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U16MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint16 *dst;
+
+#if 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));
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S16MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16LSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint32 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S32LSB.\n");
+#endif
+
+    src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S32LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint32 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S32MSB.\n");
+#endif
+
+    src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S32MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16LSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    float *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_F32LSB.\n");
+#endif
+
+    src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((float *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const float val = ((((float) SDL_SwapLE16(*src)) * DIVBY32767) - 1.0f);
+        *dst = SDL_SwapFloatLE(val);
+    }
+
+    cvt->len_cvt *= 2;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_F32LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    float *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_F32MSB.\n");
+#endif
+
+    src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((float *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const float val = ((((float) SDL_SwapLE16(*src)) * DIVBY32767) - 1.0f);
+        *dst = SDL_SwapFloatBE(val);
+    }
+
+    cvt->len_cvt *= 2;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_F32MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint8 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U8);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint8 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S8);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16LSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint16 *dst;
+
+#if 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);
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U16LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint16 *dst;
+
+#if 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);
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U16MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint16 *dst;
+
+#if 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));
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S16MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16LSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint32 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S32LSB.\n");
+#endif
+
+    src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S32LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint32 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S32MSB.\n");
+#endif
+
+    src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S32MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16LSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    float *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_F32LSB.\n");
+#endif
+
+    src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((float *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_F32LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    float *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_F32MSB.\n");
+#endif
+
+    src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((float *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_F32MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint8 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U8);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint8 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S8);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint16 *dst;
+
+#if 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);
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U16LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint16 *dst;
+
+#if 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));
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S16LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16MSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint16 *dst;
+
+#if 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));
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S16MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint32 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S32LSB.\n");
+#endif
+
+    src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S32LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16MSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint32 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S32MSB.\n");
+#endif
+
+    src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S32MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    float *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_F32LSB.\n");
+#endif
+
+    src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((float *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const float val = ((((float) SDL_SwapBE16(*src)) * DIVBY32767) - 1.0f);
+        *dst = SDL_SwapFloatLE(val);
+    }
+
+    cvt->len_cvt *= 2;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_F32LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_U16MSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    float *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_F32MSB.\n");
+#endif
+
+    src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((float *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
+        const float val = ((((float) SDL_SwapBE16(*src)) * DIVBY32767) - 1.0f);
+        *dst = SDL_SwapFloatBE(val);
+    }
+
+    cvt->len_cvt *= 2;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_F32MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint8 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U8);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint8 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S8);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint16 *dst;
+
+#if 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);
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U16LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint16 *dst;
+
+#if 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));
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S16LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16MSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Uint16 *dst;
+
+#if 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);
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U16MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint32 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S32LSB.\n");
+#endif
+
+    src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S32LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16MSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    Sint32 *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S32MSB.\n");
+#endif
+
+    src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((Sint32 *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S32MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    float *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_F32LSB.\n");
+#endif
+
+    src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((float *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_F32LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S16MSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint16 *src;
+    float *dst;
+
+#if DEBUG_CONVERT
+    fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_F32MSB.\n");
+#endif
+
+    src = ((const Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    dst = ((float *) (cvt->buf + cvt->len_cvt * 2)) - 1;
+    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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_F32MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Uint8 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U8);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Sint8 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S8);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32LSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Uint16 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U16LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32LSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Sint16 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S16LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Uint16 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U16MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Sint16 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S16MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Sint32 *dst;
+
+#if 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));
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S32MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32LSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    float *dst;
+
+#if 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);
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_F32LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    float *dst;
+
+#if 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);
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_F32MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Uint8 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U8);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Sint8 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S8);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Uint16 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U16LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Sint16 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S16LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32MSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Uint16 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U16MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32MSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Sint16 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S16MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    Sint32 *dst;
+
+#if 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));
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S32LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    float *dst;
+
+#if 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);
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_F32LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_S32MSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const Uint32 *src;
+    float *dst;
+
+#if 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);
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_F32MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Uint8 *dst;
+
+#if 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) + 1.0f) * 127.0f));
+        *dst = val;
+    }
+
+    cvt->len_cvt /= 4;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U8);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint8 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S8);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32LSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Uint16 *dst;
+
+#if 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) + 1.0f) * 32767.0f));
+        *dst = SDL_SwapLE16(val);
+    }
+
+    cvt->len_cvt /= 2;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U16LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32LSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint16 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S16LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Uint16 *dst;
+
+#if 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) + 1.0f) * 32767.0f));
+        *dst = SDL_SwapBE16(val);
+    }
+
+    cvt->len_cvt /= 2;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U16MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint16 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S16MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32LSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint32 *dst;
+
+#if 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));
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S32LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint32 *dst;
+
+#if 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));
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S32MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    float *dst;
+
+#if 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);
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_F32MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Uint8 *dst;
+
+#if 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) + 1.0f) * 127.0f));
+        *dst = val;
+    }
+
+    cvt->len_cvt /= 4;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U8);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint8 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S8);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Uint16 *dst;
+
+#if 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) + 1.0f) * 32767.0f));
+        *dst = SDL_SwapLE16(val);
+    }
+
+    cvt->len_cvt /= 2;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U16LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint16 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S16LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32MSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Uint16 *dst;
+
+#if 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) + 1.0f) * 32767.0f));
+        *dst = SDL_SwapBE16(val);
+    }
+
+    cvt->len_cvt /= 2;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_U16MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32MSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint16 *dst;
+
+#if 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;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S16MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint32 *dst;
+
+#if 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));
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S32LSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32MSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    Sint32 *dst;
+
+#if 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));
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_S32MSB);
+    }
+}
+
+static void SDLCALL
+SDL_Convert_F32MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+    int i;
+    const float *src;
+    float *dst;
+
+#if 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);
+    }
+
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, AUDIO_F32LSB);
+    }
+}
+
+#endif  /* !NO_CONVERTERS */
+
+
+const SDL_AudioTypeFilters sdl_audio_type_filters[] =
+{
+#if !NO_CONVERTERS
+    { 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 },
+#endif  /* !NO_CONVERTERS */
+    { 0, 0, NULL }
+};
+
+
+#if !NO_RESAMPLERS
+
+static void SDLCALL
+SDL_Upsample_U8_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U8, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 16;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 1;
+    const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Uint8 *target = ((const Uint8 *) cvt->buf) - 1;
+    Uint8 sample0 = src[0];
+    Uint8 last_sample0 = sample0;
+    while (dst > target) {
+        dst[0] = sample0;
+        dst--;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src--;
+            sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U8_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U8, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 16;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint8 *dst = (Uint8 *) cvt->buf;
+    const Uint8 *src = (Uint8 *) cvt->buf;
+    const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
+    Uint8 sample0 = src[0];
+    Uint8 last_sample0 = sample0;
+    while (dst < target) {
+        src++;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = sample0;
+            dst++;
+            sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
+            last_sample0 = sample0;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U8_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U8, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 32;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 2;
+    const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Uint8 *target = ((const Uint8 *) cvt->buf) - 2;
+    Uint8 sample1 = src[1];
+    Uint8 sample0 = src[0];
+    Uint8 last_sample1 = sample1;
+    Uint8 last_sample0 = sample0;
+    while (dst > target) {
+        dst[1] = sample1;
+        dst[0] = sample0;
+        dst -= 2;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 2;
+            sample1 = (Uint8) ((((Sint16) src[1]) + ((Sint16) last_sample1)) >> 1);
+            sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U8_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U8, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 32;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint8 *dst = (Uint8 *) cvt->buf;
+    const Uint8 *src = (Uint8 *) cvt->buf;
+    const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
+    Uint8 sample0 = src[0];
+    Uint8 sample1 = src[1];
+    Uint8 last_sample0 = sample0;
+    Uint8 last_sample1 = sample1;
+    while (dst < target) {
+        src += 2;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = sample0;
+            dst[1] = sample1;
+            dst += 2;
+            sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
+            sample1 = (Uint8) ((((Sint16) src[1]) + ((Sint16) last_sample1)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U8_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U8, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 4;
+    const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Uint8 *target = ((const Uint8 *) cvt->buf) - 4;
+    Uint8 sample3 = src[3];
+    Uint8 sample2 = src[2];
+    Uint8 sample1 = src[1];
+    Uint8 sample0 = src[0];
+    Uint8 last_sample3 = sample3;
+    Uint8 last_sample2 = sample2;
+    Uint8 last_sample1 = sample1;
+    Uint8 last_sample0 = sample0;
+    while (dst > target) {
+        dst[3] = sample3;
+        dst[2] = sample2;
+        dst[1] = sample1;
+        dst[0] = sample0;
+        dst -= 4;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 4;
+            sample3 = (Uint8) ((((Sint16) src[3]) + ((Sint16) last_sample3)) >> 1);
+            sample2 = (Uint8) ((((Sint16) src[2]) + ((Sint16) last_sample2)) >> 1);
+            sample1 = (Uint8) ((((Sint16) src[1]) + ((Sint16) last_sample1)) >> 1);
+            sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U8_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U8, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint8 *dst = (Uint8 *) cvt->buf;
+    const Uint8 *src = (Uint8 *) cvt->buf;
+    const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
+    Uint8 sample0 = src[0];
+    Uint8 sample1 = src[1];
+    Uint8 sample2 = src[2];
+    Uint8 sample3 = src[3];
+    Uint8 last_sample0 = sample0;
+    Uint8 last_sample1 = sample1;
+    Uint8 last_sample2 = sample2;
+    Uint8 last_sample3 = sample3;
+    while (dst < target) {
+        src += 4;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = sample0;
+            dst[1] = sample1;
+            dst[2] = sample2;
+            dst[3] = sample3;
+            dst += 4;
+            sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
+            sample1 = (Uint8) ((((Sint16) src[1]) + ((Sint16) last_sample1)) >> 1);
+            sample2 = (Uint8) ((((Sint16) src[2]) + ((Sint16) last_sample2)) >> 1);
+            sample3 = (Uint8) ((((Sint16) src[3]) + ((Sint16) last_sample3)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U8_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U8, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 96;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 6;
+    const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Uint8 *target = ((const Uint8 *) cvt->buf) - 6;
+    Uint8 sample5 = src[5];
+    Uint8 sample4 = src[4];
+    Uint8 sample3 = src[3];
+    Uint8 sample2 = src[2];
+    Uint8 sample1 = src[1];
+    Uint8 sample0 = src[0];
+    Uint8 last_sample5 = sample5;
+    Uint8 last_sample4 = sample4;
+    Uint8 last_sample3 = sample3;
+    Uint8 last_sample2 = sample2;
+    Uint8 last_sample1 = sample1;
+    Uint8 last_sample0 = sample0;
+    while (dst > target) {
+        dst[5] = sample5;
+        dst[4] = sample4;
+        dst[3] = sample3;
+        dst[2] = sample2;
+        dst[1] = sample1;
+        dst[0] = sample0;
+        dst -= 6;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 6;
+            sample5 = (Uint8) ((((Sint16) src[5]) + ((Sint16) last_sample5)) >> 1);
+            sample4 = (Uint8) ((((Sint16) src[4]) + ((Sint16) last_sample4)) >> 1);
+            sample3 = (Uint8) ((((Sint16) src[3]) + ((Sint16) last_sample3)) >> 1);
+            sample2 = (Uint8) ((((Sint16) src[2]) + ((Sint16) last_sample2)) >> 1);
+            sample1 = (Uint8) ((((Sint16) src[1]) + ((Sint16) last_sample1)) >> 1);
+            sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U8_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U8, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 96;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint8 *dst = (Uint8 *) cvt->buf;
+    const Uint8 *src = (Uint8 *) cvt->buf;
+    const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
+    Uint8 sample0 = src[0];
+    Uint8 sample1 = src[1];
+    Uint8 sample2 = src[2];
+    Uint8 sample3 = src[3];
+    Uint8 sample4 = src[4];
+    Uint8 sample5 = src[5];
+    Uint8 last_sample0 = sample0;
+    Uint8 last_sample1 = sample1;
+    Uint8 last_sample2 = sample2;
+    Uint8 last_sample3 = sample3;
+    Uint8 last_sample4 = sample4;
+    Uint8 last_sample5 = sample5;
+    while (dst < target) {
+        src += 6;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = sample0;
+            dst[1] = sample1;
+            dst[2] = sample2;
+            dst[3] = sample3;
+            dst[4] = sample4;
+            dst[5] = sample5;
+            dst += 6;
+            sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
+            sample1 = (Uint8) ((((Sint16) src[1]) + ((Sint16) last_sample1)) >> 1);
+            sample2 = (Uint8) ((((Sint16) src[2]) + ((Sint16) last_sample2)) >> 1);
+            sample3 = (Uint8) ((((Sint16) src[3]) + ((Sint16) last_sample3)) >> 1);
+            sample4 = (Uint8) ((((Sint16) src[4]) + ((Sint16) last_sample4)) >> 1);
+            sample5 = (Uint8) ((((Sint16) src[5]) + ((Sint16) last_sample5)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U8_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U8, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 8;
+    const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Uint8 *target = ((const Uint8 *) cvt->buf) - 8;
+    Uint8 sample7 = src[7];
+    Uint8 sample6 = src[6];
+    Uint8 sample5 = src[5];
+    Uint8 sample4 = src[4];
+    Uint8 sample3 = src[3];
+    Uint8 sample2 = src[2];
+    Uint8 sample1 = src[1];
+    Uint8 sample0 = src[0];
+    Uint8 last_sample7 = sample7;
+    Uint8 last_sample6 = sample6;
+    Uint8 last_sample5 = sample5;
+    Uint8 last_sample4 = sample4;
+    Uint8 last_sample3 = sample3;
+    Uint8 last_sample2 = sample2;
+    Uint8 last_sample1 = sample1;
+    Uint8 last_sample0 = sample0;
+    while (dst > target) {
+        dst[7] = sample7;
+        dst[6] = sample6;
+        dst[5] = sample5;
+        dst[4] = sample4;
+        dst[3] = sample3;
+        dst[2] = sample2;
+        dst[1] = sample1;
+        dst[0] = sample0;
+        dst -= 8;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 8;
+            sample7 = (Uint8) ((((Sint16) src[7]) + ((Sint16) last_sample7)) >> 1);
+            sample6 = (Uint8) ((((Sint16) src[6]) + ((Sint16) last_sample6)) >> 1);
+            sample5 = (Uint8) ((((Sint16) src[5]) + ((Sint16) last_sample5)) >> 1);
+            sample4 = (Uint8) ((((Sint16) src[4]) + ((Sint16) last_sample4)) >> 1);
+            sample3 = (Uint8) ((((Sint16) src[3]) + ((Sint16) last_sample3)) >> 1);
+            sample2 = (Uint8) ((((Sint16) src[2]) + ((Sint16) last_sample2)) >> 1);
+            sample1 = (Uint8) ((((Sint16) src[1]) + ((Sint16) last_sample1)) >> 1);
+            sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
+            last_sample7 = sample7;
+            last_sample6 = sample6;
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U8_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U8, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint8 *dst = (Uint8 *) cvt->buf;
+    const Uint8 *src = (Uint8 *) cvt->buf;
+    const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
+    Uint8 sample0 = src[0];
+    Uint8 sample1 = src[1];
+    Uint8 sample2 = src[2];
+    Uint8 sample3 = src[3];
+    Uint8 sample4 = src[4];
+    Uint8 sample5 = src[5];
+    Uint8 sample6 = src[6];
+    Uint8 sample7 = src[7];
+    Uint8 last_sample0 = sample0;
+    Uint8 last_sample1 = sample1;
+    Uint8 last_sample2 = sample2;
+    Uint8 last_sample3 = sample3;
+    Uint8 last_sample4 = sample4;
+    Uint8 last_sample5 = sample5;
+    Uint8 last_sample6 = sample6;
+    Uint8 last_sample7 = sample7;
+    while (dst < target) {
+        src += 8;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = sample0;
+            dst[1] = sample1;
+            dst[2] = sample2;
+            dst[3] = sample3;
+            dst[4] = sample4;
+            dst[5] = sample5;
+            dst[6] = sample6;
+            dst[7] = sample7;
+            dst += 8;
+            sample0 = (Uint8) ((((Sint16) src[0]) + ((Sint16) last_sample0)) >> 1);
+            sample1 = (Uint8) ((((Sint16) src[1]) + ((Sint16) last_sample1)) >> 1);
+            sample2 = (Uint8) ((((Sint16) src[2]) + ((Sint16) last_sample2)) >> 1);
+            sample3 = (Uint8) ((((Sint16) src[3]) + ((Sint16) last_sample3)) >> 1);
+            sample4 = (Uint8) ((((Sint16) src[4]) + ((Sint16) last_sample4)) >> 1);
+            sample5 = (Uint8) ((((Sint16) src[5]) + ((Sint16) last_sample5)) >> 1);
+            sample6 = (Uint8) ((((Sint16) src[6]) + ((Sint16) last_sample6)) >> 1);
+            sample7 = (Uint8) ((((Sint16) src[7]) + ((Sint16) last_sample7)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            last_sample6 = sample6;
+            last_sample7 = sample7;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S8_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S8, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 16;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 1;
+    const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Sint8 *target = ((const Sint8 *) cvt->buf) - 1;
+    Sint8 sample0 = ((Sint8) src[0]);
+    Sint8 last_sample0 = sample0;
+    while (dst > target) {
+        dst[0] = ((Sint8) sample0);
+        dst--;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src--;
+            sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S8_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S8, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 16;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint8 *dst = (Sint8 *) cvt->buf;
+    const Sint8 *src = (Sint8 *) cvt->buf;
+    const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
+    Sint8 sample0 = ((Sint8) src[0]);
+    Sint8 last_sample0 = sample0;
+    while (dst < target) {
+        src++;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint8) sample0);
+            dst++;
+            sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
+            last_sample0 = sample0;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S8_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S8, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 32;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 2;
+    const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Sint8 *target = ((const Sint8 *) cvt->buf) - 2;
+    Sint8 sample1 = ((Sint8) src[1]);
+    Sint8 sample0 = ((Sint8) src[0]);
+    Sint8 last_sample1 = sample1;
+    Sint8 last_sample0 = sample0;
+    while (dst > target) {
+        dst[1] = ((Sint8) sample1);
+        dst[0] = ((Sint8) sample0);
+        dst -= 2;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 2;
+            sample1 = (Sint8) ((((Sint16) ((Sint8) src[1])) + ((Sint16) last_sample1)) >> 1);
+            sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S8_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S8, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 32;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint8 *dst = (Sint8 *) cvt->buf;
+    const Sint8 *src = (Sint8 *) cvt->buf;
+    const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
+    Sint8 sample0 = ((Sint8) src[0]);
+    Sint8 sample1 = ((Sint8) src[1]);
+    Sint8 last_sample0 = sample0;
+    Sint8 last_sample1 = sample1;
+    while (dst < target) {
+        src += 2;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint8) sample0);
+            dst[1] = ((Sint8) sample1);
+            dst += 2;
+            sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
+            sample1 = (Sint8) ((((Sint16) ((Sint8) src[1])) + ((Sint16) last_sample1)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S8_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S8, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 4;
+    const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Sint8 *target = ((const Sint8 *) cvt->buf) - 4;
+    Sint8 sample3 = ((Sint8) src[3]);
+    Sint8 sample2 = ((Sint8) src[2]);
+    Sint8 sample1 = ((Sint8) src[1]);
+    Sint8 sample0 = ((Sint8) src[0]);
+    Sint8 last_sample3 = sample3;
+    Sint8 last_sample2 = sample2;
+    Sint8 last_sample1 = sample1;
+    Sint8 last_sample0 = sample0;
+    while (dst > target) {
+        dst[3] = ((Sint8) sample3);
+        dst[2] = ((Sint8) sample2);
+        dst[1] = ((Sint8) sample1);
+        dst[0] = ((Sint8) sample0);
+        dst -= 4;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 4;
+            sample3 = (Sint8) ((((Sint16) ((Sint8) src[3])) + ((Sint16) last_sample3)) >> 1);
+            sample2 = (Sint8) ((((Sint16) ((Sint8) src[2])) + ((Sint16) last_sample2)) >> 1);
+            sample1 = (Sint8) ((((Sint16) ((Sint8) src[1])) + ((Sint16) last_sample1)) >> 1);
+            sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S8_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S8, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint8 *dst = (Sint8 *) cvt->buf;
+    const Sint8 *src = (Sint8 *) cvt->buf;
+    const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
+    Sint8 sample0 = ((Sint8) src[0]);
+    Sint8 sample1 = ((Sint8) src[1]);
+    Sint8 sample2 = ((Sint8) src[2]);
+    Sint8 sample3 = ((Sint8) src[3]);
+    Sint8 last_sample0 = sample0;
+    Sint8 last_sample1 = sample1;
+    Sint8 last_sample2 = sample2;
+    Sint8 last_sample3 = sample3;
+    while (dst < target) {
+        src += 4;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint8) sample0);
+            dst[1] = ((Sint8) sample1);
+            dst[2] = ((Sint8) sample2);
+            dst[3] = ((Sint8) sample3);
+            dst += 4;
+            sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
+            sample1 = (Sint8) ((((Sint16) ((Sint8) src[1])) + ((Sint16) last_sample1)) >> 1);
+            sample2 = (Sint8) ((((Sint16) ((Sint8) src[2])) + ((Sint16) last_sample2)) >> 1);
+            sample3 = (Sint8) ((((Sint16) ((Sint8) src[3])) + ((Sint16) last_sample3)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S8_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S8, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 96;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 6;
+    const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Sint8 *target = ((const Sint8 *) cvt->buf) - 6;
+    Sint8 sample5 = ((Sint8) src[5]);
+    Sint8 sample4 = ((Sint8) src[4]);
+    Sint8 sample3 = ((Sint8) src[3]);
+    Sint8 sample2 = ((Sint8) src[2]);
+    Sint8 sample1 = ((Sint8) src[1]);
+    Sint8 sample0 = ((Sint8) src[0]);
+    Sint8 last_sample5 = sample5;
+    Sint8 last_sample4 = sample4;
+    Sint8 last_sample3 = sample3;
+    Sint8 last_sample2 = sample2;
+    Sint8 last_sample1 = sample1;
+    Sint8 last_sample0 = sample0;
+    while (dst > target) {
+        dst[5] = ((Sint8) sample5);
+        dst[4] = ((Sint8) sample4);
+        dst[3] = ((Sint8) sample3);
+        dst[2] = ((Sint8) sample2);
+        dst[1] = ((Sint8) sample1);
+        dst[0] = ((Sint8) sample0);
+        dst -= 6;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 6;
+            sample5 = (Sint8) ((((Sint16) ((Sint8) src[5])) + ((Sint16) last_sample5)) >> 1);
+            sample4 = (Sint8) ((((Sint16) ((Sint8) src[4])) + ((Sint16) last_sample4)) >> 1);
+            sample3 = (Sint8) ((((Sint16) ((Sint8) src[3])) + ((Sint16) last_sample3)) >> 1);
+            sample2 = (Sint8) ((((Sint16) ((Sint8) src[2])) + ((Sint16) last_sample2)) >> 1);
+            sample1 = (Sint8) ((((Sint16) ((Sint8) src[1])) + ((Sint16) last_sample1)) >> 1);
+            sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S8_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S8, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 96;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint8 *dst = (Sint8 *) cvt->buf;
+    const Sint8 *src = (Sint8 *) cvt->buf;
+    const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
+    Sint8 sample0 = ((Sint8) src[0]);
+    Sint8 sample1 = ((Sint8) src[1]);
+    Sint8 sample2 = ((Sint8) src[2]);
+    Sint8 sample3 = ((Sint8) src[3]);
+    Sint8 sample4 = ((Sint8) src[4]);
+    Sint8 sample5 = ((Sint8) src[5]);
+    Sint8 last_sample0 = sample0;
+    Sint8 last_sample1 = sample1;
+    Sint8 last_sample2 = sample2;
+    Sint8 last_sample3 = sample3;
+    Sint8 last_sample4 = sample4;
+    Sint8 last_sample5 = sample5;
+    while (dst < target) {
+        src += 6;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint8) sample0);
+            dst[1] = ((Sint8) sample1);
+            dst[2] = ((Sint8) sample2);
+            dst[3] = ((Sint8) sample3);
+            dst[4] = ((Sint8) sample4);
+            dst[5] = ((Sint8) sample5);
+            dst += 6;
+            sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
+            sample1 = (Sint8) ((((Sint16) ((Sint8) src[1])) + ((Sint16) last_sample1)) >> 1);
+            sample2 = (Sint8) ((((Sint16) ((Sint8) src[2])) + ((Sint16) last_sample2)) >> 1);
+            sample3 = (Sint8) ((((Sint16) ((Sint8) src[3])) + ((Sint16) last_sample3)) >> 1);
+            sample4 = (Sint8) ((((Sint16) ((Sint8) src[4])) + ((Sint16) last_sample4)) >> 1);
+            sample5 = (Sint8) ((((Sint16) ((Sint8) src[5])) + ((Sint16) last_sample5)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S8_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S8, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 8;
+    const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Sint8 *target = ((const Sint8 *) cvt->buf) - 8;
+    Sint8 sample7 = ((Sint8) src[7]);
+    Sint8 sample6 = ((Sint8) src[6]);
+    Sint8 sample5 = ((Sint8) src[5]);
+    Sint8 sample4 = ((Sint8) src[4]);
+    Sint8 sample3 = ((Sint8) src[3]);
+    Sint8 sample2 = ((Sint8) src[2]);
+    Sint8 sample1 = ((Sint8) src[1]);
+    Sint8 sample0 = ((Sint8) src[0]);
+    Sint8 last_sample7 = sample7;
+    Sint8 last_sample6 = sample6;
+    Sint8 last_sample5 = sample5;
+    Sint8 last_sample4 = sample4;
+    Sint8 last_sample3 = sample3;
+    Sint8 last_sample2 = sample2;
+    Sint8 last_sample1 = sample1;
+    Sint8 last_sample0 = sample0;
+    while (dst > target) {
+        dst[7] = ((Sint8) sample7);
+        dst[6] = ((Sint8) sample6);
+        dst[5] = ((Sint8) sample5);
+        dst[4] = ((Sint8) sample4);
+        dst[3] = ((Sint8) sample3);
+        dst[2] = ((Sint8) sample2);
+        dst[1] = ((Sint8) sample1);
+        dst[0] = ((Sint8) sample0);
+        dst -= 8;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 8;
+            sample7 = (Sint8) ((((Sint16) ((Sint8) src[7])) + ((Sint16) last_sample7)) >> 1);
+            sample6 = (Sint8) ((((Sint16) ((Sint8) src[6])) + ((Sint16) last_sample6)) >> 1);
+            sample5 = (Sint8) ((((Sint16) ((Sint8) src[5])) + ((Sint16) last_sample5)) >> 1);
+            sample4 = (Sint8) ((((Sint16) ((Sint8) src[4])) + ((Sint16) last_sample4)) >> 1);
+            sample3 = (Sint8) ((((Sint16) ((Sint8) src[3])) + ((Sint16) last_sample3)) >> 1);
+            sample2 = (Sint8) ((((Sint16) ((Sint8) src[2])) + ((Sint16) last_sample2)) >> 1);
+            sample1 = (Sint8) ((((Sint16) ((Sint8) src[1])) + ((Sint16) last_sample1)) >> 1);
+            sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
+            last_sample7 = sample7;
+            last_sample6 = sample6;
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S8_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S8, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint8 *dst = (Sint8 *) cvt->buf;
+    const Sint8 *src = (Sint8 *) cvt->buf;
+    const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
+    Sint8 sample0 = ((Sint8) src[0]);
+    Sint8 sample1 = ((Sint8) src[1]);
+    Sint8 sample2 = ((Sint8) src[2]);
+    Sint8 sample3 = ((Sint8) src[3]);
+    Sint8 sample4 = ((Sint8) src[4]);
+    Sint8 sample5 = ((Sint8) src[5]);
+    Sint8 sample6 = ((Sint8) src[6]);
+    Sint8 sample7 = ((Sint8) src[7]);
+    Sint8 last_sample0 = sample0;
+    Sint8 last_sample1 = sample1;
+    Sint8 last_sample2 = sample2;
+    Sint8 last_sample3 = sample3;
+    Sint8 last_sample4 = sample4;
+    Sint8 last_sample5 = sample5;
+    Sint8 last_sample6 = sample6;
+    Sint8 last_sample7 = sample7;
+    while (dst < target) {
+        src += 8;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint8) sample0);
+            dst[1] = ((Sint8) sample1);
+            dst[2] = ((Sint8) sample2);
+            dst[3] = ((Sint8) sample3);
+            dst[4] = ((Sint8) sample4);
+            dst[5] = ((Sint8) sample5);
+            dst[6] = ((Sint8) sample6);
+            dst[7] = ((Sint8) sample7);
+            dst += 8;
+            sample0 = (Sint8) ((((Sint16) ((Sint8) src[0])) + ((Sint16) last_sample0)) >> 1);
+            sample1 = (Sint8) ((((Sint16) ((Sint8) src[1])) + ((Sint16) last_sample1)) >> 1);
+            sample2 = (Sint8) ((((Sint16) ((Sint8) src[2])) + ((Sint16) last_sample2)) >> 1);
+            sample3 = (Sint8) ((((Sint16) ((Sint8) src[3])) + ((Sint16) last_sample3)) >> 1);
+            sample4 = (Sint8) ((((Sint16) ((Sint8) src[4])) + ((Sint16) last_sample4)) >> 1);
+            sample5 = (Sint8) ((((Sint16) ((Sint8) src[5])) + ((Sint16) last_sample5)) >> 1);
+            sample6 = (Sint8) ((((Sint16) ((Sint8) src[6])) + ((Sint16) last_sample6)) >> 1);
+            sample7 = (Sint8) ((((Sint16) ((Sint8) src[7])) + ((Sint16) last_sample7)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            last_sample6 = sample6;
+            last_sample7 = sample7;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16LSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16LSB, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 32;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 1;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 1;
+    Uint16 sample0 = SDL_SwapLE16(src[0]);
+    Uint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[0] = SDL_SwapLE16(sample0);
+        dst--;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src--;
+            sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16LSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16LSB, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 32;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Uint16 sample0 = SDL_SwapLE16(src[0]);
+    Uint16 last_sample0 = sample0;
+    while (dst < target) {
+        src++;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapLE16(sample0);
+            dst++;
+            sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            last_sample0 = sample0;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16LSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16LSB, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 2;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 2;
+    Uint16 sample1 = SDL_SwapLE16(src[1]);
+    Uint16 sample0 = SDL_SwapLE16(src[0]);
+    Uint16 last_sample1 = sample1;
+    Uint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[1] = SDL_SwapLE16(sample1);
+        dst[0] = SDL_SwapLE16(sample0);
+        dst -= 2;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 2;
+            sample1 = (Uint16) ((((Sint32) SDL_SwapLE16(src[1])) + ((Sint32) last_sample1)) >> 1);
+            sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16LSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16LSB, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Uint16 sample0 = SDL_SwapLE16(src[0]);
+    Uint16 sample1 = SDL_SwapLE16(src[1]);
+    Uint16 last_sample0 = sample0;
+    Uint16 last_sample1 = sample1;
+    while (dst < target) {
+        src += 2;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapLE16(sample0);
+            dst[1] = SDL_SwapLE16(sample1);
+            dst += 2;
+            sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            sample1 = (Uint16) ((((Sint32) SDL_SwapLE16(src[1])) + ((Sint32) last_sample1)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16LSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16LSB, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 4;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 4;
+    Uint16 sample3 = SDL_SwapLE16(src[3]);
+    Uint16 sample2 = SDL_SwapLE16(src[2]);
+    Uint16 sample1 = SDL_SwapLE16(src[1]);
+    Uint16 sample0 = SDL_SwapLE16(src[0]);
+    Uint16 last_sample3 = sample3;
+    Uint16 last_sample2 = sample2;
+    Uint16 last_sample1 = sample1;
+    Uint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[3] = SDL_SwapLE16(sample3);
+        dst[2] = SDL_SwapLE16(sample2);
+        dst[1] = SDL_SwapLE16(sample1);
+        dst[0] = SDL_SwapLE16(sample0);
+        dst -= 4;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 4;
+            sample3 = (Uint16) ((((Sint32) SDL_SwapLE16(src[3])) + ((Sint32) last_sample3)) >> 1);
+            sample2 = (Uint16) ((((Sint32) SDL_SwapLE16(src[2])) + ((Sint32) last_sample2)) >> 1);
+            sample1 = (Uint16) ((((Sint32) SDL_SwapLE16(src[1])) + ((Sint32) last_sample1)) >> 1);
+            sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16LSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16LSB, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Uint16 sample0 = SDL_SwapLE16(src[0]);
+    Uint16 sample1 = SDL_SwapLE16(src[1]);
+    Uint16 sample2 = SDL_SwapLE16(src[2]);
+    Uint16 sample3 = SDL_SwapLE16(src[3]);
+    Uint16 last_sample0 = sample0;
+    Uint16 last_sample1 = sample1;
+    Uint16 last_sample2 = sample2;
+    Uint16 last_sample3 = sample3;
+    while (dst < target) {
+        src += 4;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapLE16(sample0);
+            dst[1] = SDL_SwapLE16(sample1);
+            dst[2] = SDL_SwapLE16(sample2);
+            dst[3] = SDL_SwapLE16(sample3);
+            dst += 4;
+            sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            sample1 = (Uint16) ((((Sint32) SDL_SwapLE16(src[1])) + ((Sint32) last_sample1)) >> 1);
+            sample2 = (Uint16) ((((Sint32) SDL_SwapLE16(src[2])) + ((Sint32) last_sample2)) >> 1);
+            sample3 = (Uint16) ((((Sint32) SDL_SwapLE16(src[3])) + ((Sint32) last_sample3)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16LSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16LSB, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 192;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 6;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 6;
+    Uint16 sample5 = SDL_SwapLE16(src[5]);
+    Uint16 sample4 = SDL_SwapLE16(src[4]);
+    Uint16 sample3 = SDL_SwapLE16(src[3]);
+    Uint16 sample2 = SDL_SwapLE16(src[2]);
+    Uint16 sample1 = SDL_SwapLE16(src[1]);
+    Uint16 sample0 = SDL_SwapLE16(src[0]);
+    Uint16 last_sample5 = sample5;
+    Uint16 last_sample4 = sample4;
+    Uint16 last_sample3 = sample3;
+    Uint16 last_sample2 = sample2;
+    Uint16 last_sample1 = sample1;
+    Uint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[5] = SDL_SwapLE16(sample5);
+        dst[4] = SDL_SwapLE16(sample4);
+        dst[3] = SDL_SwapLE16(sample3);
+        dst[2] = SDL_SwapLE16(sample2);
+        dst[1] = SDL_SwapLE16(sample1);
+        dst[0] = SDL_SwapLE16(sample0);
+        dst -= 6;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 6;
+            sample5 = (Uint16) ((((Sint32) SDL_SwapLE16(src[5])) + ((Sint32) last_sample5)) >> 1);
+            sample4 = (Uint16) ((((Sint32) SDL_SwapLE16(src[4])) + ((Sint32) last_sample4)) >> 1);
+            sample3 = (Uint16) ((((Sint32) SDL_SwapLE16(src[3])) + ((Sint32) last_sample3)) >> 1);
+            sample2 = (Uint16) ((((Sint32) SDL_SwapLE16(src[2])) + ((Sint32) last_sample2)) >> 1);
+            sample1 = (Uint16) ((((Sint32) SDL_SwapLE16(src[1])) + ((Sint32) last_sample1)) >> 1);
+            sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16LSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16LSB, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 192;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Uint16 sample0 = SDL_SwapLE16(src[0]);
+    Uint16 sample1 = SDL_SwapLE16(src[1]);
+    Uint16 sample2 = SDL_SwapLE16(src[2]);
+    Uint16 sample3 = SDL_SwapLE16(src[3]);
+    Uint16 sample4 = SDL_SwapLE16(src[4]);
+    Uint16 sample5 = SDL_SwapLE16(src[5]);
+    Uint16 last_sample0 = sample0;
+    Uint16 last_sample1 = sample1;
+    Uint16 last_sample2 = sample2;
+    Uint16 last_sample3 = sample3;
+    Uint16 last_sample4 = sample4;
+    Uint16 last_sample5 = sample5;
+    while (dst < target) {
+        src += 6;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapLE16(sample0);
+            dst[1] = SDL_SwapLE16(sample1);
+            dst[2] = SDL_SwapLE16(sample2);
+            dst[3] = SDL_SwapLE16(sample3);
+            dst[4] = SDL_SwapLE16(sample4);
+            dst[5] = SDL_SwapLE16(sample5);
+            dst += 6;
+            sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            sample1 = (Uint16) ((((Sint32) SDL_SwapLE16(src[1])) + ((Sint32) last_sample1)) >> 1);
+            sample2 = (Uint16) ((((Sint32) SDL_SwapLE16(src[2])) + ((Sint32) last_sample2)) >> 1);
+            sample3 = (Uint16) ((((Sint32) SDL_SwapLE16(src[3])) + ((Sint32) last_sample3)) >> 1);
+            sample4 = (Uint16) ((((Sint32) SDL_SwapLE16(src[4])) + ((Sint32) last_sample4)) >> 1);
+            sample5 = (Uint16) ((((Sint32) SDL_SwapLE16(src[5])) + ((Sint32) last_sample5)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16LSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16LSB, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 256;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 8;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 8;
+    Uint16 sample7 = SDL_SwapLE16(src[7]);
+    Uint16 sample6 = SDL_SwapLE16(src[6]);
+    Uint16 sample5 = SDL_SwapLE16(src[5]);
+    Uint16 sample4 = SDL_SwapLE16(src[4]);
+    Uint16 sample3 = SDL_SwapLE16(src[3]);
+    Uint16 sample2 = SDL_SwapLE16(src[2]);
+    Uint16 sample1 = SDL_SwapLE16(src[1]);
+    Uint16 sample0 = SDL_SwapLE16(src[0]);
+    Uint16 last_sample7 = sample7;
+    Uint16 last_sample6 = sample6;
+    Uint16 last_sample5 = sample5;
+    Uint16 last_sample4 = sample4;
+    Uint16 last_sample3 = sample3;
+    Uint16 last_sample2 = sample2;
+    Uint16 last_sample1 = sample1;
+    Uint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[7] = SDL_SwapLE16(sample7);
+        dst[6] = SDL_SwapLE16(sample6);
+        dst[5] = SDL_SwapLE16(sample5);
+        dst[4] = SDL_SwapLE16(sample4);
+        dst[3] = SDL_SwapLE16(sample3);
+        dst[2] = SDL_SwapLE16(sample2);
+        dst[1] = SDL_SwapLE16(sample1);
+        dst[0] = SDL_SwapLE16(sample0);
+        dst -= 8;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 8;
+            sample7 = (Uint16) ((((Sint32) SDL_SwapLE16(src[7])) + ((Sint32) last_sample7)) >> 1);
+            sample6 = (Uint16) ((((Sint32) SDL_SwapLE16(src[6])) + ((Sint32) last_sample6)) >> 1);
+            sample5 = (Uint16) ((((Sint32) SDL_SwapLE16(src[5])) + ((Sint32) last_sample5)) >> 1);
+            sample4 = (Uint16) ((((Sint32) SDL_SwapLE16(src[4])) + ((Sint32) last_sample4)) >> 1);
+            sample3 = (Uint16) ((((Sint32) SDL_SwapLE16(src[3])) + ((Sint32) last_sample3)) >> 1);
+            sample2 = (Uint16) ((((Sint32) SDL_SwapLE16(src[2])) + ((Sint32) last_sample2)) >> 1);
+            sample1 = (Uint16) ((((Sint32) SDL_SwapLE16(src[1])) + ((Sint32) last_sample1)) >> 1);
+            sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            last_sample7 = sample7;
+            last_sample6 = sample6;
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16LSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16LSB, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 256;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Uint16 sample0 = SDL_SwapLE16(src[0]);
+    Uint16 sample1 = SDL_SwapLE16(src[1]);
+    Uint16 sample2 = SDL_SwapLE16(src[2]);
+    Uint16 sample3 = SDL_SwapLE16(src[3]);
+    Uint16 sample4 = SDL_SwapLE16(src[4]);
+    Uint16 sample5 = SDL_SwapLE16(src[5]);
+    Uint16 sample6 = SDL_SwapLE16(src[6]);
+    Uint16 sample7 = SDL_SwapLE16(src[7]);
+    Uint16 last_sample0 = sample0;
+    Uint16 last_sample1 = sample1;
+    Uint16 last_sample2 = sample2;
+    Uint16 last_sample3 = sample3;
+    Uint16 last_sample4 = sample4;
+    Uint16 last_sample5 = sample5;
+    Uint16 last_sample6 = sample6;
+    Uint16 last_sample7 = sample7;
+    while (dst < target) {
+        src += 8;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapLE16(sample0);
+            dst[1] = SDL_SwapLE16(sample1);
+            dst[2] = SDL_SwapLE16(sample2);
+            dst[3] = SDL_SwapLE16(sample3);
+            dst[4] = SDL_SwapLE16(sample4);
+            dst[5] = SDL_SwapLE16(sample5);
+            dst[6] = SDL_SwapLE16(sample6);
+            dst[7] = SDL_SwapLE16(sample7);
+            dst += 8;
+            sample0 = (Uint16) ((((Sint32) SDL_SwapLE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            sample1 = (Uint16) ((((Sint32) SDL_SwapLE16(src[1])) + ((Sint32) last_sample1)) >> 1);
+            sample2 = (Uint16) ((((Sint32) SDL_SwapLE16(src[2])) + ((Sint32) last_sample2)) >> 1);
+            sample3 = (Uint16) ((((Sint32) SDL_SwapLE16(src[3])) + ((Sint32) last_sample3)) >> 1);
+            sample4 = (Uint16) ((((Sint32) SDL_SwapLE16(src[4])) + ((Sint32) last_sample4)) >> 1);
+            sample5 = (Uint16) ((((Sint32) SDL_SwapLE16(src[5])) + ((Sint32) last_sample5)) >> 1);
+            sample6 = (Uint16) ((((Sint32) SDL_SwapLE16(src[6])) + ((Sint32) last_sample6)) >> 1);
+            sample7 = (Uint16) ((((Sint32) SDL_SwapLE16(src[7])) + ((Sint32) last_sample7)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            last_sample6 = sample6;
+            last_sample7 = sample7;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16LSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16LSB, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 32;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 1;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 1;
+    Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
+    Sint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[0] = ((Sint16) SDL_SwapLE16(sample0));
+        dst--;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src--;
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16LSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16LSB, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 32;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
+    Sint16 last_sample0 = sample0;
+    while (dst < target) {
+        src++;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint16) SDL_SwapLE16(sample0));
+            dst++;
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            last_sample0 = sample0;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16LSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16LSB, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 2;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 2;
+    Sint16 sample1 = ((Sint16) SDL_SwapLE16(src[1]));
+    Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
+    Sint16 last_sample1 = sample1;
+    Sint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[1] = ((Sint16) SDL_SwapLE16(sample1));
+        dst[0] = ((Sint16) SDL_SwapLE16(sample0));
+        dst -= 2;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 2;
+            sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16LSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16LSB, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
+    Sint16 sample1 = ((Sint16) SDL_SwapLE16(src[1]));
+    Sint16 last_sample0 = sample0;
+    Sint16 last_sample1 = sample1;
+    while (dst < target) {
+        src += 2;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint16) SDL_SwapLE16(sample0));
+            dst[1] = ((Sint16) SDL_SwapLE16(sample1));
+            dst += 2;
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16LSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16LSB, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 4;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 4;
+    Sint16 sample3 = ((Sint16) SDL_SwapLE16(src[3]));
+    Sint16 sample2 = ((Sint16) SDL_SwapLE16(src[2]));
+    Sint16 sample1 = ((Sint16) SDL_SwapLE16(src[1]));
+    Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
+    Sint16 last_sample3 = sample3;
+    Sint16 last_sample2 = sample2;
+    Sint16 last_sample1 = sample1;
+    Sint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[3] = ((Sint16) SDL_SwapLE16(sample3));
+        dst[2] = ((Sint16) SDL_SwapLE16(sample2));
+        dst[1] = ((Sint16) SDL_SwapLE16(sample1));
+        dst[0] = ((Sint16) SDL_SwapLE16(sample0));
+        dst -= 4;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 4;
+            sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
+            sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
+            sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16LSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16LSB, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
+    Sint16 sample1 = ((Sint16) SDL_SwapLE16(src[1]));
+    Sint16 sample2 = ((Sint16) SDL_SwapLE16(src[2]));
+    Sint16 sample3 = ((Sint16) SDL_SwapLE16(src[3]));
+    Sint16 last_sample0 = sample0;
+    Sint16 last_sample1 = sample1;
+    Sint16 last_sample2 = sample2;
+    Sint16 last_sample3 = sample3;
+    while (dst < target) {
+        src += 4;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint16) SDL_SwapLE16(sample0));
+            dst[1] = ((Sint16) SDL_SwapLE16(sample1));
+            dst[2] = ((Sint16) SDL_SwapLE16(sample2));
+            dst[3] = ((Sint16) SDL_SwapLE16(sample3));
+            dst += 4;
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
+            sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
+            sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16LSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16LSB, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 192;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 6;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 6;
+    Sint16 sample5 = ((Sint16) SDL_SwapLE16(src[5]));
+    Sint16 sample4 = ((Sint16) SDL_SwapLE16(src[4]));
+    Sint16 sample3 = ((Sint16) SDL_SwapLE16(src[3]));
+    Sint16 sample2 = ((Sint16) SDL_SwapLE16(src[2]));
+    Sint16 sample1 = ((Sint16) SDL_SwapLE16(src[1]));
+    Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
+    Sint16 last_sample5 = sample5;
+    Sint16 last_sample4 = sample4;
+    Sint16 last_sample3 = sample3;
+    Sint16 last_sample2 = sample2;
+    Sint16 last_sample1 = sample1;
+    Sint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[5] = ((Sint16) SDL_SwapLE16(sample5));
+        dst[4] = ((Sint16) SDL_SwapLE16(sample4));
+        dst[3] = ((Sint16) SDL_SwapLE16(sample3));
+        dst[2] = ((Sint16) SDL_SwapLE16(sample2));
+        dst[1] = ((Sint16) SDL_SwapLE16(sample1));
+        dst[0] = ((Sint16) SDL_SwapLE16(sample0));
+        dst -= 6;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 6;
+            sample5 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[5]))) + ((Sint32) last_sample5)) >> 1);
+            sample4 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[4]))) + ((Sint32) last_sample4)) >> 1);
+            sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
+            sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
+            sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16LSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16LSB, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 192;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
+    Sint16 sample1 = ((Sint16) SDL_SwapLE16(src[1]));
+    Sint16 sample2 = ((Sint16) SDL_SwapLE16(src[2]));
+    Sint16 sample3 = ((Sint16) SDL_SwapLE16(src[3]));
+    Sint16 sample4 = ((Sint16) SDL_SwapLE16(src[4]));
+    Sint16 sample5 = ((Sint16) SDL_SwapLE16(src[5]));
+    Sint16 last_sample0 = sample0;
+    Sint16 last_sample1 = sample1;
+    Sint16 last_sample2 = sample2;
+    Sint16 last_sample3 = sample3;
+    Sint16 last_sample4 = sample4;
+    Sint16 last_sample5 = sample5;
+    while (dst < target) {
+        src += 6;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint16) SDL_SwapLE16(sample0));
+            dst[1] = ((Sint16) SDL_SwapLE16(sample1));
+            dst[2] = ((Sint16) SDL_SwapLE16(sample2));
+            dst[3] = ((Sint16) SDL_SwapLE16(sample3));
+            dst[4] = ((Sint16) SDL_SwapLE16(sample4));
+            dst[5] = ((Sint16) SDL_SwapLE16(sample5));
+            dst += 6;
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
+            sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
+            sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
+            sample4 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[4]))) + ((Sint32) last_sample4)) >> 1);
+            sample5 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[5]))) + ((Sint32) last_sample5)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16LSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16LSB, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 256;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 8;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 8;
+    Sint16 sample7 = ((Sint16) SDL_SwapLE16(src[7]));
+    Sint16 sample6 = ((Sint16) SDL_SwapLE16(src[6]));
+    Sint16 sample5 = ((Sint16) SDL_SwapLE16(src[5]));
+    Sint16 sample4 = ((Sint16) SDL_SwapLE16(src[4]));
+    Sint16 sample3 = ((Sint16) SDL_SwapLE16(src[3]));
+    Sint16 sample2 = ((Sint16) SDL_SwapLE16(src[2]));
+    Sint16 sample1 = ((Sint16) SDL_SwapLE16(src[1]));
+    Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
+    Sint16 last_sample7 = sample7;
+    Sint16 last_sample6 = sample6;
+    Sint16 last_sample5 = sample5;
+    Sint16 last_sample4 = sample4;
+    Sint16 last_sample3 = sample3;
+    Sint16 last_sample2 = sample2;
+    Sint16 last_sample1 = sample1;
+    Sint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[7] = ((Sint16) SDL_SwapLE16(sample7));
+        dst[6] = ((Sint16) SDL_SwapLE16(sample6));
+        dst[5] = ((Sint16) SDL_SwapLE16(sample5));
+        dst[4] = ((Sint16) SDL_SwapLE16(sample4));
+        dst[3] = ((Sint16) SDL_SwapLE16(sample3));
+        dst[2] = ((Sint16) SDL_SwapLE16(sample2));
+        dst[1] = ((Sint16) SDL_SwapLE16(sample1));
+        dst[0] = ((Sint16) SDL_SwapLE16(sample0));
+        dst -= 8;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 8;
+            sample7 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[7]))) + ((Sint32) last_sample7)) >> 1);
+            sample6 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[6]))) + ((Sint32) last_sample6)) >> 1);
+            sample5 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[5]))) + ((Sint32) last_sample5)) >> 1);
+            sample4 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[4]))) + ((Sint32) last_sample4)) >> 1);
+            sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
+            sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
+            sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            last_sample7 = sample7;
+            last_sample6 = sample6;
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16LSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16LSB, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 256;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint16 sample0 = ((Sint16) SDL_SwapLE16(src[0]));
+    Sint16 sample1 = ((Sint16) SDL_SwapLE16(src[1]));
+    Sint16 sample2 = ((Sint16) SDL_SwapLE16(src[2]));
+    Sint16 sample3 = ((Sint16) SDL_SwapLE16(src[3]));
+    Sint16 sample4 = ((Sint16) SDL_SwapLE16(src[4]));
+    Sint16 sample5 = ((Sint16) SDL_SwapLE16(src[5]));
+    Sint16 sample6 = ((Sint16) SDL_SwapLE16(src[6]));
+    Sint16 sample7 = ((Sint16) SDL_SwapLE16(src[7]));
+    Sint16 last_sample0 = sample0;
+    Sint16 last_sample1 = sample1;
+    Sint16 last_sample2 = sample2;
+    Sint16 last_sample3 = sample3;
+    Sint16 last_sample4 = sample4;
+    Sint16 last_sample5 = sample5;
+    Sint16 last_sample6 = sample6;
+    Sint16 last_sample7 = sample7;
+    while (dst < target) {
+        src += 8;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint16) SDL_SwapLE16(sample0));
+            dst[1] = ((Sint16) SDL_SwapLE16(sample1));
+            dst[2] = ((Sint16) SDL_SwapLE16(sample2));
+            dst[3] = ((Sint16) SDL_SwapLE16(sample3));
+            dst[4] = ((Sint16) SDL_SwapLE16(sample4));
+            dst[5] = ((Sint16) SDL_SwapLE16(sample5));
+            dst[6] = ((Sint16) SDL_SwapLE16(sample6));
+            dst[7] = ((Sint16) SDL_SwapLE16(sample7));
+            dst += 8;
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
+            sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
+            sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
+            sample4 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[4]))) + ((Sint32) last_sample4)) >> 1);
+            sample5 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[5]))) + ((Sint32) last_sample5)) >> 1);
+            sample6 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[6]))) + ((Sint32) last_sample6)) >> 1);
+            sample7 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapLE16(src[7]))) + ((Sint32) last_sample7)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            last_sample6 = sample6;
+            last_sample7 = sample7;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16MSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16MSB, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 32;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 1;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 1;
+    Uint16 sample0 = SDL_SwapBE16(src[0]);
+    Uint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[0] = SDL_SwapBE16(sample0);
+        dst--;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src--;
+            sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16MSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16MSB, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 32;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Uint16 sample0 = SDL_SwapBE16(src[0]);
+    Uint16 last_sample0 = sample0;
+    while (dst < target) {
+        src++;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapBE16(sample0);
+            dst++;
+            sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            last_sample0 = sample0;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16MSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16MSB, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 2;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 2;
+    Uint16 sample1 = SDL_SwapBE16(src[1]);
+    Uint16 sample0 = SDL_SwapBE16(src[0]);
+    Uint16 last_sample1 = sample1;
+    Uint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[1] = SDL_SwapBE16(sample1);
+        dst[0] = SDL_SwapBE16(sample0);
+        dst -= 2;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 2;
+            sample1 = (Uint16) ((((Sint32) SDL_SwapBE16(src[1])) + ((Sint32) last_sample1)) >> 1);
+            sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16MSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16MSB, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Uint16 sample0 = SDL_SwapBE16(src[0]);
+    Uint16 sample1 = SDL_SwapBE16(src[1]);
+    Uint16 last_sample0 = sample0;
+    Uint16 last_sample1 = sample1;
+    while (dst < target) {
+        src += 2;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapBE16(sample0);
+            dst[1] = SDL_SwapBE16(sample1);
+            dst += 2;
+            sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            sample1 = (Uint16) ((((Sint32) SDL_SwapBE16(src[1])) + ((Sint32) last_sample1)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16MSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16MSB, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 4;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 4;
+    Uint16 sample3 = SDL_SwapBE16(src[3]);
+    Uint16 sample2 = SDL_SwapBE16(src[2]);
+    Uint16 sample1 = SDL_SwapBE16(src[1]);
+    Uint16 sample0 = SDL_SwapBE16(src[0]);
+    Uint16 last_sample3 = sample3;
+    Uint16 last_sample2 = sample2;
+    Uint16 last_sample1 = sample1;
+    Uint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[3] = SDL_SwapBE16(sample3);
+        dst[2] = SDL_SwapBE16(sample2);
+        dst[1] = SDL_SwapBE16(sample1);
+        dst[0] = SDL_SwapBE16(sample0);
+        dst -= 4;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 4;
+            sample3 = (Uint16) ((((Sint32) SDL_SwapBE16(src[3])) + ((Sint32) last_sample3)) >> 1);
+            sample2 = (Uint16) ((((Sint32) SDL_SwapBE16(src[2])) + ((Sint32) last_sample2)) >> 1);
+            sample1 = (Uint16) ((((Sint32) SDL_SwapBE16(src[1])) + ((Sint32) last_sample1)) >> 1);
+            sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16MSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16MSB, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Uint16 sample0 = SDL_SwapBE16(src[0]);
+    Uint16 sample1 = SDL_SwapBE16(src[1]);
+    Uint16 sample2 = SDL_SwapBE16(src[2]);
+    Uint16 sample3 = SDL_SwapBE16(src[3]);
+    Uint16 last_sample0 = sample0;
+    Uint16 last_sample1 = sample1;
+    Uint16 last_sample2 = sample2;
+    Uint16 last_sample3 = sample3;
+    while (dst < target) {
+        src += 4;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapBE16(sample0);
+            dst[1] = SDL_SwapBE16(sample1);
+            dst[2] = SDL_SwapBE16(sample2);
+            dst[3] = SDL_SwapBE16(sample3);
+            dst += 4;
+            sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            sample1 = (Uint16) ((((Sint32) SDL_SwapBE16(src[1])) + ((Sint32) last_sample1)) >> 1);
+            sample2 = (Uint16) ((((Sint32) SDL_SwapBE16(src[2])) + ((Sint32) last_sample2)) >> 1);
+            sample3 = (Uint16) ((((Sint32) SDL_SwapBE16(src[3])) + ((Sint32) last_sample3)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16MSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16MSB, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 192;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 6;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 6;
+    Uint16 sample5 = SDL_SwapBE16(src[5]);
+    Uint16 sample4 = SDL_SwapBE16(src[4]);
+    Uint16 sample3 = SDL_SwapBE16(src[3]);
+    Uint16 sample2 = SDL_SwapBE16(src[2]);
+    Uint16 sample1 = SDL_SwapBE16(src[1]);
+    Uint16 sample0 = SDL_SwapBE16(src[0]);
+    Uint16 last_sample5 = sample5;
+    Uint16 last_sample4 = sample4;
+    Uint16 last_sample3 = sample3;
+    Uint16 last_sample2 = sample2;
+    Uint16 last_sample1 = sample1;
+    Uint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[5] = SDL_SwapBE16(sample5);
+        dst[4] = SDL_SwapBE16(sample4);
+        dst[3] = SDL_SwapBE16(sample3);
+        dst[2] = SDL_SwapBE16(sample2);
+        dst[1] = SDL_SwapBE16(sample1);
+        dst[0] = SDL_SwapBE16(sample0);
+        dst -= 6;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 6;
+            sample5 = (Uint16) ((((Sint32) SDL_SwapBE16(src[5])) + ((Sint32) last_sample5)) >> 1);
+            sample4 = (Uint16) ((((Sint32) SDL_SwapBE16(src[4])) + ((Sint32) last_sample4)) >> 1);
+            sample3 = (Uint16) ((((Sint32) SDL_SwapBE16(src[3])) + ((Sint32) last_sample3)) >> 1);
+            sample2 = (Uint16) ((((Sint32) SDL_SwapBE16(src[2])) + ((Sint32) last_sample2)) >> 1);
+            sample1 = (Uint16) ((((Sint32) SDL_SwapBE16(src[1])) + ((Sint32) last_sample1)) >> 1);
+            sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16MSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16MSB, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 192;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Uint16 sample0 = SDL_SwapBE16(src[0]);
+    Uint16 sample1 = SDL_SwapBE16(src[1]);
+    Uint16 sample2 = SDL_SwapBE16(src[2]);
+    Uint16 sample3 = SDL_SwapBE16(src[3]);
+    Uint16 sample4 = SDL_SwapBE16(src[4]);
+    Uint16 sample5 = SDL_SwapBE16(src[5]);
+    Uint16 last_sample0 = sample0;
+    Uint16 last_sample1 = sample1;
+    Uint16 last_sample2 = sample2;
+    Uint16 last_sample3 = sample3;
+    Uint16 last_sample4 = sample4;
+    Uint16 last_sample5 = sample5;
+    while (dst < target) {
+        src += 6;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapBE16(sample0);
+            dst[1] = SDL_SwapBE16(sample1);
+            dst[2] = SDL_SwapBE16(sample2);
+            dst[3] = SDL_SwapBE16(sample3);
+            dst[4] = SDL_SwapBE16(sample4);
+            dst[5] = SDL_SwapBE16(sample5);
+            dst += 6;
+            sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            sample1 = (Uint16) ((((Sint32) SDL_SwapBE16(src[1])) + ((Sint32) last_sample1)) >> 1);
+            sample2 = (Uint16) ((((Sint32) SDL_SwapBE16(src[2])) + ((Sint32) last_sample2)) >> 1);
+            sample3 = (Uint16) ((((Sint32) SDL_SwapBE16(src[3])) + ((Sint32) last_sample3)) >> 1);
+            sample4 = (Uint16) ((((Sint32) SDL_SwapBE16(src[4])) + ((Sint32) last_sample4)) >> 1);
+            sample5 = (Uint16) ((((Sint32) SDL_SwapBE16(src[5])) + ((Sint32) last_sample5)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16MSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_U16MSB, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 256;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 8;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 8;
+    Uint16 sample7 = SDL_SwapBE16(src[7]);
+    Uint16 sample6 = SDL_SwapBE16(src[6]);
+    Uint16 sample5 = SDL_SwapBE16(src[5]);
+    Uint16 sample4 = SDL_SwapBE16(src[4]);
+    Uint16 sample3 = SDL_SwapBE16(src[3]);
+    Uint16 sample2 = SDL_SwapBE16(src[2]);
+    Uint16 sample1 = SDL_SwapBE16(src[1]);
+    Uint16 sample0 = SDL_SwapBE16(src[0]);
+    Uint16 last_sample7 = sample7;
+    Uint16 last_sample6 = sample6;
+    Uint16 last_sample5 = sample5;
+    Uint16 last_sample4 = sample4;
+    Uint16 last_sample3 = sample3;
+    Uint16 last_sample2 = sample2;
+    Uint16 last_sample1 = sample1;
+    Uint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[7] = SDL_SwapBE16(sample7);
+        dst[6] = SDL_SwapBE16(sample6);
+        dst[5] = SDL_SwapBE16(sample5);
+        dst[4] = SDL_SwapBE16(sample4);
+        dst[3] = SDL_SwapBE16(sample3);
+        dst[2] = SDL_SwapBE16(sample2);
+        dst[1] = SDL_SwapBE16(sample1);
+        dst[0] = SDL_SwapBE16(sample0);
+        dst -= 8;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 8;
+            sample7 = (Uint16) ((((Sint32) SDL_SwapBE16(src[7])) + ((Sint32) last_sample7)) >> 1);
+            sample6 = (Uint16) ((((Sint32) SDL_SwapBE16(src[6])) + ((Sint32) last_sample6)) >> 1);
+            sample5 = (Uint16) ((((Sint32) SDL_SwapBE16(src[5])) + ((Sint32) last_sample5)) >> 1);
+            sample4 = (Uint16) ((((Sint32) SDL_SwapBE16(src[4])) + ((Sint32) last_sample4)) >> 1);
+            sample3 = (Uint16) ((((Sint32) SDL_SwapBE16(src[3])) + ((Sint32) last_sample3)) >> 1);
+            sample2 = (Uint16) ((((Sint32) SDL_SwapBE16(src[2])) + ((Sint32) last_sample2)) >> 1);
+            sample1 = (Uint16) ((((Sint32) SDL_SwapBE16(src[1])) + ((Sint32) last_sample1)) >> 1);
+            sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            last_sample7 = sample7;
+            last_sample6 = sample6;
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16MSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_U16MSB, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 256;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Uint16 sample0 = SDL_SwapBE16(src[0]);
+    Uint16 sample1 = SDL_SwapBE16(src[1]);
+    Uint16 sample2 = SDL_SwapBE16(src[2]);
+    Uint16 sample3 = SDL_SwapBE16(src[3]);
+    Uint16 sample4 = SDL_SwapBE16(src[4]);
+    Uint16 sample5 = SDL_SwapBE16(src[5]);
+    Uint16 sample6 = SDL_SwapBE16(src[6]);
+    Uint16 sample7 = SDL_SwapBE16(src[7]);
+    Uint16 last_sample0 = sample0;
+    Uint16 last_sample1 = sample1;
+    Uint16 last_sample2 = sample2;
+    Uint16 last_sample3 = sample3;
+    Uint16 last_sample4 = sample4;
+    Uint16 last_sample5 = sample5;
+    Uint16 last_sample6 = sample6;
+    Uint16 last_sample7 = sample7;
+    while (dst < target) {
+        src += 8;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapBE16(sample0);
+            dst[1] = SDL_SwapBE16(sample1);
+            dst[2] = SDL_SwapBE16(sample2);
+            dst[3] = SDL_SwapBE16(sample3);
+            dst[4] = SDL_SwapBE16(sample4);
+            dst[5] = SDL_SwapBE16(sample5);
+            dst[6] = SDL_SwapBE16(sample6);
+            dst[7] = SDL_SwapBE16(sample7);
+            dst += 8;
+            sample0 = (Uint16) ((((Sint32) SDL_SwapBE16(src[0])) + ((Sint32) last_sample0)) >> 1);
+            sample1 = (Uint16) ((((Sint32) SDL_SwapBE16(src[1])) + ((Sint32) last_sample1)) >> 1);
+            sample2 = (Uint16) ((((Sint32) SDL_SwapBE16(src[2])) + ((Sint32) last_sample2)) >> 1);
+            sample3 = (Uint16) ((((Sint32) SDL_SwapBE16(src[3])) + ((Sint32) last_sample3)) >> 1);
+            sample4 = (Uint16) ((((Sint32) SDL_SwapBE16(src[4])) + ((Sint32) last_sample4)) >> 1);
+            sample5 = (Uint16) ((((Sint32) SDL_SwapBE16(src[5])) + ((Sint32) last_sample5)) >> 1);
+            sample6 = (Uint16) ((((Sint32) SDL_SwapBE16(src[6])) + ((Sint32) last_sample6)) >> 1);
+            sample7 = (Uint16) ((((Sint32) SDL_SwapBE16(src[7])) + ((Sint32) last_sample7)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            last_sample6 = sample6;
+            last_sample7 = sample7;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16MSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16MSB, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 32;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 1;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 1;
+    Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
+    Sint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[0] = ((Sint16) SDL_SwapBE16(sample0));
+        dst--;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src--;
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16MSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16MSB, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 32;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
+    Sint16 last_sample0 = sample0;
+    while (dst < target) {
+        src++;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint16) SDL_SwapBE16(sample0));
+            dst++;
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            last_sample0 = sample0;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16MSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16MSB, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 2;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 2;
+    Sint16 sample1 = ((Sint16) SDL_SwapBE16(src[1]));
+    Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
+    Sint16 last_sample1 = sample1;
+    Sint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[1] = ((Sint16) SDL_SwapBE16(sample1));
+        dst[0] = ((Sint16) SDL_SwapBE16(sample0));
+        dst -= 2;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 2;
+            sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16MSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16MSB, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
+    Sint16 sample1 = ((Sint16) SDL_SwapBE16(src[1]));
+    Sint16 last_sample0 = sample0;
+    Sint16 last_sample1 = sample1;
+    while (dst < target) {
+        src += 2;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint16) SDL_SwapBE16(sample0));
+            dst[1] = ((Sint16) SDL_SwapBE16(sample1));
+            dst += 2;
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16MSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16MSB, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 4;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 4;
+    Sint16 sample3 = ((Sint16) SDL_SwapBE16(src[3]));
+    Sint16 sample2 = ((Sint16) SDL_SwapBE16(src[2]));
+    Sint16 sample1 = ((Sint16) SDL_SwapBE16(src[1]));
+    Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
+    Sint16 last_sample3 = sample3;
+    Sint16 last_sample2 = sample2;
+    Sint16 last_sample1 = sample1;
+    Sint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[3] = ((Sint16) SDL_SwapBE16(sample3));
+        dst[2] = ((Sint16) SDL_SwapBE16(sample2));
+        dst[1] = ((Sint16) SDL_SwapBE16(sample1));
+        dst[0] = ((Sint16) SDL_SwapBE16(sample0));
+        dst -= 4;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 4;
+            sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
+            sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
+            sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16MSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16MSB, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
+    Sint16 sample1 = ((Sint16) SDL_SwapBE16(src[1]));
+    Sint16 sample2 = ((Sint16) SDL_SwapBE16(src[2]));
+    Sint16 sample3 = ((Sint16) SDL_SwapBE16(src[3]));
+    Sint16 last_sample0 = sample0;
+    Sint16 last_sample1 = sample1;
+    Sint16 last_sample2 = sample2;
+    Sint16 last_sample3 = sample3;
+    while (dst < target) {
+        src += 4;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint16) SDL_SwapBE16(sample0));
+            dst[1] = ((Sint16) SDL_SwapBE16(sample1));
+            dst[2] = ((Sint16) SDL_SwapBE16(sample2));
+            dst[3] = ((Sint16) SDL_SwapBE16(sample3));
+            dst += 4;
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
+            sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
+            sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16MSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16MSB, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 192;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 6;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 6;
+    Sint16 sample5 = ((Sint16) SDL_SwapBE16(src[5]));
+    Sint16 sample4 = ((Sint16) SDL_SwapBE16(src[4]));
+    Sint16 sample3 = ((Sint16) SDL_SwapBE16(src[3]));
+    Sint16 sample2 = ((Sint16) SDL_SwapBE16(src[2]));
+    Sint16 sample1 = ((Sint16) SDL_SwapBE16(src[1]));
+    Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
+    Sint16 last_sample5 = sample5;
+    Sint16 last_sample4 = sample4;
+    Sint16 last_sample3 = sample3;
+    Sint16 last_sample2 = sample2;
+    Sint16 last_sample1 = sample1;
+    Sint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[5] = ((Sint16) SDL_SwapBE16(sample5));
+        dst[4] = ((Sint16) SDL_SwapBE16(sample4));
+        dst[3] = ((Sint16) SDL_SwapBE16(sample3));
+        dst[2] = ((Sint16) SDL_SwapBE16(sample2));
+        dst[1] = ((Sint16) SDL_SwapBE16(sample1));
+        dst[0] = ((Sint16) SDL_SwapBE16(sample0));
+        dst -= 6;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 6;
+            sample5 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[5]))) + ((Sint32) last_sample5)) >> 1);
+            sample4 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[4]))) + ((Sint32) last_sample4)) >> 1);
+            sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
+            sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
+            sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16MSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16MSB, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 192;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
+    Sint16 sample1 = ((Sint16) SDL_SwapBE16(src[1]));
+    Sint16 sample2 = ((Sint16) SDL_SwapBE16(src[2]));
+    Sint16 sample3 = ((Sint16) SDL_SwapBE16(src[3]));
+    Sint16 sample4 = ((Sint16) SDL_SwapBE16(src[4]));
+    Sint16 sample5 = ((Sint16) SDL_SwapBE16(src[5]));
+    Sint16 last_sample0 = sample0;
+    Sint16 last_sample1 = sample1;
+    Sint16 last_sample2 = sample2;
+    Sint16 last_sample3 = sample3;
+    Sint16 last_sample4 = sample4;
+    Sint16 last_sample5 = sample5;
+    while (dst < target) {
+        src += 6;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint16) SDL_SwapBE16(sample0));
+            dst[1] = ((Sint16) SDL_SwapBE16(sample1));
+            dst[2] = ((Sint16) SDL_SwapBE16(sample2));
+            dst[3] = ((Sint16) SDL_SwapBE16(sample3));
+            dst[4] = ((Sint16) SDL_SwapBE16(sample4));
+            dst[5] = ((Sint16) SDL_SwapBE16(sample5));
+            dst += 6;
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
+            sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
+            sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
+            sample4 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[4]))) + ((Sint32) last_sample4)) >> 1);
+            sample5 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[5]))) + ((Sint32) last_sample5)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16MSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S16MSB, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 256;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 8;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 8;
+    Sint16 sample7 = ((Sint16) SDL_SwapBE16(src[7]));
+    Sint16 sample6 = ((Sint16) SDL_SwapBE16(src[6]));
+    Sint16 sample5 = ((Sint16) SDL_SwapBE16(src[5]));
+    Sint16 sample4 = ((Sint16) SDL_SwapBE16(src[4]));
+    Sint16 sample3 = ((Sint16) SDL_SwapBE16(src[3]));
+    Sint16 sample2 = ((Sint16) SDL_SwapBE16(src[2]));
+    Sint16 sample1 = ((Sint16) SDL_SwapBE16(src[1]));
+    Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
+    Sint16 last_sample7 = sample7;
+    Sint16 last_sample6 = sample6;
+    Sint16 last_sample5 = sample5;
+    Sint16 last_sample4 = sample4;
+    Sint16 last_sample3 = sample3;
+    Sint16 last_sample2 = sample2;
+    Sint16 last_sample1 = sample1;
+    Sint16 last_sample0 = sample0;
+    while (dst > target) {
+        dst[7] = ((Sint16) SDL_SwapBE16(sample7));
+        dst[6] = ((Sint16) SDL_SwapBE16(sample6));
+        dst[5] = ((Sint16) SDL_SwapBE16(sample5));
+        dst[4] = ((Sint16) SDL_SwapBE16(sample4));
+        dst[3] = ((Sint16) SDL_SwapBE16(sample3));
+        dst[2] = ((Sint16) SDL_SwapBE16(sample2));
+        dst[1] = ((Sint16) SDL_SwapBE16(sample1));
+        dst[0] = ((Sint16) SDL_SwapBE16(sample0));
+        dst -= 8;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 8;
+            sample7 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[7]))) + ((Sint32) last_sample7)) >> 1);
+            sample6 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[6]))) + ((Sint32) last_sample6)) >> 1);
+            sample5 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[5]))) + ((Sint32) last_sample5)) >> 1);
+            sample4 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[4]))) + ((Sint32) last_sample4)) >> 1);
+            sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
+            sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
+            sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            last_sample7 = sample7;
+            last_sample6 = sample6;
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16MSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S16MSB, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 256;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint16 sample0 = ((Sint16) SDL_SwapBE16(src[0]));
+    Sint16 sample1 = ((Sint16) SDL_SwapBE16(src[1]));
+    Sint16 sample2 = ((Sint16) SDL_SwapBE16(src[2]));
+    Sint16 sample3 = ((Sint16) SDL_SwapBE16(src[3]));
+    Sint16 sample4 = ((Sint16) SDL_SwapBE16(src[4]));
+    Sint16 sample5 = ((Sint16) SDL_SwapBE16(src[5]));
+    Sint16 sample6 = ((Sint16) SDL_SwapBE16(src[6]));
+    Sint16 sample7 = ((Sint16) SDL_SwapBE16(src[7]));
+    Sint16 last_sample0 = sample0;
+    Sint16 last_sample1 = sample1;
+    Sint16 last_sample2 = sample2;
+    Sint16 last_sample3 = sample3;
+    Sint16 last_sample4 = sample4;
+    Sint16 last_sample5 = sample5;
+    Sint16 last_sample6 = sample6;
+    Sint16 last_sample7 = sample7;
+    while (dst < target) {
+        src += 8;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint16) SDL_SwapBE16(sample0));
+            dst[1] = ((Sint16) SDL_SwapBE16(sample1));
+            dst[2] = ((Sint16) SDL_SwapBE16(sample2));
+            dst[3] = ((Sint16) SDL_SwapBE16(sample3));
+            dst[4] = ((Sint16) SDL_SwapBE16(sample4));
+            dst[5] = ((Sint16) SDL_SwapBE16(sample5));
+            dst[6] = ((Sint16) SDL_SwapBE16(sample6));
+            dst[7] = ((Sint16) SDL_SwapBE16(sample7));
+            dst += 8;
+            sample0 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[0]))) + ((Sint32) last_sample0)) >> 1);
+            sample1 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[1]))) + ((Sint32) last_sample1)) >> 1);
+            sample2 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[2]))) + ((Sint32) last_sample2)) >> 1);
+            sample3 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[3]))) + ((Sint32) last_sample3)) >> 1);
+            sample4 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[4]))) + ((Sint32) last_sample4)) >> 1);
+            sample5 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[5]))) + ((Sint32) last_sample5)) >> 1);
+            sample6 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[6]))) + ((Sint32) last_sample6)) >> 1);
+            sample7 = (Sint16) ((((Sint32) ((Sint16) SDL_SwapBE16(src[7]))) + ((Sint32) last_sample7)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            last_sample6 = sample6;
+            last_sample7 = sample7;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32LSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32LSB, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 1;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 1;
+    Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
+    Sint32 last_sample0 = sample0;
+    while (dst > target) {
+        dst[0] = ((Sint32) SDL_SwapLE32(sample0));
+        dst--;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src--;
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32LSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32LSB, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
+    Sint32 last_sample0 = sample0;
+    while (dst < target) {
+        src++;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint32) SDL_SwapLE32(sample0));
+            dst++;
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            last_sample0 = sample0;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32LSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32LSB, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 2;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 2;
+    Sint32 sample1 = ((Sint32) SDL_SwapLE32(src[1]));
+    Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
+    Sint32 last_sample1 = sample1;
+    Sint32 last_sample0 = sample0;
+    while (dst > target) {
+        dst[1] = ((Sint32) SDL_SwapLE32(sample1));
+        dst[0] = ((Sint32) SDL_SwapLE32(sample0));
+        dst -= 2;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 2;
+            sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32LSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32LSB, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
+    Sint32 sample1 = ((Sint32) SDL_SwapLE32(src[1]));
+    Sint32 last_sample0 = sample0;
+    Sint32 last_sample1 = sample1;
+    while (dst < target) {
+        src += 2;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint32) SDL_SwapLE32(sample0));
+            dst[1] = ((Sint32) SDL_SwapLE32(sample1));
+            dst += 2;
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32LSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32LSB, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 256;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 4;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 4;
+    Sint32 sample3 = ((Sint32) SDL_SwapLE32(src[3]));
+    Sint32 sample2 = ((Sint32) SDL_SwapLE32(src[2]));
+    Sint32 sample1 = ((Sint32) SDL_SwapLE32(src[1]));
+    Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
+    Sint32 last_sample3 = sample3;
+    Sint32 last_sample2 = sample2;
+    Sint32 last_sample1 = sample1;
+    Sint32 last_sample0 = sample0;
+    while (dst > target) {
+        dst[3] = ((Sint32) SDL_SwapLE32(sample3));
+        dst[2] = ((Sint32) SDL_SwapLE32(sample2));
+        dst[1] = ((Sint32) SDL_SwapLE32(sample1));
+        dst[0] = ((Sint32) SDL_SwapLE32(sample0));
+        dst -= 4;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 4;
+            sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
+            sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
+            sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32LSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32LSB, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 256;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
+    Sint32 sample1 = ((Sint32) SDL_SwapLE32(src[1]));
+    Sint32 sample2 = ((Sint32) SDL_SwapLE32(src[2]));
+    Sint32 sample3 = ((Sint32) SDL_SwapLE32(src[3]));
+    Sint32 last_sample0 = sample0;
+    Sint32 last_sample1 = sample1;
+    Sint32 last_sample2 = sample2;
+    Sint32 last_sample3 = sample3;
+    while (dst < target) {
+        src += 4;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint32) SDL_SwapLE32(sample0));
+            dst[1] = ((Sint32) SDL_SwapLE32(sample1));
+            dst[2] = ((Sint32) SDL_SwapLE32(sample2));
+            dst[3] = ((Sint32) SDL_SwapLE32(sample3));
+            dst += 4;
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
+            sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
+            sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32LSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32LSB, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 384;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 6;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 6;
+    Sint32 sample5 = ((Sint32) SDL_SwapLE32(src[5]));
+    Sint32 sample4 = ((Sint32) SDL_SwapLE32(src[4]));
+    Sint32 sample3 = ((Sint32) SDL_SwapLE32(src[3]));
+    Sint32 sample2 = ((Sint32) SDL_SwapLE32(src[2]));
+    Sint32 sample1 = ((Sint32) SDL_SwapLE32(src[1]));
+    Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
+    Sint32 last_sample5 = sample5;
+    Sint32 last_sample4 = sample4;
+    Sint32 last_sample3 = sample3;
+    Sint32 last_sample2 = sample2;
+    Sint32 last_sample1 = sample1;
+    Sint32 last_sample0 = sample0;
+    while (dst > target) {
+        dst[5] = ((Sint32) SDL_SwapLE32(sample5));
+        dst[4] = ((Sint32) SDL_SwapLE32(sample4));
+        dst[3] = ((Sint32) SDL_SwapLE32(sample3));
+        dst[2] = ((Sint32) SDL_SwapLE32(sample2));
+        dst[1] = ((Sint32) SDL_SwapLE32(sample1));
+        dst[0] = ((Sint32) SDL_SwapLE32(sample0));
+        dst -= 6;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 6;
+            sample5 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[5]))) + ((Sint64) last_sample5)) >> 1);
+            sample4 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[4]))) + ((Sint64) last_sample4)) >> 1);
+            sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
+            sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
+            sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32LSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32LSB, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 384;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
+    Sint32 sample1 = ((Sint32) SDL_SwapLE32(src[1]));
+    Sint32 sample2 = ((Sint32) SDL_SwapLE32(src[2]));
+    Sint32 sample3 = ((Sint32) SDL_SwapLE32(src[3]));
+    Sint32 sample4 = ((Sint32) SDL_SwapLE32(src[4]));
+    Sint32 sample5 = ((Sint32) SDL_SwapLE32(src[5]));
+    Sint32 last_sample0 = sample0;
+    Sint32 last_sample1 = sample1;
+    Sint32 last_sample2 = sample2;
+    Sint32 last_sample3 = sample3;
+    Sint32 last_sample4 = sample4;
+    Sint32 last_sample5 = sample5;
+    while (dst < target) {
+        src += 6;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint32) SDL_SwapLE32(sample0));
+            dst[1] = ((Sint32) SDL_SwapLE32(sample1));
+            dst[2] = ((Sint32) SDL_SwapLE32(sample2));
+            dst[3] = ((Sint32) SDL_SwapLE32(sample3));
+            dst[4] = ((Sint32) SDL_SwapLE32(sample4));
+            dst[5] = ((Sint32) SDL_SwapLE32(sample5));
+            dst += 6;
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
+            sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
+            sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
+            sample4 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[4]))) + ((Sint64) last_sample4)) >> 1);
+            sample5 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[5]))) + ((Sint64) last_sample5)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32LSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32LSB, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 512;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 8;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 8;
+    Sint32 sample7 = ((Sint32) SDL_SwapLE32(src[7]));
+    Sint32 sample6 = ((Sint32) SDL_SwapLE32(src[6]));
+    Sint32 sample5 = ((Sint32) SDL_SwapLE32(src[5]));
+    Sint32 sample4 = ((Sint32) SDL_SwapLE32(src[4]));
+    Sint32 sample3 = ((Sint32) SDL_SwapLE32(src[3]));
+    Sint32 sample2 = ((Sint32) SDL_SwapLE32(src[2]));
+    Sint32 sample1 = ((Sint32) SDL_SwapLE32(src[1]));
+    Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
+    Sint32 last_sample7 = sample7;
+    Sint32 last_sample6 = sample6;
+    Sint32 last_sample5 = sample5;
+    Sint32 last_sample4 = sample4;
+    Sint32 last_sample3 = sample3;
+    Sint32 last_sample2 = sample2;
+    Sint32 last_sample1 = sample1;
+    Sint32 last_sample0 = sample0;
+    while (dst > target) {
+        dst[7] = ((Sint32) SDL_SwapLE32(sample7));
+        dst[6] = ((Sint32) SDL_SwapLE32(sample6));
+        dst[5] = ((Sint32) SDL_SwapLE32(sample5));
+        dst[4] = ((Sint32) SDL_SwapLE32(sample4));
+        dst[3] = ((Sint32) SDL_SwapLE32(sample3));
+        dst[2] = ((Sint32) SDL_SwapLE32(sample2));
+        dst[1] = ((Sint32) SDL_SwapLE32(sample1));
+        dst[0] = ((Sint32) SDL_SwapLE32(sample0));
+        dst -= 8;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 8;
+            sample7 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[7]))) + ((Sint64) last_sample7)) >> 1);
+            sample6 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[6]))) + ((Sint64) last_sample6)) >> 1);
+            sample5 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[5]))) + ((Sint64) last_sample5)) >> 1);
+            sample4 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[4]))) + ((Sint64) last_sample4)) >> 1);
+            sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
+            sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
+            sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            last_sample7 = sample7;
+            last_sample6 = sample6;
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32LSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32LSB, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 512;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint32 sample0 = ((Sint32) SDL_SwapLE32(src[0]));
+    Sint32 sample1 = ((Sint32) SDL_SwapLE32(src[1]));
+    Sint32 sample2 = ((Sint32) SDL_SwapLE32(src[2]));
+    Sint32 sample3 = ((Sint32) SDL_SwapLE32(src[3]));
+    Sint32 sample4 = ((Sint32) SDL_SwapLE32(src[4]));
+    Sint32 sample5 = ((Sint32) SDL_SwapLE32(src[5]));
+    Sint32 sample6 = ((Sint32) SDL_SwapLE32(src[6]));
+    Sint32 sample7 = ((Sint32) SDL_SwapLE32(src[7]));
+    Sint32 last_sample0 = sample0;
+    Sint32 last_sample1 = sample1;
+    Sint32 last_sample2 = sample2;
+    Sint32 last_sample3 = sample3;
+    Sint32 last_sample4 = sample4;
+    Sint32 last_sample5 = sample5;
+    Sint32 last_sample6 = sample6;
+    Sint32 last_sample7 = sample7;
+    while (dst < target) {
+        src += 8;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint32) SDL_SwapLE32(sample0));
+            dst[1] = ((Sint32) SDL_SwapLE32(sample1));
+            dst[2] = ((Sint32) SDL_SwapLE32(sample2));
+            dst[3] = ((Sint32) SDL_SwapLE32(sample3));
+            dst[4] = ((Sint32) SDL_SwapLE32(sample4));
+            dst[5] = ((Sint32) SDL_SwapLE32(sample5));
+            dst[6] = ((Sint32) SDL_SwapLE32(sample6));
+            dst[7] = ((Sint32) SDL_SwapLE32(sample7));
+            dst += 8;
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
+            sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
+            sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
+            sample4 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[4]))) + ((Sint64) last_sample4)) >> 1);
+            sample5 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[5]))) + ((Sint64) last_sample5)) >> 1);
+            sample6 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[6]))) + ((Sint64) last_sample6)) >> 1);
+            sample7 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapLE32(src[7]))) + ((Sint64) last_sample7)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            last_sample6 = sample6;
+            last_sample7 = sample7;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32MSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32MSB, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 1;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 1;
+    Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
+    Sint32 last_sample0 = sample0;
+    while (dst > target) {
+        dst[0] = ((Sint32) SDL_SwapBE32(sample0));
+        dst--;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src--;
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32MSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32MSB, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
+    Sint32 last_sample0 = sample0;
+    while (dst < target) {
+        src++;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint32) SDL_SwapBE32(sample0));
+            dst++;
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            last_sample0 = sample0;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32MSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32MSB, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 2;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 2;
+    Sint32 sample1 = ((Sint32) SDL_SwapBE32(src[1]));
+    Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
+    Sint32 last_sample1 = sample1;
+    Sint32 last_sample0 = sample0;
+    while (dst > target) {
+        dst[1] = ((Sint32) SDL_SwapBE32(sample1));
+        dst[0] = ((Sint32) SDL_SwapBE32(sample0));
+        dst -= 2;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 2;
+            sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32MSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32MSB, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
+    Sint32 sample1 = ((Sint32) SDL_SwapBE32(src[1]));
+    Sint32 last_sample0 = sample0;
+    Sint32 last_sample1 = sample1;
+    while (dst < target) {
+        src += 2;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint32) SDL_SwapBE32(sample0));
+            dst[1] = ((Sint32) SDL_SwapBE32(sample1));
+            dst += 2;
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32MSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32MSB, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 256;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 4;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 4;
+    Sint32 sample3 = ((Sint32) SDL_SwapBE32(src[3]));
+    Sint32 sample2 = ((Sint32) SDL_SwapBE32(src[2]));
+    Sint32 sample1 = ((Sint32) SDL_SwapBE32(src[1]));
+    Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
+    Sint32 last_sample3 = sample3;
+    Sint32 last_sample2 = sample2;
+    Sint32 last_sample1 = sample1;
+    Sint32 last_sample0 = sample0;
+    while (dst > target) {
+        dst[3] = ((Sint32) SDL_SwapBE32(sample3));
+        dst[2] = ((Sint32) SDL_SwapBE32(sample2));
+        dst[1] = ((Sint32) SDL_SwapBE32(sample1));
+        dst[0] = ((Sint32) SDL_SwapBE32(sample0));
+        dst -= 4;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 4;
+            sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
+            sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
+            sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32MSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32MSB, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 256;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
+    Sint32 sample1 = ((Sint32) SDL_SwapBE32(src[1]));
+    Sint32 sample2 = ((Sint32) SDL_SwapBE32(src[2]));
+    Sint32 sample3 = ((Sint32) SDL_SwapBE32(src[3]));
+    Sint32 last_sample0 = sample0;
+    Sint32 last_sample1 = sample1;
+    Sint32 last_sample2 = sample2;
+    Sint32 last_sample3 = sample3;
+    while (dst < target) {
+        src += 4;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint32) SDL_SwapBE32(sample0));
+            dst[1] = ((Sint32) SDL_SwapBE32(sample1));
+            dst[2] = ((Sint32) SDL_SwapBE32(sample2));
+            dst[3] = ((Sint32) SDL_SwapBE32(sample3));
+            dst += 4;
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
+            sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
+            sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32MSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32MSB, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 384;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 6;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 6;
+    Sint32 sample5 = ((Sint32) SDL_SwapBE32(src[5]));
+    Sint32 sample4 = ((Sint32) SDL_SwapBE32(src[4]));
+    Sint32 sample3 = ((Sint32) SDL_SwapBE32(src[3]));
+    Sint32 sample2 = ((Sint32) SDL_SwapBE32(src[2]));
+    Sint32 sample1 = ((Sint32) SDL_SwapBE32(src[1]));
+    Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
+    Sint32 last_sample5 = sample5;
+    Sint32 last_sample4 = sample4;
+    Sint32 last_sample3 = sample3;
+    Sint32 last_sample2 = sample2;
+    Sint32 last_sample1 = sample1;
+    Sint32 last_sample0 = sample0;
+    while (dst > target) {
+        dst[5] = ((Sint32) SDL_SwapBE32(sample5));
+        dst[4] = ((Sint32) SDL_SwapBE32(sample4));
+        dst[3] = ((Sint32) SDL_SwapBE32(sample3));
+        dst[2] = ((Sint32) SDL_SwapBE32(sample2));
+        dst[1] = ((Sint32) SDL_SwapBE32(sample1));
+        dst[0] = ((Sint32) SDL_SwapBE32(sample0));
+        dst -= 6;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 6;
+            sample5 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[5]))) + ((Sint64) last_sample5)) >> 1);
+            sample4 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[4]))) + ((Sint64) last_sample4)) >> 1);
+            sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
+            sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
+            sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32MSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32MSB, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 384;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
+    Sint32 sample1 = ((Sint32) SDL_SwapBE32(src[1]));
+    Sint32 sample2 = ((Sint32) SDL_SwapBE32(src[2]));
+    Sint32 sample3 = ((Sint32) SDL_SwapBE32(src[3]));
+    Sint32 sample4 = ((Sint32) SDL_SwapBE32(src[4]));
+    Sint32 sample5 = ((Sint32) SDL_SwapBE32(src[5]));
+    Sint32 last_sample0 = sample0;
+    Sint32 last_sample1 = sample1;
+    Sint32 last_sample2 = sample2;
+    Sint32 last_sample3 = sample3;
+    Sint32 last_sample4 = sample4;
+    Sint32 last_sample5 = sample5;
+    while (dst < target) {
+        src += 6;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint32) SDL_SwapBE32(sample0));
+            dst[1] = ((Sint32) SDL_SwapBE32(sample1));
+            dst[2] = ((Sint32) SDL_SwapBE32(sample2));
+            dst[3] = ((Sint32) SDL_SwapBE32(sample3));
+            dst[4] = ((Sint32) SDL_SwapBE32(sample4));
+            dst[5] = ((Sint32) SDL_SwapBE32(sample5));
+            dst += 6;
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
+            sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
+            sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
+            sample4 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[4]))) + ((Sint64) last_sample4)) >> 1);
+            sample5 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[5]))) + ((Sint64) last_sample5)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32MSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_S32MSB, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 512;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 8;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 8;
+    Sint32 sample7 = ((Sint32) SDL_SwapBE32(src[7]));
+    Sint32 sample6 = ((Sint32) SDL_SwapBE32(src[6]));
+    Sint32 sample5 = ((Sint32) SDL_SwapBE32(src[5]));
+    Sint32 sample4 = ((Sint32) SDL_SwapBE32(src[4]));
+    Sint32 sample3 = ((Sint32) SDL_SwapBE32(src[3]));
+    Sint32 sample2 = ((Sint32) SDL_SwapBE32(src[2]));
+    Sint32 sample1 = ((Sint32) SDL_SwapBE32(src[1]));
+    Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
+    Sint32 last_sample7 = sample7;
+    Sint32 last_sample6 = sample6;
+    Sint32 last_sample5 = sample5;
+    Sint32 last_sample4 = sample4;
+    Sint32 last_sample3 = sample3;
+    Sint32 last_sample2 = sample2;
+    Sint32 last_sample1 = sample1;
+    Sint32 last_sample0 = sample0;
+    while (dst > target) {
+        dst[7] = ((Sint32) SDL_SwapBE32(sample7));
+        dst[6] = ((Sint32) SDL_SwapBE32(sample6));
+        dst[5] = ((Sint32) SDL_SwapBE32(sample5));
+        dst[4] = ((Sint32) SDL_SwapBE32(sample4));
+        dst[3] = ((Sint32) SDL_SwapBE32(sample3));
+        dst[2] = ((Sint32) SDL_SwapBE32(sample2));
+        dst[1] = ((Sint32) SDL_SwapBE32(sample1));
+        dst[0] = ((Sint32) SDL_SwapBE32(sample0));
+        dst -= 8;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 8;
+            sample7 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[7]))) + ((Sint64) last_sample7)) >> 1);
+            sample6 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[6]))) + ((Sint64) last_sample6)) >> 1);
+            sample5 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[5]))) + ((Sint64) last_sample5)) >> 1);
+            sample4 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[4]))) + ((Sint64) last_sample4)) >> 1);
+            sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
+            sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
+            sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            last_sample7 = sample7;
+            last_sample6 = sample6;
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32MSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_S32MSB, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 512;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint32 sample0 = ((Sint32) SDL_SwapBE32(src[0]));
+    Sint32 sample1 = ((Sint32) SDL_SwapBE32(src[1]));
+    Sint32 sample2 = ((Sint32) SDL_SwapBE32(src[2]));
+    Sint32 sample3 = ((Sint32) SDL_SwapBE32(src[3]));
+    Sint32 sample4 = ((Sint32) SDL_SwapBE32(src[4]));
+    Sint32 sample5 = ((Sint32) SDL_SwapBE32(src[5]));
+    Sint32 sample6 = ((Sint32) SDL_SwapBE32(src[6]));
+    Sint32 sample7 = ((Sint32) SDL_SwapBE32(src[7]));
+    Sint32 last_sample0 = sample0;
+    Sint32 last_sample1 = sample1;
+    Sint32 last_sample2 = sample2;
+    Sint32 last_sample3 = sample3;
+    Sint32 last_sample4 = sample4;
+    Sint32 last_sample5 = sample5;
+    Sint32 last_sample6 = sample6;
+    Sint32 last_sample7 = sample7;
+    while (dst < target) {
+        src += 8;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = ((Sint32) SDL_SwapBE32(sample0));
+            dst[1] = ((Sint32) SDL_SwapBE32(sample1));
+            dst[2] = ((Sint32) SDL_SwapBE32(sample2));
+            dst[3] = ((Sint32) SDL_SwapBE32(sample3));
+            dst[4] = ((Sint32) SDL_SwapBE32(sample4));
+            dst[5] = ((Sint32) SDL_SwapBE32(sample5));
+            dst[6] = ((Sint32) SDL_SwapBE32(sample6));
+            dst[7] = ((Sint32) SDL_SwapBE32(sample7));
+            dst += 8;
+            sample0 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[0]))) + ((Sint64) last_sample0)) >> 1);
+            sample1 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[1]))) + ((Sint64) last_sample1)) >> 1);
+            sample2 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[2]))) + ((Sint64) last_sample2)) >> 1);
+            sample3 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[3]))) + ((Sint64) last_sample3)) >> 1);
+            sample4 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[4]))) + ((Sint64) last_sample4)) >> 1);
+            sample5 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[5]))) + ((Sint64) last_sample5)) >> 1);
+            sample6 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[6]))) + ((Sint64) last_sample6)) >> 1);
+            sample7 = (Sint32) ((((Sint64) ((Sint32) SDL_SwapBE32(src[7]))) + ((Sint64) last_sample7)) >> 1);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            last_sample6 = sample6;
+            last_sample7 = sample7;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32LSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32LSB, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 1;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 1;
+    const float *target = ((const float *) cvt->buf) - 1;
+    float sample0 = SDL_SwapFloatLE(src[0]);
+    float last_sample0 = sample0;
+    while (dst > target) {
+        dst[0] = SDL_SwapFloatLE(sample0);
+        dst--;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src--;
+            sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32LSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32LSB, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    float sample0 = SDL_SwapFloatLE(src[0]);
+    float last_sample0 = sample0;
+    while (dst < target) {
+        src++;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapFloatLE(sample0);
+            dst++;
+            sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
+            last_sample0 = sample0;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32LSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32LSB, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 2;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 2;
+    const float *target = ((const float *) cvt->buf) - 2;
+    float sample1 = SDL_SwapFloatLE(src[1]);
+    float sample0 = SDL_SwapFloatLE(src[0]);
+    float last_sample1 = sample1;
+    float last_sample0 = sample0;
+    while (dst > target) {
+        dst[1] = SDL_SwapFloatLE(sample1);
+        dst[0] = SDL_SwapFloatLE(sample0);
+        dst -= 2;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 2;
+            sample1 = (float) ((((double) SDL_SwapFloatLE(src[1])) + ((double) last_sample1)) * 0.5);
+            sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32LSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32LSB, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    float sample0 = SDL_SwapFloatLE(src[0]);
+    float sample1 = SDL_SwapFloatLE(src[1]);
+    float last_sample0 = sample0;
+    float last_sample1 = sample1;
+    while (dst < target) {
+        src += 2;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapFloatLE(sample0);
+            dst[1] = SDL_SwapFloatLE(sample1);
+            dst += 2;
+            sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
+            sample1 = (float) ((((double) SDL_SwapFloatLE(src[1])) + ((double) last_sample1)) * 0.5);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32LSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32LSB, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 256;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 4;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 4;
+    const float *target = ((const float *) cvt->buf) - 4;
+    float sample3 = SDL_SwapFloatLE(src[3]);
+    float sample2 = SDL_SwapFloatLE(src[2]);
+    float sample1 = SDL_SwapFloatLE(src[1]);
+    float sample0 = SDL_SwapFloatLE(src[0]);
+    float last_sample3 = sample3;
+    float last_sample2 = sample2;
+    float last_sample1 = sample1;
+    float last_sample0 = sample0;
+    while (dst > target) {
+        dst[3] = SDL_SwapFloatLE(sample3);
+        dst[2] = SDL_SwapFloatLE(sample2);
+        dst[1] = SDL_SwapFloatLE(sample1);
+        dst[0] = SDL_SwapFloatLE(sample0);
+        dst -= 4;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 4;
+            sample3 = (float) ((((double) SDL_SwapFloatLE(src[3])) + ((double) last_sample3)) * 0.5);
+            sample2 = (float) ((((double) SDL_SwapFloatLE(src[2])) + ((double) last_sample2)) * 0.5);
+            sample1 = (float) ((((double) SDL_SwapFloatLE(src[1])) + ((double) last_sample1)) * 0.5);
+            sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32LSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32LSB, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 256;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    float sample0 = SDL_SwapFloatLE(src[0]);
+    float sample1 = SDL_SwapFloatLE(src[1]);
+    float sample2 = SDL_SwapFloatLE(src[2]);
+    float sample3 = SDL_SwapFloatLE(src[3]);
+    float last_sample0 = sample0;
+    float last_sample1 = sample1;
+    float last_sample2 = sample2;
+    float last_sample3 = sample3;
+    while (dst < target) {
+        src += 4;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapFloatLE(sample0);
+            dst[1] = SDL_SwapFloatLE(sample1);
+            dst[2] = SDL_SwapFloatLE(sample2);
+            dst[3] = SDL_SwapFloatLE(sample3);
+            dst += 4;
+            sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
+            sample1 = (float) ((((double) SDL_SwapFloatLE(src[1])) + ((double) last_sample1)) * 0.5);
+            sample2 = (float) ((((double) SDL_SwapFloatLE(src[2])) + ((double) last_sample2)) * 0.5);
+            sample3 = (float) ((((double) SDL_SwapFloatLE(src[3])) + ((double) last_sample3)) * 0.5);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32LSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32LSB, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 384;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 6;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 6;
+    const float *target = ((const float *) cvt->buf) - 6;
+    float sample5 = SDL_SwapFloatLE(src[5]);
+    float sample4 = SDL_SwapFloatLE(src[4]);
+    float sample3 = SDL_SwapFloatLE(src[3]);
+    float sample2 = SDL_SwapFloatLE(src[2]);
+    float sample1 = SDL_SwapFloatLE(src[1]);
+    float sample0 = SDL_SwapFloatLE(src[0]);
+    float last_sample5 = sample5;
+    float last_sample4 = sample4;
+    float last_sample3 = sample3;
+    float last_sample2 = sample2;
+    float last_sample1 = sample1;
+    float last_sample0 = sample0;
+    while (dst > target) {
+        dst[5] = SDL_SwapFloatLE(sample5);
+        dst[4] = SDL_SwapFloatLE(sample4);
+        dst[3] = SDL_SwapFloatLE(sample3);
+        dst[2] = SDL_SwapFloatLE(sample2);
+        dst[1] = SDL_SwapFloatLE(sample1);
+        dst[0] = SDL_SwapFloatLE(sample0);
+        dst -= 6;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 6;
+            sample5 = (float) ((((double) SDL_SwapFloatLE(src[5])) + ((double) last_sample5)) * 0.5);
+            sample4 = (float) ((((double) SDL_SwapFloatLE(src[4])) + ((double) last_sample4)) * 0.5);
+            sample3 = (float) ((((double) SDL_SwapFloatLE(src[3])) + ((double) last_sample3)) * 0.5);
+            sample2 = (float) ((((double) SDL_SwapFloatLE(src[2])) + ((double) last_sample2)) * 0.5);
+            sample1 = (float) ((((double) SDL_SwapFloatLE(src[1])) + ((double) last_sample1)) * 0.5);
+            sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32LSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32LSB, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 384;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    float sample0 = SDL_SwapFloatLE(src[0]);
+    float sample1 = SDL_SwapFloatLE(src[1]);
+    float sample2 = SDL_SwapFloatLE(src[2]);
+    float sample3 = SDL_SwapFloatLE(src[3]);
+    float sample4 = SDL_SwapFloatLE(src[4]);
+    float sample5 = SDL_SwapFloatLE(src[5]);
+    float last_sample0 = sample0;
+    float last_sample1 = sample1;
+    float last_sample2 = sample2;
+    float last_sample3 = sample3;
+    float last_sample4 = sample4;
+    float last_sample5 = sample5;
+    while (dst < target) {
+        src += 6;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapFloatLE(sample0);
+            dst[1] = SDL_SwapFloatLE(sample1);
+            dst[2] = SDL_SwapFloatLE(sample2);
+            dst[3] = SDL_SwapFloatLE(sample3);
+            dst[4] = SDL_SwapFloatLE(sample4);
+            dst[5] = SDL_SwapFloatLE(sample5);
+            dst += 6;
+            sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
+            sample1 = (float) ((((double) SDL_SwapFloatLE(src[1])) + ((double) last_sample1)) * 0.5);
+            sample2 = (float) ((((double) SDL_SwapFloatLE(src[2])) + ((double) last_sample2)) * 0.5);
+            sample3 = (float) ((((double) SDL_SwapFloatLE(src[3])) + ((double) last_sample3)) * 0.5);
+            sample4 = (float) ((((double) SDL_SwapFloatLE(src[4])) + ((double) last_sample4)) * 0.5);
+            sample5 = (float) ((((double) SDL_SwapFloatLE(src[5])) + ((double) last_sample5)) * 0.5);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32LSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32LSB, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 512;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 8;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 8;
+    const float *target = ((const float *) cvt->buf) - 8;
+    float sample7 = SDL_SwapFloatLE(src[7]);
+    float sample6 = SDL_SwapFloatLE(src[6]);
+    float sample5 = SDL_SwapFloatLE(src[5]);
+    float sample4 = SDL_SwapFloatLE(src[4]);
+    float sample3 = SDL_SwapFloatLE(src[3]);
+    float sample2 = SDL_SwapFloatLE(src[2]);
+    float sample1 = SDL_SwapFloatLE(src[1]);
+    float sample0 = SDL_SwapFloatLE(src[0]);
+    float last_sample7 = sample7;
+    float last_sample6 = sample6;
+    float last_sample5 = sample5;
+    float last_sample4 = sample4;
+    float last_sample3 = sample3;
+    float last_sample2 = sample2;
+    float last_sample1 = sample1;
+    float last_sample0 = sample0;
+    while (dst > target) {
+        dst[7] = SDL_SwapFloatLE(sample7);
+        dst[6] = SDL_SwapFloatLE(sample6);
+        dst[5] = SDL_SwapFloatLE(sample5);
+        dst[4] = SDL_SwapFloatLE(sample4);
+        dst[3] = SDL_SwapFloatLE(sample3);
+        dst[2] = SDL_SwapFloatLE(sample2);
+        dst[1] = SDL_SwapFloatLE(sample1);
+        dst[0] = SDL_SwapFloatLE(sample0);
+        dst -= 8;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 8;
+            sample7 = (float) ((((double) SDL_SwapFloatLE(src[7])) + ((double) last_sample7)) * 0.5);
+            sample6 = (float) ((((double) SDL_SwapFloatLE(src[6])) + ((double) last_sample6)) * 0.5);
+            sample5 = (float) ((((double) SDL_SwapFloatLE(src[5])) + ((double) last_sample5)) * 0.5);
+            sample4 = (float) ((((double) SDL_SwapFloatLE(src[4])) + ((double) last_sample4)) * 0.5);
+            sample3 = (float) ((((double) SDL_SwapFloatLE(src[3])) + ((double) last_sample3)) * 0.5);
+            sample2 = (float) ((((double) SDL_SwapFloatLE(src[2])) + ((double) last_sample2)) * 0.5);
+            sample1 = (float) ((((double) SDL_SwapFloatLE(src[1])) + ((double) last_sample1)) * 0.5);
+            sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
+            last_sample7 = sample7;
+            last_sample6 = sample6;
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32LSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32LSB, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 512;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    float sample0 = SDL_SwapFloatLE(src[0]);
+    float sample1 = SDL_SwapFloatLE(src[1]);
+    float sample2 = SDL_SwapFloatLE(src[2]);
+    float sample3 = SDL_SwapFloatLE(src[3]);
+    float sample4 = SDL_SwapFloatLE(src[4]);
+    float sample5 = SDL_SwapFloatLE(src[5]);
+    float sample6 = SDL_SwapFloatLE(src[6]);
+    float sample7 = SDL_SwapFloatLE(src[7]);
+    float last_sample0 = sample0;
+    float last_sample1 = sample1;
+    float last_sample2 = sample2;
+    float last_sample3 = sample3;
+    float last_sample4 = sample4;
+    float last_sample5 = sample5;
+    float last_sample6 = sample6;
+    float last_sample7 = sample7;
+    while (dst < target) {
+        src += 8;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapFloatLE(sample0);
+            dst[1] = SDL_SwapFloatLE(sample1);
+            dst[2] = SDL_SwapFloatLE(sample2);
+            dst[3] = SDL_SwapFloatLE(sample3);
+            dst[4] = SDL_SwapFloatLE(sample4);
+            dst[5] = SDL_SwapFloatLE(sample5);
+            dst[6] = SDL_SwapFloatLE(sample6);
+            dst[7] = SDL_SwapFloatLE(sample7);
+            dst += 8;
+            sample0 = (float) ((((double) SDL_SwapFloatLE(src[0])) + ((double) last_sample0)) * 0.5);
+            sample1 = (float) ((((double) SDL_SwapFloatLE(src[1])) + ((double) last_sample1)) * 0.5);
+            sample2 = (float) ((((double) SDL_SwapFloatLE(src[2])) + ((double) last_sample2)) * 0.5);
+            sample3 = (float) ((((double) SDL_SwapFloatLE(src[3])) + ((double) last_sample3)) * 0.5);
+            sample4 = (float) ((((double) SDL_SwapFloatLE(src[4])) + ((double) last_sample4)) * 0.5);
+            sample5 = (float) ((((double) SDL_SwapFloatLE(src[5])) + ((double) last_sample5)) * 0.5);
+            sample6 = (float) ((((double) SDL_SwapFloatLE(src[6])) + ((double) last_sample6)) * 0.5);
+            sample7 = (float) ((((double) SDL_SwapFloatLE(src[7])) + ((double) last_sample7)) * 0.5);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            last_sample6 = sample6;
+            last_sample7 = sample7;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32MSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32MSB, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 1;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 1;
+    const float *target = ((const float *) cvt->buf) - 1;
+    float sample0 = SDL_SwapFloatBE(src[0]);
+    float last_sample0 = sample0;
+    while (dst > target) {
+        dst[0] = SDL_SwapFloatBE(sample0);
+        dst--;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src--;
+            sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32MSB_1c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32MSB, 1 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 64;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    float sample0 = SDL_SwapFloatBE(src[0]);
+    float last_sample0 = sample0;
+    while (dst < target) {
+        src++;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapFloatBE(sample0);
+            dst++;
+            sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
+            last_sample0 = sample0;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32MSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32MSB, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 2;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 2;
+    const float *target = ((const float *) cvt->buf) - 2;
+    float sample1 = SDL_SwapFloatBE(src[1]);
+    float sample0 = SDL_SwapFloatBE(src[0]);
+    float last_sample1 = sample1;
+    float last_sample0 = sample0;
+    while (dst > target) {
+        dst[1] = SDL_SwapFloatBE(sample1);
+        dst[0] = SDL_SwapFloatBE(sample0);
+        dst -= 2;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 2;
+            sample1 = (float) ((((double) SDL_SwapFloatBE(src[1])) + ((double) last_sample1)) * 0.5);
+            sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32MSB_2c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32MSB, 2 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 128;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    float sample0 = SDL_SwapFloatBE(src[0]);
+    float sample1 = SDL_SwapFloatBE(src[1]);
+    float last_sample0 = sample0;
+    float last_sample1 = sample1;
+    while (dst < target) {
+        src += 2;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapFloatBE(sample0);
+            dst[1] = SDL_SwapFloatBE(sample1);
+            dst += 2;
+            sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
+            sample1 = (float) ((((double) SDL_SwapFloatBE(src[1])) + ((double) last_sample1)) * 0.5);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32MSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32MSB, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 256;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 4;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 4;
+    const float *target = ((const float *) cvt->buf) - 4;
+    float sample3 = SDL_SwapFloatBE(src[3]);
+    float sample2 = SDL_SwapFloatBE(src[2]);
+    float sample1 = SDL_SwapFloatBE(src[1]);
+    float sample0 = SDL_SwapFloatBE(src[0]);
+    float last_sample3 = sample3;
+    float last_sample2 = sample2;
+    float last_sample1 = sample1;
+    float last_sample0 = sample0;
+    while (dst > target) {
+        dst[3] = SDL_SwapFloatBE(sample3);
+        dst[2] = SDL_SwapFloatBE(sample2);
+        dst[1] = SDL_SwapFloatBE(sample1);
+        dst[0] = SDL_SwapFloatBE(sample0);
+        dst -= 4;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 4;
+            sample3 = (float) ((((double) SDL_SwapFloatBE(src[3])) + ((double) last_sample3)) * 0.5);
+            sample2 = (float) ((((double) SDL_SwapFloatBE(src[2])) + ((double) last_sample2)) * 0.5);
+            sample1 = (float) ((((double) SDL_SwapFloatBE(src[1])) + ((double) last_sample1)) * 0.5);
+            sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32MSB_4c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32MSB, 4 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 256;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    float sample0 = SDL_SwapFloatBE(src[0]);
+    float sample1 = SDL_SwapFloatBE(src[1]);
+    float sample2 = SDL_SwapFloatBE(src[2]);
+    float sample3 = SDL_SwapFloatBE(src[3]);
+    float last_sample0 = sample0;
+    float last_sample1 = sample1;
+    float last_sample2 = sample2;
+    float last_sample3 = sample3;
+    while (dst < target) {
+        src += 4;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapFloatBE(sample0);
+            dst[1] = SDL_SwapFloatBE(sample1);
+            dst[2] = SDL_SwapFloatBE(sample2);
+            dst[3] = SDL_SwapFloatBE(sample3);
+            dst += 4;
+            sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
+            sample1 = (float) ((((double) SDL_SwapFloatBE(src[1])) + ((double) last_sample1)) * 0.5);
+            sample2 = (float) ((((double) SDL_SwapFloatBE(src[2])) + ((double) last_sample2)) * 0.5);
+            sample3 = (float) ((((double) SDL_SwapFloatBE(src[3])) + ((double) last_sample3)) * 0.5);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32MSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32MSB, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 384;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 6;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 6;
+    const float *target = ((const float *) cvt->buf) - 6;
+    float sample5 = SDL_SwapFloatBE(src[5]);
+    float sample4 = SDL_SwapFloatBE(src[4]);
+    float sample3 = SDL_SwapFloatBE(src[3]);
+    float sample2 = SDL_SwapFloatBE(src[2]);
+    float sample1 = SDL_SwapFloatBE(src[1]);
+    float sample0 = SDL_SwapFloatBE(src[0]);
+    float last_sample5 = sample5;
+    float last_sample4 = sample4;
+    float last_sample3 = sample3;
+    float last_sample2 = sample2;
+    float last_sample1 = sample1;
+    float last_sample0 = sample0;
+    while (dst > target) {
+        dst[5] = SDL_SwapFloatBE(sample5);
+        dst[4] = SDL_SwapFloatBE(sample4);
+        dst[3] = SDL_SwapFloatBE(sample3);
+        dst[2] = SDL_SwapFloatBE(sample2);
+        dst[1] = SDL_SwapFloatBE(sample1);
+        dst[0] = SDL_SwapFloatBE(sample0);
+        dst -= 6;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 6;
+            sample5 = (float) ((((double) SDL_SwapFloatBE(src[5])) + ((double) last_sample5)) * 0.5);
+            sample4 = (float) ((((double) SDL_SwapFloatBE(src[4])) + ((double) last_sample4)) * 0.5);
+            sample3 = (float) ((((double) SDL_SwapFloatBE(src[3])) + ((double) last_sample3)) * 0.5);
+            sample2 = (float) ((((double) SDL_SwapFloatBE(src[2])) + ((double) last_sample2)) * 0.5);
+            sample1 = (float) ((((double) SDL_SwapFloatBE(src[1])) + ((double) last_sample1)) * 0.5);
+            sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32MSB_6c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32MSB, 6 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 384;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    float sample0 = SDL_SwapFloatBE(src[0]);
+    float sample1 = SDL_SwapFloatBE(src[1]);
+    float sample2 = SDL_SwapFloatBE(src[2]);
+    float sample3 = SDL_SwapFloatBE(src[3]);
+    float sample4 = SDL_SwapFloatBE(src[4]);
+    float sample5 = SDL_SwapFloatBE(src[5]);
+    float last_sample0 = sample0;
+    float last_sample1 = sample1;
+    float last_sample2 = sample2;
+    float last_sample3 = sample3;
+    float last_sample4 = sample4;
+    float last_sample5 = sample5;
+    while (dst < target) {
+        src += 6;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapFloatBE(sample0);
+            dst[1] = SDL_SwapFloatBE(sample1);
+            dst[2] = SDL_SwapFloatBE(sample2);
+            dst[3] = SDL_SwapFloatBE(sample3);
+            dst[4] = SDL_SwapFloatBE(sample4);
+            dst[5] = SDL_SwapFloatBE(sample5);
+            dst += 6;
+            sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
+            sample1 = (float) ((((double) SDL_SwapFloatBE(src[1])) + ((double) last_sample1)) * 0.5);
+            sample2 = (float) ((((double) SDL_SwapFloatBE(src[2])) + ((double) last_sample2)) * 0.5);
+            sample3 = (float) ((((double) SDL_SwapFloatBE(src[3])) + ((double) last_sample3)) * 0.5);
+            sample4 = (float) ((((double) SDL_SwapFloatBE(src[4])) + ((double) last_sample4)) * 0.5);
+            sample5 = (float) ((((double) SDL_SwapFloatBE(src[5])) + ((double) last_sample5)) * 0.5);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32MSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample arbitrary (x%f) AUDIO_F32MSB, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 512;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 8;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 8;
+    const float *target = ((const float *) cvt->buf) - 8;
+    float sample7 = SDL_SwapFloatBE(src[7]);
+    float sample6 = SDL_SwapFloatBE(src[6]);
+    float sample5 = SDL_SwapFloatBE(src[5]);
+    float sample4 = SDL_SwapFloatBE(src[4]);
+    float sample3 = SDL_SwapFloatBE(src[3]);
+    float sample2 = SDL_SwapFloatBE(src[2]);
+    float sample1 = SDL_SwapFloatBE(src[1]);
+    float sample0 = SDL_SwapFloatBE(src[0]);
+    float last_sample7 = sample7;
+    float last_sample6 = sample6;
+    float last_sample5 = sample5;
+    float last_sample4 = sample4;
+    float last_sample3 = sample3;
+    float last_sample2 = sample2;
+    float last_sample1 = sample1;
+    float last_sample0 = sample0;
+    while (dst > target) {
+        dst[7] = SDL_SwapFloatBE(sample7);
+        dst[6] = SDL_SwapFloatBE(sample6);
+        dst[5] = SDL_SwapFloatBE(sample5);
+        dst[4] = SDL_SwapFloatBE(sample4);
+        dst[3] = SDL_SwapFloatBE(sample3);
+        dst[2] = SDL_SwapFloatBE(sample2);
+        dst[1] = SDL_SwapFloatBE(sample1);
+        dst[0] = SDL_SwapFloatBE(sample0);
+        dst -= 8;
+        eps += srcsize;
+        if ((eps << 1) >= dstsize) {
+            src -= 8;
+            sample7 = (float) ((((double) SDL_SwapFloatBE(src[7])) + ((double) last_sample7)) * 0.5);
+            sample6 = (float) ((((double) SDL_SwapFloatBE(src[6])) + ((double) last_sample6)) * 0.5);
+            sample5 = (float) ((((double) SDL_SwapFloatBE(src[5])) + ((double) last_sample5)) * 0.5);
+            sample4 = (float) ((((double) SDL_SwapFloatBE(src[4])) + ((double) last_sample4)) * 0.5);
+            sample3 = (float) ((((double) SDL_SwapFloatBE(src[3])) + ((double) last_sample3)) * 0.5);
+            sample2 = (float) ((((double) SDL_SwapFloatBE(src[2])) + ((double) last_sample2)) * 0.5);
+            sample1 = (float) ((((double) SDL_SwapFloatBE(src[1])) + ((double) last_sample1)) * 0.5);
+            sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
+            last_sample7 = sample7;
+            last_sample6 = sample6;
+            last_sample5 = sample5;
+            last_sample4 = sample4;
+            last_sample3 = sample3;
+            last_sample2 = sample2;
+            last_sample1 = sample1;
+            last_sample0 = sample0;
+            eps -= dstsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32MSB_8c(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample arbitrary (x%f) AUDIO_F32MSB, 8 channels.\n", cvt->rate_incr);
+#endif
+
+    const int srcsize = cvt->len_cvt - 512;
+    const int dstsize = (int) (((double)cvt->len_cvt) * cvt->rate_incr);
+    register int eps = 0;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    float sample0 = SDL_SwapFloatBE(src[0]);
+    float sample1 = SDL_SwapFloatBE(src[1]);
+    float sample2 = SDL_SwapFloatBE(src[2]);
+    float sample3 = SDL_SwapFloatBE(src[3]);
+    float sample4 = SDL_SwapFloatBE(src[4]);
+    float sample5 = SDL_SwapFloatBE(src[5]);
+    float sample6 = SDL_SwapFloatBE(src[6]);
+    float sample7 = SDL_SwapFloatBE(src[7]);
+    float last_sample0 = sample0;
+    float last_sample1 = sample1;
+    float last_sample2 = sample2;
+    float last_sample3 = sample3;
+    float last_sample4 = sample4;
+    float last_sample5 = sample5;
+    float last_sample6 = sample6;
+    float last_sample7 = sample7;
+    while (dst < target) {
+        src += 8;
+        eps += dstsize;
+        if ((eps << 1) >= srcsize) {
+            dst[0] = SDL_SwapFloatBE(sample0);
+            dst[1] = SDL_SwapFloatBE(sample1);
+            dst[2] = SDL_SwapFloatBE(sample2);
+            dst[3] = SDL_SwapFloatBE(sample3);
+            dst[4] = SDL_SwapFloatBE(sample4);
+            dst[5] = SDL_SwapFloatBE(sample5);
+            dst[6] = SDL_SwapFloatBE(sample6);
+            dst[7] = SDL_SwapFloatBE(sample7);
+            dst += 8;
+            sample0 = (float) ((((double) SDL_SwapFloatBE(src[0])) + ((double) last_sample0)) * 0.5);
+            sample1 = (float) ((((double) SDL_SwapFloatBE(src[1])) + ((double) last_sample1)) * 0.5);
+            sample2 = (float) ((((double) SDL_SwapFloatBE(src[2])) + ((double) last_sample2)) * 0.5);
+            sample3 = (float) ((((double) SDL_SwapFloatBE(src[3])) + ((double) last_sample3)) * 0.5);
+            sample4 = (float) ((((double) SDL_SwapFloatBE(src[4])) + ((double) last_sample4)) * 0.5);
+            sample5 = (float) ((((double) SDL_SwapFloatBE(src[5])) + ((double) last_sample5)) * 0.5);
+            sample6 = (float) ((((double) SDL_SwapFloatBE(src[6])) + ((double) last_sample6)) * 0.5);
+            sample7 = (float) ((((double) SDL_SwapFloatBE(src[7])) + ((double) last_sample7)) * 0.5);
+            last_sample0 = sample0;
+            last_sample1 = sample1;
+            last_sample2 = sample2;
+            last_sample3 = sample3;
+            last_sample4 = sample4;
+            last_sample5 = sample5;
+            last_sample6 = sample6;
+            last_sample7 = sample7;
+            eps -= srcsize;
+        }
+    }
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+
+#if !LESS_RESAMPLERS
+
+static void SDLCALL
+SDL_Upsample_U8_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_U8, 1 channels.\n");
+#endif
+
+    //const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 1;
+    const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Uint8 *target = ((const Uint8 *) cvt->buf) - 1;
+    Sint16 last_sample0 = (Sint16) src[0];
+    while (dst > target) {
+        const Sint16 sample0 = (Sint16) src[0];
+        src--;
+        dst[1] = (Uint8) ((sample0 + last_sample0) >> 1);
+        dst[0] = (Uint8) sample0;
+        last_sample0 = sample0;
+        dst -= 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U8_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_U8, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Uint8 *dst = (Uint8 *) cvt->buf;
+    const Uint8 *src = (Uint8 *) cvt->buf;
+    const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) src[0];
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) src[0];
+        src += 2;
+        dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U8_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_U8, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 1;
+    const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Uint8 *target = ((const Uint8 *) cvt->buf) - 1;
+    Sint16 last_sample0 = (Sint16) src[0];
+    while (dst > target) {
+        const Sint16 sample0 = (Sint16) src[0];
+        src--;
+        dst[3] = (Uint8) sample0;
+        dst[2] = (Uint8) (((3 * sample0) + last_sample0) >> 2);
+        dst[1] = (Uint8) ((sample0 + last_sample0) >> 1);
+        dst[0] = (Uint8) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U8_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_U8, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Uint8 *dst = (Uint8 *) cvt->buf;
+    const Uint8 *src = (Uint8 *) cvt->buf;
+    const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) src[0];
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) src[0];
+        src += 4;
+        dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U8_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_U8, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 2;
+    const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Uint8 *target = ((const Uint8 *) cvt->buf) - 2;
+    Sint16 last_sample1 = (Sint16) src[1];
+    Sint16 last_sample0 = (Sint16) src[0];
+    while (dst > target) {
+        const Sint16 sample1 = (Sint16) src[1];
+        const Sint16 sample0 = (Sint16) src[0];
+        src -= 2;
+        dst[3] = (Uint8) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint8) sample1;
+        dst[0] = (Uint8) sample0;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U8_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_U8, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Uint8 *dst = (Uint8 *) cvt->buf;
+    const Uint8 *src = (Uint8 *) cvt->buf;
+    const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) src[0];
+    Sint16 last_sample1 = (Sint16) src[1];
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) src[0];
+        const Sint16 sample1 = (Sint16) src[1];
+        src += 4;
+        dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint8) ((sample1 + last_sample1) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U8_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_U8, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 2;
+    const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Uint8 *target = ((const Uint8 *) cvt->buf) - 2;
+    Sint16 last_sample1 = (Sint16) src[1];
+    Sint16 last_sample0 = (Sint16) src[0];
+    while (dst > target) {
+        const Sint16 sample1 = (Sint16) src[1];
+        const Sint16 sample0 = (Sint16) src[0];
+        src -= 2;
+        dst[7] = (Uint8) sample1;
+        dst[6] = (Uint8) sample0;
+        dst[5] = (Uint8) (((3 * sample1) + last_sample1) >> 2);
+        dst[4] = (Uint8) (((3 * sample0) + last_sample0) >> 2);
+        dst[3] = (Uint8) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint8) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Uint8) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U8_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_U8, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Uint8 *dst = (Uint8 *) cvt->buf;
+    const Uint8 *src = (Uint8 *) cvt->buf;
+    const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) src[0];
+    Sint16 last_sample1 = (Sint16) src[1];
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) src[0];
+        const Sint16 sample1 = (Sint16) src[1];
+        src += 8;
+        dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint8) ((sample1 + last_sample1) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U8_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_U8, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 4;
+    const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Uint8 *target = ((const Uint8 *) cvt->buf) - 4;
+    Sint16 last_sample3 = (Sint16) src[3];
+    Sint16 last_sample2 = (Sint16) src[2];
+    Sint16 last_sample1 = (Sint16) src[1];
+    Sint16 last_sample0 = (Sint16) src[0];
+    while (dst > target) {
+        const Sint16 sample3 = (Sint16) src[3];
+        const Sint16 sample2 = (Sint16) src[2];
+        const Sint16 sample1 = (Sint16) src[1];
+        const Sint16 sample0 = (Sint16) src[0];
+        src -= 4;
+        dst[7] = (Uint8) ((sample3 + last_sample3) >> 1);
+        dst[6] = (Uint8) ((sample2 + last_sample2) >> 1);
+        dst[5] = (Uint8) ((sample1 + last_sample1) >> 1);
+        dst[4] = (Uint8) ((sample0 + last_sample0) >> 1);
+        dst[3] = (Uint8) sample3;
+        dst[2] = (Uint8) sample2;
+        dst[1] = (Uint8) sample1;
+        dst[0] = (Uint8) sample0;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U8_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_U8, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Uint8 *dst = (Uint8 *) cvt->buf;
+    const Uint8 *src = (Uint8 *) cvt->buf;
+    const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) src[0];
+    Sint16 last_sample1 = (Sint16) src[1];
+    Sint16 last_sample2 = (Sint16) src[2];
+    Sint16 last_sample3 = (Sint16) src[3];
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) src[0];
+        const Sint16 sample1 = (Sint16) src[1];
+        const Sint16 sample2 = (Sint16) src[2];
+        const Sint16 sample3 = (Sint16) src[3];
+        src += 8;
+        dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint8) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint8) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Uint8) ((sample3 + last_sample3) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U8_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_U8, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 4;
+    const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Uint8 *target = ((const Uint8 *) cvt->buf) - 4;
+    Sint16 last_sample3 = (Sint16) src[3];
+    Sint16 last_sample2 = (Sint16) src[2];
+    Sint16 last_sample1 = (Sint16) src[1];
+    Sint16 last_sample0 = (Sint16) src[0];
+    while (dst > target) {
+        const Sint16 sample3 = (Sint16) src[3];
+        const Sint16 sample2 = (Sint16) src[2];
+        const Sint16 sample1 = (Sint16) src[1];
+        const Sint16 sample0 = (Sint16) src[0];
+        src -= 4;
+        dst[15] = (Uint8) sample3;
+        dst[14] = (Uint8) sample2;
+        dst[13] = (Uint8) sample1;
+        dst[12] = (Uint8) sample0;
+        dst[11] = (Uint8) (((3 * sample3) + last_sample3) >> 2);
+        dst[10] = (Uint8) (((3 * sample2) + last_sample2) >> 2);
+        dst[9] = (Uint8) (((3 * sample1) + last_sample1) >> 2);
+        dst[8] = (Uint8) (((3 * sample0) + last_sample0) >> 2);
+        dst[7] = (Uint8) ((sample3 + last_sample3) >> 1);
+        dst[6] = (Uint8) ((sample2 + last_sample2) >> 1);
+        dst[5] = (Uint8) ((sample1 + last_sample1) >> 1);
+        dst[4] = (Uint8) ((sample0 + last_sample0) >> 1);
+        dst[3] = (Uint8) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Uint8) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Uint8) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Uint8) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U8_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_U8, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Uint8 *dst = (Uint8 *) cvt->buf;
+    const Uint8 *src = (Uint8 *) cvt->buf;
+    const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) src[0];
+    Sint16 last_sample1 = (Sint16) src[1];
+    Sint16 last_sample2 = (Sint16) src[2];
+    Sint16 last_sample3 = (Sint16) src[3];
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) src[0];
+        const Sint16 sample1 = (Sint16) src[1];
+        const Sint16 sample2 = (Sint16) src[2];
+        const Sint16 sample3 = (Sint16) src[3];
+        src += 16;
+        dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint8) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint8) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Uint8) ((sample3 + last_sample3) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U8_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_U8, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 6;
+    const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Uint8 *target = ((const Uint8 *) cvt->buf) - 6;
+    Sint16 last_sample5 = (Sint16) src[5];
+    Sint16 last_sample4 = (Sint16) src[4];
+    Sint16 last_sample3 = (Sint16) src[3];
+    Sint16 last_sample2 = (Sint16) src[2];
+    Sint16 last_sample1 = (Sint16) src[1];
+    Sint16 last_sample0 = (Sint16) src[0];
+    while (dst > target) {
+        const Sint16 sample5 = (Sint16) src[5];
+        const Sint16 sample4 = (Sint16) src[4];
+        const Sint16 sample3 = (Sint16) src[3];
+        const Sint16 sample2 = (Sint16) src[2];
+        const Sint16 sample1 = (Sint16) src[1];
+        const Sint16 sample0 = (Sint16) src[0];
+        src -= 6;
+        dst[11] = (Uint8) ((sample5 + last_sample5) >> 1);
+        dst[10] = (Uint8) ((sample4 + last_sample4) >> 1);
+        dst[9] = (Uint8) ((sample3 + last_sample3) >> 1);
+        dst[8] = (Uint8) ((sample2 + last_sample2) >> 1);
+        dst[7] = (Uint8) ((sample1 + last_sample1) >> 1);
+        dst[6] = (Uint8) ((sample0 + last_sample0) >> 1);
+        dst[5] = (Uint8) sample5;
+        dst[4] = (Uint8) sample4;
+        dst[3] = (Uint8) sample3;
+        dst[2] = (Uint8) sample2;
+        dst[1] = (Uint8) sample1;
+        dst[0] = (Uint8) sample0;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 12;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U8_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_U8, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Uint8 *dst = (Uint8 *) cvt->buf;
+    const Uint8 *src = (Uint8 *) cvt->buf;
+    const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) src[0];
+    Sint16 last_sample1 = (Sint16) src[1];
+    Sint16 last_sample2 = (Sint16) src[2];
+    Sint16 last_sample3 = (Sint16) src[3];
+    Sint16 last_sample4 = (Sint16) src[4];
+    Sint16 last_sample5 = (Sint16) src[5];
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) src[0];
+        const Sint16 sample1 = (Sint16) src[1];
+        const Sint16 sample2 = (Sint16) src[2];
+        const Sint16 sample3 = (Sint16) src[3];
+        const Sint16 sample4 = (Sint16) src[4];
+        const Sint16 sample5 = (Sint16) src[5];
+        src += 12;
+        dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint8) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint8) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Uint8) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Uint8) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Uint8) ((sample5 + last_sample5) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U8_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_U8, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 6;
+    const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Uint8 *target = ((const Uint8 *) cvt->buf) - 6;
+    Sint16 last_sample5 = (Sint16) src[5];
+    Sint16 last_sample4 = (Sint16) src[4];
+    Sint16 last_sample3 = (Sint16) src[3];
+    Sint16 last_sample2 = (Sint16) src[2];
+    Sint16 last_sample1 = (Sint16) src[1];
+    Sint16 last_sample0 = (Sint16) src[0];
+    while (dst > target) {
+        const Sint16 sample5 = (Sint16) src[5];
+        const Sint16 sample4 = (Sint16) src[4];
+        const Sint16 sample3 = (Sint16) src[3];
+        const Sint16 sample2 = (Sint16) src[2];
+        const Sint16 sample1 = (Sint16) src[1];
+        const Sint16 sample0 = (Sint16) src[0];
+        src -= 6;
+        dst[23] = (Uint8) sample5;
+        dst[22] = (Uint8) sample4;
+        dst[21] = (Uint8) sample3;
+        dst[20] = (Uint8) sample2;
+        dst[19] = (Uint8) sample1;
+        dst[18] = (Uint8) sample0;
+        dst[17] = (Uint8) (((3 * sample5) + last_sample5) >> 2);
+        dst[16] = (Uint8) (((3 * sample4) + last_sample4) >> 2);
+        dst[15] = (Uint8) (((3 * sample3) + last_sample3) >> 2);
+        dst[14] = (Uint8) (((3 * sample2) + last_sample2) >> 2);
+        dst[13] = (Uint8) (((3 * sample1) + last_sample1) >> 2);
+        dst[12] = (Uint8) (((3 * sample0) + last_sample0) >> 2);
+        dst[11] = (Uint8) ((sample5 + last_sample5) >> 1);
+        dst[10] = (Uint8) ((sample4 + last_sample4) >> 1);
+        dst[9] = (Uint8) ((sample3 + last_sample3) >> 1);
+        dst[8] = (Uint8) ((sample2 + last_sample2) >> 1);
+        dst[7] = (Uint8) ((sample1 + last_sample1) >> 1);
+        dst[6] = (Uint8) ((sample0 + last_sample0) >> 1);
+        dst[5] = (Uint8) ((sample5 + (3 * last_sample5)) >> 2);
+        dst[4] = (Uint8) ((sample4 + (3 * last_sample4)) >> 2);
+        dst[3] = (Uint8) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Uint8) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Uint8) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Uint8) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 24;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U8_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_U8, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Uint8 *dst = (Uint8 *) cvt->buf;
+    const Uint8 *src = (Uint8 *) cvt->buf;
+    const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) src[0];
+    Sint16 last_sample1 = (Sint16) src[1];
+    Sint16 last_sample2 = (Sint16) src[2];
+    Sint16 last_sample3 = (Sint16) src[3];
+    Sint16 last_sample4 = (Sint16) src[4];
+    Sint16 last_sample5 = (Sint16) src[5];
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) src[0];
+        const Sint16 sample1 = (Sint16) src[1];
+        const Sint16 sample2 = (Sint16) src[2];
+        const Sint16 sample3 = (Sint16) src[3];
+        const Sint16 sample4 = (Sint16) src[4];
+        const Sint16 sample5 = (Sint16) src[5];
+        src += 24;
+        dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint8) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint8) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Uint8) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Uint8) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Uint8) ((sample5 + last_sample5) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U8_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_U8, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 8;
+    const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Uint8 *target = ((const Uint8 *) cvt->buf) - 8;
+    Sint16 last_sample7 = (Sint16) src[7];
+    Sint16 last_sample6 = (Sint16) src[6];
+    Sint16 last_sample5 = (Sint16) src[5];
+    Sint16 last_sample4 = (Sint16) src[4];
+    Sint16 last_sample3 = (Sint16) src[3];
+    Sint16 last_sample2 = (Sint16) src[2];
+    Sint16 last_sample1 = (Sint16) src[1];
+    Sint16 last_sample0 = (Sint16) src[0];
+    while (dst > target) {
+        const Sint16 sample7 = (Sint16) src[7];
+        const Sint16 sample6 = (Sint16) src[6];
+        const Sint16 sample5 = (Sint16) src[5];
+        const Sint16 sample4 = (Sint16) src[4];
+        const Sint16 sample3 = (Sint16) src[3];
+        const Sint16 sample2 = (Sint16) src[2];
+        const Sint16 sample1 = (Sint16) src[1];
+        const Sint16 sample0 = (Sint16) src[0];
+        src -= 8;
+        dst[15] = (Uint8) ((sample7 + last_sample7) >> 1);
+        dst[14] = (Uint8) ((sample6 + last_sample6) >> 1);
+        dst[13] = (Uint8) ((sample5 + last_sample5) >> 1);
+        dst[12] = (Uint8) ((sample4 + last_sample4) >> 1);
+        dst[11] = (Uint8) ((sample3 + last_sample3) >> 1);
+        dst[10] = (Uint8) ((sample2 + last_sample2) >> 1);
+        dst[9] = (Uint8) ((sample1 + last_sample1) >> 1);
+        dst[8] = (Uint8) ((sample0 + last_sample0) >> 1);
+        dst[7] = (Uint8) sample7;
+        dst[6] = (Uint8) sample6;
+        dst[5] = (Uint8) sample5;
+        dst[4] = (Uint8) sample4;
+        dst[3] = (Uint8) sample3;
+        dst[2] = (Uint8) sample2;
+        dst[1] = (Uint8) sample1;
+        dst[0] = (Uint8) sample0;
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U8_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_U8, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Uint8 *dst = (Uint8 *) cvt->buf;
+    const Uint8 *src = (Uint8 *) cvt->buf;
+    const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) src[0];
+    Sint16 last_sample1 = (Sint16) src[1];
+    Sint16 last_sample2 = (Sint16) src[2];
+    Sint16 last_sample3 = (Sint16) src[3];
+    Sint16 last_sample4 = (Sint16) src[4];
+    Sint16 last_sample5 = (Sint16) src[5];
+    Sint16 last_sample6 = (Sint16) src[6];
+    Sint16 last_sample7 = (Sint16) src[7];
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) src[0];
+        const Sint16 sample1 = (Sint16) src[1];
+        const Sint16 sample2 = (Sint16) src[2];
+        const Sint16 sample3 = (Sint16) src[3];
+        const Sint16 sample4 = (Sint16) src[4];
+        const Sint16 sample5 = (Sint16) src[5];
+        const Sint16 sample6 = (Sint16) src[6];
+        const Sint16 sample7 = (Sint16) src[7];
+        src += 16;
+        dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint8) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint8) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Uint8) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Uint8) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Uint8) ((sample5 + last_sample5) >> 1);
+        dst[6] = (Uint8) ((sample6 + last_sample6) >> 1);
+        dst[7] = (Uint8) ((sample7 + last_sample7) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U8_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_U8, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Uint8 *dst = ((Uint8 *) (cvt->buf + dstsize)) - 8;
+    const Uint8 *src = ((Uint8 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Uint8 *target = ((const Uint8 *) cvt->buf) - 8;
+    Sint16 last_sample7 = (Sint16) src[7];
+    Sint16 last_sample6 = (Sint16) src[6];
+    Sint16 last_sample5 = (Sint16) src[5];
+    Sint16 last_sample4 = (Sint16) src[4];
+    Sint16 last_sample3 = (Sint16) src[3];
+    Sint16 last_sample2 = (Sint16) src[2];
+    Sint16 last_sample1 = (Sint16) src[1];
+    Sint16 last_sample0 = (Sint16) src[0];
+    while (dst > target) {
+        const Sint16 sample7 = (Sint16) src[7];
+        const Sint16 sample6 = (Sint16) src[6];
+        const Sint16 sample5 = (Sint16) src[5];
+        const Sint16 sample4 = (Sint16) src[4];
+        const Sint16 sample3 = (Sint16) src[3];
+        const Sint16 sample2 = (Sint16) src[2];
+        const Sint16 sample1 = (Sint16) src[1];
+        const Sint16 sample0 = (Sint16) src[0];
+        src -= 8;
+        dst[31] = (Uint8) sample7;
+        dst[30] = (Uint8) sample6;
+        dst[29] = (Uint8) sample5;
+        dst[28] = (Uint8) sample4;
+        dst[27] = (Uint8) sample3;
+        dst[26] = (Uint8) sample2;
+        dst[25] = (Uint8) sample1;
+        dst[24] = (Uint8) sample0;
+        dst[23] = (Uint8) (((3 * sample7) + last_sample7) >> 2);
+        dst[22] = (Uint8) (((3 * sample6) + last_sample6) >> 2);
+        dst[21] = (Uint8) (((3 * sample5) + last_sample5) >> 2);
+        dst[20] = (Uint8) (((3 * sample4) + last_sample4) >> 2);
+        dst[19] = (Uint8) (((3 * sample3) + last_sample3) >> 2);
+        dst[18] = (Uint8) (((3 * sample2) + last_sample2) >> 2);
+        dst[17] = (Uint8) (((3 * sample1) + last_sample1) >> 2);
+        dst[16] = (Uint8) (((3 * sample0) + last_sample0) >> 2);
+        dst[15] = (Uint8) ((sample7 + last_sample7) >> 1);
+        dst[14] = (Uint8) ((sample6 + last_sample6) >> 1);
+        dst[13] = (Uint8) ((sample5 + last_sample5) >> 1);
+        dst[12] = (Uint8) ((sample4 + last_sample4) >> 1);
+        dst[11] = (Uint8) ((sample3 + last_sample3) >> 1);
+        dst[10] = (Uint8) ((sample2 + last_sample2) >> 1);
+        dst[9] = (Uint8) ((sample1 + last_sample1) >> 1);
+        dst[8] = (Uint8) ((sample0 + last_sample0) >> 1);
+        dst[7] = (Uint8) ((sample7 + (3 * last_sample7)) >> 2);
+        dst[6] = (Uint8) ((sample6 + (3 * last_sample6)) >> 2);
+        dst[5] = (Uint8) ((sample5 + (3 * last_sample5)) >> 2);
+        dst[4] = (Uint8) ((sample4 + (3 * last_sample4)) >> 2);
+        dst[3] = (Uint8) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Uint8) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Uint8) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Uint8) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 32;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U8_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_U8, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Uint8 *dst = (Uint8 *) cvt->buf;
+    const Uint8 *src = (Uint8 *) cvt->buf;
+    const Uint8 *target = (const Uint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) src[0];
+    Sint16 last_sample1 = (Sint16) src[1];
+    Sint16 last_sample2 = (Sint16) src[2];
+    Sint16 last_sample3 = (Sint16) src[3];
+    Sint16 last_sample4 = (Sint16) src[4];
+    Sint16 last_sample5 = (Sint16) src[5];
+    Sint16 last_sample6 = (Sint16) src[6];
+    Sint16 last_sample7 = (Sint16) src[7];
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) src[0];
+        const Sint16 sample1 = (Sint16) src[1];
+        const Sint16 sample2 = (Sint16) src[2];
+        const Sint16 sample3 = (Sint16) src[3];
+        const Sint16 sample4 = (Sint16) src[4];
+        const Sint16 sample5 = (Sint16) src[5];
+        const Sint16 sample6 = (Sint16) src[6];
+        const Sint16 sample7 = (Sint16) src[7];
+        src += 32;
+        dst[0] = (Uint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint8) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint8) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Uint8) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Uint8) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Uint8) ((sample5 + last_sample5) >> 1);
+        dst[6] = (Uint8) ((sample6 + last_sample6) >> 1);
+        dst[7] = (Uint8) ((sample7 + last_sample7) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S8_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S8, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 1;
+    const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Sint8 *target = ((const Sint8 *) cvt->buf) - 1;
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    while (dst > target) {
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        src--;
+        dst[1] = (Sint8) ((sample0 + last_sample0) >> 1);
+        dst[0] = (Sint8) sample0;
+        last_sample0 = sample0;
+        dst -= 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S8_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S8, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint8 *dst = (Sint8 *) cvt->buf;
+    const Sint8 *src = (Sint8 *) cvt->buf;
+    const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        src += 2;
+        dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S8_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S8, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 1;
+    const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Sint8 *target = ((const Sint8 *) cvt->buf) - 1;
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    while (dst > target) {
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        src--;
+        dst[3] = (Sint8) sample0;
+        dst[2] = (Sint8) (((3 * sample0) + last_sample0) >> 2);
+        dst[1] = (Sint8) ((sample0 + last_sample0) >> 1);
+        dst[0] = (Sint8) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S8_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S8, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint8 *dst = (Sint8 *) cvt->buf;
+    const Sint8 *src = (Sint8 *) cvt->buf;
+    const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        src += 4;
+        dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S8_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S8, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 2;
+    const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Sint8 *target = ((const Sint8 *) cvt->buf) - 2;
+    Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    while (dst > target) {
+        const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        src -= 2;
+        dst[3] = (Sint8) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint8) sample1;
+        dst[0] = (Sint8) sample0;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S8_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S8, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint8 *dst = (Sint8 *) cvt->buf;
+    const Sint8 *src = (Sint8 *) cvt->buf;
+    const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
+        src += 4;
+        dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint8) ((sample1 + last_sample1) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S8_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S8, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 2;
+    const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Sint8 *target = ((const Sint8 *) cvt->buf) - 2;
+    Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    while (dst > target) {
+        const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        src -= 2;
+        dst[7] = (Sint8) sample1;
+        dst[6] = (Sint8) sample0;
+        dst[5] = (Sint8) (((3 * sample1) + last_sample1) >> 2);
+        dst[4] = (Sint8) (((3 * sample0) + last_sample0) >> 2);
+        dst[3] = (Sint8) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint8) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint8) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S8_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S8, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint8 *dst = (Sint8 *) cvt->buf;
+    const Sint8 *src = (Sint8 *) cvt->buf;
+    const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
+        src += 8;
+        dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint8) ((sample1 + last_sample1) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S8_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S8, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 4;
+    const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Sint8 *target = ((const Sint8 *) cvt->buf) - 4;
+    Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
+    Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
+    Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    while (dst > target) {
+        const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
+        const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
+        const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        src -= 4;
+        dst[7] = (Sint8) ((sample3 + last_sample3) >> 1);
+        dst[6] = (Sint8) ((sample2 + last_sample2) >> 1);
+        dst[5] = (Sint8) ((sample1 + last_sample1) >> 1);
+        dst[4] = (Sint8) ((sample0 + last_sample0) >> 1);
+        dst[3] = (Sint8) sample3;
+        dst[2] = (Sint8) sample2;
+        dst[1] = (Sint8) sample1;
+        dst[0] = (Sint8) sample0;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S8_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S8, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint8 *dst = (Sint8 *) cvt->buf;
+    const Sint8 *src = (Sint8 *) cvt->buf;
+    const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
+    Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
+    Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
+        const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
+        const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
+        src += 8;
+        dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint8) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint8) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint8) ((sample3 + last_sample3) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S8_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S8, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 4;
+    const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Sint8 *target = ((const Sint8 *) cvt->buf) - 4;
+    Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
+    Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
+    Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    while (dst > target) {
+        const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
+        const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
+        const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        src -= 4;
+        dst[15] = (Sint8) sample3;
+        dst[14] = (Sint8) sample2;
+        dst[13] = (Sint8) sample1;
+        dst[12] = (Sint8) sample0;
+        dst[11] = (Sint8) (((3 * sample3) + last_sample3) >> 2);
+        dst[10] = (Sint8) (((3 * sample2) + last_sample2) >> 2);
+        dst[9] = (Sint8) (((3 * sample1) + last_sample1) >> 2);
+        dst[8] = (Sint8) (((3 * sample0) + last_sample0) >> 2);
+        dst[7] = (Sint8) ((sample3 + last_sample3) >> 1);
+        dst[6] = (Sint8) ((sample2 + last_sample2) >> 1);
+        dst[5] = (Sint8) ((sample1 + last_sample1) >> 1);
+        dst[4] = (Sint8) ((sample0 + last_sample0) >> 1);
+        dst[3] = (Sint8) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Sint8) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Sint8) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint8) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S8_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S8, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint8 *dst = (Sint8 *) cvt->buf;
+    const Sint8 *src = (Sint8 *) cvt->buf;
+    const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
+    Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
+    Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
+        const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
+        const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
+        src += 16;
+        dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint8) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint8) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint8) ((sample3 + last_sample3) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S8_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S8, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 6;
+    const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Sint8 *target = ((const Sint8 *) cvt->buf) - 6;
+    Sint16 last_sample5 = (Sint16) ((Sint8) src[5]);
+    Sint16 last_sample4 = (Sint16) ((Sint8) src[4]);
+    Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
+    Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
+    Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    while (dst > target) {
+        const Sint16 sample5 = (Sint16) ((Sint8) src[5]);
+        const Sint16 sample4 = (Sint16) ((Sint8) src[4]);
+        const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
+        const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
+        const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        src -= 6;
+        dst[11] = (Sint8) ((sample5 + last_sample5) >> 1);
+        dst[10] = (Sint8) ((sample4 + last_sample4) >> 1);
+        dst[9] = (Sint8) ((sample3 + last_sample3) >> 1);
+        dst[8] = (Sint8) ((sample2 + last_sample2) >> 1);
+        dst[7] = (Sint8) ((sample1 + last_sample1) >> 1);
+        dst[6] = (Sint8) ((sample0 + last_sample0) >> 1);
+        dst[5] = (Sint8) sample5;
+        dst[4] = (Sint8) sample4;
+        dst[3] = (Sint8) sample3;
+        dst[2] = (Sint8) sample2;
+        dst[1] = (Sint8) sample1;
+        dst[0] = (Sint8) sample0;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 12;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S8_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S8, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint8 *dst = (Sint8 *) cvt->buf;
+    const Sint8 *src = (Sint8 *) cvt->buf;
+    const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
+    Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
+    Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
+    Sint16 last_sample4 = (Sint16) ((Sint8) src[4]);
+    Sint16 last_sample5 = (Sint16) ((Sint8) src[5]);
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
+        const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
+        const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
+        const Sint16 sample4 = (Sint16) ((Sint8) src[4]);
+        const Sint16 sample5 = (Sint16) ((Sint8) src[5]);
+        src += 12;
+        dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint8) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint8) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint8) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint8) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint8) ((sample5 + last_sample5) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S8_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S8, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 6;
+    const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Sint8 *target = ((const Sint8 *) cvt->buf) - 6;
+    Sint16 last_sample5 = (Sint16) ((Sint8) src[5]);
+    Sint16 last_sample4 = (Sint16) ((Sint8) src[4]);
+    Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
+    Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
+    Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    while (dst > target) {
+        const Sint16 sample5 = (Sint16) ((Sint8) src[5]);
+        const Sint16 sample4 = (Sint16) ((Sint8) src[4]);
+        const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
+        const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
+        const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        src -= 6;
+        dst[23] = (Sint8) sample5;
+        dst[22] = (Sint8) sample4;
+        dst[21] = (Sint8) sample3;
+        dst[20] = (Sint8) sample2;
+        dst[19] = (Sint8) sample1;
+        dst[18] = (Sint8) sample0;
+        dst[17] = (Sint8) (((3 * sample5) + last_sample5) >> 2);
+        dst[16] = (Sint8) (((3 * sample4) + last_sample4) >> 2);
+        dst[15] = (Sint8) (((3 * sample3) + last_sample3) >> 2);
+        dst[14] = (Sint8) (((3 * sample2) + last_sample2) >> 2);
+        dst[13] = (Sint8) (((3 * sample1) + last_sample1) >> 2);
+        dst[12] = (Sint8) (((3 * sample0) + last_sample0) >> 2);
+        dst[11] = (Sint8) ((sample5 + last_sample5) >> 1);
+        dst[10] = (Sint8) ((sample4 + last_sample4) >> 1);
+        dst[9] = (Sint8) ((sample3 + last_sample3) >> 1);
+        dst[8] = (Sint8) ((sample2 + last_sample2) >> 1);
+        dst[7] = (Sint8) ((sample1 + last_sample1) >> 1);
+        dst[6] = (Sint8) ((sample0 + last_sample0) >> 1);
+        dst[5] = (Sint8) ((sample5 + (3 * last_sample5)) >> 2);
+        dst[4] = (Sint8) ((sample4 + (3 * last_sample4)) >> 2);
+        dst[3] = (Sint8) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Sint8) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Sint8) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint8) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 24;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S8_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S8, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint8 *dst = (Sint8 *) cvt->buf;
+    const Sint8 *src = (Sint8 *) cvt->buf;
+    const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
+    Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
+    Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
+    Sint16 last_sample4 = (Sint16) ((Sint8) src[4]);
+    Sint16 last_sample5 = (Sint16) ((Sint8) src[5]);
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
+        const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
+        const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
+        const Sint16 sample4 = (Sint16) ((Sint8) src[4]);
+        const Sint16 sample5 = (Sint16) ((Sint8) src[5]);
+        src += 24;
+        dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint8) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint8) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint8) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint8) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint8) ((sample5 + last_sample5) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S8_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S8, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 8;
+    const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Sint8 *target = ((const Sint8 *) cvt->buf) - 8;
+    Sint16 last_sample7 = (Sint16) ((Sint8) src[7]);
+    Sint16 last_sample6 = (Sint16) ((Sint8) src[6]);
+    Sint16 last_sample5 = (Sint16) ((Sint8) src[5]);
+    Sint16 last_sample4 = (Sint16) ((Sint8) src[4]);
+    Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
+    Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
+    Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    while (dst > target) {
+        const Sint16 sample7 = (Sint16) ((Sint8) src[7]);
+        const Sint16 sample6 = (Sint16) ((Sint8) src[6]);
+        const Sint16 sample5 = (Sint16) ((Sint8) src[5]);
+        const Sint16 sample4 = (Sint16) ((Sint8) src[4]);
+        const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
+        const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
+        const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        src -= 8;
+        dst[15] = (Sint8) ((sample7 + last_sample7) >> 1);
+        dst[14] = (Sint8) ((sample6 + last_sample6) >> 1);
+        dst[13] = (Sint8) ((sample5 + last_sample5) >> 1);
+        dst[12] = (Sint8) ((sample4 + last_sample4) >> 1);
+        dst[11] = (Sint8) ((sample3 + last_sample3) >> 1);
+        dst[10] = (Sint8) ((sample2 + last_sample2) >> 1);
+        dst[9] = (Sint8) ((sample1 + last_sample1) >> 1);
+        dst[8] = (Sint8) ((sample0 + last_sample0) >> 1);
+        dst[7] = (Sint8) sample7;
+        dst[6] = (Sint8) sample6;
+        dst[5] = (Sint8) sample5;
+        dst[4] = (Sint8) sample4;
+        dst[3] = (Sint8) sample3;
+        dst[2] = (Sint8) sample2;
+        dst[1] = (Sint8) sample1;
+        dst[0] = (Sint8) sample0;
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S8_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S8, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint8 *dst = (Sint8 *) cvt->buf;
+    const Sint8 *src = (Sint8 *) cvt->buf;
+    const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
+    Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
+    Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
+    Sint16 last_sample4 = (Sint16) ((Sint8) src[4]);
+    Sint16 last_sample5 = (Sint16) ((Sint8) src[5]);
+    Sint16 last_sample6 = (Sint16) ((Sint8) src[6]);
+    Sint16 last_sample7 = (Sint16) ((Sint8) src[7]);
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
+        const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
+        const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
+        const Sint16 sample4 = (Sint16) ((Sint8) src[4]);
+        const Sint16 sample5 = (Sint16) ((Sint8) src[5]);
+        const Sint16 sample6 = (Sint16) ((Sint8) src[6]);
+        const Sint16 sample7 = (Sint16) ((Sint8) src[7]);
+        src += 16;
+        dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint8) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint8) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint8) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint8) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint8) ((sample5 + last_sample5) >> 1);
+        dst[6] = (Sint8) ((sample6 + last_sample6) >> 1);
+        dst[7] = (Sint8) ((sample7 + last_sample7) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S8_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S8, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint8 *dst = ((Sint8 *) (cvt->buf + dstsize)) - 8;
+    const Sint8 *src = ((Sint8 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Sint8 *target = ((const Sint8 *) cvt->buf) - 8;
+    Sint16 last_sample7 = (Sint16) ((Sint8) src[7]);
+    Sint16 last_sample6 = (Sint16) ((Sint8) src[6]);
+    Sint16 last_sample5 = (Sint16) ((Sint8) src[5]);
+    Sint16 last_sample4 = (Sint16) ((Sint8) src[4]);
+    Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
+    Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
+    Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    while (dst > target) {
+        const Sint16 sample7 = (Sint16) ((Sint8) src[7]);
+        const Sint16 sample6 = (Sint16) ((Sint8) src[6]);
+        const Sint16 sample5 = (Sint16) ((Sint8) src[5]);
+        const Sint16 sample4 = (Sint16) ((Sint8) src[4]);
+        const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
+        const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
+        const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        src -= 8;
+        dst[31] = (Sint8) sample7;
+        dst[30] = (Sint8) sample6;
+        dst[29] = (Sint8) sample5;
+        dst[28] = (Sint8) sample4;
+        dst[27] = (Sint8) sample3;
+        dst[26] = (Sint8) sample2;
+        dst[25] = (Sint8) sample1;
+        dst[24] = (Sint8) sample0;
+        dst[23] = (Sint8) (((3 * sample7) + last_sample7) >> 2);
+        dst[22] = (Sint8) (((3 * sample6) + last_sample6) >> 2);
+        dst[21] = (Sint8) (((3 * sample5) + last_sample5) >> 2);
+        dst[20] = (Sint8) (((3 * sample4) + last_sample4) >> 2);
+        dst[19] = (Sint8) (((3 * sample3) + last_sample3) >> 2);
+        dst[18] = (Sint8) (((3 * sample2) + last_sample2) >> 2);
+        dst[17] = (Sint8) (((3 * sample1) + last_sample1) >> 2);
+        dst[16] = (Sint8) (((3 * sample0) + last_sample0) >> 2);
+        dst[15] = (Sint8) ((sample7 + last_sample7) >> 1);
+        dst[14] = (Sint8) ((sample6 + last_sample6) >> 1);
+        dst[13] = (Sint8) ((sample5 + last_sample5) >> 1);
+        dst[12] = (Sint8) ((sample4 + last_sample4) >> 1);
+        dst[11] = (Sint8) ((sample3 + last_sample3) >> 1);
+        dst[10] = (Sint8) ((sample2 + last_sample2) >> 1);
+        dst[9] = (Sint8) ((sample1 + last_sample1) >> 1);
+        dst[8] = (Sint8) ((sample0 + last_sample0) >> 1);
+        dst[7] = (Sint8) ((sample7 + (3 * last_sample7)) >> 2);
+        dst[6] = (Sint8) ((sample6 + (3 * last_sample6)) >> 2);
+        dst[5] = (Sint8) ((sample5 + (3 * last_sample5)) >> 2);
+        dst[4] = (Sint8) ((sample4 + (3 * last_sample4)) >> 2);
+        dst[3] = (Sint8) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Sint8) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Sint8) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint8) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 32;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S8_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S8, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint8 *dst = (Sint8 *) cvt->buf;
+    const Sint8 *src = (Sint8 *) cvt->buf;
+    const Sint8 *target = (const Sint8 *) (cvt->buf + dstsize);
+    Sint16 last_sample0 = (Sint16) ((Sint8) src[0]);
+    Sint16 last_sample1 = (Sint16) ((Sint8) src[1]);
+    Sint16 last_sample2 = (Sint16) ((Sint8) src[2]);
+    Sint16 last_sample3 = (Sint16) ((Sint8) src[3]);
+    Sint16 last_sample4 = (Sint16) ((Sint8) src[4]);
+    Sint16 last_sample5 = (Sint16) ((Sint8) src[5]);
+    Sint16 last_sample6 = (Sint16) ((Sint8) src[6]);
+    Sint16 last_sample7 = (Sint16) ((Sint8) src[7]);
+    while (dst < target) {
+        const Sint16 sample0 = (Sint16) ((Sint8) src[0]);
+        const Sint16 sample1 = (Sint16) ((Sint8) src[1]);
+        const Sint16 sample2 = (Sint16) ((Sint8) src[2]);
+        const Sint16 sample3 = (Sint16) ((Sint8) src[3]);
+        const Sint16 sample4 = (Sint16) ((Sint8) src[4]);
+        const Sint16 sample5 = (Sint16) ((Sint8) src[5]);
+        const Sint16 sample6 = (Sint16) ((Sint8) src[6]);
+        const Sint16 sample7 = (Sint16) ((Sint8) src[7]);
+        src += 32;
+        dst[0] = (Sint8) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint8) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint8) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint8) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint8) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint8) ((sample5 + last_sample5) >> 1);
+        dst[6] = (Sint8) ((sample6 + last_sample6) >> 1);
+        dst[7] = (Sint8) ((sample7 + last_sample7) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16LSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_U16LSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 1;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 1;
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        src--;
+        dst[1] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[0] = (Uint16) sample0;
+        last_sample0 = sample0;
+        dst -= 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16LSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_U16LSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        src += 2;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16LSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_U16LSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 1;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 1;
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        src--;
+        dst[3] = (Uint16) sample0;
+        dst[2] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[1] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[0] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16LSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_U16LSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        src += 4;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16LSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_U16LSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 2;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 2;
+    Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        src -= 2;
+        dst[3] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) sample1;
+        dst[0] = (Uint16) sample0;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16LSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_U16LSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
+        src += 4;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16LSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_U16LSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 2;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 2;
+    Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        src -= 2;
+        dst[7] = (Uint16) sample1;
+        dst[6] = (Uint16) sample0;
+        dst[5] = (Uint16) (((3 * sample1) + last_sample1) >> 2);
+        dst[4] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[3] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16LSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_U16LSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
+        src += 8;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16LSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_U16LSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 4;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 4;
+    Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
+        const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
+        const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        src -= 4;
+        dst[7] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[6] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[5] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[4] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[3] = (Uint16) sample3;
+        dst[2] = (Uint16) sample2;
+        dst[1] = (Uint16) sample1;
+        dst[0] = (Uint16) sample0;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16LSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_U16LSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
+        const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
+        const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
+        src += 8;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16LSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_U16LSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 4;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 4;
+    Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
+        const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
+        const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        src -= 4;
+        dst[15] = (Uint16) sample3;
+        dst[14] = (Uint16) sample2;
+        dst[13] = (Uint16) sample1;
+        dst[12] = (Uint16) sample0;
+        dst[11] = (Uint16) (((3 * sample3) + last_sample3) >> 2);
+        dst[10] = (Uint16) (((3 * sample2) + last_sample2) >> 2);
+        dst[9] = (Uint16) (((3 * sample1) + last_sample1) >> 2);
+        dst[8] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[7] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[6] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[5] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[4] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[3] = (Uint16) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Uint16) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Uint16) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16LSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_U16LSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
+        const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
+        const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
+        src += 16;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16LSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_U16LSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 6;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 6;
+    Sint32 last_sample5 = (Sint32) SDL_SwapLE16(src[5]);
+    Sint32 last_sample4 = (Sint32) SDL_SwapLE16(src[4]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample5 = (Sint32) SDL_SwapLE16(src[5]);
+        const Sint32 sample4 = (Sint32) SDL_SwapLE16(src[4]);
+        const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
+        const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
+        const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        src -= 6;
+        dst[11] = (Uint16) ((sample5 + last_sample5) >> 1);
+        dst[10] = (Uint16) ((sample4 + last_sample4) >> 1);
+        dst[9] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[8] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[7] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[6] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[5] = (Uint16) sample5;
+        dst[4] = (Uint16) sample4;
+        dst[3] = (Uint16) sample3;
+        dst[2] = (Uint16) sample2;
+        dst[1] = (Uint16) sample1;
+        dst[0] = (Uint16) sample0;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 12;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16LSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_U16LSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
+    Sint32 last_sample4 = (Sint32) SDL_SwapLE16(src[4]);
+    Sint32 last_sample5 = (Sint32) SDL_SwapLE16(src[5]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
+        const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
+        const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
+        const Sint32 sample4 = (Sint32) SDL_SwapLE16(src[4]);
+        const Sint32 sample5 = (Sint32) SDL_SwapLE16(src[5]);
+        src += 12;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Uint16) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Uint16) ((sample5 + last_sample5) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16LSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_U16LSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 6;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 6;
+    Sint32 last_sample5 = (Sint32) SDL_SwapLE16(src[5]);
+    Sint32 last_sample4 = (Sint32) SDL_SwapLE16(src[4]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample5 = (Sint32) SDL_SwapLE16(src[5]);
+        const Sint32 sample4 = (Sint32) SDL_SwapLE16(src[4]);
+        const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
+        const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
+        const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        src -= 6;
+        dst[23] = (Uint16) sample5;
+        dst[22] = (Uint16) sample4;
+        dst[21] = (Uint16) sample3;
+        dst[20] = (Uint16) sample2;
+        dst[19] = (Uint16) sample1;
+        dst[18] = (Uint16) sample0;
+        dst[17] = (Uint16) (((3 * sample5) + last_sample5) >> 2);
+        dst[16] = (Uint16) (((3 * sample4) + last_sample4) >> 2);
+        dst[15] = (Uint16) (((3 * sample3) + last_sample3) >> 2);
+        dst[14] = (Uint16) (((3 * sample2) + last_sample2) >> 2);
+        dst[13] = (Uint16) (((3 * sample1) + last_sample1) >> 2);
+        dst[12] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[11] = (Uint16) ((sample5 + last_sample5) >> 1);
+        dst[10] = (Uint16) ((sample4 + last_sample4) >> 1);
+        dst[9] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[8] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[7] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[6] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[5] = (Uint16) ((sample5 + (3 * last_sample5)) >> 2);
+        dst[4] = (Uint16) ((sample4 + (3 * last_sample4)) >> 2);
+        dst[3] = (Uint16) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Uint16) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Uint16) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 24;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16LSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_U16LSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
+    Sint32 last_sample4 = (Sint32) SDL_SwapLE16(src[4]);
+    Sint32 last_sample5 = (Sint32) SDL_SwapLE16(src[5]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
+        const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
+        const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
+        const Sint32 sample4 = (Sint32) SDL_SwapLE16(src[4]);
+        const Sint32 sample5 = (Sint32) SDL_SwapLE16(src[5]);
+        src += 24;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Uint16) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Uint16) ((sample5 + last_sample5) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16LSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_U16LSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 8;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 8;
+    Sint32 last_sample7 = (Sint32) SDL_SwapLE16(src[7]);
+    Sint32 last_sample6 = (Sint32) SDL_SwapLE16(src[6]);
+    Sint32 last_sample5 = (Sint32) SDL_SwapLE16(src[5]);
+    Sint32 last_sample4 = (Sint32) SDL_SwapLE16(src[4]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample7 = (Sint32) SDL_SwapLE16(src[7]);
+        const Sint32 sample6 = (Sint32) SDL_SwapLE16(src[6]);
+        const Sint32 sample5 = (Sint32) SDL_SwapLE16(src[5]);
+        const Sint32 sample4 = (Sint32) SDL_SwapLE16(src[4]);
+        const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
+        const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
+        const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        src -= 8;
+        dst[15] = (Uint16) ((sample7 + last_sample7) >> 1);
+        dst[14] = (Uint16) ((sample6 + last_sample6) >> 1);
+        dst[13] = (Uint16) ((sample5 + last_sample5) >> 1);
+        dst[12] = (Uint16) ((sample4 + last_sample4) >> 1);
+        dst[11] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[10] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[9] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[8] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[7] = (Uint16) sample7;
+        dst[6] = (Uint16) sample6;
+        dst[5] = (Uint16) sample5;
+        dst[4] = (Uint16) sample4;
+        dst[3] = (Uint16) sample3;
+        dst[2] = (Uint16) sample2;
+        dst[1] = (Uint16) sample1;
+        dst[0] = (Uint16) sample0;
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16LSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_U16LSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
+    Sint32 last_sample4 = (Sint32) SDL_SwapLE16(src[4]);
+    Sint32 last_sample5 = (Sint32) SDL_SwapLE16(src[5]);
+    Sint32 last_sample6 = (Sint32) SDL_SwapLE16(src[6]);
+    Sint32 last_sample7 = (Sint32) SDL_SwapLE16(src[7]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
+        const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
+        const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
+        const Sint32 sample4 = (Sint32) SDL_SwapLE16(src[4]);
+        const Sint32 sample5 = (Sint32) SDL_SwapLE16(src[5]);
+        const Sint32 sample6 = (Sint32) SDL_SwapLE16(src[6]);
+        const Sint32 sample7 = (Sint32) SDL_SwapLE16(src[7]);
+        src += 16;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Uint16) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Uint16) ((sample5 + last_sample5) >> 1);
+        dst[6] = (Uint16) ((sample6 + last_sample6) >> 1);
+        dst[7] = (Uint16) ((sample7 + last_sample7) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16LSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_U16LSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 8;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 8;
+    Sint32 last_sample7 = (Sint32) SDL_SwapLE16(src[7]);
+    Sint32 last_sample6 = (Sint32) SDL_SwapLE16(src[6]);
+    Sint32 last_sample5 = (Sint32) SDL_SwapLE16(src[5]);
+    Sint32 last_sample4 = (Sint32) SDL_SwapLE16(src[4]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample7 = (Sint32) SDL_SwapLE16(src[7]);
+        const Sint32 sample6 = (Sint32) SDL_SwapLE16(src[6]);
+        const Sint32 sample5 = (Sint32) SDL_SwapLE16(src[5]);
+        const Sint32 sample4 = (Sint32) SDL_SwapLE16(src[4]);
+        const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
+        const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
+        const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        src -= 8;
+        dst[31] = (Uint16) sample7;
+        dst[30] = (Uint16) sample6;
+        dst[29] = (Uint16) sample5;
+        dst[28] = (Uint16) sample4;
+        dst[27] = (Uint16) sample3;
+        dst[26] = (Uint16) sample2;
+        dst[25] = (Uint16) sample1;
+        dst[24] = (Uint16) sample0;
+        dst[23] = (Uint16) (((3 * sample7) + last_sample7) >> 2);
+        dst[22] = (Uint16) (((3 * sample6) + last_sample6) >> 2);
+        dst[21] = (Uint16) (((3 * sample5) + last_sample5) >> 2);
+        dst[20] = (Uint16) (((3 * sample4) + last_sample4) >> 2);
+        dst[19] = (Uint16) (((3 * sample3) + last_sample3) >> 2);
+        dst[18] = (Uint16) (((3 * sample2) + last_sample2) >> 2);
+        dst[17] = (Uint16) (((3 * sample1) + last_sample1) >> 2);
+        dst[16] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[15] = (Uint16) ((sample7 + last_sample7) >> 1);
+        dst[14] = (Uint16) ((sample6 + last_sample6) >> 1);
+        dst[13] = (Uint16) ((sample5 + last_sample5) >> 1);
+        dst[12] = (Uint16) ((sample4 + last_sample4) >> 1);
+        dst[11] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[10] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[9] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[8] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[7] = (Uint16) ((sample7 + (3 * last_sample7)) >> 2);
+        dst[6] = (Uint16) ((sample6 + (3 * last_sample6)) >> 2);
+        dst[5] = (Uint16) ((sample5 + (3 * last_sample5)) >> 2);
+        dst[4] = (Uint16) ((sample4 + (3 * last_sample4)) >> 2);
+        dst[3] = (Uint16) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Uint16) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Uint16) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 32;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16LSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_U16LSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapLE16(src[0]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapLE16(src[1]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapLE16(src[2]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapLE16(src[3]);
+    Sint32 last_sample4 = (Sint32) SDL_SwapLE16(src[4]);
+    Sint32 last_sample5 = (Sint32) SDL_SwapLE16(src[5]);
+    Sint32 last_sample6 = (Sint32) SDL_SwapLE16(src[6]);
+    Sint32 last_sample7 = (Sint32) SDL_SwapLE16(src[7]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapLE16(src[0]);
+        const Sint32 sample1 = (Sint32) SDL_SwapLE16(src[1]);
+        const Sint32 sample2 = (Sint32) SDL_SwapLE16(src[2]);
+        const Sint32 sample3 = (Sint32) SDL_SwapLE16(src[3]);
+        const Sint32 sample4 = (Sint32) SDL_SwapLE16(src[4]);
+        const Sint32 sample5 = (Sint32) SDL_SwapLE16(src[5]);
+        const Sint32 sample6 = (Sint32) SDL_SwapLE16(src[6]);
+        const Sint32 sample7 = (Sint32) SDL_SwapLE16(src[7]);
+        src += 32;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Uint16) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Uint16) ((sample5 + last_sample5) >> 1);
+        dst[6] = (Uint16) ((sample6 + last_sample6) >> 1);
+        dst[7] = (Uint16) ((sample7 + last_sample7) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16LSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S16LSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 1;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 1;
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        src--;
+        dst[1] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[0] = (Sint16) sample0;
+        last_sample0 = sample0;
+        dst -= 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16LSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S16LSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        src += 2;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16LSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S16LSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 1;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 1;
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        src--;
+        dst[3] = (Sint16) sample0;
+        dst[2] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[1] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[0] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16LSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S16LSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        src += 4;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16LSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S16LSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 2;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 2;
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        src -= 2;
+        dst[3] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) sample1;
+        dst[0] = (Sint16) sample0;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16LSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S16LSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+        src += 4;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16LSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S16LSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 2;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 2;
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        src -= 2;
+        dst[7] = (Sint16) sample1;
+        dst[6] = (Sint16) sample0;
+        dst[5] = (Sint16) (((3 * sample1) + last_sample1) >> 2);
+        dst[4] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[3] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16LSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S16LSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+        src += 8;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16LSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S16LSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 4;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 4;
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        src -= 4;
+        dst[7] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[6] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[5] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[4] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[3] = (Sint16) sample3;
+        dst[2] = (Sint16) sample2;
+        dst[1] = (Sint16) sample1;
+        dst[0] = (Sint16) sample0;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16LSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S16LSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+        src += 8;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16LSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S16LSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 4;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 4;
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        src -= 4;
+        dst[15] = (Sint16) sample3;
+        dst[14] = (Sint16) sample2;
+        dst[13] = (Sint16) sample1;
+        dst[12] = (Sint16) sample0;
+        dst[11] = (Sint16) (((3 * sample3) + last_sample3) >> 2);
+        dst[10] = (Sint16) (((3 * sample2) + last_sample2) >> 2);
+        dst[9] = (Sint16) (((3 * sample1) + last_sample1) >> 2);
+        dst[8] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[7] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[6] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[5] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[4] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[3] = (Sint16) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Sint16) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Sint16) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16LSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S16LSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+        src += 16;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16LSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S16LSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 6;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 6;
+    Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
+    Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
+        const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        src -= 6;
+        dst[11] = (Sint16) ((sample5 + last_sample5) >> 1);
+        dst[10] = (Sint16) ((sample4 + last_sample4) >> 1);
+        dst[9] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[8] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[7] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[6] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[5] = (Sint16) sample5;
+        dst[4] = (Sint16) sample4;
+        dst[3] = (Sint16) sample3;
+        dst[2] = (Sint16) sample2;
+        dst[1] = (Sint16) sample1;
+        dst[0] = (Sint16) sample0;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 12;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16LSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S16LSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+    Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
+    Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+        const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
+        const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
+        src += 12;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint16) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint16) ((sample5 + last_sample5) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16LSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S16LSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 6;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 6;
+    Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
+    Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
+        const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        src -= 6;
+        dst[23] = (Sint16) sample5;
+        dst[22] = (Sint16) sample4;
+        dst[21] = (Sint16) sample3;
+        dst[20] = (Sint16) sample2;
+        dst[19] = (Sint16) sample1;
+        dst[18] = (Sint16) sample0;
+        dst[17] = (Sint16) (((3 * sample5) + last_sample5) >> 2);
+        dst[16] = (Sint16) (((3 * sample4) + last_sample4) >> 2);
+        dst[15] = (Sint16) (((3 * sample3) + last_sample3) >> 2);
+        dst[14] = (Sint16) (((3 * sample2) + last_sample2) >> 2);
+        dst[13] = (Sint16) (((3 * sample1) + last_sample1) >> 2);
+        dst[12] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[11] = (Sint16) ((sample5 + last_sample5) >> 1);
+        dst[10] = (Sint16) ((sample4 + last_sample4) >> 1);
+        dst[9] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[8] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[7] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[6] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[5] = (Sint16) ((sample5 + (3 * last_sample5)) >> 2);
+        dst[4] = (Sint16) ((sample4 + (3 * last_sample4)) >> 2);
+        dst[3] = (Sint16) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Sint16) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Sint16) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 24;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16LSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S16LSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+    Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
+    Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+        const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
+        const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
+        src += 24;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint16) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint16) ((sample5 + last_sample5) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16LSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S16LSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 8;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 8;
+    Sint32 last_sample7 = (Sint32) ((Sint16) SDL_SwapLE16(src[7]));
+    Sint32 last_sample6 = (Sint32) ((Sint16) SDL_SwapLE16(src[6]));
+    Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
+    Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample7 = (Sint32) ((Sint16) SDL_SwapLE16(src[7]));
+        const Sint32 sample6 = (Sint32) ((Sint16) SDL_SwapLE16(src[6]));
+        const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
+        const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        src -= 8;
+        dst[15] = (Sint16) ((sample7 + last_sample7) >> 1);
+        dst[14] = (Sint16) ((sample6 + last_sample6) >> 1);
+        dst[13] = (Sint16) ((sample5 + last_sample5) >> 1);
+        dst[12] = (Sint16) ((sample4 + last_sample4) >> 1);
+        dst[11] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[10] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[9] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[8] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[7] = (Sint16) sample7;
+        dst[6] = (Sint16) sample6;
+        dst[5] = (Sint16) sample5;
+        dst[4] = (Sint16) sample4;
+        dst[3] = (Sint16) sample3;
+        dst[2] = (Sint16) sample2;
+        dst[1] = (Sint16) sample1;
+        dst[0] = (Sint16) sample0;
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16LSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S16LSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+    Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
+    Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
+    Sint32 last_sample6 = (Sint32) ((Sint16) SDL_SwapLE16(src[6]));
+    Sint32 last_sample7 = (Sint32) ((Sint16) SDL_SwapLE16(src[7]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+        const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
+        const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
+        const Sint32 sample6 = (Sint32) ((Sint16) SDL_SwapLE16(src[6]));
+        const Sint32 sample7 = (Sint32) ((Sint16) SDL_SwapLE16(src[7]));
+        src += 16;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint16) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint16) ((sample5 + last_sample5) >> 1);
+        dst[6] = (Sint16) ((sample6 + last_sample6) >> 1);
+        dst[7] = (Sint16) ((sample7 + last_sample7) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16LSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S16LSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 8;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 8;
+    Sint32 last_sample7 = (Sint32) ((Sint16) SDL_SwapLE16(src[7]));
+    Sint32 last_sample6 = (Sint32) ((Sint16) SDL_SwapLE16(src[6]));
+    Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
+    Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample7 = (Sint32) ((Sint16) SDL_SwapLE16(src[7]));
+        const Sint32 sample6 = (Sint32) ((Sint16) SDL_SwapLE16(src[6]));
+        const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
+        const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        src -= 8;
+        dst[31] = (Sint16) sample7;
+        dst[30] = (Sint16) sample6;
+        dst[29] = (Sint16) sample5;
+        dst[28] = (Sint16) sample4;
+        dst[27] = (Sint16) sample3;
+        dst[26] = (Sint16) sample2;
+        dst[25] = (Sint16) sample1;
+        dst[24] = (Sint16) sample0;
+        dst[23] = (Sint16) (((3 * sample7) + last_sample7) >> 2);
+        dst[22] = (Sint16) (((3 * sample6) + last_sample6) >> 2);
+        dst[21] = (Sint16) (((3 * sample5) + last_sample5) >> 2);
+        dst[20] = (Sint16) (((3 * sample4) + last_sample4) >> 2);
+        dst[19] = (Sint16) (((3 * sample3) + last_sample3) >> 2);
+        dst[18] = (Sint16) (((3 * sample2) + last_sample2) >> 2);
+        dst[17] = (Sint16) (((3 * sample1) + last_sample1) >> 2);
+        dst[16] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[15] = (Sint16) ((sample7 + last_sample7) >> 1);
+        dst[14] = (Sint16) ((sample6 + last_sample6) >> 1);
+        dst[13] = (Sint16) ((sample5 + last_sample5) >> 1);
+        dst[12] = (Sint16) ((sample4 + last_sample4) >> 1);
+        dst[11] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[10] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[9] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[8] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[7] = (Sint16) ((sample7 + (3 * last_sample7)) >> 2);
+        dst[6] = (Sint16) ((sample6 + (3 * last_sample6)) >> 2);
+        dst[5] = (Sint16) ((sample5 + (3 * last_sample5)) >> 2);
+        dst[4] = (Sint16) ((sample4 + (3 * last_sample4)) >> 2);
+        dst[3] = (Sint16) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Sint16) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Sint16) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 32;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16LSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S16LSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+    Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
+    Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
+    Sint32 last_sample6 = (Sint32) ((Sint16) SDL_SwapLE16(src[6]));
+    Sint32 last_sample7 = (Sint32) ((Sint16) SDL_SwapLE16(src[7]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapLE16(src[0]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapLE16(src[1]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapLE16(src[2]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapLE16(src[3]));
+        const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapLE16(src[4]));
+        const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapLE16(src[5]));
+        const Sint32 sample6 = (Sint32) ((Sint16) SDL_SwapLE16(src[6]));
+        const Sint32 sample7 = (Sint32) ((Sint16) SDL_SwapLE16(src[7]));
+        src += 32;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint16) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint16) ((sample5 + last_sample5) >> 1);
+        dst[6] = (Sint16) ((sample6 + last_sample6) >> 1);
+        dst[7] = (Sint16) ((sample7 + last_sample7) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16MSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_U16MSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 1;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 1;
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        src--;
+        dst[1] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[0] = (Uint16) sample0;
+        last_sample0 = sample0;
+        dst -= 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16MSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_U16MSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        src += 2;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16MSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_U16MSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 1;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 1;
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        src--;
+        dst[3] = (Uint16) sample0;
+        dst[2] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[1] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[0] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16MSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_U16MSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        src += 4;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16MSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_U16MSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 2;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 2;
+    Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        src -= 2;
+        dst[3] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) sample1;
+        dst[0] = (Uint16) sample0;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16MSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_U16MSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
+        src += 4;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16MSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_U16MSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 2;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 2;
+    Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        src -= 2;
+        dst[7] = (Uint16) sample1;
+        dst[6] = (Uint16) sample0;
+        dst[5] = (Uint16) (((3 * sample1) + last_sample1) >> 2);
+        dst[4] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[3] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16MSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_U16MSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
+        src += 8;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16MSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_U16MSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 4;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 4;
+    Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
+        const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
+        const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        src -= 4;
+        dst[7] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[6] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[5] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[4] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[3] = (Uint16) sample3;
+        dst[2] = (Uint16) sample2;
+        dst[1] = (Uint16) sample1;
+        dst[0] = (Uint16) sample0;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16MSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_U16MSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
+        const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
+        const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
+        src += 8;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16MSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_U16MSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 4;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 4;
+    Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
+        const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
+        const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        src -= 4;
+        dst[15] = (Uint16) sample3;
+        dst[14] = (Uint16) sample2;
+        dst[13] = (Uint16) sample1;
+        dst[12] = (Uint16) sample0;
+        dst[11] = (Uint16) (((3 * sample3) + last_sample3) >> 2);
+        dst[10] = (Uint16) (((3 * sample2) + last_sample2) >> 2);
+        dst[9] = (Uint16) (((3 * sample1) + last_sample1) >> 2);
+        dst[8] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[7] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[6] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[5] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[4] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[3] = (Uint16) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Uint16) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Uint16) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16MSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_U16MSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
+        const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
+        const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
+        src += 16;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16MSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_U16MSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 6;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 6;
+    Sint32 last_sample5 = (Sint32) SDL_SwapBE16(src[5]);
+    Sint32 last_sample4 = (Sint32) SDL_SwapBE16(src[4]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample5 = (Sint32) SDL_SwapBE16(src[5]);
+        const Sint32 sample4 = (Sint32) SDL_SwapBE16(src[4]);
+        const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
+        const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
+        const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        src -= 6;
+        dst[11] = (Uint16) ((sample5 + last_sample5) >> 1);
+        dst[10] = (Uint16) ((sample4 + last_sample4) >> 1);
+        dst[9] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[8] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[7] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[6] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[5] = (Uint16) sample5;
+        dst[4] = (Uint16) sample4;
+        dst[3] = (Uint16) sample3;
+        dst[2] = (Uint16) sample2;
+        dst[1] = (Uint16) sample1;
+        dst[0] = (Uint16) sample0;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 12;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16MSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_U16MSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
+    Sint32 last_sample4 = (Sint32) SDL_SwapBE16(src[4]);
+    Sint32 last_sample5 = (Sint32) SDL_SwapBE16(src[5]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
+        const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
+        const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
+        const Sint32 sample4 = (Sint32) SDL_SwapBE16(src[4]);
+        const Sint32 sample5 = (Sint32) SDL_SwapBE16(src[5]);
+        src += 12;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Uint16) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Uint16) ((sample5 + last_sample5) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16MSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_U16MSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 6;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 6;
+    Sint32 last_sample5 = (Sint32) SDL_SwapBE16(src[5]);
+    Sint32 last_sample4 = (Sint32) SDL_SwapBE16(src[4]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample5 = (Sint32) SDL_SwapBE16(src[5]);
+        const Sint32 sample4 = (Sint32) SDL_SwapBE16(src[4]);
+        const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
+        const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
+        const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        src -= 6;
+        dst[23] = (Uint16) sample5;
+        dst[22] = (Uint16) sample4;
+        dst[21] = (Uint16) sample3;
+        dst[20] = (Uint16) sample2;
+        dst[19] = (Uint16) sample1;
+        dst[18] = (Uint16) sample0;
+        dst[17] = (Uint16) (((3 * sample5) + last_sample5) >> 2);
+        dst[16] = (Uint16) (((3 * sample4) + last_sample4) >> 2);
+        dst[15] = (Uint16) (((3 * sample3) + last_sample3) >> 2);
+        dst[14] = (Uint16) (((3 * sample2) + last_sample2) >> 2);
+        dst[13] = (Uint16) (((3 * sample1) + last_sample1) >> 2);
+        dst[12] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[11] = (Uint16) ((sample5 + last_sample5) >> 1);
+        dst[10] = (Uint16) ((sample4 + last_sample4) >> 1);
+        dst[9] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[8] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[7] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[6] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[5] = (Uint16) ((sample5 + (3 * last_sample5)) >> 2);
+        dst[4] = (Uint16) ((sample4 + (3 * last_sample4)) >> 2);
+        dst[3] = (Uint16) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Uint16) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Uint16) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 24;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16MSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_U16MSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
+    Sint32 last_sample4 = (Sint32) SDL_SwapBE16(src[4]);
+    Sint32 last_sample5 = (Sint32) SDL_SwapBE16(src[5]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
+        const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
+        const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
+        const Sint32 sample4 = (Sint32) SDL_SwapBE16(src[4]);
+        const Sint32 sample5 = (Sint32) SDL_SwapBE16(src[5]);
+        src += 24;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Uint16) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Uint16) ((sample5 + last_sample5) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16MSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_U16MSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 8;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 8;
+    Sint32 last_sample7 = (Sint32) SDL_SwapBE16(src[7]);
+    Sint32 last_sample6 = (Sint32) SDL_SwapBE16(src[6]);
+    Sint32 last_sample5 = (Sint32) SDL_SwapBE16(src[5]);
+    Sint32 last_sample4 = (Sint32) SDL_SwapBE16(src[4]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample7 = (Sint32) SDL_SwapBE16(src[7]);
+        const Sint32 sample6 = (Sint32) SDL_SwapBE16(src[6]);
+        const Sint32 sample5 = (Sint32) SDL_SwapBE16(src[5]);
+        const Sint32 sample4 = (Sint32) SDL_SwapBE16(src[4]);
+        const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
+        const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
+        const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        src -= 8;
+        dst[15] = (Uint16) ((sample7 + last_sample7) >> 1);
+        dst[14] = (Uint16) ((sample6 + last_sample6) >> 1);
+        dst[13] = (Uint16) ((sample5 + last_sample5) >> 1);
+        dst[12] = (Uint16) ((sample4 + last_sample4) >> 1);
+        dst[11] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[10] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[9] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[8] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[7] = (Uint16) sample7;
+        dst[6] = (Uint16) sample6;
+        dst[5] = (Uint16) sample5;
+        dst[4] = (Uint16) sample4;
+        dst[3] = (Uint16) sample3;
+        dst[2] = (Uint16) sample2;
+        dst[1] = (Uint16) sample1;
+        dst[0] = (Uint16) sample0;
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16MSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_U16MSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
+    Sint32 last_sample4 = (Sint32) SDL_SwapBE16(src[4]);
+    Sint32 last_sample5 = (Sint32) SDL_SwapBE16(src[5]);
+    Sint32 last_sample6 = (Sint32) SDL_SwapBE16(src[6]);
+    Sint32 last_sample7 = (Sint32) SDL_SwapBE16(src[7]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
+        const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
+        const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
+        const Sint32 sample4 = (Sint32) SDL_SwapBE16(src[4]);
+        const Sint32 sample5 = (Sint32) SDL_SwapBE16(src[5]);
+        const Sint32 sample6 = (Sint32) SDL_SwapBE16(src[6]);
+        const Sint32 sample7 = (Sint32) SDL_SwapBE16(src[7]);
+        src += 16;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Uint16) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Uint16) ((sample5 + last_sample5) >> 1);
+        dst[6] = (Uint16) ((sample6 + last_sample6) >> 1);
+        dst[7] = (Uint16) ((sample7 + last_sample7) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_U16MSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_U16MSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Uint16 *dst = ((Uint16 *) (cvt->buf + dstsize)) - 8;
+    const Uint16 *src = ((Uint16 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Uint16 *target = ((const Uint16 *) cvt->buf) - 8;
+    Sint32 last_sample7 = (Sint32) SDL_SwapBE16(src[7]);
+    Sint32 last_sample6 = (Sint32) SDL_SwapBE16(src[6]);
+    Sint32 last_sample5 = (Sint32) SDL_SwapBE16(src[5]);
+    Sint32 last_sample4 = (Sint32) SDL_SwapBE16(src[4]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    while (dst > target) {
+        const Sint32 sample7 = (Sint32) SDL_SwapBE16(src[7]);
+        const Sint32 sample6 = (Sint32) SDL_SwapBE16(src[6]);
+        const Sint32 sample5 = (Sint32) SDL_SwapBE16(src[5]);
+        const Sint32 sample4 = (Sint32) SDL_SwapBE16(src[4]);
+        const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
+        const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
+        const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        src -= 8;
+        dst[31] = (Uint16) sample7;
+        dst[30] = (Uint16) sample6;
+        dst[29] = (Uint16) sample5;
+        dst[28] = (Uint16) sample4;
+        dst[27] = (Uint16) sample3;
+        dst[26] = (Uint16) sample2;
+        dst[25] = (Uint16) sample1;
+        dst[24] = (Uint16) sample0;
+        dst[23] = (Uint16) (((3 * sample7) + last_sample7) >> 2);
+        dst[22] = (Uint16) (((3 * sample6) + last_sample6) >> 2);
+        dst[21] = (Uint16) (((3 * sample5) + last_sample5) >> 2);
+        dst[20] = (Uint16) (((3 * sample4) + last_sample4) >> 2);
+        dst[19] = (Uint16) (((3 * sample3) + last_sample3) >> 2);
+        dst[18] = (Uint16) (((3 * sample2) + last_sample2) >> 2);
+        dst[17] = (Uint16) (((3 * sample1) + last_sample1) >> 2);
+        dst[16] = (Uint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[15] = (Uint16) ((sample7 + last_sample7) >> 1);
+        dst[14] = (Uint16) ((sample6 + last_sample6) >> 1);
+        dst[13] = (Uint16) ((sample5 + last_sample5) >> 1);
+        dst[12] = (Uint16) ((sample4 + last_sample4) >> 1);
+        dst[11] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[10] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[9] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[8] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[7] = (Uint16) ((sample7 + (3 * last_sample7)) >> 2);
+        dst[6] = (Uint16) ((sample6 + (3 * last_sample6)) >> 2);
+        dst[5] = (Uint16) ((sample5 + (3 * last_sample5)) >> 2);
+        dst[4] = (Uint16) ((sample4 + (3 * last_sample4)) >> 2);
+        dst[3] = (Uint16) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Uint16) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Uint16) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Uint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 32;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_U16MSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_U16MSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Uint16 *dst = (Uint16 *) cvt->buf;
+    const Uint16 *src = (Uint16 *) cvt->buf;
+    const Uint16 *target = (const Uint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) SDL_SwapBE16(src[0]);
+    Sint32 last_sample1 = (Sint32) SDL_SwapBE16(src[1]);
+    Sint32 last_sample2 = (Sint32) SDL_SwapBE16(src[2]);
+    Sint32 last_sample3 = (Sint32) SDL_SwapBE16(src[3]);
+    Sint32 last_sample4 = (Sint32) SDL_SwapBE16(src[4]);
+    Sint32 last_sample5 = (Sint32) SDL_SwapBE16(src[5]);
+    Sint32 last_sample6 = (Sint32) SDL_SwapBE16(src[6]);
+    Sint32 last_sample7 = (Sint32) SDL_SwapBE16(src[7]);
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) SDL_SwapBE16(src[0]);
+        const Sint32 sample1 = (Sint32) SDL_SwapBE16(src[1]);
+        const Sint32 sample2 = (Sint32) SDL_SwapBE16(src[2]);
+        const Sint32 sample3 = (Sint32) SDL_SwapBE16(src[3]);
+        const Sint32 sample4 = (Sint32) SDL_SwapBE16(src[4]);
+        const Sint32 sample5 = (Sint32) SDL_SwapBE16(src[5]);
+        const Sint32 sample6 = (Sint32) SDL_SwapBE16(src[6]);
+        const Sint32 sample7 = (Sint32) SDL_SwapBE16(src[7]);
+        src += 32;
+        dst[0] = (Uint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Uint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Uint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Uint16) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Uint16) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Uint16) ((sample5 + last_sample5) >> 1);
+        dst[6] = (Uint16) ((sample6 + last_sample6) >> 1);
+        dst[7] = (Uint16) ((sample7 + last_sample7) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16MSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S16MSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 1;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 1;
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        src--;
+        dst[1] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[0] = (Sint16) sample0;
+        last_sample0 = sample0;
+        dst -= 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16MSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S16MSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        src += 2;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16MSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S16MSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 1;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 1;
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        src--;
+        dst[3] = (Sint16) sample0;
+        dst[2] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[1] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[0] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16MSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S16MSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        src += 4;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16MSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S16MSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 2;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 2;
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        src -= 2;
+        dst[3] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) sample1;
+        dst[0] = (Sint16) sample0;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16MSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S16MSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+        src += 4;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16MSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S16MSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 2;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 2;
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        src -= 2;
+        dst[7] = (Sint16) sample1;
+        dst[6] = (Sint16) sample0;
+        dst[5] = (Sint16) (((3 * sample1) + last_sample1) >> 2);
+        dst[4] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[3] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16MSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S16MSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+        src += 8;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16MSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S16MSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 4;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 4;
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        src -= 4;
+        dst[7] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[6] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[5] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[4] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[3] = (Sint16) sample3;
+        dst[2] = (Sint16) sample2;
+        dst[1] = (Sint16) sample1;
+        dst[0] = (Sint16) sample0;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16MSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S16MSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+        src += 8;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16MSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S16MSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 4;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 4;
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        src -= 4;
+        dst[15] = (Sint16) sample3;
+        dst[14] = (Sint16) sample2;
+        dst[13] = (Sint16) sample1;
+        dst[12] = (Sint16) sample0;
+        dst[11] = (Sint16) (((3 * sample3) + last_sample3) >> 2);
+        dst[10] = (Sint16) (((3 * sample2) + last_sample2) >> 2);
+        dst[9] = (Sint16) (((3 * sample1) + last_sample1) >> 2);
+        dst[8] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[7] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[6] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[5] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[4] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[3] = (Sint16) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Sint16) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Sint16) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16MSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S16MSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+        src += 16;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16MSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S16MSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 6;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 6;
+    Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
+    Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
+        const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        src -= 6;
+        dst[11] = (Sint16) ((sample5 + last_sample5) >> 1);
+        dst[10] = (Sint16) ((sample4 + last_sample4) >> 1);
+        dst[9] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[8] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[7] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[6] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[5] = (Sint16) sample5;
+        dst[4] = (Sint16) sample4;
+        dst[3] = (Sint16) sample3;
+        dst[2] = (Sint16) sample2;
+        dst[1] = (Sint16) sample1;
+        dst[0] = (Sint16) sample0;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 12;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16MSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S16MSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+    Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
+    Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+        const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
+        const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
+        src += 12;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint16) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint16) ((sample5 + last_sample5) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16MSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S16MSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 6;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 6;
+    Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
+    Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
+        const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        src -= 6;
+        dst[23] = (Sint16) sample5;
+        dst[22] = (Sint16) sample4;
+        dst[21] = (Sint16) sample3;
+        dst[20] = (Sint16) sample2;
+        dst[19] = (Sint16) sample1;
+        dst[18] = (Sint16) sample0;
+        dst[17] = (Sint16) (((3 * sample5) + last_sample5) >> 2);
+        dst[16] = (Sint16) (((3 * sample4) + last_sample4) >> 2);
+        dst[15] = (Sint16) (((3 * sample3) + last_sample3) >> 2);
+        dst[14] = (Sint16) (((3 * sample2) + last_sample2) >> 2);
+        dst[13] = (Sint16) (((3 * sample1) + last_sample1) >> 2);
+        dst[12] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[11] = (Sint16) ((sample5 + last_sample5) >> 1);
+        dst[10] = (Sint16) ((sample4 + last_sample4) >> 1);
+        dst[9] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[8] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[7] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[6] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[5] = (Sint16) ((sample5 + (3 * last_sample5)) >> 2);
+        dst[4] = (Sint16) ((sample4 + (3 * last_sample4)) >> 2);
+        dst[3] = (Sint16) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Sint16) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Sint16) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 24;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16MSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S16MSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+    Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
+    Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+        const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
+        const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
+        src += 24;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint16) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint16) ((sample5 + last_sample5) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16MSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S16MSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 8;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 8;
+    Sint32 last_sample7 = (Sint32) ((Sint16) SDL_SwapBE16(src[7]));
+    Sint32 last_sample6 = (Sint32) ((Sint16) SDL_SwapBE16(src[6]));
+    Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
+    Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample7 = (Sint32) ((Sint16) SDL_SwapBE16(src[7]));
+        const Sint32 sample6 = (Sint32) ((Sint16) SDL_SwapBE16(src[6]));
+        const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
+        const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        src -= 8;
+        dst[15] = (Sint16) ((sample7 + last_sample7) >> 1);
+        dst[14] = (Sint16) ((sample6 + last_sample6) >> 1);
+        dst[13] = (Sint16) ((sample5 + last_sample5) >> 1);
+        dst[12] = (Sint16) ((sample4 + last_sample4) >> 1);
+        dst[11] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[10] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[9] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[8] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[7] = (Sint16) sample7;
+        dst[6] = (Sint16) sample6;
+        dst[5] = (Sint16) sample5;
+        dst[4] = (Sint16) sample4;
+        dst[3] = (Sint16) sample3;
+        dst[2] = (Sint16) sample2;
+        dst[1] = (Sint16) sample1;
+        dst[0] = (Sint16) sample0;
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16MSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S16MSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+    Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
+    Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
+    Sint32 last_sample6 = (Sint32) ((Sint16) SDL_SwapBE16(src[6]));
+    Sint32 last_sample7 = (Sint32) ((Sint16) SDL_SwapBE16(src[7]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+        const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
+        const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
+        const Sint32 sample6 = (Sint32) ((Sint16) SDL_SwapBE16(src[6]));
+        const Sint32 sample7 = (Sint32) ((Sint16) SDL_SwapBE16(src[7]));
+        src += 16;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint16) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint16) ((sample5 + last_sample5) >> 1);
+        dst[6] = (Sint16) ((sample6 + last_sample6) >> 1);
+        dst[7] = (Sint16) ((sample7 + last_sample7) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S16MSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S16MSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint16 *dst = ((Sint16 *) (cvt->buf + dstsize)) - 8;
+    const Sint16 *src = ((Sint16 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Sint16 *target = ((const Sint16 *) cvt->buf) - 8;
+    Sint32 last_sample7 = (Sint32) ((Sint16) SDL_SwapBE16(src[7]));
+    Sint32 last_sample6 = (Sint32) ((Sint16) SDL_SwapBE16(src[6]));
+    Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
+    Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    while (dst > target) {
+        const Sint32 sample7 = (Sint32) ((Sint16) SDL_SwapBE16(src[7]));
+        const Sint32 sample6 = (Sint32) ((Sint16) SDL_SwapBE16(src[6]));
+        const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
+        const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        src -= 8;
+        dst[31] = (Sint16) sample7;
+        dst[30] = (Sint16) sample6;
+        dst[29] = (Sint16) sample5;
+        dst[28] = (Sint16) sample4;
+        dst[27] = (Sint16) sample3;
+        dst[26] = (Sint16) sample2;
+        dst[25] = (Sint16) sample1;
+        dst[24] = (Sint16) sample0;
+        dst[23] = (Sint16) (((3 * sample7) + last_sample7) >> 2);
+        dst[22] = (Sint16) (((3 * sample6) + last_sample6) >> 2);
+        dst[21] = (Sint16) (((3 * sample5) + last_sample5) >> 2);
+        dst[20] = (Sint16) (((3 * sample4) + last_sample4) >> 2);
+        dst[19] = (Sint16) (((3 * sample3) + last_sample3) >> 2);
+        dst[18] = (Sint16) (((3 * sample2) + last_sample2) >> 2);
+        dst[17] = (Sint16) (((3 * sample1) + last_sample1) >> 2);
+        dst[16] = (Sint16) (((3 * sample0) + last_sample0) >> 2);
+        dst[15] = (Sint16) ((sample7 + last_sample7) >> 1);
+        dst[14] = (Sint16) ((sample6 + last_sample6) >> 1);
+        dst[13] = (Sint16) ((sample5 + last_sample5) >> 1);
+        dst[12] = (Sint16) ((sample4 + last_sample4) >> 1);
+        dst[11] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[10] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[9] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[8] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[7] = (Sint16) ((sample7 + (3 * last_sample7)) >> 2);
+        dst[6] = (Sint16) ((sample6 + (3 * last_sample6)) >> 2);
+        dst[5] = (Sint16) ((sample5 + (3 * last_sample5)) >> 2);
+        dst[4] = (Sint16) ((sample4 + (3 * last_sample4)) >> 2);
+        dst[3] = (Sint16) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Sint16) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Sint16) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint16) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 32;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S16MSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S16MSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint16 *dst = (Sint16 *) cvt->buf;
+    const Sint16 *src = (Sint16 *) cvt->buf;
+    const Sint16 *target = (const Sint16 *) (cvt->buf + dstsize);
+    Sint32 last_sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+    Sint32 last_sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+    Sint32 last_sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+    Sint32 last_sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+    Sint32 last_sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
+    Sint32 last_sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
+    Sint32 last_sample6 = (Sint32) ((Sint16) SDL_SwapBE16(src[6]));
+    Sint32 last_sample7 = (Sint32) ((Sint16) SDL_SwapBE16(src[7]));
+    while (dst < target) {
+        const Sint32 sample0 = (Sint32) ((Sint16) SDL_SwapBE16(src[0]));
+        const Sint32 sample1 = (Sint32) ((Sint16) SDL_SwapBE16(src[1]));
+        const Sint32 sample2 = (Sint32) ((Sint16) SDL_SwapBE16(src[2]));
+        const Sint32 sample3 = (Sint32) ((Sint16) SDL_SwapBE16(src[3]));
+        const Sint32 sample4 = (Sint32) ((Sint16) SDL_SwapBE16(src[4]));
+        const Sint32 sample5 = (Sint32) ((Sint16) SDL_SwapBE16(src[5]));
+        const Sint32 sample6 = (Sint32) ((Sint16) SDL_SwapBE16(src[6]));
+        const Sint32 sample7 = (Sint32) ((Sint16) SDL_SwapBE16(src[7]));
+        src += 32;
+        dst[0] = (Sint16) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint16) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint16) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint16) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint16) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint16) ((sample5 + last_sample5) >> 1);
+        dst[6] = (Sint16) ((sample6 + last_sample6) >> 1);
+        dst[7] = (Sint16) ((sample7 + last_sample7) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32LSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S32LSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 1;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 1;
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        src--;
+        dst[1] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[0] = (Sint32) sample0;
+        last_sample0 = sample0;
+        dst -= 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32LSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S32LSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        src += 2;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32LSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S32LSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 1;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 1;
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        src--;
+        dst[3] = (Sint32) sample0;
+        dst[2] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
+        dst[1] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[0] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32LSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S32LSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        src += 4;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32LSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S32LSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 2;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 2;
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        src -= 2;
+        dst[3] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) sample1;
+        dst[0] = (Sint32) sample0;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32LSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S32LSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+        src += 4;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32LSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S32LSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 2;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 2;
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        src -= 2;
+        dst[7] = (Sint32) sample1;
+        dst[6] = (Sint32) sample0;
+        dst[5] = (Sint32) (((3 * sample1) + last_sample1) >> 2);
+        dst[4] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
+        dst[3] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32LSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S32LSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+        src += 8;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32LSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S32LSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 4;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 4;
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        src -= 4;
+        dst[7] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[6] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[5] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[4] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[3] = (Sint32) sample3;
+        dst[2] = (Sint32) sample2;
+        dst[1] = (Sint32) sample1;
+        dst[0] = (Sint32) sample0;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32LSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S32LSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+        src += 8;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32LSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S32LSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 4;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 4;
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        src -= 4;
+        dst[15] = (Sint32) sample3;
+        dst[14] = (Sint32) sample2;
+        dst[13] = (Sint32) sample1;
+        dst[12] = (Sint32) sample0;
+        dst[11] = (Sint32) (((3 * sample3) + last_sample3) >> 2);
+        dst[10] = (Sint32) (((3 * sample2) + last_sample2) >> 2);
+        dst[9] = (Sint32) (((3 * sample1) + last_sample1) >> 2);
+        dst[8] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
+        dst[7] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[6] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[5] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[4] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[3] = (Sint32) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Sint32) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Sint32) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32LSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S32LSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+        src += 16;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32LSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S32LSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 6;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 6;
+    Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
+    Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
+        const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        src -= 6;
+        dst[11] = (Sint32) ((sample5 + last_sample5) >> 1);
+        dst[10] = (Sint32) ((sample4 + last_sample4) >> 1);
+        dst[9] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[8] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[7] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[6] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[5] = (Sint32) sample5;
+        dst[4] = (Sint32) sample4;
+        dst[3] = (Sint32) sample3;
+        dst[2] = (Sint32) sample2;
+        dst[1] = (Sint32) sample1;
+        dst[0] = (Sint32) sample0;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 12;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32LSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S32LSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+    Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
+    Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+        const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
+        const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
+        src += 12;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint32) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint32) ((sample5 + last_sample5) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32LSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S32LSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 6;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 6;
+    Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
+    Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
+        const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        src -= 6;
+        dst[23] = (Sint32) sample5;
+        dst[22] = (Sint32) sample4;
+        dst[21] = (Sint32) sample3;
+        dst[20] = (Sint32) sample2;
+        dst[19] = (Sint32) sample1;
+        dst[18] = (Sint32) sample0;
+        dst[17] = (Sint32) (((3 * sample5) + last_sample5) >> 2);
+        dst[16] = (Sint32) (((3 * sample4) + last_sample4) >> 2);
+        dst[15] = (Sint32) (((3 * sample3) + last_sample3) >> 2);
+        dst[14] = (Sint32) (((3 * sample2) + last_sample2) >> 2);
+        dst[13] = (Sint32) (((3 * sample1) + last_sample1) >> 2);
+        dst[12] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
+        dst[11] = (Sint32) ((sample5 + last_sample5) >> 1);
+        dst[10] = (Sint32) ((sample4 + last_sample4) >> 1);
+        dst[9] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[8] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[7] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[6] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[5] = (Sint32) ((sample5 + (3 * last_sample5)) >> 2);
+        dst[4] = (Sint32) ((sample4 + (3 * last_sample4)) >> 2);
+        dst[3] = (Sint32) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Sint32) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Sint32) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 24;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32LSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S32LSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+    Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
+    Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+        const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
+        const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
+        src += 24;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint32) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint32) ((sample5 + last_sample5) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32LSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S32LSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 8;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 8;
+    Sint64 last_sample7 = (Sint64) ((Sint32) SDL_SwapLE32(src[7]));
+    Sint64 last_sample6 = (Sint64) ((Sint32) SDL_SwapLE32(src[6]));
+    Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
+    Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample7 = (Sint64) ((Sint32) SDL_SwapLE32(src[7]));
+        const Sint64 sample6 = (Sint64) ((Sint32) SDL_SwapLE32(src[6]));
+        const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
+        const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        src -= 8;
+        dst[15] = (Sint32) ((sample7 + last_sample7) >> 1);
+        dst[14] = (Sint32) ((sample6 + last_sample6) >> 1);
+        dst[13] = (Sint32) ((sample5 + last_sample5) >> 1);
+        dst[12] = (Sint32) ((sample4 + last_sample4) >> 1);
+        dst[11] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[10] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[9] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[8] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[7] = (Sint32) sample7;
+        dst[6] = (Sint32) sample6;
+        dst[5] = (Sint32) sample5;
+        dst[4] = (Sint32) sample4;
+        dst[3] = (Sint32) sample3;
+        dst[2] = (Sint32) sample2;
+        dst[1] = (Sint32) sample1;
+        dst[0] = (Sint32) sample0;
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32LSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S32LSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+    Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
+    Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
+    Sint64 last_sample6 = (Sint64) ((Sint32) SDL_SwapLE32(src[6]));
+    Sint64 last_sample7 = (Sint64) ((Sint32) SDL_SwapLE32(src[7]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+        const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
+        const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
+        const Sint64 sample6 = (Sint64) ((Sint32) SDL_SwapLE32(src[6]));
+        const Sint64 sample7 = (Sint64) ((Sint32) SDL_SwapLE32(src[7]));
+        src += 16;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint32) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint32) ((sample5 + last_sample5) >> 1);
+        dst[6] = (Sint32) ((sample6 + last_sample6) >> 1);
+        dst[7] = (Sint32) ((sample7 + last_sample7) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32LSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S32LSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 8;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 8;
+    Sint64 last_sample7 = (Sint64) ((Sint32) SDL_SwapLE32(src[7]));
+    Sint64 last_sample6 = (Sint64) ((Sint32) SDL_SwapLE32(src[6]));
+    Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
+    Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample7 = (Sint64) ((Sint32) SDL_SwapLE32(src[7]));
+        const Sint64 sample6 = (Sint64) ((Sint32) SDL_SwapLE32(src[6]));
+        const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
+        const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        src -= 8;
+        dst[31] = (Sint32) sample7;
+        dst[30] = (Sint32) sample6;
+        dst[29] = (Sint32) sample5;
+        dst[28] = (Sint32) sample4;
+        dst[27] = (Sint32) sample3;
+        dst[26] = (Sint32) sample2;
+        dst[25] = (Sint32) sample1;
+        dst[24] = (Sint32) sample0;
+        dst[23] = (Sint32) (((3 * sample7) + last_sample7) >> 2);
+        dst[22] = (Sint32) (((3 * sample6) + last_sample6) >> 2);
+        dst[21] = (Sint32) (((3 * sample5) + last_sample5) >> 2);
+        dst[20] = (Sint32) (((3 * sample4) + last_sample4) >> 2);
+        dst[19] = (Sint32) (((3 * sample3) + last_sample3) >> 2);
+        dst[18] = (Sint32) (((3 * sample2) + last_sample2) >> 2);
+        dst[17] = (Sint32) (((3 * sample1) + last_sample1) >> 2);
+        dst[16] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
+        dst[15] = (Sint32) ((sample7 + last_sample7) >> 1);
+        dst[14] = (Sint32) ((sample6 + last_sample6) >> 1);
+        dst[13] = (Sint32) ((sample5 + last_sample5) >> 1);
+        dst[12] = (Sint32) ((sample4 + last_sample4) >> 1);
+        dst[11] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[10] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[9] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[8] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[7] = (Sint32) ((sample7 + (3 * last_sample7)) >> 2);
+        dst[6] = (Sint32) ((sample6 + (3 * last_sample6)) >> 2);
+        dst[5] = (Sint32) ((sample5 + (3 * last_sample5)) >> 2);
+        dst[4] = (Sint32) ((sample4 + (3 * last_sample4)) >> 2);
+        dst[3] = (Sint32) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Sint32) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Sint32) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 32;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32LSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S32LSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+    Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
+    Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
+    Sint64 last_sample6 = (Sint64) ((Sint32) SDL_SwapLE32(src[6]));
+    Sint64 last_sample7 = (Sint64) ((Sint32) SDL_SwapLE32(src[7]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapLE32(src[0]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapLE32(src[1]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapLE32(src[2]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapLE32(src[3]));
+        const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapLE32(src[4]));
+        const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapLE32(src[5]));
+        const Sint64 sample6 = (Sint64) ((Sint32) SDL_SwapLE32(src[6]));
+        const Sint64 sample7 = (Sint64) ((Sint32) SDL_SwapLE32(src[7]));
+        src += 32;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint32) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint32) ((sample5 + last_sample5) >> 1);
+        dst[6] = (Sint32) ((sample6 + last_sample6) >> 1);
+        dst[7] = (Sint32) ((sample7 + last_sample7) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32MSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S32MSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 1;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 1;
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        src--;
+        dst[1] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[0] = (Sint32) sample0;
+        last_sample0 = sample0;
+        dst -= 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32MSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S32MSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        src += 2;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32MSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S32MSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 1;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 1;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 1;
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        src--;
+        dst[3] = (Sint32) sample0;
+        dst[2] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
+        dst[1] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[0] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32MSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S32MSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        src += 4;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32MSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S32MSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 2;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 2;
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        src -= 2;
+        dst[3] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) sample1;
+        dst[0] = (Sint32) sample0;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32MSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S32MSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+        src += 4;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32MSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S32MSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 2;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 2;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 2;
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        src -= 2;
+        dst[7] = (Sint32) sample1;
+        dst[6] = (Sint32) sample0;
+        dst[5] = (Sint32) (((3 * sample1) + last_sample1) >> 2);
+        dst[4] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
+        dst[3] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32MSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S32MSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+        src += 8;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32MSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S32MSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 4;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 4;
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        src -= 4;
+        dst[7] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[6] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[5] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[4] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[3] = (Sint32) sample3;
+        dst[2] = (Sint32) sample2;
+        dst[1] = (Sint32) sample1;
+        dst[0] = (Sint32) sample0;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32MSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S32MSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+        src += 8;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32MSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S32MSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 4;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 4;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 4;
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        src -= 4;
+        dst[15] = (Sint32) sample3;
+        dst[14] = (Sint32) sample2;
+        dst[13] = (Sint32) sample1;
+        dst[12] = (Sint32) sample0;
+        dst[11] = (Sint32) (((3 * sample3) + last_sample3) >> 2);
+        dst[10] = (Sint32) (((3 * sample2) + last_sample2) >> 2);
+        dst[9] = (Sint32) (((3 * sample1) + last_sample1) >> 2);
+        dst[8] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
+        dst[7] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[6] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[5] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[4] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[3] = (Sint32) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Sint32) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Sint32) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32MSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S32MSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+        src += 16;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32MSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S32MSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 6;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 6;
+    Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
+    Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
+        const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        src -= 6;
+        dst[11] = (Sint32) ((sample5 + last_sample5) >> 1);
+        dst[10] = (Sint32) ((sample4 + last_sample4) >> 1);
+        dst[9] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[8] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[7] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[6] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[5] = (Sint32) sample5;
+        dst[4] = (Sint32) sample4;
+        dst[3] = (Sint32) sample3;
+        dst[2] = (Sint32) sample2;
+        dst[1] = (Sint32) sample1;
+        dst[0] = (Sint32) sample0;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 12;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32MSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S32MSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+    Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
+    Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+        const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
+        const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
+        src += 12;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint32) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint32) ((sample5 + last_sample5) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32MSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S32MSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 6;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 6;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 6;
+    Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
+    Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
+        const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        src -= 6;
+        dst[23] = (Sint32) sample5;
+        dst[22] = (Sint32) sample4;
+        dst[21] = (Sint32) sample3;
+        dst[20] = (Sint32) sample2;
+        dst[19] = (Sint32) sample1;
+        dst[18] = (Sint32) sample0;
+        dst[17] = (Sint32) (((3 * sample5) + last_sample5) >> 2);
+        dst[16] = (Sint32) (((3 * sample4) + last_sample4) >> 2);
+        dst[15] = (Sint32) (((3 * sample3) + last_sample3) >> 2);
+        dst[14] = (Sint32) (((3 * sample2) + last_sample2) >> 2);
+        dst[13] = (Sint32) (((3 * sample1) + last_sample1) >> 2);
+        dst[12] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
+        dst[11] = (Sint32) ((sample5 + last_sample5) >> 1);
+        dst[10] = (Sint32) ((sample4 + last_sample4) >> 1);
+        dst[9] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[8] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[7] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[6] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[5] = (Sint32) ((sample5 + (3 * last_sample5)) >> 2);
+        dst[4] = (Sint32) ((sample4 + (3 * last_sample4)) >> 2);
+        dst[3] = (Sint32) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Sint32) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Sint32) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 24;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32MSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S32MSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+    Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
+    Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+        const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
+        const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
+        src += 24;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint32) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint32) ((sample5 + last_sample5) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32MSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_S32MSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 8;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 8;
+    Sint64 last_sample7 = (Sint64) ((Sint32) SDL_SwapBE32(src[7]));
+    Sint64 last_sample6 = (Sint64) ((Sint32) SDL_SwapBE32(src[6]));
+    Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
+    Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample7 = (Sint64) ((Sint32) SDL_SwapBE32(src[7]));
+        const Sint64 sample6 = (Sint64) ((Sint32) SDL_SwapBE32(src[6]));
+        const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
+        const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        src -= 8;
+        dst[15] = (Sint32) ((sample7 + last_sample7) >> 1);
+        dst[14] = (Sint32) ((sample6 + last_sample6) >> 1);
+        dst[13] = (Sint32) ((sample5 + last_sample5) >> 1);
+        dst[12] = (Sint32) ((sample4 + last_sample4) >> 1);
+        dst[11] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[10] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[9] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[8] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[7] = (Sint32) sample7;
+        dst[6] = (Sint32) sample6;
+        dst[5] = (Sint32) sample5;
+        dst[4] = (Sint32) sample4;
+        dst[3] = (Sint32) sample3;
+        dst[2] = (Sint32) sample2;
+        dst[1] = (Sint32) sample1;
+        dst[0] = (Sint32) sample0;
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32MSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_S32MSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+    Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
+    Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
+    Sint64 last_sample6 = (Sint64) ((Sint32) SDL_SwapBE32(src[6]));
+    Sint64 last_sample7 = (Sint64) ((Sint32) SDL_SwapBE32(src[7]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+        const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
+        const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
+        const Sint64 sample6 = (Sint64) ((Sint32) SDL_SwapBE32(src[6]));
+        const Sint64 sample7 = (Sint64) ((Sint32) SDL_SwapBE32(src[7]));
+        src += 16;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint32) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint32) ((sample5 + last_sample5) >> 1);
+        dst[6] = (Sint32) ((sample6 + last_sample6) >> 1);
+        dst[7] = (Sint32) ((sample7 + last_sample7) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_S32MSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_S32MSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    Sint32 *dst = ((Sint32 *) (cvt->buf + dstsize)) - 8;
+    const Sint32 *src = ((Sint32 *) (cvt->buf + cvt->len_cvt)) - 8;
+    const Sint32 *target = ((const Sint32 *) cvt->buf) - 8;
+    Sint64 last_sample7 = (Sint64) ((Sint32) SDL_SwapBE32(src[7]));
+    Sint64 last_sample6 = (Sint64) ((Sint32) SDL_SwapBE32(src[6]));
+    Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
+    Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    while (dst > target) {
+        const Sint64 sample7 = (Sint64) ((Sint32) SDL_SwapBE32(src[7]));
+        const Sint64 sample6 = (Sint64) ((Sint32) SDL_SwapBE32(src[6]));
+        const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
+        const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        src -= 8;
+        dst[31] = (Sint32) sample7;
+        dst[30] = (Sint32) sample6;
+        dst[29] = (Sint32) sample5;
+        dst[28] = (Sint32) sample4;
+        dst[27] = (Sint32) sample3;
+        dst[26] = (Sint32) sample2;
+        dst[25] = (Sint32) sample1;
+        dst[24] = (Sint32) sample0;
+        dst[23] = (Sint32) (((3 * sample7) + last_sample7) >> 2);
+        dst[22] = (Sint32) (((3 * sample6) + last_sample6) >> 2);
+        dst[21] = (Sint32) (((3 * sample5) + last_sample5) >> 2);
+        dst[20] = (Sint32) (((3 * sample4) + last_sample4) >> 2);
+        dst[19] = (Sint32) (((3 * sample3) + last_sample3) >> 2);
+        dst[18] = (Sint32) (((3 * sample2) + last_sample2) >> 2);
+        dst[17] = (Sint32) (((3 * sample1) + last_sample1) >> 2);
+        dst[16] = (Sint32) (((3 * sample0) + last_sample0) >> 2);
+        dst[15] = (Sint32) ((sample7 + last_sample7) >> 1);
+        dst[14] = (Sint32) ((sample6 + last_sample6) >> 1);
+        dst[13] = (Sint32) ((sample5 + last_sample5) >> 1);
+        dst[12] = (Sint32) ((sample4 + last_sample4) >> 1);
+        dst[11] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[10] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[9] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[8] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[7] = (Sint32) ((sample7 + (3 * last_sample7)) >> 2);
+        dst[6] = (Sint32) ((sample6 + (3 * last_sample6)) >> 2);
+        dst[5] = (Sint32) ((sample5 + (3 * last_sample5)) >> 2);
+        dst[4] = (Sint32) ((sample4 + (3 * last_sample4)) >> 2);
+        dst[3] = (Sint32) ((sample3 + (3 * last_sample3)) >> 2);
+        dst[2] = (Sint32) ((sample2 + (3 * last_sample2)) >> 2);
+        dst[1] = (Sint32) ((sample1 + (3 * last_sample1)) >> 2);
+        dst[0] = (Sint32) ((sample0 + (3 * last_sample0)) >> 2);
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 32;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_S32MSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_S32MSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    Sint32 *dst = (Sint32 *) cvt->buf;
+    const Sint32 *src = (Sint32 *) cvt->buf;
+    const Sint32 *target = (const Sint32 *) (cvt->buf + dstsize);
+    Sint64 last_sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+    Sint64 last_sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+    Sint64 last_sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+    Sint64 last_sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+    Sint64 last_sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
+    Sint64 last_sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
+    Sint64 last_sample6 = (Sint64) ((Sint32) SDL_SwapBE32(src[6]));
+    Sint64 last_sample7 = (Sint64) ((Sint32) SDL_SwapBE32(src[7]));
+    while (dst < target) {
+        const Sint64 sample0 = (Sint64) ((Sint32) SDL_SwapBE32(src[0]));
+        const Sint64 sample1 = (Sint64) ((Sint32) SDL_SwapBE32(src[1]));
+        const Sint64 sample2 = (Sint64) ((Sint32) SDL_SwapBE32(src[2]));
+        const Sint64 sample3 = (Sint64) ((Sint32) SDL_SwapBE32(src[3]));
+        const Sint64 sample4 = (Sint64) ((Sint32) SDL_SwapBE32(src[4]));
+        const Sint64 sample5 = (Sint64) ((Sint32) SDL_SwapBE32(src[5]));
+        const Sint64 sample6 = (Sint64) ((Sint32) SDL_SwapBE32(src[6]));
+        const Sint64 sample7 = (Sint64) ((Sint32) SDL_SwapBE32(src[7]));
+        src += 32;
+        dst[0] = (Sint32) ((sample0 + last_sample0) >> 1);
+        dst[1] = (Sint32) ((sample1 + last_sample1) >> 1);
+        dst[2] = (Sint32) ((sample2 + last_sample2) >> 1);
+        dst[3] = (Sint32) ((sample3 + last_sample3) >> 1);
+        dst[4] = (Sint32) ((sample4 + last_sample4) >> 1);
+        dst[5] = (Sint32) ((sample5 + last_sample5) >> 1);
+        dst[6] = (Sint32) ((sample6 + last_sample6) >> 1);
+        dst[7] = (Sint32) ((sample7 + last_sample7) >> 1);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32LSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_F32LSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 1;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 1;
+    const float *target = ((const float *) cvt->buf) - 1;
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    while (dst > target) {
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        src--;
+        dst[1] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[0] = (float) sample0;
+        last_sample0 = sample0;
+        dst -= 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32LSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_F32LSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        src += 2;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32LSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_F32LSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 1;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 1;
+    const float *target = ((const float *) cvt->buf) - 1;
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    while (dst > target) {
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        src--;
+        dst[3] = (float) sample0;
+        dst[2] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
+        dst[1] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[0] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32LSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_F32LSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        src += 4;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32LSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_F32LSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 2;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 2;
+    const float *target = ((const float *) cvt->buf) - 2;
+    double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    while (dst > target) {
+        const double sample1 = (double) SDL_SwapFloatLE(src[1]);
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        src -= 2;
+        dst[3] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[2] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) sample1;
+        dst[0] = (float) sample0;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32LSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_F32LSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        const double sample1 = (double) SDL_SwapFloatLE(src[1]);
+        src += 4;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) ((sample1 + last_sample1) * 0.5);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32LSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_F32LSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 2;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 2;
+    const float *target = ((const float *) cvt->buf) - 2;
+    double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    while (dst > target) {
+        const double sample1 = (double) SDL_SwapFloatLE(src[1]);
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        src -= 2;
+        dst[7] = (float) sample1;
+        dst[6] = (float) sample0;
+        dst[5] = (float) (((3.0 * sample1) + last_sample1) * 0.25);
+        dst[4] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
+        dst[3] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[2] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) ((sample1 + (3.0 * last_sample1)) * 0.25);
+        dst[0] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32LSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_F32LSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        const double sample1 = (double) SDL_SwapFloatLE(src[1]);
+        src += 8;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) ((sample1 + last_sample1) * 0.5);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32LSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_F32LSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 4;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 4;
+    const float *target = ((const float *) cvt->buf) - 4;
+    double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
+    double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
+    double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    while (dst > target) {
+        const double sample3 = (double) SDL_SwapFloatLE(src[3]);
+        const double sample2 = (double) SDL_SwapFloatLE(src[2]);
+        const double sample1 = (double) SDL_SwapFloatLE(src[1]);
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        src -= 4;
+        dst[7] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[6] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[5] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[4] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[3] = (float) sample3;
+        dst[2] = (float) sample2;
+        dst[1] = (float) sample1;
+        dst[0] = (float) sample0;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32LSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_F32LSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
+    double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
+    double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        const double sample1 = (double) SDL_SwapFloatLE(src[1]);
+        const double sample2 = (double) SDL_SwapFloatLE(src[2]);
+        const double sample3 = (double) SDL_SwapFloatLE(src[3]);
+        src += 8;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[2] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[3] = (float) ((sample3 + last_sample3) * 0.5);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32LSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_F32LSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 4;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 4;
+    const float *target = ((const float *) cvt->buf) - 4;
+    double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
+    double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
+    double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    while (dst > target) {
+        const double sample3 = (double) SDL_SwapFloatLE(src[3]);
+        const double sample2 = (double) SDL_SwapFloatLE(src[2]);
+        const double sample1 = (double) SDL_SwapFloatLE(src[1]);
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        src -= 4;
+        dst[15] = (float) sample3;
+        dst[14] = (float) sample2;
+        dst[13] = (float) sample1;
+        dst[12] = (float) sample0;
+        dst[11] = (float) (((3.0 * sample3) + last_sample3) * 0.25);
+        dst[10] = (float) (((3.0 * sample2) + last_sample2) * 0.25);
+        dst[9] = (float) (((3.0 * sample1) + last_sample1) * 0.25);
+        dst[8] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
+        dst[7] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[6] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[5] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[4] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[3] = (float) ((sample3 + (3.0 * last_sample3)) * 0.25);
+        dst[2] = (float) ((sample2 + (3.0 * last_sample2)) * 0.25);
+        dst[1] = (float) ((sample1 + (3.0 * last_sample1)) * 0.25);
+        dst[0] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32LSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_F32LSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
+    double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
+    double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        const double sample1 = (double) SDL_SwapFloatLE(src[1]);
+        const double sample2 = (double) SDL_SwapFloatLE(src[2]);
+        const double sample3 = (double) SDL_SwapFloatLE(src[3]);
+        src += 16;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[2] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[3] = (float) ((sample3 + last_sample3) * 0.5);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32LSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_F32LSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 6;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 6;
+    const float *target = ((const float *) cvt->buf) - 6;
+    double last_sample5 = (double) SDL_SwapFloatLE(src[5]);
+    double last_sample4 = (double) SDL_SwapFloatLE(src[4]);
+    double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
+    double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
+    double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    while (dst > target) {
+        const double sample5 = (double) SDL_SwapFloatLE(src[5]);
+        const double sample4 = (double) SDL_SwapFloatLE(src[4]);
+        const double sample3 = (double) SDL_SwapFloatLE(src[3]);
+        const double sample2 = (double) SDL_SwapFloatLE(src[2]);
+        const double sample1 = (double) SDL_SwapFloatLE(src[1]);
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        src -= 6;
+        dst[11] = (float) ((sample5 + last_sample5) * 0.5);
+        dst[10] = (float) ((sample4 + last_sample4) * 0.5);
+        dst[9] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[8] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[7] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[6] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[5] = (float) sample5;
+        dst[4] = (float) sample4;
+        dst[3] = (float) sample3;
+        dst[2] = (float) sample2;
+        dst[1] = (float) sample1;
+        dst[0] = (float) sample0;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 12;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32LSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_F32LSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
+    double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
+    double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
+    double last_sample4 = (double) SDL_SwapFloatLE(src[4]);
+    double last_sample5 = (double) SDL_SwapFloatLE(src[5]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        const double sample1 = (double) SDL_SwapFloatLE(src[1]);
+        const double sample2 = (double) SDL_SwapFloatLE(src[2]);
+        const double sample3 = (double) SDL_SwapFloatLE(src[3]);
+        const double sample4 = (double) SDL_SwapFloatLE(src[4]);
+        const double sample5 = (double) SDL_SwapFloatLE(src[5]);
+        src += 12;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[2] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[3] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[4] = (float) ((sample4 + last_sample4) * 0.5);
+        dst[5] = (float) ((sample5 + last_sample5) * 0.5);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32LSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_F32LSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 6;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 6;
+    const float *target = ((const float *) cvt->buf) - 6;
+    double last_sample5 = (double) SDL_SwapFloatLE(src[5]);
+    double last_sample4 = (double) SDL_SwapFloatLE(src[4]);
+    double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
+    double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
+    double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    while (dst > target) {
+        const double sample5 = (double) SDL_SwapFloatLE(src[5]);
+        const double sample4 = (double) SDL_SwapFloatLE(src[4]);
+        const double sample3 = (double) SDL_SwapFloatLE(src[3]);
+        const double sample2 = (double) SDL_SwapFloatLE(src[2]);
+        const double sample1 = (double) SDL_SwapFloatLE(src[1]);
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        src -= 6;
+        dst[23] = (float) sample5;
+        dst[22] = (float) sample4;
+        dst[21] = (float) sample3;
+        dst[20] = (float) sample2;
+        dst[19] = (float) sample1;
+        dst[18] = (float) sample0;
+        dst[17] = (float) (((3.0 * sample5) + last_sample5) * 0.25);
+        dst[16] = (float) (((3.0 * sample4) + last_sample4) * 0.25);
+        dst[15] = (float) (((3.0 * sample3) + last_sample3) * 0.25);
+        dst[14] = (float) (((3.0 * sample2) + last_sample2) * 0.25);
+        dst[13] = (float) (((3.0 * sample1) + last_sample1) * 0.25);
+        dst[12] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
+        dst[11] = (float) ((sample5 + last_sample5) * 0.5);
+        dst[10] = (float) ((sample4 + last_sample4) * 0.5);
+        dst[9] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[8] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[7] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[6] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[5] = (float) ((sample5 + (3.0 * last_sample5)) * 0.25);
+        dst[4] = (float) ((sample4 + (3.0 * last_sample4)) * 0.25);
+        dst[3] = (float) ((sample3 + (3.0 * last_sample3)) * 0.25);
+        dst[2] = (float) ((sample2 + (3.0 * last_sample2)) * 0.25);
+        dst[1] = (float) ((sample1 + (3.0 * last_sample1)) * 0.25);
+        dst[0] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 24;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32LSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_F32LSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
+    double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
+    double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
+    double last_sample4 = (double) SDL_SwapFloatLE(src[4]);
+    double last_sample5 = (double) SDL_SwapFloatLE(src[5]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        const double sample1 = (double) SDL_SwapFloatLE(src[1]);
+        const double sample2 = (double) SDL_SwapFloatLE(src[2]);
+        const double sample3 = (double) SDL_SwapFloatLE(src[3]);
+        const double sample4 = (double) SDL_SwapFloatLE(src[4]);
+        const double sample5 = (double) SDL_SwapFloatLE(src[5]);
+        src += 24;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[2] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[3] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[4] = (float) ((sample4 + last_sample4) * 0.5);
+        dst[5] = (float) ((sample5 + last_sample5) * 0.5);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32LSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_F32LSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 8;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 8;
+    const float *target = ((const float *) cvt->buf) - 8;
+    double last_sample7 = (double) SDL_SwapFloatLE(src[7]);
+    double last_sample6 = (double) SDL_SwapFloatLE(src[6]);
+    double last_sample5 = (double) SDL_SwapFloatLE(src[5]);
+    double last_sample4 = (double) SDL_SwapFloatLE(src[4]);
+    double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
+    double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
+    double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    while (dst > target) {
+        const double sample7 = (double) SDL_SwapFloatLE(src[7]);
+        const double sample6 = (double) SDL_SwapFloatLE(src[6]);
+        const double sample5 = (double) SDL_SwapFloatLE(src[5]);
+        const double sample4 = (double) SDL_SwapFloatLE(src[4]);
+        const double sample3 = (double) SDL_SwapFloatLE(src[3]);
+        const double sample2 = (double) SDL_SwapFloatLE(src[2]);
+        const double sample1 = (double) SDL_SwapFloatLE(src[1]);
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        src -= 8;
+        dst[15] = (float) ((sample7 + last_sample7) * 0.5);
+        dst[14] = (float) ((sample6 + last_sample6) * 0.5);
+        dst[13] = (float) ((sample5 + last_sample5) * 0.5);
+        dst[12] = (float) ((sample4 + last_sample4) * 0.5);
+        dst[11] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[10] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[9] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[8] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[7] = (float) sample7;
+        dst[6] = (float) sample6;
+        dst[5] = (float) sample5;
+        dst[4] = (float) sample4;
+        dst[3] = (float) sample3;
+        dst[2] = (float) sample2;
+        dst[1] = (float) sample1;
+        dst[0] = (float) sample0;
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32LSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_F32LSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
+    double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
+    double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
+    double last_sample4 = (double) SDL_SwapFloatLE(src[4]);
+    double last_sample5 = (double) SDL_SwapFloatLE(src[5]);
+    double last_sample6 = (double) SDL_SwapFloatLE(src[6]);
+    double last_sample7 = (double) SDL_SwapFloatLE(src[7]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        const double sample1 = (double) SDL_SwapFloatLE(src[1]);
+        const double sample2 = (double) SDL_SwapFloatLE(src[2]);
+        const double sample3 = (double) SDL_SwapFloatLE(src[3]);
+        const double sample4 = (double) SDL_SwapFloatLE(src[4]);
+        const double sample5 = (double) SDL_SwapFloatLE(src[5]);
+        const double sample6 = (double) SDL_SwapFloatLE(src[6]);
+        const double sample7 = (double) SDL_SwapFloatLE(src[7]);
+        src += 16;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[2] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[3] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[4] = (float) ((sample4 + last_sample4) * 0.5);
+        dst[5] = (float) ((sample5 + last_sample5) * 0.5);
+        dst[6] = (float) ((sample6 + last_sample6) * 0.5);
+        dst[7] = (float) ((sample7 + last_sample7) * 0.5);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32LSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_F32LSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 8;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 8;
+    const float *target = ((const float *) cvt->buf) - 8;
+    double last_sample7 = (double) SDL_SwapFloatLE(src[7]);
+    double last_sample6 = (double) SDL_SwapFloatLE(src[6]);
+    double last_sample5 = (double) SDL_SwapFloatLE(src[5]);
+    double last_sample4 = (double) SDL_SwapFloatLE(src[4]);
+    double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
+    double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
+    double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    while (dst > target) {
+        const double sample7 = (double) SDL_SwapFloatLE(src[7]);
+        const double sample6 = (double) SDL_SwapFloatLE(src[6]);
+        const double sample5 = (double) SDL_SwapFloatLE(src[5]);
+        const double sample4 = (double) SDL_SwapFloatLE(src[4]);
+        const double sample3 = (double) SDL_SwapFloatLE(src[3]);
+        const double sample2 = (double) SDL_SwapFloatLE(src[2]);
+        const double sample1 = (double) SDL_SwapFloatLE(src[1]);
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        src -= 8;
+        dst[31] = (float) sample7;
+        dst[30] = (float) sample6;
+        dst[29] = (float) sample5;
+        dst[28] = (float) sample4;
+        dst[27] = (float) sample3;
+        dst[26] = (float) sample2;
+        dst[25] = (float) sample1;
+        dst[24] = (float) sample0;
+        dst[23] = (float) (((3.0 * sample7) + last_sample7) * 0.25);
+        dst[22] = (float) (((3.0 * sample6) + last_sample6) * 0.25);
+        dst[21] = (float) (((3.0 * sample5) + last_sample5) * 0.25);
+        dst[20] = (float) (((3.0 * sample4) + last_sample4) * 0.25);
+        dst[19] = (float) (((3.0 * sample3) + last_sample3) * 0.25);
+        dst[18] = (float) (((3.0 * sample2) + last_sample2) * 0.25);
+        dst[17] = (float) (((3.0 * sample1) + last_sample1) * 0.25);
+        dst[16] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
+        dst[15] = (float) ((sample7 + last_sample7) * 0.5);
+        dst[14] = (float) ((sample6 + last_sample6) * 0.5);
+        dst[13] = (float) ((sample5 + last_sample5) * 0.5);
+        dst[12] = (float) ((sample4 + last_sample4) * 0.5);
+        dst[11] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[10] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[9] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[8] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[7] = (float) ((sample7 + (3.0 * last_sample7)) * 0.25);
+        dst[6] = (float) ((sample6 + (3.0 * last_sample6)) * 0.25);
+        dst[5] = (float) ((sample5 + (3.0 * last_sample5)) * 0.25);
+        dst[4] = (float) ((sample4 + (3.0 * last_sample4)) * 0.25);
+        dst[3] = (float) ((sample3 + (3.0 * last_sample3)) * 0.25);
+        dst[2] = (float) ((sample2 + (3.0 * last_sample2)) * 0.25);
+        dst[1] = (float) ((sample1 + (3.0 * last_sample1)) * 0.25);
+        dst[0] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 32;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32LSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_F32LSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatLE(src[0]);
+    double last_sample1 = (double) SDL_SwapFloatLE(src[1]);
+    double last_sample2 = (double) SDL_SwapFloatLE(src[2]);
+    double last_sample3 = (double) SDL_SwapFloatLE(src[3]);
+    double last_sample4 = (double) SDL_SwapFloatLE(src[4]);
+    double last_sample5 = (double) SDL_SwapFloatLE(src[5]);
+    double last_sample6 = (double) SDL_SwapFloatLE(src[6]);
+    double last_sample7 = (double) SDL_SwapFloatLE(src[7]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatLE(src[0]);
+        const double sample1 = (double) SDL_SwapFloatLE(src[1]);
+        const double sample2 = (double) SDL_SwapFloatLE(src[2]);
+        const double sample3 = (double) SDL_SwapFloatLE(src[3]);
+        const double sample4 = (double) SDL_SwapFloatLE(src[4]);
+        const double sample5 = (double) SDL_SwapFloatLE(src[5]);
+        const double sample6 = (double) SDL_SwapFloatLE(src[6]);
+        const double sample7 = (double) SDL_SwapFloatLE(src[7]);
+        src += 32;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[2] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[3] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[4] = (float) ((sample4 + last_sample4) * 0.5);
+        dst[5] = (float) ((sample5 + last_sample5) * 0.5);
+        dst[6] = (float) ((sample6 + last_sample6) * 0.5);
+        dst[7] = (float) ((sample7 + last_sample7) * 0.5);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32MSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_F32MSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 1;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 1;
+    const float *target = ((const float *) cvt->buf) - 1;
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    while (dst > target) {
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        src--;
+        dst[1] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[0] = (float) sample0;
+        last_sample0 = sample0;
+        dst -= 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32MSB_1c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_F32MSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        src += 2;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32MSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_F32MSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 1;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 1;
+    const float *target = ((const float *) cvt->buf) - 1;
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    while (dst > target) {
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        src--;
+        dst[3] = (float) sample0;
+        dst[2] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
+        dst[1] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[0] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32MSB_1c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_F32MSB, 1 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        src += 4;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        last_sample0 = sample0;
+        dst++;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32MSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_F32MSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 2;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 2;
+    const float *target = ((const float *) cvt->buf) - 2;
+    double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    while (dst > target) {
+        const double sample1 = (double) SDL_SwapFloatBE(src[1]);
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        src -= 2;
+        dst[3] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[2] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) sample1;
+        dst[0] = (float) sample0;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32MSB_2c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_F32MSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        const double sample1 = (double) SDL_SwapFloatBE(src[1]);
+        src += 4;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) ((sample1 + last_sample1) * 0.5);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32MSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_F32MSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 2;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 2;
+    const float *target = ((const float *) cvt->buf) - 2;
+    double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    while (dst > target) {
+        const double sample1 = (double) SDL_SwapFloatBE(src[1]);
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        src -= 2;
+        dst[7] = (float) sample1;
+        dst[6] = (float) sample0;
+        dst[5] = (float) (((3.0 * sample1) + last_sample1) * 0.25);
+        dst[4] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
+        dst[3] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[2] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) ((sample1 + (3.0 * last_sample1)) * 0.25);
+        dst[0] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32MSB_2c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_F32MSB, 2 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        const double sample1 = (double) SDL_SwapFloatBE(src[1]);
+        src += 8;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) ((sample1 + last_sample1) * 0.5);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        dst += 2;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32MSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_F32MSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 4;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 4;
+    const float *target = ((const float *) cvt->buf) - 4;
+    double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
+    double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
+    double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    while (dst > target) {
+        const double sample3 = (double) SDL_SwapFloatBE(src[3]);
+        const double sample2 = (double) SDL_SwapFloatBE(src[2]);
+        const double sample1 = (double) SDL_SwapFloatBE(src[1]);
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        src -= 4;
+        dst[7] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[6] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[5] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[4] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[3] = (float) sample3;
+        dst[2] = (float) sample2;
+        dst[1] = (float) sample1;
+        dst[0] = (float) sample0;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32MSB_4c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_F32MSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
+    double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
+    double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        const double sample1 = (double) SDL_SwapFloatBE(src[1]);
+        const double sample2 = (double) SDL_SwapFloatBE(src[2]);
+        const double sample3 = (double) SDL_SwapFloatBE(src[3]);
+        src += 8;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[2] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[3] = (float) ((sample3 + last_sample3) * 0.5);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32MSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_F32MSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 4;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 4;
+    const float *target = ((const float *) cvt->buf) - 4;
+    double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
+    double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
+    double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    while (dst > target) {
+        const double sample3 = (double) SDL_SwapFloatBE(src[3]);
+        const double sample2 = (double) SDL_SwapFloatBE(src[2]);
+        const double sample1 = (double) SDL_SwapFloatBE(src[1]);
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        src -= 4;
+        dst[15] = (float) sample3;
+        dst[14] = (float) sample2;
+        dst[13] = (float) sample1;
+        dst[12] = (float) sample0;
+        dst[11] = (float) (((3.0 * sample3) + last_sample3) * 0.25);
+        dst[10] = (float) (((3.0 * sample2) + last_sample2) * 0.25);
+        dst[9] = (float) (((3.0 * sample1) + last_sample1) * 0.25);
+        dst[8] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
+        dst[7] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[6] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[5] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[4] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[3] = (float) ((sample3 + (3.0 * last_sample3)) * 0.25);
+        dst[2] = (float) ((sample2 + (3.0 * last_sample2)) * 0.25);
+        dst[1] = (float) ((sample1 + (3.0 * last_sample1)) * 0.25);
+        dst[0] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32MSB_4c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_F32MSB, 4 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
+    double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
+    double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        const double sample1 = (double) SDL_SwapFloatBE(src[1]);
+        const double sample2 = (double) SDL_SwapFloatBE(src[2]);
+        const double sample3 = (double) SDL_SwapFloatBE(src[3]);
+        src += 16;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[2] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[3] = (float) ((sample3 + last_sample3) * 0.5);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        dst += 4;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32MSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_F32MSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 6;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 6;
+    const float *target = ((const float *) cvt->buf) - 6;
+    double last_sample5 = (double) SDL_SwapFloatBE(src[5]);
+    double last_sample4 = (double) SDL_SwapFloatBE(src[4]);
+    double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
+    double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
+    double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    while (dst > target) {
+        const double sample5 = (double) SDL_SwapFloatBE(src[5]);
+        const double sample4 = (double) SDL_SwapFloatBE(src[4]);
+        const double sample3 = (double) SDL_SwapFloatBE(src[3]);
+        const double sample2 = (double) SDL_SwapFloatBE(src[2]);
+        const double sample1 = (double) SDL_SwapFloatBE(src[1]);
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        src -= 6;
+        dst[11] = (float) ((sample5 + last_sample5) * 0.5);
+        dst[10] = (float) ((sample4 + last_sample4) * 0.5);
+        dst[9] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[8] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[7] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[6] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[5] = (float) sample5;
+        dst[4] = (float) sample4;
+        dst[3] = (float) sample3;
+        dst[2] = (float) sample2;
+        dst[1] = (float) sample1;
+        dst[0] = (float) sample0;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 12;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32MSB_6c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_F32MSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
+    double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
+    double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
+    double last_sample4 = (double) SDL_SwapFloatBE(src[4]);
+    double last_sample5 = (double) SDL_SwapFloatBE(src[5]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        const double sample1 = (double) SDL_SwapFloatBE(src[1]);
+        const double sample2 = (double) SDL_SwapFloatBE(src[2]);
+        const double sample3 = (double) SDL_SwapFloatBE(src[3]);
+        const double sample4 = (double) SDL_SwapFloatBE(src[4]);
+        const double sample5 = (double) SDL_SwapFloatBE(src[5]);
+        src += 12;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[2] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[3] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[4] = (float) ((sample4 + last_sample4) * 0.5);
+        dst[5] = (float) ((sample5 + last_sample5) * 0.5);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32MSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_F32MSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 6;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 6;
+    const float *target = ((const float *) cvt->buf) - 6;
+    double last_sample5 = (double) SDL_SwapFloatBE(src[5]);
+    double last_sample4 = (double) SDL_SwapFloatBE(src[4]);
+    double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
+    double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
+    double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    while (dst > target) {
+        const double sample5 = (double) SDL_SwapFloatBE(src[5]);
+        const double sample4 = (double) SDL_SwapFloatBE(src[4]);
+        const double sample3 = (double) SDL_SwapFloatBE(src[3]);
+        const double sample2 = (double) SDL_SwapFloatBE(src[2]);
+        const double sample1 = (double) SDL_SwapFloatBE(src[1]);
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        src -= 6;
+        dst[23] = (float) sample5;
+        dst[22] = (float) sample4;
+        dst[21] = (float) sample3;
+        dst[20] = (float) sample2;
+        dst[19] = (float) sample1;
+        dst[18] = (float) sample0;
+        dst[17] = (float) (((3.0 * sample5) + last_sample5) * 0.25);
+        dst[16] = (float) (((3.0 * sample4) + last_sample4) * 0.25);
+        dst[15] = (float) (((3.0 * sample3) + last_sample3) * 0.25);
+        dst[14] = (float) (((3.0 * sample2) + last_sample2) * 0.25);
+        dst[13] = (float) (((3.0 * sample1) + last_sample1) * 0.25);
+        dst[12] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
+        dst[11] = (float) ((sample5 + last_sample5) * 0.5);
+        dst[10] = (float) ((sample4 + last_sample4) * 0.5);
+        dst[9] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[8] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[7] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[6] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[5] = (float) ((sample5 + (3.0 * last_sample5)) * 0.25);
+        dst[4] = (float) ((sample4 + (3.0 * last_sample4)) * 0.25);
+        dst[3] = (float) ((sample3 + (3.0 * last_sample3)) * 0.25);
+        dst[2] = (float) ((sample2 + (3.0 * last_sample2)) * 0.25);
+        dst[1] = (float) ((sample1 + (3.0 * last_sample1)) * 0.25);
+        dst[0] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 24;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32MSB_6c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_F32MSB, 6 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
+    double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
+    double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
+    double last_sample4 = (double) SDL_SwapFloatBE(src[4]);
+    double last_sample5 = (double) SDL_SwapFloatBE(src[5]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        const double sample1 = (double) SDL_SwapFloatBE(src[1]);
+        const double sample2 = (double) SDL_SwapFloatBE(src[2]);
+        const double sample3 = (double) SDL_SwapFloatBE(src[3]);
+        const double sample4 = (double) SDL_SwapFloatBE(src[4]);
+        const double sample5 = (double) SDL_SwapFloatBE(src[5]);
+        src += 24;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[2] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[3] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[4] = (float) ((sample4 + last_sample4) * 0.5);
+        dst[5] = (float) ((sample5 + last_sample5) * 0.5);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        dst += 6;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32MSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x2) AUDIO_F32MSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 2;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 8;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 8;
+    const float *target = ((const float *) cvt->buf) - 8;
+    double last_sample7 = (double) SDL_SwapFloatBE(src[7]);
+    double last_sample6 = (double) SDL_SwapFloatBE(src[6]);
+    double last_sample5 = (double) SDL_SwapFloatBE(src[5]);
+    double last_sample4 = (double) SDL_SwapFloatBE(src[4]);
+    double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
+    double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
+    double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    while (dst > target) {
+        const double sample7 = (double) SDL_SwapFloatBE(src[7]);
+        const double sample6 = (double) SDL_SwapFloatBE(src[6]);
+        const double sample5 = (double) SDL_SwapFloatBE(src[5]);
+        const double sample4 = (double) SDL_SwapFloatBE(src[4]);
+        const double sample3 = (double) SDL_SwapFloatBE(src[3]);
+        const double sample2 = (double) SDL_SwapFloatBE(src[2]);
+        const double sample1 = (double) SDL_SwapFloatBE(src[1]);
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        src -= 8;
+        dst[15] = (float) ((sample7 + last_sample7) * 0.5);
+        dst[14] = (float) ((sample6 + last_sample6) * 0.5);
+        dst[13] = (float) ((sample5 + last_sample5) * 0.5);
+        dst[12] = (float) ((sample4 + last_sample4) * 0.5);
+        dst[11] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[10] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[9] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[8] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[7] = (float) sample7;
+        dst[6] = (float) sample6;
+        dst[5] = (float) sample5;
+        dst[4] = (float) sample4;
+        dst[3] = (float) sample3;
+        dst[2] = (float) sample2;
+        dst[1] = (float) sample1;
+        dst[0] = (float) sample0;
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 16;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32MSB_8c_x2(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x2) AUDIO_F32MSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 2;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
+    double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
+    double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
+    double last_sample4 = (double) SDL_SwapFloatBE(src[4]);
+    double last_sample5 = (double) SDL_SwapFloatBE(src[5]);
+    double last_sample6 = (double) SDL_SwapFloatBE(src[6]);
+    double last_sample7 = (double) SDL_SwapFloatBE(src[7]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        const double sample1 = (double) SDL_SwapFloatBE(src[1]);
+        const double sample2 = (double) SDL_SwapFloatBE(src[2]);
+        const double sample3 = (double) SDL_SwapFloatBE(src[3]);
+        const double sample4 = (double) SDL_SwapFloatBE(src[4]);
+        const double sample5 = (double) SDL_SwapFloatBE(src[5]);
+        const double sample6 = (double) SDL_SwapFloatBE(src[6]);
+        const double sample7 = (double) SDL_SwapFloatBE(src[7]);
+        src += 16;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[2] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[3] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[4] = (float) ((sample4 + last_sample4) * 0.5);
+        dst[5] = (float) ((sample5 + last_sample5) * 0.5);
+        dst[6] = (float) ((sample6 + last_sample6) * 0.5);
+        dst[7] = (float) ((sample7 + last_sample7) * 0.5);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Upsample_F32MSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Upsample (x4) AUDIO_F32MSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt * 4;
+    float *dst = ((float *) (cvt->buf + dstsize)) - 8;
+    const float *src = ((float *) (cvt->buf + cvt->len_cvt)) - 8;
+    const float *target = ((const float *) cvt->buf) - 8;
+    double last_sample7 = (double) SDL_SwapFloatBE(src[7]);
+    double last_sample6 = (double) SDL_SwapFloatBE(src[6]);
+    double last_sample5 = (double) SDL_SwapFloatBE(src[5]);
+    double last_sample4 = (double) SDL_SwapFloatBE(src[4]);
+    double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
+    double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
+    double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    while (dst > target) {
+        const double sample7 = (double) SDL_SwapFloatBE(src[7]);
+        const double sample6 = (double) SDL_SwapFloatBE(src[6]);
+        const double sample5 = (double) SDL_SwapFloatBE(src[5]);
+        const double sample4 = (double) SDL_SwapFloatBE(src[4]);
+        const double sample3 = (double) SDL_SwapFloatBE(src[3]);
+        const double sample2 = (double) SDL_SwapFloatBE(src[2]);
+        const double sample1 = (double) SDL_SwapFloatBE(src[1]);
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        src -= 8;
+        dst[31] = (float) sample7;
+        dst[30] = (float) sample6;
+        dst[29] = (float) sample5;
+        dst[28] = (float) sample4;
+        dst[27] = (float) sample3;
+        dst[26] = (float) sample2;
+        dst[25] = (float) sample1;
+        dst[24] = (float) sample0;
+        dst[23] = (float) (((3.0 * sample7) + last_sample7) * 0.25);
+        dst[22] = (float) (((3.0 * sample6) + last_sample6) * 0.25);
+        dst[21] = (float) (((3.0 * sample5) + last_sample5) * 0.25);
+        dst[20] = (float) (((3.0 * sample4) + last_sample4) * 0.25);
+        dst[19] = (float) (((3.0 * sample3) + last_sample3) * 0.25);
+        dst[18] = (float) (((3.0 * sample2) + last_sample2) * 0.25);
+        dst[17] = (float) (((3.0 * sample1) + last_sample1) * 0.25);
+        dst[16] = (float) (((3.0 * sample0) + last_sample0) * 0.25);
+        dst[15] = (float) ((sample7 + last_sample7) * 0.5);
+        dst[14] = (float) ((sample6 + last_sample6) * 0.5);
+        dst[13] = (float) ((sample5 + last_sample5) * 0.5);
+        dst[12] = (float) ((sample4 + last_sample4) * 0.5);
+        dst[11] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[10] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[9] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[8] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[7] = (float) ((sample7 + (3.0 * last_sample7)) * 0.25);
+        dst[6] = (float) ((sample6 + (3.0 * last_sample6)) * 0.25);
+        dst[5] = (float) ((sample5 + (3.0 * last_sample5)) * 0.25);
+        dst[4] = (float) ((sample4 + (3.0 * last_sample4)) * 0.25);
+        dst[3] = (float) ((sample3 + (3.0 * last_sample3)) * 0.25);
+        dst[2] = (float) ((sample2 + (3.0 * last_sample2)) * 0.25);
+        dst[1] = (float) ((sample1 + (3.0 * last_sample1)) * 0.25);
+        dst[0] = (float) ((sample0 + (3.0 * last_sample0)) * 0.25);
+        last_sample7 = sample7;
+        last_sample6 = sample6;
+        last_sample5 = sample5;
+        last_sample4 = sample4;
+        last_sample3 = sample3;
+        last_sample2 = sample2;
+        last_sample1 = sample1;
+        last_sample0 = sample0;
+        dst -= 32;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+static void SDLCALL
+SDL_Downsample_F32MSB_8c_x4(SDL_AudioCVT * cvt, SDL_AudioFormat format)
+{
+#if DEBUG_CONVERT
+    fprintf(stderr, "Downsample (x4) AUDIO_F32MSB, 8 channels.\n");
+#endif
+
+    const int srcsize = cvt->len_cvt;
+    const int dstsize = cvt->len_cvt / 4;
+    float *dst = (float *) cvt->buf;
+    const float *src = (float *) cvt->buf;
+    const float *target = (const float *) (cvt->buf + dstsize);
+    double last_sample0 = (double) SDL_SwapFloatBE(src[0]);
+    double last_sample1 = (double) SDL_SwapFloatBE(src[1]);
+    double last_sample2 = (double) SDL_SwapFloatBE(src[2]);
+    double last_sample3 = (double) SDL_SwapFloatBE(src[3]);
+    double last_sample4 = (double) SDL_SwapFloatBE(src[4]);
+    double last_sample5 = (double) SDL_SwapFloatBE(src[5]);
+    double last_sample6 = (double) SDL_SwapFloatBE(src[6]);
+    double last_sample7 = (double) SDL_SwapFloatBE(src[7]);
+    while (dst < target) {
+        const double sample0 = (double) SDL_SwapFloatBE(src[0]);
+        const double sample1 = (double) SDL_SwapFloatBE(src[1]);
+        const double sample2 = (double) SDL_SwapFloatBE(src[2]);
+        const double sample3 = (double) SDL_SwapFloatBE(src[3]);
+        const double sample4 = (double) SDL_SwapFloatBE(src[4]);
+        const double sample5 = (double) SDL_SwapFloatBE(src[5]);
+        const double sample6 = (double) SDL_SwapFloatBE(src[6]);
+        const double sample7 = (double) SDL_SwapFloatBE(src[7]);
+        src += 32;
+        dst[0] = (float) ((sample0 + last_sample0) * 0.5);
+        dst[1] = (float) ((sample1 + last_sample1) * 0.5);
+        dst[2] = (float) ((sample2 + last_sample2) * 0.5);
+        dst[3] = (float) ((sample3 + last_sample3) * 0.5);
+        dst[4] = (float) ((sample4 + last_sample4) * 0.5);
+        dst[5] = (float) ((sample5 + last_sample5) * 0.5);
+        dst[6] = (float) ((sample6 + last_sample6) * 0.5);
+        dst[7] = (float) ((sample7 + last_sample7) * 0.5);
+        last_sample0 = sample0;
+        last_sample1 = sample1;
+        last_sample2 = sample2;
+        last_sample3 = sample3;
+        last_sample4 = sample4;
+        last_sample5 = sample5;
+        last_sample6 = sample6;
+        last_sample7 = sample7;
+        dst += 8;
+    }
+
+    cvt->len_cvt = dstsize;
+    if (cvt->filters[++cvt->filter_index]) {
+        cvt->filters[cvt->filter_index] (cvt, format);
+    }
+}
+
+#endif  /* !LESS_RESAMPLERS */
+#endif  /* !NO_RESAMPLERS */
+
+
+const SDL_AudioRateFilters sdl_audio_rate_filters[] =
+{
+#if !NO_RESAMPLERS
+    { AUDIO_U8, 1, 0, 0, SDL_Downsample_U8_1c },
+    { AUDIO_U8, 1, 1, 0, SDL_Upsample_U8_1c },
+    { AUDIO_U8, 2, 0, 0, SDL_Downsample_U8_2c },
+    { AUDIO_U8, 2, 1, 0, SDL_Upsample_U8_2c },
+    { AUDIO_U8, 4, 0, 0, SDL_Downsample_U8_4c },
+    { AUDIO_U8, 4, 1, 0, SDL_Upsample_U8_4c },
+    { AUDIO_U8, 6, 0, 0, SDL_Downsample_U8_6c },
+    { AUDIO_U8, 6, 1, 0, SDL_Upsample_U8_6c },
+    { AUDIO_U8, 8, 0, 0, SDL_Downsample_U8_8c },
+    { AUDIO_U8, 8, 1, 0, SDL_Upsample_U8_8c },
+    { AUDIO_S8, 1, 0, 0, SDL_Downsample_S8_1c },
+    { AUDIO_S8, 1, 1, 0, SDL_Upsample_S8_1c },
+    { AUDIO_S8, 2, 0, 0, SDL_Downsample_S8_2c },
+    { AUDIO_S8, 2, 1, 0, SDL_Upsample_S8_2c },
+    { AUDIO_S8, 4, 0, 0, SDL_Downsample_S8_4c },
+    { AUDIO_S8, 4, 1, 0, SDL_Upsample_S8_4c },
+    { AUDIO_S8, 6, 0, 0, SDL_Downsample_S8_6c },
+    { AUDIO_S8, 6, 1, 0, SDL_Upsample_S8_6c },
+    { AUDIO_S8, 8, 0, 0, SDL_Downsample_S8_8c },
+    { AUDIO_S8, 8, 1, 0, SDL_Upsample_S8_8c },
+    { AUDIO_U16LSB, 1, 0, 0, SDL_Downsample_U16LSB_1c },
+    { AUDIO_U16LSB, 1, 1, 0, SDL_Upsample_U16LSB_1c },
+    { AUDIO_U16LSB, 2, 0, 0, SDL_Downsample_U16LSB_2c },
+    { AUDIO_U16LSB, 2, 1, 0, SDL_Upsample_U16LSB_2c },
+    { AUDIO_U16LSB, 4, 0, 0, SDL_Downsample_U16LSB_4c },
+    { AUDIO_U16LSB, 4, 1, 0, SDL_Upsample_U16LSB_4c },
+    { AUDIO_U16LSB, 6, 0, 0, SDL_Downsample_U16LSB_6c },
+    { AUDIO_U16LSB, 6, 1, 0, SDL_Upsample_U16LSB_6c },
+    { AUDIO_U16LSB, 8, 0, 0, SDL_Downsample_U16LSB_8c },
+    { AUDIO_U16LSB, 8, 1, 0, SDL_Upsample_U16LSB_8c },
+    { AUDIO_S16LSB, 1, 0, 0, SDL_Downsample_S16LSB_1c },
+    { AUDIO_S16LSB, 1, 1, 0, SDL_Upsample_S16LSB_1c },
+    { AUDIO_S16LSB, 2, 0, 0, SDL_Downsample_S16LSB_2c },
+    { AUDIO_S16LSB, 2, 1, 0, SDL_Upsample_S16LSB_2c },
+    { AUDIO_S16LSB, 4, 0, 0, SDL_Downsample_S16LSB_4c },
+    { AUDIO_S16LSB, 4, 1, 0, SDL_Upsample_S16LSB_4c },
+    { AUDIO_S16LSB, 6, 0, 0, SDL_Downsample_S16LSB_6c },
+    { AUDIO_S16LSB, 6, 1, 0, SDL_Upsample_S16LSB_6c },
+    { AUDIO_S16LSB, 8, 0, 0, SDL_Downsample_S16LSB_8c },
+    { AUDIO_S16LSB, 8, 1, 0, SDL_Upsample_S16LSB_8c },
+    { AUDIO_U16MSB, 1, 0, 0, SDL_Downsample_U16MSB_1c },
+    { AUDIO_U16MSB, 1, 1, 0, SDL_Upsample_U16MSB_1c },
+    { AUDIO_U16MSB, 2, 0, 0, SDL_Downsample_U16MSB_2c },
+    { AUDIO_U16MSB, 2, 1, 0, SDL_Upsample_U16MSB_2c },
+    { AUDIO_U16MSB, 4, 0, 0, SDL_Downsample_U16MSB_4c },
+    { AUDIO_U16MSB, 4, 1, 0, SDL_Upsample_U16MSB_4c },
+    { AUDIO_U16MSB, 6, 0, 0, SDL_Downsample_U16MSB_6c },
+    { AUDIO_U16MSB, 6, 1, 0, SDL_Upsample_U16MSB_6c },
+    { AUDIO_U16MSB, 8, 0, 0, SDL_Downsample_U16MSB_8c },
+    { AUDIO_U16MSB, 8, 1, 0, SDL_Upsample_U16MSB_8c },
+    { AUDIO_S16MSB, 1, 0, 0, SDL_Downsample_S16MSB_1c },
+    { AUDIO_S16MSB, 1, 1, 0, SDL_Upsample_S16MSB_1c },
+    { AUDIO_S16MSB, 2, 0, 0, SDL_Downsample_S16MSB_2c },
+    { AUDIO_S16MSB, 2, 1, 0, SDL_Upsample_S16MSB_2c },
+    { AUDIO_S16MSB, 4, 0, 0, SDL_Downsample_S16MSB_4c },
+    { AUDIO_S16MSB, 4, 1, 0, SDL_Upsample_S16MSB_4c },
+    { AUDIO_S16MSB, 6, 0, 0, SDL_Downsample_S16MSB_6c },
+    { AUDIO_S16MSB, 6, 1, 0, SDL_Upsample_S16MSB_6c },
+    { AUDIO_S16MSB, 8, 0, 0, SDL_Downsample_S16MSB_8c },
+    { AUDIO_S16MSB, 8, 1, 0, SDL_Upsample_S16MSB_8c },
+    { AUDIO_S32LSB, 1, 0, 0, SDL_Downsample_S32LSB_1c },
+    { AUDIO_S32LSB, 1, 1, 0, SDL_Upsample_S32LSB_1c },
+    { AUDIO_S32LSB, 2, 0, 0, SDL_Downsample_S32LSB_2c },
+    { AUDIO_S32LSB, 2, 1, 0, SDL_Upsample_S32LSB_2c },
+    { AUDIO_S32LSB, 4, 0, 0, SDL_Downsample_S32LSB_4c },
+    { AUDIO_S32LSB, 4, 1, 0, SDL_Upsample_S32LSB_4c },
+    { AUDIO_S32LSB, 6, 0, 0, SDL_Downsample_S32LSB_6c },
+    { AUDIO_S32LSB, 6, 1, 0, SDL_Upsample_S32LSB_6c },
+    { AUDIO_S32LSB, 8, 0, 0, SDL_Downsample_S32LSB_8c },
+    { AUDIO_S32LSB, 8, 1, 0, SDL_Upsample_S32LSB_8c },
+    { AUDIO_S32MSB, 1, 0, 0, SDL_Downsample_S32MSB_1c },
+    { AUDIO_S32MSB, 1, 1, 0, SDL_Upsample_S32MSB_1c },
+    { AUDIO_S32MSB, 2, 0, 0, SDL_Downsample_S32MSB_2c },
+    { AUDIO_S32MSB, 2, 1, 0, SDL_Upsample_S32MSB_2c },
+    { AUDIO_S32MSB, 4, 0, 0, SDL_Downsample_S32MSB_4c },
+    { AUDIO_S32MSB, 4, 1, 0, SDL_Upsample_S32MSB_4c },
+    { AUDIO_S32MSB, 6, 0, 0, SDL_Downsample_S32MSB_6c },
+    { AUDIO_S32MSB, 6, 1, 0, SDL_Upsample_S32MSB_6c },
+    { AUDIO_S32MSB, 8, 0, 0, SDL_Downsample_S32MSB_8c },
+    { AUDIO_S32MSB, 8, 1, 0, SDL_Upsample_S32MSB_8c },
+    { AUDIO_F32LSB, 1, 0, 0, SDL_Downsample_F32LSB_1c },
+    { AUDIO_F32LSB, 1, 1, 0, SDL_Upsample_F32LSB_1c },
+    { AUDIO_F32LSB, 2, 0, 0, SDL_Downsample_F32LSB_2c },
+    { AUDIO_F32LSB, 2, 1, 0, SDL_Upsample_F32LSB_2c },
+    { AUDIO_F32LSB, 4, 0, 0, SDL_Downsample_F32LSB_4c },
+    { AUDIO_F32LSB, 4, 1, 0, SDL_Upsample_F32LSB_4c },
+    { AUDIO_F32LSB, 6, 0, 0, SDL_Downsample_F32LSB_6c },
+    { AUDIO_F32LSB, 6, 1, 0, SDL_Upsample_F32LSB_6c },
+    { AUDIO_F32LSB, 8, 0, 0, SDL_Downsample_F32LSB_8c },
+    { AUDIO_F32LSB, 8, 1, 0, SDL_Upsample_F32LSB_8c },
+    { AUDIO_F32MSB, 1, 0, 0, SDL_Downsample_F32MSB_1c },
+    { AUDIO_F32MSB, 1, 1, 0, SDL_Upsample_F32MSB_1c },
+    { AUDIO_F32MSB, 2, 0, 0, SDL_Downsample_F32MSB_2c },
+    { AUDIO_F32MSB, 2, 1, 0, SDL_Upsample_F32MSB_2c },
+    { AUDIO_F32MSB, 4, 0, 0, SDL_Downsample_F32MSB_4c },
+    { AUDIO_F32MSB, 4, 1, 0, SDL_Upsample_F32MSB_4c },
+    { AUDIO_F32MSB, 6, 0, 0, SDL_Downsample_F32MSB_6c },
+    { AUDIO_F32MSB, 6, 1, 0, SDL_Upsample_F32MSB_6c },
+    { AUDIO_F32MSB, 8, 0, 0, SDL_Downsample_F32MSB_8c },
+    { AUDIO_F32MSB, 8, 1, 0, SDL_Upsample_F32MSB_8c },
+#if !LESS_RESAMPLERS
+    { AUDIO_U8, 1, 0, 2, SDL_Downsample_U8_1c_x2 },
+    { AUDIO_U8, 1, 1, 2, SDL_Upsample_U8_1c_x2 },
+    { AUDIO_U8, 1, 0, 4, SDL_Downsample_U8_1c_x4 },
+    { AUDIO_U8, 1, 1, 4, SDL_Upsample_U8_1c_x4 },
+    { AUDIO_U8, 2, 0, 2, SDL_Downsample_U8_2c_x2 },
+    { AUDIO_U8, 2, 1, 2, SDL_Upsample_U8_2c_x2 },
+    { AUDIO_U8, 2, 0, 4, SDL_Downsample_U8_2c_x4 },
+    { AUDIO_U8, 2, 1, 4, SDL_Upsample_U8_2c_x4 },
+    { AUDIO_U8, 4, 0, 2, SDL_Downsample_U8_4c_x2 },
+    { AUDIO_U8, 4, 1, 2, SDL_Upsample_U8_4c_x2 },
+    { AUDIO_U8, 4, 0, 4, SDL_Downsample_U8_4c_x4 },
+    { AUDIO_U8, 4, 1, 4, SDL_Upsample_U8_4c_x4 },
+    { AUDIO_U8, 6, 0, 2, SDL_Downsample_U8_6c_x2 },
+    { AUDIO_U8, 6, 1, 2, SDL_Upsample_U8_6c_x2 },
+    { AUDIO_U8, 6, 0, 4, SDL_Downsample_U8_6c_x4 },
+    { AUDIO_U8, 6, 1, 4, SDL_Upsample_U8_6c_x4 },
+    { AUDIO_U8, 8, 0, 2, SDL_Downsample_U8_8c_x2 },
+    { AUDIO_U8, 8, 1, 2, SDL_Upsample_U8_8c_x2 },
+    { AUDIO_U8, 8, 0, 4, SDL_Downsample_U8_8c_x4 },
+    { AUDIO_U8, 8, 1, 4, SDL_Upsample_U8_8c_x4 },
+    { AUDIO_S8, 1, 0, 2, SDL_Downsample_S8_1c_x2 },
+    { AUDIO_S8, 1, 1, 2, SDL_Upsample_S8_1c_x2 },
+    { AUDIO_S8, 1, 0, 4, SDL_Downsample_S8_1c_x4 },
+    { AUDIO_S8, 1, 1, 4, SDL_Upsample_S8_1c_x4 },
+    { AUDIO_S8, 2, 0, 2, SDL_Downsample_S8_2c_x2 },
+    { AUDIO_S8, 2, 1, 2, SDL_Upsample_S8_2c_x2 },
+    { AUDIO_S8, 2, 0, 4, SDL_Downsample_S8_2c_x4 },
+    { AUDIO_S8, 2, 1, 4, SDL_Upsample_S8_2c_x4 },
+    { AUDIO_S8, 4, 0, 2, SDL_Downsample_S8_4c_x2 },
+    { AUDIO_S8, 4, 1, 2, SDL_Upsample_S8_4c_x2 },
+    { AUDIO_S8, 4, 0, 4, SDL_Downsample_S8_4c_x4 },
+    { AUDIO_S8, 4, 1, 4, SDL_Upsample_S8_4c_x4 },
+    { AUDIO_S8, 6, 0, 2, SDL_Downsample_S8_6c_x2 },
+    { AUDIO_S8, 6, 1, 2, SDL_Upsample_S8_6c_x2 },
+    { AUDIO_S8, 6, 0, 4, SDL_Downsample_S8_6c_x4 },
+    { AUDIO_S8, 6, 1, 4, SDL_Upsample_S8_6c_x4 },
+    { AUDIO_S8, 8, 0, 2, SDL_Downsample_S8_8c_x2 },
+    { AUDIO_S8, 8, 1, 2, SDL_Upsample_S8_8c_x2 },
+    { AUDIO_S8, 8, 0, 4, SDL_Downsample_S8_8c_x4 },
+    { AUDIO_S8, 8, 1, 4, SDL_Upsample_S8_8c_x4 },
+    { AUDIO_U16LSB, 1, 0, 2, SDL_Downsample_U16LSB_1c_x2 },
+    { AUDIO_U16LSB, 1, 1, 2, SDL_Upsample_U16LSB_1c_x2 },
+    { AUDIO_U16LSB, 1, 0, 4, SDL_Downsample_U16LSB_1c_x4 },
+    { AUDIO_U16LSB, 1, 1, 4, SDL_Upsample_U16LSB_1c_x4 },
+    { AUDIO_U16LSB, 2, 0, 2, SDL_Downsample_U16LSB_2c_x2 },
+    { AUDIO_U16LSB, 2, 1, 2, SDL_Upsample_U16LSB_2c_x2 },
+    { AUDIO_U16LSB, 2, 0, 4, SDL_Downsample_U16LSB_2c_x4 },
+    { AUDIO_U16LSB, 2, 1, 4, SDL_Upsample_U16LSB_2c_x4 },
+    { AUDIO_U16LSB, 4, 0, 2, SDL_Downsample_U16LSB_4c_x2 },
+    { AUDIO_U16LSB, 4, 1, 2, SDL_Upsample_U16LSB_4c_x2 },
+    { AUDIO_U16LSB, 4, 0, 4, SDL_Downsample_U16LSB_4c_x4 },
+    { AUDIO_U16LSB, 4, 1, 4, SDL_Upsample_U16LSB_4c_x4 },
+    { AUDIO_U16LSB, 6, 0, 2, SDL_Downsample_U16LSB_6c_x2 },
+    { AUDIO_U16LSB, 6, 1, 2, SDL_Upsample_U16LSB_6c_x2 },
+    { AUDIO_U16LSB, 6, 0, 4, SDL_Downsample_U16LSB_6c_x4 },
+    { AUDIO_U16LSB, 6, 1, 4, SDL_Upsample_U16LSB_6c_x4 },
+    { AUDIO_U16LSB, 8, 0, 2, SDL_Downsample_U16LSB_8c_x2 },
+    { AUDIO_U16LSB, 8, 1, 2, SDL_Upsample_U16LSB_8c_x2 },
+    { AUDIO_U16LSB, 8, 0, 4, SDL_Downsample_U16LSB_8c_x4 },
+    { AUDIO_U16LSB, 8, 1, 4, SDL_Upsample_U16LSB_8c_x4 },
+    { AUDIO_S16LSB, 1, 0, 2, SDL_Downsample_S16LSB_1c_x2 },
+    { AUDIO_S16LSB, 1, 1, 2, SDL_Upsample_S16LSB_1c_x2 },
+    { AUDIO_S16LSB, 1, 0, 4, SDL_Downsample_S16LSB_1c_x4 },
+    { AUDIO_S16LSB, 1, 1, 4, SDL_Upsample_S16LSB_1c_x4 },
+    { AUDIO_S16LSB, 2, 0, 2, SDL_Downsample_S16LSB_2c_x2 },
+    { AUDIO_S16LSB, 2, 1, 2, SDL_Upsample_S16LSB_2c_x2 },
+    { AUDIO_S16LSB, 2, 0, 4, SDL_Downsample_S16LSB_2c_x4 },
+    { AUDIO_S16LSB, 2, 1, 4, SDL_Upsample_S16LSB_2c_x4 },
+    { AUDIO_S16LSB, 4, 0, 2, SDL_Downsample_S16LSB_4c_x2 },
+    { AUDIO_S16LSB, 4, 1, 2, SDL_Upsample_S16LSB_4c_x2 },
+    { AUDIO_S16LSB, 4, 0, 4, SDL_Downsample_S16LSB_4c_x4 },
+    { AUDIO_S16LSB, 4, 1, 4, SDL_Upsample_S16LSB_4c_x4 },
+    { AUDIO_S16LSB, 6, 0, 2, SDL_Downsample_S16LSB_6c_x2 },
+    { AUDIO_S16LSB, 6, 1, 2, SDL_Upsample_S16LSB_6c_x2 },
+    { AUDIO_S16LSB, 6, 0, 4, SDL_Downsample_S16LSB_6c_x4 },
+    { AUDIO_S16LSB, 6, 1, 4, SDL_Upsample_S16LSB_6c_x4 },
+    { AUDIO_S16LSB, 8, 0, 2, SDL_Downsample_S16LSB_8c_x2 },
+    { AUDIO_S16LSB, 8, 1, 2, SDL_Upsample_S16LSB_8c_x2 },
+    { AUDIO_S16LSB, 8, 0, 4, SDL_Downsample_S16LSB_8c_x4 },
+    { AUDIO_S16LSB, 8, 1, 4, SDL_Upsample_S16LSB_8c_x4 },
+    { AUDIO_U16MSB, 1, 0, 2, SDL_Downsample_U16MSB_1c_x2 },
+    { AUDIO_U16MSB, 1, 1, 2, SDL_Upsample_U16MSB_1c_x2 },
+    { AUDIO_U16MSB, 1, 0, 4, SDL_Downsample_U16MSB_1c_x4 },
+    { AUDIO_U16MSB, 1, 1, 4, SDL_Upsample_U16MSB_1c_x4 },
+    { AUDIO_U16MSB, 2, 0, 2, SDL_Downsample_U16MSB_2c_x2 },
+    { AUDIO_U16MSB, 2, 1, 2, SDL_Upsample_U16MSB_2c_x2 },
+    { AUDIO_U16MSB, 2, 0, 4, SDL_Downsample_U16MSB_2c_x4 },
+    { AUDIO_U16MSB, 2, 1, 4, SDL_Upsample_U16MSB_2c_x4 },
+    { AUDIO_U16MSB, 4, 0, 2, SDL_Downsample_U16MSB_4c_x2 },
+    { AUDIO_U16MSB, 4, 1, 2, SDL_Upsample_U16MSB_4c_x2 },
+    { AUDIO_U16MSB, 4, 0, 4, SDL_Downsample_U16MSB_4c_x4 },
+    { AUDIO_U16MSB, 4, 1, 4, SDL_Upsample_U16MSB_4c_x4 },
+    { AUDIO_U16MSB, 6, 0, 2, SDL_Downsample_U16MSB_6c_x2 },
+    { AUDIO_U16MSB, 6, 1, 2, SDL_Upsample_U16MSB_6c_x2 },
+    { AUDIO_U16MSB, 6, 0, 4, SDL_Downsample_U16MSB_6c_x4 },
+    { AUDIO_U16MSB, 6, 1, 4, SDL_Upsample_U16MSB_6c_x4 },
+    { AUDIO_U16MSB, 8, 0, 2, SDL_Downsample_U16MSB_8c_x2 },
+    { AUDIO_U16MSB, 8, 1, 2, SDL_Upsample_U16MSB_8c_x2 },
+    { AUDIO_U16MSB, 8, 0, 4, SDL_Downsample_U16MSB_8c_x4 },
+    { AUDIO_U16MSB, 8, 1, 4, SDL_Upsample_U16MSB_8c_x4 },
+    { AUDIO_S16MSB, 1, 0, 2, SDL_Downsample_S16MSB_1c_x2 },
+    { AUDIO_S16MSB, 1, 1, 2, SDL_Upsample_S16MSB_1c_x2 },
+    { AUDIO_S16MSB, 1, 0, 4, SDL_Downsample_S16MSB_1c_x4 },
+    { AUDIO_S16MSB, 1, 1, 4, SDL_Upsample_S16MSB_1c_x4 },
+    { AUDIO_S16MSB, 2, 0, 2, SDL_Downsample_S16MSB_2c_x2 },
+    { AUDIO_S16MSB, 2, 1, 2, SDL_Upsample_S16MSB_2c_x2 },
+    { AUDIO_S16MSB, 2, 0, 4, SDL_Downsample_S16MSB_2c_x4 },
+    { AUDIO_S16MSB, 2, 1, 4, SDL_Upsample_S16MSB_2c_x4 },
+    { AUDIO_S16MSB, 4, 0, 2, SDL_Downsample_S16MSB_4c_x2 },
+    { AUDIO_S16MSB, 4, 1, 2, SDL_Upsample_S16MSB_4c_x2 },
+    { AUDIO_S16MSB, 4, 0, 4, SDL_Downsample_S16MSB_4c_x4 },
+    { AUDIO_S16MSB, 4, 1, 4, SDL_Upsample_S16MSB_4c_x4 },
+    { AUDIO_S16MSB, 6, 0, 2, SDL_Downsample_S16MSB_6c_x2 },
+    { AUDIO_S16MSB, 6, 1, 2, SDL_Upsample_S16MSB_6c_x2 },
+    { AUDIO_S16MSB, 6, 0, 4, SDL_Downsample_S16MSB_6c_x4 },
+    { AUDIO_S16MSB, 6, 1, 4, SDL_Upsample_S16MSB_6c_x4 },
+    { AUDIO_S16MSB, 8, 0, 2, SDL_Downsample_S16MSB_8c_x2 },
+    { AUDIO_S16MSB, 8, 1, 2, SDL_Upsample_S16MSB_8c_x2 },
+    { AUDIO_S16MSB, 8, 0, 4, SDL_Downsample_S16MSB_8c_x4 },
+    { AUDIO_S16MSB, 8, 1, 4, SDL_Upsample_S16MSB_8c_x4 },
+    { AUDIO_S32LSB, 1, 0, 2, SDL_Downsample_S32LSB_1c_x2 },
+    { AUDIO_S32LSB, 1, 1, 2, SDL_Upsample_S32LSB_1c_x2 },
+    { AUDIO_S32LSB, 1, 0, 4, SDL_Downsample_S32LSB_1c_x4 },
+    { AUDIO_S32LSB, 1, 1, 4, SDL_Upsample_S32LSB_1c_x4 },
+    { AUDIO_S32LSB, 2, 0, 2, SDL_Downsample_S32LSB_2c_x2 },
+    { AUDIO_S32LSB, 2, 1, 2, SDL_Upsample_S32LSB_2c_x2 },
+    { AUDIO_S32LSB, 2, 0, 4, SDL_Downsample_S32LSB_2c_x4 },
+    { AUDIO_S32LSB, 2, 1, 4, SDL_Upsample_S32LSB_2c_x4 },
+    { AUDIO_S32LSB, 4, 0, 2, SDL_Downsample_S32LSB_4c_x2 },
+    { AUDIO_S32LSB, 4, 1, 2, SDL_Upsample_S32LSB_4c_x2 },
+    { AUDIO_S32LSB, 4, 0, 4, SDL_Downsample_S32LSB_4c_x4 },
+    { AUDIO_S32LSB, 4, 1, 4, SDL_Upsample_S32LSB_4c_x4 },
+    { AUDIO_S32LSB, 6, 0, 2, SDL_Downsample_S32LSB_6c_x2 },
+    { AUDIO_S32LSB, 6, 1, 2, SDL_Upsample_S32LSB_6c_x2 },
+    { AUDIO_S32LSB, 6, 0, 4, SDL_Downsample_S32LSB_6c_x4 },
+    { AUDIO_S32LSB, 6, 1, 4, SDL_Upsample_S32LSB_6c_x4 },
+    { AUDIO_S32LSB, 8, 0, 2, SDL_Downsample_S32LSB_8c_x2 },
+    { AUDIO_S32LSB, 8, 1, 2, SDL_Upsample_S32LSB_8c_x2 },
+    { AUDIO_S32LSB, 8, 0, 4, SDL_Downsample_S32LSB_8c_x4 },
+    { AUDIO_S32LSB, 8, 1, 4, SDL_Upsample_S32LSB_8c_x4 },
+    { AUDIO_S32MSB, 1, 0, 2, SDL_Downsample_S32MSB_1c_x2 },
+    { AUDIO_S32MSB, 1, 1, 2, SDL_Upsample_S32MSB_1c_x2 },
+    { AUDIO_S32MSB, 1, 0, 4, SDL_Downsample_S32MSB_1c_x4 },
+    { AUDIO_S32MSB, 1, 1, 4, SDL_Upsample_S32MSB_1c_x4 },
+    { AUDIO_S32MSB, 2, 0, 2, SDL_Downsample_S32MSB_2c_x2 },
+    { AUDIO_S32MSB, 2, 1, 2, SDL_Upsample_S32MSB_2c_x2 },
+    { AUDIO_S32MSB, 2, 0, 4, SDL_Downsample_S32MSB_2c_x4 },
+    { AUDIO_S32MSB, 2, 1, 4, SDL_Upsample_S32MSB_2c_x4 },
+    { AUDIO_S32MSB, 4, 0, 2, SDL_Downsample_S32MSB_4c_x2 },
+    { AUDIO_S32MSB, 4, 1, 2, SDL_Upsample_S32MSB_4c_x2 },
+    { AUDIO_S32MSB, 4, 0, 4, SDL_Downsample_S32MSB_4c_x4 },
+    { AUDIO_S32MSB, 4, 1, 4, SDL_Upsample_S32MSB_4c_x4 },
+    { AUDIO_S32MSB, 6, 0, 2, SDL_Downsample_S32MSB_6c_x2 },
+    { AUDIO_S32MSB, 6, 1, 2, SDL_Upsample_S32MSB_6c_x2 },
+    { AUDIO_S32MSB, 6, 0, 4, SDL_Downsample_S32MSB_6c_x4 },
+    { AUDIO_S32MSB, 6, 1, 4, SDL_Upsample_S32MSB_6c_x4 },
+    { AUDIO_S32MSB, 8, 0, 2, SDL_Downsample_S32MSB_8c_x2 },
+    { AUDIO_S32MSB, 8, 1, 2, SDL_Upsample_S32MSB_8c_x2 },
+    { AUDIO_S32MSB, 8, 0, 4, SDL_Downsample_S32MSB_8c_x4 },
+    { AUDIO_S32MSB, 8, 1, 4, SDL_Upsample_S32MSB_8c_x4 },
+    { AUDIO_F32LSB, 1, 0, 2, SDL_Downsample_F32LSB_1c_x2 },
+    { AUDIO_F32LSB, 1, 1, 2, SDL_Upsample_F32LSB_1c_x2 },
+    { AUDIO_F32LSB, 1, 0, 4, SDL_Downsample_F32LSB_1c_x4 },
+    { AUDIO_F32LSB, 1, 1, 4, SDL_Upsample_F32LSB_1c_x4 },
+    { AUDIO_F32LSB, 2, 0, 2, SDL_Downsample_F32LSB_2c_x2 },
+    { AUDIO_F32LSB, 2, 1, 2, SDL_Upsample_F32LSB_2c_x2 },
+    { AUDIO_F32LSB, 2, 0, 4, SDL_Downsample_F32LSB_2c_x4 },
+    { AUDIO_F32LSB, 2, 1, 4, SDL_Upsample_F32LSB_2c_x4 },
+    { AUDIO_F32LSB, 4, 0, 2, SDL_Downsample_F32LSB_4c_x2 },
+    { AUDIO_F32LSB, 4, 1, 2, SDL_Upsample_F32LSB_4c_x2 },
+    { AUDIO_F32LSB, 4, 0, 4, SDL_Downsample_F32LSB_4c_x4 },
+    { AUDIO_F32LSB, 4, 1, 4, SDL_Upsample_F32LSB_4c_x4 },
+    { AUDIO_F32LSB, 6, 0, 2, SDL_Downsample_F32LSB_6c_x2 },
+    { AUDIO_F32LSB, 6, 1, 2, SDL_Upsample_F32LSB_6c_x2 },
+    { AUDIO_F32LSB, 6, 0, 4, SDL_Downsample_F32LSB_6c_x4 },
+    { AUDIO_F32LSB, 6, 1, 4, SDL_Upsample_F32LSB_6c_x4 },
+    { AUDIO_F32LSB, 8, 0, 2, SDL_Downsample_F32LSB_8c_x2 },
+    { AUDIO_F32LSB, 8, 1, 2, SDL_Upsample_F32LSB_8c_x2 },
+    { AUDIO_F32LSB, 8, 0, 4, SDL_Downsample_F32LSB_8c_x4 },
+    { AUDIO_F32LSB, 8, 1, 4, SDL_Upsample_F32LSB_8c_x4 },
+    { AUDIO_F32MSB, 1, 0, 2, SDL_Downsample_F32MSB_1c_x2 },
+    { AUDIO_F32MSB, 1, 1, 2, SDL_Upsample_F32MSB_1c_x2 },
+    { AUDIO_F32MSB, 1, 0, 4, SDL_Downsample_F32MSB_1c_x4 },
+    { AUDIO_F32MSB, 1, 1, 4, SDL_Upsample_F32MSB_1c_x4 },
+    { AUDIO_F32MSB, 2, 0, 2, SDL_Downsample_F32MSB_2c_x2 },
+    { AUDIO_F32MSB, 2, 1, 2, SDL_Upsample_F32MSB_2c_x2 },
+    { AUDIO_F32MSB, 2, 0, 4, SDL_Downsample_F32MSB_2c_x4 },
+    { AUDIO_F32MSB, 2, 1, 4, SDL_Upsample_F32MSB_2c_x4 },
+    { AUDIO_F32MSB, 4, 0, 2, SDL_Downsample_F32MSB_4c_x2 },
+    { AUDIO_F32MSB, 4, 1, 2, SDL_Upsample_F32MSB_4c_x2 },
+    { AUDIO_F32MSB, 4, 0, 4, SDL_Downsample_F32MSB_4c_x4 },
+    { AUDIO_F32MSB, 4, 1, 4, SDL_Upsample_F32MSB_4c_x4 },
+    { AUDIO_F32MSB, 6, 0, 2, SDL_Downsample_F32MSB_6c_x2 },
+    { AUDIO_F32MSB, 6, 1, 2, SDL_Upsample_F32MSB_6c_x2 },
+    { AUDIO_F32MSB, 6, 0, 4, SDL_Downsample_F32MSB_6c_x4 },
+    { AUDIO_F32MSB, 6, 1, 4, SDL_Upsample_F32MSB_6c_x4 },
+    { AUDIO_F32MSB, 8, 0, 2, SDL_Downsample_F32MSB_8c_x2 },
+    { AUDIO_F32MSB, 8, 1, 2, SDL_Upsample_F32MSB_8c_x2 },
+    { AUDIO_F32MSB, 8, 0, 4, SDL_Downsample_F32MSB_8c_x4 },
+    { AUDIO_F32MSB, 8, 1, 4, SDL_Upsample_F32MSB_8c_x4 },
+#endif  /* !LESS_RESAMPLERS */
+#endif  /* !NO_RESAMPLERS */
+    { 0, 0, 0, 0, NULL }
+};
+
+/* 390 converters generated. */
+
+/* *INDENT-ON* */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/audio/SDL_mixer.c b/macosx/plugins/Common/SDL/src/audio/SDL_mixer.c
new file mode 100644
index 00000000..63a4b5c3
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/audio/SDL_mixer.c
@@ -0,0 +1,313 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+/* This provides the default mixing callback for the SDL audio routines */
+
+#include "SDL_audio.h"
+#include "SDL_sysaudio.h"
+
+/* This table is used to add two sound values together and pin
+ * the value to avoid overflow.  (used with permission from ARDI)
+ * Changed to use 0xFE instead of 0xFF for better sound quality.
+ */
+static const Uint8 mix8[] = {
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03,
+    0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
+    0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
+    0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24,
+    0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
+    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A,
+    0x3B, 0x3C, 0x3D, 0x3E, 0x3F, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45,
+    0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
+    0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x5B,
+    0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
+    0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
+    0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C,
+    0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x91, 0x92,
+    0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D,
+    0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
+    0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, 0xB0, 0xB1, 0xB2, 0xB3,
+    0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE,
+    0xBF, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9,
+    0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, 0xD0, 0xD1, 0xD2, 0xD3, 0xD4,
+    0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF,
+    0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA,
+    0xEB, 0xEC, 0xED, 0xEE, 0xEF, 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5,
+    0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,
+    0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE
+};
+
+/* The volume ranges from 0 - 128 */
+#define ADJUST_VOLUME(s, v)	(s = (s*v)/SDL_MIX_MAXVOLUME)
+#define ADJUST_VOLUME_U8(s, v)	(s = (((s-128)*v)/SDL_MIX_MAXVOLUME)+128)
+
+
+void
+SDL_MixAudioFormat(Uint8 * dst, const Uint8 * src, SDL_AudioFormat format,
+                   Uint32 len, int volume)
+{
+    if (volume == 0) {
+        return;
+    }
+
+    switch (format) {
+
+    case AUDIO_U8:
+        {
+            Uint8 src_sample;
+
+            while (len--) {
+                src_sample = *src;
+                ADJUST_VOLUME_U8(src_sample, volume);
+                *dst = mix8[*dst + src_sample];
+                ++dst;
+                ++src;
+            }
+        }
+        break;
+
+    case AUDIO_S8:
+        {
+            {
+                Sint8 *dst8, *src8;
+                Sint8 src_sample;
+                int dst_sample;
+                const int max_audioval = ((1 << (8 - 1)) - 1);
+                const int min_audioval = -(1 << (8 - 1));
+
+                src8 = (Sint8 *) src;
+                dst8 = (Sint8 *) dst;
+                while (len--) {
+                    src_sample = *src8;
+                    ADJUST_VOLUME(src_sample, volume);
+                    dst_sample = *dst8 + src_sample;
+                    if (dst_sample > max_audioval) {
+                        *dst8 = max_audioval;
+                    } else if (dst_sample < min_audioval) {
+                        *dst8 = min_audioval;
+                    } else {
+                        *dst8 = dst_sample;
+                    }
+                    ++dst8;
+                    ++src8;
+                }
+            }
+        }
+        break;
+
+    case AUDIO_S16LSB:
+        {
+            {
+                Sint16 src1, src2;
+                int dst_sample;
+                const int max_audioval = ((1 << (16 - 1)) - 1);
+                const int min_audioval = -(1 << (16 - 1));
+
+                len /= 2;
+                while (len--) {
+                    src1 = ((src[1]) << 8 | src[0]);
+                    ADJUST_VOLUME(src1, volume);
+                    src2 = ((dst[1]) << 8 | dst[0]);
+                    src += 2;
+                    dst_sample = src1 + src2;
+                    if (dst_sample > max_audioval) {
+                        dst_sample = max_audioval;
+                    } else if (dst_sample < min_audioval) {
+                        dst_sample = min_audioval;
+                    }
+                    dst[0] = dst_sample & 0xFF;
+                    dst_sample >>= 8;
+                    dst[1] = dst_sample & 0xFF;
+                    dst += 2;
+                }
+            }
+        }
+        break;
+
+    case AUDIO_S16MSB:
+        {
+            Sint16 src1, src2;
+            int dst_sample;
+            const int max_audioval = ((1 << (16 - 1)) - 1);
+            const int min_audioval = -(1 << (16 - 1));
+
+            len /= 2;
+            while (len--) {
+                src1 = ((src[0]) << 8 | src[1]);
+                ADJUST_VOLUME(src1, volume);
+                src2 = ((dst[0]) << 8 | dst[1]);
+                src += 2;
+                dst_sample = src1 + src2;
+                if (dst_sample > max_audioval) {
+                    dst_sample = max_audioval;
+                } else if (dst_sample < min_audioval) {
+                    dst_sample = min_audioval;
+                }
+                dst[1] = dst_sample & 0xFF;
+                dst_sample >>= 8;
+                dst[0] = dst_sample & 0xFF;
+                dst += 2;
+            }
+        }
+        break;
+
+    case AUDIO_S32LSB:
+        {
+            const Uint32 *src32 = (Uint32 *) src;
+            Uint32 *dst32 = (Uint32 *) dst;
+            Sint64 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 = (Sint64) ((Sint32) SDL_SwapLE32(*src32));
+                src32++;
+                ADJUST_VOLUME(src1, volume);
+                src2 = (Sint64) ((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;
+            Sint64 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 = (Sint64) ((Sint32) SDL_SwapBE32(*src32));
+                src32++;
+                ADJUST_VOLUME(src1, volume);
+                src2 = (Sint64) ((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.402823466e+38F;
+            const double min_audioval = -3.402823466e+38F;
+
+            len /= 4;
+            while (len--) {
+                src1 = ((SDL_SwapFloatLE(*src32) * fvolume) * fmaxvolume);
+                src2 = SDL_SwapFloatLE(*dst32);
+                src32++;
+
+                dst_sample = ((double) src1) + ((double) src2);
+                if (dst_sample > max_audioval) {
+                    dst_sample = max_audioval;
+                } else if (dst_sample < min_audioval) {
+                    dst_sample = min_audioval;
+                }
+                *(dst32++) = SDL_SwapFloatLE((float) dst_sample);
+            }
+        }
+        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.402823466e+38F;
+            const double min_audioval = -3.402823466e+38F;
+
+            len /= 4;
+            while (len--) {
+                src1 = ((SDL_SwapFloatBE(*src32) * fvolume) * fmaxvolume);
+                src2 = SDL_SwapFloatBE(*dst32);
+                src32++;
+
+                dst_sample = ((double) src1) + ((double) src2);
+                if (dst_sample > max_audioval) {
+                    dst_sample = max_audioval;
+                } else if (dst_sample < min_audioval) {
+                    dst_sample = min_audioval;
+                }
+                *(dst32++) = SDL_SwapFloatBE((float) dst_sample);
+            }
+        }
+        break;
+
+    default:                   /* If this happens... FIXME! */
+        SDL_SetError("SDL_MixAudio(): unknown audio format");
+        return;
+    }
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/audio/SDL_sysaudio.h b/macosx/plugins/Common/SDL/src/audio/SDL_sysaudio.h
new file mode 100644
index 00000000..329e417b
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/audio/SDL_sysaudio.h
@@ -0,0 +1,129 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 Sam Lantinga
+
+    This library is SDL_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"
+
+#ifndef _SDL_sysaudio_h
+#define _SDL_sysaudio_h
+
+#include "SDL_mutex.h"
+#include "SDL_thread.h"
+
+/* The SDL audio driver */
+typedef struct SDL_AudioDevice SDL_AudioDevice;
+#define _THIS	SDL_AudioDevice *_this
+
+typedef struct SDL_AudioDriverImpl
+{
+    int (*DetectDevices) (int iscapture);
+    const char *(*GetDeviceName) (int index, int iscapture);
+    int (*OpenDevice) (_THIS, const char *devname, int iscapture);
+    void (*ThreadInit) (_THIS); /* Called by audio thread at start */
+    void (*WaitDevice) (_THIS);
+    void (*PlayDevice) (_THIS);
+    Uint8 *(*GetDeviceBuf) (_THIS);
+    void (*WaitDone) (_THIS);
+    void (*CloseDevice) (_THIS);
+    void (*LockDevice) (_THIS);
+    void (*UnlockDevice) (_THIS);
+    void (*Deinitialize) (void);
+
+    /* Some flags to push duplicate code into the core and reduce #ifdefs. */
+    int ProvidesOwnCallbackThread:1;
+    int SkipMixerLock:1;
+    int HasCaptureSupport:1;
+    int OnlyHasDefaultOutputDevice:1;
+    int OnlyHasDefaultInputDevice:1;
+} SDL_AudioDriverImpl;
+
+
+typedef struct SDL_AudioDriver
+{
+    /* * * */
+    /* The name of this audio driver */
+    const char *name;
+
+    /* * * */
+    /* The description of this audio driver */
+    const char *desc;
+
+    SDL_AudioDriverImpl impl;
+} SDL_AudioDriver;
+
+
+/* Streamer */
+typedef struct
+{
+    Uint8 *buffer;
+    int max_len;                /* the maximum length in bytes */
+    int read_pos, write_pos;    /* the position of the write and read heads in bytes */
+} SDL_AudioStreamer;
+
+
+/* Define the SDL audio driver structure */
+struct SDL_AudioDevice
+{
+    /* * * */
+    /* Data common to all devices */
+
+    /* The current audio specification (shared with audio thread) */
+    SDL_AudioSpec spec;
+
+    /* An audio conversion block for audio format emulation */
+    SDL_AudioCVT convert;
+
+    /* The streamer, if sample rate conversion necessitates it */
+    int use_streamer;
+    SDL_AudioStreamer streamer;
+
+    /* Current state flags */
+    int iscapture;
+    int enabled;
+    int paused;
+    int opened;
+
+    /* Fake audio buffer for when the audio hardware is busy */
+    Uint8 *fake_stream;
+
+    /* A semaphore for locking the mixing buffers */
+    SDL_mutex *mixer_lock;
+
+    /* A thread to feed the audio device */
+    SDL_Thread *thread;
+    SDL_threadID threadid;
+
+    /* * * */
+    /* Data private to this driver */
+    struct SDL_PrivateAudioData *hidden;
+};
+#undef _THIS
+
+typedef struct AudioBootStrap
+{
+    const char *name;
+    const char *desc;
+    int (*init) (SDL_AudioDriverImpl * impl);
+    int demand_only:1;          /* 1==request explicitly, or it won't be available. */
+} AudioBootStrap;
+
+#endif /* _SDL_sysaudio_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/audio/SDL_wave.c b/macosx/plugins/Common/SDL/src/audio/SDL_wave.c
new file mode 100644
index 00000000..d770e6ff
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/audio/SDL_wave.c
@@ -0,0 +1,636 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+/* Microsoft WAVE file loading routines */
+
+#include "SDL_audio.h"
+#include "SDL_wave.h"
+
+
+static int ReadChunk(SDL_RWops * src, Chunk * chunk);
+
+struct MS_ADPCM_decodestate
+{
+    Uint8 hPredictor;
+    Uint16 iDelta;
+    Sint16 iSamp1;
+    Sint16 iSamp2;
+};
+static struct MS_ADPCM_decoder
+{
+    WaveFMT wavefmt;
+    Uint16 wSamplesPerBlock;
+    Uint16 wNumCoef;
+    Sint16 aCoeff[7][2];
+    /* * * */
+    struct MS_ADPCM_decodestate state[2];
+} MS_ADPCM_state;
+
+static int
+InitMS_ADPCM(WaveFMT * format)
+{
+    Uint8 *rogue_feel;
+    Uint16 extra_info;
+    int i;
+
+    /* Set the rogue pointer to the MS_ADPCM specific data */
+    MS_ADPCM_state.wavefmt.encoding = SDL_SwapLE16(format->encoding);
+    MS_ADPCM_state.wavefmt.channels = SDL_SwapLE16(format->channels);
+    MS_ADPCM_state.wavefmt.frequency = SDL_SwapLE32(format->frequency);
+    MS_ADPCM_state.wavefmt.byterate = SDL_SwapLE32(format->byterate);
+    MS_ADPCM_state.wavefmt.blockalign = SDL_SwapLE16(format->blockalign);
+    MS_ADPCM_state.wavefmt.bitspersample =
+        SDL_SwapLE16(format->bitspersample);
+    rogue_feel = (Uint8 *) format + sizeof(*format);
+    if (sizeof(*format) == 16) {
+        extra_info = ((rogue_feel[1] << 8) | rogue_feel[0]);
+        rogue_feel += sizeof(Uint16);
+    }
+    MS_ADPCM_state.wSamplesPerBlock = ((rogue_feel[1] << 8) | rogue_feel[0]);
+    rogue_feel += sizeof(Uint16);
+    MS_ADPCM_state.wNumCoef = ((rogue_feel[1] << 8) | rogue_feel[0]);
+    rogue_feel += sizeof(Uint16);
+    if (MS_ADPCM_state.wNumCoef != 7) {
+        SDL_SetError("Unknown set of MS_ADPCM coefficients");
+        return (-1);
+    }
+    for (i = 0; i < MS_ADPCM_state.wNumCoef; ++i) {
+        MS_ADPCM_state.aCoeff[i][0] = ((rogue_feel[1] << 8) | rogue_feel[0]);
+        rogue_feel += sizeof(Uint16);
+        MS_ADPCM_state.aCoeff[i][1] = ((rogue_feel[1] << 8) | rogue_feel[0]);
+        rogue_feel += sizeof(Uint16);
+    }
+    return (0);
+}
+
+static Sint32
+MS_ADPCM_nibble(struct MS_ADPCM_decodestate *state,
+                Uint8 nybble, Sint16 * coeff)
+{
+    const Sint32 max_audioval = ((1 << (16 - 1)) - 1);
+    const Sint32 min_audioval = -(1 << (16 - 1));
+    const Sint32 adaptive[] = {
+        230, 230, 230, 230, 307, 409, 512, 614,
+        768, 614, 512, 409, 307, 230, 230, 230
+    };
+    Sint32 new_sample, delta;
+
+    new_sample = ((state->iSamp1 * coeff[0]) +
+                  (state->iSamp2 * coeff[1])) / 256;
+    if (nybble & 0x08) {
+        new_sample += state->iDelta * (nybble - 0x10);
+    } else {
+        new_sample += state->iDelta * nybble;
+    }
+    if (new_sample < min_audioval) {
+        new_sample = min_audioval;
+    } else if (new_sample > max_audioval) {
+        new_sample = max_audioval;
+    }
+    delta = ((Sint32) state->iDelta * adaptive[nybble]) / 256;
+    if (delta < 16) {
+        delta = 16;
+    }
+    state->iDelta = (Uint16) delta;
+    state->iSamp2 = state->iSamp1;
+    state->iSamp1 = (Sint16) new_sample;
+    return (new_sample);
+}
+
+static int
+MS_ADPCM_decode(Uint8 ** audio_buf, Uint32 * audio_len)
+{
+    struct MS_ADPCM_decodestate *state[2];
+    Uint8 *freeable, *encoded, *decoded;
+    Sint32 encoded_len, samplesleft;
+    Sint8 nybble, stereo;
+    Sint16 *coeff[2];
+    Sint32 new_sample;
+
+    /* Allocate the proper sized output buffer */
+    encoded_len = *audio_len;
+    encoded = *audio_buf;
+    freeable = *audio_buf;
+    *audio_len = (encoded_len / MS_ADPCM_state.wavefmt.blockalign) *
+        MS_ADPCM_state.wSamplesPerBlock *
+        MS_ADPCM_state.wavefmt.channels * sizeof(Sint16);
+    *audio_buf = (Uint8 *) SDL_malloc(*audio_len);
+    if (*audio_buf == NULL) {
+        SDL_Error(SDL_ENOMEM);
+        return (-1);
+    }
+    decoded = *audio_buf;
+
+    /* Get ready... Go! */
+    stereo = (MS_ADPCM_state.wavefmt.channels == 2);
+    state[0] = &MS_ADPCM_state.state[0];
+    state[1] = &MS_ADPCM_state.state[stereo];
+    while (encoded_len >= MS_ADPCM_state.wavefmt.blockalign) {
+        /* Grab the initial information for this block */
+        state[0]->hPredictor = *encoded++;
+        if (stereo) {
+            state[1]->hPredictor = *encoded++;
+        }
+        state[0]->iDelta = ((encoded[1] << 8) | encoded[0]);
+        encoded += sizeof(Sint16);
+        if (stereo) {
+            state[1]->iDelta = ((encoded[1] << 8) | encoded[0]);
+            encoded += sizeof(Sint16);
+        }
+        state[0]->iSamp1 = ((encoded[1] << 8) | encoded[0]);
+        encoded += sizeof(Sint16);
+        if (stereo) {
+            state[1]->iSamp1 = ((encoded[1] << 8) | encoded[0]);
+            encoded += sizeof(Sint16);
+        }
+        state[0]->iSamp2 = ((encoded[1] << 8) | encoded[0]);
+        encoded += sizeof(Sint16);
+        if (stereo) {
+            state[1]->iSamp2 = ((encoded[1] << 8) | encoded[0]);
+            encoded += sizeof(Sint16);
+        }
+        coeff[0] = MS_ADPCM_state.aCoeff[state[0]->hPredictor];
+        coeff[1] = MS_ADPCM_state.aCoeff[state[1]->hPredictor];
+
+        /* Store the two initial samples we start with */
+        decoded[0] = state[0]->iSamp2 & 0xFF;
+        decoded[1] = state[0]->iSamp2 >> 8;
+        decoded += 2;
+        if (stereo) {
+            decoded[0] = state[1]->iSamp2 & 0xFF;
+            decoded[1] = state[1]->iSamp2 >> 8;
+            decoded += 2;
+        }
+        decoded[0] = state[0]->iSamp1 & 0xFF;
+        decoded[1] = state[0]->iSamp1 >> 8;
+        decoded += 2;
+        if (stereo) {
+            decoded[0] = state[1]->iSamp1 & 0xFF;
+            decoded[1] = state[1]->iSamp1 >> 8;
+            decoded += 2;
+        }
+
+        /* Decode and store the other samples in this block */
+        samplesleft = (MS_ADPCM_state.wSamplesPerBlock - 2) *
+            MS_ADPCM_state.wavefmt.channels;
+        while (samplesleft > 0) {
+            nybble = (*encoded) >> 4;
+            new_sample = MS_ADPCM_nibble(state[0], nybble, coeff[0]);
+            decoded[0] = new_sample & 0xFF;
+            new_sample >>= 8;
+            decoded[1] = new_sample & 0xFF;
+            decoded += 2;
+
+            nybble = (*encoded) & 0x0F;
+            new_sample = MS_ADPCM_nibble(state[1], nybble, coeff[1]);
+            decoded[0] = new_sample & 0xFF;
+            new_sample >>= 8;
+            decoded[1] = new_sample & 0xFF;
+            decoded += 2;
+
+            ++encoded;
+            samplesleft -= 2;
+        }
+        encoded_len -= MS_ADPCM_state.wavefmt.blockalign;
+    }
+    SDL_free(freeable);
+    return (0);
+}
+
+struct IMA_ADPCM_decodestate
+{
+    Sint32 sample;
+    Sint8 index;
+};
+static struct IMA_ADPCM_decoder
+{
+    WaveFMT wavefmt;
+    Uint16 wSamplesPerBlock;
+    /* * * */
+    struct IMA_ADPCM_decodestate state[2];
+} IMA_ADPCM_state;
+
+static int
+InitIMA_ADPCM(WaveFMT * format)
+{
+    Uint8 *rogue_feel;
+    Uint16 extra_info;
+
+    /* Set the rogue pointer to the IMA_ADPCM specific data */
+    IMA_ADPCM_state.wavefmt.encoding = SDL_SwapLE16(format->encoding);
+    IMA_ADPCM_state.wavefmt.channels = SDL_SwapLE16(format->channels);
+    IMA_ADPCM_state.wavefmt.frequency = SDL_SwapLE32(format->frequency);
+    IMA_ADPCM_state.wavefmt.byterate = SDL_SwapLE32(format->byterate);
+    IMA_ADPCM_state.wavefmt.blockalign = SDL_SwapLE16(format->blockalign);
+    IMA_ADPCM_state.wavefmt.bitspersample =
+        SDL_SwapLE16(format->bitspersample);
+    rogue_feel = (Uint8 *) format + sizeof(*format);
+    if (sizeof(*format) == 16) {
+        extra_info = ((rogue_feel[1] << 8) | rogue_feel[0]);
+        rogue_feel += sizeof(Uint16);
+    }
+    IMA_ADPCM_state.wSamplesPerBlock = ((rogue_feel[1] << 8) | rogue_feel[0]);
+    return (0);
+}
+
+static Sint32
+IMA_ADPCM_nibble(struct IMA_ADPCM_decodestate *state, Uint8 nybble)
+{
+    const Sint32 max_audioval = ((1 << (16 - 1)) - 1);
+    const Sint32 min_audioval = -(1 << (16 - 1));
+    const int index_table[16] = {
+        -1, -1, -1, -1,
+        2, 4, 6, 8,
+        -1, -1, -1, -1,
+        2, 4, 6, 8
+    };
+    const Sint32 step_table[89] = {
+        7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31,
+        34, 37, 41, 45, 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130,
+        143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408,
+        449, 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282,
+        1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327,
+        3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630,
+        9493, 10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350,
+        22385, 24623, 27086, 29794, 32767
+    };
+    Sint32 delta, step;
+
+    /* Compute difference and new sample value */
+    step = step_table[state->index];
+    delta = step >> 3;
+    if (nybble & 0x04)
+        delta += step;
+    if (nybble & 0x02)
+        delta += (step >> 1);
+    if (nybble & 0x01)
+        delta += (step >> 2);
+    if (nybble & 0x08)
+        delta = -delta;
+    state->sample += delta;
+
+    /* Update index value */
+    state->index += index_table[nybble];
+    if (state->index > 88) {
+        state->index = 88;
+    } else if (state->index < 0) {
+        state->index = 0;
+    }
+
+    /* Clamp output sample */
+    if (state->sample > max_audioval) {
+        state->sample = max_audioval;
+    } else if (state->sample < min_audioval) {
+        state->sample = min_audioval;
+    }
+    return (state->sample);
+}
+
+/* Fill the decode buffer with a channel block of data (8 samples) */
+static void
+Fill_IMA_ADPCM_block(Uint8 * decoded, Uint8 * encoded,
+                     int channel, int numchannels,
+                     struct IMA_ADPCM_decodestate *state)
+{
+    int i;
+    Sint8 nybble;
+    Sint32 new_sample;
+
+    decoded += (channel * 2);
+    for (i = 0; i < 4; ++i) {
+        nybble = (*encoded) & 0x0F;
+        new_sample = IMA_ADPCM_nibble(state, nybble);
+        decoded[0] = new_sample & 0xFF;
+        new_sample >>= 8;
+        decoded[1] = new_sample & 0xFF;
+        decoded += 2 * numchannels;
+
+        nybble = (*encoded) >> 4;
+        new_sample = IMA_ADPCM_nibble(state, nybble);
+        decoded[0] = new_sample & 0xFF;
+        new_sample >>= 8;
+        decoded[1] = new_sample & 0xFF;
+        decoded += 2 * numchannels;
+
+        ++encoded;
+    }
+}
+
+static int
+IMA_ADPCM_decode(Uint8 ** audio_buf, Uint32 * audio_len)
+{
+    struct IMA_ADPCM_decodestate *state;
+    Uint8 *freeable, *encoded, *decoded;
+    Sint32 encoded_len, samplesleft;
+    unsigned int c, channels;
+
+    /* Check to make sure we have enough variables in the state array */
+    channels = IMA_ADPCM_state.wavefmt.channels;
+    if (channels > SDL_arraysize(IMA_ADPCM_state.state)) {
+        SDL_SetError("IMA ADPCM decoder can only handle %d channels",
+                     SDL_arraysize(IMA_ADPCM_state.state));
+        return (-1);
+    }
+    state = IMA_ADPCM_state.state;
+
+    /* Allocate the proper sized output buffer */
+    encoded_len = *audio_len;
+    encoded = *audio_buf;
+    freeable = *audio_buf;
+    *audio_len = (encoded_len / IMA_ADPCM_state.wavefmt.blockalign) *
+        IMA_ADPCM_state.wSamplesPerBlock *
+        IMA_ADPCM_state.wavefmt.channels * sizeof(Sint16);
+    *audio_buf = (Uint8 *) SDL_malloc(*audio_len);
+    if (*audio_buf == NULL) {
+        SDL_Error(SDL_ENOMEM);
+        return (-1);
+    }
+    decoded = *audio_buf;
+
+    /* Get ready... Go! */
+    while (encoded_len >= IMA_ADPCM_state.wavefmt.blockalign) {
+        /* Grab the initial information for this block */
+        for (c = 0; c < channels; ++c) {
+            /* Fill the state information for this block */
+            state[c].sample = ((encoded[1] << 8) | encoded[0]);
+            encoded += 2;
+            if (state[c].sample & 0x8000) {
+                state[c].sample -= 0x10000;
+            }
+            state[c].index = *encoded++;
+            /* Reserved byte in buffer header, should be 0 */
+            if (*encoded++ != 0) {
+                /* Uh oh, corrupt data?  Buggy code? */ ;
+            }
+
+            /* Store the initial sample we start with */
+            decoded[0] = (Uint8) (state[c].sample & 0xFF);
+            decoded[1] = (Uint8) (state[c].sample >> 8);
+            decoded += 2;
+        }
+
+        /* Decode and store the other samples in this block */
+        samplesleft = (IMA_ADPCM_state.wSamplesPerBlock - 1) * channels;
+        while (samplesleft > 0) {
+            for (c = 0; c < channels; ++c) {
+                Fill_IMA_ADPCM_block(decoded, encoded,
+                                     c, channels, &state[c]);
+                encoded += 4;
+                samplesleft -= 8;
+            }
+            decoded += (channels * 8 * 2);
+        }
+        encoded_len -= IMA_ADPCM_state.wavefmt.blockalign;
+    }
+    SDL_free(freeable);
+    return (0);
+}
+
+SDL_AudioSpec *
+SDL_LoadWAV_RW(SDL_RWops * src, int freesrc,
+               SDL_AudioSpec * spec, Uint8 ** audio_buf, Uint32 * audio_len)
+{
+    int was_error;
+    Chunk chunk;
+    int lenread;
+    int IEEE_float_encoded, MS_ADPCM_encoded, IMA_ADPCM_encoded;
+    int samplesize;
+
+    /* WAV magic header */
+    Uint32 RIFFchunk;
+    Uint32 wavelen = 0;
+    Uint32 WAVEmagic;
+    Uint32 headerDiff = 0;
+
+    /* FMT chunk */
+    WaveFMT *format = NULL;
+
+    /* Make sure we are passed a valid data source */
+    was_error = 0;
+    if (src == NULL) {
+        was_error = 1;
+        goto done;
+    }
+
+    /* Check the magic header */
+    RIFFchunk = SDL_ReadLE32(src);
+    wavelen = SDL_ReadLE32(src);
+    if (wavelen == WAVE) {      /* The RIFFchunk has already been read */
+        WAVEmagic = wavelen;
+        wavelen = RIFFchunk;
+        RIFFchunk = RIFF;
+    } else {
+        WAVEmagic = SDL_ReadLE32(src);
+    }
+    if ((RIFFchunk != RIFF) || (WAVEmagic != WAVE)) {
+        SDL_SetError("Unrecognized file type (not WAVE)");
+        was_error = 1;
+        goto done;
+    }
+    headerDiff += sizeof(Uint32);       /* for WAVE */
+
+    /* Read the audio data format chunk */
+    chunk.data = NULL;
+    do {
+        if (chunk.data != NULL) {
+            SDL_free(chunk.data);
+            chunk.data = NULL;
+        }
+        lenread = ReadChunk(src, &chunk);
+        if (lenread < 0) {
+            was_error = 1;
+            goto done;
+        }
+        /* 2 Uint32's for chunk header+len, plus the lenread */
+        headerDiff += lenread + 2 * sizeof(Uint32);
+    } while ((chunk.magic == FACT) || (chunk.magic == LIST));
+
+    /* Decode the audio data format */
+    format = (WaveFMT *) chunk.data;
+    if (chunk.magic != FMT) {
+        SDL_SetError("Complex WAVE files not supported");
+        was_error = 1;
+        goto done;
+    }
+    IEEE_float_encoded = MS_ADPCM_encoded = IMA_ADPCM_encoded = 0;
+    switch (SDL_SwapLE16(format->encoding)) {
+    case PCM_CODE:
+        /* We can understand this */
+        break;
+    case IEEE_FLOAT_CODE:
+        IEEE_float_encoded = 1;
+        /* We can understand this */
+        break;
+    case MS_ADPCM_CODE:
+        /* Try to understand this */
+        if (InitMS_ADPCM(format) < 0) {
+            was_error = 1;
+            goto done;
+        }
+        MS_ADPCM_encoded = 1;
+        break;
+    case IMA_ADPCM_CODE:
+        /* Try to understand this */
+        if (InitIMA_ADPCM(format) < 0) {
+            was_error = 1;
+            goto done;
+        }
+        IMA_ADPCM_encoded = 1;
+        break;
+    case MP3_CODE:
+        SDL_SetError("MPEG Layer 3 data not supported",
+                     SDL_SwapLE16(format->encoding));
+        was_error = 1;
+        goto done;
+    default:
+        SDL_SetError("Unknown WAVE data format: 0x%.4x",
+                     SDL_SwapLE16(format->encoding));
+        was_error = 1;
+        goto done;
+    }
+    SDL_memset(spec, 0, (sizeof *spec));
+    spec->freq = SDL_SwapLE32(format->frequency);
+
+    if (IEEE_float_encoded) {
+        if ((SDL_SwapLE16(format->bitspersample)) != 32) {
+            was_error = 1;
+        } else {
+            spec->format = AUDIO_F32;
+        }
+    } else {
+        switch (SDL_SwapLE16(format->bitspersample)) {
+        case 4:
+            if (MS_ADPCM_encoded || IMA_ADPCM_encoded) {
+                spec->format = AUDIO_S16;
+            } else {
+                was_error = 1;
+            }
+            break;
+        case 8:
+            spec->format = AUDIO_U8;
+            break;
+        case 16:
+            spec->format = AUDIO_S16;
+            break;
+        case 32:
+            spec->format = AUDIO_S32;
+            break;
+        default:
+            was_error = 1;
+            break;
+        }
+    }
+
+    if (was_error) {
+        SDL_SetError("Unknown %d-bit PCM data format",
+                     SDL_SwapLE16(format->bitspersample));
+        goto done;
+    }
+    spec->channels = (Uint8) SDL_SwapLE16(format->channels);
+    spec->samples = 4096;       /* Good default buffer size */
+
+    /* Read the audio data chunk */
+    *audio_buf = NULL;
+    do {
+        if (*audio_buf != NULL) {
+            SDL_free(*audio_buf);
+            *audio_buf = NULL;
+        }
+        lenread = ReadChunk(src, &chunk);
+        if (lenread < 0) {
+            was_error = 1;
+            goto done;
+        }
+        *audio_len = lenread;
+        *audio_buf = chunk.data;
+        if (chunk.magic != DATA)
+            headerDiff += lenread + 2 * sizeof(Uint32);
+    } while (chunk.magic != DATA);
+    headerDiff += 2 * sizeof(Uint32);   /* for the data chunk and len */
+
+    if (MS_ADPCM_encoded) {
+        if (MS_ADPCM_decode(audio_buf, audio_len) < 0) {
+            was_error = 1;
+            goto done;
+        }
+    }
+    if (IMA_ADPCM_encoded) {
+        if (IMA_ADPCM_decode(audio_buf, audio_len) < 0) {
+            was_error = 1;
+            goto done;
+        }
+    }
+
+    /* Don't return a buffer that isn't a multiple of samplesize */
+    samplesize = ((SDL_AUDIO_BITSIZE(spec->format)) / 8) * spec->channels;
+    *audio_len &= ~(samplesize - 1);
+
+  done:
+    if (format != NULL) {
+        SDL_free(format);
+    }
+    if (src) {
+        if (freesrc) {
+            SDL_RWclose(src);
+        } else {
+            /* seek to the end of the file (given by the RIFF chunk) */
+            SDL_RWseek(src, wavelen - chunk.length - headerDiff, RW_SEEK_CUR);
+        }
+    }
+    if (was_error) {
+        spec = NULL;
+    }
+    return (spec);
+}
+
+/* Since the WAV memory is allocated in the shared library, it must also
+   be freed here.  (Necessary under Win32, VC++)
+ */
+void
+SDL_FreeWAV(Uint8 * audio_buf)
+{
+    if (audio_buf != NULL) {
+        SDL_free(audio_buf);
+    }
+}
+
+static int
+ReadChunk(SDL_RWops * src, Chunk * chunk)
+{
+    chunk->magic = SDL_ReadLE32(src);
+    chunk->length = SDL_ReadLE32(src);
+    chunk->data = (Uint8 *) SDL_malloc(chunk->length);
+    if (chunk->data == NULL) {
+        SDL_Error(SDL_ENOMEM);
+        return (-1);
+    }
+    if (SDL_RWread(src, chunk->data, chunk->length, 1) != 1) {
+        SDL_Error(SDL_EFREAD);
+        SDL_free(chunk->data);
+        chunk->data = NULL;
+        return (-1);
+    }
+    return (chunk->length);
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/audio/SDL_wave.h b/macosx/plugins/Common/SDL/src/audio/SDL_wave.h
new file mode 100644
index 00000000..3c1f1234
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/audio/SDL_wave.h
@@ -0,0 +1,65 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 Sam Lantinga
+
+    This library is SDL_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"
+
+/* WAVE files are little-endian */
+
+/*******************************************/
+/* Define values for Microsoft WAVE format */
+/*******************************************/
+#define RIFF		0x46464952      /* "RIFF" */
+#define WAVE		0x45564157      /* "WAVE" */
+#define FACT		0x74636166      /* "fact" */
+#define LIST		0x5453494c      /* "LIST" */
+#define FMT		0x20746D66      /* "fmt " */
+#define DATA		0x61746164      /* "data" */
+#define PCM_CODE	0x0001
+#define MS_ADPCM_CODE	0x0002
+#define IEEE_FLOAT_CODE	0x0003
+#define IMA_ADPCM_CODE	0x0011
+#define MP3_CODE	0x0055
+#define WAVE_MONO	1
+#define WAVE_STEREO	2
+
+/* Normally, these three chunks come consecutively in a WAVE file */
+typedef struct WaveFMT
+{
+/* Not saved in the chunk we read:
+	Uint32	FMTchunk;
+	Uint32	fmtlen;
+*/
+    Uint16 encoding;
+    Uint16 channels;            /* 1 = mono, 2 = stereo */
+    Uint32 frequency;           /* One of 11025, 22050, or 44100 Hz */
+    Uint32 byterate;            /* Average bytes per second */
+    Uint16 blockalign;          /* Bytes per sample block */
+    Uint16 bitspersample;       /* One of 8, 12, 16, or 4 for ADPCM */
+} WaveFMT;
+
+/* The general chunk found in the WAVE file */
+typedef struct Chunk
+{
+    Uint32 magic;
+    Uint32 length;
+    Uint8 *data;
+} Chunk;
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/audio/macosx/SDL_coreaudio.c b/macosx/plugins/Common/SDL/src/audio/macosx/SDL_coreaudio.c
new file mode 100644
index 00000000..7d453a9c
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/audio/macosx/SDL_coreaudio.c
@@ -0,0 +1,584 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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 <CoreAudio/CoreAudio.h>
+#include <CoreServices/CoreServices.h>
+#include <AudioUnit/AudioUnit.h>
+#if MAC_OS_X_VERSION_MAX_ALLOWED <= 1050
+#include <AudioUnit/AUNTComponent.h>
+#endif
+
+#include "SDL_audio.h"
+#include "../SDL_audio_c.h"
+#include "../SDL_sysaudio.h"
+#include "SDL_coreaudio.h"
+
+#define DEBUG_COREAUDIO 0
+
+typedef struct COREAUDIO_DeviceList
+{
+    AudioDeviceID id;
+    const char *name;
+} COREAUDIO_DeviceList;
+
+static COREAUDIO_DeviceList *inputDevices = NULL;
+static int inputDeviceCount = 0;
+static COREAUDIO_DeviceList *outputDevices = NULL;
+static int outputDeviceCount = 0;
+
+static void
+free_device_list(COREAUDIO_DeviceList ** devices, int *devCount)
+{
+    if (*devices) {
+        int i = *devCount;
+        while (i--)
+            SDL_free((void *) (*devices)[i].name);
+        SDL_free(*devices);
+        *devices = NULL;
+    }
+    *devCount = 0;
+}
+
+
+static void
+build_device_list(int iscapture, COREAUDIO_DeviceList ** devices,
+                  int *devCount)
+{
+    Boolean outWritable = 0;
+    OSStatus result = noErr;
+    UInt32 size = 0;
+    AudioDeviceID *devs = NULL;
+    UInt32 i = 0;
+    UInt32 max = 0;
+
+    free_device_list(devices, devCount);
+
+    result = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices,
+                                          &size, &outWritable);
+
+    if (result != kAudioHardwareNoError)
+        return;
+
+    devs = (AudioDeviceID *) alloca(size);
+    if (devs == NULL)
+        return;
+
+    max = size / sizeof(AudioDeviceID);
+    *devices = (COREAUDIO_DeviceList *) SDL_malloc(max * sizeof(**devices));
+    if (*devices == NULL)
+        return;
+
+    result = AudioHardwareGetProperty(kAudioHardwarePropertyDevices,
+                                      &size, devs);
+    if (result != kAudioHardwareNoError)
+        return;
+
+    for (i = 0; i < max; i++) {
+        CFStringRef cfstr = NULL;
+        char *ptr = NULL;
+        AudioDeviceID dev = devs[i];
+        AudioBufferList *buflist = NULL;
+        int usable = 0;
+        CFIndex len = 0;
+
+        result = AudioDeviceGetPropertyInfo(dev, 0, iscapture,
+                                            kAudioDevicePropertyStreamConfiguration,
+                                            &size, &outWritable);
+        if (result != noErr)
+            continue;
+
+        buflist = (AudioBufferList *) SDL_malloc(size);
+        if (buflist == NULL)
+            continue;
+
+        result = AudioDeviceGetProperty(dev, 0, iscapture,
+                                        kAudioDevicePropertyStreamConfiguration,
+                                        &size, buflist);
+
+        if (result == noErr) {
+            UInt32 j;
+            for (j = 0; j < buflist->mNumberBuffers; j++) {
+                if (buflist->mBuffers[j].mNumberChannels > 0) {
+                    usable = 1;
+                    break;
+                }
+            }
+        }
+
+        SDL_free(buflist);
+
+        if (!usable)
+            continue;
+
+        size = sizeof(CFStringRef);
+        result = AudioDeviceGetProperty(dev, 0, iscapture,
+                                        kAudioDevicePropertyDeviceNameCFString,
+                                        &size, &cfstr);
+
+        if (result != kAudioHardwareNoError)
+            continue;
+
+        len = CFStringGetMaximumSizeForEncoding(CFStringGetLength(cfstr),
+                                                kCFStringEncodingUTF8);
+
+        ptr = (char *) SDL_malloc(len + 1);
+        usable = ((ptr != NULL) &&
+                  (CFStringGetCString
+                   (cfstr, ptr, len + 1, kCFStringEncodingUTF8)));
+
+        CFRelease(cfstr);
+
+        if (usable) {
+            len = strlen(ptr);
+            /* Some devices have whitespace at the end...trim it. */
+            while ((len > 0) && (ptr[len - 1] == ' ')) {
+                len--;
+            }
+            usable = (len > 0);
+        }
+
+        if (!usable) {
+            SDL_free(ptr);
+        } else {
+            ptr[len] = '\0';
+
+#if DEBUG_COREAUDIO
+            printf("COREAUDIO: Found %s device #%d: '%s' (devid %d)\n",
+                   ((iscapture) ? "capture" : "output"),
+                   (int) *devCount, ptr, (int) dev);
+#endif
+
+            (*devices)[*devCount].id = dev;
+            (*devices)[*devCount].name = ptr;
+            (*devCount)++;
+        }
+    }
+}
+
+static inline void
+build_device_lists(void)
+{
+    build_device_list(0, &outputDevices, &outputDeviceCount);
+    build_device_list(1, &inputDevices, &inputDeviceCount);
+}
+
+
+static inline void
+free_device_lists(void)
+{
+    free_device_list(&outputDevices, &outputDeviceCount);
+    free_device_list(&inputDevices, &inputDeviceCount);
+}
+
+
+static int
+find_device_id(const char *devname, int iscapture, AudioDeviceID * id)
+{
+    int i = ((iscapture) ? inputDeviceCount : outputDeviceCount);
+    COREAUDIO_DeviceList *devs = ((iscapture) ? inputDevices : outputDevices);
+    while (i--) {
+        if (SDL_strcmp(devname, devs->name) == 0) {
+            *id = devs->id;
+            return 1;
+        }
+        devs++;
+    }
+
+    return 0;
+}
+
+
+static int
+COREAUDIO_DetectDevices(int iscapture)
+{
+    if (iscapture) {
+        build_device_list(1, &inputDevices, &inputDeviceCount);
+        return inputDeviceCount;
+    } else {
+        build_device_list(0, &outputDevices, &outputDeviceCount);
+        return outputDeviceCount;
+    }
+
+    return 0;                   /* shouldn't ever hit this. */
+}
+
+
+static const char *
+COREAUDIO_GetDeviceName(int index, int iscapture)
+{
+    if ((iscapture) && (index < inputDeviceCount)) {
+        return inputDevices[index].name;
+    } else if ((!iscapture) && (index < outputDeviceCount)) {
+        return outputDevices[index].name;
+    }
+
+    SDL_SetError("No such device");
+    return NULL;
+}
+
+
+static void
+COREAUDIO_Deinitialize(void)
+{
+    free_device_lists();
+}
+
+
+/* The CoreAudio callback */
+static OSStatus
+outputCallback(void *inRefCon,
+               AudioUnitRenderActionFlags * ioActionFlags,
+               const AudioTimeStamp * inTimeStamp,
+               UInt32 inBusNumber, UInt32 inNumberFrames,
+               AudioBufferList * ioData)
+{
+    SDL_AudioDevice *this = (SDL_AudioDevice *) inRefCon;
+    AudioBuffer *abuf;
+    UInt32 remaining, len;
+    void *ptr;
+    UInt32 i;
+
+    /* Only do anything if audio is enabled and not paused */
+    if (!this->enabled || this->paused) {
+        for (i = 0; i < ioData->mNumberBuffers; i++) {
+            abuf = &ioData->mBuffers[i];
+            SDL_memset(abuf->mData, this->spec.silence, abuf->mDataByteSize);
+        }
+        return 0;
+    }
+
+    /* No SDL conversion should be needed here, ever, since we accept
+       any input format in OpenAudio, and leave the conversion to CoreAudio.
+     */
+    /*
+       assert(!this->convert.needed);
+       assert(this->spec.channels == ioData->mNumberChannels);
+     */
+
+    for (i = 0; i < ioData->mNumberBuffers; i++) {
+        abuf = &ioData->mBuffers[i];
+        remaining = abuf->mDataByteSize;
+        ptr = abuf->mData;
+        while (remaining > 0) {
+            if (this->hidden->bufferOffset >= this->hidden->bufferSize) {
+                /* Generate the data */
+                SDL_memset(this->hidden->buffer, this->spec.silence,
+                           this->hidden->bufferSize);
+                SDL_mutexP(this->mixer_lock);
+                (*this->spec.callback)(this->spec.userdata,
+                            this->hidden->buffer, this->hidden->bufferSize);
+                SDL_mutexV(this->mixer_lock);
+                this->hidden->bufferOffset = 0;
+            }
+
+            len = this->hidden->bufferSize - this->hidden->bufferOffset;
+            if (len > remaining)
+                len = remaining;
+            SDL_memcpy(ptr, (char *)this->hidden->buffer +
+                       this->hidden->bufferOffset, len);
+            ptr = (char *)ptr + len;
+            remaining -= len;
+            this->hidden->bufferOffset += len;
+        }
+    }
+
+    return 0;
+}
+
+static OSStatus
+inputCallback(void *inRefCon,
+              AudioUnitRenderActionFlags * ioActionFlags,
+              const AudioTimeStamp * inTimeStamp,
+              UInt32 inBusNumber, UInt32 inNumberFrames,
+              AudioBufferList * ioData)
+{
+    //err = AudioUnitRender(afr->fAudioUnit, ioActionFlags, inTimeStamp, inBusNumber, inNumberFrames, afr->fAudioBuffer);
+    // !!! FIXME: write me!
+    return noErr;
+}
+
+
+static void
+COREAUDIO_CloseDevice(_THIS)
+{
+    if (this->hidden != NULL) {
+        if (this->hidden->audioUnitOpened) {
+            OSStatus result = noErr;
+            AURenderCallbackStruct callback;
+            const AudioUnitElement output_bus = 0;
+            const AudioUnitElement input_bus = 1;
+            const int iscapture = this->iscapture;
+            const AudioUnitElement bus =
+                ((iscapture) ? input_bus : output_bus);
+            const AudioUnitScope scope =
+                ((iscapture) ? kAudioUnitScope_Output :
+                 kAudioUnitScope_Input);
+
+            /* stop processing the audio unit */
+            result = AudioOutputUnitStop(this->hidden->audioUnit);
+
+            /* Remove the input callback */
+            SDL_memset(&callback, '\0', sizeof(AURenderCallbackStruct));
+            result = AudioUnitSetProperty(this->hidden->audioUnit,
+                                          kAudioUnitProperty_SetRenderCallback,
+                                          scope, bus, &callback,
+                                          sizeof(callback));
+
+            CloseComponent(this->hidden->audioUnit);
+            this->hidden->audioUnitOpened = 0;
+        }
+        SDL_free(this->hidden->buffer);
+        SDL_free(this->hidden);
+        this->hidden = NULL;
+    }
+}
+
+
+#define CHECK_RESULT(msg) \
+    if (result != noErr) { \
+        COREAUDIO_CloseDevice(this); \
+        SDL_SetError("CoreAudio error (%s): %d", msg, (int) result); \
+        return 0; \
+    }
+
+static int
+find_device_by_name(_THIS, const char *devname, int iscapture)
+{
+    AudioDeviceID devid = 0;
+    OSStatus result = noErr;
+    UInt32 size = 0;
+    UInt32 alive = 0;
+    pid_t pid = 0;
+
+    if (devname == NULL) {
+        size = sizeof(AudioDeviceID);
+        const AudioHardwarePropertyID propid =
+            ((iscapture) ? kAudioHardwarePropertyDefaultInputDevice :
+             kAudioHardwarePropertyDefaultOutputDevice);
+
+        result = AudioHardwareGetProperty(propid, &size, &devid);
+        CHECK_RESULT("AudioHardwareGetProperty (default device)");
+    } else {
+        if (!find_device_id(devname, iscapture, &devid)) {
+            SDL_SetError("CoreAudio: No such audio device.");
+            return 0;
+        }
+    }
+
+    size = sizeof(alive);
+    result = AudioDeviceGetProperty(devid, 0, iscapture,
+                                    kAudioDevicePropertyDeviceIsAlive,
+                                    &size, &alive);
+    CHECK_RESULT
+        ("AudioDeviceGetProperty (kAudioDevicePropertyDeviceIsAlive)");
+
+    if (!alive) {
+        SDL_SetError("CoreAudio: requested device exists, but isn't alive.");
+        return 0;
+    }
+
+    size = sizeof(pid);
+    result = AudioDeviceGetProperty(devid, 0, iscapture,
+                                    kAudioDevicePropertyHogMode, &size, &pid);
+
+    /* some devices don't support this property, so errors are fine here. */
+    if ((result == noErr) && (pid != -1)) {
+        SDL_SetError("CoreAudio: requested device is being hogged.");
+        return 0;
+    }
+
+    this->hidden->deviceID = devid;
+    return 1;
+}
+
+
+static int
+prepare_audiounit(_THIS, const char *devname, int iscapture,
+                  const AudioStreamBasicDescription * strdesc)
+{
+    OSStatus result = noErr;
+    AURenderCallbackStruct callback;
+    ComponentDescription desc;
+    Component comp = NULL;
+    const AudioUnitElement output_bus = 0;
+    const AudioUnitElement input_bus = 1;
+    const AudioUnitElement bus = ((iscapture) ? input_bus : output_bus);
+    const AudioUnitScope scope = ((iscapture) ? kAudioUnitScope_Output :
+                                  kAudioUnitScope_Input);
+
+    if (!find_device_by_name(this, devname, iscapture)) {
+        SDL_SetError("Couldn't find requested CoreAudio device");
+        return 0;
+    }
+
+    SDL_memset(&desc, '\0', sizeof(ComponentDescription));
+    desc.componentType = kAudioUnitType_Output;
+    desc.componentSubType = kAudioUnitSubType_DefaultOutput;
+    desc.componentManufacturer = kAudioUnitManufacturer_Apple;
+
+    comp = FindNextComponent(NULL, &desc);
+    if (comp == NULL) {
+        SDL_SetError("Couldn't find requested CoreAudio component");
+        return 0;
+    }
+
+    /* Open & initialize the audio unit */
+    result = OpenAComponent(comp, &this->hidden->audioUnit);
+    CHECK_RESULT("OpenAComponent");
+
+    this->hidden->audioUnitOpened = 1;
+
+    result = AudioUnitSetProperty(this->hidden->audioUnit,
+                                  kAudioOutputUnitProperty_CurrentDevice,
+                                  kAudioUnitScope_Global, 0,
+                                  &this->hidden->deviceID,
+                                  sizeof(AudioDeviceID));
+    CHECK_RESULT
+        ("AudioUnitSetProperty (kAudioOutputUnitProperty_CurrentDevice)");
+
+    /* Set the data format of the audio unit. */
+    result = AudioUnitSetProperty(this->hidden->audioUnit,
+                                  kAudioUnitProperty_StreamFormat,
+                                  scope, bus, strdesc, sizeof(*strdesc));
+    CHECK_RESULT("AudioUnitSetProperty (kAudioUnitProperty_StreamFormat)");
+
+    /* Set the audio callback */
+    SDL_memset(&callback, '\0', sizeof(AURenderCallbackStruct));
+    callback.inputProc = ((iscapture) ? inputCallback : outputCallback);
+    callback.inputProcRefCon = this;
+    result = AudioUnitSetProperty(this->hidden->audioUnit,
+                                  kAudioUnitProperty_SetRenderCallback,
+                                  scope, bus, &callback, sizeof(callback));
+    CHECK_RESULT
+        ("AudioUnitSetProperty (kAudioUnitProperty_SetRenderCallback)");
+
+    /* Calculate the final parameters for this audio specification */
+    SDL_CalculateAudioSpec(&this->spec);
+
+    /* Allocate a sample buffer */
+    this->hidden->bufferOffset = this->hidden->bufferSize = this->spec.size;
+    this->hidden->buffer = SDL_malloc(this->hidden->bufferSize);
+
+    result = AudioUnitInitialize(this->hidden->audioUnit);
+    CHECK_RESULT("AudioUnitInitialize");
+
+    /* Finally, start processing of the audio unit */
+    result = AudioOutputUnitStart(this->hidden->audioUnit);
+    CHECK_RESULT("AudioOutputUnitStart");
+
+    /* We're running! */
+    return 1;
+}
+
+
+static int
+COREAUDIO_OpenDevice(_THIS, const char *devname, int iscapture)
+{
+    AudioStreamBasicDescription strdesc;
+    SDL_AudioFormat test_format = SDL_FirstAudioFormat(this->spec.format);
+    int valid_datatype = 0;
+
+    /* Initialize all variables that we clean on shutdown */
+    this->hidden = (struct SDL_PrivateAudioData *)
+        SDL_malloc((sizeof *this->hidden));
+    if (this->hidden == NULL) {
+        SDL_OutOfMemory();
+        return (0);
+    }
+    SDL_memset(this->hidden, 0, (sizeof *this->hidden));
+
+    /* Setup a AudioStreamBasicDescription with the requested format */
+    SDL_memset(&strdesc, '\0', sizeof(AudioStreamBasicDescription));
+    strdesc.mFormatID = kAudioFormatLinearPCM;
+    strdesc.mFormatFlags = kLinearPCMFormatFlagIsPacked;
+    strdesc.mChannelsPerFrame = this->spec.channels;
+    strdesc.mSampleRate = this->spec.freq;
+    strdesc.mFramesPerPacket = 1;
+
+    while ((!valid_datatype) && (test_format)) {
+        this->spec.format = test_format;
+        /* Just a list of valid SDL formats, so people don't pass junk here. */
+        switch (test_format) {
+        case AUDIO_U8:
+        case AUDIO_S8:
+        case AUDIO_U16LSB:
+        case AUDIO_S16LSB:
+        case AUDIO_U16MSB:
+        case AUDIO_S16MSB:
+        case AUDIO_S32LSB:
+        case AUDIO_S32MSB:
+        case AUDIO_F32LSB:
+        case AUDIO_F32MSB:
+            valid_datatype = 1;
+            strdesc.mBitsPerChannel = SDL_AUDIO_BITSIZE(this->spec.format);
+            if (SDL_AUDIO_ISBIGENDIAN(this->spec.format))
+                strdesc.mFormatFlags |= kLinearPCMFormatFlagIsBigEndian;
+
+            if (SDL_AUDIO_ISFLOAT(this->spec.format))
+                strdesc.mFormatFlags |= kLinearPCMFormatFlagIsFloat;
+            else if (SDL_AUDIO_ISSIGNED(this->spec.format))
+                strdesc.mFormatFlags |= kLinearPCMFormatFlagIsSignedInteger;
+            break;
+        }
+    }
+
+    if (!valid_datatype) {      /* shouldn't happen, but just in case... */
+        COREAUDIO_CloseDevice(this);
+        SDL_SetError("Unsupported audio format");
+        return 0;
+    }
+
+    strdesc.mBytesPerFrame =
+        strdesc.mBitsPerChannel * strdesc.mChannelsPerFrame / 8;
+    strdesc.mBytesPerPacket =
+        strdesc.mBytesPerFrame * strdesc.mFramesPerPacket;
+
+    if (!prepare_audiounit(this, devname, iscapture, &strdesc)) {
+        COREAUDIO_CloseDevice(this);
+        return 0;               /* prepare_audiounit() will call SDL_SetError()... */
+    }
+
+    return 1;                   /* good to go. */
+}
+
+static int
+COREAUDIO_Init(SDL_AudioDriverImpl * impl)
+{
+    /* Set the function pointers */
+    impl->DetectDevices = COREAUDIO_DetectDevices;
+    impl->GetDeviceName = COREAUDIO_GetDeviceName;
+    impl->OpenDevice = COREAUDIO_OpenDevice;
+    impl->CloseDevice = COREAUDIO_CloseDevice;
+    impl->Deinitialize = COREAUDIO_Deinitialize;
+    impl->ProvidesOwnCallbackThread = 1;
+
+    build_device_lists();       /* do an initial check for devices... */
+
+    return 1;   /* this audio target is available. */
+}
+
+AudioBootStrap COREAUDIO_bootstrap = {
+    "coreaudio", "Mac OS X CoreAudio", COREAUDIO_Init, 0
+};
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/audio/macosx/SDL_coreaudio.h b/macosx/plugins/Common/SDL/src/audio/macosx/SDL_coreaudio.h
new file mode 100644
index 00000000..fe374381
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/audio/macosx/SDL_coreaudio.h
@@ -0,0 +1,43 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+#ifndef _SDL_coreaudio_h
+#define _SDL_coreaudio_h
+
+#include "../SDL_sysaudio.h"
+
+/* Hidden "this" pointer for the audio functions */
+#define _THIS	SDL_AudioDevice *this
+
+struct SDL_PrivateAudioData
+{
+    AudioUnit audioUnit;
+    int audioUnitOpened;
+    void *buffer;
+    UInt32 bufferOffset;
+    UInt32 bufferSize;
+    AudioDeviceID deviceID;
+};
+
+#endif /* _SDL_coreaudio_h */
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/file/SDL_rwops.c b/macosx/plugins/Common/SDL/src/file/SDL_rwops.c
new file mode 100644
index 00000000..636361ca
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/file/SDL_rwops.c
@@ -0,0 +1,663 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+/* This file provides a general interface for SDL to read and write
+   data sources.  It can easily be extended to files, memory, etc.
+*/
+
+#include "SDL_endian.h"
+#include "SDL_rwops.h"
+
+#ifdef __APPLE__
+#include "cocoa/SDL_rwopsbundlesupport.h"
+#endif /* __APPLE__ */
+
+#ifdef __WIN32__
+
+/* Functions to read/write Win32 API file pointers */
+/* Will not use it on WinCE because stdio is buffered, it means
+   faster, and all stdio functions anyway are embedded in coredll.dll - 
+   the main wince dll*/
+
+#define WINDOWS_LEAN_AND_MEAN
+#include <windows.h>
+
+#ifndef INVALID_SET_FILE_POINTER
+#define INVALID_SET_FILE_POINTER 0xFFFFFFFF
+#endif
+
+#define READAHEAD_BUFFER_SIZE	1024
+
+static int SDLCALL
+win32_file_open(SDL_RWops * context, const char *filename, const char *mode)
+{
+#ifndef _WIN32_WCE
+    UINT old_error_mode;
+#endif
+    HANDLE h;
+    DWORD r_right, w_right;
+    DWORD must_exist, truncate;
+    int a_mode;
+
+    if (!context)
+        return -1;              /* failed (invalid call) */
+
+    context->hidden.win32io.h = INVALID_HANDLE_VALUE;   /* mark this as unusable */
+    context->hidden.win32io.buffer.data = NULL;
+    context->hidden.win32io.buffer.size = 0;
+    context->hidden.win32io.buffer.left = 0;
+
+    /* "r" = reading, file must exist */
+    /* "w" = writing, truncate existing, file may not exist */
+    /* "r+"= reading or writing, file must exist            */
+    /* "a" = writing, append file may not exist             */
+    /* "a+"= append + read, file may not exist              */
+    /* "w+" = read, write, truncate. file may not exist    */
+
+    must_exist = (SDL_strchr(mode, 'r') != NULL) ? OPEN_EXISTING : 0;
+    truncate = (SDL_strchr(mode, 'w') != NULL) ? CREATE_ALWAYS : 0;
+    r_right = (SDL_strchr(mode, '+') != NULL
+               || must_exist) ? GENERIC_READ : 0;
+    a_mode = (SDL_strchr(mode, 'a') != NULL) ? OPEN_ALWAYS : 0;
+    w_right = (a_mode || SDL_strchr(mode, '+')
+               || truncate) ? GENERIC_WRITE : 0;
+
+    if (!r_right && !w_right)   /* inconsistent mode */
+        return -1;              /* failed (invalid call) */
+
+    context->hidden.win32io.buffer.data =
+        (char *) SDL_malloc(READAHEAD_BUFFER_SIZE);
+    if (!context->hidden.win32io.buffer.data) {
+        SDL_OutOfMemory();
+        return -1;
+    }
+#ifdef _WIN32_WCE
+    {
+        size_t size = SDL_strlen(filename) + 1;
+        wchar_t *filenameW = SDL_stack_alloc(wchar_t, size);
+
+        if (MultiByteToWideChar(CP_UTF8, 0, filename, -1, filenameW, size) ==
+            0) {
+            SDL_stack_free(filenameW);
+            SDL_free(context->hidden.win32io.buffer.data);
+            context->hidden.win32io.buffer.data = NULL;
+            SDL_SetError("Unable to convert filename to Unicode");
+            return -1;
+        }
+        h = CreateFile(filenameW, (w_right | r_right),
+                       (w_right) ? 0 : FILE_SHARE_READ, NULL,
+                       (must_exist | truncate | a_mode),
+                       FILE_ATTRIBUTE_NORMAL, NULL);
+        SDL_stack_free(filenameW);
+    }
+#else
+    /* Do not open a dialog box if failure */
+    old_error_mode =
+        SetErrorMode(SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS);
+
+    h = CreateFile(filename, (w_right | r_right),
+                   (w_right) ? 0 : FILE_SHARE_READ, NULL,
+                   (must_exist | truncate | a_mode), FILE_ATTRIBUTE_NORMAL,
+                   NULL);
+
+    /* restore old behaviour */
+    SetErrorMode(old_error_mode);
+#endif /* _WIN32_WCE */
+
+    if (h == INVALID_HANDLE_VALUE) {
+        SDL_free(context->hidden.win32io.buffer.data);
+        context->hidden.win32io.buffer.data = NULL;
+        SDL_SetError("Couldn't open %s", filename);
+        return -2;              /* failed (CreateFile) */
+    }
+    context->hidden.win32io.h = h;
+    context->hidden.win32io.append = a_mode ? SDL_TRUE : SDL_FALSE;
+
+    return 0;                   /* ok */
+}
+
+static long SDLCALL
+win32_file_seek(SDL_RWops * context, long offset, int whence)
+{
+    DWORD win32whence;
+    long file_pos;
+
+    if (!context || context->hidden.win32io.h == INVALID_HANDLE_VALUE) {
+        SDL_SetError("win32_file_seek: invalid context/file not opened");
+        return -1;
+    }
+
+    /* FIXME: We may be able to satisfy the seek within buffered data */
+    if (whence == RW_SEEK_CUR && context->hidden.win32io.buffer.left) {
+        offset -= (long)context->hidden.win32io.buffer.left;
+    }
+    context->hidden.win32io.buffer.left = 0;
+
+    switch (whence) {
+    case RW_SEEK_SET:
+        win32whence = FILE_BEGIN;
+        break;
+    case RW_SEEK_CUR:
+        win32whence = FILE_CURRENT;
+        break;
+    case RW_SEEK_END:
+        win32whence = FILE_END;
+        break;
+    default:
+        SDL_SetError("win32_file_seek: Unknown value for 'whence'");
+        return -1;
+    }
+
+    file_pos =
+        SetFilePointer(context->hidden.win32io.h, offset, NULL, win32whence);
+
+    if (file_pos != INVALID_SET_FILE_POINTER)
+        return file_pos;        /* success */
+
+    SDL_Error(SDL_EFSEEK);
+    return -1;                  /* error */
+}
+
+static size_t SDLCALL
+win32_file_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
+{
+    size_t total_need;
+    size_t total_read = 0;
+    size_t read_ahead;
+    DWORD byte_read;
+
+    total_need = size * maxnum;
+
+    if (!context || context->hidden.win32io.h == INVALID_HANDLE_VALUE
+        || !total_need)
+        return 0;
+
+    if (context->hidden.win32io.buffer.left > 0) {
+        void *data = (char *) context->hidden.win32io.buffer.data +
+            context->hidden.win32io.buffer.size -
+            context->hidden.win32io.buffer.left;
+        read_ahead =
+            SDL_min(total_need, context->hidden.win32io.buffer.left);
+        SDL_memcpy(ptr, data, read_ahead);
+        context->hidden.win32io.buffer.left -= read_ahead;
+
+        if (read_ahead == total_need) {
+            return maxnum;
+        }
+        ptr = (char *) ptr + read_ahead;
+        total_need -= read_ahead;
+        total_read += read_ahead;
+    }
+
+    if (total_need < READAHEAD_BUFFER_SIZE) {
+        if (!ReadFile
+            (context->hidden.win32io.h, context->hidden.win32io.buffer.data,
+             READAHEAD_BUFFER_SIZE, &byte_read, NULL)) {
+            SDL_Error(SDL_EFREAD);
+            return 0;
+        }
+        read_ahead = SDL_min(total_need, (int) byte_read);
+        SDL_memcpy(ptr, context->hidden.win32io.buffer.data, read_ahead);
+        context->hidden.win32io.buffer.size = byte_read;
+        context->hidden.win32io.buffer.left = byte_read - read_ahead;
+        total_read += read_ahead;
+    } else {
+        if (!ReadFile
+            (context->hidden.win32io.h, ptr, (DWORD)total_need, &byte_read, NULL)) {
+            SDL_Error(SDL_EFREAD);
+            return 0;
+        }
+        total_read += byte_read;
+    }
+    return (total_read / size);
+}
+
+static size_t SDLCALL
+win32_file_write(SDL_RWops * context, const void *ptr, size_t size,
+                 size_t num)
+{
+
+    size_t total_bytes;
+    DWORD byte_written;
+    size_t nwritten;
+
+    total_bytes = size * num;
+
+    if (!context || context->hidden.win32io.h == INVALID_HANDLE_VALUE
+        || total_bytes <= 0 || !size)
+        return 0;
+
+    if (context->hidden.win32io.buffer.left) {
+        SetFilePointer(context->hidden.win32io.h,
+                       -(LONG)context->hidden.win32io.buffer.left, NULL,
+                       FILE_CURRENT);
+        context->hidden.win32io.buffer.left = 0;
+    }
+
+    /* if in append mode, we must go to the EOF before write */
+    if (context->hidden.win32io.append) {
+        if (SetFilePointer(context->hidden.win32io.h, 0L, NULL, FILE_END) ==
+            INVALID_SET_FILE_POINTER) {
+            SDL_Error(SDL_EFWRITE);
+            return 0;
+        }
+    }
+
+    if (!WriteFile
+        (context->hidden.win32io.h, ptr, (DWORD)total_bytes, &byte_written, NULL)) {
+        SDL_Error(SDL_EFWRITE);
+        return 0;
+    }
+
+    nwritten = byte_written / size;
+    return nwritten;
+}
+
+static int SDLCALL
+win32_file_close(SDL_RWops * context)
+{
+
+    if (context) {
+        if (context->hidden.win32io.h != INVALID_HANDLE_VALUE) {
+            CloseHandle(context->hidden.win32io.h);
+            context->hidden.win32io.h = INVALID_HANDLE_VALUE;   /* to be sure */
+        }
+        if (context->hidden.win32io.buffer.data) {
+            SDL_free(context->hidden.win32io.buffer.data);
+            context->hidden.win32io.buffer.data = NULL;
+        }
+        SDL_FreeRW(context);
+    }
+    return (0);
+}
+#endif /* __WIN32__ */
+
+#ifdef HAVE_STDIO_H
+
+/* Functions to read/write stdio file pointers */
+
+static long SDLCALL
+stdio_seek(SDL_RWops * context, long offset, int whence)
+{
+    if (fseek(context->hidden.stdio.fp, offset, whence) == 0) {
+        return (ftell(context->hidden.stdio.fp));
+    } else {
+        SDL_Error(SDL_EFSEEK);
+        return (-1);
+    }
+}
+
+static size_t SDLCALL
+stdio_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
+{
+    size_t nread;
+
+    nread = fread(ptr, size, maxnum, context->hidden.stdio.fp);
+    if (nread == 0 && ferror(context->hidden.stdio.fp)) {
+        SDL_Error(SDL_EFREAD);
+    }
+    return (nread);
+}
+
+static size_t SDLCALL
+stdio_write(SDL_RWops * context, const void *ptr, size_t size, size_t num)
+{
+    size_t nwrote;
+
+    nwrote = fwrite(ptr, size, num, context->hidden.stdio.fp);
+    if (nwrote == 0 && ferror(context->hidden.stdio.fp)) {
+        SDL_Error(SDL_EFWRITE);
+    }
+    return (nwrote);
+}
+
+static int SDLCALL
+stdio_close(SDL_RWops * context)
+{
+    int status = 0;
+    if (context) {
+        if (context->hidden.stdio.autoclose) {
+            /* WARNING:  Check the return value here! */
+            if (fclose(context->hidden.stdio.fp) != 0) {
+                SDL_Error(SDL_EFWRITE);
+                status = -1;
+            }
+        }
+        SDL_FreeRW(context);
+    }
+    return status;
+}
+#endif /* !HAVE_STDIO_H */
+
+/* Functions to read/write memory pointers */
+
+static long SDLCALL
+mem_seek(SDL_RWops * context, long offset, int whence)
+{
+    Uint8 *newpos;
+
+    switch (whence) {
+    case RW_SEEK_SET:
+        newpos = context->hidden.mem.base + offset;
+        break;
+    case RW_SEEK_CUR:
+        newpos = context->hidden.mem.here + offset;
+        break;
+    case RW_SEEK_END:
+        newpos = context->hidden.mem.stop + offset;
+        break;
+    default:
+        SDL_SetError("Unknown value for 'whence'");
+        return (-1);
+    }
+    if (newpos < context->hidden.mem.base) {
+        newpos = context->hidden.mem.base;
+    }
+    if (newpos > context->hidden.mem.stop) {
+        newpos = context->hidden.mem.stop;
+    }
+    context->hidden.mem.here = newpos;
+    return (long)(context->hidden.mem.here - context->hidden.mem.base);
+}
+
+static size_t SDLCALL
+mem_read(SDL_RWops * context, void *ptr, size_t size, size_t maxnum)
+{
+    size_t total_bytes;
+    size_t mem_available;
+
+    total_bytes = (maxnum * size);
+    if ((maxnum <= 0) || (size <= 0)
+        || ((total_bytes / maxnum) != (size_t) size)) {
+        return 0;
+    }
+
+    mem_available = (context->hidden.mem.stop - context->hidden.mem.here);
+    if (total_bytes > mem_available) {
+        total_bytes = mem_available;
+    }
+
+    SDL_memcpy(ptr, context->hidden.mem.here, total_bytes);
+    context->hidden.mem.here += total_bytes;
+
+    return (total_bytes / size);
+}
+
+static size_t SDLCALL
+mem_write(SDL_RWops * context, const void *ptr, size_t size, size_t num)
+{
+    if ((context->hidden.mem.here + (num * size)) > context->hidden.mem.stop) {
+        num = (context->hidden.mem.stop - context->hidden.mem.here) / size;
+    }
+    SDL_memcpy(context->hidden.mem.here, ptr, num * size);
+    context->hidden.mem.here += num * size;
+    return (num);
+}
+
+static size_t SDLCALL
+mem_writeconst(SDL_RWops * context, const void *ptr, size_t size, size_t num)
+{
+    SDL_SetError("Can't write to read-only memory");
+    return (-1);
+}
+
+static int SDLCALL
+mem_close(SDL_RWops * context)
+{
+    if (context) {
+        SDL_FreeRW(context);
+    }
+    return (0);
+}
+
+
+/* Functions to create SDL_RWops structures from various data sources */
+
+SDL_RWops *
+SDL_RWFromFile(const char *file, const char *mode)
+{
+    SDL_RWops *rwops = NULL;
+#ifdef HAVE_STDIO_H
+    FILE *fp = NULL;
+#endif
+    if (!file || !*file || !mode || !*mode) {
+        SDL_SetError("SDL_RWFromFile(): No file or no mode specified");
+        return NULL;
+    }
+#if defined(__WIN32__)
+    rwops = SDL_AllocRW();
+    if (!rwops)
+        return NULL;            /* SDL_SetError already setup by SDL_AllocRW() */
+    if (win32_file_open(rwops, file, mode) < 0) {
+        SDL_FreeRW(rwops);
+        return NULL;
+    }
+    rwops->seek = win32_file_seek;
+    rwops->read = win32_file_read;
+    rwops->write = win32_file_write;
+    rwops->close = win32_file_close;
+
+#elif HAVE_STDIO_H
+	#ifdef __APPLE__
+	fp = SDL_OpenFPFromBundleOrFallback(file, mode);
+    #else
+	fp = fopen(file, mode);
+	#endif
+	if (fp == NULL) {
+        SDL_SetError("Couldn't open %s", file);
+    } else {
+        rwops = SDL_RWFromFP(fp, 1);
+    }
+#else
+    SDL_SetError("SDL not compiled with stdio support");
+#endif /* !HAVE_STDIO_H */
+
+    return (rwops);
+}
+
+#ifdef HAVE_STDIO_H
+SDL_RWops *
+SDL_RWFromFP(FILE * fp, SDL_bool autoclose)
+{
+    SDL_RWops *rwops = NULL;
+
+#if 0
+/*#ifdef __NDS__*/
+    /* set it up so we can use stdio file function */
+    fatInitDefault();
+    printf("called fatInitDefault()");
+#endif /* __NDS__ */
+
+    rwops = SDL_AllocRW();
+    if (rwops != NULL) {
+        rwops->seek = stdio_seek;
+        rwops->read = stdio_read;
+        rwops->write = stdio_write;
+        rwops->close = stdio_close;
+        rwops->hidden.stdio.fp = fp;
+        rwops->hidden.stdio.autoclose = autoclose;
+    }
+    return (rwops);
+}
+#else
+SDL_RWops *
+SDL_RWFromFP(void * fp, SDL_bool autoclose)
+{
+    SDL_SetError("SDL not compiled with stdio support");
+    return NULL;
+}
+#endif /* HAVE_STDIO_H */
+
+SDL_RWops *
+SDL_RWFromMem(void *mem, int size)
+{
+    SDL_RWops *rwops;
+
+    rwops = SDL_AllocRW();
+    if (rwops != NULL) {
+        rwops->seek = mem_seek;
+        rwops->read = mem_read;
+        rwops->write = mem_write;
+        rwops->close = mem_close;
+        rwops->hidden.mem.base = (Uint8 *) mem;
+        rwops->hidden.mem.here = rwops->hidden.mem.base;
+        rwops->hidden.mem.stop = rwops->hidden.mem.base + size;
+    }
+    return (rwops);
+}
+
+SDL_RWops *
+SDL_RWFromConstMem(const void *mem, int size)
+{
+    SDL_RWops *rwops;
+
+    rwops = SDL_AllocRW();
+    if (rwops != NULL) {
+        rwops->seek = mem_seek;
+        rwops->read = mem_read;
+        rwops->write = mem_writeconst;
+        rwops->close = mem_close;
+        rwops->hidden.mem.base = (Uint8 *) mem;
+        rwops->hidden.mem.here = rwops->hidden.mem.base;
+        rwops->hidden.mem.stop = rwops->hidden.mem.base + size;
+    }
+    return (rwops);
+}
+
+SDL_RWops *
+SDL_AllocRW(void)
+{
+    SDL_RWops *area;
+
+    area = (SDL_RWops *) SDL_malloc(sizeof *area);
+    if (area == NULL) {
+        SDL_OutOfMemory();
+    }
+    return (area);
+}
+
+void
+SDL_FreeRW(SDL_RWops * area)
+{
+    SDL_free(area);
+}
+
+/* Functions for dynamically reading and writing endian-specific values */
+
+Uint16
+SDL_ReadLE16(SDL_RWops * src)
+{
+    Uint16 value;
+
+    SDL_RWread(src, &value, (sizeof value), 1);
+    return (SDL_SwapLE16(value));
+}
+
+Uint16
+SDL_ReadBE16(SDL_RWops * src)
+{
+    Uint16 value;
+
+    SDL_RWread(src, &value, (sizeof value), 1);
+    return (SDL_SwapBE16(value));
+}
+
+Uint32
+SDL_ReadLE32(SDL_RWops * src)
+{
+    Uint32 value;
+
+    SDL_RWread(src, &value, (sizeof value), 1);
+    return (SDL_SwapLE32(value));
+}
+
+Uint32
+SDL_ReadBE32(SDL_RWops * src)
+{
+    Uint32 value;
+
+    SDL_RWread(src, &value, (sizeof value), 1);
+    return (SDL_SwapBE32(value));
+}
+
+Uint64
+SDL_ReadLE64(SDL_RWops * src)
+{
+    Uint64 value;
+
+    SDL_RWread(src, &value, (sizeof value), 1);
+    return (SDL_SwapLE64(value));
+}
+
+Uint64
+SDL_ReadBE64(SDL_RWops * src)
+{
+    Uint64 value;
+
+    SDL_RWread(src, &value, (sizeof value), 1);
+    return (SDL_SwapBE64(value));
+}
+
+size_t
+SDL_WriteLE16(SDL_RWops * dst, Uint16 value)
+{
+    value = SDL_SwapLE16(value);
+    return (SDL_RWwrite(dst, &value, (sizeof value), 1));
+}
+
+size_t
+SDL_WriteBE16(SDL_RWops * dst, Uint16 value)
+{
+    value = SDL_SwapBE16(value);
+    return (SDL_RWwrite(dst, &value, (sizeof value), 1));
+}
+
+size_t
+SDL_WriteLE32(SDL_RWops * dst, Uint32 value)
+{
+    value = SDL_SwapLE32(value);
+    return (SDL_RWwrite(dst, &value, (sizeof value), 1));
+}
+
+size_t
+SDL_WriteBE32(SDL_RWops * dst, Uint32 value)
+{
+    value = SDL_SwapBE32(value);
+    return (SDL_RWwrite(dst, &value, (sizeof value), 1));
+}
+
+size_t
+SDL_WriteLE64(SDL_RWops * dst, Uint64 value)
+{
+    value = SDL_SwapLE64(value);
+    return (SDL_RWwrite(dst, &value, (sizeof value), 1));
+}
+
+size_t
+SDL_WriteBE64(SDL_RWops * dst, Uint64 value)
+{
+    value = SDL_SwapBE64(value);
+    return (SDL_RWwrite(dst, &value, (sizeof value), 1));
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/file/cocoa/SDL_rwopsbundlesupport.h b/macosx/plugins/Common/SDL/src/file/cocoa/SDL_rwopsbundlesupport.h
new file mode 100644
index 00000000..6929904c
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/file/cocoa/SDL_rwopsbundlesupport.h
@@ -0,0 +1,9 @@
+#ifdef __APPLE__
+
+#include <stdio.h>
+
+#ifndef SDL_rwopsbundlesupport_h
+#define SDL_rwopsbundlesupport_h
+FILE* SDL_OpenFPFromBundleOrFallback(const char *file, const char *mode);
+#endif
+#endif
diff --git a/macosx/plugins/Common/SDL/src/file/cocoa/SDL_rwopsbundlesupport.m b/macosx/plugins/Common/SDL/src/file/cocoa/SDL_rwopsbundlesupport.m
new file mode 100644
index 00000000..39b4c0e9
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/file/cocoa/SDL_rwopsbundlesupport.m
@@ -0,0 +1,45 @@
+#ifdef __APPLE__
+#import <Foundation/Foundation.h>
+
+#include "SDL_rwopsbundlesupport.h"
+
+/* For proper OS X applications, the resources are contained inside the application bundle.
+ So the strategy is to first check the application bundle for the file, then fallback to the current working directory.
+ Note: One additional corner-case is if the resource is in a framework's resource bundle instead of the app.
+ We might want to use bundle identifiers, e.g. org.libsdl.sdl to get the bundle for the framework,
+ but we would somehow need to know what the bundle identifiers we need to search are.
+ Also, note the bundle layouts are different for iPhone and Mac.
+*/
+FILE* SDL_OpenFPFromBundleOrFallback(const char *file, const char *mode)
+{
+    FILE* fp = NULL;
+
+	// If the file mode is writable, skip all the bundle stuff because generally the bundle is read-only.
+	if(strcmp("r", mode) && strcmp("rb", mode))
+	{
+		return fopen(file, mode);
+	}
+
+	NSAutoreleasePool* autorelease_pool = [[NSAutoreleasePool alloc] init];
+
+
+	NSFileManager* file_manager = [NSFileManager defaultManager];
+	NSString* resource_path = [[NSBundle mainBundle] resourcePath];
+
+	NSString* ns_string_file_component = [file_manager stringWithFileSystemRepresentation:file length:strlen(file)];
+
+	NSString* full_path_with_file_to_try = [resource_path stringByAppendingPathComponent:ns_string_file_component];
+	if([file_manager fileExistsAtPath:full_path_with_file_to_try])
+	{
+		fp = fopen([full_path_with_file_to_try fileSystemRepresentation], mode);
+	}
+	else
+	{
+		fp = fopen(file, mode);
+	}
+
+	[autorelease_pool drain];
+
+	return fp;
+}
+#endif
diff --git a/macosx/plugins/Common/SDL/src/haptic/SDL_haptic.c b/macosx/plugins/Common/SDL/src/haptic/SDL_haptic.c
new file mode 100644
index 00000000..af8c39a7
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/haptic/SDL_haptic.c
@@ -0,0 +1,708 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 2008 Edgar Simo
+
+    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_syshaptic.h"
+#include "SDL_haptic_c.h"
+#include "../joystick/SDL_joystick_c.h" /* For SDL_PrivateJoystickValid */
+
+
+Uint8 SDL_numhaptics = 0;
+SDL_Haptic **SDL_haptics = NULL;
+
+
+/*
+ * Initializes the Haptic devices.
+ */
+int
+SDL_HapticInit(void)
+{
+    int arraylen;
+    int status;
+
+    SDL_numhaptics = 0;
+    status = SDL_SYS_HapticInit();
+    if (status >= 0) {
+        arraylen = (status + 1) * sizeof(*SDL_haptics);
+        SDL_haptics = (SDL_Haptic **) SDL_malloc(arraylen);
+        if (SDL_haptics == NULL) {      /* Out of memory. */
+            SDL_numhaptics = 0;
+        } else {
+            SDL_memset(SDL_haptics, 0, arraylen);
+            SDL_numhaptics = status;
+        }
+        status = 0;
+    }
+
+    return status;
+}
+
+
+/*
+ * Checks to see if the haptic device is valid
+ */
+static int
+ValidHaptic(SDL_Haptic * haptic)
+{
+    int i;
+    int valid;
+
+    valid = 0;
+    if (haptic != NULL) {
+        for (i = 0; i < SDL_numhaptics; i++) {
+            if (SDL_haptics[i] == haptic) {
+                valid = 1;
+                break;
+            }
+        }
+    }
+
+    /* Create the error here. */
+    if (valid == 0) {
+        SDL_SetError("Haptic: Invalid haptic device identifier");
+    }
+
+    return valid;
+}
+
+
+/*
+ * Returns the number of available devices.
+ */
+int
+SDL_NumHaptics(void)
+{
+    return SDL_numhaptics;
+}
+
+
+/*
+ * Gets the name of a Haptic device by index.
+ */
+const char *
+SDL_HapticName(int device_index)
+{
+    if ((device_index < 0) || (device_index >= SDL_numhaptics)) {
+        SDL_SetError("Haptic: There are %d haptic devices available",
+                     SDL_numhaptics);
+        return NULL;
+    }
+    return SDL_SYS_HapticName(device_index);
+}
+
+
+/*
+ * Opens a Haptic device.
+ */
+SDL_Haptic *
+SDL_HapticOpen(int device_index)
+{
+    int i;
+    SDL_Haptic *haptic;
+
+    if ((device_index < 0) || (device_index >= SDL_numhaptics)) {
+        SDL_SetError("Haptic: There are %d haptic devices available",
+                     SDL_numhaptics);
+        return NULL;
+    }
+
+    /* If the haptic is already open, return it */
+    for (i = 0; SDL_haptics[i]; i++) {
+        if (device_index == SDL_haptics[i]->index) {
+            haptic = SDL_haptics[i];
+            ++haptic->ref_count;
+            return haptic;
+        }
+    }
+
+    /* Create the haptic device */
+    haptic = (SDL_Haptic *) SDL_malloc((sizeof *haptic));
+    if (haptic == NULL) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    /* Initialize the haptic device */
+    SDL_memset(haptic, 0, (sizeof *haptic));
+    haptic->index = device_index;
+    if (SDL_SYS_HapticOpen(haptic) < 0) {
+        SDL_free(haptic);
+        return NULL;
+    }
+
+    /* Disable autocenter and set gain to max. */
+    if (haptic->supported & SDL_HAPTIC_GAIN)
+        SDL_HapticSetGain(haptic, 100);
+    if (haptic->supported & SDL_HAPTIC_AUTOCENTER)
+        SDL_HapticSetAutocenter(haptic, 0);
+
+    /* Add haptic to list */
+    ++haptic->ref_count;
+    for (i = 0; SDL_haptics[i]; i++)
+        /* Skip to next haptic */ ;
+    SDL_haptics[i] = haptic;
+
+    return haptic;
+}
+
+
+/*
+ * Returns 1 if the device has been opened.
+ */
+int
+SDL_HapticOpened(int device_index)
+{
+    int i, opened;
+
+    opened = 0;
+    for (i = 0; SDL_haptics[i]; i++) {
+        if (SDL_haptics[i]->index == (Uint8) device_index) {
+            opened = 1;
+            break;
+        }
+    }
+    return opened;
+}
+
+
+/*
+ * Returns the index to a haptic device.
+ */
+int
+SDL_HapticIndex(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    return haptic->index;
+}
+
+
+/*
+ * Returns SDL_TRUE if mouse is haptic, SDL_FALSE if it isn't.
+ */
+int
+SDL_MouseIsHaptic(void)
+{
+    if (SDL_SYS_HapticMouse() < 0)
+        return SDL_FALSE;
+    return SDL_TRUE;
+}
+
+
+/*
+ * Returns the haptic device if mouse is haptic or NULL elsewise.
+ */
+SDL_Haptic *
+SDL_HapticOpenFromMouse(void)
+{
+    int device_index;
+
+    device_index = SDL_SYS_HapticMouse();
+
+    if (device_index < 0) {
+        SDL_SetError("Haptic: Mouse isn't a haptic device.");
+        return NULL;
+    }
+
+    return SDL_HapticOpen(device_index);
+}
+
+
+/*
+ * Returns SDL_TRUE if joystick has haptic features.
+ */
+int
+SDL_JoystickIsHaptic(SDL_Joystick * joystick)
+{
+    int ret;
+
+    /* Must be a valid joystick */
+    if (!SDL_PrivateJoystickValid(&joystick)) {
+        return -1;
+    }
+
+    ret = SDL_SYS_JoystickIsHaptic(joystick);
+
+    if (ret > 0)
+        return SDL_TRUE;
+    else if (ret == 0)
+        return SDL_FALSE;
+    else
+        return -1;
+}
+
+
+/*
+ * Opens a haptic device from a joystick.
+ */
+SDL_Haptic *
+SDL_HapticOpenFromJoystick(SDL_Joystick * joystick)
+{
+    int i;
+    SDL_Haptic *haptic;
+
+    /* Must be a valid joystick */
+    if (!SDL_PrivateJoystickValid(&joystick)) {
+        SDL_SetError("Haptic: Joystick isn't valid.");
+        return NULL;
+    }
+
+    /* Joystick must be haptic */
+    if (SDL_SYS_JoystickIsHaptic(joystick) <= 0) {
+        SDL_SetError("Haptic: Joystick isn't a haptic device.");
+        return NULL;
+    }
+
+    /* Check to see if joystick's haptic is already open */
+    for (i = 0; SDL_haptics[i]; i++) {
+        if (SDL_SYS_JoystickSameHaptic(SDL_haptics[i], joystick)) {
+            haptic = SDL_haptics[i];
+            ++haptic->ref_count;
+            return haptic;
+        }
+    }
+
+    /* Create the haptic device */
+    haptic = (SDL_Haptic *) SDL_malloc((sizeof *haptic));
+    if (haptic == NULL) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    /* Initialize the haptic device */
+    SDL_memset(haptic, 0, sizeof(SDL_Haptic));
+    if (SDL_SYS_HapticOpenFromJoystick(haptic, joystick) < 0) {
+        SDL_free(haptic);
+        return NULL;
+    }
+
+    /* Add haptic to list */
+    ++haptic->ref_count;
+    for (i = 0; SDL_haptics[i]; i++)
+        /* Skip to next haptic */ ;
+    SDL_haptics[i] = haptic;
+
+    return haptic;
+}
+
+
+/*
+ * Closes a SDL_Haptic device.
+ */
+void
+SDL_HapticClose(SDL_Haptic * haptic)
+{
+    int i;
+
+    /* Must be valid */
+    if (!ValidHaptic(haptic)) {
+        return;
+    }
+
+    /* Check if it's still in use */
+    if (--haptic->ref_count < 0) {
+        return;
+    }
+
+    /* Close it, properly removing effects if needed */
+    for (i = 0; i < haptic->neffects; i++) {
+        if (haptic->effects[i].hweffect != NULL) {
+            SDL_HapticDestroyEffect(haptic, i);
+        }
+    }
+    SDL_SYS_HapticClose(haptic);
+
+    /* Remove from the list */
+    for (i = 0; SDL_haptics[i]; ++i) {
+        if (haptic == SDL_haptics[i]) {
+            SDL_haptics[i] = NULL;
+            SDL_memcpy(&SDL_haptics[i], &SDL_haptics[i + 1],
+                       (SDL_numhaptics - i) * sizeof(haptic));
+            break;
+        }
+    }
+
+    /* Free */
+    SDL_free(haptic);
+}
+
+/*
+ * Cleans up after the subsystem.
+ */
+void
+SDL_HapticQuit(void)
+{
+    SDL_SYS_HapticQuit();
+    if (SDL_haptics != NULL) {
+        SDL_free(SDL_haptics);
+        SDL_haptics = NULL;
+    }
+    SDL_numhaptics = 0;
+}
+
+/*
+ * Returns the number of effects a haptic device has.
+ */
+int
+SDL_HapticNumEffects(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    return haptic->neffects;
+}
+
+
+/*
+ * Returns the number of effects a haptic device can play.
+ */
+int
+SDL_HapticNumEffectsPlaying(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    return haptic->nplaying;
+}
+
+
+/*
+ * Returns supported effects by the device.
+ */
+unsigned int
+SDL_HapticQuery(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    return haptic->supported;
+}
+
+
+/*
+ * Returns the number of axis on the device.
+ */
+int
+SDL_HapticNumAxes(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    return haptic->naxes;
+}
+
+/*
+ * Checks to see if the device can support the effect.
+ */
+int
+SDL_HapticEffectSupported(SDL_Haptic * haptic, SDL_HapticEffect * effect)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    if ((haptic->supported & effect->type) != 0)
+        return SDL_TRUE;
+    return SDL_FALSE;
+}
+
+/*
+ * Creates a new haptic effect.
+ */
+int
+SDL_HapticNewEffect(SDL_Haptic * haptic, SDL_HapticEffect * effect)
+{
+    int i;
+
+    /* Check for device validity. */
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    /* Check to see if effect is supported */
+    if (SDL_HapticEffectSupported(haptic, effect) == SDL_FALSE) {
+        SDL_SetError("Haptic: Effect not supported by haptic device.");
+        return -1;
+    }
+
+    /* See if there's a free slot */
+    for (i = 0; i < haptic->neffects; i++) {
+        if (haptic->effects[i].hweffect == NULL) {
+
+            /* Now let the backend create the real effect */
+            if (SDL_SYS_HapticNewEffect(haptic, &haptic->effects[i], effect)
+                != 0) {
+                return -1;      /* Backend failed to create effect */
+            }
+
+            SDL_memcpy(&haptic->effects[i].effect, effect,
+                       sizeof(SDL_HapticEffect));
+            return i;
+        }
+    }
+
+    SDL_SetError("Haptic: Device has no free space left.");
+    return -1;
+}
+
+/*
+ * Checks to see if an effect is valid.
+ */
+static int
+ValidEffect(SDL_Haptic * haptic, int effect)
+{
+    if ((effect < 0) || (effect >= haptic->neffects)) {
+        SDL_SetError("Haptic: Invalid effect identifier.");
+        return 0;
+    }
+    return 1;
+}
+
+/*
+ * Updates an effect.
+ */
+int
+SDL_HapticUpdateEffect(SDL_Haptic * haptic, int effect,
+                       SDL_HapticEffect * data)
+{
+    if (!ValidHaptic(haptic) || !ValidEffect(haptic, effect)) {
+        return -1;
+    }
+
+    /* Can't change type dynamically. */
+    if (data->type != haptic->effects[effect].effect.type) {
+        SDL_SetError("Haptic: Updating effect type is illegal.");
+        return -1;
+    }
+
+    /* Updates the effect */
+    if (SDL_SYS_HapticUpdateEffect(haptic, &haptic->effects[effect], data) <
+        0) {
+        return -1;
+    }
+
+    SDL_memcpy(&haptic->effects[effect].effect, data,
+               sizeof(SDL_HapticEffect));
+    return 0;
+}
+
+
+/*
+ * Runs the haptic effect on the device.
+ */
+int
+SDL_HapticRunEffect(SDL_Haptic * haptic, int effect, Uint32 iterations)
+{
+    if (!ValidHaptic(haptic) || !ValidEffect(haptic, effect)) {
+        return -1;
+    }
+
+    /* Run the effect */
+    if (SDL_SYS_HapticRunEffect(haptic, &haptic->effects[effect], iterations)
+        < 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * Stops the haptic effect on the device.
+ */
+int
+SDL_HapticStopEffect(SDL_Haptic * haptic, int effect)
+{
+    if (!ValidHaptic(haptic) || !ValidEffect(haptic, effect)) {
+        return -1;
+    }
+
+    /* Stop the effect */
+    if (SDL_SYS_HapticStopEffect(haptic, &haptic->effects[effect]) < 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * Gets rid of a haptic effect.
+ */
+void
+SDL_HapticDestroyEffect(SDL_Haptic * haptic, int effect)
+{
+    if (!ValidHaptic(haptic) || !ValidEffect(haptic, effect)) {
+        return;
+    }
+
+    /* Not allocated */
+    if (haptic->effects[effect].hweffect == NULL) {
+        return;
+    }
+
+    SDL_SYS_HapticDestroyEffect(haptic, &haptic->effects[effect]);
+}
+
+/*
+ * Gets the status of a haptic effect.
+ */
+int
+SDL_HapticGetEffectStatus(SDL_Haptic * haptic, int effect)
+{
+    if (!ValidHaptic(haptic) || !ValidEffect(haptic, effect)) {
+        return -1;
+    }
+
+    if ((haptic->supported & SDL_HAPTIC_STATUS) == 0) {
+        SDL_SetError("Haptic: Device does not support status queries.");
+        return -1;
+    }
+
+    return SDL_SYS_HapticGetEffectStatus(haptic, &haptic->effects[effect]);
+}
+
+/*
+ * Sets the global gain of the device.
+ */
+int
+SDL_HapticSetGain(SDL_Haptic * haptic, int gain)
+{
+    const char *env;
+    int real_gain, max_gain;
+
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    if ((haptic->supported & SDL_HAPTIC_GAIN) == 0) {
+        SDL_SetError("Haptic: Device does not support setting gain.");
+        return -1;
+    }
+
+    if ((gain < 0) || (gain > 100)) {
+        SDL_SetError("Haptic: Gain must be between 0 and 100.");
+        return -1;
+    }
+
+    /* We use the envvar to get the maximum gain. */
+    env = SDL_getenv("SDL_HAPTIC_GAIN_MAX");
+    if (env != NULL) {
+        max_gain = SDL_atoi(env);
+
+        /* Check for sanity. */
+        if (max_gain < 0)
+            max_gain = 0;
+        else if (max_gain > 100)
+            max_gain = 100;
+
+        /* We'll scale it linearly with SDL_HAPTIC_GAIN_MAX */
+        real_gain = (gain * max_gain) / 100;
+    } else {
+        real_gain = gain;
+    }
+
+    if (SDL_SYS_HapticSetGain(haptic, real_gain) < 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * Makes the device autocenter, 0 disables.
+ */
+int
+SDL_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    if ((haptic->supported & SDL_HAPTIC_AUTOCENTER) == 0) {
+        SDL_SetError("Haptic: Device does not support setting autocenter.");
+        return -1;
+    }
+
+    if ((autocenter < 0) || (autocenter > 100)) {
+        SDL_SetError("Haptic: Autocenter must be between 0 and 100.");
+        return -1;
+    }
+
+    if (SDL_SYS_HapticSetAutocenter(haptic, autocenter) < 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+/*
+ * Pauses the haptic device.
+ */
+int
+SDL_HapticPause(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    if ((haptic->supported & SDL_HAPTIC_PAUSE) == 0) {
+        SDL_SetError("Haptic: Device does not support setting pausing.");
+        return -1;
+    }
+
+    return SDL_SYS_HapticPause(haptic);
+}
+
+/*
+ * Unpauses the haptic device.
+ */
+int
+SDL_HapticUnpause(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    if ((haptic->supported & SDL_HAPTIC_PAUSE) == 0) {
+        return 0;               /* Not going to be paused, so we pretend it's unpaused. */
+    }
+
+    return SDL_SYS_HapticUnpause(haptic);
+}
+
+/*
+ * Stops all the currently playing effects.
+ */
+int
+SDL_HapticStopAll(SDL_Haptic * haptic)
+{
+    if (!ValidHaptic(haptic)) {
+        return -1;
+    }
+
+    return SDL_SYS_HapticStopAll(haptic);
+}
diff --git a/macosx/plugins/Common/SDL/src/haptic/SDL_haptic_c.h b/macosx/plugins/Common/SDL/src/haptic/SDL_haptic_c.h
new file mode 100644
index 00000000..4144a0fb
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/haptic/SDL_haptic_c.h
@@ -0,0 +1,26 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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
+*/
+
+extern int SDL_HapticInit(void);
+extern void SDL_HapticQuit(void);
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/haptic/SDL_syshaptic.h b/macosx/plugins/Common/SDL/src/haptic/SDL_syshaptic.h
new file mode 100644
index 00000000..9542a0d7
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/haptic/SDL_syshaptic.h
@@ -0,0 +1,201 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 2008 Edgar Simo
+
+    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_haptic.h"
+
+
+/*
+ * Number of haptic devices on the system.
+ */
+extern Uint8 SDL_numhaptics;
+
+
+struct haptic_effect
+{
+    SDL_HapticEffect effect;    /* The current event */
+    struct haptic_hweffect *hweffect;   /* The hardware behind the event */
+};
+
+/*
+ * The real SDL_Haptic struct.
+ */
+struct _SDL_Haptic
+{
+    Uint8 index;                /* Stores index it is attached to */
+
+    struct haptic_effect *effects;      /* Allocated effects */
+    int neffects;               /* Maximum amount of effects */
+    int nplaying;               /* Maximum amount of effects to play at the same time */
+    unsigned int supported;     /* Supported effects */
+    int naxes;                  /* Number of axes on the device. */
+
+    struct haptic_hwdata *hwdata;       /* Driver dependent */
+    int ref_count;              /* Count for multiple opens */
+};
+
+/* 
+ * Scans the system for haptic devices.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticInit(void);
+
+/*
+ * Gets the device dependent name of the haptic device
+ */
+extern const char *SDL_SYS_HapticName(int index);
+
+/*
+ * Opens the haptic device for usage.  The haptic device should have
+ * the index value set previously.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticOpen(SDL_Haptic * haptic);
+
+/*
+ * Returns the index of the haptic core pointer or -1 if none is found.
+ */
+int SDL_SYS_HapticMouse(void);
+
+/*
+ * Checks to see if the joystick has haptic capabilities.
+ *
+ * Returns >0 if haptic capabilities are detected, 0 if haptic
+ * capabilities aren't detected and -1 on error.
+ */
+extern int SDL_SYS_JoystickIsHaptic(SDL_Joystick * joystick);
+
+/*
+ * Opens the haptic device for usage using the same device as
+ * the joystick.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticOpenFromJoystick(SDL_Haptic * haptic,
+                                          SDL_Joystick * joystick);
+/*
+ * Checks to see if haptic device and joystick device are the same.
+ *
+ * Returns 1 if they are the same, 0 if they aren't.
+ */
+extern int SDL_SYS_JoystickSameHaptic(SDL_Haptic * haptic,
+                                      SDL_Joystick * joystick);
+
+/*
+ * Closes a haptic device after usage.
+ */
+extern void SDL_SYS_HapticClose(SDL_Haptic * haptic);
+
+/*
+ * Performs a cleanup on the haptic subsystem.
+ */
+extern void SDL_SYS_HapticQuit(void);
+
+/*
+ * Creates a new haptic effect on the haptic device using base
+ * as a template for the effect.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticNewEffect(SDL_Haptic * haptic,
+                                   struct haptic_effect *effect,
+                                   SDL_HapticEffect * base);
+
+/*
+ * Updates the haptic effect on the haptic device using data
+ * as a template.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticUpdateEffect(SDL_Haptic * haptic,
+                                      struct haptic_effect *effect,
+                                      SDL_HapticEffect * data);
+
+/*
+ * Runs the effect on the haptic device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticRunEffect(SDL_Haptic * haptic,
+                                   struct haptic_effect *effect,
+                                   Uint32 iterations);
+
+/*
+ * Stops the effect on the haptic device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticStopEffect(SDL_Haptic * haptic,
+                                    struct haptic_effect *effect);
+
+/*
+ * Cleanups up the effect on the haptic device.
+ */
+extern void SDL_SYS_HapticDestroyEffect(SDL_Haptic * haptic,
+                                        struct haptic_effect *effect);
+
+/*
+ * Queries the device for the status of effect.
+ *
+ * Returns 0 if device is stopped, >0 if device is playing and
+ * -1 on error.
+ */
+extern int SDL_SYS_HapticGetEffectStatus(SDL_Haptic * haptic,
+                                         struct haptic_effect *effect);
+
+/*
+ * Sets the global gain of the haptic device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticSetGain(SDL_Haptic * haptic, int gain);
+
+/*
+ * Sets the autocenter feature of the haptic device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter);
+
+/*
+ * Pauses the haptic device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticPause(SDL_Haptic * haptic);
+
+/*
+ * Unpauses the haptic device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticUnpause(SDL_Haptic * haptic);
+
+/*
+ * Stops all the currently playing haptic effects on the device.
+ *
+ * Returns 0 on success, -1 on error.
+ */
+extern int SDL_SYS_HapticStopAll(SDL_Haptic * haptic);
diff --git a/macosx/plugins/Common/SDL/src/haptic/darwin/SDL_syshaptic.c b/macosx/plugins/Common/SDL/src/haptic/darwin/SDL_syshaptic.c
new file mode 100644
index 00000000..c5b1e54b
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/haptic/darwin/SDL_syshaptic.c
@@ -0,0 +1,1321 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 2008 Edgar Simo
+
+    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"
+
+#ifdef SDL_HAPTIC_IOKIT
+
+#include "SDL_haptic.h"
+#include "../SDL_syshaptic.h"
+#include "SDL_joystick.h"
+#include "../../joystick/SDL_sysjoystick.h"     /* For the real SDL_Joystick */
+#include "../../joystick/darwin/SDL_sysjoystick_c.h"    /* For joystick hwdata */
+
+#include <IOKit/IOKitLib.h>
+#include <IOKit/hid/IOHIDKeys.h>
+#include <IOKit/hid/IOHIDUsageTables.h>
+#include <ForceFeedback/ForceFeedback.h>
+#include <ForceFeedback/ForceFeedbackConstants.h>
+
+#ifndef IO_OBJECT_NULL
+#define IO_OBJECT_NULL	((io_service_t)0)
+#endif
+
+#define MAX_HAPTICS  32
+
+
+/*
+ * List of available haptic devices.
+ */
+static struct
+{
+    char name[256];             /* Name of the device. */
+
+    io_service_t dev;           /* Node we use to create the device. */
+    SDL_Haptic *haptic;         /* Haptic currently assosciated with it. */
+
+    /* Usage pages for determining if it's a mouse or not. */
+    long usage;
+    long usagePage;
+} SDL_hapticlist[MAX_HAPTICS];
+
+
+/*
+ * Haptic system hardware data.
+ */
+struct haptic_hwdata
+{
+    FFDeviceObjectReference device;     /* Hardware device. */
+    UInt8 axes[3];
+};
+
+
+/*
+ * Haptic system effect data.
+ */
+struct haptic_hweffect
+{
+    FFEffectObjectReference ref;        /* Reference. */
+    struct FFEFFECT effect;     /* Hardware effect. */
+};
+
+/*
+ * Prototypes.
+ */
+static void SDL_SYS_HapticFreeFFEFFECT(FFEFFECT * effect, int type);
+static int HIDGetDeviceProduct(io_service_t dev, char *name);
+
+
+/* 
+ * Like strerror but for force feedback errors.
+ */
+static const char *
+FFStrError(HRESULT err)
+{
+    switch (err) {
+    case FFERR_DEVICEFULL:
+        return "device full";
+        /* This should be valid, but for some reason isn't defined... */
+        /*case FFERR_DEVICENOTREG:
+           return "device not registered"; */
+    case FFERR_DEVICEPAUSED:
+        return "device paused";
+    case FFERR_DEVICERELEASED:
+        return "device released";
+    case FFERR_EFFECTPLAYING:
+        return "effect playing";
+    case FFERR_EFFECTTYPEMISMATCH:
+        return "effect type mismatch";
+    case FFERR_EFFECTTYPENOTSUPPORTED:
+        return "effect type not supported";
+    case FFERR_GENERIC:
+        return "undetermined error";
+    case FFERR_HASEFFECTS:
+        return "device has effects";
+    case FFERR_INCOMPLETEEFFECT:
+        return "incomplete effect";
+    case FFERR_INTERNAL:
+        return "internal fault";
+    case FFERR_INVALIDDOWNLOADID:
+        return "invalid download id";
+    case FFERR_INVALIDPARAM:
+        return "invalid parameter";
+    case FFERR_MOREDATA:
+        return "more data";
+    case FFERR_NOINTERFACE:
+        return "interface not supported";
+    case FFERR_NOTDOWNLOADED:
+        return "effect is not downloaded";
+    case FFERR_NOTINITIALIZED:
+        return "object has not been initialized";
+    case FFERR_OUTOFMEMORY:
+        return "out of memory";
+    case FFERR_UNPLUGGED:
+        return "device is unplugged";
+    case FFERR_UNSUPPORTED:
+        return "function call unsupported";
+    case FFERR_UNSUPPORTEDAXIS:
+        return "axis unsupported";
+
+    default:
+        return "unknown error";
+    }
+}
+
+
+/*
+ * Initializes the haptic subsystem.
+ */
+int
+SDL_SYS_HapticInit(void)
+{
+    int numhaptics;
+    IOReturn result;
+    io_iterator_t iter;
+    CFDictionaryRef match;
+    io_service_t device;
+    CFMutableDictionaryRef hidProperties;
+    CFTypeRef refCF;
+
+    /* Clear all the memory. */
+    SDL_memset(SDL_hapticlist, 0, sizeof(SDL_hapticlist));
+
+    /* Get HID devices. */
+    match = IOServiceMatching(kIOHIDDeviceKey);
+    if (match == NULL) {
+        SDL_SetError("Haptic: Failed to get IOServiceMatching.");
+        return -1;
+    }
+
+    /* Now search I/O Registry for matching devices. */
+    result = IOServiceGetMatchingServices(kIOMasterPortDefault, match, &iter);
+    if (result != kIOReturnSuccess) {
+        SDL_SetError("Haptic: Couldn't create a HID object iterator.");
+        return -1;
+    }
+    /* IOServiceGetMatchingServices consumes dictionary. */
+
+    if (!IOIteratorIsValid(iter)) {     /* No iterator. */
+        numhaptics = 0;
+        return 0;
+    }
+
+    numhaptics = 0;
+    while ((device = IOIteratorNext(iter)) != IO_OBJECT_NULL) {
+
+        /* Check for force feedback. */
+        if (FFIsForceFeedback(device) == FF_OK) {
+
+            /* Set basic device data. */
+            HIDGetDeviceProduct(device, SDL_hapticlist[numhaptics].name);
+            SDL_hapticlist[numhaptics].dev = device;
+            SDL_hapticlist[numhaptics].haptic = NULL;
+
+            /* Set usage pages. */
+            hidProperties = 0;
+            refCF = 0;
+            result = IORegistryEntryCreateCFProperties(device,
+                                                       &hidProperties,
+                                                       kCFAllocatorDefault,
+                                                       kNilOptions);
+            if ((result == KERN_SUCCESS) && hidProperties) {
+                refCF =
+                    CFDictionaryGetValue(hidProperties,
+                                         CFSTR(kIOHIDPrimaryUsagePageKey));
+                if (refCF) {
+                    if (!CFNumberGetValue(refCF, kCFNumberLongType,
+                                          &SDL_hapticlist[numhaptics].
+                                          usagePage))
+                        SDL_SetError
+                            ("Haptic: Recieving device's usage page.");
+                    refCF =
+                        CFDictionaryGetValue(hidProperties,
+                                             CFSTR(kIOHIDPrimaryUsageKey));
+                    if (refCF) {
+                        if (!CFNumberGetValue(refCF, kCFNumberLongType,
+                                              &SDL_hapticlist[numhaptics].
+                                              usage))
+                            SDL_SetError("Haptic: Recieving device's usage.");
+                    }
+                }
+                CFRelease(hidProperties);
+            }
+
+            /* Device has been added. */
+            numhaptics++;
+        } else {                /* Free the unused device. */
+            IOObjectRelease(device);
+        }
+
+        /* Reached haptic limit. */
+        if (numhaptics >= MAX_HAPTICS)
+            break;
+    }
+    IOObjectRelease(iter);
+
+    return numhaptics;
+}
+
+
+/*
+ * Return the name of a haptic device, does not need to be opened.
+ */
+const char *
+SDL_SYS_HapticName(int index)
+{
+    return SDL_hapticlist[index].name;
+}
+
+/*
+ * Gets the device's product name.
+ */
+static int
+HIDGetDeviceProduct(io_service_t dev, char *name)
+{
+    CFMutableDictionaryRef hidProperties, usbProperties;
+    io_registry_entry_t parent1, parent2;
+    kern_return_t ret;
+
+    hidProperties = usbProperties = 0;
+
+    ret = IORegistryEntryCreateCFProperties(dev, &hidProperties,
+                                            kCFAllocatorDefault, kNilOptions);
+    if ((ret != KERN_SUCCESS) || !hidProperties) {
+        SDL_SetError("Haptic: Unable to create CFProperties.");
+        return -1;
+    }
+
+    /* Mac OS X currently is not mirroring all USB properties to HID page so need to look at USB device page also
+     * get dictionary for usb properties: step up two levels and get CF dictionary for USB properties
+     */
+    if ((KERN_SUCCESS ==
+         IORegistryEntryGetParentEntry(dev, kIOServicePlane, &parent1))
+        && (KERN_SUCCESS ==
+            IORegistryEntryGetParentEntry(parent1, kIOServicePlane, &parent2))
+        && (KERN_SUCCESS ==
+            IORegistryEntryCreateCFProperties(parent2, &usbProperties,
+                                              kCFAllocatorDefault,
+                                              kNilOptions))) {
+        if (usbProperties) {
+            CFTypeRef refCF = 0;
+            /* get device info
+             * try hid dictionary first, if fail then go to usb dictionary
+             */
+
+
+            /* Get product name */
+            refCF =
+                CFDictionaryGetValue(hidProperties, CFSTR(kIOHIDProductKey));
+            if (!refCF)
+                refCF =
+                    CFDictionaryGetValue(usbProperties,
+                                         CFSTR("USB Product Name"));
+            if (refCF) {
+                if (!CFStringGetCString(refCF, name, 256,
+                                        CFStringGetSystemEncoding())) {
+                    SDL_SetError
+                        ("Haptic: CFStringGetCString error retrieving pDevice->product.");
+                    return -1;
+                }
+            }
+
+            CFRelease(usbProperties);
+        } else {
+            SDL_SetError
+                ("Haptic: IORegistryEntryCreateCFProperties failed to create usbProperties.");
+            return -1;
+        }
+
+        /* Release stuff. */
+        if (kIOReturnSuccess != IOObjectRelease(parent2)) {
+            SDL_SetError("Haptic: IOObjectRelease error with parent2.");
+        }
+        if (kIOReturnSuccess != IOObjectRelease(parent1)) {
+            SDL_SetError("Haptic: IOObjectRelease error with parent1.");
+        }
+    } else {
+        SDL_SetError("Haptic: Error getting registry entries.");
+        return -1;
+    }
+
+    return 0;
+}
+
+
+#define FF_TEST(ff, s) \
+if (features.supportedEffects & (ff)) supported |= (s)
+/*
+ * Gets supported features.
+ */
+static unsigned int
+GetSupportedFeatures(SDL_Haptic * haptic)
+{
+    HRESULT ret;
+    FFDeviceObjectReference device;
+    FFCAPABILITIES features;
+    unsigned int supported;
+    Uint32 val;
+
+    device = haptic->hwdata->device;
+
+    ret = FFDeviceGetForceFeedbackCapabilities(device, &features);
+    if (ret != FF_OK) {
+        SDL_SetError("Haptic: Unable to get device's supported features.");
+        return -1;
+    }
+
+    supported = 0;
+
+    /* Get maximum effects. */
+    haptic->neffects = features.storageCapacity;
+    haptic->nplaying = features.playbackCapacity;
+
+    /* Test for effects. */
+    FF_TEST(FFCAP_ET_CONSTANTFORCE, SDL_HAPTIC_CONSTANT);
+    FF_TEST(FFCAP_ET_RAMPFORCE, SDL_HAPTIC_RAMP);
+    FF_TEST(FFCAP_ET_SQUARE, SDL_HAPTIC_SQUARE);
+    FF_TEST(FFCAP_ET_SINE, SDL_HAPTIC_SINE);
+    FF_TEST(FFCAP_ET_TRIANGLE, SDL_HAPTIC_TRIANGLE);
+    FF_TEST(FFCAP_ET_SAWTOOTHUP, SDL_HAPTIC_SAWTOOTHUP);
+    FF_TEST(FFCAP_ET_SAWTOOTHDOWN, SDL_HAPTIC_SAWTOOTHDOWN);
+    FF_TEST(FFCAP_ET_SPRING, SDL_HAPTIC_SPRING);
+    FF_TEST(FFCAP_ET_DAMPER, SDL_HAPTIC_DAMPER);
+    FF_TEST(FFCAP_ET_INERTIA, SDL_HAPTIC_INERTIA);
+    FF_TEST(FFCAP_ET_FRICTION, SDL_HAPTIC_FRICTION);
+    FF_TEST(FFCAP_ET_CUSTOMFORCE, SDL_HAPTIC_CUSTOM);
+
+    /* Check if supports gain. */
+    ret = FFDeviceGetForceFeedbackProperty(device, FFPROP_FFGAIN,
+                                           &val, sizeof(val));
+    if (ret == FF_OK)
+        supported |= SDL_HAPTIC_GAIN;
+    else if (ret != FFERR_UNSUPPORTED) {
+        SDL_SetError("Haptic: Unable to get if device supports gain: %s.",
+                     FFStrError(ret));
+        return -1;
+    }
+
+    /* Checks if supports autocenter. */
+    ret = FFDeviceGetForceFeedbackProperty(device, FFPROP_AUTOCENTER,
+                                           &val, sizeof(val));
+    if (ret == FF_OK)
+        supported |= SDL_HAPTIC_AUTOCENTER;
+    else if (ret != FFERR_UNSUPPORTED) {
+        SDL_SetError
+            ("Haptic: Unable to get if device supports autocenter: %s.",
+             FFStrError(ret));
+        return -1;
+    }
+
+    /* Check for axes, we have an artificial limit on axes */
+    haptic->naxes = ((features.numFfAxes) > 3) ? 3 : features.numFfAxes;
+    /* Actually store the axes we want to use */
+    SDL_memcpy(haptic->hwdata->axes, features.ffAxes,
+               haptic->naxes * sizeof(Uint8));
+
+    /* Always supported features. */
+    supported |= SDL_HAPTIC_STATUS | SDL_HAPTIC_PAUSE;
+
+    haptic->supported = supported;
+    return 0;;
+}
+
+
+/*
+ * Opens the haptic device from the file descriptor.
+ */
+static int
+SDL_SYS_HapticOpenFromService(SDL_Haptic * haptic, io_service_t service)
+{
+    HRESULT ret;
+    int ret2;
+
+    /* Allocate the hwdata */
+    haptic->hwdata = (struct haptic_hwdata *)
+        SDL_malloc(sizeof(*haptic->hwdata));
+    if (haptic->hwdata == NULL) {
+        SDL_OutOfMemory();
+        goto creat_err;
+    }
+    SDL_memset(haptic->hwdata, 0, sizeof(*haptic->hwdata));
+
+    /* Open the device */
+    ret = FFCreateDevice(service, &haptic->hwdata->device);
+    if (ret != FF_OK) {
+        SDL_SetError("Haptic: Unable to create device from service: %s.",
+                     FFStrError(ret));
+        goto creat_err;
+    }
+
+    /* Get supported features. */
+    ret2 = GetSupportedFeatures(haptic);
+    if (haptic->supported < 0) {
+        goto open_err;
+    }
+
+
+    /* Reset and then enable actuators. */
+    ret = FFDeviceSendForceFeedbackCommand(haptic->hwdata->device,
+                                           FFSFFC_RESET);
+    if (ret != FF_OK) {
+        SDL_SetError("Haptic: Unable to reset device: %s.", FFStrError(ret));
+        goto open_err;
+    }
+    ret = FFDeviceSendForceFeedbackCommand(haptic->hwdata->device,
+                                           FFSFFC_SETACTUATORSON);
+    if (ret != FF_OK) {
+        SDL_SetError("Haptic: Unable to enable actuators: %s.",
+                     FFStrError(ret));
+        goto open_err;
+    }
+
+
+    /* Allocate effects memory. */
+    haptic->effects = (struct haptic_effect *)
+        SDL_malloc(sizeof(struct haptic_effect) * haptic->neffects);
+    if (haptic->effects == NULL) {
+        SDL_OutOfMemory();
+        goto open_err;
+    }
+    /* Clear the memory */
+    SDL_memset(haptic->effects, 0,
+               sizeof(struct haptic_effect) * haptic->neffects);
+
+    return 0;
+
+    /* Error handling */
+  open_err:
+    FFReleaseDevice(haptic->hwdata->device);
+  creat_err:
+    if (haptic->hwdata != NULL) {
+        free(haptic->hwdata);
+        haptic->hwdata = NULL;
+    }
+    return -1;
+
+}
+
+
+/*
+ * Opens a haptic device for usage.
+ */
+int
+SDL_SYS_HapticOpen(SDL_Haptic * haptic)
+{
+    return SDL_SYS_HapticOpenFromService(haptic,
+                                         SDL_hapticlist[haptic->index].dev);
+}
+
+
+/*
+ * Opens a haptic device from first mouse it finds for usage.
+ */
+int
+SDL_SYS_HapticMouse(void)
+{
+    int i;
+
+    for (i = 0; i < SDL_numhaptics; i++) {
+        if ((SDL_hapticlist[i].usagePage == kHIDPage_GenericDesktop) &&
+            (SDL_hapticlist[i].usage == kHIDUsage_GD_Mouse))
+            return i;
+    }
+
+    return -1;
+}
+
+
+/*
+ * Checks to see if a joystick has haptic features.
+ */
+int
+SDL_SYS_JoystickIsHaptic(SDL_Joystick * joystick)
+{
+    if (joystick->hwdata->ffservice != 0)
+        return SDL_TRUE;
+    return SDL_FALSE;
+}
+
+
+/*
+ * Checks to see if the haptic device and joystick and in reality the same.
+ */
+int
+SDL_SYS_JoystickSameHaptic(SDL_Haptic * haptic, SDL_Joystick * joystick)
+{
+    if (IOObjectIsEqualTo((io_object_t) haptic->hwdata->device,
+                          joystick->hwdata->ffservice))
+        return 1;
+    return 0;
+}
+
+
+/*
+ * Opens a SDL_Haptic from a SDL_Joystick.
+ */
+int
+SDL_SYS_HapticOpenFromJoystick(SDL_Haptic * haptic, SDL_Joystick * joystick)
+{
+    return SDL_SYS_HapticOpenFromService(haptic, joystick->hwdata->ffservice);
+}
+
+
+/*
+ * Closes the haptic device.
+ */
+void
+SDL_SYS_HapticClose(SDL_Haptic * haptic)
+{
+    if (haptic->hwdata) {
+
+        /* Free Effects. */
+        SDL_free(haptic->effects);
+        haptic->effects = NULL;
+        haptic->neffects = 0;
+
+        /* Clean up */
+        FFReleaseDevice(haptic->hwdata->device);
+
+        /* Free */
+        SDL_free(haptic->hwdata);
+        haptic->hwdata = NULL;
+    }
+}
+
+
+/* 
+ * Clean up after system specific haptic stuff
+ */
+void
+SDL_SYS_HapticQuit(void)
+{
+    int i;
+
+    for (i = 0; i < SDL_numhaptics; i++) {
+        /* Opened and not closed haptics are leaked, this is on purpose.
+         * Close your haptic devices after usage. */
+
+        /* Free the io_service_t */
+        IOObjectRelease(SDL_hapticlist[i].dev);
+    }
+}
+
+
+/*
+ * Converts an SDL trigger button to an FFEFFECT trigger button.
+ */
+static DWORD
+FFGetTriggerButton(Uint16 button)
+{
+    DWORD dwTriggerButton;
+
+    dwTriggerButton = FFEB_NOTRIGGER;
+
+    if (button != 0) {
+        dwTriggerButton = FFJOFS_BUTTON(button - 1);
+    }
+
+    return dwTriggerButton;
+}
+
+
+/*
+ * Sets the direction.
+ */
+static int
+SDL_SYS_SetDirection(FFEFFECT * effect, SDL_HapticDirection * dir, int naxes)
+{
+    LONG *rglDir;
+
+    /* Handle no axes a part. */
+    if (naxes == 0) {
+        effect->dwFlags |= FFEFF_SPHERICAL;     /* Set as default. */
+        effect->rglDirection = NULL;
+        return 0;
+    }
+
+    /* Has axes. */
+    rglDir = SDL_malloc(sizeof(LONG) * naxes);
+    if (rglDir == NULL) {
+        SDL_OutOfMemory();
+        return -1;
+    }
+    SDL_memset(rglDir, 0, sizeof(LONG) * naxes);
+    effect->rglDirection = rglDir;
+
+    switch (dir->type) {
+    case SDL_HAPTIC_POLAR:
+        effect->dwFlags |= FFEFF_POLAR;
+        rglDir[0] = dir->dir[0];
+        return 0;
+    case SDL_HAPTIC_CARTESIAN:
+        effect->dwFlags |= FFEFF_CARTESIAN;
+        rglDir[0] = dir->dir[0];
+        if (naxes > 1)
+            rglDir[1] = dir->dir[1];
+        if (naxes > 2)
+            rglDir[2] = dir->dir[2];
+        return 0;
+    case SDL_HAPTIC_SPHERICAL:
+        effect->dwFlags |= FFEFF_SPHERICAL;
+        rglDir[0] = dir->dir[0];
+        if (naxes > 1)
+            rglDir[1] = dir->dir[1];
+        if (naxes > 2)
+            rglDir[2] = dir->dir[2];
+        return 0;
+
+    default:
+        SDL_SetError("Haptic: Unknown direction type.");
+        return -1;
+    }
+}
+
+
+/* Clamps and converts. */
+#define CCONVERT(x)   (((x) > 0x7FFF) ? 10000 : ((x)*10000) / 0x7FFF)
+/* Just converts. */
+#define CONVERT(x)    (((x)*10000) / 0x7FFF)
+/*
+ * Creates the FFEFFECT from a SDL_HapticEffect.
+ */
+static int
+SDL_SYS_ToFFEFFECT(SDL_Haptic * haptic, FFEFFECT * dest,
+                   SDL_HapticEffect * src)
+{
+    int i;
+    FFCONSTANTFORCE *constant;
+    FFPERIODIC *periodic;
+    FFCONDITION *condition;     /* Actually an array of conditions - one per axis. */
+    FFRAMPFORCE *ramp;
+    FFCUSTOMFORCE *custom;
+    FFENVELOPE *envelope;
+    SDL_HapticConstant *hap_constant;
+    SDL_HapticPeriodic *hap_periodic;
+    SDL_HapticCondition *hap_condition;
+    SDL_HapticRamp *hap_ramp;
+    SDL_HapticCustom *hap_custom;
+    DWORD *axes;
+
+    /* Set global stuff. */
+    SDL_memset(dest, 0, sizeof(FFEFFECT));
+    dest->dwSize = sizeof(FFEFFECT);    /* Set the structure size. */
+    dest->dwSamplePeriod = 0;   /* Not used by us. */
+    dest->dwGain = 10000;       /* Gain is set globally, not locally. */
+    dest->dwFlags = FFEFF_OBJECTOFFSETS;        /* Seems obligatory. */
+
+    /* Envelope. */
+    envelope = SDL_malloc(sizeof(FFENVELOPE));
+    if (envelope == NULL) {
+        SDL_OutOfMemory();
+        return -1;
+    }
+    SDL_memset(envelope, 0, sizeof(FFENVELOPE));
+    dest->lpEnvelope = envelope;
+    envelope->dwSize = sizeof(FFENVELOPE);      /* Always should be this. */
+
+    /* Axes. */
+    dest->cAxes = haptic->naxes;
+    if (dest->cAxes > 0) {
+        axes = SDL_malloc(sizeof(DWORD) * dest->cAxes);
+        if (axes == NULL) {
+            SDL_OutOfMemory();
+            return -1;
+        }
+        axes[0] = haptic->hwdata->axes[0];      /* Always at least one axis. */
+        if (dest->cAxes > 1) {
+            axes[1] = haptic->hwdata->axes[1];
+        }
+        if (dest->cAxes > 2) {
+            axes[2] = haptic->hwdata->axes[2];
+        }
+        dest->rgdwAxes = axes;
+    }
+
+
+    /* The big type handling switch, even bigger then linux's version. */
+    switch (src->type) {
+    case SDL_HAPTIC_CONSTANT:
+        hap_constant = &src->constant;
+        constant = SDL_malloc(sizeof(FFCONSTANTFORCE));
+        if (constant == NULL) {
+            SDL_OutOfMemory();
+            return -1;
+        }
+        SDL_memset(constant, 0, sizeof(FFCONSTANTFORCE));
+
+        /* Specifics */
+        constant->lMagnitude = CONVERT(hap_constant->level);
+        dest->cbTypeSpecificParams = sizeof(FFCONSTANTFORCE);
+        dest->lpvTypeSpecificParams = constant;
+
+        /* Generics */
+        dest->dwDuration = hap_constant->length * 1000; /* In microseconds. */
+        dest->dwTriggerButton = FFGetTriggerButton(hap_constant->button);
+        dest->dwTriggerRepeatInterval = hap_constant->interval;
+        dest->dwStartDelay = hap_constant->delay * 1000;        /* In microseconds. */
+
+        /* Direction. */
+        if (SDL_SYS_SetDirection(dest, &hap_constant->direction, dest->cAxes)
+            < 0) {
+            return -1;
+        }
+
+        /* Envelope */
+        if ((hap_constant->attack_length == 0)
+            && (hap_constant->fade_length == 0)) {
+            SDL_free(envelope);
+            dest->lpEnvelope = NULL;
+        } else {
+            envelope->dwAttackLevel = CCONVERT(hap_constant->attack_level);
+            envelope->dwAttackTime = hap_constant->attack_length * 1000;
+            envelope->dwFadeLevel = CCONVERT(hap_constant->fade_level);
+            envelope->dwFadeTime = hap_constant->fade_length * 1000;
+        }
+
+        break;
+
+    case SDL_HAPTIC_SINE:
+    case SDL_HAPTIC_SQUARE:
+    case SDL_HAPTIC_TRIANGLE:
+    case SDL_HAPTIC_SAWTOOTHUP:
+    case SDL_HAPTIC_SAWTOOTHDOWN:
+        hap_periodic = &src->periodic;
+        periodic = SDL_malloc(sizeof(FFPERIODIC));
+        if (periodic == NULL) {
+            SDL_OutOfMemory();
+            return -1;
+        }
+        SDL_memset(periodic, 0, sizeof(FFPERIODIC));
+
+        /* Specifics */
+        periodic->dwMagnitude = CONVERT(hap_periodic->magnitude);
+        periodic->lOffset = CONVERT(hap_periodic->offset);
+        periodic->dwPhase = hap_periodic->phase;
+        periodic->dwPeriod = hap_periodic->period * 1000;
+        dest->cbTypeSpecificParams = sizeof(FFPERIODIC);
+        dest->lpvTypeSpecificParams = periodic;
+
+        /* Generics */
+        dest->dwDuration = hap_periodic->length * 1000; /* In microseconds. */
+        dest->dwTriggerButton = FFGetTriggerButton(hap_periodic->button);
+        dest->dwTriggerRepeatInterval = hap_periodic->interval;
+        dest->dwStartDelay = hap_periodic->delay * 1000;        /* In microseconds. */
+
+        /* Direction. */
+        if (SDL_SYS_SetDirection(dest, &hap_periodic->direction, dest->cAxes)
+            < 0) {
+            return -1;
+        }
+
+        /* Envelope */
+        if ((hap_periodic->attack_length == 0)
+            && (hap_periodic->fade_length == 0)) {
+            SDL_free(envelope);
+            dest->lpEnvelope = NULL;
+        } else {
+            envelope->dwAttackLevel = CCONVERT(hap_periodic->attack_level);
+            envelope->dwAttackTime = hap_periodic->attack_length * 1000;
+            envelope->dwFadeLevel = CCONVERT(hap_periodic->fade_level);
+            envelope->dwFadeTime = hap_periodic->fade_length * 1000;
+        }
+
+        break;
+
+    case SDL_HAPTIC_SPRING:
+    case SDL_HAPTIC_DAMPER:
+    case SDL_HAPTIC_INERTIA:
+    case SDL_HAPTIC_FRICTION:
+        hap_condition = &src->condition;
+        condition = SDL_malloc(sizeof(FFCONDITION) * dest->cAxes);
+        if (condition == NULL) {
+            SDL_OutOfMemory();
+            return -1;
+        }
+        SDL_memset(condition, 0, sizeof(FFCONDITION));
+
+        /* Specifics */
+        for (i = 0; i < dest->cAxes; i++) {
+            condition[i].lOffset = CONVERT(hap_condition->center[i]);
+            condition[i].lPositiveCoefficient =
+                CONVERT(hap_condition->right_coeff[i]);
+            condition[i].lNegativeCoefficient =
+                CONVERT(hap_condition->left_coeff[i]);
+            condition[i].dwPositiveSaturation =
+                CCONVERT(hap_condition->right_sat[i]);
+            condition[i].dwNegativeSaturation =
+                CCONVERT(hap_condition->left_sat[i]);
+            condition[i].lDeadBand = CCONVERT(hap_condition->deadband[i]);
+        }
+        dest->cbTypeSpecificParams = sizeof(FFCONDITION) * dest->cAxes;
+        dest->lpvTypeSpecificParams = condition;
+
+        /* Generics */
+        dest->dwDuration = hap_condition->length * 1000;        /* In microseconds. */
+        dest->dwTriggerButton = FFGetTriggerButton(hap_condition->button);
+        dest->dwTriggerRepeatInterval = hap_condition->interval;
+        dest->dwStartDelay = hap_condition->delay * 1000;       /* In microseconds. */
+
+        /* Direction. */
+        if (SDL_SYS_SetDirection(dest, &hap_condition->direction, dest->cAxes)
+            < 0) {
+            return -1;
+        }
+
+        /* Envelope - Not actually supported by most CONDITION implementations. */
+        SDL_free(dest->lpEnvelope);
+        dest->lpEnvelope = NULL;
+
+        break;
+
+    case SDL_HAPTIC_RAMP:
+        hap_ramp = &src->ramp;
+        ramp = SDL_malloc(sizeof(FFRAMPFORCE));
+        if (ramp == NULL) {
+            SDL_OutOfMemory();
+            return -1;
+        }
+        SDL_memset(ramp, 0, sizeof(FFRAMPFORCE));
+
+        /* Specifics */
+        ramp->lStart = CONVERT(hap_ramp->start);
+        ramp->lEnd = CONVERT(hap_ramp->end);
+        dest->cbTypeSpecificParams = sizeof(FFRAMPFORCE);
+        dest->lpvTypeSpecificParams = ramp;
+
+        /* Generics */
+        dest->dwDuration = hap_ramp->length * 1000;     /* In microseconds. */
+        dest->dwTriggerButton = FFGetTriggerButton(hap_ramp->button);
+        dest->dwTriggerRepeatInterval = hap_ramp->interval;
+        dest->dwStartDelay = hap_ramp->delay * 1000;    /* In microseconds. */
+
+        /* Direction. */
+        if (SDL_SYS_SetDirection(dest, &hap_ramp->direction, dest->cAxes) < 0) {
+            return -1;
+        }
+
+        /* Envelope */
+        if ((hap_ramp->attack_length == 0) && (hap_ramp->fade_length == 0)) {
+            SDL_free(envelope);
+            dest->lpEnvelope = NULL;
+        } else {
+            envelope->dwAttackLevel = CCONVERT(hap_ramp->attack_level);
+            envelope->dwAttackTime = hap_ramp->attack_length * 1000;
+            envelope->dwFadeLevel = CCONVERT(hap_ramp->fade_level);
+            envelope->dwFadeTime = hap_ramp->fade_length * 1000;
+        }
+
+        break;
+
+    case SDL_HAPTIC_CUSTOM:
+        hap_custom = &src->custom;
+        custom = SDL_malloc(sizeof(FFCUSTOMFORCE));
+        if (custom == NULL) {
+            SDL_OutOfMemory();
+            return -1;
+        }
+        SDL_memset(custom, 0, sizeof(FFCUSTOMFORCE));
+
+        /* Specifics */
+        custom->cChannels = hap_custom->channels;
+        custom->dwSamplePeriod = hap_custom->period * 1000;
+        custom->cSamples = hap_custom->samples;
+        custom->rglForceData =
+            SDL_malloc(sizeof(LONG) * custom->cSamples * custom->cChannels);
+        for (i = 0; i < hap_custom->samples * hap_custom->channels; i++) {      /* Copy data. */
+            custom->rglForceData[i] = CCONVERT(hap_custom->data[i]);
+        }
+        dest->cbTypeSpecificParams = sizeof(FFCUSTOMFORCE);
+        dest->lpvTypeSpecificParams = custom;
+
+        /* Generics */
+        dest->dwDuration = hap_custom->length * 1000;   /* In microseconds. */
+        dest->dwTriggerButton = FFGetTriggerButton(hap_custom->button);
+        dest->dwTriggerRepeatInterval = hap_custom->interval;
+        dest->dwStartDelay = hap_custom->delay * 1000;  /* In microseconds. */
+
+        /* Direction. */
+        if (SDL_SYS_SetDirection(dest, &hap_custom->direction, dest->cAxes) <
+            0) {
+            return -1;
+        }
+
+        /* Envelope */
+        if ((hap_custom->attack_length == 0)
+            && (hap_custom->fade_length == 0)) {
+            SDL_free(envelope);
+            dest->lpEnvelope = NULL;
+        } else {
+            envelope->dwAttackLevel = CCONVERT(hap_custom->attack_level);
+            envelope->dwAttackTime = hap_custom->attack_length * 1000;
+            envelope->dwFadeLevel = CCONVERT(hap_custom->fade_level);
+            envelope->dwFadeTime = hap_custom->fade_length * 1000;
+        }
+
+        break;
+
+
+    default:
+        SDL_SetError("Haptic: Unknown effect type.");
+        return -1;
+    }
+
+    return 0;
+}
+
+
+/*
+ * Frees an FFEFFECT allocated by SDL_SYS_ToFFEFFECT.
+ */
+static void
+SDL_SYS_HapticFreeFFEFFECT(FFEFFECT * effect, int type)
+{
+    FFCUSTOMFORCE *custom;
+
+    if (effect->lpEnvelope != NULL) {
+        SDL_free(effect->lpEnvelope);
+        effect->lpEnvelope = NULL;
+    }
+    if (effect->rgdwAxes != NULL) {
+        SDL_free(effect->rgdwAxes);
+        effect->rgdwAxes = NULL;
+    }
+    if (effect->lpvTypeSpecificParams != NULL) {
+        if (type == SDL_HAPTIC_CUSTOM) {        /* Must free the custom data. */
+            custom = (FFCUSTOMFORCE *) effect->lpvTypeSpecificParams;
+            SDL_free(custom->rglForceData);
+            custom->rglForceData = NULL;
+        }
+        SDL_free(effect->lpvTypeSpecificParams);
+        effect->lpvTypeSpecificParams = NULL;
+    }
+    if (effect->rglDirection != NULL) {
+        SDL_free(effect->rglDirection);
+        effect->rglDirection = NULL;
+    }
+}
+
+
+/*
+ * Gets the effect type from the generic SDL haptic effect wrapper.
+ */
+CFUUIDRef
+SDL_SYS_HapticEffectType(Uint16 type)
+{
+    switch (type) {
+    case SDL_HAPTIC_CONSTANT:
+        return kFFEffectType_ConstantForce_ID;
+
+    case SDL_HAPTIC_RAMP:
+        return kFFEffectType_RampForce_ID;
+
+    case SDL_HAPTIC_SQUARE:
+        return kFFEffectType_Square_ID;
+
+    case SDL_HAPTIC_SINE:
+        return kFFEffectType_Sine_ID;
+
+    case SDL_HAPTIC_TRIANGLE:
+        return kFFEffectType_Triangle_ID;
+
+    case SDL_HAPTIC_SAWTOOTHUP:
+        return kFFEffectType_SawtoothUp_ID;
+
+    case SDL_HAPTIC_SAWTOOTHDOWN:
+        return kFFEffectType_SawtoothDown_ID;
+
+    case SDL_HAPTIC_SPRING:
+        return kFFEffectType_Spring_ID;
+
+    case SDL_HAPTIC_DAMPER:
+        return kFFEffectType_Damper_ID;
+
+    case SDL_HAPTIC_INERTIA:
+        return kFFEffectType_Inertia_ID;
+
+    case SDL_HAPTIC_FRICTION:
+        return kFFEffectType_Friction_ID;
+
+    case SDL_HAPTIC_CUSTOM:
+        return kFFEffectType_CustomForce_ID;
+
+    default:
+        SDL_SetError("Haptic: Unknown effect type.");
+        return NULL;
+    }
+}
+
+
+/*
+ * Creates a new haptic effect.
+ */
+int
+SDL_SYS_HapticNewEffect(SDL_Haptic * haptic, struct haptic_effect *effect,
+                        SDL_HapticEffect * base)
+{
+    HRESULT ret;
+    CFUUIDRef type;
+
+    /* Alloc the effect. */
+    effect->hweffect = (struct haptic_hweffect *)
+        SDL_malloc(sizeof(struct haptic_hweffect));
+    if (effect->hweffect == NULL) {
+        SDL_OutOfMemory();
+        goto err_hweffect;
+    }
+
+    /* Get the type. */
+    type = SDL_SYS_HapticEffectType(base->type);
+    if (type == NULL) {
+        goto err_hweffect;
+    }
+
+    /* Get the effect. */
+    if (SDL_SYS_ToFFEFFECT(haptic, &effect->hweffect->effect, base) < 0) {
+        goto err_effectdone;
+    }
+
+    /* Create the actual effect. */
+    ret = FFDeviceCreateEffect(haptic->hwdata->device, type,
+                               &effect->hweffect->effect,
+                               &effect->hweffect->ref);
+    if (ret != FF_OK) {
+        SDL_SetError("Haptic: Unable to create effect: %s.", FFStrError(ret));
+        goto err_effectdone;
+    }
+
+    return 0;
+
+  err_effectdone:
+    SDL_SYS_HapticFreeFFEFFECT(&effect->hweffect->effect, base->type);
+  err_hweffect:
+    if (effect->hweffect != NULL) {
+        SDL_free(effect->hweffect);
+        effect->hweffect = NULL;
+    }
+    return -1;
+}
+
+
+/*
+ * Updates an effect.
+ */
+int
+SDL_SYS_HapticUpdateEffect(SDL_Haptic * haptic,
+                           struct haptic_effect *effect,
+                           SDL_HapticEffect * data)
+{
+    HRESULT ret;
+    FFEffectParameterFlag flags;
+    FFEFFECT temp;
+
+    /* Get the effect. */
+    SDL_memset(&temp, 0, sizeof(FFEFFECT));
+    if (SDL_SYS_ToFFEFFECT(haptic, &temp, data) < 0) {
+        goto err_update;
+    }
+
+    /* Set the flags.  Might be worthwhile to diff temp with loaded effect and
+     *  only change those parameters. */
+    flags = FFEP_DIRECTION |
+        FFEP_DURATION |
+        FFEP_ENVELOPE |
+        FFEP_STARTDELAY |
+        FFEP_TRIGGERBUTTON |
+        FFEP_TRIGGERREPEATINTERVAL | FFEP_TYPESPECIFICPARAMS;
+
+    /* Create the actual effect. */
+    ret = FFEffectSetParameters(effect->hweffect->ref, &temp, flags);
+    if (ret != FF_OK) {
+        SDL_SetError("Haptic: Unable to update effect: %s.", FFStrError(ret));
+        goto err_update;
+    }
+
+    /* Copy it over. */
+    SDL_SYS_HapticFreeFFEFFECT(&effect->hweffect->effect, data->type);
+    SDL_memcpy(&effect->hweffect->effect, &temp, sizeof(FFEFFECT));
+
+    return 0;
+
+  err_update:
+    SDL_SYS_HapticFreeFFEFFECT(&temp, data->type);
+    return -1;
+}
+
+
+/*
+ * Runs an effect.
+ */
+int
+SDL_SYS_HapticRunEffect(SDL_Haptic * haptic, struct haptic_effect *effect,
+                        Uint32 iterations)
+{
+    HRESULT ret;
+    Uint32 iter;
+
+    /* Check if it's infinite. */
+    if (iterations == SDL_HAPTIC_INFINITY) {
+        iter = FF_INFINITE;
+    } else
+        iter = iterations;
+
+    /* Run the effect. */
+    ret = FFEffectStart(effect->hweffect->ref, iter, 0);
+    if (ret != FF_OK) {
+        SDL_SetError("Haptic: Unable to run the effect: %s.",
+                     FFStrError(ret));
+        return -1;
+    }
+
+    return 0;
+}
+
+
+/*
+ * Stops an effect.
+ */
+int
+SDL_SYS_HapticStopEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
+{
+    HRESULT ret;
+
+    ret = FFEffectStop(effect->hweffect->ref);
+    if (ret != FF_OK) {
+        SDL_SetError("Haptic: Unable to stop the effect: %s.",
+                     FFStrError(ret));
+        return -1;
+    }
+
+    return 0;
+}
+
+
+/*
+ * Frees the effect.
+ */
+void
+SDL_SYS_HapticDestroyEffect(SDL_Haptic * haptic, struct haptic_effect *effect)
+{
+    HRESULT ret;
+
+    ret =
+        FFDeviceReleaseEffect(haptic->hwdata->device, effect->hweffect->ref);
+    if (ret != FF_OK) {
+        SDL_SetError("Haptic: Error removing the effect from the device: %s.",
+                     FFStrError(ret));
+    }
+    SDL_SYS_HapticFreeFFEFFECT(&effect->hweffect->effect,
+                               effect->effect.type);
+    SDL_free(effect->hweffect);
+    effect->hweffect = NULL;
+}
+
+
+/*
+ * Gets the status of a haptic effect.
+ */
+int
+SDL_SYS_HapticGetEffectStatus(SDL_Haptic * haptic,
+                              struct haptic_effect *effect)
+{
+    HRESULT ret;
+    FFEffectStatusFlag status;
+
+    ret = FFEffectGetEffectStatus(effect->hweffect->ref, &status);
+    if (ret != FF_OK) {
+        SDL_SetError("Haptic: Unable to get effect status: %s.",
+                     FFStrError(ret));
+        return -1;
+    }
+
+    if (status == 0)
+        return SDL_FALSE;
+    return SDL_TRUE;            /* Assume it's playing or emulated. */
+}
+
+
+/*
+ * Sets the gain.
+ */
+int
+SDL_SYS_HapticSetGain(SDL_Haptic * haptic, int gain)
+{
+    HRESULT ret;
+    Uint32 val;
+
+    val = gain * 100;           /* Mac OS X uses 0 to 10,000 */
+    ret =
+        FFDeviceSetForceFeedbackProperty(haptic->hwdata->device,
+                                         FFPROP_FFGAIN, &val);
+    if (ret != FF_OK) {
+        SDL_SetError("Haptic: Error setting gain: %s.", FFStrError(ret));
+        return -1;
+    }
+
+    return 0;
+}
+
+
+/*
+ * Sets the autocentering.
+ */
+int
+SDL_SYS_HapticSetAutocenter(SDL_Haptic * haptic, int autocenter)
+{
+    HRESULT ret;
+    Uint32 val;
+
+    /* Mac OS X only has 0 (off) and 1 (on) */
+    if (autocenter == 0)
+        val = 0;
+    else
+        val = 1;
+
+    ret = FFDeviceSetForceFeedbackProperty(haptic->hwdata->device,
+                                           FFPROP_AUTOCENTER, &val);
+    if (ret != FF_OK) {
+        SDL_SetError("Haptic: Error setting autocenter: %s.",
+                     FFStrError(ret));
+        return -1;
+    }
+
+    return 0;
+}
+
+
+/*
+ * Pauses the device.
+ */
+int
+SDL_SYS_HapticPause(SDL_Haptic * haptic)
+{
+    HRESULT ret;
+
+    ret = FFDeviceSendForceFeedbackCommand(haptic->hwdata->device,
+                                           FFSFFC_PAUSE);
+    if (ret != FF_OK) {
+        SDL_SetError("Haptic: Error pausing device: %s.", FFStrError(ret));
+        return -1;
+    }
+
+    return 0;
+}
+
+
+/*
+ * Unpauses the device.
+ */
+int
+SDL_SYS_HapticUnpause(SDL_Haptic * haptic)
+{
+    HRESULT ret;
+
+    ret = FFDeviceSendForceFeedbackCommand(haptic->hwdata->device,
+                                           FFSFFC_CONTINUE);
+    if (ret != FF_OK) {
+        SDL_SetError("Haptic: Error pausing device: %s.", FFStrError(ret));
+        return -1;
+    }
+
+    return 0;
+}
+
+
+/*
+ * Stops all currently playing effects.
+ */
+int
+SDL_SYS_HapticStopAll(SDL_Haptic * haptic)
+{
+    HRESULT ret;
+
+    ret = FFDeviceSendForceFeedbackCommand(haptic->hwdata->device,
+                                           FFSFFC_STOPALL);
+    if (ret != FF_OK) {
+        SDL_SetError("Haptic: Error stopping device: %s.", FFStrError(ret));
+        return -1;
+    }
+
+    return 0;
+}
+
+
+#endif /* SDL_HAPTIC_IOKIT */
diff --git a/macosx/plugins/Common/SDL/src/joystick/SDL_joystick.c b/macosx/plugins/Common/SDL/src/joystick/SDL_joystick.c
new file mode 100644
index 00000000..189b8117
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/joystick/SDL_joystick.c
@@ -0,0 +1,503 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+/* This is the joystick API for Simple DirectMedia Layer */
+#include "SDL.h"
+#include "SDL_sysjoystick.h"
+#include "SDL_joystick_c.h"
+
+/* This is used for Quake III Arena */
+#define SDL_Lock_EventThread()
+#define SDL_Unlock_EventThread()
+
+Uint8 SDL_numjoysticks = 0;
+SDL_Joystick **SDL_joysticks = NULL;
+static SDL_Joystick *default_joystick = NULL;
+
+int
+SDL_JoystickInit(void)
+{
+    int arraylen;
+    int status;
+
+    SDL_numjoysticks = 0;
+    status = SDL_SYS_JoystickInit();
+    if (status >= 0) {
+        arraylen = (status + 1) * sizeof(*SDL_joysticks);
+        SDL_joysticks = (SDL_Joystick **) SDL_malloc(arraylen);
+        if (SDL_joysticks == NULL) {
+            SDL_numjoysticks = 0;
+        } else {
+            SDL_memset(SDL_joysticks, 0, arraylen);
+            SDL_numjoysticks = status;
+        }
+        status = 0;
+    }
+    default_joystick = NULL;
+    return (status);
+}
+
+/*
+ * Count the number of joysticks attached to the system
+ */
+int
+SDL_NumJoysticks(void)
+{
+    return SDL_numjoysticks;
+}
+
+/*
+ * Get the implementation dependent name of a joystick
+ */
+const char *
+SDL_JoystickName(int device_index)
+{
+    if ((device_index < 0) || (device_index >= SDL_numjoysticks)) {
+        SDL_SetError("There are %d joysticks available", SDL_numjoysticks);
+        return (NULL);
+    }
+    return (SDL_SYS_JoystickName(device_index));
+}
+
+/*
+ * Open a joystick for use - the index passed as an argument refers to
+ * the N'th joystick on the system.  This index is the value which will
+ * identify this joystick in future joystick events.
+ *
+ * This function returns a joystick identifier, or NULL if an error occurred.
+ */
+SDL_Joystick *
+SDL_JoystickOpen(int device_index)
+{
+    int i;
+    SDL_Joystick *joystick;
+
+    if ((device_index < 0) || (device_index >= SDL_numjoysticks)) {
+        SDL_SetError("There are %d joysticks available", SDL_numjoysticks);
+        return (NULL);
+    }
+
+    /* If the joystick is already open, return it */
+    for (i = 0; SDL_joysticks[i]; ++i) {
+        if (device_index == SDL_joysticks[i]->index) {
+            joystick = SDL_joysticks[i];
+            ++joystick->ref_count;
+            return (joystick);
+        }
+    }
+
+    /* Create and initialize the joystick */
+    joystick = (SDL_Joystick *) SDL_malloc((sizeof *joystick));
+    if (joystick == NULL) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    SDL_memset(joystick, 0, (sizeof *joystick));
+    joystick->index = device_index;
+    if (SDL_SYS_JoystickOpen(joystick) < 0) {
+        SDL_free(joystick);
+        return NULL;
+    }
+    if (joystick->naxes > 0) {
+        joystick->axes = (Sint16 *) SDL_malloc
+            (joystick->naxes * sizeof(Sint16));
+    }
+    if (joystick->nhats > 0) {
+        joystick->hats = (Uint8 *) SDL_malloc
+            (joystick->nhats * sizeof(Uint8));
+    }
+    if (joystick->nballs > 0) {
+        joystick->balls = (struct balldelta *) SDL_malloc
+            (joystick->nballs * sizeof(*joystick->balls));
+    }
+    if (joystick->nbuttons > 0) {
+        joystick->buttons = (Uint8 *) SDL_malloc
+            (joystick->nbuttons * sizeof(Uint8));
+    }
+    if (((joystick->naxes > 0) && !joystick->axes)
+        || ((joystick->nhats > 0) && !joystick->hats)
+        || ((joystick->nballs > 0) && !joystick->balls)
+        || ((joystick->nbuttons > 0) && !joystick->buttons)) {
+        SDL_OutOfMemory();
+        SDL_JoystickClose(joystick);
+        return NULL;
+    }
+    if (joystick->axes) {
+        SDL_memset(joystick->axes, 0, joystick->naxes * sizeof(Sint16));
+    }
+    if (joystick->hats) {
+        SDL_memset(joystick->hats, 0, joystick->nhats * sizeof(Uint8));
+    }
+    if (joystick->balls) {
+        SDL_memset(joystick->balls, 0,
+            joystick->nballs * sizeof(*joystick->balls));
+    }
+    if (joystick->buttons) {
+        SDL_memset(joystick->buttons, 0, joystick->nbuttons * sizeof(Uint8));
+    }
+
+    /* Add joystick to list */
+    ++joystick->ref_count;
+    SDL_Lock_EventThread();
+    for (i = 0; SDL_joysticks[i]; ++i)
+        /* Skip to next joystick */ ;
+    SDL_joysticks[i] = joystick;
+    SDL_Unlock_EventThread();
+
+    return (joystick);
+}
+
+/*
+ * Returns 1 if the joystick has been opened, or 0 if it has not.
+ */
+int
+SDL_JoystickOpened(int device_index)
+{
+    int i, opened;
+
+    opened = 0;
+    for (i = 0; SDL_joysticks[i]; ++i) {
+        if (SDL_joysticks[i]->index == (Uint8) device_index) {
+            opened = 1;
+            break;
+        }
+    }
+    return (opened);
+}
+
+
+/*
+ * Checks to make sure the joystick is valid.
+ */
+int
+SDL_PrivateJoystickValid(SDL_Joystick ** joystick)
+{
+    int valid;
+
+    if (*joystick == NULL) {
+        *joystick = default_joystick;
+    }
+    if (*joystick == NULL) {
+        SDL_SetError("Joystick hasn't been opened yet");
+        valid = 0;
+    } else {
+        valid = 1;
+    }
+    return valid;
+}
+
+/*
+ * Get the device index of an opened joystick.
+ */
+int
+SDL_JoystickIndex(SDL_Joystick * joystick)
+{
+    if (!SDL_PrivateJoystickValid(&joystick)) {
+        return (-1);
+    }
+    return (joystick->index);
+}
+
+/*
+ * Get the number of multi-dimensional axis controls on a joystick
+ */
+int
+SDL_JoystickNumAxes(SDL_Joystick * joystick)
+{
+    if (!SDL_PrivateJoystickValid(&joystick)) {
+        return (-1);
+    }
+    return (joystick->naxes);
+}
+
+/*
+ * Get the number of hats on a joystick
+ */
+int
+SDL_JoystickNumHats(SDL_Joystick * joystick)
+{
+    if (!SDL_PrivateJoystickValid(&joystick)) {
+        return (-1);
+    }
+    return (joystick->nhats);
+}
+
+/*
+ * Get the number of trackballs on a joystick
+ */
+int
+SDL_JoystickNumBalls(SDL_Joystick * joystick)
+{
+    if (!SDL_PrivateJoystickValid(&joystick)) {
+        return (-1);
+    }
+    return (joystick->nballs);
+}
+
+/*
+ * Get the number of buttons on a joystick
+ */
+int
+SDL_JoystickNumButtons(SDL_Joystick * joystick)
+{
+    if (!SDL_PrivateJoystickValid(&joystick)) {
+        return (-1);
+    }
+    return (joystick->nbuttons);
+}
+
+/*
+ * Get the current state of an axis control on a joystick
+ */
+Sint16
+SDL_JoystickGetAxis(SDL_Joystick * joystick, int axis)
+{
+    Sint16 state;
+
+    if (!SDL_PrivateJoystickValid(&joystick)) {
+        return (0);
+    }
+    if (axis < joystick->naxes) {
+        state = joystick->axes[axis];
+    } else {
+        SDL_SetError("Joystick only has %d axes", joystick->naxes);
+        state = 0;
+    }
+    return (state);
+}
+
+/*
+ * Get the current state of a hat on a joystick
+ */
+Uint8
+SDL_JoystickGetHat(SDL_Joystick * joystick, int hat)
+{
+    Uint8 state;
+
+    if (!SDL_PrivateJoystickValid(&joystick)) {
+        return (0);
+    }
+    if (hat < joystick->nhats) {
+        state = joystick->hats[hat];
+    } else {
+        SDL_SetError("Joystick only has %d hats", joystick->nhats);
+        state = 0;
+    }
+    return (state);
+}
+
+/*
+ * Get the ball axis change since the last poll
+ */
+int
+SDL_JoystickGetBall(SDL_Joystick * joystick, int ball, int *dx, int *dy)
+{
+    int retval;
+
+    if (!SDL_PrivateJoystickValid(&joystick)) {
+        return (-1);
+    }
+
+    retval = 0;
+    if (ball < joystick->nballs) {
+        if (dx) {
+            *dx = joystick->balls[ball].dx;
+        }
+        if (dy) {
+            *dy = joystick->balls[ball].dy;
+        }
+        joystick->balls[ball].dx = 0;
+        joystick->balls[ball].dy = 0;
+    } else {
+        SDL_SetError("Joystick only has %d balls", joystick->nballs);
+        retval = -1;
+    }
+    return (retval);
+}
+
+/*
+ * Get the current state of a button on a joystick
+ */
+Uint8
+SDL_JoystickGetButton(SDL_Joystick * joystick, int button)
+{
+    Uint8 state;
+
+    if (!SDL_PrivateJoystickValid(&joystick)) {
+        return (0);
+    }
+    if (button < joystick->nbuttons) {
+        state = joystick->buttons[button];
+    } else {
+        SDL_SetError("Joystick only has %d buttons", joystick->nbuttons);
+        state = 0;
+    }
+    return (state);
+}
+
+/*
+ * Close a joystick previously opened with SDL_JoystickOpen()
+ */
+void
+SDL_JoystickClose(SDL_Joystick * joystick)
+{
+    int i;
+
+    if (!SDL_PrivateJoystickValid(&joystick)) {
+        return;
+    }
+
+    /* First decrement ref count */
+    if (--joystick->ref_count > 0) {
+        return;
+    }
+
+    /* Lock the event queue - prevent joystick polling */
+    SDL_Lock_EventThread();
+
+    if (joystick == default_joystick) {
+        default_joystick = NULL;
+    }
+    SDL_SYS_JoystickClose(joystick);
+
+    /* Remove joystick from list */
+    for (i = 0; SDL_joysticks[i]; ++i) {
+        if (joystick == SDL_joysticks[i]) {
+            SDL_memmove(&SDL_joysticks[i], &SDL_joysticks[i + 1],
+                        (SDL_numjoysticks - i) * sizeof(joystick));
+            break;
+        }
+    }
+
+    /* Let the event thread keep running */
+    SDL_Unlock_EventThread();
+
+    /* Free the data associated with this joystick */
+    if (joystick->axes) {
+        SDL_free(joystick->axes);
+    }
+    if (joystick->hats) {
+        SDL_free(joystick->hats);
+    }
+    if (joystick->balls) {
+        SDL_free(joystick->balls);
+    }
+    if (joystick->buttons) {
+        SDL_free(joystick->buttons);
+    }
+    SDL_free(joystick);
+}
+
+void
+SDL_JoystickQuit(void)
+{
+    /* Stop the event polling */
+    SDL_Lock_EventThread();
+    SDL_numjoysticks = 0;
+    SDL_Unlock_EventThread();
+
+    /* Quit the joystick setup */
+    SDL_SYS_JoystickQuit();
+    if (SDL_joysticks) {
+        SDL_free(SDL_joysticks);
+        SDL_joysticks = NULL;
+    }
+}
+
+
+/* These are global for SDL_sysjoystick.c and SDL_events.c */
+
+int
+SDL_PrivateJoystickAxis(SDL_Joystick * joystick, Uint8 axis, Sint16 value)
+{
+    int posted;
+
+    /* Update internal joystick state */
+    joystick->axes[axis] = value;
+
+    /* Post the event, if desired */
+    posted = 0;
+
+    return (posted);
+}
+
+int
+SDL_PrivateJoystickHat(SDL_Joystick * joystick, Uint8 hat, Uint8 value)
+{
+    int posted;
+
+    /* Update internal joystick state */
+    joystick->hats[hat] = value;
+
+    /* Post the event, if desired */
+    posted = 0;
+
+    return (posted);
+}
+
+int
+SDL_PrivateJoystickBall(SDL_Joystick * joystick, Uint8 ball,
+                        Sint16 xrel, Sint16 yrel)
+{
+    int posted;
+
+    /* Update internal mouse state */
+    joystick->balls[ball].dx += xrel;
+    joystick->balls[ball].dy += yrel;
+
+    /* Post the event, if desired */
+    posted = 0;
+
+    return (posted);
+}
+
+int
+SDL_PrivateJoystickButton(SDL_Joystick * joystick, Uint8 button, Uint8 state)
+{
+    int posted;
+
+    /* Update internal joystick state */
+    joystick->buttons[button] = state;
+
+    /* Post the event, if desired */
+    posted = 0;
+
+    return (posted);
+}
+
+void
+SDL_JoystickUpdate(void)
+{
+    int i;
+
+    for (i = 0; SDL_joysticks[i]; ++i) {
+        SDL_SYS_JoystickUpdate(SDL_joysticks[i]);
+    }
+}
+
+int
+SDL_JoystickEventState(int state)
+{
+    return SDL_IGNORE;
+}
diff --git a/macosx/plugins/Common/SDL/src/joystick/SDL_joystick_c.h b/macosx/plugins/Common/SDL/src/joystick/SDL_joystick_c.h
new file mode 100644
index 00000000..e0f8529e
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/joystick/SDL_joystick_c.h
@@ -0,0 +1,47 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+/* Useful functions and variables from SDL_joystick.c */
+#include "SDL_joystick.h"
+
+/* The number of available joysticks on the system */
+extern Uint8 SDL_numjoysticks;
+
+/* Initialization and shutdown functions */
+extern int SDL_JoystickInit(void);
+extern void SDL_JoystickQuit(void);
+
+/* Internal event queueing functions */
+extern int SDL_PrivateJoystickAxis(SDL_Joystick * joystick,
+                                   Uint8 axis, Sint16 value);
+extern int SDL_PrivateJoystickBall(SDL_Joystick * joystick,
+                                   Uint8 ball, Sint16 xrel, Sint16 yrel);
+extern int SDL_PrivateJoystickHat(SDL_Joystick * joystick,
+                                  Uint8 hat, Uint8 value);
+extern int SDL_PrivateJoystickButton(SDL_Joystick * joystick,
+                                     Uint8 button, Uint8 state);
+
+/* Internal sanity checking functions */
+extern int SDL_PrivateJoystickValid(SDL_Joystick ** joystick);
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/joystick/SDL_sysjoystick.h b/macosx/plugins/Common/SDL/src/joystick/SDL_sysjoystick.h
new file mode 100644
index 00000000..ddb3b84f
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/joystick/SDL_sysjoystick.h
@@ -0,0 +1,85 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 Sam Lantinga
+
+    This library is SDL_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"
+
+/* This is the system specific header for the SDL joystick API */
+
+#include "SDL_joystick.h"
+
+/* The SDL joystick structure */
+struct _SDL_Joystick
+{
+    Uint8 index;                /* Device index */
+    const char *name;           /* Joystick name - system dependent */
+
+    int naxes;                  /* Number of axis controls on the joystick */
+    Sint16 *axes;               /* Current axis states */
+
+    int nhats;                  /* Number of hats on the joystick */
+    Uint8 *hats;                /* Current hat states */
+
+    int nballs;                 /* Number of trackballs on the joystick */
+    struct balldelta
+    {
+        int dx;
+        int dy;
+    } *balls;                   /* Current ball motion deltas */
+
+    int nbuttons;               /* Number of buttons on the joystick */
+    Uint8 *buttons;             /* Current button states */
+
+    struct joystick_hwdata *hwdata;     /* Driver dependent information */
+
+    int ref_count;              /* Reference count for multiple opens */
+};
+
+/* Function to scan the system for joysticks.
+ * Joystick 0 should be the system default joystick.
+ * This function should return the number of available joysticks, or -1
+ * on an unrecoverable fatal error.
+ */
+extern int SDL_SYS_JoystickInit(void);
+
+/* Function to get the device-dependent name of a joystick */
+extern const char *SDL_SYS_JoystickName(int index);
+
+/* Function to open a joystick for use.
+   The joystick to open is specified by the index field of the joystick.
+   This should fill the nbuttons and naxes fields of the joystick structure.
+   It returns 0, or -1 if there is an error.
+ */
+extern int SDL_SYS_JoystickOpen(SDL_Joystick * joystick);
+
+/* Function to update the state of a joystick - called as a device poll.
+ * This function shouldn't update the joystick structure directly,
+ * but instead should call SDL_PrivateJoystick*() to deliver events
+ * and update joystick device state.
+ */
+extern void SDL_SYS_JoystickUpdate(SDL_Joystick * joystick);
+
+/* Function to close a joystick after use */
+extern void SDL_SYS_JoystickClose(SDL_Joystick * joystick);
+
+/* Function to perform any system-specific joystick related cleanup */
+extern void SDL_SYS_JoystickQuit(void);
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/joystick/darwin/SDL_sysjoystick.c b/macosx/plugins/Common/SDL/src/joystick/darwin/SDL_sysjoystick.c
new file mode 100644
index 00000000..824917f2
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/joystick/darwin/SDL_sysjoystick.c
@@ -0,0 +1,847 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+#ifdef SDL_JOYSTICK_IOKIT
+
+/* SDL joystick driver for Darwin / Mac OS X, based on the IOKit HID API */
+/* Written 2001 by Max Horn */
+
+#include <unistd.h>
+#include <ctype.h>
+#include <sysexits.h>
+#include <mach/mach.h>
+#include <mach/mach_error.h>
+#include <IOKit/IOKitLib.h>
+#include <IOKit/IOCFPlugIn.h>
+#ifdef MACOS_10_0_4
+#include <IOKit/hidsystem/IOHIDUsageTables.h>
+#else
+/* The header was moved here in Mac OS X 10.1 */
+#include <Kernel/IOKit/hidsystem/IOHIDUsageTables.h>
+#endif
+#include <IOKit/hid/IOHIDLib.h>
+#include <IOKit/hid/IOHIDKeys.h>
+#include <CoreFoundation/CoreFoundation.h>
+#include <Carbon/Carbon.h>      /* for NewPtrClear, DisposePtr */
+
+/* For force feedback testing. */
+#include <ForceFeedback/ForceFeedback.h>
+#include <ForceFeedback/ForceFeedbackConstants.h>
+
+#include "SDL_joystick.h"
+#include "../SDL_sysjoystick.h"
+#include "../SDL_joystick_c.h"
+#include "SDL_sysjoystick_c.h"
+
+
+/* Linked list of all available devices */
+static recDevice *gpDeviceList = NULL;
+
+
+static void
+HIDReportErrorNum(char *strError, long numError)
+{
+    SDL_SetError(strError);
+}
+
+static void HIDGetCollectionElements(CFMutableDictionaryRef deviceProperties,
+                                     recDevice * pDevice);
+
+/* returns current value for element, polling element
+ * will return 0 on error conditions which should be accounted for by application
+ */
+
+static SInt32
+HIDGetElementValue(recDevice * pDevice, recElement * pElement)
+{
+    IOReturn result = kIOReturnSuccess;
+    IOHIDEventStruct hidEvent;
+    hidEvent.value = 0;
+
+    if (NULL != pDevice && NULL != pElement && NULL != pDevice->interface) {
+        result =
+            (*(pDevice->interface))->getElementValue(pDevice->interface,
+                                                     pElement->cookie,
+                                                     &hidEvent);
+        if (kIOReturnSuccess == result) {
+            /* record min and max for auto calibration */
+            if (hidEvent.value < pElement->minReport)
+                pElement->minReport = hidEvent.value;
+            if (hidEvent.value > pElement->maxReport)
+                pElement->maxReport = hidEvent.value;
+        }
+    }
+
+    /* auto user scale */
+    return hidEvent.value;
+}
+
+static SInt32
+HIDScaledCalibratedValue(recDevice * pDevice, recElement * pElement,
+                         long min, long max)
+{
+    float deviceScale = max - min;
+    float readScale = pElement->maxReport - pElement->minReport;
+    SInt32 value = HIDGetElementValue(pDevice, pElement);
+    if (readScale == 0)
+        return value;           /* no scaling at all */
+    else
+        return ((value - pElement->minReport) * deviceScale / readScale) +
+            min;
+}
+
+
+static void
+HIDRemovalCallback(void *target, IOReturn result, void *refcon, void *sender)
+{
+    recDevice *device = (recDevice *) refcon;
+    device->removed = 1;
+    device->uncentered = 1;
+}
+
+
+
+/* Create and open an interface to device, required prior to extracting values or building queues.
+ * Note: appliction now owns the device and must close and release it prior to exiting
+ */
+
+static IOReturn
+HIDCreateOpenDeviceInterface(io_object_t hidDevice, recDevice * pDevice)
+{
+    IOReturn result = kIOReturnSuccess;
+    HRESULT plugInResult = S_OK;
+    SInt32 score = 0;
+    IOCFPlugInInterface **ppPlugInInterface = NULL;
+
+    if (NULL == pDevice->interface) {
+        result =
+            IOCreatePlugInInterfaceForService(hidDevice,
+                                              kIOHIDDeviceUserClientTypeID,
+                                              kIOCFPlugInInterfaceID,
+                                              &ppPlugInInterface, &score);
+        if (kIOReturnSuccess == result) {
+            /* Call a method of the intermediate plug-in to create the device interface */
+            plugInResult =
+                (*ppPlugInInterface)->QueryInterface(ppPlugInInterface,
+                                                     CFUUIDGetUUIDBytes
+                                                     (kIOHIDDeviceInterfaceID),
+                                                     (void *)
+                                                     &(pDevice->interface));
+            if (S_OK != plugInResult)
+                HIDReportErrorNum
+                    ("CouldnÕt query HID class device interface from plugInInterface",
+                     plugInResult);
+            (*ppPlugInInterface)->Release(ppPlugInInterface);
+        } else
+            HIDReportErrorNum
+                ("Failed to create **plugInInterface via IOCreatePlugInInterfaceForService.",
+                 result);
+    }
+    if (NULL != pDevice->interface) {
+        result = (*(pDevice->interface))->open(pDevice->interface, 0);
+        if (kIOReturnSuccess != result)
+            HIDReportErrorNum
+                ("Failed to open pDevice->interface via open.", result);
+        else
+            (*(pDevice->interface))->setRemovalCallback(pDevice->interface,
+                                                        HIDRemovalCallback,
+                                                        pDevice, pDevice);
+
+    }
+    return result;
+}
+
+/* Closes and releases interface to device, should be done prior to exting application
+ * Note: will have no affect if device or interface do not exist
+ * application will "own" the device if interface is not closed
+ * (device may have to be plug and re-plugged in different location to get it working again without a restart)
+ */
+
+static IOReturn
+HIDCloseReleaseInterface(recDevice * pDevice)
+{
+    IOReturn result = kIOReturnSuccess;
+
+    if ((NULL != pDevice) && (NULL != pDevice->interface)) {
+        /* close the interface */
+        result = (*(pDevice->interface))->close(pDevice->interface);
+        if (kIOReturnNotOpen == result) {
+            /* do nothing as device was not opened, thus can't be closed */
+        } else if (kIOReturnSuccess != result)
+            HIDReportErrorNum("Failed to close IOHIDDeviceInterface.",
+                              result);
+        /* release the interface */
+        result = (*(pDevice->interface))->Release(pDevice->interface);
+        if (kIOReturnSuccess != result)
+            HIDReportErrorNum("Failed to release IOHIDDeviceInterface.",
+                              result);
+        pDevice->interface = NULL;
+    }
+    return result;
+}
+
+/* extracts actual specific element information from each element CF dictionary entry */
+
+static void
+HIDGetElementInfo(CFTypeRef refElement, recElement * pElement)
+{
+    long number;
+    CFTypeRef refType;
+
+    refType = CFDictionaryGetValue(refElement, CFSTR(kIOHIDElementCookieKey));
+    if (refType && CFNumberGetValue(refType, kCFNumberLongType, &number))
+        pElement->cookie = (IOHIDElementCookie) number;
+    refType = CFDictionaryGetValue(refElement, CFSTR(kIOHIDElementMinKey));
+    if (refType && CFNumberGetValue(refType, kCFNumberLongType, &number))
+        pElement->minReport = pElement->min = number;
+    pElement->maxReport = pElement->min;
+    refType = CFDictionaryGetValue(refElement, CFSTR(kIOHIDElementMaxKey));
+    if (refType && CFNumberGetValue(refType, kCFNumberLongType, &number))
+        pElement->maxReport = pElement->max = number;
+/*
+	TODO: maybe should handle the following stuff somehow?
+
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementScaledMinKey));
+	if (refType && CFNumberGetValue (refType, kCFNumberLongType, &number))
+		pElement->scaledMin = number;
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementScaledMaxKey));
+	if (refType && CFNumberGetValue (refType, kCFNumberLongType, &number))
+		pElement->scaledMax = number;
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementSizeKey));
+	if (refType && CFNumberGetValue (refType, kCFNumberLongType, &number))
+		pElement->size = number;
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementIsRelativeKey));
+	if (refType)
+		pElement->relative = CFBooleanGetValue (refType);
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementIsWrappingKey));
+	if (refType)
+		pElement->wrapping = CFBooleanGetValue (refType);
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementIsNonLinearKey));
+	if (refType)
+		pElement->nonLinear = CFBooleanGetValue (refType);
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementHasPreferedStateKey));
+	if (refType)
+		pElement->preferredState = CFBooleanGetValue (refType);
+	refType = CFDictionaryGetValue (refElement, CFSTR(kIOHIDElementHasNullStateKey));
+	if (refType)
+		pElement->nullState = CFBooleanGetValue (refType);
+*/
+}
+
+/* examines CF dictionary vlaue in device element hierarchy to determine if it is element of interest or a collection of more elements
+ * if element of interest allocate storage, add to list and retrieve element specific info
+ * if collection then pass on to deconstruction collection into additional individual elements
+ */
+
+static void
+HIDAddElement(CFTypeRef refElement, recDevice * pDevice)
+{
+    recElement *element = NULL;
+    recElement **headElement = NULL;
+    long elementType, usagePage, usage;
+    CFTypeRef refElementType =
+        CFDictionaryGetValue(refElement, CFSTR(kIOHIDElementTypeKey));
+    CFTypeRef refUsagePage =
+        CFDictionaryGetValue(refElement, CFSTR(kIOHIDElementUsagePageKey));
+    CFTypeRef refUsage =
+        CFDictionaryGetValue(refElement, CFSTR(kIOHIDElementUsageKey));
+
+
+    if ((refElementType)
+        &&
+        (CFNumberGetValue(refElementType, kCFNumberLongType, &elementType))) {
+        /* look at types of interest */
+        if ((elementType == kIOHIDElementTypeInput_Misc)
+            || (elementType == kIOHIDElementTypeInput_Button)
+            || (elementType == kIOHIDElementTypeInput_Axis)) {
+            if (refUsagePage
+                && CFNumberGetValue(refUsagePage, kCFNumberLongType,
+                                    &usagePage) && refUsage
+                && CFNumberGetValue(refUsage, kCFNumberLongType, &usage)) {
+                switch (usagePage) {    /* only interested in kHIDPage_GenericDesktop and kHIDPage_Button */
+                case kHIDPage_GenericDesktop:
+                    {
+                        switch (usage) {        /* look at usage to determine function */
+                        case kHIDUsage_GD_X:
+                        case kHIDUsage_GD_Y:
+                        case kHIDUsage_GD_Z:
+                        case kHIDUsage_GD_Rx:
+                        case kHIDUsage_GD_Ry:
+                        case kHIDUsage_GD_Rz:
+                        case kHIDUsage_GD_Slider:
+                        case kHIDUsage_GD_Dial:
+                        case kHIDUsage_GD_Wheel:
+                            element = (recElement *)
+                                NewPtrClear(sizeof(recElement));
+                            if (element) {
+                                pDevice->axes++;
+                                headElement = &(pDevice->firstAxis);
+                            }
+                            break;
+                        case kHIDUsage_GD_Hatswitch:
+                            element = (recElement *)
+                                NewPtrClear(sizeof(recElement));
+                            if (element) {
+                                pDevice->hats++;
+                                headElement = &(pDevice->firstHat);
+                            }
+                            break;
+                        }
+                    }
+                    break;
+                case kHIDPage_Button:
+                    element = (recElement *)
+                        NewPtrClear(sizeof(recElement));
+                    if (element) {
+                        pDevice->buttons++;
+                        headElement = &(pDevice->firstButton);
+                    }
+                    break;
+                default:
+                    break;
+                }
+            }
+        } else if (kIOHIDElementTypeCollection == elementType)
+            HIDGetCollectionElements((CFMutableDictionaryRef) refElement,
+                                     pDevice);
+    }
+
+    if (element && headElement) {       /* add to list */
+        recElement *elementPrevious = NULL;
+        recElement *elementCurrent = *headElement;
+        while (elementCurrent && usage >= elementCurrent->usage) {
+            elementPrevious = elementCurrent;
+            elementCurrent = elementCurrent->pNext;
+        }
+        if (elementPrevious) {
+            elementPrevious->pNext = element;
+        } else {
+            *headElement = element;
+        }
+        element->usagePage = usagePage;
+        element->usage = usage;
+        element->pNext = elementCurrent;
+        HIDGetElementInfo(refElement, element);
+        pDevice->elements++;
+    }
+}
+
+/* collects information from each array member in device element list (each array memeber = element) */
+
+static void
+HIDGetElementsCFArrayHandler(const void *value, void *parameter)
+{
+    if (CFGetTypeID(value) == CFDictionaryGetTypeID())
+        HIDAddElement((CFTypeRef) value, (recDevice *) parameter);
+}
+
+/* handles retrieval of element information from arrays of elements in device IO registry information */
+
+static void
+HIDGetElements(CFTypeRef refElementCurrent, recDevice * pDevice)
+{
+    CFTypeID type = CFGetTypeID(refElementCurrent);
+    if (type == CFArrayGetTypeID()) {   /* if element is an array */
+        CFRange range = { 0, CFArrayGetCount(refElementCurrent) };
+        /* CountElementsCFArrayHandler called for each array member */
+        CFArrayApplyFunction(refElementCurrent, range,
+                             HIDGetElementsCFArrayHandler, pDevice);
+    }
+}
+
+/* handles extracting element information from element collection CF types
+ * used from top level element decoding and hierarchy deconstruction to flatten device element list
+ */
+
+static void
+HIDGetCollectionElements(CFMutableDictionaryRef deviceProperties,
+                         recDevice * pDevice)
+{
+    CFTypeRef refElementTop =
+        CFDictionaryGetValue(deviceProperties, CFSTR(kIOHIDElementKey));
+    if (refElementTop)
+        HIDGetElements(refElementTop, pDevice);
+}
+
+/* use top level element usage page and usage to discern device usage page and usage setting appropriate vlaues in device record */
+
+static void
+HIDTopLevelElementHandler(const void *value, void *parameter)
+{
+    CFTypeRef refCF = 0;
+    if (CFGetTypeID(value) != CFDictionaryGetTypeID())
+        return;
+    refCF = CFDictionaryGetValue(value, CFSTR(kIOHIDElementUsagePageKey));
+    if (!CFNumberGetValue
+        (refCF, kCFNumberLongType, &((recDevice *) parameter)->usagePage))
+        SDL_SetError("CFNumberGetValue error retrieving pDevice->usagePage.");
+    refCF = CFDictionaryGetValue(value, CFSTR(kIOHIDElementUsageKey));
+    if (!CFNumberGetValue
+        (refCF, kCFNumberLongType, &((recDevice *) parameter)->usage))
+        SDL_SetError("CFNumberGetValue error retrieving pDevice->usage.");
+}
+
+/* extracts device info from CF dictionary records in IO registry */
+
+static void
+HIDGetDeviceInfo(io_object_t hidDevice, CFMutableDictionaryRef hidProperties,
+                 recDevice * pDevice)
+{
+    CFMutableDictionaryRef usbProperties = 0;
+    io_registry_entry_t parent1, parent2;
+
+    /* Mac OS X currently is not mirroring all USB properties to HID page so need to look at USB device page also
+     * get dictionary for usb properties: step up two levels and get CF dictionary for USB properties
+     */
+    if ((KERN_SUCCESS ==
+         IORegistryEntryGetParentEntry(hidDevice, kIOServicePlane, &parent1))
+        && (KERN_SUCCESS ==
+            IORegistryEntryGetParentEntry(parent1, kIOServicePlane, &parent2))
+        && (KERN_SUCCESS ==
+            IORegistryEntryCreateCFProperties(parent2, &usbProperties,
+                                              kCFAllocatorDefault,
+                                              kNilOptions))) {
+        if (usbProperties) {
+            CFTypeRef refCF = 0;
+            /* get device info
+             * try hid dictionary first, if fail then go to usb dictionary
+             */
+
+
+            /* get product name */
+            refCF =
+                CFDictionaryGetValue(hidProperties, CFSTR(kIOHIDProductKey));
+            if (!refCF)
+                refCF =
+                    CFDictionaryGetValue(usbProperties,
+                                         CFSTR("USB Product Name"));
+            if (refCF) {
+                if (!CFStringGetCString
+                    (refCF, pDevice->product, 256,
+                     CFStringGetSystemEncoding()))
+                    SDL_SetError
+                        ("CFStringGetCString error retrieving pDevice->product.");
+            }
+
+            /* get usage page and usage */
+            refCF =
+                CFDictionaryGetValue(hidProperties,
+                                     CFSTR(kIOHIDPrimaryUsagePageKey));
+            if (refCF) {
+                if (!CFNumberGetValue
+                    (refCF, kCFNumberLongType, &pDevice->usagePage))
+                    SDL_SetError
+                        ("CFNumberGetValue error retrieving pDevice->usagePage.");
+                refCF =
+                    CFDictionaryGetValue(hidProperties,
+                                         CFSTR(kIOHIDPrimaryUsageKey));
+                if (refCF)
+                    if (!CFNumberGetValue
+                        (refCF, kCFNumberLongType, &pDevice->usage))
+                        SDL_SetError
+                            ("CFNumberGetValue error retrieving pDevice->usage.");
+            }
+
+            if (NULL == refCF) {        /* get top level element HID usage page or usage */
+                /* use top level element instead */
+                CFTypeRef refCFTopElement = 0;
+                refCFTopElement =
+                    CFDictionaryGetValue(hidProperties,
+                                         CFSTR(kIOHIDElementKey));
+                {
+                    /* refCFTopElement points to an array of element dictionaries */
+                    CFRange range = { 0, CFArrayGetCount(refCFTopElement) };
+                    CFArrayApplyFunction(refCFTopElement, range,
+                                         HIDTopLevelElementHandler, pDevice);
+                }
+            }
+
+            CFRelease(usbProperties);
+        } else
+            SDL_SetError
+                ("IORegistryEntryCreateCFProperties failed to create usbProperties.");
+
+        if (kIOReturnSuccess != IOObjectRelease(parent2))
+            SDL_SetError("IOObjectRelease error with parent2.");
+        if (kIOReturnSuccess != IOObjectRelease(parent1))
+            SDL_SetError("IOObjectRelease error with parent1.");
+    }
+}
+
+
+static recDevice *
+HIDBuildDevice(io_object_t hidDevice)
+{
+    recDevice *pDevice = (recDevice *) NewPtrClear(sizeof(recDevice));
+    if (pDevice) {
+        /* get dictionary for HID properties */
+        CFMutableDictionaryRef hidProperties = 0;
+        kern_return_t result =
+            IORegistryEntryCreateCFProperties(hidDevice, &hidProperties,
+                                              kCFAllocatorDefault,
+                                              kNilOptions);
+        if ((result == KERN_SUCCESS) && hidProperties) {
+            /* create device interface */
+            result = HIDCreateOpenDeviceInterface(hidDevice, pDevice);
+            if (kIOReturnSuccess == result) {
+                HIDGetDeviceInfo(hidDevice, hidProperties, pDevice);    /* hidDevice used to find parents in registry tree */
+                HIDGetCollectionElements(hidProperties, pDevice);
+            } else {
+                DisposePtr((Ptr) pDevice);
+                pDevice = NULL;
+            }
+            CFRelease(hidProperties);
+        } else {
+            DisposePtr((Ptr) pDevice);
+            pDevice = NULL;
+        }
+    }
+    return pDevice;
+}
+
+/* disposes of the element list associated with a device and the memory associated with the list
+ */
+
+static void
+HIDDisposeElementList(recElement ** elementList)
+{
+    recElement *pElement = *elementList;
+    while (pElement) {
+        recElement *pElementNext = pElement->pNext;
+        DisposePtr((Ptr) pElement);
+        pElement = pElementNext;
+    }
+    *elementList = NULL;
+}
+
+/* disposes of a single device, closing and releaseing interface, freeing memory fro device and elements, setting device pointer to NULL
+ * all your device no longer belong to us... (i.e., you do not 'own' the device anymore)
+ */
+
+static recDevice *
+HIDDisposeDevice(recDevice ** ppDevice)
+{
+    kern_return_t result = KERN_SUCCESS;
+    recDevice *pDeviceNext = NULL;
+    if (*ppDevice) {
+        /* save next device prior to disposing of this device */
+        pDeviceNext = (*ppDevice)->pNext;
+
+        /* free posible io_service_t */
+        if ((*ppDevice)->ffservice) {
+            IOObjectRelease((*ppDevice)->ffservice);
+            (*ppDevice)->ffservice = 0;
+        }
+
+        /* free element lists */
+        HIDDisposeElementList(&(*ppDevice)->firstAxis);
+        HIDDisposeElementList(&(*ppDevice)->firstButton);
+        HIDDisposeElementList(&(*ppDevice)->firstHat);
+
+        result = HIDCloseReleaseInterface(*ppDevice);   /* function sanity checks interface value (now application does not own device) */
+        if (kIOReturnSuccess != result)
+            HIDReportErrorNum
+                ("HIDCloseReleaseInterface failed when trying to dipose device.",
+                 result);
+        DisposePtr((Ptr) * ppDevice);
+        *ppDevice = NULL;
+    }
+    return pDeviceNext;
+}
+
+
+/* Function to scan the system for joysticks.
+ * Joystick 0 should be the system default joystick.
+ * This function should return the number of available joysticks, or -1
+ * on an unrecoverable fatal error.
+ */
+int
+SDL_SYS_JoystickInit(void)
+{
+    IOReturn result = kIOReturnSuccess;
+    mach_port_t masterPort = 0;
+    io_iterator_t hidObjectIterator = 0;
+    CFMutableDictionaryRef hidMatchDictionary = NULL;
+    recDevice *device, *lastDevice;
+    io_object_t ioHIDDeviceObject = 0;
+
+    SDL_numjoysticks = 0;
+
+    if (gpDeviceList) {
+        SDL_SetError("Joystick: Device list already inited.");
+        return -1;
+    }
+
+    result = IOMasterPort(bootstrap_port, &masterPort);
+    if (kIOReturnSuccess != result) {
+        SDL_SetError("Joystick: IOMasterPort error with bootstrap_port.");
+        return -1;
+    }
+
+    /* Set up a matching dictionary to search I/O Registry by class name for all HID class devices. */
+    hidMatchDictionary = IOServiceMatching(kIOHIDDeviceKey);
+    if (hidMatchDictionary) {
+        /* Add key for device type (joystick, in this case) to refine the matching dictionary. */
+
+        /* NOTE: we now perform this filtering later
+           UInt32 usagePage = kHIDPage_GenericDesktop;
+           UInt32 usage = kHIDUsage_GD_Joystick;
+           CFNumberRef refUsage = NULL, refUsagePage = NULL;
+
+           refUsage = CFNumberCreate (kCFAllocatorDefault, kCFNumberIntType, &usage);
+           CFDictionarySetValue (hidMatchDictionary, CFSTR (kIOHIDPrimaryUsageKey), refUsage);
+           refUsagePage = CFNumberCreate (kCFAllocatorDefault, kCFNumberIntType, &usagePage);
+           CFDictionarySetValue (hidMatchDictionary, CFSTR (kIOHIDPrimaryUsagePageKey), refUsagePage);
+         */
+    } else {
+        SDL_SetError
+            ("Joystick: Failed to get HID CFMutableDictionaryRef via IOServiceMatching.");
+        return -1;
+    }
+
+    /*/ Now search I/O Registry for matching devices. */
+    result =
+        IOServiceGetMatchingServices(masterPort, hidMatchDictionary,
+                                     &hidObjectIterator);
+    /* Check for errors */
+    if (kIOReturnSuccess != result) {
+        SDL_SetError("Joystick: Couldn't create a HID object iterator.");
+        return -1;
+    }
+    if (!hidObjectIterator) {   /* there are no joysticks */
+        gpDeviceList = NULL;
+        SDL_numjoysticks = 0;
+        return 0;
+    }
+    /* IOServiceGetMatchingServices consumes a reference to the dictionary, so we don't need to release the dictionary ref. */
+
+    /* build flat linked list of devices from device iterator */
+
+    gpDeviceList = lastDevice = NULL;
+
+    while ((ioHIDDeviceObject = IOIteratorNext(hidObjectIterator))) {
+        /* build a device record */
+        device = HIDBuildDevice(ioHIDDeviceObject);
+        if (!device)
+            continue;
+
+        /* Filter device list to non-keyboard/mouse stuff */
+        if ((device->usagePage != kHIDPage_GenericDesktop) ||
+            ((device->usage != kHIDUsage_GD_Joystick &&
+              device->usage != kHIDUsage_GD_GamePad &&
+              device->usage != kHIDUsage_GD_MultiAxisController))) {
+
+            /* release memory for the device */
+            HIDDisposeDevice(&device);
+            DisposePtr((Ptr) device);
+            continue;
+        }
+
+        /* We have to do some storage of the io_service_t for
+         * SDL_HapticOpenFromJoystick */
+        if (FFIsForceFeedback(ioHIDDeviceObject) == FF_OK) {
+            device->ffservice = ioHIDDeviceObject;
+        } else {
+            device->ffservice = 0;
+        }
+
+        /* Add device to the end of the list */
+        if (lastDevice)
+            lastDevice->pNext = device;
+        else
+            gpDeviceList = device;
+        lastDevice = device;
+    }
+    result = IOObjectRelease(hidObjectIterator);        /* release the iterator */
+
+    /* Count the total number of devices we found */
+    device = gpDeviceList;
+    while (device) {
+        SDL_numjoysticks++;
+        device = device->pNext;
+    }
+
+    return SDL_numjoysticks;
+}
+
+/* Function to get the device-dependent name of a joystick */
+const char *
+SDL_SYS_JoystickName(int index)
+{
+    recDevice *device = gpDeviceList;
+
+    for (; index > 0; index--)
+        device = device->pNext;
+
+    return device->product;
+}
+
+/* Function to open a joystick for use.
+ * The joystick to open is specified by the index field of the joystick.
+ * This should fill the nbuttons and naxes fields of the joystick structure.
+ * It returns 0, or -1 if there is an error.
+ */
+int
+SDL_SYS_JoystickOpen(SDL_Joystick * joystick)
+{
+    recDevice *device = gpDeviceList;
+    int index;
+
+    for (index = joystick->index; index > 0; index--)
+        device = device->pNext;
+
+    joystick->hwdata = device;
+    joystick->name = device->product;
+
+    joystick->naxes = device->axes;
+    joystick->nhats = device->hats;
+    joystick->nballs = 0;
+    joystick->nbuttons = device->buttons;
+
+    return 0;
+}
+
+/* Function to update the state of a joystick - called as a device poll.
+ * This function shouldn't update the joystick structure directly,
+ * but instead should call SDL_PrivateJoystick*() to deliver events
+ * and update joystick device state.
+ */
+void
+SDL_SYS_JoystickUpdate(SDL_Joystick * joystick)
+{
+    recDevice *device = joystick->hwdata;
+    recElement *element;
+    SInt32 value, range;
+    int i;
+
+    if (device->removed) {      /* device was unplugged; ignore it. */
+        if (device->uncentered) {
+            device->uncentered = 0;
+
+            /* Tell the app that everything is centered/unpressed... */
+            for (i = 0; i < device->axes; i++)
+                SDL_PrivateJoystickAxis(joystick, i, 0);
+
+            for (i = 0; i < device->buttons; i++)
+                SDL_PrivateJoystickButton(joystick, i, 0);
+
+            for (i = 0; i < device->hats; i++)
+                SDL_PrivateJoystickHat(joystick, i, SDL_HAT_CENTERED);
+        }
+
+        return;
+    }
+
+    element = device->firstAxis;
+    i = 0;
+    while (element) {
+        value = HIDScaledCalibratedValue(device, element, -32768, 32767);
+        if (value != joystick->axes[i])
+            SDL_PrivateJoystickAxis(joystick, i, value);
+        element = element->pNext;
+        ++i;
+    }
+
+    element = device->firstButton;
+    i = 0;
+    while (element) {
+        value = HIDGetElementValue(device, element);
+        if (value > 1)          /* handle pressure-sensitive buttons */
+            value = 1;
+        if (value != joystick->buttons[i])
+            SDL_PrivateJoystickButton(joystick, i, value);
+        element = element->pNext;
+        ++i;
+    }
+
+    element = device->firstHat;
+    i = 0;
+    while (element) {
+        Uint8 pos = 0;
+
+        range = (element->max - element->min + 1);
+        value = HIDGetElementValue(device, element) - element->min;
+        if (range == 4)         /* 4 position hatswitch - scale up value */
+            value *= 2;
+        else if (range != 8)    /* Neither a 4 nor 8 positions - fall back to default position (centered) */
+            value = -1;
+        switch (value) {
+        case 0:
+            pos = SDL_HAT_UP;
+            break;
+        case 1:
+            pos = SDL_HAT_RIGHTUP;
+            break;
+        case 2:
+            pos = SDL_HAT_RIGHT;
+            break;
+        case 3:
+            pos = SDL_HAT_RIGHTDOWN;
+            break;
+        case 4:
+            pos = SDL_HAT_DOWN;
+            break;
+        case 5:
+            pos = SDL_HAT_LEFTDOWN;
+            break;
+        case 6:
+            pos = SDL_HAT_LEFT;
+            break;
+        case 7:
+            pos = SDL_HAT_LEFTUP;
+            break;
+        default:
+            /* Every other value is mapped to center. We do that because some
+             * joysticks use 8 and some 15 for this value, and apparently
+             * there are even more variants out there - so we try to be generous.
+             */
+            pos = SDL_HAT_CENTERED;
+            break;
+        }
+        if (pos != joystick->hats[i])
+            SDL_PrivateJoystickHat(joystick, i, pos);
+        element = element->pNext;
+        ++i;
+    }
+
+    return;
+}
+
+/* Function to close a joystick after use */
+void
+SDL_SYS_JoystickClose(SDL_Joystick * joystick)
+{
+    /* Should we do anything here? */
+    return;
+}
+
+/* Function to perform any system-specific joystick related cleanup */
+void
+SDL_SYS_JoystickQuit(void)
+{
+    while (NULL != gpDeviceList)
+        gpDeviceList = HIDDisposeDevice(&gpDeviceList);
+}
+
+#endif /* SDL_JOYSTICK_IOKIT */
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/joystick/darwin/SDL_sysjoystick_c.h b/macosx/plugins/Common/SDL/src/joystick/darwin/SDL_sysjoystick_c.h
new file mode 100644
index 00000000..d413f336
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/joystick/darwin/SDL_sysjoystick_c.h
@@ -0,0 +1,88 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+#ifndef SDL_JOYSTICK_IOKIT_H
+
+
+#if MAC_OS_X_VERSION_MIN_REQUIRED == 1030
+#include "10.3.9-FIX/IOHIDLib.h"
+#else
+#include <IOKit/hid/IOHIDLib.h>
+#endif
+#include <IOKit/hid/IOHIDKeys.h>
+
+
+struct recElement
+{
+    IOHIDElementCookie cookie;  /* unique value which identifies element, will NOT change */
+    long usagePage, usage;      /* HID usage */
+    long min;                   /* reported min value possible */
+    long max;                   /* reported max value possible */
+#if 0
+    /* TODO: maybe should handle the following stuff somehow? */
+
+    long scaledMin;             /* reported scaled min value possible */
+    long scaledMax;             /* reported scaled max value possible */
+    long size;                  /* size in bits of data return from element */
+    Boolean relative;           /* are reports relative to last report (deltas) */
+    Boolean wrapping;           /* does element wrap around (one value higher than max is min) */
+    Boolean nonLinear;          /* are the values reported non-linear relative to element movement */
+    Boolean preferredState;     /* does element have a preferred state (such as a button) */
+    Boolean nullState;          /* does element have null state */
+#endif                          /* 0 */
+
+    /* runtime variables used for auto-calibration */
+    long minReport;             /* min returned value */
+    long maxReport;             /* max returned value */
+
+    struct recElement *pNext;   /* next element in list */
+};
+typedef struct recElement recElement;
+
+struct joystick_hwdata
+{
+    io_service_t ffservice;     /* Interface for force feedback, 0 = no ff */
+    IOHIDDeviceInterface **interface;   /* interface to device, NULL = no interface */
+
+    char product[256];          /* name of product */
+    long usage;                 /* usage page from IOUSBHID Parser.h which defines general usage */
+    long usagePage;             /* usage within above page from IOUSBHID Parser.h which defines specific usage */
+
+    long axes;                  /* number of axis (calculated, not reported by device) */
+    long buttons;               /* number of buttons (calculated, not reported by device) */
+    long hats;                  /* number of hat switches (calculated, not reported by device) */
+    long elements;              /* number of total elements (shouldbe total of above) (calculated, not reported by device) */
+
+    recElement *firstAxis;
+    recElement *firstButton;
+    recElement *firstHat;
+
+    int removed;
+    int uncentered;
+
+    struct joystick_hwdata *pNext;      /* next device */
+};
+typedef struct joystick_hwdata recDevice;
+
+
+#endif /* SDL_JOYSTICK_IOKIT_H */
diff --git a/macosx/plugins/Common/SDL/src/thread/SDL_systhread.h b/macosx/plugins/Common/SDL/src/thread/SDL_systhread.h
new file mode 100644
index 00000000..584f20db
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/thread/SDL_systhread.h
@@ -0,0 +1,53 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+/* These are functions that need to be implemented by a port of SDL */
+
+#ifndef _SDL_systhread_h
+#define _SDL_systhread_h
+
+#include "SDL_thread.h"
+
+/* This function creates a thread, passing args to SDL_RunThread(),
+   saves a system-dependent thread id in thread->id, and returns 0
+   on success.
+*/
+#ifdef SDL_PASSED_BEGINTHREAD_ENDTHREAD
+extern int SDL_SYS_CreateThread(SDL_Thread * thread, void *args,
+                                pfnSDL_CurrentBeginThread pfnBeginThread,
+                                pfnSDL_CurrentEndThread pfnEndThread);
+#else
+extern int SDL_SYS_CreateThread(SDL_Thread * thread, void *args);
+#endif
+
+/* This function does any necessary setup in the child thread */
+extern void SDL_SYS_SetupThread(void);
+
+/* This function waits for the thread to finish and frees any data
+   allocated by SDL_SYS_CreateThread()
+ */
+extern void SDL_SYS_WaitThread(SDL_Thread * thread);
+
+#endif /* _SDL_systhread_h */
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/thread/SDL_thread.c b/macosx/plugins/Common/SDL/src/thread/SDL_thread.c
new file mode 100644
index 00000000..4d43a8e1
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/thread/SDL_thread.c
@@ -0,0 +1,291 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+/* System independent thread management routines for SDL */
+
+#include "SDL_mutex.h"
+#include "SDL_thread.h"
+#include "SDL_thread_c.h"
+#include "SDL_systhread.h"
+
+#define ARRAY_CHUNKSIZE	32
+/* The array of threads currently active in the application
+   (except the main thread)
+   The manipulation of an array here is safer than using a linked list.
+*/
+static int SDL_maxthreads = 0;
+static int SDL_numthreads = 0;
+static SDL_Thread **SDL_Threads = NULL;
+static SDL_mutex *thread_lock = NULL;
+
+static int
+SDL_ThreadsInit(void)
+{
+    int retval;
+
+    retval = 0;
+    thread_lock = SDL_CreateMutex();
+    if (thread_lock == NULL) {
+        retval = -1;
+    }
+    return (retval);
+}
+
+/* Routines for manipulating the thread list */
+static void
+SDL_AddThread(SDL_Thread * thread)
+{
+    /* WARNING:
+       If the very first threads are created simultaneously, then
+       there could be a race condition causing memory corruption.
+       In practice, this isn't a problem because by definition there
+       is only one thread running the first time this is called.
+     */
+    if (!thread_lock) {
+        if (SDL_ThreadsInit() < 0) {
+            return;
+        }
+    }
+    SDL_mutexP(thread_lock);
+
+    /* Expand the list of threads, if necessary */
+#ifdef DEBUG_THREADS
+    printf("Adding thread (%d already - %d max)\n",
+           SDL_numthreads, SDL_maxthreads);
+#endif
+    if (SDL_numthreads == SDL_maxthreads) {
+        SDL_Thread **threads;
+        threads = (SDL_Thread **) SDL_realloc(SDL_Threads,
+                                              (SDL_maxthreads +
+                                               ARRAY_CHUNKSIZE) *
+                                              (sizeof *threads));
+        if (threads == NULL) {
+            SDL_OutOfMemory();
+            goto done;
+        }
+        SDL_maxthreads += ARRAY_CHUNKSIZE;
+        SDL_Threads = threads;
+    }
+    SDL_Threads[SDL_numthreads++] = thread;
+  done:
+    SDL_mutexV(thread_lock);
+}
+
+static void
+SDL_DelThread(SDL_Thread * thread)
+{
+    int i;
+
+    if (!thread_lock) {
+        return;
+    }
+    SDL_mutexP(thread_lock);
+    for (i = 0; i < SDL_numthreads; ++i) {
+        if (thread == SDL_Threads[i]) {
+            break;
+        }
+    }
+    if (i < SDL_numthreads) {
+        if (--SDL_numthreads > 0) {
+            while (i < SDL_numthreads) {
+                SDL_Threads[i] = SDL_Threads[i + 1];
+                ++i;
+            }
+        } else {
+            SDL_maxthreads = 0;
+            SDL_free(SDL_Threads);
+            SDL_Threads = NULL;
+        }
+#ifdef DEBUG_THREADS
+        printf("Deleting thread (%d left - %d max)\n",
+               SDL_numthreads, SDL_maxthreads);
+#endif
+    }
+    SDL_mutexV(thread_lock);
+
+#if 0   /* There could be memory corruption if another thread is starting */
+    if (SDL_Threads == NULL) {
+        SDL_ThreadsQuit();
+    }
+#endif
+}
+
+/* The default (non-thread-safe) global error variable */
+static SDL_error SDL_global_error;
+
+/* Routine to get the thread-specific error variable */
+SDL_error *
+SDL_GetErrBuf(void)
+{
+    SDL_error *errbuf;
+
+    errbuf = &SDL_global_error;
+    if (SDL_Threads) {
+        int i;
+        SDL_threadID this_thread;
+
+        this_thread = SDL_ThreadID();
+        SDL_mutexP(thread_lock);
+        for (i = 0; i < SDL_numthreads; ++i) {
+            if (this_thread == SDL_Threads[i]->threadid) {
+                errbuf = &SDL_Threads[i]->errbuf;
+                break;
+            }
+        }
+        SDL_mutexV(thread_lock);
+    }
+    return (errbuf);
+}
+
+
+/* Arguments and callback to setup and run the user thread function */
+typedef struct
+{
+    int (SDLCALL * func) (void *);
+    void *data;
+    SDL_Thread *info;
+    SDL_sem *wait;
+} thread_args;
+
+void
+SDL_RunThread(void *data)
+{
+    thread_args *args;
+    int (SDLCALL * userfunc) (void *);
+    void *userdata;
+    int *statusloc;
+
+    /* Perform any system-dependent setup
+       - this function cannot fail, and cannot use SDL_SetError()
+     */
+    SDL_SYS_SetupThread();
+
+    /* Get the thread id */
+    args = (thread_args *) data;
+    args->info->threadid = SDL_ThreadID();
+
+    /* Figure out what function to run */
+    userfunc = args->func;
+    userdata = args->data;
+    statusloc = &args->info->status;
+
+    /* Wake up the parent thread */
+    SDL_SemPost(args->wait);
+
+    /* Run the function */
+    *statusloc = userfunc(userdata);
+}
+
+#ifdef SDL_PASSED_BEGINTHREAD_ENDTHREAD
+#undef SDL_CreateThread
+DECLSPEC SDL_Thread *SDLCALL
+SDL_CreateThread(int (SDLCALL * fn) (void *), void *data,
+                 pfnSDL_CurrentBeginThread pfnBeginThread,
+                 pfnSDL_CurrentEndThread pfnEndThread)
+#else
+DECLSPEC SDL_Thread *SDLCALL
+SDL_CreateThread(int (SDLCALL * fn) (void *), void *data)
+#endif
+{
+    SDL_Thread *thread;
+    thread_args *args;
+    int ret;
+
+    /* Allocate memory for the thread info structure */
+    thread = (SDL_Thread *) SDL_malloc(sizeof(*thread));
+    if (thread == NULL) {
+        SDL_OutOfMemory();
+        return (NULL);
+    }
+    SDL_memset(thread, 0, (sizeof *thread));
+    thread->status = -1;
+
+    /* Set up the arguments for the thread */
+    args = (thread_args *) SDL_malloc(sizeof(*args));
+    if (args == NULL) {
+        SDL_OutOfMemory();
+        SDL_free(thread);
+        return (NULL);
+    }
+    args->func = fn;
+    args->data = data;
+    args->info = thread;
+    args->wait = SDL_CreateSemaphore(0);
+    if (args->wait == NULL) {
+        SDL_free(thread);
+        SDL_free(args);
+        return (NULL);
+    }
+
+    /* Add the thread to the list of available threads */
+    SDL_AddThread(thread);
+
+    /* Create the thread and go! */
+#ifdef SDL_PASSED_BEGINTHREAD_ENDTHREAD
+    ret = SDL_SYS_CreateThread(thread, args, pfnBeginThread, pfnEndThread);
+#else
+    ret = SDL_SYS_CreateThread(thread, args);
+#endif
+    if (ret >= 0) {
+        /* Wait for the thread function to use arguments */
+        SDL_SemWait(args->wait);
+    } else {
+        /* Oops, failed.  Gotta free everything */
+        SDL_DelThread(thread);
+        SDL_free(thread);
+        thread = NULL;
+    }
+    SDL_DestroySemaphore(args->wait);
+    SDL_free(args);
+
+    /* Everything is running now */
+    return (thread);
+}
+
+void
+SDL_WaitThread(SDL_Thread * thread, int *status)
+{
+    if (thread) {
+        SDL_SYS_WaitThread(thread);
+        if (status) {
+            *status = thread->status;
+        }
+        SDL_DelThread(thread);
+        SDL_free(thread);
+    }
+}
+
+SDL_threadID
+SDL_GetThreadID(SDL_Thread * thread)
+{
+    SDL_threadID id;
+
+    if (thread) {
+        id = thread->threadid;
+    } else {
+        id = SDL_ThreadID();
+    }
+    return id;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/thread/SDL_thread_c.h b/macosx/plugins/Common/SDL/src/thread/SDL_thread_c.h
new file mode 100644
index 00000000..4b670580
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/thread/SDL_thread_c.h
@@ -0,0 +1,45 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+#ifndef _SDL_thread_c_h
+#define _SDL_thread_c_h
+
+/* Need the definitions of SYS_ThreadHandle */
+#include "pthread/SDL_systhread_c.h"
+#include "../SDL_error_c.h"
+
+/* This is the system-independent thread info structure */
+struct SDL_Thread
+{
+    SDL_threadID threadid;
+    SYS_ThreadHandle handle;
+    int status;
+    SDL_error errbuf;
+    void *data;
+};
+
+/* This is the function called to run a thread */
+extern void SDL_RunThread(void *data);
+
+#endif /* _SDL_thread_c_h */
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/thread/pthread/SDL_syscond.c b/macosx/plugins/Common/SDL/src/thread/pthread/SDL_syscond.c
new file mode 100644
index 00000000..547daa71
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/thread/pthread/SDL_syscond.c
@@ -0,0 +1,163 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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 <sys/time.h>
+#include <unistd.h>
+#include <errno.h>
+#include <pthread.h>
+
+#include "SDL_thread.h"
+#include "SDL_sysmutex_c.h"
+
+struct SDL_cond
+{
+    pthread_cond_t cond;
+};
+
+/* Create a condition variable */
+SDL_cond *
+SDL_CreateCond(void)
+{
+    SDL_cond *cond;
+
+    cond = (SDL_cond *) SDL_malloc(sizeof(SDL_cond));
+    if (cond) {
+        if (pthread_cond_init(&cond->cond, NULL) < 0) {
+            SDL_SetError("pthread_cond_init() failed");
+            SDL_free(cond);
+            cond = NULL;
+        }
+    }
+    return (cond);
+}
+
+/* Destroy a condition variable */
+void
+SDL_DestroyCond(SDL_cond * cond)
+{
+    if (cond) {
+        pthread_cond_destroy(&cond->cond);
+        SDL_free(cond);
+    }
+}
+
+/* Restart one of the threads that are waiting on the condition variable */
+int
+SDL_CondSignal(SDL_cond * cond)
+{
+    int retval;
+
+    if (!cond) {
+        SDL_SetError("Passed a NULL condition variable");
+        return -1;
+    }
+
+    retval = 0;
+    if (pthread_cond_signal(&cond->cond) != 0) {
+        SDL_SetError("pthread_cond_signal() failed");
+        retval = -1;
+    }
+    return retval;
+}
+
+/* Restart all threads that are waiting on the condition variable */
+int
+SDL_CondBroadcast(SDL_cond * cond)
+{
+    int retval;
+
+    if (!cond) {
+        SDL_SetError("Passed a NULL condition variable");
+        return -1;
+    }
+
+    retval = 0;
+    if (pthread_cond_broadcast(&cond->cond) != 0) {
+        SDL_SetError("pthread_cond_broadcast() failed");
+        retval = -1;
+    }
+    return retval;
+}
+
+int
+SDL_CondWaitTimeout(SDL_cond * cond, SDL_mutex * mutex, Uint32 ms)
+{
+    int retval;
+    struct timeval delta;
+    struct timespec abstime;
+
+    if (!cond) {
+        SDL_SetError("Passed a NULL condition variable");
+        return -1;
+    }
+
+    gettimeofday(&delta, NULL);
+
+    abstime.tv_sec = delta.tv_sec + (ms / 1000);
+    abstime.tv_nsec = (delta.tv_usec + (ms % 1000) * 1000) * 1000;
+    if (abstime.tv_nsec > 1000000000) {
+        abstime.tv_sec += 1;
+        abstime.tv_nsec -= 1000000000;
+    }
+
+  tryagain:
+    retval = pthread_cond_timedwait(&cond->cond, &mutex->id, &abstime);
+    switch (retval) {
+    case EINTR:
+        goto tryagain;
+        break;
+    case ETIMEDOUT:
+        retval = SDL_MUTEX_TIMEDOUT;
+        break;
+    case 0:
+        break;
+    default:
+        SDL_SetError("pthread_cond_timedwait() failed");
+        retval = -1;
+        break;
+    }
+    return retval;
+}
+
+/* Wait on the condition variable, unlocking the provided mutex.
+   The mutex must be locked before entering this function!
+ */
+int
+SDL_CondWait(SDL_cond * cond, SDL_mutex * mutex)
+{
+    int retval;
+
+    if (!cond) {
+        SDL_SetError("Passed a NULL condition variable");
+        return -1;
+    }
+
+    retval = 0;
+    if (pthread_cond_wait(&cond->cond, &mutex->id) != 0) {
+        SDL_SetError("pthread_cond_wait() failed");
+        retval = -1;
+    }
+    return retval;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/thread/pthread/SDL_sysmutex.c b/macosx/plugins/Common/SDL/src/thread/pthread/SDL_sysmutex.c
new file mode 100644
index 00000000..701c7f60
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/thread/pthread/SDL_sysmutex.c
@@ -0,0 +1,161 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+#define _GNU_SOURCE
+#include <pthread.h>
+
+#include "SDL_thread.h"
+
+#if !SDL_THREAD_PTHREAD_RECURSIVE_MUTEX && \
+    !SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP
+#define FAKE_RECURSIVE_MUTEX
+#endif
+
+struct SDL_mutex
+{
+    pthread_mutex_t id;
+#ifdef FAKE_RECURSIVE_MUTEX
+    int recursive;
+    pthread_t owner;
+#endif
+};
+
+SDL_mutex *
+SDL_CreateMutex(void)
+{
+    SDL_mutex *mutex;
+    pthread_mutexattr_t attr;
+
+    /* Allocate the structure */
+    mutex = (SDL_mutex *) SDL_calloc(1, sizeof(*mutex));
+    if (mutex) {
+        pthread_mutexattr_init(&attr);
+#if SDL_THREAD_PTHREAD_RECURSIVE_MUTEX
+        pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+#elif SDL_THREAD_PTHREAD_RECURSIVE_MUTEX_NP
+        pthread_mutexattr_setkind_np(&attr, PTHREAD_MUTEX_RECURSIVE_NP);
+#else
+        /* No extra attributes necessary */
+#endif
+        if (pthread_mutex_init(&mutex->id, &attr) != 0) {
+            SDL_SetError("pthread_mutex_init() failed");
+            SDL_free(mutex);
+            mutex = NULL;
+        }
+    } else {
+        SDL_OutOfMemory();
+    }
+    return (mutex);
+}
+
+void
+SDL_DestroyMutex(SDL_mutex * mutex)
+{
+    if (mutex) {
+        pthread_mutex_destroy(&mutex->id);
+        SDL_free(mutex);
+    }
+}
+
+/* Lock the mutex */
+int
+SDL_mutexP(SDL_mutex * mutex)
+{
+    int retval;
+#ifdef FAKE_RECURSIVE_MUTEX
+    pthread_t this_thread;
+#endif
+
+    if (mutex == NULL) {
+        SDL_SetError("Passed a NULL mutex");
+        return -1;
+    }
+
+    retval = 0;
+#ifdef FAKE_RECURSIVE_MUTEX
+    this_thread = pthread_self();
+    if (mutex->owner == this_thread) {
+        ++mutex->recursive;
+    } else {
+        /* The order of operations is important.
+           We set the locking thread id after we obtain the lock
+           so unlocks from other threads will fail.
+         */
+        if (pthread_mutex_lock(&mutex->id) == 0) {
+            mutex->owner = this_thread;
+            mutex->recursive = 0;
+        } else {
+            SDL_SetError("pthread_mutex_lock() failed");
+            retval = -1;
+        }
+    }
+#else
+    if (pthread_mutex_lock(&mutex->id) < 0) {
+        SDL_SetError("pthread_mutex_lock() failed");
+        retval = -1;
+    }
+#endif
+    return retval;
+}
+
+int
+SDL_mutexV(SDL_mutex * mutex)
+{
+    int retval;
+
+    if (mutex == NULL) {
+        SDL_SetError("Passed a NULL mutex");
+        return -1;
+    }
+
+    retval = 0;
+#ifdef FAKE_RECURSIVE_MUTEX
+    /* We can only unlock the mutex if we own it */
+    if (pthread_self() == mutex->owner) {
+        if (mutex->recursive) {
+            --mutex->recursive;
+        } else {
+            /* The order of operations is important.
+               First reset the owner so another thread doesn't lock
+               the mutex and set the ownership before we reset it,
+               then release the lock semaphore.
+             */
+            mutex->owner = 0;
+            pthread_mutex_unlock(&mutex->id);
+        }
+    } else {
+        SDL_SetError("mutex not owned by this thread");
+        retval = -1;
+    }
+
+#else
+    if (pthread_mutex_unlock(&mutex->id) < 0) {
+        SDL_SetError("pthread_mutex_unlock() failed");
+        retval = -1;
+    }
+#endif /* FAKE_RECURSIVE_MUTEX */
+
+    return retval;
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/thread/pthread/SDL_sysmutex_c.h b/macosx/plugins/Common/SDL/src/thread/pthread/SDL_sysmutex_c.h
new file mode 100644
index 00000000..e28b1190
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/thread/pthread/SDL_sysmutex_c.h
@@ -0,0 +1,33 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+#ifndef _SDL_mutex_c_h
+#define _SDL_mutex_c_h
+
+struct SDL_mutex
+{
+    pthread_mutex_t id;
+};
+
+#endif /* _SDL_mutex_c_h */
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/thread/pthread/SDL_syssem.c b/macosx/plugins/Common/SDL/src/thread/pthread/SDL_syssem.c
new file mode 100644
index 00000000..adc38a65
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/thread/pthread/SDL_syssem.c
@@ -0,0 +1,225 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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"
+
+/* An implementation of semaphores using mutexes and condition variables */
+
+#include "SDL_thread.h"
+#include "SDL_systhread_c.h"
+
+
+#if SDL_THREADS_DISABLED
+
+SDL_sem *
+SDL_CreateSemaphore(Uint32 initial_value)
+{
+    SDL_SetError("SDL not configured with thread support");
+    return (SDL_sem *) 0;
+}
+
+void
+SDL_DestroySemaphore(SDL_sem * sem)
+{
+    return;
+}
+
+int
+SDL_SemTryWait(SDL_sem * sem)
+{
+    SDL_SetError("SDL not configured with thread support");
+    return -1;
+}
+
+int
+SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout)
+{
+    SDL_SetError("SDL not configured with thread support");
+    return -1;
+}
+
+int
+SDL_SemWait(SDL_sem * sem)
+{
+    SDL_SetError("SDL not configured with thread support");
+    return -1;
+}
+
+Uint32
+SDL_SemValue(SDL_sem * sem)
+{
+    return 0;
+}
+
+int
+SDL_SemPost(SDL_sem * sem)
+{
+    SDL_SetError("SDL not configured with thread support");
+    return -1;
+}
+
+#else
+
+struct SDL_semaphore
+{
+    Uint32 count;
+    Uint32 waiters_count;
+    SDL_mutex *count_lock;
+    SDL_cond *count_nonzero;
+};
+
+SDL_sem *
+SDL_CreateSemaphore(Uint32 initial_value)
+{
+    SDL_sem *sem;
+
+    sem = (SDL_sem *) SDL_malloc(sizeof(*sem));
+    if (!sem) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+    sem->count = initial_value;
+    sem->waiters_count = 0;
+
+    sem->count_lock = SDL_CreateMutex();
+    sem->count_nonzero = SDL_CreateCond();
+    if (!sem->count_lock || !sem->count_nonzero) {
+        SDL_DestroySemaphore(sem);
+        return NULL;
+    }
+
+    return sem;
+}
+
+/* WARNING:
+   You cannot call this function when another thread is using the semaphore.
+*/
+void
+SDL_DestroySemaphore(SDL_sem * sem)
+{
+    if (sem) {
+        sem->count = 0xFFFFFFFF;
+        while (sem->waiters_count > 0) {
+            SDL_CondSignal(sem->count_nonzero);
+            //SDL_Delay(10);
+        }
+        SDL_DestroyCond(sem->count_nonzero);
+        if (sem->count_lock) {
+            SDL_mutexP(sem->count_lock);
+            SDL_mutexV(sem->count_lock);
+            SDL_DestroyMutex(sem->count_lock);
+        }
+        SDL_free(sem);
+    }
+}
+
+int
+SDL_SemTryWait(SDL_sem * sem)
+{
+    int retval;
+
+    if (!sem) {
+        SDL_SetError("Passed a NULL semaphore");
+        return -1;
+    }
+
+    retval = SDL_MUTEX_TIMEDOUT;
+    SDL_LockMutex(sem->count_lock);
+    if (sem->count > 0) {
+        --sem->count;
+        retval = 0;
+    }
+    SDL_UnlockMutex(sem->count_lock);
+
+    return retval;
+}
+
+int
+SDL_SemWaitTimeout(SDL_sem * sem, Uint32 timeout)
+{
+    int retval;
+
+    if (!sem) {
+        SDL_SetError("Passed a NULL semaphore");
+        return -1;
+    }
+
+    /* A timeout of 0 is an easy case */
+    if (timeout == 0) {
+        return SDL_SemTryWait(sem);
+    }
+
+    SDL_LockMutex(sem->count_lock);
+    ++sem->waiters_count;
+    retval = 0;
+    while ((sem->count == 0) && (retval != SDL_MUTEX_TIMEDOUT)) {
+        retval = SDL_CondWaitTimeout(sem->count_nonzero,
+                                     sem->count_lock, timeout);
+    }
+    --sem->waiters_count;
+    if (retval == 0) {
+        --sem->count;
+    }
+    SDL_UnlockMutex(sem->count_lock);
+
+    return retval;
+}
+
+int
+SDL_SemWait(SDL_sem * sem)
+{
+    return SDL_SemWaitTimeout(sem, SDL_MUTEX_MAXWAIT);
+}
+
+Uint32
+SDL_SemValue(SDL_sem * sem)
+{
+    Uint32 value;
+
+    value = 0;
+    if (sem) {
+        SDL_LockMutex(sem->count_lock);
+        value = sem->count;
+        SDL_UnlockMutex(sem->count_lock);
+    }
+    return value;
+}
+
+int
+SDL_SemPost(SDL_sem * sem)
+{
+    if (!sem) {
+        SDL_SetError("Passed a NULL semaphore");
+        return -1;
+    }
+
+    SDL_LockMutex(sem->count_lock);
+    if (sem->waiters_count > 0) {
+        SDL_CondSignal(sem->count_nonzero);
+    }
+    ++sem->count;
+    SDL_UnlockMutex(sem->count_lock);
+
+    return 0;
+}
+
+#endif /* SDL_THREADS_DISABLED */
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/thread/pthread/SDL_systhread.c b/macosx/plugins/Common/SDL/src/thread/pthread/SDL_systhread.c
new file mode 100644
index 00000000..c4f694fb
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/thread/pthread/SDL_systhread.c
@@ -0,0 +1,114 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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 <pthread.h>
+#include <signal.h>
+
+#include "SDL_thread.h"
+#include "../SDL_thread_c.h"
+#include "../SDL_systhread.h"
+
+/* List of signals to mask in the subthreads */
+static const int sig_list[] = {
+    SIGHUP, SIGINT, SIGQUIT, SIGPIPE, SIGALRM, SIGTERM, SIGCHLD, SIGWINCH,
+    SIGVTALRM, SIGPROF, 0
+};
+
+#ifdef __RISCOS__
+/* RISC OS needs to know the main thread for
+ * it's timer and event processing. */
+int riscos_using_threads = 0;
+SDL_threadID riscos_main_thread = 0;  /* Thread running events */
+#endif
+
+
+static void *
+RunThread(void *data)
+{
+    SDL_RunThread(data);
+    pthread_exit((void *) 0);
+    return ((void *) 0);        /* Prevent compiler warning */
+}
+
+int
+SDL_SYS_CreateThread(SDL_Thread * thread, void *args)
+{
+    pthread_attr_t type;
+
+    /* Set the thread attributes */
+    if (pthread_attr_init(&type) != 0) {
+        SDL_SetError("Couldn't initialize pthread attributes");
+        return (-1);
+    }
+    pthread_attr_setdetachstate(&type, PTHREAD_CREATE_JOINABLE);
+
+    /* Create the thread and go! */
+    if (pthread_create(&thread->handle, &type, RunThread, args) != 0) {
+        SDL_SetError("Not enough resources to create thread");
+        return (-1);
+    }
+#ifdef __RISCOS__
+    if (riscos_using_threads == 0) {
+        riscos_using_threads = 1;
+        riscos_main_thread = SDL_ThreadID();
+    }
+#endif
+
+    return (0);
+}
+
+void
+SDL_SYS_SetupThread(void)
+{
+    int i;
+    sigset_t mask;
+
+    /* Mask asynchronous signals for this thread */
+    sigemptyset(&mask);
+    for (i = 0; sig_list[i]; ++i) {
+        sigaddset(&mask, sig_list[i]);
+    }
+    pthread_sigmask(SIG_BLOCK, &mask, 0);
+
+#ifdef PTHREAD_CANCEL_ASYNCHRONOUS
+    /* Allow ourselves to be asynchronously cancelled */
+    {
+        int oldstate;
+        pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldstate);
+    }
+#endif
+}
+
+SDL_threadID
+SDL_ThreadID(void)
+{
+    return ((SDL_threadID) pthread_self());
+}
+
+void
+SDL_SYS_WaitThread(SDL_Thread * thread)
+{
+    pthread_join(thread->handle, 0);
+}
+
+/* vi: set ts=4 sw=4 expandtab: */
diff --git a/macosx/plugins/Common/SDL/src/thread/pthread/SDL_systhread_c.h b/macosx/plugins/Common/SDL/src/thread/pthread/SDL_systhread_c.h
new file mode 100644
index 00000000..8da81da1
--- /dev/null
+++ b/macosx/plugins/Common/SDL/src/thread/pthread/SDL_systhread_c.h
@@ -0,0 +1,28 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2010 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 <pthread.h>
+
+typedef pthread_t SYS_ThreadHandle;
+
+/* vi: set ts=4 sw=4 expandtab: */