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

audioconvert: pass samples to convert functions

Browse source 
Pass the number of samples to convert functions instead of number of
bytes because it is much more useful.
This commit is contained in:
Wim Taymans 2018-12-13 12:02:47 +01:00
parent 491dd785ad
commit 08a63ded5d
5 changed files with 242 additions and 266 deletions
Download patch file Download diff file Expand all files Collapse all files

71
spa/plugins/audioconvert/fmt-ops-sse.c
View file

@ -30,16 +30,14 @@
#include <xmmintrin.h> #include <xmmintrin.h>
static void static void
conv_s16_to_f32d_1_sse(void *data, int n_dst, void *dst[n_dst], const void *src, int n_bytes) conv_s16_to_f32d_1_sse(void *data, int n_dst, void *dst[n_dst], const void *src, int n_samples)
{ {
const int16_t *s = src; const int16_t *s = src;
float **d = (float **) dst; float **d = (float **) dst;
float *d0 = d[0]; float *d0 = d[0];
int n, n_samples; int n;
__m128 out, factor = _mm_set1_ps(1.0f / S16_SCALE); __m128 out, factor = _mm_set1_ps(1.0f / S16_SCALE);
n_samples = n_bytes / (sizeof(int16_t) * n_dst);
for(n = 0; n_samples--; n++) { for(n = 0; n_samples--; n++) {
out = _mm_cvtsi32_ss(out, *s); out = _mm_cvtsi32_ss(out, *s);
out = _mm_mul_ss(out, factor); out = _mm_mul_ss(out, factor);
@ -49,17 +47,15 @@ conv_s16_to_f32d_1_sse(void *data, int n_dst, void *dst[n_dst], const void *src,
} }
static void static void
conv_s16_to_f32d_2_sse(void *data, int n_dst, void *dst[n_dst], const void *src, int n_bytes) conv_s16_to_f32d_2_sse(void *data, int n_dst, void *dst[n_dst], const void *src, int n_samples)
{ {
const int16_t *s = src; const int16_t *s = src;
float **d = (float **) dst; float **d = (float **) dst;
float *d0 = d[0], *d1 = d[1]; float *d0 = d[0], *d1 = d[1];
int n = 0, n_samples, unrolled; int n = 0, unrolled;
__m128i in, t[2]; __m128i in, t[2];
__m128 out[2], factor = _mm_set1_ps(1.0f / S16_SCALE); __m128 out[2], factor = _mm_set1_ps(1.0f / S16_SCALE);
n_samples = n_bytes / (sizeof(int16_t) * n_dst);
if (n_dst == 2) { if (n_dst == 2) {
unrolled = n_samples / 4; unrolled = n_samples / 4;
n_samples = n_samples & 3; n_samples = n_samples & 3;
@ -94,24 +90,24 @@ conv_s16_to_f32d_2_sse(void *data, int n_dst, void *dst[n_dst], const void *src,
} }
static void static void
conv_s16_to_f32d_sse(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_s16_to_f32d_sse(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const int16_t *s = src[0]; const int16_t *s = src[0];
int i = 0; int i = 0;
for(; i + 1 < n_dst; i += 2) for(; i + 1 < n_dst; i += 2)
conv_s16_to_f32d_2_sse(data, n_dst, &dst[i], &s[i], n_bytes); conv_s16_to_f32d_2_sse(data, n_dst, &dst[i], &s[i], n_samples);
for(; i < n_dst; i++) for(; i < n_dst; i++)
conv_s16_to_f32d_1_sse(data, n_dst, &dst[i], &s[i], n_bytes); conv_s16_to_f32d_1_sse(data, n_dst, &dst[i], &s[i], n_samples);
} }
static void static void
conv_s24_to_f32d_1_sse(void *data, int n_dst, void *dst[n_dst], const void *src, int n_bytes) conv_s24_to_f32d_1_sse(void *data, int n_dst, void *dst[n_dst], const void *src, int n_samples)
{ {
const uint8_t *s = src; const uint8_t *s = src;
float **d = (float **) dst; float **d = (float **) dst;
float *d0 = d[0]; float *d0 = d[0];
int n = 0, n_samples, unrolled; int n = 0, unrolled;
__m128i in; __m128i in;
union { union {
__m128i in; __m128i in;
@ -119,8 +115,6 @@ conv_s24_to_f32d_1_sse(void *data, int n_dst, void *dst[n_dst], const void *src,
} b; } b;
__m128 out, factor = _mm_set1_ps(1.0f / S24_SCALE); __m128 out, factor = _mm_set1_ps(1.0f / S24_SCALE);
n_samples = n_bytes / (3 * n_dst);
unrolled = n_samples / 4; unrolled = n_samples / 4;
n_samples = n_samples & 3; n_samples = n_samples & 3;
@ -144,29 +138,27 @@ conv_s24_to_f32d_1_sse(void *data, int n_dst, void *dst[n_dst], const void *src,
} }
static void static void
conv_s24_to_f32d_sse(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_s24_to_f32d_sse(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const int8_t *s = src[0]; const int8_t *s = src[0];
int i = 0; int i = 0;
for(; i < n_dst; i++) for(; i < n_dst; i++)
conv_s24_to_f32d_1_sse(data, n_dst, &dst[i], &s[3*i], n_bytes); conv_s24_to_f32d_1_sse(data, n_dst, &dst[i], &s[3*i], n_samples);
} }
static void static void
conv_f32d_to_s32_1_sse(void *data, void *dst, int n_src, const void *src[n_src], int n_bytes) conv_f32d_to_s32_1_sse(void *data, void *dst, int n_src, const void *src[n_src], int n_samples)
{ {
const float **s = (const float **) src; const float **s = (const float **) src;
const float *s0 = s[0]; const float *s0 = s[0];
int32_t *d = dst; int32_t *d = dst;
int n, n_samples, unrolled; int n, unrolled;
__m128 in[1]; __m128 in[1];
__m128i out[4]; __m128i out[4];
__m128 int_max = _mm_set1_ps(S24_MAX_F); __m128 int_max = _mm_set1_ps(S24_MAX_F);
__m128 int_min = _mm_sub_ps(_mm_setzero_ps(), int_max); __m128 int_min = _mm_sub_ps(_mm_setzero_ps(), int_max);
n_samples = n_bytes / sizeof(float);
unrolled = n_samples / 4; unrolled = n_samples / 4;
n_samples = n_samples & 3; n_samples = n_samples & 3;
@ -195,19 +187,17 @@ conv_f32d_to_s32_1_sse(void *data, void *dst, int n_src, const void *src[n_src],
} }
static void static void
conv_f32d_to_s32_2_sse(void *data, void *dst, int n_src, const void *src[n_src], int n_bytes) conv_f32d_to_s32_2_sse(void *data, void *dst, int n_src, const void *src[n_src], int n_samples)
{ {
const float **s = (const float **) src; const float **s = (const float **) src;
const float *s0 = s[0], *s1 = s[1]; const float *s0 = s[0], *s1 = s[1];
int32_t *d = dst; int32_t *d = dst;
int n, n_samples, unrolled; int n, unrolled;
__m128 in[2]; __m128 in[2];
__m128i out[2], t[2]; __m128i out[2], t[2];
__m128 int_max = _mm_set1_ps(S24_MAX_F); __m128 int_max = _mm_set1_ps(S24_MAX_F);
__m128 int_min = _mm_sub_ps(_mm_setzero_ps(), int_max); __m128 int_min = _mm_sub_ps(_mm_setzero_ps(), int_max);
n_samples = n_bytes / sizeof(float);
unrolled = n_samples / 4; unrolled = n_samples / 4;
n_samples = n_samples & 3; n_samples = n_samples & 3;
@ -247,19 +237,17 @@ conv_f32d_to_s32_2_sse(void *data, void *dst, int n_src, const void *src[n_src],
} }
static void static void
conv_f32d_to_s32_4_sse(void *data, void *dst, int n_src, const void *src[n_src], int n_bytes) conv_f32d_to_s32_4_sse(void *data, void *dst, int n_src, const void *src[n_src], int n_samples)
{ {
const float **s = (const float **) src; const float **s = (const float **) src;
const float *s0 = s[0], *s1 = s[1], *s2 = s[2], *s3 = s[3]; const float *s0 = s[0], *s1 = s[1], *s2 = s[2], *s3 = s[3];
int32_t *d = dst; int32_t *d = dst;
int n, n_samples, unrolled; int n, unrolled;
__m128 in[4]; __m128 in[4];
__m128i out[4], t[4]; __m128i out[4], t[4];
__m128 int_max = _mm_set1_ps(S24_MAX_F); __m128 int_max = _mm_set1_ps(S24_MAX_F);
__m128 int_min = _mm_sub_ps(_mm_setzero_ps(), int_max); __m128 int_min = _mm_sub_ps(_mm_setzero_ps(), int_max);
n_samples = n_bytes / sizeof(float);
unrolled = n_samples / 4; unrolled = n_samples / 4;
n_samples = n_samples & 3; n_samples = n_samples & 3;
@ -314,33 +302,31 @@ conv_f32d_to_s32_4_sse(void *data, void *dst, int n_src, const void *src[n_src],
} }
static void static void
conv_f32d_to_s32_sse(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_f32d_to_s32_sse(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
int32_t *d = dst[0]; int32_t *d = dst[0];
int i = 0; int i = 0;
for(; i + 3 < n_src; i += 4) for(; i + 3 < n_src; i += 4)
conv_f32d_to_s32_4_sse(data, &d[i], n_src, &src[i], n_bytes); conv_f32d_to_s32_4_sse(data, &d[i], n_src, &src[i], n_samples);
for(; i + 1 < n_src; i += 2) for(; i + 1 < n_src; i += 2)
conv_f32d_to_s32_2_sse(data, &d[i], n_src, &src[i], n_bytes); conv_f32d_to_s32_2_sse(data, &d[i], n_src, &src[i], n_samples);
for(; i < n_src; i++) for(; i < n_src; i++)
conv_f32d_to_s32_1_sse(data, &d[i], n_src, &src[i], n_bytes); conv_f32d_to_s32_1_sse(data, &d[i], n_src, &src[i], n_samples);
} }
static void static void
conv_f32d_to_s16_1_sse(void *data, void *dst, int n_src, const void *src[n_src], int n_bytes) conv_f32d_to_s16_1_sse(void *data, void *dst, int n_src, const void *src[n_src], int n_samples)
{ {
const float **s = (const float **) src; const float **s = (const float **) src;
const float *s0 = s[0]; const float *s0 = s[0];
int16_t *d = dst; int16_t *d = dst;
int n, n_samples, unrolled; int n, unrolled;
__m128 in[1]; __m128 in[1];
__m128i out[4]; __m128i out[4];
__m128 int_max = _mm_set1_ps(S16_MAX_F); __m128 int_max = _mm_set1_ps(S16_MAX_F);
__m128 int_min = _mm_sub_ps(_mm_setzero_ps(), int_max); __m128 int_min = _mm_sub_ps(_mm_setzero_ps(), int_max);
n_samples = n_bytes / sizeof(float);
unrolled = n_samples / 4; unrolled = n_samples / 4;
n_samples = n_samples & 3; n_samples = n_samples & 3;
@ -364,18 +350,17 @@ conv_f32d_to_s16_1_sse(void *data, void *dst, int n_src, const void *src[n_src],
} }
static void static void
conv_f32d_to_s16_2_sse(void *data, void *dst, int n_src, const void *src[n_src], int n_bytes) conv_f32d_to_s16_2_sse(void *data, void *dst, int n_src, const void *src[n_src], int n_samples)
{ {
const float **s = (const float **) src; const float **s = (const float **) src;
const float *s0 = s[0], *s1 = s[1]; const float *s0 = s[0], *s1 = s[1];
int16_t *d = dst; int16_t *d = dst;
int n = 0, n_samples, unrolled; int n = 0, unrolled;
__m128 in[2]; __m128 in[2];
__m128i out[4], t[2]; __m128i out[4], t[2];
__m128 int_max = _mm_set1_ps(S16_MAX_F); __m128 int_max = _mm_set1_ps(S16_MAX_F);
__m128 int_min = _mm_sub_ps(_mm_setzero_ps(), int_max); __m128 int_min = _mm_sub_ps(_mm_setzero_ps(), int_max);
n_samples = n_bytes / sizeof(float);
unrolled = n_samples / 4; unrolled = n_samples / 4;
n_samples = n_samples & 3; n_samples = n_samples & 3;
@ -412,13 +397,13 @@ conv_f32d_to_s16_2_sse(void *data, void *dst, int n_src, const void *src[n_src],
} }
static void static void
conv_f32d_to_s16_sse(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_f32d_to_s16_sse(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
int16_t *d = dst[0]; int16_t *d = dst[0];
int i = 0; int i = 0;
for(; i + 1 < n_src; i += 2) for(; i + 1 < n_src; i += 2)
conv_f32d_to_s16_2_sse(data, &d[i], n_src, &src[i], n_bytes); conv_f32d_to_s16_2_sse(data, &d[i], n_src, &src[i], n_samples);
for(; i < n_src; i++) for(; i < n_src; i++)
conv_f32d_to_s16_1_sse(data, &d[i], n_src, &src[i], n_bytes); conv_f32d_to_s16_1_sse(data, &d[i], n_src, &src[i], n_samples);
} }

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

@ -68,17 +68,41 @@ static inline int32_t read_s24(const void *src)
#endif #endif
static void static void
conv_copy(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_copy8(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
int i; int i;
for (i = 0; i < n_src; i++) for (i = 0; i < n_src; i++)
memcpy(dst[i], src[i], n_bytes); memcpy(dst[i], src[i], n_samples);
}
static void
conv_copy16(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{
int i;
for (i = 0; i < n_src; i++)
memcpy(dst[i], src[i], n_samples * sizeof(int16_t));
}
static void
conv_copy24(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{
int i;
for (i = 0; i < n_src; i++)
memcpy(dst[i], src[i], n_samples * 3);
}
static void
conv_copy32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{
int i;
for (i = 0; i < n_src; i++)
memcpy(dst[i], src[i], n_samples * sizeof(int32_t));
} }
#define U8_TO_F32(v) (((v) * (1.0f / U8_OFFS)) - 1.0) #define U8_TO_F32(v) (((v) * (1.0f / U8_OFFS)) - 1.0)
static void static void
conv_u8_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_u8_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
int i, j; int i, j;
@ -86,34 +110,32 @@ conv_u8_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *s
const uint8_t *s = src[i]; const uint8_t *s = src[i];
float *d = dst[i]; float *d = dst[i];
for (j = 0; j < n_bytes; j++) for (j = 0; j < n_samples; j++)
d[j] = U8_TO_F32(s[j]); d[j] = U8_TO_F32(s[j]);
} }
} }
static void static void
conv_u8_to_f32d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_u8_to_f32d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const uint8_t *s = src[0]; const uint8_t *s = src[0];
float **d = (float **) dst; float **d = (float **) dst;
int i, j; int i, j;
n_bytes /= n_dst; for (j = 0; j < n_samples; j++) {
for (j = 0; j < n_bytes; j++) {
for (i = 0; i < n_dst; i++) for (i = 0; i < n_dst; i++)
d[i][j] = U8_TO_F32(*s++); d[i][j] = U8_TO_F32(*s++);
} }
} }
static void static void
conv_u8d_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_u8d_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const uint8_t **s = (const uint8_t **) src; const uint8_t **s = (const uint8_t **) src;
float *d = dst[0]; float *d = dst[0];
int i, j; int i, j;
n_bytes /= n_src; for (j = 0; j < n_samples; j++) {
for (j = 0; j < n_bytes; j++) {
for (i = 0; i < n_src; i++) for (i = 0; i < n_src; i++)
*d++ = U8_TO_F32(s[i][j]); *d++ = U8_TO_F32(s[i][j]);
} }
@ -122,90 +144,83 @@ conv_u8d_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *
#define S16_TO_F32(v) ((v) * (1.0f / S16_SCALE)) #define S16_TO_F32(v) ((v) * (1.0f / S16_SCALE))
static void static void
conv_s16_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_s16_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
int i, j; int i, j;
n_bytes /= sizeof(int16_t);
for (i = 0; i < n_src; i++) { for (i = 0; i < n_src; i++) {
const int16_t *s = src[i]; const int16_t *s = src[i];
float *d = dst[i]; float *d = dst[i];
for (j = 0; j < n_samples; j++)
for (j = 0; j < n_bytes; j++)
d[j] = S16_TO_F32(s[j]); d[j] = S16_TO_F32(s[j]);
} }
} }
static void static void
conv_s16_to_f32d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_s16_to_f32d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const int16_t *s = src[0]; const int16_t *s = src[0];
float **d = (float **) dst; float **d = (float **) dst;
int i, j; int i, j;
n_bytes /= (sizeof(int16_t) * n_dst); for (j = 0; j < n_samples; j++) {
for (j = 0; j < n_bytes; j++) {
for (i = 0; i < n_dst; i++) for (i = 0; i < n_dst; i++)
d[i][j] = S16_TO_F32(*s++); d[i][j] = S16_TO_F32(*s++);
} }
} }
static void static void
conv_s16d_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_s16d_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const int16_t **s = (const int16_t **) src; const int16_t **s = (const int16_t **) src;
float *d = dst[0]; float *d = dst[0];
int i, n, n_samples; int i, j;
n_samples = n_bytes / sizeof(int16_t); for (j = 0; j < n_samples; j++) {
for (n = 0; n < n_samples; n++) {
for (i = 0; i < n_src; i++) for (i = 0; i < n_src; i++)
*d++ = S16_TO_F32(s[i][n]); *d++ = S16_TO_F32(s[i][j]);
} }
} }
#define S32_TO_F32(v) ((v) * (1.0f / S32_SCALE)) #define S32_TO_F32(v) ((v) * (1.0f / S32_SCALE))
static void static void
conv_s32_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_s32_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
int i, j; int i, j;
n_bytes /= sizeof(int32_t);
for (i = 0; i < n_src; i++) { for (i = 0; i < n_src; i++) {
const int32_t *s = src[i]; const int32_t *s = src[i];
float *d = dst[i]; float *d = dst[i];
for (j = 0; j < n_bytes; j++) for (j = 0; j < n_samples; j++)
d[j] = S32_TO_F32(s[j]); d[j] = S32_TO_F32(s[j]);
} }
} }
static void static void
conv_s32_to_f32d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_s32_to_f32d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const int32_t *s = src[0]; const int32_t *s = src[0];
float **d = (float **) dst; float **d = (float **) dst;
int i, j; int i, j;
n_bytes /= (sizeof(int32_t) * n_dst); for (j = 0; j < n_samples; j++) {
for (j = 0; j < n_bytes; j++) {
for (i = 0; i < n_dst; i++) for (i = 0; i < n_dst; i++)
d[i][j] = S32_TO_F32(*s++); d[i][j] = S32_TO_F32(*s++);
} }
} }
static void static void
conv_s32d_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_s32d_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const int32_t **s = (const int32_t **) src; const int32_t **s = (const int32_t **) src;
float *d = dst[0]; float *d = dst[0];
int i, n, n_samples; int i, j;
n_samples = n_bytes / sizeof(int32_t); for (j = 0; j < n_samples; j++) {
for (n = 0; n < n_samples; n++) {
for (i = 0; i < n_src; i++) for (i = 0; i < n_src; i++)
*d++ = S32_TO_F32(s[i][n]); *d++ = S32_TO_F32(s[i][j]);
} }
} }
@ -213,16 +228,15 @@ conv_s32d_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void
#define S24_TO_F32(v) (((int32_t)(v)) * (1.0f / S24_SCALE)) #define S24_TO_F32(v) (((int32_t)(v)) * (1.0f / S24_SCALE))
static void static void
conv_s24_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_s24_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
int i, j; int i, j;
n_bytes /= 3;
for (i = 0; i < n_src; i++) { for (i = 0; i < n_src; i++) {
const int8_t *s = src[i]; const int8_t *s = src[i];
float *d = dst[i]; float *d = dst[i];
for (j = 0; j < n_bytes; j++) { for (j = 0; j < n_samples; j++) {
d[j] = S24_TO_F32(READ24(s)); d[j] = S24_TO_F32(READ24(s));
s += 3; s += 3;
} }
@ -230,14 +244,13 @@ conv_s24_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *
} }
static void static void
conv_s24_to_f32d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_s24_to_f32d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const uint8_t *s = src[0]; const uint8_t *s = src[0];
float **d = (float **) dst; float **d = (float **) dst;
int i, j; int i, j;
n_bytes /= (3 * n_dst); for (j = 0; j < n_samples; j++) {
for (j = 0; j < n_bytes; j++) {
for (i = 0; i < n_dst; i++) { for (i = 0; i < n_dst; i++) {
d[i][j] = S24_TO_F32(READ24(s)); d[i][j] = S24_TO_F32(READ24(s));
s += 3; s += 3;
@ -246,14 +259,13 @@ conv_s24_to_f32d(void *data, int n_dst, void *dst[n_dst], int n_src, const void
} }
static void static void
conv_s24d_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_s24d_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const uint8_t **s = (const uint8_t **) src; const uint8_t **s = (const uint8_t **) src;
float *d = dst[0]; float *d = dst[0];
int i, n, n_samples; int i, j;
n_samples = n_bytes / 3; for (j = 0; j < n_samples; j++) {
for (n = 0; n < n_samples; n++) {
for (i = 0; i < n_src; i++) { for (i = 0; i < n_src; i++) {
*d++ = S24_TO_F32(READ24(s[i])); *d++ = S24_TO_F32(READ24(s[i]));
s += 3; s += 3;
@ -262,45 +274,42 @@ conv_s24d_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void
} }
static void static void
conv_s24_32_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_s24_32_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
int i, j; int i, j;
n_bytes /= sizeof(int32_t);
for (i = 0; i < n_src; i++) { for (i = 0; i < n_src; i++) {
const int32_t *s = src[i]; const int32_t *s = src[i];
float *d = dst[i]; float *d = dst[i];
for (j = 0; j < n_bytes; j++) for (j = 0; j < n_samples; j++)
d[j] = S24_TO_F32(s[j]); d[j] = S24_TO_F32(s[j]);
} }
} }
static void static void
conv_s24_32_to_f32d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_s24_32_to_f32d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const int32_t *s = src[0]; const int32_t *s = src[0];
float **d = (float **) dst; float **d = (float **) dst;
int i, j; int i, j;
n_bytes /= (sizeof(int32_t) * n_dst); for (j = 0; j < n_samples; j++) {
for (j = 0; j < n_bytes; j++) {
for (i = 0; i < n_dst; i++) for (i = 0; i < n_dst; i++)
d[i][j] = S24_TO_F32(*s++); d[i][j] = S24_TO_F32(*s++);
} }
} }
static void static void
conv_s24_32d_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_s24_32d_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const int32_t **s = (const int32_t **) src; const int32_t **s = (const int32_t **) src;
float *d = dst[0]; float *d = dst[0];
int i, n, n_samples; int i, j;
n_samples = n_bytes / sizeof(int32_t); for (j = 0; j < n_samples; j++) {
for (n = 0; n < n_samples; n++) {
for (i = 0; i < n_src; i++) for (i = 0; i < n_src; i++)
*d++ = S24_TO_F32(s[i][n]); *d++ = S24_TO_F32(s[i][j]);
} }
} }
@ -313,45 +322,42 @@ conv_s24_32d_to_f32(void *data, int n_dst, void *dst[n_dst], int n_src, const vo
}) })
static void static void
conv_f32_to_u8(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_f32_to_u8(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
int i, j; int i, j;
n_bytes /= sizeof(float);
for (i = 0; i < n_src; i++) { for (i = 0; i < n_src; i++) {
const float *s = src[i]; const float *s = src[i];
int8_t *d = dst[i]; int8_t *d = dst[i];
for (j = 0; j < n_bytes; j++) for (j = 0; j < n_samples; j++)
d[j] = F32_TO_U8(s[j]); d[j] = F32_TO_U8(s[j]);
} }
} }
static void static void
conv_f32_to_u8d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_f32_to_u8d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const float *s = src[0]; const float *s = src[0];
int8_t **d = (int8_t **) dst; int8_t **d = (int8_t **) dst;
int i, j; int i, j;
n_bytes /= (sizeof(float) * n_dst); for (j = 0; j < n_samples; j++) {
for (j = 0; j < n_bytes; j++) {
for (i = 0; i < n_dst; i++) for (i = 0; i < n_dst; i++)
d[i][j] = F32_TO_U8(*s++); d[i][j] = F32_TO_U8(*s++);
} }
} }
static void static void
conv_f32d_to_u8(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_f32d_to_u8(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const float **s = (const float **) src; const float **s = (const float **) src;
int8_t *d = dst[0]; int8_t *d = dst[0];
int i, n, n_samples; int i, j;
n_samples = n_bytes / sizeof(float); for (j = 0; j < n_samples; j++) {
for (n = 0; n < n_samples; n++) {
for (i = 0; i < n_src; i++) for (i = 0; i < n_src; i++)
*d++ = F32_TO_U8(s[i][n]); *d++ = F32_TO_U8(s[i][j]);
} }
} }
@ -364,45 +370,42 @@ conv_f32d_to_u8(void *data, int n_dst, void *dst[n_dst], int n_src, const void *
}) })
static void static void
conv_f32_to_s16(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_f32_to_s16(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
int i, n, n_samples; int i, j;
n_samples = n_bytes / sizeof(float);
for (i = 0; i < n_src; i++) { for (i = 0; i < n_src; i++) {
const float *s = src[i]; const float *s = src[i];
int16_t *d = dst[i]; int16_t *d = dst[i];
for (n = 0; n < n_samples; n++) for (j = 0; j < n_samples; j++)
d[n] = F32_TO_S16(s[n]); d[j] = F32_TO_S16(s[j]);
} }
} }
static void static void
conv_f32_to_s16d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_f32_to_s16d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const float *s = src[0]; const float *s = src[0];
int16_t **d = (int16_t **) dst; int16_t **d = (int16_t **) dst;
int i, n, n_samples; int i, j;
n_samples = n_bytes / (sizeof(float) * n_dst); for (j = 0; j < n_samples; j++) {
for (n = 0; n < n_samples; n++) {
for (i = 0; i < n_dst; i++) for (i = 0; i < n_dst; i++)
d[i][n] = F32_TO_S16(*s++); d[i][j] = F32_TO_S16(*s++);
} }
} }
static void static void
conv_f32d_to_s16(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_f32d_to_s16(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const float **s = (const float **) src; const float **s = (const float **) src;
int16_t *d = dst[0]; int16_t *d = dst[0];
int i, n, n_samples; int i, j;
n_samples = n_bytes / sizeof(float); for (j = 0; j < n_samples; j++) {
for (n = 0; n < n_samples; n++) {
for (i = 0; i < n_src; i++) for (i = 0; i < n_src; i++)
*d++ = F32_TO_S16(s[i][n]); *d++ = F32_TO_S16(s[i][j]);
} }
} }
@ -415,45 +418,42 @@ conv_f32d_to_s16(void *data, int n_dst, void *dst[n_dst], int n_src, const void
}) })
static void static void
conv_f32_to_s32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_f32_to_s32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
int i, j; int i, j;
n_bytes /= sizeof(float);
for (i = 0; i < n_src; i++) { for (i = 0; i < n_src; i++) {
const float *s = src[i]; const float *s = src[i];
int32_t *d = dst[i]; int32_t *d = dst[i];
for (j = 0; j < n_bytes; j++) for (j = 0; j < n_samples; j++)
d[j] = F32_TO_S32(s[j]); d[j] = F32_TO_S32(s[j]);
} }
} }
static void static void
conv_f32_to_s32d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_f32_to_s32d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const float *s = src[0]; const float *s = src[0];
int32_t **d = (int32_t **) dst; int32_t **d = (int32_t **) dst;
int i, j; int i, j;
n_bytes /= (sizeof(float) * n_dst); for (j = 0; j < n_samples; j++) {
for (j = 0; j < n_bytes; j++) {
for (i = 0; i < n_dst; i++) for (i = 0; i < n_dst; i++)
d[i][j] = F32_TO_S32(*s++); d[i][j] = F32_TO_S32(*s++);
} }
} }
static void static void
conv_f32d_to_s32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_f32d_to_s32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const float **s = (const float **) src; const float **s = (const float **) src;
int32_t *d = dst[0]; int32_t *d = dst[0];
int i, n, n_samples; int i, j;
n_samples = n_bytes / sizeof(float); for (j = 0; j < n_samples; j++) {
for (n = 0; n < n_samples; n++) {
for (i = 0; i < n_src; i++) for (i = 0; i < n_src; i++)
*d++ = F32_TO_S32(s[i][n]); *d++ = F32_TO_S32(s[i][j]);
} }
} }
@ -475,30 +475,28 @@ conv_f32d_to_s32(void *data, int n_dst, void *dst[n_dst], int n_src, const void
}) })
static void static void
conv_f32_to_s24(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_f32_to_s24(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
int i, j; int i, j;
n_bytes /= sizeof(float);
for (i = 0; i < n_src; i++) { for (i = 0; i < n_src; i++) {
const float *s = src[i]; const float *s = src[i];
int8_t *d = dst[i]; int8_t *d = dst[i];
for (j = 0; j < n_bytes; j++) for (j = 0; j < n_samples; j++)
WRITE24(d, F32_TO_S24(s[j])); WRITE24(d, F32_TO_S24(s[j]));
d += 3; d += 3;
} }
} }
static void static void
conv_f32_to_s24d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_f32_to_s24d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const float *s = src[0]; const float *s = src[0];
int8_t **d = (int8_t **) dst; int8_t **d = (int8_t **) dst;
int i, j; int i, j;
n_bytes /= (sizeof(float) * n_dst); for (j = 0; j < n_samples; j++) {
for (j = 0; j < n_bytes; j++) {
for (i = 0; i < n_dst; i++) { for (i = 0; i < n_dst; i++) {
WRITE24(d[i], F32_TO_S24(*s++)); WRITE24(d[i], F32_TO_S24(*s++));
d[i] += 3; d[i] += 3;
@ -507,16 +505,15 @@ conv_f32_to_s24d(void *data, int n_dst, void *dst[n_dst], int n_src, const void
} }
static void static void
conv_f32d_to_s24(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_f32d_to_s24(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const float **s = (const float **) src; const float **s = (const float **) src;
int8_t *d = dst[0]; int8_t *d = dst[0];
int i, n, n_samples; int i, j;
n_samples = n_bytes / sizeof(float); for (j = 0; j < n_samples; j++) {
for (n = 0; n < n_samples; n++) {
for (i = 0; i < n_src; i++) { for (i = 0; i < n_src; i++) {
WRITE24(d, F32_TO_S24(s[i][n])); WRITE24(d, F32_TO_S24(s[i][j]));
d += 3; d += 3;
} }
} }
@ -524,85 +521,79 @@ conv_f32d_to_s24(void *data, int n_dst, void *dst[n_dst], int n_src, const void
static void static void
conv_f32_to_s24_32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_f32_to_s24_32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
int i, j; int i, j;
n_bytes /= sizeof(float);
for (i = 0; i < n_src; i++) { for (i = 0; i < n_src; i++) {
const float *s = src[i]; const float *s = src[i];
int32_t *d = dst[i]; int32_t *d = dst[i];
for (j = 0; j < n_bytes; j++) for (j = 0; j < n_samples; j++)
d[j] = F32_TO_S24(s[j]); d[j] = F32_TO_S24(s[j]);
} }
} }
static void static void
conv_f32_to_s24_32d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_f32_to_s24_32d(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const float *s = src[0]; const float *s = src[0];
int32_t **d = (int32_t **) dst; int32_t **d = (int32_t **) dst;
int i, j; int i, j;
n_bytes /= (sizeof(float) * n_dst); for (j = 0; j < n_samples; j++) {
for (j = 0; j < n_bytes; j++) {
for (i = 0; i < n_dst; i++) for (i = 0; i < n_dst; i++)
d[i][j] = F32_TO_S24(*s++); d[i][j] = F32_TO_S24(*s++);
} }
} }
static void static void
conv_f32d_to_s24_32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) conv_f32d_to_s24_32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const float **s = (const float **) src; const float **s = (const float **) src;
int32_t *d = dst[0]; int32_t *d = dst[0];
int i, n, n_samples; int i, j;
n_samples = n_bytes / sizeof(float); for (j = 0; j < n_samples; j++) {
for (n = 0; n < n_samples; n++) {
for (i = 0; i < n_src; i++) for (i = 0; i < n_src; i++)
*d++ = F32_TO_S24(s[i][n]); *d++ = F32_TO_S24(s[i][j]);
} }
} }
static void static void
deinterleave_8(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) deinterleave_8(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const uint8_t *s = src[0]; const uint8_t *s = src[0];
uint8_t **d = (uint8_t **) dst; uint8_t **d = (uint8_t **) dst;
int i, j; int i, j;
n_bytes /= (sizeof(uint8_t) * n_dst); for (j = 0; j < n_samples; j++) {
for (j = 0; j < n_bytes; j++) {
for (i = 0; i < n_dst; i++) for (i = 0; i < n_dst; i++)
d[i][j] = *s++; d[i][j] = *s++;
} }
} }
static void static void
deinterleave_16(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) deinterleave_16(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const uint16_t *s = src[0]; const uint16_t *s = src[0];
uint16_t **d = (uint16_t **) dst; uint16_t **d = (uint16_t **) dst;
int i, j; int i, j;
n_bytes /= (sizeof(uint16_t) * n_dst); for (j = 0; j < n_samples; j++) {
for (j = 0; j < n_bytes; j++) {
for (i = 0; i < n_dst; i++) for (i = 0; i < n_dst; i++)
d[i][j] = *s++; d[i][j] = *s++;
} }
} }
static void static void
deinterleave_24(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) deinterleave_24(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const uint8_t *s = src[0]; const uint8_t *s = src[0];
uint8_t **d = (uint8_t **) dst; uint8_t **d = (uint8_t **) dst;
int i, j; int i, j;
n_bytes /= (3 * n_dst); for (j = 0; j < n_samples; j++) {
for (j = 0; j < n_bytes; j++) {
for (i = 0; i < n_dst; i++) { for (i = 0; i < n_dst; i++) {
WRITE24(d[i], READ24(s)); WRITE24(d[i], READ24(s));
d += 3; d += 3;
@ -612,56 +603,52 @@ deinterleave_24(void *data, int n_dst, void *dst[n_dst], int n_src, const void *
} }
static void static void
deinterleave_32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) deinterleave_32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const uint32_t *s = src[0]; const uint32_t *s = src[0];
uint32_t **d = (uint32_t **) dst; uint32_t **d = (uint32_t **) dst;
int i, j; int i, j;
n_bytes /= (sizeof(uint32_t) * n_dst); for (j = 0; j < n_samples; j++) {
for (j = 0; j < n_bytes; j++) {
for (i = 0; i < n_dst; i++) for (i = 0; i < n_dst; i++)
d[i][j] = *s++; d[i][j] = *s++;
} }
} }
static void static void
interleave_8(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) interleave_8(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const int8_t **s = (const int8_t **) src; const int8_t **s = (const int8_t **) src;
uint8_t *d = dst[0]; uint8_t *d = dst[0];
int i, j; int i, j;
n_bytes /= sizeof(uint8_t); for (j = 0; j < n_samples; j++) {
for (j = 0; j < n_bytes; j++) {
for (i = 0; i < n_src; i++) for (i = 0; i < n_src; i++)
*d++ = s[i][j]; *d++ = s[i][j];
} }
} }
static void static void
interleave_16(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) interleave_16(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const int16_t **s = (const int16_t **) src; const int16_t **s = (const int16_t **) src;
uint16_t *d = dst[0]; uint16_t *d = dst[0];
int i, j; int i, j;
n_bytes /= sizeof(uint16_t); for (j = 0; j < n_samples; j++) {
for (j = 0; j < n_bytes; j++) {
for (i = 0; i < n_src; i++) for (i = 0; i < n_src; i++)
*d++ = s[i][j]; *d++ = s[i][j];
} }
} }
static void static void
interleave_24(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) interleave_24(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const int8_t **s = (const int8_t **) src; const int8_t **s = (const int8_t **) src;
uint8_t *d = dst[0]; uint8_t *d = dst[0];
int i, j; int i, j;
n_bytes /= 3; for (j = 0; j < n_samples; j++) {
for (j = 0; j < n_bytes; j++) {
for (i = 0; i < n_src; i++) { for (i = 0; i < n_src; i++) {
WRITE24(d, READ24(s[i])); WRITE24(d, READ24(s[i]));
d += 3; d += 3;
@ -671,21 +658,20 @@ interleave_24(void *data, int n_dst, void *dst[n_dst], int n_src, const void *sr
} }
static void static void
interleave_32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_bytes) interleave_32(void *data, int n_dst, void *dst[n_dst], int n_src, const void *src[n_src], int n_samples)
{ {
const int32_t **s = (const int32_t **) src; const int32_t **s = (const int32_t **) src;
uint32_t *d = dst[0]; uint32_t *d = dst[0];
int i, j; int i, j;
n_bytes /= sizeof(uint32_t); for (j = 0; j < n_samples; j++) {
for (j = 0; j < n_bytes; j++) {
for (i = 0; i < n_src; i++) for (i = 0; i < n_src; i++)
*d++ = s[i][j]; *d++ = s[i][j];
} }
} }
typedef void (*convert_func_t) (void *data, int n_dst, void *dst[n_dst], typedef void (*convert_func_t) (void *data, int n_dst, void *dst[n_dst],
int n_src, const void *src[n_src], int n_bytes); int n_src, const void *src[n_src], int n_samples);
static const struct conv_info { static const struct conv_info {
uint32_t src_fmt; uint32_t src_fmt;
@ -711,8 +697,8 @@ static const struct conv_info {
{ SPA_AUDIO_FORMAT_S16, SPA_AUDIO_FORMAT_F32P, 0, conv_s16_to_f32d }, { SPA_AUDIO_FORMAT_S16, SPA_AUDIO_FORMAT_F32P, 0, conv_s16_to_f32d },
{ SPA_AUDIO_FORMAT_S16P, SPA_AUDIO_FORMAT_F32, 0, conv_s16d_to_f32 }, { SPA_AUDIO_FORMAT_S16P, SPA_AUDIO_FORMAT_F32, 0, conv_s16d_to_f32 },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_F32, 0, conv_copy }, { SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_F32, 0, conv_copy32 },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_F32P, 0, conv_copy }, { SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_F32P, 0, conv_copy32 },
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_F32P, 0, deinterleave_32 }, { SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_F32P, 0, deinterleave_32 },
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_F32, 0, interleave_32 }, { SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_F32, 0, interleave_32 },
@ -767,32 +753,32 @@ static const struct conv_info {
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S24_32, 0, conv_f32d_to_s24_32 }, { SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_S24_32, 0, conv_f32d_to_s24_32 },
/* u8 */ /* u8 */
{ SPA_AUDIO_FORMAT_U8, SPA_AUDIO_FORMAT_U8, 0, conv_copy }, { SPA_AUDIO_FORMAT_U8, SPA_AUDIO_FORMAT_U8, 0, conv_copy8 },
{ SPA_AUDIO_FORMAT_U8P, SPA_AUDIO_FORMAT_U8P, 0, conv_copy }, { SPA_AUDIO_FORMAT_U8P, SPA_AUDIO_FORMAT_U8P, 0, conv_copy8 },
{ SPA_AUDIO_FORMAT_U8, SPA_AUDIO_FORMAT_U8P, 0, deinterleave_8 }, { SPA_AUDIO_FORMAT_U8, SPA_AUDIO_FORMAT_U8P, 0, deinterleave_8 },
{ SPA_AUDIO_FORMAT_U8P, SPA_AUDIO_FORMAT_U8, 0, interleave_8 }, { SPA_AUDIO_FORMAT_U8P, SPA_AUDIO_FORMAT_U8, 0, interleave_8 },
/* s16 */ /* s16 */
{ SPA_AUDIO_FORMAT_S16, SPA_AUDIO_FORMAT_S16, 0, conv_copy }, { SPA_AUDIO_FORMAT_S16, SPA_AUDIO_FORMAT_S16, 0, conv_copy16 },
{ SPA_AUDIO_FORMAT_S16P, SPA_AUDIO_FORMAT_S16P, 0, conv_copy }, { SPA_AUDIO_FORMAT_S16P, SPA_AUDIO_FORMAT_S16P, 0, conv_copy16 },
{ SPA_AUDIO_FORMAT_S16, SPA_AUDIO_FORMAT_S16P, 0, deinterleave_16 }, { SPA_AUDIO_FORMAT_S16, SPA_AUDIO_FORMAT_S16P, 0, deinterleave_16 },
{ SPA_AUDIO_FORMAT_S16P, SPA_AUDIO_FORMAT_S16, 0, interleave_16 }, { SPA_AUDIO_FORMAT_S16P, SPA_AUDIO_FORMAT_S16, 0, interleave_16 },
/* s32 */ /* s32 */
{ SPA_AUDIO_FORMAT_S32, SPA_AUDIO_FORMAT_S32, 0, conv_copy }, { SPA_AUDIO_FORMAT_S32, SPA_AUDIO_FORMAT_S32, 0, conv_copy32 },
{ SPA_AUDIO_FORMAT_S32P, SPA_AUDIO_FORMAT_S32P, 0, conv_copy }, { SPA_AUDIO_FORMAT_S32P, SPA_AUDIO_FORMAT_S32P, 0, conv_copy32 },
{ SPA_AUDIO_FORMAT_S32, SPA_AUDIO_FORMAT_S32P, 0, deinterleave_32 }, { SPA_AUDIO_FORMAT_S32, SPA_AUDIO_FORMAT_S32P, 0, deinterleave_32 },
{ SPA_AUDIO_FORMAT_S32P, SPA_AUDIO_FORMAT_S32, 0, interleave_32 }, { SPA_AUDIO_FORMAT_S32P, SPA_AUDIO_FORMAT_S32, 0, interleave_32 },
/* s24 */ /* s24 */
{ SPA_AUDIO_FORMAT_S24, SPA_AUDIO_FORMAT_S24, 0, conv_copy }, { SPA_AUDIO_FORMAT_S24, SPA_AUDIO_FORMAT_S24, 0, conv_copy24 },
{ SPA_AUDIO_FORMAT_S24P, SPA_AUDIO_FORMAT_S24P, 0, conv_copy }, { SPA_AUDIO_FORMAT_S24P, SPA_AUDIO_FORMAT_S24P, 0, conv_copy24 },
{ SPA_AUDIO_FORMAT_S24, SPA_AUDIO_FORMAT_S24P, 0, deinterleave_24 }, { SPA_AUDIO_FORMAT_S24, SPA_AUDIO_FORMAT_S24P, 0, deinterleave_24 },
{ SPA_AUDIO_FORMAT_S24P, SPA_AUDIO_FORMAT_S24, 0, interleave_24 }, { SPA_AUDIO_FORMAT_S24P, SPA_AUDIO_FORMAT_S24, 0, interleave_24 },
/* s24_32 */ /* s24_32 */
{ SPA_AUDIO_FORMAT_S24_32, SPA_AUDIO_FORMAT_S24_32, 0, conv_copy }, { SPA_AUDIO_FORMAT_S24_32, SPA_AUDIO_FORMAT_S24_32, 0, conv_copy32 },
{ SPA_AUDIO_FORMAT_S24_32P, SPA_AUDIO_FORMAT_S24_32P, 0, conv_copy }, { SPA_AUDIO_FORMAT_S24_32P, SPA_AUDIO_FORMAT_S24_32P, 0, conv_copy32 },
{ SPA_AUDIO_FORMAT_S24_32, SPA_AUDIO_FORMAT_S24_32P, 0, deinterleave_32 }, { SPA_AUDIO_FORMAT_S24_32, SPA_AUDIO_FORMAT_S24_32P, 0, deinterleave_32 },
{ SPA_AUDIO_FORMAT_S24_32P, SPA_AUDIO_FORMAT_S24_32, 0, interleave_32 }, { SPA_AUDIO_FORMAT_S24_32P, SPA_AUDIO_FORMAT_S24_32, 0, interleave_32 },
}; };

46
spa/plugins/audioconvert/fmtconvert.c
View file

@ -25,6 +25,7 @@
#include <errno.h> #include <errno.h>
#include <string.h> #include <string.h>
#include <stdio.h> #include <stdio.h>
#include <limits.h>
#include <spa/support/log.h> #include <spa/support/log.h>
#include <spa/utils/list.h> #include <spa/utils/list.h>
@ -84,8 +85,6 @@ struct port {
uint32_t blocks; uint32_t blocks;
uint32_t size; uint32_t size;
uint32_t offset;
struct buffer buffers[MAX_BUFFERS]; struct buffer buffers[MAX_BUFFERS];
uint32_t n_buffers; uint32_t n_buffers;
@ -759,17 +758,16 @@ static void recycle_buffer(struct impl *this, struct port *port, uint32_t id)
} }
} }
static inline struct buffer *peek_buffer(struct impl *this, struct port *port) static inline struct buffer *dequeue_buffer(struct impl *this, struct port *port)
{ {
struct buffer *b;
if (spa_list_is_empty(&port->queue)) if (spa_list_is_empty(&port->queue))
return NULL; return NULL;
return spa_list_first(&port->queue, struct buffer, link); b = spa_list_first(&port->queue, struct buffer, link);
}
static inline void dequeue_buffer(struct impl *this, struct buffer *b)
{
spa_list_remove(&b->link); spa_list_remove(&b->link);
SPA_FLAG_SET(b->flags, BUFFER_FLAG_OUT); SPA_FLAG_SET(b->flags, BUFFER_FLAG_OUT);
return b;
} }
static int impl_node_port_reuse_buffer(struct spa_node *node, uint32_t port_id, uint32_t buffer_id) static int impl_node_port_reuse_buffer(struct spa_node *node, uint32_t port_id, uint32_t buffer_id)
@ -809,8 +807,8 @@ static int impl_node_process(struct spa_node *node)
const void **src_datas; const void **src_datas;
void **dst_datas; void **dst_datas;
uint32_t n_src_datas, n_dst_datas; uint32_t n_src_datas, n_dst_datas;
int i, res = 0, n_bytes = 0, maxsize; int i, res = 0, n_samples = 0, maxsize;
uint32_t size = 0; int size = 0;
spa_return_val_if_fail(node != NULL, -EINVAL); spa_return_val_if_fail(node != NULL, -EINVAL);
@ -840,7 +838,7 @@ static int impl_node_process(struct spa_node *node)
if (inio->buffer_id >= inport->n_buffers) if (inio->buffer_id >= inport->n_buffers)
return inio->status = -EINVAL; return inio->status = -EINVAL;
if ((outbuf = peek_buffer(this, outport)) == NULL) if ((outbuf = dequeue_buffer(this, outport)) == NULL)
return outio->status = -EPIPE; return outio->status = -EPIPE;
inbuf = &inport->buffers[inio->buffer_id]; inbuf = &inport->buffers[inio->buffer_id];
@ -849,9 +847,12 @@ static int impl_node_process(struct spa_node *node)
n_src_datas = inb->n_datas; n_src_datas = inb->n_datas;
src_datas = alloca(sizeof(void*) * n_src_datas); src_datas = alloca(sizeof(void*) * n_src_datas);
size = inb->datas[0].chunk->size; size = INT_MAX;
for (i = 0; i < n_src_datas; i++) for (i = 0; i < n_src_datas; i++) {
src_datas[i] = SPA_MEMBER(inb->datas[i].data, inport->offset, void); size = SPA_MIN(size, inb->datas[0].chunk->size);
src_datas[i] = SPA_MEMBER(inb->datas[i].data, inb->datas[i].chunk->offset, void);
}
n_samples = size / inport->stride;
outb = outbuf->outbuf; outb = outbuf->outbuf;
@ -861,29 +862,22 @@ static int impl_node_process(struct spa_node *node)
maxsize = outb->datas[0].maxsize; maxsize = outb->datas[0].maxsize;
if (outport->ctrl) if (outport->ctrl)
maxsize = SPA_MIN(outport->ctrl->max_size, maxsize); maxsize = SPA_MIN(outport->ctrl->max_size, maxsize);
n_samples = SPA_MIN(n_samples, maxsize / outport->stride);
maxsize = (maxsize / outport->stride) * inport->stride;
n_bytes = SPA_MIN(size - inport->offset, maxsize);
for (i = 0; i < n_dst_datas; i++) { for (i = 0; i < n_dst_datas; i++) {
dst_datas[i] = outb->datas[this->remap[i]].data; dst_datas[i] = outb->datas[this->remap[i]].data;
outb->datas[i].chunk->offset = 0; outb->datas[i].chunk->offset = 0;
outb->datas[i].chunk->size = (n_bytes / inport->stride) * outport->stride; outb->datas[i].chunk->size = n_samples * outport->stride;
} }
spa_log_trace(this->log, NAME " %p: n_src:%d n_dst:%d in_offset:%d size:%d maxsize:%d n_bytes:%d", this, spa_log_trace(this->log, NAME " %p: n_src:%d n_dst:%d size:%d maxsize:%d n_samples:%d",
n_src_datas, n_dst_datas, inport->offset, size, maxsize, n_bytes); this, n_src_datas, n_dst_datas, size, maxsize, n_samples);
this->convert(this, n_dst_datas, dst_datas, n_src_datas, src_datas, n_bytes); this->convert(this, n_dst_datas, dst_datas, n_src_datas, src_datas, n_samples);
inport->offset += n_bytes;
if (inport->offset >= size) {
inio->status = SPA_STATUS_NEED_BUFFER; inio->status = SPA_STATUS_NEED_BUFFER;
inport->offset = 0;
res |= SPA_STATUS_NEED_BUFFER; res |= SPA_STATUS_NEED_BUFFER;
}
dequeue_buffer(this, outbuf);
outio->status = SPA_STATUS_HAVE_BUFFER; outio->status = SPA_STATUS_HAVE_BUFFER;
outio->buffer_id = outb->id; outio->buffer_id = outb->id;
res |= SPA_STATUS_HAVE_BUFFER; res |= SPA_STATUS_HAVE_BUFFER;

93
spa/plugins/audioconvert/merger.c
View file

@ -114,6 +114,7 @@ static int init_port(struct impl *this, enum spa_direction direction, uint32_t p
{ {
struct port *port = GET_PORT(this, direction, port_id); struct port *port = GET_PORT(this, direction, port_id);
int n_items = 0; int n_items = 0;
port->id = port_id; port->id = port_id;
snprintf(port->position, 16, "%s", rindex(spa_type_audio_channel[position].name, ':')+1); snprintf(port->position, 16, "%s", rindex(spa_type_audio_channel[position].name, ':')+1);
@ -762,7 +763,8 @@ impl_node_port_use_buffers(struct spa_node *node,
spa_return_val_if_fail(port->have_format, -EIO); spa_return_val_if_fail(port->have_format, -EIO);
spa_log_debug(this->log, NAME " %p: use buffers %d on port %d", this, n_buffers, port_id); spa_log_debug(this->log, NAME " %p: use buffers %d on port %d:%d",
this, n_buffers, direction, port_id);
clear_buffers(this, port); clear_buffers(this, port);
@ -856,33 +858,61 @@ impl_node_port_send_command(struct spa_node *node,
return -ENOTSUP; return -ENOTSUP;
} }
static inline int handle_monitor(struct impl *this, const void *data, int n_samples, struct port *outport) static inline int get_in_buffer(struct impl *this, struct port *port, struct buffer **buf)
{ {
struct spa_io_buffers *outio; struct spa_io_buffers *io;
struct buffer *dbuf;
struct spa_data *dd;
int size;
if ((outio = outport->io) == NULL || if ((io = port->io) == NULL ||
outio->status == SPA_STATUS_HAVE_BUFFER) io->status != SPA_STATUS_HAVE_BUFFER ||
io->buffer_id >= port->n_buffers) {
spa_log_trace(this->log, NAME " %p: empty port %d %p %d %d %d",
this, port->id, io, io->status, io->buffer_id,
port->n_buffers);
return -EPIPE;
}
*buf = &port->buffers[io->buffer_id];
io->status = SPA_STATUS_NEED_BUFFER;
return 0;
}
static inline int get_out_buffer(struct impl *this, struct port *port, struct buffer **buf)
{
struct spa_io_buffers *io;
if ((io = port->io) == NULL ||
io->status == SPA_STATUS_HAVE_BUFFER)
return SPA_STATUS_HAVE_BUFFER; return SPA_STATUS_HAVE_BUFFER;
if (outio->buffer_id < outport->n_buffers) if (io->buffer_id < port->n_buffers)
queue_buffer(this, outport, outio->buffer_id); queue_buffer(this, port, io->buffer_id);
if ((dbuf = dequeue_buffer(this, outport)) == NULL) if ((*buf = dequeue_buffer(this, port)) == NULL)
return -EPIPE; return -EPIPE;
io->status = SPA_STATUS_HAVE_BUFFER;
io->buffer_id = (*buf)->buf->id;
return 0;
}
static inline int handle_monitor(struct impl *this, const void *data, int n_samples, struct port *outport)
{
struct buffer *dbuf;
struct spa_data *dd;
int res, size;
if ((res = get_out_buffer(this, outport, &dbuf)) != 0)
return res;
dd = &dbuf->buf->datas[0]; dd = &dbuf->buf->datas[0];
size = SPA_MIN(dd->maxsize, n_samples * outport->stride); size = SPA_MIN(dd->maxsize, n_samples * outport->stride);
dd->chunk->offset = 0; dd->chunk->offset = 0;
dd->chunk->size = size; dd->chunk->size = size;
memcpy(dd->data, data, size); memcpy(dd->data, data, size);
outio->buffer_id = dbuf->buf->id; return res;
outio->status = SPA_STATUS_HAVE_BUFFER;
return SPA_STATUS_HAVE_BUFFER;
} }
static int impl_node_process(struct spa_node *node) static int impl_node_process(struct spa_node *node)
@ -890,7 +920,7 @@ static int impl_node_process(struct spa_node *node)
struct impl *this; struct impl *this;
struct port *outport; struct port *outport;
struct spa_io_buffers *outio; struct spa_io_buffers *outio;
int i, maxsize, res = 0, n_samples, n_bytes = 0; int i, maxsize, res = 0, n_samples;
struct spa_data *sd, *dd; struct spa_data *sd, *dd;
struct buffer *sbuf, *dbuf; struct buffer *sbuf, *dbuf;
uint32_t n_src_datas, n_dst_datas; uint32_t n_src_datas, n_dst_datas;
@ -908,14 +938,8 @@ static int impl_node_process(struct spa_node *node)
spa_log_trace(this->log, NAME " %p: status %d %d", this, outio->status, outio->buffer_id); spa_log_trace(this->log, NAME " %p: status %d %d", this, outio->status, outio->buffer_id);
if (outio->status == SPA_STATUS_HAVE_BUFFER) if ((res = get_out_buffer(this, outport, &dbuf)) != 0)
return SPA_STATUS_HAVE_BUFFER; return res;
if (outio->buffer_id < outport->n_buffers)
queue_buffer(this, outport, outio->buffer_id);
if ((dbuf = dequeue_buffer(this, outport)) == NULL)
return -EPIPE;
dd = &dbuf->buf->datas[0]; dd = &dbuf->buf->datas[0];
@ -933,31 +957,22 @@ static int impl_node_process(struct spa_node *node)
n_src_datas = 0; n_src_datas = 0;
for (i = 0; i < this->port_count; i++) { for (i = 0; i < this->port_count; i++) {
struct port *inport = GET_IN_PORT(this, i); struct port *inport = GET_IN_PORT(this, i);
struct spa_io_buffers *inio;
if ((inio = inport->io) == NULL || if (get_in_buffer(this, inport, &sbuf) < 0) {
inio->status != SPA_STATUS_HAVE_BUFFER ||
inio->buffer_id >= inport->n_buffers) {
spa_log_trace(this->log, NAME " %p: empty port %d %p %d %d %d", this, i, inio,
inio->status, inio->buffer_id, inport->n_buffers);
src_datas[n_src_datas++] = this->empty; src_datas[n_src_datas++] = this->empty;
continue; continue;
} }
sbuf = &inport->buffers[inio->buffer_id];
sd = &sbuf->buf->datas[0]; sd = &sbuf->buf->datas[0];
src_datas[n_src_datas++] = SPA_MEMBER(sd->data, sd->chunk->offset, void); src_datas[n_src_datas++] = SPA_MEMBER(sd->data, sd->chunk->offset, void);
n_samples = SPA_MIN(sd->chunk->size / inport->stride, n_samples); n_samples = SPA_MIN(n_samples, sd->chunk->size / inport->stride);
n_bytes = n_samples * inport->stride;
spa_log_trace(this->log, NAME " %p: %d %d %d %p", this, spa_log_trace(this->log, NAME " %p: %d %d %d %p", this,
sd->chunk->size, maxsize, n_samples, src_datas[i]); sd->chunk->size, maxsize, n_samples, src_datas[i]);
inio->status = SPA_STATUS_NEED_BUFFER;
SPA_FLAG_SET(res, SPA_STATUS_NEED_BUFFER); SPA_FLAG_SET(res, SPA_STATUS_NEED_BUFFER);
} }
for (i = 0; i < this->monitor_count; i++) for (i = 0; i < this->monitor_count; i++)
@ -971,13 +986,9 @@ static int impl_node_process(struct spa_node *node)
n_samples * outport->stride); n_samples * outport->stride);
} }
this->convert(this, n_dst_datas, dst_datas, n_src_datas, src_datas, n_bytes); this->convert(this, n_dst_datas, dst_datas, n_src_datas, src_datas, n_samples);
outio->buffer_id = dbuf->buf->id; return res | SPA_STATUS_HAVE_BUFFER;
outio->status = SPA_STATUS_HAVE_BUFFER;
SPA_FLAG_SET(res, SPA_STATUS_HAVE_BUFFER);
return res;
} }
static const struct spa_node impl_node = { static const struct spa_node impl_node = {

8
spa/plugins/audioconvert/splitter.c
View file

@ -839,7 +839,7 @@ static int impl_node_process(struct spa_node *node)
struct impl *this; struct impl *this;
struct port *inport; struct port *inport;
struct spa_io_buffers *inio; struct spa_io_buffers *inio;
int i, j, maxsize, res = 0, n_samples, n_bytes = 0; int i, j, maxsize, res = 0, n_samples;
struct spa_data *sd, *dd; struct spa_data *sd, *dd;
struct buffer *sbuf, *dbuf; struct buffer *sbuf, *dbuf;
uint32_t n_src_datas, n_dst_datas; uint32_t n_src_datas, n_dst_datas;
@ -875,7 +875,6 @@ static int impl_node_process(struct spa_node *node)
sd[i].chunk->offset, void); sd[i].chunk->offset, void);
maxsize = SPA_MIN(sd[i].chunk->size, maxsize); maxsize = SPA_MIN(sd[i].chunk->size, maxsize);
} }
n_bytes = maxsize;
n_samples = maxsize / inport->stride; n_samples = maxsize / inport->stride;
dst_datas = alloca(sizeof(void*) * MAX_PORTS); dst_datas = alloca(sizeof(void*) * MAX_PORTS);
@ -913,6 +912,7 @@ static int impl_node_process(struct spa_node *node)
maxsize = dd->maxsize; maxsize = dd->maxsize;
if (outport->ctrl) if (outport->ctrl)
maxsize = SPA_MIN(outport->ctrl->max_size, maxsize); maxsize = SPA_MIN(outport->ctrl->max_size, maxsize);
n_samples = SPA_MIN(n_samples, maxsize / outport->stride);
for (j = 0; j < dbuf->buf->n_datas; j++) { for (j = 0; j < dbuf->buf->n_datas; j++) {
dst_datas[n_dst_datas++] = dd[j].data; dst_datas[n_dst_datas++] = dd[j].data;
@ -925,9 +925,9 @@ static int impl_node_process(struct spa_node *node)
} }
spa_log_trace(this->log, NAME " %p: %d %d %d %d %d", this, spa_log_trace(this->log, NAME " %p: %d %d %d %d %d", this,
n_src_datas, n_dst_datas, n_bytes, maxsize, inport->stride); n_src_datas, n_dst_datas, n_samples, maxsize, inport->stride);
this->convert(this, n_dst_datas, dst_datas, n_src_datas, src_datas, n_bytes); this->convert(this, n_dst_datas, dst_datas, n_src_datas, src_datas, n_samples);
inio->status = SPA_STATUS_NEED_BUFFER; inio->status = SPA_STATUS_NEED_BUFFER;
res |= SPA_STATUS_NEED_BUFFER; res |= SPA_STATUS_NEED_BUFFER;