From 31575f7766d6ff39665b64a3a04412eff1c39957 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Wed, 17 Jun 2009 03:45:14 +0200 Subject: alsa: rework mixer logic Completely rework mixer logic. This now allows controlling a full set of elements from a single sink's volume slider/mute button. This also introduces sink and source "ports" that can be used to choose different input or output ports with the UI. (i.e. "mic"/"line-in" or "speaker"/"headphones". The mixer paths and device maps are now configered in external configuration files and can be tweaked as necessary. --- src/pulsecore/cli-command.c | 78 ++++++++++++++++++++-- src/pulsecore/cli-text.c | 36 +++++++++- src/pulsecore/protocol-native.c | 8 +-- src/pulsecore/sink-input.c | 10 +-- src/pulsecore/sink.c | 144 ++++++++++++++++++++++++++++++++++++---- src/pulsecore/sink.h | 46 +++++++++++-- src/pulsecore/source.c | 121 ++++++++++++++++++++++++++++++--- src/pulsecore/source.h | 32 +++++++-- 8 files changed, 425 insertions(+), 50 deletions(-) (limited to 'src/pulsecore') diff --git a/src/pulsecore/cli-command.c b/src/pulsecore/cli-command.c index 644de96e..e2c3c066 100644 --- a/src/pulsecore/cli-command.c +++ b/src/pulsecore/cli-command.c @@ -125,6 +125,8 @@ static int pa_cli_command_update_source_proplist(pa_core *c, pa_tokenizer *t, pa static int pa_cli_command_update_sink_input_proplist(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail); static int pa_cli_command_update_source_output_proplist(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail); static int pa_cli_command_card_profile(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail); +static int pa_cli_command_sink_port(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail); +static int pa_cli_command_source_port(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail); /* A method table for all available commands */ @@ -176,10 +178,12 @@ static const struct command commands[] = { { "suspend-source", pa_cli_command_suspend_source, "Suspend source (args: index|name, bool)", 3}, { "suspend", pa_cli_command_suspend, "Suspend all sinks and all sources (args: bool)", 2}, { "set-card-profile", pa_cli_command_card_profile, "Change the profile of a card (args: index, name)", 3}, + { "set-sink-port", pa_cli_command_sink_port, "Change the port of a sink (args: index, name)", 3}, + { "set-source-port", pa_cli_command_source_port, "Change the port of a source (args: index, name)", 3}, { "set-log-level", pa_cli_command_log_level, "Change the log level (args: numeric level)", 2}, { "set-log-meta", pa_cli_command_log_meta, "Show source code location in log messages (args: bool)", 2}, { "set-log-time", pa_cli_command_log_time, "Show timestamps in log messages (args: bool)", 2}, - { "set-log-backtrace", pa_cli_command_log_backtrace, "Show bakctrace in log messages (args: frames)", 2}, + { "set-log-backtrace", pa_cli_command_log_backtrace, "Show backtrace in log messages (args: frames)", 2}, { NULL, NULL, NULL, 0 } }; @@ -526,7 +530,7 @@ static int pa_cli_command_sink_volume(pa_core *c, pa_tokenizer *t, pa_strbuf *bu } pa_cvolume_set(&cvolume, sink->sample_spec.channels, volume); - pa_sink_set_volume(sink, &cvolume, TRUE, TRUE, TRUE); + pa_sink_set_volume(sink, &cvolume, TRUE, TRUE, TRUE, TRUE); return 0; } @@ -604,7 +608,7 @@ static int pa_cli_command_source_volume(pa_core *c, pa_tokenizer *t, pa_strbuf * } pa_cvolume_set(&cvolume, source->sample_spec.channels, volume); - pa_source_set_volume(source, &cvolume); + pa_source_set_volume(source, &cvolume, TRUE); return 0; } @@ -638,7 +642,7 @@ static int pa_cli_command_sink_mute(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, return -1; } - pa_sink_set_mute(sink, mute); + pa_sink_set_mute(sink, mute, TRUE); return 0; } @@ -672,7 +676,7 @@ static int pa_cli_command_source_mute(pa_core *c, pa_tokenizer *t, pa_strbuf *bu return -1; } - pa_source_set_mute(source, mute); + pa_source_set_mute(source, mute, TRUE); return 0; } @@ -1476,6 +1480,70 @@ static int pa_cli_command_card_profile(pa_core *c, pa_tokenizer *t, pa_strbuf *b return 0; } +static int pa_cli_command_sink_port(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) { + const char *n, *p; + pa_sink *sink; + + pa_core_assert_ref(c); + pa_assert(t); + pa_assert(buf); + pa_assert(fail); + + if (!(n = pa_tokenizer_get(t, 1))) { + pa_strbuf_puts(buf, "You need to specify a sink either by its name or its index.\n"); + return -1; + } + + if (!(p = pa_tokenizer_get(t, 2))) { + pa_strbuf_puts(buf, "You need to specify a profile by its name.\n"); + return -1; + } + + if (!(sink = pa_namereg_get(c, n, PA_NAMEREG_SINK))) { + pa_strbuf_puts(buf, "No sink found by this name or index.\n"); + return -1; + } + + if (pa_sink_set_port(sink, p, TRUE) < 0) { + pa_strbuf_printf(buf, "Failed to set sink port to '%s'.\n", p); + return -1; + } + + return 0; +} + +static int pa_cli_command_source_port(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) { + const char *n, *p; + pa_source *source; + + pa_core_assert_ref(c); + pa_assert(t); + pa_assert(buf); + pa_assert(fail); + + if (!(n = pa_tokenizer_get(t, 1))) { + pa_strbuf_puts(buf, "You need to specify a source either by its name or its index.\n"); + return -1; + } + + if (!(p = pa_tokenizer_get(t, 2))) { + pa_strbuf_puts(buf, "You need to specify a profile by its name.\n"); + return -1; + } + + if (!(source = pa_namereg_get(c, n, PA_NAMEREG_SOURCE))) { + pa_strbuf_puts(buf, "No source found by this name or index.\n"); + return -1; + } + + if (pa_source_set_port(source, p, TRUE) < 0) { + pa_strbuf_printf(buf, "Failed to set source port to '%s'.\n", p); + return -1; + } + + return 0; +} + static int pa_cli_command_dump(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, pa_bool_t *fail) { pa_module *m; pa_sink *sink; diff --git a/src/pulsecore/cli-text.c b/src/pulsecore/cli-text.c index bc863f05..9395513d 100644 --- a/src/pulsecore/cli-text.c +++ b/src/pulsecore/cli-text.c @@ -139,11 +139,10 @@ char *pa_card_list_to_string(pa_core *c) { if (card->profiles) { pa_card_profile *p; - void *state = NULL; + void *state; pa_strbuf_puts(s, "\tprofiles:\n"); - - while ((p = pa_hashmap_iterate(card->profiles, &state, NULL))) + PA_HASHMAP_FOREACH(p, card->profiles, state) pa_strbuf_printf(s, "\t\t%s: %s (priority %u)\n", p->name, p->description, p->priority); } @@ -307,6 +306,22 @@ char *pa_sink_list_to_string(pa_core *c) { t = pa_proplist_to_string_sep(sink->proplist, "\n\t\t"); pa_strbuf_printf(s, "\tproperties:\n\t\t%s\n", t); pa_xfree(t); + + if (sink->ports) { + pa_device_port *p; + void *state; + + pa_strbuf_puts(s, "\tports:\n"); + PA_HASHMAP_FOREACH(p, sink->ports, state) + pa_strbuf_printf(s, "\t\t%s: %s (priority %u)\n", p->name, p->description, p->priority); + } + + + if (sink->active_port) + pa_strbuf_printf( + s, + "\tactive port: <%s>\n", + sink->active_port->name); } return pa_strbuf_tostring_free(s); @@ -412,6 +427,21 @@ char *pa_source_list_to_string(pa_core *c) { t = pa_proplist_to_string_sep(source->proplist, "\n\t\t"); pa_strbuf_printf(s, "\tproperties:\n\t\t%s\n", t); pa_xfree(t); + + if (source->ports) { + pa_device_port *p; + void *state; + + pa_strbuf_puts(s, "\tports:\n"); + PA_HASHMAP_FOREACH(p, source->ports, state) + pa_strbuf_printf(s, "\t\t%s: %s (priority %u)\n", p->name, p->description, p->priority); + } + + if (source->active_port) + pa_strbuf_printf( + s, + "\tactive port: <%s>\n", + source->active_port->name); } return pa_strbuf_tostring_free(s); diff --git a/src/pulsecore/protocol-native.c b/src/pulsecore/protocol-native.c index e9e2d601..b27346b2 100644 --- a/src/pulsecore/protocol-native.c +++ b/src/pulsecore/protocol-native.c @@ -3328,9 +3328,9 @@ static void command_set_volume( CHECK_VALIDITY(c->pstream, si || sink || source, tag, PA_ERR_NOENTITY); if (sink) - pa_sink_set_volume(sink, &volume, TRUE, TRUE, TRUE); + pa_sink_set_volume(sink, &volume, TRUE, TRUE, TRUE, TRUE); else if (source) - pa_source_set_volume(source, &volume); + pa_source_set_volume(source, &volume, TRUE); else if (si) pa_sink_input_set_volume(si, &volume, TRUE, TRUE); @@ -3400,9 +3400,9 @@ static void command_set_mute( CHECK_VALIDITY(c->pstream, si || sink || source, tag, PA_ERR_NOENTITY); if (sink) - pa_sink_set_mute(sink, mute); + pa_sink_set_mute(sink, mute, TRUE); else if (source) - pa_source_set_mute(source, mute); + pa_source_set_mute(source, mute, TRUE); else if (si) pa_sink_input_set_mute(si, mute, TRUE); diff --git a/src/pulsecore/sink-input.c b/src/pulsecore/sink-input.c index 0d05b00a..a5f96351 100644 --- a/src/pulsecore/sink-input.c +++ b/src/pulsecore/sink-input.c @@ -442,7 +442,7 @@ void pa_sink_input_unlink(pa_sink_input *i) { if (i->sink->flags & PA_SINK_FLAT_VOLUME) { pa_cvolume new_volume; pa_sink_update_flat_volume(i->sink, &new_volume); - pa_sink_set_volume(i->sink, &new_volume, FALSE, FALSE, FALSE); + pa_sink_set_volume(i->sink, &new_volume, FALSE, FALSE, FALSE, FALSE); } if (i->sink->asyncmsgq) @@ -520,7 +520,7 @@ void pa_sink_input_put(pa_sink_input *i) { if (i->sink->flags & PA_SINK_FLAT_VOLUME) { pa_cvolume new_volume; pa_sink_update_flat_volume(i->sink, &new_volume); - pa_sink_set_volume(i->sink, &new_volume, FALSE, FALSE, FALSE); + pa_sink_set_volume(i->sink, &new_volume, FALSE, FALSE, FALSE, FALSE); } else pa_sink_input_set_relative_volume(i, &i->virtual_volume); @@ -900,7 +900,7 @@ void pa_sink_input_set_volume(pa_sink_input *i, const pa_cvolume *volume, pa_boo * volumes and update the flat volume of the sink */ pa_sink_update_flat_volume(i->sink, &new_volume); - pa_sink_set_volume(i->sink, &new_volume, FALSE, TRUE, FALSE); + pa_sink_set_volume(i->sink, &new_volume, FALSE, TRUE, FALSE, FALSE); } else { @@ -1159,7 +1159,7 @@ int pa_sink_input_start_move(pa_sink_input *i) { /* We might need to update the sink's volume if we are in flat * volume mode. */ pa_sink_update_flat_volume(i->sink, &new_volume); - pa_sink_set_volume(i->sink, &new_volume, FALSE, FALSE, FALSE); + pa_sink_set_volume(i->sink, &new_volume, FALSE, FALSE, FALSE, FALSE); } pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_START_MOVE, i, 0, NULL) == 0); @@ -1252,7 +1252,7 @@ int pa_sink_input_finish_move(pa_sink_input *i, pa_sink *dest, pa_bool_t save) { /* We might need to update the sink's volume if we are in flat volume mode. */ pa_sink_update_flat_volume(i->sink, &new_volume); - pa_sink_set_volume(i->sink, &new_volume, FALSE, FALSE, FALSE); + pa_sink_set_volume(i->sink, &new_volume, FALSE, FALSE, FALSE, FALSE); } pa_assert_se(pa_asyncmsgq_send(i->sink->asyncmsgq, PA_MSGOBJECT(i->sink), PA_SINK_MESSAGE_FINISH_MOVE, i, 0, NULL) == 0); diff --git a/src/pulsecore/sink.c b/src/pulsecore/sink.c index 1da094af..47792293 100644 --- a/src/pulsecore/sink.c +++ b/src/pulsecore/sink.c @@ -100,11 +100,51 @@ void pa_sink_new_data_set_muted(pa_sink_new_data *data, pa_bool_t mute) { data->muted = !!mute; } +void pa_sink_new_data_set_port(pa_sink_new_data *data, const char *port) { + pa_assert(data); + + pa_xfree(data->active_port); + data->active_port = pa_xstrdup(port); +} + void pa_sink_new_data_done(pa_sink_new_data *data) { pa_assert(data); - pa_xfree(data->name); pa_proplist_free(data->proplist); + + if (data->ports) { + pa_device_port *p; + + while ((p = pa_hashmap_steal_first(data->ports))) + pa_device_port_free(p); + + pa_hashmap_free(data->ports, NULL, NULL); + } + + pa_xfree(data->name); + pa_xfree(data->active_port); +} + +pa_device_port *pa_device_port_new(const char *name, const char *description, size_t extra) { + pa_device_port *p; + + pa_assert(name); + + p = pa_xmalloc(PA_ALIGN(sizeof(pa_device_port)) + extra); + p->name = pa_xstrdup(name); + p->description = pa_xstrdup(description); + + p->priority = 0; + + return p; +} + +void pa_device_port_free(pa_device_port *p) { + pa_assert(p); + + pa_xfree(p->name); + pa_xfree(p->description); + pa_xfree(p); } /* Called from main context */ @@ -118,6 +158,7 @@ static void reset_callbacks(pa_sink *s) { s->set_mute = NULL; s->request_rewind = NULL; s->update_requested_latency = NULL; + s->set_port = NULL; } /* Called from main context */ @@ -152,6 +193,8 @@ pa_sink* pa_sink_new( return NULL; } + /* FIXME, need to free s here on failure */ + pa_return_null_if_fail(!data->driver || pa_utf8_valid(data->driver)); pa_return_null_if_fail(data->name && pa_utf8_valid(data->name) && data->name[0]); @@ -219,6 +262,30 @@ pa_sink* pa_sink_new( s->asyncmsgq = NULL; s->rtpoll = NULL; + /* As a minor optimization we just steal the list instead of + * copying it here */ + s->ports = data->ports; + data->ports = NULL; + + s->active_port = NULL; + s->save_port = FALSE; + + if (data->active_port && s->ports) + if ((s->active_port = pa_hashmap_get(s->ports, data->active_port))) + s->save_port = data->save_port; + + if (!s->active_port && s->ports) { + void *state; + pa_device_port *p; + + PA_HASHMAP_FOREACH(p, s->ports, state) + if (!s->active_port || p->priority > s->active_port->priority) + s->active_port = p; + } + + s->save_volume = data->save_volume; + s->save_muted = data->save_muted; + pa_silence_memchunk_get( &core->silence_cache, core->mempool, @@ -467,6 +534,15 @@ static void sink_free(pa_object *o) { if (s->proplist) pa_proplist_free(s->proplist); + if (s->ports) { + pa_device_port *p; + + while ((p = pa_hashmap_steal_first(s->ports))) + pa_device_port_free(p); + + pa_hashmap_free(s->ports, NULL, NULL); + } + pa_xfree(s); } @@ -485,6 +561,7 @@ void pa_sink_set_rtpoll(pa_sink *s, pa_rtpoll *p) { pa_sink_assert_ref(s); s->rtpoll = p; + if (s->monitor_source) pa_source_set_rtpoll(s->monitor_source, p); } @@ -526,15 +603,15 @@ int pa_sink_suspend(pa_sink *s, pa_bool_t suspend, pa_suspend_cause_t cause) { } /* Called from main context */ -pa_queue *pa_sink_move_all_start(pa_sink *s) { - pa_queue *q; +pa_queue *pa_sink_move_all_start(pa_sink *s, pa_queue *q) { pa_sink_input *i, *n; uint32_t idx; pa_sink_assert_ref(s); pa_assert(PA_SINK_IS_LINKED(s->state)); - q = pa_queue_new(); + if (!q) + q = pa_queue_new(); for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = n) { n = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx)); @@ -1237,7 +1314,7 @@ void pa_sink_propagate_flat_volume(pa_sink *s) { } /* Called from main thread */ -void pa_sink_set_volume(pa_sink *s, const pa_cvolume *volume, pa_bool_t propagate, pa_bool_t sendmsg, pa_bool_t become_reference) { +void pa_sink_set_volume(pa_sink *s, const pa_cvolume *volume, pa_bool_t propagate, pa_bool_t sendmsg, pa_bool_t become_reference, pa_bool_t save) { pa_bool_t virtual_volume_changed; pa_sink_assert_ref(s); @@ -1248,6 +1325,7 @@ void pa_sink_set_volume(pa_sink *s, const pa_cvolume *volume, pa_bool_t propagat virtual_volume_changed = !pa_cvolume_equal(volume, &s->virtual_volume); s->virtual_volume = *volume; + s->save_volume = (!virtual_volume_changed && s->save_volume) || save; if (become_reference) s->reference_volume = s->virtual_volume; @@ -1318,15 +1396,17 @@ const pa_cvolume *pa_sink_get_volume(pa_sink *s, pa_bool_t force_refresh, pa_boo } /* Called from main thread */ -void pa_sink_volume_changed(pa_sink *s, const pa_cvolume *new_volume) { +void pa_sink_volume_changed(pa_sink *s, const pa_cvolume *new_volume, pa_bool_t save) { pa_sink_assert_ref(s); /* The sink implementor may call this if the volume changed to make sure everyone is notified */ - - if (pa_cvolume_equal(&s->virtual_volume, new_volume)) + if (pa_cvolume_equal(&s->virtual_volume, new_volume)) { + s->save_volume = s->save_volume || save; return; + } s->reference_volume = s->virtual_volume = *new_volume; + s->save_volume = save; if (s->flags & PA_SINK_FLAT_VOLUME) pa_sink_propagate_flat_volume(s); @@ -1335,7 +1415,7 @@ void pa_sink_volume_changed(pa_sink *s, const pa_cvolume *new_volume) { } /* Called from main thread */ -void pa_sink_set_mute(pa_sink *s, pa_bool_t mute) { +void pa_sink_set_mute(pa_sink *s, pa_bool_t mute, pa_bool_t save) { pa_bool_t old_muted; pa_sink_assert_ref(s); @@ -1343,6 +1423,7 @@ void pa_sink_set_mute(pa_sink *s, pa_bool_t mute) { old_muted = s->muted; s->muted = mute; + s->save_muted = (old_muted == s->muted && s->save_muted) || save; if (s->set_mute) s->set_mute(s); @@ -1378,15 +1459,19 @@ pa_bool_t pa_sink_get_mute(pa_sink *s, pa_bool_t force_refresh) { } /* Called from main thread */ -void pa_sink_mute_changed(pa_sink *s, pa_bool_t new_muted) { +void pa_sink_mute_changed(pa_sink *s, pa_bool_t new_muted, pa_bool_t save) { pa_sink_assert_ref(s); /* The sink implementor may call this if the volume changed to make sure everyone is notified */ - if (s->muted == new_muted) + if (s->muted == new_muted) { + s->save_muted = s->save_muted || save; return; + } s->muted = new_muted; + s->save_muted = save; + pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index); } @@ -1484,7 +1569,7 @@ unsigned pa_sink_check_suspend(pa_sink *s) { ret = 0; - for (i = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); i; i = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) { + PA_IDXSET_FOREACH(i, s->inputs, idx) { pa_sink_input_state_t st; st = pa_sink_input_get_state(i); @@ -2194,6 +2279,41 @@ size_t pa_sink_get_max_request(pa_sink *s) { return r; } +/* Called from main context */ +int pa_sink_set_port(pa_sink *s, const char *name, pa_bool_t save) { + pa_device_port *port; + + pa_assert(s); + + if (!s->set_port) { + pa_log_debug("set_port() operation not implemented for sink %u \"%s\"", s->index, s->name); + return -PA_ERR_NOTIMPLEMENTED; + } + + if (!s->ports) + return -PA_ERR_NOENTITY; + + if (!(port = pa_hashmap_get(s->ports, name))) + return -PA_ERR_NOENTITY; + + if (s->active_port == port) { + s->save_port = s->save_port || save; + return 0; + } + + if ((s->set_port(s, port)) < 0) + return -PA_ERR_NOENTITY; + + pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_CHANGE, s->index); + + pa_log_info("Changed port of sink %u \"%s\" to %s", s->index, s->name, port->name); + + s->active_port = port; + s->save_port = save; + + return 0; +} + /* Called from main context */ pa_bool_t pa_device_init_icon(pa_proplist *p, pa_bool_t is_sink) { const char *ff, *c, *t = NULL, *s = "", *profile, *bus; diff --git a/src/pulsecore/sink.h b/src/pulsecore/sink.h index 0f32d163..d16fcc01 100644 --- a/src/pulsecore/sink.h +++ b/src/pulsecore/sink.h @@ -24,6 +24,7 @@ ***/ typedef struct pa_sink pa_sink; +typedef struct pa_device_port pa_device_port; #include @@ -49,11 +50,23 @@ static inline pa_bool_t PA_SINK_IS_LINKED(pa_sink_state_t x) { return x == PA_SINK_RUNNING || x == PA_SINK_IDLE || x == PA_SINK_SUSPENDED; } +struct pa_device_port { + char *name; + char *description; + + unsigned priority; + + /* .. followed by some implementation specific data */ +}; + +#define PA_DEVICE_PORT_DATA(d) ((void*) ((uint8_t*) d + PA_ALIGN(sizeof(pa_device_port)))) + struct pa_sink { pa_msgobject parent; uint32_t index; pa_core *core; + pa_sink_state_t state; pa_sink_flags_t flags; pa_suspend_cause_t suspend_cause; @@ -83,6 +96,9 @@ struct pa_sink { pa_bool_t refresh_volume:1; pa_bool_t refresh_muted:1; + pa_bool_t save_port:1; + pa_bool_t save_volume:1; + pa_bool_t save_muted:1; pa_asyncmsgq *asyncmsgq; pa_rtpoll *rtpoll; @@ -91,6 +107,9 @@ struct pa_sink { pa_usec_t fixed_latency; /* for sinks with PA_SINK_DYNAMIC_LATENCY this is 0 */ + pa_hashmap *ports; + pa_device_port *active_port; + /* Called when the main loop requests a state change. Called from * main loop context. If returns -1 the state change will be * inhibited */ @@ -126,6 +145,10 @@ struct pa_sink { * thread context. */ void (*update_requested_latency)(pa_sink *s); /* dito */ + /* Called whenever the port shall be changed. Called from main + * thread. */ + int (*set_port)(pa_sink *s, pa_device_port *port); /* dito */ + /* Contains copies of the above data so that the real-time worker * thread can work without access locking */ struct { @@ -192,6 +215,9 @@ typedef struct pa_sink_new_data { pa_module *module; pa_card *card; + pa_hashmap *ports; + char *active_port; + pa_sample_spec sample_spec; pa_channel_map channel_map; pa_cvolume volume; @@ -203,6 +229,10 @@ typedef struct pa_sink_new_data { pa_bool_t muted_is_set:1; pa_bool_t namereg_fail:1; + + pa_bool_t save_port:1; + pa_bool_t save_volume:1; + pa_bool_t save_muted:1; } pa_sink_new_data; pa_sink_new_data* pa_sink_new_data_init(pa_sink_new_data *data); @@ -211,6 +241,7 @@ void pa_sink_new_data_set_sample_spec(pa_sink_new_data *data, const pa_sample_sp void pa_sink_new_data_set_channel_map(pa_sink_new_data *data, const pa_channel_map *map); void pa_sink_new_data_set_volume(pa_sink_new_data *data, const pa_cvolume *volume); void pa_sink_new_data_set_muted(pa_sink_new_data *data, pa_bool_t mute); +void pa_sink_new_data_set_port(pa_sink_new_data *data, const char *port); void pa_sink_new_data_done(pa_sink_new_data *data); /*** To be called exclusively by the sink driver, from main context */ @@ -236,8 +267,8 @@ void pa_sink_detach(pa_sink *s); void pa_sink_attach(pa_sink *s); void pa_sink_set_soft_volume(pa_sink *s, const pa_cvolume *volume); -void pa_sink_volume_changed(pa_sink *s, const pa_cvolume *new_volume); -void pa_sink_mute_changed(pa_sink *s, pa_bool_t new_muted); +void pa_sink_volume_changed(pa_sink *s, const pa_cvolume *new_volume, pa_bool_t save); +void pa_sink_mute_changed(pa_sink *s, pa_bool_t new_muted, pa_bool_t save); pa_bool_t pa_device_init_description(pa_proplist *p); pa_bool_t pa_device_init_icon(pa_proplist *p, pa_bool_t is_sink); @@ -260,21 +291,23 @@ int pa_sink_suspend_all(pa_core *c, pa_bool_t suspend, pa_suspend_cause_t cause) void pa_sink_update_flat_volume(pa_sink *s, pa_cvolume *new_volume); void pa_sink_propagate_flat_volume(pa_sink *s); -void pa_sink_set_volume(pa_sink *sink, const pa_cvolume *volume, pa_bool_t propagate, pa_bool_t sendmsg, pa_bool_t become_reference); +void pa_sink_set_volume(pa_sink *sink, const pa_cvolume *volume, pa_bool_t propagate, pa_bool_t sendmsg, pa_bool_t become_reference, pa_bool_t save); const pa_cvolume *pa_sink_get_volume(pa_sink *sink, pa_bool_t force_refresh, pa_bool_t reference); -void pa_sink_set_mute(pa_sink *sink, pa_bool_t mute); +void pa_sink_set_mute(pa_sink *sink, pa_bool_t mute, pa_bool_t save); pa_bool_t pa_sink_get_mute(pa_sink *sink, pa_bool_t force_refresh); pa_bool_t pa_sink_update_proplist(pa_sink *s, pa_update_mode_t mode, pa_proplist *p); +int pa_sink_set_port(pa_sink *s, const char *name, pa_bool_t save); + unsigned pa_sink_linked_by(pa_sink *s); /* Number of connected streams */ unsigned pa_sink_used_by(pa_sink *s); /* Number of connected streams which are not corked */ unsigned pa_sink_check_suspend(pa_sink *s); /* Returns how many streams are active that don't allow suspensions */ #define pa_sink_get_state(s) ((s)->state) /* Moves all inputs away, and stores them in pa_queue */ -pa_queue *pa_sink_move_all_start(pa_sink *s); +pa_queue *pa_sink_move_all_start(pa_sink *s, pa_queue *q); void pa_sink_move_all_finish(pa_sink *s, pa_queue *q, pa_bool_t save); void pa_sink_move_all_fail(pa_queue *q); @@ -307,4 +340,7 @@ void pa_sink_invalidate_requested_latency(pa_sink *s); pa_usec_t pa_sink_get_latency_within_thread(pa_sink *s); +pa_device_port *pa_device_port_new(const char *name, const char *description, size_t extra); +void pa_device_port_free(pa_device_port *p); + #endif diff --git a/src/pulsecore/source.c b/src/pulsecore/source.c index d35c8523..1e431160 100644 --- a/src/pulsecore/source.c +++ b/src/pulsecore/source.c @@ -93,11 +93,29 @@ void pa_source_new_data_set_muted(pa_source_new_data *data, pa_bool_t mute) { data->muted = !!mute; } +void pa_source_new_data_set_port(pa_source_new_data *data, const char *port) { + pa_assert(data); + + pa_xfree(data->active_port); + data->active_port = pa_xstrdup(port); +} + void pa_source_new_data_done(pa_source_new_data *data) { pa_assert(data); - pa_xfree(data->name); pa_proplist_free(data->proplist); + + if (data->ports) { + pa_device_port *p; + + while ((p = pa_hashmap_steal_first(data->ports))) + pa_device_port_free(p); + + pa_hashmap_free(data->ports, NULL, NULL); + } + + pa_xfree(data->name); + pa_xfree(data->active_port); } /* Called from main context */ @@ -110,6 +128,7 @@ static void reset_callbacks(pa_source *s) { s->get_mute = NULL; s->set_mute = NULL; s->update_requested_latency = NULL; + s->set_port = NULL; } /* Called from main context */ @@ -142,6 +161,8 @@ pa_source* pa_source_new( return NULL; } + /* FIXME, need to free s here on failure */ + pa_return_null_if_fail(!data->driver || pa_utf8_valid(data->driver)); pa_return_null_if_fail(data->name && pa_utf8_valid(data->name) && data->name[0]); @@ -210,6 +231,30 @@ pa_source* pa_source_new( s->asyncmsgq = NULL; s->rtpoll = NULL; + /* As a minor optimization we just steal the list instead of + * copying it here */ + s->ports = data->ports; + data->ports = NULL; + + s->active_port = NULL; + s->save_port = FALSE; + + if (data->active_port && s->ports) + if ((s->active_port = pa_hashmap_get(s->ports, data->active_port))) + s->save_port = data->save_port; + + if (!s->active_port && s->ports) { + void *state; + pa_device_port *p; + + PA_HASHMAP_FOREACH(p, s->ports, state) + if (!s->active_port || p->priority > s->active_port->priority) + s->active_port = p; + } + + s->save_volume = data->save_volume; + s->save_muted = data->save_muted; + pa_silence_memchunk_get( &core->silence_cache, core->mempool, @@ -400,6 +445,15 @@ static void source_free(pa_object *o) { if (s->proplist) pa_proplist_free(s->proplist); + if (s->ports) { + pa_device_port *p; + + while ((p = pa_hashmap_steal_first(s->ports))) + pa_device_port_free(p); + + pa_hashmap_free(s->ports, NULL, NULL); + } + pa_xfree(s); } @@ -472,15 +526,15 @@ int pa_source_sync_suspend(pa_source *s) { } /* Called from main context */ -pa_queue *pa_source_move_all_start(pa_source *s) { - pa_queue *q; +pa_queue *pa_source_move_all_start(pa_source *s, pa_queue *q) { pa_source_output *o, *n; uint32_t idx; pa_source_assert_ref(s); pa_assert(PA_SOURCE_IS_LINKED(s->state)); - q = pa_queue_new(); + if (!q) + q = pa_queue_new(); for (o = PA_SOURCE_OUTPUT(pa_idxset_first(s->outputs, &idx)); o; o = n) { n = PA_SOURCE_OUTPUT(pa_idxset_next(s->outputs, &idx)); @@ -667,7 +721,7 @@ pa_usec_t pa_source_get_latency_within_thread(pa_source *s) { } /* Called from main thread */ -void pa_source_set_volume(pa_source *s, const pa_cvolume *volume) { +void pa_source_set_volume(pa_source *s, const pa_cvolume *volume, pa_bool_t save) { pa_cvolume old_virtual_volume; pa_bool_t virtual_volume_changed; @@ -680,6 +734,7 @@ void pa_source_set_volume(pa_source *s, const pa_cvolume *volume) { old_virtual_volume = s->virtual_volume; s->virtual_volume = *volume; virtual_volume_changed = !pa_cvolume_equal(&old_virtual_volume, &s->virtual_volume); + s->save_volume = (!virtual_volume_changed && s->save_volume) || save; if (s->set_volume) { pa_cvolume_reset(&s->soft_volume, s->sample_spec.channels); @@ -725,20 +780,24 @@ const pa_cvolume *pa_source_get_volume(pa_source *s, pa_bool_t force_refresh) { } /* Called from main thread */ -void pa_source_volume_changed(pa_source *s, const pa_cvolume *new_volume) { +void pa_source_volume_changed(pa_source *s, const pa_cvolume *new_volume, pa_bool_t save) { pa_source_assert_ref(s); /* The source implementor may call this if the volume changed to make sure everyone is notified */ - if (pa_cvolume_equal(&s->virtual_volume, new_volume)) + if (pa_cvolume_equal(&s->virtual_volume, new_volume)) { + s->save_volume = s->save_volume || save; return; + } s->virtual_volume = *new_volume; + s->save_volume = save; + pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index); } /* Called from main thread */ -void pa_source_set_mute(pa_source *s, pa_bool_t mute) { +void pa_source_set_mute(pa_source *s, pa_bool_t mute, pa_bool_t save) { pa_bool_t old_muted; pa_source_assert_ref(s); @@ -746,6 +805,7 @@ void pa_source_set_mute(pa_source *s, pa_bool_t mute) { old_muted = s->muted; s->muted = mute; + s->save_muted = (old_muted == s->muted && s->save_muted) || save; if (s->set_mute) s->set_mute(s); @@ -781,15 +841,19 @@ pa_bool_t pa_source_get_mute(pa_source *s, pa_bool_t force_refresh) { } /* Called from main thread */ -void pa_source_mute_changed(pa_source *s, pa_bool_t new_muted) { +void pa_source_mute_changed(pa_source *s, pa_bool_t new_muted, pa_bool_t save) { pa_source_assert_ref(s); /* The source implementor may call this if the mute state changed to make sure everyone is notified */ - if (s->muted == new_muted) + if (s->muted == new_muted) { + s->save_muted = s->save_muted || save; return; + } s->muted = new_muted; + s->save_muted = save; + pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index); } @@ -866,7 +930,7 @@ unsigned pa_source_check_suspend(pa_source *s) { ret = 0; - for (o = PA_SOURCE_OUTPUT(pa_idxset_first(s->outputs, &idx)); o; o = PA_SOURCE_OUTPUT(pa_idxset_next(s->outputs, &idx))) { + PA_IDXSET_FOREACH(o, s->outputs, idx) { pa_source_output_state_t st; st = pa_source_output_get_state(o); @@ -1323,3 +1387,38 @@ size_t pa_source_get_max_rewind(pa_source *s) { return r; } + +/* Called from main context */ +int pa_source_set_port(pa_source *s, const char *name, pa_bool_t save) { + pa_device_port *port; + + pa_assert(s); + + if (!s->set_port) { + pa_log_debug("set_port() operation not implemented for sink %u \"%s\"", s->index, s->name); + return -PA_ERR_NOTIMPLEMENTED; + } + + if (!s->ports) + return -PA_ERR_NOENTITY; + + if (!(port = pa_hashmap_get(s->ports, name))) + return -PA_ERR_NOENTITY; + + if (s->active_port == port) { + s->save_port = s->save_port || save; + return 0; + } + + if ((s->set_port(s, port)) < 0) + return -PA_ERR_NOENTITY; + + pa_subscription_post(s->core, PA_SUBSCRIPTION_EVENT_SOURCE|PA_SUBSCRIPTION_EVENT_CHANGE, s->index); + + pa_log_info("Changed port of source %u \"%s\" to %s", s->index, s->name, port->name); + + s->active_port = port; + s->save_port = save; + + return 0; +} diff --git a/src/pulsecore/source.h b/src/pulsecore/source.h index 1fbed70e..7e9fd8b7 100644 --- a/src/pulsecore/source.h +++ b/src/pulsecore/source.h @@ -56,6 +56,7 @@ struct pa_source { uint32_t index; pa_core *core; + pa_source_state_t state; pa_source_flags_t flags; pa_suspend_cause_t suspend_cause; @@ -83,6 +84,10 @@ struct pa_source { pa_bool_t refresh_volume:1; pa_bool_t refresh_muted:1; + pa_bool_t save_port:1; + pa_bool_t save_volume:1; + pa_bool_t save_muted:1; + pa_asyncmsgq *asyncmsgq; pa_rtpoll *rtpoll; @@ -90,6 +95,9 @@ struct pa_source { pa_usec_t fixed_latency; /* for sources with PA_SOURCE_DYNAMIC_LATENCY this is 0 */ + pa_hashmap *ports; + pa_device_port *active_port; + /* Called when the main loop requests a state change. Called from * main loop context. If returns -1 the state change will be * inhibited */ @@ -121,6 +129,10 @@ struct pa_source { * thread context. */ void (*update_requested_latency)(pa_source *s); /* dito */ + /* Called whenever the port shall be changed. Called from main + * thread. */ + int (*set_port)(pa_source *s, pa_device_port *port); /*dito */ + /* Contains copies of the above data so that the real-time worker * thread can work without access locking */ struct { @@ -174,6 +186,9 @@ typedef struct pa_source_new_data { pa_module *module; pa_card *card; + pa_hashmap *ports; + char *active_port; + pa_sample_spec sample_spec; pa_channel_map channel_map; pa_cvolume volume; @@ -185,6 +200,10 @@ typedef struct pa_source_new_data { pa_bool_t channel_map_is_set:1; pa_bool_t namereg_fail:1; + + pa_bool_t save_port:1; + pa_bool_t save_volume:1; + pa_bool_t save_muted:1; } pa_source_new_data; pa_source_new_data* pa_source_new_data_init(pa_source_new_data *data); @@ -193,6 +212,7 @@ void pa_source_new_data_set_sample_spec(pa_source_new_data *data, const pa_sampl void pa_source_new_data_set_channel_map(pa_source_new_data *data, const pa_channel_map *map); void pa_source_new_data_set_volume(pa_source_new_data *data, const pa_cvolume *volume); void pa_source_new_data_set_muted(pa_source_new_data *data, pa_bool_t mute); +void pa_source_new_data_set_port(pa_source_new_data *data, const char *port); void pa_source_new_data_done(pa_source_new_data *data); /*** To be called exclusively by the source driver, from main context */ @@ -217,8 +237,8 @@ void pa_source_detach(pa_source *s); void pa_source_attach(pa_source *s); void pa_source_set_soft_volume(pa_source *s, const pa_cvolume *volume); -void pa_source_volume_changed(pa_source *s, const pa_cvolume *new_volume); -void pa_source_mute_changed(pa_source *s, pa_bool_t new_muted); +void pa_source_volume_changed(pa_source *s, const pa_cvolume *new_volume, pa_bool_t save); +void pa_source_mute_changed(pa_source *s, pa_bool_t new_muted, pa_bool_t save); int pa_source_sync_suspend(pa_source *s); @@ -235,20 +255,22 @@ int pa_source_update_status(pa_source*s); int pa_source_suspend(pa_source *s, pa_bool_t suspend, pa_suspend_cause_t cause); int pa_source_suspend_all(pa_core *c, pa_bool_t suspend, pa_suspend_cause_t cause); -void pa_source_set_volume(pa_source *source, const pa_cvolume *volume); +void pa_source_set_volume(pa_source *source, const pa_cvolume *volume, pa_bool_t save); const pa_cvolume *pa_source_get_volume(pa_source *source, pa_bool_t force_refresh); -void pa_source_set_mute(pa_source *source, pa_bool_t mute); +void pa_source_set_mute(pa_source *source, pa_bool_t mute, pa_bool_t save); pa_bool_t pa_source_get_mute(pa_source *source, pa_bool_t force_refresh); pa_bool_t pa_source_update_proplist(pa_source *s, pa_update_mode_t mode, pa_proplist *p); +int pa_source_set_port(pa_source *s, const char *name, pa_bool_t save); + unsigned pa_source_linked_by(pa_source *s); /* Number of connected streams */ unsigned pa_source_used_by(pa_source *s); /* Number of connected streams that are not corked */ unsigned pa_source_check_suspend(pa_source *s); /* Returns how many streams are active that don't allow suspensions */ #define pa_source_get_state(s) ((pa_source_state_t) (s)->state) /* Moves all inputs away, and stores them in pa_queue */ -pa_queue *pa_source_move_all_start(pa_source *s); +pa_queue *pa_source_move_all_start(pa_source *s, pa_queue *q); void pa_source_move_all_finish(pa_source *s, pa_queue *q, pa_bool_t save); void pa_source_move_all_fail(pa_queue *q); -- cgit