SDL: src/audio/SDL_audiotypecvt.c@3b4ce57c6215

     1 /* DO NOT EDIT THIS FILE! It is generated code. */

     2 /* Please modify SDL/src/audio/sdlgenaudiocvt.pl instead. */

     4 /*

     5     SDL - Simple DirectMedia Layer

     6     Copyright (C) 1997-2006 Sam Lantinga

     8     This library is free software; you can redistribute it and/or

     9     modify it under the terms of the GNU Lesser General Public

    10     License as published by the Free Software Foundation; either

    11     version 2.1 of the License, or (at your option) any later version.

    13     This library is distributed in the hope that it will be useful,

    14     but WITHOUT ANY WARRANTY; without even the implied warranty of

    15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    16     Lesser General Public License for more details.

    18     You should have received a copy of the GNU Lesser General Public

    19     License along with this library; if not, write to the Free Software

    20     Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    22     Sam Lantinga

    23     slouken@libsdl.org

    24 */

    26 #include "SDL_config.h"

    27 #include "SDL_audio.h"

    28 #include "SDL_audio_c.h"

    30 /* Now the generated code... */

    32 #define DIVBY127 0.0078740157480315f

    33 #define DIVBY255 0.00392156862745098f

    34 #define DIVBY32767 3.05185094759972e-05f

    35 #define DIVBY65535 1.52590218966964e-05f

    36 #define DIVBY2147483647 4.6566128752458e-10f

    38 static void SDLCALL

    39 SDL_Convert_U8_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)

    40 {

    41     int i;

    42     const Uint8 *src;

    43     Sint8 *dst;

    45 #ifdef DEBUG_CONVERT

    46     fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S8.\n");

    47 #endif

    49     src = (const Uint8 *) cvt->buf;

    50     dst = (Sint8 *) cvt->buf;

    51     for (i = cvt->len_cvt / sizeof (Uint8); i; --i, ++src, ++dst) {

    52         const Sint8 val = ((*src) ^ 0x80);

    53         *dst = ((Sint8) val);

    54     }

    56     format = AUDIO_S8;

    57     if (cvt->filters[++cvt->filter_index]) {

    58         cvt->filters[cvt->filter_index] (cvt, format);

    59     }

    60 }

    62 static void SDLCALL

    63 SDL_Convert_U8_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

    64 {

    65     int i;

    66     const Uint8 *src;

    67     Uint16 *dst;

    69 #ifdef DEBUG_CONVERT

    70     fprintf(stderr, "Converting AUDIO_U8 to AUDIO_U16LSB.\n");

    71 #endif

    73     src = (const Uint8 *) (cvt->buf + cvt->len_cvt);

    74     dst = (Uint16 *) (cvt->buf + cvt->len_cvt * 2);

    75     for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {

    76         const Uint16 val = (((Uint16) *src) << 8);

    77         *dst = SDL_SwapLE16(val);

    78     }

    80     cvt->len_cvt *= 2;

    81     format = AUDIO_U16LSB;

    82     if (cvt->filters[++cvt->filter_index]) {

    83         cvt->filters[cvt->filter_index] (cvt, format);

    84     }

    85 }

    87 static void SDLCALL

    88 SDL_Convert_U8_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

    89 {

    90     int i;

    91     const Uint8 *src;

    92     Sint16 *dst;

    94 #ifdef DEBUG_CONVERT

    95     fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S16LSB.\n");

    96 #endif

    98     src = (const Uint8 *) (cvt->buf + cvt->len_cvt);

    99     dst = (Sint16 *) (cvt->buf + cvt->len_cvt * 2);

   100     for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {

   101         const Sint16 val = (((Sint16) ((*src) ^ 0x80)) << 8);

   102         *dst = ((Sint16) SDL_SwapLE16(val));

   103     }

   105     cvt->len_cvt *= 2;

   106     format = AUDIO_S16LSB;

   107     if (cvt->filters[++cvt->filter_index]) {

   108         cvt->filters[cvt->filter_index] (cvt, format);

   109     }

   110 }

   112 static void SDLCALL

   113 SDL_Convert_U8_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   114 {

   115     int i;

   116     const Uint8 *src;

   117     Uint16 *dst;

   119 #ifdef DEBUG_CONVERT

   120     fprintf(stderr, "Converting AUDIO_U8 to AUDIO_U16MSB.\n");

   121 #endif

   123     src = (const Uint8 *) (cvt->buf + cvt->len_cvt);

   124     dst = (Uint16 *) (cvt->buf + cvt->len_cvt * 2);

   125     for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {

   126         const Uint16 val = (((Uint16) *src) << 8);

   127         *dst = SDL_SwapBE16(val);

   128     }

   130     cvt->len_cvt *= 2;

   131     format = AUDIO_U16MSB;

   132     if (cvt->filters[++cvt->filter_index]) {

   133         cvt->filters[cvt->filter_index] (cvt, format);

   134     }

   135 }

   137 static void SDLCALL

   138 SDL_Convert_U8_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   139 {

   140     int i;

   141     const Uint8 *src;

   142     Sint16 *dst;

   144 #ifdef DEBUG_CONVERT

   145     fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S16MSB.\n");

   146 #endif

   148     src = (const Uint8 *) (cvt->buf + cvt->len_cvt);

   149     dst = (Sint16 *) (cvt->buf + cvt->len_cvt * 2);

   150     for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {

   151         const Sint16 val = (((Sint16) ((*src) ^ 0x80)) << 8);

   152         *dst = ((Sint16) SDL_SwapBE16(val));

   153     }

   155     cvt->len_cvt *= 2;

   156     format = AUDIO_S16MSB;

   157     if (cvt->filters[++cvt->filter_index]) {

   158         cvt->filters[cvt->filter_index] (cvt, format);

   159     }

   160 }

   162 static void SDLCALL

   163 SDL_Convert_U8_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   164 {

   165     int i;

   166     const Uint8 *src;

   167     Sint32 *dst;

   169 #ifdef DEBUG_CONVERT

   170     fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S32LSB.\n");

   171 #endif

   173     src = (const Uint8 *) (cvt->buf + cvt->len_cvt);

   174     dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 4);

   175     for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {

   176         const Sint32 val = (((Sint32) ((*src) ^ 0x80)) << 24);

   177         *dst = ((Sint32) SDL_SwapLE32(val));

   178     }

   180     cvt->len_cvt *= 4;

   181     format = AUDIO_S32LSB;

   182     if (cvt->filters[++cvt->filter_index]) {

   183         cvt->filters[cvt->filter_index] (cvt, format);

   184     }

   185 }

   187 static void SDLCALL

   188 SDL_Convert_U8_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   189 {

   190     int i;

   191     const Uint8 *src;

   192     Sint32 *dst;

   194 #ifdef DEBUG_CONVERT

   195     fprintf(stderr, "Converting AUDIO_U8 to AUDIO_S32MSB.\n");

   196 #endif

   198     src = (const Uint8 *) (cvt->buf + cvt->len_cvt);

   199     dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 4);

   200     for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {

   201         const Sint32 val = (((Sint32) ((*src) ^ 0x80)) << 24);

   202         *dst = ((Sint32) SDL_SwapBE32(val));

   203     }

   205     cvt->len_cvt *= 4;

   206     format = AUDIO_S32MSB;

   207     if (cvt->filters[++cvt->filter_index]) {

   208         cvt->filters[cvt->filter_index] (cvt, format);

   209     }

   210 }

   212 static void SDLCALL

   213 SDL_Convert_U8_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   214 {

   215     int i;

   216     const Uint8 *src;

   217     float *dst;

   219 #ifdef DEBUG_CONVERT

   220     fprintf(stderr, "Converting AUDIO_U8 to AUDIO_F32LSB.\n");

   221 #endif

   223     src = (const Uint8 *) (cvt->buf + cvt->len_cvt);

   224     dst = (float *) (cvt->buf + cvt->len_cvt * 4);

   225     for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {

   226         const float val = (((float) *src) * DIVBY255);

   227         *dst = SDL_SwapFloatLE(val);

   228     }

   230     cvt->len_cvt *= 4;

   231     format = AUDIO_F32LSB;

   232     if (cvt->filters[++cvt->filter_index]) {

   233         cvt->filters[cvt->filter_index] (cvt, format);

   234     }

   235 }

   237 static void SDLCALL

   238 SDL_Convert_U8_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   239 {

   240     int i;

   241     const Uint8 *src;

   242     float *dst;

   244 #ifdef DEBUG_CONVERT

   245     fprintf(stderr, "Converting AUDIO_U8 to AUDIO_F32MSB.\n");

   246 #endif

   248     src = (const Uint8 *) (cvt->buf + cvt->len_cvt);

   249     dst = (float *) (cvt->buf + cvt->len_cvt * 4);

   250     for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {

   251         const float val = (((float) *src) * DIVBY255);

   252         *dst = SDL_SwapFloatBE(val);

   253     }

   255     cvt->len_cvt *= 4;

   256     format = AUDIO_F32MSB;

   257     if (cvt->filters[++cvt->filter_index]) {

   258         cvt->filters[cvt->filter_index] (cvt, format);

   259     }

   260 }

   262 static void SDLCALL

   263 SDL_Convert_S8_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   264 {

   265     int i;

   266     const Uint8 *src;

   267     Uint8 *dst;

   269 #ifdef DEBUG_CONVERT

   270     fprintf(stderr, "Converting AUDIO_S8 to AUDIO_U8.\n");

   271 #endif

   273     src = (const Uint8 *) cvt->buf;

   274     dst = (Uint8 *) cvt->buf;

   275     for (i = cvt->len_cvt / sizeof (Uint8); i; --i, ++src, ++dst) {

   276         const Uint8 val = ((((Sint8) *src)) ^ 0x80);

   277         *dst = val;

   278     }

   280     format = AUDIO_U8;

   281     if (cvt->filters[++cvt->filter_index]) {

   282         cvt->filters[cvt->filter_index] (cvt, format);

   283     }

   284 }

   286 static void SDLCALL

   287 SDL_Convert_S8_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   288 {

   289     int i;

   290     const Uint8 *src;

   291     Uint16 *dst;

   293 #ifdef DEBUG_CONVERT

   294     fprintf(stderr, "Converting AUDIO_S8 to AUDIO_U16LSB.\n");

   295 #endif

   297     src = (const Uint8 *) (cvt->buf + cvt->len_cvt);

   298     dst = (Uint16 *) (cvt->buf + cvt->len_cvt * 2);

   299     for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {

   300         const Uint16 val = (((Uint16) ((((Sint8) *src)) ^ 0x80)) << 8);

   301         *dst = SDL_SwapLE16(val);

   302     }

   304     cvt->len_cvt *= 2;

   305     format = AUDIO_U16LSB;

   306     if (cvt->filters[++cvt->filter_index]) {

   307         cvt->filters[cvt->filter_index] (cvt, format);

   308     }

   309 }

   311 static void SDLCALL

   312 SDL_Convert_S8_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   313 {

   314     int i;

   315     const Uint8 *src;

   316     Sint16 *dst;

   318 #ifdef DEBUG_CONVERT

   319     fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S16LSB.\n");

   320 #endif

   322     src = (const Uint8 *) (cvt->buf + cvt->len_cvt);

   323     dst = (Sint16 *) (cvt->buf + cvt->len_cvt * 2);

   324     for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {

   325         const Sint16 val = (((Sint16) ((Sint8) *src)) << 8);

   326         *dst = ((Sint16) SDL_SwapLE16(val));

   327     }

   329     cvt->len_cvt *= 2;

   330     format = AUDIO_S16LSB;

   331     if (cvt->filters[++cvt->filter_index]) {

   332         cvt->filters[cvt->filter_index] (cvt, format);

   333     }

   334 }

   336 static void SDLCALL

   337 SDL_Convert_S8_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   338 {

   339     int i;

   340     const Uint8 *src;

   341     Uint16 *dst;

   343 #ifdef DEBUG_CONVERT

   344     fprintf(stderr, "Converting AUDIO_S8 to AUDIO_U16MSB.\n");

   345 #endif

   347     src = (const Uint8 *) (cvt->buf + cvt->len_cvt);

   348     dst = (Uint16 *) (cvt->buf + cvt->len_cvt * 2);

   349     for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {

   350         const Uint16 val = (((Uint16) ((((Sint8) *src)) ^ 0x80)) << 8);

   351         *dst = SDL_SwapBE16(val);

   352     }

   354     cvt->len_cvt *= 2;

   355     format = AUDIO_U16MSB;

   356     if (cvt->filters[++cvt->filter_index]) {

   357         cvt->filters[cvt->filter_index] (cvt, format);

   358     }

   359 }

   361 static void SDLCALL

   362 SDL_Convert_S8_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   363 {

   364     int i;

   365     const Uint8 *src;

   366     Sint16 *dst;

   368 #ifdef DEBUG_CONVERT

   369     fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S16MSB.\n");

   370 #endif

   372     src = (const Uint8 *) (cvt->buf + cvt->len_cvt);

   373     dst = (Sint16 *) (cvt->buf + cvt->len_cvt * 2);

   374     for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {

   375         const Sint16 val = (((Sint16) ((Sint8) *src)) << 8);

   376         *dst = ((Sint16) SDL_SwapBE16(val));

   377     }

   379     cvt->len_cvt *= 2;

   380     format = AUDIO_S16MSB;

   381     if (cvt->filters[++cvt->filter_index]) {

   382         cvt->filters[cvt->filter_index] (cvt, format);

   383     }

   384 }

   386 static void SDLCALL

   387 SDL_Convert_S8_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   388 {

   389     int i;

   390     const Uint8 *src;

   391     Sint32 *dst;

   393 #ifdef DEBUG_CONVERT

   394     fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S32LSB.\n");

   395 #endif

   397     src = (const Uint8 *) (cvt->buf + cvt->len_cvt);

   398     dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 4);

   399     for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {

   400         const Sint32 val = (((Sint32) ((Sint8) *src)) << 24);

   401         *dst = ((Sint32) SDL_SwapLE32(val));

   402     }

   404     cvt->len_cvt *= 4;

   405     format = AUDIO_S32LSB;

   406     if (cvt->filters[++cvt->filter_index]) {

   407         cvt->filters[cvt->filter_index] (cvt, format);

   408     }

   409 }

   411 static void SDLCALL

   412 SDL_Convert_S8_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   413 {

   414     int i;

   415     const Uint8 *src;

   416     Sint32 *dst;

   418 #ifdef DEBUG_CONVERT

   419     fprintf(stderr, "Converting AUDIO_S8 to AUDIO_S32MSB.\n");

   420 #endif

   422     src = (const Uint8 *) (cvt->buf + cvt->len_cvt);

   423     dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 4);

   424     for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {

   425         const Sint32 val = (((Sint32) ((Sint8) *src)) << 24);

   426         *dst = ((Sint32) SDL_SwapBE32(val));

   427     }

   429     cvt->len_cvt *= 4;

   430     format = AUDIO_S32MSB;

   431     if (cvt->filters[++cvt->filter_index]) {

   432         cvt->filters[cvt->filter_index] (cvt, format);

   433     }

   434 }

   436 static void SDLCALL

   437 SDL_Convert_S8_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   438 {

   439     int i;

   440     const Uint8 *src;

   441     float *dst;

   443 #ifdef DEBUG_CONVERT

   444     fprintf(stderr, "Converting AUDIO_S8 to AUDIO_F32LSB.\n");

   445 #endif

   447     src = (const Uint8 *) (cvt->buf + cvt->len_cvt);

   448     dst = (float *) (cvt->buf + cvt->len_cvt * 4);

   449     for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {

   450         const float val = (((float) ((Sint8) *src)) * DIVBY127);

   451         *dst = SDL_SwapFloatLE(val);

   452     }

   454     cvt->len_cvt *= 4;

   455     format = AUDIO_F32LSB;

   456     if (cvt->filters[++cvt->filter_index]) {

   457         cvt->filters[cvt->filter_index] (cvt, format);

   458     }

   459 }

   461 static void SDLCALL

   462 SDL_Convert_S8_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   463 {

   464     int i;

   465     const Uint8 *src;

   466     float *dst;

   468 #ifdef DEBUG_CONVERT

   469     fprintf(stderr, "Converting AUDIO_S8 to AUDIO_F32MSB.\n");

   470 #endif

   472     src = (const Uint8 *) (cvt->buf + cvt->len_cvt);

   473     dst = (float *) (cvt->buf + cvt->len_cvt * 4);

   474     for (i = cvt->len_cvt / sizeof (Uint8); i; --i, --src, --dst) {

   475         const float val = (((float) ((Sint8) *src)) * DIVBY127);

   476         *dst = SDL_SwapFloatBE(val);

   477     }

   479     cvt->len_cvt *= 4;

   480     format = AUDIO_F32MSB;

   481     if (cvt->filters[++cvt->filter_index]) {

   482         cvt->filters[cvt->filter_index] (cvt, format);

   483     }

   484 }

   486 static void SDLCALL

   487 SDL_Convert_U16LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   488 {

   489     int i;

   490     const Uint16 *src;

   491     Uint8 *dst;

   493 #ifdef DEBUG_CONVERT

   494     fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_U8.\n");

   495 #endif

   497     src = (const Uint16 *) cvt->buf;

   498     dst = (Uint8 *) cvt->buf;

   499     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

   500         const Uint8 val = ((Uint8) (SDL_SwapLE16(*src) >> 8));

   501         *dst = val;

   502     }

   504     cvt->len_cvt /= 2;

   505     format = AUDIO_U8;

   506     if (cvt->filters[++cvt->filter_index]) {

   507         cvt->filters[cvt->filter_index] (cvt, format);

   508     }

   509 }

   511 static void SDLCALL

   512 SDL_Convert_U16LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   513 {

   514     int i;

   515     const Uint16 *src;

   516     Sint8 *dst;

   518 #ifdef DEBUG_CONVERT

   519     fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S8.\n");

   520 #endif

   522     src = (const Uint16 *) cvt->buf;

   523     dst = (Sint8 *) cvt->buf;

   524     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

   525         const Sint8 val = ((Sint8) (((SDL_SwapLE16(*src)) ^ 0x8000) >> 8));

   526         *dst = ((Sint8) val);

   527     }

   529     cvt->len_cvt /= 2;

   530     format = AUDIO_S8;

   531     if (cvt->filters[++cvt->filter_index]) {

   532         cvt->filters[cvt->filter_index] (cvt, format);

   533     }

   534 }

   536 static void SDLCALL

   537 SDL_Convert_U16LSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   538 {

   539     int i;

   540     const Uint16 *src;

   541     Sint16 *dst;

   543 #ifdef DEBUG_CONVERT

   544     fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S16LSB.\n");

   545 #endif

   547     src = (const Uint16 *) cvt->buf;

   548     dst = (Sint16 *) cvt->buf;

   549     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

   550         const Sint16 val = ((SDL_SwapLE16(*src)) ^ 0x8000);

   551         *dst = ((Sint16) SDL_SwapLE16(val));

   552     }

   554     format = AUDIO_S16LSB;

   555     if (cvt->filters[++cvt->filter_index]) {

   556         cvt->filters[cvt->filter_index] (cvt, format);

   557     }

   558 }

   560 static void SDLCALL

   561 SDL_Convert_U16LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   562 {

   563     int i;

   564     const Uint16 *src;

   565     Uint16 *dst;

   567 #ifdef DEBUG_CONVERT

   568     fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_U16MSB.\n");

   569 #endif

   571     src = (const Uint16 *) cvt->buf;

   572     dst = (Uint16 *) cvt->buf;

   573     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

   574         const Uint16 val = SDL_SwapLE16(*src);

   575         *dst = SDL_SwapBE16(val);

   576     }

   578     format = AUDIO_U16MSB;

   579     if (cvt->filters[++cvt->filter_index]) {

   580         cvt->filters[cvt->filter_index] (cvt, format);

   581     }

   582 }

   584 static void SDLCALL

   585 SDL_Convert_U16LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   586 {

   587     int i;

   588     const Uint16 *src;

   589     Sint16 *dst;

   591 #ifdef DEBUG_CONVERT

   592     fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S16MSB.\n");

   593 #endif

   595     src = (const Uint16 *) cvt->buf;

   596     dst = (Sint16 *) cvt->buf;

   597     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

   598         const Sint16 val = ((SDL_SwapLE16(*src)) ^ 0x8000);

   599         *dst = ((Sint16) SDL_SwapBE16(val));

   600     }

   602     format = AUDIO_S16MSB;

   603     if (cvt->filters[++cvt->filter_index]) {

   604         cvt->filters[cvt->filter_index] (cvt, format);

   605     }

   606 }

   608 static void SDLCALL

   609 SDL_Convert_U16LSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   610 {

   611     int i;

   612     const Uint16 *src;

   613     Sint32 *dst;

   615 #ifdef DEBUG_CONVERT

   616     fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S32LSB.\n");

   617 #endif

   619     src = (const Uint16 *) (cvt->buf + cvt->len_cvt);

   620     dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);

   621     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {

   622         const Sint32 val = (((Sint32) ((SDL_SwapLE16(*src)) ^ 0x8000)) << 16);

   623         *dst = ((Sint32) SDL_SwapLE32(val));

   624     }

   626     cvt->len_cvt *= 2;

   627     format = AUDIO_S32LSB;

   628     if (cvt->filters[++cvt->filter_index]) {

   629         cvt->filters[cvt->filter_index] (cvt, format);

   630     }

   631 }

   633 static void SDLCALL

   634 SDL_Convert_U16LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   635 {

   636     int i;

   637     const Uint16 *src;

   638     Sint32 *dst;

   640 #ifdef DEBUG_CONVERT

   641     fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_S32MSB.\n");

   642 #endif

   644     src = (const Uint16 *) (cvt->buf + cvt->len_cvt);

   645     dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);

   646     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {

   647         const Sint32 val = (((Sint32) ((SDL_SwapLE16(*src)) ^ 0x8000)) << 16);

   648         *dst = ((Sint32) SDL_SwapBE32(val));

   649     }

   651     cvt->len_cvt *= 2;

   652     format = AUDIO_S32MSB;

   653     if (cvt->filters[++cvt->filter_index]) {

   654         cvt->filters[cvt->filter_index] (cvt, format);

   655     }

   656 }

   658 static void SDLCALL

   659 SDL_Convert_U16LSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   660 {

   661     int i;

   662     const Uint16 *src;

   663     float *dst;

   665 #ifdef DEBUG_CONVERT

   666     fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_F32LSB.\n");

   667 #endif

   669     src = (const Uint16 *) (cvt->buf + cvt->len_cvt);

   670     dst = (float *) (cvt->buf + cvt->len_cvt * 2);

   671     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {

   672         const float val = (((float) SDL_SwapLE16(*src)) * DIVBY65535);

   673         *dst = SDL_SwapFloatLE(val);

   674     }

   676     cvt->len_cvt *= 2;

   677     format = AUDIO_F32LSB;

   678     if (cvt->filters[++cvt->filter_index]) {

   679         cvt->filters[cvt->filter_index] (cvt, format);

   680     }

   681 }

   683 static void SDLCALL

   684 SDL_Convert_U16LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   685 {

   686     int i;

   687     const Uint16 *src;

   688     float *dst;

   690 #ifdef DEBUG_CONVERT

   691     fprintf(stderr, "Converting AUDIO_U16LSB to AUDIO_F32MSB.\n");

   692 #endif

   694     src = (const Uint16 *) (cvt->buf + cvt->len_cvt);

   695     dst = (float *) (cvt->buf + cvt->len_cvt * 2);

   696     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {

   697         const float val = (((float) SDL_SwapLE16(*src)) * DIVBY65535);

   698         *dst = SDL_SwapFloatBE(val);

   699     }

   701     cvt->len_cvt *= 2;

   702     format = AUDIO_F32MSB;

   703     if (cvt->filters[++cvt->filter_index]) {

   704         cvt->filters[cvt->filter_index] (cvt, format);

   705     }

   706 }

   708 static void SDLCALL

   709 SDL_Convert_S16LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   710 {

   711     int i;

   712     const Uint16 *src;

   713     Uint8 *dst;

   715 #ifdef DEBUG_CONVERT

   716     fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_U8.\n");

   717 #endif

   719     src = (const Uint16 *) cvt->buf;

   720     dst = (Uint8 *) cvt->buf;

   721     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

   722         const Uint8 val = ((Uint8) (((((Sint16) SDL_SwapLE16(*src))) ^ 0x8000) >> 8));

   723         *dst = val;

   724     }

   726     cvt->len_cvt /= 2;

   727     format = AUDIO_U8;

   728     if (cvt->filters[++cvt->filter_index]) {

   729         cvt->filters[cvt->filter_index] (cvt, format);

   730     }

   731 }

   733 static void SDLCALL

   734 SDL_Convert_S16LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   735 {

   736     int i;

   737     const Uint16 *src;

   738     Sint8 *dst;

   740 #ifdef DEBUG_CONVERT

   741     fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S8.\n");

   742 #endif

   744     src = (const Uint16 *) cvt->buf;

   745     dst = (Sint8 *) cvt->buf;

   746     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

   747         const Sint8 val = ((Sint8) (((Sint16) SDL_SwapLE16(*src)) >> 8));

   748         *dst = ((Sint8) val);

   749     }

   751     cvt->len_cvt /= 2;

   752     format = AUDIO_S8;

   753     if (cvt->filters[++cvt->filter_index]) {

   754         cvt->filters[cvt->filter_index] (cvt, format);

   755     }

   756 }

   758 static void SDLCALL

   759 SDL_Convert_S16LSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   760 {

   761     int i;

   762     const Uint16 *src;

   763     Uint16 *dst;

   765 #ifdef DEBUG_CONVERT

   766     fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_U16LSB.\n");

   767 #endif

   769     src = (const Uint16 *) cvt->buf;

   770     dst = (Uint16 *) cvt->buf;

   771     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

   772         const Uint16 val = ((((Sint16) SDL_SwapLE16(*src))) ^ 0x8000);

   773         *dst = SDL_SwapLE16(val);

   774     }

   776     format = AUDIO_U16LSB;

   777     if (cvt->filters[++cvt->filter_index]) {

   778         cvt->filters[cvt->filter_index] (cvt, format);

   779     }

   780 }

   782 static void SDLCALL

   783 SDL_Convert_S16LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   784 {

   785     int i;

   786     const Uint16 *src;

   787     Uint16 *dst;

   789 #ifdef DEBUG_CONVERT

   790     fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_U16MSB.\n");

   791 #endif

   793     src = (const Uint16 *) cvt->buf;

   794     dst = (Uint16 *) cvt->buf;

   795     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

   796         const Uint16 val = ((((Sint16) SDL_SwapLE16(*src))) ^ 0x8000);

   797         *dst = SDL_SwapBE16(val);

   798     }

   800     format = AUDIO_U16MSB;

   801     if (cvt->filters[++cvt->filter_index]) {

   802         cvt->filters[cvt->filter_index] (cvt, format);

   803     }

   804 }

   806 static void SDLCALL

   807 SDL_Convert_S16LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   808 {

   809     int i;

   810     const Uint16 *src;

   811     Sint16 *dst;

   813 #ifdef DEBUG_CONVERT

   814     fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S16MSB.\n");

   815 #endif

   817     src = (const Uint16 *) cvt->buf;

   818     dst = (Sint16 *) cvt->buf;

   819     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

   820         const Sint16 val = ((Sint16) SDL_SwapLE16(*src));

   821         *dst = ((Sint16) SDL_SwapBE16(val));

   822     }

   824     format = AUDIO_S16MSB;

   825     if (cvt->filters[++cvt->filter_index]) {

   826         cvt->filters[cvt->filter_index] (cvt, format);

   827     }

   828 }

   830 static void SDLCALL

   831 SDL_Convert_S16LSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   832 {

   833     int i;

   834     const Uint16 *src;

   835     Sint32 *dst;

   837 #ifdef DEBUG_CONVERT

   838     fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S32LSB.\n");

   839 #endif

   841     src = (const Uint16 *) (cvt->buf + cvt->len_cvt);

   842     dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);

   843     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {

   844         const Sint32 val = (((Sint32) ((Sint16) SDL_SwapLE16(*src))) << 16);

   845         *dst = ((Sint32) SDL_SwapLE32(val));

   846     }

   848     cvt->len_cvt *= 2;

   849     format = AUDIO_S32LSB;

   850     if (cvt->filters[++cvt->filter_index]) {

   851         cvt->filters[cvt->filter_index] (cvt, format);

   852     }

   853 }

   855 static void SDLCALL

   856 SDL_Convert_S16LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   857 {

   858     int i;

   859     const Uint16 *src;

   860     Sint32 *dst;

   862 #ifdef DEBUG_CONVERT

   863     fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_S32MSB.\n");

   864 #endif

   866     src = (const Uint16 *) (cvt->buf + cvt->len_cvt);

   867     dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);

   868     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {

   869         const Sint32 val = (((Sint32) ((Sint16) SDL_SwapLE16(*src))) << 16);

   870         *dst = ((Sint32) SDL_SwapBE32(val));

   871     }

   873     cvt->len_cvt *= 2;

   874     format = AUDIO_S32MSB;

   875     if (cvt->filters[++cvt->filter_index]) {

   876         cvt->filters[cvt->filter_index] (cvt, format);

   877     }

   878 }

   880 static void SDLCALL

   881 SDL_Convert_S16LSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   882 {

   883     int i;

   884     const Uint16 *src;

   885     float *dst;

   887 #ifdef DEBUG_CONVERT

   888     fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_F32LSB.\n");

   889 #endif

   891     src = (const Uint16 *) (cvt->buf + cvt->len_cvt);

   892     dst = (float *) (cvt->buf + cvt->len_cvt * 2);

   893     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {

   894         const float val = (((float) ((Sint16) SDL_SwapLE16(*src))) * DIVBY32767);

   895         *dst = SDL_SwapFloatLE(val);

   896     }

   898     cvt->len_cvt *= 2;

   899     format = AUDIO_F32LSB;

   900     if (cvt->filters[++cvt->filter_index]) {

   901         cvt->filters[cvt->filter_index] (cvt, format);

   902     }

   903 }

   905 static void SDLCALL

   906 SDL_Convert_S16LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   907 {

   908     int i;

   909     const Uint16 *src;

   910     float *dst;

   912 #ifdef DEBUG_CONVERT

   913     fprintf(stderr, "Converting AUDIO_S16LSB to AUDIO_F32MSB.\n");

   914 #endif

   916     src = (const Uint16 *) (cvt->buf + cvt->len_cvt);

   917     dst = (float *) (cvt->buf + cvt->len_cvt * 2);

   918     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {

   919         const float val = (((float) ((Sint16) SDL_SwapLE16(*src))) * DIVBY32767);

   920         *dst = SDL_SwapFloatBE(val);

   921     }

   923     cvt->len_cvt *= 2;

   924     format = AUDIO_F32MSB;

   925     if (cvt->filters[++cvt->filter_index]) {

   926         cvt->filters[cvt->filter_index] (cvt, format);

   927     }

   928 }

   930 static void SDLCALL

   931 SDL_Convert_U16MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   932 {

   933     int i;

   934     const Uint16 *src;

   935     Uint8 *dst;

   937 #ifdef DEBUG_CONVERT

   938     fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_U8.\n");

   939 #endif

   941     src = (const Uint16 *) cvt->buf;

   942     dst = (Uint8 *) cvt->buf;

   943     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

   944         const Uint8 val = ((Uint8) (SDL_SwapBE16(*src) >> 8));

   945         *dst = val;

   946     }

   948     cvt->len_cvt /= 2;

   949     format = AUDIO_U8;

   950     if (cvt->filters[++cvt->filter_index]) {

   951         cvt->filters[cvt->filter_index] (cvt, format);

   952     }

   953 }

   955 static void SDLCALL

   956 SDL_Convert_U16MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   957 {

   958     int i;

   959     const Uint16 *src;

   960     Sint8 *dst;

   962 #ifdef DEBUG_CONVERT

   963     fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S8.\n");

   964 #endif

   966     src = (const Uint16 *) cvt->buf;

   967     dst = (Sint8 *) cvt->buf;

   968     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

   969         const Sint8 val = ((Sint8) (((SDL_SwapBE16(*src)) ^ 0x8000) >> 8));

   970         *dst = ((Sint8) val);

   971     }

   973     cvt->len_cvt /= 2;

   974     format = AUDIO_S8;

   975     if (cvt->filters[++cvt->filter_index]) {

   976         cvt->filters[cvt->filter_index] (cvt, format);

   977     }

   978 }

   980 static void SDLCALL

   981 SDL_Convert_U16MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

   982 {

   983     int i;

   984     const Uint16 *src;

   985     Uint16 *dst;

   987 #ifdef DEBUG_CONVERT

   988     fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_U16LSB.\n");

   989 #endif

   991     src = (const Uint16 *) cvt->buf;

   992     dst = (Uint16 *) cvt->buf;

   993     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

   994         const Uint16 val = SDL_SwapBE16(*src);

   995         *dst = SDL_SwapLE16(val);

   996     }

   998     format = AUDIO_U16LSB;

   999     if (cvt->filters[++cvt->filter_index]) {

  1000         cvt->filters[cvt->filter_index] (cvt, format);

  1001     }

  1002 }

  1004 static void SDLCALL

  1005 SDL_Convert_U16MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1006 {

  1007     int i;

  1008     const Uint16 *src;

  1009     Sint16 *dst;

  1011 #ifdef DEBUG_CONVERT

  1012     fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S16LSB.\n");

  1013 #endif

  1015     src = (const Uint16 *) cvt->buf;

  1016     dst = (Sint16 *) cvt->buf;

  1017     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

  1018         const Sint16 val = ((SDL_SwapBE16(*src)) ^ 0x8000);

  1019         *dst = ((Sint16) SDL_SwapLE16(val));

  1020     }

  1022     format = AUDIO_S16LSB;

  1023     if (cvt->filters[++cvt->filter_index]) {

  1024         cvt->filters[cvt->filter_index] (cvt, format);

  1025     }

  1026 }

  1028 static void SDLCALL

  1029 SDL_Convert_U16MSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1030 {

  1031     int i;

  1032     const Uint16 *src;

  1033     Sint16 *dst;

  1035 #ifdef DEBUG_CONVERT

  1036     fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S16MSB.\n");

  1037 #endif

  1039     src = (const Uint16 *) cvt->buf;

  1040     dst = (Sint16 *) cvt->buf;

  1041     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

  1042         const Sint16 val = ((SDL_SwapBE16(*src)) ^ 0x8000);

  1043         *dst = ((Sint16) SDL_SwapBE16(val));

  1044     }

  1046     format = AUDIO_S16MSB;

  1047     if (cvt->filters[++cvt->filter_index]) {

  1048         cvt->filters[cvt->filter_index] (cvt, format);

  1049     }

  1050 }

  1052 static void SDLCALL

  1053 SDL_Convert_U16MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1054 {

  1055     int i;

  1056     const Uint16 *src;

  1057     Sint32 *dst;

  1059 #ifdef DEBUG_CONVERT

  1060     fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S32LSB.\n");

  1061 #endif

  1063     src = (const Uint16 *) (cvt->buf + cvt->len_cvt);

  1064     dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);

  1065     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {

  1066         const Sint32 val = (((Sint32) ((SDL_SwapBE16(*src)) ^ 0x8000)) << 16);

  1067         *dst = ((Sint32) SDL_SwapLE32(val));

  1068     }

  1070     cvt->len_cvt *= 2;

  1071     format = AUDIO_S32LSB;

  1072     if (cvt->filters[++cvt->filter_index]) {

  1073         cvt->filters[cvt->filter_index] (cvt, format);

  1074     }

  1075 }

  1077 static void SDLCALL

  1078 SDL_Convert_U16MSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1079 {

  1080     int i;

  1081     const Uint16 *src;

  1082     Sint32 *dst;

  1084 #ifdef DEBUG_CONVERT

  1085     fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_S32MSB.\n");

  1086 #endif

  1088     src = (const Uint16 *) (cvt->buf + cvt->len_cvt);

  1089     dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);

  1090     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {

  1091         const Sint32 val = (((Sint32) ((SDL_SwapBE16(*src)) ^ 0x8000)) << 16);

  1092         *dst = ((Sint32) SDL_SwapBE32(val));

  1093     }

  1095     cvt->len_cvt *= 2;

  1096     format = AUDIO_S32MSB;

  1097     if (cvt->filters[++cvt->filter_index]) {

  1098         cvt->filters[cvt->filter_index] (cvt, format);

  1099     }

  1100 }

  1102 static void SDLCALL

  1103 SDL_Convert_U16MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1104 {

  1105     int i;

  1106     const Uint16 *src;

  1107     float *dst;

  1109 #ifdef DEBUG_CONVERT

  1110     fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_F32LSB.\n");

  1111 #endif

  1113     src = (const Uint16 *) (cvt->buf + cvt->len_cvt);

  1114     dst = (float *) (cvt->buf + cvt->len_cvt * 2);

  1115     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {

  1116         const float val = (((float) SDL_SwapBE16(*src)) * DIVBY65535);

  1117         *dst = SDL_SwapFloatLE(val);

  1118     }

  1120     cvt->len_cvt *= 2;

  1121     format = AUDIO_F32LSB;

  1122     if (cvt->filters[++cvt->filter_index]) {

  1123         cvt->filters[cvt->filter_index] (cvt, format);

  1124     }

  1125 }

  1127 static void SDLCALL

  1128 SDL_Convert_U16MSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1129 {

  1130     int i;

  1131     const Uint16 *src;

  1132     float *dst;

  1134 #ifdef DEBUG_CONVERT

  1135     fprintf(stderr, "Converting AUDIO_U16MSB to AUDIO_F32MSB.\n");

  1136 #endif

  1138     src = (const Uint16 *) (cvt->buf + cvt->len_cvt);

  1139     dst = (float *) (cvt->buf + cvt->len_cvt * 2);

  1140     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {

  1141         const float val = (((float) SDL_SwapBE16(*src)) * DIVBY65535);

  1142         *dst = SDL_SwapFloatBE(val);

  1143     }

  1145     cvt->len_cvt *= 2;

  1146     format = AUDIO_F32MSB;

  1147     if (cvt->filters[++cvt->filter_index]) {

  1148         cvt->filters[cvt->filter_index] (cvt, format);

  1149     }

  1150 }

  1152 static void SDLCALL

  1153 SDL_Convert_S16MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1154 {

  1155     int i;

  1156     const Uint16 *src;

  1157     Uint8 *dst;

  1159 #ifdef DEBUG_CONVERT

  1160     fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_U8.\n");

  1161 #endif

  1163     src = (const Uint16 *) cvt->buf;

  1164     dst = (Uint8 *) cvt->buf;

  1165     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

  1166         const Uint8 val = ((Uint8) (((((Sint16) SDL_SwapBE16(*src))) ^ 0x8000) >> 8));

  1167         *dst = val;

  1168     }

  1170     cvt->len_cvt /= 2;

  1171     format = AUDIO_U8;

  1172     if (cvt->filters[++cvt->filter_index]) {

  1173         cvt->filters[cvt->filter_index] (cvt, format);

  1174     }

  1175 }

  1177 static void SDLCALL

  1178 SDL_Convert_S16MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1179 {

  1180     int i;

  1181     const Uint16 *src;

  1182     Sint8 *dst;

  1184 #ifdef DEBUG_CONVERT

  1185     fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S8.\n");

  1186 #endif

  1188     src = (const Uint16 *) cvt->buf;

  1189     dst = (Sint8 *) cvt->buf;

  1190     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

  1191         const Sint8 val = ((Sint8) (((Sint16) SDL_SwapBE16(*src)) >> 8));

  1192         *dst = ((Sint8) val);

  1193     }

  1195     cvt->len_cvt /= 2;

  1196     format = AUDIO_S8;

  1197     if (cvt->filters[++cvt->filter_index]) {

  1198         cvt->filters[cvt->filter_index] (cvt, format);

  1199     }

  1200 }

  1202 static void SDLCALL

  1203 SDL_Convert_S16MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1204 {

  1205     int i;

  1206     const Uint16 *src;

  1207     Uint16 *dst;

  1209 #ifdef DEBUG_CONVERT

  1210     fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_U16LSB.\n");

  1211 #endif

  1213     src = (const Uint16 *) cvt->buf;

  1214     dst = (Uint16 *) cvt->buf;

  1215     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

  1216         const Uint16 val = ((((Sint16) SDL_SwapBE16(*src))) ^ 0x8000);

  1217         *dst = SDL_SwapLE16(val);

  1218     }

  1220     format = AUDIO_U16LSB;

  1221     if (cvt->filters[++cvt->filter_index]) {

  1222         cvt->filters[cvt->filter_index] (cvt, format);

  1223     }

  1224 }

  1226 static void SDLCALL

  1227 SDL_Convert_S16MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1228 {

  1229     int i;

  1230     const Uint16 *src;

  1231     Sint16 *dst;

  1233 #ifdef DEBUG_CONVERT

  1234     fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S16LSB.\n");

  1235 #endif

  1237     src = (const Uint16 *) cvt->buf;

  1238     dst = (Sint16 *) cvt->buf;

  1239     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

  1240         const Sint16 val = ((Sint16) SDL_SwapBE16(*src));

  1241         *dst = ((Sint16) SDL_SwapLE16(val));

  1242     }

  1244     format = AUDIO_S16LSB;

  1245     if (cvt->filters[++cvt->filter_index]) {

  1246         cvt->filters[cvt->filter_index] (cvt, format);

  1247     }

  1248 }

  1250 static void SDLCALL

  1251 SDL_Convert_S16MSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1252 {

  1253     int i;

  1254     const Uint16 *src;

  1255     Uint16 *dst;

  1257 #ifdef DEBUG_CONVERT

  1258     fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_U16MSB.\n");

  1259 #endif

  1261     src = (const Uint16 *) cvt->buf;

  1262     dst = (Uint16 *) cvt->buf;

  1263     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, ++src, ++dst) {

  1264         const Uint16 val = ((((Sint16) SDL_SwapBE16(*src))) ^ 0x8000);

  1265         *dst = SDL_SwapBE16(val);

  1266     }

  1268     format = AUDIO_U16MSB;

  1269     if (cvt->filters[++cvt->filter_index]) {

  1270         cvt->filters[cvt->filter_index] (cvt, format);

  1271     }

  1272 }

  1274 static void SDLCALL

  1275 SDL_Convert_S16MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1276 {

  1277     int i;

  1278     const Uint16 *src;

  1279     Sint32 *dst;

  1281 #ifdef DEBUG_CONVERT

  1282     fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S32LSB.\n");

  1283 #endif

  1285     src = (const Uint16 *) (cvt->buf + cvt->len_cvt);

  1286     dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);

  1287     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {

  1288         const Sint32 val = (((Sint32) ((Sint16) SDL_SwapBE16(*src))) << 16);

  1289         *dst = ((Sint32) SDL_SwapLE32(val));

  1290     }

  1292     cvt->len_cvt *= 2;

  1293     format = AUDIO_S32LSB;

  1294     if (cvt->filters[++cvt->filter_index]) {

  1295         cvt->filters[cvt->filter_index] (cvt, format);

  1296     }

  1297 }

  1299 static void SDLCALL

  1300 SDL_Convert_S16MSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1301 {

  1302     int i;

  1303     const Uint16 *src;

  1304     Sint32 *dst;

  1306 #ifdef DEBUG_CONVERT

  1307     fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_S32MSB.\n");

  1308 #endif

  1310     src = (const Uint16 *) (cvt->buf + cvt->len_cvt);

  1311     dst = (Sint32 *) (cvt->buf + cvt->len_cvt * 2);

  1312     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {

  1313         const Sint32 val = (((Sint32) ((Sint16) SDL_SwapBE16(*src))) << 16);

  1314         *dst = ((Sint32) SDL_SwapBE32(val));

  1315     }

  1317     cvt->len_cvt *= 2;

  1318     format = AUDIO_S32MSB;

  1319     if (cvt->filters[++cvt->filter_index]) {

  1320         cvt->filters[cvt->filter_index] (cvt, format);

  1321     }

  1322 }

  1324 static void SDLCALL

  1325 SDL_Convert_S16MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1326 {

  1327     int i;

  1328     const Uint16 *src;

  1329     float *dst;

  1331 #ifdef DEBUG_CONVERT

  1332     fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_F32LSB.\n");

  1333 #endif

  1335     src = (const Uint16 *) (cvt->buf + cvt->len_cvt);

  1336     dst = (float *) (cvt->buf + cvt->len_cvt * 2);

  1337     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {

  1338         const float val = (((float) ((Sint16) SDL_SwapBE16(*src))) * DIVBY32767);

  1339         *dst = SDL_SwapFloatLE(val);

  1340     }

  1342     cvt->len_cvt *= 2;

  1343     format = AUDIO_F32LSB;

  1344     if (cvt->filters[++cvt->filter_index]) {

  1345         cvt->filters[cvt->filter_index] (cvt, format);

  1346     }

  1347 }

  1349 static void SDLCALL

  1350 SDL_Convert_S16MSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1351 {

  1352     int i;

  1353     const Uint16 *src;

  1354     float *dst;

  1356 #ifdef DEBUG_CONVERT

  1357     fprintf(stderr, "Converting AUDIO_S16MSB to AUDIO_F32MSB.\n");

  1358 #endif

  1360     src = (const Uint16 *) (cvt->buf + cvt->len_cvt);

  1361     dst = (float *) (cvt->buf + cvt->len_cvt * 2);

  1362     for (i = cvt->len_cvt / sizeof (Uint16); i; --i, --src, --dst) {

  1363         const float val = (((float) ((Sint16) SDL_SwapBE16(*src))) * DIVBY32767);

  1364         *dst = SDL_SwapFloatBE(val);

  1365     }

  1367     cvt->len_cvt *= 2;

  1368     format = AUDIO_F32MSB;

  1369     if (cvt->filters[++cvt->filter_index]) {

  1370         cvt->filters[cvt->filter_index] (cvt, format);

  1371     }

  1372 }

  1374 static void SDLCALL

  1375 SDL_Convert_S32LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1376 {

  1377     int i;

  1378     const Uint32 *src;

  1379     Uint8 *dst;

  1381 #ifdef DEBUG_CONVERT

  1382     fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_U8.\n");

  1383 #endif

  1385     src = (const Uint32 *) cvt->buf;

  1386     dst = (Uint8 *) cvt->buf;

  1387     for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {

  1388         const Uint8 val = ((Uint8) (((((Sint32) SDL_SwapLE32(*src))) ^ 0x80000000) >> 24));

  1389         *dst = val;

  1390     }

  1392     cvt->len_cvt /= 4;

  1393     format = AUDIO_U8;

  1394     if (cvt->filters[++cvt->filter_index]) {

  1395         cvt->filters[cvt->filter_index] (cvt, format);

  1396     }

  1397 }

  1399 static void SDLCALL

  1400 SDL_Convert_S32LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1401 {

  1402     int i;

  1403     const Uint32 *src;

  1404     Sint8 *dst;

  1406 #ifdef DEBUG_CONVERT

  1407     fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S8.\n");

  1408 #endif

  1410     src = (const Uint32 *) cvt->buf;

  1411     dst = (Sint8 *) cvt->buf;

  1412     for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {

  1413         const Sint8 val = ((Sint8) (((Sint32) SDL_SwapLE32(*src)) >> 24));

  1414         *dst = ((Sint8) val);

  1415     }

  1417     cvt->len_cvt /= 4;

  1418     format = AUDIO_S8;

  1419     if (cvt->filters[++cvt->filter_index]) {

  1420         cvt->filters[cvt->filter_index] (cvt, format);

  1421     }

  1422 }

  1424 static void SDLCALL

  1425 SDL_Convert_S32LSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1426 {

  1427     int i;

  1428     const Uint32 *src;

  1429     Uint16 *dst;

  1431 #ifdef DEBUG_CONVERT

  1432     fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_U16LSB.\n");

  1433 #endif

  1435     src = (const Uint32 *) cvt->buf;

  1436     dst = (Uint16 *) cvt->buf;

  1437     for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {

  1438         const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapLE32(*src))) ^ 0x80000000) >> 16));

  1439         *dst = SDL_SwapLE16(val);

  1440     }

  1442     cvt->len_cvt /= 2;

  1443     format = AUDIO_U16LSB;

  1444     if (cvt->filters[++cvt->filter_index]) {

  1445         cvt->filters[cvt->filter_index] (cvt, format);

  1446     }

  1447 }

  1449 static void SDLCALL

  1450 SDL_Convert_S32LSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1451 {

  1452     int i;

  1453     const Uint32 *src;

  1454     Sint16 *dst;

  1456 #ifdef DEBUG_CONVERT

  1457     fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S16LSB.\n");

  1458 #endif

  1460     src = (const Uint32 *) cvt->buf;

  1461     dst = (Sint16 *) cvt->buf;

  1462     for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {

  1463         const Sint16 val = ((Sint16) (((Sint32) SDL_SwapLE32(*src)) >> 16));

  1464         *dst = ((Sint16) SDL_SwapLE16(val));

  1465     }

  1467     cvt->len_cvt /= 2;

  1468     format = AUDIO_S16LSB;

  1469     if (cvt->filters[++cvt->filter_index]) {

  1470         cvt->filters[cvt->filter_index] (cvt, format);

  1471     }

  1472 }

  1474 static void SDLCALL

  1475 SDL_Convert_S32LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1476 {

  1477     int i;

  1478     const Uint32 *src;

  1479     Uint16 *dst;

  1481 #ifdef DEBUG_CONVERT

  1482     fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_U16MSB.\n");

  1483 #endif

  1485     src = (const Uint32 *) cvt->buf;

  1486     dst = (Uint16 *) cvt->buf;

  1487     for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {

  1488         const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapLE32(*src))) ^ 0x80000000) >> 16));

  1489         *dst = SDL_SwapBE16(val);

  1490     }

  1492     cvt->len_cvt /= 2;

  1493     format = AUDIO_U16MSB;

  1494     if (cvt->filters[++cvt->filter_index]) {

  1495         cvt->filters[cvt->filter_index] (cvt, format);

  1496     }

  1497 }

  1499 static void SDLCALL

  1500 SDL_Convert_S32LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1501 {

  1502     int i;

  1503     const Uint32 *src;

  1504     Sint16 *dst;

  1506 #ifdef DEBUG_CONVERT

  1507     fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S16MSB.\n");

  1508 #endif

  1510     src = (const Uint32 *) cvt->buf;

  1511     dst = (Sint16 *) cvt->buf;

  1512     for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {

  1513         const Sint16 val = ((Sint16) (((Sint32) SDL_SwapLE32(*src)) >> 16));

  1514         *dst = ((Sint16) SDL_SwapBE16(val));

  1515     }

  1517     cvt->len_cvt /= 2;

  1518     format = AUDIO_S16MSB;

  1519     if (cvt->filters[++cvt->filter_index]) {

  1520         cvt->filters[cvt->filter_index] (cvt, format);

  1521     }

  1522 }

  1524 static void SDLCALL

  1525 SDL_Convert_S32LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1526 {

  1527     int i;

  1528     const Uint32 *src;

  1529     Sint32 *dst;

  1531 #ifdef DEBUG_CONVERT

  1532     fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_S32MSB.\n");

  1533 #endif

  1535     src = (const Uint32 *) cvt->buf;

  1536     dst = (Sint32 *) cvt->buf;

  1537     for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {

  1538         const Sint32 val = ((Sint32) SDL_SwapLE32(*src));

  1539         *dst = ((Sint32) SDL_SwapBE32(val));

  1540     }

  1542     format = AUDIO_S32MSB;

  1543     if (cvt->filters[++cvt->filter_index]) {

  1544         cvt->filters[cvt->filter_index] (cvt, format);

  1545     }

  1546 }

  1548 static void SDLCALL

  1549 SDL_Convert_S32LSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1550 {

  1551     int i;

  1552     const Uint32 *src;

  1553     float *dst;

  1555 #ifdef DEBUG_CONVERT

  1556     fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_F32LSB.\n");

  1557 #endif

  1559     src = (const Uint32 *) cvt->buf;

  1560     dst = (float *) cvt->buf;

  1561     for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {

  1562         const float val = (((float) ((Sint32) SDL_SwapLE32(*src))) * DIVBY2147483647);

  1563         *dst = SDL_SwapFloatLE(val);

  1564     }

  1566     format = AUDIO_F32LSB;

  1567     if (cvt->filters[++cvt->filter_index]) {

  1568         cvt->filters[cvt->filter_index] (cvt, format);

  1569     }

  1570 }

  1572 static void SDLCALL

  1573 SDL_Convert_S32LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1574 {

  1575     int i;

  1576     const Uint32 *src;

  1577     float *dst;

  1579 #ifdef DEBUG_CONVERT

  1580     fprintf(stderr, "Converting AUDIO_S32LSB to AUDIO_F32MSB.\n");

  1581 #endif

  1583     src = (const Uint32 *) cvt->buf;

  1584     dst = (float *) cvt->buf;

  1585     for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {

  1586         const float val = (((float) ((Sint32) SDL_SwapLE32(*src))) * DIVBY2147483647);

  1587         *dst = SDL_SwapFloatBE(val);

  1588     }

  1590     format = AUDIO_F32MSB;

  1591     if (cvt->filters[++cvt->filter_index]) {

  1592         cvt->filters[cvt->filter_index] (cvt, format);

  1593     }

  1594 }

  1596 static void SDLCALL

  1597 SDL_Convert_S32MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1598 {

  1599     int i;

  1600     const Uint32 *src;

  1601     Uint8 *dst;

  1603 #ifdef DEBUG_CONVERT

  1604     fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_U8.\n");

  1605 #endif

  1607     src = (const Uint32 *) cvt->buf;

  1608     dst = (Uint8 *) cvt->buf;

  1609     for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {

  1610         const Uint8 val = ((Uint8) (((((Sint32) SDL_SwapBE32(*src))) ^ 0x80000000) >> 24));

  1611         *dst = val;

  1612     }

  1614     cvt->len_cvt /= 4;

  1615     format = AUDIO_U8;

  1616     if (cvt->filters[++cvt->filter_index]) {

  1617         cvt->filters[cvt->filter_index] (cvt, format);

  1618     }

  1619 }

  1621 static void SDLCALL

  1622 SDL_Convert_S32MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1623 {

  1624     int i;

  1625     const Uint32 *src;

  1626     Sint8 *dst;

  1628 #ifdef DEBUG_CONVERT

  1629     fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S8.\n");

  1630 #endif

  1632     src = (const Uint32 *) cvt->buf;

  1633     dst = (Sint8 *) cvt->buf;

  1634     for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {

  1635         const Sint8 val = ((Sint8) (((Sint32) SDL_SwapBE32(*src)) >> 24));

  1636         *dst = ((Sint8) val);

  1637     }

  1639     cvt->len_cvt /= 4;

  1640     format = AUDIO_S8;

  1641     if (cvt->filters[++cvt->filter_index]) {

  1642         cvt->filters[cvt->filter_index] (cvt, format);

  1643     }

  1644 }

  1646 static void SDLCALL

  1647 SDL_Convert_S32MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1648 {

  1649     int i;

  1650     const Uint32 *src;

  1651     Uint16 *dst;

  1653 #ifdef DEBUG_CONVERT

  1654     fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_U16LSB.\n");

  1655 #endif

  1657     src = (const Uint32 *) cvt->buf;

  1658     dst = (Uint16 *) cvt->buf;

  1659     for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {

  1660         const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapBE32(*src))) ^ 0x80000000) >> 16));

  1661         *dst = SDL_SwapLE16(val);

  1662     }

  1664     cvt->len_cvt /= 2;

  1665     format = AUDIO_U16LSB;

  1666     if (cvt->filters[++cvt->filter_index]) {

  1667         cvt->filters[cvt->filter_index] (cvt, format);

  1668     }

  1669 }

  1671 static void SDLCALL

  1672 SDL_Convert_S32MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1673 {

  1674     int i;

  1675     const Uint32 *src;

  1676     Sint16 *dst;

  1678 #ifdef DEBUG_CONVERT

  1679     fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S16LSB.\n");

  1680 #endif

  1682     src = (const Uint32 *) cvt->buf;

  1683     dst = (Sint16 *) cvt->buf;

  1684     for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {

  1685         const Sint16 val = ((Sint16) (((Sint32) SDL_SwapBE32(*src)) >> 16));

  1686         *dst = ((Sint16) SDL_SwapLE16(val));

  1687     }

  1689     cvt->len_cvt /= 2;

  1690     format = AUDIO_S16LSB;

  1691     if (cvt->filters[++cvt->filter_index]) {

  1692         cvt->filters[cvt->filter_index] (cvt, format);

  1693     }

  1694 }

  1696 static void SDLCALL

  1697 SDL_Convert_S32MSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1698 {

  1699     int i;

  1700     const Uint32 *src;

  1701     Uint16 *dst;

  1703 #ifdef DEBUG_CONVERT

  1704     fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_U16MSB.\n");

  1705 #endif

  1707     src = (const Uint32 *) cvt->buf;

  1708     dst = (Uint16 *) cvt->buf;

  1709     for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {

  1710         const Uint16 val = ((Uint16) (((((Sint32) SDL_SwapBE32(*src))) ^ 0x80000000) >> 16));

  1711         *dst = SDL_SwapBE16(val);

  1712     }

  1714     cvt->len_cvt /= 2;

  1715     format = AUDIO_U16MSB;

  1716     if (cvt->filters[++cvt->filter_index]) {

  1717         cvt->filters[cvt->filter_index] (cvt, format);

  1718     }

  1719 }

  1721 static void SDLCALL

  1722 SDL_Convert_S32MSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1723 {

  1724     int i;

  1725     const Uint32 *src;

  1726     Sint16 *dst;

  1728 #ifdef DEBUG_CONVERT

  1729     fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S16MSB.\n");

  1730 #endif

  1732     src = (const Uint32 *) cvt->buf;

  1733     dst = (Sint16 *) cvt->buf;

  1734     for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {

  1735         const Sint16 val = ((Sint16) (((Sint32) SDL_SwapBE32(*src)) >> 16));

  1736         *dst = ((Sint16) SDL_SwapBE16(val));

  1737     }

  1739     cvt->len_cvt /= 2;

  1740     format = AUDIO_S16MSB;

  1741     if (cvt->filters[++cvt->filter_index]) {

  1742         cvt->filters[cvt->filter_index] (cvt, format);

  1743     }

  1744 }

  1746 static void SDLCALL

  1747 SDL_Convert_S32MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1748 {

  1749     int i;

  1750     const Uint32 *src;

  1751     Sint32 *dst;

  1753 #ifdef DEBUG_CONVERT

  1754     fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_S32LSB.\n");

  1755 #endif

  1757     src = (const Uint32 *) cvt->buf;

  1758     dst = (Sint32 *) cvt->buf;

  1759     for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {

  1760         const Sint32 val = ((Sint32) SDL_SwapBE32(*src));

  1761         *dst = ((Sint32) SDL_SwapLE32(val));

  1762     }

  1764     format = AUDIO_S32LSB;

  1765     if (cvt->filters[++cvt->filter_index]) {

  1766         cvt->filters[cvt->filter_index] (cvt, format);

  1767     }

  1768 }

  1770 static void SDLCALL

  1771 SDL_Convert_S32MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1772 {

  1773     int i;

  1774     const Uint32 *src;

  1775     float *dst;

  1777 #ifdef DEBUG_CONVERT

  1778     fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_F32LSB.\n");

  1779 #endif

  1781     src = (const Uint32 *) cvt->buf;

  1782     dst = (float *) cvt->buf;

  1783     for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {

  1784         const float val = (((float) ((Sint32) SDL_SwapBE32(*src))) * DIVBY2147483647);

  1785         *dst = SDL_SwapFloatLE(val);

  1786     }

  1788     format = AUDIO_F32LSB;

  1789     if (cvt->filters[++cvt->filter_index]) {

  1790         cvt->filters[cvt->filter_index] (cvt, format);

  1791     }

  1792 }

  1794 static void SDLCALL

  1795 SDL_Convert_S32MSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1796 {

  1797     int i;

  1798     const Uint32 *src;

  1799     float *dst;

  1801 #ifdef DEBUG_CONVERT

  1802     fprintf(stderr, "Converting AUDIO_S32MSB to AUDIO_F32MSB.\n");

  1803 #endif

  1805     src = (const Uint32 *) cvt->buf;

  1806     dst = (float *) cvt->buf;

  1807     for (i = cvt->len_cvt / sizeof (Uint32); i; --i, ++src, ++dst) {

  1808         const float val = (((float) ((Sint32) SDL_SwapBE32(*src))) * DIVBY2147483647);

  1809         *dst = SDL_SwapFloatBE(val);

  1810     }

  1812     format = AUDIO_F32MSB;

  1813     if (cvt->filters[++cvt->filter_index]) {

  1814         cvt->filters[cvt->filter_index] (cvt, format);

  1815     }

  1816 }

  1818 static void SDLCALL

  1819 SDL_Convert_F32LSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1820 {

  1821     int i;

  1822     const float *src;

  1823     Uint8 *dst;

  1825 #ifdef DEBUG_CONVERT

  1826     fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_U8.\n");

  1827 #endif

  1829     src = (const float *) cvt->buf;

  1830     dst = (Uint8 *) cvt->buf;

  1831     for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {

  1832         const Uint8 val = ((Uint8) (SDL_SwapFloatLE(*src) * 255.0f));

  1833         *dst = val;

  1834     }

  1836     cvt->len_cvt /= 4;

  1837     format = AUDIO_U8;

  1838     if (cvt->filters[++cvt->filter_index]) {

  1839         cvt->filters[cvt->filter_index] (cvt, format);

  1840     }

  1841 }

  1843 static void SDLCALL

  1844 SDL_Convert_F32LSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1845 {

  1846     int i;

  1847     const float *src;

  1848     Sint8 *dst;

  1850 #ifdef DEBUG_CONVERT

  1851     fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S8.\n");

  1852 #endif

  1854     src = (const float *) cvt->buf;

  1855     dst = (Sint8 *) cvt->buf;

  1856     for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {

  1857         const Sint8 val = ((Sint8) (SDL_SwapFloatLE(*src) * 127.0f));

  1858         *dst = ((Sint8) val);

  1859     }

  1861     cvt->len_cvt /= 4;

  1862     format = AUDIO_S8;

  1863     if (cvt->filters[++cvt->filter_index]) {

  1864         cvt->filters[cvt->filter_index] (cvt, format);

  1865     }

  1866 }

  1868 static void SDLCALL

  1869 SDL_Convert_F32LSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1870 {

  1871     int i;

  1872     const float *src;

  1873     Uint16 *dst;

  1875 #ifdef DEBUG_CONVERT

  1876     fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_U16LSB.\n");

  1877 #endif

  1879     src = (const float *) cvt->buf;

  1880     dst = (Uint16 *) cvt->buf;

  1881     for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {

  1882         const Uint16 val = ((Uint16) (SDL_SwapFloatLE(*src) * 65535.0f));

  1883         *dst = SDL_SwapLE16(val);

  1884     }

  1886     cvt->len_cvt /= 2;

  1887     format = AUDIO_U16LSB;

  1888     if (cvt->filters[++cvt->filter_index]) {

  1889         cvt->filters[cvt->filter_index] (cvt, format);

  1890     }

  1891 }

  1893 static void SDLCALL

  1894 SDL_Convert_F32LSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1895 {

  1896     int i;

  1897     const float *src;

  1898     Sint16 *dst;

  1900 #ifdef DEBUG_CONVERT

  1901     fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S16LSB.\n");

  1902 #endif

  1904     src = (const float *) cvt->buf;

  1905     dst = (Sint16 *) cvt->buf;

  1906     for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {

  1907         const Sint16 val = ((Sint16) (SDL_SwapFloatLE(*src) * 32767.0f));

  1908         *dst = ((Sint16) SDL_SwapLE16(val));

  1909     }

  1911     cvt->len_cvt /= 2;

  1912     format = AUDIO_S16LSB;

  1913     if (cvt->filters[++cvt->filter_index]) {

  1914         cvt->filters[cvt->filter_index] (cvt, format);

  1915     }

  1916 }

  1918 static void SDLCALL

  1919 SDL_Convert_F32LSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1920 {

  1921     int i;

  1922     const float *src;

  1923     Uint16 *dst;

  1925 #ifdef DEBUG_CONVERT

  1926     fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_U16MSB.\n");

  1927 #endif

  1929     src = (const float *) cvt->buf;

  1930     dst = (Uint16 *) cvt->buf;

  1931     for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {

  1932         const Uint16 val = ((Uint16) (SDL_SwapFloatLE(*src) * 65535.0f));

  1933         *dst = SDL_SwapBE16(val);

  1934     }

  1936     cvt->len_cvt /= 2;

  1937     format = AUDIO_U16MSB;

  1938     if (cvt->filters[++cvt->filter_index]) {

  1939         cvt->filters[cvt->filter_index] (cvt, format);

  1940     }

  1941 }

  1943 static void SDLCALL

  1944 SDL_Convert_F32LSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1945 {

  1946     int i;

  1947     const float *src;

  1948     Sint16 *dst;

  1950 #ifdef DEBUG_CONVERT

  1951     fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S16MSB.\n");

  1952 #endif

  1954     src = (const float *) cvt->buf;

  1955     dst = (Sint16 *) cvt->buf;

  1956     for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {

  1957         const Sint16 val = ((Sint16) (SDL_SwapFloatLE(*src) * 32767.0f));

  1958         *dst = ((Sint16) SDL_SwapBE16(val));

  1959     }

  1961     cvt->len_cvt /= 2;

  1962     format = AUDIO_S16MSB;

  1963     if (cvt->filters[++cvt->filter_index]) {

  1964         cvt->filters[cvt->filter_index] (cvt, format);

  1965     }

  1966 }

  1968 static void SDLCALL

  1969 SDL_Convert_F32LSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1970 {

  1971     int i;

  1972     const float *src;

  1973     Sint32 *dst;

  1975 #ifdef DEBUG_CONVERT

  1976     fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S32LSB.\n");

  1977 #endif

  1979     src = (const float *) cvt->buf;

  1980     dst = (Sint32 *) cvt->buf;

  1981     for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {

  1982         const Sint32 val = ((Sint32) (SDL_SwapFloatLE(*src) * 2147483647.0));

  1983         *dst = ((Sint32) SDL_SwapLE32(val));

  1984     }

  1986     format = AUDIO_S32LSB;

  1987     if (cvt->filters[++cvt->filter_index]) {

  1988         cvt->filters[cvt->filter_index] (cvt, format);

  1989     }

  1990 }

  1992 static void SDLCALL

  1993 SDL_Convert_F32LSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  1994 {

  1995     int i;

  1996     const float *src;

  1997     Sint32 *dst;

  1999 #ifdef DEBUG_CONVERT

  2000     fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_S32MSB.\n");

  2001 #endif

  2003     src = (const float *) cvt->buf;

  2004     dst = (Sint32 *) cvt->buf;

  2005     for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {

  2006         const Sint32 val = ((Sint32) (SDL_SwapFloatLE(*src) * 2147483647.0));

  2007         *dst = ((Sint32) SDL_SwapBE32(val));

  2008     }

  2010     format = AUDIO_S32MSB;

  2011     if (cvt->filters[++cvt->filter_index]) {

  2012         cvt->filters[cvt->filter_index] (cvt, format);

  2013     }

  2014 }

  2016 static void SDLCALL

  2017 SDL_Convert_F32LSB_to_F32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  2018 {

  2019     int i;

  2020     const float *src;

  2021     float *dst;

  2023 #ifdef DEBUG_CONVERT

  2024     fprintf(stderr, "Converting AUDIO_F32LSB to AUDIO_F32MSB.\n");

  2025 #endif

  2027     src = (const float *) cvt->buf;

  2028     dst = (float *) cvt->buf;

  2029     for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {

  2030         const float val = SDL_SwapFloatLE(*src);

  2031         *dst = SDL_SwapFloatBE(val);

  2032     }

  2034     format = AUDIO_F32MSB;

  2035     if (cvt->filters[++cvt->filter_index]) {

  2036         cvt->filters[cvt->filter_index] (cvt, format);

  2037     }

  2038 }

  2040 static void SDLCALL

  2041 SDL_Convert_F32MSB_to_U8(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  2042 {

  2043     int i;

  2044     const float *src;

  2045     Uint8 *dst;

  2047 #ifdef DEBUG_CONVERT

  2048     fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_U8.\n");

  2049 #endif

  2051     src = (const float *) cvt->buf;

  2052     dst = (Uint8 *) cvt->buf;

  2053     for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {

  2054         const Uint8 val = ((Uint8) (SDL_SwapFloatBE(*src) * 255.0f));

  2055         *dst = val;

  2056     }

  2058     cvt->len_cvt /= 4;

  2059     format = AUDIO_U8;

  2060     if (cvt->filters[++cvt->filter_index]) {

  2061         cvt->filters[cvt->filter_index] (cvt, format);

  2062     }

  2063 }

  2065 static void SDLCALL

  2066 SDL_Convert_F32MSB_to_S8(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  2067 {

  2068     int i;

  2069     const float *src;

  2070     Sint8 *dst;

  2072 #ifdef DEBUG_CONVERT

  2073     fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S8.\n");

  2074 #endif

  2076     src = (const float *) cvt->buf;

  2077     dst = (Sint8 *) cvt->buf;

  2078     for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {

  2079         const Sint8 val = ((Sint8) (SDL_SwapFloatBE(*src) * 127.0f));

  2080         *dst = ((Sint8) val);

  2081     }

  2083     cvt->len_cvt /= 4;

  2084     format = AUDIO_S8;

  2085     if (cvt->filters[++cvt->filter_index]) {

  2086         cvt->filters[cvt->filter_index] (cvt, format);

  2087     }

  2088 }

  2090 static void SDLCALL

  2091 SDL_Convert_F32MSB_to_U16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  2092 {

  2093     int i;

  2094     const float *src;

  2095     Uint16 *dst;

  2097 #ifdef DEBUG_CONVERT

  2098     fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_U16LSB.\n");

  2099 #endif

  2101     src = (const float *) cvt->buf;

  2102     dst = (Uint16 *) cvt->buf;

  2103     for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {

  2104         const Uint16 val = ((Uint16) (SDL_SwapFloatBE(*src) * 65535.0f));

  2105         *dst = SDL_SwapLE16(val);

  2106     }

  2108     cvt->len_cvt /= 2;

  2109     format = AUDIO_U16LSB;

  2110     if (cvt->filters[++cvt->filter_index]) {

  2111         cvt->filters[cvt->filter_index] (cvt, format);

  2112     }

  2113 }

  2115 static void SDLCALL

  2116 SDL_Convert_F32MSB_to_S16LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  2117 {

  2118     int i;

  2119     const float *src;

  2120     Sint16 *dst;

  2122 #ifdef DEBUG_CONVERT

  2123     fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S16LSB.\n");

  2124 #endif

  2126     src = (const float *) cvt->buf;

  2127     dst = (Sint16 *) cvt->buf;

  2128     for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {

  2129         const Sint16 val = ((Sint16) (SDL_SwapFloatBE(*src) * 32767.0f));

  2130         *dst = ((Sint16) SDL_SwapLE16(val));

  2131     }

  2133     cvt->len_cvt /= 2;

  2134     format = AUDIO_S16LSB;

  2135     if (cvt->filters[++cvt->filter_index]) {

  2136         cvt->filters[cvt->filter_index] (cvt, format);

  2137     }

  2138 }

  2140 static void SDLCALL

  2141 SDL_Convert_F32MSB_to_U16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  2142 {

  2143     int i;

  2144     const float *src;

  2145     Uint16 *dst;

  2147 #ifdef DEBUG_CONVERT

  2148     fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_U16MSB.\n");

  2149 #endif

  2151     src = (const float *) cvt->buf;

  2152     dst = (Uint16 *) cvt->buf;

  2153     for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {

  2154         const Uint16 val = ((Uint16) (SDL_SwapFloatBE(*src) * 65535.0f));

  2155         *dst = SDL_SwapBE16(val);

  2156     }

  2158     cvt->len_cvt /= 2;

  2159     format = AUDIO_U16MSB;

  2160     if (cvt->filters[++cvt->filter_index]) {

  2161         cvt->filters[cvt->filter_index] (cvt, format);

  2162     }

  2163 }

  2165 static void SDLCALL

  2166 SDL_Convert_F32MSB_to_S16MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  2167 {

  2168     int i;

  2169     const float *src;

  2170     Sint16 *dst;

  2172 #ifdef DEBUG_CONVERT

  2173     fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S16MSB.\n");

  2174 #endif

  2176     src = (const float *) cvt->buf;

  2177     dst = (Sint16 *) cvt->buf;

  2178     for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {

  2179         const Sint16 val = ((Sint16) (SDL_SwapFloatBE(*src) * 32767.0f));

  2180         *dst = ((Sint16) SDL_SwapBE16(val));

  2181     }

  2183     cvt->len_cvt /= 2;

  2184     format = AUDIO_S16MSB;

  2185     if (cvt->filters[++cvt->filter_index]) {

  2186         cvt->filters[cvt->filter_index] (cvt, format);

  2187     }

  2188 }

  2190 static void SDLCALL

  2191 SDL_Convert_F32MSB_to_S32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  2192 {

  2193     int i;

  2194     const float *src;

  2195     Sint32 *dst;

  2197 #ifdef DEBUG_CONVERT

  2198     fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S32LSB.\n");

  2199 #endif

  2201     src = (const float *) cvt->buf;

  2202     dst = (Sint32 *) cvt->buf;

  2203     for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {

  2204         const Sint32 val = ((Sint32) (SDL_SwapFloatBE(*src) * 2147483647.0));

  2205         *dst = ((Sint32) SDL_SwapLE32(val));

  2206     }

  2208     format = AUDIO_S32LSB;

  2209     if (cvt->filters[++cvt->filter_index]) {

  2210         cvt->filters[cvt->filter_index] (cvt, format);

  2211     }

  2212 }

  2214 static void SDLCALL

  2215 SDL_Convert_F32MSB_to_S32MSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  2216 {

  2217     int i;

  2218     const float *src;

  2219     Sint32 *dst;

  2221 #ifdef DEBUG_CONVERT

  2222     fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_S32MSB.\n");

  2223 #endif

  2225     src = (const float *) cvt->buf;

  2226     dst = (Sint32 *) cvt->buf;

  2227     for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {

  2228         const Sint32 val = ((Sint32) (SDL_SwapFloatBE(*src) * 2147483647.0));

  2229         *dst = ((Sint32) SDL_SwapBE32(val));

  2230     }

  2232     format = AUDIO_S32MSB;

  2233     if (cvt->filters[++cvt->filter_index]) {

  2234         cvt->filters[cvt->filter_index] (cvt, format);

  2235     }

  2236 }

  2238 static void SDLCALL

  2239 SDL_Convert_F32MSB_to_F32LSB(SDL_AudioCVT * cvt, SDL_AudioFormat format)

  2240 {

  2241     int i;

  2242     const float *src;

  2243     float *dst;

  2245 #ifdef DEBUG_CONVERT

  2246     fprintf(stderr, "Converting AUDIO_F32MSB to AUDIO_F32LSB.\n");

  2247 #endif

  2249     src = (const float *) cvt->buf;

  2250     dst = (float *) cvt->buf;

  2251     for (i = cvt->len_cvt / sizeof (float); i; --i, ++src, ++dst) {

  2252         const float val = SDL_SwapFloatBE(*src);

  2253         *dst = SDL_SwapFloatLE(val);

  2254     }

  2256     format = AUDIO_F32LSB;

  2257     if (cvt->filters[++cvt->filter_index]) {

  2258         cvt->filters[cvt->filter_index] (cvt, format);

  2259     }

  2260 }

  2262 const SDL_AudioTypeFilters sdl_audio_type_filters[] =

  2263 {

  2264     { AUDIO_U8, AUDIO_S8, SDL_Convert_U8_to_S8 },

  2265     { AUDIO_U8, AUDIO_U16LSB, SDL_Convert_U8_to_U16LSB },

  2266     { AUDIO_U8, AUDIO_S16LSB, SDL_Convert_U8_to_S16LSB },

  2267     { AUDIO_U8, AUDIO_U16MSB, SDL_Convert_U8_to_U16MSB },

  2268     { AUDIO_U8, AUDIO_S16MSB, SDL_Convert_U8_to_S16MSB },

  2269     { AUDIO_U8, AUDIO_S32LSB, SDL_Convert_U8_to_S32LSB },

  2270     { AUDIO_U8, AUDIO_S32MSB, SDL_Convert_U8_to_S32MSB },

  2271     { AUDIO_U8, AUDIO_F32LSB, SDL_Convert_U8_to_F32LSB },

  2272     { AUDIO_U8, AUDIO_F32MSB, SDL_Convert_U8_to_F32MSB },

  2273     { AUDIO_S8, AUDIO_U8, SDL_Convert_S8_to_U8 },

  2274     { AUDIO_S8, AUDIO_U16LSB, SDL_Convert_S8_to_U16LSB },

  2275     { AUDIO_S8, AUDIO_S16LSB, SDL_Convert_S8_to_S16LSB },

  2276     { AUDIO_S8, AUDIO_U16MSB, SDL_Convert_S8_to_U16MSB },

  2277     { AUDIO_S8, AUDIO_S16MSB, SDL_Convert_S8_to_S16MSB },

  2278     { AUDIO_S8, AUDIO_S32LSB, SDL_Convert_S8_to_S32LSB },

  2279     { AUDIO_S8, AUDIO_S32MSB, SDL_Convert_S8_to_S32MSB },

  2280     { AUDIO_S8, AUDIO_F32LSB, SDL_Convert_S8_to_F32LSB },

  2281     { AUDIO_S8, AUDIO_F32MSB, SDL_Convert_S8_to_F32MSB },

  2282     { AUDIO_U16LSB, AUDIO_U8, SDL_Convert_U16LSB_to_U8 },

  2283     { AUDIO_U16LSB, AUDIO_S8, SDL_Convert_U16LSB_to_S8 },

  2284     { AUDIO_U16LSB, AUDIO_S16LSB, SDL_Convert_U16LSB_to_S16LSB },

  2285     { AUDIO_U16LSB, AUDIO_U16MSB, SDL_Convert_U16LSB_to_U16MSB },

  2286     { AUDIO_U16LSB, AUDIO_S16MSB, SDL_Convert_U16LSB_to_S16MSB },

  2287     { AUDIO_U16LSB, AUDIO_S32LSB, SDL_Convert_U16LSB_to_S32LSB },

  2288     { AUDIO_U16LSB, AUDIO_S32MSB, SDL_Convert_U16LSB_to_S32MSB },

  2289     { AUDIO_U16LSB, AUDIO_F32LSB, SDL_Convert_U16LSB_to_F32LSB },

  2290     { AUDIO_U16LSB, AUDIO_F32MSB, SDL_Convert_U16LSB_to_F32MSB },

  2291     { AUDIO_S16LSB, AUDIO_U8, SDL_Convert_S16LSB_to_U8 },

  2292     { AUDIO_S16LSB, AUDIO_S8, SDL_Convert_S16LSB_to_S8 },

  2293     { AUDIO_S16LSB, AUDIO_U16LSB, SDL_Convert_S16LSB_to_U16LSB },

  2294     { AUDIO_S16LSB, AUDIO_U16MSB, SDL_Convert_S16LSB_to_U16MSB },

  2295     { AUDIO_S16LSB, AUDIO_S16MSB, SDL_Convert_S16LSB_to_S16MSB },

  2296     { AUDIO_S16LSB, AUDIO_S32LSB, SDL_Convert_S16LSB_to_S32LSB },

  2297     { AUDIO_S16LSB, AUDIO_S32MSB, SDL_Convert_S16LSB_to_S32MSB },

  2298     { AUDIO_S16LSB, AUDIO_F32LSB, SDL_Convert_S16LSB_to_F32LSB },

  2299     { AUDIO_S16LSB, AUDIO_F32MSB, SDL_Convert_S16LSB_to_F32MSB },

  2300     { AUDIO_U16MSB, AUDIO_U8, SDL_Convert_U16MSB_to_U8 },

  2301     { AUDIO_U16MSB, AUDIO_S8, SDL_Convert_U16MSB_to_S8 },

  2302     { AUDIO_U16MSB, AUDIO_U16LSB, SDL_Convert_U16MSB_to_U16LSB },

  2303     { AUDIO_U16MSB, AUDIO_S16LSB, SDL_Convert_U16MSB_to_S16LSB },

  2304     { AUDIO_U16MSB, AUDIO_S16MSB, SDL_Convert_U16MSB_to_S16MSB },

  2305     { AUDIO_U16MSB, AUDIO_S32LSB, SDL_Convert_U16MSB_to_S32LSB },

  2306     { AUDIO_U16MSB, AUDIO_S32MSB, SDL_Convert_U16MSB_to_S32MSB },

  2307     { AUDIO_U16MSB, AUDIO_F32LSB, SDL_Convert_U16MSB_to_F32LSB },

  2308     { AUDIO_U16MSB, AUDIO_F32MSB, SDL_Convert_U16MSB_to_F32MSB },

  2309     { AUDIO_S16MSB, AUDIO_U8, SDL_Convert_S16MSB_to_U8 },

  2310     { AUDIO_S16MSB, AUDIO_S8, SDL_Convert_S16MSB_to_S8 },

  2311     { AUDIO_S16MSB, AUDIO_U16LSB, SDL_Convert_S16MSB_to_U16LSB },

  2312     { AUDIO_S16MSB, AUDIO_S16LSB, SDL_Convert_S16MSB_to_S16LSB },

  2313     { AUDIO_S16MSB, AUDIO_U16MSB, SDL_Convert_S16MSB_to_U16MSB },

  2314     { AUDIO_S16MSB, AUDIO_S32LSB, SDL_Convert_S16MSB_to_S32LSB },

  2315     { AUDIO_S16MSB, AUDIO_S32MSB, SDL_Convert_S16MSB_to_S32MSB },

  2316     { AUDIO_S16MSB, AUDIO_F32LSB, SDL_Convert_S16MSB_to_F32LSB },

  2317     { AUDIO_S16MSB, AUDIO_F32MSB, SDL_Convert_S16MSB_to_F32MSB },

  2318     { AUDIO_S32LSB, AUDIO_U8, SDL_Convert_S32LSB_to_U8 },

  2319     { AUDIO_S32LSB, AUDIO_S8, SDL_Convert_S32LSB_to_S8 },

  2320     { AUDIO_S32LSB, AUDIO_U16LSB, SDL_Convert_S32LSB_to_U16LSB },

  2321     { AUDIO_S32LSB, AUDIO_S16LSB, SDL_Convert_S32LSB_to_S16LSB },

  2322     { AUDIO_S32LSB, AUDIO_U16MSB, SDL_Convert_S32LSB_to_U16MSB },

  2323     { AUDIO_S32LSB, AUDIO_S16MSB, SDL_Convert_S32LSB_to_S16MSB },

  2324     { AUDIO_S32LSB, AUDIO_S32MSB, SDL_Convert_S32LSB_to_S32MSB },

  2325     { AUDIO_S32LSB, AUDIO_F32LSB, SDL_Convert_S32LSB_to_F32LSB },

  2326     { AUDIO_S32LSB, AUDIO_F32MSB, SDL_Convert_S32LSB_to_F32MSB },

  2327     { AUDIO_S32MSB, AUDIO_U8, SDL_Convert_S32MSB_to_U8 },

  2328     { AUDIO_S32MSB, AUDIO_S8, SDL_Convert_S32MSB_to_S8 },

  2329     { AUDIO_S32MSB, AUDIO_U16LSB, SDL_Convert_S32MSB_to_U16LSB },

  2330     { AUDIO_S32MSB, AUDIO_S16LSB, SDL_Convert_S32MSB_to_S16LSB },

  2331     { AUDIO_S32MSB, AUDIO_U16MSB, SDL_Convert_S32MSB_to_U16MSB },

  2332     { AUDIO_S32MSB, AUDIO_S16MSB, SDL_Convert_S32MSB_to_S16MSB },

  2333     { AUDIO_S32MSB, AUDIO_S32LSB, SDL_Convert_S32MSB_to_S32LSB },

  2334     { AUDIO_S32MSB, AUDIO_F32LSB, SDL_Convert_S32MSB_to_F32LSB },

  2335     { AUDIO_S32MSB, AUDIO_F32MSB, SDL_Convert_S32MSB_to_F32MSB },

  2336     { AUDIO_F32LSB, AUDIO_U8, SDL_Convert_F32LSB_to_U8 },

  2337     { AUDIO_F32LSB, AUDIO_S8, SDL_Convert_F32LSB_to_S8 },

  2338     { AUDIO_F32LSB, AUDIO_U16LSB, SDL_Convert_F32LSB_to_U16LSB },

  2339     { AUDIO_F32LSB, AUDIO_S16LSB, SDL_Convert_F32LSB_to_S16LSB },

  2340     { AUDIO_F32LSB, AUDIO_U16MSB, SDL_Convert_F32LSB_to_U16MSB },

  2341     { AUDIO_F32LSB, AUDIO_S16MSB, SDL_Convert_F32LSB_to_S16MSB },

  2342     { AUDIO_F32LSB, AUDIO_S32LSB, SDL_Convert_F32LSB_to_S32LSB },

  2343     { AUDIO_F32LSB, AUDIO_S32MSB, SDL_Convert_F32LSB_to_S32MSB },

  2344     { AUDIO_F32LSB, AUDIO_F32MSB, SDL_Convert_F32LSB_to_F32MSB },

  2345     { AUDIO_F32MSB, AUDIO_U8, SDL_Convert_F32MSB_to_U8 },

  2346     { AUDIO_F32MSB, AUDIO_S8, SDL_Convert_F32MSB_to_S8 },

  2347     { AUDIO_F32MSB, AUDIO_U16LSB, SDL_Convert_F32MSB_to_U16LSB },

  2348     { AUDIO_F32MSB, AUDIO_S16LSB, SDL_Convert_F32MSB_to_S16LSB },

  2349     { AUDIO_F32MSB, AUDIO_U16MSB, SDL_Convert_F32MSB_to_U16MSB },

  2350     { AUDIO_F32MSB, AUDIO_S16MSB, SDL_Convert_F32MSB_to_S16MSB },

  2351     { AUDIO_F32MSB, AUDIO_S32LSB, SDL_Convert_F32MSB_to_S32LSB },

  2352     { AUDIO_F32MSB, AUDIO_S32MSB, SDL_Convert_F32MSB_to_S32MSB },

  2353     { AUDIO_F32MSB, AUDIO_F32LSB, SDL_Convert_F32MSB_to_F32LSB },

  2354 };

author	Ryan C. Gordon <icculus@icculus.org>
	Thu, 24 Aug 2006 12:10:46 +0000
changeset 1982	3b4ce57c6215
child 1985	8055185ae4ed
permissions	-rw-r--r--