summaryrefslogtreecommitdiffstats
path: root/discover.c
diff options
context:
space:
mode:
Diffstat (limited to 'discover.c')
-rw-r--r--discover.c758
1 files changed, 758 insertions, 0 deletions
diff --git a/discover.c b/discover.c
new file mode 100644
index 0000000..e6e8243
--- /dev/null
+++ b/discover.c
@@ -0,0 +1,758 @@
+/*
+ * module-agl-audio -- PulseAudio module for providing audio routing support
+ * (forked from "module-murphy-ivi" - https://github.com/otcshare )
+ * Copyright (c) 2012, Intel Corporation.
+ * Copyright (c) 2016, IoT.bzh
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU Lesser General Public License,
+ * version 2.1, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the
+ * Free Software Foundation, Inc., 51 Franklin St - Fifth Floor, Boston,
+ * MA 02110-1301 USA.
+ *
+ */
+#include <pulsecore/pulsecore-config.h> /* required for "core-util.h" */
+#include <pulsecore/core-util.h> /* requred for "pa_streq" */
+#include <pulsecore/device-port.h> /* required for "card.h" */
+#include <pulsecore/card.h> /* for "struct pa_card", "struct pa_card_profile" */
+
+#include "discover.h"
+#include "node.h"
+#include "utils.h"
+#include "classify.h"
+#include "router.h"
+
+#define MAX_CARD_TARGET 4 /* max number of managed sinks/sources per card */
+#define MAX_NAME_LENGTH 256 /* max sink/source name length */
+
+static void handle_alsa_card (struct userdata *, pa_card *);
+static void handle_alsa_card_sinks_and_sources (struct userdata *, pa_card *, agl_node *, const char *);
+static void get_sinks_and_sources_from_profile (pa_card_profile *, char **, char **, char *, int);
+static char *get_sink_or_source_from_str (char **, int);
+static void handle_card_ports (struct userdata *, agl_node *, pa_card *, pa_card_profile *);
+static const char *node_key (struct userdata *, agl_direction,
+ void *, pa_device_port *, char *, size_t);
+static agl_node *create_node (struct userdata *, agl_node *, bool *);
+
+struct pa_discover *pa_discover_init (struct userdata *u)
+{
+ pa_discover *discover = pa_xnew0 (pa_discover, 1);
+ discover->chmin = 1;
+ discover->chmax = 2;
+ discover->selected = true;
+ discover->nodes.byname = pa_hashmap_new (pa_idxset_string_hash_func,
+ pa_idxset_string_compare_func);
+ discover->nodes.byptr = pa_hashmap_new (pa_idxset_trivial_hash_func,
+ pa_idxset_trivial_compare_func);
+
+ return discover;
+}
+
+void pa_discover_done (struct userdata *u)
+{
+ pa_discover *discover;
+ void *state;
+ agl_node *node;
+
+ if (u && (discover = u->discover)) {
+ /*PA_HASHMAP_FOREACH(node, discover->nodes.byname, state) {
+ agl_node_destroy(u, node);
+ }*/
+ pa_hashmap_free (discover->nodes.byname);
+ pa_hashmap_free (discover->nodes.byptr);
+ pa_xfree (discover);
+ u->discover = NULL;
+ }
+}
+
+void pa_discover_add_card (struct userdata *u, pa_card *card)
+{
+ const char *bus;
+
+ pa_assert(u);
+ pa_assert(card);
+
+ if (!(bus = pa_utils_get_card_bus (card))) {
+ pa_log_debug ("ignoring card '%s' due to lack of '%s' property",
+ pa_utils_get_card_name (card), PA_PROP_DEVICE_BUS);
+ return;
+ }
+
+ if (pa_streq(bus, "pci") || pa_streq(bus, "usb") || pa_streq(bus, "platform")) {
+ pa_log_debug ("adding card '%s' thanks to its '%s' property",
+ pa_utils_get_card_name (card), PA_PROP_DEVICE_BUS);
+ pa_log_debug ("card type is '%s'", bus);
+ handle_alsa_card (u, card);
+ return;
+ }
+/* this never happens, because "pa_utils_get_card_bus()" never returns "bluetooth",
+ * but have this here as a reminder */
+#if 0
+ else if (pa_streq(bus, "bluetooth")) {
+ handle_bluetooth_card(u, card);
+ return;
+ }
+#endif
+
+ pa_log_debug ("ignoring card '%s' due to unsupported bus type '%s'",
+ pa_utils_get_card_name (card), bus);
+}
+
+void pa_discover_remove_card (struct userdata *u, pa_card *card)
+{
+ const char *bus;
+ pa_discover *discover;
+ agl_node *node;
+ void *state;
+
+ pa_assert (u);
+ pa_assert (card);
+ pa_assert_se (discover = u->discover);
+
+ if (!(bus = pa_utils_get_card_bus(card)))
+ bus = "<unknown>";
+
+ /*PA_HASHMAP_FOREACH(node, discover->nodes.byname, state) {
+ if (node->implement == agl_device &&
+ node->pacard.index == card->index)
+ {
+ if (pa_streq(bus, "pci") || pa_streq(bus, "usb") || pa_streq(bus, "platform"))
+ agl_constrain_destroy (u, node->paname);
+
+ destroy_node(u, node);
+ }*/
+
+ /* this never happens, because "pa_utils_get_card_bus()" never returns "bluetooth",
+ * but have this here as a reminder */
+#if 0
+ if (pa_streq(bus, "bluetooth"))
+ agl_constrain_destroy(u, card->name);
+#endif
+}
+
+void pa_discover_add_sink (struct userdata *u, pa_sink *sink, bool route)
+{
+ pa_core *core;
+ pa_discover *discover;
+ pa_module *module;
+ pa_card *card;
+ char kbf[256];
+ const char *key;
+ agl_node *node;
+ pa_source *null_source;
+
+ pa_assert (u);
+ pa_assert (sink);
+ pa_assert_se (core = u->core);
+ pa_assert_se (discover = u->discover);
+
+ module = sink->module;
+ card = sink->card;
+
+ if (card) {
+ /* helper function verifying that sink direction is input/output */
+ key = node_key (u, agl_output, sink, NULL, kbf, sizeof(kbf));
+ if (!key) return;
+ pa_log_debug ("Sink key: %s", key);
+ node = pa_discover_find_node_by_key (u, key);
+ if (!node) { /* ALWAYS NULL, IF CALL "handle_card_ports" FROM "handle_alsa_card" !!! */
+ if (u->state.profile)
+ pa_log_debug ("can't find node for sink (key '%s')", key);
+ else { /* how do we get here ? not in initial setup */
+ u->state.sink = sink->index;
+ pa_log_debug ("BUG ! Did you call handle_card_ports() ?");
+ }
+ return;
+ }
+ pa_log_debug("node for '%s' found (key %s). Updating with sink data",
+ node->paname, node->key);
+ node->paidx = sink->index;
+ node->available = true;
+ pa_discover_add_node_to_ptr_hash (u, sink, node);
+
+#if 0
+ /* loopback part : it is a device node, use "module-loopback" to make its */
+ if (node->implement == agl_device) {
+ null_source = pa_utils_get_null_source (u);
+ if (!null_source) {
+ pa_log ("Can't load loopback module: no initial null source");
+ return;
+ }
+ }
+#endif
+ }
+}
+
+
+static void handle_alsa_card (struct userdata *u, pa_card *card)
+{
+ agl_node data;
+ const char *cnam; /* PulseAudio name */
+ const char *cid; /* short PulseAudio name (with "alsa_name." stripped) */
+ const char *alsanam; /* ALSA name */
+ const char *udd; /* managed by udev ("1" = yes) */
+
+ memset (&data, 0, sizeof(data));
+ data.zone = pa_utils_get_zone (card->proplist, NULL);
+ data.visible = true;
+ data.amid = AM_ID_INVALID;
+ data.implement = agl_device; /* this node is a physical device */
+ data.paidx = PA_IDXSET_INVALID;
+ data.stamp = pa_utils_get_stamp (); /* each time incremented by one */
+
+ cnam = pa_utils_get_card_name (card); /* PulseAudio name */
+ cid = cnam + 10; /* PulseAudio short name, with "alsa_card." prefix removed */
+ alsanam = pa_proplist_gets (card->proplist, "alsa.card_name"); /* ALSA name */
+ udd = pa_proplist_gets (card->proplist, "module-udev-detect.discovered");
+
+ data.amdescr = (char *)alsanam;
+ data.pacard.index = card->index;
+
+ pa_log_debug ("Sound card zone: %s", data.zone);
+ pa_log_debug ("Sound card stamp: %d", data.stamp);
+ pa_log_debug ("PulseAudio card name: %s", cnam);
+ pa_log_debug ("PulseAudio short card name: %s", cid);
+ pa_log_debug ("ALSA card name: %s", alsanam);
+ if (udd)
+ pa_log_debug ("ALSA card detected by udev: %s", udd);
+
+ /* WITH THE TIZEN MODULE, ONLY UDEV-MANAGED CARDS ARE ACCEPTED
+ * NO MATTER, TREAT STATIC CARDS THE SAME WAY HERE.. */
+ /*if (!udd || (udd && !pa_streq(udd, "1"))
+ pa_log_debug ("Card not accepted, not managed by udev\n");*/
+
+ handle_alsa_card_sinks_and_sources (u, card, &data, cid);
+}
+ ;
+static void handle_alsa_card_sinks_and_sources (struct userdata *u, pa_card *card, agl_node *data, const char *cardid)
+{
+ pa_discover *discover; /* discovery restrictions (max channels...) */
+ pa_card_profile *prof;
+ void *state;
+ char *sinks[MAX_CARD_TARGET+1]; /* discovered sinks array */
+ char *sources[MAX_CARD_TARGET+1]; /* discovered sources array */
+ char namebuf[MAX_NAME_LENGTH+1]; /* discovered sink/source name buf.*/
+ const char *alsanam;
+ char paname[MAX_NAME_LENGTH+1];
+ char amname[MAX_NAME_LENGTH+1];
+ int i, j, k;
+
+ pa_assert (card);
+ pa_assert (card->profiles);
+ pa_assert_se (discover = u->discover);
+
+ alsanam = pa_proplist_gets (card->proplist, "alsa.card_name");
+ data->paname = paname;
+ data->amname = amname;
+ data->amdescr = (char *)alsanam;
+ data->pacard.index = card->index;
+
+ PA_HASHMAP_FOREACH(prof, card->profiles, state) {
+ /* TODO : skip selected profile here */
+
+ /* skip profiles withoutqx sinks/sources */
+ if (!prof->n_sinks && !prof->n_sources)
+ continue;
+ /* skip profiles with too few/many channels */
+ if (prof->n_sinks &&
+ (prof->max_sink_channels < discover->chmin ||
+ prof->max_sink_channels > discover->chmax))
+ continue;
+ if (prof->n_sources &&
+ (prof->max_source_channels < discover->chmin ||
+ prof->max_source_channels > discover->chmax))
+ continue;
+
+ /* VALID PROFILE, STORE IT */
+ pa_log_debug ("Discovered valid profile: %s", prof->name);
+ data->pacard.profile = prof->name;
+ /* NOW FILLING SINKS/SOURCE ARRAYS WITH PROFILE DATA */
+ get_sinks_and_sources_from_profile (prof, sinks, sources, namebuf, sizeof(namebuf));
+
+ /* OUTPUT DIRECTION, SINKS */
+ data->direction = agl_output;
+ data->channels = prof->max_sink_channels;
+ for (i = 0; sinks[i]; i++) {
+ pa_log_debug ("Discovered valid sink #%s on card %s", sinks[i], cardid);
+ snprintf(paname, sizeof(paname), "alsa_output.%s.%s", cardid, sinks[i]);
+ handle_card_ports(u, data, card, prof);
+ }
+
+ /* INPUT DIRECTION, SOURCES */
+ data->direction = agl_input;
+ data->channels = prof->max_source_channels;
+ for (i = 0; sources[i]; i++) {
+ pa_log_debug ("Discovered valid source #%s on card %s", sources[i], cardid);
+ snprintf(paname, sizeof(paname), "alsa_input.%s.%s", cardid, sinks[i]);
+ handle_card_ports(u, data, card, prof);
+ }
+ }
+}
+
+static void get_sinks_and_sources_from_profile (pa_card_profile *prof, char **sinks, char **sources, char *buf, int buflen)
+{
+ char *p = buf;
+ int i = 0;
+ int j = 0;
+
+ pa_assert (prof->name);
+
+ strncpy (buf, prof->name, (size_t)buflen);
+ buf[buflen-1] = '\0';
+
+ memset (sinks, 0, sizeof(char *) * (MAX_CARD_TARGET+1));
+ memset (sources, 0, sizeof(char *) * (MAX_CARD_TARGET+1));
+
+ do {
+ if (!strncmp (p, "output:", 7)) {
+ if (i >= MAX_CARD_TARGET) {
+ pa_log_debug ("number of outputs exeeds the maximum %d in "
+ "profile name '%s'", MAX_CARD_TARGET, prof->name);
+ return;
+ }
+ sinks[i++] = get_sink_or_source_from_str (&p, 7);
+ } else if (!strncmp (p, "input:", 6)) {
+ if (j >= MAX_CARD_TARGET) {
+ pa_log_debug ("number of inputs exeeds the maximum %d in "
+ "profile name '%s'", MAX_CARD_TARGET, prof->name);
+ return;
+ }
+ sources[j++] = get_sink_or_source_from_str (&p, 6);
+ } else {
+ pa_log ("%s: failed to parse profile name '%s'",
+ __FILE__, prof->name);
+ return;
+ }
+ } while (*p);
+}
+
+static char *get_sink_or_source_from_str (char **string_ptr, int offs)
+{
+ char c, *name, *end;
+
+ name = *string_ptr + offs;
+
+ for (end = name; (c = *end); end++) {
+ if (c == '+') {
+ *end++ = '\0';
+ break;
+ }
+ }
+
+ *string_ptr = end;
+
+ return name;
+}
+
+static void handle_card_ports (struct userdata *u, agl_node *data, pa_card *card, pa_card_profile *prof) {
+ agl_node *node = NULL;
+ pa_device_port *port;
+ void *state;
+ bool created;
+ bool have_ports = false;
+ char key[MAX_NAME_LENGTH+1];
+ const char *amname = data->amname;
+
+ pa_assert (u);
+ pa_assert (data);
+ pa_assert (card);
+ pa_assert (prof);
+
+ if (card->ports) {
+ PA_HASHMAP_FOREACH (port, card->ports, state) {
+ if (port->profiles &&
+ pa_hashmap_get (port->profiles, prof->name) &&
+ ((port->direction == PA_DIRECTION_INPUT && data->direction == agl_input)||
+ (port->direction == PA_DIRECTION_OUTPUT && data->direction == agl_output))) {
+ have_ports = true;
+ snprintf (key, sizeof(key), "%s@%s", data->paname, port->name);
+
+ data->key = key;
+ data->available = (port->available != PA_AVAILABLE_NO);
+ data->type = 0;
+ data->amname = amname;
+ data->paport = port->name;
+
+ printf ("Key : %s\n", key);
+
+ /* this is needed to fill the "port->type" field */
+ //pa_classify_node_by_card (data, card, prof, port);
+
+ /* this is needed to complete the "pa_discover_add_sink" first pass */
+ node = create_node (u, data, &created);
+ }
+ }
+ }
+
+ amname = "";
+ data->amname = amname;
+}
+
+static const char *node_key (struct userdata *u, agl_direction direction,
+ void *data, pa_device_port *port, char *buf, size_t len) {
+ char *type; /* "sink" or "source" */
+ const char *name; /* sink or source name */
+ pa_card *card;
+ pa_card_profile *profile;
+ const char *profile_name;
+ const char *bus;
+ char *key = NULL;
+
+ pa_assert (u);
+ pa_assert (data);
+ pa_assert (buf);
+ pa_assert (direction == agl_input || direction == agl_output);
+
+ if (direction == agl_output) {
+ pa_sink *sink = data;
+ type = pa_xstrdup ("sink");
+ name = pa_utils_get_sink_name (sink);
+ card = sink->card;
+ if (!port)
+ port = sink->active_port;
+ } else {
+ pa_source *source = data;
+ type = pa_xstrdup ("source");
+ name = pa_utils_get_source_name (source);
+ card = source->card;
+ if (!port)
+ port = source->active_port;
+ }
+
+ pa_log_debug ("Node type (sink/source): %s", type);
+ pa_log_debug ("Node name: %s", name);
+
+ if (!card)
+ return NULL;
+
+ pa_assert_se (profile = card->active_profile);
+ if (!u->state.profile) {
+ pa_log_debug ("profile is now '%s'", profile->name);
+ profile_name = profile->name;
+ } else {
+ pa_log_debug ("state.profile is not null. '%s' supresses '%s'",
+ u->state.profile, profile->name);
+ profile_name = u->state.profile;
+ }
+
+ if (!(bus = pa_utils_get_card_bus (card))) {
+ pa_log_debug ("ignoring card '%s' due to lack of '%s' property",
+ pa_utils_get_card_name (card), PA_PROP_DEVICE_BUS);
+ return NULL;
+ }
+
+ if (pa_streq(bus, "pci") || pa_streq(bus, "usb") || pa_streq(bus, "platform")) {
+ if (!port)
+ key = (char *)name;
+ else {
+ key = buf;
+ snprintf (buf, len, "%s@%s", name, port->name);
+ }
+ }
+ /* we do not handle Bluetooth yet, and the function never returns it */
+ /*else if (pa_streq(bus, "bluetooth")) {
+ }*/
+
+ return (const char *)key;
+}
+
+agl_node *pa_discover_find_node_by_key (struct userdata *u, const char *key)
+{
+ pa_discover *discover;
+ agl_node *node;
+
+ pa_assert (u);
+ pa_assert_se (discover = u->discover);
+
+ if (key)
+ node = pa_hashmap_get (discover->nodes.byname, key);
+ else
+ node = NULL;
+
+ return node;
+}
+
+void pa_discover_add_node_to_ptr_hash (struct userdata *u, void *ptr, agl_node *node)
+{
+ pa_discover *discover;
+
+ pa_assert (u);
+ pa_assert (ptr);
+ pa_assert (node);
+ pa_assert_se (discover = u->discover);
+
+ pa_hashmap_put (discover->nodes.byptr, ptr, node);
+}
+
+static agl_node *create_node (struct userdata *u, agl_node *data, bool *created_ret)
+{
+ pa_discover *discover;
+ agl_node *node;
+ bool created;
+
+ pa_assert (u);
+ pa_assert (data);
+ pa_assert (data->key);
+ pa_assert (data->paname);
+ pa_assert_se (discover = u->discover);
+
+ if ((node = pa_hashmap_get (discover->nodes.byname, data->key))) {
+ pa_log_debug ("No need to create this node");
+ created = false;
+ } else {
+ pa_log_debug ("Creating new node");
+
+ node = agl_node_create (u, data);
+ pa_hashmap_put (discover->nodes.byname, node->key, node);
+
+ /* TODO: registering the new node to the Optional router daemon */
+ /* if (node->available)
+ pa_audiomgr_register_node (u, node); */
+
+ created = true;
+ }
+
+ if (created_ret)
+ *created_ret = created;
+
+ return node;
+}
+
+void pa_discover_add_source (struct userdata *u, pa_source *source)
+{
+ static pa_nodeset_resdef def_resdef = {0, {0, 0}};
+
+ pa_core *core;
+ pa_discover *discover;
+ pa_module *module;
+ pa_card *card;
+ const char *key;
+ char kbf[256];
+ agl_node *node;
+
+ pa_assert (u);
+ pa_assert (source);
+ pa_assert_se (core = u->core);
+ pa_assert_se (discover = u->discover);
+
+ module = source->module;
+ card = source->card;
+
+ if (card) {
+ /* helper function verifying that sink direction is input/output */
+ key = node_key (u, agl_input, source, NULL, kbf, sizeof(kbf));
+ if (!key) return;
+ pa_log_debug ("Source key: %s", key);
+ node = pa_discover_find_node_by_key (u, key);
+ if (!node) { /* VERIFY IF THIS WORKS */
+ if (u->state.profile)
+ pa_log_debug ("can't find node for source (key '%s')", key);
+ else { /* how do we get here ? not in initial setup */
+ u->state.source = source->index;
+ pa_log_debug ("BUG !");
+ }
+ return;
+ }
+ pa_log_debug("node for '%s' found (key %s). Updating with source data",
+ node->paname, node->key);
+ node->paidx = source->index;
+ node->available = true;
+ pa_discover_add_node_to_ptr_hash (u, source, node);
+ }
+}
+
+bool pa_discover_preroute_sink_input(struct userdata *u, pa_sink_input_new_data *data)
+{
+ pa_core *core;
+ pa_sink *sink;
+ pa_source *source;
+ pa_discover *discover;
+ pa_nodeset *nodeset;
+ pa_proplist *pl;
+ agl_node *node;
+
+ pa_assert (u);
+ pa_assert (data);
+ pa_assert_se (core = u->core);
+ pa_assert_se (discover = u->discover);
+ pa_assert_se (nodeset = u->nodeset);
+ pa_assert_se (pl = data->proplist);
+
+ /* is there an existing matching node ? */
+ node = agl_node_get_from_data (u, agl_input, data);
+
+ if (!node) {
+ /* create node */
+ node = agl_node_create (u, NULL);
+ node->direction = agl_input;
+ node->implement = agl_stream;
+ node->type = pa_classify_guess_stream_node_type (u, pl);
+ node->visible = true;
+ node->available = true;
+ node->ignore = true; /* gets ignored initially */
+ node->paname = pa_proplist_gets (pl, PA_PROP_APPLICATION_NAME);
+ node->client = data->client;
+ /* add to global nodeset */
+ pa_idxset_put (nodeset->nodes, node, &node->index);
+ }
+
+ /* create NULL sink */
+ if (!node->nullsink)
+ node->nullsink = pa_utils_create_null_sink (u, u->nsnam);
+ if (!node->nullsink)
+ return false;
+
+ /* redirect sink input to NULL sink */
+ sink = pa_utils_get_null_sink (u, node->nullsink);
+
+ if (pa_sink_input_new_data_set_sink (data, sink, false))
+ pa_log_debug ("set sink %u for new sink-input", sink->index);
+ else
+ pa_log ("can't set sink %u for new sink-input", sink->index);
+
+ return true;
+}
+
+void pa_discover_register_sink_input (struct userdata *u, pa_sink_input *sinp)
+{
+ pa_core *core;
+ pa_discover *discover;
+ pa_proplist *pl, *client_proplist;
+ const char *media;
+ const char *name;
+ const char *role;
+ agl_node_type type;
+ agl_node node_data, *node;
+ char key[256];
+ pa_sink *sink;
+
+ pa_assert (u);
+ pa_assert (sinp);
+ pa_assert_se (core = u->core);
+ pa_assert_se (discover = u->discover);
+ pa_assert_se (pl = sinp->proplist);
+
+ media = pa_proplist_gets (sinp->proplist, PA_PROP_MEDIA_NAME);
+ if (media) {
+ /* special treatment for combine/loopback streams */
+ pa_log_debug ("Stream may me combine/loopback, in this case we should ignore it, but use it for now");
+ /* return; */
+ }
+
+ name = pa_utils_get_sink_input_name (sinp);
+ client_proplist = sinp->client ? sinp->client->proplist : NULL;
+
+ pa_log_debug ("registering input stream '%s'", name);
+
+ /* we could autodetect sink type by using:
+ * - PA_PROP_APPLICATION_PROCESS_ID;
+ * - PA_PROP_APPLICATION_PROCESS_BINARY;
+ * - PA_PROP_APPLICATION_NAME;
+ * - ...
+ but let us assume "agl_player" for now */
+ type = agl_player;
+
+ /* this sets our routing properties on the sink, which are :
+ * #define PA_PROP_ROUTING_CLASS_NAME "routing.class.name"
+ * #define PA_PROP_ROUTING_CLASS_ID "routing.class.id"
+ * #define PA_PROP_ROUTING_METHOD "routing.method" */
+ pa_utils_set_stream_routing_properties (pl, type, NULL);
+
+ /* we now create a new node for this sink */
+ memset (&node_data, 0, sizeof(node_data));
+ node_data.key = key;
+ node_data.direction = agl_input;
+ node_data.implement = agl_stream;
+ node_data.channels = sinp->channel_map.channels;
+ node_data.type = type;
+ node_data.zone = pa_utils_get_zone (sinp->proplist, client_proplist);
+ node_data.visible = true;
+ node_data.available = true;
+ node_data.amname = pa_proplist_gets (pl, "resource.set.appid");
+ node_data.amdescr = pa_proplist_gets (pl, PA_PROP_MEDIA_NAME);
+ node_data.amid = AM_ID_INVALID;
+ node_data.paname = (char *)name;
+ node_data.paidx = sinp->index;
+ /*node_data.rset.id = pa_utils_get_rsetid (pl, idbuf, sizeof(idbuf));*/
+
+ role = pa_proplist_gets (sinp->proplist, PA_PROP_MEDIA_ROLE);
+ /* MAIN PREROUTING DONE HERE ! (this was failing in the samples) */
+ /*sink = mir_router_make_prerouting (u, &data, &sinp->channel_map, role, &target);*/
+
+ node = create_node (u, &node_data, NULL);
+ pa_assert (node);
+ pa_discover_add_node_to_ptr_hash (u, sinp, node);
+/*
+ if (sink && target) {
+ pa_log_debug ("move stream to sink %u (%s)", sink->index, sink->name);
+
+ if (pa_sink_input_move_to (sinp, sink, false) < 0)
+ pa_log ("failed to route '%s' => '%s'",node->amname,target->amname);
+ else
+ pa_audiomgr_add_default_route (u, node, target);
+ }*/
+}
+
+void pa_discover_register_source_output (struct userdata *u, pa_source_output *sout)
+{
+ pa_core *core;
+ pa_discover *discover;
+ pa_proplist *pl, *client_proplist;
+ const char *media;
+ const char *name;
+ const char *role;
+ agl_node_type type;
+ agl_node node_data, *node;
+ char key[256];
+ pa_source *source;
+
+ pa_assert (u);
+ pa_assert (sout);
+ pa_assert_se (core = u->core);
+ pa_assert_se (discover = u->discover);
+ pa_assert_se (pl = sout->proplist);
+
+ media = pa_proplist_gets (sout->proplist, PA_PROP_MEDIA_NAME);
+ if (media) {
+ /* special treatment for loopback streams (not combine as with sinks !) */
+ pa_log_debug ("Stream may me loopback, in this case we should ignore it, but use it for now");
+ /* return; */
+ }
+
+ /* TODO : contrary to "pa_discover_register_sink_input", this function is always called
+ * even if we do not find PA_PROP_MEDIA_NAME (see above). */
+ //pa_utils_set_stream_routing_properties (pl, type, NULL);
+
+ name = pa_utils_get_source_output_name (sout);
+ client_proplist = sout->client ? sout->client->proplist : NULL;
+
+ pa_log_debug("registering output stream '%s'", name);
+}
+
+void pa_discover_add_sink_input (struct userdata *u, pa_sink_input *sinp)
+{
+ pa_core *core;
+ agl_node *node;
+
+ pa_assert (u);
+ pa_assert (sinp);
+ pa_assert_se (core = u->core);
+
+ if (!sinp->client)
+ return;
+
+ /* is there an existing matching node ? */
+ node = agl_node_get_from_client (u, sinp->client);
+ if (!node) return;
+
+ /* start the default routing */
+ implement_default_route (u, node, NULL, pa_utils_new_stamp ());
+}