From 6cc3a615fa4f2c0f53e77d431d77422433cda1f0 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Mon, 4 Aug 2008 19:00:43 +0200 Subject: store channel map in database and remap volumes if necessary --- src/modules/module-stream-restore.c | 33 +++++++++++++++++++++++---------- 1 file changed, 23 insertions(+), 10 deletions(-) (limited to 'src/modules/module-stream-restore.c') diff --git a/src/modules/module-stream-restore.c b/src/modules/module-stream-restore.c index 22e2ff62..cac8a9bb 100644 --- a/src/modules/module-stream-restore.c +++ b/src/modules/module-stream-restore.c @@ -65,6 +65,7 @@ static const char* const valid_modargs[] = { struct userdata { pa_core *core; + pa_module *module; pa_subscription *subscription; pa_hook_slot *sink_input_new_hook_slot, @@ -79,8 +80,9 @@ struct userdata { }; struct entry { - pa_cvolume volume; char device[PA_NAME_MAX]; + pa_channel_map channel_map; + pa_cvolume volume; pa_bool_t muted:1; }; @@ -146,7 +148,17 @@ static struct entry* read_entry(struct userdata *u, char *name) { } if (!(pa_cvolume_valid(&e->volume))) { - pa_log_warn("Invalid volume stored in database for device %s", name); + pa_log_warn("Invalid volume stored in database for stream %s", name); + goto fail; + } + + if (!(pa_channel_map_valid(&e->channel_map))) { + pa_log_warn("Invalid channel map stored in database for stream %s", name); + goto fail; + } + + if (e->volume.channels != e->channel_map.channels) { + pa_log_warn("Volume and channel map don't match in database entry for stream %s", name); goto fail; } @@ -182,6 +194,7 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3 if (!(name = get_name(sink_input->proplist, "sink-input"))) return; + entry.channel_map = sink_input->channel_map; entry.volume = *pa_sink_input_get_volume(sink_input); entry.muted = pa_sink_input_get_mute(sink_input); pa_strlcpy(entry.device, sink_input->sink->name, sizeof(entry.device)); @@ -197,15 +210,16 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3 if (!(name = get_name(source_output->proplist, "source-output"))) return; - memset(&entry.volume, 0, sizeof(entry.volume)); - entry.muted = FALSE; - + /* The following fields are filled in to make the entry valid + * according to read_entry(). They are otherwise useless */ + entry.channel_map = source_output->channel_map; + pa_cvolume_reset(&entry.volume, entry.channel_map.channels); pa_strlcpy(entry.device, source_output->source->name, sizeof(entry.device)); } if ((old = read_entry(u, name))) { - if (pa_cvolume_equal(&old->volume, &entry.volume) && + if (pa_cvolume_equal(pa_cvolume_remap(&old->volume, &old->channel_map, &entry.channel_map), &entry.volume) && !old->muted == !entry.muted && strcmp(old->device, entry.device) == 0) { @@ -276,11 +290,9 @@ static pa_hook_result_t sink_input_fixate_hook_callback(pa_core *c, pa_sink_inpu if ((e = read_entry(u, name))) { - if (u->restore_volume && - e->volume.channels == new_data->sample_spec.channels) { - + if (u->restore_volume) { pa_log_info("Restoring volume for sink input %s.", name); - pa_sink_input_new_data_set_volume(new_data, &e->volume); + pa_sink_input_new_data_set_volume(new_data, pa_cvolume_remap(&e->volume, &e->channel_map, &new_data->channel_map)); } if (u->restore_muted) { @@ -353,6 +365,7 @@ int pa__init(pa_module*m) { m->userdata = u = pa_xnew(struct userdata, 1); u->core = m->core; + u->module = m; u->save_time_event = NULL; u->restore_device = restore_device; u->restore_volume = restore_volume; -- cgit From 88c3db6636988e39c99220ba4969625b709e97ed Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Mon, 4 Aug 2008 19:01:13 +0200 Subject: add protocol extension to module-stream-restore --- src/modules/module-stream-restore.c | 332 ++++++++++++++++++++++++++++++++++-- 1 file changed, 322 insertions(+), 10 deletions(-) (limited to 'src/modules/module-stream-restore.c') diff --git a/src/modules/module-stream-restore.c b/src/modules/module-stream-restore.c index cac8a9bb..ee6fab42 100644 --- a/src/modules/module-stream-restore.c +++ b/src/modules/module-stream-restore.c @@ -46,6 +46,9 @@ #include #include #include +#include +#include +#include #include "module-stream-restore-symdef.h" @@ -70,13 +73,17 @@ struct userdata { pa_hook_slot *sink_input_new_hook_slot, *sink_input_fixate_hook_slot, - *source_output_new_hook_slot; + *source_output_new_hook_slot, + *connection_unlink_hook_slot; pa_time_event *save_time_event; GDBM_FILE gdbm_file; pa_bool_t restore_device:1; pa_bool_t restore_volume:1; pa_bool_t restore_muted:1; + + pa_native_protocol *protocol; + pa_idxset *subscribed; }; struct entry { @@ -86,6 +93,16 @@ struct entry { pa_bool_t muted:1; }; + +enum { + SUBCOMMAND_TEST, + SUBCOMMAND_READ, + SUBCOMMAND_WRITE, + SUBCOMMAND_DELETE, + SUBCOMMAND_SUBSCRIBE, + SUBCOMMAND_EVENT +}; + static void save_time_callback(pa_mainloop_api*a, pa_time_event* e, const struct timeval *tv, void *userdata) { struct userdata *u = userdata; @@ -170,6 +187,32 @@ fail: return NULL; } +static void trigger_save(struct userdata *u) { + struct timeval tv; + pa_native_connection *c; + uint32_t idx; + + for (c = pa_idxset_first(u->subscribed, &idx); c; c = pa_idxset_next(u->subscribed, &idx)) { + pa_tagstruct *t; + + t = pa_tagstruct_new(NULL, 0); + pa_tagstruct_putu32(t, PA_COMMAND_EXTENSION); + pa_tagstruct_putu32(t, 0); + pa_tagstruct_putu32(t, u->module->index); + pa_tagstruct_puts(t, u->module->name); + pa_tagstruct_putu32(t, SUBCOMMAND_EVENT); + + pa_pstream_send_tagstruct(pa_native_connection_get_pstream(c), t); + } + + if (u->save_time_event) + return; + + pa_gettimeofday(&tv); + tv.tv_sec += SAVE_INTERVAL; + u->save_time_event = u->core->mainloop->time_new(u->core->mainloop, &tv, save_time_callback, u); +} + static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint32_t idx, void *userdata) { struct userdata *u = userdata; struct entry entry, *old; @@ -185,6 +228,8 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3 t != (PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE)) return; + memset(&entry, 0, sizeof(entry)); + if ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SINK_INPUT) { pa_sink_input *sink_input; @@ -241,14 +286,9 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3 gdbm_store(u->gdbm_file, key, data, GDBM_REPLACE); - if (!u->save_time_event) { - struct timeval tv; - pa_gettimeofday(&tv); - tv.tv_sec += SAVE_INTERVAL; - u->save_time_event = u->core->mainloop->time_new(u->core->mainloop, &tv, save_time_callback, u); - } - pa_xfree(name); + + trigger_save(u); } static pa_hook_result_t sink_input_new_hook_callback(pa_core *c, pa_sink_input_new_data *new_data, struct userdata *u) { @@ -264,7 +304,6 @@ static pa_hook_result_t sink_input_new_hook_callback(pa_core *c, pa_sink_input_n pa_sink *s; if (u->restore_device && - e->device[0] && (s = pa_namereg_get(c, e->device, PA_NAMEREG_SINK, TRUE))) { pa_log_info("Restoring device for stream %s.", name); @@ -321,7 +360,6 @@ static pa_hook_result_t source_output_new_hook_callback(pa_core *c, pa_source_ou pa_source *s; if (u->restore_device && - e->device[0] && (s = pa_namereg_get(c, e->device, PA_NAMEREG_SOURCE, TRUE))) { pa_log_info("Restoring device for stream %s.", name); @@ -336,6 +374,262 @@ static pa_hook_result_t source_output_new_hook_callback(pa_core *c, pa_source_ou return PA_HOOK_OK; } +#define EXT_VERSION 1 + +static void clear_db(struct userdata *u) { + datum key; + + pa_assert(u); + + key = gdbm_firstkey(u->gdbm_file); + while (key.dptr) { + datum next_key; + next_key = gdbm_nextkey(u->gdbm_file, key); + + gdbm_delete(u->gdbm_file, key); + pa_xfree(key.dptr); + + key = next_key; + } + + gdbm_reorganize(u->gdbm_file); +} + +static void apply_entry(struct userdata *u, const char *name, struct entry *e) { + pa_sink_input *si; + pa_source_output *so; + uint32_t idx; + + pa_assert(u); + pa_assert(name); + pa_assert(e); + + for (si = pa_idxset_first(u->core->sink_inputs, &idx); si; si = pa_idxset_next(u->core->sink_inputs, &idx)) { + char *n; + pa_sink *s; + + if (!(n = get_name(si->proplist, "sink_input"))) + continue; + + if (strcmp(name, n)) { + pa_xfree(n); + continue; + } + + if (u->restore_volume) { + pa_log_info("Restoring volume for sink input %s.", name); + pa_sink_input_set_volume(si, pa_cvolume_remap(&e->volume, &e->channel_map, &si->channel_map)); + } + + if (u->restore_muted) { + pa_log_info("Restoring mute state for sink input %s.", name); + pa_sink_input_set_mute(si, e->muted); + } + + if (u->restore_device && + (s = pa_namereg_get(u->core, e->device, PA_NAMEREG_SOURCE, TRUE))) { + + pa_log_info("Restoring device for stream %s.", name); + pa_sink_input_move_to(si, s); + } + } + + for (so = pa_idxset_first(u->core->source_outputs, &idx); so; so = pa_idxset_next(u->core->source_outputs, &idx)) { + char *n; + pa_source *s; + + if (!(n = get_name(so->proplist, "source-output"))) + continue; + + if (strcmp(name, n)) { + pa_xfree(n); + continue; + } + + if (u->restore_device && + (s = pa_namereg_get(u->core, e->device, PA_NAMEREG_SOURCE, TRUE))) { + + pa_log_info("Restoring device for stream %s.", name); + pa_source_output_move_to(so, s); + } + } +} + +static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connection *c, uint32_t tag, pa_tagstruct *t) { + struct userdata *u; + uint32_t command; + pa_tagstruct *reply; + + pa_assert(p); + pa_assert(m); + pa_assert(c); + pa_assert(t); + + u = m->userdata; + + if (pa_tagstruct_getu32(t, &command) < 0) + goto fail; + + reply = pa_tagstruct_new(NULL, 0); + pa_tagstruct_putu32(reply, PA_COMMAND_REPLY); + pa_tagstruct_putu32(reply, tag); + + switch (command) { + case SUBCOMMAND_TEST: { + if (!pa_tagstruct_eof(t)) + goto fail; + + pa_tagstruct_putu32(reply, EXT_VERSION); + break; + } + + case SUBCOMMAND_READ: { + datum key; + + if (!pa_tagstruct_eof(t)) + goto fail; + + key = gdbm_firstkey(u->gdbm_file); + while (key.dptr) { + datum next_key; + struct entry *e; + char *name; + + next_key = gdbm_nextkey(u->gdbm_file, key); + + name = pa_xstrndup(key.dptr, key.dsize); + pa_xfree(key.dptr); + + if ((e = read_entry(u, name))) { + pa_tagstruct_puts(reply, name); + pa_tagstruct_put_channel_map(reply, &e->channel_map); + pa_tagstruct_put_cvolume(reply, &e->volume); + pa_tagstruct_puts(reply, e->device); + pa_tagstruct_put_boolean(reply, e->muted); + + pa_xfree(e); + } + + pa_xfree(name); + + key = next_key; + } + + break; + } + + case SUBCOMMAND_WRITE: { + uint32_t mode; + pa_bool_t apply_immediately; + + if (pa_tagstruct_getu32(t, &mode) < 0 || + pa_tagstruct_get_boolean(t, &apply_immediately) < 0) + goto fail; + + if (mode != PA_UPDATE_MERGE && + mode != PA_UPDATE_REPLACE && + mode != PA_UPDATE_SET) + goto fail; + + if (mode == PA_UPDATE_SET) + clear_db(u); + + while (!pa_tagstruct_eof(t)) { + const char *name, *device; + pa_bool_t muted; + struct entry entry; + datum key, data; + + memset(&entry, 0, sizeof(entry)); + + if (pa_tagstruct_gets(t, &name) < 0 || + pa_tagstruct_get_channel_map(t, &entry.channel_map) || + pa_tagstruct_get_cvolume(t, &entry.volume) < 0 || + pa_tagstruct_gets(t, &device) < 0 || + pa_tagstruct_get_boolean(t, &muted) < 0) + goto fail; + + if (entry.channel_map.channels != entry.volume.channels) + goto fail; + + entry.muted = muted; + pa_strlcpy(entry.device, device, sizeof(entry.device)); + + key.dptr = (void*) name; + key.dsize = strlen(name); + + data.dptr = (void*) &entry; + data.dsize = sizeof(entry); + + if (gdbm_store(u->gdbm_file, key, data, mode == PA_UPDATE_REPLACE ? GDBM_REPLACE : GDBM_INSERT) == 1) + if (apply_immediately) + apply_entry(u, name, &entry); + } + + trigger_save(u); + + break; + } + + case SUBCOMMAND_DELETE: + + while (!pa_tagstruct_eof(t)) { + const char *name; + datum key; + + if (pa_tagstruct_gets(t, &name) < 0) + goto fail; + + key.dptr = (void*) name; + key.dsize = strlen(name); + + gdbm_delete(u->gdbm_file, key); + } + + trigger_save(u); + + break; + + case SUBCOMMAND_SUBSCRIBE: { + + pa_bool_t enabled; + + if (pa_tagstruct_get_boolean(t, &enabled) < 0 || + !pa_tagstruct_eof(t)) + goto fail; + + if (enabled) + pa_idxset_put(u->subscribed, c, NULL); + else + pa_idxset_remove_by_data(u->subscribed, c, NULL); + + break; + } + + default: + goto fail; + } + + pa_pstream_send_tagstruct(pa_native_connection_get_pstream(c), reply); + return 0; + +fail: + + if (reply) + pa_tagstruct_free(reply); + + return -1; +} + +static pa_hook_result_t connection_unlink_hook_cb(pa_native_protocol *p, pa_native_connection *c, struct userdata *u) { + pa_assert(p); + pa_assert(c); + pa_assert(u); + + pa_idxset_remove_by_data(u->subscribed, c, NULL); + return PA_HOOK_OK; +} + int pa__init(pa_module*m) { pa_modargs *ma = NULL; struct userdata *u; @@ -370,6 +664,13 @@ int pa__init(pa_module*m) { u->restore_device = restore_device; u->restore_volume = restore_volume; u->restore_muted = restore_muted; + u->gdbm_file = NULL; + u->subscribed = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func); + + u->protocol = pa_native_protocol_get(m->core); + pa_native_protocol_install_ext(u->protocol, m, extension_cb); + + u->connection_unlink_hook_slot = pa_hook_connect(&pa_native_protocol_hooks(u->protocol)[PA_NATIVE_HOOK_CONNECTION_UNLINK], PA_HOOK_NORMAL, (pa_hook_cb_t) connection_unlink_hook_cb, u); u->subscription = pa_subscription_new(m->core, PA_SUBSCRIPTION_MASK_SINK_INPUT|PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT, subscribe_callback, u); @@ -436,11 +737,22 @@ void pa__done(pa_module*m) { if (u->source_output_new_hook_slot) pa_hook_slot_free(u->source_output_new_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); if (u->gdbm_file) gdbm_close(u->gdbm_file); + if (u->protocol) { + pa_native_protocol_remove_ext(u->protocol, m); + pa_native_protocol_unref(u->protocol); + } + + if (u->subscribed) + pa_idxset_free(u->subscribed, NULL, NULL); + pa_xfree(u); } -- cgit From ca127532fcddd28cc40bbbe0646a1205b365ffb7 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Tue, 5 Aug 2008 19:03:11 +0200 Subject: add a function to dump the stream database for debugging purposes --- src/modules/module-stream-restore.c | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) (limited to 'src/modules/module-stream-restore.c') diff --git a/src/modules/module-stream-restore.c b/src/modules/module-stream-restore.c index ee6fab42..b6d7b0f3 100644 --- a/src/modules/module-stream-restore.c +++ b/src/modules/module-stream-restore.c @@ -455,6 +455,38 @@ static void apply_entry(struct userdata *u, const char *name, struct entry *e) { } } +#if 0 +static void dump_database(struct userdata *u) { + datum key; + + key = gdbm_firstkey(u->gdbm_file); + while (key.dptr) { + datum next_key; + struct entry *e; + char *name; + + next_key = gdbm_nextkey(u->gdbm_file, key); + + name = pa_xstrndup(key.dptr, key.dsize); + pa_xfree(key.dptr); + + if ((e = read_entry(u, name))) { + char t[256]; + pa_log("name=%s", name); + pa_log("device=%s", e->device); + pa_log("channel_map=%s", pa_channel_map_snprint(t, sizeof(t), &e->channel_map)); + pa_log("volume=%s", pa_cvolume_snprint(t, sizeof(t), &e->volume)); + pa_log("mute=%s", pa_yes_no(e->muted)); + pa_xfree(e); + } + + pa_xfree(name); + + key = next_key; + } +} +#endif + static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connection *c, uint32_t tag, pa_tagstruct *t) { struct userdata *u; uint32_t command; -- cgit From ecb2bc4f04e5a6a71e19d4be651596cebbb83500 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Thu, 7 Aug 2008 02:28:47 +0200 Subject: Modify pa_state_path() to take an additional argument for prepending the machine id to the file name. --- src/modules/module-stream-restore.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'src/modules/module-stream-restore.c') diff --git a/src/modules/module-stream-restore.c b/src/modules/module-stream-restore.c index b6d7b0f3..ec4e7c79 100644 --- a/src/modules/module-stream-restore.c +++ b/src/modules/module-stream-restore.c @@ -666,7 +666,6 @@ int pa__init(pa_module*m) { pa_modargs *ma = NULL; struct userdata *u; char *fname, *fn; - char hn[256]; pa_sink_input *si; pa_source_output *so; uint32_t idx; @@ -714,11 +713,12 @@ int pa__init(pa_module*m) { if (restore_volume || restore_muted) u->sink_input_fixate_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_INPUT_FIXATE], PA_HOOK_EARLY, (pa_hook_cb_t) sink_input_fixate_hook_callback, u); - if (!pa_get_host_name(hn, sizeof(hn))) - goto fail; + /* We include the host identifier in the file name because gdbm + * files are CPU dependant, and we don't want things to go wrong + * if we are on a multiarch system. */ - fn = pa_sprintf_malloc("stream-volumes.%s."CANONICAL_HOST".gdbm", hn); - fname = pa_state_path(fn); + fn = pa_sprintf_malloc("stream-volumes."CANONICAL_HOST".gdbm"); + fname = pa_state_path(fn, TRUE); pa_xfree(fn); if (!fname) -- cgit From 72f520f93c576facf8a49af28b764e1be8ee4ad5 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Sat, 9 Aug 2008 17:04:27 +0200 Subject: make gcc shut up --- src/modules/module-stream-restore.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/modules/module-stream-restore.c') diff --git a/src/modules/module-stream-restore.c b/src/modules/module-stream-restore.c index ec4e7c79..b999304a 100644 --- a/src/modules/module-stream-restore.c +++ b/src/modules/module-stream-restore.c @@ -490,7 +490,7 @@ static void dump_database(struct userdata *u) { static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connection *c, uint32_t tag, pa_tagstruct *t) { struct userdata *u; uint32_t command; - pa_tagstruct *reply; + pa_tagstruct *reply = NULL; pa_assert(p); pa_assert(m); -- cgit From f68a6e5cab772184caf89895766eec32da4c7598 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Fri, 15 Aug 2008 14:33:18 +0200 Subject: don't restore devices for direct-on-input streams --- src/modules/module-stream-restore.c | 1 + 1 file changed, 1 insertion(+) (limited to 'src/modules/module-stream-restore.c') diff --git a/src/modules/module-stream-restore.c b/src/modules/module-stream-restore.c index b999304a..bf62f94c 100644 --- a/src/modules/module-stream-restore.c +++ b/src/modules/module-stream-restore.c @@ -360,6 +360,7 @@ static pa_hook_result_t source_output_new_hook_callback(pa_core *c, pa_source_ou pa_source *s; if (u->restore_device && + !new_data->direct_on_input && (s = pa_namereg_get(c, e->device, PA_NAMEREG_SOURCE, TRUE))) { pa_log_info("Restoring device for stream %s.", name); -- cgit From 512c24c65abf42d2546491607da4fed286c79e1f Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Fri, 15 Aug 2008 14:37:26 +0200 Subject: apply the correct rules to sink inputs --- src/modules/module-stream-restore.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/modules/module-stream-restore.c') diff --git a/src/modules/module-stream-restore.c b/src/modules/module-stream-restore.c index bf62f94c..e0683e72 100644 --- a/src/modules/module-stream-restore.c +++ b/src/modules/module-stream-restore.c @@ -409,7 +409,7 @@ static void apply_entry(struct userdata *u, const char *name, struct entry *e) { char *n; pa_sink *s; - if (!(n = get_name(si->proplist, "sink_input"))) + if (!(n = get_name(si->proplist, "sink-input"))) continue; if (strcmp(name, n)) { -- cgit From 63402b392be251ca5519cc668c3bf698aa33aed0 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Fri, 15 Aug 2008 14:37:54 +0200 Subject: apply volumes properly more than once in a row --- src/modules/module-stream-restore.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) (limited to 'src/modules/module-stream-restore.c') diff --git a/src/modules/module-stream-restore.c b/src/modules/module-stream-restore.c index e0683e72..5b9922ec 100644 --- a/src/modules/module-stream-restore.c +++ b/src/modules/module-stream-restore.c @@ -418,8 +418,9 @@ static void apply_entry(struct userdata *u, const char *name, struct entry *e) { } if (u->restore_volume) { + pa_cvolume v = e->volume; pa_log_info("Restoring volume for sink input %s.", name); - pa_sink_input_set_volume(si, pa_cvolume_remap(&e->volume, &e->channel_map, &si->channel_map)); + pa_sink_input_set_volume(si, pa_cvolume_remap(&v, &e->channel_map, &si->channel_map)); } if (u->restore_muted) { -- cgit From f84536bc0a76d751fe5adaef76d227a41b3285fc Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Fri, 15 Aug 2008 14:38:18 +0200 Subject: apply newly configured rules properly --- src/modules/module-stream-restore.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'src/modules/module-stream-restore.c') diff --git a/src/modules/module-stream-restore.c b/src/modules/module-stream-restore.c index 5b9922ec..73b32502 100644 --- a/src/modules/module-stream-restore.c +++ b/src/modules/module-stream-restore.c @@ -554,7 +554,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio case SUBCOMMAND_WRITE: { uint32_t mode; - pa_bool_t apply_immediately; + pa_bool_t apply_immediately = FALSE; if (pa_tagstruct_getu32(t, &mode) < 0 || pa_tagstruct_get_boolean(t, &apply_immediately) < 0) @@ -573,6 +573,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio pa_bool_t muted; struct entry entry; datum key, data; + int k; memset(&entry, 0, sizeof(entry)); @@ -595,7 +596,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio data.dptr = (void*) &entry; data.dsize = sizeof(entry); - if (gdbm_store(u->gdbm_file, key, data, mode == PA_UPDATE_REPLACE ? GDBM_REPLACE : GDBM_INSERT) == 1) + if ((k = gdbm_store(u->gdbm_file, key, data, mode == PA_UPDATE_REPLACE ? GDBM_REPLACE : GDBM_INSERT)) == 0) if (apply_immediately) apply_entry(u, name, &entry); } -- cgit From b8ba2de7ddfea2b0fa53dc7e8614d16b16ec1915 Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Mon, 18 Aug 2008 17:49:47 +0200 Subject: restore volume/device for streams only when it wasn't set before --- src/modules/module-stream-restore.c | 29 +++++++++++++++++++++-------- 1 file changed, 21 insertions(+), 8 deletions(-) (limited to 'src/modules/module-stream-restore.c') diff --git a/src/modules/module-stream-restore.c b/src/modules/module-stream-restore.c index 73b32502..7bbb47d5 100644 --- a/src/modules/module-stream-restore.c +++ b/src/modules/module-stream-restore.c @@ -306,8 +306,11 @@ static pa_hook_result_t sink_input_new_hook_callback(pa_core *c, pa_sink_input_n if (u->restore_device && (s = pa_namereg_get(c, e->device, PA_NAMEREG_SINK, TRUE))) { - pa_log_info("Restoring device for stream %s.", name); - new_data->sink = s; + if (!new_data->sink) { + pa_log_info("Restoring device for stream %s.", name); + new_data->sink = s; + } else + pa_log_info("Not restore device for stream %s, because already set.", name); } pa_xfree(e); @@ -330,13 +333,20 @@ static pa_hook_result_t sink_input_fixate_hook_callback(pa_core *c, pa_sink_inpu if ((e = read_entry(u, name))) { if (u->restore_volume) { - pa_log_info("Restoring volume for sink input %s.", name); - pa_sink_input_new_data_set_volume(new_data, pa_cvolume_remap(&e->volume, &e->channel_map, &new_data->channel_map)); + + if (!new_data->volume_is_set) { + pa_log_info("Restoring volume for sink input %s.", name); + pa_sink_input_new_data_set_volume(new_data, pa_cvolume_remap(&e->volume, &e->channel_map, &new_data->channel_map)); + } else + pa_log_debug("Not restoring volume for sink input %s, because already set.", name); } if (u->restore_muted) { - pa_log_info("Restoring mute state for sink input %s.", name); - pa_sink_input_new_data_set_muted(new_data, e->muted); + if (!new_data->muted_is_set) { + pa_log_info("Restoring mute state for sink input %s.", name); + pa_sink_input_new_data_set_muted(new_data, e->muted); + } else + pa_log_debug("Not restoring mute state for sink input %s, because already set.", name); } pa_xfree(e); @@ -363,8 +373,11 @@ static pa_hook_result_t source_output_new_hook_callback(pa_core *c, pa_source_ou !new_data->direct_on_input && (s = pa_namereg_get(c, e->device, PA_NAMEREG_SOURCE, TRUE))) { - pa_log_info("Restoring device for stream %s.", name); - new_data->source = s; + if (!new_data->source) { + pa_log_info("Restoring device for stream %s.", name); + new_data->source = s; + } else + pa_log_info("Not restroing device for stream %s, because already set", name); } pa_xfree(e); -- cgit From b7026bf248948a6a30386ddbcc137f48f369a51e Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Tue, 19 Aug 2008 22:39:54 +0200 Subject: add a few more gcc warning flags and fix quite a few problems found by doing so --- src/modules/module-stream-restore.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) (limited to 'src/modules/module-stream-restore.c') diff --git a/src/modules/module-stream-restore.c b/src/modules/module-stream-restore.c index 7bbb47d5..37e8b067 100644 --- a/src/modules/module-stream-restore.c +++ b/src/modules/module-stream-restore.c @@ -145,7 +145,7 @@ static struct entry* read_entry(struct userdata *u, char *name) { pa_assert(name); key.dptr = name; - key.dsize = strlen(name); + key.dsize = (int) strlen(name); data = gdbm_fetch(u->gdbm_file, key); @@ -277,7 +277,7 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3 } key.dptr = name; - key.dsize = strlen(name); + key.dsize = (int) strlen(name); data.dptr = (void*) &entry; data.dsize = sizeof(entry); @@ -544,7 +544,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio next_key = gdbm_nextkey(u->gdbm_file, key); - name = pa_xstrndup(key.dptr, key.dsize); + name = pa_xstrndup(key.dptr, (size_t) key.dsize); pa_xfree(key.dptr); if ((e = read_entry(u, name))) { @@ -604,7 +604,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio pa_strlcpy(entry.device, device, sizeof(entry.device)); key.dptr = (void*) name; - key.dsize = strlen(name); + key.dsize = (int) strlen(name); data.dptr = (void*) &entry; data.dsize = sizeof(entry); @@ -629,7 +629,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio goto fail; key.dptr = (void*) name; - key.dsize = strlen(name); + key.dsize = (int) strlen(name); gdbm_delete(u->gdbm_file, key); } -- cgit