mirrors/pulseaudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git synced 2025-10-29 05:40:23 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

module-switch-on-port-available: Route to preferred profile

Browse source 
This makes the routing slightly more aggressive:

 * It will try to route to another profile, if such a profile
   is preferred by the port.

 * It will allow changing profiles on transitions both to
   PA_AVAILABLE_YES and PA_AVAILABLE_NO

To accommodate there is also some refactoring.

Signed-off-by: David Henningsson <david.henningsson@canonical.com>
This commit is contained in:
David Henningsson 2015-11-17 15:10:35 +01:00 • committed by Tanu Kaskinen
parent 063a1d350f
commit e87100d41e
1 changed files with 110 additions and 72 deletions
Download patch file Download diff file Expand all files Collapse all files

182
src/modules/module-switch-on-port-available.c
View file

@ -74,22 +74,25 @@ static bool profile_good_for_input(pa_card_profile *profile) {
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");
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;
if (best_profile && best_profile->priority >= profile->priority)
continue;
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);
break;
case PA_DIRECTION_INPUT:
name = profile->input_name;
good = profile_good_for_input(profile);
break;
}
@ -97,7 +100,15 @@ static int try_to_switch_profile(pa_device_port *port) {
if (!good)
continue;
/* Give a high bonus in case this is the preferred profile */
if (port->preferred_profile && pa_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) {
@ -113,98 +124,125 @@ static int try_to_switch_profile(pa_device_port *port) {
return 0;
}
static void find_sink_and_source(pa_card *card, pa_device_port *port, pa_sink **si, pa_source **so) {
pa_sink *sink = NULL;
pa_source *source = NULL;
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(sink, card->sinks, state)
if (port == pa_hashmap_get(sink->ports, port->name))
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(source, card->sources, state)
if (port == pa_hashmap_get(source->ports, port->name))
PA_IDXSET_FOREACH(pp.source, card->sources, state)
if (port == pa_hashmap_get(pp.source->ports, port->name))
break;
break;
}
*si = sink;
*so = source;
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 bool switch_to_port(pa_device_port *port) {
struct port_pointers pp = find_port_pointers(port);
if (pp.is_port_active)
return true; /* 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 false;
}
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);
return true;
}
/* Switches away from a port, switching profiles if necessary or preferred */
static bool switch_from_port(pa_device_port *port) {
struct port_pointers pp = find_port_pointers(port);
pa_device_port *p, *best_port = NULL;
void *state;
if (!pp.is_port_active)
return true; /* Already deselected */
/* Try to find a good enough port to switch to */
PA_HASHMAP_FOREACH(p, port->card->ports, state)
if (p->direction == port->direction && p != port && p->available != PA_AVAILABLE_NO &&
(!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 (best_port)
return switch_to_port(best_port);
return false;
}
static pa_hook_result_t port_available_hook_callback(pa_core *c, pa_device_port *port, void* userdata) {
pa_card* card;
pa_sink *sink;
pa_source *source;
bool is_active_profile, is_active_port;
pa_assert(port);
if (port->available == PA_AVAILABLE_UNKNOWN)
return PA_HOOK_OK;
card = port->card;
if (!card) {
if (!port->card) {
pa_log_warn("Port %s does not have a card", port->name);
return PA_HOOK_OK;
}
if (pa_idxset_size(card->sinks) == 0 && pa_idxset_size(card->sources) == 0)
if (pa_idxset_size(port->card->sinks) == 0 && pa_idxset_size(port->card->sources) == 0)
/* This card is not initialized yet. We'll handle it in
sink_new / source_new callbacks later. */
return PA_HOOK_OK;
find_sink_and_source(card, port, &sink, &source);
is_active_profile = card->active_profile == pa_hashmap_get(port->profiles, card->active_profile->name);
is_active_port = (sink && sink->active_port == port) || (source && source->active_port == port);
if (port->available == PA_AVAILABLE_NO && !is_active_port)
return PA_HOOK_OK;
if (port->available == PA_AVAILABLE_YES) {
if (is_active_port)
return PA_HOOK_OK;
if (!is_active_profile) {
if (try_to_switch_profile(port) < 0)
return PA_HOOK_OK;
pa_assert(card->active_profile == pa_hashmap_get(port->profiles, card->active_profile->name));
/* Now that profile has changed, our sink and source pointers must be updated */
find_sink_and_source(card, port, &sink, &source);
}
if (source)
pa_source_set_port(source, port->name, false);
if (sink)
pa_sink_set_port(sink, port->name, false);
}
if (port->available == PA_AVAILABLE_NO) {
if (sink) {
pa_device_port *p2 = pa_device_port_find_best(sink->ports);
if (p2 && p2->available != PA_AVAILABLE_NO)
pa_sink_set_port(sink, p2->name, false);
else {
/* Maybe try to switch to another profile? */
}
}
if (source) {
pa_device_port *p2 = pa_device_port_find_best(source->ports);
if (p2 && p2->available != PA_AVAILABLE_NO)
pa_source_set_port(source, p2->name, false);
else {
/* Maybe try to switch to another profile? */
}
}
switch (port->available) {
case PA_AVAILABLE_YES:
switch_to_port(port);
break;
case PA_AVAILABLE_NO:
switch_from_port(port);
break;
default:
break;
}
return PA_HOOK_OK;