/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2006 Sam Lantinga

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

    modify it under the terms of the GNU Lesser General Public

    License as published by the Free Software Foundation; either

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

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

    but WITHOUT ANY WARRANTY; without even the implied warranty of

    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    Lesser General Public License for more details.

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

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

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

    Sam Lantinga

    slouken@libsdl.org

*/

#include "SDL_config.h"

/* Functions for audio drivers to perform runtime conversion of audio format */

#include "SDL_audio.h"

#include "SDL_audio_c.h"

/* Effectively mix right and left channels into a single channel */

static void SDLCALL

SDL_ConvertMono(SDL_AudioCVT * cvt, SDL_AudioFormat format)

{

    int i;

    Sint32 sample;

#ifdef DEBUG_CONVERT

    fprintf(stderr, "Converting to mono\n");

#endif

    switch (format & (SDL_AUDIO_MASK_SIGNED | SDL_AUDIO_MASK_BITSIZE)) {

    case AUDIO_U8:

        {

            Uint8 *src, *dst;

            src = cvt->buf;

            dst = cvt->buf;

            for (i = cvt->len_cvt / 2; i; --i) {

                sample = src[0] + src[1];

                *dst = (Uint8) (sample / 2);

                src += 2;

                dst += 1;

            }

        }

        break;

    case AUDIO_S8:

        {

            Sint8 *src, *dst;

            src = (Sint8 *) cvt->buf;

            dst = (Sint8 *) cvt->buf;

            for (i = cvt->len_cvt / 2; i; --i) {

                sample = src[0] + src[1];

                *dst = (Sint8) (sample / 2);

                src += 2;

                dst += 1;

            }

        }

        break;

    case AUDIO_U16:

        {

            Uint8 *src, *dst;

            src = cvt->buf;

            dst = cvt->buf;

            if (SDL_AUDIO_ISBIGENDIAN(format)) {

                for (i = cvt->len_cvt / 4; i; --i) {

                    sample = (Uint16) ((src[0] << 8) | src[1]) +

                        (Uint16) ((src[2] << 8) | src[3]);

                    sample /= 2;

                    dst[1] = (sample & 0xFF);

                    sample >>= 8;

                    dst[0] = (sample & 0xFF);

                    src += 4;

                    dst += 2;

                }

            } else {

                for (i = cvt->len_cvt / 4; i; --i) {

                    sample = (Uint16) ((src[1] << 8) | src[0]) +

                        (Uint16) ((src[3] << 8) | src[2]);

                    sample /= 2;

                    dst[0] = (sample & 0xFF);

                    sample >>= 8;

                    dst[1] = (sample & 0xFF);

                    src += 4;

                    dst += 2;

                }

            }

        }

        break;

    case AUDIO_S16:

        {

            Uint8 *src, *dst;

            src = cvt->buf;

            dst = cvt->buf;

            if (SDL_AUDIO_ISBIGENDIAN(format)) {

                for (i = cvt->len_cvt / 4; i; --i) {

                    sample = (Sint16) ((src[0] << 8) | src[1]) +

                        (Sint16) ((src[2] << 8) | src[3]);

                    sample /= 2;

                    dst[1] = (sample & 0xFF);

                    sample >>= 8;

                    dst[0] = (sample & 0xFF);

                    src += 4;

                    dst += 2;

                }

            } else {

                for (i = cvt->len_cvt / 4; i; --i) {

                    sample = (Sint16) ((src[1] << 8) | src[0]) +

                        (Sint16) ((src[3] << 8) | src[2]);

                    sample /= 2;

                    dst[0] = (sample & 0xFF);

                    sample >>= 8;

                    dst[1] = (sample & 0xFF);

                    src += 4;

                    dst += 2;

                }

            }

        }

        break;

    case AUDIO_S32:

        {

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

            Uint32 *dst = (Uint32 *) cvt->buf;

            if (SDL_AUDIO_ISBIGENDIAN(format)) {

                for (i = cvt->len_cvt / 8; i; --i, src += 2) {

                    const Sint64 added =

                        (((Sint64) (Sint32) SDL_SwapBE32(src[0])) +

                         ((Sint64) (Sint32) SDL_SwapBE32(src[1])));

                    *(dst++) = SDL_SwapBE32((Uint32) ((Sint32) (added / 2)));

                }

            } else {

                for (i = cvt->len_cvt / 8; i; --i, src += 2) {

                    const Sint64 added =

                        (((Sint64) (Sint32) SDL_SwapLE32(src[0])) +

                         ((Sint64) (Sint32) SDL_SwapLE32(src[1])));

                    *(dst++) = SDL_SwapLE32((Uint32) ((Sint32) (added / 2)));

                }

            }

        }

        break;

    case AUDIO_F32:

        {

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

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

            if (SDL_AUDIO_ISBIGENDIAN(format)) {

                for (i = cvt->len_cvt / 8; i; --i, src += 2) {

                    const float src1 = SDL_SwapFloatBE(src[0]);

                    const float src2 = SDL_SwapFloatBE(src[1]);

                    const double added = ((double) src1) + ((double) src2);

                    const float halved = (float) (added * 0.5);

                    *(dst++) = SDL_SwapFloatBE(halved);

                }

            } else {

                for (i = cvt->len_cvt / 8; i; --i, src += 2) {

                    const float src1 = SDL_SwapFloatLE(src[0]);

                    const float src2 = SDL_SwapFloatLE(src[1]);

                    const double added = ((double) src1) + ((double) src2);

                    const float halved = (float) (added * 0.5);

                    *(dst++) = SDL_SwapFloatLE(halved);

                }

            }

        }

        break;

    }

    cvt->len_cvt /= 2;

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

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

    }

}

/* Discard top 4 channels */

static void SDLCALL

SDL_ConvertStrip(SDL_AudioCVT * cvt, SDL_AudioFormat format)

{

    int i;

#ifdef DEBUG_CONVERT

    fprintf(stderr, "Converting down from 6 channels to stereo\n");

#endif

#define strip_chans_6_to_2(type) \

    { \

        const type *src = (const type *) cvt->buf; \

        type *dst = (type *) cvt->buf; \

        for (i = cvt->len_cvt / (sizeof (type) * 6); i; --i) { \

            dst[0] = src[0]; \

            dst[1] = src[1]; \

            src += 6; \

            dst += 2; \

        } \

    }

    /* this function only cares about typesize, and data as a block of bits. */

    switch (SDL_AUDIO_BITSIZE(format)) {

    case 8:

        strip_chans_6_to_2(Uint8);

        break;

    case 16:

        strip_chans_6_to_2(Uint16);

        break;

    case 32:

        strip_chans_6_to_2(Uint32);

        break;

    }

#undef strip_chans_6_to_2

    cvt->len_cvt /= 3;

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

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

    }

}

/* Discard top 2 channels of 6 */

static void SDLCALL

SDL_ConvertStrip_2(SDL_AudioCVT * cvt, SDL_AudioFormat format)

{

    int i;

#ifdef DEBUG_CONVERT

    fprintf(stderr, "Converting 6 down to quad\n");

#endif

#define strip_chans_6_to_4(type) \

    { \

        const type *src = (const type *) cvt->buf; \

        type *dst = (type *) cvt->buf; \

        for (i = cvt->len_cvt / (sizeof (type) * 6); i; --i) { \

            dst[0] = src[0]; \

            dst[1] = src[1]; \

            dst[2] = src[2]; \

            dst[3] = src[3]; \

            src += 6; \

            dst += 4; \

        } \

    }

    /* this function only cares about typesize, and data as a block of bits. */

    switch (SDL_AUDIO_BITSIZE(format)) {

    case 8:

        strip_chans_6_to_4(Uint8);

        break;

    case 16:

        strip_chans_6_to_4(Uint16);

        break;

    case 32:

        strip_chans_6_to_4(Uint32);

        break;

    }

#undef strip_chans_6_to_4

    cvt->len_cvt /= 6;

    cvt->len_cvt *= 4;

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

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

    }

}

/* Duplicate a mono channel to both stereo channels */

static void SDLCALL

SDL_ConvertStereo(SDL_AudioCVT * cvt, SDL_AudioFormat format)

{

    int i;

#ifdef DEBUG_CONVERT

    fprintf(stderr, "Converting to stereo\n");

#endif

#define dup_chans_1_to_2(type) \

    { \

        const type *src = (const type *) (cvt->buf + cvt->len_cvt); \

        type *dst = (type *) (cvt->buf + cvt->len_cvt * 2); \

        for (i = cvt->len_cvt / 2; i; --i, --src) { \

            const type val = *src; \

            dst -= 2; \

            dst[0] = dst[1] = val; \

        } \

    }

    /* this function only cares about typesize, and data as a block of bits. */

    switch (SDL_AUDIO_BITSIZE(format)) {

    case 8:

        dup_chans_1_to_2(Uint8);

        break;

    case 16:

        dup_chans_1_to_2(Uint16);

        break;

    case 32:

        dup_chans_1_to_2(Uint32);

        break;

    }

#undef dup_chans_1_to_2

    cvt->len_cvt *= 2;

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

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

    }

}

/* Duplicate a stereo channel to a pseudo-5.1 stream */

static void SDLCALL

SDL_ConvertSurround(SDL_AudioCVT * cvt, SDL_AudioFormat format)

{

    int i;

#ifdef DEBUG_CONVERT

    fprintf(stderr, "Converting stereo to surround\n");

#endif

    switch (format & (SDL_AUDIO_MASK_SIGNED | SDL_AUDIO_MASK_BITSIZE)) {

    case AUDIO_U8:

        {

            Uint8 *src, *dst, lf, rf, ce;

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

            dst = (Uint8 *) (cvt->buf + cvt->len_cvt * 3);

            for (i = cvt->len_cvt; i; --i) {

                dst -= 6;

                src -= 2;

                lf = src[0];

                rf = src[1];

                ce = (lf / 2) + (rf / 2);

                dst[0] = lf;

                dst[1] = rf;

                dst[2] = lf - ce;

                dst[3] = rf - ce;

                dst[4] = ce;

                dst[5] = ce;

            }

        }

        break;

    case AUDIO_S8:

        {

            Sint8 *src, *dst, lf, rf, ce;

            src = (Sint8 *) cvt->buf + cvt->len_cvt;

            dst = (Sint8 *) cvt->buf + cvt->len_cvt * 3;

            for (i = cvt->len_cvt; i; --i) {

                dst -= 6;

                src -= 2;

                lf = src[0];

                rf = src[1];

                ce = (lf / 2) + (rf / 2);

                dst[0] = lf;

                dst[1] = rf;

                dst[2] = lf - ce;

                dst[3] = rf - ce;

                dst[4] = ce;

                dst[5] = ce;

            }

        }

        break;

    case AUDIO_U16:

        {

            Uint8 *src, *dst;

            Uint16 lf, rf, ce, lr, rr;

            src = cvt->buf + cvt->len_cvt;

            dst = cvt->buf + cvt->len_cvt * 3;

            if (SDL_AUDIO_ISBIGENDIAN(format)) {

                for (i = cvt->len_cvt / 4; i; --i) {

                    dst -= 12;

                    src -= 4;

                    lf = (Uint16) ((src[0] << 8) | src[1]);

                    rf = (Uint16) ((src[2] << 8) | src[3]);

                    ce = (lf / 2) + (rf / 2);

                    rr = lf - ce;

                    lr = rf - ce;

                    dst[1] = (lf & 0xFF);

                    dst[0] = ((lf >> 8) & 0xFF);

                    dst[3] = (rf & 0xFF);

                    dst[2] = ((rf >> 8) & 0xFF);

                    dst[1 + 4] = (lr & 0xFF);

                    dst[0 + 4] = ((lr >> 8) & 0xFF);

                    dst[3 + 4] = (rr & 0xFF);

                    dst[2 + 4] = ((rr >> 8) & 0xFF);

                    dst[1 + 8] = (ce & 0xFF);

                    dst[0 + 8] = ((ce >> 8) & 0xFF);

                    dst[3 + 8] = (ce & 0xFF);

                    dst[2 + 8] = ((ce >> 8) & 0xFF);

                }

            } else {

                for (i = cvt->len_cvt / 4; i; --i) {

                    dst -= 12;

                    src -= 4;

                    lf = (Uint16) ((src[1] << 8) | src[0]);

                    rf = (Uint16) ((src[3] << 8) | src[2]);

                    ce = (lf / 2) + (rf / 2);

                    rr = lf - ce;

                    lr = rf - ce;

                    dst[0] = (lf & 0xFF);

                    dst[1] = ((lf >> 8) & 0xFF);

                    dst[2] = (rf & 0xFF);

                    dst[3] = ((rf >> 8) & 0xFF);

                    dst[0 + 4] = (lr & 0xFF);

                    dst[1 + 4] = ((lr >> 8) & 0xFF);

                    dst[2 + 4] = (rr & 0xFF);

                    dst[3 + 4] = ((rr >> 8) & 0xFF);

                    dst[0 + 8] = (ce & 0xFF);

                    dst[1 + 8] = ((ce >> 8) & 0xFF);

                    dst[2 + 8] = (ce & 0xFF);

                    dst[3 + 8] = ((ce >> 8) & 0xFF);

                }

            }

        }

        break;

    case AUDIO_S16:

        {

            Uint8 *src, *dst;

            Sint16 lf, rf, ce, lr, rr;

            src = cvt->buf + cvt->len_cvt;

            dst = cvt->buf + cvt->len_cvt * 3;

            if (SDL_AUDIO_ISBIGENDIAN(format)) {

                for (i = cvt->len_cvt / 4; i; --i) {

                    dst -= 12;

                    src -= 4;

                    lf = (Sint16) ((src[0] << 8) | src[1]);

                    rf = (Sint16) ((src[2] << 8) | src[3]);

                    ce = (lf / 2) + (rf / 2);

                    rr = lf - ce;

                    lr = rf - ce;

                    dst[1] = (lf & 0xFF);

                    dst[0] = ((lf >> 8) & 0xFF);