mainloop-signal.c mainloop-signal.h \
mainloop-api.c mainloop-api.h \
util.c util.h \
- hashset.c hashset.h \
+ hashmap.c hashmap.h \
namereg.c namereg.h \
sconv.c sconv.h \
resampler.c resampler.h \
memchunk.c memchunk.h \
sconv-s16le.c sconv-s16le.h \
sconv-s16be.c sconv-s16be.h \
- sioman.c sioman.h
+ sioman.c sioman.h \
+ modargs.c modargs.h
polypaudio_CFLAGS = $(AM_CFLAGS) $(LIBSAMPLERATE_CFLAGS)
polypaudio_INCLUDES = $(INCLTDL)
#define foocorehfoo
#include "idxset.h"
-#include "hashset.h"
+#include "hashmap.h"
#include "mainloop-api.h"
struct pa_core {
struct pa_idxset *clients, *sinks, *sources, *sink_inputs, *source_outputs, *modules;
- struct pa_hashset *namereg;
+ struct pa_hashmap *namereg;
uint32_t default_source_index, default_sink_index;
};
#include <assert.h>
#include <string.h>
-#include "hashset.h"
+#include "hashmap.h"
#include "idxset.h"
-struct hashset_entry {
- struct hashset_entry *next, *previous, *bucket_next, *bucket_previous;
+struct hashmap_entry {
+ struct hashmap_entry *next, *previous, *bucket_next, *bucket_previous;
unsigned hash;
const void *key;
void *value;
};
-struct pa_hashset {
+struct pa_hashmap {
unsigned size;
- struct hashset_entry **data;
- struct hashset_entry *first_entry;
+ struct hashmap_entry **data;
+ struct hashmap_entry *first_entry;
unsigned n_entries;
unsigned (*hash_func) (const void *p);
int (*compare_func) (const void*a, const void*b);
};
-struct pa_hashset *pa_hashset_new(unsigned (*hash_func) (const void *p), int (*compare_func) (const void*a, const void*b)) {
- struct pa_hashset *h;
- h = malloc(sizeof(struct pa_hashset));
+struct pa_hashmap *pa_hashmap_new(unsigned (*hash_func) (const void *p), int (*compare_func) (const void*a, const void*b)) {
+ struct pa_hashmap *h;
+ h = malloc(sizeof(struct pa_hashmap));
assert(h);
- h->data = malloc(sizeof(struct hashset_entry*)*(h->size = 1023));
+ h->data = malloc(sizeof(struct hashmap_entry*)*(h->size = 1023));
assert(h->data);
- memset(h->data, 0, sizeof(struct hashset_entry*)*(h->size = 1023));
+ memset(h->data, 0, sizeof(struct hashmap_entry*)*(h->size = 1023));
h->first_entry = NULL;
h->n_entries = 0;
h->hash_func = hash_func ? hash_func : pa_idxset_trivial_hash_func;
return h;
}
-static void remove(struct pa_hashset *h, struct hashset_entry *e) {
+static void remove(struct pa_hashmap *h, struct hashmap_entry *e) {
assert(e);
if (e->next)
h->n_entries--;
}
-void pa_hashset_free(struct pa_hashset*h, void (*free_func)(void *p, void *userdata), void *userdata) {
+void pa_hashmap_free(struct pa_hashmap*h, void (*free_func)(void *p, void *userdata), void *userdata) {
assert(h);
while (h->first_entry) {
free(h);
}
-static struct hashset_entry *get(struct pa_hashset *h, unsigned hash, const void *key) {
- struct hashset_entry *e;
+static struct hashmap_entry *get(struct pa_hashmap *h, unsigned hash, const void *key) {
+ struct hashmap_entry *e;
for (e = h->data[hash]; e; e = e->bucket_next)
if (h->compare_func(e->key, key) == 0)
return NULL;
}
-int pa_hashset_put(struct pa_hashset *h, const void *key, void *value) {
- struct hashset_entry *e;
+int pa_hashmap_put(struct pa_hashmap *h, const void *key, void *value) {
+ struct hashmap_entry *e;
unsigned hash;
assert(h && key);
if ((e = get(h, hash, key)))
return -1;
- e = malloc(sizeof(struct hashset_entry));
+ e = malloc(sizeof(struct hashmap_entry));
assert(e);
e->hash = hash;
return 0;
}
-void* pa_hashset_get(struct pa_hashset *h, const void *key) {
+void* pa_hashmap_get(struct pa_hashmap *h, const void *key) {
unsigned hash;
- struct hashset_entry *e;
+ struct hashmap_entry *e;
assert(h && key);
hash = h->hash_func(key) % h->size;
return e->value;
}
-int pa_hashset_remove(struct pa_hashset *h, const void *key) {
- struct hashset_entry *e;
+int pa_hashmap_remove(struct pa_hashmap *h, const void *key) {
+ struct hashmap_entry *e;
unsigned hash;
assert(h && key);
return 0;
}
-unsigned pa_hashset_ncontents(struct pa_hashset *h) {
+unsigned pa_hashmap_ncontents(struct pa_hashmap *h) {
return h->n_entries;
}
--- /dev/null
+#ifndef foohashmaphfoo
+#define foohashmaphfoo
+
+struct pa_hashmap;
+
+struct pa_hashmap *pa_hashmap_new(unsigned (*hash_func) (const void *p), int (*compare_func) (const void*a, const void*b));
+void pa_hashmap_free(struct pa_hashmap*, void (*free_func)(void *p, void *userdata), void *userdata);
+
+int pa_hashmap_put(struct pa_hashmap *h, const void *key, void *value);
+void* pa_hashmap_get(struct pa_hashmap *h, const void *key);
+
+int pa_hashmap_remove(struct pa_hashmap *h, const void *key);
+
+unsigned pa_hashmap_ncontents(struct pa_hashmap *h);
+
+#endif
+++ /dev/null
-#ifndef foohashsethfoo
-#define foohashsethfoo
-
-struct pa_hashset;
-
-struct pa_hashset *pa_hashset_new(unsigned (*hash_func) (const void *p), int (*compare_func) (const void*a, const void*b));
-void pa_hashset_free(struct pa_hashset*, void (*free_func)(void *p, void *userdata), void *userdata);
-
-int pa_hashset_put(struct pa_hashset *h, const void *key, void *value);
-void* pa_hashset_get(struct pa_hashset *h, const void *key);
-
-int pa_hashset_remove(struct pa_hashset *h, const void *key);
-
-unsigned pa_hashset_ncontents(struct pa_hashset *h);
-
-#endif
--- /dev/null
+#include <ctype.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "hashmap.h"
+#include "modargs.h"
+#include "idxset.h"
+#include "sample-util.h"
+
+struct pa_modargs;
+
+struct entry {
+ char *key, *value;
+};
+
+static int add_key_value(struct pa_hashmap *map, char *key, char *value, const char* const* valid_keys) {
+ struct entry *e;
+ assert(map && key && value);
+
+ if (valid_keys) {
+ const char*const* v;
+ for (v = valid_keys; *v; v++)
+ if (strcmp(*v, key) == 0)
+ break;
+
+ if (!*v) {
+ free(key);
+ free(value);
+ return -1;
+ }
+ }
+
+ e = malloc(sizeof(struct entry));
+ assert(e);
+ e->key = key;
+ e->value = value;
+ pa_hashmap_put(map, key, e);
+ return 0;
+}
+
+struct pa_modargs *pa_modargs_new(const char *args, const char* const* valid_keys) {
+ struct pa_hashmap *map = NULL;
+
+ map = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
+ assert(map);
+
+ if (args) {
+ enum { WHITESPACE, KEY, VALUE_START, VALUE_SIMPLE, VALUE_DOUBLE_QUOTES, VALUE_TICKS } state;
+ const char *p, *key, *value;
+ size_t key_len, value_len;
+
+ key = value = NULL;
+ 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;
+ 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, strndup(key, key_len), strdup(""), 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, strndup(key, key_len), strndup(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, strndup(key, key_len), strndup(value, value_len), valid_keys) < 0)
+ goto fail;
+ state = WHITESPACE;
+ } else
+ value_len++;
+ break;
+ case VALUE_TICKS:
+ if (*p == '\'') {
+ if (add_key_value(map, strndup(key, key_len), strndup(value, value_len), valid_keys) < 0)
+ goto fail;
+ state = WHITESPACE;
+ } else
+ value_len++;
+ break;
+ }
+ }
+
+ if (state == VALUE_START) {
+ if (add_key_value(map, strndup(key, key_len), strdup(""), valid_keys) < 0)
+ goto fail;
+ } else if (state == VALUE_SIMPLE) {
+ if (add_key_value(map, strndup(key, key_len), strdup(value), valid_keys) < 0)
+ goto fail;
+ } else if (state != WHITESPACE)
+ goto fail;
+ }
+
+ return (struct pa_modargs*) map;
+
+fail:
+
+ if (map)
+ pa_modargs_free((struct pa_modargs*) map);
+
+ return NULL;
+}
+
+
+static void free_func(void *p, void*userdata) {
+ struct entry *e = p;
+ assert(e);
+ free(e->key);
+ free(e->value);
+ free(e);
+}
+
+void pa_modargs_free(struct pa_modargs*ma) {
+ struct pa_hashmap *map = (struct pa_hashmap*) ma;
+ pa_hashmap_free(map, free_func, NULL);
+}
+
+const char *pa_modargs_get_value(struct pa_modargs *ma, const char *key, const char *def) {
+ struct pa_hashmap *map = (struct pa_hashmap*) ma;
+ struct entry*e;
+
+ if (!(e = pa_hashmap_get(map, key)))
+ return def;
+
+ return e->value;
+}
+
+int pa_modargs_get_value_u32(struct pa_modargs *ma, const char *key, uint32_t *value) {
+ const char *v;
+ char *e;
+ unsigned long l;
+ assert(ma && key && value);
+
+ if (!(v = pa_modargs_get_value(ma, key, NULL)))
+ return 0;
+
+ if (!*v)
+ return -1;
+
+ l = strtoul(v, &e, 0);
+ if (*e)
+ return -1;
+
+ *value = (uint32_t) l;
+ return 0;
+}
+
+int pa_modargs_get_sample_spec(struct pa_modargs *ma, struct pa_sample_spec *rss) {
+ const char *format;
+ uint32_t channels;
+ struct pa_sample_spec ss;
+ assert(ma && rss);
+
+ ss = pa_default_sample_spec;
+ if ((pa_modargs_get_value_u32(ma, "rate", &ss.rate)) < 0)
+ return -1;
+
+ channels = ss.channels;
+ if ((pa_modargs_get_value_u32(ma, "channels", &channels)) < 0)
+ return -1;
+ ss.channels = (uint8_t) channels;
+
+ if ((format = pa_modargs_get_value(ma, "format", NULL))) {
+ if (strcmp(format, "s16le") == 0)
+ ss.format = PA_SAMPLE_S16LE;
+ else if (strcmp(format, "s16be") == 0)
+ ss.format = PA_SAMPLE_S16BE;
+ else if (strcmp(format, "s16ne") == 0 || strcmp(format, "s16") == 0 || strcmp(format, "16") == 0)
+ ss.format = PA_SAMPLE_S16NE;
+ else if (strcmp(format, "u8") == 0 || strcmp(format, "8") == 0)
+ ss.format = PA_SAMPLE_U8;
+ else if (strcmp(format, "float32") == 0)
+ ss.format = PA_SAMPLE_FLOAT32;
+ else if (strcmp(format, "ulaw") == 0)
+ ss.format = PA_SAMPLE_ULAW;
+ else if (strcmp(format, "alaw") == 0)
+ ss.format = PA_SAMPLE_ALAW;
+ else
+ return -1;
+ }
+
+ if (!pa_sample_spec_valid(&ss))
+ return -1;
+
+ *rss = ss;
+
+ return 0;
+}
--- /dev/null
+#ifndef foomodargshfoo
+#define foomodargshfoo
+
+#include <inttypes.h>
+#include "sample.h"
+
+struct pa_modargs;
+
+struct pa_modargs *pa_modargs_new(const char *args, const char* const* keys);
+void pa_modargs_free(struct pa_modargs*ma);
+
+const char *pa_modargs_get_value(struct pa_modargs *ma, const char *key, const char *def);
+int pa_modargs_get_value_u32(struct pa_modargs *ma, const char *key, uint32_t *value);
+
+int pa_modargs_get_sample_spec(struct pa_modargs *ma, struct pa_sample_spec *ss);
+
+
+#endif
#include "sink.h"
#include "module.h"
#include "util.h"
+#include "modargs.h"
+
+#define DEFAULT_FIFO_NAME "/tmp/musicfifo"
+#define DEFAULT_SINK_NAME "fifo_output"
struct userdata {
+ struct pa_core *core;
+
char *filename;
struct pa_sink *sink;
struct pa_iochannel *io;
- struct pa_core *core;
void *mainloop_source;
- struct pa_mainloop_api *mainloop;
struct pa_memchunk memchunk;
};
+static const char* const valid_modargs[] = {
+ "file",
+ "rate",
+ "channels",
+ "format",
+ "sink",
+ NULL
+};
+
static void do_write(struct userdata *u) {
ssize_t r;
assert(u);
- u->mainloop->enable_fixed(u->mainloop, u->mainloop_source, 0);
+ u->core->mainloop->enable_fixed(u->core->mainloop, u->mainloop_source, 0);
if (!pa_iochannel_is_writable(u->io))
return;
assert(s && u);
if (pa_iochannel_is_writable(u->io))
- u->mainloop->enable_fixed(u->mainloop, u->mainloop_source, 1);
+ u->core->mainloop->enable_fixed(u->core->mainloop, u->mainloop_source, 1);
}
static void fixed_callback(struct pa_mainloop_api *m, void *id, void *userdata) {
int pa_module_init(struct pa_core *c, struct pa_module*m) {
struct userdata *u = NULL;
struct stat st;
- char *p;
+ const char *p;
int fd = -1;
- static const struct pa_sample_spec ss = {
- .format = PA_SAMPLE_S16NE,
- .rate = 44100,
- .channels = 2,
- };
+ struct pa_sample_spec ss;
+ struct pa_modargs *ma = NULL;
assert(c && m);
+
+ if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
+ fprintf(stderr, __FILE__": failed to parse module arguments\n");
+ goto fail;
+ }
- mkfifo((p = m->argument ? m->argument : "/tmp/musicfifo"), 0777);
+ if (pa_modargs_get_sample_spec(ma, &ss) < 0) {
+ fprintf(stderr, __FILE__": invalid sample format specification\n");
+ goto fail;
+ }
+
+ mkfifo(p = pa_modargs_get_value(ma, "file", DEFAULT_FIFO_NAME), 0777);
if ((fd = open(p, O_RDWR)) < 0) {
- fprintf(stderr, "open('%s'): %s\n", p, strerror(errno));
+ fprintf(stderr, __FILE__": open('%s'): %s\n", p, strerror(errno));
goto fail;
}
if (fstat(fd, &st) < 0) {
- fprintf(stderr, "fstat('%s'): %s\n", p, strerror(errno));
+ fprintf(stderr, __FILE__": fstat('%s'): %s\n", p, strerror(errno));
goto fail;
}
if (!S_ISFIFO(st.st_mode)) {
- fprintf(stderr, "'%s' is not a FIFO\n", p);
+ fprintf(stderr, __FILE__": '%s' is not a FIFO.\n", p);
goto fail;
}
-
u = malloc(sizeof(struct userdata));
assert(u);
+ memset(u, 0, sizeof(struct userdata));
u->filename = strdup(p);
assert(u->filename);
u->core = c;
- u->sink = pa_sink_new(c, "fifo", 0, &ss);
- assert(u->sink);
+
+ if (!(u->sink = pa_sink_new(c, pa_modargs_get_value(ma, "sink", DEFAULT_SINK_NAME), 0, &ss))) {
+ fprintf(stderr, __FILE__": failed to create sink.\n");
+ goto fail;
+ }
u->sink->notify = notify_cb;
u->sink->userdata = u;
pa_sink_set_owner(u->sink, m);
u->memchunk.memblock = NULL;
u->memchunk.length = 0;
- u->mainloop = c->mainloop;
- u->mainloop_source = u->mainloop->source_fixed(u->mainloop, fixed_callback, u);
+ u->mainloop_source = c->mainloop->source_fixed(c->mainloop, fixed_callback, u);
assert(u->mainloop_source);
- u->mainloop->enable_fixed(u->mainloop, u->mainloop_source, 0);
+ c->mainloop->enable_fixed(c->mainloop, u->mainloop_source, 0);
m->userdata = u;
+ pa_modargs_free(ma);
+
return 0;
fail:
+ if (ma)
+ pa_modargs_free(ma);
+
if (fd >= 0)
close(fd);
+ pa_module_done(c, m);
+
return -1;
}
struct userdata *u;
assert(c && m);
- u = m->userdata;
- assert(u);
+ if (!(u = m->userdata))
+ return;
if (u->memchunk.memblock)
pa_memblock_unref(u->memchunk.memblock);
pa_sink_free(u->sink);
pa_iochannel_free(u->io);
- u->mainloop->cancel_fixed(u->mainloop, u->mainloop_source);
+ u->core->mainloop->cancel_fixed(u->core->mainloop, u->mainloop_source);
assert(u->filename);
unlink(u->filename);
assert(c);
if (!c->namereg)
return;
- assert(pa_hashset_ncontents(c->namereg) == 0);
- pa_hashset_free(c->namereg, NULL, NULL);
+ assert(pa_hashmap_ncontents(c->namereg) == 0);
+ pa_hashmap_free(c->namereg, NULL, NULL);
}
const char *pa_namereg_register(struct pa_core *c, const char *name, enum pa_namereg_type type, void *data, int fail) {
assert(c && name && data);
if (!c->namereg) {
- c->namereg = pa_hashset_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
+ c->namereg = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
assert(c->namereg);
}
- if ((e = pa_hashset_get(c->namereg, name)) && fail)
+ if ((e = pa_hashmap_get(c->namereg, name)) && fail)
return NULL;
if (!e)
for (i = 1; i <= 99; i++) {
snprintf(n, l+2, "%s%u", name, i);
- if (!(e = pa_hashset_get(c->namereg, n)))
+ if (!(e = pa_hashmap_get(c->namereg, n)))
break;
}
e->name = n;
e->data = data;
- r = pa_hashset_put(c->namereg, e->name, e);
+ r = pa_hashmap_put(c->namereg, e->name, e);
assert (r >= 0);
return e->name;
int r;
assert(c && name);
- e = pa_hashset_get(c->namereg, name);
+ e = pa_hashmap_get(c->namereg, name);
assert(e);
- r = pa_hashset_remove(c->namereg, name);
+ r = pa_hashmap_remove(c->namereg, name);
assert(r >= 0);
free(e->name);
void *d = NULL;
assert(c && name);
- if ((e = pa_hashset_get(c->namereg, name)))
+ if ((e = pa_hashmap_get(c->namereg, name)))
if (e->type == e->type)
return e->data;
- native library/protocol:
more functions (esp. latency)
-- config parser/cmdline
+- make all modules use modargs.c
+- cmdline
+- daemonizing
- move more stuff from module-oss[-dma] to liboss-util
- svn-id and license in every file
- documentation
+- eliminate global variables
+
-- post 0.1
- future cancellation
- client-ui