/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2006-2009 Ariff Abdullah <ariff@FreeBSD.org>
 * All rights reserved.
 * Copyright (c) 2024-2025 The FreeBSD Foundation
 *
 * Portions of this software were developed by Christos Margiolis
 * <christos@FreeBSD.org> under sponsorship from the FreeBSD Foundation.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. 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 AUTHOR 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 AUTHOR 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.
 */

#ifndef _SND_PCM_H_
#define _SND_PCM_H_

#include <sys/param.h>

#include <dev/sound/pcm/g711.h>

#ifndef _KERNEL
#include <assert.h>     /* for __assert_unreachable() */
#endif

/*
 * Automatically turn on 64bit arithmetic on suitable archs
 * (amd64 64bit, etc..) for wider 32bit samples / integer processing.
 */
#if LONG_BIT >= 64
#undef SND_PCM_64
#define SND_PCM_64      1
#endif

typedef int32_t intpcm_t;

typedef int32_t intpcm8_t;
typedef int32_t intpcm16_t;
typedef int32_t intpcm24_t;

typedef uint32_t uintpcm_t;

typedef uint32_t uintpcm8_t;
typedef uint32_t uintpcm16_t;
typedef uint32_t uintpcm24_t;

#ifdef SND_PCM_64
typedef int64_t  intpcm32_t;
typedef uint64_t uintpcm32_t;
#else
typedef int32_t  intpcm32_t;
typedef uint32_t uintpcm32_t;
#endif

typedef int64_t intpcm64_t;
typedef uint64_t uintpcm64_t;

/* 32bit fixed point shift */
#define PCM_FXSHIFT     8

#define PCM_S8_MAX        0x7f
#define PCM_S8_MIN       -0x80
#define PCM_S16_MAX       0x7fff
#define PCM_S16_MIN      -0x8000
#define PCM_S24_MAX       0x7fffff
#define PCM_S24_MIN      -0x800000
#ifdef SND_PCM_64
#if LONG_BIT >= 64
#define PCM_S32_MAX       0x7fffffffL
#define PCM_S32_MIN      -0x80000000L
#else
#define PCM_S32_MAX       0x7fffffffLL
#define PCM_S32_MIN      -0x80000000LL
#endif
#else
#define PCM_S32_MAX       0x7fffffff
#define PCM_S32_MIN     (-0x7fffffff - 1)
#endif

/* Bytes-per-sample definition */
#define PCM_8_BPS       1
#define PCM_16_BPS      2
#define PCM_24_BPS      3
#define PCM_32_BPS      4

#define INTPCM_T(v)     ((intpcm_t)(v))
#define INTPCM8_T(v)    ((intpcm8_t)(v))
#define INTPCM16_T(v)   ((intpcm16_t)(v))
#define INTPCM24_T(v)   ((intpcm24_t)(v))
#define INTPCM32_T(v)   ((intpcm32_t)(v))

static const struct {
        const uint8_t ulaw_to_u8[G711_TABLE_SIZE];
        const uint8_t alaw_to_u8[G711_TABLE_SIZE];
        const uint8_t u8_to_ulaw[G711_TABLE_SIZE];
        const uint8_t u8_to_alaw[G711_TABLE_SIZE];
} xlaw_conv_tables = {
        ULAW_TO_U8,
        ALAW_TO_U8,
        U8_TO_ULAW,
        U8_TO_ALAW
};

/*
 * Functions for reading/writing PCM integer sample values from bytes array.
 * Since every process is done using signed integer (and to make our life less
 * miserable), unsigned sample will be converted to its signed counterpart and
 * restored during writing back.
 */
static __always_inline __unused intpcm_t
pcm_sample_read(const uint8_t *src, uint32_t fmt)
{
        intpcm_t v, e, m;
        bool s;

        fmt = AFMT_ENCODING(fmt);

        switch (fmt) {
        case AFMT_AC3:
                v = 0;
                break;
        case AFMT_MU_LAW:
                v = _G711_TO_INTPCM(xlaw_conv_tables.ulaw_to_u8, *src);
                break;
        case AFMT_A_LAW:
                v = _G711_TO_INTPCM(xlaw_conv_tables.alaw_to_u8, *src);
                break;
        case AFMT_S8:
                v = INTPCM_T((int8_t)*src);
                break;
        case AFMT_U8:
                v = INTPCM_T((int8_t)(*src ^ 0x80));
                break;
        case AFMT_S16_LE:
                v = INTPCM_T(src[0] | (int8_t)src[1] << 8);
                break;
        case AFMT_S16_BE:
                v = INTPCM_T(src[1] | (int8_t)src[0] << 8);
                break;
        case AFMT_U16_LE:
                v = INTPCM_T(src[0] | (int8_t)(src[1] ^ 0x80) << 8);
                break;
        case AFMT_U16_BE:
                v = INTPCM_T(src[1] | (int8_t)(src[0] ^ 0x80) << 8);
                break;
        case AFMT_S24_LE:
                v = INTPCM_T(src[0] | src[1] << 8 | (int8_t)src[2] << 16);
                break;
        case AFMT_S24_BE:
                v = INTPCM_T(src[2] | src[1] << 8 | (int8_t)src[0] << 16);
                break;
        case AFMT_U24_LE:
                v = INTPCM_T(src[0] | src[1] << 8 |
                    (int8_t)(src[2] ^ 0x80) << 16);
                break;
        case AFMT_U24_BE:
                v = INTPCM_T(src[2] | src[1] << 8 |
                    (int8_t)(src[0] ^ 0x80) << 16);
                break;
        case AFMT_S32_LE:
                v = INTPCM_T(src[0] | src[1] << 8 | src[2] << 16 |
                    (int8_t)src[3] << 24);
                break;
        case AFMT_S32_BE:
                v = INTPCM_T(src[3] | src[2] << 8 | src[1] << 16 |
                    (int8_t)src[0] << 24);
                break;
        case AFMT_U32_LE:
                v = INTPCM_T(src[0] | src[1] << 8 | src[2] << 16 |
                    (int8_t)(src[3] ^ 0x80) << 24);
                break;
        case AFMT_U32_BE:
                v = INTPCM_T(src[3] | src[2] << 8 | src[1] << 16 |
                    (int8_t)(src[0] ^ 0x80) << 24);
                break;
        case AFMT_F32_LE:       /* FALLTHROUGH */
        case AFMT_F32_BE:
                if (fmt == AFMT_F32_LE) {
                        v = INTPCM_T(src[0] | src[1] << 8 | src[2] << 16 |
                            (int8_t)src[3] << 24);
                } else {
                        v = INTPCM_T(src[3] | src[2] << 8 | src[1] << 16 |
                            (int8_t)src[0] << 24);
                }
                e = (v >> 23) & 0xff;
                /* NaN, +/- Inf  or too small */
                if (e == 0xff || e < 96) {
                        v = INTPCM_T(0);
                        break;
                }
                s = v & 0x80000000U;
                if (e > 126) {
                        v = INTPCM_T((s == 0) ? PCM_S32_MAX : PCM_S32_MIN);
                        break;
                }
                m = 0x800000 | (v & 0x7fffff);
                e += 8 - 127;
                if (e < 0)
                        m >>= -e;
                else
                        m <<= e;
                v = INTPCM_T((s == 0) ? m : -m);
                break;
        default:
                v = 0;
                printf("%s(): unknown format: 0x%08x\n", __func__, fmt);
                __assert_unreachable();
        }

        return (v);
}

/*
 * Read sample and normalize to 32-bit magnitude.
 */
static __always_inline __unused intpcm_t
pcm_sample_read_norm(const uint8_t *src, uint32_t fmt)
{
        return (pcm_sample_read(src, fmt) << (32 - AFMT_BIT(fmt)));
}

/*
 * Read sample and restrict magnitude to 24 bits.
 */
static __always_inline __unused intpcm_t
pcm_sample_read_calc(const uint8_t *src, uint32_t fmt)
{
        intpcm_t v;

        v = pcm_sample_read(src, fmt);

#ifndef SND_PCM_64
        /*
         * Dynamic range for humans: ~140db.
         *
         * 16bit = 96db (close enough)
         * 24bit = 144db (perfect)
         * 32bit = 196db (way too much)
         *
         * 24bit is pretty much sufficient for our signed integer processing.
         * Also, to avoid overflow, we truncate 32bit (and only 32bit) samples
         * down to 24bit (see below for the reason), unless SND_PCM_64 is
         * defined.
         */
        if (fmt & AFMT_32BIT)
                v >>= PCM_FXSHIFT;
#endif

        return (v);
}

static __always_inline __unused void
pcm_sample_write(uint8_t *dst, intpcm_t v, uint32_t fmt)
{
        intpcm_t r, e;

        fmt = AFMT_ENCODING(fmt);

        if (fmt & (AFMT_F32_LE | AFMT_F32_BE)) {
                if (v == 0)
                        r = 0;
                else if (v == PCM_S32_MAX)
                        r = 0x3f800000;
                else if (v == PCM_S32_MIN)
                        r = 0x80000000U | 0x3f800000;
                else {
                        r = 0;
                        if (v < 0) {
                                r |= 0x80000000U;
                                v = -v;
                        }
                        e = 127 - 8;
                        while ((v & 0x7f000000) != 0) {
                                v >>= 1;
                                e++;
                        }
                        while ((v & 0x7f800000) == 0) {
                                v <<= 1;
                                e--;
                        }
                        r |= (e & 0xff) << 23;
                        r |= v & 0x7fffff;
                }
                v = r;
        }

        switch (fmt) {
        case AFMT_AC3:
                *(int16_t *)dst = 0;
                break;
        case AFMT_MU_LAW:
                *dst = _INTPCM_TO_G711(xlaw_conv_tables.u8_to_ulaw, v);
                break;
        case AFMT_A_LAW:
                *dst = _INTPCM_TO_G711(xlaw_conv_tables.u8_to_alaw, v);
                break;
        case AFMT_S8:
                *(int8_t *)dst = v;
                break;
        case AFMT_U8:
                *(int8_t *)dst = v ^ 0x80;
                break;
        case AFMT_S16_LE:
                dst[0] = v;
                dst[1] = v >> 8;
                break;
        case AFMT_S16_BE:
                dst[1] = v;
                dst[0] = v >> 8;
                break;
        case AFMT_U16_LE:
                dst[0] = v;
                dst[1] = (v >> 8) ^ 0x80;
                break;
        case AFMT_U16_BE:
                dst[1] = v;
                dst[0] = (v >> 8) ^ 0x80;
                break;
        case AFMT_S24_LE:
                dst[0] = v;
                dst[1] = v >> 8;
                dst[2] = v >> 16;
                break;
        case AFMT_S24_BE:
                dst[2] = v;
                dst[1] = v >> 8;
                dst[0] = v >> 16;
                break;
        case AFMT_U24_LE:
                dst[0] = v;
                dst[1] = v >> 8;
                dst[2] = (v >> 16) ^ 0x80;
                break;
        case AFMT_U24_BE:
                dst[2] = v;
                dst[1] = v >> 8;
                dst[0] = (v >> 16) ^ 0x80;
                break;
        case AFMT_S32_LE:       /* FALLTHROUGH */
        case AFMT_F32_LE:
                dst[0] = v;
                dst[1] = v >> 8;
                dst[2] = v >> 16;
                dst[3] = v >> 24;
                break;
        case AFMT_S32_BE:       /* FALLTHROUGH */
        case AFMT_F32_BE:
                dst[3] = v;
                dst[2] = v >> 8;
                dst[1] = v >> 16;
                dst[0] = v >> 24;
                break;
        case AFMT_U32_LE:
                dst[0] = v;
                dst[1] = v >> 8;
                dst[2] = v >> 16;
                dst[3] = (v >> 24) ^ 0x80;
                break;
        case AFMT_U32_BE:
                dst[3] = v;
                dst[2] = v >> 8;
                dst[1] = v >> 16;
                dst[0] = (v >> 24) ^ 0x80;
                break;
        default:
                printf("%s(): unknown format: 0x%08x\n", __func__, fmt);
                __assert_unreachable();
        }
}

/*
 * Write sample and normalize to original magnitude.
 */
static __always_inline __unused void
pcm_sample_write_norm(uint8_t *dst, intpcm_t v, uint32_t fmt)
{
        pcm_sample_write(dst, v >> (32 - AFMT_BIT(fmt)), fmt);
}

/*
 * To be used with pcm_sample_read_calc().
 */
static __always_inline __unused void
pcm_sample_write_calc(uint8_t *dst, intpcm_t v, uint32_t fmt)
{
#ifndef SND_PCM_64
        /* Shift back to 32-bit magnitude. */
        if (fmt & AFMT_32BIT)
                v <<= PCM_FXSHIFT;
#endif
        pcm_sample_write(dst, v, fmt);
}

static __always_inline __unused intpcm_t
pcm_clamp(intpcm32_t sample, uint32_t fmt)
{
        fmt = AFMT_ENCODING(fmt);

        switch (AFMT_BIT(fmt)) {
        case 8:
                return ((sample > PCM_S8_MAX) ? PCM_S8_MAX :
                    ((sample < PCM_S8_MIN) ? PCM_S8_MIN : sample));
        case 16:
                return ((sample > PCM_S16_MAX) ? PCM_S16_MAX :
                    ((sample < PCM_S16_MIN) ? PCM_S16_MIN : sample));
        case 24:
                return ((sample > PCM_S24_MAX) ? PCM_S24_MAX :
                    ((sample < PCM_S24_MIN) ? PCM_S24_MIN : sample));
        case 32:
                return ((sample > PCM_S32_MAX) ? PCM_S32_MAX :
                    ((sample < PCM_S32_MIN) ? PCM_S32_MIN : sample));
        default:
                printf("%s(): unknown format: 0x%08x\n", __func__, fmt);
                __assert_unreachable();
        }
}

static __always_inline __unused intpcm_t
pcm_clamp_calc(intpcm32_t sample, uint32_t fmt)
{
#ifndef SND_PCM_64
        if (fmt & AFMT_32BIT) {
                return ((sample > PCM_S24_MAX) ? PCM_S32_MAX :
                    ((sample < PCM_S24_MIN) ? PCM_S32_MIN :
                    sample << PCM_FXSHIFT));
        }
#endif

        return (pcm_clamp(sample, fmt));
}

#endif  /* !_SND_PCM_H_ */