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: optimise f32d to/from s16s conversions

Browse source 
They are mostly used for sending and receiving RTP so it might be worth
to make them a bit faster.
This commit is contained in:
Wim Taymans 2025-01-24 10:35:52 +01:00
parent edcecd8975
commit 0c8f803d59
4 changed files with 427 additions and 9 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -23,6 +23,13 @@
#define _MM_CLAMP_SS(r,min,max) \
_mm_min_ss(_mm_max_ss(r, min), max)
#define _MM256_BSWAP_EPI16(x) \
({ \
_mm256_or_si256( \
_mm256_slli_epi16(x, 8), \
_mm256_srli_epi16(x, 8)); \
})
static void
conv_s16_to_f32d_1s_avx2(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src,
uint32_t n_channels, uint32_t n_samples)
@ -74,6 +81,59 @@ conv_s16_to_f32d_avx2(struct convert *conv, void * SPA_RESTRICT dst[], const voi
conv_s16_to_f32d_1s_avx2(conv, &dst[i], &s[i], n_channels, n_samples);
}
static void
conv_s16s_to_f32d_1s_avx2(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src,
uint32_t n_channels, uint32_t n_samples)
{
const uint16_t *s = src;
float *d0 = dst[0];
uint32_t n, unrolled;
__m256i in = _mm256_setzero_si256();
__m256 out, factor = _mm256_set1_ps(1.0f / S16_SCALE);
if (SPA_LIKELY(SPA_IS_ALIGNED(d0, 32)))
unrolled = n_samples & ~7;
else
unrolled = 0;
for(n = 0; n < unrolled; n += 8) {
in = _mm256_insert_epi16(in, s[0*n_channels], 1);
in = _mm256_insert_epi16(in, s[1*n_channels], 3);
in = _mm256_insert_epi16(in, s[2*n_channels], 5);
in = _mm256_insert_epi16(in, s[3*n_channels], 7);
in = _mm256_insert_epi16(in, s[4*n_channels], 9);
in = _mm256_insert_epi16(in, s[5*n_channels], 11);
in = _mm256_insert_epi16(in, s[6*n_channels], 13);
in = _mm256_insert_epi16(in, s[7*n_channels], 15);
in = _MM256_BSWAP_EPI16(in);
in = _mm256_srai_epi32(in, 16);
out = _mm256_cvtepi32_ps(in);
out = _mm256_mul_ps(out, factor);
_mm256_store_ps(&d0[n], out);
s += 8*n_channels;
}
for(; n < n_samples; n++) {
__m128 out, factor = _mm_set1_ps(1.0f / S16_SCALE);
out = _mm_cvtsi32_ss(factor, (int16_t)bswap_16(s[0]));
out = _mm_mul_ss(out, factor);
_mm_store_ss(&d0[n], out);
s += n_channels;
}
}
void
conv_s16s_to_f32d_avx2(struct convert *conv, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[],
uint32_t n_samples)
{
const uint16_t *s = src[0];
uint32_t i = 0, n_channels = conv->n_channels;
for(; i < n_channels; i++)
conv_s16s_to_f32d_1s_avx2(conv, &dst[i], &s[i], n_channels, n_samples);
}
void
conv_s16_to_f32d_2_avx2(struct convert *conv, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[],
uint32_t n_samples)
@ -132,6 +192,66 @@ conv_s16_to_f32d_2_avx2(struct convert *conv, void * SPA_RESTRICT dst[], const v
}
}
void
conv_s16s_to_f32d_2_avx2(struct convert *conv, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[],
uint32_t n_samples)
{
const uint16_t *s = src[0];
float *d0 = dst[0], *d1 = dst[1];
uint32_t n, unrolled;
__m256i in[2], t[4];
__m256 out[4], factor = _mm256_set1_ps(1.0f / S16_SCALE);
if (SPA_IS_ALIGNED(s, 32) &&
SPA_IS_ALIGNED(d0, 32) &&
SPA_IS_ALIGNED(d1, 32))
unrolled = n_samples & ~15;
else
unrolled = 0;
for(n = 0; n < unrolled; n += 16) {
in[0] = _mm256_load_si256((__m256i*)(s + 0));
in[1] = _mm256_load_si256((__m256i*)(s + 16));
in[0] = _MM256_BSWAP_EPI16(in[0]);
in[1] = _MM256_BSWAP_EPI16(in[1]);
t[0] = _mm256_slli_epi32(in[0], 16);
t[0] = _mm256_srai_epi32(t[0], 16);
out[0] = _mm256_cvtepi32_ps(t[0]);
out[0] = _mm256_mul_ps(out[0], factor);
t[1] = _mm256_srai_epi32(in[0], 16);
out[1] = _mm256_cvtepi32_ps(t[1]);
out[1] = _mm256_mul_ps(out[1], factor);
t[2] = _mm256_slli_epi32(in[1], 16);
t[2] = _mm256_srai_epi32(t[2], 16);
out[2] = _mm256_cvtepi32_ps(t[2]);
out[2] = _mm256_mul_ps(out[2], factor);
t[3] = _mm256_srai_epi32(in[1], 16);
out[3] = _mm256_cvtepi32_ps(t[3]);
out[3] = _mm256_mul_ps(out[3], factor);
_mm256_store_ps(&d0[n + 0], out[0]);
_mm256_store_ps(&d1[n + 0], out[1]);
_mm256_store_ps(&d0[n + 8], out[2]);
_mm256_store_ps(&d1[n + 8], out[3]);
s += 32;
}
for(; n < n_samples; n++) {
__m128 out[4], factor = _mm_set1_ps(1.0f / S16_SCALE);
out[0] = _mm_cvtsi32_ss(factor, (int16_t)bswap_16(s[0]));
out[0] = _mm_mul_ss(out[0], factor);
out[1] = _mm_cvtsi32_ss(factor, (int16_t)bswap_16(s[1]));
out[1] = _mm_mul_ss(out[1], factor);
_mm_store_ss(&d0[n], out[0]);
_mm_store_ss(&d1[n], out[1]);
s += 2;
}
}
static void
conv_s24_to_f32d_1s_avx2(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src,
uint32_t n_channels, uint32_t n_samples)
@ -1006,3 +1126,62 @@ conv_f32d_to_s16_2_avx2(struct convert *conv, void * SPA_RESTRICT dst[], const v
d += 2;
}
}
void
conv_f32d_to_s16s_2_avx2(struct convert *conv, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[],
uint32_t n_samples)
{
const float *s0 = src[0], *s1 = src[1];
uint16_t *d = dst[0];
uint32_t n, unrolled;
__m256 in[4];
__m256i out[4], t[4];
__m256 int_scale = _mm256_set1_ps(S16_SCALE);
if (SPA_IS_ALIGNED(s0, 32) &&
SPA_IS_ALIGNED(s1, 32))
unrolled = n_samples & ~15;
else
unrolled = 0;
for(n = 0; n < unrolled; n += 16) {
in[0] = _mm256_mul_ps(_mm256_load_ps(&s0[n+0]), int_scale);
in[1] = _mm256_mul_ps(_mm256_load_ps(&s1[n+0]), int_scale);
in[2] = _mm256_mul_ps(_mm256_load_ps(&s0[n+8]), int_scale);
in[3] = _mm256_mul_ps(_mm256_load_ps(&s1[n+8]), int_scale);
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[2] = _mm256_cvtps_epi32(in[2]); /* a0 a1 a2 a3 a4 a5 a6 a7 */
out[3] = _mm256_cvtps_epi32(in[3]); /* b0 b1 b2 b3 b4 b5 b6 b7 */
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 */
t[2] = _mm256_unpacklo_epi32(out[2], out[3]); /* a0 b0 a1 b1 a4 b4 a5 b5 */
t[3] = _mm256_unpackhi_epi32(out[2], out[3]); /* a2 b2 a3 b3 a6 b6 a7 b7 */
out[0] = _mm256_packs_epi32(t[0], t[1]); /* a0 b0 a1 b1 a2 b2 a3 b3 a4 b4 a5 b5 a6 b6 a7 b7 */
out[1] = _mm256_packs_epi32(t[2], t[3]); /* a0 b0 a1 b1 a2 b2 a3 b3 a4 b4 a5 b5 a6 b6 a7 b7 */
out[0] = _MM256_BSWAP_EPI16(out[0]);
out[1] = _MM256_BSWAP_EPI16(out[1]);
_mm256_store_si256((__m256i*)(d+0), out[0]);
_mm256_store_si256((__m256i*)(d+16), out[1]);
d += 32;
}
for(; n < n_samples; n++) {
__m128 in[4];
__m128 int_scale = _mm_set1_ps(S16_SCALE);
__m128 int_max = _mm_set1_ps(S16_MAX);
__m128 int_min = _mm_set1_ps(S16_MIN);
in[0] = _mm_mul_ss(_mm_load_ss(&s0[n]), int_scale);
in[1] = _mm_mul_ss(_mm_load_ss(&s1[n]), int_scale);
in[0] = _MM_CLAMP_SS(in[0], int_min, int_max);
in[1] = _MM_CLAMP_SS(in[1], int_min, int_max);
d[0] = bswap_16((uint16_t)_mm_cvtss_si32(in[0]));
d[1] = bswap_16((uint16_t)_mm_cvtss_si32(in[1]));
d += 2;
}
}

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

@ -12,6 +12,20 @@
#define _MM_CLAMP_SS(r,min,max) \
_mm_min_ss(_mm_max_ss(r, min), max)
#define _MM_BSWAP_EPI16(x) \
({ \
_mm_or_si128( \
_mm_slli_epi16(x, 8), \
_mm_srli_epi16(x, 8)); \
})
#define _MM_BSWAP_EPI32(x) \
({ \
__m128i a = _MM_BSWAP_EPI16(x); \
a = _mm_shufflelo_epi16(a, _MM_SHUFFLE(2, 3, 0, 1)); \
a = _mm_shufflehi_epi16(a, _MM_SHUFFLE(2, 3, 0, 1)); \
})
static void
conv_s16_to_f32d_1s_sse2(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src,
uint32_t n_channels, uint32_t n_samples)
@ -57,6 +71,52 @@ conv_s16_to_f32d_sse2(struct convert *conv, void * SPA_RESTRICT dst[], const voi
conv_s16_to_f32d_1s_sse2(conv, &dst[i], &s[i], n_channels, n_samples);
}
static void
conv_s16s_to_f32d_1s_sse2(void *data, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src,
uint32_t n_channels, uint32_t n_samples)
{
const uint16_t *s = src;
float *d0 = dst[0];
uint32_t n, unrolled;
__m128i in = _mm_setzero_si128();
__m128 out, factor = _mm_set1_ps(1.0f / S16_SCALE);
if (SPA_LIKELY(SPA_IS_ALIGNED(d0, 16)))
unrolled = n_samples & ~3;
else
unrolled = 0;
for(n = 0; n < unrolled; n += 4) {
in = _mm_insert_epi16(in, s[0*n_channels], 1);
in = _mm_insert_epi16(in, s[1*n_channels], 3);
in = _mm_insert_epi16(in, s[2*n_channels], 5);
in = _mm_insert_epi16(in, s[3*n_channels], 7);
in = _MM_BSWAP_EPI16(in);
in = _mm_srai_epi32(in, 16);
out = _mm_cvtepi32_ps(in);
out = _mm_mul_ps(out, factor);
_mm_store_ps(&d0[n], out);
s += 4*n_channels;
}
for(; n < n_samples; n++) {
out = _mm_cvtsi32_ss(factor, (int16_t)bswap_16(s[0]));
out = _mm_mul_ss(out, factor);
_mm_store_ss(&d0[n], out);
s += n_channels;
}
}
void
conv_s16s_to_f32d_sse2(struct convert *conv, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[],
uint32_t n_samples)
{
const uint16_t *s = src[0];
uint32_t i = 0, n_channels = conv->n_channels;
for(; i < n_channels; i++)
conv_s16s_to_f32d_1s_sse2(conv, &dst[i], &s[i], n_channels, n_samples);
}
void
conv_s16_to_f32d_2_sse2(struct convert *conv, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[],
uint32_t n_samples)
@ -114,6 +174,65 @@ conv_s16_to_f32d_2_sse2(struct convert *conv, void * SPA_RESTRICT dst[], const v
}
}
void
conv_s16s_to_f32d_2_sse2(struct convert *conv, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[],
uint32_t n_samples)
{
const uint16_t *s = src[0];
float *d0 = dst[0], *d1 = dst[1];
uint32_t n, unrolled;
__m128i in[2], t[4];
__m128 out[4], factor = _mm_set1_ps(1.0f / S16_SCALE);
if (SPA_IS_ALIGNED(s, 16) &&
SPA_IS_ALIGNED(d0, 16) &&
SPA_IS_ALIGNED(d1, 16))
unrolled = n_samples & ~7;
else
unrolled = 0;
for(n = 0; n < unrolled; n += 8) {
in[0] = _mm_load_si128((__m128i*)(s + 0));
in[1] = _mm_load_si128((__m128i*)(s + 8));
in[0] = _MM_BSWAP_EPI16(in[0]);
in[1] = _MM_BSWAP_EPI16(in[1]);
t[0] = _mm_slli_epi32(in[0], 16);
t[0] = _mm_srai_epi32(t[0], 16);
out[0] = _mm_cvtepi32_ps(t[0]);
out[0] = _mm_mul_ps(out[0], factor);
t[1] = _mm_srai_epi32(in[0], 16);
out[1] = _mm_cvtepi32_ps(t[1]);
out[1] = _mm_mul_ps(out[1], factor);
t[2] = _mm_slli_epi32(in[1], 16);
t[2] = _mm_srai_epi32(t[2], 16);
out[2] = _mm_cvtepi32_ps(t[2]);
out[2] = _mm_mul_ps(out[2], factor);
t[3] = _mm_srai_epi32(in[1], 16);
out[3] = _mm_cvtepi32_ps(t[3]);
out[3] = _mm_mul_ps(out[3], factor);
_mm_store_ps(&d0[n + 0], out[0]);
_mm_store_ps(&d1[n + 0], out[1]);
_mm_store_ps(&d0[n + 4], out[2]);
_mm_store_ps(&d1[n + 4], out[3]);
s += 16;
}
for(; n < n_samples; n++) {
out[0] = _mm_cvtsi32_ss(factor, (int16_t)bswap_16(s[0]));
out[0] = _mm_mul_ss(out[0], factor);
out[1] = _mm_cvtsi32_ss(factor, (int16_t)bswap_16(s[1]));
out[1] = _mm_mul_ss(out[1], factor);
_mm_store_ss(&d0[n], out[0]);
_mm_store_ss(&d1[n], out[1]);
s += 2;
}
}
#define spa_read_unaligned(ptr, type) \
__extension__ ({ \
__typeof__(type) _val; \
@ -756,15 +875,6 @@ conv_32d_to_32_sse2(struct convert *conv, void * SPA_RESTRICT dst[], const void
conv_interleave_32_1s_sse2(conv, &d[i], &src[i], n_channels, n_samples);
}
#define _MM_BSWAP_EPI32(x) \
({ \
__m128i a = _mm_or_si128( \
_mm_slli_epi16(x, 8), \
_mm_srli_epi16(x, 8)); \
a = _mm_shufflelo_epi16(a, _MM_SHUFFLE(2, 3, 0, 1)); \
a = _mm_shufflehi_epi16(a, _MM_SHUFFLE(2, 3, 0, 1)); \
})
static void
conv_interleave_32s_1s_sse2(void *data, void * SPA_RESTRICT dst, const void * SPA_RESTRICT src[],
uint32_t n_channels, uint32_t n_samples)
@ -1246,6 +1356,62 @@ conv_f32d_to_s16_sse2(struct convert *conv, void * SPA_RESTRICT dst[], const voi
conv_f32d_to_s16_1s_sse2(conv, &d[i], &src[i], n_channels, n_samples);
}
static void
conv_f32d_to_s16s_1s_sse2(void *data, void * SPA_RESTRICT dst, const void * SPA_RESTRICT src[],
uint32_t n_channels, uint32_t n_samples)
{
const float *s0 = src[0];
uint16_t *d = dst;
uint32_t n, unrolled;
__m128 in[2];
__m128i out[2];
__m128 int_scale = _mm_set1_ps(S16_SCALE);
__m128 int_max = _mm_set1_ps(S16_MAX);
__m128 int_min = _mm_set1_ps(S16_MIN);
if (SPA_IS_ALIGNED(s0, 16))
unrolled = n_samples & ~7;
else
unrolled = 0;
for(n = 0; n < unrolled; n += 8) {
in[0] = _mm_mul_ps(_mm_load_ps(&s0[n]), int_scale);
in[1] = _mm_mul_ps(_mm_load_ps(&s0[n+4]), int_scale);
out[0] = _mm_cvtps_epi32(in[0]);
out[1] = _mm_cvtps_epi32(in[1]);
out[0] = _mm_packs_epi32(out[0], out[1]);
out[0] = _MM_BSWAP_EPI16(out[0]);
d[0*n_channels] = _mm_extract_epi16(out[0], 0);
d[1*n_channels] = _mm_extract_epi16(out[0], 1);
d[2*n_channels] = _mm_extract_epi16(out[0], 2);
d[3*n_channels] = _mm_extract_epi16(out[0], 3);
d[4*n_channels] = _mm_extract_epi16(out[0], 4);
d[5*n_channels] = _mm_extract_epi16(out[0], 5);
d[6*n_channels] = _mm_extract_epi16(out[0], 6);
d[7*n_channels] = _mm_extract_epi16(out[0], 7);
d += 8*n_channels;
}
for(; n < n_samples; n++) {
in[0] = _mm_mul_ss(_mm_load_ss(&s0[n]), int_scale);
in[0] = _MM_CLAMP_SS(in[0], int_min, int_max);
*d = bswap_16((uint16_t)_mm_cvtss_si32(in[0]));
d += n_channels;
}
}
void
conv_f32d_to_s16s_sse2(struct convert *conv, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[],
uint32_t n_samples)
{
uint16_t *d = dst[0];
uint32_t i = 0, n_channels = conv->n_channels;
for(; i < n_channels; i++)
conv_f32d_to_s16s_1s_sse2(conv, &d[i], &src[i], n_channels, n_samples);
}
static void
conv_f32d_to_s16_1s_noise_sse2(struct convert *conv, void * SPA_RESTRICT dst, const void * SPA_RESTRICT src,
const float *noise, uint32_t n_channels, uint32_t n_samples)
@ -1418,3 +1584,58 @@ conv_f32d_to_s16_2_sse2(struct convert *conv, void * SPA_RESTRICT dst[], const v
d += 2;
}
}
void
conv_f32d_to_s16s_2_sse2(struct convert *conv, void * SPA_RESTRICT dst[], const void * SPA_RESTRICT src[],
uint32_t n_samples)
{
const float *s0 = src[0], *s1 = src[1];
uint16_t *d = dst[0];
uint32_t n, unrolled;
__m128 in[4];
__m128i out[4];
__m128 int_scale = _mm_set1_ps(S16_SCALE);
__m128 int_max = _mm_set1_ps(S16_MAX);
__m128 int_min = _mm_set1_ps(S16_MIN);
if (SPA_IS_ALIGNED(s0, 16) &&
SPA_IS_ALIGNED(s1, 16))
unrolled = n_samples & ~7;
else
unrolled = 0;
for(n = 0; n < unrolled; n += 8) {
in[0] = _mm_mul_ps(_mm_load_ps(&s0[n+0]), int_scale);
in[1] = _mm_mul_ps(_mm_load_ps(&s1[n+0]), int_scale);
in[2] = _mm_mul_ps(_mm_load_ps(&s0[n+4]), int_scale);
in[3] = _mm_mul_ps(_mm_load_ps(&s1[n+4]), int_scale);
out[0] = _mm_cvtps_epi32(in[0]);
out[1] = _mm_cvtps_epi32(in[1]);
out[2] = _mm_cvtps_epi32(in[2]);
out[3] = _mm_cvtps_epi32(in[3]);
out[0] = _mm_packs_epi32(out[0], out[2]);
out[1] = _mm_packs_epi32(out[1], out[3]);
out[2] = _mm_unpacklo_epi16(out[0], out[1]);
out[3] = _mm_unpackhi_epi16(out[0], out[1]);
out[2] = _MM_BSWAP_EPI16(out[2]);
out[3] = _MM_BSWAP_EPI16(out[3]);
_mm_storeu_si128((__m128i*)(d+0), out[2]);
_mm_storeu_si128((__m128i*)(d+8), out[3]);
d += 16;
}
for(; n < n_samples; n++) {
in[0] = _mm_mul_ss(_mm_load_ss(&s0[n]), int_scale);
in[1] = _mm_mul_ss(_mm_load_ss(&s1[n]), int_scale);
in[0] = _MM_CLAMP_SS(in[0], int_min, int_max);
in[1] = _MM_CLAMP_SS(in[1], int_min, int_max);
d[0] = bswap_16((uint16_t)_mm_cvtss_si32(in[0]));
d[1] = bswap_16((uint16_t)_mm_cvtss_si32(in[1]));
d += 2;
}
}

12
spa/plugins/audioconvert/fmt-ops.c
View file

@ -75,6 +75,14 @@ static struct conv_info conv_table[] =
MAKE(S16, F32P, 0, conv_s16_to_f32d_c),
MAKE(S16P, F32, 0, conv_s16d_to_f32_c),
#if defined (HAVE_AVX2)
MAKE(S16_OE, F32P, 2, conv_s16s_to_f32d_2_avx2, SPA_CPU_FLAG_AVX2),
MAKE(S16_OE, F32P, 0, conv_s16s_to_f32d_avx2, SPA_CPU_FLAG_AVX2),
#endif
#if defined (HAVE_SSE2)
MAKE(S16_OE, F32P, 2, conv_s16s_to_f32d_2_sse2, SPA_CPU_FLAG_SSE2),
MAKE(S16_OE, F32P, 0, conv_s16s_to_f32d_sse2, SPA_CPU_FLAG_SSE2),
#endif
MAKE(S16_OE, F32P, 0, conv_s16s_to_f32d_c),
MAKE(F32, F32, 0, conv_copy32_c),
@ -223,6 +231,10 @@ static struct conv_info conv_table[] =
MAKE(F32P, S16_OE, 0, conv_f32d_to_s16s_shaped_c, 0, CONV_SHAPE),
MAKE(F32P, S16_OE, 0, conv_f32d_to_s16s_noise_c, 0, CONV_NOISE),
#if defined (HAVE_SSE2)
MAKE(F32P, S16_OE, 2, conv_f32d_to_s16s_2_sse2, SPA_CPU_FLAG_SSE2),
MAKE(F32P, S16_OE, 0, conv_f32d_to_s16s_sse2, SPA_CPU_FLAG_SSE2),
#endif
MAKE(F32P, S16_OE, 0, conv_f32d_to_s16s_c),
MAKE(F32, U32, 0, conv_f32_to_u32_c),

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

@ -451,6 +451,8 @@ DEFINE_FUNCTION(s32_to_f32d, rvv);
#if defined(HAVE_SSE2)
DEFINE_FUNCTION(s16_to_f32d_2, sse2);
DEFINE_FUNCTION(s16_to_f32d, sse2);
DEFINE_FUNCTION(s16s_to_f32d, sse2);
DEFINE_FUNCTION(s16s_to_f32d_2, sse2);
DEFINE_FUNCTION(s24_to_f32d, sse2);
DEFINE_FUNCTION(s32_to_f32d, sse2);
DEFINE_FUNCTION(f32d_to_s32, sse2);
@ -458,6 +460,8 @@ DEFINE_FUNCTION(f32d_to_s32_noise, sse2);
DEFINE_FUNCTION(f32_to_s16, sse2);
DEFINE_FUNCTION(f32d_to_s16_2, sse2);
DEFINE_FUNCTION(f32d_to_s16, sse2);
DEFINE_FUNCTION(f32d_to_s16s_2, sse2);
DEFINE_FUNCTION(f32d_to_s16s, sse2);
DEFINE_FUNCTION(f32d_to_s16_noise, sse2);
DEFINE_FUNCTION(f32d_to_s16d, sse2);
DEFINE_FUNCTION(f32d_to_s16d_noise, sse2);
@ -475,6 +479,8 @@ DEFINE_FUNCTION(s24_to_f32d, sse41);
#if defined(HAVE_AVX2)
DEFINE_FUNCTION(s16_to_f32d_2, avx2);
DEFINE_FUNCTION(s16_to_f32d, avx2);
DEFINE_FUNCTION(s16s_to_f32d, avx2);
DEFINE_FUNCTION(s16s_to_f32d_2, avx2);
DEFINE_FUNCTION(s24_to_f32d, avx2);
DEFINE_FUNCTION(s32_to_f32d, avx2);
DEFINE_FUNCTION(f32d_to_s32, avx2);