/*
* Copyright (C) 2025 Linux Studio Plugins Project
* (C) 2025 Vladimir Sadovnikov
*
* This file is part of lsp-runtime-lib
* Created on: 16 апр. 2020 г.
*
* lsp-runtime-lib 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 3 of the License, or
* any later version.
*
* lsp-runtime-lib 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 lsp-runtime-lib. If not, see .
*/
#include
#include
#include
/*
* TODO: fix floating-point rounding
*
* https://www.cs.cmu.edu/~rbd/papers/cmj-float-to-int.html
*
* Most audio programs convert floating point samples to integer samples and write
* them to a file or an audio output device. I will assume that ‘‘correct’’ behavior
* is to round to the nearest integer value. Dealing with scale factors and overflow
* are also important issues, but there is no standard and the best approach may depend
* on the application. I will limit my discussion to rounding, which is where this bug occurs.
*
* The natural way to implement the conversion is to scale each floating point sample
* to some appropriate range (-32767 to 32767) and assign it to a signed 16-bit integer as follows:
* float f; // assume -32768 <= f <= 32767
* int i; // could also be “shortint”
* i = (int) f; // “(int) f” means “convert f to an int”
*
* The default float-to-integer conversion in C does not round to the nearest integer,
* but instead truncates toward zero. That means that signal values in the open interval (–1.0, 1.0)
* are all converted to zero (0). This interval is twice as large as the interval mapping to any other
* integer, and this introduces a nonlinear distortion into the signal. This is not just an issue of
* truncation versus rounding. It is well known that rounding to the nearest integer can be achieved by adding 0.5
* and rounding down, but the following C assignment is incorrect:
*
* i = (int)(f + 0.5);
*
* C does not round negative numbers down, so values in the interval (-1.5, 0.5) are converted to zero.
* In contrast, a correct conversion should map only the interval (-0.5, 0.5) to zero.
* There are several ways to perform rounding for audio, and, surprisingly, proper rounding can be faster
* than the default conversion in C. The direct implementation is to treat positive and negative numbers as
* different cases:
*
* float f; // assume -32768 <= f <= 32767
* int i; // could also be “shortint”
* if(f > 0) { i = (int)(f + 0.5); }
* else { i = (int)(f - 0.5); }
*
* This code has the problem of taking a branch, which is very slow relative to arithmetic on modern
* processors. However, this is a good approach if you can combine the rounding with testing for peak
* values and clipping out-ofrange values, which also treat positive and negative samples separately.
* An elegant approach, suggested by Phil Burk, the developer of JSyn and co-developer of PortAudio,
* is to offset the sample values to make them all positive, perform rounding, and then shift back.
* Note that I add an extra 0.5 before truncating to simulate rounding behavior:
*
* i = (((int) (f + 32768.5)) - 32768)
*
*/
namespace lsp
{
namespace mm
{
typedef void (*cvt_sample_t) (void *dst, const void *src, size_t samples);
static inline uint32_t read24bit(const uint8_t *p)
{
uint32_t res =
__IF_LEBE(
(uint32_t(p[0])) | (uint32_t(p[1]) << 8) | (uint32_t(p[2]) << 16),
(uint32_t(p[2])) | (uint32_t(p[1]) << 8) | (uint32_t(p[0]) << 16)
);
return res;
}
static inline void write24bit(uint8_t *p, uint32_t x)
{
__IF_LE(
p[0] = uint8_t(x);
p[1] = uint8_t(x >> 8);
p[2] = uint8_t(x >> 16);
)
__IF_BE(
p[0] = uint8_t(x >> 16);
p[1] = uint8_t(x >> 8);
p[2] = uint8_t(x);
)
}
bool sample_endian_swap(void *buf, size_t samples, size_t format)
{
size_t fmt = sformat_endian(format);
if (fmt == __IF_LEBE(SFMT_LE, SFMT_BE))
return true;
else if (fmt != __IF_LEBE(SFMT_BE, SFMT_LE))
return false;
switch (sformat_format(format))
{
case SFMT_U8:
case SFMT_S8:
break;
case SFMT_U16:
case SFMT_S16:
::lsp::byte_swap(static_cast(buf), samples);
break;
case SFMT_U32:
case SFMT_S32:
::lsp::byte_swap(static_cast(buf), samples);
break;
case SFMT_F32:
::lsp::byte_swap(static_cast(buf), samples);
break;
case SFMT_F64:
::lsp::byte_swap(static_cast(buf), samples);
break;
case SFMT_U24: case SFMT_S24:
{
uint8_t x, *ptr = static_cast(buf);
while (samples--)
{
x = ptr[0];
ptr[0] = ptr[2];
ptr[2] = x;
ptr += 3;
}
break;
}
default:
return false;
}
return true;
}
#define CVT_SHIFT(TYPE) (uint32_t(1 << (sizeof(TYPE)*8 - 1)))
#define CVT_RANGE(TYPE) (uint32_t(1 << (sizeof(TYPE)*8 - 1))-1)
// Integer conversions
#define CVT_UI_TO_UI(DTYPE, STYPE, SHIFT) \
for (STYPE *sptr = static_cast(src); samples > 0; --samples, ++sptr, ++dptr) \
*dptr = (DTYPE)((*sptr) SHIFT);
#define CVT_UI_TO_SI(DTYPE, STYPE, SHIFT) \
for (STYPE *sptr = static_cast(src); samples > 0; --samples, ++sptr, ++dptr) \
*dptr = (DTYPE)((*sptr - CVT_SHIFT(STYPE)) SHIFT);
#define CVT_SI_TO_UI(DTYPE, STYPE, SHIFT) \
for (STYPE *sptr = static_cast(src); samples > 0; --samples, ++sptr, ++dptr) \
*dptr = (DTYPE)((*sptr + CVT_SHIFT(STYPE)) SHIFT);
#define CVT_SI_TO_SI(DTYPE, STYPE, SHIFT) \
for (STYPE *sptr = static_cast(src); samples > 0; --samples, ++sptr, ++dptr) \
*dptr = (DTYPE)((*sptr) SHIFT);
#define CVT_UI_TO_FX(DTYPE, STYPE) \
for (STYPE *sptr = static_cast(src); samples > 0; --samples, ++sptr, ++dptr) \
*dptr = ((STYPE)(*sptr - CVT_SHIFT(STYPE))) * (DTYPE(1.0 / CVT_RANGE(STYPE)));
#define CVT_SI_TO_FX(DTYPE, STYPE) \
for (STYPE *sptr = static_cast(src); samples > 0; --samples, ++sptr, ++dptr) \
*dptr = ((STYPE)(*sptr)) * (DTYPE(1.0 / CVT_RANGE(STYPE)));
#define CVT_UI_TO_XI(DTYPE, STYPE, SHIFT) \
if (sign) \
CVT_UI_TO_SI(DTYPE, STYPE, SHIFT) \
else \
CVT_UI_TO_UI(DTYPE, STYPE, SHIFT)
#define CVT_SI_TO_XI(DTYPE, STYPE, SHIFT) \
if (sign) \
CVT_SI_TO_SI(DTYPE, STYPE, SHIFT) \
else \
CVT_SI_TO_UI(DTYPE, STYPE, SHIFT)
// Integer 24-bit conversions
#define CVT_U24_TO_UI(DTYPE, SHIFT) \
for (uint8_t *sptr = static_cast(src); samples > 0; --samples, sptr += 3, ++dptr) \
*dptr = (DTYPE)(read24bit(sptr) SHIFT);
#define CVT_U24_TO_SI(DTYPE, SHIFT) \
for (uint8_t *sptr = static_cast(src); samples > 0; --samples, sptr += 3, ++dptr) \
*dptr = (DTYPE)((read24bit(sptr) - 0x800000) SHIFT);
#define CVT_S24_TO_UI(DTYPE, SHIFT) \
for (uint8_t *sptr = static_cast(src); samples > 0; --samples, sptr += 3, ++dptr) \
*dptr = (DTYPE)((read24bit(sptr) + 0x800000) SHIFT);
#define CVT_S24_TO_SI(DTYPE, SHIFT) \
for (uint8_t *sptr = static_cast(src); samples > 0; --samples, sptr += 3, ++dptr) \
*dptr = (DTYPE)(read24bit(sptr) SHIFT);
#define CVT_U24_TO_FX(DTYPE) \
for (uint8_t *sptr = static_cast(src); samples > 0; --samples, sptr += 3, ++dptr) \
*dptr = (int32_t(read24bit(sptr) - 0x800000) * (DTYPE(1.0)/0x7fffff));
#define CVT_S24_TO_FX(DTYPE) \
for (uint8_t *sptr = static_cast(src); samples > 0; --samples, sptr += 3, ++dptr) \
*dptr = ((int32_t(read24bit(sptr) << 8) >> 8) * (DTYPE(1.0)/0x7fffff));
#define CVT_U24_TO_XI(DTYPE, SHIFT) \
if (sign) \
CVT_U24_TO_SI(DTYPE, SHIFT) \
else \
CVT_U24_TO_UI(DTYPE, SHIFT)
#define CVT_S24_TO_XI(DTYPE, SHIFT) \
if (sign) \
CVT_S24_TO_SI(DTYPE, SHIFT) \
else \
CVT_S24_TO_UI(DTYPE, SHIFT)
#define CVT_UI_TO_UI24(STYPE, SHIFT) \
for (STYPE *sptr = static_cast(src); samples > 0; --samples, ++sptr, dptr += 3) \
write24bit(dptr, uint32_t((*sptr) SHIFT));
#define CVT_UI_TO_SI24(STYPE, SHIFT) \
for (STYPE *sptr = static_cast(src); samples > 0; --samples, ++sptr, dptr += 3) \
write24bit(dptr, uint32_t((*sptr - CVT_SHIFT(STYPE)) SHIFT));
#define CVT_SI_TO_UI24(STYPE, SHIFT) \
for (STYPE *sptr = static_cast(src); samples > 0; --samples, ++sptr, dptr += 3) \
write24bit(dptr, uint32_t((*sptr + CVT_SHIFT(STYPE)) SHIFT));
#define CVT_SI_TO_SI24(STYPE, SHIFT) \
for (STYPE *sptr = static_cast(src); samples > 0; --samples, ++sptr, dptr += 3) \
write24bit(dptr, uint32_t((*sptr) SHIFT));
#define CVT_UI_TO_XI24(STYPE, SHIFT) \
if (sign) \
CVT_UI_TO_SI24(STYPE, SHIFT) \
else \
CVT_UI_TO_UI24(STYPE, SHIFT)
#define CVT_SI_TO_XI24(STYPE, SHIFT) \
if (sign) \
CVT_SI_TO_SI24(STYPE, SHIFT) \
else \
CVT_SI_TO_UI24(STYPE, SHIFT)
#define CVT_SI24_TO_UI24() \
for (uint8_t *sptr = static_cast(src); samples > 0; --samples, sptr += 3, dptr += 3) \
write24bit(dptr, read24bit(sptr) + 0x800000);
#define CVT_UI24_TO_SI24() \
for (uint8_t *sptr = static_cast(src); samples > 0; --samples, sptr += 3, dptr += 3) \
write24bit(dptr, read24bit(sptr) - 0x800000);
// Float conversions
#define CVT_F32_TO_UI(STYPE, DTYPE) \
for (f32_t *sptr = static_cast(src); samples > 0; --samples, ++sptr, ++dptr) \
*dptr = (STYPE)(*sptr * f32_t(CVT_RANGE(DTYPE))) + (DTYPE)CVT_SHIFT(DTYPE);
#define CVT_F32_TO_SI(DTYPE) \
for (f32_t *sptr = static_cast(src); samples > 0; --samples, ++sptr, ++dptr) \
*dptr = (DTYPE)(*sptr * f32_t(CVT_RANGE(DTYPE)));
#define CVT_F32_TO_XI(STYPE, DTYPE) \
if (sign) \
CVT_F32_TO_SI(STYPE) \
else \
CVT_F32_TO_UI(STYPE, DTYPE)
// Double conversions
#define CVT_F64_TO_UI(STYPE, DTYPE) \
for (f64_t *sptr = static_cast(src); samples > 0; --samples, ++sptr, ++dptr) \
*dptr = (STYPE)(*sptr * f64_t(CVT_RANGE(DTYPE))) + (DTYPE)CVT_SHIFT(DTYPE);
#define CVT_F64_TO_SI(DTYPE) \
for (f64_t *sptr = static_cast(src); samples > 0; --samples, ++sptr, ++dptr) \
*dptr = (DTYPE)(*sptr * f64_t(CVT_RANGE(DTYPE)));
#define CVT_F64_TO_XI(STYPE, DTYPE) \
if (sign) \
CVT_F64_TO_SI(STYPE) \
else \
CVT_F64_TO_UI(STYPE, DTYPE)
// Floating-point conversions
#define CVT_FX_TO_SI24(STYPE) \
for (STYPE *sptr = static_cast(src); samples > 0; --samples, ++sptr, dptr += 3) \
write24bit(dptr, int32_t(*sptr * 0x7fffff));
#define CVT_FX_TO_UI24(STYPE) \
for (STYPE *sptr = static_cast(src); samples > 0; --samples, ++sptr, dptr += 3) \
write24bit(dptr, int32_t(*sptr * 0x7fffff) - 0x800000);
#define CVT_FX_TO_XI24(STYPE) \
if (sign) \
CVT_FX_TO_SI24(STYPE) \
else \
CVT_FX_TO_UI24(STYPE)
#define CVT_FX_TO_UI32(STYPE) \
for (STYPE *sptr = static_cast(src); samples > 0; --samples, ++sptr, ++dptr) \
*dptr = (int32_t)(*sptr * f64_t(CVT_RANGE(uint32_t))) + (uint32_t)CVT_SHIFT(uint32_t);
#define CVT_FX_TO_SI32(STYPE) \
for (STYPE *sptr = static_cast(src); samples > 0; --samples, ++sptr, ++dptr) \
*dptr = (int32_t)(*sptr * f64_t(CVT_RANGE(uint32_t)));
#define CVT_FX_TO_XI32(STYPE) \
if (sign) \
CVT_FX_TO_SI32(STYPE) \
else \
CVT_FX_TO_UI32(STYPE)
#define CVT_FX_TO_FX(DTYPE, STYPE) \
for (STYPE *sptr = static_cast(src); samples > 0; --samples, ++sptr, ++dptr) \
*dptr = (DTYPE)(*sptr);
bool convert_to_8bit(void *dst, void *src, size_t samples, size_t to, size_t from)
{
int sign = sformat_sign(to);
if (sign < 0)
return false;
uint8_t *dptr = static_cast(dst);
switch (sformat_format(from))
{
case SFMT_U8:
if (sign) CVT_UI_TO_SI(uint8_t, uint8_t, )
else ::memcpy(dptr, src, samples * sizeof(uint8_t));
return true;
case SFMT_S8:
if (sign) ::memcpy(dptr, src, samples * sizeof(uint8_t));
else CVT_SI_TO_UI(uint8_t, uint8_t, )
return true;
case SFMT_U16: CVT_UI_TO_XI(uint8_t, uint16_t, >> 8) return true;
case SFMT_S16: CVT_SI_TO_XI(uint8_t, uint16_t, >> 8) return true;
case SFMT_U24: CVT_U24_TO_XI(uint8_t, >> 16) return true;
case SFMT_S24: CVT_S24_TO_XI(uint8_t, >> 16) return true;
case SFMT_U32: CVT_UI_TO_XI(uint8_t, uint32_t, >> 24) return true;
case SFMT_S32: CVT_SI_TO_XI(uint8_t, uint32_t, >> 24) return true;
case SFMT_F32: CVT_F32_TO_XI(int8_t, uint8_t) return true;
case SFMT_F64: CVT_F64_TO_XI(int8_t, uint8_t) return true;
default:
break;
}
return false;
}
bool convert_to_16bit(void *dst, void *src, size_t samples, size_t to, size_t from)
{
int sign = sformat_sign(to);
if (sign < 0)
return false;
uint16_t *dptr = static_cast(dst);
switch (sformat_format(from))
{
case SFMT_U8: CVT_UI_TO_XI(uint16_t, uint8_t, << 8) return true;
case SFMT_S8: CVT_SI_TO_XI(uint16_t, uint8_t, << 8) return true;
case SFMT_U16:
if (sign) CVT_UI_TO_SI(uint16_t, uint16_t, )
else ::memcpy(dptr, src, samples * sizeof(uint16_t));
return true;
case SFMT_S16:
if (sign) ::memcpy(dptr, src, samples * sizeof(uint16_t));
else CVT_SI_TO_UI(uint16_t, uint16_t, )
return true;
case SFMT_U24: CVT_U24_TO_XI(uint16_t, >> 8) return true;
case SFMT_S24: CVT_S24_TO_XI(uint16_t, >> 8) return true;
case SFMT_U32: CVT_UI_TO_XI(uint16_t, uint32_t, >> 16) return true;
case SFMT_S32: CVT_SI_TO_XI(uint16_t, uint32_t, >> 16) return true;
case SFMT_F32: CVT_F32_TO_XI(int16_t, uint16_t) return true;
case SFMT_F64: CVT_F64_TO_XI(int16_t, uint16_t) return true;
default:
break;
}
return false;
}
bool convert_to_24bit(void *dst, void *src, size_t samples, size_t to, size_t from)
{
int sign = sformat_sign(to);
if (sign < 0)
return false;
uint8_t *dptr = static_cast(dst);
switch (sformat_format(from))
{
case SFMT_U8: CVT_UI_TO_XI24(uint8_t, << 16) return true;
case SFMT_S8: CVT_SI_TO_XI24(uint8_t, << 16) return true;
case SFMT_U16: CVT_UI_TO_XI24(uint16_t, << 8) return true;
case SFMT_S16: CVT_SI_TO_XI24(uint16_t, << 8) return true;
case SFMT_U24:
if (sign) CVT_UI24_TO_SI24()
else ::memcpy(dptr, src, samples * sizeof(uint8_t) * 3);
return true;
case SFMT_S24:
if (sign) ::memcpy(dptr, src, samples * sizeof(uint8_t) * 3);
else CVT_SI24_TO_UI24()
return true;
case SFMT_U32: CVT_UI_TO_XI24(uint32_t, >> 8) return true;
case SFMT_S32: CVT_SI_TO_XI24(uint32_t, >> 8) return true;
case SFMT_F32: CVT_FX_TO_XI24(f32_t) return true;
case SFMT_F64: CVT_FX_TO_XI24(f64_t) return true;
default:
break;
}
return false;
}
bool convert_to_32bit(void *dst, void *src, size_t samples, size_t to, size_t from)
{
int sign = sformat_sign(to);
if (sign < 0)
return false;
uint32_t *dptr = static_cast(dst);
switch (sformat_format(from))
{
case SFMT_U8: CVT_UI_TO_XI(uint32_t, uint8_t, << 24) return true;
case SFMT_S8: CVT_SI_TO_XI(uint32_t, uint8_t, << 24) return true;
case SFMT_U16: CVT_UI_TO_XI(uint32_t, uint16_t, << 16) return true;
case SFMT_S16: CVT_SI_TO_XI(uint32_t, uint16_t, << 16) return true;
case SFMT_U24: CVT_U24_TO_XI(uint32_t, << 8) return true;
case SFMT_S24: CVT_S24_TO_XI(uint32_t, << 8) return true;
case SFMT_U32:
if (sign) CVT_UI_TO_SI(uint32_t, uint32_t, )
else ::memcpy(dptr, src, samples * sizeof(uint32_t));
return true;
case SFMT_S32:
if (sign) ::memcpy(dptr, src, samples * sizeof(uint32_t));
else CVT_SI_TO_UI(uint32_t, uint32_t, )
return true;
case SFMT_F32: CVT_FX_TO_XI32(f32_t) return true;
case SFMT_F64: CVT_FX_TO_XI32(f64_t) return true;
default:
break;
}
return false;
}
bool convert_to_f32(void *dst, void *src, size_t samples, size_t to, size_t from)
{
f32_t *dptr = static_cast(dst);
switch (sformat_format(from))
{
case SFMT_U8: CVT_UI_TO_FX(f32_t, int8_t) return true;
case SFMT_S8: CVT_SI_TO_FX(f32_t, int8_t) return true;
case SFMT_U16: CVT_UI_TO_FX(f32_t, int16_t) return true;
case SFMT_S16: CVT_SI_TO_FX(f32_t, int16_t) return true;
case SFMT_U24: CVT_U24_TO_FX(f32_t) return true;
case SFMT_S24: CVT_S24_TO_FX(f32_t) return true;
case SFMT_U32: CVT_UI_TO_FX(f32_t, int32_t) return true;
case SFMT_S32: CVT_SI_TO_FX(f32_t, int32_t) return true;
case SFMT_F32:
::memcpy(dptr, src, samples * sizeof(f32_t));
return true;
case SFMT_F64: CVT_FX_TO_FX(f32_t, f64_t) return true;
default:
break;
}
return false;
}
bool convert_to_f64(void *dst, void *src, size_t samples, size_t to, size_t from)
{
f64_t *dptr = static_cast(dst);
switch (sformat_format(from))
{
case SFMT_U8: CVT_UI_TO_FX(f64_t, int8_t) return true;
case SFMT_S8: CVT_SI_TO_FX(f64_t, int8_t) return true;
case SFMT_U16: CVT_UI_TO_FX(f64_t, int16_t) return true;
case SFMT_S16: CVT_SI_TO_FX(f64_t, int16_t) return true;
case SFMT_U24: CVT_U24_TO_FX(f64_t) return true;
case SFMT_S24: CVT_S24_TO_FX(f64_t) return true;
case SFMT_U32: CVT_UI_TO_FX(f64_t, int32_t) return true;
case SFMT_S32: CVT_SI_TO_FX(f64_t, int32_t) return true;
case SFMT_F32: CVT_FX_TO_FX(f64_t, f32_t) return true;
case SFMT_F64:
::memcpy(dptr, src, samples * sizeof(f64_t));
return true;
default:
break;
}
return false;
}
bool convert_samples(void *dst, void *src, size_t samples, size_t to, size_t from)
{
// Convert source sample endianess
if (!sample_endian_swap(src, samples, from))
return false;
// Apply sample conversion
switch (sformat_format(to))
{
case SFMT_U8:
case SFMT_S8:
return convert_to_8bit(dst, src, samples, to, from);
case SFMT_U16:
case SFMT_S16:
return convert_to_16bit(dst, src, samples, to, from);
case SFMT_U24:
case SFMT_S24:
return convert_to_24bit(dst, src, samples, to, from);
case SFMT_U32:
case SFMT_S32:
return convert_to_32bit(dst, src, samples, to, from);
case SFMT_F32:
return convert_to_f32(dst, src, samples, to, from);
case SFMT_F64:
return convert_to_f64(dst, src, samples, to, from);
default:
break;
}
// Convert target sample endianess
if (!sample_endian_swap(dst, samples, to))
return false;
return false;
}
} /* namespace mm */
} /* namespace lsp */