/*
 * Copyright (c) 2003-2004, Marcus Overhagen
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification,
 * are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
 * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include <ByteOrder.h>
#include <OS.h>
#include "AudioConversion.h"
#include "RawFormats.h"

// XXX GCC doesn't always generate nice code...

typedef float float32;
typedef double float64;

class uint8_sample
{
public:
        inline operator uint8() const { return data; }
        inline operator int8()  const { return (int32)data - 128; }
        inline operator int16() const { return ((int32)data - 128) << 8; }
        inline operator int32() const { return ((int32)data - 128) << 24; }
        inline operator float() const { return ((int32)data - 128) * (1.0f / 127.0f); }
private:
        uint8 data;
} _PACKED;

class int8_sample
{
public:
        inline operator uint8() const { return (int32)data + 128; }
        inline operator int8()  const { return data; }
        inline operator int16() const { return (int16)data << 8; }
        inline operator int32() const { return (int32)data << 24; }
        inline operator float() const { return (int32)data * (1.0f / 127.0f); }
private:
        int8 data;
} _PACKED;

class int16_sample
{
public:
        inline operator uint8() const { return (uint8)((int8)(data >> 8) + 128); }
        inline operator int8()  const { return (int8)(data >> 8); }
        inline operator int16() const { return data; }
        inline operator int32() const { return (int32)data << 16; }
        inline operator float() const { return data * (1.0f / 32767.0f); }
private:
        int16 data;
} _PACKED;

class int24_sample
{
public:
#if B_HOST_IS_LENDIAN
        inline operator uint8() const { return (int32)data[2] + 128; }
        inline operator int8()  const { return (int8)data[2]; }
        inline operator int16() const { return (int16)((uint32)data[2] << 8 | (uint32)data[1]); }
        inline operator int32() const { return (int32)((uint32)data[2] << 24 | (uint32)data[1] << 16 | (uint32)data[0] << 8); }
        inline operator float() const { return (int32)((uint32)data[2] << 24 | (uint32)data[1] << 16 | (uint32)data[0] << 8) * (1.0f / 2147483647.0f); }
#else
        inline operator uint8() const { return (int32)data[0] + 128; }
        inline operator int8()  const { return (int8)data[0]; }
        inline operator int16() const { return (int16)((uint32)data[0] << 8 | (uint32)data[1]); }
        inline operator int32() const { return (int32)((uint32)data[0] << 24 | (uint32)data[1] << 16 | (uint32)data[2] << 8); }
        inline operator float() const { return (int32)((uint32)data[0] << 24 | (uint32)data[1] << 16 | (uint32)data[2] << 8) * (1.0f / 2147483647.0f); }
#endif
private:
        uint8 data[3];
} _PACKED;

class int32_sample
{
public:
        inline operator uint8() const { return (int8)(data >> 24) + 128; }
        inline operator int8()  const { return (int8)(data >> 24); }
        inline operator int16() const { return (int16)(data >> 16); }
        inline operator int32() const { return data; }
        inline operator float() const { return data * (1.0f / 2147483647.0f); }
private:
        int32 data;
} _PACKED;

class float32_sample
{
public:
        inline operator uint8() const { int32 v = (int32)(data * 127.0f) + 128; if (v > 255) v = 255; else if (v < 0) v = 0; return v; }
        inline operator int8()  const { int32 v = (int32)(data * 127.0f); if (v > 127) v = 127; else if (v < -127) v = -127; return v; }
        inline operator int16() const { int32 v = (int32)(data * 32767.0f); if (v > 32767) v = 32767; else if (v < -32767) v = -32767; return v; }
        inline operator int32() const { if (data <= -1.0f) return INT32_MIN; if (data >= 1.0f) return INT32_MAX; return (int32)(data * INT32_MAX); }
        inline operator float() const { return data; }
private:
        float32 data;
} _PACKED;

class float64_sample
{
public:
        inline operator uint8() const { int32 v = (int32)(data * 127.0f) + 128; if (v > 255) v = 255; else if (v < 0) v = 0; return v; }
        inline operator int8()  const { int32 v = (int32)(data * 127.0f); if (v > 127) v = 127; else if (v < -127) v = -127; return v; }
        inline operator int16() const { int32 v = (int32)(data * 32767.0f); if (v > 32767) v = 32767; else if (v < -32767) v = -32767; return v; }
        inline operator int32() const { float64 v; if (data < -1.0) v = -1.0; else if (data > 1.0) v = 1.0; else v = data; return (int32)(v * INT32_MAX); }
        inline operator float() const { return data; }
private:
        float64 data;
} _PACKED;

#define CONVERT(src_type, dst_type)                             \
void src_type##_to_##dst_type (void *dst, const void *src, int32 count) \
{                                                                                               \
        const src_type##_sample *s = (const src_type##_sample *) src;   \
        dst_type *d = (dst_type *) dst; \
        int32 c = count >> 4;                           \
        if (!c) goto fin1;                                                      \
        do {                                                                            \
                d[0] = s[0]; d[1] = s[1];                               \
                d[2] = s[2]; d[3] = s[3];                               \
                d[4] = s[4]; d[5] = s[5];                               \
                d[6] = s[6]; d[7] = s[7];                               \
                d[8] = s[8]; d[9] = s[9];                               \
                d[10] = s[10]; d[11] = s[11];                   \
                d[12] = s[12]; d[13] = s[13];                   \
                d[14] = s[14]; d[15] = s[15];                   \
                s += 16; d += 16;                                               \
        } while (--c);                                                          \
fin1:                                                                                   \
        c = count & 15;                                                         \
        if (!c) goto fin2;                                                      \
        do {                                                                            \
                *(d++) = *(s++);                                                \
        } while (--c);                                                          \
fin2:                                                                                   \
        ;                                                                                       \
}


CONVERT(uint8, uint8)
CONVERT(uint8, int8)
CONVERT(uint8, int16)
CONVERT(uint8, int32)
CONVERT(uint8, float32)

CONVERT(int8, uint8)
CONVERT(int8, int8)
CONVERT(int8, int16)
CONVERT(int8, int32)
CONVERT(int8, float32)

CONVERT(int16, uint8)
CONVERT(int16, int8)
CONVERT(int16, int16)
CONVERT(int16, int32)
CONVERT(int16, float32)

CONVERT(int24, uint8)
CONVERT(int24, int8)
CONVERT(int24, int16)
CONVERT(int24, int32)
CONVERT(int24, float32)

CONVERT(int32, uint8)
CONVERT(int32, int8)
CONVERT(int32, int16)
CONVERT(int32, int32)
CONVERT(int32, float32)

CONVERT(float32, uint8)
CONVERT(float32, int8)
CONVERT(float32, int16)
CONVERT(float32, int32)
CONVERT(float32, float32)

CONVERT(float64, uint8)
CONVERT(float64, int8)
CONVERT(float64, int16)
CONVERT(float64, int32)
CONVERT(float64, float32)

void
swap_int16(void *data, int32 count)
{
        swap_data(B_INT16_TYPE, data, count * 2, B_SWAP_ALWAYS);
}

void
swap_int24(void *data, int32 count)
{
        int32 c = count;
        uint8 *d = (uint8 *)data;
        if (!c)
                return;
        do {
                uint8 temp = d[0];
                d[0] = d[2];
                d[2] = temp;
                d += 3;
        } while (--c);
}

void
swap_int32(void *data, int32 count)
{
        swap_data(B_INT32_TYPE, data, count * 4, B_SWAP_ALWAYS);
}

void
swap_float32(void *data, int32 count)
{
        swap_data(B_FLOAT_TYPE, data, count * 4, B_SWAP_ALWAYS);
}

void
swap_float64(void *data, int32 count)
{
        swap_data(B_INT64_TYPE, data, count * 8, B_SWAP_ALWAYS);
}