almixer_isolated: ALmixer.c comparison

comparison ALmixer.c @ 12:bfe90b4f3d87

Bug fixes to FadeIn. Documentation fixes Minor API changes w.r.t. return types. (ALboolean instead of ALint)

author	Eric Wing <ewing . public \|-at-\| gmail . com>
date	Fri, 05 Nov 2010 20:59:13 -0700
parents	c808684660a7
children	54aa96ae8912

comparison

equal deleted inserted replaced

-:eca6f008fad0
+:bfe90b4f3d87
 	#include "SoundDecoder.h"
 #else
 	#include "SDL_sound.h"
 #endif
-#include "al.h" /* OpenAL */
+#ifdef ANDROID_NDK
-#include "alc.h" /* For creating OpenAL contexts */
+	#include <AL/al.h>
+	#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
 			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_nec - s_ticksBaseTime.tv_nsec) / 1000000);
+			return (ALuint)((current_time.tv_sec - s_ticksBaseTime.tv_sec)*1000.0 + (current_time.tv_nsec - s_ticksBaseTime.tv_nsec) / 1000000);
 		#endif
 	}
 	static void ALmixer_Delay(ALuint milliseconds_delay)
 	{
 		#if defined(_WIN32)
 /* 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 ALint Internal_RewindData(ALmixer_Data* data)
+static ALboolean 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;
+		return AL_FALSE;
 	}
 	/* Might have to require Halt */
 	/* Okay, we assume Halt or natural stop has already
 		data->eof = 0;
 #if 0
 #if defined(DISABLE_PREDECODED_SEEK)
 		/* Since we can't seek predecoded stuff, it should be rewound */
-		return 0;
+		return AL_TRUE;
 #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;
+			return AL_TRUE;
 		}
 		/* Else, the sample has already been reallocated,
 		 * and we can fall to normal behavior
 		 */
 #endif
 		 * If it's NULL, we can't do anything, but
 		 * it should already be "rewound".
 		 */
 		if(NULL == data->sample)
 		{
-			return 0;
+			return AL_TRUE;
 		}
 		/* 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;
+		return AL_TRUE;
 	}
 	/* Remaining stuff for streamed data */
 	data->eof = 0;
 	retval = Sound_Rewind(data->sample);
 	if(0 == retval)
 	{
 		ALmixer_SetError( Sound_GetError() );
-		return -1;
+		return AL_FALSE;
 	}
 #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;
+			return AL_FALSE;
 		}
 		else if(0 == bytes_returned)
 		{
-			return -1;
+			return AL_FALSE;
 		}
 		retval += bytes_returned;
 	}
 #endif
-	return retval;
+	return AL_TRUE;
 }
 static ALint Internal_RewindChannel(ALint channel)
 {
 	ALint retval = 0;
 	ALenum error;
 	ALint state;
+	ALint running_count = 0;
 	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;
 					 * 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);
+					running_count += Internal_RewindData(ALmixer_Channel_List[i].almixer_data);
 				}
 			}
 		}
 	}
-	return retval;
+	if(-1 == retval)
+	{
+		return -1;
+	}
+	else
+	{
+		return running_count;
+	}
 }
 static ALint Internal_RewindSource(ALuint source)
 {
 /* 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 ALint Internal_SeekData(ALmixer_Data* data, ALuint msec)
+static ALboolean Internal_SeekData(ALmixer_Data* data, ALuint msec)
 {
 	ALint retval;
 	if(NULL == data)
 	{
 		ALmixer_SetError("Cannot Seek because data is NULL");
-		return -1;
+		return AL_FALSE;
 	}
 	/* Seek for predecoded files involves moving the chunk pointer around */
 	if(data->decoded_all)
 	{
 		 * I can't shut them down myself, so I have to return an error.
 		 */
 		if(data->in_use)
 		{
 			ALmixer_SetError("Cannot seek on predecoded data while instances are playing");
-			return -1;
+			return AL_FALSE;
 		}
 #if 0
 #if defined(DISABLE_PREDECODED_SEEK)
 		ALmixer_SetError("Seek support for predecoded samples was not compiled in");
-		return -1;
+		return AL_FALSE;
 #elif !defined(DISABLE_SEEK_MEMORY_OPTIMIZATION)
 		/* By default, ALmixer frees the Sound_Sample for predecoded
 		 * samples because of the potential memory waste.
 		 * However, to seek a sample, we need to have a full
 		 */
 		if(NULL == data->sample)
 		{
 			if( -1 == Reconstruct_Sound_Sample(data) )
 			{
-				return -1;
+				return AL_FALSE;
 			}
 		}
 #endif
 #endif
 		/* If access_data was set, then we still have the
 		 * get access to the buffers
 		 */
 		if(NULL == data->sample)
 		{
 			ALmixer_SetError("Cannot seek because access_data flag was set false when data was initialized");
-			return -1;
+			return AL_FALSE;
 		}
 		byte_position = Convert_Msec_To_Byte_Pos(&data->sample->desired, msec);
-		return( Set_Predecoded_Seek_Position(data, byte_position) );
+		retval = Set_Predecoded_Seek_Position(data, byte_position);
+		if(-1 == retval)
+		{
+			return AL_FALSE;
+		}
+		else
+		{
+			return AL_TRUE;
+		}
 	}
 	else
 	{
 		/* Reset eof flag?? */
 		data->eof = 0;
 		fprintf(stderr, "Sound seek error: %s\n", ALmixer_GetError());
 			/* Try rewinding to clean up? */
 /*
 			Internal_RewindData(data);
 */
-			return -1;
+			return AL_FALSE;
 		}
-		return 0;
+		return AL_TRUE;
 	}
-	return 0;
+	return AL_TRUE;
 }
 static ALint Internal_FadeInChannelTimed(ALint channel, ALmixer_Data* data, ALint loops, ALuint fade_ticks, ALint expire_ticks)
 					 * so t = current_time-start_time / (end_time-start_time)
 					 *
 					 */
 					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_MAX_GAIN, current_volume);
+						AL_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",
 								alGetString(error));
 					}
 /* 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
 */
-ALint ALmixer_RewindData(ALmixer_Data* data)
+ALboolean ALmixer_RewindData(ALmixer_Data* data)
 {
-	ALint retval;
+	ALboolean retval;
 #ifdef ENABLE_ALMIXER_THREADS
 	SDL_LockMutex(s_simpleLock);
 #endif
 	retval = Internal_RewindData(data);
 #ifdef ENABLE_ALMIXER_THREADS
 }
 /* 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 */
-ALint ALmixer_SeekData(ALmixer_Data* data, ALuint msec)
+ALboolean ALmixer_SeekData(ALmixer_Data* data, ALuint msec)
 {
-	ALint retval;
+	ALboolean retval;
 #ifdef ENABLE_ALMIXER_THREADS
 	SDL_LockMutex(s_simpleLock);
 #endif
 	retval = Internal_SeekData(data, msec);
 #ifdef ENABLE_ALMIXER_THREADS

Mercurial > almixer_isolated

comparison ALmixer.c @ 12:bfe90b4f3d87