1 /* DO NOT EDIT! This file is generated by sdlgenaudiocvt.pl */
3 SDL - Simple DirectMedia Layer
4 Copyright (C) 1997-2009 Sam Lantinga
6 This library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
11 This library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public
17 License along with this library; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
24 #include "SDL_config.h"
25 #include "SDL_audio.h"
26 #include "SDL_audio_c.h"
30 #define DIVBY127 0.0078740157480315f
31 #define DIVBY32767 3.05185094759972e-05f
32 #define DIVBY2147483647 4.6566128752458e-10f
35 SDL_Convert_U8_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
42 fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S8.\n");
45 src = (const Uint8 *) cvt->buf;
46 dst = (Sint8 *) cvt->buf;
47 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, ++src, ++dst) {
48 const Sint8 val = ((*src) ^ 0x80);
53 if (cvt->filters[++cvt->filter_index]) {
54 cvt->filters[cvt->filter_index] (cvt, format);
59 SDL_Convert_U8_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
66 fprintf(stderr, "Converting AUDIO_U8 to AUDIO_U16LSB.\n");
69 src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
70 dst = (Uint16 *) (cvt->buf + cvt->len_cvt * 2);
71 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
72 const Uint16 val = (((Uint16) *src) << 8);
73 *dst = SDL_SwapLE16(val);
77 format = AUDIO_U16LSB;
78 if (cvt->filters[++cvt->filter_index]) {
79 cvt->filters[cvt->filter_index] (cvt, format);
84 SDL_Convert_U8_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
91 fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S16LSB.\n");
94 src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
95 dst = (Sint16 *) (cvt->buf + cvt->len_cvt * 2);
96 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
97 const Sint16 val = (((Sint16) ((*src) ^ 0x80)) << 8);
98 *dst = ((Sint16) SDL_SwapLE16(val));
102 format = AUDIO_S16LSB;
103 if (cvt->filters[++cvt->filter_index]) {
104 cvt->filters[cvt->filter_index] (cvt, format);
109 SDL_Convert_U8_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
116 fprintf(stderr, "Converting AUDIO_U8 to AUDIO_U16MSB.\n");
119 src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
120 dst = (Uint16 *) (cvt->buf + cvt->len_cvt * 2);
121 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
122 const Uint16 val = (((Uint16) *src) << 8);
123 *dst = SDL_SwapBE16(val);
127 format = AUDIO_U16MSB;
128 if (cvt->filters[++cvt->filter_index]) {
129 cvt->filters[cvt->filter_index] (cvt, format);
134 SDL_Convert_U8_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
141 fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S16MSB.\n");
144 src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
145 dst = (Sint16 *) (cvt->buf + cvt->len_cvt * 2);
146 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
147 const Sint16 val = (((Sint16) ((*src) ^ 0x80)) << 8);
148 *dst = ((Sint16) SDL_SwapBE16(val));
152 format = AUDIO_S16MSB;
153 if (cvt->filters[++cvt->filter_index]) {
154 cvt->filters[cvt->filter_index] (cvt, format);
159 SDL_Convert_U8_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
166 fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S32LSB.\n");
169 src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
170 dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 4);
171 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
172 const Sint32 val = (((Sint32) ((*src) ^ 0x80)) << 24);
173 *dst = ((Sint32) SDL_SwapLE32(val));
177 format = AUDIO_S32LSB;
178 if (cvt->filters[++cvt->filter_index]) {
179 cvt->filters[cvt->filter_index] (cvt, format);
184 SDL_Convert_U8_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
191 fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S32MSB.\n");
194 src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
195 dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 4);
196 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
197 const Sint32 val = (((Sint32) ((*src) ^ 0x80)) << 24);
198 *dst = ((Sint32) SDL_SwapBE32(val));
202 format = AUDIO_S32MSB;
203 if (cvt->filters[++cvt->filter_index]) {
204 cvt->filters[cvt->filter_index] (cvt, format);
209 SDL_Convert_U8_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
216 fprintf(stderr, "Converting AUDIO_U8 to AUDIO_F32LSB.\n");
219 src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
220 dst = (float *) (cvt->buf + cvt->len_cvt * 4);
221 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
222 const float val = ((((float) *src) * DIVBY127) - 1.0f);
223 *dst = SDL_SwapFloatLE(val);
227 format = AUDIO_F32LSB;
228 if (cvt->filters[++cvt->filter_index]) {
229 cvt->filters[cvt->filter_index] (cvt, format);
234 SDL_Convert_U8_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
241 fprintf(stderr, "Converting AUDIO_U8 to AUDIO_F32MSB.\n");
244 src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
245 dst = (float *) (cvt->buf + cvt->len_cvt * 4);
246 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
247 const float val = ((((float) *src) * DIVBY127) - 1.0f);
248 *dst = SDL_SwapFloatBE(val);
252 format = AUDIO_F32MSB;
253 if (cvt->filters[++cvt->filter_index]) {
254 cvt->filters[cvt->filter_index] (cvt, format);
259 SDL_Convert_S8_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
266 fprintf(stderr, "Converting AUDIO_S8 to AUDIO_U8.\n");
269 src = (const Uint8 *) cvt->buf;
270 dst = (Uint8 *) cvt->buf;
271 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, ++src, ++dst) {
272 const Uint8 val = ((((Sint8) *src)) ^ 0x80);
277 if (cvt->filters[++cvt->filter_index]) {
278 cvt->filters[cvt->filter_index] (cvt, format);
283 SDL_Convert_S8_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
290 fprintf(stderr, "Converting AUDIO_S8 to AUDIO_U16LSB.\n");
293 src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
294 dst = (Uint16 *) (cvt->buf + cvt->len_cvt * 2);
295 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
296 const Uint16 val = (((Uint16) ((((Sint8) *src)) ^ 0x80)) << 8);
297 *dst = SDL_SwapLE16(val);
301 format = AUDIO_U16LSB;
302 if (cvt->filters[++cvt->filter_index]) {
303 cvt->filters[cvt->filter_index] (cvt, format);
308 SDL_Convert_S8_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
315 fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S16LSB.\n");
318 src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
319 dst = (Sint16 *) (cvt->buf + cvt->len_cvt * 2);
320 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
321 const Sint16 val = (((Sint16) ((Sint8) *src)) << 8);
322 *dst = ((Sint16) SDL_SwapLE16(val));
326 format = AUDIO_S16LSB;
327 if (cvt->filters[++cvt->filter_index]) {
328 cvt->filters[cvt->filter_index] (cvt, format);
333 SDL_Convert_S8_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
340 fprintf(stderr, "Converting AUDIO_S8 to AUDIO_U16MSB.\n");
343 src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
344 dst = (Uint16 *) (cvt->buf + cvt->len_cvt * 2);
345 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
346 const Uint16 val = (((Uint16) ((((Sint8) *src)) ^ 0x80)) << 8);
347 *dst = SDL_SwapBE16(val);
351 format = AUDIO_U16MSB;
352 if (cvt->filters[++cvt->filter_index]) {
353 cvt->filters[cvt->filter_index] (cvt, format);
358 SDL_Convert_S8_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
365 fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S16MSB.\n");
368 src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
369 dst = (Sint16 *) (cvt->buf + cvt->len_cvt * 2);
370 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
371 const Sint16 val = (((Sint16) ((Sint8) *src)) << 8);
372 *dst = ((Sint16) SDL_SwapBE16(val));
376 format = AUDIO_S16MSB;
377 if (cvt->filters[++cvt->filter_index]) {
378 cvt->filters[cvt->filter_index] (cvt, format);
383 SDL_Convert_S8_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
390 fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S32LSB.\n");
393 src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
394 dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 4);
395 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
396 const Sint32 val = (((Sint32) ((Sint8) *src)) << 24);
397 *dst = ((Sint32) SDL_SwapLE32(val));
401 format = AUDIO_S32LSB;
402 if (cvt->filters[++cvt->filter_index]) {
403 cvt->filters[cvt->filter_index] (cvt, format);
408 SDL_Convert_S8_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
415 fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S32MSB.\n");
418 src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
419 dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 4);
420 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
421 const Sint32 val = (((Sint32) ((Sint8) *src)) << 24);
422 *dst = ((Sint32) SDL_SwapBE32(val));
426 format = AUDIO_S32MSB;
427 if (cvt->filters[++cvt->filter_index]) {
428 cvt->filters[cvt->filter_index] (cvt, format);
433 SDL_Convert_S8_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
440 fprintf(stderr, "Converting AUDIO_S8 to AUDIO_F32LSB.\n");
443 src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
444 dst = (float *) (cvt->buf + cvt->len_cvt * 4);
445 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
446 const float val = (((float) ((Sint8) *src)) * DIVBY127);
447 *dst = SDL_SwapFloatLE(val);
451 format = AUDIO_F32LSB;
452 if (cvt->filters[++cvt->filter_index]) {
453 cvt->filters[cvt->filter_index] (cvt, format);
458 SDL_Convert_S8_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
465 fprintf(stderr, "Converting AUDIO_S8 to AUDIO_F32MSB.\n");
468 src = (const Uint8 *) (cvt->buf + cvt->len_cvt);
469 dst = (float *) (cvt->buf + cvt->len_cvt * 4);
470 for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {
471 const float val = (((float) ((Sint8) *src)) * DIVBY127);
472 *dst = SDL_SwapFloatBE(val);
476 format = AUDIO_F32MSB;
477 if (cvt->filters[++cvt->filter_index]) {
478 cvt->filters[cvt->filter_index] (cvt, format);
483 SDL_Convert_U16LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
490 fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_U8.\n");
493 src = (const Uint16 *) cvt->buf;
494 dst = (Uint8 *) cvt->buf;
495 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
496 const Uint8 val = ((Uint8) (SDL_SwapLE16(*src) >> 8));
502 if (cvt->filters[++cvt->filter_index]) {
503 cvt->filters[cvt->filter_index] (cvt, format);
508 SDL_Convert_U16LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
515 fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S8.\n");
518 src = (const Uint16 *) cvt->buf;
519 dst = (Sint8 *) cvt->buf;
520 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
521 const Sint8 val = ((Sint8) (((SDL_SwapLE16(*src)) ^ 0x8000) >> 8));
522 *dst = ((Sint8) val);
527 if (cvt->filters[++cvt->filter_index]) {
528 cvt->filters[cvt->filter_index] (cvt, format);
533 SDL_Convert_U16LSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
540 fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S16LSB.\n");
543 src = (const Uint16 *) cvt->buf;
544 dst = (Sint16 *) cvt->buf;
545 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
546 const Sint16 val = ((SDL_SwapLE16(*src)) ^ 0x8000);
547 *dst = ((Sint16) SDL_SwapLE16(val));
550 format = AUDIO_S16LSB;
551 if (cvt->filters[++cvt->filter_index]) {
552 cvt->filters[cvt->filter_index] (cvt, format);
557 SDL_Convert_U16LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
564 fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_U16MSB.\n");
567 src = (const Uint16 *) cvt->buf;
568 dst = (Uint16 *) cvt->buf;
569 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
570 const Uint16 val = SDL_SwapLE16(*src);
571 *dst = SDL_SwapBE16(val);
574 format = AUDIO_U16MSB;
575 if (cvt->filters[++cvt->filter_index]) {
576 cvt->filters[cvt->filter_index] (cvt, format);
581 SDL_Convert_U16LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
588 fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S16MSB.\n");
591 src = (const Uint16 *) cvt->buf;
592 dst = (Sint16 *) cvt->buf;
593 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
594 const Sint16 val = ((SDL_SwapLE16(*src)) ^ 0x8000);
595 *dst = ((Sint16) SDL_SwapBE16(val));
598 format = AUDIO_S16MSB;
599 if (cvt->filters[++cvt->filter_index]) {
600 cvt->filters[cvt->filter_index] (cvt, format);
605 SDL_Convert_U16LSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
612 fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S32LSB.\n");
615 src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
616 dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
617 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
618 const Sint32 val = (((Sint32) ((SDL_SwapLE16(*src)) ^ 0x8000)) << 16);
619 *dst = ((Sint32) SDL_SwapLE32(val));
623 format = AUDIO_S32LSB;
624 if (cvt->filters[++cvt->filter_index]) {
625 cvt->filters[cvt->filter_index] (cvt, format);
630 SDL_Convert_U16LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
637 fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S32MSB.\n");
640 src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
641 dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
642 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
643 const Sint32 val = (((Sint32) ((SDL_SwapLE16(*src)) ^ 0x8000)) << 16);
644 *dst = ((Sint32) SDL_SwapBE32(val));
648 format = AUDIO_S32MSB;
649 if (cvt->filters[++cvt->filter_index]) {
650 cvt->filters[cvt->filter_index] (cvt, format);
655 SDL_Convert_U16LSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
662 fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_F32LSB.\n");
665 src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
666 dst = (float *) (cvt->buf + cvt->len_cvt * 2);
667 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
668 const float val = ((((float) SDL_SwapLE16(*src)) * DIVBY32767) - 1.0f);
669 *dst = SDL_SwapFloatLE(val);
673 format = AUDIO_F32LSB;
674 if (cvt->filters[++cvt->filter_index]) {
675 cvt->filters[cvt->filter_index] (cvt, format);
680 SDL_Convert_U16LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
687 fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_F32MSB.\n");
690 src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
691 dst = (float *) (cvt->buf + cvt->len_cvt * 2);
692 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
693 const float val = ((((float) SDL_SwapLE16(*src)) * DIVBY32767) - 1.0f);
694 *dst = SDL_SwapFloatBE(val);
698 format = AUDIO_F32MSB;
699 if (cvt->filters[++cvt->filter_index]) {
700 cvt->filters[cvt->filter_index] (cvt, format);
705 SDL_Convert_S16LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
712 fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_U8.\n");
715 src = (const Uint16 *) cvt->buf;
716 dst = (Uint8 *) cvt->buf;
717 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
718 const Uint8 val = ((Uint8) (((((Sint16) SDL_SwapLE16(*src))) ^ 0x8000) >> 8));
724 if (cvt->filters[++cvt->filter_index]) {
725 cvt->filters[cvt->filter_index] (cvt, format);
730 SDL_Convert_S16LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
737 fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S8.\n");
740 src = (const Uint16 *) cvt->buf;
741 dst = (Sint8 *) cvt->buf;
742 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
743 const Sint8 val = ((Sint8) (((Sint16) SDL_SwapLE16(*src)) >> 8));
744 *dst = ((Sint8) val);
749 if (cvt->filters[++cvt->filter_index]) {
750 cvt->filters[cvt->filter_index] (cvt, format);
755 SDL_Convert_S16LSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
762 fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_U16LSB.\n");
765 src = (const Uint16 *) cvt->buf;
766 dst = (Uint16 *) cvt->buf;
767 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
768 const Uint16 val = ((((Sint16) SDL_SwapLE16(*src))) ^ 0x8000);
769 *dst = SDL_SwapLE16(val);
772 format = AUDIO_U16LSB;
773 if (cvt->filters[++cvt->filter_index]) {
774 cvt->filters[cvt->filter_index] (cvt, format);
779 SDL_Convert_S16LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
786 fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_U16MSB.\n");
789 src = (const Uint16 *) cvt->buf;
790 dst = (Uint16 *) cvt->buf;
791 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
792 const Uint16 val = ((((Sint16) SDL_SwapLE16(*src))) ^ 0x8000);
793 *dst = SDL_SwapBE16(val);
796 format = AUDIO_U16MSB;
797 if (cvt->filters[++cvt->filter_index]) {
798 cvt->filters[cvt->filter_index] (cvt, format);
803 SDL_Convert_S16LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
810 fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S16MSB.\n");
813 src = (const Uint16 *) cvt->buf;
814 dst = (Sint16 *) cvt->buf;
815 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
816 const Sint16 val = ((Sint16) SDL_SwapLE16(*src));
817 *dst = ((Sint16) SDL_SwapBE16(val));
820 format = AUDIO_S16MSB;
821 if (cvt->filters[++cvt->filter_index]) {
822 cvt->filters[cvt->filter_index] (cvt, format);
827 SDL_Convert_S16LSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
834 fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S32LSB.\n");
837 src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
838 dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
839 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
840 const Sint32 val = (((Sint32) ((Sint16) SDL_SwapLE16(*src))) << 16);
841 *dst = ((Sint32) SDL_SwapLE32(val));
845 format = AUDIO_S32LSB;
846 if (cvt->filters[++cvt->filter_index]) {
847 cvt->filters[cvt->filter_index] (cvt, format);
852 SDL_Convert_S16LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
859 fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S32MSB.\n");
862 src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
863 dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
864 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
865 const Sint32 val = (((Sint32) ((Sint16) SDL_SwapLE16(*src))) << 16);
866 *dst = ((Sint32) SDL_SwapBE32(val));
870 format = AUDIO_S32MSB;
871 if (cvt->filters[++cvt->filter_index]) {
872 cvt->filters[cvt->filter_index] (cvt, format);
877 SDL_Convert_S16LSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
884 fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_F32LSB.\n");
887 src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
888 dst = (float *) (cvt->buf + cvt->len_cvt * 2);
889 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
890 const float val = (((float) ((Sint16) SDL_SwapLE16(*src))) * DIVBY32767);
891 *dst = SDL_SwapFloatLE(val);
895 format = AUDIO_F32LSB;
896 if (cvt->filters[++cvt->filter_index]) {
897 cvt->filters[cvt->filter_index] (cvt, format);
902 SDL_Convert_S16LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
909 fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_F32MSB.\n");
912 src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
913 dst = (float *) (cvt->buf + cvt->len_cvt * 2);
914 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
915 const float val = (((float) ((Sint16) SDL_SwapLE16(*src))) * DIVBY32767);
916 *dst = SDL_SwapFloatBE(val);
920 format = AUDIO_F32MSB;
921 if (cvt->filters[++cvt->filter_index]) {
922 cvt->filters[cvt->filter_index] (cvt, format);
927 SDL_Convert_U16MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
934 fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_U8.\n");
937 src = (const Uint16 *) cvt->buf;
938 dst = (Uint8 *) cvt->buf;
939 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
940 const Uint8 val = ((Uint8) (SDL_SwapBE16(*src) >> 8));
946 if (cvt->filters[++cvt->filter_index]) {
947 cvt->filters[cvt->filter_index] (cvt, format);
952 SDL_Convert_U16MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
959 fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S8.\n");
962 src = (const Uint16 *) cvt->buf;
963 dst = (Sint8 *) cvt->buf;
964 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
965 const Sint8 val = ((Sint8) (((SDL_SwapBE16(*src)) ^ 0x8000) >> 8));
966 *dst = ((Sint8) val);
971 if (cvt->filters[++cvt->filter_index]) {
972 cvt->filters[cvt->filter_index] (cvt, format);
977 SDL_Convert_U16MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
984 fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_U16LSB.\n");
987 src = (const Uint16 *) cvt->buf;
988 dst = (Uint16 *) cvt->buf;
989 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
990 const Uint16 val = SDL_SwapBE16(*src);
991 *dst = SDL_SwapLE16(val);
994 format = AUDIO_U16LSB;
995 if (cvt->filters[++cvt->filter_index]) {
996 cvt->filters[cvt->filter_index] (cvt, format);
1001 SDL_Convert_U16MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1007 #ifdef DEBUG_CONVERT
1008 fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S16LSB.\n");
1011 src = (const Uint16 *) cvt->buf;
1012 dst = (Sint16 *) cvt->buf;
1013 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
1014 const Sint16 val = ((SDL_SwapBE16(*src)) ^ 0x8000);
1015 *dst = ((Sint16) SDL_SwapLE16(val));
1018 format = AUDIO_S16LSB;
1019 if (cvt->filters[++cvt->filter_index]) {
1020 cvt->filters[cvt->filter_index] (cvt, format);
1025 SDL_Convert_U16MSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1031 #ifdef DEBUG_CONVERT
1032 fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S16MSB.\n");
1035 src = (const Uint16 *) cvt->buf;
1036 dst = (Sint16 *) cvt->buf;
1037 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
1038 const Sint16 val = ((SDL_SwapBE16(*src)) ^ 0x8000);
1039 *dst = ((Sint16) SDL_SwapBE16(val));
1042 format = AUDIO_S16MSB;
1043 if (cvt->filters[++cvt->filter_index]) {
1044 cvt->filters[cvt->filter_index] (cvt, format);
1049 SDL_Convert_U16MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1055 #ifdef DEBUG_CONVERT
1056 fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S32LSB.\n");
1059 src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
1060 dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
1061 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
1062 const Sint32 val = (((Sint32) ((SDL_SwapBE16(*src)) ^ 0x8000)) << 16);
1063 *dst = ((Sint32) SDL_SwapLE32(val));
1067 format = AUDIO_S32LSB;
1068 if (cvt->filters[++cvt->filter_index]) {
1069 cvt->filters[cvt->filter_index] (cvt, format);
1074 SDL_Convert_U16MSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1080 #ifdef DEBUG_CONVERT
1081 fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S32MSB.\n");
1084 src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
1085 dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
1086 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
1087 const Sint32 val = (((Sint32) ((SDL_SwapBE16(*src)) ^ 0x8000)) << 16);
1088 *dst = ((Sint32) SDL_SwapBE32(val));
1092 format = AUDIO_S32MSB;
1093 if (cvt->filters[++cvt->filter_index]) {
1094 cvt->filters[cvt->filter_index] (cvt, format);
1099 SDL_Convert_U16MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1105 #ifdef DEBUG_CONVERT
1106 fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_F32LSB.\n");
1109 src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
1110 dst = (float *) (cvt->buf + cvt->len_cvt * 2);
1111 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
1112 const float val = ((((float) SDL_SwapBE16(*src)) * DIVBY32767) - 1.0f);
1113 *dst = SDL_SwapFloatLE(val);
1117 format = AUDIO_F32LSB;
1118 if (cvt->filters[++cvt->filter_index]) {
1119 cvt->filters[cvt->filter_index] (cvt, format);
1124 SDL_Convert_U16MSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1130 #ifdef DEBUG_CONVERT
1131 fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_F32MSB.\n");
1134 src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
1135 dst = (float *) (cvt->buf + cvt->len_cvt * 2);
1136 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
1137 const float val = ((((float) SDL_SwapBE16(*src)) * DIVBY32767) - 1.0f);
1138 *dst = SDL_SwapFloatBE(val);
1142 format = AUDIO_F32MSB;
1143 if (cvt->filters[++cvt->filter_index]) {
1144 cvt->filters[cvt->filter_index] (cvt, format);
1149 SDL_Convert_S16MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1155 #ifdef DEBUG_CONVERT
1156 fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_U8.\n");
1159 src = (const Uint16 *) cvt->buf;
1160 dst = (Uint8 *) cvt->buf;
1161 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
1162 const Uint8 val = ((Uint8) (((((Sint16) SDL_SwapBE16(*src))) ^ 0x8000) >> 8));
1168 if (cvt->filters[++cvt->filter_index]) {
1169 cvt->filters[cvt->filter_index] (cvt, format);
1174 SDL_Convert_S16MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1180 #ifdef DEBUG_CONVERT
1181 fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S8.\n");
1184 src = (const Uint16 *) cvt->buf;
1185 dst = (Sint8 *) cvt->buf;
1186 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
1187 const Sint8 val = ((Sint8) (((Sint16) SDL_SwapBE16(*src)) >> 8));
1188 *dst = ((Sint8) val);
1193 if (cvt->filters[++cvt->filter_index]) {
1194 cvt->filters[cvt->filter_index] (cvt, format);
1199 SDL_Convert_S16MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1205 #ifdef DEBUG_CONVERT
1206 fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_U16LSB.\n");
1209 src = (const Uint16 *) cvt->buf;
1210 dst = (Uint16 *) cvt->buf;
1211 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
1212 const Uint16 val = ((((Sint16) SDL_SwapBE16(*src))) ^ 0x8000);
1213 *dst = SDL_SwapLE16(val);
1216 format = AUDIO_U16LSB;
1217 if (cvt->filters[++cvt->filter_index]) {
1218 cvt->filters[cvt->filter_index] (cvt, format);
1223 SDL_Convert_S16MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1229 #ifdef DEBUG_CONVERT
1230 fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S16LSB.\n");
1233 src = (const Uint16 *) cvt->buf;
1234 dst = (Sint16 *) cvt->buf;
1235 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
1236 const Sint16 val = ((Sint16) SDL_SwapBE16(*src));
1237 *dst = ((Sint16) SDL_SwapLE16(val));
1240 format = AUDIO_S16LSB;
1241 if (cvt->filters[++cvt->filter_index]) {
1242 cvt->filters[cvt->filter_index] (cvt, format);
1247 SDL_Convert_S16MSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1253 #ifdef DEBUG_CONVERT
1254 fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_U16MSB.\n");
1257 src = (const Uint16 *) cvt->buf;
1258 dst = (Uint16 *) cvt->buf;
1259 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {
1260 const Uint16 val = ((((Sint16) SDL_SwapBE16(*src))) ^ 0x8000);
1261 *dst = SDL_SwapBE16(val);
1264 format = AUDIO_U16MSB;
1265 if (cvt->filters[++cvt->filter_index]) {
1266 cvt->filters[cvt->filter_index] (cvt, format);
1271 SDL_Convert_S16MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1277 #ifdef DEBUG_CONVERT
1278 fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S32LSB.\n");
1281 src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
1282 dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
1283 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
1284 const Sint32 val = (((Sint32) ((Sint16) SDL_SwapBE16(*src))) << 16);
1285 *dst = ((Sint32) SDL_SwapLE32(val));
1289 format = AUDIO_S32LSB;
1290 if (cvt->filters[++cvt->filter_index]) {
1291 cvt->filters[cvt->filter_index] (cvt, format);
1296 SDL_Convert_S16MSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1302 #ifdef DEBUG_CONVERT
1303 fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S32MSB.\n");
1306 src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
1307 dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);
1308 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
1309 const Sint32 val = (((Sint32) ((Sint16) SDL_SwapBE16(*src))) << 16);
1310 *dst = ((Sint32) SDL_SwapBE32(val));
1314 format = AUDIO_S32MSB;
1315 if (cvt->filters[++cvt->filter_index]) {
1316 cvt->filters[cvt->filter_index] (cvt, format);
1321 SDL_Convert_S16MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1327 #ifdef DEBUG_CONVERT
1328 fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_F32LSB.\n");
1331 src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
1332 dst = (float *) (cvt->buf + cvt->len_cvt * 2);
1333 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
1334 const float val = (((float) ((Sint16) SDL_SwapBE16(*src))) * DIVBY32767);
1335 *dst = SDL_SwapFloatLE(val);
1339 format = AUDIO_F32LSB;
1340 if (cvt->filters[++cvt->filter_index]) {
1341 cvt->filters[cvt->filter_index] (cvt, format);
1346 SDL_Convert_S16MSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1352 #ifdef DEBUG_CONVERT
1353 fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_F32MSB.\n");
1356 src = (const Uint16 *) (cvt->buf + cvt->len_cvt);
1357 dst = (float *) (cvt->buf + cvt->len_cvt * 2);
1358 for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {
1359 const float val = (((float) ((Sint16) SDL_SwapBE16(*src))) * DIVBY32767);
1360 *dst = SDL_SwapFloatBE(val);
1364 format = AUDIO_F32MSB;
1365 if (cvt->filters[++cvt->filter_index]) {
1366 cvt->filters[cvt->filter_index] (cvt, format);
1371 SDL_Convert_S32LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1377 #ifdef DEBUG_CONVERT
1378 fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_U8.\n");
1381 src = (const Uint32 *) cvt->buf;
1382 dst = (Uint8 *) cvt->buf;
1383 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1384 const Uint8 val = ((Uint8) (((((Sint32) SDL_SwapLE32(*src))) ^ 0x80000000) >> 24));
1390 if (cvt->filters[++cvt->filter_index]) {
1391 cvt->filters[cvt->filter_index] (cvt, format);
1396 SDL_Convert_S32LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1402 #ifdef DEBUG_CONVERT
1403 fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S8.\n");
1406 src = (const Uint32 *) cvt->buf;
1407 dst = (Sint8 *) cvt->buf;
1408 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1409 const Sint8 val = ((Sint8) (((Sint32) SDL_SwapLE32(*src)) >> 24));
1410 *dst = ((Sint8) val);
1415 if (cvt->filters[++cvt->filter_index]) {
1416 cvt->filters[cvt->filter_index] (cvt, format);
1421 SDL_Convert_S32LSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1427 #ifdef DEBUG_CONVERT
1428 fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_U16LSB.\n");
1431 src = (const Uint32 *) cvt->buf;
1432 dst = (Uint16 *) cvt->buf;
1433 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1434 const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapLE32(*src))) ^ 0x80000000) >> 16));
1435 *dst = SDL_SwapLE16(val);
1439 format = AUDIO_U16LSB;
1440 if (cvt->filters[++cvt->filter_index]) {
1441 cvt->filters[cvt->filter_index] (cvt, format);
1446 SDL_Convert_S32LSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1452 #ifdef DEBUG_CONVERT
1453 fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S16LSB.\n");
1456 src = (const Uint32 *) cvt->buf;
1457 dst = (Sint16 *) cvt->buf;
1458 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1459 const Sint16 val = ((Sint16) (((Sint32) SDL_SwapLE32(*src)) >> 16));
1460 *dst = ((Sint16) SDL_SwapLE16(val));
1464 format = AUDIO_S16LSB;
1465 if (cvt->filters[++cvt->filter_index]) {
1466 cvt->filters[cvt->filter_index] (cvt, format);
1471 SDL_Convert_S32LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1477 #ifdef DEBUG_CONVERT
1478 fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_U16MSB.\n");
1481 src = (const Uint32 *) cvt->buf;
1482 dst = (Uint16 *) cvt->buf;
1483 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1484 const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapLE32(*src))) ^ 0x80000000) >> 16));
1485 *dst = SDL_SwapBE16(val);
1489 format = AUDIO_U16MSB;
1490 if (cvt->filters[++cvt->filter_index]) {
1491 cvt->filters[cvt->filter_index] (cvt, format);
1496 SDL_Convert_S32LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1502 #ifdef DEBUG_CONVERT
1503 fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S16MSB.\n");
1506 src = (const Uint32 *) cvt->buf;
1507 dst = (Sint16 *) cvt->buf;
1508 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1509 const Sint16 val = ((Sint16) (((Sint32) SDL_SwapLE32(*src)) >> 16));
1510 *dst = ((Sint16) SDL_SwapBE16(val));
1514 format = AUDIO_S16MSB;
1515 if (cvt->filters[++cvt->filter_index]) {
1516 cvt->filters[cvt->filter_index] (cvt, format);
1521 SDL_Convert_S32LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1527 #ifdef DEBUG_CONVERT
1528 fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S32MSB.\n");
1531 src = (const Uint32 *) cvt->buf;
1532 dst = (Sint32 *) cvt->buf;
1533 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1534 const Sint32 val = ((Sint32) SDL_SwapLE32(*src));
1535 *dst = ((Sint32) SDL_SwapBE32(val));
1538 format = AUDIO_S32MSB;
1539 if (cvt->filters[++cvt->filter_index]) {
1540 cvt->filters[cvt->filter_index] (cvt, format);
1545 SDL_Convert_S32LSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1551 #ifdef DEBUG_CONVERT
1552 fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_F32LSB.\n");
1555 src = (const Uint32 *) cvt->buf;
1556 dst = (float *) cvt->buf;
1557 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1558 const float val = (((float) ((Sint32) SDL_SwapLE32(*src))) * DIVBY2147483647);
1559 *dst = SDL_SwapFloatLE(val);
1562 format = AUDIO_F32LSB;
1563 if (cvt->filters[++cvt->filter_index]) {
1564 cvt->filters[cvt->filter_index] (cvt, format);
1569 SDL_Convert_S32LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1575 #ifdef DEBUG_CONVERT
1576 fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_F32MSB.\n");
1579 src = (const Uint32 *) cvt->buf;
1580 dst = (float *) cvt->buf;
1581 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1582 const float val = (((float) ((Sint32) SDL_SwapLE32(*src))) * DIVBY2147483647);
1583 *dst = SDL_SwapFloatBE(val);
1586 format = AUDIO_F32MSB;
1587 if (cvt->filters[++cvt->filter_index]) {
1588 cvt->filters[cvt->filter_index] (cvt, format);
1593 SDL_Convert_S32MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1599 #ifdef DEBUG_CONVERT
1600 fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_U8.\n");
1603 src = (const Uint32 *) cvt->buf;
1604 dst = (Uint8 *) cvt->buf;
1605 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1606 const Uint8 val = ((Uint8) (((((Sint32) SDL_SwapBE32(*src))) ^ 0x80000000) >> 24));
1612 if (cvt->filters[++cvt->filter_index]) {
1613 cvt->filters[cvt->filter_index] (cvt, format);
1618 SDL_Convert_S32MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1624 #ifdef DEBUG_CONVERT
1625 fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S8.\n");
1628 src = (const Uint32 *) cvt->buf;
1629 dst = (Sint8 *) cvt->buf;
1630 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1631 const Sint8 val = ((Sint8) (((Sint32) SDL_SwapBE32(*src)) >> 24));
1632 *dst = ((Sint8) val);
1637 if (cvt->filters[++cvt->filter_index]) {
1638 cvt->filters[cvt->filter_index] (cvt, format);
1643 SDL_Convert_S32MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1649 #ifdef DEBUG_CONVERT
1650 fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_U16LSB.\n");
1653 src = (const Uint32 *) cvt->buf;
1654 dst = (Uint16 *) cvt->buf;
1655 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1656 const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapBE32(*src))) ^ 0x80000000) >> 16));
1657 *dst = SDL_SwapLE16(val);
1661 format = AUDIO_U16LSB;
1662 if (cvt->filters[++cvt->filter_index]) {
1663 cvt->filters[cvt->filter_index] (cvt, format);
1668 SDL_Convert_S32MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1674 #ifdef DEBUG_CONVERT
1675 fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S16LSB.\n");
1678 src = (const Uint32 *) cvt->buf;
1679 dst = (Sint16 *) cvt->buf;
1680 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1681 const Sint16 val = ((Sint16) (((Sint32) SDL_SwapBE32(*src)) >> 16));
1682 *dst = ((Sint16) SDL_SwapLE16(val));
1686 format = AUDIO_S16LSB;
1687 if (cvt->filters[++cvt->filter_index]) {
1688 cvt->filters[cvt->filter_index] (cvt, format);
1693 SDL_Convert_S32MSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1699 #ifdef DEBUG_CONVERT
1700 fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_U16MSB.\n");
1703 src = (const Uint32 *) cvt->buf;
1704 dst = (Uint16 *) cvt->buf;
1705 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1706 const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapBE32(*src))) ^ 0x80000000) >> 16));
1707 *dst = SDL_SwapBE16(val);
1711 format = AUDIO_U16MSB;
1712 if (cvt->filters[++cvt->filter_index]) {
1713 cvt->filters[cvt->filter_index] (cvt, format);
1718 SDL_Convert_S32MSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1724 #ifdef DEBUG_CONVERT
1725 fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S16MSB.\n");
1728 src = (const Uint32 *) cvt->buf;
1729 dst = (Sint16 *) cvt->buf;
1730 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1731 const Sint16 val = ((Sint16) (((Sint32) SDL_SwapBE32(*src)) >> 16));
1732 *dst = ((Sint16) SDL_SwapBE16(val));
1736 format = AUDIO_S16MSB;
1737 if (cvt->filters[++cvt->filter_index]) {
1738 cvt->filters[cvt->filter_index] (cvt, format);
1743 SDL_Convert_S32MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1749 #ifdef DEBUG_CONVERT
1750 fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S32LSB.\n");
1753 src = (const Uint32 *) cvt->buf;
1754 dst = (Sint32 *) cvt->buf;
1755 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1756 const Sint32 val = ((Sint32) SDL_SwapBE32(*src));
1757 *dst = ((Sint32) SDL_SwapLE32(val));
1760 format = AUDIO_S32LSB;
1761 if (cvt->filters[++cvt->filter_index]) {
1762 cvt->filters[cvt->filter_index] (cvt, format);
1767 SDL_Convert_S32MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1773 #ifdef DEBUG_CONVERT
1774 fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_F32LSB.\n");
1777 src = (const Uint32 *) cvt->buf;
1778 dst = (float *) cvt->buf;
1779 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1780 const float val = (((float) ((Sint32) SDL_SwapBE32(*src))) * DIVBY2147483647);
1781 *dst = SDL_SwapFloatLE(val);
1784 format = AUDIO_F32LSB;
1785 if (cvt->filters[++cvt->filter_index]) {
1786 cvt->filters[cvt->filter_index] (cvt, format);
1791 SDL_Convert_S32MSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1797 #ifdef DEBUG_CONVERT
1798 fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_F32MSB.\n");
1801 src = (const Uint32 *) cvt->buf;
1802 dst = (float *) cvt->buf;
1803 for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {
1804 const float val = (((float) ((Sint32) SDL_SwapBE32(*src))) * DIVBY2147483647);
1805 *dst = SDL_SwapFloatBE(val);
1808 format = AUDIO_F32MSB;
1809 if (cvt->filters[++cvt->filter_index]) {
1810 cvt->filters[cvt->filter_index] (cvt, format);
1815 SDL_Convert_F32LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1821 #ifdef DEBUG_CONVERT
1822 fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_U8.\n");
1825 src = (const float *) cvt->buf;
1826 dst = (Uint8 *) cvt->buf;
1827 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
1828 const Uint8 val = ((Uint8) ((SDL_SwapFloatLE(*src) + 1.0f) * 127.0f));
1834 if (cvt->filters[++cvt->filter_index]) {
1835 cvt->filters[cvt->filter_index] (cvt, format);
1840 SDL_Convert_F32LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1846 #ifdef DEBUG_CONVERT
1847 fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S8.\n");
1850 src = (const float *) cvt->buf;
1851 dst = (Sint8 *) cvt->buf;
1852 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
1853 const Sint8 val = ((Sint8) (SDL_SwapFloatLE(*src) * 127.0f));
1854 *dst = ((Sint8) val);
1859 if (cvt->filters[++cvt->filter_index]) {
1860 cvt->filters[cvt->filter_index] (cvt, format);
1865 SDL_Convert_F32LSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1871 #ifdef DEBUG_CONVERT
1872 fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_U16LSB.\n");
1875 src = (const float *) cvt->buf;
1876 dst = (Uint16 *) cvt->buf;
1877 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
1878 const Uint16 val = ((Uint16) ((SDL_SwapFloatLE(*src) + 1.0f) * 32767.0f));
1879 *dst = SDL_SwapLE16(val);
1883 format = AUDIO_U16LSB;
1884 if (cvt->filters[++cvt->filter_index]) {
1885 cvt->filters[cvt->filter_index] (cvt, format);
1890 SDL_Convert_F32LSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1896 #ifdef DEBUG_CONVERT
1897 fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S16LSB.\n");
1900 src = (const float *) cvt->buf;
1901 dst = (Sint16 *) cvt->buf;
1902 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
1903 const Sint16 val = ((Sint16) (SDL_SwapFloatLE(*src) * 32767.0f));
1904 *dst = ((Sint16) SDL_SwapLE16(val));
1908 format = AUDIO_S16LSB;
1909 if (cvt->filters[++cvt->filter_index]) {
1910 cvt->filters[cvt->filter_index] (cvt, format);
1915 SDL_Convert_F32LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1921 #ifdef DEBUG_CONVERT
1922 fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_U16MSB.\n");
1925 src = (const float *) cvt->buf;
1926 dst = (Uint16 *) cvt->buf;
1927 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
1928 const Uint16 val = ((Uint16) ((SDL_SwapFloatLE(*src) + 1.0f) * 32767.0f));
1929 *dst = SDL_SwapBE16(val);
1933 format = AUDIO_U16MSB;
1934 if (cvt->filters[++cvt->filter_index]) {
1935 cvt->filters[cvt->filter_index] (cvt, format);
1940 SDL_Convert_F32LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1946 #ifdef DEBUG_CONVERT
1947 fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S16MSB.\n");
1950 src = (const float *) cvt->buf;
1951 dst = (Sint16 *) cvt->buf;
1952 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
1953 const Sint16 val = ((Sint16) (SDL_SwapFloatLE(*src) * 32767.0f));
1954 *dst = ((Sint16) SDL_SwapBE16(val));
1958 format = AUDIO_S16MSB;
1959 if (cvt->filters[++cvt->filter_index]) {
1960 cvt->filters[cvt->filter_index] (cvt, format);
1965 SDL_Convert_F32LSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1971 #ifdef DEBUG_CONVERT
1972 fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S32LSB.\n");
1975 src = (const float *) cvt->buf;
1976 dst = (Sint32 *) cvt->buf;
1977 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
1978 const Sint32 val = ((Sint32) (SDL_SwapFloatLE(*src) * 2147483647.0));
1979 *dst = ((Sint32) SDL_SwapLE32(val));
1982 format = AUDIO_S32LSB;
1983 if (cvt->filters[++cvt->filter_index]) {
1984 cvt->filters[cvt->filter_index] (cvt, format);
1989 SDL_Convert_F32LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
1995 #ifdef DEBUG_CONVERT
1996 fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S32MSB.\n");
1999 src = (const float *) cvt->buf;
2000 dst = (Sint32 *) cvt->buf;
2001 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2002 const Sint32 val = ((Sint32) (SDL_SwapFloatLE(*src) * 2147483647.0));
2003 *dst = ((Sint32) SDL_SwapBE32(val));
2006 format = AUDIO_S32MSB;
2007 if (cvt->filters[++cvt->filter_index]) {
2008 cvt->filters[cvt->filter_index] (cvt, format);
2013 SDL_Convert_F32LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2019 #ifdef DEBUG_CONVERT
2020 fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_F32MSB.\n");
2023 src = (const float *) cvt->buf;
2024 dst = (float *) cvt->buf;
2025 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2026 const float val = SDL_SwapFloatLE(*src);
2027 *dst = SDL_SwapFloatBE(val);
2030 format = AUDIO_F32MSB;
2031 if (cvt->filters[++cvt->filter_index]) {
2032 cvt->filters[cvt->filter_index] (cvt, format);
2037 SDL_Convert_F32MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2043 #ifdef DEBUG_CONVERT
2044 fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_U8.\n");
2047 src = (const float *) cvt->buf;
2048 dst = (Uint8 *) cvt->buf;
2049 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2050 const Uint8 val = ((Uint8) ((SDL_SwapFloatBE(*src) + 1.0f) * 127.0f));
2056 if (cvt->filters[++cvt->filter_index]) {
2057 cvt->filters[cvt->filter_index] (cvt, format);
2062 SDL_Convert_F32MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2068 #ifdef DEBUG_CONVERT
2069 fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S8.\n");
2072 src = (const float *) cvt->buf;
2073 dst = (Sint8 *) cvt->buf;
2074 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2075 const Sint8 val = ((Sint8) (SDL_SwapFloatBE(*src) * 127.0f));
2076 *dst = ((Sint8) val);
2081 if (cvt->filters[++cvt->filter_index]) {
2082 cvt->filters[cvt->filter_index] (cvt, format);
2087 SDL_Convert_F32MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2093 #ifdef DEBUG_CONVERT
2094 fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_U16LSB.\n");
2097 src = (const float *) cvt->buf;
2098 dst = (Uint16 *) cvt->buf;
2099 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2100 const Uint16 val = ((Uint16) ((SDL_SwapFloatBE(*src) + 1.0f) * 32767.0f));
2101 *dst = SDL_SwapLE16(val);
2105 format = AUDIO_U16LSB;
2106 if (cvt->filters[++cvt->filter_index]) {
2107 cvt->filters[cvt->filter_index] (cvt, format);
2112 SDL_Convert_F32MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2118 #ifdef DEBUG_CONVERT
2119 fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S16LSB.\n");
2122 src = (const float *) cvt->buf;
2123 dst = (Sint16 *) cvt->buf;
2124 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2125 const Sint16 val = ((Sint16) (SDL_SwapFloatBE(*src) * 32767.0f));
2126 *dst = ((Sint16) SDL_SwapLE16(val));
2130 format = AUDIO_S16LSB;
2131 if (cvt->filters[++cvt->filter_index]) {
2132 cvt->filters[cvt->filter_index] (cvt, format);
2137 SDL_Convert_F32MSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2143 #ifdef DEBUG_CONVERT
2144 fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_U16MSB.\n");
2147 src = (const float *) cvt->buf;
2148 dst = (Uint16 *) cvt->buf;
2149 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2150 const Uint16 val = ((Uint16) ((SDL_SwapFloatBE(*src) + 1.0f) * 32767.0f));
2151 *dst = SDL_SwapBE16(val);
2155 format = AUDIO_U16MSB;
2156 if (cvt->filters[++cvt->filter_index]) {
2157 cvt->filters[cvt->filter_index] (cvt, format);
2162 SDL_Convert_F32MSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2168 #ifdef DEBUG_CONVERT
2169 fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S16MSB.\n");
2172 src = (const float *) cvt->buf;
2173 dst = (Sint16 *) cvt->buf;
2174 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2175 const Sint16 val = ((Sint16) (SDL_SwapFloatBE(*src) * 32767.0f));
2176 *dst = ((Sint16) SDL_SwapBE16(val));
2180 format = AUDIO_S16MSB;
2181 if (cvt->filters[++cvt->filter_index]) {
2182 cvt->filters[cvt->filter_index] (cvt, format);
2187 SDL_Convert_F32MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2193 #ifdef DEBUG_CONVERT
2194 fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S32LSB.\n");
2197 src = (const float *) cvt->buf;
2198 dst = (Sint32 *) cvt->buf;
2199 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2200 const Sint32 val = ((Sint32) (SDL_SwapFloatBE(*src) * 2147483647.0));
2201 *dst = ((Sint32) SDL_SwapLE32(val));
2204 format = AUDIO_S32LSB;
2205 if (cvt->filters[++cvt->filter_index]) {
2206 cvt->filters[cvt->filter_index] (cvt, format);
2211 SDL_Convert_F32MSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2217 #ifdef DEBUG_CONVERT
2218 fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S32MSB.\n");
2221 src = (const float *) cvt->buf;
2222 dst = (Sint32 *) cvt->buf;
2223 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2224 const Sint32 val = ((Sint32) (SDL_SwapFloatBE(*src) * 2147483647.0));
2225 *dst = ((Sint32) SDL_SwapBE32(val));
2228 format = AUDIO_S32MSB;
2229 if (cvt->filters[++cvt->filter_index]) {
2230 cvt->filters[cvt->filter_index] (cvt, format);
2235 SDL_Convert_F32MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)
2241 #ifdef DEBUG_CONVERT
2242 fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_F32LSB.\n");
2245 src = (const float *) cvt->buf;
2246 dst = (float *) cvt->buf;
2247 for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {
2248 const float val = SDL_SwapFloatBE(*src);
2249 *dst = SDL_SwapFloatLE(val);
2252 format = AUDIO_F32LSB;
2253 if (cvt->filters[++cvt->filter_index]) {
2254 cvt->filters[cvt->filter_index] (cvt, format);
2258 const SDL_AudioTypeFilters sdl_audio_type_filters[] =
2260 { AUDIO_U8, AUDIO_S8, SDL_Convert_U8_to_S8 },
2261 { AUDIO_U8, AUDIO_U16LSB, SDL_Convert_U8_to_U16LSB },
2262 { AUDIO_U8, AUDIO_S16LSB, SDL_Convert_U8_to_S16LSB },
2263 { AUDIO_U8, AUDIO_U16MSB, SDL_Convert_U8_to_U16MSB },
2264 { AUDIO_U8, AUDIO_S16MSB, SDL_Convert_U8_to_S16MSB },
2265 { AUDIO_U8, AUDIO_S32LSB, SDL_Convert_U8_to_S32LSB },
2266 { AUDIO_U8, AUDIO_S32MSB, SDL_Convert_U8_to_S32MSB },
2267 { AUDIO_U8, AUDIO_F32LSB, SDL_Convert_U8_to_F32LSB },
2268 { AUDIO_U8, AUDIO_F32MSB, SDL_Convert_U8_to_F32MSB },
2269 { AUDIO_S8, AUDIO_U8, SDL_Convert_S8_to_U8 },
2270 { AUDIO_S8, AUDIO_U16LSB, SDL_Convert_S8_to_U16LSB },
2271 { AUDIO_S8, AUDIO_S16LSB, SDL_Convert_S8_to_S16LSB },
2272 { AUDIO_S8, AUDIO_U16MSB, SDL_Convert_S8_to_U16MSB },
2273 { AUDIO_S8, AUDIO_S16MSB, SDL_Convert_S8_to_S16MSB },
2274 { AUDIO_S8, AUDIO_S32LSB, SDL_Convert_S8_to_S32LSB },
2275 { AUDIO_S8, AUDIO_S32MSB, SDL_Convert_S8_to_S32MSB },
2276 { AUDIO_S8, AUDIO_F32LSB, SDL_Convert_S8_to_F32LSB },
2277 { AUDIO_S8, AUDIO_F32MSB, SDL_Convert_S8_to_F32MSB },
2278 { AUDIO_U16LSB, AUDIO_U8, SDL_Convert_U16LSB_to_U8 },
2279 { AUDIO_U16LSB, AUDIO_S8, SDL_Convert_U16LSB_to_S8 },
2280 { AUDIO_U16LSB, AUDIO_S16LSB, SDL_Convert_U16LSB_to_S16LSB },
2281 { AUDIO_U16LSB, AUDIO_U16MSB, SDL_Convert_U16LSB_to_U16MSB },
2282 { AUDIO_U16LSB, AUDIO_S16MSB, SDL_Convert_U16LSB_to_S16MSB },
2283 { AUDIO_U16LSB, AUDIO_S32LSB, SDL_Convert_U16LSB_to_S32LSB },
2284 { AUDIO_U16LSB, AUDIO_S32MSB, SDL_Convert_U16LSB_to_S32MSB },
2285 { AUDIO_U16LSB, AUDIO_F32LSB, SDL_Convert_U16LSB_to_F32LSB },
2286 { AUDIO_U16LSB, AUDIO_F32MSB, SDL_Convert_U16LSB_to_F32MSB },
2287 { AUDIO_S16LSB, AUDIO_U8, SDL_Convert_S16LSB_to_U8 },
2288 { AUDIO_S16LSB, AUDIO_S8, SDL_Convert_S16LSB_to_S8 },
2289 { AUDIO_S16LSB, AUDIO_U16LSB, SDL_Convert_S16LSB_to_U16LSB },
2290 { AUDIO_S16LSB, AUDIO_U16MSB, SDL_Convert_S16LSB_to_U16MSB },
2291 { AUDIO_S16LSB, AUDIO_S16MSB, SDL_Convert_S16LSB_to_S16MSB },
2292 { AUDIO_S16LSB, AUDIO_S32LSB, SDL_Convert_S16LSB_to_S32LSB },
2293 { AUDIO_S16LSB, AUDIO_S32MSB, SDL_Convert_S16LSB_to_S32MSB },
2294 { AUDIO_S16LSB, AUDIO_F32LSB, SDL_Convert_S16LSB_to_F32LSB },
2295 { AUDIO_S16LSB, AUDIO_F32MSB, SDL_Convert_S16LSB_to_F32MSB },
2296 { AUDIO_U16MSB, AUDIO_U8, SDL_Convert_U16MSB_to_U8 },
2297 { AUDIO_U16MSB, AUDIO_S8, SDL_Convert_U16MSB_to_S8 },
2298 { AUDIO_U16MSB, AUDIO_U16LSB, SDL_Convert_U16MSB_to_U16LSB },
2299 { AUDIO_U16MSB, AUDIO_S16LSB, SDL_Convert_U16MSB_to_S16LSB },
2300 { AUDIO_U16MSB, AUDIO_S16MSB, SDL_Convert_U16MSB_to_S16MSB },
2301 { AUDIO_U16MSB, AUDIO_S32LSB, SDL_Convert_U16MSB_to_S32LSB },
2302 { AUDIO_U16MSB, AUDIO_S32MSB, SDL_Convert_U16MSB_to_S32MSB },
2303 { AUDIO_U16MSB, AUDIO_F32LSB, SDL_Convert_U16MSB_to_F32LSB },
2304 { AUDIO_U16MSB, AUDIO_F32MSB, SDL_Convert_U16MSB_to_F32MSB },
2305 { AUDIO_S16MSB, AUDIO_U8, SDL_Convert_S16MSB_to_U8 },
2306 { AUDIO_S16MSB, AUDIO_S8, SDL_Convert_S16MSB_to_S8 },
2307 { AUDIO_S16MSB, AUDIO_U16LSB, SDL_Convert_S16MSB_to_U16LSB },
2308 { AUDIO_S16MSB, AUDIO_S16LSB, SDL_Convert_S16MSB_to_S16LSB },
2309 { AUDIO_S16MSB, AUDIO_U16MSB, SDL_Convert_S16MSB_to_U16MSB },
2310 { AUDIO_S16MSB, AUDIO_S32LSB, SDL_Convert_S16MSB_to_S32LSB },
2311 { AUDIO_S16MSB, AUDIO_S32MSB, SDL_Convert_S16MSB_to_S32MSB },
2312 { AUDIO_S16MSB, AUDIO_F32LSB, SDL_Convert_S16MSB_to_F32LSB },
2313 { AUDIO_S16MSB, AUDIO_F32MSB, SDL_Convert_S16MSB_to_F32MSB },
2314 { AUDIO_S32LSB, AUDIO_U8, SDL_Convert_S32LSB_to_U8 },
2315 { AUDIO_S32LSB, AUDIO_S8, SDL_Convert_S32LSB_to_S8 },
2316 { AUDIO_S32LSB, AUDIO_U16LSB, SDL_Convert_S32LSB_to_U16LSB },
2317 { AUDIO_S32LSB, AUDIO_S16LSB, SDL_Convert_S32LSB_to_S16LSB },
2318 { AUDIO_S32LSB, AUDIO_U16MSB, SDL_Convert_S32LSB_to_U16MSB },
2319 { AUDIO_S32LSB, AUDIO_S16MSB, SDL_Convert_S32LSB_to_S16MSB },
2320 { AUDIO_S32LSB, AUDIO_S32MSB, SDL_Convert_S32LSB_to_S32MSB },
2321 { AUDIO_S32LSB, AUDIO_F32LSB, SDL_Convert_S32LSB_to_F32LSB },
2322 { AUDIO_S32LSB, AUDIO_F32MSB, SDL_Convert_S32LSB_to_F32MSB },
2323 { AUDIO_S32MSB, AUDIO_U8, SDL_Convert_S32MSB_to_U8 },
2324 { AUDIO_S32MSB, AUDIO_S8, SDL_Convert_S32MSB_to_S8 },
2325 { AUDIO_S32MSB, AUDIO_U16LSB, SDL_Convert_S32MSB_to_U16LSB },
2326 { AUDIO_S32MSB, AUDIO_S16LSB, SDL_Convert_S32MSB_to_S16LSB },
2327 { AUDIO_S32MSB, AUDIO_U16MSB, SDL_Convert_S32MSB_to_U16MSB },
2328 { AUDIO_S32MSB, AUDIO_S16MSB, SDL_Convert_S32MSB_to_S16MSB },
2329 { AUDIO_S32MSB, AUDIO_S32LSB, SDL_Convert_S32MSB_to_S32LSB },
2330 { AUDIO_S32MSB, AUDIO_F32LSB, SDL_Convert_S32MSB_to_F32LSB },
2331 { AUDIO_S32MSB, AUDIO_F32MSB, SDL_Convert_S32MSB_to_F32MSB },
2332 { AUDIO_F32LSB, AUDIO_U8, SDL_Convert_F32LSB_to_U8 },
2333 { AUDIO_F32LSB, AUDIO_S8, SDL_Convert_F32LSB_to_S8 },
2334 { AUDIO_F32LSB, AUDIO_U16LSB, SDL_Convert_F32LSB_to_U16LSB },
2335 { AUDIO_F32LSB, AUDIO_S16LSB, SDL_Convert_F32LSB_to_S16LSB },
2336 { AUDIO_F32LSB, AUDIO_U16MSB, SDL_Convert_F32LSB_to_U16MSB },
2337 { AUDIO_F32LSB, AUDIO_S16MSB, SDL_Convert_F32LSB_to_S16MSB },
2338 { AUDIO_F32LSB, AUDIO_S32LSB, SDL_Convert_F32LSB_to_S32LSB },
2339 { AUDIO_F32LSB, AUDIO_S32MSB, SDL_Convert_F32LSB_to_S32MSB },
2340 { AUDIO_F32LSB, AUDIO_F32MSB, SDL_Convert_F32LSB_to_F32MSB },
2341 { AUDIO_F32MSB, AUDIO_U8, SDL_Convert_F32MSB_to_U8 },
2342 { AUDIO_F32MSB, AUDIO_S8, SDL_Convert_F32MSB_to_S8 },
2343 { AUDIO_F32MSB, AUDIO_U16LSB, SDL_Convert_F32MSB_to_U16LSB },
2344 { AUDIO_F32MSB, AUDIO_S16LSB, SDL_Convert_F32MSB_to_S16LSB },
2345 { AUDIO_F32MSB, AUDIO_U16MSB, SDL_Convert_F32MSB_to_U16MSB },
2346 { AUDIO_F32MSB, AUDIO_S16MSB, SDL_Convert_F32MSB_to_S16MSB },
2347 { AUDIO_F32MSB, AUDIO_S32LSB, SDL_Convert_F32MSB_to_S32LSB },
2348 { AUDIO_F32MSB, AUDIO_S32MSB, SDL_Convert_F32MSB_to_S32MSB },
2349 { AUDIO_F32MSB, AUDIO_F32LSB, SDL_Convert_F32MSB_to_F32LSB },
2355 /* vi: set ts=4 sw=4 expandtab: */