src/audio/SDL_wave.c - third_party/sdl - Git at Google

 /*
     SDL - Simple DirectMedia Layer
     Copyright (C) 1997-2009 Sam Lantinga

     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
     License as published by the Free Software Foundation; either
     version 2.1 of the License, or (at your option) any later version.

     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Lesser General Public License for more details.

     You should have received a copy of the GNU Lesser General Public
     License along with this library; if not, write to the Free Software
     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

     Sam Lantinga
     slouken@libsdl.org
 */
 #include "SDL_config.h"

 /* Microsoft WAVE file loading routines */

 #include "SDL_audio.h"
 #include "SDL_wave.h"


 static int ReadChunk(SDL_RWops *src, Chunk *chunk);

 struct MS_ADPCM_decodestate {
 	Uint8 hPredictor;
 	Uint16 iDelta;
 	Sint16 iSamp1;
 	Sint16 iSamp2;
 };
 static struct MS_ADPCM_decoder {
 	WaveFMT wavefmt;
 	Uint16 wSamplesPerBlock;
 	Uint16 wNumCoef;
 	Sint16 aCoeff[7][2];
 	/* * * */
 	struct MS_ADPCM_decodestate state[2];
 } MS_ADPCM_state;

 static int InitMS_ADPCM(WaveFMT *format)
 {
 	Uint8 *rogue_feel;
 	Uint16 extra_info;
 	int i;

 	/* Set the rogue pointer to the MS_ADPCM specific data */
 	MS_ADPCM_state.wavefmt.encoding = SDL_SwapLE16(format->encoding);
 	MS_ADPCM_state.wavefmt.channels = SDL_SwapLE16(format->channels);
 	MS_ADPCM_state.wavefmt.frequency = SDL_SwapLE32(format->frequency);
 	MS_ADPCM_state.wavefmt.byterate = SDL_SwapLE32(format->byterate);
 	MS_ADPCM_state.wavefmt.blockalign = SDL_SwapLE16(format->blockalign);
 	MS_ADPCM_state.wavefmt.bitspersample =
 					 SDL_SwapLE16(format->bitspersample);
 	rogue_feel = (Uint8 *)format+sizeof(*format);
 	if ( sizeof(*format) == 16 ) {
 		extra_info = ((rogue_feel[1]<<8)|rogue_feel[0]);
 		rogue_feel += sizeof(Uint16);
 	}
 	MS_ADPCM_state.wSamplesPerBlock = ((rogue_feel[1]<<8)|rogue_feel[0]);
 	rogue_feel += sizeof(Uint16);
 	MS_ADPCM_state.wNumCoef = ((rogue_feel[1]<<8)|rogue_feel[0]);
 	rogue_feel += sizeof(Uint16);
 	if ( MS_ADPCM_state.wNumCoef != 7 ) {
 		SDL_SetError("Unknown set of MS_ADPCM coefficients");
 		return(-1);
 	}
 	for ( i=0; i<MS_ADPCM_state.wNumCoef; ++i ) {
 		MS_ADPCM_state.aCoeff[i][0] = ((rogue_feel[1]<<8)|rogue_feel[0]);
 		rogue_feel += sizeof(Uint16);
 		MS_ADPCM_state.aCoeff[i][1] = ((rogue_feel[1]<<8)|rogue_feel[0]);
 		rogue_feel += sizeof(Uint16);
 	}
 	return(0);
 }

 static Sint32 MS_ADPCM_nibble(struct MS_ADPCM_decodestate *state,
 					Uint8 nybble, Sint16 *coeff)
 {
 	const Sint32 max_audioval = ((1<<(16-1))-1);
 	const Sint32 min_audioval = -(1<<(16-1));
 	const Sint32 adaptive[] = {
 		230, 230, 230, 230, 307, 409, 512, 614,
 		768, 614, 512, 409, 307, 230, 230, 230
 	};
 	Sint32 new_sample, delta;

 	new_sample = ((state->iSamp1 * coeff[0]) +
 		      (state->iSamp2 * coeff[1]))/256;
 	if ( nybble & 0x08 ) {
 		new_sample += state->iDelta * (nybble-0x10);
 	} else {
 		new_sample += state->iDelta * nybble;
 	}
 	if ( new_sample < min_audioval ) {
 		new_sample = min_audioval;
 	} else
 	if ( new_sample > max_audioval ) {
 		new_sample = max_audioval;
 	}
 	delta = ((Sint32)state->iDelta * adaptive[nybble])/256;
 	if ( delta < 16 ) {
 		delta = 16;
 	}
 	state->iDelta = (Uint16)delta;
 	state->iSamp2 = state->iSamp1;
 	state->iSamp1 = (Sint16)new_sample;
 	return(new_sample);
 }

 static int MS_ADPCM_decode(Uint8 **audio_buf, Uint32 *audio_len)
 {
 	struct MS_ADPCM_decodestate *state[2];
 	Uint8 *freeable, *encoded, *decoded;
 	Sint32 encoded_len, samplesleft;
 	Sint8 nybble, stereo;
 	Sint16 *coeff[2];
 	Sint32 new_sample;

 	/* Allocate the proper sized output buffer */
 	encoded_len = *audio_len;
 	encoded = *audio_buf;
 	freeable = *audio_buf;
 	*audio_len = (encoded_len/MS_ADPCM_state.wavefmt.blockalign) *
 				MS_ADPCM_state.wSamplesPerBlock*
 				MS_ADPCM_state.wavefmt.channels*sizeof(Sint16);
 	*audio_buf = (Uint8 *)SDL_malloc(*audio_len);
 	if ( *audio_buf == NULL ) {
 		SDL_Error(SDL_ENOMEM);
 		return(-1);
 	}
 	decoded = *audio_buf;

 	/* Get ready... Go! */
 	stereo = (MS_ADPCM_state.wavefmt.channels == 2);
 	state[0] = &MS_ADPCM_state.state[0];
 	state[1] = &MS_ADPCM_state.state[stereo];
 	while ( encoded_len >= MS_ADPCM_state.wavefmt.blockalign ) {
 		/* Grab the initial information for this block */
 		state[0]->hPredictor = *encoded++;
 		if ( stereo ) {
 			state[1]->hPredictor = *encoded++;
 		}
 		state[0]->iDelta = ((encoded[1]<<8)|encoded[0]);
 		encoded += sizeof(Sint16);
 		if ( stereo ) {
 			state[1]->iDelta = ((encoded[1]<<8)|encoded[0]);
 			encoded += sizeof(Sint16);
 		}
 		state[0]->iSamp1 = ((encoded[1]<<8)|encoded[0]);
 		encoded += sizeof(Sint16);
 		if ( stereo ) {
 			state[1]->iSamp1 = ((encoded[1]<<8)|encoded[0]);
 			encoded += sizeof(Sint16);
 		}
 		state[0]->iSamp2 = ((encoded[1]<<8)|encoded[0]);
 		encoded += sizeof(Sint16);
 		if ( stereo ) {
 			state[1]->iSamp2 = ((encoded[1]<<8)|encoded[0]);
 			encoded += sizeof(Sint16);
 		}
 		coeff[0] = MS_ADPCM_state.aCoeff[state[0]->hPredictor];
 		coeff[1] = MS_ADPCM_state.aCoeff[state[1]->hPredictor];

 		/* Store the two initial samples we start with */
 		decoded[0] = state[0]->iSamp2&0xFF;
 		decoded[1] = state[0]->iSamp2>>8;
 		decoded += 2;
 		if ( stereo ) {
 			decoded[0] = state[1]->iSamp2&0xFF;
 			decoded[1] = state[1]->iSamp2>>8;
 			decoded += 2;
 		}
 		decoded[0] = state[0]->iSamp1&0xFF;
 		decoded[1] = state[0]->iSamp1>>8;
 		decoded += 2;
 		if ( stereo ) {
 			decoded[0] = state[1]->iSamp1&0xFF;
 			decoded[1] = state[1]->iSamp1>>8;
 			decoded += 2;
 		}

 		/* Decode and store the other samples in this block */
 		samplesleft = (MS_ADPCM_state.wSamplesPerBlock-2)*
 					MS_ADPCM_state.wavefmt.channels;
 		while ( samplesleft > 0 ) {
 			nybble = (*encoded)>>4;
 			new_sample = MS_ADPCM_nibble(state[0],nybble,coeff[0]);
 			decoded[0] = new_sample&0xFF;
 			new_sample >>= 8;
 			decoded[1] = new_sample&0xFF;
 			decoded += 2;

 			nybble = (*encoded)&0x0F;
 			new_sample = MS_ADPCM_nibble(state[1],nybble,coeff[1]);
 			decoded[0] = new_sample&0xFF;
 			new_sample >>= 8;
 			decoded[1] = new_sample&0xFF;
 			decoded += 2;

 			++encoded;
 			samplesleft -= 2;
 		}
 		encoded_len -= MS_ADPCM_state.wavefmt.blockalign;
 	}
 	SDL_free(freeable);
 	return(0);
 }

 struct IMA_ADPCM_decodestate {
 	Sint32 sample;
 	Sint8 index;
 };
 static struct IMA_ADPCM_decoder {
 	WaveFMT wavefmt;
 	Uint16 wSamplesPerBlock;
 	/* * * */
 	struct IMA_ADPCM_decodestate state[2];
 } IMA_ADPCM_state;

 static int InitIMA_ADPCM(WaveFMT *format)
 {
 	Uint8 *rogue_feel;
 	Uint16 extra_info;

 	/* Set the rogue pointer to the IMA_ADPCM specific data */
 	IMA_ADPCM_state.wavefmt.encoding = SDL_SwapLE16(format->encoding);
 	IMA_ADPCM_state.wavefmt.channels = SDL_SwapLE16(format->channels);
 	IMA_ADPCM_state.wavefmt.frequency = SDL_SwapLE32(format->frequency);
 	IMA_ADPCM_state.wavefmt.byterate = SDL_SwapLE32(format->byterate);
 	IMA_ADPCM_state.wavefmt.blockalign = SDL_SwapLE16(format->blockalign);
 	IMA_ADPCM_state.wavefmt.bitspersample =
 					 SDL_SwapLE16(format->bitspersample);
 	rogue_feel = (Uint8 *)format+sizeof(*format);
 	if ( sizeof(*format) == 16 ) {
 		extra_info = ((rogue_feel[1]<<8)|rogue_feel[0]);
 		rogue_feel += sizeof(Uint16);
 	}
 	IMA_ADPCM_state.wSamplesPerBlock = ((rogue_feel[1]<<8)|rogue_feel[0]);
 	return(0);
 }

 static Sint32 IMA_ADPCM_nibble(struct IMA_ADPCM_decodestate *state,Uint8 nybble)
 {
 	const Sint32 max_audioval = ((1<<(16-1))-1);
 	const Sint32 min_audioval = -(1<<(16-1));
 	const int index_table[16] = {
 		-1, -1, -1, -1,
 		 2,  4,  6,  8,
 		-1, -1, -1, -1,
 		 2,  4,  6,  8
 	};
 	const Sint32 step_table[89] = {
 		7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31,
 		34, 37, 41, 45, 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130,
 		143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408,
 		449, 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282,
 		1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327,
 		3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630,
 		9493, 10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350,
 		22385, 24623, 27086, 29794, 32767
 	};
 	Sint32 delta, step;

 	/* Compute difference and new sample value */
 	step = step_table[state->index];
 	delta = step >> 3;
 	if ( nybble & 0x04 ) delta += step;
 	if ( nybble & 0x02 ) delta += (step >> 1);
 	if ( nybble & 0x01 ) delta += (step >> 2);
 	if ( nybble & 0x08 ) delta = -delta;
 	state->sample += delta;

 	/* Update index value */
 	state->index += index_table[nybble];
 	if ( state->index > 88 ) {
 		state->index = 88;
 	} else
 	if ( state->index < 0 ) {
 		state->index = 0;
 	}

 	/* Clamp output sample */
 	if ( state->sample > max_audioval ) {
 		state->sample = max_audioval;
 	} else
 	if ( state->sample < min_audioval ) {
 		state->sample = min_audioval;
 	}
 	return(state->sample);
 }

 /* Fill the decode buffer with a channel block of data (8 samples) */
 static void Fill_IMA_ADPCM_block(Uint8 *decoded, Uint8 *encoded,
 	int channel, int numchannels, struct IMA_ADPCM_decodestate *state)
 {
 	int i;
 	Sint8 nybble;
 	Sint32 new_sample;

 	decoded += (channel * 2);
 	for ( i=0; i<4; ++i ) {
 		nybble = (*encoded)&0x0F;
 		new_sample = IMA_ADPCM_nibble(state, nybble);
 		decoded[0] = new_sample&0xFF;
 		new_sample >>= 8;
 		decoded[1] = new_sample&0xFF;
 		decoded += 2 * numchannels;

 		nybble = (*encoded)>>4;
 		new_sample = IMA_ADPCM_nibble(state, nybble);
 		decoded[0] = new_sample&0xFF;
 		new_sample >>= 8;
 		decoded[1] = new_sample&0xFF;
 		decoded += 2 * numchannels;

 		++encoded;
 	}
 }

 static int IMA_ADPCM_decode(Uint8 **audio_buf, Uint32 *audio_len)
 {
 	struct IMA_ADPCM_decodestate *state;
 	Uint8 *freeable, *encoded, *decoded;
 	Sint32 encoded_len, samplesleft;
 	unsigned int c, channels;

 	/* Check to make sure we have enough variables in the state array */
 	channels = IMA_ADPCM_state.wavefmt.channels;
 	if ( channels > SDL_arraysize(IMA_ADPCM_state.state) ) {
 		SDL_SetError("IMA ADPCM decoder can only handle %d channels",
 					SDL_arraysize(IMA_ADPCM_state.state));
 		return(-1);
 	}
 	state = IMA_ADPCM_state.state;

 	/* Allocate the proper sized output buffer */
 	encoded_len = *audio_len;
 	encoded = *audio_buf;
 	freeable = *audio_buf;
 	*audio_len = (encoded_len/IMA_ADPCM_state.wavefmt.blockalign) *
 				IMA_ADPCM_state.wSamplesPerBlock*
 				IMA_ADPCM_state.wavefmt.channels*sizeof(Sint16);
 	*audio_buf = (Uint8 *)SDL_malloc(*audio_len);
 	if ( *audio_buf == NULL ) {
 		SDL_Error(SDL_ENOMEM);
 		return(-1);
 	}
 	decoded = *audio_buf;

 	/* Get ready... Go! */
 	while ( encoded_len >= IMA_ADPCM_state.wavefmt.blockalign ) {
 		/* Grab the initial information for this block */
 		for ( c=0; c<channels; ++c ) {
 			/* Fill the state information for this block */
 			state[c].sample = ((encoded[1]<<8)|encoded[0]);
 			encoded += 2;
 			if ( state[c].sample & 0x8000 ) {
 				state[c].sample -= 0x10000;
 			}
 			state[c].index = *encoded++;
 			/* Reserved byte in buffer header, should be 0 */
 			if ( *encoded++ != 0 ) {
 				/* Uh oh, corrupt data?  Buggy code? */;
 			}

 			/* Store the initial sample we start with */
 			decoded[0] = (Uint8)(state[c].sample&0xFF);
 			decoded[1] = (Uint8)(state[c].sample>>8);
 			decoded += 2;
 		}

 		/* Decode and store the other samples in this block */
 		samplesleft = (IMA_ADPCM_state.wSamplesPerBlock-1)*channels;
 		while ( samplesleft > 0 ) {
 			for ( c=0; c<channels; ++c ) {
 				Fill_IMA_ADPCM_block(decoded, encoded,
 						c, channels, &state[c]);
 				encoded += 4;
 				samplesleft -= 8;
 			}
 			decoded += (channels * 8 * 2);
 		}
 		encoded_len -= IMA_ADPCM_state.wavefmt.blockalign;
 	}
 	SDL_free(freeable);
 	return(0);
 }

 SDL_AudioSpec * SDL_LoadWAV_RW (SDL_RWops *src, int freesrc,
 		SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len)
 {
 	int was_error;
 	Chunk chunk;
 	int lenread;
 	int MS_ADPCM_encoded, IMA_ADPCM_encoded;
 	int samplesize;

 	/* WAV magic header */
 	Uint32 RIFFchunk;
 	Uint32 wavelen = 0;
 	Uint32 WAVEmagic;
 	Uint32 headerDiff = 0;

 	/* FMT chunk */
 	WaveFMT *format = NULL;

 	/* Make sure we are passed a valid data source */
 	was_error = 0;
 	if ( src == NULL ) {
 		was_error = 1;
 		goto done;
 	}

 	/* Check the magic header */
 	RIFFchunk	= SDL_ReadLE32(src);
 	wavelen		= SDL_ReadLE32(src);
 	if ( wavelen == WAVE ) { /* The RIFFchunk has already been read */
 		WAVEmagic = wavelen;
 		wavelen   = RIFFchunk;
 		RIFFchunk = RIFF;
 	} else {
 		WAVEmagic = SDL_ReadLE32(src);
 	}
 	if ( (RIFFchunk != RIFF) || (WAVEmagic != WAVE) ) {
 		SDL_SetError("Unrecognized file type (not WAVE)");
 		was_error = 1;
 		goto done;
 	}
 	headerDiff += sizeof(Uint32); /* for WAVE */

 	/* Read the audio data format chunk */
 	chunk.data = NULL;
 	do {
 		if ( chunk.data != NULL ) {
 			SDL_free(chunk.data);
 			chunk.data = NULL;
 		}
 		lenread = ReadChunk(src, &chunk);
 		if ( lenread < 0 ) {
 			was_error = 1;
 			goto done;
 		}
 		/* 2 Uint32's for chunk header+len, plus the lenread */
 		headerDiff += lenread + 2 * sizeof(Uint32);
 	} while ( (chunk.magic == FACT) || (chunk.magic == LIST) );

 	/* Decode the audio data format */
 	format = (WaveFMT *)chunk.data;
 	if ( chunk.magic != FMT ) {
 		SDL_SetError("Complex WAVE files not supported");
 		was_error = 1;
 		goto done;
 	}
 	MS_ADPCM_encoded = IMA_ADPCM_encoded = 0;
 	switch (SDL_SwapLE16(format->encoding)) {
 		case PCM_CODE:
 			/* We can understand this */
 			break;
 		case MS_ADPCM_CODE:
 			/* Try to understand this */
 			if ( InitMS_ADPCM(format) < 0 ) {
 				was_error = 1;
 				goto done;
 			}
 			MS_ADPCM_encoded = 1;
 			break;
 		case IMA_ADPCM_CODE:
 			/* Try to understand this */
 			if ( InitIMA_ADPCM(format) < 0 ) {
 				was_error = 1;
 				goto done;
 			}
 			IMA_ADPCM_encoded = 1;
 			break;
 		case MP3_CODE:
 			SDL_SetError("MPEG Layer 3 data not supported",
 					SDL_SwapLE16(format->encoding));
 			was_error = 1;
 			goto done;
 		default:
 			SDL_SetError("Unknown WAVE data format: 0x%.4x",
 					SDL_SwapLE16(format->encoding));
 			was_error = 1;
 			goto done;
 	}
 	SDL_memset(spec, 0, (sizeof *spec));
 	spec->freq = SDL_SwapLE32(format->frequency);
 	switch (SDL_SwapLE16(format->bitspersample)) {
 		case 4:
 			if ( MS_ADPCM_encoded || IMA_ADPCM_encoded ) {
 				spec->format = AUDIO_S16;
 			} else {
 				was_error = 1;
 			}
 			break;
 		case 8:
 			spec->format = AUDIO_U8;
 			break;
 		case 16:
 			spec->format = AUDIO_S16;
 			break;
 		default:
 			was_error = 1;
 			break;
 	}
 	if ( was_error ) {
 		SDL_SetError("Unknown %d-bit PCM data format",
 			SDL_SwapLE16(format->bitspersample));
 		goto done;
 	}
 	spec->channels = (Uint8)SDL_SwapLE16(format->channels);
 	spec->samples = 4096;		/* Good default buffer size */

 	/* Read the audio data chunk */
 	*audio_buf = NULL;
 	do {
 		if ( *audio_buf != NULL ) {
 			SDL_free(*audio_buf);
 			*audio_buf = NULL;
 		}
 		lenread = ReadChunk(src, &chunk);
 		if ( lenread < 0 ) {
 			was_error = 1;
 			goto done;
 		}
 		*audio_len = lenread;
 		*audio_buf = chunk.data;
 		if(chunk.magic != DATA) headerDiff += lenread + 2 * sizeof(Uint32);
 	} while ( chunk.magic != DATA );
 	headerDiff += 2 * sizeof(Uint32); /* for the data chunk and len */

 	if ( MS_ADPCM_encoded ) {
 		if ( MS_ADPCM_decode(audio_buf, audio_len) < 0 ) {
 			was_error = 1;
 			goto done;
 		}
 	}
 	if ( IMA_ADPCM_encoded ) {
 		if ( IMA_ADPCM_decode(audio_buf, audio_len) < 0 ) {
 			was_error = 1;
 			goto done;
 		}
 	}

 	/* Don't return a buffer that isn't a multiple of samplesize */
 	samplesize = ((spec->format & 0xFF)/8)*spec->channels;
 	*audio_len &= ~(samplesize-1);

 done:
 	if ( format != NULL ) {
 		SDL_free(format);
 	}
 	if ( src ) {
 		if ( freesrc ) {
 			SDL_RWclose(src);
 		} else {
 			/* seek to the end of the file (given by the RIFF chunk) */
 			SDL_RWseek(src, wavelen - chunk.length - headerDiff, RW_SEEK_CUR);
 		}
 	}
 	if ( was_error ) {
 		spec = NULL;
 	}
 	return(spec);
 }

 /* Since the WAV memory is allocated in the shared library, it must also
    be freed here.  (Necessary under Win32, VC++)
  */
 void SDL_FreeWAV(Uint8 *audio_buf)
 {
 	if ( audio_buf != NULL ) {
 		SDL_free(audio_buf);
 	}
 }

 static int ReadChunk(SDL_RWops *src, Chunk *chunk)
 {
 	chunk->magic	= SDL_ReadLE32(src);
 	chunk->length	= SDL_ReadLE32(src);
 	chunk->data = (Uint8 *)SDL_malloc(chunk->length);
 	if ( chunk->data == NULL ) {
 		SDL_Error(SDL_ENOMEM);
 		return(-1);
 	}
 	if ( SDL_RWread(src, chunk->data, chunk->length, 1) != 1 ) {
 		SDL_Error(SDL_EFREAD);
 		SDL_free(chunk->data);
 		chunk->data = NULL;
 		return(-1);
 	}
 	return(chunk->length);
 }
	/*
	SDL - Simple DirectMedia Layer
	Copyright (C) 1997-2009 Sam Lantinga

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

	Sam Lantinga
	slouken@libsdl.org
	*/
	#include "SDL_config.h"

	/* Microsoft WAVE file loading routines */

	#include "SDL_audio.h"
	#include "SDL_wave.h"


	static int ReadChunk(SDL_RWops src, Chunk chunk);

	struct MS_ADPCM_decodestate {
	Uint8 hPredictor;
	Uint16 iDelta;
	Sint16 iSamp1;
	Sint16 iSamp2;
	};
	static struct MS_ADPCM_decoder {
	WaveFMT wavefmt;
	Uint16 wSamplesPerBlock;
	Uint16 wNumCoef;
	Sint16 aCoeff[7][2];
	/* * * */
	struct MS_ADPCM_decodestate state[2];
	} MS_ADPCM_state;

	static int InitMS_ADPCM(WaveFMT *format)
	{
	Uint8 *rogue_feel;
	Uint16 extra_info;
	int i;

	/* Set the rogue pointer to the MS_ADPCM specific data */
	MS_ADPCM_state.wavefmt.encoding = SDL_SwapLE16(format->encoding);
	MS_ADPCM_state.wavefmt.channels = SDL_SwapLE16(format->channels);
	MS_ADPCM_state.wavefmt.frequency = SDL_SwapLE32(format->frequency);
	MS_ADPCM_state.wavefmt.byterate = SDL_SwapLE32(format->byterate);
	MS_ADPCM_state.wavefmt.blockalign = SDL_SwapLE16(format->blockalign);
	MS_ADPCM_state.wavefmt.bitspersample =
	SDL_SwapLE16(format->bitspersample);
	rogue_feel = (Uint8 )format+sizeof(format);
	if ( sizeof(*format) == 16 ) {
	extra_info = ((rogue_feel[1]<<8)\|rogue_feel[0]);
	rogue_feel += sizeof(Uint16);
	}
	MS_ADPCM_state.wSamplesPerBlock = ((rogue_feel[1]<<8)\|rogue_feel[0]);
	rogue_feel += sizeof(Uint16);
	MS_ADPCM_state.wNumCoef = ((rogue_feel[1]<<8)\|rogue_feel[0]);
	rogue_feel += sizeof(Uint16);
	if ( MS_ADPCM_state.wNumCoef != 7 ) {
	SDL_SetError("Unknown set of MS_ADPCM coefficients");
	return(-1);
	}
	for ( i=0; i<MS_ADPCM_state.wNumCoef; ++i ) {
	MS_ADPCM_state.aCoeff[i][0] = ((rogue_feel[1]<<8)\|rogue_feel[0]);
	rogue_feel += sizeof(Uint16);
	MS_ADPCM_state.aCoeff[i][1] = ((rogue_feel[1]<<8)\|rogue_feel[0]);
	rogue_feel += sizeof(Uint16);
	}
	return(0);
	}

	static Sint32 MS_ADPCM_nibble(struct MS_ADPCM_decodestate *state,
	Uint8 nybble, Sint16 *coeff)
	{
	const Sint32 max_audioval = ((1<<(16-1))-1);
	const Sint32 min_audioval = -(1<<(16-1));
	const Sint32 adaptive[] = {
	230, 230, 230, 230, 307, 409, 512, 614,
	768, 614, 512, 409, 307, 230, 230, 230
	};
	Sint32 new_sample, delta;

	new_sample = ((state->iSamp1 * coeff[0]) +
	(state->iSamp2 * coeff[1]))/256;
	if ( nybble & 0x08 ) {
	new_sample += state->iDelta * (nybble-0x10);
	} else {
	new_sample += state->iDelta * nybble;
	}
	if ( new_sample < min_audioval ) {
	new_sample = min_audioval;
	} else
	if ( new_sample > max_audioval ) {
	new_sample = max_audioval;
	}
	delta = ((Sint32)state->iDelta * adaptive[nybble])/256;
	if ( delta < 16 ) {
	delta = 16;
	}
	state->iDelta = (Uint16)delta;
	state->iSamp2 = state->iSamp1;
	state->iSamp1 = (Sint16)new_sample;
	return(new_sample);
	}

	static int MS_ADPCM_decode(Uint8 *audio_buf, Uint32 audio_len)
	{
	struct MS_ADPCM_decodestate *state[2];
	Uint8 freeable, encoded, *decoded;
	Sint32 encoded_len, samplesleft;
	Sint8 nybble, stereo;
	Sint16 *coeff[2];
	Sint32 new_sample;

	/* Allocate the proper sized output buffer */
	encoded_len = *audio_len;
	encoded = *audio_buf;
	freeable = *audio_buf;
	audio_len = (encoded_len/MS_ADPCM_state.wavefmt.blockalign)
	MS_ADPCM_state.wSamplesPerBlock*
	MS_ADPCM_state.wavefmt.channels*sizeof(Sint16);
	audio_buf = (Uint8 )SDL_malloc(*audio_len);
	if ( *audio_buf == NULL ) {
	SDL_Error(SDL_ENOMEM);
	return(-1);
	}
	decoded = *audio_buf;

	/* Get ready... Go! */
	stereo = (MS_ADPCM_state.wavefmt.channels == 2);
	state[0] = &MS_ADPCM_state.state[0];
	state[1] = &MS_ADPCM_state.state[stereo];
	while ( encoded_len >= MS_ADPCM_state.wavefmt.blockalign ) {
	/* Grab the initial information for this block */
	state[0]->hPredictor = *encoded++;
	if ( stereo ) {
	state[1]->hPredictor = *encoded++;
	}
	state[0]->iDelta = ((encoded[1]<<8)\|encoded[0]);
	encoded += sizeof(Sint16);
	if ( stereo ) {
	state[1]->iDelta = ((encoded[1]<<8)\|encoded[0]);
	encoded += sizeof(Sint16);
	}
	state[0]->iSamp1 = ((encoded[1]<<8)\|encoded[0]);
	encoded += sizeof(Sint16);
	if ( stereo ) {
	state[1]->iSamp1 = ((encoded[1]<<8)\|encoded[0]);
	encoded += sizeof(Sint16);
	}
	state[0]->iSamp2 = ((encoded[1]<<8)\|encoded[0]);
	encoded += sizeof(Sint16);
	if ( stereo ) {
	state[1]->iSamp2 = ((encoded[1]<<8)\|encoded[0]);
	encoded += sizeof(Sint16);
	}
	coeff[0] = MS_ADPCM_state.aCoeff[state[0]->hPredictor];
	coeff[1] = MS_ADPCM_state.aCoeff[state[1]->hPredictor];

	/* Store the two initial samples we start with */
	decoded[0] = state[0]->iSamp2&0xFF;
	decoded[1] = state[0]->iSamp2>>8;
	decoded += 2;
	if ( stereo ) {
	decoded[0] = state[1]->iSamp2&0xFF;
	decoded[1] = state[1]->iSamp2>>8;
	decoded += 2;
	}
	decoded[0] = state[0]->iSamp1&0xFF;
	decoded[1] = state[0]->iSamp1>>8;
	decoded += 2;
	if ( stereo ) {
	decoded[0] = state[1]->iSamp1&0xFF;
	decoded[1] = state[1]->iSamp1>>8;
	decoded += 2;
	}

	/* Decode and store the other samples in this block */
	samplesleft = (MS_ADPCM_state.wSamplesPerBlock-2)*
	MS_ADPCM_state.wavefmt.channels;
	while ( samplesleft > 0 ) {
	nybble = (*encoded)>>4;
	new_sample = MS_ADPCM_nibble(state[0],nybble,coeff[0]);
	decoded[0] = new_sample&0xFF;
	new_sample >>= 8;
	decoded[1] = new_sample&0xFF;
	decoded += 2;

	nybble = (*encoded)&0x0F;
	new_sample = MS_ADPCM_nibble(state[1],nybble,coeff[1]);
	decoded[0] = new_sample&0xFF;
	new_sample >>= 8;
	decoded[1] = new_sample&0xFF;
	decoded += 2;

	++encoded;
	samplesleft -= 2;
	}
	encoded_len -= MS_ADPCM_state.wavefmt.blockalign;
	}
	SDL_free(freeable);
	return(0);
	}

	struct IMA_ADPCM_decodestate {
	Sint32 sample;
	Sint8 index;
	};
	static struct IMA_ADPCM_decoder {
	WaveFMT wavefmt;
	Uint16 wSamplesPerBlock;
	/* * * */
	struct IMA_ADPCM_decodestate state[2];
	} IMA_ADPCM_state;

	static int InitIMA_ADPCM(WaveFMT *format)
	{
	Uint8 *rogue_feel;
	Uint16 extra_info;

	/* Set the rogue pointer to the IMA_ADPCM specific data */
	IMA_ADPCM_state.wavefmt.encoding = SDL_SwapLE16(format->encoding);
	IMA_ADPCM_state.wavefmt.channels = SDL_SwapLE16(format->channels);
	IMA_ADPCM_state.wavefmt.frequency = SDL_SwapLE32(format->frequency);
	IMA_ADPCM_state.wavefmt.byterate = SDL_SwapLE32(format->byterate);
	IMA_ADPCM_state.wavefmt.blockalign = SDL_SwapLE16(format->blockalign);
	IMA_ADPCM_state.wavefmt.bitspersample =
	SDL_SwapLE16(format->bitspersample);
	rogue_feel = (Uint8 )format+sizeof(format);
	if ( sizeof(*format) == 16 ) {
	extra_info = ((rogue_feel[1]<<8)\|rogue_feel[0]);
	rogue_feel += sizeof(Uint16);
	}
	IMA_ADPCM_state.wSamplesPerBlock = ((rogue_feel[1]<<8)\|rogue_feel[0]);
	return(0);
	}

	static Sint32 IMA_ADPCM_nibble(struct IMA_ADPCM_decodestate *state,Uint8 nybble)
	{
	const Sint32 max_audioval = ((1<<(16-1))-1);
	const Sint32 min_audioval = -(1<<(16-1));
	const int index_table[16] = {
	-1, -1, -1, -1,
	2, 4, 6, 8,
	-1, -1, -1, -1,
	2, 4, 6, 8
	};
	const Sint32 step_table[89] = {
	7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31,
	34, 37, 41, 45, 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130,
	143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408,
	449, 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282,
	1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327,
	3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630,
	9493, 10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350,
	22385, 24623, 27086, 29794, 32767
	};
	Sint32 delta, step;

	/* Compute difference and new sample value */
	step = step_table[state->index];
	delta = step >> 3;
	if ( nybble & 0x04 ) delta += step;
	if ( nybble & 0x02 ) delta += (step >> 1);
	if ( nybble & 0x01 ) delta += (step >> 2);
	if ( nybble & 0x08 ) delta = -delta;
	state->sample += delta;

	/* Update index value */
	state->index += index_table[nybble];
	if ( state->index > 88 ) {
	state->index = 88;
	} else
	if ( state->index < 0 ) {
	state->index = 0;
	}

	/* Clamp output sample */
	if ( state->sample > max_audioval ) {
	state->sample = max_audioval;
	} else
	if ( state->sample < min_audioval ) {
	state->sample = min_audioval;
	}
	return(state->sample);
	}

	/* Fill the decode buffer with a channel block of data (8 samples) */
	static void Fill_IMA_ADPCM_block(Uint8 decoded, Uint8 encoded,
	int channel, int numchannels, struct IMA_ADPCM_decodestate *state)
	{
	int i;
	Sint8 nybble;
	Sint32 new_sample;

	decoded += (channel * 2);
	for ( i=0; i<4; ++i ) {
	nybble = (*encoded)&0x0F;
	new_sample = IMA_ADPCM_nibble(state, nybble);
	decoded[0] = new_sample&0xFF;
	new_sample >>= 8;
	decoded[1] = new_sample&0xFF;
	decoded += 2 * numchannels;

	nybble = (*encoded)>>4;
	new_sample = IMA_ADPCM_nibble(state, nybble);
	decoded[0] = new_sample&0xFF;
	new_sample >>= 8;
	decoded[1] = new_sample&0xFF;
	decoded += 2 * numchannels;

	++encoded;
	}
	}

	static int IMA_ADPCM_decode(Uint8 *audio_buf, Uint32 audio_len)
	{
	struct IMA_ADPCM_decodestate *state;
	Uint8 freeable, encoded, *decoded;
	Sint32 encoded_len, samplesleft;
	unsigned int c, channels;

	/* Check to make sure we have enough variables in the state array */
	channels = IMA_ADPCM_state.wavefmt.channels;
	if ( channels > SDL_arraysize(IMA_ADPCM_state.state) ) {
	SDL_SetError("IMA ADPCM decoder can only handle %d channels",
	SDL_arraysize(IMA_ADPCM_state.state));
	return(-1);
	}
	state = IMA_ADPCM_state.state;

	/* Allocate the proper sized output buffer */
	encoded_len = *audio_len;
	encoded = *audio_buf;
	freeable = *audio_buf;
	audio_len = (encoded_len/IMA_ADPCM_state.wavefmt.blockalign)
	IMA_ADPCM_state.wSamplesPerBlock*
	IMA_ADPCM_state.wavefmt.channels*sizeof(Sint16);
	audio_buf = (Uint8 )SDL_malloc(*audio_len);
	if ( *audio_buf == NULL ) {
	SDL_Error(SDL_ENOMEM);
	return(-1);
	}
	decoded = *audio_buf;

	/* Get ready... Go! */
	while ( encoded_len >= IMA_ADPCM_state.wavefmt.blockalign ) {
	/* Grab the initial information for this block */
	for ( c=0; c<channels; ++c ) {
	/* Fill the state information for this block */
	state[c].sample = ((encoded[1]<<8)\|encoded[0]);
	encoded += 2;
	if ( state[c].sample & 0x8000 ) {
	state[c].sample -= 0x10000;
	}
	state[c].index = *encoded++;
	/* Reserved byte in buffer header, should be 0 */
	if ( *encoded++ != 0 ) {
	/* Uh oh, corrupt data? Buggy code? */;
	}

	/* Store the initial sample we start with */
	decoded[0] = (Uint8)(state[c].sample&0xFF);
	decoded[1] = (Uint8)(state[c].sample>>8);
	decoded += 2;
	}

	/* Decode and store the other samples in this block */
	samplesleft = (IMA_ADPCM_state.wSamplesPerBlock-1)*channels;
	while ( samplesleft > 0 ) {
	for ( c=0; c<channels; ++c ) {
	Fill_IMA_ADPCM_block(decoded, encoded,
	c, channels, &state[c]);
	encoded += 4;
	samplesleft -= 8;
	}
	decoded += (channels * 8 * 2);
	}
	encoded_len -= IMA_ADPCM_state.wavefmt.blockalign;
	}
	SDL_free(freeable);
	return(0);
	}

	SDL_AudioSpec * SDL_LoadWAV_RW (SDL_RWops *src, int freesrc,
	SDL_AudioSpec spec, Uint8 audio_buf, Uint32 audio_len)
	{
	int was_error;
	Chunk chunk;
	int lenread;
	int MS_ADPCM_encoded, IMA_ADPCM_encoded;
	int samplesize;

	/* WAV magic header */
	Uint32 RIFFchunk;
	Uint32 wavelen = 0;
	Uint32 WAVEmagic;
	Uint32 headerDiff = 0;

	/* FMT chunk */
	WaveFMT *format = NULL;

	/* Make sure we are passed a valid data source */
	was_error = 0;
	if ( src == NULL ) {
	was_error = 1;
	goto done;
	}

	/* Check the magic header */
	RIFFchunk = SDL_ReadLE32(src);
	wavelen = SDL_ReadLE32(src);
	if ( wavelen == WAVE ) { /* The RIFFchunk has already been read */
	WAVEmagic = wavelen;
	wavelen = RIFFchunk;
	RIFFchunk = RIFF;
	} else {
	WAVEmagic = SDL_ReadLE32(src);
	}
	if ( (RIFFchunk != RIFF) \|\| (WAVEmagic != WAVE) ) {
	SDL_SetError("Unrecognized file type (not WAVE)");
	was_error = 1;
	goto done;
	}
	headerDiff += sizeof(Uint32); /* for WAVE */

	/* Read the audio data format chunk */
	chunk.data = NULL;
	do {
	if ( chunk.data != NULL ) {
	SDL_free(chunk.data);
	chunk.data = NULL;
	}
	lenread = ReadChunk(src, &chunk);
	if ( lenread < 0 ) {
	was_error = 1;
	goto done;
	}
	/* 2 Uint32's for chunk header+len, plus the lenread */
	headerDiff += lenread + 2 * sizeof(Uint32);
	} while ( (chunk.magic == FACT) \|\| (chunk.magic == LIST) );

	/* Decode the audio data format */
	format = (WaveFMT *)chunk.data;
	if ( chunk.magic != FMT ) {
	SDL_SetError("Complex WAVE files not supported");
	was_error = 1;
	goto done;
	}
	MS_ADPCM_encoded = IMA_ADPCM_encoded = 0;
	switch (SDL_SwapLE16(format->encoding)) {
	case PCM_CODE:
	/* We can understand this */
	break;
	case MS_ADPCM_CODE:
	/* Try to understand this */
	if ( InitMS_ADPCM(format) < 0 ) {
	was_error = 1;
	goto done;
	}
	MS_ADPCM_encoded = 1;
	break;
	case IMA_ADPCM_CODE:
	/* Try to understand this */
	if ( InitIMA_ADPCM(format) < 0 ) {
	was_error = 1;
	goto done;
	}
	IMA_ADPCM_encoded = 1;
	break;
	case MP3_CODE:
	SDL_SetError("MPEG Layer 3 data not supported",
	SDL_SwapLE16(format->encoding));
	was_error = 1;
	goto done;
	default:
	SDL_SetError("Unknown WAVE data format: 0x%.4x",
	SDL_SwapLE16(format->encoding));
	was_error = 1;
	goto done;
	}
	SDL_memset(spec, 0, (sizeof *spec));
	spec->freq = SDL_SwapLE32(format->frequency);
	switch (SDL_SwapLE16(format->bitspersample)) {
	case 4:
	if ( MS_ADPCM_encoded \|\| IMA_ADPCM_encoded ) {
	spec->format = AUDIO_S16;
	} else {
	was_error = 1;
	}
	break;
	case 8:
	spec->format = AUDIO_U8;
	break;
	case 16:
	spec->format = AUDIO_S16;
	break;
	default:
	was_error = 1;
	break;
	}
	if ( was_error ) {
	SDL_SetError("Unknown %d-bit PCM data format",
	SDL_SwapLE16(format->bitspersample));
	goto done;
	}
	spec->channels = (Uint8)SDL_SwapLE16(format->channels);
	spec->samples = 4096; /* Good default buffer size */

	/* Read the audio data chunk */
	*audio_buf = NULL;
	do {
	if ( *audio_buf != NULL ) {
	SDL_free(*audio_buf);
	*audio_buf = NULL;
	}
	lenread = ReadChunk(src, &chunk);
	if ( lenread < 0 ) {
	was_error = 1;
	goto done;
	}
	*audio_len = lenread;
	*audio_buf = chunk.data;
	if(chunk.magic != DATA) headerDiff += lenread + 2 * sizeof(Uint32);
	} while ( chunk.magic != DATA );
	headerDiff += 2 * sizeof(Uint32); /* for the data chunk and len */

	if ( MS_ADPCM_encoded ) {
	if ( MS_ADPCM_decode(audio_buf, audio_len) < 0 ) {
	was_error = 1;
	goto done;
	}
	}
	if ( IMA_ADPCM_encoded ) {
	if ( IMA_ADPCM_decode(audio_buf, audio_len) < 0 ) {
	was_error = 1;
	goto done;
	}
	}

	/* Don't return a buffer that isn't a multiple of samplesize */
	samplesize = ((spec->format & 0xFF)/8)*spec->channels;
	*audio_len &= ~(samplesize-1);

	done:
	if ( format != NULL ) {
	SDL_free(format);
	}
	if ( src ) {
	if ( freesrc ) {
	SDL_RWclose(src);
	} else {
	/* seek to the end of the file (given by the RIFF chunk) */
	SDL_RWseek(src, wavelen - chunk.length - headerDiff, RW_SEEK_CUR);
	}
	}
	if ( was_error ) {
	spec = NULL;
	}
	return(spec);
	}

	/* Since the WAV memory is allocated in the shared library, it must also
	be freed here. (Necessary under Win32, VC++)
	*/
	void SDL_FreeWAV(Uint8 *audio_buf)
	{
	if ( audio_buf != NULL ) {
	SDL_free(audio_buf);
	}
	}

	static int ReadChunk(SDL_RWops src, Chunk chunk)
	{
	chunk->magic = SDL_ReadLE32(src);
	chunk->length = SDL_ReadLE32(src);
	chunk->data = (Uint8 *)SDL_malloc(chunk->length);
	if ( chunk->data == NULL ) {
	SDL_Error(SDL_ENOMEM);
	return(-1);
	}
	if ( SDL_RWread(src, chunk->data, chunk->length, 1) != 1 ) {
	SDL_Error(SDL_EFREAD);
	SDL_free(chunk->data);
	chunk->data = NULL;
	return(-1);
	}
	return(chunk->length);
	}