e14743d1 |
1 | /* |
2 | SDL - Simple DirectMedia Layer |
3 | Copyright (C) 1997-2009 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 | /* Functions for audio drivers to perform runtime conversion of audio format */ |
25 | |
26 | #include "SDL_audio.h" |
27 | |
28 | |
29 | /* Effectively mix right and left channels into a single channel */ |
30 | void SDLCALL SDL_ConvertMono(SDL_AudioCVT *cvt, Uint16 format) |
31 | { |
32 | int i; |
33 | Sint32 sample; |
34 | |
35 | #ifdef DEBUG_CONVERT |
36 | fprintf(stderr, "Converting to mono\n"); |
37 | #endif |
38 | switch (format&0x8018) { |
39 | |
40 | case AUDIO_U8: { |
41 | Uint8 *src, *dst; |
42 | |
43 | src = cvt->buf; |
44 | dst = cvt->buf; |
45 | for ( i=cvt->len_cvt/2; i; --i ) { |
46 | sample = src[0] + src[1]; |
47 | *dst = (Uint8)(sample / 2); |
48 | src += 2; |
49 | dst += 1; |
50 | } |
51 | } |
52 | break; |
53 | |
54 | case AUDIO_S8: { |
55 | Sint8 *src, *dst; |
56 | |
57 | src = (Sint8 *)cvt->buf; |
58 | dst = (Sint8 *)cvt->buf; |
59 | for ( i=cvt->len_cvt/2; i; --i ) { |
60 | sample = src[0] + src[1]; |
61 | *dst = (Sint8)(sample / 2); |
62 | src += 2; |
63 | dst += 1; |
64 | } |
65 | } |
66 | break; |
67 | |
68 | case AUDIO_U16: { |
69 | Uint8 *src, *dst; |
70 | |
71 | src = cvt->buf; |
72 | dst = cvt->buf; |
73 | if ( (format & 0x1000) == 0x1000 ) { |
74 | for ( i=cvt->len_cvt/4; i; --i ) { |
75 | sample = (Uint16)((src[0]<<8)|src[1])+ |
76 | (Uint16)((src[2]<<8)|src[3]); |
77 | sample /= 2; |
78 | dst[1] = (sample&0xFF); |
79 | sample >>= 8; |
80 | dst[0] = (sample&0xFF); |
81 | src += 4; |
82 | dst += 2; |
83 | } |
84 | } else { |
85 | for ( i=cvt->len_cvt/4; i; --i ) { |
86 | sample = (Uint16)((src[1]<<8)|src[0])+ |
87 | (Uint16)((src[3]<<8)|src[2]); |
88 | sample /= 2; |
89 | dst[0] = (sample&0xFF); |
90 | sample >>= 8; |
91 | dst[1] = (sample&0xFF); |
92 | src += 4; |
93 | dst += 2; |
94 | } |
95 | } |
96 | } |
97 | break; |
98 | |
99 | case AUDIO_S16: { |
100 | Uint8 *src, *dst; |
101 | |
102 | src = cvt->buf; |
103 | dst = cvt->buf; |
104 | if ( (format & 0x1000) == 0x1000 ) { |
105 | for ( i=cvt->len_cvt/4; i; --i ) { |
106 | sample = (Sint16)((src[0]<<8)|src[1])+ |
107 | (Sint16)((src[2]<<8)|src[3]); |
108 | sample /= 2; |
109 | dst[1] = (sample&0xFF); |
110 | sample >>= 8; |
111 | dst[0] = (sample&0xFF); |
112 | src += 4; |
113 | dst += 2; |
114 | } |
115 | } else { |
116 | for ( i=cvt->len_cvt/4; i; --i ) { |
117 | sample = (Sint16)((src[1]<<8)|src[0])+ |
118 | (Sint16)((src[3]<<8)|src[2]); |
119 | sample /= 2; |
120 | dst[0] = (sample&0xFF); |
121 | sample >>= 8; |
122 | dst[1] = (sample&0xFF); |
123 | src += 4; |
124 | dst += 2; |
125 | } |
126 | } |
127 | } |
128 | break; |
129 | } |
130 | cvt->len_cvt /= 2; |
131 | if ( cvt->filters[++cvt->filter_index] ) { |
132 | cvt->filters[cvt->filter_index](cvt, format); |
133 | } |
134 | } |
135 | |
136 | /* Discard top 4 channels */ |
137 | void SDLCALL SDL_ConvertStrip(SDL_AudioCVT *cvt, Uint16 format) |
138 | { |
139 | int i; |
140 | Sint32 lsample, rsample; |
141 | |
142 | #ifdef DEBUG_CONVERT |
143 | fprintf(stderr, "Converting down to stereo\n"); |
144 | #endif |
145 | switch (format&0x8018) { |
146 | |
147 | case AUDIO_U8: { |
148 | Uint8 *src, *dst; |
149 | |
150 | src = cvt->buf; |
151 | dst = cvt->buf; |
152 | for ( i=cvt->len_cvt/6; i; --i ) { |
153 | dst[0] = src[0]; |
154 | dst[1] = src[1]; |
155 | src += 6; |
156 | dst += 2; |
157 | } |
158 | } |
159 | break; |
160 | |
161 | case AUDIO_S8: { |
162 | Sint8 *src, *dst; |
163 | |
164 | src = (Sint8 *)cvt->buf; |
165 | dst = (Sint8 *)cvt->buf; |
166 | for ( i=cvt->len_cvt/6; i; --i ) { |
167 | dst[0] = src[0]; |
168 | dst[1] = src[1]; |
169 | src += 6; |
170 | dst += 2; |
171 | } |
172 | } |
173 | break; |
174 | |
175 | case AUDIO_U16: { |
176 | Uint8 *src, *dst; |
177 | |
178 | src = cvt->buf; |
179 | dst = cvt->buf; |
180 | if ( (format & 0x1000) == 0x1000 ) { |
181 | for ( i=cvt->len_cvt/12; i; --i ) { |
182 | lsample = (Uint16)((src[0]<<8)|src[1]); |
183 | rsample = (Uint16)((src[2]<<8)|src[3]); |
184 | dst[1] = (lsample&0xFF); |
185 | lsample >>= 8; |
186 | dst[0] = (lsample&0xFF); |
187 | dst[3] = (rsample&0xFF); |
188 | rsample >>= 8; |
189 | dst[2] = (rsample&0xFF); |
190 | src += 12; |
191 | dst += 4; |
192 | } |
193 | } else { |
194 | for ( i=cvt->len_cvt/12; i; --i ) { |
195 | lsample = (Uint16)((src[1]<<8)|src[0]); |
196 | rsample = (Uint16)((src[3]<<8)|src[2]); |
197 | dst[0] = (lsample&0xFF); |
198 | lsample >>= 8; |
199 | dst[1] = (lsample&0xFF); |
200 | dst[2] = (rsample&0xFF); |
201 | rsample >>= 8; |
202 | dst[3] = (rsample&0xFF); |
203 | src += 12; |
204 | dst += 4; |
205 | } |
206 | } |
207 | } |
208 | break; |
209 | |
210 | case AUDIO_S16: { |
211 | Uint8 *src, *dst; |
212 | |
213 | src = cvt->buf; |
214 | dst = cvt->buf; |
215 | if ( (format & 0x1000) == 0x1000 ) { |
216 | for ( i=cvt->len_cvt/12; i; --i ) { |
217 | lsample = (Sint16)((src[0]<<8)|src[1]); |
218 | rsample = (Sint16)((src[2]<<8)|src[3]); |
219 | dst[1] = (lsample&0xFF); |
220 | lsample >>= 8; |
221 | dst[0] = (lsample&0xFF); |
222 | dst[3] = (rsample&0xFF); |
223 | rsample >>= 8; |
224 | dst[2] = (rsample&0xFF); |
225 | src += 12; |
226 | dst += 4; |
227 | } |
228 | } else { |
229 | for ( i=cvt->len_cvt/12; i; --i ) { |
230 | lsample = (Sint16)((src[1]<<8)|src[0]); |
231 | rsample = (Sint16)((src[3]<<8)|src[2]); |
232 | dst[0] = (lsample&0xFF); |
233 | lsample >>= 8; |
234 | dst[1] = (lsample&0xFF); |
235 | dst[2] = (rsample&0xFF); |
236 | rsample >>= 8; |
237 | dst[3] = (rsample&0xFF); |
238 | src += 12; |
239 | dst += 4; |
240 | } |
241 | } |
242 | } |
243 | break; |
244 | } |
245 | cvt->len_cvt /= 3; |
246 | if ( cvt->filters[++cvt->filter_index] ) { |
247 | cvt->filters[cvt->filter_index](cvt, format); |
248 | } |
249 | } |
250 | |
251 | |
252 | /* Discard top 2 channels of 6 */ |
253 | void SDLCALL SDL_ConvertStrip_2(SDL_AudioCVT *cvt, Uint16 format) |
254 | { |
255 | int i; |
256 | Sint32 lsample, rsample; |
257 | |
258 | #ifdef DEBUG_CONVERT |
259 | fprintf(stderr, "Converting 6 down to quad\n"); |
260 | #endif |
261 | switch (format&0x8018) { |
262 | |
263 | case AUDIO_U8: { |
264 | Uint8 *src, *dst; |
265 | |
266 | src = cvt->buf; |
267 | dst = cvt->buf; |
268 | for ( i=cvt->len_cvt/4; i; --i ) { |
269 | dst[0] = src[0]; |
270 | dst[1] = src[1]; |
271 | src += 4; |
272 | dst += 2; |
273 | } |
274 | } |
275 | break; |
276 | |
277 | case AUDIO_S8: { |
278 | Sint8 *src, *dst; |
279 | |
280 | src = (Sint8 *)cvt->buf; |
281 | dst = (Sint8 *)cvt->buf; |
282 | for ( i=cvt->len_cvt/4; i; --i ) { |
283 | dst[0] = src[0]; |
284 | dst[1] = src[1]; |
285 | src += 4; |
286 | dst += 2; |
287 | } |
288 | } |
289 | break; |
290 | |
291 | case AUDIO_U16: { |
292 | Uint8 *src, *dst; |
293 | |
294 | src = cvt->buf; |
295 | dst = cvt->buf; |
296 | if ( (format & 0x1000) == 0x1000 ) { |
297 | for ( i=cvt->len_cvt/8; i; --i ) { |
298 | lsample = (Uint16)((src[0]<<8)|src[1]); |
299 | rsample = (Uint16)((src[2]<<8)|src[3]); |
300 | dst[1] = (lsample&0xFF); |
301 | lsample >>= 8; |
302 | dst[0] = (lsample&0xFF); |
303 | dst[3] = (rsample&0xFF); |
304 | rsample >>= 8; |
305 | dst[2] = (rsample&0xFF); |
306 | src += 8; |
307 | dst += 4; |
308 | } |
309 | } else { |
310 | for ( i=cvt->len_cvt/8; i; --i ) { |
311 | lsample = (Uint16)((src[1]<<8)|src[0]); |
312 | rsample = (Uint16)((src[3]<<8)|src[2]); |
313 | dst[0] = (lsample&0xFF); |
314 | lsample >>= 8; |
315 | dst[1] = (lsample&0xFF); |
316 | dst[2] = (rsample&0xFF); |
317 | rsample >>= 8; |
318 | dst[3] = (rsample&0xFF); |
319 | src += 8; |
320 | dst += 4; |
321 | } |
322 | } |
323 | } |
324 | break; |
325 | |
326 | case AUDIO_S16: { |
327 | Uint8 *src, *dst; |
328 | |
329 | src = cvt->buf; |
330 | dst = cvt->buf; |
331 | if ( (format & 0x1000) == 0x1000 ) { |
332 | for ( i=cvt->len_cvt/8; i; --i ) { |
333 | lsample = (Sint16)((src[0]<<8)|src[1]); |
334 | rsample = (Sint16)((src[2]<<8)|src[3]); |
335 | dst[1] = (lsample&0xFF); |
336 | lsample >>= 8; |
337 | dst[0] = (lsample&0xFF); |
338 | dst[3] = (rsample&0xFF); |
339 | rsample >>= 8; |
340 | dst[2] = (rsample&0xFF); |
341 | src += 8; |
342 | dst += 4; |
343 | } |
344 | } else { |
345 | for ( i=cvt->len_cvt/8; i; --i ) { |
346 | lsample = (Sint16)((src[1]<<8)|src[0]); |
347 | rsample = (Sint16)((src[3]<<8)|src[2]); |
348 | dst[0] = (lsample&0xFF); |
349 | lsample >>= 8; |
350 | dst[1] = (lsample&0xFF); |
351 | dst[2] = (rsample&0xFF); |
352 | rsample >>= 8; |
353 | dst[3] = (rsample&0xFF); |
354 | src += 8; |
355 | dst += 4; |
356 | } |
357 | } |
358 | } |
359 | break; |
360 | } |
361 | cvt->len_cvt /= 2; |
362 | if ( cvt->filters[++cvt->filter_index] ) { |
363 | cvt->filters[cvt->filter_index](cvt, format); |
364 | } |
365 | } |
366 | |
367 | /* Duplicate a mono channel to both stereo channels */ |
368 | void SDLCALL SDL_ConvertStereo(SDL_AudioCVT *cvt, Uint16 format) |
369 | { |
370 | int i; |
371 | |
372 | #ifdef DEBUG_CONVERT |
373 | fprintf(stderr, "Converting to stereo\n"); |
374 | #endif |
375 | if ( (format & 0xFF) == 16 ) { |
376 | Uint16 *src, *dst; |
377 | |
378 | src = (Uint16 *)(cvt->buf+cvt->len_cvt); |
379 | dst = (Uint16 *)(cvt->buf+cvt->len_cvt*2); |
380 | for ( i=cvt->len_cvt/2; i; --i ) { |
381 | dst -= 2; |
382 | src -= 1; |
383 | dst[0] = src[0]; |
384 | dst[1] = src[0]; |
385 | } |
386 | } else { |
387 | Uint8 *src, *dst; |
388 | |
389 | src = cvt->buf+cvt->len_cvt; |
390 | dst = cvt->buf+cvt->len_cvt*2; |
391 | for ( i=cvt->len_cvt; i; --i ) { |
392 | dst -= 2; |
393 | src -= 1; |
394 | dst[0] = src[0]; |
395 | dst[1] = src[0]; |
396 | } |
397 | } |
398 | cvt->len_cvt *= 2; |
399 | if ( cvt->filters[++cvt->filter_index] ) { |
400 | cvt->filters[cvt->filter_index](cvt, format); |
401 | } |
402 | } |
403 | |
404 | |
405 | /* Duplicate a stereo channel to a pseudo-5.1 stream */ |
406 | void SDLCALL SDL_ConvertSurround(SDL_AudioCVT *cvt, Uint16 format) |
407 | { |
408 | int i; |
409 | |
410 | #ifdef DEBUG_CONVERT |
411 | fprintf(stderr, "Converting stereo to surround\n"); |
412 | #endif |
413 | switch (format&0x8018) { |
414 | |
415 | case AUDIO_U8: { |
416 | Uint8 *src, *dst, lf, rf, ce; |
417 | |
418 | src = (Uint8 *)(cvt->buf+cvt->len_cvt); |
419 | dst = (Uint8 *)(cvt->buf+cvt->len_cvt*3); |
420 | for ( i=cvt->len_cvt; i; --i ) { |
421 | dst -= 6; |
422 | src -= 2; |
423 | lf = src[0]; |
424 | rf = src[1]; |
425 | ce = (lf/2) + (rf/2); |
426 | dst[0] = lf; |
427 | dst[1] = rf; |
428 | dst[2] = lf - ce; |
429 | dst[3] = rf - ce; |
430 | dst[4] = ce; |
431 | dst[5] = ce; |
432 | } |
433 | } |
434 | break; |
435 | |
436 | case AUDIO_S8: { |
437 | Sint8 *src, *dst, lf, rf, ce; |
438 | |
439 | src = (Sint8 *)cvt->buf+cvt->len_cvt; |
440 | dst = (Sint8 *)cvt->buf+cvt->len_cvt*3; |
441 | for ( i=cvt->len_cvt; i; --i ) { |
442 | dst -= 6; |
443 | src -= 2; |
444 | lf = src[0]; |
445 | rf = src[1]; |
446 | ce = (lf/2) + (rf/2); |
447 | dst[0] = lf; |
448 | dst[1] = rf; |
449 | dst[2] = lf - ce; |
450 | dst[3] = rf - ce; |
451 | dst[4] = ce; |
452 | dst[5] = ce; |
453 | } |
454 | } |
455 | break; |
456 | |
457 | case AUDIO_U16: { |
458 | Uint8 *src, *dst; |
459 | Uint16 lf, rf, ce, lr, rr; |
460 | |
461 | src = cvt->buf+cvt->len_cvt; |
462 | dst = cvt->buf+cvt->len_cvt*3; |
463 | |
464 | if ( (format & 0x1000) == 0x1000 ) { |
465 | for ( i=cvt->len_cvt/4; i; --i ) { |
466 | dst -= 12; |
467 | src -= 4; |
468 | lf = (Uint16)((src[0]<<8)|src[1]); |
469 | rf = (Uint16)((src[2]<<8)|src[3]); |
470 | ce = (lf/2) + (rf/2); |
471 | rr = lf - ce; |
472 | lr = rf - ce; |
473 | dst[1] = (lf&0xFF); |
474 | dst[0] = ((lf>>8)&0xFF); |
475 | dst[3] = (rf&0xFF); |
476 | dst[2] = ((rf>>8)&0xFF); |
477 | |
478 | dst[1+4] = (lr&0xFF); |
479 | dst[0+4] = ((lr>>8)&0xFF); |
480 | dst[3+4] = (rr&0xFF); |
481 | dst[2+4] = ((rr>>8)&0xFF); |
482 | |
483 | dst[1+8] = (ce&0xFF); |
484 | dst[0+8] = ((ce>>8)&0xFF); |
485 | dst[3+8] = (ce&0xFF); |
486 | dst[2+8] = ((ce>>8)&0xFF); |
487 | } |
488 | } else { |
489 | for ( i=cvt->len_cvt/4; i; --i ) { |
490 | dst -= 12; |
491 | src -= 4; |
492 | lf = (Uint16)((src[1]<<8)|src[0]); |
493 | rf = (Uint16)((src[3]<<8)|src[2]); |
494 | ce = (lf/2) + (rf/2); |
495 | rr = lf - ce; |
496 | lr = rf - ce; |
497 | dst[0] = (lf&0xFF); |
498 | dst[1] = ((lf>>8)&0xFF); |
499 | dst[2] = (rf&0xFF); |
500 | dst[3] = ((rf>>8)&0xFF); |
501 | |
502 | dst[0+4] = (lr&0xFF); |
503 | dst[1+4] = ((lr>>8)&0xFF); |
504 | dst[2+4] = (rr&0xFF); |
505 | dst[3+4] = ((rr>>8)&0xFF); |
506 | |
507 | dst[0+8] = (ce&0xFF); |
508 | dst[1+8] = ((ce>>8)&0xFF); |
509 | dst[2+8] = (ce&0xFF); |
510 | dst[3+8] = ((ce>>8)&0xFF); |
511 | } |
512 | } |
513 | } |
514 | break; |
515 | |
516 | case AUDIO_S16: { |
517 | Uint8 *src, *dst; |
518 | Sint16 lf, rf, ce, lr, rr; |
519 | |
520 | src = cvt->buf+cvt->len_cvt; |
521 | dst = cvt->buf+cvt->len_cvt*3; |
522 | |
523 | if ( (format & 0x1000) == 0x1000 ) { |
524 | for ( i=cvt->len_cvt/4; i; --i ) { |
525 | dst -= 12; |
526 | src -= 4; |
527 | lf = (Sint16)((src[0]<<8)|src[1]); |
528 | rf = (Sint16)((src[2]<<8)|src[3]); |
529 | ce = (lf/2) + (rf/2); |
530 | rr = lf - ce; |
531 | lr = rf - ce; |
532 | dst[1] = (lf&0xFF); |
533 | dst[0] = ((lf>>8)&0xFF); |
534 | dst[3] = (rf&0xFF); |
535 | dst[2] = ((rf>>8)&0xFF); |
536 | |
537 | dst[1+4] = (lr&0xFF); |
538 | dst[0+4] = ((lr>>8)&0xFF); |
539 | dst[3+4] = (rr&0xFF); |
540 | dst[2+4] = ((rr>>8)&0xFF); |
541 | |
542 | dst[1+8] = (ce&0xFF); |
543 | dst[0+8] = ((ce>>8)&0xFF); |
544 | dst[3+8] = (ce&0xFF); |
545 | dst[2+8] = ((ce>>8)&0xFF); |
546 | } |
547 | } else { |
548 | for ( i=cvt->len_cvt/4; i; --i ) { |
549 | dst -= 12; |
550 | src -= 4; |
551 | lf = (Sint16)((src[1]<<8)|src[0]); |
552 | rf = (Sint16)((src[3]<<8)|src[2]); |
553 | ce = (lf/2) + (rf/2); |
554 | rr = lf - ce; |
555 | lr = rf - ce; |
556 | dst[0] = (lf&0xFF); |
557 | dst[1] = ((lf>>8)&0xFF); |
558 | dst[2] = (rf&0xFF); |
559 | dst[3] = ((rf>>8)&0xFF); |
560 | |
561 | dst[0+4] = (lr&0xFF); |
562 | dst[1+4] = ((lr>>8)&0xFF); |
563 | dst[2+4] = (rr&0xFF); |
564 | dst[3+4] = ((rr>>8)&0xFF); |
565 | |
566 | dst[0+8] = (ce&0xFF); |
567 | dst[1+8] = ((ce>>8)&0xFF); |
568 | dst[2+8] = (ce&0xFF); |
569 | dst[3+8] = ((ce>>8)&0xFF); |
570 | } |
571 | } |
572 | } |
573 | break; |
574 | } |
575 | cvt->len_cvt *= 3; |
576 | if ( cvt->filters[++cvt->filter_index] ) { |
577 | cvt->filters[cvt->filter_index](cvt, format); |
578 | } |
579 | } |
580 | |
581 | |
582 | /* Duplicate a stereo channel to a pseudo-4.0 stream */ |
583 | void SDLCALL SDL_ConvertSurround_4(SDL_AudioCVT *cvt, Uint16 format) |
584 | { |
585 | int i; |
586 | |
587 | #ifdef DEBUG_CONVERT |
588 | fprintf(stderr, "Converting stereo to quad\n"); |
589 | #endif |
590 | switch (format&0x8018) { |
591 | |
592 | case AUDIO_U8: { |
593 | Uint8 *src, *dst, lf, rf, ce; |
594 | |
595 | src = (Uint8 *)(cvt->buf+cvt->len_cvt); |
596 | dst = (Uint8 *)(cvt->buf+cvt->len_cvt*2); |
597 | for ( i=cvt->len_cvt; i; --i ) { |
598 | dst -= 4; |
599 | src -= 2; |
600 | lf = src[0]; |
601 | rf = src[1]; |
602 | ce = (lf/2) + (rf/2); |
603 | dst[0] = lf; |
604 | dst[1] = rf; |
605 | dst[2] = lf - ce; |
606 | dst[3] = rf - ce; |
607 | } |
608 | } |
609 | break; |
610 | |
611 | case AUDIO_S8: { |
612 | Sint8 *src, *dst, lf, rf, ce; |
613 | |
614 | src = (Sint8 *)cvt->buf+cvt->len_cvt; |
615 | dst = (Sint8 *)cvt->buf+cvt->len_cvt*2; |
616 | for ( i=cvt->len_cvt; i; --i ) { |
617 | dst -= 4; |
618 | src -= 2; |
619 | lf = src[0]; |
620 | rf = src[1]; |
621 | ce = (lf/2) + (rf/2); |
622 | dst[0] = lf; |
623 | dst[1] = rf; |
624 | dst[2] = lf - ce; |
625 | dst[3] = rf - ce; |
626 | } |
627 | } |
628 | break; |
629 | |
630 | case AUDIO_U16: { |
631 | Uint8 *src, *dst; |
632 | Uint16 lf, rf, ce, lr, rr; |
633 | |
634 | src = cvt->buf+cvt->len_cvt; |
635 | dst = cvt->buf+cvt->len_cvt*2; |
636 | |
637 | if ( (format & 0x1000) == 0x1000 ) { |
638 | for ( i=cvt->len_cvt/4; i; --i ) { |
639 | dst -= 8; |
640 | src -= 4; |
641 | lf = (Uint16)((src[0]<<8)|src[1]); |
642 | rf = (Uint16)((src[2]<<8)|src[3]); |
643 | ce = (lf/2) + (rf/2); |
644 | rr = lf - ce; |
645 | lr = rf - ce; |
646 | dst[1] = (lf&0xFF); |
647 | dst[0] = ((lf>>8)&0xFF); |
648 | dst[3] = (rf&0xFF); |
649 | dst[2] = ((rf>>8)&0xFF); |
650 | |
651 | dst[1+4] = (lr&0xFF); |
652 | dst[0+4] = ((lr>>8)&0xFF); |
653 | dst[3+4] = (rr&0xFF); |
654 | dst[2+4] = ((rr>>8)&0xFF); |
655 | } |
656 | } else { |
657 | for ( i=cvt->len_cvt/4; i; --i ) { |
658 | dst -= 8; |
659 | src -= 4; |
660 | lf = (Uint16)((src[1]<<8)|src[0]); |
661 | rf = (Uint16)((src[3]<<8)|src[2]); |
662 | ce = (lf/2) + (rf/2); |
663 | rr = lf - ce; |
664 | lr = rf - ce; |
665 | dst[0] = (lf&0xFF); |
666 | dst[1] = ((lf>>8)&0xFF); |
667 | dst[2] = (rf&0xFF); |
668 | dst[3] = ((rf>>8)&0xFF); |
669 | |
670 | dst[0+4] = (lr&0xFF); |
671 | dst[1+4] = ((lr>>8)&0xFF); |
672 | dst[2+4] = (rr&0xFF); |
673 | dst[3+4] = ((rr>>8)&0xFF); |
674 | } |
675 | } |
676 | } |
677 | break; |
678 | |
679 | case AUDIO_S16: { |
680 | Uint8 *src, *dst; |
681 | Sint16 lf, rf, ce, lr, rr; |
682 | |
683 | src = cvt->buf+cvt->len_cvt; |
684 | dst = cvt->buf+cvt->len_cvt*2; |
685 | |
686 | if ( (format & 0x1000) == 0x1000 ) { |
687 | for ( i=cvt->len_cvt/4; i; --i ) { |
688 | dst -= 8; |
689 | src -= 4; |
690 | lf = (Sint16)((src[0]<<8)|src[1]); |
691 | rf = (Sint16)((src[2]<<8)|src[3]); |
692 | ce = (lf/2) + (rf/2); |
693 | rr = lf - ce; |
694 | lr = rf - ce; |
695 | dst[1] = (lf&0xFF); |
696 | dst[0] = ((lf>>8)&0xFF); |
697 | dst[3] = (rf&0xFF); |
698 | dst[2] = ((rf>>8)&0xFF); |
699 | |
700 | dst[1+4] = (lr&0xFF); |
701 | dst[0+4] = ((lr>>8)&0xFF); |
702 | dst[3+4] = (rr&0xFF); |
703 | dst[2+4] = ((rr>>8)&0xFF); |
704 | } |
705 | } else { |
706 | for ( i=cvt->len_cvt/4; i; --i ) { |
707 | dst -= 8; |
708 | src -= 4; |
709 | lf = (Sint16)((src[1]<<8)|src[0]); |
710 | rf = (Sint16)((src[3]<<8)|src[2]); |
711 | ce = (lf/2) + (rf/2); |
712 | rr = lf - ce; |
713 | lr = rf - ce; |
714 | dst[0] = (lf&0xFF); |
715 | dst[1] = ((lf>>8)&0xFF); |
716 | dst[2] = (rf&0xFF); |
717 | dst[3] = ((rf>>8)&0xFF); |
718 | |
719 | dst[0+4] = (lr&0xFF); |
720 | dst[1+4] = ((lr>>8)&0xFF); |
721 | dst[2+4] = (rr&0xFF); |
722 | dst[3+4] = ((rr>>8)&0xFF); |
723 | } |
724 | } |
725 | } |
726 | break; |
727 | } |
728 | cvt->len_cvt *= 2; |
729 | if ( cvt->filters[++cvt->filter_index] ) { |
730 | cvt->filters[cvt->filter_index](cvt, format); |
731 | } |
732 | } |
733 | |
734 | |
735 | /* Convert 8-bit to 16-bit - LSB */ |
736 | void SDLCALL SDL_Convert16LSB(SDL_AudioCVT *cvt, Uint16 format) |
737 | { |
738 | int i; |
739 | Uint8 *src, *dst; |
740 | |
741 | #ifdef DEBUG_CONVERT |
742 | fprintf(stderr, "Converting to 16-bit LSB\n"); |
743 | #endif |
744 | src = cvt->buf+cvt->len_cvt; |
745 | dst = cvt->buf+cvt->len_cvt*2; |
746 | for ( i=cvt->len_cvt; i; --i ) { |
747 | src -= 1; |
748 | dst -= 2; |
749 | dst[1] = *src; |
750 | dst[0] = 0; |
751 | } |
752 | format = ((format & ~0x0008) | AUDIO_U16LSB); |
753 | cvt->len_cvt *= 2; |
754 | if ( cvt->filters[++cvt->filter_index] ) { |
755 | cvt->filters[cvt->filter_index](cvt, format); |
756 | } |
757 | } |
758 | /* Convert 8-bit to 16-bit - MSB */ |
759 | void SDLCALL SDL_Convert16MSB(SDL_AudioCVT *cvt, Uint16 format) |
760 | { |
761 | int i; |
762 | Uint8 *src, *dst; |
763 | |
764 | #ifdef DEBUG_CONVERT |
765 | fprintf(stderr, "Converting to 16-bit MSB\n"); |
766 | #endif |
767 | src = cvt->buf+cvt->len_cvt; |
768 | dst = cvt->buf+cvt->len_cvt*2; |
769 | for ( i=cvt->len_cvt; i; --i ) { |
770 | src -= 1; |
771 | dst -= 2; |
772 | dst[0] = *src; |
773 | dst[1] = 0; |
774 | } |
775 | format = ((format & ~0x0008) | AUDIO_U16MSB); |
776 | cvt->len_cvt *= 2; |
777 | if ( cvt->filters[++cvt->filter_index] ) { |
778 | cvt->filters[cvt->filter_index](cvt, format); |
779 | } |
780 | } |
781 | |
782 | /* Convert 16-bit to 8-bit */ |
783 | void SDLCALL SDL_Convert8(SDL_AudioCVT *cvt, Uint16 format) |
784 | { |
785 | int i; |
786 | Uint8 *src, *dst; |
787 | |
788 | #ifdef DEBUG_CONVERT |
789 | fprintf(stderr, "Converting to 8-bit\n"); |
790 | #endif |
791 | src = cvt->buf; |
792 | dst = cvt->buf; |
793 | if ( (format & 0x1000) != 0x1000 ) { /* Little endian */ |
794 | ++src; |
795 | } |
796 | for ( i=cvt->len_cvt/2; i; --i ) { |
797 | *dst = *src; |
798 | src += 2; |
799 | dst += 1; |
800 | } |
801 | format = ((format & ~0x9010) | AUDIO_U8); |
802 | cvt->len_cvt /= 2; |
803 | if ( cvt->filters[++cvt->filter_index] ) { |
804 | cvt->filters[cvt->filter_index](cvt, format); |
805 | } |
806 | } |
807 | |
808 | /* Toggle signed/unsigned */ |
809 | void SDLCALL SDL_ConvertSign(SDL_AudioCVT *cvt, Uint16 format) |
810 | { |
811 | int i; |
812 | Uint8 *data; |
813 | |
814 | #ifdef DEBUG_CONVERT |
815 | fprintf(stderr, "Converting audio signedness\n"); |
816 | #endif |
817 | data = cvt->buf; |
818 | if ( (format & 0xFF) == 16 ) { |
819 | if ( (format & 0x1000) != 0x1000 ) { /* Little endian */ |
820 | ++data; |
821 | } |
822 | for ( i=cvt->len_cvt/2; i; --i ) { |
823 | *data ^= 0x80; |
824 | data += 2; |
825 | } |
826 | } else { |
827 | for ( i=cvt->len_cvt; i; --i ) { |
828 | *data++ ^= 0x80; |
829 | } |
830 | } |
831 | format = (format ^ 0x8000); |
832 | if ( cvt->filters[++cvt->filter_index] ) { |
833 | cvt->filters[cvt->filter_index](cvt, format); |
834 | } |
835 | } |
836 | |
837 | /* Toggle endianness */ |
838 | void SDLCALL SDL_ConvertEndian(SDL_AudioCVT *cvt, Uint16 format) |
839 | { |
840 | int i; |
841 | Uint8 *data, tmp; |
842 | |
843 | #ifdef DEBUG_CONVERT |
844 | fprintf(stderr, "Converting audio endianness\n"); |
845 | #endif |
846 | data = cvt->buf; |
847 | for ( i=cvt->len_cvt/2; i; --i ) { |
848 | tmp = data[0]; |
849 | data[0] = data[1]; |
850 | data[1] = tmp; |
851 | data += 2; |
852 | } |
853 | format = (format ^ 0x1000); |
854 | if ( cvt->filters[++cvt->filter_index] ) { |
855 | cvt->filters[cvt->filter_index](cvt, format); |
856 | } |
857 | } |
858 | |
859 | /* Convert rate up by multiple of 2 */ |
860 | void SDLCALL SDL_RateMUL2(SDL_AudioCVT *cvt, Uint16 format) |
861 | { |
862 | int i; |
863 | Uint8 *src, *dst; |
864 | |
865 | #ifdef DEBUG_CONVERT |
866 | fprintf(stderr, "Converting audio rate * 2\n"); |
867 | #endif |
868 | src = cvt->buf+cvt->len_cvt; |
869 | dst = cvt->buf+cvt->len_cvt*2; |
870 | switch (format & 0xFF) { |
871 | case 8: |
872 | for ( i=cvt->len_cvt; i; --i ) { |
873 | src -= 1; |
874 | dst -= 2; |
875 | dst[0] = src[0]; |
876 | dst[1] = src[0]; |
877 | } |
878 | break; |
879 | case 16: |
880 | for ( i=cvt->len_cvt/2; i; --i ) { |
881 | src -= 2; |
882 | dst -= 4; |
883 | dst[0] = src[0]; |
884 | dst[1] = src[1]; |
885 | dst[2] = src[0]; |
886 | dst[3] = src[1]; |
887 | } |
888 | break; |
889 | } |
890 | cvt->len_cvt *= 2; |
891 | if ( cvt->filters[++cvt->filter_index] ) { |
892 | cvt->filters[cvt->filter_index](cvt, format); |
893 | } |
894 | } |
895 | |
896 | |
897 | /* Convert rate up by multiple of 2, for stereo */ |
898 | void SDLCALL SDL_RateMUL2_c2(SDL_AudioCVT *cvt, Uint16 format) |
899 | { |
900 | int i; |
901 | Uint8 *src, *dst; |
902 | |
903 | #ifdef DEBUG_CONVERT |
904 | fprintf(stderr, "Converting audio rate * 2\n"); |
905 | #endif |
906 | src = cvt->buf+cvt->len_cvt; |
907 | dst = cvt->buf+cvt->len_cvt*2; |
908 | switch (format & 0xFF) { |
909 | case 8: |
910 | for ( i=cvt->len_cvt/2; i; --i ) { |
911 | src -= 2; |
912 | dst -= 4; |
913 | dst[0] = src[0]; |
914 | dst[1] = src[1]; |
915 | dst[2] = src[0]; |
916 | dst[3] = src[1]; |
917 | } |
918 | break; |
919 | case 16: |
920 | for ( i=cvt->len_cvt/4; i; --i ) { |
921 | src -= 4; |
922 | dst -= 8; |
923 | dst[0] = src[0]; |
924 | dst[1] = src[1]; |
925 | dst[2] = src[2]; |
926 | dst[3] = src[3]; |
927 | dst[4] = src[0]; |
928 | dst[5] = src[1]; |
929 | dst[6] = src[2]; |
930 | dst[7] = src[3]; |
931 | } |
932 | break; |
933 | } |
934 | cvt->len_cvt *= 2; |
935 | if ( cvt->filters[++cvt->filter_index] ) { |
936 | cvt->filters[cvt->filter_index](cvt, format); |
937 | } |
938 | } |
939 | |
940 | /* Convert rate up by multiple of 2, for quad */ |
941 | void SDLCALL SDL_RateMUL2_c4(SDL_AudioCVT *cvt, Uint16 format) |
942 | { |
943 | int i; |
944 | Uint8 *src, *dst; |
945 | |
946 | #ifdef DEBUG_CONVERT |
947 | fprintf(stderr, "Converting audio rate * 2\n"); |
948 | #endif |
949 | src = cvt->buf+cvt->len_cvt; |
950 | dst = cvt->buf+cvt->len_cvt*2; |
951 | switch (format & 0xFF) { |
952 | case 8: |
953 | for ( i=cvt->len_cvt/4; i; --i ) { |
954 | src -= 4; |
955 | dst -= 8; |
956 | dst[0] = src[0]; |
957 | dst[1] = src[1]; |
958 | dst[2] = src[2]; |
959 | dst[3] = src[3]; |
960 | dst[4] = src[0]; |
961 | dst[5] = src[1]; |
962 | dst[6] = src[2]; |
963 | dst[7] = src[3]; |
964 | } |
965 | break; |
966 | case 16: |
967 | for ( i=cvt->len_cvt/8; i; --i ) { |
968 | src -= 8; |
969 | dst -= 16; |
970 | dst[0] = src[0]; |
971 | dst[1] = src[1]; |
972 | dst[2] = src[2]; |
973 | dst[3] = src[3]; |
974 | dst[4] = src[4]; |
975 | dst[5] = src[5]; |
976 | dst[6] = src[6]; |
977 | dst[7] = src[7]; |
978 | dst[8] = src[0]; |
979 | dst[9] = src[1]; |
980 | dst[10] = src[2]; |
981 | dst[11] = src[3]; |
982 | dst[12] = src[4]; |
983 | dst[13] = src[5]; |
984 | dst[14] = src[6]; |
985 | dst[15] = src[7]; |
986 | } |
987 | break; |
988 | } |
989 | cvt->len_cvt *= 2; |
990 | if ( cvt->filters[++cvt->filter_index] ) { |
991 | cvt->filters[cvt->filter_index](cvt, format); |
992 | } |
993 | } |
994 | |
995 | |
996 | /* Convert rate up by multiple of 2, for 5.1 */ |
997 | void SDLCALL SDL_RateMUL2_c6(SDL_AudioCVT *cvt, Uint16 format) |
998 | { |
999 | int i; |
1000 | Uint8 *src, *dst; |
1001 | |
1002 | #ifdef DEBUG_CONVERT |
1003 | fprintf(stderr, "Converting audio rate * 2\n"); |
1004 | #endif |
1005 | src = cvt->buf+cvt->len_cvt; |
1006 | dst = cvt->buf+cvt->len_cvt*2; |
1007 | switch (format & 0xFF) { |
1008 | case 8: |
1009 | for ( i=cvt->len_cvt/6; i; --i ) { |
1010 | src -= 6; |
1011 | dst -= 12; |
1012 | dst[0] = src[0]; |
1013 | dst[1] = src[1]; |
1014 | dst[2] = src[2]; |
1015 | dst[3] = src[3]; |
1016 | dst[4] = src[4]; |
1017 | dst[5] = src[5]; |
1018 | dst[6] = src[0]; |
1019 | dst[7] = src[1]; |
1020 | dst[8] = src[2]; |
1021 | dst[9] = src[3]; |
1022 | dst[10] = src[4]; |
1023 | dst[11] = src[5]; |
1024 | } |
1025 | break; |
1026 | case 16: |
1027 | for ( i=cvt->len_cvt/12; i; --i ) { |
1028 | src -= 12; |
1029 | dst -= 24; |
1030 | dst[0] = src[0]; |
1031 | dst[1] = src[1]; |
1032 | dst[2] = src[2]; |
1033 | dst[3] = src[3]; |
1034 | dst[4] = src[4]; |
1035 | dst[5] = src[5]; |
1036 | dst[6] = src[6]; |
1037 | dst[7] = src[7]; |
1038 | dst[8] = src[8]; |
1039 | dst[9] = src[9]; |
1040 | dst[10] = src[10]; |
1041 | dst[11] = src[11]; |
1042 | dst[12] = src[0]; |
1043 | dst[13] = src[1]; |
1044 | dst[14] = src[2]; |
1045 | dst[15] = src[3]; |
1046 | dst[16] = src[4]; |
1047 | dst[17] = src[5]; |
1048 | dst[18] = src[6]; |
1049 | dst[19] = src[7]; |
1050 | dst[20] = src[8]; |
1051 | dst[21] = src[9]; |
1052 | dst[22] = src[10]; |
1053 | dst[23] = src[11]; |
1054 | } |
1055 | break; |
1056 | } |
1057 | cvt->len_cvt *= 2; |
1058 | if ( cvt->filters[++cvt->filter_index] ) { |
1059 | cvt->filters[cvt->filter_index](cvt, format); |
1060 | } |
1061 | } |
1062 | |
1063 | /* Convert rate down by multiple of 2 */ |
1064 | void SDLCALL SDL_RateDIV2(SDL_AudioCVT *cvt, Uint16 format) |
1065 | { |
1066 | int i; |
1067 | Uint8 *src, *dst; |
1068 | |
1069 | #ifdef DEBUG_CONVERT |
1070 | fprintf(stderr, "Converting audio rate / 2\n"); |
1071 | #endif |
1072 | src = cvt->buf; |
1073 | dst = cvt->buf; |
1074 | switch (format & 0xFF) { |
1075 | case 8: |
1076 | for ( i=cvt->len_cvt/2; i; --i ) { |
1077 | dst[0] = src[0]; |
1078 | src += 2; |
1079 | dst += 1; |
1080 | } |
1081 | break; |
1082 | case 16: |
1083 | for ( i=cvt->len_cvt/4; i; --i ) { |
1084 | dst[0] = src[0]; |
1085 | dst[1] = src[1]; |
1086 | src += 4; |
1087 | dst += 2; |
1088 | } |
1089 | break; |
1090 | } |
1091 | cvt->len_cvt /= 2; |
1092 | if ( cvt->filters[++cvt->filter_index] ) { |
1093 | cvt->filters[cvt->filter_index](cvt, format); |
1094 | } |
1095 | } |
1096 | |
1097 | |
1098 | /* Convert rate down by multiple of 2, for stereo */ |
1099 | void SDLCALL SDL_RateDIV2_c2(SDL_AudioCVT *cvt, Uint16 format) |
1100 | { |
1101 | int i; |
1102 | Uint8 *src, *dst; |
1103 | |
1104 | #ifdef DEBUG_CONVERT |
1105 | fprintf(stderr, "Converting audio rate / 2\n"); |
1106 | #endif |
1107 | src = cvt->buf; |
1108 | dst = cvt->buf; |
1109 | switch (format & 0xFF) { |
1110 | case 8: |
1111 | for ( i=cvt->len_cvt/4; i; --i ) { |
1112 | dst[0] = src[0]; |
1113 | dst[1] = src[1]; |
1114 | src += 4; |
1115 | dst += 2; |
1116 | } |
1117 | break; |
1118 | case 16: |
1119 | for ( i=cvt->len_cvt/8; i; --i ) { |
1120 | dst[0] = src[0]; |
1121 | dst[1] = src[1]; |
1122 | dst[2] = src[2]; |
1123 | dst[3] = src[3]; |
1124 | src += 8; |
1125 | dst += 4; |
1126 | } |
1127 | break; |
1128 | } |
1129 | cvt->len_cvt /= 2; |
1130 | if ( cvt->filters[++cvt->filter_index] ) { |
1131 | cvt->filters[cvt->filter_index](cvt, format); |
1132 | } |
1133 | } |
1134 | |
1135 | |
1136 | /* Convert rate down by multiple of 2, for quad */ |
1137 | void SDLCALL SDL_RateDIV2_c4(SDL_AudioCVT *cvt, Uint16 format) |
1138 | { |
1139 | int i; |
1140 | Uint8 *src, *dst; |
1141 | |
1142 | #ifdef DEBUG_CONVERT |
1143 | fprintf(stderr, "Converting audio rate / 2\n"); |
1144 | #endif |
1145 | src = cvt->buf; |
1146 | dst = cvt->buf; |
1147 | switch (format & 0xFF) { |
1148 | case 8: |
1149 | for ( i=cvt->len_cvt/8; i; --i ) { |
1150 | dst[0] = src[0]; |
1151 | dst[1] = src[1]; |
1152 | dst[2] = src[2]; |
1153 | dst[3] = src[3]; |
1154 | src += 8; |
1155 | dst += 4; |
1156 | } |
1157 | break; |
1158 | case 16: |
1159 | for ( i=cvt->len_cvt/16; i; --i ) { |
1160 | dst[0] = src[0]; |
1161 | dst[1] = src[1]; |
1162 | dst[2] = src[2]; |
1163 | dst[3] = src[3]; |
1164 | dst[4] = src[4]; |
1165 | dst[5] = src[5]; |
1166 | dst[6] = src[6]; |
1167 | dst[7] = src[7]; |
1168 | src += 16; |
1169 | dst += 8; |
1170 | } |
1171 | break; |
1172 | } |
1173 | cvt->len_cvt /= 2; |
1174 | if ( cvt->filters[++cvt->filter_index] ) { |
1175 | cvt->filters[cvt->filter_index](cvt, format); |
1176 | } |
1177 | } |
1178 | |
1179 | /* Convert rate down by multiple of 2, for 5.1 */ |
1180 | void SDLCALL SDL_RateDIV2_c6(SDL_AudioCVT *cvt, Uint16 format) |
1181 | { |
1182 | int i; |
1183 | Uint8 *src, *dst; |
1184 | |
1185 | #ifdef DEBUG_CONVERT |
1186 | fprintf(stderr, "Converting audio rate / 2\n"); |
1187 | #endif |
1188 | src = cvt->buf; |
1189 | dst = cvt->buf; |
1190 | switch (format & 0xFF) { |
1191 | case 8: |
1192 | for ( i=cvt->len_cvt/12; i; --i ) { |
1193 | dst[0] = src[0]; |
1194 | dst[1] = src[1]; |
1195 | dst[2] = src[2]; |
1196 | dst[3] = src[3]; |
1197 | dst[4] = src[4]; |
1198 | dst[5] = src[5]; |
1199 | src += 12; |
1200 | dst += 6; |
1201 | } |
1202 | break; |
1203 | case 16: |
1204 | for ( i=cvt->len_cvt/24; i; --i ) { |
1205 | dst[0] = src[0]; |
1206 | dst[1] = src[1]; |
1207 | dst[2] = src[2]; |
1208 | dst[3] = src[3]; |
1209 | dst[4] = src[4]; |
1210 | dst[5] = src[5]; |
1211 | dst[6] = src[6]; |
1212 | dst[7] = src[7]; |
1213 | dst[8] = src[8]; |
1214 | dst[9] = src[9]; |
1215 | dst[10] = src[10]; |
1216 | dst[11] = src[11]; |
1217 | src += 24; |
1218 | dst += 12; |
1219 | } |
1220 | break; |
1221 | } |
1222 | cvt->len_cvt /= 2; |
1223 | if ( cvt->filters[++cvt->filter_index] ) { |
1224 | cvt->filters[cvt->filter_index](cvt, format); |
1225 | } |
1226 | } |
1227 | |
1228 | /* Very slow rate conversion routine */ |
1229 | void SDLCALL SDL_RateSLOW(SDL_AudioCVT *cvt, Uint16 format) |
1230 | { |
1231 | double ipos; |
1232 | int i, clen; |
1233 | |
1234 | #ifdef DEBUG_CONVERT |
1235 | fprintf(stderr, "Converting audio rate * %4.4f\n", 1.0/cvt->rate_incr); |
1236 | #endif |
1237 | clen = (int)((double)cvt->len_cvt / cvt->rate_incr); |
1238 | if ( cvt->rate_incr > 1.0 ) { |
1239 | switch (format & 0xFF) { |
1240 | case 8: { |
1241 | Uint8 *output; |
1242 | |
1243 | output = cvt->buf; |
1244 | ipos = 0.0; |
1245 | for ( i=clen; i; --i ) { |
1246 | *output = cvt->buf[(int)ipos]; |
1247 | ipos += cvt->rate_incr; |
1248 | output += 1; |
1249 | } |
1250 | } |
1251 | break; |
1252 | |
1253 | case 16: { |
1254 | Uint16 *output; |
1255 | |
1256 | clen &= ~1; |
1257 | output = (Uint16 *)cvt->buf; |
1258 | ipos = 0.0; |
1259 | for ( i=clen/2; i; --i ) { |
1260 | *output=((Uint16 *)cvt->buf)[(int)ipos]; |
1261 | ipos += cvt->rate_incr; |
1262 | output += 1; |
1263 | } |
1264 | } |
1265 | break; |
1266 | } |
1267 | } else { |
1268 | switch (format & 0xFF) { |
1269 | case 8: { |
1270 | Uint8 *output; |
1271 | |
1272 | output = cvt->buf+clen; |
1273 | ipos = (double)cvt->len_cvt; |
1274 | for ( i=clen; i; --i ) { |
1275 | ipos -= cvt->rate_incr; |
1276 | output -= 1; |
1277 | *output = cvt->buf[(int)ipos]; |
1278 | } |
1279 | } |
1280 | break; |
1281 | |
1282 | case 16: { |
1283 | Uint16 *output; |
1284 | |
1285 | clen &= ~1; |
1286 | output = (Uint16 *)(cvt->buf+clen); |
1287 | ipos = (double)cvt->len_cvt/2; |
1288 | for ( i=clen/2; i; --i ) { |
1289 | ipos -= cvt->rate_incr; |
1290 | output -= 1; |
1291 | *output=((Uint16 *)cvt->buf)[(int)ipos]; |
1292 | } |
1293 | } |
1294 | break; |
1295 | } |
1296 | } |
1297 | cvt->len_cvt = clen; |
1298 | if ( cvt->filters[++cvt->filter_index] ) { |
1299 | cvt->filters[cvt->filter_index](cvt, format); |
1300 | } |
1301 | } |
1302 | |
1303 | int SDL_ConvertAudio(SDL_AudioCVT *cvt) |
1304 | { |
1305 | /* Make sure there's data to convert */ |
1306 | if ( cvt->buf == NULL ) { |
1307 | SDL_SetError("No buffer allocated for conversion"); |
1308 | return(-1); |
1309 | } |
1310 | /* Return okay if no conversion is necessary */ |
1311 | cvt->len_cvt = cvt->len; |
1312 | if ( cvt->filters[0] == NULL ) { |
1313 | return(0); |
1314 | } |
1315 | |
1316 | /* Set up the conversion and go! */ |
1317 | cvt->filter_index = 0; |
1318 | cvt->filters[0](cvt, cvt->src_format); |
1319 | return(0); |
1320 | } |
1321 | |
1322 | /* Creates a set of audio filters to convert from one format to another. |
1323 | Returns -1 if the format conversion is not supported, or 1 if the |
1324 | audio filter is set up. |
1325 | */ |
1326 | |
1327 | int SDL_BuildAudioCVT(SDL_AudioCVT *cvt, |
1328 | Uint16 src_format, Uint8 src_channels, int src_rate, |
1329 | Uint16 dst_format, Uint8 dst_channels, int dst_rate) |
1330 | { |
1331 | /*printf("Build format %04x->%04x, channels %u->%u, rate %d->%d\n", |
1332 | src_format, dst_format, src_channels, dst_channels, src_rate, dst_rate);*/ |
1333 | /* Start off with no conversion necessary */ |
1334 | cvt->needed = 0; |
1335 | cvt->filter_index = 0; |
1336 | cvt->filters[0] = NULL; |
1337 | cvt->len_mult = 1; |
1338 | cvt->len_ratio = 1.0; |
1339 | |
1340 | /* First filter: Endian conversion from src to dst */ |
1341 | if ( (src_format & 0x1000) != (dst_format & 0x1000) |
1342 | && ((src_format & 0xff) == 16) && ((dst_format & 0xff) == 16)) { |
1343 | cvt->filters[cvt->filter_index++] = SDL_ConvertEndian; |
1344 | } |
1345 | |
1346 | /* Second filter: Sign conversion -- signed/unsigned */ |
1347 | if ( (src_format & 0x8000) != (dst_format & 0x8000) ) { |
1348 | cvt->filters[cvt->filter_index++] = SDL_ConvertSign; |
1349 | } |
1350 | |
1351 | /* Next filter: Convert 16 bit <--> 8 bit PCM */ |
1352 | if ( (src_format & 0xFF) != (dst_format & 0xFF) ) { |
1353 | switch (dst_format&0x10FF) { |
1354 | case AUDIO_U8: |
1355 | cvt->filters[cvt->filter_index++] = |
1356 | SDL_Convert8; |
1357 | cvt->len_ratio /= 2; |
1358 | break; |
1359 | case AUDIO_U16LSB: |
1360 | cvt->filters[cvt->filter_index++] = |
1361 | SDL_Convert16LSB; |
1362 | cvt->len_mult *= 2; |
1363 | cvt->len_ratio *= 2; |
1364 | break; |
1365 | case AUDIO_U16MSB: |
1366 | cvt->filters[cvt->filter_index++] = |
1367 | SDL_Convert16MSB; |
1368 | cvt->len_mult *= 2; |
1369 | cvt->len_ratio *= 2; |
1370 | break; |
1371 | } |
1372 | } |
1373 | |
1374 | /* Last filter: Mono/Stereo conversion */ |
1375 | if ( src_channels != dst_channels ) { |
1376 | if ( (src_channels == 1) && (dst_channels > 1) ) { |
1377 | cvt->filters[cvt->filter_index++] = |
1378 | SDL_ConvertStereo; |
1379 | cvt->len_mult *= 2; |
1380 | src_channels = 2; |
1381 | cvt->len_ratio *= 2; |
1382 | } |
1383 | if ( (src_channels == 2) && |
1384 | (dst_channels == 6) ) { |
1385 | cvt->filters[cvt->filter_index++] = |
1386 | SDL_ConvertSurround; |
1387 | src_channels = 6; |
1388 | cvt->len_mult *= 3; |
1389 | cvt->len_ratio *= 3; |
1390 | } |
1391 | if ( (src_channels == 2) && |
1392 | (dst_channels == 4) ) { |
1393 | cvt->filters[cvt->filter_index++] = |
1394 | SDL_ConvertSurround_4; |
1395 | src_channels = 4; |
1396 | cvt->len_mult *= 2; |
1397 | cvt->len_ratio *= 2; |
1398 | } |
1399 | while ( (src_channels*2) <= dst_channels ) { |
1400 | cvt->filters[cvt->filter_index++] = |
1401 | SDL_ConvertStereo; |
1402 | cvt->len_mult *= 2; |
1403 | src_channels *= 2; |
1404 | cvt->len_ratio *= 2; |
1405 | } |
1406 | if ( (src_channels == 6) && |
1407 | (dst_channels <= 2) ) { |
1408 | cvt->filters[cvt->filter_index++] = |
1409 | SDL_ConvertStrip; |
1410 | src_channels = 2; |
1411 | cvt->len_ratio /= 3; |
1412 | } |
1413 | if ( (src_channels == 6) && |
1414 | (dst_channels == 4) ) { |
1415 | cvt->filters[cvt->filter_index++] = |
1416 | SDL_ConvertStrip_2; |
1417 | src_channels = 4; |
1418 | cvt->len_ratio /= 2; |
1419 | } |
1420 | /* This assumes that 4 channel audio is in the format: |
1421 | Left {front/back} + Right {front/back} |
1422 | so converting to L/R stereo works properly. |
1423 | */ |
1424 | while ( ((src_channels%2) == 0) && |
1425 | ((src_channels/2) >= dst_channels) ) { |
1426 | cvt->filters[cvt->filter_index++] = |
1427 | SDL_ConvertMono; |
1428 | src_channels /= 2; |
1429 | cvt->len_ratio /= 2; |
1430 | } |
1431 | if ( src_channels != dst_channels ) { |
1432 | /* Uh oh.. */; |
1433 | } |
1434 | } |
1435 | |
1436 | /* Do rate conversion */ |
1437 | cvt->rate_incr = 0.0; |
1438 | if ( (src_rate/100) != (dst_rate/100) ) { |
1439 | Uint32 hi_rate, lo_rate; |
1440 | int len_mult; |
1441 | double len_ratio; |
1442 | void (SDLCALL *rate_cvt)(SDL_AudioCVT *cvt, Uint16 format); |
1443 | |
1444 | if ( src_rate > dst_rate ) { |
1445 | hi_rate = src_rate; |
1446 | lo_rate = dst_rate; |
1447 | switch (src_channels) { |
1448 | case 1: rate_cvt = SDL_RateDIV2; break; |
1449 | case 2: rate_cvt = SDL_RateDIV2_c2; break; |
1450 | case 4: rate_cvt = SDL_RateDIV2_c4; break; |
1451 | case 6: rate_cvt = SDL_RateDIV2_c6; break; |
1452 | default: return -1; |
1453 | } |
1454 | len_mult = 1; |
1455 | len_ratio = 0.5; |
1456 | } else { |
1457 | hi_rate = dst_rate; |
1458 | lo_rate = src_rate; |
1459 | switch (src_channels) { |
1460 | case 1: rate_cvt = SDL_RateMUL2; break; |
1461 | case 2: rate_cvt = SDL_RateMUL2_c2; break; |
1462 | case 4: rate_cvt = SDL_RateMUL2_c4; break; |
1463 | case 6: rate_cvt = SDL_RateMUL2_c6; break; |
1464 | default: return -1; |
1465 | } |
1466 | len_mult = 2; |
1467 | len_ratio = 2.0; |
1468 | } |
1469 | /* If hi_rate = lo_rate*2^x then conversion is easy */ |
1470 | while ( ((lo_rate*2)/100) <= (hi_rate/100) ) { |
1471 | cvt->filters[cvt->filter_index++] = rate_cvt; |
1472 | cvt->len_mult *= len_mult; |
1473 | lo_rate *= 2; |
1474 | cvt->len_ratio *= len_ratio; |
1475 | } |
1476 | /* We may need a slow conversion here to finish up */ |
1477 | if ( (lo_rate/100) != (hi_rate/100) ) { |
1478 | #if 1 |
1479 | /* The problem with this is that if the input buffer is |
1480 | say 1K, and the conversion rate is say 1.1, then the |
1481 | output buffer is 1.1K, which may not be an acceptable |
1482 | buffer size for the audio driver (not a power of 2) |
1483 | */ |
1484 | /* For now, punt and hope the rate distortion isn't great. |
1485 | */ |
1486 | #else |
1487 | if ( src_rate < dst_rate ) { |
1488 | cvt->rate_incr = (double)lo_rate/hi_rate; |
1489 | cvt->len_mult *= 2; |
1490 | cvt->len_ratio /= cvt->rate_incr; |
1491 | } else { |
1492 | cvt->rate_incr = (double)hi_rate/lo_rate; |
1493 | cvt->len_ratio *= cvt->rate_incr; |
1494 | } |
1495 | cvt->filters[cvt->filter_index++] = SDL_RateSLOW; |
1496 | #endif |
1497 | } |
1498 | } |
1499 | |
1500 | /* Set up the filter information */ |
1501 | if ( cvt->filter_index != 0 ) { |
1502 | cvt->needed = 1; |
1503 | cvt->src_format = src_format; |
1504 | cvt->dst_format = dst_format; |
1505 | cvt->len = 0; |
1506 | cvt->buf = NULL; |
1507 | cvt->filters[cvt->filter_index] = NULL; |
1508 | } |
1509 | return(cvt->needed); |
1510 | } |