mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-10-31 22:25:38 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

mixer: Move floatmix to the audio mixer plugin

Browse source 
Move floatmix to the audiomixer plugin and change the name to
AUDIO_MIXER_DSP.
Add runtime selectable sse and sse2 optimizations.
Load the port mixer plugin dynamically based on the factory_name.
Add some more debug
This commit is contained in:
Wim Taymans 2019-10-03 16:20:12 +02:00
parent 27eabede35
commit 0ecbe4844e
13 changed files with 482 additions and 404 deletions
Download patch file Download diff file Expand all files Collapse all files

85
spa/plugins/audiomixer/audiomixer.c
View file

@ -27,6 +27,7 @@
#include <stdio.h>
#include <spa/support/log.h>
#include <spa/support/cpu.h>
#include <spa/utils/list.h>
#include <spa/utils/names.h>
#include <spa/node/node.h>
@ -96,8 +97,10 @@ struct impl {
struct spa_node node;
struct spa_log *log;
struct spa_cpu *cpu;
uint32_t cpu_flags;
struct spa_audiomixer_ops ops;
struct mix_ops ops;
uint64_t info_all;
struct spa_node_info info;
@ -115,12 +118,6 @@ struct impl {
struct spa_audio_info format;
uint32_t bpf;
mix_clear_func_t clear;
mix_func_t copy;
mix_func_t add;
mix_scale_func_t copy_scale;
mix_scale_func_t add_scale;
bool started;
};
@ -481,24 +478,12 @@ static int port_set_format(void *object,
if (memcmp(&info, &this->format, sizeof(struct spa_audio_info)))
return -EINVAL;
} else {
if (info.info.raw.format == SPA_AUDIO_FORMAT_S16) {
this->clear = this->ops.clear[FMT_S16];
this->copy = this->ops.copy[FMT_S16];
this->add = this->ops.add[FMT_S16];
this->copy_scale = this->ops.copy_scale[FMT_S16];
this->add_scale = this->ops.add_scale[FMT_S16];
this->bpf = sizeof(int16_t) * info.info.raw.channels;
}
else if (info.info.raw.format == SPA_AUDIO_FORMAT_F32) {
this->clear = this->ops.clear[FMT_F32];
this->copy = this->ops.copy[FMT_F32];
this->add = this->ops.add[FMT_F32];
this->copy_scale = this->ops.copy_scale[FMT_F32];
this->add_scale = this->ops.add_scale[FMT_F32];
this->bpf = sizeof(float) * info.info.raw.channels;
}
else
return -EINVAL;
this->ops.fmt = info.info.raw.format;
this->ops.n_channels = info.info.raw.channels;
this->ops.cpu_flags = this->cpu_flags;
if ((res = mix_ops_init(&this->ops)) < 0)
return res;
this->have_format = true;
this->format = info;
@ -651,6 +636,8 @@ add_port_data(struct impl *this, void *out, size_t outsize, struct port *port, i
void *data;
double volume = *port->io_volume;
bool mute = *port->io_mute;
const void *s0[2], *s1[2];
uint32_t n_src;
b = spa_list_first(&port->queue, struct buffer, link);
@ -668,29 +655,24 @@ add_port_data(struct impl *this, void *out, size_t outsize, struct port *port, i
len1 = SPA_MIN(outsize, maxsize - offset);
len2 = outsize - len1;
if (volume < 0.001 || mute) {
/* silence, for the first layer clear, otherwise do nothing */
if (layer == 0) {
this->clear(out, len1);
if (len2 > 0)
this->clear(SPA_MEMBER(out, len1, void), len2);
}
n_src = 0;
if (layer > 0) {
s0[n_src] = out;
s1[n_src] = SPA_MEMBER(out, len1, void);
n_src++;
}
else if (volume < 0.999 || volume > 1.001) {
mix_scale_func_t mix = layer == 0 ? this->copy_scale : this->add_scale;
s0[n_src] = SPA_MEMBER(data, offset, void);
s1[n_src] = data;
n_src++;
mix(out, SPA_MEMBER(data, offset, void), volume, len1);
if (len2 > 0)
mix(SPA_MEMBER(out, len1, void), data, volume, len2);
if (volume < 0.001 || mute) {
/* silence, do nothing */
}
else {
mix_func_t mix = layer == 0 ? this->copy : this->add;
mix(out, SPA_MEMBER(data, offset, void), len1);
mix_ops_process(&this->ops, out, s0, n_src, len1);
if (len2 > 0)
mix(SPA_MEMBER(out, len1, void), data, len2);
mix_ops_process(&this->ops, SPA_MEMBER(out, len1, void), s1, n_src, len2);
}
port->queued_bytes -= outsize;
if (port->queued_bytes == 0) {
@ -863,6 +845,13 @@ static int impl_get_interface(struct spa_handle *handle, uint32_t type, void **i
static int impl_clear(struct spa_handle *handle)
{
struct impl *this;
spa_return_val_if_fail(handle != NULL, -EINVAL);
this = (struct impl *) handle;
mix_ops_free(&this->ops);
return 0;
}
@ -893,9 +882,17 @@ impl_init(const struct spa_handle_factory *factory,
this = (struct impl *) handle;
for (i = 0; i < n_support; i++) {
if (support[i].type == SPA_TYPE_INTERFACE_Log)
switch (support[i].type) {
case SPA_TYPE_INTERFACE_Log:
this->log = support[i].data;
break;
case SPA_TYPE_INTERFACE_CPU:
this->cpu = support[i].data;
break;
}
}
if (this->cpu)
this->cpu_flags = spa_cpu_get_flags(this->cpu);
spa_hook_list_init(&this->hooks);
@ -929,8 +926,6 @@ impl_init(const struct spa_handle_factory *factory,
spa_list_init(&port->queue);
spa_audiomixer_get_ops(&this->ops);
return 0;
}

41
spa/plugins/audiomixer/meson.build
View file

@ -1,7 +1,46 @@
audiomixer_sources = ['audiomixer.c', 'mix-ops.c', 'plugin.c']
audiomixer_sources = [
'audiomixer.c',
'mix-ops.c',
'mixer-dsp.c',
'plugin.c']
simd_cargs = []
simd_dependencies = []
audiomixer_c = static_library('audiomixer_c',
['mix-ops-c.c' ],
c_args : ['-O3'],
include_directories : [spa_inc],
install : false
)
simd_dependencies += audiomixer_c
if have_sse
audiomixer_sse = static_library('audiomixer_sse',
['mix-ops-sse.c' ],
c_args : [sse_args, '-O3', '-DHAVE_SSE'],
include_directories : [spa_inc],
install : false
)
simd_cargs += ['-DHAVE_SSE']
simd_dependencies += audiomixer_sse
endif
if have_sse2
audiomixer_sse2 = static_library('audiomixer_sse2',
['mix-ops-sse2.c' ],
c_args : [sse2_args, '-O3', '-DHAVE_SSE2'],
include_directories : [spa_inc],
install : false
)
simd_cargs += ['-DHAVE_SSE2']
simd_dependencies += audiomixer_sse2
endif
audiomixerlib = shared_library('spa-audiomixer',
audiomixer_sources,
c_args : simd_cargs,
link_with : simd_dependencies,
include_directories : [spa_inc],
dependencies : [ mathlib ],
install : true,
install_dir : '@0@/spa/audiomixer/'.format(get_option('libdir')))

69
spa/plugins/audiomixer/mix-ops-c.c Normal file
View file

@ -0,0 +1,69 @@
/* Spa
*
* Copyright © 2019 Wim Taymans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#include <string.h>
#include <stdio.h>
#include <math.h>
#include <spa/utils/defs.h>
#include "mix-ops.h"
void
mix_f32_c(struct mix_ops *ops, void * SPA_RESTRICT dst, const void * SPA_RESTRICT src[],
uint32_t n_src, uint32_t n_samples)
{
uint32_t i, n;
float *d = dst;
if (n_src == 0)
memset(dst, 0, n_samples * sizeof(float));
else if (dst != src[0])
memcpy(dst, src[0], n_samples * sizeof(float));
for (i = 1; i < n_src; i++) {
const float *s = src[i];
for (n = 0; n < n_samples; n++)
d[n] += s[n];
}
}
void
mix_f64_c(struct mix_ops *ops, void * SPA_RESTRICT dst, const void * SPA_RESTRICT src[],
uint32_t n_src, uint32_t n_samples)
{
uint32_t i, n;
double *d = dst;
if (n_src == 0)
memset(dst, 0, n_samples * sizeof(double));
else if (dst != src[0])
memcpy(dst, src[0], n_samples * sizeof(double));
for (i = 1; i < n_src; i++) {
const double *s = src[i];
for (n = 0; n < n_samples; n++)
d[n] += s[n];
}
}

89
spa/plugins/audiomixer/mix-ops-sse.c Normal file
View file

@ -0,0 +1,89 @@
/* Spa
*
* Copyright © 2019 Wim Taymans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#include <string.h>
#include <stdio.h>
#include <math.h>
#include <spa/utils/defs.h>
#include "mix-ops.h"
#include <xmmintrin.h>
static inline void mix_2(float * dst, const float * SPA_RESTRICT src, uint32_t n_samples)
{
uint32_t n, unrolled;
__m128 in1[4], in2[4];
if (SPA_IS_ALIGNED(src, 16) &&
SPA_IS_ALIGNED(dst, 16))
unrolled = n_samples & ~15;
else
unrolled = 0;
for (n = 0; n < unrolled; n += 16) {
in1[0] = _mm_load_ps(&dst[n+ 0]);
in1[1] = _mm_load_ps(&dst[n+ 4]);
in1[2] = _mm_load_ps(&dst[n+ 8]);
in1[3] = _mm_load_ps(&dst[n+12]);
in2[0] = _mm_load_ps(&src[n+ 0]);
in2[1] = _mm_load_ps(&src[n+ 4]);
in2[2] = _mm_load_ps(&src[n+ 8]);
in2[3] = _mm_load_ps(&src[n+12]);
in1[0] = _mm_add_ps(in1[0], in2[0]);
in1[1] = _mm_add_ps(in1[1], in2[1]);
in1[2] = _mm_add_ps(in1[2], in2[2]);
in1[3] = _mm_add_ps(in1[3], in2[3]);
_mm_store_ps(&dst[n+ 0], in1[0]);
_mm_store_ps(&dst[n+ 4], in1[1]);
_mm_store_ps(&dst[n+ 8], in1[2]);
_mm_store_ps(&dst[n+12], in1[3]);
}
for (; n < n_samples; n++) {
in1[0] = _mm_load_ss(&dst[n]),
in2[0] = _mm_load_ss(&src[n]),
in1[0] = _mm_add_ss(in1[0], in2[0]);
_mm_store_ss(&dst[n], in1[0]);
}
}
void
mix_f32_sse(struct mix_ops *ops, void * SPA_RESTRICT dst, const void * SPA_RESTRICT src[],
uint32_t n_src, uint32_t n_samples)
{
uint32_t i;
if (n_src == 0)
memset(dst, 0, n_samples * sizeof(float));
else if (dst != src[0])
memcpy(dst, src[0], n_samples * sizeof(float));
for (i = 1; i < n_src; i++) {
mix_2(dst, src[i], n_samples);
}
}

89
spa/plugins/audiomixer/mix-ops-sse2.c Normal file
View file

@ -0,0 +1,89 @@
/* Spa
*
* Copyright © 2019 Wim Taymans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#include <string.h>
#include <stdio.h>
#include <math.h>
#include <spa/utils/defs.h>
#include "mix-ops.h"
#include <emmintrin.h>
static inline void mix_2(double * dst, const double * SPA_RESTRICT src, uint32_t n_samples)
{
uint32_t n, unrolled;
__m128d in1[4], in2[4];
if (SPA_IS_ALIGNED(src, 16) &&
SPA_IS_ALIGNED(dst, 16))
unrolled = n_samples & ~7;
else
unrolled = 0;
for (n = 0; n < unrolled; n += 8) {
in1[0] = _mm_load_pd(&dst[n+ 0]);
in1[1] = _mm_load_pd(&dst[n+ 2]);
in1[2] = _mm_load_pd(&dst[n+ 4]);
in1[3] = _mm_load_pd(&dst[n+ 6]);
in2[0] = _mm_load_pd(&src[n+ 0]);
in2[1] = _mm_load_pd(&src[n+ 2]);
in2[2] = _mm_load_pd(&src[n+ 4]);
in2[3] = _mm_load_pd(&src[n+ 6]);
in1[0] = _mm_add_pd(in1[0], in2[0]);
in1[1] = _mm_add_pd(in1[1], in2[1]);
in1[2] = _mm_add_pd(in1[2], in2[2]);
in1[3] = _mm_add_pd(in1[3], in2[3]);
_mm_store_pd(&dst[n+ 0], in1[0]);
_mm_store_pd(&dst[n+ 2], in1[1]);
_mm_store_pd(&dst[n+ 4], in1[2]);
_mm_store_pd(&dst[n+ 6], in1[3]);
}
for (; n < n_samples; n++) {
in1[0] = _mm_load_sd(&dst[n]),
in2[0] = _mm_load_sd(&src[n]),
in1[0] = _mm_add_sd(in1[0], in2[0]);
_mm_store_sd(&dst[n], in1[0]);
}
}
void
mix_f64_sse2(struct mix_ops *ops, void * SPA_RESTRICT dst, const void * SPA_RESTRICT src[],
uint32_t n_src, uint32_t n_samples)
{
uint32_t i;
if (n_src == 0)
memset(dst, 0, n_samples * sizeof(double));
else if (dst != src[0])
memcpy(dst, src[0], n_samples * sizeof(double));
for (i = 1; i < n_src; i++) {
mix_2(dst, src[i], n_samples);
}
}

304
spa/plugins/audiomixer/mix-ops.c
View file

@ -1,6 +1,6 @@
/* Spa
*
* Copyright © 2018 Wim Taymans
* Copyright © 2019 Wim Taymans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
@ -22,262 +22,86 @@
* DEALINGS IN THE SOFTWARE.
*/
#include <string.h>
#include <stdio.h>
#include <math.h>
#include <spa/support/cpu.h>
#include <spa/utils/defs.h>
#include <spa/param/audio/format-utils.h>
#include "mix-ops.h"
static void
clear_s16(void *dst, int n_bytes)
{
memset(dst, 0, n_bytes);
}
typedef void (*mix_func_t) (struct mix_ops *ops, void * SPA_RESTRICT dst,
const void * SPA_RESTRICT src[], uint32_t n_src, uint32_t n_samples);
static void
clear_f32(void *dst, int n_bytes)
{
memset(dst, 0, n_bytes);
}
struct mix_info {
uint32_t fmt;
uint32_t n_channels;
uint32_t cpu_flags;
uint32_t stride;
mix_func_t process;
};
static void
copy_s16(void *dst, const void *src, int n_bytes)
static struct mix_info mix_table[] =
{
memcpy(dst, src, n_bytes);
}
/* f32 */
#if defined (HAVE_SSE)
{ SPA_AUDIO_FORMAT_F32, 1, SPA_CPU_FLAG_SSE, 4, mix_f32_sse },
{ SPA_AUDIO_FORMAT_F32P, 1, SPA_CPU_FLAG_SSE, 4, mix_f32_sse },
#endif
{ SPA_AUDIO_FORMAT_F32, 1, 0, 4, mix_f32_c },
{ SPA_AUDIO_FORMAT_F32P, 1, 0, 4, mix_f32_c },
static void
copy_f32(void *dst, const void *src, int n_bytes)
#if defined (HAVE_SSE2)
{ SPA_AUDIO_FORMAT_F64, 1, SPA_CPU_FLAG_SSE2, 8, mix_f64_sse2 },
{ SPA_AUDIO_FORMAT_F64P, 1, SPA_CPU_FLAG_SSE2, 8, mix_f64_sse2 },
#endif
{ SPA_AUDIO_FORMAT_F64, 1, 0, 8, mix_f64_c },
{ SPA_AUDIO_FORMAT_F64P, 1, 0, 8, mix_f64_c },
};
#define MATCH_CHAN(a,b) ((a) == 0 || (a) == (b))
#define MATCH_CPU_FLAGS(a,b) ((a) == 0 || ((a) & (b)) == a)
static const struct mix_info *find_mix_info(uint32_t fmt,
uint32_t n_channels, uint32_t cpu_flags)
{
memcpy(dst, src, n_bytes);
}
size_t i;
static void
add_s16(void *dst, const void *src, int n_bytes)
{
const int16_t *s = src;
int16_t *d = dst;
int32_t t;
n_bytes /= sizeof(int16_t);
while (n_bytes--) {
t = *d + *s;
*d = SPA_CLAMP(t, INT16_MIN, INT16_MAX);
d++;
s++;
for (i = 0; i < SPA_N_ELEMENTS(mix_table); i++) {
if (mix_table[i].fmt == fmt &&
MATCH_CHAN(mix_table[i].n_channels, n_channels) &&
MATCH_CPU_FLAGS(mix_table[i].cpu_flags, cpu_flags))
return &mix_table[i];
}
return NULL;
}
static void
add_f32(void *dst, const void *src, int n_bytes)
static void impl_mix_ops_clear(struct mix_ops *ops, void * SPA_RESTRICT dst, uint32_t n_samples)
{
const float *s = src;
float *d = dst;
n_bytes /= sizeof(float);
while (n_bytes--) {
*d += *s;
d++;
s++;
}
const struct mix_info *info = ops->priv;
memset(dst, 0, n_samples * info->stride);
}
static void
copy_scale_s16(void *dst, const void *src, const double scale, int n_bytes)
static void impl_mix_ops_free(struct mix_ops *ops)
{
const int16_t *s = src;
int16_t *d = dst;;
int32_t v = scale * (1 << 11), t;
n_bytes /= sizeof(int16_t);
while (n_bytes--) {
t = (*s * v) >> 11;
*d = SPA_CLAMP(t, INT16_MIN, INT16_MAX);
d++;
s++;
}
spa_zero(*ops);
}
static void
copy_scale_f32(void *dst, const void *src, const double scale, int n_bytes)
int mix_ops_init(struct mix_ops *ops)
{
const float *s = src;
float *d = dst;
float v = scale;
const struct mix_info *info;
n_bytes /= sizeof(float);
while (n_bytes--) {
*d = *s * v;
d++;
s++;
}
}
static void
add_scale_s16(void *dst, const void *src, const double scale, int n_bytes)
{
const int16_t *s = src;
int16_t *d = dst;
int32_t v = scale * (1 << 11), t;
n_bytes /= sizeof(int16_t);
while (n_bytes--) {
t = *d + ((*s * v) >> 11);
*d = SPA_CLAMP(t, INT16_MIN, INT16_MAX);
d++;
s++;
}
}
static void
add_scale_f32(void *dst, const void *src, const double scale, int n_bytes)
{
const float *s = src;
float *d = dst;
float v = scale;
n_bytes /= sizeof(float);
while (n_bytes--) {
*d += *s * v;
d++;
s++;
}
}
static void
copy_s16_i(void *dst, int dst_stride, const void *src, int src_stride, int n_bytes)
{
const int16_t *s = src;
int16_t *d = dst;
n_bytes /= sizeof(int16_t);
while (n_bytes--) {
*d = *s;
d += dst_stride;
s += src_stride;
}
}
static void
copy_f32_i(void *dst, int dst_stride, const void *src, int src_stride, int n_bytes)
{
const float *s = src;
float *d = dst;
n_bytes /= sizeof(float);
while (n_bytes--) {
*d = *s;
d += dst_stride;
s += src_stride;
}
}
static void
add_s16_i(void *dst, int dst_stride, const void *src, int src_stride, int n_bytes)
{
const int16_t *s = src;
int16_t *d = dst;
int32_t t;
n_bytes /= sizeof(int16_t);
while (n_bytes--) {
t = *d + *s;
*d = SPA_CLAMP(t, INT16_MIN, INT16_MAX);
d += dst_stride;
s += src_stride;
}
}
static void
add_f32_i(void *dst, int dst_stride, const void *src, int src_stride, int n_bytes)
{
const float *s = src;
float *d = dst;
n_bytes /= sizeof(float);
while (n_bytes--) {
*d += *s;
d += dst_stride;
s += src_stride;
}
}
static void
copy_scale_s16_i(void *dst, int dst_stride, const void *src, int src_stride, const double scale, int n_bytes)
{
const int16_t *s = src;
int16_t *d = dst;
int32_t v = scale * (1 << 11), t;
n_bytes /= sizeof(int16_t);
while (n_bytes--) {
t = (*s * v) >> 11;
*d = SPA_CLAMP(t, INT16_MIN, INT16_MAX);
d += dst_stride;
s += src_stride;
}
}
static void
copy_scale_f32_i(void *dst, int dst_stride, const void *src, int src_stride, const double scale, int n_bytes)
{
const float *s = src;
float *d = dst;
float v = scale;
n_bytes /= sizeof(float);
while (n_bytes--) {
*d = *s * v;
d += dst_stride;
s += src_stride;
}
}
static void
add_scale_s16_i(void *dst, int dst_stride, const void *src, int src_stride, const double scale, int n_bytes)
{
const int16_t *s = src;
int16_t *d = dst;
int32_t v = scale * (1 << 11), t;
n_bytes /= sizeof(int16_t);
while (n_bytes--) {
t = *d + ((*s * v) >> 11);
*d = SPA_CLAMP(t, INT16_MIN, INT16_MAX);
d += dst_stride;
s += src_stride;
}
}
static void
add_scale_f32_i(void *dst, int dst_stride, const void *src, int src_stride, const double scale, int n_bytes)
{
const float *s = src;
float *d = dst;
float v = scale;
n_bytes /= sizeof(float);
while (n_bytes--) {
*d += *s * v;
d += dst_stride;
s += src_stride;
}
}
void spa_audiomixer_get_ops(struct spa_audiomixer_ops *ops)
{
ops->clear[FMT_S16] = clear_s16;
ops->clear[FMT_F32] = clear_f32;
ops->copy[FMT_S16] = copy_s16;
ops->copy[FMT_F32] = copy_f32;
ops->add[FMT_S16] = add_s16;
ops->add[FMT_F32] = add_f32;
ops->copy_scale[FMT_S16] = copy_scale_s16;
ops->copy_scale[FMT_F32] = copy_scale_f32;
ops->add_scale[FMT_S16] = add_scale_s16;
ops->add_scale[FMT_F32] = add_scale_f32;
ops->copy_i[FMT_S16] = copy_s16_i;
ops->copy_i[FMT_F32] = copy_f32_i;
ops->add_i[FMT_S16] = add_s16_i;
ops->add_i[FMT_F32] = add_f32_i;
ops->copy_scale_i[FMT_S16] = copy_scale_s16_i;
ops->copy_scale_i[FMT_F32] = copy_scale_f32_i;
ops->add_scale_i[FMT_S16] = add_scale_s16_i;
ops->add_scale_i[FMT_F32] = add_scale_f32_i;
info = find_mix_info(ops->fmt, ops->n_channels, ops->cpu_flags);
if (info == NULL)
return -ENOTSUP;
ops->priv = info;
ops->cpu_flags = info->cpu_flags;
ops->clear = impl_mix_ops_clear;
ops->process = info->process;
ops->free = impl_mix_ops_free;
return 0;
}

59
spa/plugins/audiomixer/mix-ops.h
View file

@ -1,6 +1,6 @@
/* Spa
*
* Copyright © 2018 Wim Taymans
* Copyright © 2019 Wim Taymans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
@ -22,35 +22,40 @@
* DEALINGS IN THE SOFTWARE.
*/
#include <string.h>
#include <stdio.h>
#include <spa/utils/defs.h>
typedef void (*mix_clear_func_t) (void *dst, int n_bytes);
typedef void (*mix_func_t) (void *dst, const void *src, int n_bytes);
typedef void (*mix_scale_func_t) (void *dst, const void *src, const double scale, int n_bytes);
typedef void (*mix_i_func_t) (void *dst, int dst_stride,
const void *src, int src_stride, int n_bytes);
typedef void (*mix_scale_i_func_t) (void *dst, int dst_stride,
const void *src, int src_stride, const double scale, int n_bytes);
struct mix_ops {
uint32_t fmt;
uint32_t n_channels;
uint32_t cpu_flags;
enum {
FMT_S16,
FMT_F32,
FMT_MAX,
void (*clear) (struct mix_ops *ops, void * SPA_RESTRICT dst, uint32_t n_samples);
void (*process) (struct mix_ops *ops,
void * SPA_RESTRICT dst,
const void * SPA_RESTRICT src[], uint32_t n_src,
uint32_t n_samples);
void (*free) (struct mix_ops *ops);
const void *priv;
};
struct spa_audiomixer_ops {
mix_clear_func_t clear[FMT_MAX];
mix_func_t copy[FMT_MAX];
mix_func_t add[FMT_MAX];
mix_scale_func_t copy_scale[FMT_MAX];
mix_scale_func_t add_scale[FMT_MAX];
mix_i_func_t copy_i[FMT_MAX];
mix_i_func_t add_i[FMT_MAX];
mix_scale_i_func_t copy_scale_i[FMT_MAX];
mix_scale_i_func_t add_scale_i[FMT_MAX];
};
int mix_ops_init(struct mix_ops *ops);
void spa_audiomixer_get_ops(struct spa_audiomixer_ops *ops);
#define mix_ops_clear(ops,...) (ops)->clear(ops, __VA_ARGS__)
#define mix_ops_process(ops,...) (ops)->process(ops, __VA_ARGS__)
#define mix_ops_free(ops) (ops)->free(ops)
#define DEFINE_FUNCTION(name,arch) \
void mix_##name##_##arch(struct mix_ops *ops, void * SPA_RESTRICT dst, \
const void * SPA_RESTRICT src[], uint32_t n_src, \
uint32_t n_samples) \
DEFINE_FUNCTION(f32, c);
DEFINE_FUNCTION(f64, c);
#if defined(HAVE_SSE)
DEFINE_FUNCTION(f32, sse);
#endif
#if defined(HAVE_SSE2)
DEFINE_FUNCTION(f64, sse2);
#endif

888
spa/plugins/audiomixer/mixer-dsp.c Normal file
View file

@ -0,0 +1,888 @@
/* Spa
*
* Copyright © 2018 Wim Taymans
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <spa/support/log.h>
#include <spa/support/cpu.h>
#include <spa/utils/list.h>
#include <spa/utils/names.h>
#include <spa/node/node.h>
#include <spa/node/utils.h>
#include <spa/node/io.h>
#include <spa/param/audio/format-utils.h>
#include <spa/param/param.h>
#include <spa/pod/filter.h>
#include "mix-ops.h"
#define NAME "mixer-dsp"
#define MAX_BUFFERS 64
#define MAX_PORTS 128
#define MAX_SAMPLES 1024
#define PORT_DEFAULT_VOLUME 1.0
#define PORT_DEFAULT_MUTE false
struct port_props {
double volume;
int32_t mute;
};
static void port_props_reset(struct port_props *props)
{
props->volume = PORT_DEFAULT_VOLUME;
props->mute = PORT_DEFAULT_MUTE;
}
struct buffer {
uint32_t id;
#define BUFFER_FLAG_QUEUED (1 << 0)
uint32_t flags;
struct spa_list link;
struct spa_buffer *buffer;
struct spa_meta_header *h;
struct spa_buffer buf;
struct spa_data datas[1];
struct spa_chunk chunk[1];
};
struct port {
uint32_t direction;
uint32_t id;
struct port_props props;
struct spa_io_buffers *io;
uint64_t info_all;
struct spa_port_info info;
struct spa_param_info params[8];
unsigned int valid:1;
unsigned int have_format:1;
struct buffer buffers[MAX_BUFFERS];
uint32_t n_buffers;
struct spa_list queue;
size_t queued_bytes;
};
struct impl {
struct spa_handle handle;
struct spa_node node;
struct spa_log *log;
struct spa_cpu *cpu;
uint32_t cpu_flags;
struct mix_ops ops;
uint64_t info_all;
struct spa_node_info info;
struct spa_param_info params[8];
struct spa_hook_list hooks;
uint32_t port_count;
uint32_t last_port;
struct port in_ports[MAX_PORTS];
struct port out_ports[1];
bool have_format;
int n_formats;
struct spa_audio_info format;
uint32_t stride;
bool started;
float empty[MAX_SAMPLES + 15];
};
#define CHECK_FREE_IN_PORT(this,d,p) ((d) == SPA_DIRECTION_INPUT && (p) < MAX_PORTS && !this->in_ports[(p)].valid)
#define CHECK_IN_PORT(this,d,p) ((d) == SPA_DIRECTION_INPUT && (p) < MAX_PORTS && this->in_ports[(p)].valid)
#define CHECK_OUT_PORT(this,d,p) ((d) == SPA_DIRECTION_OUTPUT && (p) == 0)
#define CHECK_PORT(this,d,p) (CHECK_OUT_PORT(this,d,p) || CHECK_IN_PORT (this,d,p))
#define GET_IN_PORT(this,p) (&this->in_ports[p])
#define GET_OUT_PORT(this,p) (&this->out_ports[p])
#define GET_PORT(this,d,p) (d == SPA_DIRECTION_INPUT ? GET_IN_PORT(this,p) : GET_OUT_PORT(this,p))
static int impl_node_enum_params(void *object, int seq,
uint32_t id, uint32_t start, uint32_t num,
const struct spa_pod *filter)
{
return -ENOTSUP;
}
static int impl_node_set_param(void *object, uint32_t id, uint32_t flags,
const struct spa_pod *param)
{
return -ENOTSUP;
}
static int impl_node_set_io(void *object, uint32_t id, void *data, size_t size)
{
return -ENOTSUP;
}
static int impl_node_send_command(void *object, const struct spa_command *command)
{
struct impl *this = object;
spa_return_val_if_fail(this != NULL, -EINVAL);
spa_return_val_if_fail(command != NULL, -EINVAL);
switch (SPA_NODE_COMMAND_ID(command)) {
case SPA_NODE_COMMAND_Start:
this->started = true;
break;
case SPA_NODE_COMMAND_Pause:
this->started = false;
break;
default:
return -ENOTSUP;
}
return 0;
}
static void emit_node_info(struct impl *this, bool full)
{
if (full)
this->info.change_mask = this->info_all;
if (this->info.change_mask) {
spa_node_emit_info(&this->hooks, &this->info);
this->info.change_mask = 0;
}
}
static void emit_port_info(struct impl *this, struct port *port, bool full)
{
if (full)
port->info.change_mask = port->info_all;
if (port->info.change_mask) {
spa_node_emit_port_info(&this->hooks,
port->direction, port->id, &port->info);
port->info.change_mask = 0;
}
}
static int impl_node_add_listener(void *object,
struct spa_hook *listener,
const struct spa_node_events *events,
void *data)
{
struct impl *this = object;
struct spa_hook_list save;
uint32_t i;
spa_return_val_if_fail(this != NULL, -EINVAL);
spa_hook_list_isolate(&this->hooks, &save, listener, events, data);
emit_node_info(this, true);
emit_port_info(this, GET_OUT_PORT(this, 0), true);
for (i = 0; i < this->last_port; i++) {
if (this->in_ports[i].valid)
emit_port_info(this, GET_IN_PORT(this, i), true);
}
spa_hook_list_join(&this->hooks, &save);
return 0;
}
static int
impl_node_set_callbacks(void *object,
const struct spa_node_callbacks *callbacks,
void *user_data)
{
return 0;
}
static int impl_node_add_port(void *object, enum spa_direction direction, uint32_t port_id,
const struct spa_dict *props)
{
struct impl *this = object;
struct port *port;
spa_return_val_if_fail(this != NULL, -EINVAL);
spa_return_val_if_fail(CHECK_FREE_IN_PORT(this, direction, port_id), -EINVAL);
port = GET_IN_PORT (this, port_id);
port->direction = direction;
port->id = port_id;
port_props_reset(&port->props);
spa_list_init(&port->queue);
port->info_all = SPA_PORT_CHANGE_MASK_FLAGS |
SPA_PORT_CHANGE_MASK_PARAMS;
port->info = SPA_PORT_INFO_INIT();
port->info.flags = SPA_PORT_FLAG_NO_REF |
SPA_PORT_FLAG_DYNAMIC_DATA |
SPA_PORT_FLAG_REMOVABLE |
SPA_PORT_FLAG_OPTIONAL;
port->params[0] = SPA_PARAM_INFO(SPA_PARAM_EnumFormat, SPA_PARAM_INFO_READ);
port->params[1] = SPA_PARAM_INFO(SPA_PARAM_Meta, SPA_PARAM_INFO_READ);
port->params[2] = SPA_PARAM_INFO(SPA_PARAM_IO, SPA_PARAM_INFO_READ);
port->params[3] = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_WRITE);
port->params[4] = SPA_PARAM_INFO(SPA_PARAM_Buffers, 0);
port->info.params = port->params;
port->info.n_params = 5;
this->port_count++;
if (this->last_port <= port_id)
this->last_port = port_id + 1;
port->valid = true;
spa_log_debug(this->log, NAME " %p: add port %d %d", this, port_id, this->last_port);
emit_port_info(this, port, true);
return 0;
}
static int
impl_node_remove_port(void *object, enum spa_direction direction, uint32_t port_id)
{
struct impl *this = object;
struct port *port;
spa_return_val_if_fail(this != NULL, -EINVAL);
spa_return_val_if_fail(CHECK_IN_PORT(this, direction, port_id), -EINVAL);
port = GET_IN_PORT (this, port_id);
port->valid = false;
this->port_count--;
if (port->have_format && this->have_format) {
if (--this->n_formats == 0)
this->have_format = false;
}
spa_memzero(port, sizeof(struct port));
if (port_id == this->last_port - 1) {
int i;
for (i = this->last_port - 1; i >= 0; i--)
if (GET_IN_PORT (this, i)->valid)
break;
this->last_port = i + 1;
}
spa_log_debug(this->log, NAME " %p: remove port %d %d", this, port_id, this->last_port);
spa_node_emit_port_info(&this->hooks, direction, port_id, NULL);
return 0;
}
static int port_enum_formats(void *object,
enum spa_direction direction, uint32_t port_id,
uint32_t index,
struct spa_pod **param,
struct spa_pod_builder *builder)
{
struct impl *this = object;
switch (index) {
case 0:
if (this->have_format) {
*param = spa_format_audio_raw_build(builder, SPA_PARAM_EnumFormat,
&this->format.info.raw);
} else {
*param = spa_pod_builder_add_object(builder,
SPA_TYPE_OBJECT_Format, SPA_PARAM_EnumFormat,
SPA_FORMAT_mediaType, SPA_POD_Id(SPA_MEDIA_TYPE_audio),
SPA_FORMAT_mediaSubtype, SPA_POD_Id(SPA_MEDIA_SUBTYPE_raw),
SPA_FORMAT_AUDIO_format, SPA_POD_Id(SPA_AUDIO_FORMAT_F32P),
SPA_FORMAT_AUDIO_rate, SPA_POD_CHOICE_RANGE_Int(44100, 1, INT32_MAX),
SPA_FORMAT_AUDIO_channels, SPA_POD_Int(1));
}
break;
default:
return 0;
}
return 1;
}
static int
impl_node_port_enum_params(void *object, int seq,
enum spa_direction direction, uint32_t port_id,
uint32_t id, uint32_t start, uint32_t num,
const struct spa_pod *filter)
{
struct impl *this = object;
struct port *port;
struct spa_pod *param;
struct spa_pod_builder b = { 0 };
uint8_t buffer[1024];
struct spa_result_node_params result;
uint32_t count = 0;
int res;
spa_return_val_if_fail(this != NULL, -EINVAL);
spa_return_val_if_fail(num != 0, -EINVAL);
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
port = GET_PORT(this, direction, port_id);
result.id = id;
result.next = start;
next:
result.index = result.next++;
spa_pod_builder_init(&b, buffer, sizeof(buffer));
switch (id) {
case SPA_PARAM_EnumFormat:
if ((res = port_enum_formats(this, direction, port_id, result.index, &param, &b)) <= 0)
return res;
break;
case SPA_PARAM_Format:
if (!port->have_format)
return -EIO;
if (result.index > 0)
return 0;
param = spa_format_audio_raw_build(&b, id, &this->format.info.raw);
break;
case SPA_PARAM_Buffers:
if (!port->have_format)
return -EIO;
if (result.index > 0)
return 0;
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamBuffers, id,
SPA_PARAM_BUFFERS_buffers, SPA_POD_CHOICE_RANGE_Int(1, 1, MAX_BUFFERS),
SPA_PARAM_BUFFERS_blocks, SPA_POD_Int(1),
SPA_PARAM_BUFFERS_size, SPA_POD_CHOICE_RANGE_Int(
1024 * this->stride,
16 * this->stride,
INT32_MAX / this->stride),
SPA_PARAM_BUFFERS_stride, SPA_POD_Int(this->stride),
SPA_PARAM_BUFFERS_align, SPA_POD_Int(16));
break;
case SPA_PARAM_Meta:
switch (result.index) {
case 0:
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamMeta, id,
SPA_PARAM_META_type, SPA_POD_Id(SPA_META_Header),
SPA_PARAM_META_size, SPA_POD_Int(sizeof(struct spa_meta_header)));
break;
default:
return 0;
}
break;
case SPA_PARAM_IO:
switch (result.index) {
case 0:
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamIO, id,
SPA_PARAM_IO_id, SPA_POD_Id(SPA_IO_Buffers),
SPA_PARAM_IO_size, SPA_POD_Int(sizeof(struct spa_io_buffers)));
break;
default:
return 0;
}
break;
default:
return -ENOENT;
}
if (spa_pod_filter(&b, &result.param, param, filter) < 0)
goto next;
spa_node_emit_result(&this->hooks, seq, 0, SPA_RESULT_TYPE_NODE_PARAMS, &result);
if (++count != num)
goto next;
return 0;
}
static int clear_buffers(struct impl *this, struct port *port)
{
if (port->n_buffers > 0) {
spa_log_debug(this->log, NAME " %p: clear buffers %p", this, port);
port->n_buffers = 0;
spa_list_init(&port->queue);
}
return 0;
}
static int queue_buffer(struct impl *this, struct port *port, struct buffer *b)
{
if (SPA_FLAG_IS_SET(b->flags, BUFFER_FLAG_QUEUED))
return -EINVAL;
spa_list_append(&port->queue, &b->link);
SPA_FLAG_SET(b->flags, BUFFER_FLAG_QUEUED);
spa_log_trace_fp(this->log, NAME " %p: queue buffer %d", this, b->id);
return 0;
}
static struct buffer *dequeue_buffer(struct impl *this, struct port *port)
{
struct buffer *b;
if (spa_list_is_empty(&port->queue))
return NULL;
b = spa_list_first(&port->queue, struct buffer, link);
spa_list_remove(&b->link);
SPA_FLAG_CLEAR(b->flags, BUFFER_FLAG_QUEUED);
spa_log_trace_fp(this->log, NAME " %p: dequeue buffer %d", this, b->id);
return b;
}
static int port_set_format(void *object,
enum spa_direction direction,
uint32_t port_id,
uint32_t flags,
const struct spa_pod *format)
{
struct impl *this = object;
struct port *port;
int res;
port = GET_PORT(this, direction, port_id);
if (format == NULL) {
if (port->have_format) {
port->have_format = false;
if (--this->n_formats == 0)
this->have_format = false;
clear_buffers(this, port);
}
} else {
struct spa_audio_info info = { 0 };
if ((res = spa_format_parse(format, &info.media_type, &info.media_subtype)) < 0)
return res;
if (info.media_type != SPA_MEDIA_TYPE_audio ||
info.media_subtype != SPA_MEDIA_SUBTYPE_raw)
return -EINVAL;
if (spa_format_audio_raw_parse(format, &info.info.raw) < 0)
return -EINVAL;
if (info.info.raw.format != SPA_AUDIO_FORMAT_F32P)
return -EINVAL;
if (info.info.raw.channels != 1)
return -EINVAL;
if (this->have_format) {
if (info.info.raw.rate != this->format.info.raw.rate)
return -EINVAL;
} else {
this->ops.fmt = info.info.raw.format;
this->ops.n_channels = info.info.raw.channels;
this->ops.cpu_flags = this->cpu_flags;
if ((res = mix_ops_init(&this->ops)) < 0)
return res;
this->stride = sizeof(float);
this->have_format = true;
this->format = info;
}
if (!port->have_format) {
this->n_formats++;
port->have_format = true;
spa_log_debug(this->log, NAME " %p: set format on port %d:%d",
this, direction, port_id);
}
}
port->info.change_mask |= SPA_PORT_CHANGE_MASK_PARAMS;
if (port->have_format) {
port->params[3] = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_READWRITE);
port->params[4] = SPA_PARAM_INFO(SPA_PARAM_Buffers, SPA_PARAM_INFO_READ);
} else {
port->params[3] = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_WRITE);
port->params[4] = SPA_PARAM_INFO(SPA_PARAM_Buffers, 0);
}
emit_port_info(this, port, false);
return 0;
}
static int
impl_node_port_set_param(void *object,
enum spa_direction direction, uint32_t port_id,
uint32_t id, uint32_t flags,
const struct spa_pod *param)
{
struct impl *this = object;
spa_return_val_if_fail(this != NULL, -EINVAL);
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
if (id == SPA_PARAM_Format) {
return port_set_format(this, direction, port_id, flags, param);
}
else
return -ENOENT;
}
static int
impl_node_port_use_buffers(void *object,
enum spa_direction direction,
uint32_t port_id,
uint32_t flags,
struct spa_buffer **buffers,
uint32_t n_buffers)
{
struct impl *this = object;
struct port *port;
uint32_t i;
spa_return_val_if_fail(this != NULL, -EINVAL);
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
port = GET_PORT(this, direction, port_id);
spa_log_debug(this->log, NAME " %p: use buffers %d on port %d:%d",
this, n_buffers, direction, port_id);
spa_return_val_if_fail(port->have_format, -EIO);
clear_buffers(this, port);
for (i = 0; i < n_buffers; i++) {
struct buffer *b;
struct spa_data *d = buffers[i]->datas;
b = &port->buffers[i];
b->buffer = buffers[i];
b->flags = 0;
b->id = i;
b->h = spa_buffer_find_meta_data(buffers[i], SPA_META_Header, sizeof(*b->h));
if (!((d[0].type == SPA_DATA_MemPtr ||
d[0].type == SPA_DATA_MemFd ||
d[0].type == SPA_DATA_DmaBuf) && d[0].data != NULL)) {
spa_log_error(this->log, NAME " %p: invalid memory on buffer %d", this, i);
return -EINVAL;
}
if (!SPA_IS_ALIGNED(d[0].data, 16)) {
spa_log_warn(this->log, NAME " %p: memory on buffer %d not aligned", this, i);
}
if (direction == SPA_DIRECTION_OUTPUT)
queue_buffer(this, port, b);
}
port->n_buffers = n_buffers;
return 0;
}
static int
impl_node_port_set_io(void *object,
enum spa_direction direction, uint32_t port_id,
uint32_t id, void *data, size_t size)
{
struct impl *this = object;
struct port *port;
spa_return_val_if_fail(this != NULL, -EINVAL);
spa_return_val_if_fail(CHECK_PORT(this, direction, port_id), -EINVAL);
port = GET_PORT(this, direction, port_id);
spa_log_debug(this->log, NAME " %p: port %d:%d io %d %p/%zd", this,
direction, port_id, id, data, size);
switch (id) {
case SPA_IO_Buffers:
port->io = data;
break;
default:
return -ENOENT;
}
return 0;
}
static int impl_node_port_reuse_buffer(void *object, uint32_t port_id, uint32_t buffer_id)
{
struct impl *this = object;
struct port *port;
spa_return_val_if_fail(this != NULL, -EINVAL);
spa_return_val_if_fail(CHECK_PORT(this, SPA_DIRECTION_OUTPUT, port_id), -EINVAL);
port = GET_OUT_PORT(this, 0);
if (buffer_id >= port->n_buffers)
return -EINVAL;
return queue_buffer(this, port, &port->buffers[buffer_id]);
}
static int impl_node_process(void *object)
{
struct impl *this = object;
struct port *outport;
struct spa_io_buffers *outio;
uint32_t n_samples, n_buffers, i, maxsize;
struct buffer **buffers;
struct buffer *outb;
const void **datas;
spa_return_val_if_fail(this != NULL, -EINVAL);
outport = GET_OUT_PORT(this, 0);
outio = outport->io;
spa_return_val_if_fail(outio != NULL, -EIO);
spa_log_trace_fp(this->log, NAME " %p: status %p %d %d",
this, outio, outio->status, outio->buffer_id);
if (outio->status == SPA_STATUS_HAVE_DATA)
return outio->status;
/* recycle */
if (outio->buffer_id < outport->n_buffers) {
queue_buffer(this, outport, &outport->buffers[outio->buffer_id]);
outio->buffer_id = SPA_ID_INVALID;
}
buffers = alloca(MAX_PORTS * sizeof(struct buffer *));
datas = alloca(MAX_PORTS * sizeof(void *));
n_buffers = 0;
maxsize = MAX_SAMPLES * sizeof(float);
for (i = 0; i < this->last_port; i++) {
struct port *inport = GET_IN_PORT(this, i);
struct spa_io_buffers *inio = NULL;
struct buffer *inb;
if (!inport->valid ||
(inio = inport->io) == NULL ||
inio->buffer_id >= inport->n_buffers ||
inio->status != SPA_STATUS_HAVE_DATA) {
spa_log_trace_fp(this->log, NAME " %p: skip input idx:%d valid:%d "
"io:%p status:%d buf_id:%d n_buffers:%d", this,
i, inport->valid, inio,
inio ? inio->status : -1,
inio ? inio->buffer_id : SPA_ID_INVALID,
inport->n_buffers);
continue;
}
spa_log_trace_fp(this->log, NAME " %p: mix input %d %p->%p %d %d", this,
i, inio, outio, inio->status, inio->buffer_id);
inb = &inport->buffers[inio->buffer_id];
maxsize = SPA_MIN(inb->buffer->datas[0].chunk->size, maxsize);
datas[n_buffers] = inb->buffer->datas[0].data;
buffers[n_buffers++] = inb;
inio->status = SPA_STATUS_NEED_DATA;
}
outb = dequeue_buffer(this, outport);
if (outb == NULL) {
spa_log_trace(this->log, NAME " %p: out of buffers", this);
return -EPIPE;
}
n_samples = maxsize / sizeof(float);
if (n_buffers == 1) {
*outb->buffer = *buffers[0]->buffer;
}
else {
outb->buffer->n_datas = 1;
outb->buffer->datas = outb->datas;
outb->datas[0].data = SPA_PTR_ALIGN(this->empty, 16, void);
outb->datas[0].chunk = outb->chunk;
outb->datas[0].chunk->offset = 0;
outb->datas[0].chunk->size = n_samples * sizeof(float);
outb->datas[0].chunk->stride = sizeof(float);
mix_ops_process(&this->ops, outb->datas[0].data, datas, n_buffers, n_samples);
}
outio->buffer_id = outb->id;
outio->status = SPA_STATUS_HAVE_DATA;
return SPA_STATUS_HAVE_DATA | SPA_STATUS_NEED_DATA;
}
static const struct spa_node_methods impl_node = {
SPA_VERSION_NODE_METHODS,
.add_listener = impl_node_add_listener,
.set_callbacks = impl_node_set_callbacks,
.enum_params = impl_node_enum_params,
.set_param = impl_node_set_param,
.set_io = impl_node_set_io,
.send_command = impl_node_send_command,
.add_port = impl_node_add_port,
.remove_port = impl_node_remove_port,
.port_enum_params = impl_node_port_enum_params,
.port_set_param = impl_node_port_set_param,
.port_use_buffers = impl_node_port_use_buffers,
.port_set_io = impl_node_port_set_io,
.port_reuse_buffer = impl_node_port_reuse_buffer,
.process = impl_node_process,
};
static int impl_get_interface(struct spa_handle *handle, uint32_t type, void **interface)
{
struct impl *this;
spa_return_val_if_fail(handle != NULL, -EINVAL);
spa_return_val_if_fail(interface != NULL, -EINVAL);
this = (struct impl *) handle;
if (type == SPA_TYPE_INTERFACE_Node)
*interface = &this->node;
else
return -ENOENT;
return 0;
}
static int impl_clear(struct spa_handle *handle)
{
return 0;
}
static size_t
impl_get_size(const struct spa_handle_factory *factory,
const struct spa_dict *params)
{
return sizeof(struct impl);
}
static int
impl_init(const struct spa_handle_factory *factory,
struct spa_handle *handle,
const struct spa_dict *info,
const struct spa_support *support,
uint32_t n_support)
{
struct impl *this;
struct port *port;
uint32_t i;
spa_return_val_if_fail(factory != NULL, -EINVAL);
spa_return_val_if_fail(handle != NULL, -EINVAL);
handle->get_interface = impl_get_interface;
handle->clear = impl_clear;
this = (struct impl *) handle;
for (i = 0; i < n_support; i++) {
switch (support[i].type) {
case SPA_TYPE_INTERFACE_Log:
this->log = support[i].data;
break;
case SPA_TYPE_INTERFACE_CPU:
this->cpu = support[i].data;
break;
}
}
if (this->cpu)
this->cpu_flags = spa_cpu_get_flags(this->cpu);
spa_hook_list_init(&this->hooks);
this->node.iface = SPA_INTERFACE_INIT(
SPA_TYPE_INTERFACE_Node,
SPA_VERSION_NODE,
&impl_node, this);
this->info = SPA_NODE_INFO_INIT();
this->info.max_input_ports = MAX_PORTS;
this->info.max_output_ports = 1;
this->info.change_mask |= SPA_NODE_CHANGE_MASK_FLAGS;
this->info.flags = SPA_NODE_FLAG_RT | SPA_NODE_FLAG_IN_DYNAMIC_PORTS;
port = GET_OUT_PORT(this, 0);
port->valid = true;
port->direction = SPA_DIRECTION_OUTPUT;
port->id = 0;
port->info = SPA_PORT_INFO_INIT();
port->info.change_mask |= SPA_PORT_CHANGE_MASK_FLAGS;
port->info.flags = SPA_PORT_FLAG_DYNAMIC_DATA;
port->info.change_mask |= SPA_PORT_CHANGE_MASK_PARAMS;
port->params[0] = SPA_PARAM_INFO(SPA_PARAM_EnumFormat, SPA_PARAM_INFO_READ);
port->params[1] = SPA_PARAM_INFO(SPA_PARAM_Meta, SPA_PARAM_INFO_READ);
port->params[2] = SPA_PARAM_INFO(SPA_PARAM_IO, SPA_PARAM_INFO_READ);
port->params[3] = SPA_PARAM_INFO(SPA_PARAM_Format, SPA_PARAM_INFO_WRITE);
port->params[4] = SPA_PARAM_INFO(SPA_PARAM_Buffers, 0);
port->info.params = port->params;
port->info.n_params = 5;
spa_list_init(&port->queue);
return 0;
}
static const struct spa_interface_info impl_interfaces[] = {
{SPA_TYPE_INTERFACE_Node,},
};
static int
impl_enum_interface_info(const struct spa_handle_factory *factory,
const struct spa_interface_info **info,
uint32_t *index)
{
spa_return_val_if_fail(factory != NULL, -EINVAL);
spa_return_val_if_fail(info != NULL, -EINVAL);
spa_return_val_if_fail(index != NULL, -EINVAL);
switch (*index) {
case 0:
*info = &impl_interfaces[*index];
break;
default:
return 0;
}
(*index)++;
return 1;
}
const struct spa_handle_factory spa_mixer_dsp_factory = {
SPA_VERSION_HANDLE_FACTORY,
SPA_NAME_AUDIO_MIXER_DSP,
NULL,
impl_get_size,
impl_init,
impl_enum_interface_info,
};

4
spa/plugins/audiomixer/plugin.c
View file

@ -27,6 +27,7 @@
#include <spa/support/plugin.h>
extern const struct spa_handle_factory spa_audiomixer_factory;
extern const struct spa_handle_factory spa_mixer_dsp_factory;
SPA_EXPORT
int spa_handle_factory_enum(const struct spa_handle_factory **factory, uint32_t *index)
@ -38,6 +39,9 @@ int spa_handle_factory_enum(const struct spa_handle_factory **factory, uint32_t
case 0:
*factory = &spa_audiomixer_factory;
break;
case 1:
*factory = &spa_mixer_dsp_factory;
break;
default:
return 0;
}