mirror of
https://gitlab.freedesktop.org/pipewire/pipewire.git
synced 2025-11-01 22:58:50 -04:00
audioconvert: pass samples to convert functions
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
parent
491dd785ad
commit
08a63ded5d
5 changed files with 242 additions and 266 deletions
|
|
@ -30,16 +30,14 @@
|
|||
#include <xmmintrin.h>
|
||||
|
||||
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;
|
||||
float **d = (float **) dst;
|
||||
float *d0 = d[0];
|
||||
int n, n_samples;
|
||||
int n;
|
||||
__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++) {
|
||||
out = _mm_cvtsi32_ss(out, *s);
|
||||
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
|
||||
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;
|
||||
float **d = (float **) dst;
|
||||
float *d0 = d[0], *d1 = d[1];
|
||||
int n = 0, n_samples, unrolled;
|
||||
int n = 0, unrolled;
|
||||
__m128i in, t[2];
|
||||
__m128 out[2], factor = _mm_set1_ps(1.0f / S16_SCALE);
|
||||
|
||||
n_samples = n_bytes / (sizeof(int16_t) * n_dst);
|
||||
|
||||
if (n_dst == 2) {
|
||||
unrolled = n_samples / 4;
|
||||
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
|
||||
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];
|
||||
int i = 0;
|
||||
|
||||
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++)
|
||||
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
|
||||
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;
|
||||
float **d = (float **) dst;
|
||||
float *d0 = d[0];
|
||||
int n = 0, n_samples, unrolled;
|
||||
int n = 0, unrolled;
|
||||
__m128i in;
|
||||
union {
|
||||
__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;
|
||||
__m128 out, factor = _mm_set1_ps(1.0f / S24_SCALE);
|
||||
|
||||
n_samples = n_bytes / (3 * n_dst);
|
||||
|
||||
unrolled = n_samples / 4;
|
||||
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
|
||||
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];
|
||||
int i = 0;
|
||||
|
||||
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
|
||||
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 *s0 = s[0];
|
||||
int32_t *d = dst;
|
||||
int n, n_samples, unrolled;
|
||||
int n, unrolled;
|
||||
__m128 in[1];
|
||||
__m128i out[4];
|
||||
__m128 int_max = _mm_set1_ps(S24_MAX_F);
|
||||
__m128 int_min = _mm_sub_ps(_mm_setzero_ps(), int_max);
|
||||
|
||||
n_samples = n_bytes / sizeof(float);
|
||||
|
||||
unrolled = n_samples / 4;
|
||||
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
|
||||
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 *s0 = s[0], *s1 = s[1];
|
||||
int32_t *d = dst;
|
||||
int n, n_samples, unrolled;
|
||||
int n, unrolled;
|
||||
__m128 in[2];
|
||||
__m128i out[2], t[2];
|
||||
__m128 int_max = _mm_set1_ps(S24_MAX_F);
|
||||
__m128 int_min = _mm_sub_ps(_mm_setzero_ps(), int_max);
|
||||
|
||||
n_samples = n_bytes / sizeof(float);
|
||||
|
||||
unrolled = n_samples / 4;
|
||||
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
|
||||
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 *s0 = s[0], *s1 = s[1], *s2 = s[2], *s3 = s[3];
|
||||
int32_t *d = dst;
|
||||
int n, n_samples, unrolled;
|
||||
int n, unrolled;
|
||||
__m128 in[4];
|
||||
__m128i out[4], t[4];
|
||||
__m128 int_max = _mm_set1_ps(S24_MAX_F);
|
||||
__m128 int_min = _mm_sub_ps(_mm_setzero_ps(), int_max);
|
||||
|
||||
n_samples = n_bytes / sizeof(float);
|
||||
|
||||
unrolled = n_samples / 4;
|
||||
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
|
||||
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];
|
||||
int i = 0;
|
||||
|
||||
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)
|
||||
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++)
|
||||
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
|
||||
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 *s0 = s[0];
|
||||
int16_t *d = dst;
|
||||
int n, n_samples, unrolled;
|
||||
int n, unrolled;
|
||||
__m128 in[1];
|
||||
__m128i out[4];
|
||||
__m128 int_max = _mm_set1_ps(S16_MAX_F);
|
||||
__m128 int_min = _mm_sub_ps(_mm_setzero_ps(), int_max);
|
||||
|
||||
n_samples = n_bytes / sizeof(float);
|
||||
|
||||
unrolled = n_samples / 4;
|
||||
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
|
||||
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 *s0 = s[0], *s1 = s[1];
|
||||
int16_t *d = dst;
|
||||
int n = 0, n_samples, unrolled;
|
||||
int n = 0, unrolled;
|
||||
__m128 in[2];
|
||||
__m128i out[4], t[2];
|
||||
__m128 int_max = _mm_set1_ps(S16_MAX_F);
|
||||
__m128 int_min = _mm_sub_ps(_mm_setzero_ps(), int_max);
|
||||
|
||||
n_samples = n_bytes / sizeof(float);
|
||||
unrolled = n_samples / 4;
|
||||
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
|
||||
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];
|
||||
int i = 0;
|
||||
|
||||
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++)
|
||||
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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -68,17 +68,41 @@ static inline int32_t read_s24(const void *src)
|
|||
#endif
|
||||
|
||||
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;
|
||||
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)
|
||||
|
||||
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;
|
||||
|
||||
|
|
@ -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];
|
||||
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]);
|
||||
}
|
||||
}
|
||||
|
||||
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];
|
||||
float **d = (float **) dst;
|
||||
int i, j;
|
||||
|
||||
n_bytes /= n_dst;
|
||||
for (j = 0; j < n_bytes; j++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_dst; i++)
|
||||
d[i][j] = U8_TO_F32(*s++);
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
float *d = dst[0];
|
||||
int i, j;
|
||||
|
||||
n_bytes /= n_src;
|
||||
for (j = 0; j < n_bytes; j++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_src; i++)
|
||||
*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))
|
||||
|
||||
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;
|
||||
|
||||
n_bytes /= sizeof(int16_t);
|
||||
for (i = 0; i < n_src; i++) {
|
||||
const int16_t *s = src[i];
|
||||
float *d = dst[i];
|
||||
|
||||
for (j = 0; j < n_bytes; j++)
|
||||
for (j = 0; j < n_samples; j++)
|
||||
d[j] = S16_TO_F32(s[j]);
|
||||
}
|
||||
}
|
||||
|
||||
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];
|
||||
float **d = (float **) dst;
|
||||
int i, j;
|
||||
|
||||
n_bytes /= (sizeof(int16_t) * n_dst);
|
||||
for (j = 0; j < n_bytes; j++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_dst; i++)
|
||||
d[i][j] = S16_TO_F32(*s++);
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
float *d = dst[0];
|
||||
int i, n, n_samples;
|
||||
int i, j;
|
||||
|
||||
n_samples = n_bytes / sizeof(int16_t);
|
||||
for (n = 0; n < n_samples; n++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
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))
|
||||
|
||||
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;
|
||||
|
||||
n_bytes /= sizeof(int32_t);
|
||||
for (i = 0; i < n_src; i++) {
|
||||
const int32_t *s = src[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]);
|
||||
}
|
||||
}
|
||||
|
||||
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];
|
||||
float **d = (float **) dst;
|
||||
int i, j;
|
||||
|
||||
n_bytes /= (sizeof(int32_t) * n_dst);
|
||||
for (j = 0; j < n_bytes; j++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_dst; i++)
|
||||
d[i][j] = S32_TO_F32(*s++);
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
float *d = dst[0];
|
||||
int i, n, n_samples;
|
||||
int i, j;
|
||||
|
||||
n_samples = n_bytes / sizeof(int32_t);
|
||||
for (n = 0; n < n_samples; n++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
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))
|
||||
|
||||
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;
|
||||
|
||||
n_bytes /= 3;
|
||||
for (i = 0; i < n_src; i++) {
|
||||
const int8_t *s = src[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));
|
||||
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
|
||||
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];
|
||||
float **d = (float **) dst;
|
||||
int i, j;
|
||||
|
||||
n_bytes /= (3 * n_dst);
|
||||
for (j = 0; j < n_bytes; j++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_dst; i++) {
|
||||
d[i][j] = S24_TO_F32(READ24(s));
|
||||
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
|
||||
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;
|
||||
float *d = dst[0];
|
||||
int i, n, n_samples;
|
||||
int i, j;
|
||||
|
||||
n_samples = n_bytes / 3;
|
||||
for (n = 0; n < n_samples; n++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_src; i++) {
|
||||
*d++ = S24_TO_F32(READ24(s[i]));
|
||||
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
|
||||
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;
|
||||
|
||||
n_bytes /= sizeof(int32_t);
|
||||
for (i = 0; i < n_src; i++) {
|
||||
const int32_t *s = src[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]);
|
||||
}
|
||||
}
|
||||
|
||||
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];
|
||||
float **d = (float **) dst;
|
||||
int i, j;
|
||||
|
||||
n_bytes /= (sizeof(int32_t) * n_dst);
|
||||
for (j = 0; j < n_bytes; j++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_dst; i++)
|
||||
d[i][j] = S24_TO_F32(*s++);
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
float *d = dst[0];
|
||||
int i, n, n_samples;
|
||||
int i, j;
|
||||
|
||||
n_samples = n_bytes / sizeof(int32_t);
|
||||
for (n = 0; n < n_samples; n++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
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
|
||||
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;
|
||||
|
||||
n_bytes /= sizeof(float);
|
||||
for (i = 0; i < n_src; i++) {
|
||||
const float *s = src[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]);
|
||||
}
|
||||
}
|
||||
|
||||
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];
|
||||
int8_t **d = (int8_t **) dst;
|
||||
int i, j;
|
||||
|
||||
n_bytes /= (sizeof(float) * n_dst);
|
||||
for (j = 0; j < n_bytes; j++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_dst; i++)
|
||||
d[i][j] = F32_TO_U8(*s++);
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
int8_t *d = dst[0];
|
||||
int i, n, n_samples;
|
||||
int i, j;
|
||||
|
||||
n_samples = n_bytes / sizeof(float);
|
||||
for (n = 0; n < n_samples; n++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
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
|
||||
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++) {
|
||||
const float *s = src[i];
|
||||
int16_t *d = dst[i];
|
||||
|
||||
for (n = 0; n < n_samples; n++)
|
||||
d[n] = F32_TO_S16(s[n]);
|
||||
for (j = 0; j < n_samples; j++)
|
||||
d[j] = F32_TO_S16(s[j]);
|
||||
}
|
||||
}
|
||||
|
||||
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];
|
||||
int16_t **d = (int16_t **) dst;
|
||||
int i, n, n_samples;
|
||||
int i, j;
|
||||
|
||||
n_samples = n_bytes / (sizeof(float) * n_dst);
|
||||
for (n = 0; n < n_samples; n++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_dst; i++)
|
||||
d[i][n] = F32_TO_S16(*s++);
|
||||
d[i][j] = F32_TO_S16(*s++);
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
int16_t *d = dst[0];
|
||||
int i, n, n_samples;
|
||||
int i, j;
|
||||
|
||||
n_samples = n_bytes / sizeof(float);
|
||||
for (n = 0; n < n_samples; n++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
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
|
||||
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;
|
||||
|
||||
n_bytes /= sizeof(float);
|
||||
for (i = 0; i < n_src; i++) {
|
||||
const float *s = src[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]);
|
||||
}
|
||||
}
|
||||
|
||||
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];
|
||||
int32_t **d = (int32_t **) dst;
|
||||
int i, j;
|
||||
|
||||
n_bytes /= (sizeof(float) * n_dst);
|
||||
for (j = 0; j < n_bytes; j++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_dst; i++)
|
||||
d[i][j] = F32_TO_S32(*s++);
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
int32_t *d = dst[0];
|
||||
int i, n, n_samples;
|
||||
int i, j;
|
||||
|
||||
n_samples = n_bytes / sizeof(float);
|
||||
for (n = 0; n < n_samples; n++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
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
|
||||
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;
|
||||
|
||||
n_bytes /= sizeof(float);
|
||||
for (i = 0; i < n_src; i++) {
|
||||
const float *s = src[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]));
|
||||
d += 3;
|
||||
}
|
||||
}
|
||||
|
||||
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];
|
||||
int8_t **d = (int8_t **) dst;
|
||||
int i, j;
|
||||
|
||||
n_bytes /= (sizeof(float) * n_dst);
|
||||
for (j = 0; j < n_bytes; j++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_dst; i++) {
|
||||
WRITE24(d[i], F32_TO_S24(*s++));
|
||||
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
|
||||
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;
|
||||
int8_t *d = dst[0];
|
||||
int i, n, n_samples;
|
||||
int i, j;
|
||||
|
||||
n_samples = n_bytes / sizeof(float);
|
||||
for (n = 0; n < n_samples; n++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
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;
|
||||
}
|
||||
}
|
||||
|
|
@ -524,85 +521,79 @@ conv_f32d_to_s24(void *data, int n_dst, void *dst[n_dst], int n_src, const 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;
|
||||
|
||||
n_bytes /= sizeof(float);
|
||||
for (i = 0; i < n_src; i++) {
|
||||
const float *s = src[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]);
|
||||
}
|
||||
}
|
||||
|
||||
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];
|
||||
int32_t **d = (int32_t **) dst;
|
||||
int i, j;
|
||||
|
||||
n_bytes /= (sizeof(float) * n_dst);
|
||||
for (j = 0; j < n_bytes; j++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_dst; i++)
|
||||
d[i][j] = F32_TO_S24(*s++);
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
int32_t *d = dst[0];
|
||||
int i, n, n_samples;
|
||||
int i, j;
|
||||
|
||||
n_samples = n_bytes / sizeof(float);
|
||||
for (n = 0; n < n_samples; n++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_src; i++)
|
||||
*d++ = F32_TO_S24(s[i][n]);
|
||||
*d++ = F32_TO_S24(s[i][j]);
|
||||
}
|
||||
}
|
||||
|
||||
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];
|
||||
uint8_t **d = (uint8_t **) dst;
|
||||
int i, j;
|
||||
|
||||
n_bytes /= (sizeof(uint8_t) * n_dst);
|
||||
for (j = 0; j < n_bytes; j++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_dst; i++)
|
||||
d[i][j] = *s++;
|
||||
}
|
||||
}
|
||||
|
||||
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];
|
||||
uint16_t **d = (uint16_t **) dst;
|
||||
int i, j;
|
||||
|
||||
n_bytes /= (sizeof(uint16_t) * n_dst);
|
||||
for (j = 0; j < n_bytes; j++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_dst; i++)
|
||||
d[i][j] = *s++;
|
||||
}
|
||||
}
|
||||
|
||||
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];
|
||||
uint8_t **d = (uint8_t **) dst;
|
||||
int i, j;
|
||||
|
||||
n_bytes /= (3 * n_dst);
|
||||
for (j = 0; j < n_bytes; j++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_dst; i++) {
|
||||
WRITE24(d[i], READ24(s));
|
||||
d += 3;
|
||||
|
|
@ -612,56 +603,52 @@ deinterleave_24(void *data, int n_dst, void *dst[n_dst], int n_src, const 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];
|
||||
uint32_t **d = (uint32_t **) dst;
|
||||
int i, j;
|
||||
|
||||
n_bytes /= (sizeof(uint32_t) * n_dst);
|
||||
for (j = 0; j < n_bytes; j++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_dst; i++)
|
||||
d[i][j] = *s++;
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
uint8_t *d = dst[0];
|
||||
int i, j;
|
||||
|
||||
n_bytes /= sizeof(uint8_t);
|
||||
for (j = 0; j < n_bytes; j++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_src; i++)
|
||||
*d++ = s[i][j];
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
uint16_t *d = dst[0];
|
||||
int i, j;
|
||||
|
||||
n_bytes /= sizeof(uint16_t);
|
||||
for (j = 0; j < n_bytes; j++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_src; i++)
|
||||
*d++ = s[i][j];
|
||||
}
|
||||
}
|
||||
|
||||
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;
|
||||
uint8_t *d = dst[0];
|
||||
int i, j;
|
||||
|
||||
n_bytes /= 3;
|
||||
for (j = 0; j < n_bytes; j++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_src; i++) {
|
||||
WRITE24(d, READ24(s[i]));
|
||||
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
|
||||
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;
|
||||
uint32_t *d = dst[0];
|
||||
int i, j;
|
||||
|
||||
n_bytes /= sizeof(uint32_t);
|
||||
for (j = 0; j < n_bytes; j++) {
|
||||
for (j = 0; j < n_samples; j++) {
|
||||
for (i = 0; i < n_src; i++)
|
||||
*d++ = s[i][j];
|
||||
}
|
||||
}
|
||||
|
||||
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 {
|
||||
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_S16P, SPA_AUDIO_FORMAT_F32, 0, conv_s16d_to_f32 },
|
||||
|
||||
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_F32, 0, conv_copy },
|
||||
{ SPA_AUDIO_FORMAT_F32P, SPA_AUDIO_FORMAT_F32P, 0, conv_copy },
|
||||
{ SPA_AUDIO_FORMAT_F32, SPA_AUDIO_FORMAT_F32, 0, conv_copy32 },
|
||||
{ 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_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 },
|
||||
|
||||
/* u8 */
|
||||
{ SPA_AUDIO_FORMAT_U8, SPA_AUDIO_FORMAT_U8, 0, conv_copy },
|
||||
{ SPA_AUDIO_FORMAT_U8P, SPA_AUDIO_FORMAT_U8P, 0, conv_copy },
|
||||
{ SPA_AUDIO_FORMAT_U8, SPA_AUDIO_FORMAT_U8, 0, conv_copy8 },
|
||||
{ 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_U8P, SPA_AUDIO_FORMAT_U8, 0, interleave_8 },
|
||||
|
||||
/* s16 */
|
||||
{ SPA_AUDIO_FORMAT_S16, SPA_AUDIO_FORMAT_S16, 0, conv_copy },
|
||||
{ SPA_AUDIO_FORMAT_S16P, SPA_AUDIO_FORMAT_S16P, 0, conv_copy },
|
||||
{ SPA_AUDIO_FORMAT_S16, SPA_AUDIO_FORMAT_S16, 0, conv_copy16 },
|
||||
{ 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_S16P, SPA_AUDIO_FORMAT_S16, 0, interleave_16 },
|
||||
|
||||
/* s32 */
|
||||
{ SPA_AUDIO_FORMAT_S32, SPA_AUDIO_FORMAT_S32, 0, conv_copy },
|
||||
{ SPA_AUDIO_FORMAT_S32P, SPA_AUDIO_FORMAT_S32P, 0, conv_copy },
|
||||
{ SPA_AUDIO_FORMAT_S32, SPA_AUDIO_FORMAT_S32, 0, conv_copy32 },
|
||||
{ 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_S32P, SPA_AUDIO_FORMAT_S32, 0, interleave_32 },
|
||||
|
||||
/* s24 */
|
||||
{ SPA_AUDIO_FORMAT_S24, SPA_AUDIO_FORMAT_S24, 0, conv_copy },
|
||||
{ SPA_AUDIO_FORMAT_S24P, SPA_AUDIO_FORMAT_S24P, 0, conv_copy },
|
||||
{ SPA_AUDIO_FORMAT_S24, SPA_AUDIO_FORMAT_S24, 0, conv_copy24 },
|
||||
{ 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_S24P, SPA_AUDIO_FORMAT_S24, 0, interleave_24 },
|
||||
|
||||
/* s24_32 */
|
||||
{ SPA_AUDIO_FORMAT_S24_32, SPA_AUDIO_FORMAT_S24_32, 0, conv_copy },
|
||||
{ SPA_AUDIO_FORMAT_S24_32P, SPA_AUDIO_FORMAT_S24_32P, 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_copy32 },
|
||||
{ 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 },
|
||||
};
|
||||
|
|
|
|||
|
|
@ -25,6 +25,7 @@
|
|||
#include <errno.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <limits.h>
|
||||
|
||||
#include <spa/support/log.h>
|
||||
#include <spa/utils/list.h>
|
||||
|
|
@ -84,8 +85,6 @@ struct port {
|
|||
uint32_t blocks;
|
||||
uint32_t size;
|
||||
|
||||
uint32_t offset;
|
||||
|
||||
struct buffer buffers[MAX_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))
|
||||
return NULL;
|
||||
return spa_list_first(&port->queue, struct buffer, link);
|
||||
}
|
||||
|
||||
static inline void dequeue_buffer(struct impl *this, struct buffer *b)
|
||||
{
|
||||
b = spa_list_first(&port->queue, struct buffer, link);
|
||||
spa_list_remove(&b->link);
|
||||
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)
|
||||
|
|
@ -809,8 +807,8 @@ static int impl_node_process(struct spa_node *node)
|
|||
const void **src_datas;
|
||||
void **dst_datas;
|
||||
uint32_t n_src_datas, n_dst_datas;
|
||||
int i, res = 0, n_bytes = 0, maxsize;
|
||||
uint32_t size = 0;
|
||||
int i, res = 0, n_samples = 0, maxsize;
|
||||
int size = 0;
|
||||
|
||||
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)
|
||||
return inio->status = -EINVAL;
|
||||
|
||||
if ((outbuf = peek_buffer(this, outport)) == NULL)
|
||||
if ((outbuf = dequeue_buffer(this, outport)) == NULL)
|
||||
return outio->status = -EPIPE;
|
||||
|
||||
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;
|
||||
src_datas = alloca(sizeof(void*) * n_src_datas);
|
||||
|
||||
size = inb->datas[0].chunk->size;
|
||||
for (i = 0; i < n_src_datas; i++)
|
||||
src_datas[i] = SPA_MEMBER(inb->datas[i].data, inport->offset, void);
|
||||
size = INT_MAX;
|
||||
for (i = 0; i < n_src_datas; i++) {
|
||||
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;
|
||||
|
||||
|
|
@ -861,29 +862,22 @@ static int impl_node_process(struct spa_node *node)
|
|||
maxsize = outb->datas[0].maxsize;
|
||||
if (outport->ctrl)
|
||||
maxsize = SPA_MIN(outport->ctrl->max_size, maxsize);
|
||||
|
||||
maxsize = (maxsize / outport->stride) * inport->stride;
|
||||
n_bytes = SPA_MIN(size - inport->offset, maxsize);
|
||||
n_samples = SPA_MIN(n_samples, maxsize / outport->stride);
|
||||
|
||||
for (i = 0; i < n_dst_datas; i++) {
|
||||
dst_datas[i] = outb->datas[this->remap[i]].data;
|
||||
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,
|
||||
n_src_datas, n_dst_datas, inport->offset, size, maxsize, n_bytes);
|
||||
spa_log_trace(this->log, NAME " %p: n_src:%d n_dst:%d size:%d maxsize:%d n_samples:%d",
|
||||
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;
|
||||
inport->offset = 0;
|
||||
res |= SPA_STATUS_NEED_BUFFER;
|
||||
}
|
||||
inio->status = SPA_STATUS_NEED_BUFFER;
|
||||
res |= SPA_STATUS_NEED_BUFFER;
|
||||
|
||||
dequeue_buffer(this, outbuf);
|
||||
outio->status = SPA_STATUS_HAVE_BUFFER;
|
||||
outio->buffer_id = outb->id;
|
||||
res |= SPA_STATUS_HAVE_BUFFER;
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
int n_items = 0;
|
||||
|
||||
port->id = port_id;
|
||||
|
||||
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_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);
|
||||
|
||||
|
|
@ -856,33 +858,61 @@ impl_node_port_send_command(struct spa_node *node,
|
|||
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 buffer *dbuf;
|
||||
struct spa_data *dd;
|
||||
int size;
|
||||
struct spa_io_buffers *io;
|
||||
|
||||
if ((outio = outport->io) == NULL ||
|
||||
outio->status == SPA_STATUS_HAVE_BUFFER)
|
||||
if ((io = port->io) == NULL ||
|
||||
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;
|
||||
|
||||
if (outio->buffer_id < outport->n_buffers)
|
||||
queue_buffer(this, outport, outio->buffer_id);
|
||||
if (io->buffer_id < port->n_buffers)
|
||||
queue_buffer(this, port, io->buffer_id);
|
||||
|
||||
if ((dbuf = dequeue_buffer(this, outport)) == NULL)
|
||||
if ((*buf = dequeue_buffer(this, port)) == NULL)
|
||||
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];
|
||||
size = SPA_MIN(dd->maxsize, n_samples * outport->stride);
|
||||
dd->chunk->offset = 0;
|
||||
dd->chunk->size = size;
|
||||
memcpy(dd->data, data, size);
|
||||
|
||||
outio->buffer_id = dbuf->buf->id;
|
||||
outio->status = SPA_STATUS_HAVE_BUFFER;
|
||||
|
||||
return SPA_STATUS_HAVE_BUFFER;
|
||||
return res;
|
||||
}
|
||||
|
||||
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 port *outport;
|
||||
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 buffer *sbuf, *dbuf;
|
||||
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);
|
||||
|
||||
if (outio->status == SPA_STATUS_HAVE_BUFFER)
|
||||
return SPA_STATUS_HAVE_BUFFER;
|
||||
|
||||
if (outio->buffer_id < outport->n_buffers)
|
||||
queue_buffer(this, outport, outio->buffer_id);
|
||||
|
||||
if ((dbuf = dequeue_buffer(this, outport)) == NULL)
|
||||
return -EPIPE;
|
||||
if ((res = get_out_buffer(this, outport, &dbuf)) != 0)
|
||||
return res;
|
||||
|
||||
dd = &dbuf->buf->datas[0];
|
||||
|
||||
|
|
@ -933,31 +957,22 @@ static int impl_node_process(struct spa_node *node)
|
|||
n_src_datas = 0;
|
||||
for (i = 0; i < this->port_count; i++) {
|
||||
struct port *inport = GET_IN_PORT(this, i);
|
||||
struct spa_io_buffers *inio;
|
||||
|
||||
if ((inio = inport->io) == NULL ||
|
||||
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);
|
||||
if (get_in_buffer(this, inport, &sbuf) < 0) {
|
||||
src_datas[n_src_datas++] = this->empty;
|
||||
continue;
|
||||
}
|
||||
|
||||
sbuf = &inport->buffers[inio->buffer_id];
|
||||
sd = &sbuf->buf->datas[0];
|
||||
|
||||
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_bytes = n_samples * inport->stride;
|
||||
n_samples = SPA_MIN(n_samples, sd->chunk->size / inport->stride);
|
||||
|
||||
spa_log_trace(this->log, NAME " %p: %d %d %d %p", this,
|
||||
sd->chunk->size, maxsize, n_samples, src_datas[i]);
|
||||
|
||||
inio->status = SPA_STATUS_NEED_BUFFER;
|
||||
SPA_FLAG_SET(res, SPA_STATUS_NEED_BUFFER);
|
||||
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
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;
|
||||
outio->status = SPA_STATUS_HAVE_BUFFER;
|
||||
SPA_FLAG_SET(res, SPA_STATUS_HAVE_BUFFER);
|
||||
|
||||
return res;
|
||||
return res | SPA_STATUS_HAVE_BUFFER;
|
||||
}
|
||||
|
||||
static const struct spa_node impl_node = {
|
||||
|
|
|
|||
|
|
@ -839,7 +839,7 @@ static int impl_node_process(struct spa_node *node)
|
|||
struct impl *this;
|
||||
struct port *inport;
|
||||
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 buffer *sbuf, *dbuf;
|
||||
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);
|
||||
maxsize = SPA_MIN(sd[i].chunk->size, maxsize);
|
||||
}
|
||||
n_bytes = maxsize;
|
||||
n_samples = maxsize / inport->stride;
|
||||
|
||||
dst_datas = alloca(sizeof(void*) * MAX_PORTS);
|
||||
|
|
@ -913,6 +912,7 @@ static int impl_node_process(struct spa_node *node)
|
|||
maxsize = dd->maxsize;
|
||||
if (outport->ctrl)
|
||||
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++) {
|
||||
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,
|
||||
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;
|
||||
res |= SPA_STATUS_NEED_BUFFER;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue