mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-03 09:01:54 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
pipewire/spa/plugins/audioconvert/fmt-ops.h

429 lines
14 KiB
C
Raw Normal View History

audioconvert: handle more optimizations Compile an optimized library for the given CPU with the right flags, then link it with the main library.
2019-03-27 17:58:48 +01:00
/* Spa
*
* Copyright © 2019 Wim Taymans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#include <math.h>
Add support for MidnightBSD Fix build issue Fix build issue
2022-06-19 14:03:56 -04:00
#if defined(__FreeBSD__) || defined(__MidnightBSD__)
Don't include byteswap.h on FreeBSD, use sys/endian.h instead
2021-10-22 17:50:42 +03:00
#include <sys/endian.h>
#define bswap_16 bswap16
#define bswap_32 bswap32
Fix build on FreeBSD by defining bswap_64.
2022-01-26 11:06:58 +03:00
#define bswap_64 bswap64
Don't include byteswap.h on FreeBSD, use sys/endian.h instead
2021-10-22 17:50:42 +03:00
#else
audioconvert: add more conversions Add the other endian conversions.
2021-08-17 14:45:00 +02:00
#include <byteswap.h>
Don't include byteswap.h on FreeBSD, use sys/endian.h instead
2021-10-22 17:50:42 +03:00
#endif
audioconvert: handle more optimizations Compile an optimized library for the given CPU with the right flags, then link it with the main library.
2019-03-27 17:58:48 +01:00
#include <spa/utils/defs.h>
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
#include <spa/utils/string.h>
#define FMT_OPS_MAX_ALIGN 32
audioconvert: handle more optimizations Compile an optimized library for the given CPU with the right flags, then link it with the main library.
2019-03-27 17:58:48 +01:00
audioconvert: improve format conversion Make dither noise as a value between -0.5 and 0.5 and add this to the scaled samples. For this, we first need to do the scaling and then the CLAMP to the target depth. This optimizes to the same code but allows us to avoid under and overflows when we add the dither noise. Add more dithering methods. Expose a dither.method property on audioconvert. Disable dither when the target depth > 16.
2022-06-29 14:10:15 +02:00
#define U8_MIN 0u
#define U8_MAX 255u
#define U8_SCALE 127.5f
#define U8_OFFS 128.f
#define U8_TO_F32(v) ((((uint8_t)(v)) * (1.0f / U8_OFFS)) - 1.0)
#define F32_TO_U8(v) (uint8_t)SPA_CLAMP((v) * U8_SCALE + U8_OFFS, U8_MIN, U8_MAX)
#define F32_TO_U8_D(v,d) (uint8_t)SPA_CLAMP((v) * U8_SCALE + U8_OFFS + (d), U8_MIN, U8_MAX)
#define S8_MIN -127
#define S8_MAX 127
#define S8_MAX_F 127.0f
#define S8_SCALE 127.0f
#define S8_TO_F32(v) (((int8_t)(v)) * (1.0f / S8_SCALE))
#define F32_TO_S8(v) (int8_t)SPA_CLAMP((v) * S8_SCALE, S8_MIN, S8_MAX)
#define F32_TO_S8_D(v,d) (int8_t)SPA_CLAMP((v) * S8_SCALE + (d), S8_MIN, S8_MAX)
#define U16_MIN 0u
#define U16_MAX 65535u
#define U16_SCALE 32767.5f
#define U16_OFFS 32768.f
#define U16_TO_F32(v) ((((uint16_t)(v)) * (1.0f / U16_OFFS)) - 1.0)
#define U16S_TO_F32(v) (((uint16_t)bswap_16((uint16_t)(v)) * (1.0f / U16_OFFS)) - 1.0)
#define F32_TO_U16(v) (uint16_t)SPA_CLAMP((v) * U16_SCALE + U16_OFFS, U16_MIN, U16_MAX)
#define F32_TO_U16_D(v,d) (uint16_t)SPA_CLAMP((v) * U16_SCALE + U16_OFFS + (d), U16_MIN, U16_MAX)
#define F32_TO_U16S(v) bswap_16(F32_TO_U16(v))
#define F32_TO_U16S_D(v,d) bswap_16(F32_TO_U16_D(v,d))
#define S16_MIN -32767
#define S16_MAX 32767
#define S16_MAX_F 32767.0f
#define S16_SCALE 32767.0f
#define S16_TO_F32(v) (((int16_t)(v)) * (1.0f / S16_SCALE))
#define S16S_TO_F32(v) (((int16_t)bswap_16(v)) * (1.0f / S16_SCALE))
#define F32_TO_S16(v) (int16_t)SPA_CLAMP((v) * S16_SCALE, S16_MIN, S16_MAX)
#define F32_TO_S16_D(v,d) (int16_t)SPA_CLAMP((v) * S16_SCALE + (d), S16_MIN, S16_MAX)
#define F32_TO_S16S(v) bswap_16(F32_TO_S16(v))
#define F32_TO_S16S_D(v,d) bswap_16(F32_TO_S16_D(v,d))
#define U24_MIN 0u
#define U24_MAX 16777215u
#define U24_SCALE 8388607.5f
#define U24_OFFS 8388608.f
#define U24_TO_F32(v) ((((uint32_t)(v)) * (1.0f / U24_OFFS)) - 1.0)
#define F32_TO_U24(v) (uint32_t)SPA_CLAMP((v) * U24_SCALE + U24_OFFS, U24_MIN, U24_MAX)
#define F32_TO_U24_D(v,d) (uint32_t)SPA_CLAMP((v) * U24_SCALE + U24_OFFS + (d), U24_MIN, U24_MAX)
#define S24_MIN -8388607
#define S24_MAX 8388607
#define S24_MAX_F 8388607.0f
#define S24_SCALE 8388607.0f
#define S24_TO_F32(v) (((int32_t)(v)) * (1.0f / S24_SCALE))
#define F32_TO_S24(v) (int32_t)SPA_CLAMP((v) * S24_SCALE, S24_MIN, S24_MAX)
#define F32_TO_S24_D(v,d) (int32_t)SPA_CLAMP((v) * S24_SCALE + (d), S24_MIN, S24_MAX)
#define U32_MIN 0u
#define U32_MAX 4294967040u
#define U32_SCALE 2147483520.f
#define U32_OFFS 2147483520.f
#define U32_TO_F32(v) ((((uint32_t)(v)) * (1.0f / U32_OFFS)) - 1.0)
#define F32_TO_U32(v) (uint32_t)SPA_CLAMP((v) * U32_SCALE + U32_OFFS, U32_MIN, U32_MAX)
#define F32_TO_U32_D(v,d) (uint32_t)SPA_CLAMP((v) * U32_SCALE + U32_OFFS + (d), U32_MIN, U32_MAX)
#define S32_MIN -2147483520
#define S32_MAX 2147483520
#define S32_MAX_F 2147483520.f
#define S32_SCALE 2147483648.f
#define S32_TO_F32(v) (((int32_t)(v)) * (1.0f / S32_SCALE))
#define S32S_TO_F32(v) (((int32_t)bswap_32(v)) * (1.0f / S32_SCALE))
#define F32_TO_S32(v) (int32_t)SPA_CLAMP((v) * S32_SCALE, S32_MIN, S32_MAX)
#define F32_TO_S32_D(v,d) (int32_t)SPA_CLAMP((v) * S32_SCALE + (d), S32_MIN, S32_MAX)
#define F32_TO_S32S(v) bswap_32(F32_TO_S32(v))
#define F32_TO_S32S_D(v,d) bswap_32(F32_TO_S32_D(v,d))
audioconvert: handle more optimizations Compile an optimized library for the given CPU with the right flags, then link it with the main library.
2019-03-27 17:58:48 +01:00
fmtconvert: add support for U16, U24, U32 and U24_32 formats
2021-09-08 09:07:49 -04:00
#define U24_32_TO_F32(v) U32_TO_F32((v)<<8)
#define U24_32S_TO_F32(v) U32_TO_F32(((int32_t)bswap_32(v))<<8)
#define F32_TO_U24_32(v) F32_TO_U24(v)
#define F32_TO_U24_32S(v) bswap_32(F32_TO_U24(v))
audioconvert: improve format conversion Make dither noise as a value between -0.5 and 0.5 and add this to the scaled samples. For this, we first need to do the scaling and then the CLAMP to the target depth. This optimizes to the same code but allows us to avoid under and overflows when we add the dither noise. Add more dithering methods. Expose a dither.method property on audioconvert. Disable dither when the target depth > 16.
2022-06-29 14:10:15 +02:00
#define F32_TO_U24_32_D(v,d) F32_TO_U24_D(v,d)
#define F32_TO_U24_32S_D(v,d) bswap_32(F32_TO_U24_D(v,d))
fmtconvert: add support for U16, U24, U32 and U24_32 formats
2021-09-08 09:07:49 -04:00
audioconvert: fix s24_32 to float s24_32 needs to be sign extended before converting to float because the upper bits are undefined and might be anything. Fixes #1393
2021-07-06 12:42:39 +02:00
#define S24_32_TO_F32(v) S32_TO_F32((v)<<8)
audioconvert: add more format support Add support to endian conversion as well.
2021-08-17 15:03:03 +02:00
#define S24_32S_TO_F32(v) S32_TO_F32(((int32_t)bswap_32(v))<<8)
audioconvert: fix s24_32 to float s24_32 needs to be sign extended before converting to float because the upper bits are undefined and might be anything. Fixes #1393
2021-07-06 12:42:39 +02:00
#define F32_TO_S24_32(v) F32_TO_S24(v)
audioconvert: add more conversions Add the other endian conversions.
2021-08-17 14:45:00 +02:00
#define F32_TO_S24_32S(v) bswap_32(F32_TO_S24(v))
audioconvert: improve format conversion Make dither noise as a value between -0.5 and 0.5 and add this to the scaled samples. For this, we first need to do the scaling and then the CLAMP to the target depth. This optimizes to the same code but allows us to avoid under and overflows when we add the dither noise. Add more dithering methods. Expose a dither.method property on audioconvert. Disable dither when the target depth > 16.
2022-06-29 14:10:15 +02:00
#define F32_TO_S24_32_D(v,d) F32_TO_S24_D(v,d)
#define F32_TO_S24_32S_D(v,d) bswap_32(F32_TO_S24_D(v,d))
audioconvert: fix s24_32 to float s24_32 needs to be sign extended before converting to float because the upper bits are undefined and might be anything. Fixes #1393
2021-07-06 12:42:39 +02:00
fmtconvert: add support for U16, U24, U32 and U24_32 formats
2021-09-08 09:07:49 -04:00
static inline uint32_t read_u24(const void *src)
{
const uint8_t *s = src;
#if __BYTE_ORDER == __LITTLE_ENDIAN
return (((uint32_t)s[2] << 16) | ((uint32_t)(uint8_t)s[1] << 8) | (uint32_t)(uint8_t)s[0]);
#else
return (((uint32_t)s[0] << 16) | ((uint32_t)(uint8_t)s[1] << 8) | (uint32_t)(uint8_t)s[2]);
#endif
}
audioconvert: handle more optimizations Compile an optimized library for the given CPU with the right flags, then link it with the main library.
2019-03-27 17:58:48 +01:00
static inline int32_t read_s24(const void *src)
{
const int8_t *s = src;
#if __BYTE_ORDER == __LITTLE_ENDIAN
return (((int32_t)s[2] << 16) | ((uint32_t)(uint8_t)s[1] << 8) | (uint32_t)(uint8_t)s[0]);
#else
return (((int32_t)s[0] << 16) | ((uint32_t)(uint8_t)s[1] << 8) | (uint32_t)(uint8_t)s[2]);
#endif
}
fmt-ops: add support for s24 with endian conversion
2020-01-27 15:46:25 +01:00
static inline int32_t read_s24s(const void *src)
{
const int8_t *s = src;
#if __BYTE_ORDER == __LITTLE_ENDIAN
return (((int32_t)s[0] << 16) | ((uint32_t)(uint8_t)s[1] << 8) | (uint32_t)(uint8_t)s[2]);
#else
return (((int32_t)s[2] << 16) | ((uint32_t)(uint8_t)s[1] << 8) | (uint32_t)(uint8_t)s[0]);
#endif
}
fmtconvert: add support for U16, U24, U32 and U24_32 formats
2021-09-08 09:07:49 -04:00
static inline void write_u24(void *dst, uint32_t val)
{
uint8_t *d = dst;
#if __BYTE_ORDER == __LITTLE_ENDIAN
d[0] = (uint8_t) (val);
d[1] = (uint8_t) (val >> 8);
d[2] = (uint8_t) (val >> 16);
#else
d[0] = (uint8_t) (val >> 16);
d[1] = (uint8_t) (val >> 8);
d[2] = (uint8_t) (val);
#endif
}
audioconvert: handle more optimizations Compile an optimized library for the given CPU with the right flags, then link it with the main library.
2019-03-27 17:58:48 +01:00
static inline void write_s24(void *dst, int32_t val)
{
uint8_t *d = dst;
#if __BYTE_ORDER == __LITTLE_ENDIAN
d[0] = (uint8_t) (val);
d[1] = (uint8_t) (val >> 8);
d[2] = (uint8_t) (val >> 16);
#else
d[0] = (uint8_t) (val >> 16);
d[1] = (uint8_t) (val >> 8);
d[2] = (uint8_t) (val);
#endif
}
fmt-ops: add support for s24 with endian conversion
2020-01-27 15:46:25 +01:00
static inline void write_s24s(void *dst, int32_t val)
{
uint8_t *d = dst;
#if __BYTE_ORDER == __LITTLE_ENDIAN
d[0] = (uint8_t) (val >> 16);
d[1] = (uint8_t) (val >> 8);
d[2] = (uint8_t) (val);
#else
d[0] = (uint8_t) (val);
d[1] = (uint8_t) (val >> 8);
d[2] = (uint8_t) (val >> 16);
#endif
}
audioconvert: pass state to functions Pass some state to convert and channelmix functions. This makes it possible to select per channel optimized convert functions but also makes it possible to implement noise shaping later. Pass the channelmix matrix and volume in the state. Handle specialized 2 channel s16 -> f32 conversion
2019-03-29 17:39:59 +01:00
#define MAX_NS 64
struct convert {
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
uint32_t quantize;
uint32_t noise;
#define DITHER_METHOD_NONE 0
#define DITHER_METHOD_RECTANGULAR 1
#define DITHER_METHOD_TRIANGULAR 2
#define DITHER_METHOD_SHAPED_5 3
uint32_t method;
audioconvert: pass state to functions Pass some state to convert and channelmix functions. This makes it possible to select per channel optimized convert functions but also makes it possible to implement noise shaping later. Pass the channelmix matrix and volume in the state. Handle specialized 2 channel s16 -> f32 conversion
2019-03-29 17:39:59 +01:00
uint32_t src_fmt;
uint32_t dst_fmt;
uint32_t n_channels;
audioconvert: improve format conversion Make dither noise as a value between -0.5 and 0.5 and add this to the scaled samples. For this, we first need to do the scaling and then the CLAMP to the target depth. This optimizes to the same code but allows us to avoid under and overflows when we add the dither noise. Add more dithering methods. Expose a dither.method property on audioconvert. Disable dither when the target depth > 16.
2022-06-29 14:10:15 +02:00
uint32_t rate;
audioconvert: pass state to functions Pass some state to convert and channelmix functions. This makes it possible to select per channel optimized convert functions but also makes it possible to implement noise shaping later. Pass the channelmix matrix and volume in the state. Handle specialized 2 channel s16 -> f32 conversion
2019-03-29 17:39:59 +01:00
uint32_t cpu_flags;
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
const char *func_name;
audioconvert: pass state to functions Pass some state to convert and channelmix functions. This makes it possible to select per channel optimized convert functions but also makes it possible to implement noise shaping later. Pass the channelmix matrix and volume in the state. Handle specialized 2 channel s16 -> f32 conversion
2019-03-29 17:39:59 +01:00
make bitfields unsigned Remove driver property from client-node of client-stream.
2019-04-10 17:52:42 +02:00
unsigned int is_passthrough:1;
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
audioconvert: improve format conversion Make dither noise as a value between -0.5 and 0.5 and add this to the scaled samples. For this, we first need to do the scaling and then the CLAMP to the target depth. This optimizes to the same code but allows us to avoid under and overflows when we add the dither noise. Add more dithering methods. Expose a dither.method property on audioconvert. Disable dither when the target depth > 16.
2022-06-29 14:10:15 +02:00
float scale;
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
uint32_t random[16 + FMT_OPS_MAX_ALIGN/4];
audioconvert: improve format conversion Make dither noise as a value between -0.5 and 0.5 and add this to the scaled samples. For this, we first need to do the scaling and then the CLAMP to the target depth. This optimizes to the same code but allows us to avoid under and overflows when we add the dither noise. Add more dithering methods. Expose a dither.method property on audioconvert. Disable dither when the target depth > 16.
2022-06-29 14:10:15 +02:00
float *dither;
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
uint32_t dither_size;
audioconvert: pass state to functions Pass some state to convert and channelmix functions. This makes it possible to select per channel optimized convert functions but also makes it possible to implement noise shaping later. Pass the channelmix matrix and volume in the state. Handle specialized 2 channel s16 -> f32 conversion
2019-03-29 17:39:59 +01:00
float ns_data[MAX_NS];
uint32_t ns_idx;
uint32_t ns_size;
void (*process) (struct convert *conv, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[],
uint32_t n_samples);
void (*free) (struct convert *conv);
};
int convert_init(struct convert *conv);
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
static const struct dither_method_info {
const char *label;
const char *description;
uint32_t method;
} dither_method_info[] = {
[DITHER_METHOD_NONE] = { "none", "Disabled", DITHER_METHOD_NONE },
[DITHER_METHOD_RECTANGULAR] = { "rectangular", "Rectangular dithering", DITHER_METHOD_RECTANGULAR },
[DITHER_METHOD_TRIANGULAR] = { "triangular", "Triangular dithering", DITHER_METHOD_TRIANGULAR },
[DITHER_METHOD_SHAPED_5] = { "shaped5", "Shaped 5 dithering", DITHER_METHOD_SHAPED_5 }
};
static inline uint32_t dither_method_from_label(const char *label)
{
uint32_t i;
for (i = 0; i < SPA_N_ELEMENTS(dither_method_info); i++) {
if (spa_streq(dither_method_info[i].label, label))
return dither_method_info[i].method;
}
return DITHER_METHOD_NONE;
}
audioconvert: pass state to functions Pass some state to convert and channelmix functions. This makes it possible to select per channel optimized convert functions but also makes it possible to implement noise shaping later. Pass the channelmix matrix and volume in the state. Handle specialized 2 channel s16 -> f32 conversion
2019-03-29 17:39:59 +01:00
#define convert_process(conv,...) (conv)->process(conv, __VA_ARGS__)
#define convert_free(conv) (conv)->free(conv)
audioconvert: handle more optimizations Compile an optimized library for the given CPU with the right flags, then link it with the main library.
2019-03-27 17:58:48 +01:00
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
#define DEFINE_FUNCTION(name,arch) \
audioconvert: pass state to functions Pass some state to convert and channelmix functions. This makes it possible to select per channel optimized convert functions but also makes it possible to implement noise shaping later. Pass the channelmix matrix and volume in the state. Handle specialized 2 channel s16 -> f32 conversion
2019-03-29 17:39:59 +01:00
void conv_##name##_##arch(struct convert *conv, void * SPA_RESTRICT dst[], \
const void * SPA_RESTRICT src[], uint32_t n_samples) \
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(copy8d, c);
DEFINE_FUNCTION(copy8, c);
DEFINE_FUNCTION(copy16d, c);
DEFINE_FUNCTION(copy16, c);
DEFINE_FUNCTION(copy24d, c);
DEFINE_FUNCTION(copy24, c);
DEFINE_FUNCTION(copy32d, c);
DEFINE_FUNCTION(copy32, c);
audioconvert: add f64 conversion See #1990
2022-01-10 13:04:31 +01:00
DEFINE_FUNCTION(copy64d, c);
DEFINE_FUNCTION(copy64, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(u8d_to_f32d, c);
DEFINE_FUNCTION(u8_to_f32, c);
DEFINE_FUNCTION(u8_to_f32d, c);
DEFINE_FUNCTION(u8d_to_f32, c);
audioconvert: handle S8/S8P raw audio formats
2021-05-05 08:56:59 +03:00
DEFINE_FUNCTION(s8d_to_f32d, c);
DEFINE_FUNCTION(s8_to_f32, c);
DEFINE_FUNCTION(s8_to_f32d, c);
DEFINE_FUNCTION(s8d_to_f32, c);
audioconvert: add converstion to and from alaw/ulaw
2021-08-17 17:32:25 +02:00
DEFINE_FUNCTION(ulaw_to_f32d, c);
DEFINE_FUNCTION(alaw_to_f32d, c);
fmtconvert: add support for U16, U24, U32 and U24_32 formats
2021-09-08 09:07:49 -04:00
DEFINE_FUNCTION(u16_to_f32, c);
DEFINE_FUNCTION(u16_to_f32d, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(s16d_to_f32d, c);
DEFINE_FUNCTION(s16_to_f32, c);
DEFINE_FUNCTION(s16_to_f32d, c);
audioconvert: add more conversions Add the other endian conversions.
2021-08-17 14:45:00 +02:00
DEFINE_FUNCTION(s16s_to_f32d, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(s16d_to_f32, c);
fmtconvert: add support for U16, U24, U32 and U24_32 formats
2021-09-08 09:07:49 -04:00
DEFINE_FUNCTION(u32_to_f32, c);
DEFINE_FUNCTION(u32_to_f32d, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(s32d_to_f32d, c);
DEFINE_FUNCTION(s32_to_f32, c);
DEFINE_FUNCTION(s32_to_f32d, c);
audioconvert: add more conversions Add the other endian conversions.
2021-08-17 14:45:00 +02:00
DEFINE_FUNCTION(s32s_to_f32d, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(s32d_to_f32, c);
fmtconvert: add support for U16, U24, U32 and U24_32 formats
2021-09-08 09:07:49 -04:00
DEFINE_FUNCTION(u24_to_f32, c);
DEFINE_FUNCTION(u24_to_f32d, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(s24d_to_f32d, c);
DEFINE_FUNCTION(s24_to_f32, c);
DEFINE_FUNCTION(s24_to_f32d, c);
fmt-ops: add support for s24 with endian conversion
2020-01-27 15:46:25 +01:00
DEFINE_FUNCTION(s24s_to_f32d, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(s24d_to_f32, c);
fmtconvert: add support for U16, U24, U32 and U24_32 formats
2021-09-08 09:07:49 -04:00
DEFINE_FUNCTION(u24_32_to_f32, c);
DEFINE_FUNCTION(u24_32_to_f32d, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(s24_32d_to_f32d, c);
DEFINE_FUNCTION(s24_32_to_f32, c);
DEFINE_FUNCTION(s24_32_to_f32d, c);
audioconvert: add more conversions Add the other endian conversions.
2021-08-17 14:45:00 +02:00
DEFINE_FUNCTION(s24_32s_to_f32d, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(s24_32d_to_f32, c);
audioconvert: add f64 conversion See #1990
2022-01-10 13:04:31 +01:00
DEFINE_FUNCTION(f64d_to_f32d, c);
DEFINE_FUNCTION(f64_to_f32, c);
DEFINE_FUNCTION(f64_to_f32d, c);
DEFINE_FUNCTION(f64s_to_f32d, c);
DEFINE_FUNCTION(f64d_to_f32, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(f32d_to_u8d, c);
audioconvert: improve format conversion Make dither noise as a value between -0.5 and 0.5 and add this to the scaled samples. For this, we first need to do the scaling and then the CLAMP to the target depth. This optimizes to the same code but allows us to avoid under and overflows when we add the dither noise. Add more dithering methods. Expose a dither.method property on audioconvert. Disable dither when the target depth > 16.
2022-06-29 14:10:15 +02:00
DEFINE_FUNCTION(f32d_to_u8d_dither, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(f32_to_u8, c);
DEFINE_FUNCTION(f32_to_u8d, c);
DEFINE_FUNCTION(f32d_to_u8, c);
audioconvert: improve format conversion Make dither noise as a value between -0.5 and 0.5 and add this to the scaled samples. For this, we first need to do the scaling and then the CLAMP to the target depth. This optimizes to the same code but allows us to avoid under and overflows when we add the dither noise. Add more dithering methods. Expose a dither.method property on audioconvert. Disable dither when the target depth > 16.
2022-06-29 14:10:15 +02:00
DEFINE_FUNCTION(f32d_to_u8_dither, c);
audioconvert: handle S8/S8P raw audio formats
2021-05-05 08:56:59 +03:00
DEFINE_FUNCTION(f32d_to_s8d, c);
audioconvert: improve format conversion Make dither noise as a value between -0.5 and 0.5 and add this to the scaled samples. For this, we first need to do the scaling and then the CLAMP to the target depth. This optimizes to the same code but allows us to avoid under and overflows when we add the dither noise. Add more dithering methods. Expose a dither.method property on audioconvert. Disable dither when the target depth > 16.
2022-06-29 14:10:15 +02:00
DEFINE_FUNCTION(f32d_to_s8d_dither, c);
audioconvert: handle S8/S8P raw audio formats
2021-05-05 08:56:59 +03:00
DEFINE_FUNCTION(f32_to_s8, c);
DEFINE_FUNCTION(f32_to_s8d, c);
DEFINE_FUNCTION(f32d_to_s8, c);
audioconvert: improve format conversion Make dither noise as a value between -0.5 and 0.5 and add this to the scaled samples. For this, we first need to do the scaling and then the CLAMP to the target depth. This optimizes to the same code but allows us to avoid under and overflows when we add the dither noise. Add more dithering methods. Expose a dither.method property on audioconvert. Disable dither when the target depth > 16.
2022-06-29 14:10:15 +02:00
DEFINE_FUNCTION(f32d_to_s8_dither, c);
audioconvert: add converstion to and from alaw/ulaw
2021-08-17 17:32:25 +02:00
DEFINE_FUNCTION(f32d_to_alaw, c);
DEFINE_FUNCTION(f32d_to_ulaw, c);
fmtconvert: add support for U16, U24, U32 and U24_32 formats
2021-09-08 09:07:49 -04:00
DEFINE_FUNCTION(f32_to_u16, c);
DEFINE_FUNCTION(f32d_to_u16, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(f32d_to_s16d, c);
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
DEFINE_FUNCTION(f32d_to_s16d_dither, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(f32_to_s16, c);
DEFINE_FUNCTION(f32_to_s16d, c);
DEFINE_FUNCTION(f32d_to_s16, c);
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
DEFINE_FUNCTION(f32d_to_s16_dither, c);
audioconvert: add more conversions Add the other endian conversions.
2021-08-17 14:45:00 +02:00
DEFINE_FUNCTION(f32d_to_s16s, c);
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
DEFINE_FUNCTION(f32d_to_s16s_dither, c);
fmtconvert: add support for U16, U24, U32 and U24_32 formats
2021-09-08 09:07:49 -04:00
DEFINE_FUNCTION(f32_to_u32, c);
DEFINE_FUNCTION(f32d_to_u32, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(f32d_to_s32d, c);
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
DEFINE_FUNCTION(f32d_to_s32d_dither, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(f32_to_s32, c);
DEFINE_FUNCTION(f32_to_s32d, c);
DEFINE_FUNCTION(f32d_to_s32, c);
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
DEFINE_FUNCTION(f32d_to_s32_dither, c);
audioconvert: add more conversions Add the other endian conversions.
2021-08-17 14:45:00 +02:00
DEFINE_FUNCTION(f32d_to_s32s, c);
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
DEFINE_FUNCTION(f32d_to_s32s_dither, c);
fmtconvert: add support for U16, U24, U32 and U24_32 formats
2021-09-08 09:07:49 -04:00
DEFINE_FUNCTION(f32_to_u24, c);
DEFINE_FUNCTION(f32d_to_u24, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(f32d_to_s24d, c);
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
DEFINE_FUNCTION(f32d_to_s24d_dither, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(f32_to_s24, c);
DEFINE_FUNCTION(f32_to_s24d, c);
DEFINE_FUNCTION(f32d_to_s24, c);
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
DEFINE_FUNCTION(f32d_to_s24_dither, c);
fmt: support f32p -> s24s conversion As used by MAudio Fasttrack Pro See rhbz#916017
2021-01-14 17:58:54 +01:00
DEFINE_FUNCTION(f32d_to_s24s, c);
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
DEFINE_FUNCTION(f32d_to_s24s_dither, c);
fmtconvert: add support for U16, U24, U32 and U24_32 formats
2021-09-08 09:07:49 -04:00
DEFINE_FUNCTION(f32_to_u24_32, c);
DEFINE_FUNCTION(f32d_to_u24_32, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(f32d_to_s24_32d, c);
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
DEFINE_FUNCTION(f32d_to_s24_32d_dither, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(f32_to_s24_32, c);
DEFINE_FUNCTION(f32_to_s24_32d, c);
DEFINE_FUNCTION(f32d_to_s24_32, c);
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
DEFINE_FUNCTION(f32d_to_s24_32_dither, c);
audioconvert: add more conversions Add the other endian conversions.
2021-08-17 14:45:00 +02:00
DEFINE_FUNCTION(f32d_to_s24_32s, c);
audioconvert: move dither and noise to fmt-ops We need to do dithering and noise when converting f32 to the target format. This is more natural because we can work in 32 bits integers instead of floats. This will also make it possible to actually calculate the error between source and target values and implement some sort of feedback and noise shaping later.
2022-06-28 16:55:50 +02:00
DEFINE_FUNCTION(f32d_to_s24_32s_dither, c);
audioconvert: add f64 conversion See #1990
2022-01-10 13:04:31 +01:00
DEFINE_FUNCTION(f32d_to_f64d, c);
DEFINE_FUNCTION(f32_to_f64, c);
DEFINE_FUNCTION(f32_to_f64d, c);
DEFINE_FUNCTION(f32d_to_f64, c);
DEFINE_FUNCTION(f32d_to_f64s, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(deinterleave_8, c);
DEFINE_FUNCTION(deinterleave_16, c);
DEFINE_FUNCTION(deinterleave_24, c);
DEFINE_FUNCTION(deinterleave_32, c);
audioconvert: add more conversions Add the other endian conversions.
2021-08-17 14:45:00 +02:00
DEFINE_FUNCTION(deinterleave_32s, c);
audioconvert: add f64 conversion See #1990
2022-01-10 13:04:31 +01:00
DEFINE_FUNCTION(deinterleave_64, c);
DEFINE_FUNCTION(deinterleave_64s, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(interleave_8, c);
DEFINE_FUNCTION(interleave_16, c);
DEFINE_FUNCTION(interleave_24, c);
DEFINE_FUNCTION(interleave_32, c);
audioconvert: add more conversions Add the other endian conversions.
2021-08-17 14:45:00 +02:00
DEFINE_FUNCTION(interleave_32s, c);
audioconvert: add f64 conversion See #1990
2022-01-10 13:04:31 +01:00
DEFINE_FUNCTION(interleave_64, c);
DEFINE_FUNCTION(interleave_64s, c);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
fmt-ops: add neon optimizations for format conversion
2020-03-30 10:59:21 -04:00
#if defined(HAVE_NEON)
audioconvert: add stereo deinterleave neon asm This can take some shortcuts and convert twice as many samples in one iteration as the strided stereo deinterleave one.
2021-10-28 11:30:04 +02:00
DEFINE_FUNCTION(s16_to_f32d_2, neon);
fmt-ops: add neon optimizations for format conversion
2020-03-30 10:59:21 -04:00
DEFINE_FUNCTION(s16_to_f32d, neon);
DEFINE_FUNCTION(f32d_to_s16, neon);
#endif
audioconvert: handle more optimizations Compile an optimized library for the given CPU with the right flags, then link it with the main library.
2019-03-27 17:58:48 +01:00
#if defined(HAVE_SSE2)
audioconvert: pass state to functions Pass some state to convert and channelmix functions. This makes it possible to select per channel optimized convert functions but also makes it possible to implement noise shaping later. Pass the channelmix matrix and volume in the state. Handle specialized 2 channel s16 -> f32 conversion
2019-03-29 17:39:59 +01:00
DEFINE_FUNCTION(s16_to_f32d_2, sse2);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(s16_to_f32d, sse2);
DEFINE_FUNCTION(s24_to_f32d, sse2);
fmt: add sse2 optimized s32->f32d
2019-10-24 11:06:04 +02:00
DEFINE_FUNCTION(s32_to_f32d, sse2);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(f32d_to_s32, sse2);
audioconvert: improve format conversion Make dither noise as a value between -0.5 and 0.5 and add this to the scaled samples. For this, we first need to do the scaling and then the CLAMP to the target depth. This optimizes to the same code but allows us to avoid under and overflows when we add the dither noise. Add more dithering methods. Expose a dither.method property on audioconvert. Disable dither when the target depth > 16.
2022-06-29 14:10:15 +02:00
DEFINE_FUNCTION(f32d_to_s32_dither, sse2);
fmt-ops: add sse2 version of f32 to s16 planar/interleaved
2020-07-03 11:04:39 +02:00
DEFINE_FUNCTION(f32_to_s16, sse2);
fmt-ops: add optimized f32 to s16 stereo conversion
2020-03-16 13:04:21 +01:00
DEFINE_FUNCTION(f32d_to_s16_2, sse2);
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(f32d_to_s16, sse2);
fmt-ops: add sse2 version of f32 to s16 planar/interleaved
2020-07-03 11:04:39 +02:00
DEFINE_FUNCTION(f32d_to_s16d, sse2);
audioconvert: add SSE (de)interleave_32(s) versions
2022-03-11 13:17:10 +01:00
DEFINE_FUNCTION(deinterleave_32, sse2);
DEFINE_FUNCTION(deinterleave_32s, sse2);
DEFINE_FUNCTION(interleave_32, sse2);
DEFINE_FUNCTION(interleave_32s, sse2);
audioconvert: handle more optimizations Compile an optimized library for the given CPU with the right flags, then link it with the main library.
2019-03-27 17:58:48 +01:00
#endif
#if defined(HAVE_SSSE3)
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(s24_to_f32d, ssse3);
audioconvert: handle more optimizations Compile an optimized library for the given CPU with the right flags, then link it with the main library.
2019-03-27 17:58:48 +01:00
#endif
#if defined(HAVE_SSE41)
audioconvert: compile c version separately Also compile the c versions in a separate module with their own flags.
2019-03-28 21:07:53 +01:00
DEFINE_FUNCTION(s24_to_f32d, sse41);
fmt-ops: add avx2 optimized version Only one optimized version but the sse2 version are compiled with the avx2 flags so that they get optimized better.
2020-03-16 16:11:29 +01:00
#endif
#if defined(HAVE_AVX2)
DEFINE_FUNCTION(s16_to_f32d_2, avx2);
DEFINE_FUNCTION(s16_to_f32d, avx2);
DEFINE_FUNCTION(s24_to_f32d, avx2);
DEFINE_FUNCTION(s32_to_f32d, avx2);
DEFINE_FUNCTION(f32d_to_s32, avx2);
fmt-ops: flesh out avx optimizations
2020-03-17 17:27:47 +01:00
DEFINE_FUNCTION(f32d_to_s16_4, avx2);
fmt-ops: add avx2 optimized version Only one optimized version but the sse2 version are compiled with the avx2 flags so that they get optimized better.
2020-03-16 16:11:29 +01:00
DEFINE_FUNCTION(f32d_to_s16_2, avx2);
DEFINE_FUNCTION(f32d_to_s16, avx2);
audioconvert: handle more optimizations Compile an optimized library for the given CPU with the right flags, then link it with the main library.
2019-03-27 17:58:48 +01:00
#endif
audioconvert: add volume ops Add volume helpers and use this for the monitor output ports so that we can add volumes to the monitor output signal as well.
2021-02-05 15:08:26 +01:00
#undef DEFINE_FUNCTION
Reference in a new issue Copy permalink