almixer_isolated: ALmixer.c comparison

comparison ALmixer.c @ 6:4b1048af7e55

Disabled some of the debugging printfs

author	Eric Wing <ewing . public \|-at-\| gmail . com>
date	Thu, 28 Oct 2010 02:32:46 -0700
parents	a929285e1db0
children	c808684660a7

comparison

equal deleted inserted replaced

-:8cb13d89451a
+:4b1048af7e55
 	{
 		fprintf(stderr, "Error in PrintQueueStatus, Can't get buffers_processed: %s\n",
 			alGetString(error));
 	}
+	/*
 	fprintf(stderr, "For source: %d, buffers_queued=%d, buffers_processed=%d\n",
 			source,
 			buffers_queued,
 			buffers_processed);
+*/
 }
 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].needs_stream = 0;
 	ALmixer_Channel_List[channel].paused = 0;
 	ALmixer_Channel_List[channel].halted = 0;
 		data->sample->desired.format,
 		AL_FALSE
 	);
 }
-/* From SDL_Sound's playsound. Converts milliseconds to byte positions.
+/* 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)
 {
 	float frames_per_ms;
 	ALuint frame_offset;
 	ALuint frame_size;
-	fprintf(stderr, "In convert\n" );
 	if(info == NULL)
 	{
 		fprintf(stderr, "Error, info is NULL\n");
 	}
-	else
-	{
-		fprintf(stderr, "Not an error: info is not 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 = (ALuint) (frames_per_ms * ((float) ms));
-	fprintf(stderr, "%d\n", frame_offset);
 	frame_size = (ALuint) ((info->format & 0xFF) / 8) * info->channels;
-	fprintf(stderr, "%d\n", frame_size);
+	return frame_offset * frame_size;
-	return(frame_offset * frame_size);
+}
-} /* cvtMsToBytePos */
 static ALint Set_Predecoded_Seek_Position(ALmixer_Data* data, ALuint byte_position)
 {
 	ALenum error;
 	/* clear error */
 	/* Is it greater than,  or greater-than or equal to ?? */
 	if(byte_position > data->total_bytes)
 	{
 		/* We can't go past the end, so set to end? */
+		/*
 	fprintf(stderr, "Error, can't seek past end\n");
+	*/
 	/* In case the below thing doesn't work,
 	 * just rewind the whole thing.
 	 *
 		alBufferData(data->buffer[0],
 			TranslateFormat(&data->sample->desired),
 		return -1;
 	}
 	index = LookUpBuffer(buffer, data->buffer_map_list, data->max_queue_buffers);
 	if(-1 == index)
 	{
+		/*
 fprintf(stderr, ">>>>>>>CopyData catch, albuffer=%d\n",buffer);
+*/
 		return -1;
 	}
 	/* Copy the data to the access buffer */
 	memcpy(data->buffer_map_list[index].data, data->sample->buffer, num_bytes);
 	data->buffer_map_list[index].num_bytes = data->sample->buffer_size;
 		 */
 		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;
 	}
 /*********** END EXPERIMENT ******************************/
 /******* END REMOVE ME ********************************/
 #endif
 		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)
 			 * 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)
 	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));
 				 * 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)
 					}
 				}
 				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++;
 			}
 	/* 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;
 		*/
 	}
 		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++)
 	{
 	}
 #endif
-fprintf(stderr, "end Rewinding for stream\n");
 	return retval;
 }
 	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
 		 * before the last buffer is filled.
 		 * Stop conditions are we run out of
 		 * data or we max out our preload buffers.
 		 */
+		/*
 	fprintf(stderr, "Filling buffer #%d (AL id is %d)\n", 0, data->buffer[0]);
+	*/
 		for(j=1; j<data->num_startup_buffers; j++)
 		{
+	/*
 	fprintf(stderr, "Filling buffer #%d (AL id is %d)\n", j, data->buffer[j]);
-	/*
 	fprintf(stderr, ">>>>>>>>>>>>>>>>>>HACK for GetMoreData2\n");
 	*/
 		bytes_returned = GetMoreData(
 				data,
 				data->buffer[j]);
 			{
 				/* No more data to buffer */
 				/* Check for loops */
 				if( ALmixer_Channel_List[channel].loops != 0 )
 				{
+					/*
 fprintf(stderr, "Need to rewind. In RAMPUP, handling loop\n");
+*/
 					if(0 == Sound_Rewind(data->sample))
 					{
 fprintf(stderr, "error in rewind\n");
 						ALmixer_SetError( Sound_GetError() );
 						ALmixer_Channel_List[channel].loops = 0;
 					/* Remember to reset the data->eof flag */
 					data->eof = 0;
 					if(ALmixer_Channel_List[channel].loops > 0)
 					{
 						ALmixer_Channel_List[channel].loops--;
+						/*
 fprintf(stderr, "Inside 000 >>>>>>>>>>Loops=%d\n", ALmixer_Channel_List[channel].loops);
+*/
 					}
 					/* Would like to redo the loop, but due to
 					 * Sound_Rewind() bugs, we would risk falling
 					 * into an infinite loop
 					 */
 	alGetError();
 	/* If the user specified a specific channel */
 	if(channel >= 0)
 	{
-		fprintf(stderr, "Pause on channel %d\n", channel);
 		/* only need to process channel if in use */
 		if(ALmixer_Channel_List[channel].channel_in_use)
 		{
 			/* We don't want to repause if already
 			 * paused because the fadeout/expire
 	else
 	{
 		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 */
 			if(ALmixer_Channel_List[i].channel_in_use)
 			{
 				/* We don't want to repause if already
 				 * paused because the fadeout/expire
 				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",
 							alGetString(error) );
 	alGetError();
 	/* If the user specified a specific channel */
 	if(channel >= 0)
 	{
-		fprintf(stderr, "Pause on channel %d\n", channel);
 		/* only need to process channel if in use */
 		if(ALmixer_Channel_List[channel].channel_in_use)
 		{
 			alGetSourcei(
 				ALmixer_Channel_List[channel].alsource,
 					ALmixer_SetError("%s",
 						alGetString(error) );
 					retval = -1;
 				}
 			}
-		fprintf(stderr, "Pause on channel %d, channel in use\n", channel);
 		}
 	}
 	/* The user wants to halt all channels */
 	else
 	{
 		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 */
 			if(ALmixer_Channel_List[i].channel_in_use)
 			{
-	fprintf(stderr, "SourcePause %d\n", i);
 				alGetSourcei(
 					ALmixer_Channel_List[i].alsource,
 					AL_SOURCE_STATE, &state
 				);
 	if((error = alGetError()) != AL_NO_ERROR)
 		{
 			ALmixer_SetError("Cannot seek because access_data flag was set false when data was initialized");
 			return -1;
 		}
-		fprintf(stderr, "Calling convert\n");
 		byte_position = Convert_Msec_To_Byte_Pos(&data->sample->desired, msec);
-		fprintf(stderr, "Calling Set_Predecoded_Seek...%d\n", byte_position);
 		return( Set_Predecoded_Seek_Position(data, byte_position) );
 	}
 	else
 	{
 		/* Reset eof flag?? */
 	{
 		fprintf(stderr, "36Testing error: %s\n",
 			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_GAIN, value);
 	if((error = alGetError()) != AL_NO_ERROR)
 	/* Enable fading effects via the flag */
 	ALmixer_Channel_List[channel].fade_enabled = 1;
 	/* Set fade start time */
 	ALmixer_Channel_List[channel].fade_start_time
 		= ALmixer_Channel_List[channel].start_time;
-	fprintf(stderr, "Current time =%d\n", current_time);
 	/* Set the fade expire ticks */
 	ALmixer_Channel_List[channel].fade_expire_ticks = fade_ticks;
 	/* Set 1/(endtime-starttime) or 1/deltaT */
 	ALmixer_Channel_List[channel].fade_inv_time = 1.0f / fade_ticks;
 	{
 		fprintf(stderr, "41Testing error: %s\n",
 			alGetString(error));
 	}
 			ALmixer_Channel_List[channel].fade_end_volume = value;
-			fprintf(stderr, "MIN gain: %f\n", value);
 			/* Set expire start time */
 			ALmixer_Channel_List[channel].start_time = current_time;
 			/* Set the expire ticks */
 			ALmixer_Channel_List[channel].expire_ticks = ticks;
 	{
 		fprintf(stderr, "43Testing error: %s\n",
 			alGetString(error));
 	}
 				ALmixer_Channel_List[i].fade_end_volume = value;
-				fprintf(stderr, "MIN gain: %f\n", value);
 				/* Set expire start time */
 				ALmixer_Channel_List[i].start_time = current_time;
 				/* Set the expire ticks */
 				ALmixer_Channel_List[i].expire_ticks = ticks;
 				#if 0
 					else if(0 == bytes_returned)
 				#endif
 					if(0 == bytes_returned)
 					{
+						/*
 				fprintf(stderr, "We got 0 bytes from reading. Checking for loops\n");
+				*/
 						/* Check for loops */
 						if( ALmixer_Channel_List[i].loops != 0 )
 						{
 							/* We have to loop, so rewind
 							 * and fetch more data
 							 */
+							/*
 				fprintf(stderr, "Rewinding data\n");
+				*/
 							if(0 == Sound_Rewind(
 								ALmixer_Channel_List[i].almixer_data->sample))
 							{
 				fprintf(stderr, "Rewinding failed\n");
 								ALmixer_SetError( Sound_GetError() );
 							 * buffer, we don't want to lose it.
 							 */
 							if(ALmixer_Channel_List[i].almixer_data->num_buffers_in_use
 								< ALmixer_Channel_List[i].almixer_data->max_queue_buffers)
 							{
+								/*
 				fprintf(stderr, "We got %d bytes from reading loop. Filling unused packet\n", bytes_returned);
+				*/
 								/* Grab next packet */
 								bytes_returned = GetMoreData(
 									ALmixer_Channel_List[i].almixer_data,
 										ALmixer_Channel_List[i].almixer_data->buffer[
 										ALmixer_Channel_List[i].almixer_data->num_buffers_in_use]
 								);
+								/*
 				fprintf(stderr, "We reread %d bytes into unused packet\n", bytes_returned);
+				*/
 							}
 							/* Refilling unqueued packet */
 							else
 							{
+								/*
 				fprintf(stderr, "We got %d bytes from reading loop. Filling unqueued packet\n", bytes_returned);
+				*/
 								/* Grab next packet */
 								bytes_returned = GetMoreData(
 									ALmixer_Channel_List[i].almixer_data,
 									unqueued_buffer_id);
+								/*
 				fprintf(stderr, "We reread %d bytes into unqueued packet\n", bytes_returned);
+				*/
 							}
 							/* Another error check */
 							/*
 							if(bytes_returned <= 0)
 							*/
 						 * to have to create an array for the
 						 * unqueued_buffer_id's
 						 */
 						for(temp_count=0; temp_count<buffers_processed; temp_count++)
 						{
+							/*
 							fprintf(stderr, "unqueuing remainder, %d\n", temp_count);
+							*/
 							alSourceUnqueueBuffers(
 								ALmixer_Channel_List[i].alsource,
 								1, &unqueued_buffer_id
 							);
 							if((error = alGetError()) != AL_NO_ERROR)
 							{
 								fprintf(stderr, "59Testing error: %s\n",
 										alGetString(error));
 							}
 						}
+						/*
 						fprintf(stderr, "done unqueuing remainder for this loop, %d\n", temp_count);
+						*/
 						/* Need to update counts since we removed everything.
 						 * If we don't update the counts here, we end up in the
 						 *	"Shouldn't be here section, but maybe it's okay due to race conditions"
 						 */
 						alGetSourcei(
 		fprintf(stderr, "61Testing error: %s\n",
 			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);
+		*/
 /*
 							PrintQueueStatus(ALmixer_Channel_List[i].alsource);
 */
 							/* Rather than force unqueuing the buffer, let's see if
 							* setting the buffer to none works (the OpenAL 1.0
 		{
 			/* should I also be sleeping/yielding here? */
 			ALmixer_Delay(0);
 		}
 	}
+	/*
 fprintf(stderr, "Thread is closing\n");
+*/
 	return 0;
 }
 #endif /* End of ENABLE_ALMIXER_THREADS */
 	/* Make sure ALmixer isn't already initialized */
 	if(ALmixer_Initialized)
 	{
 		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 */
 	}
 	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 */
 /*
 		else
 		{
 			SIGN_TYPE_8BIT_FORMAT = AUDIO_U8;
 		}
 		SDL_CloseAudio();
-fprintf(stderr, "Obtained format = %d", obtained.format);
 	}
 	else
 	{
 		/* Well, I guess I'm in trouble. I guess it's my best guess
 		 */
 	sprintf(device_string, "'((sampling-rate %d))", attrlist[1]);
 	dev = alcOpenDevice(  (const ALubyte *) device_string );
 #else
 	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 AL_FALSE;
 	}
 	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 AL_FALSE;
 	}
-	fprintf(stderr, "Context checking...\n");
 	/* Hmmm, OSX is returning 1 on alcMakeContextCurrent,
 	 * but ALC_NO_ERROR is defined to ALC_FALSE.
 	 * According to Garin Hiebert, this is actually an inconsistency
 /*
 	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? */
 	}
 #endif
 /* #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
 	 * try it out.
 	 * ***** ALC_CONVERT_DATA_UPON_LOADING
 	 * This extension allows the caller to tell OpenAL to preconvert to the native Core
 	#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()) )
 	{
+	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
 	/* The Source_Map_List must be sorted by source for binary searches
 	 */
 	qsort(Source_Map_List, Number_of_Channels_global, sizeof(Source_Map), Compare_Source_Map);
-	fprintf(stderr, "Sorted Source_Map_List is:\n");
+	/*
-	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();
+*/
 #ifdef ENABLE_ALMIXER_THREADS
 	s_simpleLock = SDL_CreateMutex();
 	if(NULL == s_simpleLock)
 	{
 		/* SDL sets the error message already? */
 		ALmixer_Initialized = 0;
 		Number_of_Channels_global = 0;
 		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
 	 */
 	/* Make sure ALmixer isn't already initialized */
 	if(ALmixer_Initialized)
 	{
 		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
 	/* Set the defaults */
 	attrlist[0] = ALC_FREQUENCY;
 	attrlist[1] = ALMIXER_DEFAULT_FREQUENCY;
 	attrlist[2] = ALC_SYNC;
 		else
 		{
 			SIGN_TYPE_8BIT_FORMAT = AUDIO_U8;
 		}
 		SDL_CloseAudio();
-fprintf(stderr, "Obtained format = %d", obtained.format);
 	}
 	else
 	{
 		/* Well, I guess I'm in trouble. I guess it's my best guess
 		 */
 	sprintf(device_string, "'((sampling-rate %d))", attrlist[1]);
 	dev = alcOpenDevice(  (const ALubyte *) device_string );
 #else
 	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 AL_FALSE;
 	}
 	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)
 	 * 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
+	*/
+#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
 	 * try it out.
 	 * ***** ALC_CONVERT_DATA_UPON_LOADING
 	 #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()) )
 	{
+		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
 	return AL_TRUE;
 	/* The Source_Map_List must be sorted by source for binary searches
 	 */
 	qsort(Source_Map_List, Number_of_Channels_global, sizeof(Source_Map), Compare_Source_Map);
-	fprintf(stderr, "Sorted Source_Map_List is:\n");
-	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");
 #ifdef ENABLE_ALMIXER_THREADS
 	s_simpleLock = SDL_CreateMutex();
 	if(NULL == s_simpleLock)
 	{
 		ALmixer_Initialized = 0;
 		Number_of_Channels_global = 0;
 		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
 	 */
 	}
 #ifdef ENABLE_ALMIXER_THREADS
 	SDL_LockMutex(s_simpleLock);
 #endif
 	/* Shutdown everything before closing context */
-	fprintf(stderr, "Halting channels\n");
 	Internal_HaltChannel(-1, AL_FALSE);
 	/* This flag will cause the thread to terminate */
 	ALmixer_Initialized = 0;
 #ifdef ENABLE_ALMIXER_THREADS
 	SDL_UnlockMutex(s_simpleLock);
-	fprintf(stderr, "Closing thread\n");
 	SDL_WaitThread(Stream_Thread_global, NULL);
-	fprintf(stderr, "Destroying mutex\n");
 	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++)
 	{
-	fprintf(stderr, "Deleting OpenAL source: %d\n", ALmixer_Channel_List[i].alsource);
 		alDeleteSources(1, &ALmixer_Channel_List[i].alsource);
 	}
 	/* Delete all the channels */
 	free(ALmixer_Channel_List);
 	free(Source_Map_List);
 		 * decoded, so we can treat it like one.
 		 */
 		if(sample->flags & SOUND_SAMPLEFLAG_EOF)
 		{
+			/*
 	fprintf(stderr, "We got LUCKY! File is predecoded even though STREAM was requested\n");
+*/
 			ret_data->decoded_all = 1;
 			/* Need to keep this information around for
 			 * seek and rewind abilities.
 			 */
 			ret_data->total_bytes = bytes_decoded;
 		}
 		/* Else, we need to stream the data, so we'll
 		 * create multple buffers for queuing */
 		else
 		{
+			/*
 	fprintf(stderr, "Loading streamed data (not lucky)\n");
+	*/
 			ret_data->decoded_all = 0;
 			/* This information is for predecoded.
 			 * Set to 0, since we don't know.
 			 */
 		} /* End of do stream */
 	} /* end of DECODE_STREAM */
 	/* User requested decode all (easy, nothing to figure out) */
 	else if(AL_TRUE == decode_mode_is_predecoded)
 	{
-#ifndef ALMIXER_DISABLE_PREDECODED_PRECOMPUTE_BUFFER_SIZE_OPTIMIZATION
+#ifdef 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,
 			Sound_FreeSample(sample);
 			free(ret_data->buffer);
 			free(ret_data);
 			return NULL;
 		}
+		/*
 		fprintf(stderr, "Actual rate=%d, desired=%d\n", sample->actual.rate, sample->desired.rate);
+*/
 		/* Now copy the data to the OpenAL buffer */
 		/* We can't just set a pointer because the API needs
 		 * its own copy to assist hardware acceleration */
 		alBufferData(ret_data->buffer[0],
 			TranslateFormat(&sample->desired),
 		 * so don't do anything.
 		 */
 #endif
 #endif
-fprintf(stderr, "Made it\n");
 		/* okay we're done here */
 	}
 	else
 	{
 		/* Shouldn't get here */
 		Sound_FreeSample(sample);
 		free(ret_data);
 		return NULL;
 	}
-fprintf(stderr, "Returning data\n");
 	return ret_data;
 }
 /* This will load a sample for us. Most of the uglyness is
 	{
 		ALmixer_SetError(Sound_GetError());
 		return NULL;
 	}
+	/*
 		fprintf(stderr, "Correction test: Actual rate=%d, desired=%d, actual format=%d, desired format=%d\n", sample->actual.rate, sample->desired.rate, sample->actual.format, sample->desired.format);
+*/
 	return( DoLoad(sample, buffersize, decode_mode_is_predecoded, max_queue_buffers, num_startup_buffers, access_data));
 }
 /* This is a back door for RAW samples or if you need the

Mercurial > almixer_isolated

comparison ALmixer.c @ 6:4b1048af7e55