-/* $Id$ */
-
/***
This file is part of PulseAudio.
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 of the License,
+ 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
#include <pulsecore/hashmap.h>
#include <pulsecore/idxset.h>
-#include <pulsecore/sample-util.h>
-#include <pulsecore/namereg.h>
-#include <pulsecore/sink.h>
-#include <pulsecore/source.h>
#include <pulsecore/core-util.h>
#include <pulsecore/macro.h>
#include "modargs.h"
+struct pa_modargs {
+ pa_hashmap *raw;
+ pa_hashmap *unescaped;
+};
+
struct entry {
char *key, *value;
};
-static int add_key_value(pa_hashmap *map, char *key, char *value, const char* const valid_keys[]) {
+static int add_key_value(pa_modargs *ma, char *key, char *value, const char* const valid_keys[]) {
struct entry *e;
+ char *raw;
- pa_assert(map);
+ pa_assert(ma);
+ pa_assert(ma->raw);
+ pa_assert(ma->unescaped);
pa_assert(key);
pa_assert(value);
+ if (pa_hashmap_get(ma->unescaped, key)) {
+ pa_xfree(key);
+ pa_xfree(value);
+ return -1;
+ }
+
if (valid_keys) {
const char*const* v;
for (v = valid_keys; *v; v++)
}
}
+ raw = pa_xstrdup(value);
+
e = pa_xnew(struct entry, 1);
e->key = key;
- e->value = value;
- pa_hashmap_put(map, key, e);
+ e->value = pa_unescape(value);
+ pa_hashmap_put(ma->unescaped, key, e);
+
+ if (pa_streq(raw, value))
+ pa_xfree(raw);
+ else {
+ e = pa_xnew(struct entry, 1);
+ e->key = pa_xstrdup(key);
+ e->value = raw;
+ pa_hashmap_put(ma->raw, key, e);
+ }
return 0;
}
pa_modargs *pa_modargs_new(const char *args, const char* const* valid_keys) {
- pa_hashmap *map = NULL;
+ enum {
+ WHITESPACE,
+ KEY,
+ VALUE_START,
+ VALUE_SIMPLE,
+ VALUE_SIMPLE_ESCAPED,
+ VALUE_DOUBLE_QUOTES,
+ VALUE_DOUBLE_QUOTES_ESCAPED,
+ VALUE_TICKS,
+ VALUE_TICKS_ESCAPED
+ } state;
+
+ const char *p, *key = NULL, *value = NULL;
+ size_t key_len = 0, value_len = 0;
+ pa_modargs *ma = pa_xnew(pa_modargs, 1);
+
+ ma->raw = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
+ ma->unescaped = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
+
+ if (!args)
+ return ma;
+
+ state = WHITESPACE;
+
+ for (p = args; *p; p++) {
+ switch (state) {
+
+ case WHITESPACE:
+ if (*p == '=')
+ goto fail;
+ else if (!isspace(*p)) {
+ key = p;
+ state = KEY;
+ key_len = 1;
+ }
+ break;
- map = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
+ case KEY:
+ if (*p == '=')
+ state = VALUE_START;
+ else if (isspace(*p))
+ goto fail;
+ else
+ key_len++;
+ break;
- if (args) {
- enum { WHITESPACE, KEY, VALUE_START, VALUE_SIMPLE, VALUE_DOUBLE_QUOTES, VALUE_TICKS } state;
- const char *p, *key, *value;
- size_t key_len = 0, value_len = 0;
+ case VALUE_START:
+ if (*p == '\'') {
+ state = VALUE_TICKS;
+ value = p+1;
+ value_len = 0;
+ } else if (*p == '"') {
+ state = VALUE_DOUBLE_QUOTES;
+ value = p+1;
+ value_len = 0;
+ } else if (isspace(*p)) {
+ if (add_key_value(ma,
+ pa_xstrndup(key, key_len),
+ pa_xstrdup(""),
+ valid_keys) < 0)
+ goto fail;
+ state = WHITESPACE;
+ } else if (*p == '\\') {
+ state = VALUE_SIMPLE_ESCAPED;
+ value = p;
+ value_len = 1;
+ } else {
+ state = VALUE_SIMPLE;
+ value = p;
+ value_len = 1;
+ }
+ break;
+
+ case VALUE_SIMPLE:
+ if (isspace(*p)) {
+ if (add_key_value(ma,
+ pa_xstrndup(key, key_len),
+ pa_xstrndup(value, value_len),
+ valid_keys) < 0)
+ goto fail;
+ state = WHITESPACE;
+ } else if (*p == '\\') {
+ state = VALUE_SIMPLE_ESCAPED;
+ value_len++;
+ } else
+ value_len++;
+ break;
- key = value = NULL;
- state = WHITESPACE;
- for (p = args; *p; p++) {
- switch (state) {
- case WHITESPACE:
- if (*p == '=')
+ case VALUE_SIMPLE_ESCAPED:
+ state = VALUE_SIMPLE;
+ value_len++;
+ break;
+
+ case VALUE_DOUBLE_QUOTES:
+ if (*p == '"') {
+ if (add_key_value(ma,
+ pa_xstrndup(key, key_len),
+ pa_xstrndup(value, value_len),
+ valid_keys) < 0)
goto fail;
- else if (!isspace(*p)) {
- key = p;
- state = KEY;
- key_len = 1;
- }
- break;
- case KEY:
- if (*p == '=')
- state = VALUE_START;
- else
- key_len++;
- break;
- case VALUE_START:
- if (*p == '\'') {
- state = VALUE_TICKS;
- value = p+1;
- value_len = 0;
- } else if (*p == '"') {
- state = VALUE_DOUBLE_QUOTES;
- value = p+1;
- value_len = 0;
- } else if (isspace(*p)) {
- if (add_key_value(map, pa_xstrndup(key, key_len), pa_xstrdup(""), valid_keys) < 0)
- goto fail;
- state = WHITESPACE;
- } else {
- state = VALUE_SIMPLE;
- value = p;
- value_len = 1;
- }
- break;
- case VALUE_SIMPLE:
- if (isspace(*p)) {
- if (add_key_value(map, pa_xstrndup(key, key_len), pa_xstrndup(value, value_len), valid_keys) < 0)
- goto fail;
- state = WHITESPACE;
- } else
- value_len++;
- break;
- case VALUE_DOUBLE_QUOTES:
- if (*p == '"') {
- if (add_key_value(map, pa_xstrndup(key, key_len), pa_xstrndup(value, value_len), valid_keys) < 0)
- goto fail;
- state = WHITESPACE;
- } else
- value_len++;
- break;
- case VALUE_TICKS:
- if (*p == '\'') {
- if (add_key_value(map, pa_xstrndup(key, key_len), pa_xstrndup(value, value_len), valid_keys) < 0)
- goto fail;
- state = WHITESPACE;
- } else
- value_len++;
- break;
- }
+ state = WHITESPACE;
+ } else if (*p == '\\') {
+ state = VALUE_DOUBLE_QUOTES_ESCAPED;
+ value_len++;
+ } else
+ value_len++;
+ break;
+
+ case VALUE_DOUBLE_QUOTES_ESCAPED:
+ state = VALUE_DOUBLE_QUOTES;
+ value_len++;
+ break;
+
+ case VALUE_TICKS:
+ if (*p == '\'') {
+ if (add_key_value(ma,
+ pa_xstrndup(key, key_len),
+ pa_xstrndup(value, value_len),
+ valid_keys) < 0)
+ goto fail;
+ state = WHITESPACE;
+ } else if (*p == '\\') {
+ state = VALUE_TICKS_ESCAPED;
+ value_len++;
+ } else
+ value_len++;
+ break;
+
+ case VALUE_TICKS_ESCAPED:
+ state = VALUE_TICKS;
+ value_len++;
+ break;
}
+ }
- if (state == VALUE_START) {
- if (add_key_value(map, pa_xstrndup(key, key_len), pa_xstrdup(""), valid_keys) < 0)
- goto fail;
- } else if (state == VALUE_SIMPLE) {
- if (add_key_value(map, pa_xstrndup(key, key_len), pa_xstrdup(value), valid_keys) < 0)
- goto fail;
- } else if (state != WHITESPACE)
+ if (state == VALUE_START) {
+ if (add_key_value(ma, pa_xstrndup(key, key_len), pa_xstrdup(""), valid_keys) < 0)
goto fail;
- }
+ } else if (state == VALUE_SIMPLE) {
+ if (add_key_value(ma, pa_xstrndup(key, key_len), pa_xstrdup(value), valid_keys) < 0)
+ goto fail;
+ } else if (state != WHITESPACE)
+ goto fail;
- return (pa_modargs*) map;
+ return ma;
fail:
- if (map)
- pa_modargs_free((pa_modargs*) map);
+ pa_modargs_free(ma);
return NULL;
}
-static void free_func(void *p, PA_GCC_UNUSED void*userdata) {
+static void free_func(void *p, void*userdata) {
struct entry *e = p;
pa_assert(e);
}
void pa_modargs_free(pa_modargs*ma) {
- pa_hashmap *map = (pa_hashmap*) ma;
- pa_hashmap_free(map, free_func, NULL);
+ pa_assert(ma);
+
+ pa_hashmap_free(ma->raw, free_func, NULL);
+ pa_hashmap_free(ma->unescaped, free_func, NULL);
+ pa_xfree(ma);
}
const char *pa_modargs_get_value(pa_modargs *ma, const char *key, const char *def) {
- pa_hashmap *map = (pa_hashmap*) ma;
struct entry*e;
- if (!(e = pa_hashmap_get(map, key)))
+ pa_assert(ma);
+ pa_assert(key);
+
+ if (!(e = pa_hashmap_get(ma->unescaped, key)))
return def;
return e->value;
}
-int pa_modargs_get_value_u32(pa_modargs *ma, const char *key, uint32_t *value) {
- const char *v;
+static const char *modargs_get_value_raw(pa_modargs *ma, const char *key, const char *def) {
+ struct entry*e;
pa_assert(ma);
pa_assert(key);
+
+ if (!(e = pa_hashmap_get(ma->raw, key)))
+ if (!(e = pa_hashmap_get(ma->unescaped, key)))
+ return def;
+
+ return e->value;
+}
+
+int pa_modargs_get_value_u32(pa_modargs *ma, const char *key, uint32_t *value) {
+ const char *v;
+
pa_assert(value);
if (!(v = pa_modargs_get_value(ma, key, NULL)))
int pa_modargs_get_value_s32(pa_modargs *ma, const char *key, int32_t *value) {
const char *v;
- pa_assert(ma);
- pa_assert(key);
pa_assert(value);
if (!(v = pa_modargs_get_value(ma, key, NULL)))
const char *v;
int r;
- pa_assert(ma);
- pa_assert(key);
pa_assert(value);
if (!(v = pa_modargs_get_value(ma, key, NULL)))
uint32_t channels;
pa_sample_spec ss;
- pa_assert(ma);
pa_assert(rss);
ss = *rss;
- if ((pa_modargs_get_value_u32(ma, "rate", &ss.rate)) < 0)
+ if ((pa_modargs_get_value_u32(ma, "rate", &ss.rate)) < 0 ||
+ ss.rate <= 0 ||
+ ss.rate > PA_RATE_MAX)
return -1;
channels = ss.channels;
- if ((pa_modargs_get_value_u32(ma, "channels", &channels)) < 0)
+ if ((pa_modargs_get_value_u32(ma, "channels", &channels)) < 0 ||
+ channels <= 0 ||
+ channels >= PA_CHANNELS_MAX)
return -1;
ss.channels = (uint8_t) channels;
return 0;
}
+int pa_modargs_get_alternate_sample_rate(pa_modargs *ma, uint32_t *alternate_rate) {
+ pa_assert(ma);
+ pa_assert(alternate_rate);
+
+ if ((pa_modargs_get_value_u32(ma, "alternate_rate", alternate_rate)) < 0 ||
+ *alternate_rate <= 0 ||
+ *alternate_rate > PA_RATE_MAX ||
+ !((*alternate_rate % 4000 == 0) || (*alternate_rate % 11025 == 0)))
+ return -1;
+
+ return 0;
+}
+
int pa_modargs_get_channel_map(pa_modargs *ma, const char *name, pa_channel_map *rmap) {
pa_channel_map map;
const char *cm;
- pa_assert(ma);
pa_assert(rmap);
map = *rmap;
return 0;
}
-int pa_modargs_get_sample_spec_and_channel_map(pa_modargs *ma, pa_sample_spec *rss, pa_channel_map *rmap, pa_channel_map_def_t def) {
+int pa_modargs_get_sample_spec_and_channel_map(
+ pa_modargs *ma,
+ pa_sample_spec *rss,
+ pa_channel_map *rmap,
+ pa_channel_map_def_t def) {
+
pa_sample_spec ss;
pa_channel_map map;
- pa_assert(ma);
pa_assert(rss);
pa_assert(rmap);
if (pa_modargs_get_sample_spec(ma, &ss) < 0)
return -1;
- if (!pa_channel_map_init_auto(&map, ss.channels, def))
- map.channels = 0;
+ map = *rmap;
+
+ if (ss.channels != map.channels)
+ pa_channel_map_init_extend(&map, ss.channels, def);
if (pa_modargs_get_channel_map(ma, NULL, &map) < 0)
return -1;
return 0;
}
+
+int pa_modargs_get_proplist(pa_modargs *ma, const char *name, pa_proplist *p, pa_update_mode_t m) {
+ const char *v;
+ pa_proplist *n;
+
+ pa_assert(ma);
+ pa_assert(name);
+ pa_assert(p);
+
+ if (!(v = modargs_get_value_raw(ma, name, NULL)))
+ return 0;
+
+ if (!(n = pa_proplist_from_string(v)))
+ return -1;
+
+ pa_proplist_update(p, m, n);
+ pa_proplist_free(n);
+
+ return 0;
+}
+
+const char *pa_modargs_iterate(pa_modargs *ma, void **state) {
+ struct entry *e;
+
+ pa_assert(ma);
+
+ if (!(e = pa_hashmap_iterate(ma->unescaped, state, NULL)))
+ return NULL;
+
+ return e->key;
+}