src/audio/SDL_wave.c
author Sam Lantinga <slouken@libsdl.org>
Fri, 14 Dec 2001 12:38:15 +0000
changeset 252 e8157fcb3114
parent 171 02e27b705645
child 297 f6ffac90895c
permissions -rw-r--r--
Updated the source with the correct e-mail address
     1 /*
     2     SDL - Simple DirectMedia Layer
     3     Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga
     4 
     5     This library is free software; you can redistribute it and/or
     6     modify it under the terms of the GNU Library General Public
     7     License as published by the Free Software Foundation; either
     8     version 2 of the License, or (at your option) any later version.
     9 
    10     This library is distributed in the hope that it will be useful,
    11     but WITHOUT ANY WARRANTY; without even the implied warranty of
    12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    13     Library General Public License for more details.
    14 
    15     You should have received a copy of the GNU Library General Public
    16     License along with this library; if not, write to the Free
    17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
    18 
    19     Sam Lantinga
    20     slouken@libsdl.org
    21 */
    22 
    23 #ifdef SAVE_RCSID
    24 static char rcsid =
    25  "@(#) $Id$";
    26 #endif
    27 
    28 #ifndef DISABLE_FILE
    29 
    30 /* Microsoft WAVE file loading routines */
    31 
    32 #include <stdlib.h>
    33 #include <string.h>
    34 
    35 #include "SDL_error.h"
    36 #include "SDL_audio.h"
    37 #include "SDL_wave.h"
    38 #include "SDL_endian.h"
    39 
    40 #ifndef NELEMS
    41 #define NELEMS(array)	((sizeof array)/(sizeof array[0]))
    42 #endif
    43 
    44 static int ReadChunk(SDL_RWops *src, Chunk *chunk);
    45 
    46 struct MS_ADPCM_decodestate {
    47 	Uint8 hPredictor;
    48 	Uint16 iDelta;
    49 	Sint16 iSamp1;
    50 	Sint16 iSamp2;
    51 };
    52 static struct MS_ADPCM_decoder {
    53 	WaveFMT wavefmt;
    54 	Uint16 wSamplesPerBlock;
    55 	Uint16 wNumCoef;
    56 	Sint16 aCoeff[7][2];
    57 	/* * * */
    58 	struct MS_ADPCM_decodestate state[2];
    59 } MS_ADPCM_state;
    60 
    61 static int InitMS_ADPCM(WaveFMT *format)
    62 {
    63 	Uint8 *rogue_feel;
    64 	Uint16 extra_info;
    65 	int i;
    66 
    67 	/* Set the rogue pointer to the MS_ADPCM specific data */
    68 	MS_ADPCM_state.wavefmt.encoding = SDL_SwapLE16(format->encoding);
    69 	MS_ADPCM_state.wavefmt.channels = SDL_SwapLE16(format->channels);
    70 	MS_ADPCM_state.wavefmt.frequency = SDL_SwapLE32(format->frequency);
    71 	MS_ADPCM_state.wavefmt.byterate = SDL_SwapLE32(format->byterate);
    72 	MS_ADPCM_state.wavefmt.blockalign = SDL_SwapLE16(format->blockalign);
    73 	MS_ADPCM_state.wavefmt.bitspersample =
    74 					 SDL_SwapLE16(format->bitspersample);
    75 	rogue_feel = (Uint8 *)format+sizeof(*format);
    76 	if ( sizeof(*format) == 16 ) {
    77 		extra_info = ((rogue_feel[1]<<8)|rogue_feel[0]);
    78 		rogue_feel += sizeof(Uint16);
    79 	}
    80 	MS_ADPCM_state.wSamplesPerBlock = ((rogue_feel[1]<<8)|rogue_feel[0]);
    81 	rogue_feel += sizeof(Uint16);
    82 	MS_ADPCM_state.wNumCoef = ((rogue_feel[1]<<8)|rogue_feel[0]);
    83 	rogue_feel += sizeof(Uint16);
    84 	if ( MS_ADPCM_state.wNumCoef != 7 ) {
    85 		SDL_SetError("Unknown set of MS_ADPCM coefficients");
    86 		return(-1);
    87 	}
    88 	for ( i=0; i<MS_ADPCM_state.wNumCoef; ++i ) {
    89 		MS_ADPCM_state.aCoeff[i][0] = ((rogue_feel[1]<<8)|rogue_feel[0]);
    90 		rogue_feel += sizeof(Uint16);
    91 		MS_ADPCM_state.aCoeff[i][1] = ((rogue_feel[1]<<8)|rogue_feel[0]);
    92 		rogue_feel += sizeof(Uint16);
    93 	}
    94 	return(0);
    95 }
    96 
    97 static Sint32 MS_ADPCM_nibble(struct MS_ADPCM_decodestate *state,
    98 					Uint8 nybble, Sint16 *coeff)
    99 {
   100 	const Sint32 max_audioval = ((1<<(16-1))-1);
   101 	const Sint32 min_audioval = -(1<<(16-1));
   102 	const Sint32 adaptive[] = {
   103 		230, 230, 230, 230, 307, 409, 512, 614,
   104 		768, 614, 512, 409, 307, 230, 230, 230
   105 	};
   106 	Sint32 new_sample, delta;
   107 
   108 	new_sample = ((state->iSamp1 * coeff[0]) +
   109 		      (state->iSamp2 * coeff[1]))/256;
   110 	if ( nybble & 0x08 ) {
   111 		new_sample += state->iDelta * (nybble-0x10);
   112 	} else {
   113 		new_sample += state->iDelta * nybble;
   114 	}
   115 	if ( new_sample < min_audioval ) {
   116 		new_sample = min_audioval;
   117 	} else
   118 	if ( new_sample > max_audioval ) {
   119 		new_sample = max_audioval;
   120 	}
   121 	delta = ((Sint32)state->iDelta * adaptive[nybble])/256;
   122 	if ( delta < 16 ) {
   123 		delta = 16;
   124 	}
   125 	state->iDelta = delta;
   126 	state->iSamp2 = state->iSamp1;
   127 	state->iSamp1 = new_sample;
   128 	return(new_sample);
   129 }
   130 
   131 static int MS_ADPCM_decode(Uint8 **audio_buf, Uint32 *audio_len)
   132 {
   133 	struct MS_ADPCM_decodestate *state[2];
   134 	Uint8 *freeable, *encoded, *decoded;
   135 	Sint32 encoded_len, samplesleft;
   136 	Sint8 nybble, stereo;
   137 	Sint16 *coeff[2];
   138 	Sint32 new_sample;
   139 
   140 	/* Allocate the proper sized output buffer */
   141 	encoded_len = *audio_len;
   142 	encoded = *audio_buf;
   143 	freeable = *audio_buf;
   144 	*audio_len = (encoded_len/MS_ADPCM_state.wavefmt.blockalign) * 
   145 				MS_ADPCM_state.wSamplesPerBlock*
   146 				MS_ADPCM_state.wavefmt.channels*sizeof(Sint16);
   147 	*audio_buf = (Uint8 *)malloc(*audio_len);
   148 	if ( *audio_buf == NULL ) {
   149 		SDL_Error(SDL_ENOMEM);
   150 		return(-1);
   151 	}
   152 	decoded = *audio_buf;
   153 
   154 	/* Get ready... Go! */
   155 	stereo = (MS_ADPCM_state.wavefmt.channels == 2);
   156 	state[0] = &MS_ADPCM_state.state[0];
   157 	state[1] = &MS_ADPCM_state.state[stereo];
   158 	while ( encoded_len >= MS_ADPCM_state.wavefmt.blockalign ) {
   159 		/* Grab the initial information for this block */
   160 		state[0]->hPredictor = *encoded++;
   161 		if ( stereo ) {
   162 			state[1]->hPredictor = *encoded++;
   163 		}
   164 		state[0]->iDelta = ((encoded[1]<<8)|encoded[0]);
   165 		encoded += sizeof(Sint16);
   166 		if ( stereo ) {
   167 			state[1]->iDelta = ((encoded[1]<<8)|encoded[0]);
   168 			encoded += sizeof(Sint16);
   169 		}
   170 		state[0]->iSamp1 = ((encoded[1]<<8)|encoded[0]);
   171 		encoded += sizeof(Sint16);
   172 		if ( stereo ) {
   173 			state[1]->iSamp1 = ((encoded[1]<<8)|encoded[0]);
   174 			encoded += sizeof(Sint16);
   175 		}
   176 		state[0]->iSamp2 = ((encoded[1]<<8)|encoded[0]);
   177 		encoded += sizeof(Sint16);
   178 		if ( stereo ) {
   179 			state[1]->iSamp2 = ((encoded[1]<<8)|encoded[0]);
   180 			encoded += sizeof(Sint16);
   181 		}
   182 		coeff[0] = MS_ADPCM_state.aCoeff[state[0]->hPredictor];
   183 		coeff[1] = MS_ADPCM_state.aCoeff[state[1]->hPredictor];
   184 
   185 		/* Store the two initial samples we start with */
   186 		decoded[0] = state[0]->iSamp2&0xFF;
   187 		decoded[1] = state[0]->iSamp2>>8;
   188 		decoded += 2;
   189 		if ( stereo ) {
   190 			decoded[0] = state[1]->iSamp2&0xFF;
   191 			decoded[1] = state[1]->iSamp2>>8;
   192 			decoded += 2;
   193 		}
   194 		decoded[0] = state[0]->iSamp1&0xFF;
   195 		decoded[1] = state[0]->iSamp1>>8;
   196 		decoded += 2;
   197 		if ( stereo ) {
   198 			decoded[0] = state[1]->iSamp1&0xFF;
   199 			decoded[1] = state[1]->iSamp1>>8;
   200 			decoded += 2;
   201 		}
   202 
   203 		/* Decode and store the other samples in this block */
   204 		samplesleft = (MS_ADPCM_state.wSamplesPerBlock-2)*
   205 					MS_ADPCM_state.wavefmt.channels;
   206 		while ( samplesleft > 0 ) {
   207 			nybble = (*encoded)>>4;
   208 			new_sample = MS_ADPCM_nibble(state[0],nybble,coeff[0]);
   209 			decoded[0] = new_sample&0xFF;
   210 			new_sample >>= 8;
   211 			decoded[1] = new_sample&0xFF;
   212 			decoded += 2;
   213 
   214 			nybble = (*encoded)&0x0F;
   215 			new_sample = MS_ADPCM_nibble(state[1],nybble,coeff[1]);
   216 			decoded[0] = new_sample&0xFF;
   217 			new_sample >>= 8;
   218 			decoded[1] = new_sample&0xFF;
   219 			decoded += 2;
   220 
   221 			++encoded;
   222 			samplesleft -= 2;
   223 		}
   224 		encoded_len -= MS_ADPCM_state.wavefmt.blockalign;
   225 	}
   226 	free(freeable);
   227 	return(0);
   228 }
   229 
   230 struct IMA_ADPCM_decodestate {
   231 	Sint32 sample;
   232 	Sint8 index;
   233 };
   234 static struct IMA_ADPCM_decoder {
   235 	WaveFMT wavefmt;
   236 	Uint16 wSamplesPerBlock;
   237 	/* * * */
   238 	struct IMA_ADPCM_decodestate state[2];
   239 } IMA_ADPCM_state;
   240 
   241 static int InitIMA_ADPCM(WaveFMT *format)
   242 {
   243 	Uint8 *rogue_feel;
   244 	Uint16 extra_info;
   245 
   246 	/* Set the rogue pointer to the IMA_ADPCM specific data */
   247 	IMA_ADPCM_state.wavefmt.encoding = SDL_SwapLE16(format->encoding);
   248 	IMA_ADPCM_state.wavefmt.channels = SDL_SwapLE16(format->channels);
   249 	IMA_ADPCM_state.wavefmt.frequency = SDL_SwapLE32(format->frequency);
   250 	IMA_ADPCM_state.wavefmt.byterate = SDL_SwapLE32(format->byterate);
   251 	IMA_ADPCM_state.wavefmt.blockalign = SDL_SwapLE16(format->blockalign);
   252 	IMA_ADPCM_state.wavefmt.bitspersample =
   253 					 SDL_SwapLE16(format->bitspersample);
   254 	rogue_feel = (Uint8 *)format+sizeof(*format);
   255 	if ( sizeof(*format) == 16 ) {
   256 		extra_info = ((rogue_feel[1]<<8)|rogue_feel[0]);
   257 		rogue_feel += sizeof(Uint16);
   258 	}
   259 	IMA_ADPCM_state.wSamplesPerBlock = ((rogue_feel[1]<<8)|rogue_feel[0]);
   260 	return(0);
   261 }
   262 
   263 static Sint32 IMA_ADPCM_nibble(struct IMA_ADPCM_decodestate *state,Uint8 nybble)
   264 {
   265 	const Sint32 max_audioval = ((1<<(16-1))-1);
   266 	const Sint32 min_audioval = -(1<<(16-1));
   267 	const int index_table[16] = {
   268 		-1, -1, -1, -1,
   269 		 2,  4,  6,  8,
   270 		-1, -1, -1, -1,
   271 		 2,  4,  6,  8
   272 	};
   273 	const Sint32 step_table[89] = {
   274 		7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31,
   275 		34, 37, 41, 45, 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130,
   276 		143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408,
   277 		449, 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282,
   278 		1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327,
   279 		3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630,
   280 		9493, 10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350,
   281 		22385, 24623, 27086, 29794, 32767
   282 	};
   283 	Sint32 delta, step;
   284 
   285 	/* Compute difference and new sample value */
   286 	step = step_table[state->index];
   287 	delta = step >> 3;
   288 	if ( nybble & 0x04 ) delta += step;
   289 	if ( nybble & 0x02 ) delta += (step >> 1);
   290 	if ( nybble & 0x01 ) delta += (step >> 2);
   291 	if ( nybble & 0x08 ) delta = -delta;
   292 	state->sample += delta;
   293 
   294 	/* Update index value */
   295 	state->index += index_table[nybble];
   296 	if ( state->index > 88 ) {
   297 		state->index = 88;
   298 	} else
   299 	if ( state->index < 0 ) {
   300 		state->index = 0;
   301 	}
   302 
   303 	/* Clamp output sample */
   304 	if ( state->sample > max_audioval ) {
   305 		state->sample = max_audioval;
   306 	} else
   307 	if ( state->sample < min_audioval ) {
   308 		state->sample = min_audioval;
   309 	}
   310 	return(state->sample);
   311 }
   312 
   313 /* Fill the decode buffer with a channel block of data (8 samples) */
   314 static void Fill_IMA_ADPCM_block(Uint8 *decoded, Uint8 *encoded,
   315 	int channel, int numchannels, struct IMA_ADPCM_decodestate *state)
   316 {
   317 	int i;
   318 	Sint8 nybble;
   319 	Sint32 new_sample;
   320 
   321 	decoded += (channel * 2);
   322 	for ( i=0; i<4; ++i ) {
   323 		nybble = (*encoded)&0x0F;
   324 		new_sample = IMA_ADPCM_nibble(state, nybble);
   325 		decoded[0] = new_sample&0xFF;
   326 		new_sample >>= 8;
   327 		decoded[1] = new_sample&0xFF;
   328 		decoded += 2 * numchannels;
   329 
   330 		nybble = (*encoded)>>4;
   331 		new_sample = IMA_ADPCM_nibble(state, nybble);
   332 		decoded[0] = new_sample&0xFF;
   333 		new_sample >>= 8;
   334 		decoded[1] = new_sample&0xFF;
   335 		decoded += 2 * numchannels;
   336 
   337 		++encoded;
   338 	}
   339 }
   340 
   341 static int IMA_ADPCM_decode(Uint8 **audio_buf, Uint32 *audio_len)
   342 {
   343 	struct IMA_ADPCM_decodestate *state;
   344 	Uint8 *freeable, *encoded, *decoded;
   345 	Sint32 encoded_len, samplesleft;
   346 	int c, channels;
   347 
   348 	/* Check to make sure we have enough variables in the state array */
   349 	channels = IMA_ADPCM_state.wavefmt.channels;
   350 	if ( channels > NELEMS(IMA_ADPCM_state.state) ) {
   351 		SDL_SetError("IMA ADPCM decoder can only handle %d channels",
   352 						NELEMS(IMA_ADPCM_state.state));
   353 		return(-1);
   354 	}
   355 	state = IMA_ADPCM_state.state;
   356 
   357 	/* Allocate the proper sized output buffer */
   358 	encoded_len = *audio_len;
   359 	encoded = *audio_buf;
   360 	freeable = *audio_buf;
   361 	*audio_len = (encoded_len/IMA_ADPCM_state.wavefmt.blockalign) * 
   362 				IMA_ADPCM_state.wSamplesPerBlock*
   363 				IMA_ADPCM_state.wavefmt.channels*sizeof(Sint16);
   364 	*audio_buf = (Uint8 *)malloc(*audio_len);
   365 	if ( *audio_buf == NULL ) {
   366 		SDL_Error(SDL_ENOMEM);
   367 		return(-1);
   368 	}
   369 	decoded = *audio_buf;
   370 
   371 	/* Get ready... Go! */
   372 	while ( encoded_len >= IMA_ADPCM_state.wavefmt.blockalign ) {
   373 		/* Grab the initial information for this block */
   374 		for ( c=0; c<channels; ++c ) {
   375 			/* Fill the state information for this block */
   376 			state[c].sample = ((encoded[1]<<8)|encoded[0]);
   377 			encoded += 2;
   378 			if ( state[c].sample & 0x8000 ) {
   379 				state[c].sample -= 0x10000;
   380 			}
   381 			state[c].index = *encoded++;
   382 			/* Reserved byte in buffer header, should be 0 */
   383 			if ( *encoded++ != 0 ) {
   384 				/* Uh oh, corrupt data?  Buggy code? */;
   385 			}
   386 
   387 			/* Store the initial sample we start with */
   388 			decoded[0] = state[c].sample&0xFF;
   389 			decoded[1] = state[c].sample>>8;
   390 			decoded += 2;
   391 		}
   392 
   393 		/* Decode and store the other samples in this block */
   394 		samplesleft = (IMA_ADPCM_state.wSamplesPerBlock-1)*channels;
   395 		while ( samplesleft > 0 ) {
   396 			for ( c=0; c<channels; ++c ) {
   397 				Fill_IMA_ADPCM_block(decoded, encoded,
   398 						c, channels, &state[c]);
   399 				encoded += 4;
   400 				samplesleft -= 8;
   401 			}
   402 			decoded += (channels * 8 * 2);
   403 		}
   404 		encoded_len -= IMA_ADPCM_state.wavefmt.blockalign;
   405 	}
   406 	free(freeable);
   407 	return(0);
   408 }
   409 
   410 SDL_AudioSpec * SDL_LoadWAV_RW (SDL_RWops *src, int freesrc,
   411 		SDL_AudioSpec *spec, Uint8 **audio_buf, Uint32 *audio_len)
   412 {
   413 	int was_error;
   414 	Chunk chunk;
   415 	int lenread;
   416 	int MS_ADPCM_encoded, IMA_ADPCM_encoded;
   417 	int samplesize;
   418 
   419 	/* WAV magic header */
   420 	Uint32 RIFFchunk;
   421 	Uint32 wavelen;
   422 	Uint32 WAVEmagic;
   423 
   424 	/* FMT chunk */
   425 	WaveFMT *format = NULL;
   426 
   427 	/* Make sure we are passed a valid data source */
   428 	was_error = 0;
   429 	if ( src == NULL ) {
   430 		was_error = 1;
   431 		goto done;
   432 	}
   433 		
   434 	/* Check the magic header */
   435 	RIFFchunk	= SDL_ReadLE32(src);
   436 	wavelen		= SDL_ReadLE32(src);
   437 	if ( wavelen == WAVE ) { /* The RIFFchunk has already been read */
   438 		WAVEmagic = wavelen;
   439 		wavelen   = RIFFchunk;
   440 		RIFFchunk = RIFF;
   441 	} else {
   442 		WAVEmagic = SDL_ReadLE32(src);
   443 	}
   444 	if ( (RIFFchunk != RIFF) || (WAVEmagic != WAVE) ) {
   445 		SDL_SetError("Unrecognized file type (not WAVE)");
   446 		was_error = 1;
   447 		goto done;
   448 	}
   449 
   450 	/* Read the audio data format chunk */
   451 	chunk.data = NULL;
   452 	do {
   453 		if ( chunk.data != NULL ) {
   454 			free(chunk.data);
   455 		}
   456 		lenread = ReadChunk(src, &chunk);
   457 		if ( lenread < 0 ) {
   458 			was_error = 1;
   459 			goto done;
   460 		}
   461 	} while ( (chunk.magic == FACT) || (chunk.magic == LIST) );
   462 
   463 	/* Decode the audio data format */
   464 	format = (WaveFMT *)chunk.data;
   465 	if ( chunk.magic != FMT ) {
   466 		SDL_SetError("Complex WAVE files not supported");
   467 		was_error = 1;
   468 		goto done;
   469 	}
   470 	MS_ADPCM_encoded = IMA_ADPCM_encoded = 0;
   471 	switch (SDL_SwapLE16(format->encoding)) {
   472 		case PCM_CODE:
   473 			/* We can understand this */
   474 			break;
   475 		case MS_ADPCM_CODE:
   476 			/* Try to understand this */
   477 			if ( InitMS_ADPCM(format) < 0 ) {
   478 				was_error = 1;
   479 				goto done;
   480 			}
   481 			MS_ADPCM_encoded = 1;
   482 			break;
   483 		case IMA_ADPCM_CODE:
   484 			/* Try to understand this */
   485 			if ( InitIMA_ADPCM(format) < 0 ) {
   486 				was_error = 1;
   487 				goto done;
   488 			}
   489 			IMA_ADPCM_encoded = 1;
   490 			break;
   491 		default:
   492 			SDL_SetError("Unknown WAVE data format: 0x%.4x",
   493 					SDL_SwapLE16(format->encoding));
   494 			was_error = 1;
   495 			goto done;
   496 	}
   497 	memset(spec, 0, (sizeof *spec));
   498 	spec->freq = SDL_SwapLE32(format->frequency);
   499 	switch (SDL_SwapLE16(format->bitspersample)) {
   500 		case 4:
   501 			if ( MS_ADPCM_encoded || IMA_ADPCM_encoded ) {
   502 				spec->format = AUDIO_S16;
   503 			} else {
   504 				was_error = 1;
   505 			}
   506 			break;
   507 		case 8:
   508 			spec->format = AUDIO_U8;
   509 			break;
   510 		case 16:
   511 			spec->format = AUDIO_S16;
   512 			break;
   513 		default:
   514 			was_error = 1;
   515 			break;
   516 	}
   517 	if ( was_error ) {
   518 		SDL_SetError("Unknown %d-bit PCM data format",
   519 			SDL_SwapLE16(format->bitspersample));
   520 		goto done;
   521 	}
   522 	spec->channels = (Uint8)SDL_SwapLE16(format->channels);
   523 	spec->samples = 4096;		/* Good default buffer size */
   524 
   525 	/* Read the audio data chunk */
   526 	*audio_buf = NULL;
   527 	do {
   528 		if ( *audio_buf != NULL ) {
   529 			free(*audio_buf);
   530 		}
   531 		lenread = ReadChunk(src, &chunk);
   532 		if ( lenread < 0 ) {
   533 			was_error = 1;
   534 			goto done;
   535 		}
   536 		*audio_len = lenread;
   537 		*audio_buf = chunk.data;
   538 	} while ( chunk.magic != DATA );
   539 
   540 	if ( MS_ADPCM_encoded ) {
   541 		if ( MS_ADPCM_decode(audio_buf, audio_len) < 0 ) {
   542 			was_error = 1;
   543 			goto done;
   544 		}
   545 	}
   546 	if ( IMA_ADPCM_encoded ) {
   547 		if ( IMA_ADPCM_decode(audio_buf, audio_len) < 0 ) {
   548 			was_error = 1;
   549 			goto done;
   550 		}
   551 	}
   552 
   553 	/* Don't return a buffer that isn't a multiple of samplesize */
   554 	samplesize = ((spec->format & 0xFF)/8)*spec->channels;
   555 	*audio_len &= ~(samplesize-1);
   556 
   557 done:
   558 	if ( format != NULL ) {
   559 		free(format);
   560 	}
   561 	if ( freesrc && src ) {
   562 		SDL_RWclose(src);
   563 	}
   564 	if ( was_error ) {
   565 		spec = NULL;
   566 	}
   567 	return(spec);
   568 }
   569 
   570 /* Since the WAV memory is allocated in the shared library, it must also
   571    be freed here.  (Necessary under Win32, VC++)
   572  */
   573 void SDL_FreeWAV(Uint8 *audio_buf)
   574 {
   575 	if ( audio_buf != NULL ) {
   576 		free(audio_buf);
   577 	}
   578 }
   579 
   580 static int ReadChunk(SDL_RWops *src, Chunk *chunk)
   581 {
   582 	chunk->magic	= SDL_ReadLE32(src);
   583 	chunk->length	= SDL_ReadLE32(src);
   584 	chunk->data = (Uint8 *)malloc(chunk->length);
   585 	if ( chunk->data == NULL ) {
   586 		SDL_Error(SDL_ENOMEM);
   587 		return(-1);
   588 	}
   589 	if ( SDL_RWread(src, chunk->data, chunk->length, 1) != 1 ) {
   590 		SDL_Error(SDL_EFREAD);
   591 		free(chunk->data);
   592 		return(-1);
   593 	}
   594 	return(chunk->length);
   595 }
   596 
   597 #endif /* ENABLE_FILE */