almixer_isolated: SDL_ALmixer.c comparison

comparison SDL_ALmixer.c @ 2:279d0427ef26

Overhaul prep for first public release.

author	Eric Wing <ewing . public \|-at-\| gmail . com>
date	Wed, 27 Oct 2010 16:52:44 -0700
parents	a8a8fe374984
children

comparison

equal deleted inserted replaced

-:a8a8fe374984
+:279d0427ef26
 * Eric Wing
 */
 #include "SDL_ALmixer.h"
-#include "SDL.h" /* For SDL_GetTicks(), SDL_Delay */
+#ifdef ALMIXER_COMPILE_WITHOUT_SDL
-#include "SDL_sound.h"
+	#include "ALmixer_rwops.h"
+	#include "SoundDecoder.h"
+#else
+	#include "SDL_sound.h"
+#endif
 #include "al.h" /* OpenAL */
 #include "alc.h" /* For creating OpenAL contexts */
 #ifdef __APPLE__
 	/* For performance things like ALC_CONVERT_DATA_UPON_LOADING */
 	/* Note: ALC_CONVERT_DATA_UPON_LOADING used to be in the alc.h header.
 	 * But in the Tiger OpenAL 1.1 release (10.4.7 and Xcode 2.4), the
 	 * define was moved to a new header file and renamed to
 	 * ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING.
 	 */
-	#include <OpenAL/MacOSX_OALExtensions.h>
+/*
+	#include <TargetConditionals.h>
+	#if (TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1)
+	#else
+		#include <OpenAL/MacOSX_OALExtensions.h>
+	#endif
+*/
 #endif
 /* For malloc, bsearch, qsort */
 #include <stdlib.h>
 * to work around the Nvidia problem of the
 * lack of a buffer query.
 */
 #include "CircularQueue.h"
+#ifdef ENABLE_ALMIXER_THREADS
 /* Needed for the Mutex locks (and threads if enabled) */
-#include "SDL_thread.h"
+	#ifdef ALMIXER_COMPILE_WITHOUT_SDL
+		#include "SimpleMutex.h"
+		#include "SimpleThread.h"
+		typedef struct SimpleMutex SDL_mutex;
+		typedef struct SimpleThread SDL_Thread;
+		#define SDL_CreateMutex SimpleMutex_CreateMutex
+		#define SDL_DestroyMutex SimpleMutex_DestroyMutex
+		#define SDL_LockMutex SimpleMutex_LockMutex
+		#define SDL_UnlockMutex SimpleMutex_UnlockMutex
+		#define SDL_CreateThread SimpleThread_CreateThread
+		#define SDL_WaitThread SimpleThread_WaitThread
+	#else
+		#include "SDL_thread.h"
+	#endif
+#endif
 /* Because of the API differences between the Loki
 * and Creative distributions, we need to know which
 * version to use. The LOKI distribution currently
 * has AL_BYTE_LOKI defined in altypes.h which
 * identify the Creative dist.
 * I'm not sure if or how the Nvidia distribution differs
 * from the Creative distribution. So for
 * now, the Nvidia distribution gets lumped with the
 * Creative dist and I hope nothing will break.
-* My aluGetErrorString may be the most vulnerable.
+* My alGetString may be the most vulnerable.
 */
 #ifdef AL_BYTE_LOKI
 	#define USING_LOKI_AL_DIST
 	/* This is a short term fix to get around the
 	 * queuing problem with non-power of two buffer sizes.
 */
 #define NUMBER_OF_START_UP_BUFFERS 	2
 #endif
 /************ END REMOVE  ME (Don't need anymore) ********/
-static SDL_bool ALmixer_Initialized = 0;
+#ifdef ALMIXER_COMPILE_WITHOUT_SDL
+	#include "tErrorLib.h"
+	static TErrorPool* s_ALmixerErrorPool = NULL;
+#endif
+static ALboolean ALmixer_Initialized = 0;
 /* This should be set correctly by Init */
-static Uint32 ALmixer_Frequency_global = ALMIXER_DEFAULT_FREQUENCY;
+static ALuint ALmixer_Frequency_global = ALMIXER_DEFAULT_FREQUENCY;
 /* Will be initialized in Init */
-static Sint32 Number_of_Channels_global = 0;
+static ALint Number_of_Channels_global = 0;
-static Sint32 Number_of_Reserve_Channels_global = 0;
+static ALint Number_of_Reserve_Channels_global = 0;
-static Uint32 Is_Playing_global = 0;
+static ALuint Is_Playing_global = 0;
+#ifdef ENABLE_ALMIXER_THREADS
 /* This is for a simple lock system. It is not meant to be good,
 * but just sufficient to minimize/avoid threading issues
 */
-static SDL_mutex* simple_lock;
+static SDL_mutex* s_simpleLock;
-#ifdef ENABLE_ALMIXER_THREADS
 static SDL_Thread* Stream_Thread_global = NULL;
 #endif
+#ifdef __APPLE__
+static ALvoid Internal_alcMacOSXMixerOutputRate(const ALdouble sample_rate)
+{
+static void (*alcMacOSXMixerOutputRateProcPtr)(const ALdouble) = NULL;
+if(NULL == alcMacOSXMixerOutputRateProcPtr)
+	{
+		alcMacOSXMixerOutputRateProcPtr = alGetProcAddress((const ALCchar*) "alcMacOSXMixerOutputRate");
+}
+if(NULL != alcMacOSXMixerOutputRateProcPtr)
+	{
+alcMacOSXMixerOutputRateProcPtr(sample_rate);
+	}
+return;
+}
+ALdouble Internal_alcMacOSXGetMixerOutputRate()
+{
+static ALdouble (*alcMacOSXGetMixerOutputRateProcPtr)(void) = NULL;
+if(NULL == alcMacOSXGetMixerOutputRateProcPtr)
+	{
+		alcMacOSXGetMixerOutputRateProcPtr = alGetProcAddress((const ALCchar*) "alcMacOSXGetMixerOutputRate");
+}
+if(NULL != alcMacOSXGetMixerOutputRateProcPtr)
+	{
+return alcMacOSXGetMixerOutputRateProcPtr();
+	}
+return 0.0;
+}
+#endif
+#ifdef ALMIXER_COMPILE_WITHOUT_SDL
+	#if defined(__APPLE__)
+		#include <QuartzCore/QuartzCore.h>
+	  	#include <unistd.h>
+		static CFTimeInterval s_ticksBaseTime = 0.0;
+	#elif defined(_WIN32)
+		#define WIN32_LEAN_AND_MEAN
+		#include <windows.h>
+		#include <winbase.h>
+			LARGE_INTEGER s_hiResTicksPerSecond;
+			double s_hiResSecondsPerTick;
+			LARGE_INTEGER s_ticksBaseTime;
+	#else
+	  	#include <unistd.h>
+		#include <time.h>
+		static struct timespec s_ticksBaseTime;
+	#endif
+	static void ALmixer_InitTime()
+	{
+		#if defined(__APPLE__)
+			s_ticksBaseTime = CACurrentMediaTime();
+		#elif defined(_WIN32)
+			LARGE_INTEGER hi_res_ticks_per_second;
+			if(TRUE == QueryPerformanceFrequency(&hi_res_ticks_per_second))
+			{
+				QueryPerformanceCounter(&s_ticksBaseTime);
+				s_hiResSecondsPerTick = 1.0 / hi_res_ticks_per_second;
+			}
+			else
+			{
+				ALMixer_SetError("Windows error: High resolution clock failed.");
+				fprintf(stderr, "Windows error: High resolution clock failed. Audio will not work correctly.\n");
+			}
+		#else
+			/* clock_gettime is POSIX.1-2001 */
+			clock_gettime(CLOCK_MONOTONIC, &s_ticksBaseTime);
+		#endif
+	}
+	static ALuint ALmixer_GetTicks()
+	{
+		#if defined(__APPLE__)
+			return (ALuint)((CACurrentMediaTime()-s_ticksBaseTime)*1000.0);
+		#elif defined(_WIN32)
+			LARGE_INTEGER current_time;
+			QueryPerformanceCounter(&current_time);
+			return (ALuint)((current_time.QuadPart - s_ticksBaseTime.QuadPart) * 1000 * s_hiResSecondsPerTick);
+		#else /* assuming POSIX */
+			/* clock_gettime is POSIX.1-2001 */
+			struct timespec current_time;
+			clock_gettime(CLOCK_MONOTONIC, &current_time);
+			return (ALuint)((current_time.tv_sec - s_ticksBaseTime.tv_sec)*1000.0 + (current_time.tv_nec - s_ticksBaseTime.tv_nsec) / 1000000);
+		#endif
+	}
+	static void ALmixer_Delay(ALuint milliseconds_delay)
+	{
+		#if defined(_WIN32)
+		Sleep(milliseconds_delay);
+		#else
+		usleep(milliseconds_delay);
+		#endif
+	}
+#else
+	#include "SDL.h" /* For SDL_GetTicks(), SDL_Delay */
+	#define ALmixer_GetTicks SDL_GetTicks
+	#define ALmixer_Delay SDL_Delay
+#endif
 /* If ENABLE_PARANOID_SIGNEDNESS_CHECK is used,
 * these values will be reset on Init()
 * Consider these values Read-Only.
 #define ALMIXER_SIGNED_VALUE 127
 #define ALMIXER_UNSIGNED_VALUE 255
 #ifdef ENABLE_PARANOID_SIGNEDNESS_CHECK
-static Uint16 SIGN_TYPE_16_BIT_FORMAT = AUDIO_S16SYS;
+static ALushort SIGN_TYPE_16_BIT_FORMAT = AUDIO_S16SYS;
-static Uint16 SIGN_TYPE_8_BIT_FORMAT = AUDIO_S8;
+static ALushort SIGN_TYPE_8_BIT_FORMAT = AUDIO_S8;
 #else
-static const Uint16 SIGN_TYPE_16_BIT_FORMAT = AUDIO_S16SYS;
+static const ALushort SIGN_TYPE_16_BIT_FORMAT = AUDIO_S16SYS;
-static const Uint16 SIGN_TYPE_8_BIT_FORMAT = AUDIO_S8;
+static const ALushort SIGN_TYPE_8_BIT_FORMAT = AUDIO_S8;
 #endif
 /* This can be private instead of being in the header now that I moved
 * ALmixer_Data inside here.
 typedef struct ALmixer_Buffer_Map ALmixer_Buffer_Map;
 struct ALmixer_Data
 {
-	SDL_bool decoded_all; /* dictates different behaviors */
+	ALboolean decoded_all; /* dictates different behaviors */
-	Sint32 total_time; /* total playing time of sample (msec) */
+	ALint total_time; /* total playing time of sample (msec) */
-	Uint32 in_use; /* needed to prevent sharing for streams */
+	ALuint in_use; /* needed to prevent sharing for streams */
-	SDL_bool eof; /* flag for eof, only used for streams  */
+	ALboolean eof; /* flag for eof, only used for streams  */
-	Uint32 total_bytes; /* For predecoded */
+	ALuint total_bytes; /* For predecoded */
-	Uint32 loaded_bytes; /* For predecoded (for seek) */
+	ALuint loaded_bytes; /* For predecoded (for seek) */
 	Sound_Sample* sample; /* SDL_Sound provides the data */
 	ALuint* buffer; /* array of OpenAL buffers (at least 1 for predecoded) */
 	/* Needed for streamed buffers */
-	Uint32 max_queue_buffers; /* Max number of queue buffers */
+	ALuint max_queue_buffers; /* Max number of queue buffers */
-	Uint32 num_startup_buffers; /* Number of ramp-up buffers */
+	ALuint num_startup_buffers; /* Number of ramp-up buffers */
-	Uint32 num_buffers_in_use; /* number of buffers in use */
+	ALuint num_buffers_in_use; /* number of buffers in use */
 	/* This stuff is for streamed buffers that require data access */
 	ALmixer_Buffer_Map* buffer_map_list; /* translate ALbuffer to index
 									and holds pointer to copy of data for
 									data access */
 };
 static struct ALmixer_Channel
 {
-	SDL_bool channel_in_use;
+	ALboolean channel_in_use;
-	SDL_bool callback_update; /* For streaming determination */
+	ALboolean callback_update; /* For streaming determination */
-	SDL_bool needs_stream; /* For streaming determination */
+	ALboolean needs_stream; /* For streaming determination */
-	SDL_bool halted;
+	ALboolean halted;
-	SDL_bool paused;
+	ALboolean paused;
 	ALuint alsource;
 	ALmixer_Data* almixer_data;
-	Sint32 loops;
+	ALint loops;
-	Sint32 expire_ticks;
+	ALint expire_ticks;
-	Uint32 start_time;
+	ALuint start_time;
-	SDL_bool fade_enabled;
+	ALboolean fade_enabled;
-	Uint32 fade_expire_ticks;
+	ALuint fade_expire_ticks;
-	Uint32 fade_start_time;
+	ALuint fade_start_time;
 	ALfloat fade_inv_time;
 	ALfloat fade_start_volume;
 	ALfloat fade_end_volume;
 	ALfloat max_volume;
 	ALfloat min_volume;
 	/* Do we need other flags?
-	Uint8 *samples;
+	ALbyte *samples;
 	int volume;
 	int looping;
 	int tag;
-	Uint32 expire;
+	ALuint expire;
-	Uint32 start_time;
+	ALuint start_time;
 	Mix_Fading fading;
 	int fade_volume;
-	Uint32 fade_length;
+	ALuint fade_length;
-	Uint32 ticks_fade;
+	ALuint ticks_fade;
 	effect_info *effects;
 	*/
 } *ALmixer_Channel_List = NULL;
 struct ALmixer_Buffer_Map
 {
 	ALuint albuffer;
-	Sint32 index; /* might not need */
+	ALint index; /* might not need */
-	Uint8* data;
+	ALbyte* data;
-	Uint32 num_bytes;
+	ALuint num_bytes;
 };
 /* This will be used to find a channel if the user supplies a source */
 typedef struct Source_Map
 {
 ALuint source;
-Sint32 channel;
+ALint channel;
 } Source_Map;
 /* Keep an array of all sources with their associated channel */
 static Source_Map* Source_Map_List;
 static int Compare_Source_Map(const void* a, const void* b)
 }
 /* This is for the user defined callback via
 * ALmixer_ChannelFinished()
 */
-static void (*Channel_Done_Callback)(Sint32 channel, void* userdata) = NULL;
+static void (*Channel_Done_Callback)(ALint which_channel, ALuint al_source, ALmixer_Data* almixer_data, ALboolean finished_naturally, void* user_data) = NULL;
 static void* Channel_Done_Callback_Userdata = NULL;
-static void (*Channel_Data_Callback)(Sint32 which_channel, Uint8* data, Uint32 num_bytes, Uint32 frequency, Uint8 channels, Uint8 bit_depth, SDL_bool is_unsigned, SDL_bool decode_mode_is_predecoded, Uint32 length_in_msec, void* user_data) = NULL;
+static void (*Channel_Data_Callback)(ALint which_channel, ALuint al_source, ALbyte* data, ALuint num_bytes, ALuint frequency, ALubyte channels, ALubyte bit_depth, ALboolean is_unsigned, ALboolean decode_mode_is_predecoded, ALuint length_in_msec, void* user_data) = NULL;
 static void* Channel_Data_Callback_Userdata = NULL;
-/* I thought OpenAL seemed to lack an error number to string converter...
-* but I was wrong. Apparently they call it alGetString() which
-* breaks from the OpenGL gluGetErrorString() convention.
-* (And since the documentation for OpenAL is so bad, I didn't see
-* it until I had already written my own aluGetErrorString().)
-* So for convenience, I will just call alGetString from here.
-*/
-static const ALubyte* aluGetErrorString(ALenum error)
-{
-	return alGetString(error);
-#if 0
-	switch(error)
-	{
-		case AL_NO_ERROR:
-			return NULL;
-			break;
-		case AL_INVALID_NAME:
-			return "Invalid name (ID)";
-			break;
-		case AL_INVALID_VALUE:
-			return "Invalid value";
-			break;
-		case AL_OUT_OF_MEMORY:
-			return "Out of memory";
-			break;
-			/* Damn, even the error values are skewed between distributions */
-			/* For the Creative Labs distributions (don't know about Nvidia) */
-			/* For the Loki based distributions */
-#ifdef USING_LOKI_AL_DIST
-		case AL_ILLEGAL_ENUM:
-			return "Invalid enum value";
-			break;
-		case AL_ILLEGAL_COMMAND:
-			return "Requested operation is not valid";
-			break;
-			/*
-#elif USING_CREATIVE_AL_DIST
-			 */
-#else
-		case AL_INVALID_ENUM:
-			return "Invalid enum value";
-			break;
-		case AL_INVALID_OPERATION:
-			return "Requested operation is not valid";
-			break;
-			/*
-#elif USING_NVIDIA_AL_DIST
-			 */
-			/*
-			 case alGetEnumValue((ALubyte*)"??????");
-			 */
-#endif
-		default:
-			return "Unknown error value passed to aluGetErrorString()";
-			break;
-	}
-	/* Make compiler happy */
-	return NULL;
-#endif
-}
 static void PrintQueueStatus(ALuint source)
 {
 	ALint buffers_queued = 0;
 	);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "Error in PrintQueueStatus, Can't get buffers_queued: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 	/* Get the number of buffers processed
 	 * so we know if we need to refill
 	 */
 	alGetSourcei(
 		&buffers_processed
 	);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "Error in PrintQueueStatus, Can't get buffers_processed: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 	fprintf(stderr, "For source: %d, buffers_queued=%d, buffers_processed=%d\n",
 			source,
 			buffers_queued,
 }
-static void Init_Channel(Sint32 channel)
+static void Init_Channel(ALint channel)
 {
 fprintf(stderr, "Init channel %d\n", channel);
 	ALmixer_Channel_List[channel].channel_in_use = 0;
 	ALmixer_Channel_List[channel].callback_update = 0;
 	ALmixer_Channel_List[channel].almixer_data = NULL;
 }
 /* Quick helper function to clean up a channel
 * after it's done playing */
-static void Clean_Channel(Sint32 channel)
+static void Clean_Channel(ALint channel)
 {
 	ALenum error;
 	ALmixer_Channel_List[channel].channel_in_use = 0;
 	ALmixer_Channel_List[channel].callback_update = 0;
 	ALmixer_Channel_List[channel].needs_stream = 0;
 		ALmixer_Channel_List[channel].max_volume);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "10Testing errpr before unqueue because getting stuff, for OS X this is expected: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 	alSourcef(ALmixer_Channel_List[channel].alsource, AL_MIN_GAIN,
 		ALmixer_Channel_List[channel].min_volume);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "11Testing errpr before unqueue because getting stuff, for OS X this is expected: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 	if(ALmixer_Channel_List[channel].almixer_data != NULL)
 	{
 		if(ALmixer_Channel_List[channel].almixer_data->in_use > 0)
 /* What shoud this return?
 * 127 for signed, 255 for unsigned
 */
-static Uint8 GetSignednessValue(Uint16 format)
+static ALubyte GetSignednessValue(ALushort format)
 {
 	switch(format)
 	{
 		case AUDIO_U8:
 		case AUDIO_U16LSB:
 	}
 	return 0;
 }
-static Uint8 GetBitDepth(Uint16 format)
+static ALubyte GetBitDepth(ALushort format)
 {
-	Uint8 bit_depth = 16;
+	ALubyte bit_depth = 16;
 	switch(format)
 	{
 		case AUDIO_U8:
 		case AUDIO_S8:
 /* Need to translate between SDL/SDL_Sound audiospec
 * and OpenAL conventions */
 static ALenum TranslateFormat(Sound_AudioInfo* info)
 {
-	Uint8 bit_depth;
+	ALubyte bit_depth;
 	bit_depth = GetBitDepth(info->format);
 	if(0 == bit_depth)
 	{
 		fprintf(stderr, "Warning: Unknown bit depth. Setting to 16\n");
 /* This will compute the total playing time
 * based upon the number of bytes and audio info.
 * (In prinicple, it should compute the time for any given length)
 */
-static Uint32 Compute_Total_Time_Decomposed(Uint32 bytes_per_sample, Uint32 frequency, Uint8 channels, Uint32 total_bytes)
+static ALuint Compute_Total_Time_Decomposed(ALuint bytes_per_sample, ALuint frequency, ALubyte channels, size_t total_bytes)
 {
 	double total_sec;
-	Uint32 total_msec;
+	ALuint total_msec;
-	Uint32 bytes_per_sec;
+	ALuint bytes_per_sec;
 	if(0 == total_bytes)
 	{
 		return 0;
 	}
 	total_sec = total_bytes / (double)bytes_per_sec;
 	/* Now convert seconds to milliseconds
 		* Add .5 to the float to do rounding before the final cast
 		*/
-	total_msec = (Uint32) ( (total_sec * 1000) + 0.5 );
+	total_msec = (ALuint) ( (total_sec * 1000) + 0.5 );
 	/*
 	 fprintf(stderr, "freq=%d, bytes_per_sample=%d, channels=%d, total_msec=%d\n", frequency, bytes_per_sample, channels, total_msec);
 	*/
 	return total_msec;
 }
-static Uint32 Compute_Total_Time(Sound_AudioInfo *info, Uint32 total_bytes)
+static ALuint Compute_Total_Time(Sound_AudioInfo *info, size_t total_bytes)
 {
-	Uint32 bytes_per_sample;
+	ALuint bytes_per_sample;
 	if(0 == total_bytes)
 	{
 		return 0;
 	}
 	/* SDL has a mask trick I was not aware of. Mask the upper bits
-		* of the format, and you get 8 or 16 which is the bits per sample.
+	 * of the format, and you get 8 or 16 which is the bits per sample.
-		* Divide by 8bits_per_bytes and you get bytes_per_sample
+	 * Divide by 8bits_per_bytes and you get bytes_per_sample
-		*/
+	 * I tested this under 32-bit and 64-bit and big and little endian
-	bytes_per_sample = (Uint32) ((info->format & 0xFF) / 8);
+	 * to make sure this still works since I have since moved from
+	 * Uint32 to unspecified size types like ALuint.
+	 */
+	bytes_per_sample = (ALuint) ((info->format & 0xFF) / 8);
 	return Compute_Total_Time_Decomposed(bytes_per_sample, info->rate, info->channels, total_bytes);
 } /* End Compute_Total_Time */
+static size_t Compute_Total_Bytes_Decomposed(ALuint bytes_per_sample, ALuint frequency, ALubyte channels, ALuint total_msec)
+{
+	double total_sec;
+	ALuint bytes_per_sec;
+	size_t total_bytes;
+	if(0 >= total_msec)
+	{
+		return 0;
+	}
+	/* To compute Bytes per second, do
+		* samples_per_sec * bytes_per_sample * number_of_channels
+		*/
+	bytes_per_sec = frequency * bytes_per_sample * channels;
+	/* convert milliseconds to seconds */
+	total_sec = total_msec / 1000.0;
+	/* Now to get total bytes */
+	total_bytes = (size_t)(((double)bytes_per_sec * total_sec) + 0.5);
+/*	 fprintf(stderr, "freq=%d, bytes_per_sample=%d, channels=%d, total_msec=%d, total_bytes=%d\n", frequency, bytes_per_sample, channels, total_msec, total_bytes);
+*/
+	return total_bytes;
+}
+static size_t Compute_Total_Bytes(Sound_AudioInfo *info, ALuint total_msec)
+{
+	ALuint bytes_per_sample;
+	if(0 >= total_msec)
+	{
+		return 0;
+	}
+	/* SDL has a mask trick I was not aware of. Mask the upper bits
+	 * of the format, and you get 8 or 16 which is the bits per sample.
+	 * Divide by 8bits_per_bytes and you get bytes_per_sample
+	 * I tested this under 32-bit and 64-bit and big and little endian
+	 * to make sure this still works since I have since moved from
+	 * Uint32 to unspecified size types like ALuint.
+	 */
+	bytes_per_sample = (ALuint) ((info->format & 0xFF) / 8);
+	return Compute_Total_Bytes_Decomposed(bytes_per_sample, info->rate, info->channels, total_msec);
+}
+/* The back-end decoders seem to need to decode in quantized frame sizes.
+* So if I can pad the bytes to the next quanta, things might go more smoothly.
+*/
+static size_t Compute_Total_Bytes_With_Frame_Padding(Sound_AudioInfo *info, ALuint total_msec)
+{
+	ALuint bytes_per_sample;
+	ALuint bytes_per_frame;
+	size_t evenly_divisible_frames;
+	size_t remainder_frames;
+	size_t return_bytes;
+	size_t total_bytes = Compute_Total_Bytes(info, total_msec);
+	bytes_per_sample = (ALuint) ((info->format & 0xFF) / 8);
+	bytes_per_frame = bytes_per_sample * info->channels;
+	evenly_divisible_frames = total_bytes / bytes_per_frame;
+	remainder_frames = total_bytes % bytes_per_frame;
+	return_bytes = (evenly_divisible_frames * bytes_per_frame)  + (remainder_frames * bytes_per_frame);
+	/* Experimentally, some times I see to come up short in
+	 * actual bytes decoded and I see a second pass is needed.
+	 * I'm worried this may have additional performance implications.
+	 * Sometimes in the second pass (depending on file),
+	 * I have seen between 0 and 18 bytes.
+	 * I'm tempted to pad the bytes by some arbitrary amount.
+	 * However, I think currently the way SDL_sound is implemented,
+	 * there is a big waste of memory up front instead of per-pass,
+	 * so maybe I shouldn't worry about this.
+	 */
+	/*
+	return_bytes += 64;
+	*/
+	/*
+	 fprintf(stderr, "remainder_frames=%d, padded_total_bytes=%d\n", remainder_frames, return_bytes);
+	 */
+	 return return_bytes;
+}
 /**************** REMOVED ****************************/
 /* This was removed because I originally thought
 * OpenAL could return a pointer to the buffer data,
 */
 #ifndef DISABLE_SEEK_MEMORY_OPTIMIZATION
 static void Set_AudioInfo(Sound_AudioInfo* info, ALint frequency, ALint bits, ALint channels)
 {
-	info->rate = (Uint32)frequency;
+	info->rate = (ALuint)frequency;
-	info->channels = (Uint8)channels;
+	info->channels = (ALubyte)channels;
 	/* Not sure if it should be signed or unsigned. Hopefully
 	 * that detail won't be needed.
 	 */
 	if(8 == bits)
 		info->rate, info->channels, info->format);
 }
-static Sint32 Reconstruct_Sound_Sample(ALmixer_Data* data)
+static ALint Reconstruct_Sound_Sample(ALmixer_Data* data)
 {
 	ALenum error;
 	ALint* data_from_albuffer;
 	ALint freq;
 	ALint bits;
 	alGetError();
 	alGetBufferi(data->buffer[0], AL_FREQUENCY, &freq);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
-		ALmixer_SetError("alGetBufferi(AL_FREQUENCT): %s", aluGetErrorString(error) );
+		ALmixer_SetError("alGetBufferi(AL_FREQUENCY): %s", alGetString(error) );
 		free(data->sample);
 		data->sample = NULL;
 		return -1;
 	}
 	alGetBufferi(data->buffer[0], AL_BITS, &bits);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
-		ALmixer_SetError("alGetBufferi(AL_BITS): %s", aluGetErrorString(error) );
+		ALmixer_SetError("alGetBufferi(AL_BITS): %s", alGetString(error) );
 		free(data->sample);
 		data->sample = NULL;
 		return -1;
 	}
 	alGetBufferi(data->buffer[0], AL_CHANNELS, &channels);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
-		ALmixer_SetError("alGetBufferi(AL_CHANNELS): %s", aluGetErrorString(error) );
+		ALmixer_SetError("alGetBufferi(AL_CHANNELS): %s", alGetString(error) );
 		free(data->sample);
 		data->sample = NULL;
 		return -1;
 	}
 	alGetBufferi(data->buffer[0], AL_SIZE, &size);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
-		ALmixer_SetError("alGetBufferi(AL_SIZE): %s", aluGetErrorString(error) );
+		ALmixer_SetError("alGetBufferi(AL_SIZE): %s", alGetString(error) );
 		free(data->sample);
 		data->sample = NULL;
 		return -1;
 	}
 	alGetBufferi(data->buffer[0], AL_DATA, data_from_albuffer);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
-		ALmixer_SetError("alGetBufferi(AL_DATA): %s", aluGetErrorString(error) );
+		ALmixer_SetError("alGetBufferi(AL_DATA): %s", alGetString(error) );
 		free(data->sample);
 		data->sample = NULL;
 		return -1;
 	}
 	/* Now that we have all the attributes, we need to
 	 * allocate memory for the buffer and reconstruct
 	 * the AudioInfo attributes.
 	 */
-	data->sample->buffer = malloc(size*sizeof(Uint8));
+	data->sample->buffer = malloc(size*sizeof(ALbyte));
 	if(NULL == data->sample->buffer)
 	{
 		ALmixer_SetError("Out of memory for sample->buffer");
 		free(data->sample);
 		data->sample = NULL;
 #endif /* End DISABLE_SEEK_MEMORY_OPTIMIZATION */
 #endif
 /*************** END REMOVED *************************/
-static void Invoke_Channel_Done_Callback(Sint32 channel)
+static void Invoke_Channel_Done_Callback(ALint which_channel, ALboolean did_finish_naturally)
 {
 	if(NULL == Channel_Done_Callback)
 	{
 		return;
 	}
-	Channel_Done_Callback(channel, Channel_Done_Callback_Userdata);
+	Channel_Done_Callback(which_channel, ALmixer_Channel_List[which_channel].alsource, ALmixer_Channel_List[which_channel].almixer_data, did_finish_naturally, Channel_Done_Callback_Userdata);
 }
-static Sint32 LookUpBuffer(ALuint buffer, ALmixer_Buffer_Map* buffer_map_list, Uint32 num_items_in_list)
+static ALint LookUpBuffer(ALuint buffer, ALmixer_Buffer_Map* buffer_map_list, ALuint num_items_in_list)
 {
 	/* Only the first value is used for the key */
 	ALmixer_Buffer_Map key = { 0, 0, NULL, 0 };
 	ALmixer_Buffer_Map* found_item = NULL;
 	key.albuffer = buffer;
 */
 /*
 * channels: 1 for mono, 2 for stereo
 *
 */
-static void Invoke_Channel_Data_Callback(Sint32 which_channel, Uint8* data, Uint32 num_bytes, Uint32 frequency, Uint8 channels, Uint16 format, SDL_bool decode_mode_is_predecoded)
+static void Invoke_Channel_Data_Callback(ALint which_channel, ALbyte* data, ALuint num_bytes, ALuint frequency, ALubyte channels, ALushort format, ALboolean decode_mode_is_predecoded)
 {
-	SDL_bool is_unsigned;
+	ALboolean is_unsigned;
-	Uint8 bits_per_sample = GetBitDepth(format);
+	ALubyte bits_per_sample = GetBitDepth(format);
-	Uint32 bytes_per_sample;
+	ALuint bytes_per_sample;
-	Uint32 length_in_msec;
+	ALuint length_in_msec;
 	if(GetSignednessValue(format) == ALMIXER_UNSIGNED_VALUE)
 	{
 		is_unsigned = 1;
 	}
 	else
 	{
 		is_unsigned = 0;
 	}
-	bytes_per_sample = (Uint32) (bits_per_sample / 8);
+	bytes_per_sample = (ALuint) (bits_per_sample / 8);
 	length_in_msec = Compute_Total_Time_Decomposed(bytes_per_sample, frequency, channels, num_bytes);
 /*
 	fprintf(stderr, "%x %x %x %x, bytes=%d, whichchan=%d, freq=%d, channels=%d\n", data[0], data[1], data[2], data[3], num_bytes, channels, frequency, channels);
 		return;
 	}
 	/*
 	 * Channel_Data_Callback(which_channel, data, num_bytes, frequency, channels, GetBitDepth(format), format, decode_mode_is_predecoded);
 	*/
-	Channel_Data_Callback(which_channel, data, num_bytes, frequency, channels, bits_per_sample, is_unsigned, decode_mode_is_predecoded, length_in_msec, Channel_Data_Callback_Userdata);
+	Channel_Data_Callback(which_channel, ALmixer_Channel_List[which_channel].alsource, data, num_bytes, frequency, channels, bits_per_sample, is_unsigned, decode_mode_is_predecoded, length_in_msec, Channel_Data_Callback_Userdata);
 }
-static void Invoke_Predecoded_Channel_Data_Callback(Sint32 channel, ALmixer_Data* data)
+static void Invoke_Predecoded_Channel_Data_Callback(ALint channel, ALmixer_Data* data)
 {
 	if(NULL == data->sample)
 	{
 		return;
 	}
 	/* The buffer position is complicated because if the current data was seeked,
 	 * we must adjust the buffer to the seek position
 	 */
 	Invoke_Channel_Data_Callback(channel,
-		(((Uint8*) data->sample->buffer) + (data->total_bytes - data->loaded_bytes) ),
+		(((ALbyte*) data->sample->buffer) + (data->total_bytes - data->loaded_bytes) ),
 		data->loaded_bytes,
 		data->sample->desired.rate,
 		data->sample->desired.channels,
 		data->sample->desired.format,
-		SDL_TRUE
+		AL_TRUE
 	);
 }
-static void Invoke_Streamed_Channel_Data_Callback(Sint32 channel, ALmixer_Data* data, ALuint buffer)
+static void Invoke_Streamed_Channel_Data_Callback(ALint channel, ALmixer_Data* data, ALuint buffer)
 {
-	Sint32 index;
+	ALint index;
 	if(NULL == data->buffer_map_list)
 	{
 		return;
 	}
 	index = LookUpBuffer(buffer, data->buffer_map_list, data->max_queue_buffers);
 		data->buffer_map_list[index].data,
 		data->buffer_map_list[index].num_bytes,
 		data->sample->desired.rate,
 		data->sample->desired.channels,
 		data->sample->desired.format,
-		SDL_FALSE
+		AL_FALSE
 	);
 }
 /* From SDL_Sound's playsound. Converts milliseconds to byte positions.
 * This is needed for seeking on predecoded samples
 */
-static Uint32 Convert_Msec_To_Byte_Pos(Sound_AudioInfo *info, Uint32 ms)
+static ALuint Convert_Msec_To_Byte_Pos(Sound_AudioInfo *info, ALuint ms)
 {
 	float frames_per_ms;
-	Uint32 frame_offset;
+	ALuint frame_offset;
-	Uint32 frame_size;
+	ALuint frame_size;
 	fprintf(stderr, "In convert\n" );
 	if(info == NULL)
 	{
 		fprintf(stderr, "Error, info is NULL\n");
 	}
 	fprintf(stderr, "The rate=%d\n", info->rate);
 	/* "frames" == "sample frames" */
 	frames_per_ms = ((float) info->rate) / 1000.0f;
 	fprintf(stderr, "%f\n", frames_per_ms);
-	frame_offset = (Uint32) (frames_per_ms * ((float) ms));
+	frame_offset = (ALuint) (frames_per_ms * ((float) ms));
 	fprintf(stderr, "%d\n", frame_offset);
-	frame_size = (Uint32) ((info->format & 0xFF) / 8) * info->channels;
+	frame_size = (ALuint) ((info->format & 0xFF) / 8) * info->channels;
 	fprintf(stderr, "%d\n", frame_size);
 	return(frame_offset * frame_size);
 } /* cvtMsToBytePos */
-static Sint32 Set_Predecoded_Seek_Position(ALmixer_Data* data, Uint32 byte_position)
+static ALint Set_Predecoded_Seek_Position(ALmixer_Data* data, ALuint byte_position)
 {
 	ALenum error;
 	/* clear error */
 	alGetError();
 	/* In case the below thing doesn't work,
 	 * just rewind the whole thing.
 	 *
 		alBufferData(data->buffer[0],
 			TranslateFormat(&data->sample->desired),
-			 (Uint8*) data->sample->buffer,
+			 (ALbyte*) data->sample->buffer,
 			 data->total_bytes,
 			data->sample->desired.rate
 		);
 	*/
 		 * and it still hung. 4 didn't hang, but I got a clip
 		 * artifact. 8 seemed to work okay.
 		 */
 		alBufferData(data->buffer[0],
 			TranslateFormat(&data->sample->desired),
-			 (((Uint8*) data->sample->buffer) + (data->total_bytes - 8) ),
+			 (((ALbyte*) data->sample->buffer) + (data->total_bytes - 8) ),
 			 8,
 			data->sample->desired.rate
 		);
 		if( (error = alGetError()) != AL_NO_ERROR)
 		{
-			ALmixer_SetError("Can't seek past end and alBufferData failed: %s\n", aluGetErrorString(error));
+			ALmixer_SetError("Can't seek past end and alBufferData failed: %s\n", alGetString(error));
 			return -1;
 		}
 		/* Need to set the loaded_bytes field because I don't trust the OpenAL
 		 * query command to work because I don't know if it will mutilate the
 		 * size for its own purposes or return the original size
 		return 0;
 	}
 	alBufferData(data->buffer[0],
 		TranslateFormat(&data->sample->desired),
-		&(((Uint8*)data->sample->buffer)[byte_position]),
+		&(((ALbyte*)data->sample->buffer)[byte_position]),
 		data->total_bytes - byte_position,
 		data->sample->desired.rate
 	);
 	if( (error = alGetError()) != AL_NO_ERROR)
 	{
-		ALmixer_SetError("alBufferData failed: %s\n", aluGetErrorString(error));
+		ALmixer_SetError("alBufferData failed: %s\n", alGetString(error));
 		return -1;
 	}
 	/* Need to set the loaded_bytes field because I don't trust the OpenAL
 	 * query command to work because I don't know if it will mutilate the
 	 * size for its own purposes or return the original size
 }
 /* Because we have multiple queue buffers and OpenAL won't let
 * us access them, we need to keep copies of each buffer around
 */
-static Sint32 CopyDataToAccessBuffer(ALmixer_Data* data, Uint32 num_bytes, ALuint buffer)
+static ALint CopyDataToAccessBuffer(ALmixer_Data* data, ALuint num_bytes, ALuint buffer)
 {
-	Sint32 index;
+	ALint index;
 	/* We only want to copy if access_data is true.
 	 * This is determined by whether memory has been
 	 * allocated in the buffer_map_list or not
 	 */
 	if(NULL == data->buffer_map_list)
 /* For streamed data, gets more data
 * and prepares it in the active Mix_chunk
 */
-static Uint32 GetMoreData(ALmixer_Data* data, ALuint buffer)
+static ALuint GetMoreData(ALmixer_Data* data, ALuint buffer)
 {
-	Uint32 bytes_decoded;
+	ALuint bytes_decoded;
 	ALenum error;
 	if(NULL == data)
 	{
 		ALmixer_SetError("Cannot GetMoreData() because ALmixer_Data* is NULL\n");
 		return 0;
 		Sound_FreeSample(data->sample);
 		*/
 		return 0;
 	}
+/*	fprintf(stderr, "GetMoreData bytes_decoded=%d\n", bytes_decoded); */
 	/* Don't forget to add check for EOF */
 	/* Will return 0 bytes and pass the buck to check sample->flags */
 	if(0 == bytes_decoded)
 	{
-#if 1
+		data->eof = 1;
+#if 0
 fprintf(stderr, "Hit eof while trying to buffer\n");
-		data->eof = 1;
 		if(data->sample->flags & SOUND_SAMPLEFLAG_EOF)
 		{
 			fprintf(stderr, "\tEOF flag\n");
 		}
 		if(data->sample->flags & SOUND_SAMPLEFLAG_CANSEEK)
 	 * (like Ogg), then you will get breakup in between
 	 * packets.
 	 */
 	if( (bytes_decoded) < data->sample->buffer_size)
 	{
-		Uint8 bit_depth;
+		ALubyte bit_depth;
-		Uint8 signedness_value;
+		ALubyte signedness_value;
 		int silence_value;
 		/* Crap, memset value needs to be the "silent" value,
 		 * but it will differ for signed/unsigned and bit depth
 		 */
 		bit_depth = GetBitDepth(data->sample->desired.format);
 		 * silence_value.
 		 * I don't think I have to worry about endian issues for
 		 * this part since the data is for internal use only
 		 * at this point.
 		 */
-		memset( &( ((Uint8*)(data->sample->buffer))[bytes_decoded] ), silence_value, data->sample->buffer_size - bytes_decoded);
+		memset( &( ((ALbyte*)(data->sample->buffer))[bytes_decoded] ), silence_value, data->sample->buffer_size - bytes_decoded);
 		/* Now reset the bytes_decoded to reflect the entire
 		 * buffer to tell alBufferData what our full size is.
 		 */
 	fprintf(stderr, "ALTERED bytes decoded for silence: Original end was %d\n", bytes_decoded);
 		bytes_decoded = data->sample->buffer_size;
 		bytes_decoded,
 		data->sample->desired.rate
 	);
 	if( (error = alGetError()) != AL_NO_ERROR)
 	{
-		ALmixer_SetError("alBufferData failed: %s\n", aluGetErrorString(error));
+		ALmixer_SetError("alBufferData failed: %s\n", alGetString(error));
 		return 0;
 	}
 	/* If we need to, copy the data also to the access area
 	 * (the function will do the check for us)
 /********************  EXPERIEMENT ****************************
 * Test function to force maximum buffer filling during loops
 * REMOVE LATER
 *********************************************/
 #if 0
-static Sint32 GetMoreData2(ALmixer_Data* data, ALuint buffer)
+static ALint GetMoreData2(ALmixer_Data* data, ALuint buffer)
 {
-	Sint32 bytes_decoded;
+	ALint bytes_decoded;
 	ALenum error;
 	if(NULL == data)
 	{
 		ALmixer_SetError("Cannot GetMoreData() because ALmixer_Data* is NULL\n");
 		return -1;
 		int retval;
 		memcpy(tempbuffer1, data->sample->buffer, bytes_decoded);
 		retval = Sound_SetBufferSize(data->sample, 16384-bytes_decoded);
 		if(retval == 1)
 		{
-			Uint32 new_bytes;
+			ALuint new_bytes;
 			Sound_Rewind(data->sample);
 			new_bytes = Sound_Decode(data->sample);
 			fprintf(stderr, "Orig bytes: %d, Make up bytes_decoded=%d, total=%d\n", bytes_decoded, new_bytes, new_bytes+bytes_decoded);
 			memcpy(tempbuffer2, data->sample->buffer, new_bytes);
 		bytes_decoded,
 		data->sample->desired.rate
 	);
 	if( (error = alGetError()) != AL_NO_ERROR)
 	{
-		ALmixer_SetError("alBufferData failed: %s\n", aluGetErrorString(error));
+		ALmixer_SetError("alBufferData failed: %s\n", alGetString(error));
 		return -1;
 	}
 fprintf(stderr, "GetMoreData2222 returning %d bytes decoded\n", bytes_decoded);
 	return bytes_decoded;
 /* This function will look up the source for the corresponding channel */
 /* Must return 0 on error instead of -1 because of unsigned int */
-static ALuint Internal_GetSource(Sint32 channel)
+static ALuint Internal_GetSource(ALint channel)
 {
-	Sint32 i;
+	ALint i;
 	/* Make sure channel is in bounds */
 	if(channel >= Number_of_Channels_global)
 	{
 		ALmixer_SetError("Requested channel (%d) exceeds maximum channel (%d) because only %d channels are allocated", channel, Number_of_Channels_global-1, Number_of_Channels_global);
 		return 0;
 	/* Last case: Return the source for the channel */
 	return ALmixer_Channel_List[channel].alsource;
 }
 /* This function will look up the channel for the corresponding source */
-static Sint32 Internal_GetChannel(ALuint source)
+static ALint Internal_GetChannel(ALuint source)
 {
-	Sint32 i;
+	ALint i;
 	/* Only the first value is used for the key */
 	Source_Map key = { 0, 0 };
 	Source_Map* found_item = NULL;
 	key.source = source;
 /* This function will find the first available channel (not in use)
 * from the specified start channel. Reserved channels to not qualify
 * as available.
 */
-static Sint32 Internal_FindFreeChannel(Sint32 start_channel)
+static ALint Internal_FindFreeChannel(ALint start_channel)
 {
 	/* Start at the number of reserved so we skip over
 	 * all the reserved channels.
 	 */
-	Sint32 i = Number_of_Reserve_Channels_global;
+	ALint i = Number_of_Reserve_Channels_global;
 	/* Quick check to see if we're out of bounds */
 	if(start_channel >= Number_of_Channels_global)
 	{
 		return -1;
 	}
 	}
 	/* If we get here, all sources are in use */
 	return -1;
 }
+/* Will return the number of channels halted
+* or 0 for error
+*/
+static ALint Internal_HaltChannel(ALint channel, ALboolean did_finish_naturally)
+{
+	ALint retval = 0;
+	ALint counter = 0;
+	ALenum error;
+	ALint buffers_still_queued;
+	ALint buffers_processed;
+	if(channel >= Number_of_Channels_global)
+	{
+		ALmixer_SetError("Cannot halt channel %d because it exceeds maximum number of channels (%d)\n", channel, Number_of_Channels_global);
+		return -1;
+	}
+	/* If the user specified a specific channel */
+	if(channel >= 0)
+	{
+		fprintf(stderr, "Halt on channel %d\n", channel);
+		/* only need to process channel if in use */
+		if(ALmixer_Channel_List[channel].channel_in_use)
+		{
+			alSourceStop(ALmixer_Channel_List[channel].alsource);
+			if((error = alGetError()) != AL_NO_ERROR)
+			{
+				fprintf(stderr, "14Testing error: %s\n",
+					alGetString(error));
+			}
+			/* Here's the situation. My old method of using
+			 * alSourceUnqueueBuffers() seemed to be invalid in light
+			 * of all the problems I suffered through with getting
+			 * the CoreData backend to work with this code.
+			 * As such, I'm changing all the code to set the buffer to
+			 * AL_NONE. Furthermore, the queued vs. non-queued issue
+			 * doesn't need to apply here. For non-queued, Loki,
+			 * Creative Windows, and CoreAudio seem to leave the
+			 * buffer queued (Old Mac didn't.) For queued, we need to
+			 * remove the processed buffers and force remove the
+			 * still-queued buffers.
+			 */
+			fprintf(stderr, "Halt on channel %d, channel in use\n", channel);
+			alGetSourcei(
+				ALmixer_Channel_List[channel].alsource,
+				AL_BUFFERS_QUEUED, &buffers_still_queued
+			);
+			if((error = alGetError()) != AL_NO_ERROR)
+			{
+				fprintf(stderr, "17Testing Error with buffers_still_queued: %s",
+					alGetString(error));
+				ALmixer_SetError("Failed detecting still queued buffers: %s",
+					alGetString(error) );
+				retval = -1;
+			}
+			alGetSourcei(
+				ALmixer_Channel_List[channel].alsource,
+				AL_BUFFERS_PROCESSED, &buffers_processed
+			);
+			if((error = alGetError()) != AL_NO_ERROR)
+			{
+				fprintf(stderr, "17Testing Error with buffers_processed: %s",
+					alGetString(error));
+				ALmixer_SetError("Failed detecting still processed buffers: %s",
+					alGetString(error) );
+				retval = -1;
+			}
+			/* If either of these is greater than 0, it means we need
+			 * to clear the source
+			 */
+			if((buffers_still_queued > 0) || (buffers_processed > 0))
+			{
+				alSourcei(ALmixer_Channel_List[channel].alsource,
+					AL_BUFFER,
+					AL_NONE);
+				if((error = alGetError()) != AL_NO_ERROR)
+				{
+					fprintf(stderr, "17Testing Error with clearing buffer from source: %s",
+						alGetString(error));
+					ALmixer_SetError("Failed to clear buffer from source: %s",
+						alGetString(error) );
+					retval = -1;
+				}
+			}
+			ALmixer_Channel_List[channel].almixer_data->num_buffers_in_use  = 0;
+			Clean_Channel(channel);
+			Is_Playing_global--;
+			/* Launch callback for consistency? */
+			Invoke_Channel_Done_Callback(channel, did_finish_naturally);
+			counter++;
+		}
+	}
+	/* The user wants to halt all channels */
+	else
+	{
+		ALint i;
+		for(i=0; i<Number_of_Channels_global; i++)
+		{
+			fprintf(stderr, "Halting channel %d\n", i);
+			fprintf(stderr, "in use %d\n", ALmixer_Channel_List[i].channel_in_use );
+			/* only need to process channel if in use */
+			if(ALmixer_Channel_List[i].channel_in_use)
+			{
+				fprintf(stderr, "SourceStop %d\n", i);
+				alSourceStop(ALmixer_Channel_List[i].alsource);
+				if((error = alGetError()) != AL_NO_ERROR)
+				{
+					fprintf(stderr, "19Testing error: %s\n",
+						alGetString(error));
+				}
+				/* Here's the situation. My old method of using
+				 * alSourceUnqueueBuffers() seemed to be invalid in light
+				 * of all the problems I suffered through with getting
+				 * the CoreData backend to work with this code.
+				 * As such, I'm changing all the code to set the buffer to
+				 * AL_NONE. Furthermore, the queued vs. non-queued issue
+				 * doesn't need to apply here. For non-queued, Loki,
+				 * Creative Windows, and CoreAudio seem to leave the
+				 * buffer queued (Old Mac didn't.) For queued, we need to
+				 * remove the processed buffers and force remove the
+				 * still-queued buffers.
+				 */
+				fprintf(stderr, "Halt on channel %d, channel in use\n", channel);
+				alGetSourcei(
+					ALmixer_Channel_List[i].alsource,
+					AL_BUFFERS_QUEUED, &buffers_still_queued
+				);
+				if((error = alGetError()) != AL_NO_ERROR)
+				{
+					fprintf(stderr, "17Testing Error with buffers_still_queued: %s",
+						alGetString(error));
+					ALmixer_SetError("Failed detecting still queued buffers: %s",
+						alGetString(error) );
+					retval = -1;
+				}
+				alGetSourcei(
+					ALmixer_Channel_List[i].alsource,
+					AL_BUFFERS_PROCESSED, &buffers_processed
+				);
+				if((error = alGetError()) != AL_NO_ERROR)
+				{
+					fprintf(stderr, "17Testing Error with buffers_processed: %s",
+						alGetString(error));
+					ALmixer_SetError("Failed detecting still processed buffers: %s",
+						alGetString(error) );
+					retval = -1;
+				}
+				/* If either of these is greater than 0, it means we need
+				 * to clear the source
+				 */
+				if((buffers_still_queued > 0) || (buffers_processed > 0))
+				{
+					alSourcei(ALmixer_Channel_List[i].alsource,
+						AL_BUFFER,
+						AL_NONE);
+					if((error = alGetError()) != AL_NO_ERROR)
+					{
+						fprintf(stderr, "17Testing Error with clearing buffer from source: %s",
+							alGetString(error));
+						ALmixer_SetError("Failed to clear buffer from source: %s",
+							alGetString(error) );
+						retval = -1;
+					}
+				}
+				ALmixer_Channel_List[i].almixer_data->num_buffers_in_use  = 0;
+	fprintf(stderr, "Clean channel %d\n", i);
+				Clean_Channel(i);
+				Is_Playing_global--;
+				/* Launch callback for consistency? */
+	fprintf(stderr, "Callback%d\n", i);
+				Invoke_Channel_Done_Callback(i, did_finish_naturally);
+				/* Increment the counter */
+				counter++;
+			}
+			/* Let's halt everything just in case there
+			 * are bugs.
+			 */
+			/*
+			else
+			{
+				alSourceStop(ALmixer_Channel_List[channel].alsource);
+				/ * Can't clean because the in_use counter for
+				 * data will get messed up * /
+				Clean_Channel(channel);
+			}
+			*/
+			/* Just in case */
+			Is_Playing_global = 0;
+		}
+	}
+	if(-1 == retval)
+	{
+		return -1;
+	}
+	return counter;
+}
+/* Will return the source halted or the total number of channels
+* if all were halted or 0 for error
+*/
+static ALint Internal_HaltSource(ALuint source, ALboolean did_finish_naturally)
+{
+	ALint channel;
+	if(0 == source)
+	{
+		/* Will return the number of sources halted */
+		return Internal_HaltChannel(-1, did_finish_naturally);
+	}
+	channel = Internal_GetChannel(source);
+	if(-1 == channel)
+	{
+		ALmixer_SetError("Cannot halt source: %s", ALmixer_GetError());
+		return -1;
+	}
+	return Internal_HaltChannel(channel, did_finish_naturally);
+}
 /* Note: Behaves, almost like SDL_mixer, but keep in mind
 * that there is no "music" channel anymore, so 0
 * Also, callbacks for deleted channels will not be called.
 * I really need to do error checking, for realloc and
 * GenSources, but reversing the damage is too painful
 * for me to think about at the moment, so it's not in here.
 */
-static Sint32 Internal_AllocateChannels(Sint32 numchans)
+static ALint Internal_AllocateChannels(ALint numchans)
 {
 	ALenum error;
 	int i;
 	/* Return info */
 	if(numchans < 0)
 			/* Generate a new source and associate it with the channel */
 			alGenSources(1, &ALmixer_Channel_List[i].alsource);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "12Testing errpr before unqueue because getting stuff, for OS X this is expected: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 			/* Copy the source so the SourceMap has it too */
 			Source_Map_List[i].source = ALmixer_Channel_List[i].alsource;
 			Source_Map_List[i].channel = i;
 			/* Clean the channel because there are some things that need to
 	if(numchans < Number_of_Channels_global)
 	{
 		for(i=numchans; i<Number_of_Channels_global; i++)
 		{
 			/* Halt the channel */
-			ALmixer_HaltChannel(i);
+			Internal_HaltChannel(i, AL_FALSE);
 			/* Delete source associated with the channel */
 			alDeleteSources(1, &ALmixer_Channel_List[i].alsource);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "13Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 		}
 		/* Not sure how safe this is, but SDL_mixer does it
 	/* Shouldn't ever reach here */
 	return -1;
 }
-static Sint32 Internal_ReserveChannels(Sint32 num)
+static ALint Internal_ReserveChannels(ALint num)
 {
 	/* Can't reserve more than the max num of channels */
 	/* Actually, I'll allow it for people who just want to
 	 * set the value really high to effectively disable
 	 * auto-assignment
 	Number_of_Reserve_Channels_global = num;
 	return Number_of_Reserve_Channels_global;
 }
+/* This will rewind the SDL_Sound sample for streamed
+* samples and start buffering up the data for the next
+* playback. This may require samples to be halted
-static Sint32 Internal_PlayChannelTimed(Sint32 channel, ALmixer_Data* data, Sint32 loops, Sint32 ticks)
+*/
+static ALint Internal_RewindData(ALmixer_Data* data)
+{
+	ALint retval = 0;
+	/*
+	ALint bytes_returned;
+	ALint i;
+	*/
+	if(NULL == data)
+	{
+		ALmixer_SetError("Cannot rewind because data is NULL\n");
+		return -1;
+	}
+	/* Might have to require Halt */
+	/* Okay, we assume Halt or natural stop has already
+	 * cleared the data buffers
+	 */
+	if(data->in_use)
+	{
+		fprintf(stderr, "Warning sample is in use. May not be able to rewind\n");
+		/*
+		ALmixer_SetError("Data is in use. Cannot rewind unless all sources using the data are halted\n");
+		return -1;
+		*/
+	}
+	/* Because Seek can alter things even in predecoded data,
+	 * decoded data must also be rewound
+	 */
+	if(data->decoded_all)
+	{
+		data->eof = 0;
+#if 0
+#if defined(DISABLE_PREDECODED_SEEK)
+		/* Since we can't seek predecoded stuff, it should be rewound */
+		return 0;
+#elif !defined(DISABLE_SEEK_MEMORY_OPTIMIZATION)
+		/* This case is if the Sound_Sample has been deleted.
+		 * It assumes the data is already at the beginning.
+		 */
+		if(NULL == data->sample)
+		{
+			return 0;
+		}
+		/* Else, the sample has already been reallocated,
+		 * and we can fall to normal behavior
+		 */
+#endif
+#endif
+		/* If access_data, was enabled, the sound sample
+		 * still exists and we can do stuff.
+		 * If it's NULL, we can't do anything, but
+		 * it should already be "rewound".
+		 */
+		if(NULL == data->sample)
+		{
+			return 0;
+		}
+		/* Else, the sample has already been reallocated,
+		 * and we can fall to normal behavior
+		 */
+		Set_Predecoded_Seek_Position(data, 0);
+	/*
+		return data->total_bytes;
+	*/
+		return 0;
+	}
+	/* Remaining stuff for streamed data */
+fprintf(stderr, "Rewinding for stream\n");
+	data->eof = 0;
+	retval = Sound_Rewind(data->sample);
+	if(0 == retval)
+	{
+		ALmixer_SetError( Sound_GetError() );
+		return -1;
+	}
+fprintf(stderr, "Rewinding succeeded\n");
+fprintf(stderr, "calling GetMoreData for Rewinding for stream\n");
+#if 0
+	/* Clear error */
+	alGetError();
+	for(i=0; i<data->num_buffers; i++)
+	{
+		bytes_returned = GetMoreData(data, data->buffer[i]);
+		if(-1 == bytes_returned)
+		{
+			return -1;
+		}
+		else if(0 == bytes_returned)
+		{
+			return -1;
+		}
+		retval += bytes_returned;
+	}
+#endif
+fprintf(stderr, "end Rewinding for stream\n");
+	return retval;
+}
+static ALint Internal_RewindChannel(ALint channel)
+{
+	ALint retval = 0;
+	ALenum error;
+	ALint state;
+	if(channel >= Number_of_Channels_global)
+	{
+		ALmixer_SetError("Cannot rewind channel %d because it exceeds maximum number of channels (%d)\n", channel, Number_of_Channels_global);
+		return -1;
+	}
+	if((error = alGetError()) != AL_NO_ERROR)
+	{
+		fprintf(stderr, "24Testing error: %s\n",
+			alGetString(error));
+	}
+	/* Clear error */
+	alGetError();
+	/* If the user specified a specific channel */
+	if(channel >= 0)
+	{
+		/* only need to process channel if in use */
+		if(ALmixer_Channel_List[channel].channel_in_use)
+		{
+			/* What should I do? Do I just rewind the channel
+			 * or also rewind the data? Since the data is
+			 * shared, let's make it the user's responsibility
+			 * to rewind the data.
+			 */
+			if(ALmixer_Channel_List[channel].almixer_data->decoded_all)
+			{
+				alGetSourcei(
+					ALmixer_Channel_List[channel].alsource,
+					AL_SOURCE_STATE, &state
+				);
+	if((error = alGetError()) != AL_NO_ERROR)
+	{
+		fprintf(stderr, "25Testing error: %s\n",
+			alGetString(error));
+	}
+				alSourceRewind(ALmixer_Channel_List[channel].alsource);
+				if((error = alGetError()) != AL_NO_ERROR)
+				{
+					ALmixer_SetError("%s",
+						alGetString(error) );
+					retval = -1;
+				}
+				/* Need to resume playback if it was originally playing */
+				if(AL_PLAYING == state)
+				{
+					alSourcePlay(ALmixer_Channel_List[channel].alsource);
+					if((error = alGetError()) != AL_NO_ERROR)
+					{
+						ALmixer_SetError("%s",
+							alGetString(error) );
+						retval = -1;
+					}
+				}
+				else if(AL_PAUSED == state)
+				{
+					/* HACK: The problem is that when paused, after
+					 * the Rewind, I can't get it off the INITIAL
+					 * state without restarting
+					 */
+					alSourcePlay(ALmixer_Channel_List[channel].alsource);
+	if((error = alGetError()) != AL_NO_ERROR)
+	{
+		fprintf(stderr, "25Testing error: %s\n",
+			alGetString(error));
+	}
+					alSourcePause(ALmixer_Channel_List[channel].alsource);
+					if((error = alGetError()) != AL_NO_ERROR)
+					{
+						ALmixer_SetError("%s",
+							alGetString(error) );
+						retval = -1;
+					}
+				}
+			}
+			else
+			{
+				/* Streamed data is different. Rewinding the channel
+				 * does no good. Rewinding the data will have an
+				 * effect, but it will be lagged based on how
+				 * much data is queued. Recommend users call Halt
+				 * before rewind if they want immediate results.
+				 */
+				retval = Internal_RewindData(ALmixer_Channel_List[channel].almixer_data);
+			}
+		}
+	}
+	/* The user wants to rewind all channels */
+	else
+	{
+		ALint i;
+		for(i=0; i<Number_of_Channels_global; i++)
+		{
+	fprintf(stderr, "in use %d\n", ALmixer_Channel_List[i].channel_in_use );
+			/* only need to process channel if in use */
+			if(ALmixer_Channel_List[i].channel_in_use)
+			{
+				/* What should I do? Do I just rewind the channel
+				 * or also rewind the data? Since the data is
+				 * shared, let's make it the user's responsibility
+				 * to rewind the data.
+				 */
+				if(ALmixer_Channel_List[i].almixer_data->decoded_all)
+				{
+					alGetSourcei(
+						ALmixer_Channel_List[i].alsource,
+						AL_SOURCE_STATE, &state
+					);
+	if((error = alGetError()) != AL_NO_ERROR)
+	{
+		fprintf(stderr, "26Testing error: %s\n",
+			alGetString(error));
+	}
+					alSourceRewind(ALmixer_Channel_List[i].alsource);
+					if((error = alGetError()) != AL_NO_ERROR)
+					{
+						ALmixer_SetError("%s",
+							alGetString(error) );
+						retval = -1;
+					}
+					/* Need to resume playback if it was originally playing */
+					if(AL_PLAYING == state)
+					{
+						alSourcePlay(ALmixer_Channel_List[i].alsource);
+						if((error = alGetError()) != AL_NO_ERROR)
+						{
+							ALmixer_SetError("%s",
+								alGetString(error) );
+							retval = -1;
+						}
+					}
+					else if(AL_PAUSED == state)
+					{
+						/* HACK: The problem is that when paused, after
+						 * the Rewind, I can't get it off the INITIAL
+						 * state without restarting
+						 */
+						alSourcePlay(ALmixer_Channel_List[i].alsource);
+	if((error = alGetError()) != AL_NO_ERROR)
+	{
+		fprintf(stderr, "27Testing error: %s\n",
+			alGetString(error));
+	}
+						alSourcePause(ALmixer_Channel_List[i].alsource);
+						if((error = alGetError()) != AL_NO_ERROR)
+						{
+							ALmixer_SetError("%s",
+								alGetString(error) );
+							retval = -1;
+						}
+					}
+				}
+				else
+				{
+					/* Streamed data is different. Rewinding the channel
+					 * does no good. Rewinding the data will have an
+					 * effect, but it will be lagged based on how
+					 * much data is queued. Recommend users call Halt
+					 * before rewind if they want immediate results.
+					 */
+					retval = Internal_RewindData(ALmixer_Channel_List[i].almixer_data);
+				}
+			}
+		}
+	}
+	return retval;
+}
+static ALint Internal_RewindSource(ALuint source)
+{
+	ALint channel;
+	if(0 == source)
+	{
+		return Internal_RewindChannel(-1) + 1;
+	}
+	channel = Internal_GetChannel(source);
+	if(-1 == channel)
+	{
+		ALmixer_SetError("Cannot rewind source: %s", ALmixer_GetError());
+		return 0;
+	}
+	return Internal_RewindChannel(channel) + 1;
+}
+static ALint Internal_PlayChannelTimed(ALint channel, ALmixer_Data* data, ALint loops, ALint ticks)
 {
 	ALenum error;
 	int ret_flag = 0;
 	if(NULL == data)
 	{
 		 * This mainly affects streamed files,
 	 	 * so the check is placed here
 		 */
 		if(data->eof)
 		{
-			if( -1 == ALmixer_RewindData(data) )
+			if( -1 == Internal_RewindData(data) )
 			{
 				ALmixer_SetError("Can't play sample because it is at EOF and cannot rewind");
 				return -1;
 			}
 		}
 	}
 	/* We need to provide the user with the first available channel */
 	if(-1 == channel)
 	{
-		Sint32 i;
+		ALint i;
 		for(i=Number_of_Reserve_Channels_global; i<Number_of_Channels_global; i++)
 		{
 			if(0 == ALmixer_Channel_List[i].channel_in_use)
 			{
 				channel = i;
 	/* Shouldn't need updating until a callback is fired
 	 * (assuming that we call Play in this function
 	 */
 	ALmixer_Channel_List[channel].needs_stream = 0;
 	ALmixer_Channel_List[channel].almixer_data = data;
-	ALmixer_Channel_List[channel].start_time = SDL_GetTicks();
+	ALmixer_Channel_List[channel].start_time = ALmixer_GetTicks();
 	/* If user entered -1 (or less), set to -1 */
 	if(ticks < 0)
 	{
 		ALmixer_Channel_List[channel].expire_ticks = -1;
 		alSourcei(ALmixer_Channel_List[channel].alsource, AL_LOOPING, AL_FALSE);
 	}
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "13Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 #if 0
 	/* Because of the corner case, predecoded
 	 * files must add +1 to the loops.
 			AL_BUFFER,
 			data->buffer[0]);
 		if((error = alGetError()) != AL_NO_ERROR)
 		{
 			ALmixer_SetError("Could not bind data to source: %s",
-				aluGetErrorString(error) );
+				alGetString(error) );
 			Clean_Channel(channel);
 			return -1;
 		}
 		/* Make data available if access_data is enabled */
 	}
 	else
 	{
 		/* Need to use the streaming buffer for binding */
-		Uint32 bytes_returned;
+		ALuint bytes_returned;
-		Uint32 j;
+		ALuint j;
 		data->num_buffers_in_use=0;
 /****** MODIFICATION must go here *********/
 		/* Since buffer queuing is pushed off until here to
 		 * avoid buffer conflicts, we must start reading
 		 * data here. First we make sure we have at least one
 		bytes_returned = GetMoreData(
 				data,
 				data->buffer[j]);
 		/*
 		 * This might be a problem. I made a mistake with the types. I accidentally
-		 * made the bytes returned an Sint32 and returned -1 on error.
+		 * made the bytes returned an ALint and returned -1 on error.
-		 * Bytes returned should be a Uint32, so now I no longer have a -1 case
+		 * Bytes returned should be a ALuint, so now I no longer have a -1 case
 		 * to check. I hope I didn't break anything here
 		 */
 		#if 0
 			if(bytes_returned < 0)
 			{
 			data->num_buffers_in_use,
 			data->buffer);
 		if((error = alGetError()) != AL_NO_ERROR)
 		{
 			ALmixer_SetError("Could not bind data to source: %s",
-				aluGetErrorString(error) );
+				alGetString(error) );
 			Clean_Channel(channel);
 			return -1;
 		}
 		/* This is part of the hideous Nvidia workaround. In order to figure out
 		 * which buffer to show during callbacks (for things like
 		 * data structure. This code will be called only if
 		 * "access_data" was set, indicated by whether the queue is NULL.
 		 */
 		if(data->circular_buffer_queue != NULL)
 		{
-			Uint32 k;
+			ALuint k;
-			Uint32 queue_ret_flag;
+			ALuint queue_ret_flag;
 			for(k=0; k<data->num_buffers_in_use; k++)
 			{
+//				fprintf(stderr, "56c: CircularQueue_PushBack.\n");
 				queue_ret_flag = CircularQueueUnsignedInt_PushBack(data->circular_buffer_queue, data->buffer[k]);
 				if(0 == queue_ret_flag)
 				{
 					fprintf(stderr, "Serious internal error: CircularQueue could not push into queue.\n");
 					ALmixer_SetError("Serious internal error: CircularQueue failed to push into queue");
 	 */
 	alSourcePlay(ALmixer_Channel_List[channel].alsource);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		ALmixer_SetError("Play failed: %s",
-			aluGetErrorString(error) );
+			alGetString(error) );
 		Clean_Channel(channel);
 		return -1;
 	}
 	/* Add to the counter that something is playing */
 * first available channels because source and channels have
 * a one-to-one mapping in this API. It is quite easy for
 * a channel/source to already be in use because of this.
 * In this event, an error message will be returned to you.
 */
-static ALuint Internal_PlaySourceTimed(ALuint source, ALmixer_Data* data, Sint32 loops, Sint32 ticks)
+static ALuint Internal_PlaySourceTimed(ALuint source, ALmixer_Data* data, ALint loops, ALint ticks)
 {
-	Sint32 channel;
+	ALint channel;
-	Sint32 retval;
+	ALint retval;
 	if(0 == source)
 	{
 		retval = Internal_PlayChannelTimed(-1, data, loops, ticks);
 		if(-1 == retval)
 		{
 	return 0;
 }
-/* Will return the number of channels halted
-* or 0 for error
+/* Returns the channel or number of channels actually paused */
-*/
-static Sint32 Internal_HaltChannel(Sint32 channel)
+static ALint Internal_PauseChannel(ALint channel)
 {
-	Sint32 retval = 0;
-	Sint32 counter = 0;
-	ALenum error;
-	ALint buffers_still_queued;
-	ALint buffers_processed;
-	if(channel >= Number_of_Channels_global)
-	{
-		ALmixer_SetError("Cannot halt channel %d because it exceeds maximum number of channels (%d)\n", channel, Number_of_Channels_global);
-		return -1;
-	}
-	/* If the user specified a specific channel */
-	if(channel >= 0)
-	{
-		fprintf(stderr, "Halt on channel %d\n", channel);
-		/* only need to process channel if in use */
-		if(ALmixer_Channel_List[channel].channel_in_use)
-		{
-			alSourceStop(ALmixer_Channel_List[channel].alsource);
-			if((error = alGetError()) != AL_NO_ERROR)
-			{
-				fprintf(stderr, "14Testing error: %s\n",
-					aluGetErrorString(error));
-			}
-			/* Here's the situation. My old method of using
-			 * alSourceUnqueueBuffers() seemed to be invalid in light
-			 * of all the problems I suffered through with getting
-			 * the CoreData backend to work with this code.
-			 * As such, I'm changing all the code to set the buffer to
-			 * AL_NONE. Furthermore, the queued vs. non-queued issue
-			 * doesn't need to apply here. For non-queued, Loki,
-			 * Creative Windows, and CoreAudio seem to leave the
-			 * buffer queued (Old Mac didn't.) For queued, we need to
-			 * remove the processed buffers and force remove the
-			 * still-queued buffers.
-			 */
-			fprintf(stderr, "Halt on channel %d, channel in use\n", channel);
-			alGetSourcei(
-				ALmixer_Channel_List[channel].alsource,
-				AL_BUFFERS_QUEUED, &buffers_still_queued
-			);
-			if((error = alGetError()) != AL_NO_ERROR)
-			{
-				fprintf(stderr, "17Testing Error with buffers_still_queued: %s",
-					aluGetErrorString(error));
-				ALmixer_SetError("Failed detecting still queued buffers: %s",
-					aluGetErrorString(error) );
-				retval = -1;
-			}
-			alGetSourcei(
-				ALmixer_Channel_List[channel].alsource,
-				AL_BUFFERS_PROCESSED, &buffers_processed
-			);
-			if((error = alGetError()) != AL_NO_ERROR)
-			{
-				fprintf(stderr, "17Testing Error with buffers_processed: %s",
-					aluGetErrorString(error));
-				ALmixer_SetError("Failed detecting still processed buffers: %s",
-					aluGetErrorString(error) );
-				retval = -1;
-			}
-			/* If either of these is greater than 0, it means we need
-			 * to clear the source
-			 */
-			if((buffers_still_queued > 0) || (buffers_processed > 0))
-			{
-				alSourcei(ALmixer_Channel_List[channel].alsource,
-					AL_BUFFER,
-					AL_NONE);
-				if((error = alGetError()) != AL_NO_ERROR)
-				{
-					fprintf(stderr, "17Testing Error with clearing buffer from source: %s",
-						aluGetErrorString(error));
-					ALmixer_SetError("Failed to clear buffer from source: %s",
-						aluGetErrorString(error) );
-					retval = -1;
-				}
-			}
-			ALmixer_Channel_List[channel].almixer_data->num_buffers_in_use  = 0;
-			Clean_Channel(channel);
-			Is_Playing_global--;
-			/* Launch callback for consistency? */
-			Invoke_Channel_Done_Callback(channel);
-			counter++;
-		}
-	}
-	/* The user wants to halt all channels */
-	else
-	{
-		Sint32 i;
-		for(i=0; i<Number_of_Channels_global; i++)
-		{
-			fprintf(stderr, "Halting channel %d\n", i);
-			fprintf(stderr, "in use %d\n", ALmixer_Channel_List[i].channel_in_use );
-			/* only need to process channel if in use */
-			if(ALmixer_Channel_List[i].channel_in_use)
-			{
-				fprintf(stderr, "SourceStop %d\n", i);
-				alSourceStop(ALmixer_Channel_List[i].alsource);
-				if((error = alGetError()) != AL_NO_ERROR)
-				{
-					fprintf(stderr, "19Testing error: %s\n",
-						aluGetErrorString(error));
-				}
-				/* Here's the situation. My old method of using
-				 * alSourceUnqueueBuffers() seemed to be invalid in light
-				 * of all the problems I suffered through with getting
-				 * the CoreData backend to work with this code.
-				 * As such, I'm changing all the code to set the buffer to
-				 * AL_NONE. Furthermore, the queued vs. non-queued issue
-				 * doesn't need to apply here. For non-queued, Loki,
-				 * Creative Windows, and CoreAudio seem to leave the
-				 * buffer queued (Old Mac didn't.) For queued, we need to
-				 * remove the processed buffers and force remove the
-				 * still-queued buffers.
-				 */
-				fprintf(stderr, "Halt on channel %d, channel in use\n", channel);
-				alGetSourcei(
-					ALmixer_Channel_List[i].alsource,
-					AL_BUFFERS_QUEUED, &buffers_still_queued
-				);
-				if((error = alGetError()) != AL_NO_ERROR)
-				{
-					fprintf(stderr, "17Testing Error with buffers_still_queued: %s",
-						aluGetErrorString(error));
-					ALmixer_SetError("Failed detecting still queued buffers: %s",
-						aluGetErrorString(error) );
-					retval = -1;
-				}
-				alGetSourcei(
-					ALmixer_Channel_List[i].alsource,
-					AL_BUFFERS_PROCESSED, &buffers_processed
-				);
-				if((error = alGetError()) != AL_NO_ERROR)
-				{
-					fprintf(stderr, "17Testing Error with buffers_processed: %s",
-						aluGetErrorString(error));
-					ALmixer_SetError("Failed detecting still processed buffers: %s",
-						aluGetErrorString(error) );
-					retval = -1;
-				}
-				/* If either of these is greater than 0, it means we need
-				 * to clear the source
-				 */
-				if((buffers_still_queued > 0) || (buffers_processed > 0))
-				{
-					alSourcei(ALmixer_Channel_List[i].alsource,
-						AL_BUFFER,
-						AL_NONE);
-					if((error = alGetError()) != AL_NO_ERROR)
-					{
-						fprintf(stderr, "17Testing Error with clearing buffer from source: %s",
-							aluGetErrorString(error));
-						ALmixer_SetError("Failed to clear buffer from source: %s",
-							aluGetErrorString(error) );
-						retval = -1;
-					}
-				}
-				ALmixer_Channel_List[i].almixer_data->num_buffers_in_use  = 0;
-	fprintf(stderr, "Clean channel %d\n", i);
-				Clean_Channel(i);
-				Is_Playing_global--;
-				/* Launch callback for consistency? */
-	fprintf(stderr, "Callback%d\n", i);
-				Invoke_Channel_Done_Callback(i);
-				/* Increment the counter */
-				counter++;
-			}
-			/* Let's halt everything just in case there
-			 * are bugs.
-			 */
-			/*
-			else
-			{
-				alSourceStop(ALmixer_Channel_List[channel].alsource);
-				/ * Can't clean because the in_use counter for
-				 * data will get messed up * /
-				Clean_Channel(channel);
-			}
-			*/
-			/* Just in case */
-			Is_Playing_global = 0;
-		}
-	}
-	if(-1 == retval)
-	{
-		return -1;
-	}
-	return counter;
-}
-/* Will return the source halted or the total number of channels
-* if all were halted or 0 for error
-*/
-static Sint32 Internal_HaltSource(ALuint source)
-{
-	Sint32 channel;
-	if(0 == source)
-	{
-		/* Will return the number of sources halted */
-		return Internal_HaltChannel(-1);
-	}
-	channel = Internal_GetChannel(source);
-	if(-1 == channel)
-	{
-		ALmixer_SetError("Cannot halt source: %s", ALmixer_GetError());
-		return 0;
-	}
-	return Internal_HaltChannel(channel);
-}
-/* This will rewind the SDL_Sound sample for streamed
-* samples and start buffering up the data for the next
-* playback. This may require samples to be halted
-*/
-static Sint32 Internal_RewindData(ALmixer_Data* data)
-{
-	Sint32 retval = 0;
-	/*
-	Sint32 bytes_returned;
-	Sint32 i;
-	*/
-	if(NULL == data)
-	{
-		ALmixer_SetError("Cannot rewind because data is NULL\n");
-		return -1;
-	}
-	/* Might have to require Halt */
-	/* Okay, we assume Halt or natural stop has already
-	 * cleared the data buffers
-	 */
-	if(data->in_use)
-	{
-		fprintf(stderr, "Warning sample is in use. May not be able to rewind\n");
-		/*
-		ALmixer_SetError("Data is in use. Cannot rewind unless all sources using the data are halted\n");
-		return -1;
-		*/
-	}
-	/* Because Seek can alter things even in predecoded data,
-	 * decoded data must also be rewound
-	 */
-	if(data->decoded_all)
-	{
-		data->eof = 0;
-#if 0
-#if defined(DISABLE_PREDECODED_SEEK)
-		/* Since we can't seek predecoded stuff, it should be rewound */
-		return 0;
-#elif !defined(DISABLE_SEEK_MEMORY_OPTIMIZATION)
-		/* This case is if the Sound_Sample has been deleted.
-		 * It assumes the data is already at the beginning.
-		 */
-		if(NULL == data->sample)
-		{
-			return 0;
-		}
-		/* Else, the sample has already been reallocated,
-		 * and we can fall to normal behavior
-		 */
-#endif
-#endif
-		/* If access_data, was enabled, the sound sample
-		 * still exists and we can do stuff.
-		 * If it's NULL, we can't do anything, but
-		 * it should already be "rewound".
-		 */
-		if(NULL == data->sample)
-		{
-			return 0;
-		}
-		/* Else, the sample has already been reallocated,
-		 * and we can fall to normal behavior
-		 */
-		Set_Predecoded_Seek_Position(data, 0);
-	/*
-		return data->total_bytes;
-	*/
-		return 0;
-	}
-	/* Remaining stuff for streamed data */
-fprintf(stderr, "Rewinding for stream\n");
-	data->eof = 0;
-	retval = Sound_Rewind(data->sample);
-	if(0 == retval)
-	{
-		ALmixer_SetError( Sound_GetError() );
-		return -1;
-	}
-fprintf(stderr, "Rewinding succeeded\n");
-fprintf(stderr, "calling GetMoreData for Rewinding for stream\n");
-#if 0
-	/* Clear error */
-	alGetError();
-	for(i=0; i<data->num_buffers; i++)
-	{
-		bytes_returned = GetMoreData(data, data->buffer[i]);
-		if(-1 == bytes_returned)
-		{
-			return -1;
-		}
-		else if(0 == bytes_returned)
-		{
-			return -1;
-		}
-		retval += bytes_returned;
-	}
-#endif
-fprintf(stderr, "end Rewinding for stream\n");
-	return retval;
-}
-static Sint32 Internal_RewindChannel(Sint32 channel)
-{
-	Sint32 retval = 0;
 	ALenum error;
 	ALint state;
+	ALint retval = 0;
-	if(channel >= Number_of_Channels_global)
+	ALint counter = 0;
-	{
-		ALmixer_SetError("Cannot rewind channel %d because it exceeds maximum number of channels (%d)\n", channel, Number_of_Channels_global);
-		return -1;
-	}
-	if((error = alGetError()) != AL_NO_ERROR)
-	{
-		fprintf(stderr, "24Testing error: %s\n",
-			aluGetErrorString(error));
-	}
-	/* Clear error */
-	alGetError();
-	/* If the user specified a specific channel */
-	if(channel >= 0)
-	{
-		/* only need to process channel if in use */
-		if(ALmixer_Channel_List[channel].channel_in_use)
-		{
-			/* What should I do? Do I just rewind the channel
-			 * or also rewind the data? Since the data is
-			 * shared, let's make it the user's responsibility
-			 * to rewind the data.
-			 */
-			if(ALmixer_Channel_List[channel].almixer_data->decoded_all)
-			{
-				alGetSourcei(
-					ALmixer_Channel_List[channel].alsource,
-					AL_SOURCE_STATE, &state
-				);
-	if((error = alGetError()) != AL_NO_ERROR)
-	{
-		fprintf(stderr, "25Testing error: %s\n",
-			aluGetErrorString(error));
-	}
-				alSourceRewind(ALmixer_Channel_List[channel].alsource);
-				if((error = alGetError()) != AL_NO_ERROR)
-				{
-					ALmixer_SetError("%s",
-						aluGetErrorString(error) );
-					retval = -1;
-				}
-				/* Need to resume playback if it was originally playing */
-				if(AL_PLAYING == state)
-				{
-					alSourcePlay(ALmixer_Channel_List[channel].alsource);
-					if((error = alGetError()) != AL_NO_ERROR)
-					{
-						ALmixer_SetError("%s",
-							aluGetErrorString(error) );
-						retval = -1;
-					}
-				}
-				else if(AL_PAUSED == state)
-				{
-					/* HACK: The problem is that when paused, after
-					 * the Rewind, I can't get it off the INITIAL
-					 * state without restarting
-					 */
-					alSourcePlay(ALmixer_Channel_List[channel].alsource);
-	if((error = alGetError()) != AL_NO_ERROR)
-	{
-		fprintf(stderr, "25Testing error: %s\n",
-			aluGetErrorString(error));
-	}
-					alSourcePause(ALmixer_Channel_List[channel].alsource);
-					if((error = alGetError()) != AL_NO_ERROR)
-					{
-						ALmixer_SetError("%s",
-							aluGetErrorString(error) );
-						retval = -1;
-					}
-				}
-			}
-			else
-			{
-				/* Streamed data is different. Rewinding the channel
-				 * does no good. Rewinding the data will have an
-				 * effect, but it will be lagged based on how
-				 * much data is queued. Recommend users call Halt
-				 * before rewind if they want immediate results.
-				 */
-				retval = Internal_RewindData(ALmixer_Channel_List[channel].almixer_data);
-			}
-		}
-	}
-	/* The user wants to halt all channels */
-	else
-	{
-		Sint32 i;
-		for(i=0; i<Number_of_Channels_global; i++)
-		{
-	fprintf(stderr, "in use %d\n", ALmixer_Channel_List[i].channel_in_use );
-			/* only need to process channel if in use */
-			if(ALmixer_Channel_List[i].channel_in_use)
-			{
-				/* What should I do? Do I just rewind the channel
-				 * or also rewind the data? Since the data is
-				 * shared, let's make it the user's responsibility
-				 * to rewind the data.
-				 */
-				if(ALmixer_Channel_List[i].almixer_data->decoded_all)
-				{
-					alGetSourcei(
-						ALmixer_Channel_List[i].alsource,
-						AL_SOURCE_STATE, &state
-					);
-	if((error = alGetError()) != AL_NO_ERROR)
-	{
-		fprintf(stderr, "26Testing error: %s\n",
-			aluGetErrorString(error));
-	}
-					alSourceRewind(ALmixer_Channel_List[i].alsource);
-					if((error = alGetError()) != AL_NO_ERROR)
-					{
-						ALmixer_SetError("%s",
-							aluGetErrorString(error) );
-						retval = -1;
-					}
-					/* Need to resume playback if it was originally playing */
-					if(AL_PLAYING == state)
-					{
-						alSourcePlay(ALmixer_Channel_List[i].alsource);
-						if((error = alGetError()) != AL_NO_ERROR)
-						{
-							ALmixer_SetError("%s",
-								aluGetErrorString(error) );
-							retval = -1;
-						}
-					}
-					else if(AL_PAUSED == state)
-					{
-						/* HACK: The problem is that when paused, after
-						 * the Rewind, I can't get it off the INITIAL
-						 * state without restarting
-						 */
-						alSourcePlay(ALmixer_Channel_List[i].alsource);
-	if((error = alGetError()) != AL_NO_ERROR)
-	{
-		fprintf(stderr, "27Testing error: %s\n",
-			aluGetErrorString(error));
-	}
-						alSourcePause(ALmixer_Channel_List[i].alsource);
-						if((error = alGetError()) != AL_NO_ERROR)
-						{
-							ALmixer_SetError("%s",
-								aluGetErrorString(error) );
-							retval = -1;
-						}
-					}
-				}
-				else
-				{
-					/* Streamed data is different. Rewinding the channel
-					 * does no good. Rewinding the data will have an
-					 * effect, but it will be lagged based on how
-					 * much data is queued. Recommend users call Halt
-					 * before rewind if they want immediate results.
-					 */
-					retval = Internal_RewindData(ALmixer_Channel_List[i].almixer_data);
-				}
-			}
-		}
-	}
-	return retval;
-}
-static Sint32 Internal_RewindSource(ALuint source)
-{
-	Sint32 channel;
-	if(0 == source)
-	{
-		return Internal_RewindChannel(-1);
-	}
-	channel = Internal_GetChannel(source);
-	if(-1 == channel)
-	{
-		ALmixer_SetError("Cannot rewind source: %s", ALmixer_GetError());
-		return 0;
-	}
-	return Internal_RewindChannel(channel);
-}
-/* Returns the channel or number of channels actually paused */
-static Sint32 Internal_PauseChannel(Sint32 channel)
-{
-	ALenum error;
-	ALint state;
-	Sint32 retval = 0;
-	Sint32 counter = 0;
 	if(channel >= Number_of_Channels_global)
 	{
 		ALmixer_SetError("Cannot pause channel %d because it exceeds maximum number of channels (%d)\n", channel, Number_of_Channels_global);
 		return -1;
 	}
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "28Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 	/* Clear error */
 	alGetError();
 	/* If the user specified a specific channel */
 				AL_SOURCE_STATE, &state
 			);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "29Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 			if(AL_PLAYING == state)
 			{
 				/* Count the actual number of channels being paused */
 				counter++;
 				alSourcePause(ALmixer_Channel_List[channel].alsource);
 				if((error = alGetError()) != AL_NO_ERROR)
 				{
 					ALmixer_SetError("%s",
-						aluGetErrorString(error) );
+						alGetString(error) );
 					retval = -1;
 				}
 				/* We need to pause the expire time count down */
 				if(ALmixer_Channel_List[channel].expire_ticks != -1)
 				{
-					Uint32 current_time = SDL_GetTicks();
+					ALuint current_time = ALmixer_GetTicks();
-					Uint32 diff_time;
+					ALuint diff_time;
 					diff_time = current_time -
 						ALmixer_Channel_List[channel].start_time;
 					/* When we unpause, we will want to reset
 					 * the start time so we can continue
 					 * to base calculations off GetTicks().
 					}
 				}
 				/* Do the same as expire time for fading */
 				if(ALmixer_Channel_List[channel].fade_enabled)
 				{
-					Uint32 current_time = SDL_GetTicks();
+					ALuint current_time = ALmixer_GetTicks();
-					Uint32 diff_time;
+					ALuint diff_time;
 					diff_time = current_time -
 						ALmixer_Channel_List[channel].fade_start_time;
 					/* When we unpause, we will want to reset
 					 * the start time so we can continue
 					 * to base calculations off GetTicks().
 		} /* End If in use */
 	} /* End specific channel */
 	/* The user wants to halt all channels */
 	else
 	{
-		Sint32 i;
+		ALint i;
 		for(i=0; i<Number_of_Channels_global; i++)
 		{
 	fprintf(stderr, "Pausing channel %d\n", i);
 	fprintf(stderr, "in use %d\n", ALmixer_Channel_List[i].channel_in_use );
 			/* only need to process channel if in use */
 					AL_SOURCE_STATE, &state
 				);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "30Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 				if(AL_PLAYING == state)
 				{
 					/* Count the actual number of channels being paused */
 					counter++;
 						fprintf(stderr, "SourcePause %d\n", i);
 					alSourcePause(ALmixer_Channel_List[i].alsource);
 					if((error = alGetError()) != AL_NO_ERROR)
 					{
 						ALmixer_SetError("%s",
-							aluGetErrorString(error) );
+							alGetString(error) );
 						retval = -1;
 					}
 					/* We need to pause the expire time count down */
 					if(ALmixer_Channel_List[i].expire_ticks != -1)
 					{
-						Uint32 current_time = SDL_GetTicks();
+						ALuint current_time = ALmixer_GetTicks();
-						Uint32 diff_time;
+						ALuint diff_time;
 						diff_time = current_time -
 							ALmixer_Channel_List[i].start_time;
 						/* When we unpause, we will want to reset
 						 * the start time so we can continue
 						 * to base calculations off GetTicks().
 						}
 					}
 					/* Do the same as expire time for fading */
 					if(ALmixer_Channel_List[i].fade_enabled)
 					{
-						Uint32 current_time = SDL_GetTicks();
+						ALuint current_time = ALmixer_GetTicks();
-						Uint32 diff_time;
+						ALuint diff_time;
 						diff_time = current_time -
 							ALmixer_Channel_List[i].fade_start_time;
 						/* When we unpause, we will want to reset
 						 * the start time so we can continue
 						 * to base calculations off GetTicks().
 	}
 	return counter;
 }
 /* Returns the channel or number of channels actually paused */
-static Sint32 Internal_PauseSource(ALuint source)
+static ALint Internal_PauseSource(ALuint source)
 {
-	Sint32 channel;
+	ALint channel;
 	if(0 == source)
 	{
 		return Internal_PauseChannel(-1);
 	}
 	return Internal_PauseChannel(channel);
 }
-static Sint32 Internal_ResumeChannel(Sint32 channel)
+static ALint Internal_ResumeChannel(ALint channel)
 {
 	ALint state;
 	ALenum error;
-	Sint32 retval = 0;
+	ALint retval = 0;
-	Sint32 counter = 0;
+	ALint counter = 0;
 	if(channel >= Number_of_Channels_global)
 	{
 		ALmixer_SetError("Cannot pause channel %d because it exceeds maximum number of channels (%d)\n", channel, Number_of_Channels_global);
 		return -1;
 	}
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "31Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 	/* Clear error */
 	alGetError();
 	/* If the user specified a specific channel */
 				AL_SOURCE_STATE, &state
 			);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "32Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 			if(AL_PAUSED == state)
 			{
 				/* Count the actual number of channels resumed */
 				counter++;
 				/* We need to resume the expire time count down */
 				if(ALmixer_Channel_List[channel].expire_ticks != -1)
 				{
-					ALmixer_Channel_List[channel].start_time = SDL_GetTicks();
+					ALmixer_Channel_List[channel].start_time = ALmixer_GetTicks();
 				}
 				/* Do the same as expire time for fading */
 				if(ALmixer_Channel_List[channel].fade_enabled)
 				{
-					ALmixer_Channel_List[channel].fade_start_time = SDL_GetTicks();
+					ALmixer_Channel_List[channel].fade_start_time = ALmixer_GetTicks();
 				}
 				alSourcePlay(ALmixer_Channel_List[channel].alsource);
 				if((error = alGetError()) != AL_NO_ERROR)
 				{
 					ALmixer_SetError("%s",
-						aluGetErrorString(error) );
+						alGetString(error) );
 					retval = -1;
 				}
 			}
 		fprintf(stderr, "Pause on channel %d, channel in use\n", channel);
 		}
 	}
 	/* The user wants to halt all channels */
 	else
 	{
-		Sint32 i;
+		ALint i;
 		for(i=0; i<Number_of_Channels_global; i++)
 		{
 	fprintf(stderr, "Pausing channel %d\n", i);
 	fprintf(stderr, "in use %d\n", ALmixer_Channel_List[i].channel_in_use );
 			/* only need to process channel if in use */
 					AL_SOURCE_STATE, &state
 				);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "33Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 				if(AL_PAUSED == state)
 				{
 					/* Count the actual number of channels resumed */
 					counter++;
 					/* We need to resume the expire time count down */
 					if(ALmixer_Channel_List[i].expire_ticks != -1)
 					{
-						ALmixer_Channel_List[i].start_time = SDL_GetTicks();
+						ALmixer_Channel_List[i].start_time = ALmixer_GetTicks();
 					}
 					/* Do the same as expire time for fading */
 					if(ALmixer_Channel_List[i].fade_enabled)
 					{
-						ALmixer_Channel_List[i].fade_start_time = SDL_GetTicks();
+						ALmixer_Channel_List[i].fade_start_time = ALmixer_GetTicks();
 					}
 					alSourcePlay(ALmixer_Channel_List[i].alsource);
 					if((error = alGetError()) != AL_NO_ERROR)
 					{
 						ALmixer_SetError("%s",
-							aluGetErrorString(error) );
+							alGetString(error) );
 						retval = -1;
 					}
 				}
 			}
 		}
 	}
 	return counter;
 }
-static Sint32 Internal_ResumeSource(ALuint source)
+static ALint Internal_ResumeSource(ALuint source)
 {
-	Sint32 channel;
+	ALint channel;
 	if(0 == source)
 	{
 		return Internal_ResumeChannel(-1);
 	}
 /* Might consider setting eof to 0 as a "feature"
 * This will allow seek to end to stay there because
 * Play automatically rewinds if at the end */
-static Sint32 Internal_Seek(ALmixer_Data* data, Uint32 msec)
+static ALint Internal_SeekData(ALmixer_Data* data, ALuint msec)
 {
-	Sint32 retval;
+	ALint retval;
 	if(NULL == data)
 	{
 		ALmixer_SetError("Cannot Seek because data is NULL");
 		return -1;
 	}
 	/* Seek for predecoded files involves moving the chunk pointer around */
 	if(data->decoded_all)
 	{
-		Uint32 byte_position;
+		ALuint byte_position;
 		/* OpenAL doesn't seem to like it if I change the buffer
 		 * while playing (crashes), so I must require that Seek only
 		 * be done when the data is not in use.
 		 * Since data may be shared among multiple sources,
 	return 0;
 }
-static Sint32 Internal_FadeInChannelTimed(Sint32 channel, ALmixer_Data* data, Sint32 loops, Uint32 fade_ticks, Sint32 expire_ticks)
+static ALint Internal_FadeInChannelTimed(ALint channel, ALmixer_Data* data, ALint loops, ALuint fade_ticks, ALint expire_ticks)
 {
 	ALfloat value;
 	ALenum error;
 	ALfloat original_value;
-	Uint32 current_time = SDL_GetTicks();
+	ALuint current_time = ALmixer_GetTicks();
-	Sint32 retval;
+	ALint retval;
 	if(channel >= Number_of_Channels_global)
 	{
 	}
 	/* Get the original volume in case of a problem */
 	alGetSourcef(ALmixer_Channel_List[channel].alsource,
-		AL_MAX_GAIN, &original_value);
+		AL_GAIN, &original_value);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "35Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
-	/* Get the Max volume */
+	ALmixer_Channel_List[channel].fade_end_volume = original_value;
-	/*
-	alGetSourcef(ALmixer_Channel_List[channel].alsource,
-		AL_MAX_GAIN, &value);
-	ALmixer_Channel_List[channel].fade_end_volume = value;
-	fprintf(stderr, "MAX gain: %f\n", value);
-	*/
-	ALmixer_Channel_List[channel].fade_end_volume =
-		ALmixer_Channel_List[channel].max_volume;
 	/* Get the Min volume */
 	alGetSourcef(ALmixer_Channel_List[channel].alsource,
 		AL_MIN_GAIN, &value);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "36Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 	ALmixer_Channel_List[channel].fade_start_volume = value;
 	fprintf(stderr, "MIN gain: %f\n", value);
 	/* Set the actual volume */
 	alSourcef(ALmixer_Channel_List[channel].alsource,
-		AL_MAX_GAIN, value);
+		AL_GAIN, value);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "37Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 	/* Now call PlayChannelTimed */
 	retval = Internal_PlayChannelTimed(channel, data, loops, expire_ticks);
 		 */
 		/* Restore the original value to avoid accidental
 		 * distruption of playback
 		 */
 		alSourcef(ALmixer_Channel_List[channel].alsource,
-			AL_MAX_GAIN, original_value);
+			AL_GAIN, original_value);
-	if((error = alGetError()) != AL_NO_ERROR)
+		if((error = alGetError()) != AL_NO_ERROR)
-	{
+		{
-		fprintf(stderr, "38Testing error: %s\n",
+			fprintf(stderr, "38Testing error: %s\n",
-			aluGetErrorString(error));
+				alGetString(error));
-	}
+		}
 		return retval;
 	}
 	/* We can't accept 0 as a value because of div-by-zero.
 	 * If zero, just call PlayChannelTimed at normal
 	 * volume
 	 */
 	if(0 == fade_ticks)
 	{
 		alSourcef(ALmixer_Channel_List[channel].alsource,
-			AL_MAX_GAIN,
+			AL_GAIN,
 			ALmixer_Channel_List[channel].fade_end_volume
 		);
-	if((error = alGetError()) != AL_NO_ERROR)
+		if((error = alGetError()) != AL_NO_ERROR)
-	{
+		{
-		fprintf(stderr, "39Testing error: %s\n",
+			fprintf(stderr, "39Testing error: %s\n",
-			aluGetErrorString(error));
+				alGetString(error));
-	}
+		}
 		return retval;
 	}
 	/* Enable fading effects via the flag */
 	return retval;
 }
-static ALuint Internal_FadeInSourceTimed(ALuint source, ALmixer_Data* data, Sint32 loops, Uint32 fade_ticks, Sint32 expire_ticks)
+static ALuint Internal_FadeInSourceTimed(ALuint source, ALmixer_Data* data, ALint loops, ALuint fade_ticks, ALint expire_ticks)
 {
-	Sint32 channel;
+	ALint channel;
-	Sint32 retval;
+	ALint retval;
 	if(0 == source)
 	{
 		retval = Internal_FadeInChannelTimed(-1, data, loops, fade_ticks, expire_ticks);
 		if(-1 == retval)
 		{
 /* Will fade out currently playing channels.
 * It starts at the current volume level and goes down */
-static Sint32 Internal_FadeOutChannel(Sint32 channel, Uint32 ticks)
+static ALint Internal_FadeOutChannel(ALint channel, ALuint ticks)
 {
 	ALfloat value;
 	ALenum error;
-	Uint32 current_time = SDL_GetTicks();
+	ALuint current_time = ALmixer_GetTicks();
-	Uint32 counter = 0;
+	ALuint counter = 0;
 	/* We can't accept 0 as a value because of div-by-zero.
 	 * If zero, just call Halt at normal
 	 * volume
 	 */
 	if(0 == ticks)
 	{
-		return Internal_HaltChannel(channel);
+		return Internal_HaltChannel(channel, AL_TRUE);
 	}
 	if(channel >= Number_of_Channels_global)
 	{
 	{
 		if(ALmixer_Channel_List[channel].channel_in_use)
 		{
 			/* Get the current volume */
 			alGetSourcef(ALmixer_Channel_List[channel].alsource,
-				AL_MAX_GAIN, &value);
+				AL_GAIN, &value);
 			ALmixer_Channel_List[channel].fade_start_volume = value;
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "40Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 			/* Get the Min volume */
 			alGetSourcef(ALmixer_Channel_List[channel].alsource,
 				AL_MIN_GAIN, &value);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "41Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 			ALmixer_Channel_List[channel].fade_end_volume = value;
 			fprintf(stderr, "MIN gain: %f\n", value);
 			/* Set expire start time */
 		}
 	}
 	/* Else need to fade out all channels */
 	else
 	{
-		Sint32 i;
+		ALint i;
 		for(i=0; i<Number_of_Channels_global; i++)
 		{
 			if(ALmixer_Channel_List[i].channel_in_use)
 			{
 				/* Get the current volume */
 				alGetSourcef(ALmixer_Channel_List[i].alsource,
-					AL_MAX_GAIN, &value);
+					AL_GAIN, &value);
 				ALmixer_Channel_List[i].fade_start_volume = value;
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "42Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 				/* Get the Min volume */
 				alGetSourcef(ALmixer_Channel_List[i].alsource,
 					AL_MIN_GAIN, &value);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "43Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 				ALmixer_Channel_List[i].fade_end_volume = value;
 				fprintf(stderr, "MIN gain: %f\n", value);
 				/* Set expire start time */
 	}
 	return counter;
 }
-static Sint32 Internal_FadeOutSource(ALuint source, Uint32 ticks)
+static ALint Internal_FadeOutSource(ALuint source, ALuint ticks)
 {
-	Sint32 channel;
+	ALint channel;
 	if(0 == source)
 	{
 		return Internal_FadeOutChannel(-1, ticks);
 	}
 /* Will fade currently playing channels.
 * It starts at the current volume level and go to target
 * Only affects channels that are playing
 */
-static Sint32 Internal_FadeChannel(Sint32 channel, Uint32 ticks, ALfloat volume)
+static ALint Internal_FadeChannel(ALint channel, ALuint ticks, ALfloat volume)
 {
 	ALfloat value;
 	ALenum error;
-	Uint32 current_time = SDL_GetTicks();
+	ALuint current_time = ALmixer_GetTicks();
-	Uint32 counter = 0;
+	ALuint counter = 0;
 	if(channel >= Number_of_Channels_global)
 	{
 			ALmixer_SetError("Requested channel (%d) exceeds maximum channel (%d) because only %d channels are allocated", channel, Number_of_Channels_global-1, Number_of_Channels_global);
 		return -1;
 		{
 			if(ticks > 0)
 			{
 				/* Get the current volume */
 				alGetSourcef(ALmixer_Channel_List[channel].alsource,
-					AL_MAX_GAIN, &value);
+					AL_GAIN, &value);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "44Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 				ALmixer_Channel_List[channel].fade_start_volume = value;
 				/* Set the target volume */
 				ALmixer_Channel_List[channel].fade_end_volume = volume;
 				ALmixer_Channel_List[channel].fade_inv_time = 1.0f / ticks;
 			}
 			else
 			{
 				alSourcef(ALmixer_Channel_List[channel].alsource,
-					AL_MAX_GAIN, volume);
+					AL_GAIN, volume);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "45Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 			}
 			counter++;
 		}
 	}
 	/* Else need to fade out all channels */
 	else
 	{
-		Sint32 i;
+		ALint i;
 		for(i=0; i<Number_of_Channels_global; i++)
 		{
 			if(volume < ALmixer_Channel_List[i].min_volume)
 			{
 				volume = ALmixer_Channel_List[i].min_volume;
 			{
 				if(ticks > 0)
 				{
 					/* Get the current volume */
 					alGetSourcef(ALmixer_Channel_List[i].alsource,
-						AL_MAX_GAIN, &value);
+						AL_GAIN, &value);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "46Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 					ALmixer_Channel_List[i].fade_start_volume = value;
 					/* Set target volume */
 					ALmixer_Channel_List[i].fade_end_volume = volume;
 					ALmixer_Channel_List[i].fade_inv_time = 1.0f / ticks;
 				}
 				else
 				{
 					alSourcef(ALmixer_Channel_List[i].alsource,
-						AL_MAX_GAIN, volume);
+						AL_GAIN, volume);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "47Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 				}
 				counter++;
 			}
 		} /* End for loop */
 	}
 	return counter;
 }
-static Sint32 Internal_FadeSource(ALuint source, Uint32 ticks, ALfloat volume)
+static ALint Internal_FadeSource(ALuint source, ALuint ticks, ALfloat volume)
 {
-	Sint32 channel;
+	ALint channel;
 	if(0 == source)
 	{
 		return Internal_FadeChannel(-1, ticks, volume);
 	}
 /* Set a volume regardless if it's in use or not.
 */
-static Sint32 Internal_SetMaxVolumeChannel(Sint32 channel, ALfloat volume)
+static ALboolean Internal_SetVolumeChannel(ALint channel, ALfloat volume)
 {
 	ALenum error;
-	Sint32 retval = 0;
+	ALboolean retval = AL_TRUE;
 	if(channel >= Number_of_Channels_global)
 	{
+		ALmixer_SetError("Requested channel (%d) exceeds maximum channel (%d) because only %d channels are allocated", channel, Number_of_Channels_global-1, Number_of_Channels_global);
+		return AL_FALSE;
+	}
+	if(channel >= 0)
+	{
+		if(volume < 0.0f)
+		{
+			volume = 0.0f;
+		}
+		else if(volume > 1.0f)
+		{
+			volume = 1.0f;
+		}
+		alSourcef(ALmixer_Channel_List[channel].alsource,
+				  AL_GAIN, volume);
+		if((error = alGetError()) != AL_NO_ERROR)
+		{
+			ALmixer_SetError("%s",
+							 alGetString(error) );
+			retval = AL_FALSE;
+		}
+	}
+	else
+	{
+		ALint i;
+		for(i=0; i<Number_of_Channels_global; i++)
+		{
+			if(volume < 0.0f)
+			{
+				volume = 0.0f;
+			}
+			else if(volume > 1.0f)
+			{
+				volume = 1.0f;
+			}
+			alSourcef(ALmixer_Channel_List[i].alsource,
+					  AL_GAIN, volume);
+			if((error = alGetError()) != AL_NO_ERROR)
+			{
+				ALmixer_SetError("%s",
+								 alGetString(error) );
+				retval = AL_FALSE;
+			}
+		}
+	}
+	return retval;
+}
+static ALboolean Internal_SetVolumeSource(ALuint source, ALfloat volume)
+{
+	ALint channel;
+	if(0 == source)
+	{
+		return Internal_SetVolumeChannel(-1, volume);
+	}
+	channel = Internal_GetChannel(source);
+	if(-1 == channel)
+	{
+		ALmixer_SetError("Cannot SetMaxVolume: %s", ALmixer_GetError());
+		return AL_FALSE;
+	}
+	return Internal_SetVolumeChannel(channel, volume);
+}
+static ALfloat Internal_GetVolumeChannel(ALint channel)
+{
+	 ALfloat value;
+	 ALenum error;
+	ALfloat running_total = 0.0f;
+	ALfloat retval = 0.0f;
+	if(channel >= Number_of_Channels_global)
+	{
+		ALmixer_SetError("Requested channel (%d) exceeds maximum channel (%d) because only %d channels are allocated", channel, Number_of_Channels_global-1, Number_of_Channels_global);
+		return -1.0f;
+	}
+	if(channel >= 0)
+	{
+		 alGetSourcef(ALmixer_Channel_List[channel].alsource,
+		 AL_GAIN, &value);
+		 if((error = alGetError()) != AL_NO_ERROR)
+		 {
+			 ALmixer_SetError("%s", alGetString(error) );
+			 retval = -1.0f;
+		 }
+		 else
+		 {
+			 retval = value;
+		 }
+	}
+	else
+	{
+		ALint i;
+		for(i=0; i<Number_of_Channels_global; i++)
+		{
+			 alGetSourcef(ALmixer_Channel_List[i].alsource,
+			 AL_GAIN, &value);
+			 if((error = alGetError()) != AL_NO_ERROR)
+			 {
+				 ALmixer_SetError("%s", alGetString(error) );
+				 retval = -1;
+			 }
+			 else
+			 {
+				 running_total += value;
+			 }
+		}
+		if(0 == Number_of_Channels_global)
+		{
+			ALmixer_SetError("No channels are allocated");
+			retval = -1.0f;
+		}
+		else
+		{
+			retval = running_total / Number_of_Channels_global;
+		}
+	}
+	return retval;
+}
+static ALfloat Internal_GetVolumeSource(ALuint source)
+{
+	ALint channel;
+	if(0 == source)
+	{
+		return Internal_GetVolumeChannel(-1);
+	}
+	channel = Internal_GetChannel(source);
+	if(-1 == channel)
+	{
+		ALmixer_SetError("Cannot GetVolume: %s", ALmixer_GetError());
+		return -1.0f;
+	}
+	return Internal_GetVolumeChannel(channel);
+}
+/* Set a volume regardless if it's in use or not.
+*/
+static ALboolean Internal_SetMaxVolumeChannel(ALint channel, ALfloat volume)
+{
+	ALenum error;
+	ALboolean retval = AL_TRUE;
+	if(channel >= Number_of_Channels_global)
+	{
 			ALmixer_SetError("Requested channel (%d) exceeds maximum channel (%d) because only %d channels are allocated", channel, Number_of_Channels_global-1, Number_of_Channels_global);
-		return -1;
+		return AL_FALSE;
 	}
 	if(channel >= 0)
 	{
 		if(volume < 0.0f)
 		alSourcef(ALmixer_Channel_List[channel].alsource,
 			AL_MAX_GAIN, volume);
 		if((error = alGetError()) != AL_NO_ERROR)
 		{
 			ALmixer_SetError("%s",
-				aluGetErrorString(error) );
+				alGetString(error) );
-			retval = -1;
+			retval = AL_FALSE;
 		}
 		if(ALmixer_Channel_List[channel].max_volume < ALmixer_Channel_List[channel].min_volume)
 		{
 			ALmixer_Channel_List[channel].min_volume = volume;
 			alSourcef(ALmixer_Channel_List[channel].alsource,
 				AL_MIN_GAIN, volume);
 			if((error = alGetError()) != AL_NO_ERROR)
 			{
 				ALmixer_SetError("%s",
-					aluGetErrorString(error) );
+					alGetString(error) );
-				retval = -1;
+				retval = AL_FALSE;
 			}
 		}
 	}
 	else
 	{
-		Sint32 i;
+		ALint i;
 		for(i=0; i<Number_of_Channels_global; i++)
 		{
 			if(volume < 0.0f)
 			{
 				volume = 0.0f;
 			alSourcef(ALmixer_Channel_List[i].alsource,
 				AL_MAX_GAIN, volume);
 			if((error = alGetError()) != AL_NO_ERROR)
 			{
 				ALmixer_SetError("%s",
-					aluGetErrorString(error) );
+					alGetString(error) );
-				retval = -1;
+				retval = AL_FALSE;
 			}
 			if(ALmixer_Channel_List[i].max_volume < ALmixer_Channel_List[i].min_volume)
 			{
 				ALmixer_Channel_List[i].min_volume = volume;
 				alSourcef(ALmixer_Channel_List[i].alsource,
 					AL_MIN_GAIN, volume);
 				if((error = alGetError()) != AL_NO_ERROR)
 				{
 					ALmixer_SetError("%s",
-						aluGetErrorString(error) );
+						alGetString(error) );
-					retval = -1;
+					retval = AL_FALSE;
 				}
 			}
 		}
 	}
 	return retval;
 }
-static Sint32 Internal_SetMaxVolumeSource(ALuint source, ALfloat volume)
+static ALint Internal_SetMaxVolumeSource(ALuint source, ALfloat volume)
 {
-	Sint32 channel;
+	ALint channel;
 	if(0 == source)
 	{
 		return Internal_SetMaxVolumeChannel(-1, volume);
 	}
 	channel = Internal_GetChannel(source);
 	if(-1 == channel)
 	{
 		ALmixer_SetError("Cannot SetMaxVolume: %s", ALmixer_GetError());
-		return -1;
+		return AL_FALSE;
 	}
 	return Internal_SetMaxVolumeChannel(channel, volume);
 }
-static ALfloat Internal_GetMaxVolumeChannel(Sint32 channel)
+static ALfloat Internal_GetMaxVolumeChannel(ALint channel)
 {
 	/*
 	ALfloat value;
 	ALenum error;
 	*/
 		alGetSourcef(ALmixer_Channel_List[channel].alsource,
 			AL_GAIN, &value);
 		if((error = alGetError()) != AL_NO_ERROR)
 		{
 			ALmixer_SetError("%s",
-				aluGetErrorString(error) );
+				alGetString(error) );
 			retval = -1.0f;
 		}
 		else
 		{
 			retval = value;
 		retval = ALmixer_Channel_List[channel].max_volume;
 	}
 	else
 	{
-		Sint32 i;
+		ALint i;
 		for(i=0; i<Number_of_Channels_global; i++)
 		{
 			/*
 			alGetSourcef(ALmixer_Channel_List[i].alsource,
 				AL_GAIN, &value);
 			if((error = alGetError()) != AL_NO_ERROR)
 			{
 				ALmixer_SetError("%s",
-					aluGetErrorString(error) );
+					alGetString(error) );
 				retval = -1;
 			}
 			else
 			{
 				running_total += value;
 	return retval;
 }
 static ALfloat Internal_GetMaxVolumeSource(ALuint source)
 {
-	Sint32 channel;
+	ALint channel;
 	if(0 == source)
 	{
 		return Internal_GetMaxVolumeChannel(-1);
 	}
 }
 /* Set a volume regardless if it's in use or not.
 */
-static Sint32 Internal_SetMinVolumeChannel(Sint32 channel, ALfloat volume)
+static ALboolean Internal_SetMinVolumeChannel(ALint channel, ALfloat volume)
 {
 	ALenum error;
-	Sint32 retval = 0;
+	ALboolean retval = AL_TRUE;
 	if(channel >= Number_of_Channels_global)
 	{
 			ALmixer_SetError("Requested channel (%d) exceeds maximum channel (%d) because only %d channels are allocated", channel, Number_of_Channels_global-1, Number_of_Channels_global);
-		return -1;
+		return AL_FALSE;
 	}
 	if(channel >= 0)
 	{
 		if(volume < 0.0f)
 		alSourcef(ALmixer_Channel_List[channel].alsource,
 			AL_MIN_GAIN, volume);
 		if((error = alGetError()) != AL_NO_ERROR)
 		{
 			ALmixer_SetError("%s",
-				aluGetErrorString(error) );
+				alGetString(error) );
-			retval = -1;
+			retval = AL_FALSE;
 		}
 		if(ALmixer_Channel_List[channel].max_volume < ALmixer_Channel_List[channel].min_volume)
 		{
 			ALmixer_Channel_List[channel].max_volume = volume;
 			alSourcef(ALmixer_Channel_List[channel].alsource,
 				AL_MAX_GAIN, volume);
 			if((error = alGetError()) != AL_NO_ERROR)
 			{
 				ALmixer_SetError("%s",
-					aluGetErrorString(error) );
+					alGetString(error) );
-				retval = -1;
+				retval = AL_FALSE;
 			}
 		}
 	}
 	else
 	{
-		Sint32 i;
+		ALint i;
 		for(i=0; i<Number_of_Channels_global; i++)
 		{
 			if(volume < 0.0f)
 			{
 				volume = 0.0f;
 			alSourcef(ALmixer_Channel_List[i].alsource,
 				AL_MIN_GAIN, volume);
 			if((error = alGetError()) != AL_NO_ERROR)
 			{
 				ALmixer_SetError("%s",
-					aluGetErrorString(error) );
+					alGetString(error) );
-				retval = -1;
+				retval = AL_FALSE;
 			}
 			if(ALmixer_Channel_List[i].max_volume < ALmixer_Channel_List[i].min_volume)
 			{
 				ALmixer_Channel_List[i].max_volume = volume;
 				alSourcef(ALmixer_Channel_List[i].alsource,
 					AL_MAX_GAIN, volume);
 				if((error = alGetError()) != AL_NO_ERROR)
 				{
 					ALmixer_SetError("%s",
-						aluGetErrorString(error) );
+						alGetString(error) );
-					retval = -1;
+					retval = AL_FALSE;
 				}
 			}
 		}
 	}
 	return retval;
 }
-static Sint32 Internal_SetMinVolumeSource(ALuint source, ALfloat volume)
+static ALboolean Internal_SetMinVolumeSource(ALuint source, ALfloat volume)
 {
-	Sint32 channel;
+	ALint channel;
 	if(0 == source)
 	{
 		return Internal_SetMinVolumeChannel(-1, volume);
 	}
 	channel = Internal_GetChannel(source);
 	if(-1 == channel)
 	{
 		ALmixer_SetError("Cannot SetMaxVolume: %s", ALmixer_GetError());
-		return -1;
+		return AL_FALSE;
 	}
 	return Internal_SetMinVolumeChannel(channel, volume);
 }
-static ALfloat Internal_GetMinVolumeChannel(Sint32 channel)
+static ALfloat Internal_GetMinVolumeChannel(ALint channel)
 {
 	/*
 	ALfloat value;
 	ALenum error;
 	*/
 		alGetSourcef(ALmixer_Channel_List[channel].alsource,
 			AL_GAIN, &value);
 		if((error = alGetError()) != AL_NO_ERROR)
 		{
 			ALmixer_SetError("%s",
-				aluGetErrorString(error) );
+				alGetString(error) );
 			retval = -1.0f;
 		}
 		else
 		{
 			retval = value;
 		retval = ALmixer_Channel_List[channel].min_volume;
 	}
 	else
 	{
-		Sint32 i;
+		ALint i;
 		for(i=0; i<Number_of_Channels_global; i++)
 		{
 			/*
 			alGetSourcef(ALmixer_Channel_List[i].alsource,
 				AL_GAIN, &value);
 			if((error = alGetError()) != AL_NO_ERROR)
 			{
 				ALmixer_SetError("%s",
-					aluGetErrorString(error) );
+					alGetString(error) );
 				retval = -1;
 			}
 			else
 			{
 				running_total += value;
 	return retval;
 }
 static ALfloat Internal_GetMinVolumeSource(ALuint source)
 {
-	Sint32 channel;
+	ALint channel;
 	if(0 == source)
 	{
 		return Internal_GetMinVolumeChannel(-1);
 	}
 	return Internal_GetMinVolumeChannel(channel);
 }
 /* Changes the listener volume */
-static Sint32 Internal_SetMasterVolume(ALfloat volume)
+static ALboolean Internal_SetMasterVolume(ALfloat volume)
 {
 	ALenum error;
 	alListenerf(AL_GAIN, volume);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		ALmixer_SetError("%s",
-			aluGetErrorString(error) );
+			alGetString(error) );
-		return -1;
+		return AL_FALSE;
 	}
-	return 0;
+	return AL_TRUE;
 }
 static ALfloat Internal_GetMasterVolume()
 {
 	ALenum error;
 	ALfloat volume;
 	alGetListenerf(AL_GAIN, &volume);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		ALmixer_SetError("%s",
-			aluGetErrorString(error) );
+			alGetString(error) );
 		return -1.0f;
 	}
 	return volume;
 }
 /* Will fade out currently playing channels.
 * It starts at the current volume level and goes down */
-static Sint32 Internal_ExpireChannel(Sint32 channel, Sint32 ticks)
+static ALint Internal_ExpireChannel(ALint channel, ALint ticks)
 {
-	Uint32 current_time = SDL_GetTicks();
+	ALuint current_time = ALmixer_GetTicks();
-	Uint32 counter = 0;
+	ALuint counter = 0;
 	/* We can't accept 0 as a value because of div-by-zero.
 	 * If zero, just call Halt at normal
 	 * volume
 	 */
 	if(0 == ticks)
 	{
-		return Internal_HaltChannel(channel);
+		return Internal_HaltChannel(channel, AL_TRUE);
 	}
 	if(ticks < -1)
 	{
 		ticks = -1;
 	}
 		}
 	}
 	/* Else need to fade out all channels */
 	else
 	{
-		Sint32 i;
+		ALint i;
 		for(i=0; i<Number_of_Channels_global; i++)
 		{
 			if(ALmixer_Channel_List[i].channel_in_use)
 			{
 				/* Set expire start time */
 	}
 	return counter;
 }
-static Sint32 Internal_ExpireSource(ALuint source, Sint32 ticks)
+static ALint Internal_ExpireSource(ALuint source, ALint ticks)
 {
-	Sint32 channel;
+	ALint channel;
 	if(0 == source)
 	{
 		return Internal_ExpireChannel(-1, ticks);
 	}
 	}
 	return Internal_ExpireChannel(channel, ticks);
 }
-static Sint32 Internal_QueryChannel(Sint32 channel)
+static ALint Internal_QueryChannel(ALint channel)
 {
-	Sint32 i;
+	ALint i;
-	Sint32 counter = 0;
+	ALint counter = 0;
 	if(channel >= Number_of_Channels_global)
 	{
 		ALmixer_SetError("Invalid channel: %d", channel);
 		return -1;
 	}
 	}
 	return counter;
 }
-static Sint32 Internal_QuerySource(ALuint source)
+static ALint Internal_QuerySource(ALuint source)
 {
-	Sint32 channel;
+	ALint channel;
 	if(0 == source)
 	{
 		return Internal_QueryChannel(-1);
 	}
 	return Internal_QueryChannel(channel);
 }
-static Sint32 Internal_CountUnreservedUsedChannels()
+static ALuint Internal_CountUnreservedUsedChannels()
 {
-	Sint32 i;
+	ALint i;
-	Sint32 counter = 0;
+	ALuint counter = 0;
 	/* Else, return the number of channels in use */
 	for(i=Number_of_Reserve_Channels_global; i<Number_of_Channels_global; i++)
 	{
 		}
 	}
 	return counter;
 }
-static Sint32 Internal_CountUnreservedFreeChannels()
+static ALuint Internal_CountUnreservedFreeChannels()
 {
-	Sint32 i;
+	ALint i;
-	Sint32 counter = 0;
+	ALuint counter = 0;
 	/* Else, return the number of channels in use */
 	for(i=Number_of_Reserve_Channels_global; i<Number_of_Channels_global; i++)
 	{
 		}
 	}
 	return counter;
 }
-static Sint32 Internal_CountAllUsedChannels()
+static ALuint Internal_CountAllUsedChannels()
 {
-	Sint32 i;
+	ALint i;
-	Sint32 counter = 0;
+	ALuint counter = 0;
 	/* Else, return the number of channels in use */
 	for(i=0; i<Number_of_Channels_global; i++)
 	{
 		}
 	}
 	return counter;
 }
-static Sint32 Internal_CountAllFreeChannels()
+static ALuint Internal_CountAllFreeChannels()
 {
-	Sint32 i;
+	ALint i;
-	Sint32 counter = 0;
+	ALuint counter = 0;
 	/* Else, return the number of channels in use */
 	for(i=0; i<Number_of_Channels_global; i++)
 	{
 	}
 	return counter;
 }
-static Sint32 Internal_PlayingChannel(Sint32 channel)
+static ALint Internal_PlayingChannel(ALint channel)
 {
-	Sint32 i;
+	ALint i;
-	Sint32 counter = 0;
+	ALint counter = 0;
 	ALint state;
 	if(channel >= Number_of_Channels_global)
 	{
 		ALmixer_SetError("Invalid channel: %d", channel);
 	}
 	return counter;
 }
-static Sint32 Internal_PlayingSource(ALuint source)
+static ALint Internal_PlayingSource(ALuint source)
 {
-	Sint32 channel;
+	ALint channel;
 	if(0 == source)
 	{
 		return Internal_PlayingChannel(-1);
 	}
 	return Internal_PlayingChannel(channel);
 }
-static Sint32 Internal_PausedChannel(Sint32 channel)
+static ALint Internal_PausedChannel(ALint channel)
 {
-	Sint32 i;
+	ALint i;
-	Sint32 counter = 0;
+	ALint counter = 0;
 	ALint state;
 	if(channel >= Number_of_Channels_global)
 	{
 		ALmixer_SetError("Invalid channel: %d", channel);
 	}
 	return counter;
 }
-static Sint32 Internal_PausedSource(ALuint source)
+static ALint Internal_PausedSource(ALuint source)
 {
-	Sint32 channel;
+	ALint channel;
 	if(0 == source)
 	{
 		return Internal_PausedChannel(-1);
 	}
 * call the next update loop in case you are worried
 * about preserving CPU cycles. The idea is that
 * when a buffer is queued, there was probably some
 * CPU intensive looping which took awhile.
 * It's mainly provided as a convenience.
-* Timing the call with SDL_GetTicks() would produce
+* Timing the call with ALmixer_GetTicks() would produce
 * more accurate information.
 * Returns a negative value if there was an error,
 * the value being the number of errors.
 */
-static Sint32 Update_ALmixer(void* data)
+static ALint Update_ALmixer(void* data)
 {
-	Sint32 retval = 0;
+	ALint retval = 0;
-	Sint32 error_flag = 0;
+	ALint error_flag = 0;
 	ALenum error;
 	ALint state;
-	Sint32 i=0;
+	ALint i=0;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	if(0 == ALmixer_Initialized)
 	{
-		SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+		SDL_UnlockMutex(s_simpleLock);
+#endif
 		return 0;
 	}
 	/* Check the quick flag to see if anything needs updating */
 	/* If anything is playing, then we have to do work */
 	if( 0 == Is_Playing_global)
 	{
-		SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+		SDL_UnlockMutex(s_simpleLock);
+#endif
 		return 0;
 	}
 	/* Clear error */
 	if((error = alGetError()) != AL_NO_ERROR)
 				{
 		fprintf(stderr, "08Testing errpr before unqueue because getting stuff, for OS X this is expected: %s\n",
-				aluGetErrorString(error));
+				alGetString(error));
 				}
 	alGetError();
 	for(i=0; i<Number_of_Channels_global; i++)
 	{
 			/* For simplicity, before we do anything else,
 			 * we can check the timeout and fading values
 			 * and do the appropriate things
 			 */
-			Uint32 current_time = SDL_GetTicks();
+			ALuint current_time = ALmixer_GetTicks();
 			/* Check to see if we need to halt due to Timed play */
 			if(ALmixer_Channel_List[i].expire_ticks != -1)
 			{
-				Uint32 target_time = (Uint32)ALmixer_Channel_List[i].expire_ticks
+				ALuint target_time = (ALuint)ALmixer_Channel_List[i].expire_ticks
 					 + ALmixer_Channel_List[i].start_time;
 				alGetSourcei(ALmixer_Channel_List[i].alsource,
 					AL_SOURCE_STATE, &state);
 				if((error = alGetError()) != AL_NO_ERROR)
 				{
 					fprintf(stderr, "06Testing errpr before unqueue because getting stuff, for OS X this is expected: %s\n",
-							aluGetErrorString(error));
+							alGetString(error));
 				}
 				/* Check the time, and also make sure that it is not
 				 * paused (if paused, we don't want to make the
 				 * evaluation because when resumed, we will adjust
 				 */
 				if( (current_time >= target_time)
 					&& (state != AL_PAUSED) )
 				{
 					/* Stop the playback */
-					ALmixer_HaltChannel(i);
+					Internal_HaltChannel(i, AL_TRUE);
 					if((error = alGetError()) != AL_NO_ERROR)
 					{
 						fprintf(stderr, "07Testing errpr before unqueue because getting stuff, for OS X this is expected: %s\n",
-								aluGetErrorString(error));
+								alGetString(error));
 					}
 					/* Everything should be done so go on to the next loop */
 					continue;
 				}
 			} /* End if time expired check */
 			/* Check to see if we need to adjust the volume for fading */
 			if( ALmixer_Channel_List[i].fade_enabled )
 			{
-				Uint32 target_time = ALmixer_Channel_List[i].fade_expire_ticks
+				ALuint target_time = ALmixer_Channel_List[i].fade_expire_ticks
 					 + ALmixer_Channel_List[i].fade_start_time;
 				alGetSourcei(ALmixer_Channel_List[i].alsource,
 					AL_SOURCE_STATE, &state);
 				if((error = alGetError()) != AL_NO_ERROR)
 				{
 					fprintf(stderr, "05Testing errpr before unqueue because getting stuff, for OS X this is expected: %s\n",
-							aluGetErrorString(error));
+							alGetString(error));
 				}
 				/* Check the time, and also make sure that it is not
 				 * paused (if paused, we don't want to make the
 				 * evaluation because when resumed, we will adjust
 				 * the times to compensate for the pause).
 				 */
 				if(state != AL_PAUSED)
 				{
 					ALfloat t;
-					Uint32 delta_time;
+					ALuint delta_time;
 					ALfloat current_volume;
 					if(current_time >= target_time)
 					{
 						/* Need to constrain value to the end time
 						 * (can't go pass the value for calculations)
 					alSourcef(ALmixer_Channel_List[i].alsource,
 						AL_MAX_GAIN, current_volume);
 					if((error = alGetError()) != AL_NO_ERROR)
 					{
 						fprintf(stderr, "04Testing errpr before unqueue because getting stuff, for OS X this is expected: %s\n",
-								aluGetErrorString(error));
+								alGetString(error));
 					}
 	/*
 	fprintf(stderr, "Current time =%d\n", current_time);
 						fprintf(stderr, "Current vol=%f on channel %d\n", current_volume, i);
 				 */
 				if((error = alGetError()) != AL_NO_ERROR)
 				{
 					fprintf(stderr, "03Testing errpr before unqueue because getting stuff, for OS X this is expected: %s\n",
-							aluGetErrorString(error));
+							alGetString(error));
 				}
 				alGetSourcei(
 					ALmixer_Channel_List[i].alsource,
 					AL_SOURCE_STATE, &state
 				);
 				if((error = alGetError()) != AL_NO_ERROR)
 				{
 					fprintf(stderr, "02Testing errpr before unqueue because getting stuff, for OS X this is expected: %s\n",
-							aluGetErrorString(error));
+							alGetString(error));
 				}
 				if(AL_STOPPED == state)
 				{
 						}
 						alSourcePlay(ALmixer_Channel_List[i].alsource);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "50Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 						continue;
 					}
 					/* No loops. End play. */
 					else
 						 */
 						ALint buffers_still_queued;
 						if((error = alGetError()) != AL_NO_ERROR)
 						{
 							fprintf(stderr, "01Testing errpr before unqueue because getting stuff, for OS X this is expected: %s\n",
-									aluGetErrorString(error));
+									alGetString(error));
 						}
 						alGetSourcei(
 							ALmixer_Channel_List[i].alsource,
 							AL_BUFFERS_QUEUED, &buffers_still_queued
 						);
 						if((error = alGetError()) != AL_NO_ERROR)
 						{
 		fprintf(stderr, "Error with unqueue, for OS X this is expected: %s\n",
-							aluGetErrorString(error));
+							alGetString(error));
 							ALmixer_SetError("Failed detecting unqueued predecoded buffer (expected with OS X): %s",
-								aluGetErrorString(error) );
+								alGetString(error) );
 							error_flag--;
 						}
 						if(buffers_still_queued > 0)
 						{
 							*/
 #endif
 							if((error = alGetError()) != AL_NO_ERROR)
 							{
 		fprintf(stderr, "Error with unqueue, after alSourceUnqueueBuffers, buffers_still_queued=%d, error is: %s", buffers_still_queued,
-								aluGetErrorString(error));
+								alGetString(error));
 								ALmixer_SetError("Predecoded Unqueue buffer failed: %s",
-									aluGetErrorString(error) );
+									alGetString(error) );
 								error_flag--;
 							}
 						}
 						Clean_Channel(i);
 						/* Subtract counter */
 						Is_Playing_global--;
 						/* Launch callback */
-						Invoke_Channel_Done_Callback(i);
+						Invoke_Channel_Done_Callback(i, AL_TRUE);
 						/* We're done for this loop.
 						 * Go to next channel
 						 */
 						continue;
 					AL_BUFFERS_QUEUED, &buffers_still_queued
 				);
 				if((error = alGetError()) != AL_NO_ERROR)
 				{
 					fprintf(stderr, "51Testing error: %s\n",
-						aluGetErrorString(error));
+						alGetString(error));
 				}
 				/* Get the number of buffers processed
 				 * so we know if we need to refill
 				 */
+				 /* WARNING: It looks like Snow Leopard some times crashes on this call under x86_64
+				  * typically when I suffer a lot of buffer underruns.
+				  */
+//				 fprintf(stderr, "calling AL_BUFFERS_PROCESSED on source:%d", ALmixer_Channel_List[i].alsource);
 				alGetSourcei(
 					ALmixer_Channel_List[i].alsource,
 					AL_BUFFERS_PROCESSED, &buffers_processed
 				);
 				if((error = alGetError()) != AL_NO_ERROR)
 				{
 					fprintf(stderr, "52Testing error: %s\n",
-						aluGetErrorString(error));
+						alGetString(error));
 				}
+//				fprintf(stderr, "finished AL_BUFFERS_PROCESSED, buffers_processed=%d", buffers_processed);
 /* WTF!!! The Nvidia distribution is failing on the alGetSourcei(source, AL_BUFFER, buf_id) call.
 * I need this call to figure out which buffer OpenAL is currently playing.
 * It keeps returning an "Invalid Enum" error.
 * This is totally inane! It's a basic query.
 					AL_BUFFER, &current_buffer_id
 				);
 				if((error = alGetError()) != AL_NO_ERROR)
 				{
 					fprintf(stderr, "53Testing error: %s\n",
-						aluGetErrorString(error));
+						alGetString(error));
 				}
 				/* Before the hard stuff, check to see if the
 				 * current queued AL buffer has changed.
 				 * If it has, we should launch a data callback if
 				   && (
 							(buffers_processed > 0) || (0 == ALmixer_Channel_List[i].almixer_data->current_buffer)
 					)
 				   )
 				{
-					Uint32 k;
+					ALint k;
-					Uint32 queue_ret_flag;
+					ALuint queue_ret_flag;
-					Uint8 is_out_of_sync = 0;
+					ALubyte is_out_of_sync = 0;
-					Uint32 my_queue_size = CircularQueueUnsignedInt_Size(ALmixer_Channel_List[i].almixer_data->circular_buffer_queue);
+					ALuint my_queue_size = CircularQueueUnsignedInt_Size(ALmixer_Channel_List[i].almixer_data->circular_buffer_queue);
 					/* Ugh, I have to deal with signed/unsigned mismatch here. */
 					ALint buffers_unplayed_int = buffers_still_queued - buffers_processed;
-					Uint32 unplayed_buffers;
+					ALuint unplayed_buffers;
 					if(buffers_unplayed_int < 0)
 					{
 						unplayed_buffers = 0;
 					}
 					else
 					{
-						unplayed_buffers = (Uint32)buffers_unplayed_int;
+						unplayed_buffers = (ALuint)buffers_unplayed_int;
 					}
 /*
 					fprintf(stderr, "Queue in processed check, before pop, buffers_processed=%d\n", buffers_processed);
 					CircularQueueUnsignedInt_Print(ALmixer_Channel_List[i].almixer_data->circular_buffer_queue);
 */
 					/* First, let's syncronize our queue with the OpenAL queue */
 					#if 0
 					fprintf(stderr, "inside, Buffers processed=%d, Buffers queued=%d, my queue=%d\n",
 							buffers_processed, buffers_still_queued, my_queue_size);
 					#endif
-					if(my_queue_size > unplayed_buffers)
+					is_out_of_sync = 1;
+					for(k=0; k<buffers_processed; k++)
 					{
-						is_out_of_sync = 1;
+						queue_ret_flag = CircularQueueUnsignedInt_PopFront(
-						for(k=0; k<(my_queue_size - unplayed_buffers); k++)
+							ALmixer_Channel_List[i].almixer_data->circular_buffer_queue);
+						if(0 == queue_ret_flag)
 						{
-							queue_ret_flag = CircularQueueUnsignedInt_PopFront(
+							fprintf(stderr, "53 Error popping queue\n");
-								ALmixer_Channel_List[i].almixer_data->circular_buffer_queue);
+						}
-							if(0 == queue_ret_flag)
+					}
-							{
-								fprintf(stderr, "53 Error popping queue\n");
-							}
-						}
-					}
 					my_queue_size = CircularQueueUnsignedInt_Size(ALmixer_Channel_List[i].almixer_data->circular_buffer_queue);
 					/* We have several possibilities we need to handle:
 					 * 1) We are in an initial state or underrun and need to do a data callback on the head.
 					 * 2) We were out of sync and need to do a new data callback on the new head.
 					 * 3) We were not out of sync but just had left over processed buffers which caused us to
 				 * We also might find no buffers we need to fill,
 				 * in which case we just keep going
 				 */
 				if( ! ALmixer_Channel_List[i].almixer_data->eof)
 				{
-					Uint32 bytes_returned;
+					ALuint bytes_returned;
 					/* We have a priority. We first must assign
 					 * unused buffers in reserve. If there is nothing
 					 * left, then we may unqueue buffers. We can't
 					 * do it the other way around because we will
 					 * lose the pointer to the unqueued buffer
 							1, &unqueued_buffer_id
 						);
 						if((error = alGetError()) != AL_NO_ERROR)
 						{
 				fprintf(stderr, "Error with unqueue: %s",
-							aluGetErrorString(error));
+							alGetString(error));
 							ALmixer_SetError("Unqueue buffer failed: %s",
-								aluGetErrorString(error) );
+								alGetString(error) );
 							error_flag--;
 						}
 /*
 						fprintf(stderr, "Right after unqueue...");
 						PrintQueueStatus(ALmixer_Channel_List[i].alsource);
 					 * don't need to fill any buffers */
 					else
 					{
 						/* Might want to check state */
 						/* In case the playback stopped,
-						 * we need to resume */
+						 * we need to resume
+						 * a.k.a. buffer underrun
+						 */
 						#if 1
 						/* Try not refetching the state here because I'm getting a duplicate
 						 buffer playback (hiccup) */
 						alGetSourcei(
 							ALmixer_Channel_List[i].alsource,
 							AL_SOURCE_STATE, &state
 						);
 						if((error = alGetError()) != AL_NO_ERROR)
 						{
 							fprintf(stderr, "54bTesting error: %s\n",
-								aluGetErrorString(error));
+								alGetString(error));
 						}
 						/* Get the number of buffers processed
 						 */
 						alGetSourcei(
 							ALmixer_Channel_List[i].alsource,
 							&buffers_processed
 						);
 						if((error = alGetError()) != AL_NO_ERROR)
 						{
 							fprintf(stderr, "54cError, Can't get buffers_processed: %s\n",
-								aluGetErrorString(error));
+								alGetString(error));
 						}
 #endif
 						if(AL_STOPPED == state)
 						{
 							/* Resuming in not eof, but nothing to buffer */
 							 * There is currently an assumption that a buffer
 							 * was queued above so I actually have something
 							 * to play.
 							 */
 							ALint temp_count;
-/*
+#if 0
-							fprintf(stderr, "STOPPED1, need to clear processed, status is:\n");
+							fprintf(stderr, "STOPPED1, need to clear processed=%d, status is:\n", buffers_processed);
 							PrintQueueStatus(ALmixer_Channel_List[i].alsource);
-*/
+#endif
 							for(temp_count=0; temp_count<buffers_processed; temp_count++)
 							{
 								alSourceUnqueueBuffers(
 									ALmixer_Channel_List[i].alsource,
 									1, &unqueued_buffer_id
 								);
 								if((error = alGetError()) != AL_NO_ERROR)
 								{
 									fprintf(stderr, "55aTesting error: %s\n",
-										aluGetErrorString(error));
+										alGetString(error));
 									error_flag--;
 								}
 							}
-/*
+#if 0
 							fprintf(stderr, "After unqueue clear...:\n");
 							PrintQueueStatus(ALmixer_Channel_List[i].alsource);
-*/
+#endif
-							alSourcePlay(ALmixer_Channel_List[i].alsource);
+							/* My assertion: We are STOPPED but not EOF.
+							 * This means we have a buffer underrun.
+							 * We just cleared out the unqueued buffers.
+							 * So we need to reset the mixer_data to reflect we have
+							 * no buffers in queue.
+							 * We need to GetMoreData and then queue up the data.
+							 * Then we need to resume playing.
+							 */
+#if 0
+							int buffers_queued;
+							alGetSourcei(
+										 ALmixer_Channel_List[i].alsource,
+										 AL_BUFFERS_QUEUED,
+										 &buffers_queued
+										 );
 							if((error = alGetError()) != AL_NO_ERROR)
 							{
-								fprintf(stderr, "55Tbesting error: %s\n",
+								fprintf(stderr, "Error in PrintQueueStatus, Can't get buffers_queued: %s\n",
-									aluGetErrorString(error));
+										alGetString(error));
+							}
+							assert(buffers_queued == 0);
+							fprintf(stderr, "buffer underrun: buffers_queued:%d\n", buffers_queued);
+#endif
+							/* Reset the number of buffers in use to 0 */
+							ALmixer_Channel_List[i].almixer_data->num_buffers_in_use = 0;
+							/* Get more data and put it in the first buffer */
+							bytes_returned = GetMoreData(
+								ALmixer_Channel_List[i].almixer_data,
+								ALmixer_Channel_List[i].almixer_data->buffer[0]
+							);
+							/* NOTE: We might want to look for EOF and handle it here.
+							 * Currently, I just let the next loop handle it which seems to be working.
+							 */
+							if(bytes_returned > 0)
+							{
+								/* Queue up the new data */
+								alSourceQueueBuffers(
+													 ALmixer_Channel_List[i].alsource,
+													 1,
+													 &ALmixer_Channel_List[i].almixer_data->buffer[0]
+								);
+								if((error = alGetError()) != AL_NO_ERROR)
+								{
+									fprintf(stderr, "56e alSourceQueueBuffers error: %s\n",
+											alGetString(error));
+								}
+								/* Increment the number of buffers in use */
+								ALmixer_Channel_List[i].almixer_data->num_buffers_in_use++;
+								/* We need to empty and update the circular buffer queue if it is in use */
+								if(ALmixer_Channel_List[i].almixer_data->circular_buffer_queue != NULL)
+								{
+									ALuint queue_ret_flag;
+									CircularQueueUnsignedInt_Clear(ALmixer_Channel_List[i].almixer_data->circular_buffer_queue);
+									queue_ret_flag = CircularQueueUnsignedInt_PushBack(
+																					   ALmixer_Channel_List[i].almixer_data->circular_buffer_queue,
+																					   ALmixer_Channel_List[i].almixer_data->buffer[0]
+																					   );
+									if(0 == queue_ret_flag)
+									{
+										fprintf(stderr, "56fSerious internal error: CircularQueue could not push into queue.\n");
+										ALmixer_SetError("Serious internal error: CircularQueue failed to push into queue");
+									}
+								}
+								/* Resume playback from underrun */
+								alSourcePlay(ALmixer_Channel_List[i].alsource);
+								if((error = alGetError()) != AL_NO_ERROR)
+								{
+									fprintf(stderr, "55Tbesting error: %s\n",
+										alGetString(error));
+								}
 							}
 						}
 						/* Let's escape to the next loop.
 						 * All code below this point is for queuing up
 						 */
 						/*
 					/* In the previous branch, we just grabbed more data.
 					 * Let's check it to make sure it's okay,
 					 * and then queue it up
 					 */
-					/* This check doesn't work anymore because it is now Uint32 */
+					/* This check doesn't work anymore because it is now ALuint */
 				#if 0
 					if(-1 == bytes_returned)
 					{
 						/* Problem occurred...not sure what to do */
 						/* Go to next loop? */
 								ALmixer_Channel_List[i].almixer_data->num_buffers_in_use]
 						);
 						if((error = alGetError()) != AL_NO_ERROR)
 						{
 							fprintf(stderr, "56Testing error: %s\n",
-								aluGetErrorString(error));
+								alGetString(error));
 						}
 						/* This is part of the hideous Nvidia workaround. In order to figure out
 						 * which buffer to show during callbacks (for things like
 						 * o-scopes), I must keep a copy of the buffers that are queued in my own
 						 * data structure. This code will be called only if
 						 * "access_data" was set, indicated by whether the queue is NULL.
 						 */
 						if(ALmixer_Channel_List[i].almixer_data->circular_buffer_queue != NULL)
 						{
-							Uint32 queue_ret_flag;
+							ALuint queue_ret_flag;
+//				fprintf(stderr, "56d: CircularQueue_PushBack.\n");
 							queue_ret_flag = CircularQueueUnsignedInt_PushBack(
 								ALmixer_Channel_List[i].almixer_data->circular_buffer_queue,
 								ALmixer_Channel_List[i].almixer_data->buffer[ALmixer_Channel_List[i].almixer_data->num_buffers_in_use]
 							);
 							if(0 == queue_ret_flag)
 							ALmixer_Channel_List[i].alsource,
 							1, &unqueued_buffer_id);
 						if((error = alGetError()) != AL_NO_ERROR)
 						{
 							ALmixer_SetError("Could not QueueBuffer: %s",
-								aluGetErrorString(error) );
+								alGetString(error) );
 							error_flag--;
 							continue;
 						}
 						/* This is part of the hideous Nvidia workaround. In order to figure out
 						 * which buffer to show during callbacks (for things like
 						 * data structure. This code will be called only if
 						 * "access_data" was set, indicated by whether the queue is NULL.
 						 */
 						if(ALmixer_Channel_List[i].almixer_data->circular_buffer_queue != NULL)
 						{
-							Uint32 queue_ret_flag;
+							ALuint queue_ret_flag;
+//				fprintf(stderr, "56e: CircularQueue_PushBack.\n");
 							queue_ret_flag = CircularQueueUnsignedInt_PushBack(
 								ALmixer_Channel_List[i].almixer_data->circular_buffer_queue,
 								unqueued_buffer_id
 							);
 							if(0 == queue_ret_flag)
 							{
 								fprintf(stderr, "56bSerious internal error: CircularQueue could not push into queue.\n");
 								ALmixer_SetError("Serious internal error: CircularQueue failed to push into queue");
 							}
-							/*
+#if 0
 							else
 							{
 								CircularQueueUnsignedInt_Print(ALmixer_Channel_List[i].almixer_data->circular_buffer_queue);
 							}
-							 */
+#endif
 						}
 					}
 					/* If we used an available buffer queue,
 					 * then we need to update the number of them in use
 					 */
 						AL_SOURCE_STATE, &state
 					);
 					if((error = alGetError()) != AL_NO_ERROR)
 					{
 						fprintf(stderr, "57bTesting error: %s\n",
-							aluGetErrorString(error));
+							alGetString(error));
 					}
 					/* Get the number of buffers processed
 					 */
 					alGetSourcei(
 						ALmixer_Channel_List[i].alsource,
 						&buffers_processed
 					);
 					if((error = alGetError()) != AL_NO_ERROR)
 					{
 						fprintf(stderr, "57cError, Can't get buffers_processed: %s\n",
-							aluGetErrorString(error));
+							alGetString(error));
 					}
 					#endif
 					if(AL_STOPPED == state)
 					{
 					/*
 									1, &unqueued_buffer_id
 								);
 								if((error = alGetError()) != AL_NO_ERROR)
 								{
 									fprintf(stderr, "58aTesting error: %s\n",
-										aluGetErrorString(error));
+										alGetString(error));
 									error_flag--;
 								}
 							}
 /*
 							fprintf(stderr, "After unqueue clear...:\n");
 							alSourcePlay(ALmixer_Channel_List[i].alsource);
 							if((error = alGetError()) != AL_NO_ERROR)
 							{
 								fprintf(stderr, "55Tbesting 8rror: %s\n",
-									aluGetErrorString(error));
+									alGetString(error));
 							}
 					}
 					continue;
 				} /* END if( ! eof) */
 				/* We have hit EOF in the SDL_Sound sample and there
 				{
 					/* Let's continue to remove the used up
 					 * buffers as they come in. */
 					if(buffers_processed > 0)
 					{
-						Sint32 temp_count;
+						ALint temp_count;
 						/* Do as a for-loop because I don't want
 						 * to have to create an array for the
 						 * unqueued_buffer_id's
 						 */
 						for(temp_count=0; temp_count<buffers_processed; temp_count++)
 								1, &unqueued_buffer_id
 							);
 							if((error = alGetError()) != AL_NO_ERROR)
 							{
 								fprintf(stderr, "59Testing error: %s\n",
-										aluGetErrorString(error));
+										alGetString(error));
 							}
 						}
 						fprintf(stderr, "done unqueuing remainder for this loop, %d\n", temp_count);
 						/* Need to update counts since we removed everything.
 									 AL_BUFFERS_QUEUED, &buffers_still_queued
 									 );
 						if((error = alGetError()) != AL_NO_ERROR)
 						{
 							fprintf(stderr, "5100Testing error: %s\n",
-									aluGetErrorString(error));
+									alGetString(error));
 						}
 						/* Get the number of buffers processed
 							* so we know if we need to refill
 							*/
 						alGetSourcei(
 									 AL_BUFFERS_PROCESSED, &buffers_processed
 									 );
 						if((error = alGetError()) != AL_NO_ERROR)
 						{
 							fprintf(stderr, "5200Testing error: %s\n",
-									aluGetErrorString(error));
+									alGetString(error));
 						}
 					}
 					/* Else if buffers_processed == 0
 							AL_SOURCE_STATE, &state
 						);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "60Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 						if(AL_STOPPED == state)
 						{
 							ALmixer_Channel_List[i].almixer_data->num_buffers_in_use  = 0;
 							/* Playback has ended.
 							Clean_Channel(i);
 							/* Subtract counter */
 							Is_Playing_global--;
 							/* Launch callback */
-							Invoke_Channel_Done_Callback(i);
+							Invoke_Channel_Done_Callback(i, AL_TRUE);
 							/* We're done for this loop.
 							 * Go to next channel
 							 */
 							continue;
 							AL_SOURCE_STATE, &state
 						);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "61Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 						if(AL_STOPPED == state)
 						{
 		fprintf(stderr, "Shouldn't be here. %d Buffers still in queue, but play stopped. This might be correct though because race conditions could have caused the STOP to happen right after our other tests...Checking queue status...\n", buffers_still_queued);
 /*
 #ifdef ENABLE_ALMIXER_ALC_SYNC
 	alcProcessContext(alcGetCurrentContext());
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "62Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 #endif
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	/* Return the number of errors */
 	if(error_flag < 0)
 	{
 		return error_flag;
 	}
 	return retval;
 }
 #ifdef ENABLE_PARANOID_SIGNEDNESS_CHECK
 /* This is only here so we can call SDL_OpenAudio() */
-static void my_dummy_audio_callback(void* userdata, Uint8* stream, int len)
+static void my_dummy_audio_callback(void* userdata, ALbyte* stream, int len)
 {
 }
 #endif
 * finish the threads.
 */
 static int Stream_Data_Thread_Callback(void* data)
 {
-	Sint32 retval;
+	ALint retval;
 	while(ALmixer_Initialized)
 	{
 		retval = Update_ALmixer(data);
 		/* 0 means that nothing needed updating and
 			 * little work was done in update
 			 */
 			/* Make sure times are multiples of 10
 			 * for optimal performance and accuracy in Linux
 			 */
-			SDL_Delay(10);
+			ALmixer_Delay(10);
 		}
 		else
 		{
 			/* should I also be sleeping/yielding here? */
-			SDL_Delay(0);
+			ALmixer_Delay(0);
 		}
 	}
 fprintf(stderr, "Thread is closing\n");
 	return 0;
 }
 #endif /* End of ENABLE_ALMIXER_THREADS */
-/* Using -1 on error and 0 on success to follow SDL/SDL_mixer conventions,
+/* SDL/SDL_mixer returns -1 on error and 0 on success.
-* though I actually prefer 0/1 conventions (SDL_Sound/OpenAL/GL).
+* I actually prefer false/true conventions (SDL_Sound/OpenAL/GL)
+* so SDL_mixer porting people beware.
 * Warning: SDL_QuitSubSystem(SDL_INIT_AUDIO) is called which
 * means the SDL audio system will be disabled. It will not
 * be restored (in case SDL is not actually being used) so
 * the user will need to restart it if they need it after
 * OpenAL shuts down.
 */
-Sint32 ALmixer_Init(Uint32 frequency, Sint32 num_sources, Uint32 refresh)
+ALboolean ALmixer_Init(ALuint frequency, ALint num_sources, ALuint refresh)
 {
 	ALCdevice* dev;
 	ALCcontext* context;
-	Sint32 i;
+	ALint i;
 	ALenum error;
 	ALuint* source;
 #ifdef USING_LOKI_AL_DIST
 	/* The Loki dist requires that I set both the
 	/* Redo: I'm going to allow ALC_REFRESH to be set.
 	 * However, if no value is specified, I don't
 	 * want it in the list so I can get the OpenAL defaults
 	 */
 	ALint attrlist[7];
+	ALsizei current_attrlist_index = 0;
 #ifdef ENABLE_PARANOID_SIGNEDNESS_CHECK
 	/* More problems: I'm getting bit by endian/signedness issues on
 	 * different platforms. I can find the endianess easily enough,
 	 * but I don't know how to determine what the correct signedness
 	SDL_AudioSpec desired;
 	SDL_AudioSpec obtained;
 #endif
 	/* Make sure ALmixer isn't already initialized */
 	if(ALmixer_Initialized)
 	{
-		return -1;
+		return AL_FALSE;
 	}
 #ifdef USING_LOKI_AL_DIST
 fprintf(stderr, "Found Loki dist\n");
 #elif defined(USING_CREATIVE_AL_DIST)
 fprintf(stderr, "Found Creative dist\n");
 #elif defined(USING_NVIDIA_AL_DIST)
 fprintf(stderr, "Found Nvidia dist\n");
 #endif
+#ifdef ALMIXER_COMPILE_WITHOUT_SDL
+	ALmixer_InitTime();
+	/* Note: The pool may have been created on previous Init's */
+	/* I leave the pool allocated allocated in case the user wants
+	 * to read the pool in case of a failure (such as in this function).
+	 * This is not actually a leak.
+	 */
+	if(NULL == s_ALmixerErrorPool)
+	{
+		s_ALmixerErrorPool = TError_CreateErrorPool();
+	}
+	if(NULL == s_ALmixerErrorPool)
+	{
+		return AL_FALSE;
+	}
+		fprintf(stderr, "tError Test0\n");
+		ALmixer_SetError("Initing (and testing SetError)");
+		fprintf(stderr, "tError Test1: %s\n", ALmixer_GetError());
+		fprintf(stderr, "tError Test2: %s\n", ALmixer_GetError());
+#endif
 	/* Set the defaults */
+/*
 	attrlist[0] = ALC_FREQUENCY;
 	attrlist[1] = ALMIXER_DEFAULT_FREQUENCY;
 	attrlist[2] = ALC_SYNC;
 #ifdef ENABLE_ALMIXER_ALC_SYNC
 	attrlist[3] = ALC_TRUE;
 #else
 	attrlist[3] = ALC_FALSE;
 #endif
+*/
 	/* Set frequency value if it is not 0 */
 	if(0 != frequency)
 	{
-		attrlist[1] = (ALint)frequency;
+		attrlist[current_attrlist_index] = ALC_FREQUENCY;
-	}
+		current_attrlist_index++;
+		attrlist[current_attrlist_index] = (ALint)frequency;
+		current_attrlist_index++;
+	}
+#ifdef ENABLE_ALMIXER_ALC_SYNC
+		attrlist[current_attrlist_index] = ALC_SYNC;
+		current_attrlist_index++;
+		attrlist[current_attrlist_index] = ALC_TRUE;
+		current_attrlist_index++;
+#endif
 	/* If the user specifies a refresh value,
 	 * make room for it
 	 */
 	if(0 != refresh)
 	{
-		attrlist[4] = (ALint)ALC_REFRESH;
+		attrlist[current_attrlist_index] = (ALint)ALC_REFRESH;
-		attrlist[5] = refresh;
+		current_attrlist_index++;
-		attrlist[6] = '\0';
+		attrlist[current_attrlist_index] = refresh;
-	}
+		current_attrlist_index++;
-	/* Terminate the list without any refresh values */
-	else
-	{
-		attrlist[4] = '\0';
 	}
-	/* It looks like OpenAL won't let us ask it what
+	/* End attribute list */
-	 * the set frequency is, so we need to save our
+	attrlist[current_attrlist_index] = '\0';
-	 * own copy. Yuck.
-	 * Update: J. Valenzuela just updated the Loki
-	 * dist (2003/01/02) to handle this.
-	 * The demo is in testattrib.c. However, this
-	 * looks kind of cumbersome to parse, and I've
-	 * already put this in my code, so I guess I'll
-	 * leave it for now.
-	 */
-	ALmixer_Frequency_global = attrlist[1];
 	/* Initialize SDL_Sound */
 	if(! Sound_Init() )
 	{
 		ALmixer_SetError(Sound_GetError());
-		return -1;
+		return AL_FALSE;
 	}
 #ifdef ENABLE_PARANOID_SIGNEDNESS_CHECK
 	/* Here is the paranoid check that opens
 	 * SDL audio in an attempt to find the correct
 	 * system values.
 		 */
 		SIGN_TYPE_16_BIT_FORMAT = AUDIO_S16SYS;
 		SIGN_TYPE_8_BIT_FORMAT = AUDIO_S8;
 	}
 #endif
+#ifndef ALMIXER_COMPILE_WITHOUT_SDL
 	/* Weirdness: It seems that SDL_Init(SDL_INIT_AUDIO)
 	 * causes OpenAL and SMPEG to conflict. For some reason
 	 * if SDL_Init on audio is active, then all the SMPEG
 	 * decoded sound comes out silent. Unfortunately,
 	 * Sound_Init() invokes SDL_Init on audio. I'm
 	 * not sure why it actually needs it...
 	 * But we'll attempt to disable it here after the
 	 * SDL_Sound::Init call and hope it doesn't break SDL_Sound.
 	 */
 	SDL_QuitSubSystem(SDL_INIT_AUDIO);
+#endif
 	/* I'm told NULL will call the default string
 	 * and hopefully do the right thing for each platform
 	 */
 	/*
 	dev = alcOpenDevice( NULL );
 #endif
 	fprintf(stderr,"sampling-rate is %d\n", attrlist[1]);
 	if(NULL == dev)
 	{
 		ALmixer_SetError("Cannot open sound device for OpenAL");
-		return -1;
+		return AL_FALSE;
 	}
+#ifdef __APPLE__
+	/* The ALC_FREQUENCY attribute is ignored with Apple's implementation. */
+	/* This extension must be called before the context is created. */
+	if(0 != frequency)
+	{
+		Internal_alcMacOSXMixerOutputRate((ALdouble)frequency);
+	}
+	ALmixer_Frequency_global = (ALuint)Internal_alcMacOSXGetMixerOutputRate();
+		fprintf(stderr, "Internal_alcMacOSXMixerOutputRate is: %lf", Internal_alcMacOSXGetMixerOutputRate());
+#endif
 	context = alcCreateContext(dev, attrlist);
 	if(NULL == context)
 	{
 		ALmixer_SetError("Cannot create a context OpenAL");
 		alcCloseDevice(dev);
-		return -1;
+		return AL_FALSE;
 	}
 	fprintf(stderr, "Context checking...\n");
 	/* Hmmm, OSX is returning 1 on alcMakeContextCurrent,
 	if( (ALC_NO_ERROR != error) )
 	{
 		ALmixer_SetError("Could not MakeContextCurrent");
 		alcDestroyContext(context);
 		alcCloseDevice(dev);
-		return -1;
+		return AL_FALSE;
 	}
+	/* It looks like OpenAL won't let us ask it what
+	 * the set frequency is, so we need to save our
+	 * own copy. Yuck.
+	 * Update: J. Valenzuela just updated the Loki
+	 * dist (2003/01/02) to handle this.
+	 * The demo is in testattrib.c.
+	 */
+/*
+	ALmixer_Frequency_global = frequency;
+*/
+#ifndef __APPLE__
+	alcGetIntegerv(dev, ALC_FREQUENCY, 1, &ALmixer_Frequency_global);
+	fprintf(stderr, "alcGetIntegerv ALC_FREQUENCY is: %d", ALmixer_Frequency_global);
+#endif
 #if 0
 	/* OSX is failing on alcMakeContextCurrent(). Try checking it first? */
 	if(alcGetCurrentContext() != context)
 	{
 		/* Hmmm, OSX is returning 1 on alcMakeContextCurrent,
 #endif
 		{
 			ALmixer_SetError("Could not MakeContextCurrent");
 			alcDestroyContext(context);
 			alcCloseDevice(dev);
-			return -1;
+			return AL_FALSE;
 		}
 	}
 #endif
 	 *	This feature is toggled on/off by using the alDisable() & alEnable() APIs. This
 	 *	setting will be applied to all subsequent
 	 *	calls to alBufferData().
 	 */
 #ifdef __APPLE__
-	alEnable(ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING);
+/*
+	#if (TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1)
+	#else
+	#endif
+*/
+	ALenum convert_data_enum = alcGetEnumValue(dev, "ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING");
+	fprintf(stderr, "ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING=0x%x", convert_data_enum);
+	if(0 != convert_data_enum)
+	{
+		alEnable(convert_data_enum);
+	}
+	if( (AL_NO_ERROR != alGetError()) )
+	{
+		ALmixer_SetError("ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING attempted but failed");
+	}
 #endif
 		ALmixer_SetError("Out of Memory for Channel List");
 		alcDestroyContext(context);
 		alcCloseDevice(dev);
 		ALmixer_Initialized = 0;
 		Number_of_Channels_global = 0;
-		return -1;
+		return AL_FALSE;
 	}
 	/* Allocate memory for the list of sources that map to the channels */
 	Source_Map_List = (Source_Map*) malloc(Number_of_Channels_global * sizeof(Source_Map));
 	if(NULL == Source_Map_List)
 		free(ALmixer_Channel_List);
 		alcDestroyContext(context);
 		alcCloseDevice(dev);
 		ALmixer_Initialized = 0;
 		Number_of_Channels_global = 0;
-		return -1;
+		return AL_FALSE;
 	}
 	/* Create array that will hold the sources */
 	source = (ALuint*)malloc(Number_of_Channels_global * sizeof(ALuint));
 	if(NULL == source)
 		free(ALmixer_Channel_List);
 		alcDestroyContext(context);
 		alcCloseDevice(dev);
 		ALmixer_Initialized = 0;
 		Number_of_Channels_global = 0;
-		return -1;
+		return AL_FALSE;
 	}
 	/* Clear the error state */
 	alGetError();
 	/* Generate the OpenAL sources */
 	alGenSources(Number_of_Channels_global, source);
 	if( (error=alGetError()) != AL_NO_ERROR)
 	{
-		ALmixer_SetError("Couldn't generate sources: %s\n", aluGetErrorString(error));
+		ALmixer_SetError("Couldn't generate sources: %s\n", alGetString(error));
 		free(ALmixer_Channel_List);
 		free(Source_Map_List);
 		alcDestroyContext(context);
 		alcCloseDevice(dev);
 		ALmixer_Initialized = 0;
 		Number_of_Channels_global = 0;
-		return -1;
+		return AL_FALSE;
 	}
 	/* Initialize each channel and associate one source to one channel */
 	for(i=0; i<Number_of_Channels_global; i++)
 	{
 	for(i=0; i<Number_of_Channels_global; i++)
 	{
 		fprintf(stderr, "Source: %d, Channel: %d\n", Source_Map_List[i].source, Source_Map_List[i].channel);
 	}
 	fprintf(stderr, "\n");
+	ALmixer_OutputDecoders();
-	simple_lock = SDL_CreateMutex();
-	if(NULL == simple_lock)
+#ifdef ENABLE_ALMIXER_THREADS
+	s_simpleLock = SDL_CreateMutex();
+	if(NULL == s_simpleLock)
 	{
 		/* SDL sets the error message already? */
 		free(source);
 		free(ALmixer_Channel_List);
 		free(Source_Map_List);
 		alcDestroyContext(context);
 		alcCloseDevice(dev);
 		ALmixer_Initialized = 0;
 		Number_of_Channels_global = 0;
-		return -1;
+		return AL_FALSE;
 	}
-#ifdef ENABLE_ALMIXER_THREADS
 	Stream_Thread_global = SDL_CreateThread(Stream_Data_Thread_Callback, NULL);
 	if(NULL == Stream_Thread_global)
 	{
 		/* SDL sets the error message already? */
-		SDL_DestroyMutex(simple_lock);
+		SDL_DestroyMutex(s_simpleLock);
 		free(source);
 		free(ALmixer_Channel_List);
 		free(Source_Map_List);
 		alcDestroyContext(context);
 		alcCloseDevice(dev);
 		ALmixer_Initialized = 0;
 		Number_of_Channels_global = 0;
-		return -1;
+		return AL_FALSE;
 	}
 	fprintf(stderr, "Using threads\n");
 #endif /* End of ENABLE_ALMIXER_THREADS */
 	/* We don't need this array any more because all the sources
 	 * are connected to channels
 	 */
 	free(source);
-	return 0;
+	return AL_TRUE;
 }
-Sint32 ALmixer_Init_Context(Uint32 frequency, Uint32 refresh)
+ALboolean ALmixer_InitContext(ALuint frequency, ALuint refresh)
 {
 	ALCdevice* dev;
 	ALCcontext* context;
 	ALCenum error;
 	/* Redo: I'm going to allow ALC_REFRESH to be set.
 	 * However, if no value is specified, I don't
 	 * want it in the list so I can get the OpenAL defaults
 	 */
 	ALint attrlist[7];
+	ALsizei current_attrlist_index = 0;
 #ifdef ENABLE_PARANOID_SIGNEDNESS_CHECK
 	/* More problems: I'm getting bit by endian/signedness issues on
 	 * different platforms. I can find the endianess easily enough,
 	 * but I don't know how to determine what the correct signedness
 	/* Make sure ALmixer isn't already initialized */
 	if(ALmixer_Initialized)
 	{
-		return -1;
+		return AL_FALSE;
 	}
 #ifdef USING_LOKI_AL_DIST
 fprintf(stderr, "Found Loki dist\n");
 #elif defined(USING_CREATIVE_AL_DIST)
 fprintf(stderr, "Found Creative dist\n");
 #ifdef ENABLE_ALMIXER_ALC_SYNC
 	attrlist[3] = ALC_TRUE;
 #else
 	attrlist[3] = ALC_FALSE;
 #endif
 	/* Set frequency value if it is not 0 */
 	if(0 != frequency)
 	{
-		attrlist[1] = (ALint)frequency;
+		attrlist[current_attrlist_index] = ALC_FREQUENCY;
-	}
+		current_attrlist_index++;
+		attrlist[current_attrlist_index] = (ALint)frequency;
+		current_attrlist_index++;
+	}
+#ifdef ENABLE_ALMIXER_ALC_SYNC
+		attrlist[current_attrlist_index] = ALC_SYNC;
+		current_attrlist_index++;
+		attrlist[current_attrlist_index] = ALC_TRUE;
+		current_attrlist_index++;
+#endif
 	/* If the user specifies a refresh value,
 	 * make room for it
 	 */
 	if(0 != refresh)
 	{
-		attrlist[4] = (ALint)ALC_REFRESH;
+		attrlist[current_attrlist_index] = (ALint)ALC_REFRESH;
-		attrlist[5] = refresh;
+		current_attrlist_index++;
-		attrlist[6] = '\0';
+		attrlist[current_attrlist_index] = refresh;
-	}
+		current_attrlist_index++;
-	/* Terminate the list without any refresh values */
-	else
-	{
-		attrlist[4] = '\0';
 	}
-	/* It looks like OpenAL won't let us ask it what
+	/* End attribute list */
-	 * the set frequency is, so we need to save our
+	attrlist[current_attrlist_index] = '\0';
-	 * own copy. Yuck.
-	 * Update: J. Valenzuela just updated the Loki
-	 * dist (2003/01/02) to handle this.
-	 * The demo is in testattrib.c. However, this
-	 * looks kind of cumbersome to parse, and I've
-	 * already put this in my code, so I guess I'll
-	 * leave it for now.
-	 */
-	ALmixer_Frequency_global = attrlist[1];
 	/* Initialize SDL_Sound */
 	if(! Sound_Init() )
 	{
 		ALmixer_SetError(Sound_GetError());
-		return -1;
+		return AL_FALSE;
 	}
 #ifdef ENABLE_PARANOID_SIGNEDNESS_CHECK
 	/* Here is the paranoid check that opens
 	 * SDL audio in an attempt to find the correct
 	 * system values.
 		 */
 		SIGN_TYPE_16_BIT_FORMAT = AUDIO_S16SYS;
 		SIGN_TYPE_8_BIT_FORMAT = AUDIO_S8;
 	}
 #endif
+#ifndef ALMIXER_COMPILE_WITHOUT_SDL
 	/* Weirdness: It seems that SDL_Init(SDL_INIT_AUDIO)
 	 * causes OpenAL and SMPEG to conflict. For some reason
 	 * if SDL_Init on audio is active, then all the SMPEG
 	 * decoded sound comes out silent. Unfortunately,
 	 * Sound_Init() invokes SDL_Init on audio. I'm
 	 * not sure why it actually needs it...
 	 * But we'll attempt to disable it here after the
 	 * SDL_Sound::Init call and hope it doesn't break SDL_Sound.
 	 */
 	SDL_QuitSubSystem(SDL_INIT_AUDIO);
+#endif
 	/* I'm told NULL will call the default string
 	 * and hopefully do the right thing for each platform
 	 */
 	/*
 	dev = alcOpenDevice( NULL );
 #endif
 	fprintf(stderr,"sampling-rate is %d\n", attrlist[1]);
 	if(NULL == dev)
 	{
 		ALmixer_SetError("Cannot open sound device for OpenAL");
-		return -1;
+		return AL_FALSE;
 	}
+#ifdef __APPLE__
+	/* The ALC_FREQUENCY attribute is ignored with Apple's implementation. */
+	/* This extension must be called before the context is created. */
+	if(0 != frequency)
+	{
+		Internal_alcMacOSXMixerOutputRate((ALdouble)frequency);
+	}
+	ALmixer_Frequency_global = (ALuint)Internal_alcMacOSXGetMixerOutputRate();
+		fprintf(stderr, "Internal_alcMacOSXMixerOutputRate is: %lf", Internal_alcMacOSXGetMixerOutputRate());
+#endif
 	context = alcCreateContext(dev, attrlist);
 	if(NULL == context)
 	{
 		ALmixer_SetError("Cannot create a context OpenAL");
 		alcCloseDevice(dev);
-		return -1;
+		return AL_FALSE;
 	}
 	/* Hmmm, OSX is returning 1 on alcMakeContextCurrent,
 	 * but ALC_NO_ERROR is defined to ALC_FALSE.
 	if( (ALC_NO_ERROR != error) )
 	{
 		ALmixer_SetError("Could not MakeContextCurrent");
 		alcDestroyContext(context);
 		alcCloseDevice(dev);
-		return -1;
+		return AL_FALSE;
 	}
 #if 0
 	/* OSX is failing on alcMakeContextCurrent(). Try checking it first? */
 #endif
 		{
 			ALmixer_SetError("Could not MakeContextCurrent");
 			alcDestroyContext(context);
 			alcCloseDevice(dev);
-			return -1;
+			return AL_FALSE;
 		}
 	}
 #endif
+	/* It looks like OpenAL won't let us ask it what
+	 * the set frequency is, so we need to save our
+	 * own copy. Yuck.
+	 * Update: J. Valenzuela just updated the Loki
+	 * dist (2003/01/02) to handle this.
+	 * The demo is in testattrib.c.
+	 */
+#ifndef __APPLE__
+	alcGetIntegerv(dev, ALC_FREQUENCY, 1, &ALmixer_Frequency_global);
+	fprintf(stderr, "alcGetIntegerv ALC_FREQUENCY is: %d", ALmixer_Frequency_global);
+#endif
 	fprintf(stderr, "done Context\n");
 	/* Saw this in the README with the OS X OpenAL distribution.
 	 * It looked interesting and simple, so I thought I might
 	 *	This feature is toggled on/off by using the alDisable() & alEnable() APIs. This
 	 *	setting will be applied to all subsequent
 	 *	calls to alBufferData().
 	 */
 #ifdef __APPLE__
-	alEnable(ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING);
+	/*
-#endif
+	 #if (TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1)
-	return 0;
+	 #else
-}
+	 #endif
+	 */
+	ALenum convert_data_enum = alcGetEnumValue(dev, "ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING");
-Sint32 ALmixer_Init_Mixer(Sint32 num_sources)
+	fprintf(stderr, "ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING=0x%x", convert_data_enum);
+	if(0 != convert_data_enum)
+	{
+		alEnable(convert_data_enum);
+	}
+	if( (AL_NO_ERROR != alGetError()) )
+	{
+		ALmixer_SetError("ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING attempted but failed");
+	}
+#endif
+	return AL_TRUE;
+}
+ALboolean ALmixer_InitMixer(ALint num_sources)
 {
-	Sint32 i;
+	ALint i;
 	ALenum error;
 	ALuint* source;
 	ALmixer_Initialized = 1;
+#ifdef ALMIXER_COMPILE_WITHOUT_SDL
+	ALmixer_InitTime();
+	/* Note: The pool may have been created on previous Init's */
+	/* I leave the pool allocated allocated in case the user wants
+	 * to read the pool in case of a failure (such as in this function).
+	 * This is not actually a leak.
+	 */
+	if(NULL == s_ALmixerErrorPool)
+	{
+		s_ALmixerErrorPool = TError_CreateErrorPool();
+	}
+	if(NULL == s_ALmixerErrorPool)
+	{
+		return AL_FALSE;
+	}
+	/*
+		fprintf(stderr, "tError Test0\n");
+		ALmixer_SetError("Initing (and testing SetError)");
+		fprintf(stderr, "tError Test1: %s\n", ALmixer_GetError());
+		fprintf(stderr, "tError Test2: %s\n", ALmixer_GetError());
+	 */
+#endif
 	if(num_sources <= 0)
 	{
 		Number_of_Channels_global = ALMIXER_DEFAULT_NUM_CHANNELS;
 	}
 	if(NULL == ALmixer_Channel_List)
 	{
 		ALmixer_SetError("Out of Memory for Channel List");
 		ALmixer_Initialized = 0;
 		Number_of_Channels_global = 0;
-		return -1;
+		return AL_FALSE;
 	}
 	/* Allocate memory for the list of sources that map to the channels */
 	Source_Map_List = (Source_Map*) malloc(Number_of_Channels_global * sizeof(Source_Map));
 	if(NULL == Source_Map_List)
 	{
 		ALmixer_SetError("Out of Memory for Source Map List");
 		free(ALmixer_Channel_List);
 		ALmixer_Initialized = 0;
 		Number_of_Channels_global = 0;
-		return -1;
+		return AL_FALSE;
 	}
 	/* Create array that will hold the sources */
 	source = (ALuint*)malloc(Number_of_Channels_global * sizeof(ALuint));
 	if(NULL == source)
 		ALmixer_SetError("Out of Memory for sources");
 		free(Source_Map_List);
 		free(ALmixer_Channel_List);
 		ALmixer_Initialized = 0;
 		Number_of_Channels_global = 0;
-		return -1;
+		return AL_FALSE;
 	}
 	/* Clear the error state */
 	alGetError();
 	/* Generate the OpenAL sources */
 	alGenSources(Number_of_Channels_global, source);
 	if( (error=alGetError()) != AL_NO_ERROR)
 	{
-		ALmixer_SetError("Couldn't generate sources: %s\n", aluGetErrorString(error));
+		ALmixer_SetError("Couldn't generate sources: %s\n", alGetString(error));
 		free(ALmixer_Channel_List);
 		free(Source_Map_List);
 		ALmixer_Initialized = 0;
 		Number_of_Channels_global = 0;
-		return -1;
+		return AL_FALSE;
 	}
 	/* Initialize each channel and associate one source to one channel */
 	for(i=0; i<Number_of_Channels_global; i++)
 	{
 	{
 		fprintf(stderr, "Source: %d, Channel: %d\n", Source_Map_List[i].source, Source_Map_List[i].channel);
 	}
 	fprintf(stderr, "\n");
-	simple_lock = SDL_CreateMutex();
-	if(NULL == simple_lock)
+#ifdef ENABLE_ALMIXER_THREADS
+	s_simpleLock = SDL_CreateMutex();
+	if(NULL == s_simpleLock)
 	{
 		/* SDL sets the error message already? */
 		free(source);
 		free(ALmixer_Channel_List);
 		free(Source_Map_List);
 		ALmixer_Initialized = 0;
 		Number_of_Channels_global = 0;
-		return -1;
+		return AL_FALSE;
 	}
-#ifdef ENABLE_ALMIXER_THREADS
 	Stream_Thread_global = SDL_CreateThread(Stream_Data_Thread_Callback, NULL);
 	if(NULL == Stream_Thread_global)
 	{
 		/* SDL sets the error message already? */
-		SDL_DestroyMutex(simple_lock);
+		SDL_DestroyMutex(s_simpleLock);
 		free(source);
 		free(ALmixer_Channel_List);
 		free(Source_Map_List);
 		ALmixer_Initialized = 0;
 		Number_of_Channels_global = 0;
-		return -1;
+		return AL_FALSE;
 	}
 	fprintf(stderr, "Using threads\n");
 #endif /* End of ENABLE_ALMIXER_THREADS */
 	/* We don't need this array any more because all the sources
 	 * are connected to channels
 	 */
 	free(source);
-	return 0;
+	return AL_TRUE;
 }
 /* Keep the return value void to allow easy use with
 */
 void ALmixer_Quit()
 {
 	ALCcontext* context;
 	ALCdevice* dev;
-	Sint32 i;
+	ALint i;
 	if( ! ALmixer_Initialized)
 	{
 		return;
 	}
+#ifdef ENABLE_ALMIXER_THREADS
-	SDL_LockMutex(simple_lock);
+	SDL_LockMutex(s_simpleLock);
+#endif
 	/* Shutdown everything before closing context */
 	fprintf(stderr, "Halting channels\n");
-	Internal_HaltChannel(-1);
+	Internal_HaltChannel(-1, AL_FALSE);
 	/* This flag will cause the thread to terminate */
 	ALmixer_Initialized = 0;
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
-#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
 	fprintf(stderr, "Closing thread\n");
 	SDL_WaitThread(Stream_Thread_global, NULL);
-#endif
 	fprintf(stderr, "Destroying mutex\n");
-	SDL_DestroyMutex(simple_lock);
+	SDL_DestroyMutex(s_simpleLock);
+#endif
 	fprintf(stderr, "Deleting OpenAL sources\n");
 	/* Delete all the OpenAL sources */
 	for(i=0; i<Number_of_Channels_global; i++)
 	{
 	}
 	alcCloseDevice(dev);
 	Sound_Quit();
+#ifdef ALMIXER_COMPILE_WITHOUT_SDL
+	/* Remember: ALmixer_SetError/GetError calls will not work while this is gone. */
+	TError_FreeErrorPool(s_ALmixerErrorPool);
+	s_ALmixerErrorPool = NULL;
+#endif
 	return;
 }
-SDL_bool ALmixer_IsInitialized()
+ALboolean ALmixer_IsInitialized()
 {
 	return ALmixer_Initialized;
 }
-Uint32 ALmixer_GetFrequency()
+ALuint ALmixer_GetFrequency()
 {
 	return ALmixer_Frequency_global;
 }
-const SDL_version* ALmixer_Linked_Version()
+const ALmixer_version* ALmixer_GetLinkedVersion()
 {
-	static SDL_version linked_mixver;
+	static ALmixer_version linked_mixver;
-	ALMIXER_VERSION(&linked_mixver);
+	ALMIXER_GET_COMPILED_VERSION(&linked_mixver);
 	return(&linked_mixver);
 }
+#ifdef ALMIXER_COMPILE_WITHOUT_SDL
+const char* ALmixer_GetError()
+{
+	const char* error_string = NULL;
+	if(NULL == s_ALmixerErrorPool)
+	{
+		return "Error: You should not call ALmixer_GetError while ALmixer is not initialized";
+	}
+	error_string = TError_GetLastErrorStr(s_ALmixerErrorPool);
+	/* SDL returns empty strings instead of NULL */
+	if(NULL == error_string)
+	{
+		return "";
+	}
+	else
+	{
+		return error_string;
+	}
+}
+void ALmixer_SetError(const char* err_str, ...)
+{
+	if(NULL == s_ALmixerErrorPool)
+	{
+		fprintf(stderr, "Error: You should not call ALmixer_SetError while ALmixer 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_ALmixerErrorPool, 1, err_str, argp);
+	va_end(argp);
+}
+#endif
 #if 0
-void ALmixer_Output_Attributes()
+void ALmixer_OutputAttributes()
 {
 	ALint num_flags = 0;
 	ALint* flags = 0;
 	int i;
 	ALCdevice* dev = alcGetContextsDevice( alcGetCurrentContext() );
 	free(flags);
 }
 #endif
-void ALmixer_Output_Decoders()
+void ALmixer_OutputDecoders()
 {
 	Sound_Version sound_compile_version;
 	Sound_Version sound_link_version;
 	const Sound_DecoderInfo **rc = Sound_AvailableDecoders();
 	} /* else */
 	fprintf(stream, "\n");
 }
-void ALmixer_Output_OpenAL_Info()
+void ALmixer_OutputOpenALInfo()
 {
-	SDL_version mixer_compile_version;
+	ALmixer_version mixer_compile_version;
-	const SDL_version * mixer_link_version=ALmixer_Linked_Version();
+	const ALmixer_version * mixer_link_version=ALmixer_GetLinkedVersion();
 	FILE* stream = stdout;
 	fprintf(stream, "OpenAL Information:\n");
 	fprintf(stream, "\tAL_VENDOR: %s\n", alGetString( AL_VENDOR ) );
 	fprintf(stream, "\tAL_VERSION: %s\n", alGetString( AL_VERSION ) );
 	fprintf(stream, "\tAL_RENDERER: %s\n", alGetString( AL_RENDERER ) );
 	fprintf(stream, "\tAL_EXTENSIONS: %s\n", alGetString( AL_EXTENSIONS ) );
-	ALMIXER_VERSION(&mixer_compile_version);
+	ALMIXER_GET_COMPILED_VERSION(&mixer_compile_version);
 	fprintf(stream, "\nSDL_ALmixer Information:\n");
 	fprintf(stream, "\tCompiled with SDL_ALmixer version: %d.%d.%d\n",
 		mixer_compile_version.major,
 		mixer_compile_version.minor,
 		mixer_compile_version.patch);
 	#endif
 	fprintf(stream, "\n");
 }
-Sint32 ALmixer_AllocateChannels(Sint32 numchans)
+ALint ALmixer_AllocateChannels(ALint numchans)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_AllocateChannels(numchans);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_ReserveChannels(Sint32 num)
+ALint ALmixer_ReserveChannels(ALint num)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_ReserveChannels(num);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-static ALmixer_Data* DoLoad(Sound_Sample* sample, Uint32 buffersize, SDL_bool decode_mode_is_predecoded, Uint32 max_queue_buffers, Uint32 num_startup_buffers, SDL_bool access_data)
+static ALmixer_Data* DoLoad(Sound_Sample* sample, ALuint buffersize, ALboolean decode_mode_is_predecoded, ALuint max_queue_buffers, ALuint num_startup_buffers, ALboolean access_data)
 {
-	Uint32 bytes_decoded;
+	ALuint bytes_decoded;
 	ALmixer_Data* ret_data;
 	ALenum error;
 	/* Allocate memory */
 	ret_data = (ALmixer_Data *)malloc(sizeof(ALmixer_Data));
 	/* Now decode and load the data into a data chunk */
 	/* Different cases for Streamed and Predecoded
 	 * Streamed might turn into a predecoded if buffersize
 	 * is large enough */
-	if(SDL_FALSE == decode_mode_is_predecoded)
+	if(AL_FALSE == decode_mode_is_predecoded)
 	{
 		bytes_decoded = Sound_Decode(sample);
 		if(sample->flags & SOUND_SAMPLEFLAG_ERROR)
 		{
 			ALmixer_SetError(Sound_GetError());
 			alGetError();
 			/* Now generate an OpenAL buffer using that first element */
 			alGenBuffers(1, ret_data->buffer);
 			if( (error = alGetError()) != AL_NO_ERROR)
 			{
-				ALmixer_SetError("alGenBuffers failed: %s\n", aluGetErrorString(error));
+				ALmixer_SetError("alGenBuffers failed: %s\n", alGetString(error));
 				Sound_FreeSample(sample);
 				free(ret_data->buffer);
 				free(ret_data);
 				return NULL;
 			}
 				bytes_decoded,
 				sample->desired.rate
 			);
 			if( (error = alGetError()) != AL_NO_ERROR)
 			{
-				ALmixer_SetError("alBufferData failed: %s\n", aluGetErrorString(error));
+				ALmixer_SetError("alBufferData failed: %s\n", alGetString(error));
 				Sound_FreeSample(sample);
 				alDeleteBuffers(1, ret_data->buffer);
 				free(ret_data->buffer);
 				free(ret_data);
 				return NULL;
 			alGetError();
 			/* Now generate an OpenAL buffer using that first element */
 			alGenBuffers(max_queue_buffers, ret_data->buffer);
 			if( (error = alGetError()) != AL_NO_ERROR)
 			{
-				ALmixer_SetError("alGenBuffers failed: %s\n", aluGetErrorString(error));
+				ALmixer_SetError("alGenBuffers failed: %s\n", alGetString(error));
 				Sound_FreeSample(sample);
 				free(ret_data->buffer);
 				free(ret_data);
 				return NULL;
 			}
 			 * Allocate the memory for the buffers here
 			 * and initialize the albuffer-index map
 			 */
 			if(access_data)
 			{
-				Uint32 j;
+				ALuint j;
 				/* Create buffers for data access
 				 * Should be the same number as the number of queue buffers
 				 */
 				ret_data->buffer_map_list = (ALmixer_Buffer_Map*)malloc( sizeof(ALmixer_Buffer_Map) * max_queue_buffers);
 				if(NULL == ret_data->buffer_map_list)
 				for(j=0; j<max_queue_buffers; j++)
 				{
 					ret_data->buffer_map_list[j].albuffer = ret_data->buffer[j];
 					ret_data->buffer_map_list[j].index = j;
 					ret_data->buffer_map_list[j].num_bytes = 0;
-					ret_data->buffer_map_list[j].data = (Uint8*)malloc( sizeof(Uint8) * buffersize);
+					ret_data->buffer_map_list[j].data = (ALbyte*)malloc( sizeof(ALbyte) * buffersize);
 					if(NULL == ret_data->buffer_map_list[j].data)
 					{
 						ALmixer_SetError("Out of Memory");
 						break;
 					}
 		} /* End of do stream */
 	} /* end of DECODE_STREAM */
 	/* User requested decode all (easy, nothing to figure out) */
-	else if(SDL_TRUE == decode_mode_is_predecoded)
+	else if(AL_TRUE == decode_mode_is_predecoded)
 	{
+#ifndef ALMIXER_DISABLE_PREDECODED_PRECOMPUTE_BUFFER_SIZE_OPTIMIZATION
+		/* SDL_sound (behind the scenes) seems to loop on buffer_size chunks
+		 * until the buffer is filled. It seems like we can
+		 * do much better and precompute the size of the buffer
+		 * so looping isn't needed.
+		 * WARNING: Due to the way SDL_sound is currently implemented,
+		 * this may waste a lot of memory up front.
+		 * SDL_sound seems to pre-create a buffer of the requested size,
+		 * but on DecodeAll, an entirely new buffer is created and
+		 * everything is memcpy'd into the new buffer in read chunks
+		 * of the buffer_size. This means we need roughly twice the memory
+		 * to load a file.
+		 */
+		ALint sound_duration = Sound_GetDuration(sample);
+		if(sound_duration > 0)
+		{
+			size_t total_bytes = Compute_Total_Bytes_With_Frame_Padding(&sample->desired, (ALuint)sound_duration);
+			int buffer_resize_succeeded = Sound_SetBufferSize(sample, total_bytes);
+			if(0 == buffer_resize_succeeded)
+			{
+				ALmixer_SetError(Sound_GetError());
+				Sound_FreeSample(sample);
+				free(ret_data);
+				return NULL;
+			}
+		}
+#endif /* ALMIXER_DISABLE_PREDECODED_PRECOMPUTE_BUFFER_SIZE_OPTIMIZATION */
 		bytes_decoded = Sound_DecodeAll(sample);
 		if(sample->flags & SOUND_SAMPLEFLAG_ERROR)
 		{
 			ALmixer_SetError(Sound_GetError());
 			Sound_FreeSample(sample);
 		alGetError();
 		/* Now generate an OpenAL buffer using that first element */
 		alGenBuffers(1, ret_data->buffer);
 		if( (error = alGetError()) != AL_NO_ERROR)
 		{
-			ALmixer_SetError("alGenBuffers failed: %s\n", aluGetErrorString(error));
+			ALmixer_SetError("alGenBuffers failed: %s\n", alGetString(error));
 			Sound_FreeSample(sample);
 			free(ret_data->buffer);
 			free(ret_data);
 			return NULL;
 		}
 			bytes_decoded,
 			sample->desired.rate
 		);
 		if( (error = alGetError()) != AL_NO_ERROR)
 		{
-			ALmixer_SetError("alBufferData failed: %s\n", aluGetErrorString(error));
+			ALmixer_SetError("alBufferData failed: %s\n", alGetString(error));
 			Sound_FreeSample(sample);
 			alDeleteBuffers(1, ret_data->buffer);
 			free(ret_data->buffer);
 			free(ret_data);
 			return NULL;
 * I don't like the AudioInfo parameter. I removed it once,
 * but the system will fail on RAW samples because the user
 * must specify it, so I had to bring it back.
 * Remember I must close the rwops if there is an error before NewSample()
 */
-ALmixer_Data* ALmixer_LoadSample_RW(SDL_RWops* rwops, const char* fileext, Uint32 buffersize, SDL_bool decode_mode_is_predecoded, Uint32 max_queue_buffers, Uint32 num_startup_buffers, SDL_bool access_data)
+ALmixer_Data* ALmixer_LoadSample_RW(ALmixer_RWops* rwops, const char* fileext, ALuint buffersize, ALboolean decode_mode_is_predecoded, ALuint max_queue_buffers, ALuint num_startup_buffers, ALboolean access_data)
 {
 	Sound_Sample* sample = NULL;
 	Sound_AudioInfo target;
 	/* Initialize target values to defaults
 /* This will load a sample for us from
 * a file (instead of RWops). Most of the uglyness is
 * error checking and the fact that streamed/predecoded files
 * must be treated differently.
 */
-ALmixer_Data* ALmixer_LoadSample(const char* filename, Uint32 buffersize, SDL_bool decode_mode_is_predecoded, Uint32 max_queue_buffers, Uint32 num_startup_buffers, SDL_bool access_data)
+ALmixer_Data* ALmixer_LoadSample(const char* filename, ALuint buffersize, ALboolean decode_mode_is_predecoded, ALuint max_queue_buffers, ALuint num_startup_buffers, ALboolean access_data)
 {
 	Sound_Sample* sample = NULL;
 	Sound_AudioInfo target;
 	/* Initialize target values to defaults
 /* This is a back door for RAW samples or if you need the
 * AudioInfo field. Use at your own risk.
 */
-ALmixer_Data* ALmixer_LoadSample_RAW_RW(SDL_RWops* rwops, const char* fileext, ALmixer_AudioInfo* desired, Uint32 buffersize, SDL_bool decode_mode_is_predecoded, Uint32 max_queue_buffers, Uint32 num_startup_buffers, SDL_bool access_data)
+ALmixer_Data* ALmixer_LoadSample_RAW_RW(ALmixer_RWops* rwops, const char* fileext, ALmixer_AudioInfo* desired, ALuint buffersize, ALboolean decode_mode_is_predecoded, ALuint max_queue_buffers, ALuint num_startup_buffers, ALboolean access_data)
 {
 	Sound_Sample* sample = NULL;
 	Sound_AudioInfo sound_desired;
 	/* Rather than copying the data from struct to struct, I could just
 	 * cast the thing since the structs are meant to be identical.
 /* This is a back door for RAW samples or if you need the
 * AudioInfo field. Use at your own risk.
 */
-ALmixer_Data* ALmixer_LoadSample_RAW(const char* filename, ALmixer_AudioInfo* desired, Uint32 buffersize, SDL_bool decode_mode_is_predecoded, Uint32 max_queue_buffers, Uint32 num_startup_buffers, SDL_bool access_data)
+ALmixer_Data* ALmixer_LoadSample_RAW(const char* filename, ALmixer_AudioInfo* desired, ALuint buffersize, ALboolean decode_mode_is_predecoded, ALuint max_queue_buffers, ALuint num_startup_buffers, ALboolean access_data)
 {
 	Sound_Sample* sample = NULL;
 	Sound_AudioInfo sound_desired;
 	/* Rather than copying the data from struct to struct, I could just
 	 * cast the thing since the structs are meant to be identical.
 		}
 		alDeleteBuffers(1, data->buffer);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "70Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 	}
 	else
 	{
-		Uint32 i;
+		ALuint i;
 		/* Delete buffer copies if access_data was enabled */
 		if(data->buffer_map_list != NULL)
 		{
 			for(i=0; i<data->max_queue_buffers; i++)
 		Sound_FreeSample(data->sample);
 		alDeleteBuffers(data->max_queue_buffers, data->buffer);
 	if((error = alGetError()) != AL_NO_ERROR)
 	{
 		fprintf(stderr, "71Testing error: %s\n",
-			aluGetErrorString(error));
+			alGetString(error));
 	}
 	}
 	free(data->buffer);
 	free(data);
 }
-Sint32 ALmixer_GetTotalTime(ALmixer_Data* data)
+ALint ALmixer_GetTotalTime(ALmixer_Data* data)
 {
+	if(NULL == data)
+	{
+		return -1;
+	}
 	return data->total_time;
 }
 /* This function will look up the source for the corresponding channel */
 /* Must return 0 on error instead of -1 because of unsigned int */
-ALuint ALmixer_GetSource(Sint32 channel)
+ALuint ALmixer_GetSource(ALint channel)
 {
 	ALuint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_GetSource(channel);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
 /* This function will look up the channel for the corresponding source */
-Sint32 ALmixer_GetChannel(ALuint source)
+ALint ALmixer_GetChannel(ALuint source)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_GetChannel(source);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_FindFreeChannel(Sint32 start_channel)
+ALint ALmixer_FindFreeChannel(ALint start_channel)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_FindFreeChannel(start_channel);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
 * call the next update loop in case you are worried
 * about preserving CPU cycles. The idea is that
 * when a buffer is queued, there was probably some
 * CPU intensive looping which took awhile.
 * It's mainly provided as a convenience.
-* Timing the call with SDL_GetTicks() would produce
+* Timing the call with ALmixer_GetTicks() would produce
 * more accurate information.
 * Returns a negative value if there was an error,
 * the value being the number of errors.
 */
-Sint32 ALmixer_Update()
+ALint ALmixer_Update()
 {
 #ifdef ENABLE_ALMIXER_THREADS
 	/* The thread will handle all updates by itself.
 	 * Don't allow the user to explicitly call update.
 	 */
 #endif
 }
-void ALmixer_ChannelFinished(void (*channel_finished)(Sint32 channel, void* userdata), void* userdata)
+void ALmixer_SetPlaybackFinishedCallback(void (*playback_finished_callback)(ALint which_channel, ALuint al_source, ALmixer_Data* almixer_data, ALboolean finished_naturally, void* user_data), void* user_data)
 {
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
-	Channel_Done_Callback = channel_finished;
+	SDL_LockMutex(s_simpleLock);
-	Channel_Done_Callback_Userdata = userdata;
+#endif
-	SDL_UnlockMutex(simple_lock);
+	Channel_Done_Callback = playback_finished_callback;
-}
+	Channel_Done_Callback_Userdata = user_data;
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
-void ALmixer_ChannelData(void (*channel_data)(Sint32 which_chan, Uint8* data, Uint32 num_bytes, Uint32 frequency, Uint8 channels, Uint8 bit_depth, SDL_bool is_unsigned, SDL_bool decode_mode_is_predecoded, Uint32 length_in_msec, void* user_data), void* user_data)
+#endif
-{
+}
-	SDL_LockMutex(simple_lock);
-	Channel_Data_Callback = channel_data;
+void ALmixer_SetPlaybackDataCallback(void (*playback_data_callback)(ALint which_chan, ALuint al_source, ALbyte* data, ALuint num_bytes, ALuint frequency, ALubyte channels, ALubyte bit_depth, ALboolean is_unsigned, ALboolean decode_mode_is_predecoded, ALuint length_in_msec, void* user_data), void* user_data)
+{
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
+	Channel_Data_Callback = playback_data_callback;
 	Channel_Data_Callback_Userdata = user_data;
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
-}
+	SDL_UnlockMutex(s_simpleLock);
+#endif
+}
-Sint32 ALmixer_PlayChannelTimed(Sint32 channel, ALmixer_Data* data, Sint32 loops, Sint32 ticks)
-{
-	Sint32 retval;
+ALint ALmixer_PlayChannelTimed(ALint channel, ALmixer_Data* data, ALint loops, ALint ticks)
-	SDL_LockMutex(simple_lock);
+{
+	ALint retval;
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_PlayChannelTimed(channel, data, loops, ticks);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
 /* In case the user wants to specify a source instead of a channel,
 * first available channels because source and channels have
 * a one-to-one mapping in this API. It is quite easy for
 * a channel/source to already be in use because of this.
 * In this event, an error message will be returned to you.
 */
-ALuint ALmixer_PlaySourceTimed(ALuint source, ALmixer_Data* data, Sint32 loops, Sint32 ticks)
+ALuint ALmixer_PlaySourceTimed(ALuint source, ALmixer_Data* data, ALint loops, ALint ticks)
 {
 	ALuint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_PlaySourceTimed(source, data, loops, ticks);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
 /* Will return the number of channels halted
 * or 0 for error
 */
-Sint32 ALmixer_HaltChannel(Sint32 channel)
+ALint ALmixer_HaltChannel(ALint channel)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
-	retval = Internal_HaltChannel(channel);
+	SDL_LockMutex(s_simpleLock);
-	SDL_UnlockMutex(simple_lock);
+#endif
+	retval = Internal_HaltChannel(channel, AL_FALSE);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
 /* Will return the number of channels halted
 * or 0 for error
 */
-Sint32 ALmixer_HaltSource(ALuint source)
+ALint ALmixer_HaltSource(ALuint source)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
-	retval = Internal_HaltSource(source);
+	SDL_LockMutex(s_simpleLock);
-	SDL_UnlockMutex(simple_lock);
+#endif
+	retval = Internal_HaltSource(source, AL_FALSE);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
 /* This will rewind the SDL_Sound sample for streamed
 * samples and start buffering up the data for the next
 * playback. This may require samples to be halted
 */
-Sint32 ALmixer_RewindData(ALmixer_Data* data)
+ALint ALmixer_RewindData(ALmixer_Data* data)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_RewindData(data);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_RewindChannel(Sint32 channel)
+ALint ALmixer_RewindChannel(ALint channel)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_RewindChannel(channel);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_RewindSource(ALuint source)
+ALint ALmixer_RewindSource(ALuint source)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_RewindSource(source);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_PauseChannel(Sint32 channel)
+ALint ALmixer_PauseChannel(ALint channel)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_PauseChannel(channel);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_PauseSource(ALuint source)
+ALint ALmixer_PauseSource(ALuint source)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_PauseSource(source);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_ResumeChannel(Sint32 channel)
+ALint ALmixer_ResumeChannel(ALint channel)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_ResumeChannel(channel);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_ResumeSource(ALuint source)
+ALint ALmixer_ResumeSource(ALuint source)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_ResumeSource(source);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
 /* Might consider setting eof to 0 as a "feature"
 * This will allow seek to end to stay there because
 * Play automatically rewinds if at the end */
-Sint32 ALmixer_Seek(ALmixer_Data* data, Uint32 msec)
+ALint ALmixer_SeekData(ALmixer_Data* data, ALuint msec)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
-	retval = Internal_Seek(data, msec);
+	SDL_LockMutex(s_simpleLock);
-	SDL_UnlockMutex(simple_lock);
+#endif
+	retval = Internal_SeekData(data, msec);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_FadeInChannelTimed(Sint32 channel, ALmixer_Data* data, Sint32 loops, Uint32 fade_ticks, Sint32 expire_ticks)
+ALint ALmixer_FadeInChannelTimed(ALint channel, ALmixer_Data* data, ALint loops, ALuint fade_ticks, ALint expire_ticks)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_FadeInChannelTimed(channel, data, loops, fade_ticks, expire_ticks);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-ALuint ALmixer_FadeInSourceTimed(ALuint source, ALmixer_Data* data, Sint32 loops, Uint32 fade_ticks, Sint32 expire_ticks)
+ALuint ALmixer_FadeInSourceTimed(ALuint source, ALmixer_Data* data, ALint loops, ALuint fade_ticks, ALint expire_ticks)
 {
 	ALuint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_FadeInSourceTimed(source, data, loops, fade_ticks, expire_ticks);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_FadeOutChannel(Sint32 channel, Uint32 ticks)
+ALint ALmixer_FadeOutChannel(ALint channel, ALuint ticks)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_FadeOutChannel(channel, ticks);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_FadeOutSource(ALuint source, Uint32 ticks)
+ALint ALmixer_FadeOutSource(ALuint source, ALuint ticks)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_FadeOutSource(source, ticks);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_FadeChannel(Sint32 channel, Uint32 ticks, ALfloat volume)
+ALint ALmixer_FadeChannel(ALint channel, ALuint ticks, ALfloat volume)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_FadeChannel(channel, ticks, volume);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_FadeSource(ALuint source, Uint32 ticks, ALfloat volume)
+ALint ALmixer_FadeSource(ALuint source, ALuint ticks, ALfloat volume)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_FadeSource(source, ticks, volume);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_SetMaxVolumeChannel(Sint32 channel, ALfloat volume)
-{
+ALboolean ALmixer_SetVolumeChannel(ALint channel, ALfloat volume)
-	Sint32 retval;
+{
-	SDL_LockMutex(simple_lock);
+	ALboolean retval;
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
+	retval = Internal_SetVolumeChannel(channel, volume);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
+	return retval;
+}
+ALboolean ALmixer_SetVolumeSource(ALuint source, ALfloat volume)
+{
+	ALboolean retval;
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
+	retval = Internal_SetVolumeSource(source, volume);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
+	return retval;
+}
+ALfloat ALmixer_GetVolumeChannel(ALint channel)
+{
+	ALfloat retval;
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
+	retval = Internal_GetVolumeChannel(channel);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
+	return retval;
+}
+ALfloat ALmixer_GetVolumeSource(ALuint source)
+{
+	ALfloat retval;
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
+	retval = Internal_GetVolumeSource(source);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
+	return retval;
+}
+ALboolean ALmixer_SetMaxVolumeChannel(ALint channel, ALfloat volume)
+{
+	ALboolean retval;
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_SetMaxVolumeChannel(channel, volume);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_SetMaxVolumeSource(ALuint source, ALfloat volume)
+ALboolean ALmixer_SetMaxVolumeSource(ALuint source, ALfloat volume)
 {
-	Sint32 retval;
+	ALboolean retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_SetMaxVolumeSource(source, volume);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-ALfloat ALmixer_GetMaxVolumeChannel(Sint32 channel)
+ALfloat ALmixer_GetMaxVolumeChannel(ALint channel)
 {
 	ALfloat retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_GetMaxVolumeChannel(channel);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
 ALfloat ALmixer_GetMaxVolumeSource(ALuint source)
 {
 	ALfloat retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_GetMaxVolumeSource(source);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_SetMinVolumeChannel(Sint32 channel, ALfloat volume)
+ALboolean ALmixer_SetMinVolumeChannel(ALint channel, ALfloat volume)
 {
-	Sint32 retval;
+	ALboolean retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_SetMinVolumeChannel(channel, volume);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_SetMinVolumeSource(ALuint source, ALfloat volume)
+ALboolean ALmixer_SetMinVolumeSource(ALuint source, ALfloat volume)
 {
-	Sint32 retval;
+	ALboolean retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_SetMinVolumeSource(source, volume);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-ALfloat ALmixer_GetMinVolumeChannel(Sint32 channel)
+ALfloat ALmixer_GetMinVolumeChannel(ALint channel)
 {
 	ALfloat retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_GetMinVolumeChannel(channel);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
 ALfloat ALmixer_GetMinVolumeSource(ALuint source)
 {
 	ALfloat retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_GetMinVolumeSource(source);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_SetMasterVolume(ALfloat volume)
+ALboolean ALmixer_SetMasterVolume(ALfloat volume)
 {
-	Sint32 retval;
+	ALboolean retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_SetMasterVolume(volume);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
 ALfloat ALmixer_GetMasterVolume()
 {
 	ALfloat retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_GetMasterVolume();
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_ExpireChannel(Sint32 channel, Sint32 ticks)
+ALint ALmixer_ExpireChannel(ALint channel, ALint ticks)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_ExpireChannel(channel, ticks);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_ExpireSource(ALuint source, Sint32 ticks)
+ALint ALmixer_ExpireSource(ALuint source, ALint ticks)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_ExpireSource(source, ticks);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_QueryChannel(Sint32 channel)
+ALint ALmixer_IsActiveChannel(ALint channel)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_QueryChannel(channel);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_QuerySource(ALuint source)
+ALint ALmixer_IsActiveSource(ALuint source)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_QuerySource(source);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_PlayingChannel(Sint32 channel)
+ALint ALmixer_IsPlayingChannel(ALint channel)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_PlayingChannel(channel);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_PlayingSource(ALuint source)
+ALint ALmixer_IsPlayingSource(ALuint source)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_PlayingSource(source);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_PausedChannel(Sint32 channel)
+ALint ALmixer_IsPausedChannel(ALint channel)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_PausedChannel(channel);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_PausedSource(ALuint source)
+ALint ALmixer_IsPausedSource(ALuint source)
 {
-	Sint32 retval;
+	ALint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_PausedSource(source);
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_CountAllFreeChannels()
+ALuint ALmixer_CountAllFreeChannels()
 {
-	Sint32 retval;
+	ALuint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_CountAllFreeChannels();
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_CountUnreservedFreeChannels()
+ALuint ALmixer_CountUnreservedFreeChannels()
 {
-	Sint32 retval;
+	ALuint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_CountUnreservedFreeChannels();
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_CountAllUsedChannels()
+ALuint ALmixer_CountAllUsedChannels()
 {
-	Sint32 retval;
+	ALuint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_CountAllUsedChannels();
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-Sint32 ALmixer_CountUnreservedUsedChannels()
+ALuint ALmixer_CountUnreservedUsedChannels()
 {
-	Sint32 retval;
+	ALuint retval;
-	SDL_LockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
 	retval = Internal_CountUnreservedUsedChannels();
-	SDL_UnlockMutex(simple_lock);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
 	return retval;
 }
-SDL_bool ALmixer_IsPredecoded(ALmixer_Data* data)
+ALboolean ALmixer_IsPredecoded(ALmixer_Data* data)
 {
 	if(NULL == data)
 	{
-		return SDL_FALSE;
+		return AL_FALSE;
 	}
 	return data->decoded_all;
 }
+ALboolean ALmixer_CompiledWithThreadBackend()
+{
+#ifdef ENABLE_ALMIXER_THREADS
+	return AL_TRUE;
+#else
+	return AL_FALSE;
+#endif
+}

Mercurial > almixer_isolated

comparison SDL_ALmixer.c @ 2:279d0427ef26