mirrors/pipewire
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pipewire/pipewire.git synced 2025-11-14 06:59:57 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add PortConfig parameter

Browse source 
Add a new PortConfig parameter to configure ports of elements that
are marked with the SPA_NODE_FLAG_*_PORT_CONFIG. This is used to
configure the operation of the audioconver/audioadapter nodes and
how it should convert the internal format. We want to use the
Profile parameter only for cases where there is an enumeration of
values, like with device configuration.

Add unit tests for audioconvert and adapter to check if they handle
PortConfig correctly.

Make the media session use the PortConfig to dynamically configure
the device nodes.

Remove audio-dsp, it is not used anymore and can/should be implemented
with a simple audioconvert spa node now and some PortConfig.
This commit is contained in:
Wim Taymans 2019-08-06 12:45:20 +02:00
parent acdfed0d04
commit f41720e7db
29 changed files with 1693 additions and 1300 deletions
Download patch file Download diff file Expand all files Collapse all files

1
src/examples/alsa-monitor.c
View file

@ -121,7 +121,6 @@ static struct alsa_node *alsa_create_node(struct alsa_object *obj, uint32_t id,
str = "alsa-device";
pw_properties_set(node->props, PW_KEY_NODE_NAME, str);
pw_properties_set(node->props, "factory.name", info->factory_name);
pw_properties_set(node->props, "merger.monitor", "1");
node->monitor = monitor;
node->object = obj;

21
src/examples/media-session.c
View file

@ -1098,15 +1098,16 @@ do_link_profile:
spa_pod_builder_init(&b, buf, sizeof(buf));
param = spa_format_audio_raw_build(&b, SPA_PARAM_Format, &audio_info);
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamProfile, SPA_PARAM_Profile,
SPA_PARAM_PROFILE_direction, SPA_POD_Id(pw_direction_reverse(direction)),
SPA_PARAM_PROFILE_format, SPA_POD_Pod(param));
SPA_TYPE_OBJECT_ParamPortConfig, SPA_PARAM_PortConfig,
SPA_PARAM_PORT_CONFIG_direction, SPA_POD_Id(pw_direction_reverse(direction)),
SPA_PARAM_PORT_CONFIG_mode, SPA_POD_Id(SPA_PARAM_PORT_CONFIG_MODE_dsp),
SPA_PARAM_PORT_CONFIG_format, SPA_POD_Pod(param));
if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG))
spa_debug_pod(2, NULL, param);
pw_node_proxy_set_param((struct pw_node_proxy*)node->obj.proxy,
SPA_PARAM_Profile, 0, param);
SPA_PARAM_PortConfig, 0, param);
stream_set_volume(impl, node, 1.0, false);
n_links = audio_info.channels;
@ -1144,17 +1145,19 @@ static void rescan_session(struct impl *impl, struct session *sess)
info = node->format;
info.rate = DEFAULT_SAMPLERATE;
pw_log_debug(NAME" %p: setting profile for session %d", impl, sess->id);
pw_log_debug(NAME" %p: setting profile for session %d %d", impl, sess->id, sess->direction);
spa_pod_builder_init(&b, buf, sizeof(buf));
param = spa_format_audio_raw_build(&b, SPA_PARAM_Format, &info);
param = spa_pod_builder_add_object(&b,
SPA_TYPE_OBJECT_ParamProfile, SPA_PARAM_Profile,
SPA_PARAM_PROFILE_direction, SPA_POD_Id(pw_direction_reverse(sess->direction)),
SPA_PARAM_PROFILE_format, SPA_POD_Pod(param));
SPA_TYPE_OBJECT_ParamPortConfig, SPA_PARAM_PortConfig,
SPA_PARAM_PORT_CONFIG_direction, SPA_POD_Id(pw_direction_reverse(sess->direction)),
SPA_PARAM_PORT_CONFIG_mode, SPA_POD_Id(SPA_PARAM_PORT_CONFIG_MODE_dsp),
SPA_PARAM_PORT_CONFIG_monitor, SPA_POD_Bool(true),
SPA_PARAM_PORT_CONFIG_format, SPA_POD_Pod(param));
pw_node_proxy_set_param((struct pw_node_proxy*)sess->node->obj.proxy,
SPA_PARAM_Profile, 0, param);
SPA_PARAM_PortConfig, 0, param);
schedule_rescan(impl);
sess->starting = false;

12
src/modules/meson.build
View file

@ -97,18 +97,6 @@ test('pw-test-protocol-native',
'PIPEWIRE_MODULE_DIR=@0@/src/modules/'.format(meson.build_root())
])
pipewire_module_audio_dsp = shared_library('pipewire-module-audio-dsp',
[ 'module-audio-dsp.c',
'module-audio-dsp/audio-dsp.c',
'module-audio-dsp/floatmix.c',
'spa/spa-node.c' ],
c_args : pipewire_module_c_args,
include_directories : [configinc, spa_inc],
install : true,
install_dir : modules_install_dir,
dependencies : [mathlib, dl_lib, rt_lib, pipewire_dep],
)
pipewire_module_adapter = shared_library('pipewire-module-adapter',
[ 'module-adapter.c',
'module-adapter/adapter.c',

2
src/modules/module-adapter/floatmix.c
View file

@ -872,7 +872,7 @@ impl_init(const struct spa_handle_factory *factory,
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_DYNAMIC_INPUT_PORTS;
this->info.flags = SPA_NODE_FLAG_RT | SPA_NODE_FLAG_IN_DYNAMIC_PORTS;
port = GET_OUT_PORT(this, 0);
port->valid = true;

232
src/modules/module-audio-dsp.c
View file

@ -1,232 +0,0 @@
/* PipeWire
*
* 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 <string.h>
#include <stdio.h>
#include <errno.h>
#include <dlfcn.h>
#include "config.h"
#include <spa/node/node.h>
#include <spa/utils/hook.h>
#include <spa/param/audio/format-utils.h>
#include <spa/pod/filter.h>
#include <pipewire/pipewire.h>
#include "pipewire/private.h"
#include "module-audio-dsp/audio-dsp.h"
static const struct spa_dict_item module_props[] = {
{ PW_KEY_MODULE_AUTHOR, "Wim Taymans <wim.taymans@gmail.com>" },
{ PW_KEY_MODULE_DESCRIPTION, "Manage audio DSP nodes" },
{ PW_KEY_MODULE_VERSION, PACKAGE_VERSION },
};
struct factory_data {
struct pw_factory *this;
struct spa_list node_list;
struct pw_module *module;
struct spa_hook module_listener;
};
struct node_data {
struct factory_data *data;
struct spa_list link;
struct pw_node *dsp;
struct spa_hook dsp_listener;
struct spa_hook resource_listener;
};
static void resource_destroy(void *data)
{
struct node_data *nd = data;
spa_hook_remove(&nd->resource_listener);
if (nd->dsp)
pw_node_destroy(nd->dsp);
}
static const struct pw_resource_events resource_events = {
PW_VERSION_RESOURCE_EVENTS,
.destroy = resource_destroy
};
static void node_destroy(void *data)
{
struct node_data *nd = data;
spa_list_remove(&nd->link);
nd->dsp = NULL;
}
static const struct pw_node_events node_events = {
PW_VERSION_NODE_EVENTS,
.destroy = node_destroy
};
static void *create_object(void *_data,
struct pw_resource *resource,
uint32_t type,
uint32_t version,
struct pw_properties *properties,
uint32_t new_id)
{
struct factory_data *d = _data;
struct pw_client *client;
struct pw_node *dsp;
int res;
struct node_data *nd;
struct pw_resource *bound_resource;
if (resource == NULL)
goto error_resource;
client = pw_resource_get_client(resource);
dsp = pw_audio_dsp_new(pw_module_get_core(d->module),
properties,
sizeof(struct node_data));
properties = NULL;
if (dsp == NULL) {
if (errno == ENOMEM)
goto error_no_mem;
else
goto error_usage;
}
nd = pw_audio_dsp_get_user_data(dsp);
nd->data = d;
nd->dsp = dsp;
spa_list_append(&d->node_list, &nd->link);
pw_node_register(dsp, client, pw_module_get_global(d->module), NULL);
pw_node_add_listener(dsp, &nd->dsp_listener, &node_events, nd);
res = pw_global_bind(pw_node_get_global(dsp), client,
PW_PERM_RWX, PW_VERSION_NODE_PROXY, new_id);
if (res < 0)
goto error_bind;
if ((bound_resource = pw_client_find_resource(client, new_id)) == NULL)
goto error_bind;
pw_resource_add_listener(bound_resource, &nd->resource_listener, &resource_events, nd);
pw_node_set_active(dsp, true);
return dsp;
error_resource:
res = -EINVAL;
pw_log_error("audio-dsp needs a resource");
pw_resource_error(resource, res, "no resource");
goto error_cleanup;
error_no_mem:
res = -errno;
pw_log_error("can't create node: %m");
pw_resource_error(resource, res, "no memory");
goto error_cleanup;
error_usage:
res = -EINVAL;
pw_log_error("usage: "AUDIO_DSP_USAGE);
pw_resource_error(resource, res, "usage: "AUDIO_DSP_USAGE);
goto error_cleanup;
error_bind:
pw_resource_error(resource, res, "can't bind dsp node");
goto error_cleanup;
error_cleanup:
if (properties)
pw_properties_free(properties);
errno = -res;
return NULL;
}
static const struct pw_factory_implementation impl_factory = {
PW_VERSION_FACTORY_IMPLEMENTATION,
.create_object = create_object,
};
static void module_destroy(void *data)
{
struct factory_data *d = data;
struct node_data *nd, *t;
spa_hook_remove(&d->module_listener);
spa_list_for_each_safe(nd, t, &d->node_list, link)
pw_node_destroy(nd->dsp);
pw_factory_destroy(d->this);
}
static const struct pw_module_events module_events = {
PW_VERSION_MODULE_EVENTS,
.destroy = module_destroy,
};
static int module_init(struct pw_module *module, struct pw_properties *properties)
{
struct pw_core *core = pw_module_get_core(module);
struct pw_factory *factory;
struct factory_data *data;
factory = pw_factory_new(core,
"audio-dsp",
PW_TYPE_INTERFACE_Node,
PW_VERSION_NODE_PROXY,
pw_properties_new(
PW_KEY_FACTORY_USAGE, AUDIO_DSP_USAGE,
NULL),
sizeof(*data));
if (factory == NULL)
return -errno;
data = pw_factory_get_user_data(factory);
data->this = factory;
data->module = module;
spa_list_init(&data->node_list);
pw_log_debug("module %p: new", module);
pw_factory_set_implementation(factory,
&impl_factory,
data);
pw_factory_register(factory, NULL, pw_module_get_global(module), NULL);
pw_module_add_listener(module, &data->module_listener, &module_events, data);
pw_module_update_properties(module, &SPA_DICT_INIT_ARRAY(module_props));
return 0;
}
SPA_EXPORT
int pipewire__module_init(struct pw_module *module, const char *args)
{
return module_init(module, NULL);
}

359
src/modules/module-audio-dsp/audio-dsp.c
View file

@ -1,359 +0,0 @@
/* PipeWire
*
* 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 <string.h>
#include <stdio.h>
#include <errno.h>
#include <math.h>
#include <time.h>
#include "config.h"
#include <spa/node/node.h>
#include <spa/utils/hook.h>
#include <spa/utils/names.h>
#include <spa/param/audio/format-utils.h>
#include <spa/utils/type-info.h>
#include <spa/param/audio/type-info.h>
#include "pipewire/pipewire.h"
#include "pipewire/private.h"
#include "modules/spa/spa-node.h"
#define NAME "audio-dsp"
#define PORT_BUFFERS 1
#define MAX_BUFFER_SIZE 2048
extern const struct spa_handle_factory spa_floatmix_factory;
struct buffer {
struct spa_buffer buf;
struct spa_data datas[1];
struct spa_chunk chunk[1];
};
struct node;
struct port {
struct spa_list link;
struct pw_port *port;
struct node *node;
struct buffer buffers[PORT_BUFFERS];
struct spa_buffer *bufs[PORT_BUFFERS];
struct spa_handle *spa_handle;
struct spa_node *spa_node;
float empty[MAX_BUFFER_SIZE + 15];
};
struct node {
struct pw_core *core;
struct pw_node *node;
struct spa_hook node_listener;
void *user_data;
enum pw_direction direction;
struct pw_properties *props;
struct spa_audio_info format;
int max_buffer_size;
struct spa_list ports;
};
/** \endcond */
static void init_buffer(struct port *port, uint32_t id)
{
struct buffer *b = &port->buffers[id];
b->buf.n_metas = 0;
b->buf.metas = NULL;
b->buf.n_datas = 1;
b->buf.datas = b->datas;
b->datas[0].type = SPA_DATA_MemPtr;
b->datas[0].flags = SPA_DATA_FLAG_DYNAMIC;
b->datas[0].fd = -1;
b->datas[0].mapoffset = 0;
b->datas[0].maxsize = SPA_ROUND_DOWN_N(sizeof(port->empty), 16);
b->datas[0].data = SPA_PTR_ALIGN(port->empty, 16, void);
b->datas[0].chunk = b->chunk;
b->datas[0].chunk->offset = 0;
b->datas[0].chunk->size = 0;
b->datas[0].chunk->stride = 0;
port->bufs[id] = &b->buf;
memset(port->empty, 0, sizeof(port->empty));
pw_log_debug("%p %d", b->datas[0].data, b->datas[0].maxsize);
}
static void init_port(struct port *p, enum spa_direction direction)
{
int i;
for (i = 0; i < PORT_BUFFERS; i++)
init_buffer(p, i);
}
static int port_use_buffers(void *data,
uint32_t flags,
struct spa_buffer **buffers, uint32_t n_buffers)
{
struct port *p = data;
struct pw_port *port = p->port;
struct pw_node *node = port->node;
int res, i;
pw_log_debug(NAME " %p: port %p", p->node->node, port);
if (n_buffers > 0) {
for (i = 0; i < PORT_BUFFERS; i++)
init_buffer(p, i);
n_buffers = PORT_BUFFERS;
buffers = p->bufs;
}
res = spa_node_port_use_buffers(port->mix,
pw_direction_reverse(port->direction), 0,
flags,
buffers, n_buffers);
res = spa_node_port_use_buffers(node->node,
port->direction, port->port_id,
flags,
buffers, n_buffers);
return res;
}
static const struct pw_port_implementation port_implementation = {
.use_buffers = port_use_buffers,
};
static void node_destroy(void *data)
{
struct node *n = data;
struct port *p, *tmp;
pw_properties_free(n->props);
spa_list_for_each_safe(p, tmp, &n->ports, link) {
pw_port_set_mix(p->port, NULL, 0);
spa_list_remove(&p->link);
spa_handle_clear(p->spa_handle);
free(p);
}
}
static void node_port_init(void *data, struct pw_port *port)
{
struct node *n = data;
struct port *p;
const struct pw_properties *old;
enum pw_direction direction;
struct pw_properties *new;
const char *str;
void *iface;
const struct spa_support *support;
uint32_t n_support;
char position[8], *prefix;
bool monitor;
direction = pw_port_get_direction(port);
old = pw_port_get_properties(port);
monitor = (str = pw_properties_get(old, PW_KEY_PORT_MONITOR)) != NULL &&
pw_properties_parse_bool(str);
if (!monitor && direction == n->direction)
return;
new = pw_properties_new(PW_KEY_FORMAT_DSP, "32 bit float mono audio", NULL);
if (monitor)
prefix = "monitor";
else if (direction == PW_DIRECTION_INPUT)
prefix = "playback";
else
prefix = "capture";
if ((str = pw_properties_get(old, PW_KEY_AUDIO_CHANNEL)) == NULL ||
strcmp(str, "UNK") == 0) {
snprintf(position, 7, "%d", port->port_id);
str = position;
}
pw_properties_setf(new, PW_KEY_PORT_NAME, "%s_%s", prefix, str);
if (direction != n->direction) {
pw_properties_setf(new, PW_KEY_PORT_ALIAS1, "%s_pcm:%s:%s%s",
pw_properties_get(n->props, PW_KEY_DEVICE_API),
pw_properties_get(n->props, "audio-dsp.name"),
direction == PW_DIRECTION_INPUT ? "in" : "out",
str);
pw_properties_set(new, PW_KEY_PORT_PHYSICAL, "1");
pw_properties_set(new, PW_KEY_PORT_TERMINAL, "1");
}
pw_port_update_properties(port, &new->dict);
pw_properties_free(new);
if (direction == n->direction)
return;
p = calloc(1, sizeof(struct port) +
spa_handle_factory_get_size(&spa_floatmix_factory, NULL));
p->node = n;
p->port = port;
init_port(p, direction);
p->spa_handle = SPA_MEMBER(p, sizeof(struct port), struct spa_handle);
support = pw_core_get_support(n->core, &n_support);
spa_handle_factory_init(&spa_floatmix_factory,
p->spa_handle, NULL,
support, n_support);
spa_handle_get_interface(p->spa_handle, SPA_TYPE_INTERFACE_Node, &iface);
p->spa_node = iface;
if (direction == PW_DIRECTION_INPUT) {
pw_log_debug("mix node %p", p->spa_node);
pw_port_set_mix(port, p->spa_node, PW_PORT_MIX_FLAG_MULTI);
port->impl = SPA_CALLBACKS_INIT(&port_implementation, p);
}
spa_list_append(&n->ports, &p->link);
}
static const struct pw_node_events node_events = {
PW_VERSION_NODE_EVENTS,
.destroy = node_destroy,
.port_init = node_port_init,
};
struct pw_node *pw_audio_dsp_new(struct pw_core *core,
struct pw_properties *props,
size_t user_data_size)
{
struct pw_node *node;
struct node *n;
const char *api, *alias, *str;
char node_name[128];
enum pw_direction direction;
uint32_t max_buffer_size;
int i, res = -ENOENT;
if ((str = pw_properties_get(props, "audio-dsp.direction")) == NULL) {
pw_log_error("missing audio-dsp.direction property");
goto error;
}
direction = pw_properties_parse_int(str);
if ((str = pw_properties_get(props, "audio-dsp.maxbuffer")) == NULL) {
pw_log_error("missing audio-dsp.maxbuffer property");
goto error;
}
max_buffer_size = pw_properties_parse_int(str);
if ((api = pw_properties_get(props, PW_KEY_DEVICE_API)) == NULL) {
pw_log_error("missing "PW_KEY_DEVICE_API" property");
goto error;
}
if ((alias = pw_properties_get(props, "audio-dsp.name")) == NULL) {
pw_log_error("missing audio-dsp.name property");
goto error;
}
snprintf(node_name, sizeof(node_name), "system_%s", alias);
for (i = 0; node_name[i]; i++) {
if (node_name[i] == ':' || node_name[i] == ',')
node_name[i] = '_';
}
pw_properties_set(props,
PW_KEY_MEDIA_CLASS,
direction == PW_DIRECTION_OUTPUT ?
"Audio/DSP/Playback" :
"Audio/DSP/Capture");
pw_properties_set(props, PW_KEY_NODE_DRIVER, NULL);
if ((str = pw_properties_get(props, PW_KEY_NODE_ID)) != NULL)
pw_properties_set(props, PW_KEY_NODE_SESSION, str);
if ((str = pw_properties_get(props, "audio-dsp.mode")) == NULL) {
if (direction == PW_DIRECTION_OUTPUT) {
if (pw_properties_get(props, "merger.monitor") == NULL)
pw_properties_set(props, "merger.monitor", "1");
str = "merge";
} else {
str = "split";
}
}
pw_properties_set(props, "factory.mode", str);
pw_properties_set(props, SPA_KEY_LIBRARY_NAME, "audioconvert/libspa-audioconvert");
node = pw_spa_node_load(core, NULL, NULL,
SPA_NAME_AUDIO_CONVERT,
node_name,
PW_SPA_NODE_FLAG_ACTIVATE | PW_SPA_NODE_FLAG_NO_REGISTER,
pw_properties_copy(props),
sizeof(struct node) + user_data_size);
if (node == NULL) {
res = -errno;
pw_log_error("can't load spa node: %m");
goto error;
}
n = pw_spa_node_get_user_data(node);
n->core = core;
n->node = node;
n->direction = direction;
n->props = props;
spa_list_init(&n->ports);
n->max_buffer_size = max_buffer_size;
if (user_data_size > 0)
n->user_data = SPA_MEMBER(n, sizeof(struct node), void);
pw_node_add_listener(node, &n->node_listener, &node_events, n);
return node;
error:
if (props)
pw_properties_free(props);
errno = -res;
return NULL;
}
void *pw_audio_dsp_get_user_data(struct pw_node *node)
{
struct node *n = pw_spa_node_get_user_data(node);
return n->user_data;
}

52
src/modules/module-audio-dsp/audio-dsp.h
View file

@ -1,52 +0,0 @@
/* PipeWire
*
* 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.
*/
#ifndef PIPEWIRE_AUDIO_DSP_H
#define PIPEWIRE_AUDIO_DSP_H
#include <pipewire/core.h>
#include <pipewire/node.h>
#ifdef __cplusplus
extern "C" {
#endif
#define AUDIO_DSP_USAGE "audio-dsp.direction=<enum spa_direction> " \
"audio-dsp.maxbuffer=<int> " \
"audio-dsp.name=<string> " \
PW_KEY_DEVICE_API"=<string> " \
"["PW_KEY_NODE_ID"=<int>]"
struct pw_node *
pw_audio_dsp_new(struct pw_core *core,
struct pw_properties *properties,
size_t user_data_size);
void *pw_audio_dsp_get_user_data(struct pw_node *node);
#ifdef __cplusplus
}
#endif
#endif /* PIPEWIRE_AUDIO_DSP_H */

926
src/modules/module-audio-dsp/floatmix.c
View file

@ -1,926 +0,0 @@
/* 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/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>
#define NAME "floatmix"
#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;
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_CHECK(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_UNSET(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->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);
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]);
}
#if defined (__SSE__)
#include <xmmintrin.h>
static void mix_2(float * dst, const float * SPA_RESTRICT src1,
const float * SPA_RESTRICT src2, uint32_t n_samples)
{
uint32_t n, unrolled;
__m128 in1[4], in2[4];
if (SPA_IS_ALIGNED(src1, 16) &&
SPA_IS_ALIGNED(src2, 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(&src1[n+ 0]);
in1[1] = _mm_load_ps(&src1[n+ 4]);
in1[2] = _mm_load_ps(&src1[n+ 8]);
in1[3] = _mm_load_ps(&src1[n+12]);
in2[0] = _mm_load_ps(&src2[n+ 0]);
in2[1] = _mm_load_ps(&src2[n+ 4]);
in2[2] = _mm_load_ps(&src2[n+ 8]);
in2[3] = _mm_load_ps(&src2[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(&src1[n]),
in2[0] = _mm_load_ss(&src2[n]),
in1[0] = _mm_add_ss(in1[0], in2[0]);
_mm_store_ss(&dst[n], in1[0]);
}
}
#else
static void mix_2(float * dst, const float * SPA_RESTRICT src1,
const float * SPA_RESTRICT src2, uint32_t n_samples)
{
uint32_t i;
for (i = 0; i < n_samples; i++)
dst[i] = src1[i] + src2[i];
}
#endif
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;
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_BUFFER)
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 *));
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_BUFFER) {
spa_log_trace_fp(this->log, NAME " %p: skip input %d %d %p %d %d %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);
buffers[n_buffers++] = inb;
inio->status = SPA_STATUS_NEED_BUFFER;
}
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 {
float *dst;
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);
dst = outb->datas[0].data;
if (n_buffers == 0) {
memset(dst, 0, n_samples * sizeof(float));
}
else {
/* first 2 buffers, add and store */
mix_2(dst, buffers[0]->buffer->datas[0].data,
buffers[1]->buffer->datas[0].data, n_samples);
/* next buffers */
for (i = 2; i < n_buffers; i++)
mix_2(dst, dst, buffers[i]->buffer->datas[0].data, n_samples);
}
}
outio->buffer_id = outb->id;
outio->status = SPA_STATUS_HAVE_BUFFER;
return SPA_STATUS_HAVE_BUFFER | SPA_STATUS_NEED_BUFFER;
}
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++) {
if (support[i].type == SPA_TYPE_INTERFACE_Log)
this->log = support[i].data;
}
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_DYNAMIC_INPUT_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_floatmix_factory = {
SPA_VERSION_HANDLE_FACTORY,
SPA_NAME_AUDIO_MIXER,
NULL,
impl_get_size,
impl_init,
impl_enum_interface_info,
};

5
src/pipewire/node.c
View file

@ -1430,21 +1430,24 @@ uint32_t pw_node_get_free_port_id(struct pw_node *node, enum pw_direction direct
uint32_t n_ports, max_ports;
struct pw_map *portmap;
uint32_t port_id;
bool dynamic;
int res;
if (direction == PW_DIRECTION_INPUT) {
max_ports = node->info.max_input_ports;
n_ports = node->info.n_input_ports;
portmap = &node->input_port_map;
dynamic = SPA_FLAG_CHECK(node->spa_flags, SPA_NODE_FLAG_IN_DYNAMIC_PORTS);
} else {
max_ports = node->info.max_output_ports;
n_ports = node->info.n_output_ports;
portmap = &node->output_port_map;
dynamic = SPA_FLAG_CHECK(node->spa_flags, SPA_NODE_FLAG_OUT_DYNAMIC_PORTS);
}
pw_log_debug("node %p: direction %s n_ports:%u max_ports:%u",
node, pw_direction_as_string(direction), n_ports, max_ports);
if (n_ports >= max_ports) {
if (!dynamic || n_ports >= max_ports) {
res = -ENOSPC;
goto error;
}