From 9f765897dbacee91544e89bff1791a9bca052b80 Mon Sep 17 00:00:00 2001 From: Wim Taymans Date: Thu, 7 Nov 2019 16:39:13 +0100 Subject: [PATCH] add missing files --- src/examples/media-session/monitor.c | 251 +++++ src/examples/media-session/policy.c | 1264 ++++++++++++++++++++++++++ 2 files changed, 1515 insertions(+) create mode 100644 src/examples/media-session/monitor.c create mode 100644 src/examples/media-session/policy.c diff --git a/src/examples/media-session/monitor.c b/src/examples/media-session/monitor.c new file mode 100644 index 000000000..3dec28a43 --- /dev/null +++ b/src/examples/media-session/monitor.c @@ -0,0 +1,251 @@ +/* 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 +#include +#include +#include +#include + +#include "config.h" + +#include +#include +#include +#include +#include +#include + +#include "pipewire/pipewire.h" +#include "pipewire/private.h" +#include "extensions/session-manager.h" + +#include + +#define NAME "media-session" + +#define DEFAULT_IDLE_SECONDS 3 + +struct impl; + +struct monitor { + struct impl *impl; + + struct spa_handle *handle; + + struct spa_device *monitor; + struct spa_hook listener; + + struct spa_list object_list; +}; + +struct impl { + struct timespec now; + + struct pw_core *core; + struct pw_remote *remote; + struct spa_hook remote_listener; + + struct pw_core_proxy *core_proxy; + + struct monitor bluez5_monitor; + struct monitor alsa_monitor; + struct monitor v4l2_monitor; + + struct sm_metadata *metadata; + + struct pw_client_session_proxy *client_session; + struct spa_hook client_session_listener; + struct pw_session_info client_session_info; + + struct spa_dbus *dbus; + struct spa_dbus_connection *dbus_connection; + DBusConnection *conn; + + struct pw_proxy *midi_bridge; + + struct spa_source *jack_timeout; + struct pw_proxy *jack_device; +}; + +struct alsa_object; + +static int setup_alsa_endpoint(struct alsa_object *obj); + +#include "alsa-monitor.c" +#include "alsa-endpoint.c" +#include "v4l2-monitor.c" +#include "bluez-monitor.c" +#include "metadata.c" + +static int client_session_set_id(void *object, uint32_t id) +{ + struct impl *impl = object; + + pw_log_debug("got sesssion id:%d", id); + impl->client_session_info.id = id; + + pw_client_session_proxy_update(impl->client_session, + PW_CLIENT_SESSION_UPDATE_INFO, + 0, NULL, + &impl->client_session_info); + return 0; +} + +static int client_session_set_param(void *object, uint32_t id, uint32_t flags, + const struct spa_pod *param) +{ + struct impl *impl = object; + pw_proxy_error((struct pw_proxy*)impl->client_session, + -ENOTSUP, "Session:SetParam not supported"); + return -ENOTSUP; +} + +static int client_session_link_set_param(void *object, uint32_t link_id, uint32_t id, uint32_t flags, + const struct spa_pod *param) +{ + struct impl *impl = object; + pw_proxy_error((struct pw_proxy*)impl->client_session, + -ENOTSUP, "Session:LinkSetParam not supported"); + return -ENOTSUP; +} + +static int client_session_create_link(void *object, const struct spa_dict *props) +{ + return -ENOTSUP; +} + +static int client_session_destroy_link(void *object, uint32_t link_id) +{ + return -ENOTSUP; +} + +static int client_session_link_request_state(void *object, uint32_t link_id, uint32_t state) +{ + return -ENOTSUP; +} + + +static const struct pw_client_session_proxy_events client_session_events = { + PW_VERSION_CLIENT_SESSION_PROXY_METHODS, + .set_id = client_session_set_id, + .set_param = client_session_set_param, + .link_set_param = client_session_link_set_param, + .create_link = client_session_create_link, + .destroy_link = client_session_destroy_link, + .link_request_state = client_session_link_request_state, +}; + +static void start_services(struct impl *impl) +{ + const struct spa_support *support; + uint32_t n_support; + + support = pw_core_get_support(impl->core, &n_support); + + impl->dbus = spa_support_find(support, n_support, SPA_TYPE_INTERFACE_DBus); + if (impl->dbus) + impl->dbus_connection = spa_dbus_get_connection(impl->dbus, DBUS_BUS_SESSION); + if (impl->dbus_connection) + impl->conn = spa_dbus_connection_get(impl->dbus_connection); + if (impl->conn == NULL) + pw_log_warn("no dbus connection, device reservation disabled"); + else + pw_log_debug("got dbus connection %p", impl->conn); + + pw_remote_export(impl->remote, + PW_TYPE_INTERFACE_Metadata, + NULL, + impl->metadata, + 0); + + impl->client_session = pw_core_proxy_create_object(impl->core_proxy, + "client-session", + PW_TYPE_INTERFACE_ClientSession, + PW_VERSION_CLIENT_SESSION_PROXY, + NULL, 0); + impl->client_session_info.version = PW_VERSION_SESSION_INFO; + + pw_client_session_proxy_add_listener(impl->client_session, + &impl->client_session_listener, + &client_session_events, + impl); + + bluez5_start_monitor(impl, &impl->bluez5_monitor); + alsa_start_monitor(impl, &impl->alsa_monitor); + alsa_start_midi_bridge(impl); + alsa_start_jack_device(impl); + v4l2_start_monitor(impl, &impl->v4l2_monitor); +} + +static void on_state_changed(void *_data, enum pw_remote_state old, enum pw_remote_state state, const char *error) +{ + struct impl *impl = _data; + + switch (state) { + case PW_REMOTE_STATE_ERROR: + pw_log_error(NAME" %p: remote error: %s", impl, error); + break; + + case PW_REMOTE_STATE_CONNECTED: + pw_log_info(NAME" %p: connected", impl); + impl->core_proxy = pw_remote_get_core_proxy(impl->remote); + start_services(impl); + break; + + case PW_REMOTE_STATE_UNCONNECTED: + pw_log_info(NAME" %p: disconnected", impl); + impl->core_proxy = NULL; + break; + + default: + printf("remote state: \"%s\"\n", pw_remote_state_as_string(state)); + break; + } +} + +static const struct pw_remote_events remote_events = { + PW_VERSION_REMOTE_EVENTS, + .state_changed = on_state_changed, +}; + +int sm_monitor_start(struct pw_remote *remote) +{ + struct impl *impl; + + impl = calloc(1, sizeof(*impl)); + if (impl == NULL) + return -errno; + + impl->core = pw_remote_get_core(remote); + impl->remote = remote; + + clock_gettime(CLOCK_MONOTONIC, &impl->now); + + impl->metadata = sm_metadata_new(NULL); + + pw_remote_add_listener(impl->remote, &impl->remote_listener, &remote_events, impl); + + return 0; +} diff --git a/src/examples/media-session/policy.c b/src/examples/media-session/policy.c new file mode 100644 index 000000000..c5b3be323 --- /dev/null +++ b/src/examples/media-session/policy.c @@ -0,0 +1,1264 @@ +/* PipeWire + * + * 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 +#include +#include +#include +#include + +#include "config.h" + +#include +#include +#include +#include +#include + +#include "pipewire/pipewire.h" +#include "pipewire/private.h" +#include "extensions/session-manager.h" + +#define NAME "media-session" + +#define DEFAULT_CHANNELS 2 +#define DEFAULT_SAMPLERATE 48000 + +#define DEFAULT_IDLE_SECONDS 3 + +struct impl; + +struct impl { + struct timespec now; + + struct pw_core *core; + struct pw_remote *remote; + struct spa_hook remote_listener; + + struct pw_core_proxy *core_proxy; + struct spa_hook core_listener; + + struct pw_registry_proxy *registry_proxy; + struct spa_hook registry_listener; + + struct pw_map globals; + + struct spa_list client_list; + struct spa_list node_list; + struct spa_list session_list; + int seq; +}; + +struct object { + struct impl *impl; + uint32_t id; + uint32_t type; + struct pw_proxy *proxy; + struct spa_hook listener; +}; + +struct client { + struct object obj; + + struct spa_list l; + + struct spa_hook listener; + struct pw_client_info *info; +}; + +struct node { + struct object obj; + + struct spa_list l; + + struct spa_hook listener; + struct pw_node_info *info; + + uint32_t client_id; + + struct spa_list session_link; + struct session *session; + + struct node *peer; + + struct session *manager; + struct spa_list port_list; + + enum pw_direction direction; +#define NODE_TYPE_UNKNOWN 0 +#define NODE_TYPE_STREAM 1 +#define NODE_TYPE_DEVICE 2 + uint32_t type; + char *media; + + uint32_t media_type; + uint32_t media_subtype; + struct spa_audio_info_raw format; +}; + +struct port { + struct object obj; + + struct spa_list l; + enum pw_direction direction; + struct pw_port_info *info; + struct node *node; +#define PORT_FLAG_NONE 0 +#define PORT_FLAG_DSP (1<<0) +#define PORT_FLAG_SKIP (1<<1) + uint32_t flags; + + struct spa_hook listener; +}; + +struct link { + struct object obj; + struct port *out; + struct port *in; +}; + +struct session { + struct spa_list l; + + uint32_t id; + + struct impl *impl; + enum pw_direction direction; + int priority; + uint64_t plugged; + + struct node *node; + + struct spa_list node_list; + + struct spa_hook listener; + + struct spa_source *idle_timeout; + + bool starting; + bool enabled; + bool busy; + bool exclusive; + bool need_dsp; +}; + +static void add_object(struct impl *impl, struct object *obj) +{ + size_t size = pw_map_get_size(&impl->globals); + while (obj->id > size) + pw_map_insert_at(&impl->globals, size++, NULL); + pw_map_insert_at(&impl->globals, obj->id, obj); +} + +static void remove_object(struct impl *impl, struct object *obj) +{ + pw_map_insert_at(&impl->globals, obj->id, NULL); +} + +static void *find_object(struct impl *impl, uint32_t id) +{ + void *obj; + if ((obj = pw_map_lookup(&impl->globals, id)) != NULL) + return obj; + return NULL; +} + +static void schedule_rescan(struct impl *impl) +{ + if (impl->core_proxy) + impl->seq = pw_core_proxy_sync(impl->core_proxy, 0, impl->seq); +} + +static void remove_idle_timeout(struct session *sess) +{ + struct impl *impl = sess->impl; + struct pw_loop *main_loop = pw_core_get_main_loop(impl->core); + + if (sess->idle_timeout) { + pw_loop_destroy_source(main_loop, sess->idle_timeout); + sess->idle_timeout = NULL; + } +} + +static void idle_timeout(void *data, uint64_t expirations) +{ + struct session *sess = data; + struct impl *impl = sess->impl; + struct spa_command *cmd = &SPA_NODE_COMMAND_INIT(SPA_NODE_COMMAND_Suspend); + + pw_log_debug(NAME " %p: session %d idle timeout", impl, sess->id); + + remove_idle_timeout(sess); + + pw_node_proxy_send_command((struct pw_node_proxy*)sess->node->obj.proxy, cmd); +} + +static void add_idle_timeout(struct session *sess) +{ + struct timespec value; + struct impl *impl = sess->impl; + struct pw_loop *main_loop = pw_core_get_main_loop(impl->core); + + if (sess->idle_timeout == NULL) + sess->idle_timeout = pw_loop_add_timer(main_loop, idle_timeout, sess); + + value.tv_sec = DEFAULT_IDLE_SECONDS; + value.tv_nsec = 0; + pw_loop_update_timer(main_loop, sess->idle_timeout, &value, NULL, false); +} + +static int on_node_idle(struct impl *impl, struct node *node) +{ + struct session *sess = node->manager; + + if (sess == NULL) + return 0; + + switch (node->type) { + case NODE_TYPE_DEVICE: + pw_log_debug(NAME" %p: device idle for session %d", impl, sess->id); + sess->busy = false; + sess->exclusive = false; + add_idle_timeout(sess); + break; + default: + break; + } + return 0; +} + +static int on_node_running(struct impl *impl, struct node *node) +{ + struct session *sess = node->manager; + + if (sess == NULL) + return 0; + + switch (node->type) { + case NODE_TYPE_DEVICE: + pw_log_debug(NAME" %p: device running or session %d", impl, sess->id); + remove_idle_timeout(sess); + break; + default: + break; + } + return 0; +} + +static void node_event_info(void *object, const struct pw_node_info *info) +{ + struct node *n = object; + struct impl *impl = n->obj.impl; + + pw_log_debug(NAME" %p: info for node %d type %d", impl, n->obj.id, n->type); + n->info = pw_node_info_update(n->info, info); + + if (info->change_mask & PW_NODE_CHANGE_MASK_STATE) { + switch (info->state) { + case PW_NODE_STATE_IDLE: + on_node_idle(impl, n); + break; + case PW_NODE_STATE_RUNNING: + on_node_running(impl, n); + break; + case PW_NODE_STATE_SUSPENDED: + break; + default: + break; + } + } +} + +static void node_event_param(void *object, int seq, + uint32_t id, uint32_t index, uint32_t next, + const struct spa_pod *param) +{ + struct node *n = object; + struct impl *impl = n->obj.impl; + struct spa_audio_info_raw info = { 0, }; + + pw_log_debug(NAME" %p: param for node %d, %d", impl, n->obj.id, id); + + if (id != SPA_PARAM_EnumFormat) + goto error; + + if (spa_format_parse(param, &n->media_type, &n->media_subtype) < 0) + goto error; + + if (n->media_type != SPA_MEDIA_TYPE_audio || + n->media_subtype != SPA_MEDIA_SUBTYPE_raw) + return; + + spa_pod_object_fixate((struct spa_pod_object*)param); + if (pw_log_level_enabled(SPA_LOG_LEVEL_DEBUG)) + spa_debug_pod(2, NULL, param); + + if (spa_format_audio_raw_parse(param, &info) < 0) + goto error; + + if (n->format.channels < info.channels) + n->format = info; + return; + + error: + pw_log_warn("unhandled param:"); + if (pw_log_level_enabled(SPA_LOG_LEVEL_WARN)) + spa_debug_pod(2, NULL, param); + return; +} + +static const struct pw_node_proxy_events node_events = { + PW_VERSION_NODE_PROXY_EVENTS, + .info = node_event_info, + .param = node_event_param, +}; + +static void remove_session(struct impl *impl, struct session *sess) +{ + struct node *n, *t; + + pw_log_debug(NAME " %p: remove session '%d'", impl, sess->id); + remove_idle_timeout(sess); + + spa_list_for_each_safe(n, t, &sess->node_list, session_link) { + n->session = NULL; + spa_list_remove(&n->session_link); + } + + spa_list_remove(&sess->l); + free(sess); +} + +static void node_proxy_destroy(void *data) +{ + struct node *n = data; + struct impl *impl = n->obj.impl; + struct port *p, *t; + + pw_log_debug(NAME " %p: proxy destroy node %d", impl, n->obj.id); + + spa_list_remove(&n->l); + + spa_list_for_each_safe(p, t, &n->port_list, l) { + spa_list_remove(&p->l); + p->node = NULL; + } + if (n->info) + pw_node_info_free(n->info); + free(n->media); + if (n->session) { + spa_list_remove(&n->session_link); + n->session = NULL; + } + if (n->manager) { + switch (n->type) { + case NODE_TYPE_DEVICE: + remove_session(impl, n->manager); + n->manager = NULL; + break; + } + } +} + +static const struct pw_proxy_events node_proxy_events = { + PW_VERSION_PROXY_EVENTS, + .destroy = node_proxy_destroy, +}; + +static int +handle_node(struct impl *impl, uint32_t id, + uint32_t type, const struct spa_dict *props) +{ + const char *str, *media_class; + bool need_dsp = false; + enum pw_direction direction; + struct pw_proxy *p; + struct node *node; + uint32_t client_id = SPA_ID_INVALID; + + if (props && (str = spa_dict_lookup(props, PW_KEY_CLIENT_ID)) != NULL) + client_id = atoi(str); + + p = pw_registry_proxy_bind(impl->registry_proxy, + id, type, PW_VERSION_NODE_PROXY, + sizeof(struct node)); + + node = pw_proxy_get_user_data(p); + node->obj.impl = impl; + node->obj.id = id; + node->obj.type = type; + node->obj.proxy = p; + node->client_id = client_id; + spa_list_init(&node->port_list); + pw_proxy_add_listener(p, &node->obj.listener, &node_proxy_events, node); + pw_proxy_add_object_listener(p, &node->listener, &node_events, node); + add_object(impl, &node->obj); + spa_list_append(&impl->node_list, &node->l); + node->type = NODE_TYPE_UNKNOWN; + + media_class = props ? spa_dict_lookup(props, PW_KEY_MEDIA_CLASS) : NULL; + + pw_log_debug(NAME" %p: node "PW_KEY_MEDIA_CLASS" %s", impl, media_class); + + if (media_class == NULL) + return 0; + + if (strstr(media_class, "Stream/") == media_class) { + media_class += strlen("Stream/"); + + if (strstr(media_class, "Output/") == media_class) { + direction = PW_DIRECTION_OUTPUT; + media_class += strlen("Output/"); + } + else if (strstr(media_class, "Input/") == media_class) { + direction = PW_DIRECTION_INPUT; + media_class += strlen("Input/"); + } + else + return 0; + + node->direction = direction; + node->type = NODE_TYPE_STREAM; + node->media = strdup(media_class); + pw_log_debug(NAME "%p: node %d is stream %s", impl, id, node->media); + + } + else { + struct session *sess; + + if (strstr(media_class, "Audio/") == media_class) { + need_dsp = true; + media_class += strlen("Audio/"); + } + else if (strstr(media_class, "Video/") == media_class) { + media_class += strlen("Video/"); + } + else + return 0; + + if (strcmp(media_class, "Sink") == 0) + direction = PW_DIRECTION_OUTPUT; + else if (strcmp(media_class, "Source") == 0) + direction = PW_DIRECTION_INPUT; + else + return 0; + + sess = calloc(1, sizeof(struct session)); + sess->impl = impl; + sess->direction = direction; + sess->id = id; + sess->need_dsp = need_dsp; + sess->enabled = false; + sess->starting = need_dsp; + sess->node = node; + if ((str = spa_dict_lookup(props, PW_KEY_NODE_PLUGGED)) != NULL) + sess->plugged = pw_properties_parse_uint64(str); + else + sess->plugged = SPA_TIMESPEC_TO_NSEC(&impl->now); + + if ((str = spa_dict_lookup(props, PW_KEY_PRIORITY_SESSION)) != NULL) + sess->priority = pw_properties_parse_int(str); + else + sess->priority = 0; + + spa_list_init(&sess->node_list); + spa_list_append(&impl->session_list, &sess->l); + + node->direction = direction; + node->type = NODE_TYPE_DEVICE; + node->manager = sess; + + pw_log_debug(NAME" %p: new session for device node %d %d prio:%d", impl, id, + need_dsp, sess->priority); + } + pw_node_proxy_enum_params((struct pw_node_proxy*)p, + 0, SPA_PARAM_EnumFormat, + 0, -1, NULL); + return 1; +} + +static void port_event_info(void *object, const struct pw_port_info *info) +{ + struct port *p = object; + pw_log_debug(NAME" %p: info for port %d", p->obj.impl, p->obj.id); + p->info = pw_port_info_update(p->info, info); +} + +static void port_event_param(void *object, int seq, + uint32_t id, uint32_t index, uint32_t next, + const struct spa_pod *param) +{ + struct port *p = object; + struct node *node = p->node; + struct spa_audio_info_raw info = { 0, }; + + pw_log_debug(NAME" %p: param for port %d", p->obj.impl, p->obj.id); + + if (node == NULL) + return; + + if (id != SPA_PARAM_EnumFormat) + return; + + if (node->manager) + node->manager->enabled = true; + + if (spa_format_parse(param, &node->media_type, &node->media_subtype) < 0) + return; + + if (node->media_type != SPA_MEDIA_TYPE_audio || + node->media_subtype != SPA_MEDIA_SUBTYPE_raw) + return; + + spa_pod_fixate((struct spa_pod*)param); + + if (spa_format_audio_raw_parse(param, &info) < 0) + return; + + if (info.channels > node->format.channels) + node->format = info; +} + +static const struct pw_port_proxy_events port_events = { + PW_VERSION_PORT_PROXY_EVENTS, + .info = port_event_info, + .param = port_event_param, +}; + +static void port_proxy_destroy(void *data) +{ + struct port *p = data; + + pw_log_debug(NAME " %p: proxy destroy port %d", p->obj.impl, p->obj.id); + + if (p->node) { + spa_list_remove(&p->l); + p->node = NULL; + } + if (p->info) + pw_port_info_free(p->info); +} + +static const struct pw_proxy_events port_proxy_events = { + PW_VERSION_PROXY_EVENTS, + .destroy = port_proxy_destroy, +}; + +static int +handle_port(struct impl *impl, uint32_t id, uint32_t type, + const struct spa_dict *props) +{ + struct port *port; + struct pw_proxy *p; + struct node *node; + const char *str; + uint32_t node_id; + + if (props == NULL || (str = spa_dict_lookup(props, PW_KEY_NODE_ID)) == NULL) + return -EINVAL; + + node_id = atoi(str); + + if ((node = find_object(impl, node_id)) == NULL) + return -ESRCH; + + if (props == NULL || (str = spa_dict_lookup(props, PW_KEY_PORT_DIRECTION)) == NULL) + return -EINVAL; + + p = pw_registry_proxy_bind(impl->registry_proxy, + id, type, PW_VERSION_PORT_PROXY, + sizeof(struct port)); + + port = pw_proxy_get_user_data(p); + port->obj.impl = impl; + port->obj.id = id; + port->obj.type = type; + port->obj.proxy = p; + port->node = node; + port->direction = strcmp(str, "out") ? PW_DIRECTION_OUTPUT : PW_DIRECTION_INPUT; + + if (props != NULL && (str = spa_dict_lookup(props, PW_KEY_FORMAT_DSP)) != NULL) + port->flags |= PORT_FLAG_DSP; + + pw_proxy_add_listener(p, &port->obj.listener, &port_proxy_events, port); + pw_proxy_add_object_listener(p, &port->listener, &port_events, port); + add_object(impl, &port->obj); + + spa_list_append(&node->port_list, &port->l); + + pw_log_debug(NAME" %p: new port %d for node %d type %d %08x", impl, id, node_id, + node->type, port->flags); + + if (node->type == NODE_TYPE_DEVICE) { + pw_port_proxy_enum_params((struct pw_port_proxy*)p, + 0, SPA_PARAM_EnumFormat, + 0, -1, NULL); + } + + + return 0; +} + +static void client_event_info(void *object, const struct pw_client_info *info) +{ + struct client *c = object; + uint32_t i; + + pw_log_debug(NAME" %p: info for client %d", c->obj.impl, c->obj.id); + c->info = pw_client_info_update(c->info, info); + for (i = 0; i < info->props->n_items; i++) + pw_log_debug(NAME" %p: %s = %s", c, + info->props->items[i].key, + info->props->items[i].value); +} + +static const struct pw_client_proxy_events client_events = { + PW_VERSION_CLIENT_PROXY_EVENTS, + .info = client_event_info, +}; + +static void client_proxy_destroy(void *data) +{ + struct client *c = data; + + pw_log_debug(NAME " %p: proxy destroy client %d", c->obj.impl, c->obj.id); + + spa_list_remove(&c->l); + if (c->info) + pw_client_info_free(c->info); +} + +static const struct pw_proxy_events client_proxy_events = { + PW_VERSION_PROXY_EVENTS, + .destroy = client_proxy_destroy, +}; + +static int +handle_client(struct impl *impl, uint32_t id, + uint32_t type, const struct spa_dict *props) +{ + struct pw_proxy *p; + struct client *client; + struct pw_permission perms[2]; + const char *str; + + p = pw_registry_proxy_bind(impl->registry_proxy, + id, type, PW_VERSION_CLIENT_PROXY, + sizeof(struct client)); + + client = pw_proxy_get_user_data(p); + client->obj.impl = impl; + client->obj.id = id; + client->obj.type = type; + client->obj.proxy = p; + + pw_proxy_add_listener(p, &client->obj.listener, &client_proxy_events, client); + pw_proxy_add_object_listener(p, &client->listener, &client_events, client); + add_object(impl, &client->obj); + spa_list_append(&impl->client_list, &client->l); + + if (props == NULL) + return 0; + + str = spa_dict_lookup(props, PW_KEY_ACCESS); + if (str == NULL) + return 0; + + if (strcmp(str, "restricted") == 0) { + perms[0] = PW_PERMISSION_INIT(-1, PW_PERM_RWX); + pw_client_proxy_update_permissions((struct pw_client_proxy*)p, + 1, perms); + } + return 0; +} + +static void +registry_global(void *data,uint32_t id, + uint32_t permissions, uint32_t type, uint32_t version, + const struct spa_dict *props) +{ + struct impl *impl = data; + int res; + + pw_log_debug(NAME " %p: new global '%d' %d", impl, id, type); + + switch (type) { + case PW_TYPE_INTERFACE_Client: + res = handle_client(impl, id, type, props); + break; + + case PW_TYPE_INTERFACE_Node: + res = handle_node(impl, id, type, props); + break; + + case PW_TYPE_INTERFACE_Port: + res = handle_port(impl, id, type, props); + break; + + default: + res = 0; + break; + } + if (res < 0) { + pw_log_warn(NAME" %p: can't handle global %d", impl, id); + } + else + schedule_rescan(impl); +} + +static void +registry_global_remove(void *data, uint32_t id) +{ + struct impl *impl = data; + struct object *obj; + + pw_log_debug(NAME " %p: remove global '%d'", impl, id); + + if ((obj = find_object(impl, id)) == NULL) + return; + + switch (obj->type) { + case PW_TYPE_INTERFACE_Node: + { + struct node *node = (struct node*) obj, *n; + if (node->manager) + remove_session(impl, node->manager); + node->manager = NULL; + + spa_list_for_each(n, &impl->node_list, l) { + if (n->peer == node) + n->peer = NULL; + } + break; + } + default: + break; + } + remove_object(impl, obj); + schedule_rescan(impl); +} + +static const struct pw_registry_proxy_events registry_events = { + PW_VERSION_REGISTRY_PROXY_EVENTS, + .global = registry_global, + .global_remove = registry_global_remove, +}; + + +struct find_data { + struct impl *impl; + uint32_t path_id; + const char *media_class; + struct session *sess; + bool exclusive; + int priority; + uint64_t plugged; +}; + +static int find_session(void *data, struct session *sess) +{ + struct find_data *find = data; + struct impl *impl = find->impl; + const struct spa_dict *props; + const char *str; + int priority = 0; + uint64_t plugged = 0; + + pw_log_debug(NAME " %p: looking at session '%d' enabled:%d busy:%d exclusive:%d", + impl, sess->id, sess->enabled, sess->busy, sess->exclusive); + + if (!sess->enabled) + return 0; + + if (find->path_id != SPA_ID_INVALID && sess->id != find->path_id) + return 0; + + if (find->path_id == SPA_ID_INVALID) { + if ((props = sess->node->info->props) == NULL) + return 0; + + if ((str = spa_dict_lookup(props, PW_KEY_MEDIA_CLASS)) == NULL) + return 0; + + if (strcmp(str, find->media_class) != 0) + return 0; + + plugged = sess->plugged; + priority = sess->priority; + } + + if ((find->exclusive && sess->busy) || sess->exclusive) { + pw_log_debug(NAME " %p: session '%d' in use", impl, sess->id); + return 0; + } + + pw_log_debug(NAME " %p: found session '%d' %"PRIu64" prio:%d", impl, + sess->id, plugged, priority); + + if (find->sess == NULL || + priority > find->priority || + (priority == find->priority && plugged > find->plugged)) { + pw_log_debug(NAME " %p: new best %d %" PRIu64, impl, priority, plugged); + find->sess = sess; + find->priority = priority; + find->plugged = plugged; + } + return 0; +} + +static int link_nodes(struct node *peer, enum pw_direction direction, struct node *node, int max) +{ + struct impl *impl = peer->obj.impl; + struct port *p; + + pw_log_debug(NAME " %p: link nodes %d %d %d", impl, max, node->obj.id, peer->obj.id); + + spa_list_for_each(p, &peer->port_list, l) { + struct pw_properties *props; + + pw_log_debug(NAME " %p: port %p: %d %d", impl, p, p->direction, p->flags); + + if (p->direction == direction) + continue; + if (p->flags & PORT_FLAG_SKIP) + continue; + + if (max-- == 0) + return 0; + + props = pw_properties_new(NULL, NULL); + if (p->direction == PW_DIRECTION_OUTPUT) { + pw_properties_setf(props, PW_KEY_LINK_OUTPUT_NODE, "%d", node->obj.id); + pw_properties_setf(props, PW_KEY_LINK_OUTPUT_PORT, "%d", -1); + pw_properties_setf(props, PW_KEY_LINK_INPUT_NODE, "%d", peer->obj.id); + pw_properties_setf(props, PW_KEY_LINK_INPUT_PORT, "%d", p->obj.id); + pw_log_debug(NAME " %p: node %d -> port %d:%d", impl, + node->obj.id, peer->obj.id, p->obj.id); + + } + else { + pw_properties_setf(props, PW_KEY_LINK_OUTPUT_NODE, "%d", peer->obj.id); + pw_properties_setf(props, PW_KEY_LINK_OUTPUT_PORT, "%d", p->obj.id); + pw_properties_setf(props, PW_KEY_LINK_INPUT_NODE, "%d", node->obj.id); + pw_properties_setf(props, PW_KEY_LINK_INPUT_PORT, "%d", -1); + pw_log_debug(NAME " %p: port %d:%d -> node %d", impl, + peer->obj.id, p->obj.id, node->obj.id); + } + + pw_core_proxy_create_object(impl->core_proxy, + "link-factory", + PW_TYPE_INTERFACE_Link, + PW_VERSION_LINK_PROXY, + &props->dict, + 0); + + pw_properties_free(props); + } + node->peer = peer; + + return 0; +} + +static void stream_set_volume(struct impl *impl, struct node *node, float volume, bool mute) +{ + char buf[1024]; + struct spa_pod_builder b = SPA_POD_BUILDER_INIT(buf, sizeof(buf)); + + pw_log_debug(NAME " %p: node %d set volume:%f mute:%d", impl, node->obj.id, volume, mute); + + pw_node_proxy_set_param((struct pw_node_proxy*)node->obj.proxy, + SPA_PARAM_Props, 0, + spa_pod_builder_add_object(&b, + SPA_TYPE_OBJECT_Props, SPA_PARAM_Props, + SPA_PROP_volume, SPA_POD_Float(volume), + SPA_PROP_mute, SPA_POD_Bool(mute))); +} + +static int rescan_node(struct impl *impl, struct node *node) +{ + struct spa_dict *props; + const char *str, *media, *category, *role; + bool exclusive; + struct find_data find; + struct session *session; + struct pw_node_info *info; + struct node *peer; + enum pw_direction direction; + struct spa_pod_builder b = { 0, }; + struct spa_audio_info_raw audio_info = { 0, }; + struct spa_pod *param; + char buf[1024]; + int n_links = 0; + + if (node->type == NODE_TYPE_DEVICE) + return 0; + + if (node->session != NULL || node->peer != NULL) + return 0; + + if (node->info == NULL || node->info->props == NULL) { + pw_log_debug(NAME " %p: node %d has no properties", impl, node->obj.id); + return 0; + } + + info = node->info; + props = info->props; + + str = spa_dict_lookup(props, PW_KEY_NODE_AUTOCONNECT); + if (str == NULL || !pw_properties_parse_bool(str)) { + pw_log_debug(NAME" %p: node %d does not need autoconnect", impl, node->obj.id); + return 0; + } + + if ((media = spa_dict_lookup(props, PW_KEY_MEDIA_TYPE)) == NULL) + media = node->media; + if (media == NULL) { + pw_log_debug(NAME" %p: node %d has unknown media", impl, node->obj.id); + return 0; + } + + spa_zero(find); + + if ((category = spa_dict_lookup(props, PW_KEY_MEDIA_CATEGORY)) == NULL) { + pw_log_debug(NAME" %p: node %d find category from ports: %d %d", + impl, node->obj.id, info->n_input_ports, info->n_output_ports); + if (node->direction == PW_DIRECTION_INPUT || + (info->n_input_ports > 0 && info->n_output_ports == 0)) + category = "Capture"; + else if (node->direction == PW_DIRECTION_OUTPUT || + (info->n_output_ports > 0 && info->n_input_ports == 0)) + category = "Playback"; + else if (info->n_output_ports > 0 && info->n_input_ports > 0) + category = "Duplex"; + else { + pw_log_warn(NAME" %p: node %d can't determine category", + impl, node->obj.id); + return -EINVAL; + } + } + + if ((role = spa_dict_lookup(props, PW_KEY_MEDIA_ROLE)) == NULL) { + if (strcmp(media, "Audio") == 0) { + if (strcmp(category, "Duplex") == 0) + role = "Communication"; + else if (strcmp(category, "Capture") == 0) + role = "Production"; + else + role = "Music"; + } + else if (strcmp(media, "Video") == 0) { + if (strcmp(category, "Duplex") == 0) + role = "Communication"; + else if (strcmp(category, "Capture") == 0) + role = "Camera"; + else + role = "Video"; + } + } + + if ((str = spa_dict_lookup(props, PW_KEY_NODE_EXCLUSIVE)) != NULL) + exclusive = pw_properties_parse_bool(str); + else + exclusive = false; + + if (strcmp(media, "Audio") == 0) { + if (strcmp(category, "Playback") == 0) + find.media_class = "Audio/Sink"; + else if (strcmp(category, "Capture") == 0) + find.media_class = "Audio/Source"; + else { + pw_log_debug(NAME" %p: node %d unhandled category %s", + impl, node->obj.id, category); + return -EINVAL; + } + } + else if (strcmp(media, "Video") == 0) { + if (strcmp(category, "Capture") == 0) + find.media_class = "Video/Source"; + else { + pw_log_debug(NAME" %p: node %d unhandled category %s", + impl, node->obj.id, category); + return -EINVAL; + } + } + else { + pw_log_debug(NAME" %p: node %d unhandled media %s", + impl, node->obj.id, media); + return -EINVAL; + } + + if (strcmp(category, "Capture") == 0) + direction = PW_DIRECTION_OUTPUT; + else if (strcmp(category, "Playback") == 0) + direction = PW_DIRECTION_INPUT; + else { + pw_log_debug(NAME" %p: node %d unhandled category %s", + impl, node->obj.id, category); + return -EINVAL; + } + + str = spa_dict_lookup(props, PW_KEY_NODE_TARGET); + if (str != NULL) + find.path_id = atoi(str); + else + find.path_id = SPA_ID_INVALID; + + pw_log_info(NAME " %p: '%s' '%s' '%s' exclusive:%d target %d", impl, + media, category, role, exclusive, find.path_id); + + find.impl = impl; + find.exclusive = exclusive; + + spa_list_for_each(session, &impl->session_list, l) + find_session(&find, session); + + if (find.sess == NULL && find.path_id != SPA_ID_INVALID) { + pw_log_debug(NAME " %p: no session found for %d, try node", impl, node->obj.id); + + n_links = 1; + if ((peer = find_object(impl, find.path_id)) != NULL) { + if (peer->obj.type == PW_TYPE_INTERFACE_Node) { + if (peer->media_type == SPA_MEDIA_TYPE_audio) + goto do_link_profile; + else + goto do_link; + } + } + else { + str = spa_dict_lookup(props, PW_KEY_NODE_DONT_RECONNECT); + if (str != NULL && pw_properties_parse_bool(str)) { + pw_registry_proxy_destroy(impl->registry_proxy, node->obj.id); + return -ENOENT; + } + } + } + + if (find.sess == NULL) { + struct client *client; + + pw_log_warn(NAME " %p: no session found for %d", impl, node->obj.id); + + client = find_object(impl, node->client_id); + if (client && client->obj.type == PW_TYPE_INTERFACE_Client) { + pw_client_proxy_error((struct pw_client_proxy*)client->obj.proxy, + node->obj.id, -ENOENT, "no session available"); + } + return -ENOENT; + } + + session = find.sess; + + if (session->starting) { + pw_log_info(NAME " %p: session %d is starting", impl, session->id); + return 0; + } + + if (exclusive && session->busy) { + pw_log_warn(NAME" %p: session %d busy, can't get exclusive access", impl, session->id); + return -EBUSY; + } + peer = session->node; + session->exclusive = exclusive; + + pw_log_debug(NAME" %p: linking to session '%d'", impl, session->id); + + session->busy = true; + node->session = session; + spa_list_append(&session->node_list, &node->session_link); + + if (!exclusive && peer->media_type == SPA_MEDIA_TYPE_audio) { +do_link_profile: + audio_info = peer->format; + + if (direction == PW_DIRECTION_INPUT) + audio_info.channels = SPA_MIN(audio_info.channels, node->format.channels); + else + audio_info.channels = SPA_MAX(audio_info.channels, node->format.channels); + + pw_log_debug(NAME" %p: channels: %d -> %d", impl, + node->format.channels, audio_info.channels); + + audio_info.rate = DEFAULT_SAMPLERATE; + + 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_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_PortConfig, 0, param); + + stream_set_volume(impl, node, 1.0, false); + n_links = audio_info.channels; + } else { + n_links = audio_info.channels = 1; + } +do_link: + link_nodes(peer, direction, node, n_links); + + return 1; +} + +static void rescan_session(struct impl *impl, struct session *sess) +{ + struct node *node = sess->node; + struct spa_audio_info_raw info = { 0, }; + uint8_t buf[1024]; + struct spa_pod_builder b = { 0, }; + struct spa_pod *param; + + if (!sess->starting) + return; + + if (node->info->props == NULL) { + pw_log_debug(NAME " %p: node %p has no properties", impl, node); + return; + } + + if (node->media_type != SPA_MEDIA_TYPE_audio || + node->media_subtype != SPA_MEDIA_SUBTYPE_raw) { + pw_log_debug(NAME " %p: node %p has no media type", impl, node); + return; + } + + info = node->format; + info.rate = DEFAULT_SAMPLERATE; + + 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_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_PortConfig, 0, param); + schedule_rescan(impl); + + sess->starting = false; +} + +static void do_rescan(struct impl *impl) +{ + struct session *sess; + struct node *node; + + clock_gettime(CLOCK_MONOTONIC, &impl->now); + pw_log_debug("media-session %p: do rescan", impl); + + spa_list_for_each(sess, &impl->session_list, l) + rescan_session(impl, sess); + spa_list_for_each(node, &impl->node_list, l) + rescan_node(impl, node); +} + +static void core_done(void *data, uint32_t id, int seq) +{ + struct impl *impl = data; + pw_log_debug("media-session %p: sync %u %d/%d", impl, id, seq, impl->seq); + if (impl->seq == seq) + do_rescan(impl); +} + +static const struct pw_core_proxy_events core_events = { + PW_VERSION_CORE_EVENTS, + .done = core_done +}; + +static void on_state_changed(void *_data, enum pw_remote_state old, enum pw_remote_state state, const char *error) +{ + struct impl *impl = _data; + + switch (state) { + case PW_REMOTE_STATE_ERROR: + pw_log_error(NAME" %p: remote error: %s", impl, error); + break; + + case PW_REMOTE_STATE_CONNECTED: + pw_log_info(NAME" %p: connected", impl); + impl->core_proxy = pw_remote_get_core_proxy(impl->remote); + pw_core_proxy_add_listener(impl->core_proxy, + &impl->core_listener, + &core_events, impl); + impl->registry_proxy = pw_core_proxy_get_registry(impl->core_proxy, + PW_VERSION_REGISTRY_PROXY, 0); + pw_registry_proxy_add_listener(impl->registry_proxy, + &impl->registry_listener, + ®istry_events, impl); + schedule_rescan(impl); + break; + + case PW_REMOTE_STATE_UNCONNECTED: + pw_log_info(NAME" %p: disconnected", impl); + impl->core_proxy = NULL; + impl->registry_proxy = NULL; + break; + + default: + printf("remote state: \"%s\"\n", pw_remote_state_as_string(state)); + break; + } +} + +static const struct pw_remote_events remote_events = { + PW_VERSION_REMOTE_EVENTS, + .state_changed = on_state_changed, +}; + +int sm_policy_start(struct pw_remote *remote) +{ + struct impl *impl; + + impl = calloc(1, sizeof(struct impl)); + if (impl == NULL) + return -errno; + + impl->core = pw_remote_get_core(remote); + impl->remote = remote; + + pw_map_init(&impl->globals, 64, 64); + + spa_list_init(&impl->client_list); + spa_list_init(&impl->node_list); + spa_list_init(&impl->session_list); + + pw_remote_add_listener(impl->remote, &impl->remote_listener, &remote_events, impl); + + return 0; +} + +int sm_policy_stop(struct pw_core *core) +{ + return 0; +}