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

436 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
audioconvert: tweak more conversion constants Tweak some more constants to make lossless conversions work. Add some tests for lossless conversion. Add some more tests.
2022-07-05 15:50:05 +02:00
#define U8_SCALE 128.f
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_OFFS 128.f
audioconvert: use right scale value Disable assert, it seems to fail on clang.
2022-07-05 16:02:24 +02:00
#define U8_TO_F32(v) ((((uint8_t)(v)) * (1.0f / U8_SCALE)) - 1.0f)
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_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)
audioconvert: tweak more conversion constants Tweak some more constants to make lossless conversions work. Add some tests for lossless conversion. Add some more tests.
2022-07-05 15:50:05 +02:00
#define S8_MIN -128
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 S8_MAX 127
audioconvert: tweak more conversion constants Tweak some more constants to make lossless conversions work. Add some tests for lossless conversion. Add some more tests.
2022-07-05 15:50:05 +02:00
#define S8_SCALE 128.0f
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 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
audioconvert: tweak more conversion constants Tweak some more constants to make lossless conversions work. Add some tests for lossless conversion. Add some more tests.
2022-07-05 15:50:05 +02:00
#define U16_SCALE 32768.f
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 U16_OFFS 32768.f
audioconvert: use right scale value Disable assert, it seems to fail on clang.
2022-07-05 16:02:24 +02:00
#define U16_TO_F32(v) ((((uint16_t)(v)) * (1.0f / U16_SCALE)) - 1.0f)
audioconvert: tweak conversion constants Tweak the conversion constants a bit so that they handle the extreme ranges a bit better. Align the C and vector instructions. Reactivate the unit test asserts when a conversion fails.
2022-07-05 12:20:02 +02:00
#define U16S_TO_F32(v) (((uint16_t)bswap_16((uint16_t)(v)) * (1.0f / U16_OFFS)) - 1.0f)
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_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))
audioconvert: tweak conversion constants Tweak the conversion constants a bit so that they handle the extreme ranges a bit better. Align the C and vector instructions. Reactivate the unit test asserts when a conversion fails.
2022-07-05 12:20:02 +02:00
#define S16_MIN -32768
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 S16_MAX 32767
audioconvert: tweak conversion constants Tweak the conversion constants a bit so that they handle the extreme ranges a bit better. Align the C and vector instructions. Reactivate the unit test asserts when a conversion fails.
2022-07-05 12:20:02 +02:00
#define S16_SCALE 32768.0f
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 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
audioconvert: tweak more conversion constants Tweak some more constants to make lossless conversions work. Add some tests for lossless conversion. Add some more tests.
2022-07-05 15:50:05 +02:00
#define U24_SCALE 8388608.f
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 U24_OFFS 8388608.f
audioconvert: use right scale value Disable assert, it seems to fail on clang.
2022-07-05 16:02:24 +02:00
#define U24_TO_F32(v) ((u24_to_u32(v) * (1.0f / U24_SCALE)) - 1.0f)
audioconvert: simplify 24 bits handling Make a new uint42_t and int24_t type and use that to handle 24 bits samples. This makes it easier because we can iterate and copy the structs like other types.
2022-07-01 12:24:35 +02:00
#define F32_TO_U24(v) u32_to_u24(SPA_CLAMP((v) * U24_SCALE + U24_OFFS, U24_MIN, U24_MAX))
#define F32_TO_U24_D(v,d) u32_to_u24(SPA_CLAMP((v) * U24_SCALE + U24_OFFS + (d), U24_MIN, U24_MAX))
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
audioconvert: tweak conversion constants Tweak the conversion constants a bit so that they handle the extreme ranges a bit better. Align the C and vector instructions. Reactivate the unit test asserts when a conversion fails.
2022-07-05 12:20:02 +02:00
#define S24_MIN -8388608
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 S24_MAX 8388607
audioconvert: tweak conversion constants Tweak the conversion constants a bit so that they handle the extreme ranges a bit better. Align the C and vector instructions. Reactivate the unit test asserts when a conversion fails.
2022-07-05 12:20:02 +02:00
#define S24_SCALE 8388608.0f
audioconvert: simplify 24 bits handling Make a new uint42_t and int24_t type and use that to handle 24 bits samples. This makes it easier because we can iterate and copy the structs like other types.
2022-07-01 12:24:35 +02:00
#define S24_TO_F32(v) (s24_to_s32(v) * (1.0f / S24_SCALE))
#define S24S_TO_F32(v) (s24_to_s32(bswap_s24(v)) * (1.0f / S24_SCALE))
#define F32_TO_S24(v) s32_to_s24(SPA_CLAMP((v) * S24_SCALE, S24_MIN, S24_MAX))
#define F32_TO_S24S(v) bswap_s24(F32_TO_S24(v))
#define F32_TO_S24_D(v,d) s32_to_s24(SPA_CLAMP((v) * S24_SCALE + (d), S24_MIN, S24_MAX))
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
audioconvert: improve s24_32 and u24_32 conversion We should ignore the upper 8 bits, so first shift them out and then use the s32/u32 conversion functions. Add a test for this.
2022-07-09 18:07:49 +02:00
#define U24_32_TO_F32(v) U32_TO_F32((v)<<8)
fmt-ops: express 32 bits formats in terms of 32_24 bits formats
2022-07-07 20:11:08 +02:00
#define U24_32S_TO_F32(v) U24_32_TO_F32(((uint32_t)bswap_32(v)))
#define F32_TO_U24_32(v) (uint32_t)SPA_CLAMP((v) * U24_SCALE + U24_OFFS, U24_MIN, U24_MAX)
#define F32_TO_U24_32S(v) bswap_32(F32_TO_U24_32(v))
#define F32_TO_U24_32_D(v,d) (uint32_t)SPA_CLAMP((v) * U24_SCALE + U24_OFFS + (d), U24_MIN, U24_MAX)
#define F32_TO_U24_32S_D(v,d) bswap_32(F32_TO_U24_32_D(v,d))
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 U32_MIN 0u
audioconvert: use 24 bits for 32 formats The float only preserves 24 bits so use this. Otherwise we get overflows and errors in clang.
2022-07-07 18:38:32 +02:00
#define U32_MAX 4294967295u
audioconvert: tweak more conversion constants Tweak some more constants to make lossless conversions work. Add some tests for lossless conversion. Add some more tests.
2022-07-05 15:50:05 +02:00
#define U32_SCALE 2147483648.f
audioconvert: tweak conversion constants Tweak the conversion constants a bit so that they handle the extreme ranges a bit better. Align the C and vector instructions. Reactivate the unit test asserts when a conversion fails.
2022-07-05 12:20:02 +02:00
#define U32_OFFS 2147483648.f
audioconvert: improve s24_32 and u24_32 conversion We should ignore the upper 8 bits, so first shift them out and then use the s32/u32 conversion functions. Add a test for this.
2022-07-09 18:07:49 +02:00
#define U32_TO_F32(v) (((((uint32_t)(v)) >> 8) * (1.0f / U24_SCALE)) - 1.0f)
fmt-ops: express 32 bits formats in terms of 32_24 bits formats
2022-07-07 20:11:08 +02:00
#define F32_TO_U32(v) (F32_TO_U24_32(v) << 8)
#define F32_TO_U32_D(v,d) (F32_TO_U24_32_D(v,d) << 8)
audioconvert: improve s24_32 and u24_32 conversion We should ignore the upper 8 bits, so first shift them out and then use the s32/u32 conversion functions. Add a test for this.
2022-07-09 18:07:49 +02:00
#define S24_32_TO_F32(v) S32_TO_F32((v)<<8)
fmt-ops: express 32 bits formats in terms of 32_24 bits formats
2022-07-07 20:11:08 +02:00
#define S24_32S_TO_F32(v) S24_32_TO_F32(((int32_t)bswap_32(v)))
#define F32_TO_S24_32(v) (int32_t)SPA_CLAMP((v) * S24_SCALE, S24_MIN, S24_MAX)
#define F32_TO_S24_32S(v) bswap_32(F32_TO_S24_32(v))
#define F32_TO_S24_32_D(v,d) (int32_t)SPA_CLAMP((v) * S24_SCALE + (d), S24_MIN, S24_MAX)
#define F32_TO_S24_32S_D(v,d) bswap_32(F32_TO_S24_32_D(v,d))
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
audioconvert: tweak conversion constants Tweak the conversion constants a bit so that they handle the extreme ranges a bit better. Align the C and vector instructions. Reactivate the unit test asserts when a conversion fails.
2022-07-05 12:20:02 +02:00
#define S32_MIN -2147483648
audioconvert: use 24 bits for 32 formats The float only preserves 24 bits so use this. Otherwise we get overflows and errors in clang.
2022-07-07 18:38:32 +02:00
#define S32_MAX 2147483647
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 S32_SCALE 2147483648.f
audioconvert: improve s24_32 and u24_32 conversion We should ignore the upper 8 bits, so first shift them out and then use the s32/u32 conversion functions. Add a test for this.
2022-07-09 18:07:49 +02:00
#define S32_TO_F32(v) ((((int32_t)(v)) >> 8) * (1.0f / S24_SCALE))
fmt-ops: express 32 bits formats in terms of 32_24 bits formats
2022-07-07 20:11:08 +02:00
#define S32S_TO_F32(v) S32_TO_F32(bswap_32(v))
#define F32_TO_S32(v) (F32_TO_S24_32(v) << 8)
#define F32_TO_S32_D(v,d) (F32_TO_S24_32_D(v,d) << 8)
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_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
audioconvert: simplify 24 bits handling Make a new uint42_t and int24_t type and use that to handle 24 bits samples. This makes it easier because we can iterate and copy the structs like other types.
2022-07-01 12:24:35 +02:00
typedef struct {
fmtconvert: add support for U16, U24, U32 and U24_32 formats
2021-09-08 09:07:49 -04:00
#if __BYTE_ORDER == __LITTLE_ENDIAN
audioconvert: simplify 24 bits handling Make a new uint42_t and int24_t type and use that to handle 24 bits samples. This makes it easier because we can iterate and copy the structs like other types.
2022-07-01 12:24:35 +02:00
uint8_t v3;
uint8_t v2;
uint8_t v1;
fmtconvert: add support for U16, U24, U32 and U24_32 formats
2021-09-08 09:07:49 -04:00
#else
audioconvert: simplify 24 bits handling Make a new uint42_t and int24_t type and use that to handle 24 bits samples. This makes it easier because we can iterate and copy the structs like other types.
2022-07-01 12:24:35 +02:00
uint8_t v1;
uint8_t v2;
uint8_t v3;
fmtconvert: add support for U16, U24, U32 and U24_32 formats
2021-09-08 09:07:49 -04:00
#endif
audioconvert: simplify 24 bits handling Make a new uint42_t and int24_t type and use that to handle 24 bits samples. This makes it easier because we can iterate and copy the structs like other types.
2022-07-01 12:24:35 +02:00
} __attribute__ ((packed)) uint24_t;
fmtconvert: add support for U16, U24, U32 and U24_32 formats
2021-09-08 09:07:49 -04:00
audioconvert: simplify 24 bits handling Make a new uint42_t and int24_t type and use that to handle 24 bits samples. This makes it easier because we can iterate and copy the structs like other types.
2022-07-01 12:24:35 +02:00
typedef struct {
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 __BYTE_ORDER == __LITTLE_ENDIAN
audioconvert: simplify 24 bits handling Make a new uint42_t and int24_t type and use that to handle 24 bits samples. This makes it easier because we can iterate and copy the structs like other types.
2022-07-01 12:24:35 +02:00
uint8_t v3;
uint8_t v2;
int8_t v1;
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
#else
audioconvert: simplify 24 bits handling Make a new uint42_t and int24_t type and use that to handle 24 bits samples. This makes it easier because we can iterate and copy the structs like other types.
2022-07-01 12:24:35 +02:00
int8_t v1;
uint8_t v2;
uint8_t v3;
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: simplify 24 bits handling Make a new uint42_t and int24_t type and use that to handle 24 bits samples. This makes it easier because we can iterate and copy the structs like other types.
2022-07-01 12:24:35 +02:00
} __attribute__ ((packed)) int24_t;
static inline uint32_t u24_to_u32(uint24_t src)
{
return ((uint32_t)src.v1 << 16) | ((uint32_t)src.v2 << 8) | (uint32_t)src.v3;
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: fix pack/unpack of s24/u24 Copy the values into the right place in the struct.
2022-07-05 12:18:57 +02:00
#define U32_TO_U24(s) (uint24_t) { .v1 = (uint8_t)(((uint32_t)s) >> 16), \
.v2 = (uint8_t)(((uint32_t)s) >> 8), .v3 = (uint8_t)((uint32_t)s) }
audioconvert: simplify 24 bits handling Make a new uint42_t and int24_t type and use that to handle 24 bits samples. This makes it easier because we can iterate and copy the structs like other types.
2022-07-01 12:24:35 +02:00
static inline uint24_t u32_to_u24(uint32_t src)
fmt-ops: add support for s24 with endian conversion
2020-01-27 15:46:25 +01:00
{
audioconvert: fix pack/unpack of s24/u24 Copy the values into the right place in the struct.
2022-07-05 12:18:57 +02:00
return U32_TO_U24(src);
fmt-ops: add support for s24 with endian conversion
2020-01-27 15:46:25 +01:00
}
audioconvert: simplify 24 bits handling Make a new uint42_t and int24_t type and use that to handle 24 bits samples. This makes it easier because we can iterate and copy the structs like other types.
2022-07-01 12:24:35 +02:00
static inline int32_t s24_to_s32(int24_t src)
fmtconvert: add support for U16, U24, U32 and U24_32 formats
2021-09-08 09:07:49 -04:00
{
audioconvert: simplify 24 bits handling Make a new uint42_t and int24_t type and use that to handle 24 bits samples. This makes it easier because we can iterate and copy the structs like other types.
2022-07-01 12:24:35 +02:00
return ((int32_t)src.v1 << 16) | ((uint32_t)src.v2 << 8) | (uint32_t)src.v3;
fmtconvert: add support for U16, U24, U32 and U24_32 formats
2021-09-08 09:07:49 -04:00
}
audioconvert: fix pack/unpack of s24/u24 Copy the values into the right place in the struct.
2022-07-05 12:18:57 +02:00
#define S32_TO_S24(s) (int24_t) { .v1 = (int8_t)(((int32_t)s) >> 16), \
.v2 = (uint8_t)(((uint32_t)s) >> 8), .v3 = (uint8_t)((uint32_t)s) }
audioconvert: simplify 24 bits handling Make a new uint42_t and int24_t type and use that to handle 24 bits samples. This makes it easier because we can iterate and copy the structs like other types.
2022-07-01 12:24:35 +02:00
static inline int24_t s32_to_s24(int32_t src)
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: fix pack/unpack of s24/u24 Copy the values into the right place in the struct.
2022-07-05 12:18:57 +02:00
return S32_TO_S24(src);
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: simplify 24 bits handling Make a new uint42_t and int24_t type and use that to handle 24 bits samples. This makes it easier because we can iterate and copy the structs like other types.
2022-07-01 12:24:35 +02:00
static inline uint24_t bswap_u24(uint24_t src)
fmt-ops: add support for s24 with endian conversion
2020-01-27 15:46:25 +01:00
{
audioconvert: Fix s24/u24 byte swapping
2022-07-05 14:56:54 +02:00
return (uint24_t) { .v1 = src.v3, .v2 = src.v2, .v3 = src.v1 };
audioconvert: simplify 24 bits handling Make a new uint42_t and int24_t type and use that to handle 24 bits samples. This makes it easier because we can iterate and copy the structs like other types.
2022-07-01 12:24:35 +02:00
}
static inline int24_t bswap_s24(int24_t src)
{
audioconvert: Fix s24/u24 byte swapping
2022-07-05 14:56:54 +02:00
return (int24_t) { .v1 = src.v3, .v2 = src.v2, .v3 = src.v1 };
fmt-ops: add support for s24 with endian conversion
2020-01-27 15:46:25 +01:00
}
audioconvert: implement f64s Add swapping functions for f64s. Fix the awkward interleave/deinterleave names for 32s.
2022-07-11 10:58:51 +02:00
#define F32_TO_F32S(v) \
bswap_32((union { uint32_t i; float f; }){ .f = (v) }.i)
#define F32S_TO_F32(v) \
((union { uint32_t i; float f; }){ .i = bswap_32(v) }.f)
#define F64_TO_F64S(v) \
bswap_32((union { uint64_t i; double d; }){ .d = (v) }.i)
#define F64S_TO_F64(v) \
((union { uint64_t i; double d; }){ .i = bswap_32(v) }.d)
audioconvert: implement noise shaping To compare the results: pw-cat -r test.wav --format=u8 -P '{ dither.method=none }' vs: pw-cat -r test.wav --format=u8 -P '{ dither.method=shaped5 }'
2022-06-29 17:31:32 +02:00
#define NS_MAX 8
#define NS_MASK (NS_MAX-1)
struct shaper {
float e[NS_MAX];
uint32_t idx;
float r;
};
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
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 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: implement noise shaping To compare the results: pw-cat -r test.wav --format=u8 -P '{ dither.method=none }' vs: pw-cat -r test.wav --format=u8 -P '{ dither.method=shaped5 }'
2022-06-29 17:31:32 +02:00
struct shaper shaper[64];
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 (*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: implement noise shaping To compare the results: pw-cat -r test.wav --format=u8 -P '{ dither.method=none }' vs: pw-cat -r test.wav --format=u8 -P '{ dither.method=shaped5 }'
2022-06-29 17:31:32 +02:00
DEFINE_FUNCTION(f32d_to_u8d_shaped, 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: implement noise shaping To compare the results: pw-cat -r test.wav --format=u8 -P '{ dither.method=none }' vs: pw-cat -r test.wav --format=u8 -P '{ dither.method=shaped5 }'
2022-06-29 17:31:32 +02:00
DEFINE_FUNCTION(f32d_to_u8_shaped, 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: implement noise shaping To compare the results: pw-cat -r test.wav --format=u8 -P '{ dither.method=none }' vs: pw-cat -r test.wav --format=u8 -P '{ dither.method=shaped5 }'
2022-06-29 17:31:32 +02:00
DEFINE_FUNCTION(f32d_to_s8d_shaped, 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: implement noise shaping To compare the results: pw-cat -r test.wav --format=u8 -P '{ dither.method=none }' vs: pw-cat -r test.wav --format=u8 -P '{ dither.method=shaped5 }'
2022-06-29 17:31:32 +02:00
DEFINE_FUNCTION(f32d_to_s8_shaped, 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: implement noise shaping To compare the results: pw-cat -r test.wav --format=u8 -P '{ dither.method=none }' vs: pw-cat -r test.wav --format=u8 -P '{ dither.method=shaped5 }'
2022-06-29 17:31:32 +02:00
DEFINE_FUNCTION(f32d_to_s16d_shaped, 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: implement noise shaping To compare the results: pw-cat -r test.wav --format=u8 -P '{ dither.method=none }' vs: pw-cat -r test.wav --format=u8 -P '{ dither.method=shaped5 }'
2022-06-29 17:31:32 +02:00
DEFINE_FUNCTION(f32d_to_s16_shaped, 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);
audioconvert: implement noise shaping To compare the results: pw-cat -r test.wav --format=u8 -P '{ dither.method=none }' vs: pw-cat -r test.wav --format=u8 -P '{ dither.method=shaped5 }'
2022-06-29 17:31:32 +02:00
DEFINE_FUNCTION(f32d_to_s16s_shaped, 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: implement (de)interleave with existing functions
2022-06-30 18:24:05 +02:00
DEFINE_FUNCTION(8_to_8d, c);
DEFINE_FUNCTION(16_to_16d, c);
DEFINE_FUNCTION(24_to_24d, c);
DEFINE_FUNCTION(32_to_32d, c);
audioconvert: implement f64s Add swapping functions for f64s. Fix the awkward interleave/deinterleave names for 32s.
2022-07-11 10:58:51 +02:00
DEFINE_FUNCTION(32s_to_32d, c);
audioconvert: implement (de)interleave with existing functions
2022-06-30 18:24:05 +02:00
DEFINE_FUNCTION(64_to_64d, c);
DEFINE_FUNCTION(64s_to_64sd, c);
DEFINE_FUNCTION(8d_to_8, c);
DEFINE_FUNCTION(16d_to_16, c);
DEFINE_FUNCTION(24d_to_24, c);
DEFINE_FUNCTION(32d_to_32, c);
audioconvert: implement f64s Add swapping functions for f64s. Fix the awkward interleave/deinterleave names for 32s.
2022-07-11 10:58:51 +02:00
DEFINE_FUNCTION(32d_to_32s, c);
audioconvert: implement (de)interleave with existing functions
2022-06-30 18:24:05 +02:00
DEFINE_FUNCTION(64d_to_64, c);
DEFINE_FUNCTION(64sd_to_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);
audioconvert: add sse2 s16 dither functions
2022-07-12 10:34:13 +02:00
DEFINE_FUNCTION(f32d_to_s16_dither, 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 sse2 s16 dither functions
2022-07-12 10:34:13 +02:00
DEFINE_FUNCTION(f32d_to_s16d_dither, sse2);
audioconvert: implement (de)interleave with existing functions
2022-06-30 18:24:05 +02:00
DEFINE_FUNCTION(32_to_32d, sse2);
audioconvert: implement f64s Add swapping functions for f64s. Fix the awkward interleave/deinterleave names for 32s.
2022-07-11 10:58:51 +02:00
DEFINE_FUNCTION(32s_to_32d, sse2);
audioconvert: implement (de)interleave with existing functions
2022-06-30 18:24:05 +02:00
DEFINE_FUNCTION(32d_to_32, sse2);
audioconvert: implement f64s Add swapping functions for f64s. Fix the awkward interleave/deinterleave names for 32s.
2022-07-11 10:58:51 +02:00
DEFINE_FUNCTION(32d_to_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