diff options
Diffstat (limited to 'src/modules/module-switch-on-port-available.c')
| -rw-r--r-- | src/modules/module-switch-on-port-available.c | 630 |
1 files changed, 630 insertions, 0 deletions
diff --git a/src/modules/module-switch-on-port-available.c b/src/modules/module-switch-on-port-available.c new file mode 100644 index 0000000..99d61a4 --- /dev/null +++ b/src/modules/module-switch-on-port-available.c @@ -0,0 +1,630 @@ +/*** + This file is part of PulseAudio. + + Copyright 2006 Lennart Poettering + Copyright 2011 Canonical Ltd + + PulseAudio is free software; you can redistribute it and/or modify + it under the terms of the GNU Lesser General Public License as published + by the Free Software Foundation; either version 2.1 of the License, + or (at your option) any later version. + + PulseAudio is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU Lesser General Public License + along with PulseAudio; if not, see <http://www.gnu.org/licenses/>. +***/ + +#ifdef HAVE_CONFIG_H +#include <config.h> +#endif + +#include <pulsecore/core.h> +#include <pulsecore/core-util.h> +#include <pulsecore/device-port.h> +#include <pulsecore/hashmap.h> + +PA_MODULE_AUTHOR("David Henningsson"); +PA_MODULE_DESCRIPTION("Switches ports and profiles when devices are plugged/unplugged"); +PA_MODULE_LOAD_ONCE(true); +PA_MODULE_VERSION(PACKAGE_VERSION); + +struct card_info { + struct userdata *userdata; + pa_card *card; + + /* We need to cache the active profile, because we want to compare the old + * and new profiles in the PROFILE_CHANGED hook. Without this we'd only + * have access to the new profile. */ + pa_card_profile *active_profile; +}; + +struct userdata { + pa_hashmap *card_infos; /* pa_card -> struct card_info */ +}; + +static void card_info_new(struct userdata *u, pa_card *card) { + struct card_info *info; + + info = pa_xnew0(struct card_info, 1); + info->userdata = u; + info->card = card; + info->active_profile = card->active_profile; + + pa_hashmap_put(u->card_infos, card, info); +} + +static void card_info_free(struct card_info *info) { + pa_hashmap_remove(info->userdata->card_infos, info->card); + pa_xfree(info); +} + +static bool profile_good_for_output(pa_card_profile *profile, pa_device_port *port) { + pa_card *card; + pa_sink *sink; + uint32_t idx; + + pa_assert(profile); + + card = profile->card; + + if (!pa_safe_streq(card->active_profile->input_name, profile->input_name)) + return false; + + if (card->active_profile->n_sources != profile->n_sources) + return false; + + if (card->active_profile->max_source_channels != profile->max_source_channels) + return false; + + if (port == card->preferred_output_port) + return true; + + PA_IDXSET_FOREACH(sink, card->sinks, idx) { + if (!sink->active_port) + continue; + + if ((sink->active_port->available != PA_AVAILABLE_NO) && (sink->active_port->priority >= port->priority)) + return false; + } + + return true; +} + +static bool profile_good_for_input(pa_card_profile *profile, pa_device_port *port) { + pa_card *card; + pa_source *source; + uint32_t idx; + + pa_assert(profile); + + card = profile->card; + + if (!pa_safe_streq(card->active_profile->output_name, profile->output_name)) + return false; + + if (card->active_profile->n_sinks != profile->n_sinks) + return false; + + if (card->active_profile->max_sink_channels != profile->max_sink_channels) + return false; + + if (port == card->preferred_input_port) + return true; + + PA_IDXSET_FOREACH(source, card->sources, idx) { + if (!source->active_port) + continue; + + if ((source->active_port->available != PA_AVAILABLE_NO) && (source->active_port->priority >= port->priority)) + return false; + } + + return true; +} + +static int try_to_switch_profile(pa_device_port *port) { + pa_card_profile *best_profile = NULL, *profile; + void *state; + unsigned best_prio = 0; + + pa_log_debug("Finding best profile for port %s, preferred = %s", + port->name, pa_strnull(port->preferred_profile)); + + PA_HASHMAP_FOREACH(profile, port->profiles, state) { + bool good = false; + const char *name; + unsigned prio = profile->priority; + + /* We make a best effort to keep other direction unchanged */ + switch (port->direction) { + case PA_DIRECTION_OUTPUT: + name = profile->output_name; + good = profile_good_for_output(profile, port); + break; + + case PA_DIRECTION_INPUT: + name = profile->input_name; + good = profile_good_for_input(profile, port); + break; + } + + if (!good) + continue; + + /* Give a high bonus in case this is the preferred profile */ + if (pa_safe_streq(name ? name : profile->name, port->preferred_profile)) + prio += 1000000; + + if (best_profile && best_prio >= prio) + continue; + + best_profile = profile; + best_prio = prio; + } + + if (!best_profile) { + pa_log_debug("No suitable profile found"); + return -1; + } + + if (pa_card_set_profile(port->card, best_profile, false) != 0) { + pa_log_debug("Could not set profile %s", best_profile->name); + return -1; + } + + return 0; +} + +struct port_pointers { + pa_device_port *port; + pa_sink *sink; + pa_source *source; + bool is_possible_profile_active; + bool is_preferred_profile_active; + bool is_port_active; +}; + +static const char* profile_name_for_dir(pa_card_profile *cp, pa_direction_t dir) { + if (dir == PA_DIRECTION_OUTPUT && cp->output_name) + return cp->output_name; + if (dir == PA_DIRECTION_INPUT && cp->input_name) + return cp->input_name; + return cp->name; +} + +static struct port_pointers find_port_pointers(pa_device_port *port) { + struct port_pointers pp = { .port = port }; + uint32_t state; + pa_card *card; + + pa_assert(port); + pa_assert_se(card = port->card); + + switch (port->direction) { + case PA_DIRECTION_OUTPUT: + PA_IDXSET_FOREACH(pp.sink, card->sinks, state) + if (port == pa_hashmap_get(pp.sink->ports, port->name)) + break; + break; + + case PA_DIRECTION_INPUT: + PA_IDXSET_FOREACH(pp.source, card->sources, state) + if (port == pa_hashmap_get(pp.source->ports, port->name)) + break; + break; + } + + pp.is_possible_profile_active = + card->active_profile == pa_hashmap_get(port->profiles, card->active_profile->name); + pp.is_preferred_profile_active = pp.is_possible_profile_active && (!port->preferred_profile || + pa_safe_streq(port->preferred_profile, profile_name_for_dir(card->active_profile, port->direction))); + pp.is_port_active = (pp.sink && pp.sink->active_port == port) || (pp.source && pp.source->active_port == port); + + return pp; +} + +/* Switches to a port, switching profiles if necessary or preferred */ +static void switch_to_port(pa_device_port *port, struct port_pointers pp) { + if (pp.is_port_active) + return; /* Already selected */ + + pa_log_debug("Trying to switch to port %s", port->name); + if (!pp.is_preferred_profile_active) { + if (try_to_switch_profile(port) < 0) { + if (!pp.is_possible_profile_active) + return; + } + else + /* Now that profile has changed, our sink and source pointers must be updated */ + pp = find_port_pointers(port); + } + + if (pp.source) + pa_source_set_port(pp.source, port->name, false); + if (pp.sink) + pa_sink_set_port(pp.sink, port->name, false); +} + +/* Switches away from a port, switching profiles if necessary or preferred */ +static void switch_from_port(pa_device_port *port, struct port_pointers pp) { + pa_device_port *p, *best_port = NULL; + void *state; + + if (!pp.is_port_active) + return; /* Already deselected */ + + /* Try to find a good enough port to switch to */ + PA_HASHMAP_FOREACH(p, port->card->ports, state) { + if (p == port) + continue; + + if (p->available == PA_AVAILABLE_NO) + continue; + + if (p->direction != port->direction) + continue; + + if (!best_port || best_port->priority < p->priority) + best_port = p; + } + + pa_log_debug("Trying to switch away from port %s, found %s", port->name, best_port ? best_port->name : "no better option"); + + /* If there is no available port to switch to we need check if the active + * profile is still available in the + * PA_CORE_HOOK_CARD_PROFILE_AVAILABLE_CHANGED callback, as at this point + * the profile availability hasn't been updated yet. */ + if (best_port) { + struct port_pointers best_pp = find_port_pointers(best_port); + switch_to_port(best_port, best_pp); + } +} + + +static pa_hook_result_t port_available_hook_callback(pa_core *c, pa_device_port *port, void* userdata) { + struct port_pointers pp = find_port_pointers(port); + + if (!port->card) { + pa_log_warn("Port %s does not have a card", port->name); + return PA_HOOK_OK; + } + + /* Our profile switching logic caused trouble with bluetooth headsets (see + * https://bugs.freedesktop.org/show_bug.cgi?id=107044) and + * module-bluetooth-policy takes care of automatic profile switching + * anyway, so we ignore bluetooth cards in + * module-switch-on-port-available. */ + if (pa_safe_streq(pa_proplist_gets(port->card->proplist, PA_PROP_DEVICE_BUS), "bluetooth")) + return PA_HOOK_OK; + + switch (port->available) { + case PA_AVAILABLE_UNKNOWN: + /* If a port availability became unknown, let's see if it's part of + * some availability group. If it is, it is likely to be a headphone + * jack that does not have impedance sensing to detect whether what was + * plugged in was a headphone, headset or microphone. In desktop + * environments that support it, this will trigger a user choice to + * select what kind of device was plugged in. However, let's switch to + * the headphone port at least, so that we have don't break + * functionality for setups that can't trigger this kind of + * interaction. + * + * For headset or microphone, if they are part of some availability group + * and they become unknown from off, it needs to check if their source is + * unlinked or not, if their source is unlinked, let switch_to_port() + * process them, then with the running of pa_card_set_profile(), their + * source will be created, otherwise the headset or microphone can't be used + * to record sound since there is no source for these 2 ports. This issue + * is observed on Dell machines which have multi-function audio jack but no + * internal mic. + * + * We should make this configurable so that users can optionally + * override the default to a headset or mic. */ + + /* Not part of a group of ports, so likely not a combination port */ + if (!port->availability_group) { + pa_log_debug("Not switching to port %s, its availability is unknown and it's not in any availability group.", port->name); + break; + } + + /* Switch the headphone port, the input ports without source and the + * input ports their source->active_port is part of a group of ports. + */ + if (port->direction == PA_DIRECTION_INPUT && pp.source && !pp.source->active_port->availability_group) { + pa_log_debug("Not switching to input port %s, its availability is unknown.", port->name); + break; + } + + switch_to_port(port, pp); + break; + + case PA_AVAILABLE_YES: + switch_to_port(port, pp); + break; + case PA_AVAILABLE_NO: + switch_from_port(port, pp); + break; + default: + break; + } + + return PA_HOOK_OK; +} + +static pa_card_profile *find_best_profile(pa_card *card) { + pa_card_profile *profile, *best_profile; + void *state; + + pa_assert(card); + best_profile = pa_hashmap_get(card->profiles, "off"); + + PA_HASHMAP_FOREACH(profile, card->profiles, state) { + if (profile->available == PA_AVAILABLE_NO) + continue; + + if (profile->priority > best_profile->priority) + best_profile = profile; + } + + return best_profile; +} + +static pa_hook_result_t card_profile_available_hook_callback(pa_core *c, pa_card_profile *profile, struct userdata *u) { + pa_card *card; + + pa_assert(profile); + pa_assert_se(card = profile->card); + + if (profile->available != PA_AVAILABLE_NO) + return PA_HOOK_OK; + + if (!pa_streq(profile->name, card->active_profile->name)) + return PA_HOOK_OK; + + pa_log_debug("Active profile %s on card %s became unavailable, switching to another profile", profile->name, card->name); + pa_card_set_profile(card, find_best_profile(card), false); + + return PA_HOOK_OK; + +} + +static void handle_all_unavailable(pa_core *core) { + pa_card *card; + uint32_t state; + + PA_IDXSET_FOREACH(card, core->cards, state) { + pa_device_port *port; + void *state2; + + PA_HASHMAP_FOREACH(port, card->ports, state2) { + if (port->available == PA_AVAILABLE_NO) + port_available_hook_callback(core, port, NULL); + } + } +} + +static pa_device_port *new_sink_source(pa_hashmap *ports, const char *name) { + + void *state; + pa_device_port *i, *p = NULL; + + if (!ports) + return NULL; + if (name) + p = pa_hashmap_get(ports, name); + if (!p) + PA_HASHMAP_FOREACH(i, ports, state) + if (!p || i->priority > p->priority) + p = i; + if (!p) + return NULL; + if (p->available != PA_AVAILABLE_NO) + return NULL; + + pa_assert_se(p = pa_device_port_find_best(ports)); + return p; +} + +static pa_hook_result_t sink_new_hook_callback(pa_core *c, pa_sink_new_data *new_data, void *u) { + + pa_device_port *p = new_sink_source(new_data->ports, new_data->active_port); + + if (p) { + pa_log_debug("Switching initial port for sink '%s' to '%s'", new_data->name, p->name); + pa_sink_new_data_set_port(new_data, p->name); + } + return PA_HOOK_OK; +} + +static pa_hook_result_t source_new_hook_callback(pa_core *c, pa_source_new_data *new_data, void *u) { + + pa_device_port *p = new_sink_source(new_data->ports, new_data->active_port); + + if (p) { + pa_log_debug("Switching initial port for source '%s' to '%s'", new_data->name, p->name); + pa_source_new_data_set_port(new_data, p->name); + } + return PA_HOOK_OK; +} + +static pa_hook_result_t card_put_hook_callback(pa_core *core, pa_card *card, struct userdata *u) { + card_info_new(u, card); + + return PA_HOOK_OK; +} + +static pa_hook_result_t card_unlink_hook_callback(pa_core *core, pa_card *card, struct userdata *u) { + card_info_free(pa_hashmap_get(u->card_infos, card)); + + return PA_HOOK_OK; +} + +static void update_preferred_input_port(pa_card *card, pa_card_profile *old_profile, pa_card_profile *new_profile) { + pa_source *source; + + /* If the profile change didn't affect input, it doesn't indicate change in + * the user's input port preference. */ + if (pa_safe_streq(old_profile->input_name, new_profile->input_name)) + return; + + /* If there are more than one source, we don't know which of those the user + * prefers. If there are no sources, then the user doesn't seem to care + * about input at all. */ + if (pa_idxset_size(card->sources) != 1) { + pa_card_set_preferred_port(card, PA_DIRECTION_INPUT, NULL); + return; + } + + /* If the profile change modified the set of sinks, then it's unclear + * whether the user wanted to activate some specific input port, or was the + * input change only a side effect of activating some output. If the new + * profile contains no sinks, though, then we know the user only cares + * about input. */ + if (pa_idxset_size(card->sinks) > 0 && !pa_safe_streq(old_profile->output_name, new_profile->output_name)) { + pa_card_set_preferred_port(card, PA_DIRECTION_INPUT, NULL); + return; + } + + source = pa_idxset_first(card->sources, NULL); + + /* We know the user wanted to activate this source. The user might not have + * wanted to activate the port that was selected by default, but if that's + * the case, the user will change the port manually, and we'll update the + * port preference at that time. If no port change occurs, we can assume + * that the user likes the port that is now active. */ + pa_card_set_preferred_port(card, PA_DIRECTION_INPUT, source->active_port); +} + +static void update_preferred_output_port(pa_card *card, pa_card_profile *old_profile, pa_card_profile *new_profile) { + pa_sink *sink; + + /* If the profile change didn't affect output, it doesn't indicate change in + * the user's output port preference. */ + if (pa_safe_streq(old_profile->output_name, new_profile->output_name)) + return; + + /* If there are more than one sink, we don't know which of those the user + * prefers. If there are no sinks, then the user doesn't seem to care about + * output at all. */ + if (pa_idxset_size(card->sinks) != 1) { + pa_card_set_preferred_port(card, PA_DIRECTION_OUTPUT, NULL); + return; + } + + /* If the profile change modified the set of sources, then it's unclear + * whether the user wanted to activate some specific output port, or was + * the output change only a side effect of activating some input. If the + * new profile contains no sources, though, then we know the user only + * cares about output. */ + if (pa_idxset_size(card->sources) > 0 && !pa_safe_streq(old_profile->input_name, new_profile->input_name)) { + pa_card_set_preferred_port(card, PA_DIRECTION_OUTPUT, NULL); + return; + } + + sink = pa_idxset_first(card->sinks, NULL); + + /* We know the user wanted to activate this sink. The user might not have + * wanted to activate the port that was selected by default, but if that's + * the case, the user will change the port manually, and we'll update the + * port preference at that time. If no port change occurs, we can assume + * that the user likes the port that is now active. */ + pa_card_set_preferred_port(card, PA_DIRECTION_OUTPUT, sink->active_port); +} + +static pa_hook_result_t card_profile_changed_callback(pa_core *core, pa_card *card, struct userdata *u) { + struct card_info *info; + pa_card_profile *old_profile; + pa_card_profile *new_profile; + + info = pa_hashmap_get(u->card_infos, card); + old_profile = info->active_profile; + new_profile = card->active_profile; + info->active_profile = new_profile; + + /* This profile change wasn't initiated by the user, so it doesn't signal + * a change in the user's port preferences. */ + if (!card->save_profile) + return PA_HOOK_OK; + + update_preferred_input_port(card, old_profile, new_profile); + update_preferred_output_port(card, old_profile, new_profile); + + return PA_HOOK_OK; +} + +static pa_hook_result_t source_port_changed_callback(pa_core *core, pa_source *source, void *userdata) { + if (!source->save_port) + return PA_HOOK_OK; + + pa_card_set_preferred_port(source->card, PA_DIRECTION_INPUT, source->active_port); + + return PA_HOOK_OK; +} + +static pa_hook_result_t sink_port_changed_callback(pa_core *core, pa_sink *sink, void *userdata) { + if (!sink->save_port) + return PA_HOOK_OK; + + pa_card_set_preferred_port(sink->card, PA_DIRECTION_OUTPUT, sink->active_port); + + return PA_HOOK_OK; +} + +int pa__init(pa_module*m) { + struct userdata *u; + pa_card *card; + uint32_t idx; + + pa_assert(m); + + u = m->userdata = pa_xnew0(struct userdata, 1); + u->card_infos = pa_hashmap_new(NULL, NULL); + + PA_IDXSET_FOREACH(card, m->core->cards, idx) + card_info_new(u, card); + + /* Make sure we are after module-device-restore, so we can overwrite that suggestion if necessary */ + pa_module_hook_connect(m, &m->core->hooks[PA_CORE_HOOK_SINK_NEW], + PA_HOOK_NORMAL, (pa_hook_cb_t) sink_new_hook_callback, NULL); + pa_module_hook_connect(m, &m->core->hooks[PA_CORE_HOOK_SOURCE_NEW], + PA_HOOK_NORMAL, (pa_hook_cb_t) source_new_hook_callback, NULL); + pa_module_hook_connect(m, &m->core->hooks[PA_CORE_HOOK_PORT_AVAILABLE_CHANGED], + PA_HOOK_LATE, (pa_hook_cb_t) port_available_hook_callback, NULL); + pa_module_hook_connect(m, &m->core->hooks[PA_CORE_HOOK_CARD_PROFILE_AVAILABLE_CHANGED], + PA_HOOK_LATE, (pa_hook_cb_t) card_profile_available_hook_callback, NULL); + pa_module_hook_connect(m, &m->core->hooks[PA_CORE_HOOK_CARD_PUT], + PA_HOOK_NORMAL, (pa_hook_cb_t) card_put_hook_callback, u); + pa_module_hook_connect(m, &m->core->hooks[PA_CORE_HOOK_CARD_UNLINK], + PA_HOOK_NORMAL, (pa_hook_cb_t) card_unlink_hook_callback, u); + pa_module_hook_connect(m, &m->core->hooks[PA_CORE_HOOK_CARD_PROFILE_CHANGED], + PA_HOOK_NORMAL, (pa_hook_cb_t) card_profile_changed_callback, u); + pa_module_hook_connect(m, &m->core->hooks[PA_CORE_HOOK_SOURCE_PORT_CHANGED], + PA_HOOK_NORMAL, (pa_hook_cb_t) source_port_changed_callback, NULL); + pa_module_hook_connect(m, &m->core->hooks[PA_CORE_HOOK_SINK_PORT_CHANGED], + PA_HOOK_NORMAL, (pa_hook_cb_t) sink_port_changed_callback, NULL); + + handle_all_unavailable(m->core); + + return 0; +} + +void pa__done(pa_module *module) { + struct userdata *u; + struct card_info *info; + + pa_assert(module); + + if (!(u = module->userdata)) + return; + + while ((info = pa_hashmap_last(u->card_infos))) + card_info_free(info); + + pa_hashmap_free(u->card_infos); + + pa_xfree(u); +} |