Adding upstream version 0.3.65.upstream/0.3.65upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 548 insertions, 0 deletions

diff --git a/src/modules/module-adapter/adapter.c b/src/modules/module-adapter/adapter.c
new file mode 100644
index 0000000..19c5713
--- /dev/null
+++ b/src/modules/module-adapter/adapter.c
@@ -0,0 +1,548 @@
+/* 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/node/utils.h>
+#include <spa/utils/hook.h>
+#include <spa/utils/result.h>
+#include <spa/utils/names.h>
+#include <spa/utils/string.h>
+#include <spa/utils/type-info.h>
+#include <spa/param/format.h>
+#include <spa/param/audio/format.h>
+#include <spa/param/audio/format-utils.h>
+#include <spa/param/format-utils.h>
+#include <spa/debug/types.h>
+#include <spa/utils/json-pod.h>
+
+#include "pipewire/pipewire.h"
+
+#include "modules/spa/spa-node.h"
+
+#define NAME "adapter"
+
+PW_LOG_TOPIC_EXTERN(mod_topic);
+#define PW_LOG_TOPIC_DEFAULT mod_topic
+
+struct buffer {
+	struct spa_buffer buf;
+	struct spa_data datas[1];
+	struct spa_chunk chunk[1];
+};
+
+struct node {
+	struct pw_context *context;
+
+	struct pw_impl_node *node;
+	struct spa_hook node_listener;
+
+	struct spa_node *follower;
+
+	void *user_data;
+	enum pw_direction direction;
+	struct pw_properties *props;
+
+	uint32_t media_type;
+	uint32_t media_subtype;
+
+	struct spa_list ports;
+};
+
+/** \endcond */
+static void node_free(void *data)
+{
+	struct node *n = data;
+	spa_hook_remove(&n->node_listener);
+	pw_properties_free(n->props);
+}
+
+static void node_port_init(void *data, struct pw_impl_port *port)
+{
+	struct node *n = data;
+	const struct pw_properties *old;
+	enum pw_direction direction;
+	struct pw_properties *new;
+	const char *str, *path, *desc, *nick, *name, *node_name, *media_class, *prop_port_names, *override_device_prefix;
+	char position[8], *prefix;
+	bool is_monitor, is_device, is_duplex, is_virtual, is_control = false, no_device_port_prefix;
+
+	direction = pw_impl_port_get_direction(port);
+
+	old = pw_impl_port_get_properties(port);
+
+	is_monitor = pw_properties_get_bool(old, PW_KEY_PORT_MONITOR, false);
+	if (!is_monitor && direction != n->direction)
+		return;
+
+	if ((str = pw_properties_get(old, PW_KEY_FORMAT_DSP)) != NULL)
+		is_control = spa_streq(str, "8 bit raw midi");
+
+	path = pw_properties_get(n->props, PW_KEY_OBJECT_PATH);
+	media_class = pw_properties_get(n->props, PW_KEY_MEDIA_CLASS);
+
+	if (media_class != NULL &&
+	    (strstr(media_class, "Sink") != NULL ||
+	     strstr(media_class, "Source") != NULL))
+		is_device = true;
+	else
+		is_device = false;
+
+	is_duplex = media_class != NULL && strstr(media_class, "Duplex") != NULL;
+	is_virtual = media_class != NULL && strstr(media_class, "Virtual") != NULL;
+
+	new = pw_properties_new(NULL, NULL);
+
+	override_device_prefix = pw_properties_get(n->props, PW_KEY_NODE_DEVICE_PORT_NAME_PREFIX);
+
+	if (is_control)
+		prefix = direction == PW_DIRECTION_INPUT ?
+			"control" : "notify";
+	else if (is_duplex)
+		prefix = direction == PW_DIRECTION_INPUT ?
+			"playback" : "capture";
+	else if (is_virtual)
+		prefix = direction == PW_DIRECTION_INPUT ?
+			"input" : "capture";
+	else if (is_device)
+		prefix = direction == PW_DIRECTION_INPUT ?
+			override_device_prefix != NULL ?
+				strdup(override_device_prefix) : "playback"
+				: is_monitor ? "monitor" : override_device_prefix != NULL ?
+					strdup(override_device_prefix) : "capture";
+	else
+		prefix = direction == PW_DIRECTION_INPUT ?
+			"input" : is_monitor ? "monitor" : "output";
+
+	if ((str = pw_properties_get(old, PW_KEY_AUDIO_CHANNEL)) == NULL ||
+	    spa_streq(str, "UNK")) {
+		snprintf(position, sizeof(position), "%d", pw_impl_port_get_id(port) + 1);
+		str = position;
+	}
+	if (direction == n->direction) {
+		if (is_device) {
+			pw_properties_set(new, PW_KEY_PORT_PHYSICAL, "true");
+			pw_properties_set(new, PW_KEY_PORT_TERMINAL, "true");
+		}
+	}
+
+	desc = pw_properties_get(n->props, PW_KEY_NODE_DESCRIPTION);
+	nick = pw_properties_get(n->props, PW_KEY_NODE_NICK);
+	name = pw_properties_get(n->props, PW_KEY_NODE_NAME);
+
+	if ((node_name = desc) == NULL && (node_name = nick) == NULL &&
+	    (node_name = name) == NULL)
+		node_name = "node";
+
+	pw_properties_setf(new, PW_KEY_OBJECT_PATH, "%s:%s_%d",
+			path ? path : node_name, prefix, pw_impl_port_get_id(port));
+	
+	no_device_port_prefix = is_device && !is_monitor 
+		&& override_device_prefix != NULL && strlen(override_device_prefix) == 0;
+
+	if (is_control)
+		pw_properties_setf(new, PW_KEY_PORT_NAME, "%s", prefix);
+	else if (no_device_port_prefix)
+		pw_properties_setf(new, PW_KEY_PORT_NAME, "%s", str);
+	else
+		pw_properties_setf(new, PW_KEY_PORT_NAME, "%s_%s", prefix, str);
+
+	if ((node_name = nick) == NULL && (node_name = desc) == NULL &&
+	    (node_name = name) == NULL)
+		node_name = "node";
+
+	if (is_control)
+		pw_properties_setf(new, PW_KEY_PORT_ALIAS, "%s:%s",
+			node_name, prefix);
+	else
+		pw_properties_setf(new, PW_KEY_PORT_ALIAS, "%s:%s_%s",
+			node_name, prefix, str);
+
+	prop_port_names = pw_properties_get(n->props, PW_KEY_NODE_CHANNELNAMES);
+	if (prop_port_names) {
+		struct spa_json it[2];
+		char v[256];
+
+		spa_json_init(&it[0], prop_port_names, strlen(prop_port_names));
+		if (spa_json_enter_array(&it[0], &it[1]) <= 0)
+			spa_json_init(&it[1], prop_port_names, strlen(prop_port_names));
+
+		uint32_t i;
+		for (i = 0; i < pw_impl_port_get_id(port) + 1; i++)
+			if (spa_json_get_string(&it[1], v, sizeof(v)) <= 0)
+				break;
+
+		if (i == pw_impl_port_get_id(port) + 1 && strlen(v) > 0) {
+			if (no_device_port_prefix) {
+				pw_properties_setf(new, PW_KEY_PORT_NAME, "%s", v);
+			} else {
+				pw_properties_setf(new, PW_KEY_PORT_NAME, "%s_%s", prefix, v);
+			}
+		}
+	}
+
+	pw_impl_port_update_properties(port, &new->dict);
+	pw_properties_free(new);
+}
+
+static const struct pw_impl_node_events node_events = {
+	PW_VERSION_IMPL_NODE_EVENTS,
+	.free = node_free,
+	.port_init = node_port_init,
+};
+
+static int handle_node_param(struct pw_impl_node *node, const char *key, const char *value)
+{
+	const struct spa_type_info *ti;
+	uint8_t buffer[1024];
+	struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buffer, sizeof(buffer));
+	struct spa_pod *pod;
+	int res;
+
+	ti = spa_debug_type_find_short(spa_type_param, key);
+	if (ti == NULL)
+		return -ENOENT;
+
+	if ((res = spa_json_to_pod(&b, 0, ti, value, strlen(value))) < 0)
+		return res;
+
+	if ((pod = spa_pod_builder_deref(&b, 0)) == NULL)
+		return -ENOSPC;
+
+	if ((res = pw_impl_node_set_param(node, ti->type, 0, pod)) < 0)
+		return res;
+
+	return 0;
+}
+
+static int find_format(struct spa_node *node, enum pw_direction direction,
+		uint32_t *media_type, uint32_t *media_subtype)
+{
+	uint32_t state = 0;
+	uint8_t buffer[4096];
+	struct spa_pod_builder b;
+	int res;
+	struct spa_pod *format;
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	if ((res = spa_node_port_enum_params_sync(node,
+				direction == PW_DIRECTION_INPUT ?
+					SPA_DIRECTION_INPUT :
+					SPA_DIRECTION_OUTPUT, 0,
+				SPA_PARAM_EnumFormat, &state,
+				NULL, &format, &b)) != 1) {
+		res = res < 0 ? res : -ENOENT;
+		pw_log_warn("%p: can't get format: %s", node, spa_strerror(res));
+		return res;
+	}
+
+	if ((res = spa_format_parse(format, media_type, media_subtype)) < 0)
+		return res;
+
+	pw_log_debug("%p: %s/%s", node,
+			spa_debug_type_find_name(spa_type_media_type, *media_type),
+			spa_debug_type_find_name(spa_type_media_subtype, *media_subtype));
+	return 0;
+}
+
+static int do_auto_port_config(struct node *n, const char *str)
+{
+	uint32_t state = 0, i;
+	uint8_t buffer[4096];
+	struct spa_pod_builder b;
+#define POSITION_PRESERVE 0
+#define POSITION_AUX 1
+#define POSITION_UNKNOWN 2
+	int res, position = POSITION_PRESERVE;
+	struct spa_pod *param;
+	uint32_t media_type, media_subtype;
+	bool have_format = false, monitor = false, control = false;
+	struct spa_audio_info format = { 0, };
+	enum spa_param_port_config_mode mode = SPA_PARAM_PORT_CONFIG_MODE_none;
+	struct spa_json it[2];
+	char key[1024], val[256];
+
+	spa_json_init(&it[0], str, strlen(str));
+	if (spa_json_enter_object(&it[0], &it[1]) <= 0)
+		return -EINVAL;
+
+	while (spa_json_get_string(&it[1], key, sizeof(key)) > 0) {
+		if (spa_json_get_string(&it[1], val, sizeof(val)) <= 0)
+			break;
+
+		if (spa_streq(key, "mode")) {
+			mode = spa_debug_type_find_type_short(spa_type_param_port_config_mode, val);
+			if (mode == SPA_ID_INVALID)
+				mode = SPA_PARAM_PORT_CONFIG_MODE_none;
+		} else if (spa_streq(key, "monitor")) {
+			monitor = spa_atob(val);
+		} else if (spa_streq(key, "control")) {
+			control = spa_atob(val);
+		} else if (spa_streq(key, "position")) {
+			if (spa_streq(val, "unknown"))
+				position = POSITION_UNKNOWN;
+			else if (spa_streq(val, "aux"))
+				position = POSITION_AUX;
+			else
+				position = POSITION_PRESERVE;
+		}
+        }
+
+	while (true) {
+		struct spa_audio_info info = { 0, };
+		struct spa_pod *position = NULL;
+		uint32_t n_position = 0;
+
+		spa_pod_builder_init(&b, buffer, sizeof(buffer));
+		if ((res = spa_node_port_enum_params_sync(n->follower,
+					n->direction == PW_DIRECTION_INPUT ?
+						SPA_DIRECTION_INPUT :
+						SPA_DIRECTION_OUTPUT, 0,
+					SPA_PARAM_EnumFormat, &state,
+					NULL, &param, &b)) != 1)
+			break;
+
+		if ((res = spa_format_parse(param, &media_type, &media_subtype)) < 0)
+			continue;
+
+		if (media_type != SPA_MEDIA_TYPE_audio ||
+		    media_subtype != SPA_MEDIA_SUBTYPE_raw)
+			continue;
+
+		spa_pod_object_fixate((struct spa_pod_object*)param);
+
+		if (spa_pod_parse_object(param,
+				SPA_TYPE_OBJECT_Format, NULL,
+				SPA_FORMAT_AUDIO_format,        SPA_POD_Id(&info.info.raw.format),
+				SPA_FORMAT_AUDIO_rate,          SPA_POD_Int(&info.info.raw.rate),
+				SPA_FORMAT_AUDIO_channels,      SPA_POD_Int(&info.info.raw.channels),
+				SPA_FORMAT_AUDIO_position,      SPA_POD_OPT_Pod(&position)) < 0)
+			continue;
+
+		if (position != NULL)
+			n_position = spa_pod_copy_array(position, SPA_TYPE_Id,
+					info.info.raw.position, SPA_AUDIO_MAX_CHANNELS);
+		if (n_position == 0 || n_position != info.info.raw.channels)
+			SPA_FLAG_SET(info.info.raw.flags, SPA_AUDIO_FLAG_UNPOSITIONED);
+
+		if (format.info.raw.channels >= info.info.raw.channels)
+			continue;
+
+		format = info;
+		have_format = true;
+	}
+	if (!have_format)
+		return -ENOENT;
+
+	if (position == POSITION_AUX) {
+		for (i = 0; i < format.info.raw.channels; i++)
+			format.info.raw.position[i] = SPA_AUDIO_CHANNEL_START_Aux + i;
+	} else if (position == POSITION_UNKNOWN) {
+		for (i = 0; i < format.info.raw.channels; i++)
+			format.info.raw.position[i] = SPA_AUDIO_CHANNEL_UNKNOWN;
+	}
+
+	spa_pod_builder_init(&b, buffer, sizeof(buffer));
+	param = spa_format_audio_raw_build(&b, SPA_PARAM_Format, &format.info.raw);
+	param = spa_pod_builder_add_object(&b,
+		SPA_TYPE_OBJECT_ParamPortConfig, SPA_PARAM_PortConfig,
+		SPA_PARAM_PORT_CONFIG_direction, SPA_POD_Id(n->direction),
+		SPA_PARAM_PORT_CONFIG_mode,      SPA_POD_Id(mode),
+		SPA_PARAM_PORT_CONFIG_monitor,   SPA_POD_Bool(monitor),
+		SPA_PARAM_PORT_CONFIG_control,   SPA_POD_Bool(control),
+		SPA_PARAM_PORT_CONFIG_format,    SPA_POD_Pod(param));
+	pw_impl_node_set_param(n->node, SPA_PARAM_PortConfig, 0, param);
+
+	return 0;
+}
+
+struct info_data {
+	struct spa_hook listener;
+	struct spa_node *node;
+	struct pw_properties *props;
+	uint32_t n_input_ports;
+	uint32_t max_input_ports;
+	uint32_t n_output_ports;
+	uint32_t max_output_ports;
+};
+
+static void info_event(void *data, const struct spa_node_info *info)
+{
+	struct info_data *d = data;
+
+	pw_properties_update(d->props, info->props);
+
+	d->max_input_ports = info->max_input_ports;
+	d->max_output_ports = info->max_output_ports;
+}
+
+static void port_info_event(void *data, enum spa_direction direction, uint32_t port,
+		const struct spa_port_info *info)
+{
+	struct info_data *d = data;
+
+	if (direction == SPA_DIRECTION_OUTPUT)
+		d->n_output_ports++;
+	else if (direction == SPA_DIRECTION_INPUT)
+		d->n_input_ports++;
+}
+
+static const struct spa_node_events node_info_events = {
+	.version = SPA_VERSION_NODE_EVENTS,
+	.info = info_event,
+	.port_info = port_info_event,
+};
+
+struct pw_impl_node *pw_adapter_new(struct pw_context *context,
+		struct spa_node *follower,
+		struct pw_properties *props,
+		size_t user_data_size)
+{
+	struct pw_impl_node *node;
+	struct node *n;
+	const char *str, *factory_name;
+	enum pw_direction direction;
+	int res;
+	uint32_t media_type, media_subtype;
+	const struct spa_dict_item *it;
+	struct pw_properties *copy;
+	struct info_data info;
+
+	spa_zero(info);
+	info.node = follower;
+	info.props = props;
+
+	res = spa_node_add_listener(info.node, &info.listener, &node_info_events, &info);
+	if (res < 0)
+		goto error;
+
+	spa_hook_remove(&info.listener);
+
+	pw_log_debug("%p: in %d/%d out %d/%d", info.node,
+			info.n_input_ports, info.max_input_ports,
+			info.n_output_ports, info.max_output_ports);
+
+	if (info.n_output_ports > 0) {
+		direction = PW_DIRECTION_OUTPUT;
+	} else if (info.n_input_ports > 0) {
+		direction = PW_DIRECTION_INPUT;
+	} else {
+		res = -EINVAL;
+		goto error;
+	}
+
+	if ((str = pw_properties_get(props, PW_KEY_NODE_ID)) != NULL)
+		pw_properties_set(props, PW_KEY_NODE_SESSION, str);
+
+	if (pw_properties_get(props, "factory.mode") == NULL) {
+		if (direction == PW_DIRECTION_INPUT)
+			str = "merge";
+		else
+			str = "split";
+		pw_properties_set(props, "factory.mode", str);
+	}
+
+	if ((res = find_format(follower, direction, &media_type, &media_subtype)) < 0)
+		goto error;
+
+	if (media_type == SPA_MEDIA_TYPE_audio) {
+		pw_properties_setf(props, "audio.adapt.follower", "pointer:%p", follower);
+		pw_properties_set(props, SPA_KEY_LIBRARY_NAME, "audioconvert/libspa-audioconvert");
+		if (pw_properties_get(props, PW_KEY_MEDIA_CLASS) == NULL)
+			pw_properties_setf(props, PW_KEY_MEDIA_CLASS, "Audio/%s",
+				direction == PW_DIRECTION_INPUT ? "Sink" : "Source");
+		factory_name = SPA_NAME_AUDIO_ADAPT;
+	}
+	else if (media_type == SPA_MEDIA_TYPE_video) {
+		pw_properties_setf(props, "video.adapt.follower", "pointer:%p", follower);
+		pw_properties_set(props, SPA_KEY_LIBRARY_NAME, "videoconvert/libspa-videoconvert");
+		if (pw_properties_get(props, PW_KEY_MEDIA_CLASS) == NULL)
+			pw_properties_setf(props, PW_KEY_MEDIA_CLASS, "Video/%s",
+				direction == PW_DIRECTION_INPUT ? "Sink" : "Source");
+		factory_name = SPA_NAME_VIDEO_ADAPT;
+	} else {
+		res = -ENOTSUP;
+		goto error;
+	}
+
+	copy = pw_properties_new(NULL, NULL);
+	spa_dict_for_each(it, &props->dict) {
+		if (!spa_strstartswith(it->key, "node.param.") &&
+		    !spa_strstartswith(it->key, "port.param."))
+			pw_properties_set(copy, it->key, it->value);
+	}
+	node = pw_spa_node_load(context,
+				factory_name,
+				PW_SPA_NODE_FLAG_ACTIVATE | PW_SPA_NODE_FLAG_NO_REGISTER,
+				copy, 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->context = context;
+	n->node = node;
+	n->follower = follower;
+	n->direction = direction;
+	n->props = props;
+	n->media_type = media_type;
+	n->media_subtype = media_subtype;
+	spa_list_init(&n->ports);
+
+	if (user_data_size > 0)
+		n->user_data = SPA_PTROFF(n, sizeof(struct node), void);
+
+	pw_impl_node_add_listener(node, &n->node_listener, &node_events, n);
+
+	if ((str = pw_properties_get(props, "adapter.auto-port-config")) != NULL)
+		do_auto_port_config(n, str);
+
+	spa_dict_for_each(it, &props->dict) {
+		if (spa_strstartswith(it->key, "node.param.")) {
+			if ((res = handle_node_param(node, &it->key[11], it->value)) < 0)
+				pw_log_warn("can't set node param: %s", spa_strerror(res));
+		}
+	}
+	return node;
+
+error:
+	pw_properties_free(props);
+	errno = -res;
+	return NULL;
+}
+
+void *pw_adapter_get_user_data(struct pw_impl_node *node)
+{
+	struct node *n = pw_spa_node_get_user_data(node);
+	return n->user_data;
+}