src/audio/SDL_wave.c

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