mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-10-29 05:40:27 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

audioconvert: avoid even more precision loss in F32 to S32 conversion

Browse source 
This is somewhat similar to the S32->F32 conversion improvements,
but here things a bit more tricky...

The main consideration is that the limits to which we clamp
must be valid 32-bit signed integers, but not all such integers
are exactly losslessly representable in `float32_t`.

For example it we'd clamp to `2147483647`,
that is actually a `2147483648.0f`,
and `2147483648` is not a valid 32-bit signed integer,
so the post-clamp conversion would basically be UB.
We don't have this problem for negative bound, though.

But as we know, any 25-bit signed integer is losslessly
round-trippable through float32_t, and since multiplying by 2
only changes the float's exponent, we can clamp to `2147483520`!
The algorithm of selection of the pre-clamping scale is unaffected.

This additionally avoids right-shift, and thus is even faster.

As `test_lossless_s32_lossless_subset` shows,
if the integer is in the form of s25+shift,
the maximal absolute error is finally zero.

Without going through `float`->`double`->`int`,
i'm not sure if the `float`->`int` conversion
can be improved further.
This commit is contained in:
Roman Lebedev 2024-06-25 19:20:42 +03:00
parent f4c89b1b40
commit 7c40cafa7c
No known key found for this signature in database
GPG key ID: 083C3EBB4A1689E0
4 changed files with 50 additions and 70 deletions
Download patch file Download diff file Expand all files Collapse all files

53
spa/plugins/audioconvert/fmt-ops-avx2.c
View file

@ -316,7 +316,7 @@ conv_s32_to_f32d_4s_avx2(void *data, void * SPA_RESTRICT dst[], const void * SPA
float *d0 = dst[0], *d1 = dst[1], *d2 = dst[2], *d3 = dst[3];
uint32_t n, unrolled;
__m256i in[4];
__m256 out[4], factor = _mm256_set1_ps(1.0f / S32_SCALE);
__m256 out[4], factor = _mm256_set1_ps(1.0f / S32_SCALE_I2F);
__m256i mask1 = _mm256_setr_epi32(0*n_channels, 1*n_channels, 2*n_channels, 3*n_channels,
4*n_channels, 5*n_channels, 6*n_channels, 7*n_channels);
@ -352,7 +352,7 @@ conv_s32_to_f32d_4s_avx2(void *data, void * SPA_RESTRICT dst[], const void * SPA
s += 8*n_channels;
}
for(; n < n_samples; n++) {
__m128 out[4], factor = _mm_set1_ps(1.0f / S32_SCALE);
__m128 out[4], factor = _mm_set1_ps(1.0f / S32_SCALE_I2F);
out[0] = _mm_cvtsi32_ss(factor, s[0]);
out[1] = _mm_cvtsi32_ss(factor, s[1]);
out[2] = _mm_cvtsi32_ss(factor, s[2]);
@ -377,7 +377,7 @@ conv_s32_to_f32d_2s_avx2(void *data, void * SPA_RESTRICT dst[], const void * SPA
float *d0 = dst[0], *d1 = dst[1];
uint32_t n, unrolled;
__m256i in[4];
__m256 out[4], factor = _mm256_set1_ps(1.0f / S32_SCALE);
__m256 out[4], factor = _mm256_set1_ps(1.0f / S32_SCALE_I2F);
__m256i mask1 = _mm256_setr_epi32(0*n_channels, 1*n_channels, 2*n_channels, 3*n_channels,
4*n_channels, 5*n_channels, 6*n_channels, 7*n_channels);
@ -403,7 +403,7 @@ conv_s32_to_f32d_2s_avx2(void *data, void * SPA_RESTRICT dst[], const void * SPA
s += 8*n_channels;
}
for(; n < n_samples; n++) {
__m128 out[2], factor = _mm_set1_ps(1.0f / S32_SCALE);
__m128 out[2], factor = _mm_set1_ps(1.0f / S32_SCALE_I2F);
out[0] = _mm_cvtsi32_ss(factor, s[0]);
out[1] = _mm_cvtsi32_ss(factor, s[1]);
out[0] = _mm_mul_ss(out[0], factor);
@ -422,7 +422,7 @@ conv_s32_to_f32d_1s_avx2(void *data, void * SPA_RESTRICT dst[], const void * SPA
float *d0 = dst[0];
uint32_t n, unrolled;
__m256i in[2];
__m256 out[2], factor = _mm256_set1_ps(1.0f / S32_SCALE);
__m256 out[2], factor = _mm256_set1_ps(1.0f / S32_SCALE_I2F);
__m256i mask1 = _mm256_setr_epi32(0*n_channels, 1*n_channels, 2*n_channels, 3*n_channels,
4*n_channels, 5*n_channels, 6*n_channels, 7*n_channels);
@ -447,7 +447,7 @@ conv_s32_to_f32d_1s_avx2(void *data, void * SPA_RESTRICT dst[], const void * SPA
s += 16*n_channels;
}
for(; n < n_samples; n++) {
__m128 out, factor = _mm_set1_ps(1.0f / S32_SCALE);
__m128 out, factor = _mm_set1_ps(1.0f / S32_SCALE_I2F);
out = _mm_cvtsi32_ss(factor, s[0]);
out = _mm_mul_ss(out, factor);
_mm_store_ss(&d0[n], out);
@ -479,9 +479,9 @@ conv_f32d_to_s32_1s_avx2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
uint32_t n, unrolled;
__m128 in[1];
__m128i out[4];
__m128 scale = _mm_set1_ps(S25_SCALE);
__m128 int_max = _mm_set1_ps(S25_MAX);
__m128 int_min = _mm_set1_ps(S25_MIN);
__m128 scale = _mm_set1_ps(S32_SCALE_F2I);
__m128 int_min = _mm_set1_ps(S32_MIN_F2I);
__m128 int_max = _mm_set1_ps(S32_MAX_F2I);
if (SPA_IS_ALIGNED(s0, 16))
unrolled = n_samples & ~3;
@ -492,7 +492,6 @@ conv_f32d_to_s32_1s_avx2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
in[0] = _mm_mul_ps(_mm_load_ps(&s0[n]), scale);
in[0] = _MM_CLAMP_PS(in[0], int_min, int_max);
out[0] = _mm_cvtps_epi32(in[0]);
out[0] = _mm_slli_epi32(out[0], 7);
out[1] = _mm_shuffle_epi32(out[0], _MM_SHUFFLE(0, 3, 2, 1));
out[2] = _mm_shuffle_epi32(out[0], _MM_SHUFFLE(1, 0, 3, 2));
out[3] = _mm_shuffle_epi32(out[0], _MM_SHUFFLE(2, 1, 0, 3));
@ -507,7 +506,7 @@ conv_f32d_to_s32_1s_avx2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
in[0] = _mm_load_ss(&s0[n]);
in[0] = _mm_mul_ss(in[0], scale);
in[0] = _MM_CLAMP_SS(in[0], int_min, int_max);
*d = _mm_cvtss_si32(in[0]) << 7;
*d = _mm_cvtss_si32(in[0]);
d += n_channels;
}
}
@ -527,9 +526,9 @@ conv_f32d_to_s32_2s_avx2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
uint32_t n, unrolled;
__m256 in[2];
__m256i out[2], t[2];
__m256 scale = _mm256_set1_ps(S25_SCALE);
__m256 int_min = _mm256_set1_ps(S25_MIN);
__m256 int_max = _mm256_set1_ps(S25_MAX);
__m256 scale = _mm256_set1_ps(S32_SCALE_F2I);
__m256 int_min = _mm256_set1_ps(S32_MIN_F2I);
__m256 int_max = _mm256_set1_ps(S32_MAX_F2I);
if (SPA_IS_ALIGNED(s0, 32) &&
SPA_IS_ALIGNED(s1, 32))
@ -546,8 +545,6 @@ conv_f32d_to_s32_2s_avx2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
out[0] = _mm256_cvtps_epi32(in[0]); /* a0 a1 a2 a3 a4 a5 a6 a7 */
out[1] = _mm256_cvtps_epi32(in[1]); /* b0 b1 b2 b3 b4 b5 b6 b7 */
out[0] = _mm256_slli_epi32(out[0], 7);
out[1] = _mm256_slli_epi32(out[1], 7);
t[0] = _mm256_unpacklo_epi32(out[0], out[1]); /* a0 b0 a1 b1 a4 b4 a5 b5 */
t[1] = _mm256_unpackhi_epi32(out[0], out[1]); /* a2 b2 a3 b3 a6 b6 a7 b7 */
@ -576,9 +573,9 @@ conv_f32d_to_s32_2s_avx2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
for(; n < n_samples; n++) {
__m128 in[2];
__m128i out[2];
__m128 scale = _mm_set1_ps(S25_SCALE);
__m128 int_min = _mm_set1_ps(S25_MIN);
__m128 int_max = _mm_set1_ps(S25_MAX);
__m128 scale = _mm_set1_ps(S32_SCALE_F2I);
__m128 int_min = _mm_set1_ps(S32_MIN_F2I);
__m128 int_max = _mm_set1_ps(S32_MAX_F2I);
in[0] = _mm_load_ss(&s0[n]);
in[1] = _mm_load_ss(&s1[n]);
@ -588,7 +585,6 @@ conv_f32d_to_s32_2s_avx2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
in[0] = _mm_mul_ps(in[0], scale);
in[0] = _MM_CLAMP_PS(in[0], int_min, int_max);
out[0] = _mm_cvtps_epi32(in[0]);
out[0] = _mm_slli_epi32(out[0], 7);
_mm_storel_epi64((__m128i*)d, out[0]);
d += n_channels;
}
@ -603,9 +599,9 @@ conv_f32d_to_s32_4s_avx2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
uint32_t n, unrolled;
__m256 in[4];
__m256i out[4], t[4];
__m256 scale = _mm256_set1_ps(S25_SCALE);
__m256 int_min = _mm256_set1_ps(S25_MIN);
__m256 int_max = _mm256_set1_ps(S25_MAX);
__m256 scale = _mm256_set1_ps(S32_SCALE_F2I);
__m256 int_min = _mm256_set1_ps(S32_MIN_F2I);
__m256 int_max = _mm256_set1_ps(S32_MAX_F2I);
if (SPA_IS_ALIGNED(s0, 32) &&
SPA_IS_ALIGNED(s1, 32) &&
@ -630,10 +626,6 @@ conv_f32d_to_s32_4s_avx2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
out[1] = _mm256_cvtps_epi32(in[1]); /* b0 b1 b2 b3 b4 b5 b6 b7 */
out[2] = _mm256_cvtps_epi32(in[2]); /* c0 c1 c2 c3 c4 c5 c6 c7 */
out[3] = _mm256_cvtps_epi32(in[3]); /* d0 d1 d2 d3 d4 d5 d6 d7 */
out[0] = _mm256_slli_epi32(out[0], 7);
out[1] = _mm256_slli_epi32(out[1], 7);
out[2] = _mm256_slli_epi32(out[2], 7);
out[3] = _mm256_slli_epi32(out[3], 7);
t[0] = _mm256_unpacklo_epi32(out[0], out[1]); /* a0 b0 a1 b1 a4 b4 a5 b5 */
t[1] = _mm256_unpackhi_epi32(out[0], out[1]); /* a2 b2 a3 b3 a6 b6 a7 b7 */
@ -658,9 +650,9 @@ conv_f32d_to_s32_4s_avx2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
for(; n < n_samples; n++) {
__m128 in[4];
__m128i out[4];
__m128 scale = _mm_set1_ps(S25_SCALE);
__m128 int_min = _mm_set1_ps(S25_MIN);
__m128 int_max = _mm_set1_ps(S25_MAX);
__m128 scale = _mm_set1_ps(S32_SCALE_F2I);
__m128 int_min = _mm_set1_ps(S32_MIN_F2I);
__m128 int_max = _mm_set1_ps(S32_MAX_F2I);
in[0] = _mm_load_ss(&s0[n]);
in[1] = _mm_load_ss(&s1[n]);
@ -674,7 +666,6 @@ conv_f32d_to_s32_4s_avx2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
in[0] = _mm_mul_ps(in[0], scale);
in[0] = _MM_CLAMP_PS(in[0], int_min, int_max);
out[0] = _mm_cvtps_epi32(in[0]);
out[0] = _mm_slli_epi32(out[0], 7);
_mm_storeu_si128((__m128i*)d, out[0]);
d += n_channels;
}

40
spa/plugins/audioconvert/fmt-ops-sse2.c
View file

@ -335,7 +335,7 @@ conv_s32_to_f32d_1s_sse2(void *data, void * SPA_RESTRICT dst[], const void * SPA
float *d0 = dst[0];
uint32_t n, unrolled;
__m128i in;
__m128 out, factor = _mm_set1_ps(1.0f / S32_SCALE);
__m128 out, factor = _mm_set1_ps(1.0f / S32_SCALE_I2F);
if (SPA_IS_ALIGNED(d0, 16))
unrolled = n_samples & ~3;
@ -380,9 +380,9 @@ conv_f32d_to_s32_1s_sse2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
uint32_t n, unrolled;
__m128 in[1];
__m128i out[4];
__m128 scale = _mm_set1_ps(S25_SCALE);
__m128 int_min = _mm_set1_ps(S25_MIN);
__m128 int_max = _mm_set1_ps(S25_MAX);
__m128 scale = _mm_set1_ps(S32_SCALE_F2I);
__m128 int_min = _mm_set1_ps(S32_MIN_F2I);
__m128 int_max = _mm_set1_ps(S32_MAX_F2I);
if (SPA_IS_ALIGNED(s0, 16))
unrolled = n_samples & ~3;
@ -393,7 +393,6 @@ conv_f32d_to_s32_1s_sse2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
in[0] = _mm_mul_ps(_mm_load_ps(&s0[n]), scale);
in[0] = _MM_CLAMP_PS(in[0], int_min, int_max);
out[0] = _mm_cvtps_epi32(in[0]);
out[0] = _mm_slli_epi32(out[0], 7);
out[1] = _mm_shuffle_epi32(out[0], _MM_SHUFFLE(0, 3, 2, 1));
out[2] = _mm_shuffle_epi32(out[0], _MM_SHUFFLE(1, 0, 3, 2));
out[3] = _mm_shuffle_epi32(out[0], _MM_SHUFFLE(2, 1, 0, 3));
@ -408,7 +407,7 @@ conv_f32d_to_s32_1s_sse2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
in[0] = _mm_load_ss(&s0[n]);
in[0] = _mm_mul_ss(in[0], scale);
in[0] = _MM_CLAMP_SS(in[0], int_min, int_max);
*d = _mm_cvtss_si32(in[0]) << 7;
*d = _mm_cvtss_si32(in[0]);
d += n_channels;
}
}
@ -422,9 +421,9 @@ conv_f32d_to_s32_2s_sse2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
uint32_t n, unrolled;
__m128 in[2];
__m128i out[2], t[2];
__m128 scale = _mm_set1_ps(S25_SCALE);
__m128 int_min = _mm_set1_ps(S25_MIN);
__m128 int_max = _mm_set1_ps(S25_MAX);
__m128 scale = _mm_set1_ps(S32_SCALE_F2I);
__m128 int_min = _mm_set1_ps(S32_MIN_F2I);
__m128 int_max = _mm_set1_ps(S32_MAX_F2I);
if (SPA_IS_ALIGNED(s0, 16) &&
SPA_IS_ALIGNED(s1, 16))
@ -441,8 +440,6 @@ conv_f32d_to_s32_2s_sse2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
out[0] = _mm_cvtps_epi32(in[0]);
out[1] = _mm_cvtps_epi32(in[1]);
out[0] = _mm_slli_epi32(out[0], 7);
out[1] = _mm_slli_epi32(out[1], 7);
t[0] = _mm_unpacklo_epi32(out[0], out[1]);
t[1] = _mm_unpackhi_epi32(out[0], out[1]);
@ -462,7 +459,6 @@ conv_f32d_to_s32_2s_sse2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
in[0] = _mm_mul_ps(in[0], scale);
in[0] = _MM_CLAMP_PS(in[0], int_min, int_max);
out[0] = _mm_cvtps_epi32(in[0]);
out[0] = _mm_slli_epi32(out[0], 7);
_mm_storel_epi64((__m128i*)d, out[0]);
d += n_channels;
}
@ -477,9 +473,9 @@ conv_f32d_to_s32_4s_sse2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
uint32_t n, unrolled;
__m128 in[4];
__m128i out[4];
__m128 scale = _mm_set1_ps(S25_SCALE);
__m128 int_min = _mm_set1_ps(S25_MIN);
__m128 int_max = _mm_set1_ps(S25_MAX);
__m128 scale = _mm_set1_ps(S32_SCALE_F2I);
__m128 int_min = _mm_set1_ps(S32_MIN_F2I);
__m128 int_max = _mm_set1_ps(S32_MAX_F2I);
if (SPA_IS_ALIGNED(s0, 16) &&
SPA_IS_ALIGNED(s1, 16) &&
@ -506,10 +502,6 @@ conv_f32d_to_s32_4s_sse2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
out[1] = _mm_cvtps_epi32(in[1]);
out[2] = _mm_cvtps_epi32(in[2]);
out[3] = _mm_cvtps_epi32(in[3]);
out[0] = _mm_slli_epi32(out[0], 7);
out[1] = _mm_slli_epi32(out[1], 7);
out[2] = _mm_slli_epi32(out[2], 7);
out[3] = _mm_slli_epi32(out[3], 7);
_mm_storeu_si128((__m128i*)(d + 0*n_channels), out[0]);
_mm_storeu_si128((__m128i*)(d + 1*n_channels), out[1]);
@ -530,7 +522,6 @@ conv_f32d_to_s32_4s_sse2(void *data, void * SPA_RESTRICT dst, const void * SPA_R
in[0] = _mm_mul_ps(in[0], scale);
in[0] = _MM_CLAMP_PS(in[0], int_min, int_max);
out[0] = _mm_cvtps_epi32(in[0]);
out[0] = _mm_slli_epi32(out[0], 7);
_mm_storeu_si128((__m128i*)d, out[0]);
d += n_channels;
}
@ -629,9 +620,9 @@ conv_f32d_to_s32_1s_noise_sse2(struct convert *conv, void * SPA_RESTRICT dst, co
uint32_t n, unrolled;
__m128 in[1];
__m128i out[4];
__m128 scale = _mm_set1_ps(S25_SCALE);
__m128 int_min = _mm_set1_ps(S25_MIN);
__m128 int_max = _mm_set1_ps(S25_MAX);
__m128 scale = _mm_set1_ps(S32_SCALE_F2I);
__m128 int_min = _mm_set1_ps(S32_MIN_F2I);
__m128 int_max = _mm_set1_ps(S32_MAX_F2I);
if (SPA_IS_ALIGNED(s, 16))
unrolled = n_samples & ~3;
@ -643,7 +634,6 @@ conv_f32d_to_s32_1s_noise_sse2(struct convert *conv, void * SPA_RESTRICT dst, co
in[0] = _mm_add_ps(in[0], _mm_load_ps(&noise[n]));
in[0] = _MM_CLAMP_PS(in[0], int_min, int_max);
out[0] = _mm_cvtps_epi32(in[0]);
out[0] = _mm_slli_epi32(out[0], 7);
out[1] = _mm_shuffle_epi32(out[0], _MM_SHUFFLE(0, 3, 2, 1));
out[2] = _mm_shuffle_epi32(out[0], _MM_SHUFFLE(1, 0, 3, 2));
out[3] = _mm_shuffle_epi32(out[0], _MM_SHUFFLE(2, 1, 0, 3));
@ -659,7 +649,7 @@ conv_f32d_to_s32_1s_noise_sse2(struct convert *conv, void * SPA_RESTRICT dst, co
in[0] = _mm_mul_ss(in[0], scale);
in[0] = _mm_add_ss(in[0], _mm_load_ss(&noise[n]));
in[0] = _MM_CLAMP_SS(in[0], int_min, int_max);
*d = _mm_cvtss_si32(in[0]) << 7;
*d = _mm_cvtss_si32(in[0]);
d += n_channels;
}
}

10
spa/plugins/audioconvert/fmt-ops.h
View file

@ -121,10 +121,14 @@
#define S32_MIN -2147483648
#define S32_MAX 2147483647
#define S32_SCALE 2147483648.0f
#define S32_TO_F32(v) ITOF(int32_t, v, S32_SCALE, 0.0f)
#define S32_SCALE_I2F 2147483648.0f
#define S32_TO_F32(v) ITOF(int32_t, v, S32_SCALE_I2F, 0.0f)
#define S32S_TO_F32(v) S32_TO_F32(bswap_32(v))
#define F32_TO_S32_D(v,d) S25_32_TO_S32(F32_TO_S25_32_D(v,d))
#define S32_MIN_F2I ((int32_t)(((uint32_t)(S25_MIN)) << 7))
#define S32_MAX_F2I ((S25_MAX) << 7)
#define S32_SCALE_F2I (-((float)(S32_MIN_F2I)))
#define F32_TO_S32_D(v,d) FTOI(int32_t, v, S32_SCALE_F2I, 0.0f, d, S32_MIN_F2I, S32_MAX_F2I)
#define F32_TO_S32(v) F32_TO_S32_D(v, 0.0f)
#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))

17
spa/plugins/audioconvert/test-fmt-ops.c
View file

@ -299,11 +299,11 @@ static void test_f32_s32(void)
1.0f/0x100000000, -1.0f/0x100000000, 1.0f/0x200000000, -1.0f/0x200000000,
};
static const int32_t out[] = { 0x00000000, 0x7fffff80, 0x80000000,
0x40000000, 0xc0000000, 0x7fffff80, 0x80000000, 0x00000100,
0xffffff00, 0x00000100, 0xffffff00, 0x00000080, 0xffffff80,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
0x40000000, 0xc0000000, 0x7fffff80, 0x80000000, 0x000000cd,
0xffffff33, 0x00000100, 0xffffff00, 0x00000080, 0xffffff80,
0x00000040, 0xffffffc0, 0x00000020, 0xffffffe0, 0x00000010,
0xfffffff0, 0x00000008, 0xfffffff8, 0x00000004, 0xfffffffc,
0x00000002, 0xfffffffe, 0x00000001, 0xffffffff, 0x00000000,
0x00000000, 0x00000000, 0x00000000,
};
@ -687,20 +687,15 @@ static void test_lossless_s32_lossless_subset(void)
{
int32_t i, j;
int all_lossless = 1;
int32_t max_abs_err = -1;
fprintf(stderr, "test %s:\n", __func__);
for (i = S25_MIN; i <= S25_MAX; i+=1) {
for(j = 0; j < 8; ++j) {
int32_t s = i * (1<<j);
float v = S32_TO_F32(s);
int32_t t = F32_TO_S32(v);
all_lossless &= s == t;
max_abs_err = SPA_MAX(max_abs_err, SPA_ABS(s - t));
spa_assert_se(s == t);
}
}
spa_assert_se(!all_lossless);
spa_assert_se(max_abs_err == 64);
}
static void test_lossless_u32(void)