The idea of the feature is that a device vendor may want to initialize
device volumes to known good defaults. The factory settings are read
from a configuration that contains entries that look like this:
[Entry sink:foodevicename:barportname]
volume = front-left:70%,front-right:70%
The settings are written to the device-restore database during module
loading, but only if the database doesn't already contain an entry
with matching key, so user choices are not overwritten.
---
src/modules/module-device-restore.c | 143 ++++++++++++++++++++++++++++++++++-
1 file changed, 142 insertions(+), 1 deletion(-)
diff --git a/src/modules/module-device-restore.c b/src/modules/module-device-restore.c
index e334ff6..b1b2d38 100644
--- a/src/modules/module-device-restore.c
+++ b/src/modules/module-device-restore.c
@@ -53,6 +53,7 @@
#include <pulsecore/pstream-util.h>
#include <pulsecore/database.h>
#include <pulsecore/tagstruct.h>
+#include <pulsecore/conf-parser.h>
#include "module-device-restore-symdef.h"
@@ -64,15 +65,19 @@ PA_MODULE_USAGE(
"restore_port=<Save/restore port?> "
"restore_volume=<Save/restore volumes?> "
"restore_muted=<Save/restore muted states?> "
- "restore_formats=<Save/restore saved formats?>");
+ "restore_formats=<Save/restore saved formats?> "
+ "factory_settings=<file>");
#define SAVE_INTERVAL (10 * PA_USEC_PER_SEC)
+#define DEFAULT_FACTORY_SETTINGS_FILE PA_DEFAULT_CONFIG_DIR PA_PATH_SEP "device-restore-factory-settings.conf"
+#define DEFAULT_FACTORY_SETTINGS_FILE_USER "device-restore-factory-settings.conf"
static const char* const valid_modargs[] = {
"restore_volume",
"restore_muted",
"restore_port",
"restore_formats",
+ "factory_settings",
NULL
};
@@ -131,6 +136,13 @@ struct perportentry {
pa_idxset *formats;
};
+struct factory_settings_entry {
+ char *key;
+ pa_cvolume volume;
+ pa_channel_map channel_map;
+ bool volume_valid;
+};
+
static void save_time_callback(pa_mainloop_api*a, pa_time_event* e, const struct timeval *t, void *userdata) {
struct userdata *u = userdata;
@@ -1230,6 +1242,130 @@ static pa_hook_result_t connection_unlink_hook_cb(pa_native_protocol *p, pa_nati
return PA_HOOK_OK;
}
+static struct factory_settings_entry *factory_settings_entry_get(pa_hashmap *factory_settings, const char *section) {
+ struct factory_settings_entry *entry;
+
+ pa_assert(factory_settings);
+
+ if (!section || !pa_startswith(section, "Entry "))
+ return NULL;
+
+ section += 6;
+
+ if ((entry = pa_hashmap_get(factory_settings, section)))
+ return entry;
+
+ entry = pa_xnew0(struct factory_settings_entry, 1);
+ entry->key = pa_xstrdup(section);
+ pa_hashmap_put(factory_settings, entry->key, entry);
+
+ return entry;
+}
+
+static int parse_volume_cb(pa_config_parser_state *state) {
+ pa_hashmap *factory_settings;
+ struct factory_settings_entry *entry;
+
+ pa_assert(state);
+
+ factory_settings = state->userdata;
+
+ if (!(entry = factory_settings_entry_get(factory_settings, state->section))) {
+ pa_log("[%s:%u] volume option not expected in section '%s'.", state->filename, state->lineno, pa_strnull(state->section));
+ return -1;
+ }
+
+ if (pa_parse_cvolume(state->rvalue, &entry->volume, &entry->channel_map) < 0) {
+ pa_log("[%s:%u] failed to parse volume.", state->filename, state->lineno);
+ return -1;
+ }
+
+ entry->volume_valid = true;
+
+ return 0;
+}
+
+static int load_factory_settings(struct userdata *u, const char *filename) {
+ FILE *f = NULL;
+ char *fn;
+ int r;
+ pa_hashmap *factory_settings;
+ struct factory_settings_entry *entry;
+ void *state;
+
+ pa_config_item config_items[] = {
+ { "volume", parse_volume_cb, NULL, NULL },
+ { NULL, NULL, NULL, NULL }
+ };
+
+ if (!filename && !(f = pa_open_config_file(DEFAULT_FACTORY_SETTINGS_FILE, DEFAULT_FACTORY_SETTINGS_FILE_USER, NULL, &fn))) {
+ if (errno != ENOENT)
+ return -1;
+
+ return 0;
+ }
+
+ /* pa_config_parse() would open the file for us if we didn't open it
+ * ourselves, but if pa_config_parse() has to open the file, it will not
+ * return an error if the file is not found. That's supposedly useful in
+ * other situations, but we want to report failure if filename was
+ * explicitly configured and the file is not found, so we have to open the
+ * file ourselves. */
+ if (filename && !(f = pa_fopen_cloexec(filename, "r"))) {
+ pa_log("Failed to open '%s': %s", filename, pa_cstrerror(errno));
+ return -1;
+ }
+
+ if (!filename)
+ filename = fn;
+
+ factory_settings = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
+
+ if ((r = pa_config_parse(filename, f, config_items, NULL, factory_settings)) < 0)
+ goto finish;
+
+ PA_HASHMAP_FOREACH(entry, factory_settings, state) {
+ struct perportentry *ppe;
+
+ if (!entry->volume_valid)
+ continue;
+
+ ppe = perportentry_read_raw_name(u, entry->key);
+
+ if (!ppe || !ppe->volume_valid) {
+ if (!ppe)
+ ppe = perportentry_new(FALSE);
+
+ ppe->volume = entry->volume;
+ ppe->channel_map = entry->channel_map;
+ ppe->volume_valid = true;
+
+ perportentry_write_raw_name(u, entry->key, ppe);
+ pa_log_debug("Added factory settings to the database for entry %s.", entry->key);
+
+ /* Note that the device type doesn't matter when we give PA_INVALID_INDEX. */
+ trigger_save(u, PA_DEVICE_TYPE_SINK, PA_INVALID_INDEX);
+ }
+
+ perportentry_free(ppe);
+ }
+
+finish:
+
+ while ((entry = pa_hashmap_steal_first(factory_settings))) {
+ pa_xfree(entry->key);
+ pa_xfree(entry);
+ }
+
+ pa_hashmap_free(factory_settings, NULL, NULL);
+ pa_xfree(fn);
+
+ if (f)
+ fclose(f);
+
+ return r;
+}
+
int pa__init(pa_module*m) {
pa_modargs *ma = NULL;
struct userdata *u;
@@ -1302,6 +1438,11 @@ int pa__init(pa_module*m) {
pa_log_info("Successfully opened database file '%s'.", fname);
pa_xfree(fname);
+ if (load_factory_settings(u, pa_modargs_get_value(ma, "factory_settings", NULL)) < 0) {
+ pa_log("Loading factory settings failed.");
+ goto fail;
+ }
+
PA_IDXSET_FOREACH(sink, m->core->sinks, idx)
subscribe_callback(m->core, PA_SUBSCRIPTION_EVENT_SINK|PA_SUBSCRIPTION_EVENT_NEW, sink->index, u);
--
1.7.10.4
