mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-02 09:01:50 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add volume and mute control support in audiomixer

Browse source
This commit is contained in:
Wim Taymans 2017-11-23 16:55:32 +01:00
parent 4b84e34744
commit cb3198c458
5 changed files with 212 additions and 81 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -29,16 +29,31 @@
#include <spa/param/audio/format-utils.h> #include <spa/param/audio/format-utils.h>
#include <spa/param/buffers.h> #include <spa/param/buffers.h>
#include <spa/param/meta.h> #include <spa/param/meta.h>
#include <spa/param/io.h>
#include <lib/pod.h> #include <lib/pod.h>
#include "conv.h" #include "mix-ops.h"
#define NAME "audiomixer" #define NAME "audiomixer"
#define MAX_BUFFERS 64 #define MAX_BUFFERS 64
#define MAX_PORTS 128 #define MAX_PORTS 128
#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 { struct buffer {
struct spa_list link; struct spa_list link;
bool outstanding; bool outstanding;
@ -51,8 +66,12 @@ struct buffer {
struct port { struct port {
bool valid; bool valid;
struct port_props props;
struct spa_io_buffers *io; struct spa_io_buffers *io;
struct spa_io_control_range *range; struct spa_io_control_range *io_range;
double *io_volume;
int32_t *io_mute;
struct spa_port_info info; struct spa_port_info info;
@ -68,6 +87,10 @@ struct port {
struct type { struct type {
uint32_t node; uint32_t node;
uint32_t format; uint32_t format;
uint32_t prop_volume;
uint32_t prop_mute;
uint32_t io_prop_volume;
uint32_t io_prop_mute;
struct spa_type_io io; struct spa_type_io io;
struct spa_type_param param; struct spa_type_param param;
struct spa_type_media_type media_type; struct spa_type_media_type media_type;
@ -79,12 +102,17 @@ struct type {
struct spa_type_data data; struct spa_type_data data;
struct spa_type_param_buffers param_buffers; struct spa_type_param_buffers param_buffers;
struct spa_type_param_meta param_meta; struct spa_type_param_meta param_meta;
struct spa_type_param_io param_io;
}; };
static inline void init_type(struct type *type, struct spa_type_map *map) static inline void init_type(struct type *type, struct spa_type_map *map)
{ {
type->node = spa_type_map_get_id(map, SPA_TYPE__Node); type->node = spa_type_map_get_id(map, SPA_TYPE__Node);
type->format = spa_type_map_get_id(map, SPA_TYPE__Format); type->format = spa_type_map_get_id(map, SPA_TYPE__Format);
type->prop_volume = spa_type_map_get_id(map, SPA_TYPE_PROPS__volume);
type->prop_mute = spa_type_map_get_id(map, SPA_TYPE_PROPS__mute);
type->io_prop_volume = spa_type_map_get_id(map, SPA_TYPE_IO_INPUT_PROP_BASE "volume");
type->io_prop_mute = spa_type_map_get_id(map, SPA_TYPE_IO_INPUT_PROP_BASE "mute");
spa_type_io_map(map, &type->io); spa_type_io_map(map, &type->io);
spa_type_param_map(map, &type->param); spa_type_param_map(map, &type->param);
spa_type_media_type_map(map, &type->media_type); spa_type_media_type_map(map, &type->media_type);
@ -96,6 +124,7 @@ static inline void init_type(struct type *type, struct spa_type_map *map)
spa_type_data_map(map, &type->data); spa_type_data_map(map, &type->data);
spa_type_param_buffers_map(map, &type->param_buffers); spa_type_param_buffers_map(map, &type->param_buffers);
spa_type_param_meta_map(map, &type->param_meta); spa_type_param_meta_map(map, &type->param_meta);
spa_type_param_io_map(map, &type->param_io);
} }
struct impl { struct impl {
@ -121,8 +150,11 @@ struct impl {
struct spa_audio_info format; struct spa_audio_info format;
uint32_t bpf; uint32_t bpf;
mix_clear_func_t clear;
mix_func_t copy; mix_func_t copy;
mix_func_t add; mix_func_t add;
mix_scale_func_t copy_scale;
mix_scale_func_t add_scale;
bool started; bool started;
}; };
@ -250,6 +282,11 @@ static int impl_node_add_port(struct spa_node *node, enum spa_direction directio
port = GET_IN_PORT (this, port_id); port = GET_IN_PORT (this, port_id);
port->valid = true; port->valid = true;
port_props_reset(&port->props);
port->io_volume = &port->props.volume;
port->io_mute = &port->props.mute;
spa_list_init(&port->queue); spa_list_init(&port->queue);
port->info.flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS | port->info.flags = SPA_PORT_INFO_FLAG_CAN_USE_BUFFERS |
SPA_PORT_INFO_FLAG_REMOVABLE | SPA_PORT_INFO_FLAG_REMOVABLE |
@ -411,7 +448,8 @@ impl_node_port_enum_params(struct spa_node *node,
uint32_t list[] = { t->param.idEnumFormat, uint32_t list[] = { t->param.idEnumFormat,
t->param.idFormat, t->param.idFormat,
t->param.idBuffers, t->param.idBuffers,
t->param.idMeta }; t->param.idMeta,
t->param.idIO };
if (*index < SPA_N_ELEMENTS(list)) if (*index < SPA_N_ELEMENTS(list))
param = spa_pod_builder_object(&b, id, t->param.List, param = spa_pod_builder_object(&b, id, t->param.List,
@ -458,6 +496,45 @@ impl_node_port_enum_params(struct spa_node *node,
return 0; return 0;
} }
} }
else if (id == t->param.idIO) {
struct port_props *p = &port->props;
switch (*index) {
case 0:
param = spa_pod_builder_object(&b,
id, t->param_io.IO,
":", t->param_io.id, "I", t->io.Buffers,
":", t->param_io.size, "i", sizeof(struct spa_io_buffers));
break;
case 1:
param = spa_pod_builder_object(&b,
id, t->param_io.IO,
":", t->param_io.id, "I", t->io.ControlRange,
":", t->param_io.size, "i", sizeof(struct spa_io_control_range));
break;
case 2:
if (direction == SPA_DIRECTION_OUTPUT)
return 0;
param = spa_pod_builder_object(&b,
id, t->param_io.IO,
":", t->param_io.id, "I", t->io_prop_volume,
":", t->param_io.size, "i", sizeof(struct spa_pod_double),
":", t->param_io.propId, "I", t->prop_volume,
":", t->param_io.propType, "dr", p->volume, 2, 0.0, 10.0);
break;
case 3:
param = spa_pod_builder_object(&b,
id, t->param_io.IO,
":", t->param_io.id, "I", t->io_prop_mute,
":", t->param_io.size, "i", sizeof(struct spa_pod_bool),
":", t->param_io.propId, "I", t->prop_mute,
":", t->param_io.propType, "b", p->mute);
break;
default:
return 0;
}
}
else else
return -ENOENT; return -ENOENT;
@ -517,13 +594,19 @@ static int port_set_format(struct spa_node *node,
return -EINVAL; return -EINVAL;
} else { } else {
if (info.info.raw.format == t->audio_format.S16) { if (info.info.raw.format == t->audio_format.S16) {
this->copy = this->ops.copy[CONV_S16_S16]; this->clear = this->ops.clear[FMT_S16];
this->add = this->ops.add[CONV_S16_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; this->bpf = sizeof(int16_t) * info.info.raw.channels;
} }
else if (info.info.raw.format == t->audio_format.F32) { else if (info.info.raw.format == t->audio_format.F32) {
this->copy = this->ops.copy[CONV_F32_F32]; this->clear = this->ops.clear[FMT_F32];
this->add = this->ops.add[CONV_F32_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; this->bpf = sizeof(float) * info.info.raw.channels;
} }
else else
@ -648,7 +731,17 @@ impl_node_port_set_io(struct spa_node *node,
if (id == t->io.Buffers) if (id == t->io.Buffers)
port->io = data; port->io = data;
else if (id == t->io.ControlRange) else if (id == t->io.ControlRange)
port->range = data; port->io_range = data;
else if (id == t->io_prop_volume && direction == SPA_DIRECTION_INPUT)
if (SPA_POD_TYPE(data) == SPA_POD_TYPE_DOUBLE)
port->io_volume = &SPA_POD_VALUE(struct spa_pod_double, data);
else
return -EINVAL;
else if (id == t->io_prop_mute && direction == SPA_DIRECTION_INPUT)
if (SPA_POD_TYPE(data) == SPA_POD_TYPE_BOOL)
port->io_mute = &SPA_POD_VALUE(struct spa_pod_bool, data);
else
return -EINVAL;
else else
return -ENOENT; return -ENOENT;
@ -695,14 +788,15 @@ impl_node_port_send_command(struct spa_node *node,
} }
static inline void static inline void
add_port_data(struct impl *this, void *out, size_t outsize, size_t next, struct port *port, int layer) add_port_data(struct impl *this, void *out, size_t outsize, struct port *port, int layer)
{ {
size_t insize; size_t insize;
struct buffer *b; struct buffer *b;
uint32_t index, offset, len1, len2, maxsize; uint32_t index, offset, len1, len2, maxsize;
mix_func_t mix = layer == 0 ? this->copy : this->add;
struct spa_data *d; struct spa_data *d;
void *data; void *data;
double volume = *port->io_volume;
bool mute = *port->io_mute;
b = spa_list_first(&port->queue, struct buffer, link); b = spa_list_first(&port->queue, struct buffer, link);
@ -718,9 +812,30 @@ add_port_data(struct impl *this, void *out, size_t outsize, size_t next, struct
offset = index % maxsize; offset = index % maxsize;
len1 = SPA_MIN(outsize, maxsize - offset); len1 = SPA_MIN(outsize, maxsize - offset);
mix(out, SPA_MEMBER(data, offset, void), len1); len2 = outsize - len1;
if ((len2 = outsize - len1) > 0)
mix(out + len1, data, len2); 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(out + len1, len2);
}
}
else if (volume < 0.999 || volume > 1.001) {
mix_func_t mix = layer == 0 ? this->copy : this->add;
mix(out, SPA_MEMBER(data, offset, void), len1);
if (len2 > 0)
mix(out + len1, data, len2);
}
else {
mix_scale_func_t mix = layer == 0 ? this->copy_scale : this->add_scale;
mix(out, SPA_MEMBER(data, offset, void), volume, len1);
if (len2 > 0)
mix(out + len1, data, volume, len2);
}
port->queued_bytes -= outsize; port->queued_bytes -= outsize;
@ -777,14 +892,14 @@ static int mix_output(struct impl *this, size_t n_bytes)
if (in_port->io == NULL || in_port->n_buffers == 0) if (in_port->io == NULL || in_port->n_buffers == 0)
continue; continue;
if (spa_list_is_empty(&in_port->queue)) { if (in_port->queued_bytes == 0) {
spa_log_warn(this->log, NAME " %p: underrun stream %d", this, i); spa_log_warn(this->log, NAME " %p: underrun stream %d", this, i);
in_port->queued_bytes = 0;
continue; continue;
} }
add_port_data(this, SPA_MEMBER(od[0].data, offset, void), len1, len2, in_port, layer);
add_port_data(this, SPA_MEMBER(od[0].data, offset, void), len1, in_port, layer);
if (len2 > 0) if (len2 > 0)
add_port_data(this, od[0].data, len2, 0, in_port, layer); add_port_data(this, od[0].data, len2, in_port, layer);
layer++; layer++;
} }
@ -905,8 +1020,8 @@ static int impl_node_process_output(struct spa_node *node)
continue; continue;
if (inport->queued_bytes == 0) { if (inport->queued_bytes == 0) {
if (inport->range && outport->range) if (inport->io_range && outport->io_range)
*inport->range = *outport->range; *inport->io_range = *outport->io_range;
inio->status = SPA_STATUS_NEED_BUFFER; inio->status = SPA_STATUS_NEED_BUFFER;
} else { } else {
inio->status = SPA_STATUS_OK; inio->status = SPA_STATUS_OK;

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

@ -1,4 +1,4 @@
audiomixer_sources = ['audiomixer.c', 'conv.c', 'plugin.c'] audiomixer_sources = ['audiomixer.c', 'mix-ops.c', 'plugin.c']
audiomixerlib = shared_library('spa-audiomixer', audiomixerlib = shared_library('spa-audiomixer',
audiomixer_sources, audiomixer_sources,

104
spa/plugins/audiomixer/conv.c → spa/plugins/audiomixer/mix-ops.c
View file

@ -17,22 +17,34 @@
* Boston, MA 02110-1301, USA. * Boston, MA 02110-1301, USA.
*/ */
#include "conv.h" #include "mix-ops.h"
static void static void
copy_s16_s16(void *dst, const void *src, int n_bytes) clear_s16(void *dst, int n_bytes)
{
memset(dst, 0, n_bytes);
}
static void
clear_f32(void *dst, int n_bytes)
{
memset(dst, 0, n_bytes);
}
static void
copy_s16(void *dst, const void *src, int n_bytes)
{ {
memcpy(dst, src, n_bytes); memcpy(dst, src, n_bytes);
} }
static void static void
copy_f32_f32(void *dst, const void *src, int n_bytes) copy_f32(void *dst, const void *src, int n_bytes)
{ {
memcpy(dst, src, n_bytes); memcpy(dst, src, n_bytes);
} }
static void static void
add_s16_s16(void *dst, const void *src, int n_bytes) add_s16(void *dst, const void *src, int n_bytes)
{ {
const int16_t *s = src; const int16_t *s = src;
int16_t *d = dst; int16_t *d = dst;
@ -48,7 +60,7 @@ add_s16_s16(void *dst, const void *src, int n_bytes)
} }
static void static void
add_f32_f32(void *dst, const void *src, int n_bytes) add_f32(void *dst, const void *src, int n_bytes)
{ {
const float *s = src; const float *s = src;
float *d = dst; float *d = dst;
@ -62,15 +74,15 @@ add_f32_f32(void *dst, const void *src, int n_bytes)
} }
static void static void
copy_scale_s16_s16(void *dst, const void *src, const void *scale, int n_bytes) copy_scale_s16(void *dst, const void *src, const double scale, int n_bytes)
{ {
const int16_t *s = src; const int16_t *s = src;
int16_t *d = dst;; int16_t *d = dst;;
int32_t v = *(int16_t*)scale, t; int32_t v = scale * (1 << 11), t;
n_bytes /= sizeof(int16_t); n_bytes /= sizeof(int16_t);
while (n_bytes--) { while (n_bytes--) {
t = (*s * v) >> 16; t = (*s * v) >> 11;
*d = SPA_CLAMP(t, INT16_MIN, INT16_MAX); *d = SPA_CLAMP(t, INT16_MIN, INT16_MAX);
d++; d++;
s++; s++;
@ -78,11 +90,11 @@ copy_scale_s16_s16(void *dst, const void *src, const void *scale, int n_bytes)
} }
static void static void
copy_scale_f32_f32(void *dst, const void *src, const void *scale, int n_bytes) copy_scale_f32(void *dst, const void *src, const double scale, int n_bytes)
{ {
const float *s = src; const float *s = src;
float *d = dst; float *d = dst;
float v = *(float*)scale; float v = scale;
n_bytes /= sizeof(float); n_bytes /= sizeof(float);
while (n_bytes--) { while (n_bytes--) {
@ -93,15 +105,15 @@ copy_scale_f32_f32(void *dst, const void *src, const void *scale, int n_bytes)
} }
static void static void
add_scale_s16_s16(void *dst, const void *src, const void *scale, int n_bytes) add_scale_s16(void *dst, const void *src, const double scale, int n_bytes)
{ {
const int16_t *s = src; const int16_t *s = src;
int16_t *d = dst; int16_t *d = dst;
int32_t v = *(int16_t*)scale, t; int32_t v = scale * (1 << 11), t;
n_bytes /= sizeof(int16_t); n_bytes /= sizeof(int16_t);
while (n_bytes--) { while (n_bytes--) {
t = *d + ((*s * v) >> 16); t = *d + ((*s * v) >> 11);
*d = SPA_CLAMP(t, INT16_MIN, INT16_MAX); *d = SPA_CLAMP(t, INT16_MIN, INT16_MAX);
d++; d++;
s++; s++;
@ -109,11 +121,11 @@ add_scale_s16_s16(void *dst, const void *src, const void *scale, int n_bytes)
} }
static void static void
add_scale_f32_f32(void *dst, const void *src, const void *scale, int n_bytes) add_scale_f32(void *dst, const void *src, const double scale, int n_bytes)
{ {
const float *s = src; const float *s = src;
float *d = dst; float *d = dst;
float v = *(float*)scale; float v = scale;
n_bytes /= sizeof(float); n_bytes /= sizeof(float);
while (n_bytes--) { while (n_bytes--) {
@ -124,7 +136,7 @@ add_scale_f32_f32(void *dst, const void *src, const void *scale, int n_bytes)
} }
static void static void
copy_s16_s16_i(void *dst, int dst_stride, const void *src, int src_stride, int n_bytes) copy_s16_i(void *dst, int dst_stride, const void *src, int src_stride, int n_bytes)
{ {
const int16_t *s = src; const int16_t *s = src;
int16_t *d = dst; int16_t *d = dst;
@ -138,7 +150,7 @@ copy_s16_s16_i(void *dst, int dst_stride, const void *src, int src_stride, int n
} }
static void static void
copy_f32_f32_i(void *dst, int dst_stride, const void *src, int src_stride, int n_bytes) copy_f32_i(void *dst, int dst_stride, const void *src, int src_stride, int n_bytes)
{ {
const float *s = src; const float *s = src;
float *d = dst; float *d = dst;
@ -152,7 +164,7 @@ copy_f32_f32_i(void *dst, int dst_stride, const void *src, int src_stride, int n
} }
static void static void
add_s16_s16_i(void *dst, int dst_stride, const void *src, int src_stride, int n_bytes) add_s16_i(void *dst, int dst_stride, const void *src, int src_stride, int n_bytes)
{ {
const int16_t *s = src; const int16_t *s = src;
int16_t *d = dst; int16_t *d = dst;
@ -168,7 +180,7 @@ add_s16_s16_i(void *dst, int dst_stride, const void *src, int src_stride, int n_
} }
static void static void
add_f32_f32_i(void *dst, int dst_stride, const void *src, int src_stride, int n_bytes) add_f32_i(void *dst, int dst_stride, const void *src, int src_stride, int n_bytes)
{ {
const float *s = src; const float *s = src;
float *d = dst; float *d = dst;
@ -182,15 +194,15 @@ add_f32_f32_i(void *dst, int dst_stride, const void *src, int src_stride, int n_
} }
static void static void
copy_scale_s16_s16_i(void *dst, int dst_stride, const void *src, int src_stride, const void *scale, int n_bytes) 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; const int16_t *s = src;
int16_t *d = dst; int16_t *d = dst;
int32_t v = *(int16_t*)scale, t; int32_t v = scale * (1 << 11), t;
n_bytes /= sizeof(int16_t); n_bytes /= sizeof(int16_t);
while (n_bytes--) { while (n_bytes--) {
t = (*s * v) >> 16; t = (*s * v) >> 11;
*d = SPA_CLAMP(t, INT16_MIN, INT16_MAX); *d = SPA_CLAMP(t, INT16_MIN, INT16_MAX);
d += dst_stride; d += dst_stride;
s += src_stride; s += src_stride;
@ -198,11 +210,11 @@ copy_scale_s16_s16_i(void *dst, int dst_stride, const void *src, int src_stride,
} }
static void static void
copy_scale_f32_f32_i(void *dst, int dst_stride, const void *src, int src_stride, const void *scale, int n_bytes) 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; const float *s = src;
float *d = dst; float *d = dst;
float v = *(float*)scale; float v = scale;
n_bytes /= sizeof(float); n_bytes /= sizeof(float);
while (n_bytes--) { while (n_bytes--) {
@ -213,15 +225,15 @@ copy_scale_f32_f32_i(void *dst, int dst_stride, const void *src, int src_stride,
} }
static void static void
add_scale_s16_s16_i(void *dst, int dst_stride, const void *src, int src_stride, const void *scale, int n_bytes) 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; const int16_t *s = src;
int16_t *d = dst; int16_t *d = dst;
int32_t v = *(int16_t*)scale, t; int32_t v = scale * (1 << 11), t;
n_bytes /= sizeof(int16_t); n_bytes /= sizeof(int16_t);
while (n_bytes--) { while (n_bytes--) {
t = *d + ((*s * v) >> 16); t = *d + ((*s * v) >> 11);
*d = SPA_CLAMP(t, INT16_MIN, INT16_MAX); *d = SPA_CLAMP(t, INT16_MIN, INT16_MAX);
d += dst_stride; d += dst_stride;
s += src_stride; s += src_stride;
@ -229,11 +241,11 @@ add_scale_s16_s16_i(void *dst, int dst_stride, const void *src, int src_stride,
} }
static void static void
add_scale_f32_f32_i(void *dst, int dst_stride, const void *src, int src_stride, const void *scale, int n_bytes) 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; const float *s = src;
float *d = dst; float *d = dst;
float v = *(float*)scale; float v = scale;
n_bytes /= sizeof(float); n_bytes /= sizeof(float);
while (n_bytes--) { while (n_bytes--) {
@ -245,20 +257,22 @@ add_scale_f32_f32_i(void *dst, int dst_stride, const void *src, int src_stride,
void spa_audiomixer_get_ops(struct spa_audiomixer_ops *ops) void spa_audiomixer_get_ops(struct spa_audiomixer_ops *ops)
{ {
ops->copy[CONV_S16_S16] = copy_s16_s16; ops->clear[FMT_S16] = clear_s16;
ops->copy[CONV_F32_F32] = copy_f32_f32; ops->clear[FMT_F32] = clear_f32;
ops->add[CONV_S16_S16] = add_s16_s16; ops->copy[FMT_S16] = copy_s16;
ops->add[CONV_F32_F32] = add_f32_f32; ops->copy[FMT_F32] = copy_f32;
ops->copy_scale[CONV_S16_S16] = copy_scale_s16_s16; ops->add[FMT_S16] = add_s16;
ops->copy_scale[CONV_F32_F32] = copy_scale_f32_f32; ops->add[FMT_F32] = add_f32;
ops->add_scale[CONV_S16_S16] = add_scale_s16_s16; ops->copy_scale[FMT_S16] = copy_scale_s16;
ops->add_scale[CONV_F32_F32] = add_scale_f32_f32; ops->copy_scale[FMT_F32] = copy_scale_f32;
ops->copy_i[CONV_S16_S16] = copy_s16_s16_i; ops->add_scale[FMT_S16] = add_scale_s16;
ops->copy_i[CONV_F32_F32] = copy_f32_f32_i; ops->add_scale[FMT_F32] = add_scale_f32;
ops->add_i[CONV_S16_S16] = add_s16_s16_i; ops->copy_i[FMT_S16] = copy_s16_i;
ops->add_i[CONV_F32_F32] = add_f32_f32_i; ops->copy_i[FMT_F32] = copy_f32_i;
ops->copy_scale_i[CONV_S16_S16] = copy_scale_s16_s16_i; ops->add_i[FMT_S16] = add_s16_i;
ops->copy_scale_i[CONV_F32_F32] = copy_scale_f32_f32_i; ops->add_i[FMT_F32] = add_f32_i;
ops->add_scale_i[CONV_S16_S16] = add_scale_s16_s16_i; ops->copy_scale_i[FMT_S16] = copy_scale_s16_i;
ops->add_scale_i[CONV_F32_F32] = add_scale_f32_f32_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;
} }

28
spa/plugins/audiomixer/conv.h → spa/plugins/audiomixer/mix-ops.h
View file

@ -22,28 +22,30 @@
#include <spa/utils/defs.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_func_t) (void *dst, const void *src, int n_bytes);
typedef void (*mix_scale_func_t) (void *dst, const void *src, const void *scale, 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, typedef void (*mix_i_func_t) (void *dst, int dst_stride,
const void *src, int src_stride, int n_bytes); const void *src, int src_stride, int n_bytes);
typedef void (*mix_scale_i_func_t) (void *dst, int dst_stride, typedef void (*mix_scale_i_func_t) (void *dst, int dst_stride,
const void *src, int src_stride, const void *scale, int n_bytes); const void *src, int src_stride, const double scale, int n_bytes);
enum { enum {
CONV_S16_S16, FMT_S16,
CONV_F32_F32, FMT_F32,
CONV_MAX, FMT_MAX,
}; };
struct spa_audiomixer_ops { struct spa_audiomixer_ops {
mix_func_t copy[CONV_MAX]; mix_clear_func_t clear[FMT_MAX];
mix_func_t add[CONV_MAX]; mix_func_t copy[FMT_MAX];
mix_scale_func_t copy_scale[CONV_MAX]; mix_func_t add[FMT_MAX];
mix_scale_func_t add_scale[CONV_MAX]; mix_scale_func_t copy_scale[FMT_MAX];
mix_i_func_t copy_i[CONV_MAX]; mix_scale_func_t add_scale[FMT_MAX];
mix_i_func_t add_i[CONV_MAX]; mix_i_func_t copy_i[FMT_MAX];
mix_scale_i_func_t copy_scale_i[CONV_MAX]; mix_i_func_t add_i[FMT_MAX];
mix_scale_i_func_t add_scale_i[CONV_MAX]; mix_scale_i_func_t copy_scale_i[FMT_MAX];
mix_scale_i_func_t add_scale_i[FMT_MAX];
}; };
void spa_audiomixer_get_ops(struct spa_audiomixer_ops *ops); void spa_audiomixer_get_ops(struct spa_audiomixer_ops *ops);

6
spa/plugins/audiotestsrc/audiotestsrc.c
View file

@ -680,7 +680,7 @@ impl_node_port_enum_params(struct spa_node *node,
param = spa_pod_builder_object(&b, param = spa_pod_builder_object(&b,
id, t->param_io.IO, id, t->param_io.IO,
":", t->param_io.id, "I", t->io_prop_wave, ":", t->param_io.id, "I", t->io_prop_wave,
":", t->param_io.size, "i", sizeof(uint32_t), ":", t->param_io.size, "i", sizeof(struct spa_pod_id),
":", t->param_io.propId, "I", t->prop_wave, ":", t->param_io.propId, "I", t->prop_wave,
":", t->param_io.propType, "Ie", p->wave, ":", t->param_io.propType, "Ie", p->wave,
2, t->wave_sine, 2, t->wave_sine,
@ -690,7 +690,7 @@ impl_node_port_enum_params(struct spa_node *node,
param = spa_pod_builder_object(&b, param = spa_pod_builder_object(&b,
id, t->param_io.IO, id, t->param_io.IO,
":", t->param_io.id, "I", t->io_prop_freq, ":", t->param_io.id, "I", t->io_prop_freq,
":", t->param_io.size, "i", sizeof(double), ":", t->param_io.size, "i", sizeof(struct spa_pod_double),
":", t->param_io.propId, "I", t->prop_freq, ":", t->param_io.propId, "I", t->prop_freq,
":", t->param_io.propType, "dr", p->freq, 2, 0.0, 50000000.0); ":", t->param_io.propType, "dr", p->freq, 2, 0.0, 50000000.0);
break; break;
@ -698,7 +698,7 @@ impl_node_port_enum_params(struct spa_node *node,
param = spa_pod_builder_object(&b, param = spa_pod_builder_object(&b,
id, t->param_io.IO, id, t->param_io.IO,
":", t->param_io.id, "I", t->io_prop_volume, ":", t->param_io.id, "I", t->io_prop_volume,
":", t->param_io.size, "i", sizeof(double), ":", t->param_io.size, "i", sizeof(struct spa_pod_double),
":", t->param_io.propId, "I", t->prop_volume, ":", t->param_io.propId, "I", t->prop_volume,
":", t->param_io.propType, "dr", p->volume, 2, 0.0, 10.0); ":", t->param_io.propType, "dr", p->volume, 2, 0.0, 10.0);
break; break;