struct entry {
uint8_t version;
char description[PA_NAME_MAX];
+ pa_bool_t user_set_description;
char icon[PA_NAME_MAX];
role_indexes_t priority;
} PA_GCC_PACKED;
SUBCOMMAND_RENAME,
SUBCOMMAND_DELETE,
SUBCOMMAND_ROLE_DEVICE_PRIORITY_ROUTING,
- SUBCOMMAND_PREFER_DEVICE,
- SUBCOMMAND_DEFER_DEVICE,
+ SUBCOMMAND_REORDER,
SUBCOMMAND_SUBSCRIBE,
SUBCOMMAND_EVENT
};
goto fail;
}
+ if (!memchr(e->icon, 0, sizeof(e->icon))) {
+ pa_log_warn("Database contains entry for device %s with missing NUL byte in icon", name);
+ goto fail;
+ }
+
return e;
fail:
pa_log_debug(" %s No sink specified", human);
} else {
pa_source *s;
- if (PA_INVALID_INDEX != u->preferred_sinks[role_index] && (s = pa_idxset_get_by_index(u->core->sinks, u->preferred_sinks[role_index])))
+ if (PA_INVALID_INDEX != u->preferred_sources[role_index] && (s = pa_idxset_get_by_index(u->core->sources, u->preferred_sources[role_index])))
pa_log_debug(" %s %s (%s)", human, pa_strnull(pa_proplist_gets(s->proplist, PA_PROP_DEVICE_DESCRIPTION)), s->name);
else
pa_log_debug(" %s No source specified", human);
key = next_key;
}
- pa_log_debug(" Highest priority devices per-role:");
-
- pa_log_debug(" Sinks:");
- for (uint32_t role = ROLE_NONE; role < NUM_ROLES; ++role) {
- char name[13];
- uint32_t len = PA_MIN(12u, strlen(role_names[role]));
- strncpy(name, role_names[role], len);
- for (int i = len+1; i < 12; ++i) name[i] = ' ';
- name[len] = ':'; name[0] -= 32; name[12] = '\0';
- dump_database_helper(u, role, name, TRUE);
- }
+ if (u->do_routing) {
+ pa_log_debug(" Highest priority devices per-role:");
+
+ pa_log_debug(" Sinks:");
+ for (uint32_t role = ROLE_NONE; role < NUM_ROLES; ++role) {
+ char name[13];
+ uint32_t len = PA_MIN(12u, strlen(role_names[role]));
+ strncpy(name, role_names[role], len);
+ for (int i = len+1; i < 12; ++i) name[i] = ' ';
+ name[len] = ':'; name[0] -= 32; name[12] = '\0';
+ dump_database_helper(u, role, name, TRUE);
+ }
- pa_log_debug(" Sources:");
- for (uint32_t role = ROLE_NONE; role < NUM_ROLES; ++role) {
- char name[13];
- uint32_t len = PA_MIN(12u, strlen(role_names[role]));
- strncpy(name, role_names[role], len);
- for (int i = len+1; i < 12; ++i) name[i] = ' ';
- name[len] = ':'; name[0] -= 32; name[12] = '\0';
- dump_database_helper(u, role, name, FALSE);
+ pa_log_debug(" Sources:");
+ for (uint32_t role = ROLE_NONE; role < NUM_ROLES; ++role) {
+ char name[13];
+ uint32_t len = PA_MIN(12u, strlen(role_names[role]));
+ strncpy(name, role_names[role], len);
+ for (int i = len+1; i < 12; ++i) name[i] = ' ';
+ name[len] = ':'; name[0] -= 32; name[12] = '\0';
+ dump_database_helper(u, role, name, FALSE);
+ }
}
pa_log_debug("Completed database dump");
}
static pa_bool_t entries_equal(const struct entry *a, const struct entry *b) {
- /** @todo: Compare the priority lists too */
- if (strncmp(a->description, b->description, sizeof(a->description)))
+
+ pa_assert(a);
+ pa_assert(b);
+
+ if (strncmp(a->description, b->description, sizeof(a->description))
+ || a->user_set_description != b->user_set_description
+ || strncmp(a->icon, b->icon, sizeof(a->icon)))
return FALSE;
+ for (int i=0; i < NUM_ROLES; ++i)
+ if (a->priority[i] != b->priority[i])
+ return FALSE;
+
return TRUE;
}
for (uint32_t i = 0; i < NUM_ROLES; ++i) {
entry->priority[i] = max_priority[i] + 1;
}
+ entry->user_set_description = FALSE;
}
return old;
indexes = &u->preferred_sources;
for (uint32_t i = 0; i < NUM_ROLES; ++i) {
- *indexes[i] = PA_INVALID_INDEX;
+ (*indexes)[i] = PA_INVALID_INDEX;
}
pa_zero(highest_priority_available);
done = !pa_database_next(u->database, &key, &next_key, NULL);
if (key.size > strlen(prefix) && strncmp(key.data, prefix, strlen(prefix)) == 0) {
- char *name;
+ char *name, *device_name;
struct entry *e;
name = pa_xstrndup(key.data, key.size);
+ device_name = get_name(name, prefix);
if ((e = read_entry(u, name))) {
for (uint32_t i = 0; i < NUM_ROLES; ++i) {
- if (highest_priority_available[i] && e->priority[i] < highest_priority_available[i]) {
+ if (!highest_priority_available[i] || e->priority[i] < highest_priority_available[i]) {
/* We've found a device with a higher priority than that we've currently got,
so see if it is currently available or not and update our list */
uint32_t idx;
pa_bool_t found = FALSE;
- char *device_name = get_name(name, prefix);
if (sink_mode) {
pa_sink *sink;
}
if (found) {
highest_priority_available[i] = e->priority[i];
- *indexes[i] = idx;
+ (*indexes)[i] = idx;
}
- pa_xfree(device_name);
}
}
}
pa_xfree(name);
+ pa_xfree(device_name);
}
pa_datum_free(&key);
return;
if (si->sink != sink)
- pa_sink_input_move_to(si, sink, TRUE);
+ pa_sink_input_move_to(si, sink, FALSE);
}
static pa_hook_result_t route_sink_inputs(struct userdata *u, pa_sink *ignore_sink) {
return;
if (so->source != source)
- pa_source_output_move_to(so, source, TRUE);
+ pa_source_output_move_to(so, source, FALSE);
}
static pa_hook_result_t route_source_outputs(struct userdata *u, pa_source* ignore_source) {
old = load_or_initialize_entry(u, &entry, name, "sink:");
- pa_strlcpy(entry.description, pa_strnull(pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_DESCRIPTION)), sizeof(entry.description));
+ if (!entry.user_set_description)
+ pa_strlcpy(entry.description, pa_strnull(pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_DESCRIPTION)), sizeof(entry.description));
+ else if (strncmp(entry.description, pa_strnull(pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_DESCRIPTION)), sizeof(entry.description)) != 0) {
+ /* Warning: If two modules fight over the description, this could cause an infinite loop.
+ by changing the description here, we retrigger this subscription callback. The only thing stopping us from
+ looping is the fact that the string comparison will fail on the second iteration. If another module tries to manage
+ the description, this will fail... */
+ pa_sink_set_description(sink, entry.description);
+ }
+
pa_strlcpy(entry.icon, pa_strnull(pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_ICON_NAME)), sizeof(entry.icon));
- } else if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SOURCE) {
+ } else if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SOURCE) {
pa_source *source;
pa_assert((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SOURCE);
old = load_or_initialize_entry(u, &entry, name, "source:");
- pa_strlcpy(entry.description, pa_strnull(pa_proplist_gets(source->proplist, PA_PROP_DEVICE_DESCRIPTION)), sizeof(entry.description));
+ if (!entry.user_set_description)
+ pa_strlcpy(entry.description, pa_strnull(pa_proplist_gets(source->proplist, PA_PROP_DEVICE_DESCRIPTION)), sizeof(entry.description));
+ else if (strncmp(entry.description, pa_strnull(pa_proplist_gets(source->proplist, PA_PROP_DEVICE_DESCRIPTION)), sizeof(entry.description)) != 0) {
+ /* Warning: If two modules fight over the description, this could cause an infinite loop.
+ by changing the description here, we retrigger this subscription callback. The only thing stopping us from
+ looping is the fact that the string comparison will fail on the second iteration. If another module tries to manage
+ the description, this will fail... */
+ pa_source_set_description(source, entry.description);
+ }
+
pa_strlcpy(entry.icon, pa_strnull(pa_proplist_gets(source->proplist, PA_PROP_DEVICE_ICON_NAME)), sizeof(entry.icon));
}
pa_xfree(old);
pa_xfree(name);
- /* Even if the entries are equal, the availability or otherwise
- of the sink/source may have changed so we notify clients all the same */
- notify_subscribers(u);
-
return;
}
pa_log_info("Storing device %s.", name);
- pa_database_set(u->database, &key, &data, TRUE);
+ if (pa_database_set(u->database, &key, &data, TRUE) == 0)
+ trigger_save(u);
+ else
+ pa_log_warn("Could not save device");;
pa_xfree(name);
-
- trigger_save(u);
}
static pa_hook_result_t sink_new_hook_callback(pa_core *c, pa_sink_new_data *new_data, struct userdata *u) {
name = pa_sprintf_malloc("sink:%s", new_data->name);
if ((e = read_entry(u, name))) {
- if (strncmp(e->description, pa_proplist_gets(new_data->proplist, PA_PROP_DEVICE_DESCRIPTION), sizeof(e->description)) != 0) {
+ if (e->user_set_description && strncmp(e->description, pa_proplist_gets(new_data->proplist, PA_PROP_DEVICE_DESCRIPTION), sizeof(e->description)) != 0) {
pa_log_info("Restoring description for sink %s.", new_data->name);
pa_proplist_sets(new_data->proplist, PA_PROP_DEVICE_DESCRIPTION, e->description);
}
name = pa_sprintf_malloc("source:%s", new_data->name);
if ((e = read_entry(u, name))) {
- if (strncmp(e->description, pa_proplist_gets(new_data->proplist, PA_PROP_DEVICE_DESCRIPTION), sizeof(e->description)) != 0) {
+ if (e->user_set_description && strncmp(e->description, pa_proplist_gets(new_data->proplist, PA_PROP_DEVICE_DESCRIPTION), sizeof(e->description)) != 0) {
/* NB, We cannot detect if we are a monitor here... this could mess things up a bit... */
pa_log_info("Restoring description for source %s.", new_data->name);
pa_proplist_sets(new_data->proplist, PA_PROP_DEVICE_DESCRIPTION, e->description);
}
static pa_hook_result_t sink_input_new_hook_callback(pa_core *c, pa_sink_input_new_data *new_data, struct userdata *u) {
+ const char *role;
+ uint32_t role_index;
+
pa_assert(c);
pa_assert(new_data);
pa_assert(u);
return PA_HOOK_OK;
if (new_data->sink)
- pa_log_debug("Not restoring device for stream, because already set.");
+ pa_log_debug("Not restoring device for stream because already set.");
else {
- const char *role;
- uint32_t role_index;
-
if (!(role = pa_proplist_gets(new_data->proplist, PA_PROP_MEDIA_ROLE)))
- role_index = get_role_index("");
+ role_index = get_role_index("none");
else
role_index = get_role_index(role);
pa_sink *sink;
if ((sink = pa_idxset_get_by_index(u->core->sinks, device_index))) {
- new_data->sink = sink;
- new_data->save_sink = TRUE;
+ if (!pa_sink_input_new_data_set_sink(new_data, sink, FALSE))
+ pa_log_debug("Not restoring device for stream because no supported format was found");
}
}
}
}
static pa_hook_result_t source_output_new_hook_callback(pa_core *c, pa_source_output_new_data *new_data, struct userdata *u) {
+ const char *role;
+ uint32_t role_index;
+
pa_assert(c);
pa_assert(new_data);
pa_assert(u);
return PA_HOOK_OK;
if (new_data->source)
- pa_log_debug("Not restoring device for stream, because already set");
+ pa_log_debug("Not restoring device for stream because already set.");
else {
- const char *role;
- uint32_t role_index;
-
if (!(role = pa_proplist_gets(new_data->proplist, PA_PROP_MEDIA_ROLE)))
- role_index = get_role_index("");
+ role_index = get_role_index("none");
else
role_index = get_role_index(role);
if (PA_INVALID_INDEX != device_index) {
pa_source *source;
- if ((source = pa_idxset_get_by_index(u->core->sources, device_index))) {
- new_data->source = source;
- new_data->save_source = TRUE;
- }
+ if ((source = pa_idxset_get_by_index(u->core->sources, device_index)))
+ if (!pa_source_output_new_data_set_source(new_data, source, FALSE))
+ pa_log_debug("Not restoring device for stream because no supported format was found");
}
}
}
pa_assert(u->core == c);
pa_assert(u->on_hotplug);
+ notify_subscribers(u);
+
return route_sink_inputs(u, NULL);
}
pa_assert(u->core == c);
pa_assert(u->on_hotplug);
+ notify_subscribers(u);
+
return route_source_outputs(u, NULL);
}
if (c->state == PA_CORE_SHUTDOWN)
return PA_HOOK_OK;
+ notify_subscribers(u);
+
return route_sink_inputs(u, sink);
}
if (c->state == PA_CORE_SHUTDOWN)
return PA_HOOK_OK;
+ notify_subscribers(u);
+
return route_source_outputs(u, source);
}
static void apply_entry(struct userdata *u, const char *name, struct entry *e) {
- pa_sink *sink;
- pa_source *source;
uint32_t idx;
char *n;
pa_assert(name);
pa_assert(e);
+ if (!e->user_set_description)
+ return;
+
if ((n = get_name(name, "sink:"))) {
- for (sink = pa_idxset_first(u->core->sinks, &idx); sink; sink = pa_idxset_next(u->core->sinks, &idx)) {
- if (!pa_streq(sink->name, n)) {
+ pa_sink *s;
+ PA_IDXSET_FOREACH(s, u->core->sinks, idx) {
+ if (!pa_streq(s->name, n)) {
continue;
}
- pa_log_info("Setting description for sink %s.", sink->name);
- pa_sink_set_description(sink, e->description);
+ pa_log_info("Setting description for sink %s to '%s'", s->name, e->description);
+ pa_sink_set_description(s, e->description);
}
pa_xfree(n);
}
else if ((n = get_name(name, "source:"))) {
- for (source = pa_idxset_first(u->core->sources, &idx); source; source = pa_idxset_next(u->core->sources, &idx)) {
- if (!pa_streq(source->name, n)) {
+ pa_source *s;
+ PA_IDXSET_FOREACH(s, u->core->sources, idx) {
+ if (!pa_streq(s->name, n)) {
continue;
}
- if (source->monitor_of) {
- pa_log_warn("Cowardly refusing to set the description for monitor source %s.", source->name);
+ if (s->monitor_of) {
+ pa_log_warn("Cowardly refusing to set the description for monitor source %s.", s->name);
continue;
}
- pa_log_info("Setting description for source %s.", source->name);
- pa_source_set_description(source, e->description);
+ pa_log_info("Setting description for source %s to '%s'", s->name, e->description);
+ pa_source_set_description(s, e->description);
}
pa_xfree(n);
}
if ((e = read_entry(u, name))) {
uint32_t idx;
- char *devname;
- pa_bool_t available = FALSE;
+ char *device_name;
+ uint32_t found_index = PA_INVALID_INDEX;
- if ((devname = get_name(name, "sink:"))) {
+ if ((device_name = get_name(name, "sink:"))) {
pa_sink* s;
PA_IDXSET_FOREACH(s, u->core->sinks, idx) {
- if (strcmp(s->name, devname) == 0) {
- available = TRUE;
+ if (strcmp(s->name, device_name) == 0) {
+ found_index = s->index;
break;
}
}
- pa_xfree(devname);
- } else if ((devname = get_name(name, "source:"))) {
+ pa_xfree(device_name);
+ } else if ((device_name = get_name(name, "source:"))) {
pa_source* s;
PA_IDXSET_FOREACH(s, u->core->sources, idx) {
- if (strcmp(s->name, devname) == 0) {
- available = TRUE;
+ if (strcmp(s->name, device_name) == 0) {
+ found_index = s->index;
break;
}
}
- pa_xfree(devname);
+ pa_xfree(device_name);
}
pa_tagstruct_puts(reply, name);
pa_tagstruct_puts(reply, e->description);
pa_tagstruct_puts(reply, e->icon);
- pa_tagstruct_put_boolean(reply, available);
+ pa_tagstruct_putu32(reply, found_index);
pa_tagstruct_putu32(reply, NUM_ROLES);
for (uint32_t i = ROLE_NONE; i < NUM_ROLES; ++i) {
if (!device || !*device || !description || !*description)
goto fail;
- if ((e = read_entry(u, device)) && ENTRY_VERSION == e->version) {
+ if ((e = read_entry(u, device))) {
pa_datum key, data;
pa_strlcpy(e->description, description, sizeof(e->description));
+ e->user_set_description = TRUE;
key.data = (char *) device;
key.size = strlen(device);
break;
}
- case SUBCOMMAND_PREFER_DEVICE:
- case SUBCOMMAND_DEFER_DEVICE: {
+ case SUBCOMMAND_REORDER: {
- const char *role, *device;
+ const char *role;
struct entry *e;
- uint32_t role_index;
+ uint32_t role_index, n_devices;
+ pa_datum key, data;
+ pa_bool_t done, sink_mode = TRUE;
+ struct device_t { uint32_t prio; char *device; };
+ struct device_t *device;
+ struct device_t **devices;
+ uint32_t i, idx, offset;
+ pa_hashmap *h;
+ /*void *state;*/
+ pa_bool_t first;
if (pa_tagstruct_gets(t, &role) < 0 ||
- pa_tagstruct_gets(t, &device) < 0)
+ pa_tagstruct_getu32(t, &n_devices) < 0 ||
+ n_devices < 1)
goto fail;
- if (!role || !device || !*device)
+ if (PA_INVALID_INDEX == (role_index = get_role_index(role)))
goto fail;
- role_index = get_role_index(role);
- if (PA_INVALID_INDEX == role_index)
- goto fail;
-
- if ((e = read_entry(u, device)) && ENTRY_VERSION == e->version) {
- pa_datum key, data;
- pa_bool_t done;
- char* prefix = NULL;
- uint32_t priority;
- pa_bool_t haschanged = FALSE;
-
- if (strncmp(device, "sink:", 5) == 0)
- prefix = pa_xstrdup("sink:");
- else if (strncmp(device, "source:", 7) == 0)
- prefix = pa_xstrdup("source:");
+ /* Cycle through the devices given and make sure they exist */
+ h = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
+ first = TRUE;
+ idx = 0;
+ for (i = 0; i < n_devices; ++i) {
+ const char *s;
+ if (pa_tagstruct_gets(t, &s) < 0) {
+ while ((device = pa_hashmap_steal_first(h))) {
+ pa_xfree(device->device);
+ pa_xfree(device);
+ }
- if (!prefix)
+ pa_hashmap_free(h, NULL, NULL);
+ pa_log_error("Protocol error on reorder");
goto fail;
+ }
- priority = e->priority[role_index];
-
- /* Now we need to load up all the other entries of this type and shuffle the priroities around */
+ /* Ensure this is a valid entry */
+ if (!(e = read_entry(u, s))) {
+ while ((device = pa_hashmap_steal_first(h))) {
+ pa_xfree(device->device);
+ pa_xfree(device);
+ }
- done = !pa_database_first(u->database, &key, NULL);
+ pa_hashmap_free(h, NULL, NULL);
+ pa_log_error("Client specified an unknown device in it's reorder list.");
+ goto fail;
+ }
+ pa_xfree(e);
- while (!done && !haschanged) {
- pa_datum next_key;
+ if (first) {
+ first = FALSE;
+ sink_mode = (0 == strncmp("sink:", s, 5));
+ } else if ((sink_mode && 0 != strncmp("sink:", s, 5)) || (!sink_mode && 0 != strncmp("source:", s, 7))) {
+ while ((device = pa_hashmap_steal_first(h))) {
+ pa_xfree(device->device);
+ pa_xfree(device);
+ }
- done = !pa_database_next(u->database, &key, &next_key, NULL);
+ pa_hashmap_free(h, NULL, NULL);
+ pa_log_error("Attempted to reorder mixed devices (sinks and sources)");
+ goto fail;
+ }
- /* Only read devices with the right prefix */
- if (key.size > strlen(prefix) && strncmp(key.data, prefix, strlen(prefix)) == 0) {
- char *name;
- struct entry *e2;
+ /* Add the device to our hashmap. If it's alredy in it, free it now and carry on */
+ device = pa_xnew(struct device_t, 1);
+ device->device = pa_xstrdup(s);
+ if (pa_hashmap_put(h, device->device, device) == 0) {
+ device->prio = idx;
+ idx++;
+ } else {
+ pa_xfree(device->device);
+ pa_xfree(device);
+ }
+ }
- name = pa_xstrndup(key.data, key.size);
+ /*pa_log_debug("Hashmap contents (received from client)");
+ PA_HASHMAP_FOREACH(device, h, state) {
+ pa_log_debug(" - %s (%d)", device->device, device->prio);
+ }*/
- if ((e2 = read_entry(u, name))) {
- if (SUBCOMMAND_PREFER_DEVICE == command) {
- /* PREFER */
- if (e2->priority[role_index] == (priority - 1)) {
- e2->priority[role_index]++;
- haschanged = TRUE;
- }
- } else {
- /* DEFER */
- if (e2->priority[role_index] == (priority + 1)) {
- e2->priority[role_index]--;
- haschanged = TRUE;
- }
- }
-
- if (haschanged) {
- data.data = e2;
- data.size = sizeof(*e2);
+ /* Now cycle through our list and add all the devices.
+ This has the effect of addign in any in our DB,
+ not specified in the device list (and thus will be
+ tacked on at the end) */
+ offset = idx;
+ done = !pa_database_first(u->database, &key, NULL);
- if (pa_database_set(u->database, &key, &data, TRUE))
- pa_log_warn("Could not save device");
- }
+ while (!done && idx < 256) {
+ pa_datum next_key;
- pa_xfree(e2);
- }
+ done = !pa_database_next(u->database, &key, &next_key, NULL);
- pa_xfree(name);
+ device = pa_xnew(struct device_t, 1);
+ device->device = pa_xstrndup(key.data, key.size);
+ if ((sink_mode && 0 == strncmp("sink:", device->device, 5))
+ || (!sink_mode && 0 == strncmp("source:", device->device, 7))) {
+
+ /* Add the device to our hashmap. If it's alredy in it, free it now and carry on */
+ if (pa_hashmap_put(h, device->device, device) == 0
+ && (e = read_entry(u, device->device))) {
+ /* We add offset on to the existing priorirty so that when we order, the
+ existing entries are always lower priority than the new ones. */
+ device->prio = (offset + e->priority[role_index]);
+ pa_xfree(e);
}
-
- pa_datum_free(&key);
- key = next_key;
+ else {
+ pa_xfree(device->device);
+ pa_xfree(device);
+ }
+ } else {
+ pa_xfree(device->device);
+ pa_xfree(device);
}
- /* Now write out our actual entry */
- if (haschanged) {
- if (SUBCOMMAND_PREFER_DEVICE == command)
- e->priority[role_index]--;
- else
- e->priority[role_index]++;
+ pa_datum_free(&key);
- key.data = (char *) device;
- key.size = strlen(device);
+ key = next_key;
+ }
- data.data = e;
- data.size = sizeof(*e);
+ /*pa_log_debug("Hashmap contents (combined with database)");
+ PA_HASHMAP_FOREACH(device, h, state) {
+ pa_log_debug(" - %s (%d)", device->device, device->prio);
+ }*/
+
+ /* Now we put all the entries in a simple list for sorting it. */
+ n_devices = pa_hashmap_size(h);
+ devices = pa_xnew(struct device_t *, n_devices);
+ idx = 0;
+ while ((device = pa_hashmap_steal_first(h))) {
+ devices[idx++] = device;
+ }
+ pa_hashmap_free(h, NULL, NULL);
+
+ /* Simple bubble sort */
+ for (i = 0; i < n_devices; ++i) {
+ for (uint32_t j = i; j < n_devices; ++j) {
+ if (devices[i]->prio > devices[j]->prio) {
+ struct device_t *tmp;
+ tmp = devices[i];
+ devices[i] = devices[j];
+ devices[j] = tmp;
+ }
+ }
+ }
- if (pa_database_set(u->database, &key, &data, TRUE))
- pa_log_warn("Could not save device");
+ /*pa_log_debug("Sorted device list");
+ for (i = 0; i < n_devices; ++i) {
+ pa_log_debug(" - %s (%d)", devices[i]->device, devices[i]->prio);
+ }*/
+
+ /* Go through in order and write the new entry and cleanup our own list */
+ idx = 1;
+ first = TRUE;
+ for (i = 0; i < n_devices; ++i) {
+ if ((e = read_entry(u, devices[i]->device))) {
+ if (e->priority[role_index] == idx)
+ idx++;
+ else {
+ e->priority[role_index] = idx;
+
+ key.data = (char *) devices[i]->device;
+ key.size = strlen(devices[i]->device);
+
+ data.data = e;
+ data.size = sizeof(*e);
+
+ if (pa_database_set(u->database, &key, &data, TRUE) == 0) {
+ first = FALSE;
+ idx++;
+ }
+ }
- trigger_save(u);
+ pa_xfree(e);
}
+ pa_xfree(devices[i]->device);
+ pa_xfree(devices[i]);
+ }
- pa_xfree(e);
+ if (!first) {
+ trigger_save(u);
- pa_xfree(prefix);
+ if (sink_mode)
+ route_sink_inputs(u, NULL);
+ else
+ route_source_outputs(u, NULL);
}
- else
- pa_log_warn("Could not reorder device %s, no entry in database", device);
break;
}
return PA_HOOK_OK;
}
+struct prioritised_indexes {
+ uint32_t index;
+ int32_t priority;
+};
+
int pa__init(pa_module*m) {
pa_modargs *ma = NULL;
struct userdata *u;
pa_source *source;
uint32_t idx;
pa_bool_t do_routing = FALSE, on_hotplug = TRUE, on_rescue = TRUE;
+ uint32_t total_devices;
pa_assert(m);
u->source_new_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_NEW], PA_HOOK_EARLY, (pa_hook_cb_t) source_new_hook_callback, u);
/* The following slots are used to deal with routing */
- /* A little bit later than module-stream-restore, module-intended-roles */
- u->sink_input_new_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_INPUT_NEW], PA_HOOK_EARLY+15, (pa_hook_cb_t) sink_input_new_hook_callback, u);
- u->source_output_new_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_NEW], PA_HOOK_EARLY+15, (pa_hook_cb_t) source_output_new_hook_callback, u);
+ /* A little bit later than module-stream-restore, but before module-intended-roles */
+ u->sink_input_new_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_INPUT_NEW], PA_HOOK_EARLY+5, (pa_hook_cb_t) sink_input_new_hook_callback, u);
+ u->source_output_new_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_NEW], PA_HOOK_EARLY+5, (pa_hook_cb_t) source_output_new_hook_callback, u);
if (on_hotplug) {
- /* A little bit later than module-stream-restore, module-intended-roles */
- u->sink_put_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_PUT], PA_HOOK_LATE+15, (pa_hook_cb_t) sink_put_hook_callback, u);
- u->source_put_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_PUT], PA_HOOK_LATE+15, (pa_hook_cb_t) source_put_hook_callback, u);
+ /* A little bit later than module-stream-restore, but before module-intended-roles */
+ u->sink_put_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_PUT], PA_HOOK_LATE+5, (pa_hook_cb_t) sink_put_hook_callback, u);
+ u->source_put_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_PUT], PA_HOOK_LATE+5, (pa_hook_cb_t) source_put_hook_callback, u);
}
if (on_rescue) {
- /* A little bit later than module-stream-restore, module-intended-roles, a little bit earlier than module-rescue-streams, ... */
- u->sink_unlink_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_UNLINK], PA_HOOK_LATE+15, (pa_hook_cb_t) sink_unlink_hook_callback, u);
- u->source_unlink_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_UNLINK], PA_HOOK_LATE+15, (pa_hook_cb_t) source_unlink_hook_callback, u);
+ /* A little bit later than module-stream-restore, a little bit earlier than module-intended-roles, module-rescue-streams, ... */
+ u->sink_unlink_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_UNLINK], PA_HOOK_LATE+5, (pa_hook_cb_t) sink_unlink_hook_callback, u);
+ u->source_unlink_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_UNLINK], PA_HOOK_LATE+5, (pa_hook_cb_t) source_unlink_hook_callback, u);
}
if (!(fname = pa_state_path("device-manager", TRUE)))
goto fail;
}
- pa_log_info("Sucessfully opened database file '%s'.", fname);
+ pa_log_info("Successfully opened database file '%s'.", fname);
pa_xfree(fname);
- /* We cycle over all the available sinks so that they are added to our database if they are not in it yet */
- PA_IDXSET_FOREACH(sink, m->core->sinks, idx)
- subscribe_callback(m->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_NEW, sink->index, u);
+ /* Attempt to inject the devices into the list in priority order */
+ total_devices = PA_MAX(pa_idxset_size(m->core->sinks), pa_idxset_size(m->core->sources));
+ if (total_devices > 0 && total_devices < 128) {
+ uint32_t i;
+ struct prioritised_indexes p_i[128];
+
+ /* We cycle over all the available sinks so that they are added to our database if they are not in it yet */
+ i = 0;
+ PA_IDXSET_FOREACH(sink, m->core->sinks, idx) {
+ pa_log_debug("Found sink index %u", sink->index);
+ p_i[i ].index = sink->index;
+ p_i[i++].priority = sink->priority;
+ }
+ /* Bubble sort it (only really useful for first time creation) */
+ if (i > 1)
+ for (uint32_t j = 0; j < i; ++j)
+ for (uint32_t k = 0; k < i; ++k)
+ if (p_i[j].priority > p_i[k].priority) {
+ struct prioritised_indexes tmp_pi = p_i[k];
+ p_i[k] = p_i[j];
+ p_i[j] = tmp_pi;
+ }
+ /* Register it */
+ for (uint32_t j = 0; j < i; ++j)
+ subscribe_callback(m->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_NEW, p_i[j].index, u);
+
+
+ /* We cycle over all the available sources so that they are added to our database if they are not in it yet */
+ i = 0;
+ PA_IDXSET_FOREACH(source, m->core->sources, idx) {
+ p_i[i ].index = source->index;
+ p_i[i++].priority = source->priority;
+ }
+ /* Bubble sort it (only really useful for first time creation) */
+ if (i > 1)
+ for (uint32_t j = 0; j < i; ++j)
+ for (uint32_t k = 0; k < i; ++k)
+ if (p_i[j].priority > p_i[k].priority) {
+ struct prioritised_indexes tmp_pi = p_i[k];
+ p_i[k] = p_i[j];
+ p_i[j] = tmp_pi;
+ }
+ /* Register it */
+ for (uint32_t j = 0; j < i; ++j)
+ subscribe_callback(m->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_NEW, p_i[j].index, u);
+ }
+ else if (total_devices > 0) {
+ /* This user has a *lot* of devices... */
+ PA_IDXSET_FOREACH(sink, m->core->sinks, idx)
+ subscribe_callback(m->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_NEW, sink->index, u);
- PA_IDXSET_FOREACH(source, m->core->sources, idx)
- subscribe_callback(m->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_NEW, source->index, u);
+ PA_IDXSET_FOREACH(source, m->core->sources, idx)
+ subscribe_callback(m->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_NEW, source->index, u);
+ }
/* Perform the routing (if it's enabled) which will update our priority list cache too */
+ for (uint32_t i = 0; i < NUM_ROLES; ++i) {
+ u->preferred_sinks[i] = u->preferred_sources[i] = PA_INVALID_INDEX;
+ }
+
route_sink_inputs(u, NULL);
route_source_outputs(u, NULL);
if (ma)
pa_modargs_free(ma);
- return -1;
+ return -1;
}
void pa__done(pa_module*m) {
if (u->source_unlink_hook_slot)
pa_hook_slot_free(u->source_unlink_hook_slot);
+ if (u->connection_unlink_hook_slot)
+ pa_hook_slot_free(u->connection_unlink_hook_slot);
+
if (u->save_time_event)
u->core->mainloop->time_free(u->save_time_event);