gosu 1.4.5.pre1 → 1.4.5

data/dependencies/SDL_sound/SDL_sound_coreaudio.c

@@ -12,7 +12,6 @@
 #if SOUND_SUPPORTS_COREAUDIO
 
 #include <stddef.h> /* NULL */
-#include <arpa/inet.h> /* htonl */
 #include <AudioToolbox/AudioToolbox.h>
 
 typedef struct CoreAudioFileContainer
@@ -153,13 +152,13 @@ static AudioFileTypeID CoreAudio_GetAudioTypeForExtension(const char* file_exten
 	{
 		return 0;
 	}
-
 }
 
-static const char* CoreAudio_FourCCToString(int32_t error_code)
+#ifdef DEBUG_CHATTER /* used with SNDDBG() */
+static const char* CoreAudio_FourCCToString(Sint32 error_code)
 {
 	static char return_string[16];
-	uint32_t big_endian_code = htonl(error_code);
+	Uint32 big_endian_code = SDL_SwapBE32((Uint32)error_code);
 	char* big_endian_str = (char*)&big_endian_code;
 	// see if it appears to be a 4-char-code
 	if(isprint(big_endian_str[0])
@@ -187,7 +186,7 @@ static const char* CoreAudio_FourCCToString(int32_t error_code)
 	}
 	return return_string;
 }
-
+#endif
 
 
 SInt64 CoreAudio_SizeCallback(void* inClientData)
@@ -229,12 +228,10 @@ static int CoreAudio_open(Sound_Sample *sample, const char *ext)
 	AudioStreamBasicDescription	output_format;
 	Float64 estimated_duration;
 	UInt32 format_size;
-	
 
 	core_audio_file_container = (CoreAudioFileContainer*)SDL_malloc(sizeof(CoreAudioFileContainer));
 	BAIL_IF_MACRO(core_audio_file_container == NULL, ERR_OUT_OF_MEMORY, 0);
 
-
 	audio_file_id = (AudioFileID*)SDL_malloc(sizeof(AudioFileID));
 	BAIL_IF_MACRO(audio_file_id == NULL, ERR_OUT_OF_MEMORY, 0);
 
@@ -255,15 +252,15 @@ static int CoreAudio_open(Sound_Sample *sample, const char *ext)
 		SNDDBG(("Core Audio: can't grok data. reason: [%s].\n", CoreAudio_FourCCToString(error_result)));
 		BAIL_MACRO("Core Audio: Not valid audio data.", 0);
 	} /* if */
-	
-    format_size = sizeof(actual_format);
-    error_result = AudioFileGetProperty(
+
+	format_size = sizeof(actual_format);
+	error_result = AudioFileGetProperty(
 		*audio_file_id,
 		kAudioFilePropertyDataFormat,
 		&format_size,
 		&actual_format
 	);
-    if (error_result != noErr)
+	if (error_result != noErr)
 	{
 		AudioFileClose(*audio_file_id);
 		SDL_free(audio_file_id);
@@ -272,14 +269,14 @@ static int CoreAudio_open(Sound_Sample *sample, const char *ext)
 		BAIL_MACRO("Core Audio: Not valid audio data.", 0);
 	} /* if */
 
-    format_size = sizeof(estimated_duration);
-    error_result = AudioFileGetProperty(
+	format_size = sizeof(estimated_duration);
+	error_result = AudioFileGetProperty(
 		*audio_file_id,
 		kAudioFilePropertyEstimatedDuration,
 		&format_size,
 		&estimated_duration
 	);
-    if (error_result != noErr)
+	if (error_result != noErr)
 	{
 		AudioFileClose(*audio_file_id);
 		SDL_free(audio_file_id);
@@ -288,61 +285,65 @@ static int CoreAudio_open(Sound_Sample *sample, const char *ext)
 		BAIL_MACRO("Core Audio: Not valid audio data.", 0);
 	} /* if */
 
-
 	core_audio_file_container->audioFileID = audio_file_id;
-	
+
 	internal->decoder_private = core_audio_file_container;
-	
+
 	sample->flags = SOUND_SAMPLEFLAG_CANSEEK;
 	sample->actual.rate = (UInt32) actual_format.mSampleRate;
 	sample->actual.channels = (UInt8)actual_format.mChannelsPerFrame;
 	internal->total_time = (SInt32)(estimated_duration * 1000.0 + 0.5);
 
-#if 0
-	/* FIXME: Both Core Audio and SDL 1.3 support float and 32-bit formats */
-	if(actual_format.mFormatFlags & kAudioFormatFlagIsBigEndian)
+	if(0 == sample->desired.format)
 	{
-		if(16 == actual_format.mBitsPerChannel)
+		if(32 == actual_format.mBitsPerChannel)
 		{
-			if(kAudioFormatFlagIsSignedInteger & actual_format.mFormatFlags)
+			if(kAudioFormatFlagIsFloat & actual_format.mFormatFlags)
 			{
-				sample->actual.format = AUDIO_S16MSB;
+				if(actual_format.mFormatFlags & kAudioFormatFlagIsBigEndian)
+				{
+					sample->actual.format = AUDIO_F32MSB;
+				}
+				else
+				{
+					sample->actual.format = AUDIO_F32LSB;
+				}
 			}
 			else
 			{
-				sample->actual.format = AUDIO_U16MSB;				
+				if(actual_format.mFormatFlags & kAudioFormatFlagIsBigEndian)
+				{
+					sample->actual.format = AUDIO_S32MSB;
+				}
+				else
+				{
+					sample->actual.format = AUDIO_S32LSB;
+				}
 			}
 		}
-		else if(8 == actual_format.mBitsPerChannel)
+		else if(16 == actual_format.mBitsPerChannel)
 		{
 			if(kAudioFormatFlagIsSignedInteger & actual_format.mFormatFlags)
 			{
-				sample->actual.format = AUDIO_S8;
+				if(actual_format.mFormatFlags & kAudioFormatFlagIsBigEndian)
+				{
+					sample->actual.format = AUDIO_S16MSB;
+				}
+				else
+				{
+					sample->actual.format = AUDIO_S16LSB;
+				}
 			}
 			else
 			{
-				sample->actual.format = AUDIO_U8;				
-			}
-		}
-		else // might be 0 for undefined? 
-		{
-			// This case seems to come up a lot for me. Maybe for file types like .m4a?
-			sample->actual.format = AUDIO_S16SYS;
-			SNDDBG(("Core Audio: Unsupported actual_format.mBitsPerChannel: [%d].\n", actual_format.mBitsPerChannel));
-			
-		}
-	}
-	else // little endian
-	{
-		if(16 == actual_format.mBitsPerChannel)
-		{
-			if(kAudioFormatFlagIsSignedInteger & actual_format.mFormatFlags)
-			{
-				sample->actual.format = AUDIO_S16LSB;
-			}
-			else
-			{
-				sample->actual.format = AUDIO_U16LSB;				
+				if(actual_format.mFormatFlags & kAudioFormatFlagIsBigEndian)
+				{
+					sample->actual.format = AUDIO_U16MSB;
+				}
+				else
+				{
+					sample->actual.format = AUDIO_U16LSB;
+				}
 			}
 		}
 		else if(8 == actual_format.mBitsPerChannel)
@@ -353,39 +354,38 @@ static int CoreAudio_open(Sound_Sample *sample, const char *ext)
 			}
 			else
 			{
-				sample->actual.format = AUDIO_U8;				
+				sample->actual.format = AUDIO_U8;
 			}
 		}
-		else // might be 0 for undefined? 
+		else // might be 0 for undefined?
 		{
+			// This case seems to come up a lot for me. Maybe for file types like .m4a?
 			sample->actual.format = AUDIO_S16SYS;
-			
 			SNDDBG(("Core Audio: Unsupported actual_format.mBitsPerChannel: [%d].\n", actual_format.mBitsPerChannel));
 		}
-
 	}
-#else
-	
-	
-	
-    /*
-     * I want to use Core Audio to do conversion and decoding for performance reasons.
-	 * This is particularly important on mobile devices like iOS.
-	 * Taking from the Ogg Vorbis decode, I pretend the "actual" format is the same 
-	 * as the desired format. 
-     */
-    sample->actual.format = (sample->desired.format == 0) ?
-	AUDIO_S16SYS : sample->desired.format;
-#endif	
+	else
+	{
+		/*
+		 * I want to use Core Audio to do conversion and decoding for performance reasons.
+		 * This is particularly important on mobile devices like iOS.
+		 * Taking from the Ogg Vorbis decode, I pretend the "actual" format is the same
+		 * as the desired format.
+		 */
+		sample->actual.format = sample->desired.format;
+	}
 
+	/* AUDIO_U16LSB and AUDIO_U16MSB don't seem to be supported by CoreAudio. */
+	if (sample->actual.format == AUDIO_U16LSB)
+		sample->actual.format = AUDIO_S16LSB;
+	if (sample->actual.format == AUDIO_U16MSB)
+		sample->actual.format = AUDIO_S16MSB;
 
 	SNDDBG(("CoreAudio: channels == (%d).\n", sample->actual.channels));
 	SNDDBG(("CoreAudio: sampling rate == (%d).\n",sample->actual.rate));
 	SNDDBG(("CoreAudio: total seconds of sample == (%d).\n", internal->total_time));
 	SNDDBG(("CoreAudio: sample->actual.format == (%d).\n", sample->actual.format));
 
-
-	
 	error_result = ExtAudioFileWrapAudioFileID(*audio_file_id,
 		false, // set to false for read-only
 		&core_audio_file_container->extAudioFileRef
@@ -399,7 +399,6 @@ static int CoreAudio_open(Sound_Sample *sample, const char *ext)
 		BAIL_MACRO("Core Audio: Failed to wrap data.", 0);
 	} /* if */
 
-
 	/* The output format must be linear PCM because that's the only type OpenAL knows how to deal with.
 	 * Set the client format to 16 bit signed integer (native-endian) data because that is the most
 	 * optimal format on iPhone/iPod Touch hardware.
@@ -408,74 +407,37 @@ static int CoreAudio_open(Sound_Sample *sample, const char *ext)
 	output_format.mSampleRate = actual_format.mSampleRate; // preserve the original sample rate
 	output_format.mChannelsPerFrame = actual_format.mChannelsPerFrame; // preserve the number of channels
 	output_format.mFormatID = kAudioFormatLinearPCM; // We want linear PCM data
+	output_format.mFormatFlags = kAudioFormatFlagIsPacked; // I seem to read failures problems without kAudioFormatFlagIsPacked. From a mailing list post, this seems to be a Core Audio bug.
 	output_format.mFramesPerPacket = 1; // We know for linear PCM, the definition is 1 frame per packet
+	output_format.mBitsPerChannel = SDL_AUDIO_BITSIZE(sample->actual.format);
 
-	if(sample->desired.format == 0)
+	if(SDL_AUDIO_ISFLOAT(sample->actual.format))
 	{
-		// do AUDIO_S16SYS
-		output_format.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked; // I seem to read failures problems without kAudioFormatFlagIsPacked. From a mailing list post, this seems to be a Core Audio bug.
-		output_format.mBitsPerChannel = 16; // We know we want 16-bit
+		output_format.mFormatFlags |= kAudioFormatFlagIsFloat;
 	}
-	else
-	{
-		output_format.mFormatFlags = 0; // clear flags
-		output_format.mFormatFlags |= kAudioFormatFlagIsPacked; // I seem to read failures problems without kAudioFormatFlagIsPacked. From a mailing list post, this seems to be a Core Audio bug.
-		// Mask against bitsize
-		if(0xFF & sample->desired.format)
-		{
-			output_format.mBitsPerChannel = 16; /* 16-bit */
-		}
-		else
-		{
-			output_format.mBitsPerChannel = 8; /* 8-bit */
-		}
 
-		// Mask for signed/unsigned
-		if((1<<15) & sample->desired.format)
-		{
-			output_format.mFormatFlags = output_format.mFormatFlags | kAudioFormatFlagIsSignedInteger;
+	if(SDL_AUDIO_ISSIGNED(sample->actual.format))
+	{
+		output_format.mFormatFlags |= kAudioFormatFlagIsSignedInteger;
+	}
 
-		}
-		else
-		{
-			// no flag set for unsigned
-		}
-		// Mask for big/little endian
-		if((1<<12) & sample->desired.format)
-		{
-			output_format.mFormatFlags = output_format.mFormatFlags | kAudioFormatFlagIsBigEndian;
-		}
-		else
-		{
-			// no flag set for little endian 
-		}
+	if(SDL_AUDIO_ISBIGENDIAN(sample->actual.format))
+	{
+		output_format.mFormatFlags |= kAudioFormatFlagIsBigEndian;
 	}
 
 	output_format.mBytesPerPacket = output_format.mBitsPerChannel/8 * output_format.mChannelsPerFrame; // e.g. 16-bits/8 * channels => so 2-bytes per channel per frame
 	output_format.mBytesPerFrame = output_format.mBitsPerChannel/8 * output_format.mChannelsPerFrame; // For PCM, since 1 frame is 1 packet, it is the same as mBytesPerPacket
 
-	
-/*
-	output_format.mSampleRate = actual_format.mSampleRate; // preserve the original sample rate
-	output_format.mChannelsPerFrame = actual_format.mChannelsPerFrame; // preserve the number of channels
-	output_format.mFormatID = kAudioFormatLinearPCM; // We want linear PCM data
-//	output_format.mFormatFlags = kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked | kAudioFormatFlagIsSignedInteger;
-	output_format.mFormatFlags = kAudioFormatFlagsNativeEndian |  kAudioFormatFlagIsSignedInteger;
-	output_format.mFramesPerPacket = 1; // We know for linear PCM, the definition is 1 frame per packet
-	output_format.mBitsPerChannel = 16; // We know we want 16-bit
-	output_format.mBytesPerPacket = 2 * output_format.mChannelsPerFrame; // We know we are using 16-bit, so 2-bytes per channel per frame
-	output_format.mBytesPerFrame = 2 * output_format.mChannelsPerFrame; // For PCM, since 1 frame is 1 packet, it is the same as mBytesPerPacket
-*/
-	SNDDBG(("output_format: mSampleRate: %lf\n", output_format.mSampleRate)); 
-	SNDDBG(("output_format: mChannelsPerFrame: %d\n", output_format.mChannelsPerFrame)); 
-	SNDDBG(("output_format: mFormatID: %d\n", output_format.mFormatID)); 
-	SNDDBG(("output_format: mFormatFlags: %d\n", output_format.mFormatFlags)); 
-	SNDDBG(("output_format: mFramesPerPacket: %d\n", output_format.mFramesPerPacket)); 
-	SNDDBG(("output_format: mBitsPerChannel: %d\n", output_format.mBitsPerChannel)); 
-	SNDDBG(("output_format: mBytesPerPacket: %d\n", output_format.mBytesPerPacket)); 
-	SNDDBG(("output_format: mBytesPerFrame: %d\n", output_format.mBytesPerFrame)); 
-	
-	
+	SNDDBG(("output_format: mSampleRate: %lf\n", output_format.mSampleRate));
+	SNDDBG(("output_format: mChannelsPerFrame: %d\n", output_format.mChannelsPerFrame));
+	SNDDBG(("output_format: mFormatID: %d\n", output_format.mFormatID));
+	SNDDBG(("output_format: mFormatFlags: %d\n", output_format.mFormatFlags));
+	SNDDBG(("output_format: mFramesPerPacket: %d\n", output_format.mFramesPerPacket));
+	SNDDBG(("output_format: mBitsPerChannel: %d\n", output_format.mBitsPerChannel));
+	SNDDBG(("output_format: mBytesPerPacket: %d\n", output_format.mBytesPerPacket));
+	SNDDBG(("output_format: mBytesPerFrame: %d\n", output_format.mBytesPerFrame));
+
 	/* Set the desired client (output) data format */
 	error_result = ExtAudioFileSetProperty(core_audio_file_container->extAudioFileRef, kExtAudioFileProperty_ClientDataFormat, sizeof(output_format), &output_format);
 	if(noErr != error_result)
@@ -486,21 +448,16 @@ static int CoreAudio_open(Sound_Sample *sample, const char *ext)
 		SDL_free(core_audio_file_container);
 		SNDDBG(("Core Audio: ExtAudioFileSetProperty(kExtAudioFileProperty_ClientDataFormat) failed, reason: [%s].\n", CoreAudio_FourCCToString(error_result)));
 		BAIL_MACRO("Core Audio: Not valid audio data.", 0);
-	}	
-
+	}
 
 	core_audio_file_container->outputFormat = (AudioStreamBasicDescription*)SDL_malloc(sizeof(AudioStreamBasicDescription));
 	BAIL_IF_MACRO(core_audio_file_container->outputFormat == NULL, ERR_OUT_OF_MEMORY, 0);
 
-
-	
 	/* Copy the output format to the audio_description that was passed in so the 
 	 * info will be returned to the user.
 	 */
 	SDL_memcpy(core_audio_file_container->outputFormat, &output_format, sizeof(AudioStreamBasicDescription));
 
-	
-
 	return 1;
 } /* CoreAudio_open */
 
@@ -545,55 +502,48 @@ static Uint32 CoreAudio_read(Sound_Sample *sample)
 
 
 //	void* temp_buffer = SDL_malloc(max_buffer_size);
-	
+
 	AudioBufferList audio_buffer_list;
 	audio_buffer_list.mNumberBuffers = 1;
 	audio_buffer_list.mBuffers[0].mDataByteSize = max_buffer_size;
 	audio_buffer_list.mBuffers[0].mNumberChannels = core_audio_file_container->outputFormat->mChannelsPerFrame;
 	audio_buffer_list.mBuffers[0].mData = internal->buffer;
 
-
 	bytes_remaining = max_buffer_size;
 	buffer_size_in_frames_remaining = buffer_size_in_frames;
-	
-	// oops. Due to the kAudioFormatFlagIsPacked bug, 
+
+	// oops. Due to the kAudioFormatFlagIsPacked bug,
 	// I was misled to believe that Core Audio
-	// was not always filling my entire requested buffer. 
+	// was not always filling my entire requested buffer.
 	// So this while-loop might be unnecessary.
-	// However, I have not exhaustively tested all formats, 
+	// However, I have not exhaustively tested all formats,
 	// so maybe it is possible this loop is useful.
 	// It might also handle the not-evenly disvisible case above.
 	while(buffer_size_in_frames_remaining > 0 && !(sample->flags & SOUND_SAMPLEFLAG_EOF))
 	{
-		
 		data_buffer_size = (UInt32)(buffer_size_in_frames * core_audio_file_container->outputFormat->mBytesPerFrame);
-//		printf("data_buffer_size=%d\n", data_buffer_size); 
+//		printf("data_buffer_size=%d\n", data_buffer_size);
 
 		buffer_size_in_frames = buffer_size_in_frames_remaining;
-		
-//		printf("reading buffer_size_in_frames=%"PRId64"\n", buffer_size_in_frames); 
 
+//		printf("reading buffer_size_in_frames=%"PRId64"\n", buffer_size_in_frames); 
 
 		audio_buffer_list.mBuffers[0].mDataByteSize = bytes_remaining;
 		audio_buffer_list.mBuffers[0].mData = &(((UInt8*)internal->buffer)[total_bytes_read]);
 
-		
 		/* Read the data into an AudioBufferList */
 		error_result = ExtAudioFileRead(core_audio_file_container->extAudioFileRef, &buffer_size_in_frames, &audio_buffer_list);
 		if(error_result == noErr)
 		{
-		
-		
 			/* Success */
-			
 			total_frames_read += buffer_size_in_frames;
 			buffer_size_in_frames_remaining = buffer_size_in_frames_remaining - buffer_size_in_frames;
-			
+
 //			printf("read buffer_size_in_frames=%"PRId64", buffer_size_in_frames_remaining=%"PRId64"\n", buffer_size_in_frames, buffer_size_in_frames_remaining); 
 
 			/* ExtAudioFileRead returns the number of frames actually read. Need to convert back to bytes. */
 			data_buffer_size = (UInt32)(buffer_size_in_frames * core_audio_file_container->outputFormat->mBytesPerFrame);
-//			printf("data_buffer_size=%d\n", data_buffer_size); 
+//			printf("data_buffer_size=%d\n", data_buffer_size);
 
 			total_bytes_read += data_buffer_size;
 			bytes_remaining = bytes_remaining - data_buffer_size;
@@ -601,20 +551,18 @@ static Uint32 CoreAudio_read(Sound_Sample *sample)
 			/* Note: 0 == buffer_size_in_frames is a legitimate value meaning we are EOF. */
 			if(0 == buffer_size_in_frames)
 			{
-				sample->flags |= SOUND_SAMPLEFLAG_EOF;			
+				sample->flags |= SOUND_SAMPLEFLAG_EOF;
 			}
-
 		}
-		else 
+		else
 		{
 			SNDDBG(("Core Audio: ExtAudioFileReadfailed, reason: [%s].\n", CoreAudio_FourCCToString(error_result)));
 
 			sample->flags |= SOUND_SAMPLEFLAG_ERROR;
 			break;
-			
 		}
 	}
-	
+
 	if( (!(sample->flags & SOUND_SAMPLEFLAG_EOF)) && (total_bytes_read < max_buffer_size))
 	{
 		SNDDBG(("Core Audio: ExtAudioFileReadfailed SOUND_SAMPLEFLAG_EAGAIN, reason: [total_bytes_read < max_buffer_size], %d, %d.\n", total_bytes_read , max_buffer_size));
@@ -628,13 +576,12 @@ static Uint32 CoreAudio_read(Sound_Sample *sample)
 
 static int CoreAudio_rewind(Sound_Sample *sample)
 {
-	OSStatus error_result = noErr;	
+	OSStatus error_result = noErr;
 	Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
 	CoreAudioFileContainer* core_audio_file_container = (CoreAudioFileContainer *) internal->decoder_private;
-	
+
 	error_result = ExtAudioFileSeek(core_audio_file_container->extAudioFileRef, 0);
-	if(error_result != noErr)
-	{
+	if(error_result != noErr) {
 		sample->flags |= SOUND_SAMPLEFLAG_ERROR;
 	}
 	return 1;
@@ -651,10 +598,8 @@ static int CoreAudio_seek(Sound_Sample *sample, Uint32 ms)
 	Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;
 	CoreAudioFileContainer* core_audio_file_container = (CoreAudioFileContainer *) internal->decoder_private;
 	SInt64 frame_offset = 0;
-	AudioStreamBasicDescription	actual_format;
-	UInt32 format_size;
 
-	
+#if 0 /* not working */
 	/* I'm confused. The Apple documentation says this:
 	"Seek position is specified in the sample rate and frame count of the file’s audio data format
 	— not your application’s audio data format."
@@ -663,16 +608,15 @@ static int CoreAudio_seek(Sound_Sample *sample, Uint32 ms)
 	When I use outputFormat, things seem to work correctly.
 	I must be misinterpreting the documentation or doing something wrong.
 	*/
-#if 0 /* not working */
-    format_size = sizeof(AudioStreamBasicDescription);
-    error_result = AudioFileGetProperty(
+	AudioStreamBasicDescription	actual_format;
+	UInt32 format_size = sizeof(AudioStreamBasicDescription);
+	error_result = AudioFileGetProperty(
 		*core_audio_file_container->audioFileID,
 		kAudioFilePropertyDataFormat,
 		&format_size,
 		&actual_format
 	);
-    if(error_result != noErr)
-	{
+	if(error_result != noErr) {
 		sample->flags |= SOUND_SAMPLEFLAG_ERROR;
 		BAIL_MACRO("Core Audio: Could not GetProperty for kAudioFilePropertyDataFormat.", 0);
 	} /* if */
@@ -686,11 +630,10 @@ static int CoreAudio_seek(Sound_Sample *sample, Uint32 ms)
 
 	// computed against actual format and not the client format
 	error_result = ExtAudioFileSeek(core_audio_file_container->extAudioFileRef, frame_offset);
-	if(error_result != noErr)
-	{
+	if(error_result != noErr) {
 		sample->flags |= SOUND_SAMPLEFLAG_ERROR;
 	}
-	
+
 	return 1;
 } /* CoreAudio_seek */
 
@@ -730,7 +673,7 @@ const Sound_DecoderFunctions __Sound_DecoderFunctions_CoreAudio =
         "Eric Wing <ewing . public @ playcontrol.net>",
         "https://playcontrol.net"
     },
-	
+
     CoreAudio_init,       /*   init() method */
     CoreAudio_quit,       /*   quit() method */
     CoreAudio_open,       /*   open() method */

data/dependencies/SDL_sound/SDL_sound_flac.c

@@ -35,12 +35,6 @@
 #define DRFLAC_FREE(p) SDL_free((p))
 #define DRFLAC_COPY_MEMORY(dst, src, sz) SDL_memcpy((dst), (src), (sz))
 #define DRFLAC_ZERO_MEMORY(p, sz) SDL_memset((p), 0, (sz))
-#ifndef __WATCOMC__ /* #@!.!.. */
-#if SDL_VERSION_ATLEAST(2, 0, 9)
-#define exp SDL_exp
-#endif
-#define floor SDL_floor
-#endif
 
 #include "dr_flac.h"
 

data/dependencies/SDL_sound/SDL_sound_internal.h

@@ -20,6 +20,11 @@
 
 #include "SDL_sound.h"
 
+/* SDL_AudioStream, which we use internally, didn't arrive until SDL 2.0.7. */
+#if !SDL_VERSION_ATLEAST(2, 0, 7)
+#error SDL_sound requires SDL 2.0.7 or later. Please upgrade.
+#endif
+
 #if ((defined(__GNUC__) && (__GNUC__ >= 4)) || defined(__clang__)) && !(defined(_WIN32) || defined(__OS2__))
 #define SOUND_HAVE_PRAGMA_VISIBILITY 1
 #endif
@@ -140,7 +145,9 @@ typedef struct __SOUND_DECODERFUNCTIONS__
          *    Sound_Sample *prev;  (offlimits)
          *    SDL_RWops *rw;       (can use, but do NOT close it)
          *    const Sound_DecoderFunctions *funcs; (that's this structure)
-         *    SDL_AudioCVT sdlcvt; (offlimits)
+         *    SDL_AudioStream stream; (offlimits)
+         *    SDL_bool pending_eof; (offlimits)
+         *    SDL_bool pending_error; (offlimits)
          *    void *buffer;        (offlimits until read() method)
          *    Uint32 buffer_size;  (offlimits until read() method)
          *    void *decoder_private; (read and write access)
@@ -205,7 +212,7 @@ typedef struct __SOUND_DECODERFUNCTIONS__
         /*
          * Reset the decoding to the beginning of the stream. Nonzero on
          *  success, zero on failure.
-         *  
+         *
          * The purpose of this method is to allow for higher efficiency than
          *  an application could get by just recreating the sample externally;
          *  not only do they not have to reopen the RWops, reallocate buffers,
@@ -223,9 +230,9 @@ typedef struct __SOUND_DECODERFUNCTIONS__
         /*
          * Reposition the decoding to an arbitrary point. Nonzero on
          *  success, zero on failure.
-         *  
+         *
          * The purpose of this method is to allow for higher efficiency than
-         *  an application could get by just rewinding the sample and 
+         *  an application could get by just rewinding the sample and
          *  decoding to a given point.
          *
          * The decoder is responsible for calling seek() on the associated
@@ -246,7 +253,9 @@ typedef struct __SOUND_SAMPLEINTERNAL__
     Sound_Sample *prev;
     SDL_RWops *rw;
     const Sound_DecoderFunctions *funcs;
-    SDL_AudioCVT sdlcvt;
+    SDL_AudioStream *stream;
+    SDL_bool pending_eof;
+    SDL_bool pending_error;
     void *buffer;
     Uint32 buffer_size;
     void *decoder_private;
@@ -272,6 +281,10 @@ typedef struct __SOUND_SAMPLEINTERNAL__
 #define ERR_PREV_EOF             "Previous decoding already triggered EOF"
 #define ERR_CANNOT_SEEK          "Sample is not seekable"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 /*
  * Call this to set the message returned by Sound_GetError().
  *  Please only use the ERR_* constants above, or add new constants to the
@@ -305,6 +318,15 @@ extern char *SDL_strtokr(char *s1, const char *s2, char **saveptr);
 extern int SDL_rand(void);
 extern void SDL_srand(unsigned int seed);
 
+/* Wrappers around the SDL versions of these in case you're on an older SDL */
+extern void *__Sound_SIMDAlloc(const size_t len);
+extern void *__Sound_SIMDRealloc(void *mem, const size_t len);
+extern void __Sound_SIMDFree(void *ptr);
+
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* defined _INCLUDE_SDL_SOUND_INTERNAL_H_ */
 
 /* end of SDL_sound_internal.h ... */

data/dependencies/SDL_sound/SDL_sound_modplug.c

@@ -121,14 +121,26 @@ static int MODPLUG_open(Sound_Sample *sample, const char *ext)
 
     SDL_memcpy(&sample->actual, &sample->desired, sizeof (Sound_AudioInfo));
     if (sample->actual.rate == 0) sample->actual.rate = 44100;
-    if (sample->actual.channels == 0) sample->actual.channels = 2;
+    if (sample->actual.channels != 1) sample->actual.channels = 2;
     if (sample->actual.format == 0) sample->actual.format = AUDIO_S16SYS;
 
-    SDL_zero(settings);
+    switch (sample->actual.format) {
+    case AUDIO_U8:
+    case AUDIO_S8:
+        sample->actual.format = AUDIO_U8;
+        break;
+    case AUDIO_S32MSB:
+    case AUDIO_S32LSB:
+    case AUDIO_F32MSB:
+    case AUDIO_F32LSB:
+        sample->actual.format = AUDIO_S32SYS;
+        break;
+    default:
+        sample->actual.format = AUDIO_S16SYS;
+        break;
+    }
 
-    settings.mChannels=sample->actual.channels;
-    settings.mFrequency=sample->actual.rate;
-    settings.mBits = sample->actual.format & 0xFF;
+    SDL_zero(settings);
 
     /* The settings will require some experimenting. I've borrowed some
         of them from the XMMS ModPlug plugin. */
@@ -143,9 +155,9 @@ static int MODPLUG_open(Sound_Sample *sample, const char *ext)
     settings.mBassRange = 30;
     settings.mSurroundDepth = 20;
     settings.mSurroundDelay = 20;
-    settings.mChannels = 2;
-    settings.mBits = 16;
-    settings.mFrequency = 44100;
+    settings.mChannels = sample->actual.channels;
+    settings.mBits = SDL_AUDIO_BITSIZE(sample->actual.format);
+    settings.mFrequency = sample->actual.rate;
     settings.mResamplingMode = MODPLUG_RESAMPLE_FIR;
     settings.mLoopCount = 0;