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-c.c

396 lines
14 KiB
C
Raw Normal View History

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
/* Spa
*
* Copyright © 2018 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 <string.h>
#include <stdio.h>
#include <math.h>
#include <spa/support/cpu.h>
#include <spa/utils/defs.h>
#include <spa/param/audio/format-utils.h>
#include "fmt-ops.h"
audioconvert: add converstion to and from alaw/ulaw
2021-08-17 17:32:25 +02:00
#include "law.h"
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
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02:00
#define MAKE_COPY(size) \
void conv_copy ##size## d_c(struct convert *conv, \
void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], \
uint32_t n_samples) \
{ \
uint32_t i, n_channels = conv->n_channels; \
for (i = 0; i < n_channels; i++) \
spa_memcpy(dst[i], src[i], n_samples * (size>>3)); \
} \
void conv_copy ##size## _c(struct convert *conv, \
void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], \
uint32_t n_samples) \
{ \
spa_memcpy(dst[0], src[0], n_samples * conv->n_channels * (size>>3)); \
}
MAKE_COPY(8);
MAKE_COPY(16);
MAKE_COPY(24);
MAKE_COPY(32);
MAKE_COPY(64);
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 MAKE_D_TO_D(sname,stype,dname,dtype,func) \
audioconvert: implement (de)interleave with existing functions
2022-06-30 18:24:05 +02:00
void conv_ ##sname## d_to_ ##dname## d_c(struct convert *conv, \
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02:00
void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], \
uint32_t n_samples) \
{ \
uint32_t i, j, n_channels = conv->n_channels; \
for (i = 0; i < n_channels; i++) { \
const stype *s = src[i]; \
dtype *d = dst[i]; \
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
for (j = 0; j < n_samples; j++) \
d[j] = func (s[j]); \
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02: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
#define MAKE_I_TO_I(sname,stype,dname,dtype,func) \
audioconvert: implement (de)interleave with existing functions
2022-06-30 18:24:05 +02:00
void conv_ ##sname## _to_ ##dname## _c(struct convert *conv, \
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02:00
void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], \
uint32_t n_samples) \
{ \
uint32_t j; \
const stype *s = src[0]; \
dtype *d = dst[0]; \
n_samples *= conv->n_channels; \
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
for (j = 0; j < n_samples; j++) \
d[j] = func (s[j]); \
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02: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
#define MAKE_I_TO_D(sname,stype,dname,dtype,func) \
audioconvert: implement (de)interleave with existing functions
2022-06-30 18:24:05 +02:00
void conv_ ##sname## _to_ ##dname## d_c(struct convert *conv, \
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02:00
void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], \
uint32_t n_samples) \
{ \
const stype *s = src[0]; \
dtype **d = (dtype**)dst; \
uint32_t i, j, n_channels = conv->n_channels; \
for (j = 0; j < n_samples; j++) { \
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
for (i = 0; i < n_channels; i++) \
d[i][j] = func (*s++); \
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02: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
#define MAKE_D_TO_I(sname,stype,dname,dtype,func) \
audioconvert: implement (de)interleave with existing functions
2022-06-30 18:24:05 +02:00
void conv_ ##sname## d_to_ ##dname## _c(struct convert *conv, \
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02:00
void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], \
uint32_t n_samples) \
{ \
const stype **s = (const stype **)src; \
dtype *d = dst[0]; \
uint32_t i, j, n_channels = conv->n_channels; \
for (j = 0; j < n_samples; j++) { \
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
for (i = 0; i < n_channels; i++) \
*d++ = func (s[i][j]); \
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02:00
} \
}
/* to f32 */
MAKE_D_TO_D(u8, uint8_t, f32, float, U8_TO_F32);
MAKE_I_TO_I(u8, uint8_t, f32, float, U8_TO_F32);
MAKE_I_TO_D(u8, uint8_t, f32, float, U8_TO_F32);
MAKE_D_TO_I(u8, uint8_t, f32, float, U8_TO_F32);
MAKE_D_TO_D(s8, int8_t, f32, float, S8_TO_F32);
MAKE_I_TO_I(s8, int8_t, f32, float, S8_TO_F32);
MAKE_I_TO_D(s8, int8_t, f32, float, S8_TO_F32);
MAKE_D_TO_I(s8, int8_t, f32, float, S8_TO_F32);
MAKE_I_TO_D(alaw, uint8_t, f32, float, alaw_to_f32);
MAKE_I_TO_D(ulaw, uint8_t, f32, float, ulaw_to_f32);
MAKE_I_TO_I(u16, uint16_t, f32, float, U16_TO_F32);
MAKE_I_TO_D(u16, uint16_t, f32, float, U16_TO_F32);
MAKE_D_TO_D(s16, int16_t, f32, float, S16_TO_F32);
MAKE_I_TO_I(s16, int16_t, f32, float, S16_TO_F32);
MAKE_I_TO_D(s16, int16_t, f32, float, S16_TO_F32);
MAKE_D_TO_I(s16, int16_t, f32, float, S16_TO_F32);
MAKE_I_TO_D(s16s, uint16_t, f32, float, S16S_TO_F32);
MAKE_I_TO_I(u32, uint32_t, f32, float, U32_TO_F32);
MAKE_I_TO_D(u32, uint32_t, f32, float, U32_TO_F32);
MAKE_D_TO_D(s32, int32_t, f32, float, S32_TO_F32);
MAKE_I_TO_I(s32, int32_t, f32, float, S32_TO_F32);
MAKE_I_TO_D(s32, int32_t, f32, float, S32_TO_F32);
MAKE_D_TO_I(s32, int32_t, f32, float, S32_TO_F32);
MAKE_I_TO_D(s32s, uint32_t, f32, float, S32S_TO_F32);
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
MAKE_I_TO_I(u24, uint24_t, f32, float, U24_TO_F32);
MAKE_I_TO_D(u24, uint24_t, f32, float, U24_TO_F32);
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02: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
MAKE_D_TO_D(s24, int24_t, f32, float, S24_TO_F32);
MAKE_I_TO_I(s24, int24_t, f32, float, S24_TO_F32);
MAKE_I_TO_D(s24, int24_t, f32, float, S24_TO_F32);
MAKE_D_TO_I(s24, int24_t, f32, float, S24_TO_F32);
MAKE_I_TO_D(s24s, int24_t, f32, float, S24S_TO_F32);
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02:00
MAKE_I_TO_I(u24_32, uint32_t, f32, float, U24_32_TO_F32);
MAKE_I_TO_D(u24_32, uint32_t, f32, float, U24_32_TO_F32);
MAKE_D_TO_D(s24_32, int32_t, f32, float, S24_32_TO_F32);
MAKE_I_TO_I(s24_32, int32_t, f32, float, S24_32_TO_F32);
MAKE_I_TO_D(s24_32, int32_t, f32, float, S24_32_TO_F32);
MAKE_D_TO_I(s24_32, int32_t, f32, float, S24_32_TO_F32);
MAKE_I_TO_D(s24_32s, uint32_t, f32, float, S24_32S_TO_F32);
MAKE_D_TO_D(f64, double, f32, float, (float));
MAKE_I_TO_I(f64, double, f32, float, (float));
MAKE_I_TO_D(f64, double, f32, float, (float));
MAKE_D_TO_I(f64, double, f32, float, (float));
audioconvert: implement f64s Add swapping functions for f64s. Fix the awkward interleave/deinterleave names for 32s.
2022-07-11 10:58:51 +02:00
MAKE_I_TO_D(f64s, uint64_t, f32, float, (float)F64S_TO_F64);
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02:00
/* from f32 */
MAKE_D_TO_D(f32, float, u8, uint8_t, F32_TO_U8);
MAKE_I_TO_I(f32, float, u8, uint8_t, F32_TO_U8);
MAKE_I_TO_D(f32, float, u8, uint8_t, F32_TO_U8);
MAKE_D_TO_I(f32, float, u8, uint8_t, F32_TO_U8);
MAKE_D_TO_D(f32, float, s8, int8_t, F32_TO_S8);
MAKE_I_TO_I(f32, float, s8, int8_t, F32_TO_S8);
MAKE_I_TO_D(f32, float, s8, int8_t, F32_TO_S8);
MAKE_D_TO_I(f32, float, s8, int8_t, F32_TO_S8);
MAKE_D_TO_I(f32, float, alaw, uint8_t, f32_to_alaw);
MAKE_D_TO_I(f32, float, ulaw, uint8_t, f32_to_ulaw);
MAKE_I_TO_I(f32, float, u16, uint16_t, F32_TO_U16);
MAKE_D_TO_I(f32, float, u16, uint16_t, F32_TO_U16);
MAKE_D_TO_D(f32, float, s16, int16_t, F32_TO_S16);
MAKE_I_TO_I(f32, float, s16, int16_t, F32_TO_S16);
MAKE_I_TO_D(f32, float, s16, int16_t, F32_TO_S16);
MAKE_D_TO_I(f32, float, s16, int16_t, F32_TO_S16);
MAKE_D_TO_I(f32, float, s16s, uint16_t, F32_TO_S16S);
MAKE_I_TO_I(f32, float, u32, uint32_t, F32_TO_U32);
MAKE_D_TO_I(f32, float, u32, uint32_t, F32_TO_U32);
MAKE_D_TO_D(f32, float, s32, int32_t, F32_TO_S32);
MAKE_I_TO_I(f32, float, s32, int32_t, F32_TO_S32);
MAKE_I_TO_D(f32, float, s32, int32_t, F32_TO_S32);
MAKE_D_TO_I(f32, float, s32, int32_t, F32_TO_S32);
MAKE_D_TO_I(f32, float, s32s, uint32_t, F32_TO_S32S);
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
MAKE_I_TO_I(f32, float, u24, uint24_t, F32_TO_U24);
MAKE_D_TO_I(f32, float, u24, uint24_t, F32_TO_U24);
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02: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
MAKE_D_TO_D(f32, float, s24, int24_t, F32_TO_S24);
MAKE_I_TO_I(f32, float, s24, int24_t, F32_TO_S24);
MAKE_I_TO_D(f32, float, s24, int24_t, F32_TO_S24);
MAKE_D_TO_I(f32, float, s24, int24_t, F32_TO_S24);
MAKE_D_TO_I(f32, float, s24s, int24_t, F32_TO_S24S);
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02:00
MAKE_I_TO_I(f32, float, u24_32, uint32_t, F32_TO_U24_32);
MAKE_D_TO_I(f32, float, u24_32, uint32_t, F32_TO_U24_32);
MAKE_D_TO_D(f32, float, s24_32, int32_t, F32_TO_S24_32);
MAKE_I_TO_I(f32, float, s24_32, int32_t, F32_TO_S24_32);
MAKE_I_TO_D(f32, float, s24_32, int32_t, F32_TO_S24_32);
MAKE_D_TO_I(f32, float, s24_32, int32_t, F32_TO_S24_32);
MAKE_D_TO_I(f32, float, s24_32s, uint32_t, F32_TO_S24_32S);
MAKE_D_TO_D(f32, float, f64, double, (double));
MAKE_I_TO_I(f32, float, f64, double, (double));
MAKE_I_TO_D(f32, float, f64, double, (double));
MAKE_D_TO_I(f32, float, f64, double, (double));
audioconvert: implement f64s Add swapping functions for f64s. Fix the awkward interleave/deinterleave names for 32s.
2022-07-11 10:58:51 +02:00
MAKE_D_TO_I(f32, float, f64s, uint64_t, F64_TO_F64S);
audioconvert: add more conversions Add the other endian conversions.
2021-08-17 14:45:00 +02:00
audioconvert: add f64 conversion See #1990
2022-01-10 13:04:31 +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
static inline int32_t
audioconvert: use faster noise generator
2022-06-29 14:33:41 +02:00
lcnoise(uint32_t *state)
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: use faster noise generator
2022-06-29 14:33:41 +02:00
*state = (*state * 96314165) + 907633515;
return (int32_t)(*state);
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 inline void update_dither_c(struct convert *conv, uint32_t n_samples)
{
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 n;
float *dither = conv->dither, scale = conv->scale;
uint32_t *state = &conv->random[0];
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: add triangular dither
2022-07-11 16:28:51 +02:00
if (conv->method < DITHER_METHOD_TRIANGULAR) {
for (n = 0; n < n_samples; n++)
dither[n] = lcnoise(state) * scale;
} else {
for (n = 0; n < n_samples; n++)
dither[n] = (lcnoise(state) + lcnoise(state)) * 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
}
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 MAKE_D_dither(dname,dtype,func) \
audioconvert: implement (de)interleave with existing functions
2022-06-30 18:24:05 +02:00
void conv_f32d_to_ ##dname## d_dither_c(struct convert *conv, \
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02:00
void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], \
uint32_t n_samples) \
{ \
uint32_t i, j, k, chunk, n_channels = conv->n_channels, dither_size = conv->dither_size; \
float *dither = conv->dither; \
update_dither_c(conv, SPA_MIN(n_samples, dither_size)); \
for (i = 0; i < n_channels; i++) { \
const float *s = src[i]; \
dtype *d = dst[i]; \
for (j = 0; j < n_samples;) { \
chunk = SPA_MIN(n_samples - j, dither_size); \
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
for (k = 0; k < chunk; k++, j++) \
d[j] = func (s[j], dither[k]); \
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02: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
#define MAKE_I_dither(dname,dtype,func) \
audioconvert: implement (de)interleave with existing functions
2022-06-30 18:24:05 +02:00
void conv_f32d_to_ ##dname## _dither_c(struct convert *conv, \
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02:00
void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], \
uint32_t n_samples) \
{ \
const float **s = (const float **) src; \
dtype *d = dst[0]; \
uint32_t i, j, k, chunk, n_channels = conv->n_channels, dither_size = conv->dither_size; \
float *dither = conv->dither; \
update_dither_c(conv, SPA_MIN(n_samples, dither_size)); \
for (j = 0; j < n_samples;) { \
chunk = SPA_MIN(n_samples - j, dither_size); \
for (k = 0; k < chunk; k++, j++) { \
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
for (i = 0; i < n_channels; i++) \
*d++ = func (s[i][j], dither[k]); \
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02:00
} \
} \
}
MAKE_D_dither(u8, uint8_t, F32_TO_U8_D);
MAKE_I_dither(u8, uint8_t, F32_TO_U8_D);
MAKE_D_dither(s8, int8_t, F32_TO_S8_D);
MAKE_I_dither(s8, int8_t, F32_TO_S8_D);
MAKE_D_dither(s16, int16_t, F32_TO_S16_D);
MAKE_I_dither(s16, int16_t, F32_TO_S16_D);
MAKE_I_dither(s16s, uint16_t, F32_TO_S16S_D);
MAKE_D_dither(s32, int32_t, F32_TO_S32_D);
MAKE_I_dither(s32, int32_t, F32_TO_S32_D);
MAKE_I_dither(s32s, uint32_t, F32_TO_S32S_D);
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
MAKE_D_dither(s24, int24_t, F32_TO_S24_D);
MAKE_I_dither(s24, int24_t, F32_TO_S24_D);
MAKE_I_dither(s24s, int24_t, F32_TO_S24_D);
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02:00
MAKE_D_dither(s24_32, int32_t, F32_TO_S24_32_D);
MAKE_I_dither(s24_32, int32_t, F32_TO_S24_32_D);
MAKE_I_dither(s24_32s, int32_t, F32_TO_S24_32S_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 SHAPER5(type,s,scale,offs,sh,min,max,d) \
({ \
type t; \
float v = s * scale + offs + \
- sh->e[idx] * 2.033f \
+ sh->e[(idx - 1) & NS_MASK] * 2.165f \
- sh->e[(idx - 2) & NS_MASK] * 1.959f \
+ sh->e[(idx - 3) & NS_MASK] * 1.590f \
- sh->e[(idx - 4) & NS_MASK] * 0.6149f; \
t = (type)SPA_CLAMP(v + d, min, max); \
idx = (idx + 1) & NS_MASK; \
sh->e[idx] = t - v; \
t; \
})
#define F32_TO_U8_SH(s,sh,d) SHAPER5(uint8_t, s, U8_SCALE, U8_OFFS, sh, U8_MIN, U8_MAX, d)
#define F32_TO_S8_SH(s,sh,d) SHAPER5(int8_t, s, S8_SCALE, 0, sh, S8_MIN, S8_MAX, d)
#define F32_TO_S16_SH(s,sh,d) SHAPER5(int16_t, s, S16_SCALE, 0, sh, S16_MIN, S16_MAX, d)
#define F32_TO_S16S_SH(s,sh,d) bswap_16(F32_TO_S16_SH(s,sh,d))
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 MAKE_D_shaped(dname,dtype,func) \
audioconvert: implement (de)interleave with existing functions
2022-06-30 18:24:05 +02:00
void conv_f32d_to_ ##dname## d_shaped_c(struct convert *conv, \
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02:00
void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], \
uint32_t n_samples) \
{ \
uint32_t i, j, k, chunk, n_channels = conv->n_channels, dither_size = conv->dither_size; \
float *dither = conv->dither; \
update_dither_c(conv, SPA_MIN(n_samples, dither_size)); \
for (i = 0; i < n_channels; i++) { \
const float *s = src[i]; \
dtype *d = dst[i]; \
struct shaper *sh = &conv->shaper[i]; \
uint32_t idx = sh->idx; \
for (j = 0; j < n_samples;) { \
chunk = SPA_MIN(n_samples - j, dither_size); \
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
for (k = 0; k < chunk; k++, j++) \
d[j] = func (s[j], sh, dither[k]); \
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02:00
} \
sh->idx = idx; \
} \
}
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 MAKE_I_shaped(dname,dtype,func) \
audioconvert: implement (de)interleave with existing functions
2022-06-30 18:24:05 +02:00
void conv_f32d_to_ ##dname## _shaped_c(struct convert *conv, \
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02:00
void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[], \
uint32_t n_samples) \
{ \
dtype *d0 = dst[0]; \
uint32_t i, j, k, chunk, n_channels = conv->n_channels, dither_size = conv->dither_size; \
float *dither = conv->dither; \
update_dither_c(conv, SPA_MIN(n_samples, dither_size)); \
for (i = 0; i < n_channels; i++) { \
const float *s = src[i]; \
dtype *d = &d0[i]; \
struct shaper *sh = &conv->shaper[i]; \
uint32_t idx = sh->idx; \
for (j = 0; j < n_samples;) { \
chunk = SPA_MIN(n_samples - j, dither_size); \
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
for (k = 0; k < chunk; k++, j++) \
d[j*n_channels] = func (s[j], sh, dither[k]); \
audioconvert: use macros to generate code Most of the outer loops are all the same.
2022-06-30 17:49:44 +02:00
} \
sh->idx = idx; \
} \
}
MAKE_D_shaped(u8, uint8_t, F32_TO_U8_SH);
MAKE_I_shaped(u8, uint8_t, F32_TO_U8_SH);
MAKE_D_shaped(s8, int8_t, F32_TO_S8_SH);
MAKE_I_shaped(s8, int8_t, F32_TO_S8_SH);
MAKE_D_shaped(s16, int16_t, F32_TO_S16_SH);
MAKE_I_shaped(s16, int16_t, F32_TO_S16_SH);
MAKE_I_shaped(s16s, uint16_t, F32_TO_S16S_SH);
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 MAKE_DEINTERLEAVE(size1,size2, type,func) \
MAKE_I_TO_D(size1,type,size2,type,func)
MAKE_DEINTERLEAVE(8, 8, uint8_t, (uint8_t));
MAKE_DEINTERLEAVE(16, 16, uint16_t, (uint16_t));
MAKE_DEINTERLEAVE(24, 24, uint24_t, (uint24_t));
MAKE_DEINTERLEAVE(32, 32, uint32_t, (uint32_t));
MAKE_DEINTERLEAVE(32s, 32, uint32_t, bswap_32);
MAKE_DEINTERLEAVE(64, 64, uint64_t, (uint64_t));
#define MAKE_INTERLEAVE(size1,size2,type,func) \
MAKE_D_TO_I(size1,type,size2,type,func)
MAKE_INTERLEAVE(8, 8, uint8_t, (uint8_t));
MAKE_INTERLEAVE(16, 16, uint16_t, (uint16_t));
MAKE_INTERLEAVE(24, 24, uint24_t, (uint24_t));
MAKE_INTERLEAVE(32, 32, uint32_t, (uint32_t));
MAKE_INTERLEAVE(32, 32s, uint32_t, bswap_32);
MAKE_INTERLEAVE(64, 64, uint64_t, (uint64_t));
Reference in a new issue Copy permalink