Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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@devolution.com
  21. */
  22.  
  23. #ifdef SAVE_RCSID
  24. static char rcsid =
  25.  "@(#) $Id: SDL_wave.c,v 1.2 2001/04/26 16:50:17 hercules Exp $";
  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.         WAVEmagic       = SDL_ReadLE32(src);
  438.         if ( (RIFFchunk != RIFF) || (WAVEmagic != WAVE) ) {
  439.                 SDL_SetError("Unrecognized file type (not WAVE)");
  440.                 was_error = 1;
  441.                 goto done;
  442.         }
  443.  
  444.         /* Read the audio data format chunk */
  445.         chunk.data = NULL;
  446.         do {
  447.                 if ( chunk.data != NULL ) {
  448.                         free(chunk.data);
  449.                 }
  450.                 lenread = ReadChunk(src, &chunk);
  451.                 if ( lenread < 0 ) {
  452.                         was_error = 1;
  453.                         goto done;
  454.                 }
  455.         } while ( (chunk.magic == FACT) || (chunk.magic == LIST) );
  456.  
  457.         /* Decode the audio data format */
  458.         format = (WaveFMT *)chunk.data;
  459.         if ( chunk.magic != FMT ) {
  460.                 SDL_SetError("Complex WAVE files not supported");
  461.                 was_error = 1;
  462.                 goto done;
  463.         }
  464.         MS_ADPCM_encoded = IMA_ADPCM_encoded = 0;
  465.         switch (SDL_SwapLE16(format->encoding)) {
  466.                 case PCM_CODE:
  467.                         /* We can understand this */
  468.                         break;
  469.                 case MS_ADPCM_CODE:
  470.                         /* Try to understand this */
  471.                         if ( InitMS_ADPCM(format) < 0 ) {
  472.                                 was_error = 1;
  473.                                 goto done;
  474.                         }
  475.                         MS_ADPCM_encoded = 1;
  476.                         break;
  477.                 case IMA_ADPCM_CODE:
  478.                         /* Try to understand this */
  479.                         if ( InitIMA_ADPCM(format) < 0 ) {
  480.                                 was_error = 1;
  481.                                 goto done;
  482.                         }
  483.                         IMA_ADPCM_encoded = 1;
  484.                         break;
  485.                 default:
  486.                         SDL_SetError("Unknown WAVE data format: 0x%.4x",
  487.                                         SDL_SwapLE16(format->encoding));
  488.                         was_error = 1;
  489.                         goto done;
  490.         }
  491.         memset(spec, 0, (sizeof *spec));
  492.         spec->freq = SDL_SwapLE32(format->frequency);
  493.         switch (SDL_SwapLE16(format->bitspersample)) {
  494.                 case 4:
  495.                         if ( MS_ADPCM_encoded || IMA_ADPCM_encoded ) {
  496.                                 spec->format = AUDIO_S16;
  497.                         } else {
  498.                                 was_error = 1;
  499.                         }
  500.                         break;
  501.                 case 8:
  502.                         spec->format = AUDIO_U8;
  503.                         break;
  504.                 case 16:
  505.                         spec->format = AUDIO_S16;
  506.                         break;
  507.                 default:
  508.                         was_error = 1;
  509.                         break;
  510.         }
  511.         if ( was_error ) {
  512.                 SDL_SetError("Unknown %d-bit PCM data format",
  513.                         SDL_SwapLE16(format->bitspersample));
  514.                 goto done;
  515.         }
  516.         spec->channels = (Uint8)SDL_SwapLE16(format->channels);
  517.         spec->samples = 4096;           /* Good default buffer size */
  518.  
  519.         /* Read the audio data chunk */
  520.         *audio_buf = NULL;
  521.         do {
  522.                 if ( *audio_buf != NULL ) {
  523.                         free(*audio_buf);
  524.                 }
  525.                 lenread = ReadChunk(src, &chunk);
  526.                 if ( lenread < 0 ) {
  527.                         was_error = 1;
  528.                         goto done;
  529.                 }
  530.                 *audio_len = lenread;
  531.                 *audio_buf = chunk.data;
  532.         } while ( chunk.magic != DATA );
  533.  
  534.         if ( MS_ADPCM_encoded ) {
  535.                 if ( MS_ADPCM_decode(audio_buf, audio_len) < 0 ) {
  536.                         was_error = 1;
  537.                         goto done;
  538.                 }
  539.         }
  540.         if ( IMA_ADPCM_encoded ) {
  541.                 if ( IMA_ADPCM_decode(audio_buf, audio_len) < 0 ) {
  542.                         was_error = 1;
  543.                         goto done;
  544.                 }
  545.         }
  546.  
  547.         /* Don't return a buffer that isn't a multiple of samplesize */
  548.         samplesize = ((spec->format & 0xFF)/8)*spec->channels;
  549.         *audio_len &= ~(samplesize-1);
  550.  
  551. done:
  552.         if ( format != NULL ) {
  553.                 free(format);
  554.         }
  555.         if ( freesrc && src ) {
  556.                 SDL_RWclose(src);
  557.         }
  558.         if ( was_error ) {
  559.                 spec = NULL;
  560.         }
  561.         return(spec);
  562. }
  563.  
  564. /* Since the WAV memory is allocated in the shared library, it must also
  565.    be freed here.  (Necessary under Win32, VC++)
  566.  */
  567. void SDL_FreeWAV(Uint8 *audio_buf)
  568. {
  569.         if ( audio_buf != NULL ) {
  570.                 free(audio_buf);
  571.         }
  572. }
  573.  
  574. static int ReadChunk(SDL_RWops *src, Chunk *chunk)
  575. {
  576.         chunk->magic    = SDL_ReadLE32(src);
  577.         chunk->length   = SDL_ReadLE32(src);
  578.         chunk->data = (Uint8 *)malloc(chunk->length);
  579.         if ( chunk->data == NULL ) {
  580.                 SDL_Error(SDL_ENOMEM);
  581.                 return(-1);
  582.         }
  583.         if ( SDL_RWread(src, chunk->data, chunk->length, 1) != 1 ) {
  584.                 SDL_Error(SDL_EFREAD);
  585.                 free(chunk->data);
  586.                 return(-1);
  587.         }
  588.         return(chunk->length);
  589. }
  590.  
  591. #endif /* ENABLE_FILE */
  592.