1 /*
2 Simple DirectMedia Layer
3 Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
4
5 This software is provided 'as-is', without any express or implied
6 warranty. In no event will the authors be held liable for any damages
7 arising from the use of this software.
8
9 Permission is granted to anyone to use this software for any purpose,
10 including commercial applications, and to alter it and redistribute it
11 freely, subject to the following restrictions:
12
13 1. The origin of this software must not be misrepresented; you must not
14 claim that you wrote the original software. If you use this software
15 in a product, an acknowledgment in the product documentation would be
16 appreciated but is not required.
17 2. Altered source versions must be plainly marked as such, and must not be
18 misrepresented as being the original software.
19 3. This notice may not be removed or altered from any source distribution.
20 */
21 #include "../SDL_internal.h"
22
23 /* Microsoft WAVE file loading routines */
24
25 #include "SDL_audio.h"
26 #include "SDL_wave.h"
27
28
29 static int ReadChunk(SDL_RWops * src, Chunk * chunk);
30
31 struct MS_ADPCM_decodestate
32 {
33 Uint8 hPredictor;
34 Uint16 iDelta;
35 Sint16 iSamp1;
36 Sint16 iSamp2;
37 };
38 static struct MS_ADPCM_decoder
39 {
40 WaveFMT wavefmt;
41 Uint16 wSamplesPerBlock;
42 Uint16 wNumCoef;
43 Sint16 aCoeff[7][2];
44 /* * * */
45 struct MS_ADPCM_decodestate state[2];
46 } MS_ADPCM_state;
47
48 static int
InitMS_ADPCM(WaveFMT * format)49 InitMS_ADPCM(WaveFMT * format)
50 {
51 Uint8 *rogue_feel;
52 int i;
53
54 /* Set the rogue pointer to the MS_ADPCM specific data */
55 MS_ADPCM_state.wavefmt.encoding = SDL_SwapLE16(format->encoding);
56 MS_ADPCM_state.wavefmt.channels = SDL_SwapLE16(format->channels);
57 MS_ADPCM_state.wavefmt.frequency = SDL_SwapLE32(format->frequency);
58 MS_ADPCM_state.wavefmt.byterate = SDL_SwapLE32(format->byterate);
59 MS_ADPCM_state.wavefmt.blockalign = SDL_SwapLE16(format->blockalign);
60 MS_ADPCM_state.wavefmt.bitspersample =
61 SDL_SwapLE16(format->bitspersample);
62 rogue_feel = (Uint8 *) format + sizeof(*format);
63 if (sizeof(*format) == 16) {
64 /* const Uint16 extra_info = ((rogue_feel[1] << 8) | rogue_feel[0]); */
65 rogue_feel += sizeof(Uint16);
66 }
67 MS_ADPCM_state.wSamplesPerBlock = ((rogue_feel[1] << 8) | rogue_feel[0]);
68 rogue_feel += sizeof(Uint16);
69 MS_ADPCM_state.wNumCoef = ((rogue_feel[1] << 8) | rogue_feel[0]);
70 rogue_feel += sizeof(Uint16);
71 if (MS_ADPCM_state.wNumCoef != 7) {
72 SDL_SetError("Unknown set of MS_ADPCM coefficients");
73 return (-1);
74 }
75 for (i = 0; i < MS_ADPCM_state.wNumCoef; ++i) {
76 MS_ADPCM_state.aCoeff[i][0] = ((rogue_feel[1] << 8) | rogue_feel[0]);
77 rogue_feel += sizeof(Uint16);
78 MS_ADPCM_state.aCoeff[i][1] = ((rogue_feel[1] << 8) | rogue_feel[0]);
79 rogue_feel += sizeof(Uint16);
80 }
81 return (0);
82 }
83
84 static Sint32
MS_ADPCM_nibble(struct MS_ADPCM_decodestate * state,Uint8 nybble,Sint16 * coeff)85 MS_ADPCM_nibble(struct MS_ADPCM_decodestate *state,
86 Uint8 nybble, Sint16 * coeff)
87 {
88 const Sint32 max_audioval = ((1 << (16 - 1)) - 1);
89 const Sint32 min_audioval = -(1 << (16 - 1));
90 const Sint32 adaptive[] = {
91 230, 230, 230, 230, 307, 409, 512, 614,
92 768, 614, 512, 409, 307, 230, 230, 230
93 };
94 Sint32 new_sample, delta;
95
96 new_sample = ((state->iSamp1 * coeff[0]) +
97 (state->iSamp2 * coeff[1])) / 256;
98 if (nybble & 0x08) {
99 new_sample += state->iDelta * (nybble - 0x10);
100 } else {
101 new_sample += state->iDelta * nybble;
102 }
103 if (new_sample < min_audioval) {
104 new_sample = min_audioval;
105 } else if (new_sample > max_audioval) {
106 new_sample = max_audioval;
107 }
108 delta = ((Sint32) state->iDelta * adaptive[nybble]) / 256;
109 if (delta < 16) {
110 delta = 16;
111 }
112 state->iDelta = (Uint16) delta;
113 state->iSamp2 = state->iSamp1;
114 state->iSamp1 = (Sint16) new_sample;
115 return (new_sample);
116 }
117
118 static int
MS_ADPCM_decode(Uint8 ** audio_buf,Uint32 * audio_len)119 MS_ADPCM_decode(Uint8 ** audio_buf, Uint32 * audio_len)
120 {
121 struct MS_ADPCM_decodestate *state[2];
122 Uint8 *freeable, *encoded, *decoded;
123 Sint32 encoded_len, samplesleft;
124 Sint8 nybble;
125 Uint8 stereo;
126 Sint16 *coeff[2];
127 Sint32 new_sample;
128
129 /* Allocate the proper sized output buffer */
130 encoded_len = *audio_len;
131 encoded = *audio_buf;
132 freeable = *audio_buf;
133 *audio_len = (encoded_len / MS_ADPCM_state.wavefmt.blockalign) *
134 MS_ADPCM_state.wSamplesPerBlock *
135 MS_ADPCM_state.wavefmt.channels * sizeof(Sint16);
136 *audio_buf = (Uint8 *) SDL_malloc(*audio_len);
137 if (*audio_buf == NULL) {
138 return SDL_OutOfMemory();
139 }
140 decoded = *audio_buf;
141
142 /* Get ready... Go! */
143 stereo = (MS_ADPCM_state.wavefmt.channels == 2);
144 state[0] = &MS_ADPCM_state.state[0];
145 state[1] = &MS_ADPCM_state.state[stereo];
146 while (encoded_len >= MS_ADPCM_state.wavefmt.blockalign) {
147 /* Grab the initial information for this block */
148 state[0]->hPredictor = *encoded++;
149 if (stereo) {
150 state[1]->hPredictor = *encoded++;
151 }
152 state[0]->iDelta = ((encoded[1] << 8) | encoded[0]);
153 encoded += sizeof(Sint16);
154 if (stereo) {
155 state[1]->iDelta = ((encoded[1] << 8) | encoded[0]);
156 encoded += sizeof(Sint16);
157 }
158 state[0]->iSamp1 = ((encoded[1] << 8) | encoded[0]);
159 encoded += sizeof(Sint16);
160 if (stereo) {
161 state[1]->iSamp1 = ((encoded[1] << 8) | encoded[0]);
162 encoded += sizeof(Sint16);
163 }
164 state[0]->iSamp2 = ((encoded[1] << 8) | encoded[0]);
165 encoded += sizeof(Sint16);
166 if (stereo) {
167 state[1]->iSamp2 = ((encoded[1] << 8) | encoded[0]);
168 encoded += sizeof(Sint16);
169 }
170 coeff[0] = MS_ADPCM_state.aCoeff[state[0]->hPredictor];
171 coeff[1] = MS_ADPCM_state.aCoeff[state[1]->hPredictor];
172
173 /* Store the two initial samples we start with */
174 decoded[0] = state[0]->iSamp2 & 0xFF;
175 decoded[1] = state[0]->iSamp2 >> 8;
176 decoded += 2;
177 if (stereo) {
178 decoded[0] = state[1]->iSamp2 & 0xFF;
179 decoded[1] = state[1]->iSamp2 >> 8;
180 decoded += 2;
181 }
182 decoded[0] = state[0]->iSamp1 & 0xFF;
183 decoded[1] = state[0]->iSamp1 >> 8;
184 decoded += 2;
185 if (stereo) {
186 decoded[0] = state[1]->iSamp1 & 0xFF;
187 decoded[1] = state[1]->iSamp1 >> 8;
188 decoded += 2;
189 }
190
191 /* Decode and store the other samples in this block */
192 samplesleft = (MS_ADPCM_state.wSamplesPerBlock - 2) *
193 MS_ADPCM_state.wavefmt.channels;
194 while (samplesleft > 0) {
195 nybble = (*encoded) >> 4;
196 new_sample = MS_ADPCM_nibble(state[0], nybble, coeff[0]);
197 decoded[0] = new_sample & 0xFF;
198 new_sample >>= 8;
199 decoded[1] = new_sample & 0xFF;
200 decoded += 2;
201
202 nybble = (*encoded) & 0x0F;
203 new_sample = MS_ADPCM_nibble(state[1], nybble, coeff[1]);
204 decoded[0] = new_sample & 0xFF;
205 new_sample >>= 8;
206 decoded[1] = new_sample & 0xFF;
207 decoded += 2;
208
209 ++encoded;
210 samplesleft -= 2;
211 }
212 encoded_len -= MS_ADPCM_state.wavefmt.blockalign;
213 }
214 SDL_free(freeable);
215 return (0);
216 }
217
218 struct IMA_ADPCM_decodestate
219 {
220 Sint32 sample;
221 Sint8 index;
222 };
223 static struct IMA_ADPCM_decoder
224 {
225 WaveFMT wavefmt;
226 Uint16 wSamplesPerBlock;
227 /* * * */
228 struct IMA_ADPCM_decodestate state[2];
229 } IMA_ADPCM_state;
230
231 static int
InitIMA_ADPCM(WaveFMT * format)232 InitIMA_ADPCM(WaveFMT * format)
233 {
234 Uint8 *rogue_feel;
235
236 /* Set the rogue pointer to the IMA_ADPCM specific data */
237 IMA_ADPCM_state.wavefmt.encoding = SDL_SwapLE16(format->encoding);
238 IMA_ADPCM_state.wavefmt.channels = SDL_SwapLE16(format->channels);
239 IMA_ADPCM_state.wavefmt.frequency = SDL_SwapLE32(format->frequency);
240 IMA_ADPCM_state.wavefmt.byterate = SDL_SwapLE32(format->byterate);
241 IMA_ADPCM_state.wavefmt.blockalign = SDL_SwapLE16(format->blockalign);
242 IMA_ADPCM_state.wavefmt.bitspersample =
243 SDL_SwapLE16(format->bitspersample);
244 rogue_feel = (Uint8 *) format + sizeof(*format);
245 if (sizeof(*format) == 16) {
246 /* const Uint16 extra_info = ((rogue_feel[1] << 8) | rogue_feel[0]); */
247 rogue_feel += sizeof(Uint16);
248 }
249 IMA_ADPCM_state.wSamplesPerBlock = ((rogue_feel[1] << 8) | rogue_feel[0]);
250 return (0);
251 }
252
253 static Sint32
IMA_ADPCM_nibble(struct IMA_ADPCM_decodestate * state,Uint8 nybble)254 IMA_ADPCM_nibble(struct IMA_ADPCM_decodestate *state, Uint8 nybble)
255 {
256 const Sint32 max_audioval = ((1 << (16 - 1)) - 1);
257 const Sint32 min_audioval = -(1 << (16 - 1));
258 const int index_table[16] = {
259 -1, -1, -1, -1,
260 2, 4, 6, 8,
261 -1, -1, -1, -1,
262 2, 4, 6, 8
263 };
264 const Sint32 step_table[89] = {
265 7, 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 21, 23, 25, 28, 31,
266 34, 37, 41, 45, 50, 55, 60, 66, 73, 80, 88, 97, 107, 118, 130,
267 143, 157, 173, 190, 209, 230, 253, 279, 307, 337, 371, 408,
268 449, 494, 544, 598, 658, 724, 796, 876, 963, 1060, 1166, 1282,
269 1411, 1552, 1707, 1878, 2066, 2272, 2499, 2749, 3024, 3327,
270 3660, 4026, 4428, 4871, 5358, 5894, 6484, 7132, 7845, 8630,
271 9493, 10442, 11487, 12635, 13899, 15289, 16818, 18500, 20350,
272 22385, 24623, 27086, 29794, 32767
273 };
274 Sint32 delta, step;
275
276 /* Compute difference and new sample value */
277 if (state->index > 88) {
278 state->index = 88;
279 } else if (state->index < 0) {
280 state->index = 0;
281 }
282 /* explicit cast to avoid gcc warning about using 'char' as array index */
283 step = step_table[(int)state->index];
284 delta = step >> 3;
285 if (nybble & 0x04)
286 delta += step;
287 if (nybble & 0x02)
288 delta += (step >> 1);
289 if (nybble & 0x01)
290 delta += (step >> 2);
291 if (nybble & 0x08)
292 delta = -delta;
293 state->sample += delta;
294
295 /* Update index value */
296 state->index += index_table[nybble];
297
298 /* Clamp output sample */
299 if (state->sample > max_audioval) {
300 state->sample = max_audioval;
301 } else if (state->sample < min_audioval) {
302 state->sample = min_audioval;
303 }
304 return (state->sample);
305 }
306
307 /* Fill the decode buffer with a channel block of data (8 samples) */
308 static void
Fill_IMA_ADPCM_block(Uint8 * decoded,Uint8 * encoded,int channel,int numchannels,struct IMA_ADPCM_decodestate * state)309 Fill_IMA_ADPCM_block(Uint8 * decoded, Uint8 * encoded,
310 int channel, int numchannels,
311 struct IMA_ADPCM_decodestate *state)
312 {
313 int i;
314 Sint8 nybble;
315 Sint32 new_sample;
316
317 decoded += (channel * 2);
318 for (i = 0; i < 4; ++i) {
319 nybble = (*encoded) & 0x0F;
320 new_sample = IMA_ADPCM_nibble(state, nybble);
321 decoded[0] = new_sample & 0xFF;
322 new_sample >>= 8;
323 decoded[1] = new_sample & 0xFF;
324 decoded += 2 * numchannels;
325
326 nybble = (*encoded) >> 4;
327 new_sample = IMA_ADPCM_nibble(state, nybble);
328 decoded[0] = new_sample & 0xFF;
329 new_sample >>= 8;
330 decoded[1] = new_sample & 0xFF;
331 decoded += 2 * numchannels;
332
333 ++encoded;
334 }
335 }
336
337 static int
IMA_ADPCM_decode(Uint8 ** audio_buf,Uint32 * audio_len)338 IMA_ADPCM_decode(Uint8 ** audio_buf, Uint32 * audio_len)
339 {
340 struct IMA_ADPCM_decodestate *state;
341 Uint8 *freeable, *encoded, *decoded;
342 Sint32 encoded_len, samplesleft;
343 unsigned int c, channels;
344
345 /* Check to make sure we have enough variables in the state array */
346 channels = IMA_ADPCM_state.wavefmt.channels;
347 if (channels > SDL_arraysize(IMA_ADPCM_state.state)) {
348 SDL_SetError("IMA ADPCM decoder can only handle %u channels",
349 (unsigned int)SDL_arraysize(IMA_ADPCM_state.state));
350 return (-1);
351 }
352 state = IMA_ADPCM_state.state;
353
354 /* Allocate the proper sized output buffer */
355 encoded_len = *audio_len;
356 encoded = *audio_buf;
357 freeable = *audio_buf;
358 *audio_len = (encoded_len / IMA_ADPCM_state.wavefmt.blockalign) *
359 IMA_ADPCM_state.wSamplesPerBlock *
360 IMA_ADPCM_state.wavefmt.channels * sizeof(Sint16);
361 *audio_buf = (Uint8 *) SDL_malloc(*audio_len);
362 if (*audio_buf == NULL) {
363 return SDL_OutOfMemory();
364 }
365 decoded = *audio_buf;
366
367 /* Get ready... Go! */
368 while (encoded_len >= IMA_ADPCM_state.wavefmt.blockalign) {
369 /* Grab the initial information for this block */
370 for (c = 0; c < channels; ++c) {
371 /* Fill the state information for this block */
372 state[c].sample = ((encoded[1] << 8) | encoded[0]);
373 encoded += 2;
374 if (state[c].sample & 0x8000) {
375 state[c].sample -= 0x10000;
376 }
377 state[c].index = *encoded++;
378 /* Reserved byte in buffer header, should be 0 */
379 if (*encoded++ != 0) {
380 /* Uh oh, corrupt data? Buggy code? */ ;
381 }
382
383 /* Store the initial sample we start with */
384 decoded[0] = (Uint8) (state[c].sample & 0xFF);
385 decoded[1] = (Uint8) (state[c].sample >> 8);
386 decoded += 2;
387 }
388
389 /* Decode and store the other samples in this block */
390 samplesleft = (IMA_ADPCM_state.wSamplesPerBlock - 1) * channels;
391 while (samplesleft > 0) {
392 for (c = 0; c < channels; ++c) {
393 Fill_IMA_ADPCM_block(decoded, encoded,
394 c, channels, &state[c]);
395 encoded += 4;
396 samplesleft -= 8;
397 }
398 decoded += (channels * 8 * 2);
399 }
400 encoded_len -= IMA_ADPCM_state.wavefmt.blockalign;
401 }
402 SDL_free(freeable);
403 return (0);
404 }
405
406
407 static int
ConvertSint24ToSint32(Uint8 ** audio_buf,Uint32 * audio_len)408 ConvertSint24ToSint32(Uint8 ** audio_buf, Uint32 * audio_len)
409 {
410 const double DIVBY8388608 = 0.00000011920928955078125;
411 const Uint32 original_len = *audio_len;
412 const Uint32 samples = original_len / 3;
413 const Uint32 expanded_len = samples * sizeof (Uint32);
414 Uint8 *ptr = (Uint8 *) SDL_realloc(*audio_buf, expanded_len);
415 const Uint8 *src;
416 Uint32 *dst;
417 Uint32 i;
418
419 if (!ptr) {
420 return SDL_OutOfMemory();
421 }
422
423 *audio_buf = ptr;
424 *audio_len = expanded_len;
425
426 /* work from end to start, since we're expanding in-place. */
427 src = (ptr + original_len) - 3;
428 dst = ((Uint32 *) (ptr + expanded_len)) - 1;
429 for (i = 0; i < samples; i++) {
430 /* There's probably a faster way to do all this. */
431 const Sint32 converted = ((Sint32) ( (((Uint32) src[2]) << 24) |
432 (((Uint32) src[1]) << 16) |
433 (((Uint32) src[0]) << 8) )) >> 8;
434 const double scaled = (((double) converted) * DIVBY8388608);
435 src -= 3;
436 *(dst--) = (Sint32) (scaled * 2147483647.0);
437 }
438
439 return 0;
440 }
441
442
443 /* GUIDs that are used by WAVE_FORMAT_EXTENSIBLE */
444 static const Uint8 extensible_pcm_guid[16] = { 1, 0, 0, 0, 0, 0, 16, 0, 128, 0, 0, 170, 0, 56, 155, 113 };
445 static const Uint8 extensible_ieee_guid[16] = { 3, 0, 0, 0, 0, 0, 16, 0, 128, 0, 0, 170, 0, 56, 155, 113 };
446
447 SDL_AudioSpec *
SDL_LoadWAV_RW(SDL_RWops * src,int freesrc,SDL_AudioSpec * spec,Uint8 ** audio_buf,Uint32 * audio_len)448 SDL_LoadWAV_RW(SDL_RWops * src, int freesrc,
449 SDL_AudioSpec * spec, Uint8 ** audio_buf, Uint32 * audio_len)
450 {
451 int was_error;
452 Chunk chunk;
453 int lenread;
454 int IEEE_float_encoded, MS_ADPCM_encoded, IMA_ADPCM_encoded;
455 int samplesize;
456
457 /* WAV magic header */
458 Uint32 RIFFchunk;
459 Uint32 wavelen = 0;
460 Uint32 WAVEmagic;
461 Uint32 headerDiff = 0;
462
463 /* FMT chunk */
464 WaveFMT *format = NULL;
465 WaveExtensibleFMT *ext = NULL;
466
467 SDL_zero(chunk);
468
469 /* Make sure we are passed a valid data source */
470 was_error = 0;
471 if (src == NULL) {
472 was_error = 1;
473 goto done;
474 }
475
476 /* Check the magic header */
477 RIFFchunk = SDL_ReadLE32(src);
478 wavelen = SDL_ReadLE32(src);
479 if (wavelen == WAVE) { /* The RIFFchunk has already been read */
480 WAVEmagic = wavelen;
481 wavelen = RIFFchunk;
482 RIFFchunk = RIFF;
483 } else {
484 WAVEmagic = SDL_ReadLE32(src);
485 }
486 if ((RIFFchunk != RIFF) || (WAVEmagic != WAVE)) {
487 SDL_SetError("Unrecognized file type (not WAVE)");
488 was_error = 1;
489 goto done;
490 }
491 headerDiff += sizeof(Uint32); /* for WAVE */
492
493 /* Read the audio data format chunk */
494 chunk.data = NULL;
495 do {
496 SDL_free(chunk.data);
497 chunk.data = NULL;
498 lenread = ReadChunk(src, &chunk);
499 if (lenread < 0) {
500 was_error = 1;
501 goto done;
502 }
503 /* 2 Uint32's for chunk header+len, plus the lenread */
504 headerDiff += lenread + 2 * sizeof(Uint32);
505 } while ((chunk.magic == FACT) || (chunk.magic == LIST) || (chunk.magic == BEXT) || (chunk.magic == JUNK));
506
507 /* Decode the audio data format */
508 format = (WaveFMT *) chunk.data;
509 if (chunk.magic != FMT) {
510 SDL_SetError("Complex WAVE files not supported");
511 was_error = 1;
512 goto done;
513 }
514 IEEE_float_encoded = MS_ADPCM_encoded = IMA_ADPCM_encoded = 0;
515 switch (SDL_SwapLE16(format->encoding)) {
516 case PCM_CODE:
517 /* We can understand this */
518 break;
519 case IEEE_FLOAT_CODE:
520 IEEE_float_encoded = 1;
521 /* We can understand this */
522 break;
523 case MS_ADPCM_CODE:
524 /* Try to understand this */
525 if (InitMS_ADPCM(format) < 0) {
526 was_error = 1;
527 goto done;
528 }
529 MS_ADPCM_encoded = 1;
530 break;
531 case IMA_ADPCM_CODE:
532 /* Try to understand this */
533 if (InitIMA_ADPCM(format) < 0) {
534 was_error = 1;
535 goto done;
536 }
537 IMA_ADPCM_encoded = 1;
538 break;
539 case EXTENSIBLE_CODE:
540 /* note that this ignores channel masks, smaller valid bit counts
541 inside a larger container, and most subtypes. This is just enough
542 to get things that didn't really _need_ WAVE_FORMAT_EXTENSIBLE
543 to be useful working when they use this format flag. */
544 ext = (WaveExtensibleFMT *) format;
545 if (SDL_SwapLE16(ext->size) < 22) {
546 SDL_SetError("bogus extended .wav header");
547 was_error = 1;
548 goto done;
549 }
550 if (SDL_memcmp(ext->subformat, extensible_pcm_guid, 16) == 0) {
551 break; /* cool. */
552 } else if (SDL_memcmp(ext->subformat, extensible_ieee_guid, 16) == 0) {
553 IEEE_float_encoded = 1;
554 break;
555 }
556 break;
557 case MP3_CODE:
558 SDL_SetError("MPEG Layer 3 data not supported");
559 was_error = 1;
560 goto done;
561 default:
562 SDL_SetError("Unknown WAVE data format: 0x%.4x",
563 SDL_SwapLE16(format->encoding));
564 was_error = 1;
565 goto done;
566 }
567 SDL_zerop(spec);
568 spec->freq = SDL_SwapLE32(format->frequency);
569
570 if (IEEE_float_encoded) {
571 if ((SDL_SwapLE16(format->bitspersample)) != 32) {
572 was_error = 1;
573 } else {
574 spec->format = AUDIO_F32;
575 }
576 } else {
577 switch (SDL_SwapLE16(format->bitspersample)) {
578 case 4:
579 if (MS_ADPCM_encoded || IMA_ADPCM_encoded) {
580 spec->format = AUDIO_S16;
581 } else {
582 was_error = 1;
583 }
584 break;
585 case 8:
586 spec->format = AUDIO_U8;
587 break;
588 case 16:
589 spec->format = AUDIO_S16;
590 break;
591 case 24: /* convert this. */
592 spec->format = AUDIO_S32;
593 break;
594 case 32:
595 spec->format = AUDIO_S32;
596 break;
597 default:
598 was_error = 1;
599 break;
600 }
601 }
602
603 if (was_error) {
604 SDL_SetError("Unknown %d-bit PCM data format",
605 SDL_SwapLE16(format->bitspersample));
606 goto done;
607 }
608 spec->channels = (Uint8) SDL_SwapLE16(format->channels);
609 spec->samples = 4096; /* Good default buffer size */
610
611 /* Read the audio data chunk */
612 *audio_buf = NULL;
613 do {
614 SDL_free(*audio_buf);
615 *audio_buf = NULL;
616 lenread = ReadChunk(src, &chunk);
617 if (lenread < 0) {
618 was_error = 1;
619 goto done;
620 }
621 *audio_len = lenread;
622 *audio_buf = chunk.data;
623 if (chunk.magic != DATA)
624 headerDiff += lenread + 2 * sizeof(Uint32);
625 } while (chunk.magic != DATA);
626 headerDiff += 2 * sizeof(Uint32); /* for the data chunk and len */
627
628 if (MS_ADPCM_encoded) {
629 if (MS_ADPCM_decode(audio_buf, audio_len) < 0) {
630 was_error = 1;
631 goto done;
632 }
633 }
634 if (IMA_ADPCM_encoded) {
635 if (IMA_ADPCM_decode(audio_buf, audio_len) < 0) {
636 was_error = 1;
637 goto done;
638 }
639 }
640
641 if (SDL_SwapLE16(format->bitspersample) == 24) {
642 if (ConvertSint24ToSint32(audio_buf, audio_len) < 0) {
643 was_error = 1;
644 goto done;
645 }
646 }
647
648 /* Don't return a buffer that isn't a multiple of samplesize */
649 samplesize = ((SDL_AUDIO_BITSIZE(spec->format)) / 8) * spec->channels;
650 *audio_len &= ~(samplesize - 1);
651
652 done:
653 SDL_free(format);
654 if (src) {
655 if (freesrc) {
656 SDL_RWclose(src);
657 } else {
658 /* seek to the end of the file (given by the RIFF chunk) */
659 SDL_RWseek(src, wavelen - chunk.length - headerDiff, RW_SEEK_CUR);
660 }
661 }
662 if (was_error) {
663 spec = NULL;
664 }
665 return (spec);
666 }
667
668 /* Since the WAV memory is allocated in the shared library, it must also
669 be freed here. (Necessary under Win32, VC++)
670 */
671 void
SDL_FreeWAV(Uint8 * audio_buf)672 SDL_FreeWAV(Uint8 * audio_buf)
673 {
674 SDL_free(audio_buf);
675 }
676
677 static int
ReadChunk(SDL_RWops * src,Chunk * chunk)678 ReadChunk(SDL_RWops * src, Chunk * chunk)
679 {
680 chunk->magic = SDL_ReadLE32(src);
681 chunk->length = SDL_ReadLE32(src);
682 chunk->data = (Uint8 *) SDL_malloc(chunk->length);
683 if (chunk->data == NULL) {
684 return SDL_OutOfMemory();
685 }
686 if (SDL_RWread(src, chunk->data, chunk->length, 1) != 1) {
687 SDL_free(chunk->data);
688 chunk->data = NULL;
689 return SDL_Error(SDL_EFREAD);
690 }
691 return (chunk->length);
692 }
693
694 /* vi: set ts=4 sw=4 expandtab: */
695