--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Isolated/ALmixer_RWops.c	Thu Apr 28 16:22:30 2011 -0700
@@ -0,0 +1,108 @@
+#ifndef ALMIXER_COMPILED_WITH_SDL
+
+#include "ALmixer_RWops.h"
+#include <stdlib.h> /* malloc, free */
+#include <stdio.h> /* fopen, fseek, fread, fclose */
+#include <string.h> /* strerror */
+#include <errno.h> /* errno */
+
+/* (Note this is different than stdio's seek. This returns ftell.)
+ */
+static int stdio_seek(ALmixer_RWops* the_context, long offset, int whence)
+{
+	if(0 == fseek(the_context->hidden.stdio.fp, offset, whence))
+	{
+		return(ftell(the_context->hidden.stdio.fp));
+	}
+	else
+   	{
+/*		ALmixer_SetError("ALmixer_RWops seek failed: %s", strerror(errno)); */
+		return (-1);
+	}
+}
+
+static size_t stdio_read(ALmixer_RWops* the_context, void* ptr, size_t size, size_t nitems)
+{
+	size_t bytes_read;
+
+	bytes_read = fread(ptr, size, nitems, the_context->hidden.stdio.fp);
+	if(0 == bytes_read && ferror(the_context->hidden.stdio.fp))
+	{
+		/* not sure if strerror can convert ferror */
+/*		ALmixer_SetError("ALmixer_RWops read failed: %s", strerror(ferror(the_context->hidden.stdio.fp))); */
+	}
+	return bytes_read;
+}
+
+static size_t stdio_write(ALmixer_RWops* the_context, const void* ptr, size_t size, size_t nitems)
+{
+	size_t bytes_written;
+
+	bytes_written = fwrite(ptr, size, nitems, the_context->hidden.stdio.fp);
+	if(0 == bytes_written && ferror(the_context->hidden.stdio.fp))
+	{
+/*		ALmixer_SetError("ALmixer_RWops write failed: %s", strerror(ferror(the_context->hidden.stdio.fp))); */
+	}
+	return bytes_written;
+}
+
+static int stdio_close(ALmixer_RWops* the_context)
+{
+	int return_status = 0;
+	if(NULL != the_context)
+	{
+		if(0 != the_context->hidden.stdio.autoclose)
+		{
+			if(0 != fclose(the_context->hidden.stdio.fp))
+			{
+/*				ALmixer_SetError("ALmixer_RWops close failed: %s", strerror(errno)); */
+				return_status = -1;
+			}
+		}
+		free(the_context);
+	}
+	return return_status;
+}
+
+ALmixer_RWops* ALmixer_RWFromFP(FILE* file_pointer, char autoclose_flag)
+{
+    ALmixer_RWops* rw_ops = NULL;
+
+	rw_ops = (ALmixer_RWops*)malloc(sizeof(ALmixer_RWops));
+	if(NULL == rw_ops)
+	{
+/*		ALmixer_SetError("ALmixer_RWFromFP: Out of memory"); */
+		return NULL;
+	}
+
+	rw_ops->seek = stdio_seek;
+	rw_ops->read = stdio_read;
+	rw_ops->write = stdio_write;
+	rw_ops->close = stdio_close;
+	rw_ops->hidden.stdio.fp = file_pointer;
+	rw_ops->hidden.stdio.autoclose = autoclose_flag;
+	return rw_ops;
+}
+
+ALmixer_RWops* ALmixer_RWFromFile(const char* file_name, const char* file_mode)
+{
+    ALmixer_RWops* rw_ops = NULL;
+    FILE* file_pointer = NULL;
+    if(NULL == file_name || NULL == file_mode)
+	{
+/*		ALmixer_SetError("ALmixer_RWFromFile: No file or mode specified"); */
+        return NULL;
+    }
+	file_pointer = fopen(file_name, file_mode);
+	if(NULL == file_pointer)
+	{
+/*		ALmixer_SetError("ALmixer_RWFromFile: Could not open file: %s", strerror(errno)); */
+		return NULL;
+    }
+
+	rw_ops = ALmixer_RWFromFP(file_pointer, 1);
+    return rw_ops;
+}
+
+
+#endif /* ALMIXER_COMPILED_WITH_SDL */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Isolated/ALmixer_RWops.h	Thu Apr 28 16:22:30 2011 -0700
@@ -0,0 +1,117 @@
+#ifndef ALMIXER_RWOPS
+#define ALMIXER_RWOPS
+
+	#if defined(_WIN32)
+		#if defined(ALMIXER_RWOPS_BUILD_LIBRARY)
+			#define ALMIXER_RWOPS_DECLSPEC __declspec(dllexport)
+		#else
+			#define ALMIXER_RWOPS_DECLSPEC __declspec(dllimport)
+		#endif
+	#else
+		#if defined(ALMIXER_RWOPS_BUILD_LIBRARY)
+			#if defined (__GNUC__) && __GNUC__ >= 4
+				#define ALMIXER_RWOPS_DECLSPEC __attribute__((visibility("default")))
+			#else
+				#define ALMIXER_RWOPS_DECLSPEC
+			#endif
+		#else
+			#define ALMIXER_RWOPS_DECLSPEC
+		#endif
+	#endif
+
+	#if defined(_WIN32)
+		#define ALMIXER_RWOPS_CALL __cdecl
+	#else
+		#define ALMIXER_RWOPS_CALL
+	#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+	/* Trying to keep compatibility with SDL_RWops,
+	 * but I don't plan on reimplementing everything.
+	 */
+	#include <stdio.h>
+	#include <stddef.h>
+	/* The 'type' parameter needs to be 32-bits to match SDL_RWops.
+	 * <stdint.h> has been problematic for Visual Studio for years.
+	 * It appears that Visual Studio 2010 finally includes this.
+	 */
+	#include <stdint.h>
+	typedef struct ALmixer_RWops 
+	{
+		/** Seek to 'offset' relative to whence, one of stdio's whence values:
+		 *	SEEK_SET, SEEK_CUR, SEEK_END
+		 *  Returns the final offset in the data source.
+		 *  (Note this is different than stdio's seek. This returns ftell.)
+		 */
+		int (ALMIXER_RWOPS_CALL *seek)(struct ALmixer_RWops* the_context, long offset, int whence);
+
+		/** Read up to 'nitems' objects each of size 'size' from the data
+		 *  source to the area pointed at by 'ptr'.
+		 *  Returns the number of objects read, or -1 if the read failed.
+		 */
+		size_t (ALMIXER_RWOPS_CALL *read)(struct ALmixer_RWops* the_context, void* ptr, size_t size, size_t nitems);
+
+		/** Write exactly 'nitems' objects each of size 'size' from the area
+		 *  pointed at by 'ptr' to data source.
+		 *  Returns 'num', or -1 if the write failed.
+		 */
+		size_t (ALMIXER_RWOPS_CALL *write)(struct ALmixer_RWops* the_context, const void* ptr, size_t size, size_t nitems);
+
+		/** Close and free an allocated ALmixer_RWops structure */
+		int (ALMIXER_RWOPS_CALL *close)(struct ALmixer_RWops* the_context);
+
+		/* type Needs to be a 32-bit to be compatible with SDL */
+		uint32_t type;
+		union 
+		{
+#if defined(__WIN32__) && !defined(__SYMBIAN32__)
+			/* Chances are that I will not implement this path.
+			 * But I want the padding to be the same as SDL.
+			 */
+			struct 
+			{
+				int   append;
+				void *h;
+				struct
+				{
+					void *data;
+					int size;
+					int left;
+				} buffer;
+			} win32io;
+#endif
+	    	struct 
+			{
+				int autoclose;
+	 			FILE* fp;
+	    	} stdio;
+	   		struct 
+			{
+				unsigned char* base;
+			 	unsigned char* here;
+				unsigned char* stop;
+			} mem;
+		  	struct 
+			{
+				void* data1;
+	    	} unknown;
+		} hidden;
+	} ALmixer_RWops;
+
+	extern ALMIXER_RWOPS_DECLSPEC ALmixer_RWops* ALMIXER_RWOPS_CALL ALmixer_RWFromFile(const char* file_name, const char* file_mode);
+	extern ALMIXER_RWOPS_DECLSPEC ALmixer_RWops* ALMIXER_RWOPS_CALL ALmixer_RWFromFP(FILE* file_pointer, char autoclose_flag);
+
+#define ALmixer_RWseek(rwops, offset, whence) (rwops)->seek(rwops, offset, whence)
+#define ALmixer_RWtell(rwops) (rwops)->seek(rwops, 0, SEEK_CUR)
+#define ALmixer_RWread(rwops, ptr, size, nitems) (rwops)->read(rwops, ptr, size, nitems)
+	
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Isolated/LGPL/SDL_endian_minimal.h	Thu Apr 28 16:22:30 2011 -0700
@@ -0,0 +1,99 @@
+/*
+ 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
+ */
+
+/* 
+ Attention: This is a stripped down file of SDL_endian for our purposes. 
+ This code is licensed under the LGPL.
+ This means we must not compile this code into anything that we are not willing to
+ publicly release source code. 
+ You should compile this into a separate dynamic library that is isolated from proprietary code.
+ */
+
+
+#ifndef SDL_endian_minimal_h
+#define SDL_endian_minimal_h
+
+#ifdef ANDROID_NDK
+#include <endian.h>
+
+#define SDL_BYTEORDER _BYTE_ORDER
+#define SDL_BIG_ENDIAN _BIG_ENDIAN
+#define SDL_LITTLE_ENDIAN _LITTLE_ENDIAN
+#endif
+
+#include <stdint.h>
+
+
+#if defined(__GNUC__) && defined(__i386__) && \
+   !(__GNUC__ == 2 && __GNUC_MINOR__ <= 95 /* broken gcc version */)
+static __inline__ uint32_t SDL_Swap32(uint32_t x)
+{
+	__asm__("bswap %0" : "=r" (x) : "0" (x));
+	return x;
+}
+#elif defined(__GNUC__) && defined(__x86_64__)
+static __inline__ uint32_t SDL_Swap32(uint32_t x)
+{
+	__asm__("bswapl %0" : "=r" (x) : "0" (x));
+	return x;
+}
+#elif defined(__GNUC__) && (defined(__powerpc__) || defined(__ppc__))
+static __inline__ uint32_t SDL_Swap32(uint32_t x)
+{
+	uint32_t 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__))
+static __inline__ uint32_t SDL_Swap32(uint32_t x)
+{
+	__asm__("rorw #8,%0\n\tswap %0\n\trorw #8,%0" : "=d" (x) :  "0" (x) : "cc");
+	return x;
+}
+#else
+static __inline__ uint32_t SDL_Swap32(uint32_t x) {
+	return((x<<24)|((x<<8)&0x00FF0000)|((x>>8)&0x0000FF00)|(x>>24));
+}
+#endif
+
+
+#if SDL_BYTEORDER == SDL_BIG_ENDIAN
+#define SDL_SwapLE16(X)	SDL_Swap16(X)
+#define SDL_SwapLE32(X)	SDL_Swap32(X)
+#define SDL_SwapLE64(X)	SDL_Swap64(X)
+#define SDL_SwapBE16(X)	(X)
+#define SDL_SwapBE32(X)	(X)
+#define SDL_SwapBE64(X)	(X)
+#else
+#define SDL_SwapLE16(X)	(X)
+#define SDL_SwapLE32(X)	(X)
+#define SDL_SwapLE64(X)	(X)
+#define SDL_SwapBE16(X)	SDL_Swap16(X)
+#define SDL_SwapBE32(X)	SDL_Swap32(X)
+#define SDL_SwapBE64(X)	SDL_Swap64(X)
+#endif
+
+
+#endif // SDL_endian_minimal_h

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Isolated/LGPL/SDL_sound_minimal.c	Thu Apr 28 16:22:30 2011 -0700
@@ -0,0 +1,41 @@
+/*
+ * SDL_sound -- An abstract sound format decoding API.
+ * Copyright (C) 2001  Ryan C. Gordon.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+/* 
+ Attention: This is a stripped down file of SDL_endian for our purposes. 
+ This code is licensed under the LGPL.
+ This means we must not compile this code into anything that we are not willing to
+ publicly release source code. 
+ You should compile this into a separate dynamic library that is isolated from proprietary code.
+ */
+ 
+ 
+#include <stdint.h>
+#include "SoundDecoder.h"
+
+uint32_t __Sound_convertMsToBytePos(Sound_AudioInfo *info, uint32_t ms)
+{
+    /* "frames" == "sample frames" */
+    float frames_per_ms = ((float) info->rate) / 1000.0f;
+    uint32_t frame_offset = (uint32_t) (frames_per_ms * ((float) ms));
+    uint32_t frame_size = (uint32_t) ((info->format & 0xFF) / 8) * info->channels;
+    return(frame_offset * frame_size);
+} /* __Sound_convertMsToBytePos */
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Isolated/LGPL/mpg123.c	Thu Apr 28 16:22:30 2011 -0700
@@ -0,0 +1,393 @@
+/*
+ * SDL_sound -- An abstract sound format decoding API.
+ * Copyright (C) 2001  Ryan C. Gordon.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+/*
+ * libmpg123 decoder for SDL_sound. This is a very lightweight MP3 decoder,
+ *  which is included with the SDL_sound source, so that it doesn't rely on
+ *  unnecessary external libraries.
+ *
+ * libmpg123 is part of mpg123, and can be found in its original
+ *  form at: http://www.mpg123.org/
+ *
+ * Please see the file LICENSE.txt in the source's root directory. The included
+ *  source code for libmpg123 falls under the LGPL, which is the same license
+ *  as SDL_sound (so you can consider it a single work).
+ *
+ *  This file written by Ryan C. Gordon. (icculus@icculus.org)
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#ifdef SOUND_SUPPORTS_MPG123
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#include "mpg123.h"
+
+#ifdef ALMIXER_COMPILE_WITHOUT_SDL
+#include "SoundDecoder.h"
+#include "SoundDecoder_Internal.h"
+#include "SimpleMutex.h"
+#include "ALmixer_RWops.h"
+#include <stdint.h>
+		typedef struct SimpleMutex SDL_mutex;
+		typedef struct ALmixer_RWops SDL_RWops;
+		#define SDL_CreateMutex SimpleMutex_CreateMutex
+		#define SDL_DestroyMutex SimpleMutex_DestroyMutex
+		#define SDL_LockMutex SimpleMutex_LockMutex
+		#define SDL_UnlockMutex SimpleMutex_UnlockMutex
+		typedef uint32_t Uint32;
+		#define SDL_RWseek ALmixer_RWseek
+		#define SDL_RWread ALmixer_RWread
+
+#else
+#include "SDL_sound.h"
+
+#define __SDL_SOUND_INTERNAL__
+#include "SDL_sound_internal.h"
+#endif
+
+#ifdef _MSC_VER
+#define snprintf _snprintf
+#endif
+
+
+static int MPG123_init(void);
+static void MPG123_quit(void);
+static int MPG123_open(Sound_Sample *sample, const char *ext);
+static void MPG123_close(Sound_Sample *sample);
+static Uint32 MPG123_read(Sound_Sample *sample);
+static int MPG123_rewind(Sound_Sample *sample);
+static int MPG123_seek(Sound_Sample *sample, Uint32 ms);
+
+/* !!! FIXME: MPEG and MPG extensions? */
+static const char *extensions_mpg123[] = { "MP3", NULL };
+const Sound_DecoderFunctions __Sound_DecoderFunctions_MPG123 =
+{
+    {
+        extensions_mpg123,
+        "MP3 decoding via internal libmpg123",
+        "Ryan C. Gordon <icculus@icculus.org>",
+        "http://www.icculus.org/SDL_sound/"
+    },
+
+    MPG123_init,       /*   init() method */
+    MPG123_quit,       /*   quit() method */
+    MPG123_open,       /*   open() method */
+    MPG123_close,      /*  close() method */
+    MPG123_read,       /*   read() method */
+    MPG123_rewind,     /* rewind() method */
+    MPG123_seek        /*   seek() method */
+};
+
+
+/* this is what we store in our internal->decoder_private field... */
+typedef mpg123_handle mpg123_t;
+
+static SDL_mutex *mpg123_mutex = NULL;
+static int mpg123_rwops_count = 0;
+static SDL_RWops **mpg123_rwops = NULL;
+
+static void print_decoders(const char *kind, char **decoders)
+{
+    SNDDBG(("%s:", kind));
+    if (*decoders == NULL)
+	{
+        SNDDBG((" [none]"));
+	}
+    else
+    {
+        do
+        {
+            SNDDBG((" %s", *decoders));
+        } while (*(++decoders));
+    } /* else */
+    SNDDBG(("\n"));
+} /* print_decoders */
+
+
+static int MPG123_init(void)
+{
+    int retval = 0;
+    assert(mpg123_mutex == NULL);
+    if (mpg123_init() == MPG123_OK)
+    {
+        char **supported = mpg123_supported_decoders();
+        print_decoders("ALL MPG123 DECODERS", mpg123_decoders());
+        print_decoders("SUPPORTED MPG123 DECODERS", mpg123_supported_decoders());
+        if ((supported != NULL) && (*supported != NULL))
+        {
+            mpg123_mutex = SDL_CreateMutex();
+            if (mpg123_mutex != NULL)
+                retval = 1;  /* at least one decoder available. */
+        } /* if */
+    } /* if */
+
+    return retval;
+} /* MPG123_init */
+
+
+static void MPG123_quit(void)
+{
+    mpg123_exit();
+    SDL_DestroyMutex(mpg123_mutex);
+    mpg123_mutex = NULL;
+    free(mpg123_rwops);
+    mpg123_rwops = NULL;
+    mpg123_rwops_count = 0;
+} /* MPG123_quit */
+
+
+/* bridge rwops reading to libmpg123 hooks. */
+static ssize_t rwread(int fd, void *buf, size_t len)
+{
+    SDL_RWops *rw = NULL;
+    SDL_LockMutex(mpg123_mutex);
+    rw = mpg123_rwops[fd];
+    SDL_UnlockMutex(mpg123_mutex);
+    return (ssize_t) SDL_RWread(rw, buf, 1, len);
+} /* rwread */
+
+
+/* bridge rwops seeking to libmpg123 hooks. */
+static off_t rwseek(int fd, off_t pos, int whence)
+{
+    SDL_RWops *rw = NULL;
+    SDL_LockMutex(mpg123_mutex);
+    rw = mpg123_rwops[fd];
+    SDL_UnlockMutex(mpg123_mutex);
+    return (off_t) SDL_RWseek(rw, pos, whence);
+} /* rwseek */
+
+
+static const char *set_error(mpg123_handle *mp, const int err)
+{
+    char buffer[128];
+    const char *str = NULL;
+    if ((err == MPG123_ERR) && (mp != NULL))
+        str = mpg123_strerror(mp);
+    else
+        str = mpg123_plain_strerror(err);
+
+    snprintf(buffer, sizeof (buffer), "MPG123: %s", str);
+    __Sound_SetError(buffer);
+    
+    return(NULL);  /* this is for BAIL_MACRO to not try to reset the string. */
+} /* set_error */
+
+
+/* Make sure we are only given decoded data in a format we can handle. */
+static int set_formats(mpg123_handle *mp)
+{
+    int rc = 0;
+    const long *rates = NULL;
+    size_t ratecount = 0;
+    const int channels = MPG123_STEREO | MPG123_MONO;
+    const int encodings = /* !!! FIXME: SDL 1.3 can do sint32 and float32.
+                          MPG123_ENC_SIGNED_32 | MPG123_ENC_FLOAT_32 | */
+                          MPG123_ENC_SIGNED_8 | MPG123_ENC_UNSIGNED_8 |
+                          MPG123_ENC_SIGNED_16 | MPG123_ENC_UNSIGNED_16;
+
+    mpg123_rates(&rates, &ratecount);
+
+    rc = mpg123_format_none(mp);
+    while ((ratecount--) && (rc == MPG123_OK))
+        rc = mpg123_format(mp, *(rates++), channels, encodings);
+
+    return(rc);
+} /* set_formats */
+
+
+static int MPG123_open(Sound_Sample *sample, const char *ext)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    mpg123_handle *mp = NULL;
+    long rate = 0;
+    int channels = 0;
+    int fmt = 0;
+    int rc = 0;
+    off_t len = 0;
+    int seekable = 0;
+    void *ptr = NULL;
+    int rwops = 0;
+
+    /* !!! FIXME: so much tapdance because we need a pointer, not an int. */
+    SDL_LockMutex(mpg123_mutex);
+    for (rwops = 0; rwops < mpg123_rwops_count; rwops++)
+    {
+        if (mpg123_rwops[rwops] == NULL)
+        break;
+    } /* for */
+    if (rwops < mpg123_rwops_count)
+        ptr = mpg123_rwops;
+    else
+    {
+        mpg123_rwops_count++;
+        ptr = realloc(mpg123_rwops, sizeof (SDL_RWops *) * mpg123_rwops_count);
+        if (ptr != NULL)
+            mpg123_rwops = (SDL_RWops **) ptr;
+    } /* else */
+    if (ptr != NULL)
+        mpg123_rwops[rwops] = internal->rw;
+    SDL_UnlockMutex(mpg123_mutex);
+    BAIL_IF_MACRO(ptr == NULL, ERR_OUT_OF_MEMORY, 0);
+
+    if ((mp = mpg123_new(NULL, &rc)) == NULL)
+        goto mpg123_open_failed;
+    else if ((rc = set_formats(mp)) != MPG123_OK)
+        goto mpg123_open_failed;
+    else if ((rc = mpg123_replace_reader(mp, rwread, rwseek)) != MPG123_OK)
+        goto mpg123_open_failed;
+    else if ((rc = mpg123_open_fd(mp, rwops)) != MPG123_OK)
+        goto mpg123_open_failed;
+    else if ((rc = mpg123_scan(mp)) != MPG123_OK)
+        goto mpg123_open_failed;  /* !!! FIXME: this may be wrong. */
+    else if ((rc = mpg123_getformat(mp, &rate, &channels, &fmt)) != MPG123_OK)
+        goto mpg123_open_failed;
+
+    if (mpg123_seek(mp, 0, SEEK_END) >= 0)  /* can seek? */
+    {
+        len = mpg123_tell(mp);
+        if ((rc = (int) mpg123_seek(mp, 0, SEEK_SET)) < 0)
+            goto mpg123_open_failed;
+        seekable = 1;
+    } /* if */
+
+    internal->decoder_private = mp;
+    sample->actual.rate = rate;
+    sample->actual.channels = channels;
+
+    rc = MPG123_BAD_OUTFORMAT;  /* in case this fails... */
+    if (fmt == MPG123_ENC_SIGNED_8)
+        sample->actual.format = AUDIO_S8;
+    else if (fmt == MPG123_ENC_UNSIGNED_8)
+        sample->actual.format = AUDIO_U8;
+    else if (fmt == MPG123_ENC_SIGNED_16)
+        sample->actual.format = AUDIO_S16SYS;
+    else if (fmt == MPG123_ENC_UNSIGNED_16)
+         sample->actual.format = AUDIO_U16SYS;
+    /* !!! FIXME: SDL 1.3 can do sint32 and float32 ...
+    else if (fmt == MPG123_ENC_SIGNED_32)
+        sample->actual.format = AUDIO_S32SYS;
+    else if (fmt == MPG123_ENC_FLOAT_32)
+        sample->actual.format = AUDIO_F32SYS;
+    */
+    else
+        goto mpg123_open_failed;
+
+    SNDDBG(("MPG123: Accepting data stream.\n"));
+
+    sample->flags = SOUND_SAMPLEFLAG_NONE;
+    internal->total_time = -1;
+    if (seekable)
+    {
+        sample->flags |= SOUND_SAMPLEFLAG_CANSEEK;
+        internal->total_time = ((len / rate) * 1000) +
+                               (((len % rate) * 1000) / rate);
+    } /* if */
+
+    return(1); /* we'll handle this data. */
+
+mpg123_open_failed:
+    SDL_LockMutex(mpg123_mutex);
+    mpg123_rwops[rwops] = NULL;
+    if (rwops == mpg123_rwops_count)
+        mpg123_rwops_count--;
+    SDL_UnlockMutex(mpg123_mutex);
+    set_error(mp, rc);
+    mpg123_delete(mp);  /* NULL is safe. */
+    return(0);
+} /* MPG123_open */
+
+
+static void MPG123_close(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    mpg123_t *mp = ((mpg123_t *) internal->decoder_private);
+    int i;
+
+    SDL_LockMutex(mpg123_mutex);
+    for (i = 0; i < mpg123_rwops_count; i++)
+    {
+        if (mpg123_rwops[i] == internal->rw)
+            mpg123_rwops[i] = NULL;
+    } /* for */
+
+    for (i = mpg123_rwops_count-1; i >= 0; i--)
+    {
+        if (mpg123_rwops[i] != NULL)
+            break;
+    } /* for */
+    mpg123_rwops_count = i + 1;
+    SDL_UnlockMutex(mpg123_mutex);
+
+    mpg123_close(mp);  /* don't need this at the moment, but it's safe. */
+    mpg123_delete(mp);
+} /* MPG123_close */
+
+
+static Uint32 MPG123_read(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    mpg123_t *mp = ((mpg123_t *) internal->decoder_private);
+    size_t bw = 0;
+    const int rc = mpg123_read(mp, (unsigned char *) internal->buffer,
+                               internal->buffer_size, &bw);
+    if (rc == MPG123_DONE)
+        sample->flags |= SOUND_SAMPLEFLAG_EOF;
+    else if (rc != MPG123_OK)
+    {
+        sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+        set_error(mp, rc);
+    } /* else if */
+
+    return((Uint32) bw);
+} /* MPG123_read */
+
+
+static int MPG123_rewind(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    mpg123_t *mp = ((mpg123_t *) internal->decoder_private);
+    const int rc = (int) mpg123_seek(mp, 0, SEEK_SET);
+    BAIL_IF_MACRO(rc < 0, set_error(mp, rc), 0);
+    return(1);
+} /* MPG123_rewind */
+
+
+static int MPG123_seek(Sound_Sample *sample, Uint32 ms)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    mpg123_t *mp = ((mpg123_t *) internal->decoder_private);
+    const float frames_per_ms = ((float) sample->actual.rate) / 1000.0f;
+    const off_t frame_offset = (off_t) (frames_per_ms * ((float) ms));
+    const int rc = (int) mpg123_seek(mp, frame_offset , SEEK_SET);
+    BAIL_IF_MACRO(rc < 0, set_error(mp, rc), 0);
+    return(1);
+} /* MPG123_seek */
+
+#endif /* SOUND_SUPPORTS_MPG123 */
+
+/* end of mpg123.c ... */
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Isolated/LGPL/oggtremor.c	Thu Apr 28 16:22:30 2011 -0700
@@ -0,0 +1,379 @@
+/*
+ * SDL_sound -- An abstract sound format decoding API.
+ * Copyright (C) 2001  Ryan C. Gordon.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+/*
+ * Ogg Vorbis decoder for SDL_sound.
+ *
+ * This driver handles .OGG audio files, and depends on libvorbisfile to
+ *  do the actual decoding work. libvorbisfile is part of libvorbis, which
+ *  is part of the Ogg Vorbis project.
+ *
+ *   Ogg Vorbis: http://www.xiph.org/ogg/vorbis/
+ *   vorbisfile documentation: http://www.xiph.org/ogg/vorbis/doc/vorbisfile/
+ *
+ * Please see the file LICENSE.txt in the source's root directory.
+ *
+ *  This file written by Ryan C. Gordon. (icculus@icculus.org)
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#ifdef SOUND_SUPPORTS_OGG
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "SoundDecoder.h"
+
+#include "SoundDecoder_Internal.h"
+#include "SDL_endian_minimal.h"
+#include "ALmixer_RWops.h"
+
+//#include <vorbis/codec.h>
+#include <ivorbisfile.h>
+#define ERR_IO_ERROR "I/O error"
+
+
+static int OGG_init(void);
+static void OGG_quit(void);
+static int OGG_open(Sound_Sample *sample, const char *ext);
+static void OGG_close(Sound_Sample *sample);
+static uint32_t OGG_read(Sound_Sample *sample);
+static int OGG_rewind(Sound_Sample *sample);
+static int OGG_seek(Sound_Sample *sample, uint32_t ms);
+
+static const char *extensions_ogg[] = { "OGG", NULL };
+const Sound_DecoderFunctions __Sound_DecoderFunctions_OGG =
+{
+    {
+        extensions_ogg,
+        "Ogg Vorbis audio through VorbisFile",
+        "Ryan C. Gordon <icculus@icculus.org>",
+        "http://www.icculus.org/SDL_sound/"
+    },
+
+    OGG_init,       /*   init() method */
+    OGG_quit,       /*   quit() method */
+    OGG_open,       /*   open() method */
+    OGG_close,      /*  close() method */
+    OGG_read,       /*   read() method */
+    OGG_rewind,     /* rewind() method */
+    OGG_seek        /*   seek() method */
+};
+
+
+static int OGG_init(void)
+{
+    return(1);  /* always succeeds. */
+} /* OGG_init */
+
+
+static void OGG_quit(void)
+{
+    /* it's a no-op. */
+} /* OGG_quit */
+
+
+
+    /*
+     * These are callbacks from vorbisfile that let them read data from
+     *  a RWops...
+     */
+
+static size_t RWops_ogg_read(void *ptr, size_t size, size_t nmemb, void *datasource)
+{
+    return((size_t) ALmixer_RWread((ALmixer_RWops *) datasource, ptr, size, nmemb));
+} /* RWops_ogg_read */
+
+static int RWops_ogg_seek(void *datasource, ogg_int64_t offset, int whence)
+{
+    return(ALmixer_RWseek((ALmixer_RWops *) datasource, offset, whence));
+} /* RWops_ogg_seek */
+
+static int RWops_ogg_close(void *datasource)
+{
+    /* do nothing; SDL_sound will delete the RWops at a higher level. */
+    return(0);  /* this is success in fclose(), so I guess that's okay. */
+} /* RWops_ogg_close */
+
+static long RWops_ogg_tell(void *datasource)
+{
+    return((long) ALmixer_RWtell((ALmixer_RWops *) datasource));
+} /* RWops_ogg_tell */
+
+static const ov_callbacks RWops_ogg_callbacks =
+{
+    RWops_ogg_read,
+    RWops_ogg_seek,
+    RWops_ogg_close,
+    RWops_ogg_tell
+};
+
+
+    /* Return a human readable version of an VorbisFile error code... */
+#if (defined DEBUG_CHATTER)
+static const char *ogg_error(int errnum)
+{
+    switch(errnum)
+    {
+        case OV_EREAD:
+            return("i/o error");
+        case OV_ENOTVORBIS:
+            return("not a vorbis file");
+        case OV_EVERSION:
+            return("Vorbis version mismatch");
+        case OV_EBADHEADER:
+            return("invalid Vorbis bitstream header");
+        case OV_EFAULT:
+            return("internal logic fault in Vorbis library");
+    } /* switch */
+
+    return("unknown error");
+} /* ogg_error */
+#endif
+
+static __inline__ void output_ogg_comments(OggVorbis_File *vf)
+{
+#if (defined DEBUG_CHATTER)
+    int i;
+    vorbis_comment *vc = ov_comment(vf, -1);
+
+    if (vc == NULL)
+        return;
+
+    SNDDBG(("OGG: vendor == [%s].\n", vc->vendor));
+    for (i = 0; i < vc->comments; i++)
+    {
+        SNDDBG(("OGG: user comment [%s].\n", vc->user_comments[i]));
+    } /* for */
+#endif
+} /* output_ogg_comments */
+
+
+static int OGG_open(Sound_Sample *sample, const char *ext)
+{
+    int rc;
+    double total_time;
+    OggVorbis_File *vf;
+    vorbis_info *info;
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+
+    vf = (OggVorbis_File *) malloc(sizeof (OggVorbis_File));
+    BAIL_IF_MACRO(vf == NULL, ERR_OUT_OF_MEMORY, 0);
+
+    rc = ov_open_callbacks(internal->rw, vf, NULL, 0, RWops_ogg_callbacks);
+    if (rc != 0)
+    {
+#if (defined DEBUG_CHATTER)		
+        SNDDBG(("OGG: can't grok data. reason: [%s].\n", ogg_error(rc)));
+#endif
+        free(vf);
+        BAIL_MACRO("OGG: Not valid Ogg Vorbis data.", 0);
+    } /* if */
+
+    info = ov_info(vf, -1);
+    if (info == NULL)
+    {
+        ov_clear(vf);
+        free(vf);
+        BAIL_MACRO("OGG: failed to retrieve bitstream info", 0);
+    } /* if */
+
+    output_ogg_comments(vf);
+	
+    SNDDBG(("OGG: bitstream version == (%d).\n", info->version));
+    SNDDBG(("OGG: bitstream channels == (%d).\n", info->channels));
+    SNDDBG(("OGG: bitstream sampling rate == (%ld).\n", info->rate));
+    SNDDBG(("OGG: seekable == {%s}.\n", ov_seekable(vf) ? "TRUE" : "FALSE"));
+    SNDDBG(("OGG: number of logical bitstreams == (%ld).\n", ov_streams(vf)));
+    SNDDBG(("OGG: serial number == (%ld).\n", ov_serialnumber(vf, -1)));
+    SNDDBG(("OGG: total seconds of sample == (%f).\n", ov_time_total(vf, -1)));
+
+    internal->decoder_private = vf;
+    sample->flags = SOUND_SAMPLEFLAG_CANSEEK;
+    sample->actual.rate = (uint32_t) info->rate;
+    sample->actual.channels = (uint8_t) info->channels;
+    total_time = ov_time_total(vf, -1);
+    if (OV_EINVAL == total_time)
+      internal->total_time = -1;
+    else
+      internal->total_time = (int32_t)(total_time * 1000.0 + 0.5);
+
+
+    /*
+     * Since we might have more than one logical bitstream in the OGG file,
+     *  and these bitstreams may be in different formats, we might be
+     *  converting two or three times: once in vorbisfile, once again in
+     *  SDL_sound, and perhaps a third time to get it to the sound device's
+     *  format. That's wickedly inefficient.
+     *
+     * To combat this a little, if the user specified a desired format, we
+     *  claim that to be the "actual" format of the collection of logical
+     *  bitstreams. This means that VorbisFile will do a conversion as
+     *  necessary, and SDL_sound will not. If the user didn't specify a
+     *  desired format, then we pretend the "actual" format is something that
+     *  OGG files are apparently commonly encoded in.
+     */
+    sample->actual.format = (sample->desired.format == 0) ?
+                             AUDIO_S16SYS : sample->desired.format;
+    return(1);
+} /* OGG_open */
+
+
+static void OGG_close(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    OggVorbis_File *vf = (OggVorbis_File *) internal->decoder_private;
+    ov_clear(vf);
+    free(vf);
+} /* OGG_close */
+
+/* Note: According to the Vorbis documentation:
+ * "ov_read() will  decode at most one vorbis packet per invocation, 
+ * so the value returned will generally be less than length."
+ * Due to this, for buffer sizes like 16384, SDL_Sound was always getting
+ * an underfilled buffer and always setting the EAGAIN flag.
+ * Since the SDL_Sound API implies that the entire buffer
+ * should be filled unless EOF, additional code has been added
+ * to this function to call ov_read() until the buffer is filled.
+ * However, there may still be some corner cases where the buffer
+ * cannot be entirely filled. So be aware.
+ */
+static uint32_t OGG_read(Sound_Sample *sample)
+{
+    int rc;
+    int bitstream;
+	Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    OggVorbis_File *vf = (OggVorbis_File *) internal->decoder_private;
+    
+    rc = ov_read(vf, internal->buffer, internal->buffer_size,
+            &bitstream);
+
+        /* Make sure the read went smoothly... */
+    if (rc == 0)
+        sample->flags |= SOUND_SAMPLEFLAG_EOF;
+        
+    else if (rc < 0)
+        sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+
+    /* If the buffer isn't filled, keep trying to fill it
+     * until no more data can be grabbed */
+    else if ((uint32_t) rc < internal->buffer_size)
+	{
+        /* Creating a pointer to the buffer that denotes where to start
+         * writing new data. */
+        uint8_t* buffer_start_point = NULL;
+        int total_bytes_read = rc;
+        int bytes_remaining = internal->buffer_size - rc;
+
+        /* Keep grabbing data until something prevents
+         * us from getting more. (Could be EOF,
+         * packets are too large to fit in remaining
+         * space, or an error.)
+         */
+        while( (rc > 0) && (bytes_remaining > 0) )
+        {
+        /* Set buffer pointer to end of last write */
+        /* All the messiness is to get rid of the warning for
+         * dereferencing a void*
+         */
+            buffer_start_point = &(((uint8_t*)internal->buffer)[total_bytes_read]);
+            rc = ov_read(vf, buffer_start_point, bytes_remaining,
+                &bitstream);
+            /* Make sure rc > 0 because we don't accidently want
+             * to change the counters if there was an error
+             */
+            if(rc > 0)
+            {
+                total_bytes_read += rc;
+                bytes_remaining = bytes_remaining - rc;
+            }
+	    }
+        /* I think the minimum read size is 2, though I'm
+         * not sure about this. (I've hit cases where I
+         * couldn't read less than 4.) What I don't want to do is
+         * accidently claim we hit EOF when the reason rc == 0
+         * is because the requested amount of data was smaller
+         * than the minimum packet size.
+         * For now, I will be conservative
+         * and not set the EOF flag, and let the next call to 
+         * this function figure it out.
+         * I think the ERROR flag is safe to set because 
+         * it looks like OGG simply returns 0 if the 
+         * read size is too small. 
+         * And in most cases for sensible buffer sizes, 
+         * this fix will fill the buffer,
+         * so we can set the EAGAIN flag without worrying
+         * that it will always be set.
+         */
+        if(rc < 0)
+	    {
+            sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+        }
+        else if(rc == 0)
+        {
+            /* Do nothing for now until there is a better solution */
+            /* sample->flags |= SOUND_SAMPLEFLAG_EOF; */
+        }
+
+        /* Test for a buffer underrun. It should occur less frequently
+         * now, but it still may happen and not necessarily mean
+         * anything useful. */
+        if ((uint32_t) total_bytes_read < internal->buffer_size)
+        {
+            sample->flags |= SOUND_SAMPLEFLAG_EAGAIN;
+        }
+        /* change rc to the total bytes read so function
+         * can return the correct value.
+         */
+        rc = total_bytes_read;
+    }
+
+    return((uint32_t) rc);
+} /* OGG_read */
+
+
+static int OGG_rewind(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    OggVorbis_File *vf = (OggVorbis_File *) internal->decoder_private;
+
+    BAIL_IF_MACRO(ov_raw_seek(vf, 0) < 0, ERR_IO_ERROR, 0);
+    return(1);
+} /* OGG_rewind */
+
+
+static int OGG_seek(Sound_Sample *sample, uint32_t ms)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    OggVorbis_File *vf = (OggVorbis_File *) internal->decoder_private;
+    double timepos = (((double) ms) / 1000.0);
+    BAIL_IF_MACRO(ov_time_seek(vf, timepos) < 0, ERR_IO_ERROR, 0);
+    return(1);
+} /* OGG_seek */
+
+#endif /* SOUND_SUPPORTS_OGG */
+
+
+/* end of ogg.c ... */
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Isolated/LGPL/wav.c	Thu Apr 28 16:22:30 2011 -0700
@@ -0,0 +1,846 @@
+/*
+ * SDL_sound -- An abstract sound format decoding API.
+ * Copyright (C) 2001  Ryan C. Gordon.
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+/* 
+ Attention: This is a stripped down file of SDL_endian for our purposes. 
+ This code is licensed under the LGPL.
+ This means we must not compile this code into anything that we are not willing to
+ publicly release source code. 
+ You should compile this into a separate dynamic library that is isolated from proprietary code.
+ */
+
+/*
+ * WAV decoder for SDL_sound.
+ *
+ * This driver handles Microsoft .WAVs, in as many of the thousands of
+ *  variations as we can.
+ *
+ * Please see the file LICENSE.txt in the source's root directory.
+ *
+ *  This file written by Ryan C. Gordon. (icculus@icculus.org)
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#ifdef SOUND_SUPPORTS_WAV
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+//#include "SDL_sound.h"
+
+//#define __SDL_SOUND_INTERNAL__
+//#include "SDL_sound_internal.h"
+
+
+#include "SoundDecoder.h"
+
+#include "SoundDecoder_Internal.h"
+#include "SDL_endian_minimal.h"
+#include "ALmixer_RWops.h"
+
+#define ERR_IO_ERROR "I/O error"
+#define assert(x)
+
+static int WAV_init(void);
+static void WAV_quit(void);
+static int WAV_open(Sound_Sample *sample, const char *ext);
+static void WAV_close(Sound_Sample *sample);
+static uint32_t WAV_read(Sound_Sample *sample);
+static int WAV_rewind(Sound_Sample *sample);
+static int WAV_seek(Sound_Sample *sample, uint32_t ms);
+
+static const char *extensions_wav[] = { "WAV", NULL };
+const Sound_DecoderFunctions __Sound_DecoderFunctions_WAV =
+{
+    {
+        extensions_wav,
+        "Microsoft WAVE audio format",
+        "Ryan C. Gordon <icculus@icculus.org>",
+        "http://www.icculus.org/SDL_sound/"
+    },
+
+    WAV_init,       /*   init() method */
+    WAV_quit,       /*   quit() method */
+    WAV_open,       /*   open() method */
+    WAV_close,      /*  close() method */
+    WAV_read,       /*   read() method */
+    WAV_rewind,     /* rewind() method */
+    WAV_seek        /*   seek() method */
+};
+
+
+/* Better than SDL_ReadLE16, since you can detect i/o errors... */
+static __inline__ int read_le16(ALmixer_RWops *rw, uint16_t *ui16)
+{
+    int rc = ALmixer_RWread(rw, ui16, sizeof (uint16_t), 1);
+    BAIL_IF_MACRO(rc != 1, ERR_IO_ERROR, 0);
+    *ui16 = SDL_SwapLE16(*ui16);
+    return(1);
+} /* read_le16 */
+
+
+/* Better than SDL_ReadLE32, since you can detect i/o errors... */
+static __inline__ int read_le32(ALmixer_RWops *rw, uint32_t *ui32)
+{
+    int rc = ALmixer_RWread(rw, ui32, sizeof (uint32_t), 1);
+    BAIL_IF_MACRO(rc != 1, ERR_IO_ERROR, 0);
+    *ui32 = SDL_SwapLE32(*ui32);
+    return(1);
+} /* read_le32 */
+
+
+/* This is just cleaner on the caller's end... */
+static __inline__ int read_uint8_t(ALmixer_RWops *rw, uint8_t *ui8)
+{
+    int rc = ALmixer_RWread(rw, ui8, sizeof (uint8_t), 1);
+    BAIL_IF_MACRO(rc != 1, ERR_IO_ERROR, 0);
+    return(1);
+} /* read_uint8_t */
+
+
+static __inline__ uint16_t SDL_ReadLE16( ALmixer_RWops *rw )
+{
+	uint16_t result = 0;
+	
+	int rc = read_le16( rw, &result );
+	
+	return result;
+}
+static __inline__ uint32_t SDL_ReadLE32( ALmixer_RWops *rw )
+{
+	uint32_t result = 0;
+	
+	int rc = read_le32( rw, &result );
+	
+	return result;
+}
+
+    /* Chunk management code... */
+
+#define riffID 0x46464952  /* "RIFF", in ascii. */
+#define waveID 0x45564157  /* "WAVE", in ascii. */
+#define factID 0x74636166  /* "fact", in ascii. */
+
+
+/*****************************************************************************
+ * The FORMAT chunk...                                                       *
+ *****************************************************************************/
+
+#define fmtID  0x20746D66  /* "fmt ", in ascii. */
+
+#define FMT_NORMAL 0x0001    /* Uncompressed waveform data.     */
+#define FMT_ADPCM  0x0002    /* ADPCM compressed waveform data. */
+
+typedef struct
+{
+    int16_t iCoef1;
+    int16_t iCoef2;
+} ADPCMCOEFSET;
+
+typedef struct
+{
+    uint8_t bPredictor;
+    uint16_t iDelta;
+    int16_t iSamp1;
+    int16_t iSamp2;
+} ADPCMBLOCKHEADER;
+
+typedef struct S_WAV_FMT_T
+{
+    uint32_t chunkID;
+    int32_t chunkSize;
+    int16_t wFormatTag;
+    uint16_t wChannels;
+    uint32_t dwSamplesPerSec;
+    uint32_t dwAvgBytesPerSec;
+    uint16_t wBlockAlign;
+    uint16_t wBitsPerSample;
+
+    uint32_t next_chunk_offset;
+    
+    uint32_t sample_frame_size;
+    uint32_t data_starting_offset;
+    uint32_t total_bytes;
+
+    void (*free)(struct S_WAV_FMT_T *fmt);
+    uint32_t (*read_sample)(Sound_Sample *sample);
+    int (*rewind_sample)(Sound_Sample *sample);
+    int (*seek_sample)(Sound_Sample *sample, uint32_t ms);
+
+    union
+    {
+        struct
+        {
+            uint16_t cbSize;
+            uint16_t wSamplesPerBlock;
+            uint16_t wNumCoef;
+            ADPCMCOEFSET *aCoef;
+            ADPCMBLOCKHEADER *blockheaders;
+            uint32_t samples_left_in_block;
+            int nibble_state;
+            int8_t nibble;
+        } adpcm;
+
+        /* put other format-specific data here... */
+    } fmt;
+} fmt_t;
+
+
+/*
+ * Read in a fmt_t from disk. This makes this process safe regardless of
+ *  the processor's byte order or how the fmt_t structure is packed.
+ * Note that the union "fmt" is not read in here; that is handled as 
+ *  needed in the read_fmt_* functions.
+ */
+static int read_fmt_chunk(ALmixer_RWops *rw, fmt_t *fmt)
+{
+    /* skip reading the chunk ID, since it was already read at this point... */
+    fmt->chunkID = fmtID;
+
+    BAIL_IF_MACRO(!read_le32(rw, &fmt->chunkSize), NULL, 0);
+    BAIL_IF_MACRO(fmt->chunkSize < 16, "WAV: Invalid chunk size", 0);
+    fmt->next_chunk_offset = ALmixer_RWtell(rw) + fmt->chunkSize;
+    
+    BAIL_IF_MACRO(!read_le16(rw, &fmt->wFormatTag), NULL, 0);
+    BAIL_IF_MACRO(!read_le16(rw, &fmt->wChannels), NULL, 0);
+    BAIL_IF_MACRO(!read_le32(rw, &fmt->dwSamplesPerSec), NULL, 0);
+    BAIL_IF_MACRO(!read_le32(rw, &fmt->dwAvgBytesPerSec), NULL, 0);
+    BAIL_IF_MACRO(!read_le16(rw, &fmt->wBlockAlign), NULL, 0);
+    BAIL_IF_MACRO(!read_le16(rw, &fmt->wBitsPerSample), NULL, 0);
+
+    return(1);
+} /* read_fmt_chunk */
+
+
+
+/*****************************************************************************
+ * The DATA chunk...                                                         *
+ *****************************************************************************/
+
+#define dataID 0x61746164  /* "data", in ascii. */
+
+typedef struct
+{
+    uint32_t chunkID;
+    int32_t chunkSize;
+    /* Then, (chunkSize) bytes of waveform data... */
+} data_t;
+
+
+/*
+ * Read in a data_t from disk. This makes this process safe regardless of
+ *  the processor's byte order or how the fmt_t structure is packed.
+ */
+static int read_data_chunk(ALmixer_RWops *rw, data_t *data)
+{
+    /* skip reading the chunk ID, since it was already read at this point... */
+    data->chunkID = dataID;
+    BAIL_IF_MACRO(!read_le32(rw, &data->chunkSize), NULL, 0);
+    return(1);
+} /* read_data_chunk */
+
+
+
+
+/*****************************************************************************
+ * this is what we store in our internal->decoder_private field...           *
+ *****************************************************************************/
+
+typedef struct
+{
+    fmt_t *fmt;
+    int32_t bytesLeft;
+} wav_t;
+
+
+
+
+/*****************************************************************************
+ * Normal, uncompressed waveform handler...                                  *
+ *****************************************************************************/
+
+/*
+ * Sound_Decode() lands here for uncompressed WAVs...
+ */
+static uint32_t read_sample_fmt_normal(Sound_Sample *sample)
+{
+    uint32_t retval;
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    wav_t *w = (wav_t *) internal->decoder_private;
+    uint32_t max = (internal->buffer_size < (uint32_t) w->bytesLeft) ?
+                    internal->buffer_size : (uint32_t) w->bytesLeft;
+
+    assert(max > 0);
+
+        /*
+         * We don't actually do any decoding, so we read the wav data
+         *  directly into the internal buffer...
+         */
+    retval = ALmixer_RWread(internal->rw, internal->buffer, 1, max);
+
+    w->bytesLeft -= retval;
+
+        /* Make sure the read went smoothly... */
+    if ((retval == 0) || (w->bytesLeft == 0))
+        sample->flags |= SOUND_SAMPLEFLAG_EOF;
+
+    else if (retval == -1)
+        sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+
+        /* (next call this EAGAIN may turn into an EOF or error.) */
+    else if (retval < internal->buffer_size)
+        sample->flags |= SOUND_SAMPLEFLAG_EAGAIN;
+
+    return(retval);
+} /* read_sample_fmt_normal */
+
+
+static int seek_sample_fmt_normal(Sound_Sample *sample, uint32_t ms)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    wav_t *w = (wav_t *) internal->decoder_private;
+    fmt_t *fmt = w->fmt;
+    int offset = __Sound_convertMsToBytePos(&sample->actual, ms);
+    int pos = (int) (fmt->data_starting_offset + offset);
+    int rc = ALmixer_RWseek(internal->rw, pos, SEEK_SET);
+    BAIL_IF_MACRO(rc != pos, ERR_IO_ERROR, 0);
+    w->bytesLeft = fmt->total_bytes - offset;
+    return(1);  /* success. */
+} /* seek_sample_fmt_normal */
+
+
+static int rewind_sample_fmt_normal(Sound_Sample *sample)
+{
+    /* no-op. */
+    return(1);
+} /* rewind_sample_fmt_normal */
+
+
+static int read_fmt_normal(ALmixer_RWops *rw, fmt_t *fmt)
+{
+    /* (don't need to read more from the RWops...) */
+    fmt->free = NULL;
+    fmt->read_sample = read_sample_fmt_normal;
+    fmt->rewind_sample = rewind_sample_fmt_normal;
+    fmt->seek_sample = seek_sample_fmt_normal;
+    return(1);
+} /* read_fmt_normal */
+
+
+
+/*****************************************************************************
+ * ADPCM compression handler...                                              *
+ *****************************************************************************/
+
+#define FIXED_POINT_COEF_BASE      256
+#define FIXED_POINT_ADAPTION_BASE  256
+#define SMALLEST_ADPCM_DELTA       16
+
+
+static __inline__ int read_adpcm_block_headers(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    ALmixer_RWops *rw = internal->rw;
+    wav_t *w = (wav_t *) internal->decoder_private;
+    fmt_t *fmt = w->fmt;
+    ADPCMBLOCKHEADER *headers = fmt->fmt.adpcm.blockheaders;
+    int i;
+    int max = fmt->wChannels;
+
+    if (w->bytesLeft < fmt->wBlockAlign)
+    {
+        sample->flags |= SOUND_SAMPLEFLAG_EOF;
+        return(0);
+    } /* if */
+
+    w->bytesLeft -= fmt->wBlockAlign;
+
+    for (i = 0; i < max; i++)
+        BAIL_IF_MACRO(!read_uint8_t(rw, &headers[i].bPredictor), NULL, 0);
+
+    for (i = 0; i < max; i++)
+        BAIL_IF_MACRO(!read_le16(rw, &headers[i].iDelta), NULL, 0);
+
+    for (i = 0; i < max; i++)
+        BAIL_IF_MACRO(!read_le16(rw, &headers[i].iSamp1), NULL, 0);
+
+    for (i = 0; i < max; i++)
+        BAIL_IF_MACRO(!read_le16(rw, &headers[i].iSamp2), NULL, 0);
+
+    fmt->fmt.adpcm.samples_left_in_block = fmt->fmt.adpcm.wSamplesPerBlock;
+    fmt->fmt.adpcm.nibble_state = 0;
+    return(1);
+} /* read_adpcm_block_headers */
+
+
+static __inline__ void do_adpcm_nibble(uint8_t nib,
+                                       ADPCMBLOCKHEADER *header,
+                                       int32_t lPredSamp)
+{
+	static const int32_t max_audioval = ((1<<(16-1))-1);
+	static const int32_t min_audioval = -(1<<(16-1));
+	static const int32_t AdaptionTable[] =
+    {
+		230, 230, 230, 230, 307, 409, 512, 614,
+		768, 614, 512, 409, 307, 230, 230, 230
+	};
+
+    int32_t lNewSamp;
+    int32_t delta;
+
+    if (nib & 0x08)
+        lNewSamp = lPredSamp + (header->iDelta * (nib - 0x10));
+	else
+        lNewSamp = lPredSamp + (header->iDelta * nib);
+
+        /* clamp value... */
+    if (lNewSamp < min_audioval)
+        lNewSamp = min_audioval;
+    else if (lNewSamp > max_audioval)
+        lNewSamp = max_audioval;
+
+    delta = ((int32_t) header->iDelta * AdaptionTable[nib]) /
+              FIXED_POINT_ADAPTION_BASE;
+
+	if (delta < SMALLEST_ADPCM_DELTA)
+	    delta = SMALLEST_ADPCM_DELTA;
+
+    header->iDelta = delta;
+	header->iSamp2 = header->iSamp1;
+	header->iSamp1 = lNewSamp;
+} /* do_adpcm_nibble */
+
+
+static __inline__ int decode_adpcm_sample_frame(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    wav_t *w = (wav_t *) internal->decoder_private;
+    fmt_t *fmt = w->fmt;
+    ADPCMBLOCKHEADER *headers = fmt->fmt.adpcm.blockheaders;
+    ALmixer_RWops *rw = internal->rw;
+    int i;
+    int max = fmt->wChannels;
+    int32_t delta;
+    uint8_t nib = fmt->fmt.adpcm.nibble;
+
+    for (i = 0; i < max; i++)
+    {
+        uint8_t byte;
+        int16_t iCoef1 = fmt->fmt.adpcm.aCoef[headers[i].bPredictor].iCoef1;
+        int16_t iCoef2 = fmt->fmt.adpcm.aCoef[headers[i].bPredictor].iCoef2;
+        int32_t lPredSamp = ((headers[i].iSamp1 * iCoef1) +
+                            (headers[i].iSamp2 * iCoef2)) / 
+                             FIXED_POINT_COEF_BASE;
+
+        if (fmt->fmt.adpcm.nibble_state == 0)
+        {
+            BAIL_IF_MACRO(!read_uint8_t(rw, &nib), NULL, 0);
+            fmt->fmt.adpcm.nibble_state = 1;
+            do_adpcm_nibble(nib >> 4, &headers[i], lPredSamp);
+        } /* if */
+        else
+        {
+            fmt->fmt.adpcm.nibble_state = 0;
+            do_adpcm_nibble(nib & 0x0F, &headers[i], lPredSamp);
+        } /* else */
+    } /* for */
+
+    fmt->fmt.adpcm.nibble = nib;
+    return(1);
+} /* decode_adpcm_sample_frame */
+
+
+static __inline__ void put_adpcm_sample_frame1(void *_buf, fmt_t *fmt)
+{
+    uint16_t *buf = (uint16_t *) _buf;
+    ADPCMBLOCKHEADER *headers = fmt->fmt.adpcm.blockheaders;
+    int i;
+    for (i = 0; i < fmt->wChannels; i++)
+        *(buf++) = headers[i].iSamp1;
+} /* put_adpcm_sample_frame1 */
+
+
+static __inline__ void put_adpcm_sample_frame2(void *_buf, fmt_t *fmt)
+{
+    uint16_t *buf = (uint16_t *) _buf;
+    ADPCMBLOCKHEADER *headers = fmt->fmt.adpcm.blockheaders;
+    int i;
+    for (i = 0; i < fmt->wChannels; i++)
+        *(buf++) = headers[i].iSamp2;
+} /* put_adpcm_sample_frame2 */
+
+
+/*
+ * Sound_Decode() lands here for ADPCM-encoded WAVs...
+ */
+static uint32_t read_sample_fmt_adpcm(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    wav_t *w = (wav_t *) internal->decoder_private;
+    fmt_t *fmt = w->fmt;
+    uint32_t bw = 0;
+
+    while (bw < internal->buffer_size)
+    {
+        /* write ongoing sample frame before reading more data... */
+        switch (fmt->fmt.adpcm.samples_left_in_block)
+        {
+            case 0:  /* need to read a new block... */
+                if (!read_adpcm_block_headers(sample))
+                {
+                    if ((sample->flags & SOUND_SAMPLEFLAG_EOF) == 0)
+                        sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+                    return(bw);
+                } /* if */
+
+                /* only write first sample frame for now. */
+                put_adpcm_sample_frame2((uint8_t *) internal->buffer + bw, fmt);
+                fmt->fmt.adpcm.samples_left_in_block--;
+                bw += fmt->sample_frame_size;
+                break;
+
+            case 1:  /* output last sample frame of block... */
+                put_adpcm_sample_frame1((uint8_t *) internal->buffer + bw, fmt);
+                fmt->fmt.adpcm.samples_left_in_block--;
+                bw += fmt->sample_frame_size;
+                break;
+
+            default: /* output latest sample frame and read a new one... */
+                put_adpcm_sample_frame1((uint8_t *) internal->buffer + bw, fmt);
+                fmt->fmt.adpcm.samples_left_in_block--;
+                bw += fmt->sample_frame_size;
+
+                if (!decode_adpcm_sample_frame(sample))
+                {
+                    sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+                    return(bw);
+                } /* if */
+        } /* switch */
+    } /* while */
+
+    return(bw);
+} /* read_sample_fmt_adpcm */
+
+
+/*
+ * Sound_FreeSample() lands here for ADPCM-encoded WAVs...
+ */
+static void free_fmt_adpcm(fmt_t *fmt)
+{
+    if (fmt->fmt.adpcm.aCoef != NULL)
+        free(fmt->fmt.adpcm.aCoef);
+
+    if (fmt->fmt.adpcm.blockheaders != NULL)
+        free(fmt->fmt.adpcm.blockheaders);
+} /* free_fmt_adpcm */
+
+
+static int rewind_sample_fmt_adpcm(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    wav_t *w = (wav_t *) internal->decoder_private;
+    w->fmt->fmt.adpcm.samples_left_in_block = 0;
+    return(1);
+} /* rewind_sample_fmt_adpcm */
+
+
+static int seek_sample_fmt_adpcm(Sound_Sample *sample, uint32_t ms)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    wav_t *w = (wav_t *) internal->decoder_private;
+    fmt_t *fmt = w->fmt;
+    uint32_t origsampsleft = fmt->fmt.adpcm.samples_left_in_block;
+    int origpos = ALmixer_RWtell(internal->rw);
+    int offset = __Sound_convertMsToBytePos(&sample->actual, ms);
+    int bpb = (fmt->fmt.adpcm.wSamplesPerBlock * fmt->sample_frame_size);
+    int skipsize = (offset / bpb) * fmt->wBlockAlign;
+    int pos = skipsize + fmt->data_starting_offset;
+    int rc = ALmixer_RWseek(internal->rw, pos, SEEK_SET);
+    BAIL_IF_MACRO(rc != pos, ERR_IO_ERROR, 0);
+
+    /* The offset we need is in this block, so we need to decode to there. */
+    skipsize += (offset % bpb);
+    rc = (offset % bpb);  /* bytes into this block we need to decode */
+    if (!read_adpcm_block_headers(sample))
+    {
+        ALmixer_RWseek(internal->rw, origpos, SEEK_SET);  /* try to make sane. */
+        return(0);
+    } /* if */
+
+    /* first sample frame of block is a freebie. :) */
+    fmt->fmt.adpcm.samples_left_in_block--;
+    rc -= fmt->sample_frame_size;
+    while (rc > 0)
+    {
+        if (!decode_adpcm_sample_frame(sample))
+        {
+            ALmixer_RWseek(internal->rw, origpos, SEEK_SET);
+            fmt->fmt.adpcm.samples_left_in_block = origsampsleft;
+            return(0);
+        } /* if */
+
+        fmt->fmt.adpcm.samples_left_in_block--;
+        rc -= fmt->sample_frame_size;
+    } /* while */
+
+    w->bytesLeft = fmt->total_bytes - skipsize;
+    return(1);  /* success. */
+} /* seek_sample_fmt_adpcm */
+
+
+/*
+ * Read in the adpcm-specific info from disk. This makes this process
+ *  safe regardless of the processor's byte order or how the fmt_t 
+ *  structure is packed.
+ */
+static int read_fmt_adpcm(ALmixer_RWops *rw, fmt_t *fmt)
+{
+    size_t i;
+
+    memset(&fmt->fmt.adpcm, '\0', sizeof (fmt->fmt.adpcm));
+    fmt->free = free_fmt_adpcm;
+    fmt->read_sample = read_sample_fmt_adpcm;
+    fmt->rewind_sample = rewind_sample_fmt_adpcm;
+    fmt->seek_sample = seek_sample_fmt_adpcm;
+
+    BAIL_IF_MACRO(!read_le16(rw, &fmt->fmt.adpcm.cbSize), NULL, 0);
+    BAIL_IF_MACRO(!read_le16(rw, &fmt->fmt.adpcm.wSamplesPerBlock), NULL, 0);
+    BAIL_IF_MACRO(!read_le16(rw, &fmt->fmt.adpcm.wNumCoef), NULL, 0);
+
+    /* fmt->free() is always called, so these malloc()s will be cleaned up. */
+
+    i = sizeof (ADPCMCOEFSET) * fmt->fmt.adpcm.wNumCoef;
+    fmt->fmt.adpcm.aCoef = (ADPCMCOEFSET *) malloc(i);
+    BAIL_IF_MACRO(fmt->fmt.adpcm.aCoef == NULL, ERR_OUT_OF_MEMORY, 0);
+
+    for (i = 0; i < fmt->fmt.adpcm.wNumCoef; i++)
+    {
+        BAIL_IF_MACRO(!read_le16(rw, &fmt->fmt.adpcm.aCoef[i].iCoef1), NULL, 0);
+        BAIL_IF_MACRO(!read_le16(rw, &fmt->fmt.adpcm.aCoef[i].iCoef2), NULL, 0);
+    } /* for */
+
+    i = sizeof (ADPCMBLOCKHEADER) * fmt->wChannels;
+    fmt->fmt.adpcm.blockheaders = (ADPCMBLOCKHEADER *) malloc(i);
+    BAIL_IF_MACRO(fmt->fmt.adpcm.blockheaders == NULL, ERR_OUT_OF_MEMORY, 0);
+
+    return(1);
+} /* read_fmt_adpcm */
+
+
+
+/*****************************************************************************
+ * Everything else...                                                        *
+ *****************************************************************************/
+
+static int WAV_init(void)
+{
+    return(1);  /* always succeeds. */
+} /* WAV_init */
+
+
+static void WAV_quit(void)
+{
+    /* it's a no-op. */
+} /* WAV_quit */
+
+
+static int read_fmt(ALmixer_RWops *rw, fmt_t *fmt)
+{
+    /* if it's in this switch statement, we support the format. */
+    switch (fmt->wFormatTag)
+    {
+        case FMT_NORMAL:
+            SNDDBG(("WAV: Appears to be uncompressed audio.\n"));
+            return(read_fmt_normal(rw, fmt));
+
+        case FMT_ADPCM:
+            SNDDBG(("WAV: Appears to be ADPCM compressed audio.\n"));
+            return(read_fmt_adpcm(rw, fmt));
+
+        /* add other types here. */
+
+        default:
+#ifdef ANDROID_NDK
+            SNDDBG(("WAV: Format is unknown.\n"));
+#else
+            SNDDBG(("WAV: Format 0x%X is unknown.\n",
+                    (unsigned int) fmt->wFormatTag));
+#endif
+            BAIL_MACRO("WAV: Unsupported format", 0);
+    } /* switch */
+
+    assert(0);  /* shouldn't hit this point. */
+    return(0);
+} /* read_fmt */
+
+
+/*
+ * Locate a specific chunk in the WAVE file by ID...
+ */
+static int find_chunk(ALmixer_RWops *rw, uint32_t id)
+{
+    int32_t siz = 0;
+    uint32_t _id = 0;
+    uint32_t pos = ALmixer_RWtell(rw);
+
+    while (1)
+    {
+        BAIL_IF_MACRO(!read_le32(rw, &_id), NULL, 0);
+        if (_id == id)
+            return(1);
+
+            /* skip ahead and see what next chunk is... */
+        BAIL_IF_MACRO(!read_le32(rw, &siz), NULL, 0);
+        assert(siz >= 0);
+        pos += (sizeof (uint32_t) * 2) + siz;
+        if (siz > 0)
+            BAIL_IF_MACRO(ALmixer_RWseek(rw, pos, SEEK_SET) != pos, NULL, 0);
+    } /* while */
+
+    return(0);  /* shouldn't hit this, but just in case... */
+} /* find_chunk */
+
+
+static int WAV_open_internal(Sound_Sample *sample, const char *ext, fmt_t *fmt)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    ALmixer_RWops *rw = internal->rw;
+    data_t d;
+    wav_t *w;
+    uint32_t pos;
+
+    BAIL_IF_MACRO(SDL_ReadLE32(rw) != riffID, "WAV: Not a RIFF file.", 0);
+    SDL_ReadLE32(rw);  /* throw the length away; we get this info later. */
+    BAIL_IF_MACRO(SDL_ReadLE32(rw) != waveID, "WAV: Not a WAVE file.", 0);
+    BAIL_IF_MACRO(!find_chunk(rw, fmtID), "WAV: No format chunk.", 0);
+    BAIL_IF_MACRO(!read_fmt_chunk(rw, fmt), "WAV: Can't read format chunk.", 0);
+
+    sample->actual.channels = (uint8_t) fmt->wChannels;
+    sample->actual.rate = fmt->dwSamplesPerSec;
+    if ((fmt->wBitsPerSample == 4) /*|| (fmt->wBitsPerSample == 0) */ )
+        sample->actual.format = AUDIO_S16SYS;
+    else if (fmt->wBitsPerSample == 8)
+        sample->actual.format = AUDIO_U8;
+    else if (fmt->wBitsPerSample == 16)
+        sample->actual.format = AUDIO_S16LSB;
+    else
+    {
+#ifdef ANDROID_NDK
+       SNDDBG(("WAV: unsupported sample size.\n"));
+#else
+        SNDDBG(("WAV: %d bits per sample!?\n", (int) fmt->wBitsPerSample));
+#endif
+        BAIL_MACRO("WAV: Unsupported sample size.", 0);
+    } /* else */
+
+    BAIL_IF_MACRO(!read_fmt(rw, fmt), NULL, 0);
+    ALmixer_RWseek(rw, fmt->next_chunk_offset, SEEK_SET);
+    BAIL_IF_MACRO(!find_chunk(rw, dataID), "WAV: No data chunk.", 0);
+    BAIL_IF_MACRO(!read_data_chunk(rw, &d), "WAV: Can't read data chunk.", 0);
+
+    w = (wav_t *) malloc(sizeof(wav_t));
+    BAIL_IF_MACRO(w == NULL, ERR_OUT_OF_MEMORY, 0);
+    w->fmt = fmt;
+    fmt->total_bytes = w->bytesLeft = d.chunkSize;
+    fmt->data_starting_offset = ALmixer_RWtell(rw);
+    fmt->sample_frame_size = ( ((sample->actual.format & 0xFF) / 8) *
+                               sample->actual.channels );
+    internal->decoder_private = (void *) w;
+
+    internal->total_time = (fmt->total_bytes / fmt->dwAvgBytesPerSec) * 1000;
+    internal->total_time += (fmt->total_bytes % fmt->dwAvgBytesPerSec)
+                              *  1000 / fmt->dwAvgBytesPerSec;
+
+    sample->flags = SOUND_SAMPLEFLAG_NONE;
+    if (fmt->seek_sample != NULL)
+        sample->flags |= SOUND_SAMPLEFLAG_CANSEEK;
+
+    SNDDBG(("WAV: Accepting data stream.\n"));
+    return(1); /* we'll handle this data. */
+} /* WAV_open_internal */
+
+
+static int WAV_open(Sound_Sample *sample, const char *ext)
+{
+    int rc;
+
+    fmt_t *fmt = (fmt_t *) malloc(sizeof (fmt_t));
+    BAIL_IF_MACRO(fmt == NULL, ERR_OUT_OF_MEMORY, 0);
+    memset(fmt, '\0', sizeof (fmt_t));
+
+    rc = WAV_open_internal(sample, ext, fmt);
+    if (!rc)
+    {
+        if (fmt->free != NULL)
+            fmt->free(fmt);
+        free(fmt);
+    } /* if */
+
+    return(rc);
+} /* WAV_open */
+
+
+static void WAV_close(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    wav_t *w = (wav_t *) internal->decoder_private;
+
+    if (w->fmt->free != NULL)
+        w->fmt->free(w->fmt);
+
+    free(w->fmt);
+    free(w);
+} /* WAV_close */
+
+
+static uint32_t WAV_read(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    wav_t *w = (wav_t *) internal->decoder_private;
+    return(w->fmt->read_sample(sample));
+} /* WAV_read */
+
+
+static int WAV_rewind(Sound_Sample *sample)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    wav_t *w = (wav_t *) internal->decoder_private;
+    fmt_t *fmt = w->fmt;
+    int rc = ALmixer_RWseek(internal->rw, fmt->data_starting_offset, SEEK_SET);
+    BAIL_IF_MACRO(rc != fmt->data_starting_offset, ERR_IO_ERROR, 0);
+    w->bytesLeft = fmt->total_bytes;
+    return(fmt->rewind_sample(sample));
+} /* WAV_rewind */
+
+
+static int WAV_seek(Sound_Sample *sample, uint32_t ms)
+{
+    Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+    wav_t *w = (wav_t *) internal->decoder_private;
+    return(w->fmt->seek_sample(sample, ms));
+} /* WAV_seek */
+
+#endif /* SOUND_SUPPORTS_WAV */
+
+/* end of wav.c ... */
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Isolated/SimpleMutex.c	Thu Apr 28 16:22:30 2011 -0700
@@ -0,0 +1,155 @@
+#include "SimpleMutex.h"
+#include <stdlib.h>
+
+#if defined(DEBUG)
+#include <stdio.h>
+#define MUTEXDBG(x) printf x
+#else
+#define MUTEXDBG(x)
+#endif
+
+#if defined(_WIN32) && !defined(__CYGWIN32__)
+		#include <windows.h>
+		#include <winbase.h> /* For CreateMutex(), LockFile() */
+
+		struct SimpleMutex
+		{
+			HANDLE nativeMutex;
+		};
+
+
+		SimpleMutex* SimpleMutex_CreateMutex()
+		{
+			SimpleMutex* simple_mutex = (SimpleMutex*)malloc(sizeof(SimpleMutex));
+			if(NULL == simple_mutex)
+			{
+				MUTEXDBG(("Out of memory.\n"));				
+				return NULL;		
+			}
+			simple_mutex->nativeMutex = CreateMutex(NULL, FALSE, NULL);
+			if(NULL == simple_mutex->nativeMutex)
+			{
+				MUTEXDBG(("Out of memory.\n"));				
+				free(simple_mutex);
+				return NULL;		
+			}
+			return simple_mutex;
+		}
+		void SimpleMutex_DestroyMutex(SimpleMutex* simple_mutex)
+		{
+			if(NULL == simple_mutex)
+			{
+				return;
+			}
+			CloseHandle(simple_mutex->nativeMutex);
+			free(simple_mutex);
+		}
+		/* This will return true if locking is successful, false if not.
+		 */
+		int SimpleMutex_LockMutex(SimpleMutex* simple_mutex)
+		{
+#ifdef DEBUG
+			if(NULL == simple_mutex)
+			{
+				MUTEXDBG(("SimpleMutex_LockMutex was passed NULL\n"));	
+				return 0;
+			}
+#endif
+			return(
+				WaitForSingleObject(
+					simple_mutex->nativeMutex,
+					INFINITE
+				) != WAIT_FAILED
+			);
+		}
+		void SimpleMutex_UnlockMutex(SimpleMutex* simple_mutex)
+		{
+#ifdef DEBUG
+			if(NULL == simple_mutex)
+			{
+				MUTEXDBG(("SimpleMutex_UnlockMutex was passed NULL\n"));	
+				return;
+			}
+#endif
+			ReleaseMutex(
+				simple_mutex->nativeMutex
+			);
+		}
+#else /* Assuming POSIX...maybe not a good assumption. */
+		#include <pthread.h>
+
+		struct SimpleMutex
+		{
+			pthread_mutex_t* nativeMutex;
+		};
+
+		SimpleMutex* SimpleMutex_CreateMutex()
+		{
+			int ret_val;
+			SimpleMutex* simple_mutex = (SimpleMutex*)malloc(sizeof(SimpleMutex));
+			if(NULL == simple_mutex)
+			{
+				MUTEXDBG(("Out of memory.\n"));				
+				return NULL;		
+			}
+			simple_mutex->nativeMutex = (pthread_mutex_t*)malloc(sizeof(pthread_mutex_t));
+			if(NULL == simple_mutex->nativeMutex)
+			{
+				MUTEXDBG(("Out of memory.\n"));
+				free(simple_mutex);
+				return NULL;		
+			}
+
+			ret_val = pthread_mutex_init(simple_mutex->nativeMutex, NULL);
+			if(0 != ret_val)
+			{
+				free(simple_mutex->nativeMutex);
+				free(simple_mutex);
+				return NULL;
+			}
+			return simple_mutex;
+		}
+		void SimpleMutex_DestroyMutex(SimpleMutex* simple_mutex)
+		{
+			if(NULL != simple_mutex)
+			{
+				pthread_mutex_destroy(simple_mutex->nativeMutex);
+				free(simple_mutex->nativeMutex);
+				free(simple_mutex);
+			}
+		}
+		/* This will return true if locking is successful, false if not.
+		 * (This is the opposite of pthread_mutex_lock which returns 
+		 * 0 for success.)
+		 */
+		int SimpleMutex_LockMutex(SimpleMutex* simple_mutex)
+		{
+#ifdef DEBUG
+			if(NULL == simple_mutex)
+			{
+				MUTEXDBG(("SimpleMutex_LockMutex was passed NULL\n"));	
+				return 0;
+			}
+#endif
+			return(
+				pthread_mutex_lock(
+					simple_mutex->nativeMutex
+				) == 0
+			);
+		}
+		void SimpleMutex_UnlockMutex(SimpleMutex* simple_mutex)
+		{
+#ifdef DEBUG			
+			if(NULL == simple_mutex)
+			{
+				MUTEXDBG(("SimpleMutex_LockMutex was passed NULL\n"));	
+				return;
+			}
+#endif
+			pthread_mutex_unlock(
+				simple_mutex->nativeMutex
+			);
+		}
+#endif
+
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Isolated/SimpleMutex.h	Thu Apr 28 16:22:30 2011 -0700
@@ -0,0 +1,25 @@
+/* Copyright: Eric Wing 2003 */
+
+#ifndef SIMPLE_MUTEX_H
+#define SIMPLE_MUTEX_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+	
+
+typedef struct SimpleMutex SimpleMutex;
+
+SimpleMutex* SimpleMutex_CreateMutex(void);
+void SimpleMutex_DestroyMutex(SimpleMutex* simple_mutex);
+int SimpleMutex_LockMutex(SimpleMutex* simple_mutex);
+void SimpleMutex_UnlockMutex(SimpleMutex* simple_mutex);
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Isolated/SimpleThread.h	Thu Apr 28 16:22:30 2011 -0700
@@ -0,0 +1,30 @@
+#ifndef SIMPLE_THREAD
+#define SIMPLE_THREAD
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+	
+#include <stddef.h>
+
+typedef struct SimpleThread SimpleThread;
+
+
+SimpleThread* SimpleThread_CreateThread(int (*user_function)(void*), void* user_data);
+
+size_t SimpleThread_GetCurrentThreadID(void);
+size_t SimpleThread_GetThreadID(SimpleThread* simple_thread);
+
+void SimpleThread_WaitThread(SimpleThread* simple_thread, int* thread_status);
+
+
+int SimpleThread_GetThreadPriority(SimpleThread* simple_thread);
+void SimpleThread_SetThreadPriority(SimpleThread* simple_thread, int priority_level);
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Isolated/SimpleThreadPosix.c	Thu Apr 28 16:22:30 2011 -0700
@@ -0,0 +1,214 @@
+#include "SimpleThread.h"
+#include <stddef.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <signal.h>
+
+#if defined(DEBUG)
+#include <stdio.h>
+#define THRDDBG(x) printf x
+#else
+#define THRDDBG(x)
+#endif
+
+
+struct SimpleThread
+{
+	size_t threadID;
+	pthread_t nativeThread;
+	int threadStatus;
+//    void* userData;	
+};
+
+typedef struct SimpleThreadArguments
+{
+    int (*userFunction)(void*);
+    void* userData;
+    SimpleThread* simpleThread;
+} SimpleThreadArguments;
+
+
+
+static void* Internal_RunThread(void* user_data)
+{
+	int (*user_function)(void*);
+	void* function_user_data;
+	int* status_val;
+
+#if 0
+	/* disable signals */
+	sigset_t disable_set;
+
+	/*
+	   in the main thread, set up the desired signal mask, common to most threads
+	   any newly created threads will inherit this signal mask
+	   */
+	sigemptyset(&disable_set);
+	sigaddset(&disable_set, SIGHUP);
+	sigaddset(&disable_set, SIGINT);
+	sigaddset(&disable_set, SIGUSR1);
+	sigaddset(&disable_set, SIGUSR2);
+	sigaddset(&disable_set, SIGALRM);
+	sigaddset(&disable_set, SIGQUIT);
+	sigaddset(&disable_set, SIGPIPE);
+	sigaddset(&disable_set, SIGTERM);
+	sigaddset(&disable_set, SIGCHLD);
+	sigaddset(&disable_set, SIGWINCH);
+	sigaddset(&disable_set, SIGVTALRM);
+	sigaddset(&disable_set, SIGPROF);
+
+
+	/* block out these signals */
+	sigprocmask(SIG_BLOCK, &disable_set, NULL);
+#endif
+
+	SimpleThreadArguments* simple_thread_arguments = (SimpleThreadArguments*)user_data;
+	simple_thread_arguments->simpleThread->threadID = SimpleThread_GetCurrentThreadID();
+
+	user_function = simple_thread_arguments->userFunction;
+	function_user_data = simple_thread_arguments->userData;
+	status_val = &simple_thread_arguments->simpleThread->threadStatus;
+
+	
+	/* I hope this is safe to delete on a different thread than it was created for. */
+	free(simple_thread_arguments);
+
+	*status_val = user_function(function_user_data);
+
+	pthread_exit(NULL);
+	return NULL;
+}
+
+
+SimpleThread* SimpleThread_CreateThread(int (*user_function)(void*), void* user_data)
+{
+	pthread_attr_t thread_attributes;
+	int ret_val;
+	SimpleThread* new_thread;
+	SimpleThreadArguments* simple_thread_arguments;
+
+	new_thread = (SimpleThread*)malloc(sizeof(SimpleThread));
+	if(NULL == new_thread)
+	{
+		THRDDBG(("Out of memory.\n"));				
+		return NULL;
+	}
+
+	ret_val = pthread_attr_init(&thread_attributes);
+	if(0 != ret_val)
+	{
+		/* failed */
+		THRDDBG(("pthread_attr_init failed with: %d\n", ret_val));		
+		free(new_thread);
+		return 0;
+	}
+	ret_val = pthread_attr_setdetachstate(&thread_attributes, PTHREAD_CREATE_JOINABLE);
+	if(0 != ret_val)
+	{
+		THRDDBG(("pthread_attr_setdetachstate failed with: %d\n", ret_val));
+		free(new_thread);
+		return NULL;
+	}
+
+	simple_thread_arguments = (SimpleThreadArguments*)malloc(sizeof(SimpleThreadArguments));
+	if(NULL == simple_thread_arguments)
+	{
+		THRDDBG(("Out of memory.\n"));
+		free(new_thread);		
+		return NULL;
+	}
+	simple_thread_arguments->userFunction = user_function;
+	simple_thread_arguments->userData = user_data;
+	simple_thread_arguments->simpleThread = new_thread;
+
+	ret_val = pthread_create(&new_thread->nativeThread, &thread_attributes, Internal_RunThread, simple_thread_arguments);
+	if(0 != ret_val)
+	{
+		THRDDBG(("pthread_create failed with: %d\n", ret_val));
+		free(simple_thread_arguments);		
+		free(new_thread);		
+		return NULL;
+	}
+	
+	return new_thread;
+}
+
+
+
+size_t SimpleThread_GetCurrentThreadID()
+{
+    return (size_t)pthread_self();
+}
+
+void SimpleThread_WaitThread(SimpleThread* simple_thread, int* thread_status)
+{
+	int ret_val;	
+	if(NULL == simple_thread)
+	{
+		THRDDBG(("SimpleThread_WaitThread was passed NULL\n"));	
+		return;
+	}
+
+
+    ret_val = pthread_join(simple_thread->nativeThread, 0);
+	if(0 != ret_val)
+	{
+		THRDDBG(("pthread_join failed with: %d\n", ret_val));
+	}
+	if(NULL != thread_status)
+	{
+		*thread_status = simple_thread->threadStatus;
+	}
+	free(simple_thread);
+}
+
+size_t SimpleThread_GetThreadID(SimpleThread* simple_thread)
+{
+	if(NULL == simple_thread)
+	{
+		THRDDBG(("SimpleThread_GetThreadID was passed NULL\n"));	
+		return 0;
+	}
+	return simple_thread->threadID;
+}
+
+
+int SimpleThread_GetThreadPriority(SimpleThread* simple_thread)
+{
+	struct sched_param schedule_param;
+	int sched_policy;
+	int ret_val;
+	
+	if(NULL == simple_thread)
+	{
+		THRDDBG(("SimpleThread_GetThreadPriority was passed NULL\n"));	
+		return -1; /* Not sure what to return. Do other platforms use negative numbers? */
+	}
+	ret_val = pthread_getschedparam(simple_thread->nativeThread, &sched_policy, &schedule_param);
+	if(0 != ret_val)
+	{
+		THRDDBG(("SimpleThread_GetThreadPriority pthread_getschedparam failed with: %d\n", ret_val));
+		return -1;
+	}
+	return schedule_param.sched_priority;
+}
+
+void SimpleThread_SetThreadPriority(SimpleThread* simple_thread, int priority_level)
+{
+	struct sched_param schedule_param;
+	int ret_val;
+	
+	if(NULL == simple_thread)
+	{
+		THRDDBG(("SimpleThread_SetThreadPriority was passed NULL\n"));	
+		return;
+	}
+	schedule_param.sched_priority = priority_level; /* PTHREAD_MIN_PRIORITY=0 to PTHREAD_MAX_PRIORITY=31 */
+	ret_val = pthread_setschedparam(simple_thread->nativeThread, SCHED_OTHER, &schedule_param);
+	if(0 != ret_val)
+	{
+		THRDDBG(("SimpleThread_SetThreadPriority pthread_setschedparam failed with: %d\n", ret_val));
+		return;
+	}
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Isolated/SoundDecoder.c	Thu Apr 28 16:22:30 2011 -0700
@@ -0,0 +1,711 @@
+#ifndef ALMIXER_COMPILED_WITH_SDL
+
+#include "SoundDecoder.h"
+#include "SoundDecoder_Internal.h"
+#include "tErrorLib.h"
+#include "LinkedList.h"
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#ifdef ANDROID_NDK
+#include <android/log.h>
+#endif
+
+/* A partial shim reimplementation of SDL_sound to work around the LGPL issues.
+ * This implementation is more limited than SDL_sound. 
+ * For example, there is no generic software conversion routines.
+ * Functions are also not necessarily thread safe.
+ * This implementation relies on the back-end decoder much more heavily 
+ * than SDL_sound. (For example, I bypass the internal->buffer.)
+ */
+
+static LinkedList* s_listOfLoadedSamples = NULL;
+
+static signed char s_isInitialized = 0;
+static TErrorPool* s_errorPool = NULL;
+
+static const SoundDecoder_DecoderInfo** s_availableDecoders = NULL;
+
+#ifdef __APPLE__
+//extern const SoundDecoder_DecoderFunctions __SoundDecoder_DecoderFunctions_CoreAudio;
+extern const Sound_DecoderFunctions __Sound_DecoderFunctions_CoreAudio;
+#endif
+#ifdef ANDROID_NDK
+#ifdef SOUND_SUPPORTS_WAV
+extern const Sound_DecoderFunctions __Sound_DecoderFunctions_WAV;
+#endif
+#ifdef SOUND_SUPPORTS_MPG123
+extern const Sound_DecoderFunctions __Sound_DecoderFunctions_MPG123;
+#endif
+#ifdef SOUND_SUPPORTS_OGG
+extern const Sound_DecoderFunctions __Sound_DecoderFunctions_OGG;
+#endif
+#endif
+
+typedef struct
+{
+    int available;
+    const SoundDecoder_DecoderFunctions* funcs;
+} SoundElement;
+
+static SoundElement s_linkedDecoders[] =
+{
+#if defined(__APPLE__)
+    { 0, &__Sound_DecoderFunctions_CoreAudio },
+#endif
+#if defined(ANDROID_NDK)
+#ifdef SOUND_SUPPORTS_WAV
+    { 0, &__Sound_DecoderFunctions_WAV },
+#endif
+#ifdef SOUND_SUPPORTS_MPG123
+    { 0, &__Sound_DecoderFunctions_MPG123 },
+#endif
+#ifdef SOUND_SUPPORTS_OGG
+    { 0, &__Sound_DecoderFunctions_OGG },
+#endif
+#endif
+    { 0, NULL }
+};
+
+
+#include <ctype.h>
+int SoundDecoder_strcasecmp(const char* str1, const char* str2)
+{
+	int the_char1;
+	int the_char2;
+	int i = 0;
+	if(str1 == str2)
+	{
+		return 0;
+	}
+	if(NULL == str1)
+	{
+		return -1;
+	}
+	if(NULL == str2)
+	{
+		return 1;
+	}
+
+	do
+	{
+		the_char1 = tolower(str1[i]);
+		the_char2 = tolower(str2[i]);
+		if(the_char1 < the_char2)
+		{
+			return -1;
+		}
+		else if(the_char1 > the_char2)
+		{
+			return 1;
+		}
+		i++;
+	} while( (0 != the_char1) && (0 != the_char2) );
+
+	return 0;
+}
+
+
+#ifdef ANDROID_NDK
+#include <stdarg.h>
+#include <android/log.h>
+int SoundDecoder_DebugPrint(const char* format, ...)
+{
+	va_list arg_list; 
+	int ret_val;
+
+	va_start(arg_list, format); 
+	ret_val = __android_log_vprint(ANDROID_LOG_INFO, "SoundDecoder", format, arg_list); 
+	va_end(arg_list);
+	return ret_val;
+}
+#endif
+
+const char* SoundDecoder_GetError()
+{
+	const char* error_string = NULL;
+	if(NULL == s_errorPool)
+	{
+		return "Error: You should not call SoundDecoder_GetError while Sound is not initialized";
+	}
+	error_string = TError_GetLastErrorStr(s_errorPool);
+	/* SDL returns empty strings instead of NULL */
+	if(NULL == error_string)
+	{
+		return "";
+	}
+	else
+	{
+		return error_string;
+	}
+}
+
+void SoundDecoder_ClearError()
+{
+	if(NULL == s_errorPool)
+	{
+		return;
+	}
+	TError_SetError(s_errorPool, 0, NULL);
+}
+
+void SoundDecoder_SetError(const char* err_str, ...)
+{
+	if(NULL == s_errorPool)
+	{
+		fprintf(stderr, "Error: You should not call SoundDecoder_SetError while Sound is not initialized\n");
+		return;
+	}
+	va_list argp;
+	va_start(argp, err_str);
+	// SDL_SetError which I'm emulating has no number parameter.
+	TError_SetErrorv(s_errorPool, 1, err_str, argp);
+	va_end(argp);
+#ifdef ANDROID_NDK
+	__android_log_print(ANDROID_LOG_INFO, "SoundDecoder_SetError", TError_GetLastErrorStr(s_errorPool));
+#endif
+}
+
+
+void SoundDecoder_GetLinkedVersion(SoundDecoder_Version* the_version)
+{
+	if(NULL != the_version)
+	{
+		the_version->major = SOUNDDECODER_VER_MAJOR;
+		the_version->minor = SOUNDDECODER_VER_MINOR;
+		the_version->patch = SOUNDDECODER_VER_PATCH;
+	}
+}
+
+
+const SoundDecoder_DecoderInfo** SoundDecoder_AvailableDecoders()
+{
+    return(s_availableDecoders);
+}
+
+int SoundDecoder_Init()
+{
+	size_t total_number_of_decoders;
+	size_t i;
+	size_t current_pos = 0;	
+	if(1 == s_isInitialized)
+	{
+		return 1;
+	}
+	if(NULL == s_errorPool)
+	{
+		s_errorPool = TError_CreateErrorPool();
+	}
+	if(NULL == s_errorPool)
+	{
+		return 0;
+	}
+
+	total_number_of_decoders = sizeof(s_linkedDecoders) / sizeof(s_linkedDecoders[0]);
+	s_availableDecoders = (const SoundDecoder_DecoderInfo **)malloc((total_number_of_decoders) * sizeof(SoundDecoder_DecoderInfo*));
+	if(NULL == s_availableDecoders)
+	{
+		SoundDecoder_SetError(ERR_OUT_OF_MEMORY);
+		return 0;
+	}
+
+	/* Allocate memory for linked list of sound samples. */
+	s_listOfLoadedSamples = LinkedList_Create();
+	if(NULL == s_listOfLoadedSamples)
+	{
+		free(s_availableDecoders);
+		s_availableDecoders = NULL;
+		SoundDecoder_SetError(ERR_OUT_OF_MEMORY);
+		return 0;
+	}
+
+	for(i = 0; s_linkedDecoders[i].funcs != NULL; i++)
+	{
+		s_linkedDecoders[i].available = s_linkedDecoders[i].funcs->init();
+		if(s_linkedDecoders[i].available)
+		{
+			s_availableDecoders[current_pos] = &(s_linkedDecoders[i].funcs->info);
+			current_pos++;
+		}
+	}
+
+	s_availableDecoders[current_pos] = NULL;
+	s_isInitialized = 1;
+	return 1;
+}
+
+void SoundDecoder_Quit()
+{
+    size_t i;	
+	if(0 == s_isInitialized)
+	{
+		return;
+	}
+
+	/* 
+	 * SDL_sound actually embeds the linked list in the internal data structure.
+	 * So any sample can potentially reach any other sample.
+	 * But I'm keeping my own separate list.
+	 */
+	while(LinkedList_Size(s_listOfLoadedSamples) > 0)
+	{
+		SoundDecoder_Sample* sound_sample = (SoundDecoder_Sample*)LinkedList_PopBack(s_listOfLoadedSamples);
+		SoundDecoder_FreeSample(sound_sample);
+	}
+	LinkedList_Free(s_listOfLoadedSamples);
+	s_listOfLoadedSamples = NULL;
+
+	
+    for(i = 0; s_linkedDecoders[i].funcs != NULL; i++)
+    {
+        if (s_linkedDecoders[i].available)
+        {
+            s_linkedDecoders[i].funcs->quit();
+            s_linkedDecoders[i].available = 0;
+        }
+    }
+
+    if(NULL != s_availableDecoders)
+	{
+        free(s_availableDecoders);
+	}
+	s_availableDecoders = NULL;
+
+
+	/* Remember: ALmixer_SetError/GetError calls will not work while this is gone. */
+	TError_FreeErrorPool(s_errorPool);
+	s_errorPool = NULL;
+
+	s_isInitialized = 0;	
+}
+
+
+void SoundDecoder_FreeSample(SoundDecoder_Sample* sound_sample)
+{
+	SoundDecoder_SampleInternal* sample_internal;
+
+	/* Quit unloads all samples, so it is not possible to free a sample
+	 * when not initialized.
+	 */
+	if(0 == s_isInitialized)
+	{
+		return;
+	}
+
+	if(sound_sample == NULL)
+	{
+		return;
+	}
+
+	/* SDL_sound keeps a linked list of all the loaded samples.
+	 * We want to remove the current sample from that list.
+	 */
+	LinkedListNode* the_node = LinkedList_Find(s_listOfLoadedSamples, sound_sample, NULL);
+	if(NULL == the_node)
+	{
+		SoundDecoder_SetError("SoundDecoder_FreeSample: Internal Error, sample does not exist in linked list.");
+		return;
+	}
+	LinkedList_Remove(s_listOfLoadedSamples, the_node);
+
+	sample_internal = (SoundDecoder_SampleInternal*)sound_sample->opaque;
+
+	/* Ugh...SDL_sound has a lot of pointers. 
+	 * I hope I didn't miss any dynamic memory.
+	 */
+
+	/* Call close on the decoder */
+	sample_internal->funcs->close(sound_sample);
+
+	if(NULL != sample_internal->rw)
+	{
+		sample_internal->rw->close(sample_internal->rw);
+	}
+
+	/* Ooops. The public buffer might be shared with the internal buffer.
+	 * Make sure to not accidentally double delete.
+	 */
+	if((NULL != sample_internal->buffer)
+		&& (sample_internal->buffer != sound_sample->buffer)
+	)
+	{
+		free(sample_internal->buffer);
+	}
+	free(sample_internal);
+
+	if(NULL != sound_sample->buffer)
+	{
+		free(sound_sample->buffer);
+	}
+	free(sound_sample);
+}
+
+
+
+static int Internal_LoadSample(const SoundDecoder_DecoderFunctions *funcs,
+	SoundDecoder_Sample* sound_sample, const char *ext
+)
+{
+    SoundDecoder_SampleInternal* internal_sample = (SoundDecoder_SampleInternal*)sound_sample->opaque;
+    long current_file_position = internal_sample->rw->seek(internal_sample->rw, 0, SEEK_CUR);
+
+    /* fill in the funcs for this decoder... */
+    sound_sample->decoder = &funcs->info;
+	internal_sample->funcs = funcs;
+	if (!funcs->open(sound_sample, ext))
+	{
+		internal_sample->rw->seek(internal_sample->rw, current_file_position, SEEK_SET);
+		return 0;
+	}
+
+	/* we found a compatible decoder */
+
+	/* SDL_sound normally goes on to setup a bunch of things to 
+	 * support format conversion via SDL APIs.
+	 * I am not porting any of that stuff.
+	 * My goal is to simply setup the struct properties to values
+	 * that will not cause any confusion with other parts of the implementation.
+	 */
+
+
+	if(0 == sound_sample->desired.format)
+	{
+		sound_sample->desired.format = sound_sample->actual.format;
+	}
+	if(0 == sound_sample->desired.channels)
+	{
+		sound_sample->desired.channels = sound_sample->actual.channels;
+	}
+	if(0 == sound_sample->desired.rate)
+	{
+		sound_sample->desired.rate = sound_sample->actual.rate;
+	}
+
+	/* I'm a little confused at the difference between the internal
+	 * public buffer. I am going to make them the same.
+	 * I assume I already allocated the public buffer.
+	 */
+	internal_sample->buffer = sound_sample->buffer;
+	internal_sample->buffer_size = sound_sample->buffer_size;
+
+	/* Insert the new sample into the linked list of samples. */
+	LinkedList_PushBack(s_listOfLoadedSamples, sound_sample);
+	
+	return 1;
+}
+
+
+
+SoundDecoder_Sample* SoundDecoder_NewSampleFromFile(const char* file_name,
+                                      SoundDecoder_AudioInfo* desired_format,
+                                      size_t buffer_size)
+{
+	
+    const char* file_extension;
+    ALmixer_RWops* rw_ops;
+
+
+	if(0 == s_isInitialized)
+	{
+		SoundDecoder_SetError(ERR_NOT_INITIALIZED);
+		return NULL;
+	}
+	if(NULL == file_name)
+	{
+		SoundDecoder_SetError("No file specified");
+		return NULL;
+	}
+
+    file_extension = strrchr(file_name, '.');
+	if(NULL != file_extension)
+	{
+        file_extension++;
+	}
+
+    rw_ops = ALmixer_RWFromFile(file_name, "rb");
+
+     return SoundDecoder_NewSample(rw_ops, file_extension, desired_format, buffer_size);
+}
+
+
+SoundDecoder_Sample* SoundDecoder_NewSample(ALmixer_RWops* rw_ops, const char* file_extension, SoundDecoder_AudioInfo* desired_format, size_t buffer_size)
+{
+    SoundDecoder_Sample* new_sample;
+    SoundDecoder_SampleInternal* internal_sample;
+    SoundElement* current_decoder;
+
+	if(0 == s_isInitialized)
+	{
+		SoundDecoder_SetError(ERR_NOT_INITIALIZED);
+		return NULL;
+	}
+	if(NULL == rw_ops)
+	{
+		SoundDecoder_SetError("No file specified");
+		return NULL;
+	}
+
+	new_sample = (SoundDecoder_Sample*)calloc(1, sizeof(SoundDecoder_Sample));
+	if(NULL == new_sample)
+	{
+		SoundDecoder_SetError(ERR_OUT_OF_MEMORY);
+		return NULL;
+	}
+	internal_sample = (SoundDecoder_SampleInternal*)calloc(1, sizeof(SoundDecoder_SampleInternal));
+	if(NULL == internal_sample)
+	{
+		free(new_sample);
+		SoundDecoder_SetError(ERR_OUT_OF_MEMORY);
+		return NULL;
+	}
+	new_sample->buffer = calloc(1, buffer_size);
+	if(NULL == new_sample->buffer)
+	{
+		free(internal_sample);
+		free(new_sample);
+		SoundDecoder_SetError(ERR_OUT_OF_MEMORY);
+		return NULL;
+	}
+
+	new_sample->buffer_size = buffer_size;
+
+    if(NULL != desired_format)
+	{
+		memcpy(&new_sample->desired, desired_format, sizeof(SoundDecoder_AudioInfo));
+	}
+
+	internal_sample->rw = rw_ops;
+	new_sample->opaque = internal_sample;
+
+
+    if(NULL != file_extension)
+    {
+        for(current_decoder = &s_linkedDecoders[0]; current_decoder->funcs != NULL; current_decoder++)
+        {
+            if(current_decoder->available)
+            {
+                const char** decoder_file_extension = current_decoder->funcs->info.extensions;
+                while(*decoder_file_extension)
+                {
+                    if(0 == (SoundDecoder_strcasecmp(*decoder_file_extension, file_extension)))
+                    {
+                        if(Internal_LoadSample(current_decoder->funcs, new_sample, file_extension))
+						{
+							return(new_sample);
+						}
+                        break;  /* go to the next decoder */ 
+                    }
+					decoder_file_extension++;
+                }
+            }
+        }
+    }
+
+    /* no direct file_extensionension match? Try everything we've got... */
+	for(current_decoder = &s_linkedDecoders[0]; current_decoder->funcs != NULL; current_decoder++)
+	{
+		if(current_decoder->available)
+		{
+			int already_tried_decoder = 0;
+			const char** decoder_file_extension = current_decoder->funcs->info.extensions;
+
+			/* skip decoders we already tried from the above loop */
+			while(*decoder_file_extension)
+			{
+				if(SoundDecoder_strcasecmp(*decoder_file_extension, file_extension) == 0)
+				{
+					already_tried_decoder = 1;
+					break;
+				}
+				decoder_file_extension++;
+			}
+
+			if(0 == already_tried_decoder)
+			{
+				if (Internal_LoadSample(current_decoder->funcs, new_sample, file_extension))
+				{
+					return new_sample;
+				}
+			}
+		}
+	}
+
+	/* could not find a decoder */
+	SoundDecoder_SetError(ERR_UNSUPPORTED_FORMAT);
+	/* clean up the memory */
+	free(new_sample->opaque);
+	if(NULL != new_sample->buffer)
+	{
+		free(new_sample->buffer);
+	}
+	free(new_sample);
+	
+	rw_ops->close(rw_ops);
+	return NULL;
+}
+
+
+int SoundDecoder_SetBufferSize(SoundDecoder_Sample* sound_sample, size_t new_buffer_size)
+{
+	SoundDecoder_SampleInternal* internal_sample = NULL;
+	void* new_buffer_ptr = NULL;
+
+    BAIL_IF_MACRO(!s_isInitialized, ERR_NOT_INITIALIZED, 0);
+	BAIL_IF_MACRO(NULL == sound_sample, ERR_NULL_SAMPLE, 0);
+
+    internal_sample = ((SoundDecoder_SampleInternal*)sound_sample->opaque);
+
+
+    new_buffer_ptr = realloc(sound_sample->buffer, new_buffer_size);
+    BAIL_IF_MACRO(NULL == new_buffer_ptr, ERR_OUT_OF_MEMORY, 0);
+
+	sound_sample->buffer = new_buffer_ptr;
+    sound_sample->buffer_size = new_buffer_size;
+	internal_sample->buffer = sound_sample->buffer;
+	internal_sample->buffer_size = sound_sample->buffer_size;
+
+    return 1;
+}
+
+
+size_t SoundDecoder_Decode(SoundDecoder_Sample* sound_sample)
+{
+    SoundDecoder_SampleInternal* internal_sample = NULL;
+    size_t bytes_read = 0;
+
+    BAIL_IF_MACRO(!s_isInitialized, ERR_NOT_INITIALIZED, 0);
+	BAIL_IF_MACRO(NULL == sound_sample, ERR_NULL_SAMPLE, 0);
+	BAIL_IF_MACRO(sound_sample->flags & SOUND_SAMPLEFLAG_ERROR, ERR_PREVIOUS_SAMPLE_ERROR, 0);
+	BAIL_IF_MACRO(sound_sample->flags & SOUND_SAMPLEFLAG_EOF, ERR_ALREADY_AT_EOF_ERROR, 0);
+
+    internal_sample = (SoundDecoder_SampleInternal*)sound_sample->opaque;
+
+    assert(sound_sample->buffer != NULL);
+    assert(sound_sample->buffer_size > 0);
+    assert(internal_sample->buffer != NULL);
+    assert(internal_sample->buffer_size > 0);
+
+ 	/* reset EAGAIN. Decoder can flip it back on if it needs to. */
+    sound_sample->flags &= ~SOUND_SAMPLEFLAG_EAGAIN;
+    bytes_read = internal_sample->funcs->read(sound_sample);
+    return bytes_read;
+}
+
+
+size_t SoundDecoder_DecodeAll(SoundDecoder_Sample* sound_sample)
+{
+    SoundDecoder_SampleInternal* internal_sample = NULL;
+    void* data_buffer = NULL;
+    size_t updated_buffer_size = 0;
+
+    BAIL_IF_MACRO(!s_isInitialized, ERR_NOT_INITIALIZED, 0);
+	BAIL_IF_MACRO(NULL == sound_sample, ERR_NULL_SAMPLE, 0);
+
+	/* My original thought was to call SetBufferSize and resize to 
+	 * the size needed to hold the entire decoded file utilizing total_time,
+	 * but it appears SDL_sound simply loops on SoundDecoder_Decode.
+	 * I suppose it is possible to partially decode or seek a file, and then
+	 * call DecodeAll so you won't have the whole thing in which case
+	 * my idea would waste memory.
+	 */
+    while( (0 == (sound_sample->flags & SOUND_SAMPLEFLAG_EOF) )
+		&& (0 == (sound_sample->flags & SOUND_SAMPLEFLAG_ERROR))
+	)
+    {
+        size_t bytes_decoded = SoundDecoder_Decode(sound_sample);
+        void* realloced_ptr = realloc(data_buffer, updated_buffer_size + bytes_decoded);
+        if(NULL == realloced_ptr)
+        {
+            sound_sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+            SoundDecoder_SetError(ERR_OUT_OF_MEMORY);
+			if(NULL != data_buffer)
+			{
+				free(data_buffer);
+			}
+			return bytes_decoded;
+        }
+		data_buffer = realloced_ptr;
+		/* copy the chunk of decoded PCM to the end of our new data buffer */
+		memcpy( ((char*)data_buffer) + updated_buffer_size, sound_sample->buffer, bytes_decoded );
+		updated_buffer_size += bytes_decoded;
+    }
+
+    internal_sample = (SoundDecoder_SampleInternal*)sound_sample->opaque;
+	if(internal_sample->buffer != sound_sample->buffer)
+	{
+		free(internal_sample->buffer);
+	}
+    free(sound_sample->buffer);
+
+	sound_sample->buffer = data_buffer;
+	sound_sample->buffer_size = updated_buffer_size;
+	internal_sample->buffer = sound_sample->buffer;
+	internal_sample->buffer_size = sound_sample->buffer_size;
+
+    return sound_sample->buffer_size;
+}
+
+
+int SoundDecoder_Rewind(SoundDecoder_Sample* sound_sample)
+{
+    SoundDecoder_SampleInternal* internal_sample;
+	int ret_val;
+	
+    BAIL_IF_MACRO(!s_isInitialized, ERR_NOT_INITIALIZED, 0);
+	BAIL_IF_MACRO(NULL == sound_sample, ERR_NULL_SAMPLE, 0);
+
+    internal_sample = (SoundDecoder_SampleInternal*)sound_sample->opaque;
+	ret_val = internal_sample->funcs->rewind(sound_sample);
+    if(0 == ret_val)
+    {
+        sound_sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+		SoundDecoder_SetError("Rewind failed");		
+        return 0;
+    }
+	/* reset flags */
+    sound_sample->flags &= ~SOUND_SAMPLEFLAG_EAGAIN;
+    sound_sample->flags &= ~SOUND_SAMPLEFLAG_ERROR;
+    sound_sample->flags &= ~SOUND_SAMPLEFLAG_EOF;
+
+    return 1;
+}
+
+
+int SoundDecoder_Seek(SoundDecoder_Sample* sound_sample, size_t ms)
+{
+    SoundDecoder_SampleInternal* internal_sample;
+	int ret_val;
+
+    BAIL_IF_MACRO(!s_isInitialized, ERR_NOT_INITIALIZED, 0);
+	BAIL_IF_MACRO(NULL == sound_sample, ERR_NULL_SAMPLE, 0);
+	
+	BAIL_IF_MACRO(!(sound_sample->flags & SOUND_SAMPLEFLAG_CANSEEK), "Sound sample is not seekable", 0);
+
+    internal_sample = (SoundDecoder_SampleInternal*)sound_sample->opaque;
+	ret_val = internal_sample->funcs->seek(sound_sample, ms);
+	if(0 == ret_val)
+	{
+        sound_sample->flags |= SOUND_SAMPLEFLAG_ERROR;		
+		SoundDecoder_SetError("Seek failed");
+		return 0;
+	}
+	/* reset flags */
+    sound_sample->flags &= ~SOUND_SAMPLEFLAG_EAGAIN;
+    sound_sample->flags &= ~SOUND_SAMPLEFLAG_ERROR;
+    sound_sample->flags &= ~SOUND_SAMPLEFLAG_EOF;
+
+    return 1;
+}
+
+
+ptrdiff_t SoundDecoder_GetDuration(SoundDecoder_Sample* sound_sample)
+{
+    SoundDecoder_SampleInternal* internal_sample;
+    BAIL_IF_MACRO(!s_isInitialized, ERR_NOT_INITIALIZED, -1);
+	BAIL_IF_MACRO(NULL == sound_sample, ERR_NULL_SAMPLE, 0);	
+    internal_sample = (SoundDecoder_SampleInternal*)sound_sample->opaque;
+    return internal_sample->total_time;
+}
+
+#endif

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Isolated/SoundDecoder.h	Thu Apr 28 16:22:30 2011 -0700
@@ -0,0 +1,200 @@
+
+/*
+ * This is a wrapper interface that tries to provide a similar
+ * front-end interface to SDL_sound.
+ */
+
+#ifndef SOUNDDECODER_H 
+#define SOUNDDECODER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+	
+
+#include <stdint.h>
+#include <stddef.h>
+
+#include "al.h" /* OpenAL */
+
+/* Compatibility defines for SDL */
+#define AUDIO_U8 0x0008
+#define AUDIO_S8 0x8008
+#define AUDIO_U16LSB 0x0010	
+#define AUDIO_S16LSB 0x8010
+#define AUDIO_U16MSB 0x1010
+#define AUDIO_S16MSB 0x9010
+#define AUDIO_U16 AUDIO_U16LSB
+#define AUDIO_S16 AUDIO_S16LSB
+
+#ifdef ANDROID_NDK
+	#include <endian.h>
+	#if _BYTE_ORDER == _BIG_ENDIAN
+		#define __BIG_ENDIAN__ 1
+	#elif _BYTE_ORDER == _LITTLE_ENDIAN
+		#define __LITTLE_ENDIAN__ 1
+	#else
+		#warning "Android falling back to __LITTLE_ENDIAN__"
+		#define __LITTLE_ENDIAN__ 1
+	#endif
+#endif
+
+#if __BIG_ENDIAN__
+#warning "Using __BIG_ENDIAN__"
+#define AUDIO_U16SYS AUDIO_U16MSB
+#define AUDIO_S16SYS AUDIO_S16MSB
+#elif __LITTLE_ENDIAN__
+#define AUDIO_U16SYS	AUDIO_U16LSB
+#define AUDIO_S16SYS	AUDIO_S16LSB
+#else
+#warning "Using __LITTLE_ENDIAN__ as fallback"
+#define AUDIO_U16SYS	AUDIO_U16LSB
+#define AUDIO_S16SYS	AUDIO_S16LSB
+#endif
+
+struct ALmixer_RWops;
+
+typedef enum
+{
+	SOUND_SAMPLEFLAG_NONE = 0,
+	SOUND_SAMPLEFLAG_CANSEEK = 1,
+	SOUND_SAMPLEFLAG_EOF     = 1 << 29,
+	SOUND_SAMPLEFLAG_ERROR   = 1 << 30,
+	SOUND_SAMPLEFLAG_EAGAIN  = 1 << 31 
+} SoundDecoder_SampleFlags;
+
+#define Sound_SampleFlags SoundDecoder_SampleFlags;
+
+typedef struct SoundDecoder_AudioInfo
+{
+    //uint16_t format;  /**< Equivalent of SDL_AudioSpec.format. */
+    ALushort format;  /**< Equivalent of SDL_AudioSpec.format. */
+    ALubyte channels;
+    // uint8_t channels;
+    //uint32_t rate; 
+    ALuint rate; 
+} SoundDecoder_AudioInfo;
+
+//#define Sound_AudioInfo SoundDecoder_AudioInfo;
+typedef struct SoundDecoder_AudioInfo Sound_AudioInfo;
+
+
+
+typedef struct SoundDecoder_DecoderInfo
+{
+    const char** extensions;
+    const char* description;
+    const char* author;
+    const char* url;
+} SoundDecoder_DecoderInfo;
+
+//#define Sound_DecoderInfo SoundDecoder_DecoderInfo;
+typedef struct SoundDecoder_DecoderInfo Sound_DecoderInfo;
+
+
+
+typedef struct SoundDecoder_Sample
+{
+    void* opaque;
+    const SoundDecoder_DecoderInfo* decoder;
+    SoundDecoder_AudioInfo desired;
+    SoundDecoder_AudioInfo actual;
+    void *buffer;
+    size_t buffer_size;
+    SoundDecoder_SampleFlags flags;
+} SoundDecoder_Sample;
+
+//#define Sound_Sample SoundDecoder_Sample;
+typedef struct SoundDecoder_Sample Sound_Sample;
+
+
+typedef struct SoundDecoder_Version
+{
+    int major;
+    int minor;
+    int patch;
+} SoundDecoder_Version;
+
+//#define Sound_Version SoundDecoder_Version;
+typedef struct SoundDecoder_Version Sound_Version;
+
+
+#define SOUNDDECODER_VER_MAJOR 0
+#define SOUNDDECODER_VER_MINOR 0
+#define SOUNDDECODER_VER_PATCH 1
+
+#define SOUNDDECODER_VERSION(x) \
+{ \
+    (x)->major = SOUNDDECODER_VER_MAJOR; \
+    (x)->minor = SOUNDDECODER_VER_MINOR; \
+    (x)->patch = SOUNDDECODER_VER_PATCH; \
+}
+
+#define SOUND_VERSION SOUNDDECODER_VERSION
+
+void SoundDecoder_GetLinkedVersion(SoundDecoder_Version *ver);
+#define Sound_GetLinkedVersion SoundDecoder_GetLinkedVersion
+
+int SoundDecoder_Init(void);
+#define Sound_Init SoundDecoder_Init
+
+void SoundDecoder_Quit(void);
+#define Sound_Quit SoundDecoder_Quit
+
+
+const SoundDecoder_DecoderInfo** SoundDecoder_AvailableDecoders(void);
+#define Sound_AvailableDecoders SoundDecoder_AvailableDecoders
+
+
+const char* SoundDecoder_GetError(void);
+#define Sound_GetError SoundDecoder_GetError
+
+
+void SoundDecoder_ClearError(void);
+#define Sound_ClearError SoundDecoder_ClearError
+
+
+
+SoundDecoder_Sample* SoundDecoder_NewSample(
+	struct ALmixer_RWops* rw_ops,
+	const char* ext,
+	SoundDecoder_AudioInfo* desired,
+	size_t buffer_size);
+#define Sound_NewSample SoundDecoder_NewSample
+
+SoundDecoder_Sample* SoundDecoder_NewSampleFromFile(const char* file_name,
+	SoundDecoder_AudioInfo* desired,
+	size_t bufferSize);
+#define Sound_NewSampleFromFile SoundDecoder_NewSampleFromFile
+
+
+void SoundDecoder_FreeSample(SoundDecoder_Sample* sound_sample);
+#define Sound_FreeSample SoundDecoder_FreeSample
+
+
+ptrdiff_t SoundDecoder_GetDuration(SoundDecoder_Sample* sound_sample);
+#define Sound_GetDuration SoundDecoder_GetDuration
+
+int SoundDecoder_SetBufferSize(SoundDecoder_Sample* sound_sample, size_t new_buffer_size);
+#define Sound_SetBufferSize SoundDecoder_SetBufferSize
+
+size_t SoundDecoder_Decode(SoundDecoder_Sample* sound_sample);
+#define Sound_Decode SoundDecoder_Decode
+
+size_t SoundDecoder_DecodeAll(SoundDecoder_Sample* sound_sample);
+#define Sound_DecodeAll SoundDecoder_DecodeAll
+
+int SoundDecoder_Rewind(SoundDecoder_Sample* sound_sample);
+#define Sound_Rewind SoundDecoder_Rewind
+
+int SoundDecoder_Seek(SoundDecoder_Sample* sound_sample, size_t ms);
+#define Sound_Seek SoundDecoder_Seek
+
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Isolated/SoundDecoder_Internal.h	Thu Apr 28 16:22:30 2011 -0700
@@ -0,0 +1,84 @@
+#ifndef SOUNDDECODER_INTERNAL_H
+#define SOUNDDECODER_INTERNAL_H
+
+#include <stdio.h>
+#include "al.h" /* OpenAL */
+#include "ALmixer_RWops.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+	
+
+typedef struct SoundDecoder_DecoderFunctions
+{
+    const SoundDecoder_DecoderInfo info;
+    int (*init)(void);
+    void (*quit)(void);
+    int (*open)(SoundDecoder_Sample *sample, const char *ext);
+    void (*close)(SoundDecoder_Sample *sample);
+    size_t (*read)(SoundDecoder_Sample *sample);
+    int (*rewind)(SoundDecoder_Sample *sample);
+    int (*seek)(SoundDecoder_Sample *sample, size_t ms);
+} SoundDecoder_DecoderFunctions;
+
+typedef struct SoundDecoder_DecoderFunctions Sound_DecoderFunctions;
+
+
+
+typedef struct SoundDecoder_SampleInternal
+{
+    ALmixer_RWops *rw;
+    const SoundDecoder_DecoderFunctions *funcs;
+    void *buffer;
+    size_t buffer_size;
+    void *decoder_private;
+    ptrdiff_t total_time;
+} SoundDecoder_SampleInternal;
+
+typedef struct SoundDecoder_SampleInternal Sound_SampleInternal;
+
+#define BAIL_MACRO(e, r) { SoundDecoder_SetError(e); return r; }
+#define BAIL_IF_MACRO(c, e, r) if (c) { SoundDecoder_SetError(e); return r; }
+#define ERR_OUT_OF_MEMORY "Out of memory"
+#define ERR_NOT_INITIALIZED "SoundDecoder not initialized"
+#define ERR_UNSUPPORTED_FORMAT "Unsupported codec"
+#define ERR_NULL_SAMPLE "Sound sample is NULL"
+#define ERR_PREVIOUS_SAMPLE_ERROR "Cannot operate on sample due to previous error"
+#define ERR_ALREADY_AT_EOF_ERROR "Cannot operate on sample because already at EOF"
+
+#ifdef ANDROID_NDK
+
+/* This macro crashes when a format string is used. 
+ * Provide a real function instead.
+#include <android/log.h>
+#define SNDDBG(x) __android_log_print(ANDROID_LOG_INFO, "Corona", x);
+*/
+/* Android doesn't seem to understand the 'restrict' qualifier. */
+int SoundDecoder_DebugPrint(const char* format, ...);
+#define SNDDBG(x) SoundDecoder_DebugPrint x
+
+#else
+
+#if (defined DEBUG_CHATTER)
+#define SNDDBG(x) printf x
+#else
+#define SNDDBG(x)
+#endif
+
+#endif
+
+void SoundDecoder_SetError(const char* err_str, ...);
+#define __Sound_SetError SoundDecoder_SetError
+
+int SoundDecoder_strcasecmp(const char *x, const char *y);
+#define __Sound_strcasecmp SoundDecoder_strcasecmp
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Isolated/UNUSED/SimpleSemaphore.h	Thu Apr 28 16:22:30 2011 -0700
@@ -0,0 +1,26 @@
+#ifndef SIMPLE_SEMAPHORE_H
+#define SIMPLE_SEMAPHORE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+	
+typedef struct SimpleSemaphore SimpleSemaphore;
+
+SimpleSemaphore* SimpleSemaphore_CreateSemaphore(int initial_value);
+
+void SimpleSemaphore_DestroySemaphore(SimpleSemaphore* simple_semaphore);
+
+int SimpleSemaphore_SemaphoreTryWait(SimpleSemaphore* simple_semaphore);
+int SimpleSemaphore_SemaphoreWait(SimpleSemaphore* simple_semaphore);
+int SimpleSemaphore_SemaphoreGetValue(SimpleSemaphore* simple_semaphore);
+int SimpleSemaphore_SemaphorePost(SimpleSemaphore* simple_semaphore);
+
+/* Ends C function definitions when using C++ */
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Isolated/UNUSED/SimpleSemaphorePosix.c	Thu Apr 28 16:22:30 2011 -0700
@@ -0,0 +1,122 @@
+#include "SimpleSemaphore.h"
+#include <semaphore.h>
+#include <stdlib.h>
+
+#if defined(DEBUG)
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#define SEMDBG(x) printf x
+#else
+#define SEMDBG(x)
+#endif
+
+
+
+struct SimpleSemaphore
+{
+    sem_t theSemaphore;
+};
+
+SimpleSemaphore* SimpleSemaphore_CreateSemaphore(int initial_value)
+{
+	int ret_val;	
+    SimpleSemaphore* simple_semaphore = (SimpleSemaphore*)malloc(sizeof(SimpleSemaphore));
+	if(NULL == simple_semaphore)
+	{
+		SEMDBG(("Out of memory.\n"));						
+		return NULL;
+	}
+	/* Drat: sem_init isn't available on OS X */
+#ifdef __APPLE__
+	#warning "sem_init (unnamed semaphores) do not work on OS X. This code is broken."
+#endif
+	ret_val = sem_init(&simple_semaphore->theSemaphore, 0, initial_value);
+	if(0 != ret_val)
+	{
+		/* failed */
+		SEMDBG(("sem_init failed with: %d\n", ret_val));		
+		free(simple_semaphore);
+		return 0;
+	}
+
+    return simple_semaphore;
+}
+
+void SimpleSemaphore_DestroySemaphore(SimpleSemaphore* simple_semaphore)
+{
+	if(NULL == simple_semaphore)
+	{
+		return;
+	}
+	sem_destroy(&simple_semaphore->theSemaphore);
+	free(simple_semaphore);
+}
+
+int SimpleSemaphore_SemaphoreTryWait(SimpleSemaphore* simple_semaphore)
+{
+    int ret_val;
+	if(NULL == simple_semaphore)
+	{
+		SEMDBG(("SimpleSemaphore_SemTryWait was passed a NULL semaphore\n"));	
+		return 0;
+	}
+    ret_val = sem_trywait(&simple_semaphore->theSemaphore);
+	if(0 == ret_val)
+	{
+		return 1;
+    }
+	else
+	{
+		return 0;
+	}
+}
+
+int SimpleSemaphore_SemaphoreWait(SimpleSemaphore* simple_semaphore)
+{
+    int ret_val;
+	if(NULL == simple_semaphore)
+	{
+		SEMDBG(("SimpleSemaphore_SemaphoreWait was passed a NULL semaphore\n"));	
+		return 0;
+	}
+    ret_val = sem_wait(&simple_semaphore->theSemaphore);
+	if(0 == ret_val)
+	{
+		return 1;
+    }
+	else
+	{
+		return 0;
+	}
+}
+
+int SimpleSemaphore_SemaphoreGetValue(SimpleSemaphore* simple_semaphore)
+{
+    int ret_val = 0;
+	if(NULL == simple_semaphore)
+	{
+		SEMDBG(("SimpleSemaphore_SemaphoreGetValue was passed a NULL semaphore\n"));	
+		return 0;
+	}
+	sem_getvalue(&simple_semaphore->theSemaphore, &ret_val);
+	return ret_val;
+}
+
+int SimpleSemaphore_SemaphorePost(SimpleSemaphore* simple_semaphore)
+{
+    int ret_val;
+	if(NULL == simple_semaphore)
+	{
+		SEMDBG(("SimpleSemaphore_SemaphorePost was passed a NULL semaphore\n"));	
+		return 0;
+	}
+
+    ret_val = sem_post(&simple_semaphore->theSemaphore);
+ 	if(-1 == ret_val)
+	{
+		SEMDBG(("sem_post failed with: %s\n", strerror(errno)));		
+	}
+    return ret_val;
+}
+

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Isolated/coreaudio.c	Thu Apr 28 16:22:30 2011 -0700
@@ -0,0 +1,784 @@
+#ifdef ALMIXER_COMPILE_WITHOUT_SDL
+
+/*
+ * SDL_sound Core Audio backend
+ * Copyright (C) 2010 Eric Wing <ewing . public @ playcontrol.net>
+ *
+ * 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#if HAVE_CONFIG_H
+#  include <config.h>
+#endif
+
+#ifdef __APPLE__
+
+#include <stddef.h> /* NULL */
+#include <stdio.h> /* printf */
+#include <arpa/inet.h> /* htonl */
+#include <AudioToolbox/AudioToolbox.h>
+
+#include "SoundDecoder.h"
+
+#include "SoundDecoder_Internal.h"
+
+typedef struct CoreAudioFileContainer
+{
+	AudioFileID* audioFileID;
+	ExtAudioFileRef extAudioFileRef;
+	AudioStreamBasicDescription* outputFormat;
+} CoreAudioFileContainer;
+
+static int CoreAudio_init(void);
+static void CoreAudio_quit(void);
+static int CoreAudio_open(Sound_Sample *sample, const char *ext);
+static void CoreAudio_close(Sound_Sample *sample);
+static size_t CoreAudio_read(Sound_Sample *sample);
+static int CoreAudio_rewind(Sound_Sample *sample);
+static int CoreAudio_seek(Sound_Sample *sample, size_t ms);
+
+static const char *extensions_coreaudio[] = 
+{
+	"aif",
+	"aiff",
+	"aifc",
+	"wav",
+	"wave",
+	"mp3",
+	"mp4",
+	"m4a",
+	"aac",
+	"adts",
+	"caf",
+	"Sd2f",
+	"Sd2",
+	"au",
+	"snd",
+	"next",
+	"mp2",
+	"mp1",
+	"ac3",
+	"3gpp",
+	"3gp",
+	"3gp2",
+	"3g2",
+	"amrf",
+	"amr",
+	"ima4",
+	"ima",
+	NULL 
+};
+const Sound_DecoderFunctions __Sound_DecoderFunctions_CoreAudio =
+{
+    {
+        extensions_coreaudio,
+        "Decode audio through Core Audio through",
+        "Eric Wing <ewing . public @ playcontrol.net>",
+        "http://playcontrol.net"
+    },
+	
+    CoreAudio_init,       /*   init() method */
+    CoreAudio_quit,       /*   quit() method */
+    CoreAudio_open,       /*   open() method */
+    CoreAudio_close,      /*  close() method */
+    CoreAudio_read,       /*   read() method */
+    CoreAudio_rewind,     /* rewind() method */
+    CoreAudio_seek        /*   seek() method */
+};
+
+
+static int CoreAudio_init(void)
+{
+    return(1);  /* always succeeds. */
+} /* CoreAudio_init */
+
+
+static void CoreAudio_quit(void)
+{
+    /* it's a no-op. */
+} /* CoreAudio_quit */
+
+/*
+   http://developer.apple.com/library/ios/#documentation/MusicAudio/Reference/AudioFileConvertRef/Reference/reference.html
+   kAudioFileAIFFType = 'AIFF',
+   kAudioFileAIFCType            = 'AIFC',
+   kAudioFileWAVEType            = 'WAVE',
+   kAudioFileSoundDesigner2Type  = 'Sd2f',
+   kAudioFileNextType            = 'NeXT',
+   kAudioFileMP3Type             = 'MPG3',
+   kAudioFileMP2Type             = 'MPG2',
+   kAudioFileMP1Type             = 'MPG1',
+   kAudioFileAC3Type             = 'ac-3',
+   kAudioFileAAC_ADTSType        = 'adts',
+   kAudioFileMPEG4Type           = 'mp4f',
+   kAudioFileM4AType             = 'm4af',
+   kAudioFileCAFType             = 'caff',
+   kAudioFile3GPType             = '3gpp',
+   kAudioFile3GP2Type            = '3gp2',
+   kAudioFileAMRType             = 'amrf'
+*/
+static AudioFileTypeID CoreAudio_GetAudioTypeForExtension(const char* file_extension)
+{
+	if( (__Sound_strcasecmp(file_extension, "aif") == 0)
+		|| (__Sound_strcasecmp(file_extension, "aiff") == 0)
+		|| (__Sound_strcasecmp(file_extension, "aifc") == 0)
+	)
+	{
+		return kAudioFileAIFCType;
+	}
+	else if( (__Sound_strcasecmp(file_extension, "wav") == 0)
+		|| (__Sound_strcasecmp(file_extension, "wave") == 0)
+	)
+	{
+		return kAudioFileWAVEType;
+	}
+	else if( (__Sound_strcasecmp(file_extension, "mp3") == 0)
+	)
+	{
+		return kAudioFileMP3Type;
+	}
+	else if( (__Sound_strcasecmp(file_extension, "mp4") == 0)
+	)
+	{
+		return kAudioFileMPEG4Type;
+	}
+	else if( (__Sound_strcasecmp(file_extension, "m4a") == 0)
+	)
+	{
+		return kAudioFileM4AType;
+	}
+	else if( (__Sound_strcasecmp(file_extension, "aac") == 0)
+	)
+	{
+		return kAudioFileAAC_ADTSType;
+	}
+	else if( (__Sound_strcasecmp(file_extension, "adts") == 0)
+	)
+	{
+		return kAudioFileAAC_ADTSType;
+	}
+	else if( (__Sound_strcasecmp(file_extension, "caf") == 0)
+		|| (__Sound_strcasecmp(file_extension, "caff") == 0)
+	)
+	{
+		return kAudioFileCAFType;
+	}
+	else if( (__Sound_strcasecmp(file_extension, "Sd2f") == 0)
+		|| (__Sound_strcasecmp(file_extension, "sd2") == 0)
+	)
+	{
+		return kAudioFileSoundDesigner2Type;
+	}
+	else if( (__Sound_strcasecmp(file_extension, "au") == 0)
+		|| (__Sound_strcasecmp(file_extension, "snd") == 0)
+		|| (__Sound_strcasecmp(file_extension, "next") == 0)
+	)
+	{
+		return kAudioFileNextType;
+	}
+	else if( (__Sound_strcasecmp(file_extension, "mp2") == 0)
+	)
+	{
+		return kAudioFileMP2Type;
+	}
+	else if( (__Sound_strcasecmp(file_extension, "mp1") == 0)
+	)
+	{
+		return kAudioFileMP1Type;
+	}
+	else if( (__Sound_strcasecmp(file_extension, "ac3") == 0)
+	)
+	{
+		return kAudioFileAC3Type;
+	}
+	else if( (__Sound_strcasecmp(file_extension, "3gpp") == 0)
+			|| (__Sound_strcasecmp(file_extension, "3gp") == 0)
+	)
+	{
+		return kAudioFile3GPType;
+	}
+	else if( (__Sound_strcasecmp(file_extension, "3gp2") == 0)
+			|| (__Sound_strcasecmp(file_extension, "3g2") == 0)
+	)
+	{
+		return kAudioFile3GP2Type;
+	}
+	else if( (__Sound_strcasecmp(file_extension, "amrf") == 0)
+		|| (__Sound_strcasecmp(file_extension, "amr") == 0)
+	)
+	{
+		return kAudioFileAMRType;
+	}
+	else if( (__Sound_strcasecmp(file_extension, "ima4") == 0)
+		|| (__Sound_strcasecmp(file_extension, "ima") == 0)
+	)
+	{
+		/* not sure about this one */
+		return kAudioFileCAFType;
+	}
+	else
+	{
+		return 0;
+	}
+
+}
+
+static const char* CoreAudio_FourCCToString(int32_t error_code)
+{
+	static char return_string[16];
+	uint32_t big_endian_code = htonl(error_code);
+	char* big_endian_str = (char*)&big_endian_code;
+	// see if it appears to be a 4-char-code
+	if(isprint(big_endian_str[0])
+	   && isprint(big_endian_str[1])
+	   && isprint(big_endian_str[2])
+	   && isprint (big_endian_str[3]))
+	{
+		return_string[0] = '\'';
+		return_string[1] = big_endian_str[0];
+		return_string[2] = big_endian_str[1];
+		return_string[3] = big_endian_str[2];
+		return_string[4] = big_endian_str[3];
+		return_string[5] = '\'';
+		return_string[6] = '\0';
+	}
+	else if(error_code > -200000 && error_code < 200000)
+	{
+		// no, format it as an integer
+		snprintf(return_string, 16, "%d", error_code);
+	}
+	else
+	{
+		// no, format it as an integer but in hex
+		snprintf(return_string, 16, "0x%x", error_code);
+	}
+	return return_string;
+}
+
+
+
+SInt64 CoreAudio_SizeCallback(void* inClientData)
+{
+	ALmixer_RWops* rw_ops = (ALmixer_RWops*)inClientData;
+	SInt64 current_position = ALmixer_RWtell(rw_ops);
+	SInt64 end_position = ALmixer_RWseek(rw_ops, 0, SEEK_END);
+	ALmixer_RWseek(rw_ops, current_position, SEEK_SET);
+//	fprintf(stderr, "CoreAudio_SizeCallback:%d\n", end_position);
+
+	return end_position;
+}
+
+OSStatus CoreAudio_ReadCallback(
+	void* inClientData,
+	SInt64 inPosition,
+	UInt32 requestCount,
+	void* data_buffer,
+	UInt32* actualCount
+)
+{
+	ALmixer_RWops* rw_ops = (ALmixer_RWops*)inClientData;
+	ALmixer_RWseek(rw_ops, inPosition, SEEK_SET);
+	size_t bytes_actually_read = ALmixer_RWread(rw_ops, data_buffer, 1, requestCount);
+	// Not sure how to test for a read error with ALmixer_RWops
+//	fprintf(stderr, "CoreAudio_ReadCallback:%d, %d\n", requestCount, bytes_actually_read);
+
+	*actualCount = bytes_actually_read;
+	return noErr;
+}
+
+
+static int CoreAudio_open(Sound_Sample *sample, const char *ext)
+{
+	CoreAudioFileContainer* core_audio_file_container;
+	AudioFileID* audio_file_id;
+	OSStatus error_result;
+	Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+	AudioStreamBasicDescription	actual_format;
+	AudioStreamBasicDescription	output_format;
+	Float64 estimated_duration;
+	UInt32 format_size;
+	
+
+	core_audio_file_container = (CoreAudioFileContainer*)malloc(sizeof(CoreAudioFileContainer));
+	BAIL_IF_MACRO(core_audio_file_container == NULL, ERR_OUT_OF_MEMORY, 0);
+
+
+	audio_file_id = (AudioFileID*)malloc(sizeof(AudioFileID));
+	BAIL_IF_MACRO(audio_file_id == NULL, ERR_OUT_OF_MEMORY, 0);
+
+	error_result = AudioFileOpenWithCallbacks(
+		internal->rw,
+		CoreAudio_ReadCallback,
+		NULL,
+		CoreAudio_SizeCallback,
+		NULL,
+		CoreAudio_GetAudioTypeForExtension(ext),
+		audio_file_id
+	);
+	if (error_result != noErr)
+	{
+		AudioFileClose(*audio_file_id);
+		free(audio_file_id);
+		free(core_audio_file_container);
+		SNDDBG(("Core Audio: can't grok data. reason: [%s].\n", CoreAudio_FourCCToString(error_result)));
+		BAIL_MACRO("Core Audio: Not valid audio data.", 0);
+	} /* if */
+	
+    format_size = sizeof(actual_format);
+    error_result = AudioFileGetProperty(
+		*audio_file_id,
+		kAudioFilePropertyDataFormat,
+		&format_size,
+		&actual_format
+	);
+    if (error_result != noErr)
+	{
+		AudioFileClose(*audio_file_id);
+		free(audio_file_id);
+		free(core_audio_file_container);
+		SNDDBG(("Core Audio: AudioFileGetProperty failed. reason: [%s]", CoreAudio_FourCCToString(error_result)));
+		BAIL_MACRO("Core Audio: Not valid audio data.", 0);
+	} /* if */
+
+    format_size = sizeof(estimated_duration);
+    error_result = AudioFileGetProperty(
+		*audio_file_id,
+		kAudioFilePropertyEstimatedDuration,
+		&format_size,
+		&estimated_duration
+	);
+    if (error_result != noErr)
+	{
+		AudioFileClose(*audio_file_id);
+		free(audio_file_id);
+		free(core_audio_file_container);
+		SNDDBG(("Core Audio: AudioFileGetProperty failed. reason: [%s].\n", CoreAudio_FourCCToString(error_result)));
+		BAIL_MACRO("Core Audio: Not valid audio data.", 0);
+	} /* if */
+
+
+	core_audio_file_container->audioFileID = audio_file_id;
+	
+	internal->decoder_private = core_audio_file_container;
+	
+	sample->flags = SOUND_SAMPLEFLAG_CANSEEK;
+	sample->actual.rate = (UInt32) actual_format.mSampleRate;
+	sample->actual.channels = (UInt8)actual_format.mChannelsPerFrame;
+	internal->total_time = (SInt32)(estimated_duration * 1000.0 + 0.5);
+
+#if 0
+	/* FIXME: Both Core Audio and SDL 1.3 support float and 32-bit formats */
+	if(actual_format.mFormatFlags & kAudioFormatFlagIsBigEndian)
+	{
+		if(16 == actual_format.mBitsPerChannel)
+		{
+			if(kAudioFormatFlagIsSignedInteger & actual_format.mFormatFlags)
+			{
+				sample->actual.format = AUDIO_S16MSB;
+			}
+			else
+			{
+				sample->actual.format = AUDIO_U16MSB;				
+			}
+		}
+		else if(8 == actual_format.mBitsPerChannel)
+		{
+			if(kAudioFormatFlagIsSignedInteger & actual_format.mFormatFlags)
+			{
+				sample->actual.format = AUDIO_S8;
+			}
+			else
+			{
+				sample->actual.format = AUDIO_U8;				
+			}
+		}
+		else // might be 0 for undefined? 
+		{
+			// This case seems to come up a lot for me. Maybe for file types like .m4a?
+			sample->actual.format = AUDIO_S16SYS;
+			SNDDBG(("Core Audio: Unsupported actual_format.mBitsPerChannel: [%d].\n", actual_format.mBitsPerChannel));
+			
+		}
+	}
+	else // little endian
+	{
+		if(16 == actual_format.mBitsPerChannel)
+		{
+			if(kAudioFormatFlagIsSignedInteger & actual_format.mFormatFlags)
+			{
+				sample->actual.format = AUDIO_S16LSB;
+			}
+			else
+			{
+				sample->actual.format = AUDIO_U16LSB;				
+			}
+		}
+		else if(8 == actual_format.mBitsPerChannel)
+		{
+			if(kAudioFormatFlagIsSignedInteger & actual_format.mFormatFlags)
+			{
+				sample->actual.format = AUDIO_S8;
+			}
+			else
+			{
+				sample->actual.format = AUDIO_U8;				
+			}
+		}
+		else // might be 0 for undefined? 
+		{
+			sample->actual.format = AUDIO_S16SYS;
+			
+			SNDDBG(("Core Audio: Unsupported actual_format.mBitsPerChannel: [%d].\n", actual_format.mBitsPerChannel));
+		}
+
+	}
+#else
+	
+	
+	
+    /*
+     * I want to use Core Audio to do conversion and decoding for performance reasons.
+	 * This is particularly important on mobile devices like iOS.
+	 * Taking from the Ogg Vorbis decode, I pretend the "actual" format is the same 
+	 * as the desired format. 
+     */
+    sample->actual.format = (sample->desired.format == 0) ?
+	AUDIO_S16SYS : sample->desired.format;
+#endif	
+
+
+	SNDDBG(("CoreAudio: channels == (%d).\n", sample->actual.channels));
+	SNDDBG(("CoreAudio: sampling rate == (%d).\n",sample->actual.rate));
+	SNDDBG(("CoreAudio: total seconds of sample == (%d).\n", internal->total_time));
+	SNDDBG(("CoreAudio: sample->actual.format == (%d).\n", sample->actual.format));
+
+
+	
+	error_result = ExtAudioFileWrapAudioFileID(*audio_file_id,
+		false, // set to false for read-only
+		&core_audio_file_container->extAudioFileRef
+	);
+	if(error_result != noErr)
+	{
+		AudioFileClose(*audio_file_id);
+		free(audio_file_id);
+		free(core_audio_file_container);
+		SNDDBG(("Core Audio: can't wrap data. reason: [%s].\n", CoreAudio_FourCCToString(error_result)));
+		BAIL_MACRO("Core Audio: Failed to wrap data.", 0);
+	} /* if */
+
+
+	/* The output format must be linear PCM because that's the only type OpenAL knows how to deal with.
+	 * Set the client format to 16 bit signed integer (native-endian) data because that is the most
+	 * optimal format on iPhone/iPod Touch hardware.
+	 * Maintain the channel count and sample rate of the original source format.
+	 */
+	output_format.mSampleRate = actual_format.mSampleRate; // preserve the original sample rate
+	output_format.mChannelsPerFrame = actual_format.mChannelsPerFrame; // preserve the number of channels
+	output_format.mFormatID = kAudioFormatLinearPCM; // We want linear PCM data
+	output_format.mFramesPerPacket = 1; // We know for linear PCM, the definition is 1 frame per packet
+
+	if(sample->desired.format == 0)
+	{
+		// do AUDIO_S16SYS
+		output_format.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked; // I seem to read failures problems without kAudioFormatFlagIsPacked. From a mailing list post, this seems to be a Core Audio bug.
+		output_format.mBitsPerChannel = 16; // We know we want 16-bit
+	}
+	else
+	{
+		output_format.mFormatFlags = 0; // clear flags
+		output_format.mFormatFlags |= kAudioFormatFlagIsPacked; // I seem to read failures problems without kAudioFormatFlagIsPacked. From a mailing list post, this seems to be a Core Audio bug.
+		// Mask against bitsize
+		if(0xFF & sample->desired.format)
+		{
+			output_format.mBitsPerChannel = 16; /* 16-bit */
+		}
+		else
+		{
+			output_format.mBitsPerChannel = 8; /* 8-bit */
+		}
+
+		// Mask for signed/unsigned
+		if((1<<15) & sample->desired.format)
+		{
+			output_format.mFormatFlags = output_format.mFormatFlags | kAudioFormatFlagIsSignedInteger;
+
+		}
+		else
+		{
+			// no flag set for unsigned
+		}
+		// Mask for big/little endian
+		if((1<<12) & sample->desired.format)
+		{
+			output_format.mFormatFlags = output_format.mFormatFlags | kAudioFormatFlagIsBigEndian;
+		}
+		else
+		{
+			// no flag set for little endian 
+		}
+	}
+
+	output_format.mBytesPerPacket = output_format.mBitsPerChannel/8 * output_format.mChannelsPerFrame; // e.g. 16-bits/8 * channels => so 2-bytes per channel per frame
+	output_format.mBytesPerFrame = output_format.mBitsPerChannel/8 * output_format.mChannelsPerFrame; // For PCM, since 1 frame is 1 packet, it is the same as mBytesPerPacket
+
+	
+/*
+	output_format.mSampleRate = actual_format.mSampleRate; // preserve the original sample rate
+	output_format.mChannelsPerFrame = actual_format.mChannelsPerFrame; // preserve the number of channels
+	output_format.mFormatID = kAudioFormatLinearPCM; // We want linear PCM data
+//	output_format.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked | kAudioFormatFlagIsSignedInteger;
+	output_format.mFormatFlags = kAudioFormatFlagsNativeEndian |  kAudioFormatFlagIsSignedInteger;
+	output_format.mFramesPerPacket = 1; // We know for linear PCM, the definition is 1 frame per packet
+	output_format.mBitsPerChannel = 16; // We know we want 16-bit
+	output_format.mBytesPerPacket = 2 * output_format.mChannelsPerFrame; // We know we are using 16-bit, so 2-bytes per channel per frame
+	output_format.mBytesPerFrame = 2 * output_format.mChannelsPerFrame; // For PCM, since 1 frame is 1 packet, it is the same as mBytesPerPacket
+*/
+	SNDDBG(("output_format: mSampleRate: %lf\n", output_format.mSampleRate)); 
+	SNDDBG(("output_format: mChannelsPerFrame: %d\n", output_format.mChannelsPerFrame)); 
+	SNDDBG(("output_format: mFormatID: %d\n", output_format.mFormatID)); 
+	SNDDBG(("output_format: mFormatFlags: %d\n", output_format.mFormatFlags)); 
+	SNDDBG(("output_format: mFramesPerPacket: %d\n", output_format.mFramesPerPacket)); 
+	SNDDBG(("output_format: mBitsPerChannel: %d\n", output_format.mBitsPerChannel)); 
+	SNDDBG(("output_format: mBytesPerPacket: %d\n", output_format.mBytesPerPacket)); 
+	SNDDBG(("output_format: mBytesPerFrame: %d\n", output_format.mBytesPerFrame)); 
+	
+	
+	/* Set the desired client (output) data format */
+	error_result = ExtAudioFileSetProperty(core_audio_file_container->extAudioFileRef, kExtAudioFileProperty_ClientDataFormat, sizeof(output_format), &output_format);
+	if(noErr != error_result)
+	{
+		ExtAudioFileDispose(core_audio_file_container->extAudioFileRef);
+		AudioFileClose(*audio_file_id);
+		free(audio_file_id);
+		free(core_audio_file_container);
+		SNDDBG(("Core Audio: ExtAudioFileSetProperty(kExtAudioFileProperty_ClientDataFormat) failed, reason: [%s].\n", CoreAudio_FourCCToString(error_result)));
+		BAIL_MACRO("Core Audio: Not valid audio data.", 0);
+	}	
+
+
+	core_audio_file_container->outputFormat = (AudioStreamBasicDescription*)malloc(sizeof(AudioStreamBasicDescription));
+	BAIL_IF_MACRO(core_audio_file_container->outputFormat == NULL, ERR_OUT_OF_MEMORY, 0);
+
+
+	
+	/* Copy the output format to the audio_description that was passed in so the 
+	 * info will be returned to the user.
+	 */
+	memcpy(core_audio_file_container->outputFormat, &output_format, sizeof(AudioStreamBasicDescription));
+
+	
+
+	return(1);
+} /* CoreAudio_open */
+
+
+static void CoreAudio_close(Sound_Sample *sample)
+{
+	Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+	CoreAudioFileContainer* core_audio_file_container = (CoreAudioFileContainer *) internal->decoder_private;
+	
+	free(core_audio_file_container->outputFormat);
+	ExtAudioFileDispose(core_audio_file_container->extAudioFileRef);
+	AudioFileClose(*core_audio_file_container->audioFileID);
+	free(core_audio_file_container->audioFileID);
+	free(core_audio_file_container);
+		
+} /* CoreAudio_close */
+
+
+static size_t CoreAudio_read(Sound_Sample *sample)
+{
+	OSStatus error_result = noErr;	
+	/* Documentation/example shows SInt64, but is problematic for big endian
+	 * on 32-bit cast for ExtAudioFileRead() because it takes the upper
+	 * bits which turn to 0.
+	 */
+	UInt32 buffer_size_in_frames = 0;
+	UInt32 buffer_size_in_frames_remaining = 0;
+	UInt32 total_frames_read = 0;
+	UInt32 data_buffer_size = 0;
+	UInt32 bytes_remaining = 0;
+	size_t total_bytes_read = 0;
+	Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+	CoreAudioFileContainer* core_audio_file_container = (CoreAudioFileContainer *) internal->decoder_private;
+	UInt32 max_buffer_size = internal->buffer_size;
+
+//	printf("internal->buffer_size=%d, internal->buffer=0x%x, sample->buffer_size=%d\n", internal->buffer_size, internal->buffer, sample->buffer_size); 
+//	printf("internal->max_buffer_size=%d\n", max_buffer_size); 
+
+	/* Compute how many frames will fit into our max buffer size */
+	/* Warning: If this is not evenly divisible, the buffer will not be completely filled which violates the SDL_sound assumption. */
+	buffer_size_in_frames = max_buffer_size / core_audio_file_container->outputFormat->mBytesPerFrame;
+//	printf("buffer_size_in_frames=%ld, internal->buffer_size=%d, internal->buffer=0x%x outputFormat->mBytesPerFrame=%d, sample->buffer_size=%d\n", buffer_size_in_frames, internal->buffer_size, internal->buffer, core_audio_file_container->outputFormat->mBytesPerFrame, sample->buffer_size); 
+
+
+//	void* temp_buffer = malloc(max_buffer_size);
+	
+	AudioBufferList audio_buffer_list;
+	audio_buffer_list.mNumberBuffers = 1;
+	audio_buffer_list.mBuffers[0].mDataByteSize = max_buffer_size;
+	audio_buffer_list.mBuffers[0].mNumberChannels = core_audio_file_container->outputFormat->mChannelsPerFrame;
+	audio_buffer_list.mBuffers[0].mData = internal->buffer;
+
+
+	bytes_remaining = max_buffer_size;
+	buffer_size_in_frames_remaining = buffer_size_in_frames;
+	
+	// oops. Due to the kAudioFormatFlagIsPacked bug, 
+	// I was misled to believe that Core Audio
+	// was not always filling my entire requested buffer. 
+	// So this while-loop might be unnecessary.
+	// However, I have not exhaustively tested all formats, 
+	// so maybe it is possible this loop is useful.
+	// It might also handle the not-evenly disvisible case above.
+	while(buffer_size_in_frames_remaining > 0 && !(sample->flags & SOUND_SAMPLEFLAG_EOF))
+	{
+		
+		data_buffer_size = (UInt32)(buffer_size_in_frames * core_audio_file_container->outputFormat->mBytesPerFrame);
+//		printf("data_buffer_size=%d\n", data_buffer_size); 
+
+		buffer_size_in_frames = buffer_size_in_frames_remaining;
+		
+//		printf("reading buffer_size_in_frames=%"PRId64"\n", buffer_size_in_frames); 
+
+
+		audio_buffer_list.mBuffers[0].mDataByteSize = bytes_remaining;
+		audio_buffer_list.mBuffers[0].mData = &(((UInt8*)internal->buffer)[total_bytes_read]);
+
+		
+		/* Read the data into an AudioBufferList */
+		error_result = ExtAudioFileRead(core_audio_file_container->extAudioFileRef, &buffer_size_in_frames, &audio_buffer_list);
+		if(error_result == noErr)
+		{
+		
+		
+			/* Success */
+			
+			total_frames_read += buffer_size_in_frames;
+			buffer_size_in_frames_remaining = buffer_size_in_frames_remaining - buffer_size_in_frames;
+			
+//			printf("read buffer_size_in_frames=%"PRId64", buffer_size_in_frames_remaining=%"PRId64"\n", buffer_size_in_frames, buffer_size_in_frames_remaining); 
+
+			/* ExtAudioFileRead returns the number of frames actually read. Need to convert back to bytes. */
+			data_buffer_size = (UInt32)(buffer_size_in_frames * core_audio_file_container->outputFormat->mBytesPerFrame);
+//			printf("data_buffer_size=%d\n", data_buffer_size); 
+
+			total_bytes_read += data_buffer_size;
+			bytes_remaining = bytes_remaining - data_buffer_size;
+
+			/* Note: 0 == buffer_size_in_frames is a legitimate value meaning we are EOF. */
+			if(0 == buffer_size_in_frames)
+			{
+				sample->flags |= SOUND_SAMPLEFLAG_EOF;			
+			}
+
+		}
+		else 
+		{
+			SNDDBG(("Core Audio: ExtAudioFileReadfailed, reason: [%s].\n", CoreAudio_FourCCToString(error_result)));
+
+			sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+			break;
+			
+		}
+	}
+	
+	if( (!(sample->flags & SOUND_SAMPLEFLAG_EOF)) && (total_bytes_read < max_buffer_size))
+	{
+		SNDDBG(("Core Audio: ExtAudioFileReadfailed SOUND_SAMPLEFLAG_EAGAIN, reason: [total_bytes_read < max_buffer_size], %d, %d.\n", total_bytes_read , max_buffer_size));
+		
+		/* Don't know what to do here. */
+		sample->flags |= SOUND_SAMPLEFLAG_EAGAIN;
+	}
+	return total_bytes_read;
+} /* CoreAudio_read */
+
+
+static int CoreAudio_rewind(Sound_Sample *sample)
+{
+	OSStatus error_result = noErr;	
+	Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+	CoreAudioFileContainer* core_audio_file_container = (CoreAudioFileContainer *) internal->decoder_private;
+	
+	error_result = ExtAudioFileSeek(core_audio_file_container->extAudioFileRef, 0);
+	if(error_result != noErr)
+	{
+		sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+	}
+	return(1);
+} /* CoreAudio_rewind */
+
+/* Note: I found this tech note:
+ http://developer.apple.com/library/mac/#qa/qa2009/qa1678.html
+ I don't know if this applies to us. So far, I haven't noticed the problem,
+ so I haven't applied any of the techniques.
+ */
+static int CoreAudio_seek(Sound_Sample *sample, size_t ms)
+{
+	OSStatus error_result = noErr;	
+	Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
+	CoreAudioFileContainer* core_audio_file_container = (CoreAudioFileContainer *) internal->decoder_private;
+	SInt64 frame_offset = 0;
+
+	/* I'm confused. The Apple documentation says this:
+	 "Seek position is specified in the sample rate and frame count of the file’s audio data format
+	 — not your application’s audio data format."
+	 My interpretation is that I want to get the "actual format of the file and compute the frame offset.
+	 But when I try that, seeking goes to the wrong place.
+	 When I use outputFormat, things seem to work correctly.
+	 I must be misinterpreting the documentation or doing something wrong.
+	 */
+#if 0 /* not working */
+	AudioStreamBasicDescription	actual_format;
+	UInt32 format_size;
+    format_size = sizeof(AudioStreamBasicDescription);
+    error_result = AudioFileGetProperty(
+		*core_audio_file_container->audioFileID,
+		kAudioFilePropertyDataFormat,
+		&format_size,
+		&actual_format
+	);
+    if(error_result != noErr)
+	{
+		sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+		BAIL_MACRO("Core Audio: Could not GetProperty for kAudioFilePropertyDataFormat.", 0);
+	} /* if */
+
+	// packetIndex = (pos * sampleRate) / framesPerPacket
+	frame_offset = (SInt64)((ms/1000.0 * actual_format.mSampleRate) / actual_format.mFramesPerPacket);
+	// computed against actual format and not the client format
+
+	// packetIndex = (pos * sampleRate) / framesPerPacket
+	//	frame_offset = (SInt64)((ms/1000.0 * actual_format.mSampleRate) / actual_format.mFramesPerPacket);
+#else /* seems to work, but I'm confused */
+	// packetIndex = (pos * sampleRate) / framesPerPacket
+	frame_offset = (SInt64)((ms/1000.0 * core_audio_file_container->outputFormat->mSampleRate) / core_audio_file_container->outputFormat->mFramesPerPacket);	
+#endif
+	
+	// computed against actual format and not the client format
+	error_result = ExtAudioFileSeek(core_audio_file_container->extAudioFileRef, frame_offset);
+	if(error_result != noErr)
+	{
+		sample->flags |= SOUND_SAMPLEFLAG_ERROR;
+	}
+	return(1);
+} /* CoreAudio_seek */
+
+#endif /* __APPLE__ */
+
+
+#endif /* ALMIXER_COMPILE_WITHOUT_SDL */
+