almixer_isolated: ALmixer.c comparison

comparison ALmixer.c @ 22:58f03008ea05

- Added Seek APIs - Added new API for interruption handling like on iOS - Made support for ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING an opt-in compile define because iOS kept reporting it supported this even though it didn't and some people reported that on Mac, this sometimes failed (but I couldn't reproduce). - Made number of sources unsigned - Some minor 64-bit clean ups

author	Eric Wing <ewing . public \|-at-\| gmail . com>
date	Fri, 24 Dec 2010 03:23:02 -0800
parents	038baa026db3
children	e085cbc573cf

comparison

equal deleted inserted replaced

-:14c22fc3c753
+:58f03008ea05
 */
 #include "ALmixer.h"
 #ifdef ALMIXER_COMPILE_WITHOUT_SDL
-	#include "ALmixer_rwops.h"
+	#include "ALmixer_RWops.h"
 	#include "SoundDecoder.h"
 #else
 	#include "SDL_sound.h"
 #endif
-#ifdef ANDROID_NDK
+#include "al.h" /* OpenAL */
-	#include <AL/al.h>
+#include "alc.h" /* For creating OpenAL contexts */
-	#include <AL/alc.h>
-#else
-	#include "al.h" /* OpenAL */
-	#include "alc.h" /* For creating OpenAL contexts */
-#endif
 #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 <TargetConditionals.h>
 /*
-	#include <TargetConditionals.h>
 	#if (TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1)
+		#include <AudioToolbox/AudioToolbox.h>
 	#else
 		#include <OpenAL/MacOSX_OALExtensions.h>
 	#endif
 */
 #endif
 /* For malloc, bsearch, qsort */
 #include <stdlib.h>
 static SDL_Thread* Stream_Thread_global = NULL;
 #endif
 static LinkedList* s_listOfALmixerData = NULL;
+/* Special stuff for iOS interruption handling */
+static ALCcontext* s_interruptionContext = NULL;
 #ifdef __APPLE__
 static ALvoid Internal_alcMacOSXMixerOutputRate(const ALdouble sample_rate)
 {
 			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);
-		#elif ANDROID_NDK
 		#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_nsec - s_ticksBaseTime.tv_nsec) / 1000000);
 struct ALmixer_Data
 {
 	ALboolean decoded_all; /* dictates different behaviors */
-	ALint total_time; /* total playing time of sample (msec) */
+	ALint total_time; /* total playing time of sample (msec), obsolete now that we pushed our changes to SDL_sound */
 	ALuint in_use; /* needed to prevent sharing for streams */
 	ALboolean eof; /* flag for eof, only used for streams  */
 	ALuint total_bytes; /* For predecoded */
 	*/
 	ALmixer_Channel_List[channel].almixer_data = NULL;
 }
-#if 0
-/* Not needed anymore because not doing any fileext checks.
-*
-* Unfortunately, strcasecmp isn't portable so here's a
-* reimplementation of it (taken from SDL_sound)
-*/
-static int ALmixer_strcasecmp(const char* x, const char* y)
-{
-	int ux, uy;
-	if (x == y)  /* same pointer? Both NULL? */
-		return(0);
-	if (x == NULL)
-		return(-1);
-	if (y == NULL)
-		return(1);
-	do
-	{
-		ux = toupper((int) *x);
-		uy = toupper((int) *y);
-		if (ux > uy)
-			return(1);
-		else if (ux < uy)
-			return(-1);
-		x++;
-		y++;
-	} while ((ux) && (uy));
-return(0);
-}
-#endif
 /* What shoud this return?
 * 127 for signed, 255 for unsigned
 */
 static ALubyte GetSignednessValue(ALushort format)
 {
 }
 /* Converts milliseconds to byte positions.
 * This is needed for seeking on predecoded samples
 */
-static ALuint Convert_Msec_To_Byte_Pos(Sound_AudioInfo *info, ALuint ms)
+static ALuint Convert_Msec_To_Byte_Pos(Sound_AudioInfo* audio_info, ALuint number_of_milliseconds)
 {
-	float frames_per_ms;
+	ALuint bytes_per_sample;
-	ALuint frame_offset;
+	ALuint bytes_per_frame;
-	ALuint frame_size;
+	float bytes_per_millisecond;
-	if(info == NULL)
+	float byte_position;
+	if(audio_info == NULL)
 	{
 		fprintf(stderr, "Error, info is NULL\n");
 	}
-	/* "frames" == "sample frames" */
+	/* SDL has a mask trick I was not aware of. Mask the upper bits
-	frames_per_ms = ((float) info->rate) / 1000.0f;
+	 * of the format, and you get 8 or 16 which is the bits per sample.
-	frame_offset = (ALuint) (frames_per_ms * ((float) ms));
+	 * Divide by 8bits_per_bytes and you get bytes_per_sample
-	frame_size = (ALuint) ((info->format & 0xFF) / 8) * info->channels;
+	 * I tested this under 32-bit and 64-bit and big and little endian
-	return frame_offset * frame_size;
+	 * to make sure this still works since I have since moved from
+	 * Uint32 to unspecified size types like ALuint.
+	 */
+	bytes_per_sample = (ALuint) ((audio_info->format & 0xFF) / 8);
+	bytes_per_frame = bytes_per_sample * audio_info->channels;
+	bytes_per_millisecond = (float)bytes_per_frame * (audio_info->rate / 1000.0f);
+	byte_position = ((float)(number_of_milliseconds)) * bytes_per_millisecond;
+	return (ALuint)(byte_position + 0.5);
 }
 static ALint Set_Predecoded_Seek_Position(ALmixer_Data* data, ALuint byte_position)
 {
 	ALenum error;
 static ALint Internal_RewindSource(ALuint source)
 {
 	ALint channel;
 	if(0 == source)
 	{
-		return Internal_RewindChannel(-1) + 1;
+		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) + 1;
+	return Internal_RewindChannel(channel);
 }
 	return AL_TRUE;
 }
+static ALint Internal_SeekChannel(ALint channel, ALuint msec)
+{
+	ALint retval = 0;
+	ALenum error;
+	ALint state;
+	ALint running_count = 0;
+	if(0 == msec)
+	{
+		return Internal_RewindChannel(channel);
+	}
+	if(channel >= Number_of_Channels_global)
+	{
+		ALmixer_SetError("Cannot seek 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)
+			{
+				/* convert milliseconds to seconds */
+				ALfloat sec_offset = msec / 1000.0f;
+				alGetSourcei(
+							 ALmixer_Channel_List[channel].alsource,
+							 AL_SOURCE_STATE, &state
+							 );
+				if((error = alGetError()) != AL_NO_ERROR)
+				{
+					fprintf(stderr, "25Testing error: %s\n",
+							alGetString(error));
+				}
+				/* OpenAL seek */
+				alSourcef(ALmixer_Channel_List[channel].alsource, AL_SEC_OFFSET, sec_offset);
+				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_SeekData(ALmixer_Channel_List[channel].almixer_data, msec);
+			}
+		}
+	}
+	/* The user wants to rewind all channels */
+	else
+	{
+		ALint i;
+		ALfloat sec_offset = msec / 1000.0f;
+		for(i=0; i<Number_of_Channels_global; i++)
+		{
+			/* 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));
+					}
+					alSourcef(ALmixer_Channel_List[channel].alsource, AL_SEC_OFFSET, sec_offset);
+					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.
+					 */
+					running_count += Internal_SeekData(ALmixer_Channel_List[i].almixer_data, msec);
+				}
+			}
+		}
+	}
+	if(-1 == retval)
+	{
+		return -1;
+	}
+	else
+	{
+		return running_count;
+	}
+}
+static ALint Internal_SeekSource(ALuint source, ALuint msec)
+{
+	ALint channel;
+	if(0 == source)
+	{
+		return Internal_SeekChannel(-1, msec);
+	}
+	channel = Internal_GetChannel(source);
+	if(-1 == channel)
+	{
+		ALmixer_SetError("Cannot seek source: %s", ALmixer_GetError());
+		return 0;
+	}
+	return Internal_SeekChannel(channel, msec);
+}
 static ALint Internal_FadeInChannelTimed(ALint channel, ALmixer_Data* data, ALint loops, ALuint fade_ticks, ALint expire_ticks)
 {
 	ALfloat value;
 	ALenum error;
 #ifdef ENABLE_ALMIXER_THREADS
 	SDL_LockMutex(s_simpleLock);
 #endif
 	if(0 == ALmixer_Initialized)
+	{
+#ifdef ENABLE_ALMIXER_THREADS
+		SDL_UnlockMutex(s_simpleLock);
+#endif
+		return 0;
+	}
+	/* Bypass if in interruption event */
+	if(NULL == alcGetCurrentContext())
 	{
 #ifdef ENABLE_ALMIXER_THREADS
 		SDL_UnlockMutex(s_simpleLock);
 #endif
 		return 0;
 					 */
 					delta_time = current_time - ALmixer_Channel_List[i].fade_start_time;
 					t = (ALfloat) delta_time * ALmixer_Channel_List[i].fade_inv_time;
 					current_volume = (1.0f-t) * ALmixer_Channel_List[i].fade_start_volume
 						+ t * ALmixer_Channel_List[i].fade_end_volume;
+					/*
 					fprintf(stderr, "start_vol=%f, end_vol:%f, current_volume: %f\n", ALmixer_Channel_List[i].fade_start_volume, ALmixer_Channel_List[i].fade_end_volume, current_volume);
+					*/
 					/* Set the volume */
 					alSourcef(ALmixer_Channel_List[i].alsource,
 						AL_GAIN, current_volume);
 					if((error = alGetError()) != AL_NO_ERROR)
 					{
 * 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.
 */
-ALboolean ALmixer_Init(ALuint frequency, ALint num_sources, ALuint refresh)
+ALboolean ALmixer_Init(ALuint frequency, ALuint num_sources, ALuint refresh)
 {
 	ALCdevice* dev;
 	ALCcontext* context;
 	ALint i;
 	ALenum error;
 	 * (per source) at render timem at the expense of a larger memory footprint.
 	 *
 	 *	This feature is toggled on/off by using the alDisable() & alEnable() APIs. This
 	 *	setting will be applied to all subsequent
 	 *	calls to alBufferData().
+	 *
+	 * Update: Some people keep reporting that they see the enable fail on Mac, but I can't reproduce it myself.
+	 * Rather than deal with it right now, I think I am going to make it an opt-in thing.
 	 */
-#ifdef __APPLE__
+#if defined(__APPLE__) && defined(ALMIXER_USE_OSX_CONVERT_DATA_UPON_LOADING)
 /*
+iPhone is getting this enum, but is failing on the enable, so I guess I'll define it out.
+*/
 	#if (TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1)
 	#else
+		/* iOS reports this enum exists, but loading it always fails, so make it Mac only. */
+		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()) )
+		{
+			fprintf(stderr, "ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING attempted but failed");
+			ALmixer_SetError("ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING attempted but failed");
+		}
 	#endif
-*/
-	ALenum convert_data_enum = alcGetEnumValue(dev, "ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING");
+#endif /* __APPLE__ */
-	/*
-	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()) )
-	{
-	fprintf(stderr, "ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING attempted but failed");
-		ALmixer_SetError("ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING attempted but failed");
-	}
-#endif
 	ALmixer_Initialized = 1;
-	if(num_sources <= 0)
+	if(num_sources == 0)
 	{
 		Number_of_Channels_global = ALMIXER_DEFAULT_NUM_CHANNELS;
 	}
 	else
 	{
-		Number_of_Channels_global = num_sources;
+		/* probably should make Number_of_Channels_global an ALuint, but need to cast which_channel all the time */
+		Number_of_Channels_global = (ALint)num_sources;
 	}
 	Number_of_Reserve_Channels_global = 0;
 	Is_Playing_global = 0;
 	/* Set to Null in case system quit and was reinitialized */
 	Channel_Done_Callback = NULL;
 	 * (per source) at render timem at the expense of a larger memory footprint.
 	 *
 	 *	This feature is toggled on/off by using the alDisable() & alEnable() APIs. This
 	 *	setting will be applied to all subsequent
 	 *	calls to alBufferData().
+	 * Update: Some people keep reporting that they see the enable fail on Mac, but I can't reproduce it myself.
+	 * Rather than deal with it right now, I think I am going to make it an opt-in thing.
 	 */
-#ifdef __APPLE__
+#if defined(__APPLE__) && defined(ALMIXER_USE_OSX_CONVERT_DATA_UPON_LOADING)
 	/*
-	 #if (TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1)
+	 iPhone is getting this enum, but is failing on the enable, so I guess I'll define it out.
+	 */
+	#if (TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1)
-	 #else
+	#else
-	 #endif
+		/* iOS reports this enum exists, but loading it always fails, so make it Mac only. */
-	 */
+		ALenum convert_data_enum = alcGetEnumValue(dev, "ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING");
-	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);
-	fprintf(stderr, "ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING=0x%x", convert_data_enum);
+		 */
-	*/
+		if(0 != convert_data_enum)
-	if(0 != convert_data_enum)
+		{
-	{
+			alEnable(convert_data_enum);
-		alEnable(convert_data_enum);
+		}
-	}
+		if( (AL_NO_ERROR != alGetError()) )
-	if( (AL_NO_ERROR != alGetError()) )
+		{
-	{
+			fprintf(stderr, "ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING attempted but failed");
-		fprintf(stderr, "ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING attempted but failed");
+			ALmixer_SetError("ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING attempted but failed");
-		ALmixer_SetError("ALC_MAC_OSX_CONVERT_DATA_UPON_LOADING attempted but failed");
+		}
-	}
+	#endif
 #endif
 	return AL_TRUE;
 }
-ALboolean ALmixer_InitMixer(ALint num_sources)
+ALboolean ALmixer_InitMixer(ALuint num_sources)
 {
 	ALint i;
 	ALenum error;
 	ALuint* source;
 		fprintf(stderr, "tError Test1: %s\n", ALmixer_GetError());
 		fprintf(stderr, "tError Test2: %s\n", ALmixer_GetError());
 	 */
 #endif
-	if(num_sources <= 0)
+	if(num_sources == 0)
 	{
 		Number_of_Channels_global = ALMIXER_DEFAULT_NUM_CHANNELS;
 	}
 	else
 	{
-		Number_of_Channels_global = num_sources;
+		Number_of_Channels_global = (ALint)num_sources;
 	}
 	Number_of_Reserve_Channels_global = 0;
 	Is_Playing_global = 0;
 	/* Set to Null in case system quit and was reinitialized */
 	Channel_Done_Callback = NULL;
 	 */
 	free(source);
 	return AL_TRUE;
 }
+void ALmixer_BeginInterruption()
+{
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
+	s_interruptionContext = alcGetCurrentContext();
+	if(NULL != s_interruptionContext)
+	{
+		/* iOS alcSuspendContext is a no-op */
+		alcSuspendContext(s_interruptionContext);
+		alcMakeContextCurrent(NULL);
+	}
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
+}
+void ALmixer_EndInterruption()
+{
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
+	/* Note: iOS, you need to set the AudioSession active.
+	 * But if the AudioSession is not initialized, this SetActive
+	 * call fails.
+	 * So this is probably better if calling app sets this.
+	 */
+/*
+#if (TARGET_OS_IPHONE == 1) || (TARGET_IPHONE_SIMULATOR == 1)
+	OSStatus the_error = AudioSessionSetActive(true);
+	if(noErr != the_error)
+	{
+		fprintf(stderr, "Error setting audio session active! %d\n", the_error);
+	}
+#endif
+*/
+	if(NULL != s_interruptionContext)
+	{
+		alcMakeContextCurrent(s_interruptionContext);
+		alcProcessContext(s_interruptionContext);
+		s_interruptionContext = NULL;
+	}
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
+}
 /* Keep the return value void to allow easy use with
 * atexit()
 */
 void ALmixer_Quit()
 		return;
 	}
 #ifdef ENABLE_ALMIXER_THREADS
 	SDL_LockMutex(s_simpleLock);
 #endif
+	/* Several things we need to do:
+	 First, we need to check if we are in an interruption.
+	 If so, we need to reactivate the alcContext so we can call OpenAL functions.
+	 Next, we should delete the OpenAL sources.
+	 Next, we need to free all the sound data via ALmixer_FreeData().
+	 Finally, we can delete the OpenAL context.
+	 */
+	context = alcGetCurrentContext();
+	if(NULL == context)
+	{
+		/* We might have an interruption event where the current context is NULL */
+		if(NULL == s_interruptionContext)
+		{
+			/* Nothing left to try. I think we're done. */
+			fprintf(stderr, "ALmixer_Quit: Assertion Error. Expecting to find an OpenAL context, but could not find one.\n");
+			return;
+		}
+		else
+		{
+			context = s_interruptionContext;
+			/* reactivate the context so we can call OpenAL functions */
+			alcMakeContextCurrent(context);
+			s_interruptionContext = NULL;
+		}
+	}
 	/* Shutdown everything before closing context */
 	Internal_HaltChannel(-1, AL_FALSE);
 	/* This flag will cause the thread to terminate */
 	ALmixer_Initialized = 0;
 	SDL_UnlockMutex(s_simpleLock);
 	SDL_WaitThread(Stream_Thread_global, NULL);
 	SDL_DestroyMutex(s_simpleLock);
 #endif
 	/* Delete all the OpenAL sources */
 	for(i=0; i<Number_of_Channels_global; i++)
 	{
 		alDeleteSources(1, &ALmixer_Channel_List[i].alsource);
 	}
 	/* Delete all the channels */
 	free(ALmixer_Channel_List);
 	free(Source_Map_List);
 	/* Reset the Number_of_Channels just in case somebody
 	 * tries using a ALmixer function.
 	 * I probably should put "Initialized" checks everywhere,
 	 * but I'm too lazy at the moment.
 	 */
 	Number_of_Channels_global = 0;
-	context = alcGetCurrentContext();
-	if(NULL == context)
-	{
-		return;
-	}
-	/* Need to get the device before I close the context */
-	dev = alcGetContextsDevice(context);
-	alcDestroyContext(context);
-	if(NULL == dev)
-	{
-		return;
-	}
-	alcCloseDevice(dev);
 	/* Delete the list of ALmixerData's before Sound_Quit deletes
 	 * its own underlying information and I potentially have dangling pointers.
 	 */
 	while(LinkedList_Size(s_listOfALmixerData) > 0)
 	{
 		ALmixer_Data* almixer_data = LinkedList_Back(s_listOfALmixerData);
 		ALmixer_FreeData(almixer_data);
 	}
 	LinkedList_Free(s_listOfALmixerData);
 	s_listOfALmixerData = NULL;
+	/* Need to get the device before I close the context */
+	dev = alcGetContextsDevice(context);
+	alcMakeContextCurrent(NULL);
+	alcDestroyContext(context);
+	if(NULL == dev)
+	{
+		return;
+	}
+	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);
 			/* This information is for predecoded.
 			 * Set to 0, since we don't know.
 			 */
 			ret_data->total_bytes = 0;
+			ret_data->total_time = Sound_GetDuration(sample);
 			/* Create buffers for data
 			 */
 			ret_data->buffer = (ALuint*)malloc( sizeof(ALuint) * max_queue_buffers);
 			if(NULL == ret_data->buffer)
 			{
 	ALenum error;
 	if(NULL == data)
 	{
 		return;
 	}
+	/* Bypass if in interruption event */
+	if(NULL == alcGetCurrentContext())
+	{
+		fprintf(stderr, "ALmixer_FreeData: Programmer Error. You cannot delete data when the OpenAL content is currently NULL. You may have already called ALmixer_Quit() or are in an interruption event\n");
+		return;
+	}
 	if(data->decoded_all)
 	{
 		/* If access_data was enabled, then the Sound_Sample*
 		 * still exists. We need to free it
 		if(data->sample != NULL)
 		{
 			Sound_FreeSample(data->sample);
 		}
 		alDeleteBuffers(1, data->buffer);
-	if((error = alGetError()) != AL_NO_ERROR)
+		if((error = alGetError()) != AL_NO_ERROR)
-	{
+		{
-		fprintf(stderr, "70Testing error: %s\n",
+			fprintf(stderr, "ALmixer_FreeData: alDeleteBuffers failed. %s\n", alGetString(error));
-			alGetString(error));
+		}
-	}
 	}
 	else
 	{
 		ALuint i;
 			CircularQueueUnsignedInt_FreeQueue(data->circular_buffer_queue);
 		}
 		Sound_FreeSample(data->sample);
 		alDeleteBuffers(data->max_queue_buffers, data->buffer);
-	if((error = alGetError()) != AL_NO_ERROR)
+		if((error = alGetError()) != AL_NO_ERROR)
-	{
+		{
-		fprintf(stderr, "71Testing error: %s\n",
+			fprintf(stderr, "ALmixer_FreeData: alDeleteBuffers failed. %s\n", alGetString(error));
-			alGetString(error));
+		}
-	}
 	}
 	free(data->buffer);
 	LinkedList_Remove(s_listOfALmixerData,
 		LinkedList_Find(s_listOfALmixerData, data, NULL)
 {
 	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 */
 	SDL_UnlockMutex(s_simpleLock);
 #endif
 	return retval;
 }
+ALint ALmixer_SeekChannel(ALint channel, ALuint msec)
+{
+	ALint retval;
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
+	retval = Internal_SeekChannel(channel, msec);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
+	return retval;
+}
+ALint ALmixer_SeekSource(ALuint source, ALuint msec)
+{
+	ALint retval;
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_LockMutex(s_simpleLock);
+#endif
+	retval = Internal_SeekSource(source, msec);
+#ifdef ENABLE_ALMIXER_THREADS
+	SDL_UnlockMutex(s_simpleLock);
+#endif
+	return retval;
+}
 ALint ALmixer_FadeInChannelTimed(ALint channel, ALmixer_Data* data, ALint loops, ALuint fade_ticks, ALint expire_ticks)
 {
 	ALint retval;
 #ifdef ENABLE_ALMIXER_THREADS
 	SDL_LockMutex(s_simpleLock);

Mercurial > almixer_isolated

comparison ALmixer.c @ 22:58f03008ea05