# Compiler/linker flags #
###################################
-AM_CFLAGS = -D_GNU_SOURCE -I$(top_srcdir)
+AM_CFLAGS = -I$(top_srcdir)
AM_CFLAGS += $(PTHREAD_CFLAGS) -D_POSIX_PTHREAD_SEMANTICS
AM_CFLAGS += $(LTDLINCL)
AM_CFLAGS += $(LIBSAMPLERATE_CFLAGS) $(LIBSNDFILE_CFLAGS)
voltest_LDADD = $(AM_LDADD)
voltest_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
-cpulimit_test_SOURCES = cpulimit-test.c cpulimit.c util.c log.c cpulimit.h util.h log.h
+cpulimit_test_SOURCES = cpulimit-test.c cpulimit.c util.c log.c cpulimit.h util.h log.h idxset.c idxset.h
cpulimit_test_CFLAGS = $(AM_CFLAGS)
cpulimit_test_LDADD = $(AM_LDADD) libpolyp-mainloop-@PA_MAJORMINOR@.la
cpulimit_test_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
-cpulimit_test2_SOURCES = cpulimit-test.c cpulimit.c util.c log.c cpulimit.h util.h log.h
+cpulimit_test2_SOURCES = cpulimit-test.c cpulimit.c util.c log.c cpulimit.h util.h log.h idxset.c idxset.h
cpulimit_test2_CFLAGS = $(AM_CFLAGS) -DTEST2
cpulimit_test2_LDADD = $(AM_LDADD) libpolyp-mainloop-@PA_MAJORMINOR@.la
cpulimit_test2_LDFLAGS = $(AM_LDFLAGS) $(BINLDFLAGS)
/* Set the hardware parameters of the given ALSA device. Returns the
* selected fragment settings in *period and *period_size */
-int pa_alsa_set_hw_params(snd_pcm_t *pcm_handle, const struct pa_sample_spec *ss, uint32_t *periods, snd_pcm_uframes_t *period_size) {
+int pa_alsa_set_hw_params(snd_pcm_t *pcm_handle, const pa_sample_spec *ss, uint32_t *periods, snd_pcm_uframes_t *period_size) {
int ret = -1;
snd_pcm_uframes_t buffer_size;
snd_pcm_hw_params_t *hwparams = NULL;
* *io_events. Store the length of that array in *n_io_events. Use the
* specified callback function and userdata. The array has to be freed
* with pa_free_io_events(). */
-int pa_create_io_events(snd_pcm_t *pcm_handle, struct pa_mainloop_api* m, struct pa_io_event ***io_events, unsigned *n_io_events, void (*cb)(struct pa_mainloop_api*a, struct pa_io_event *e, int fd, enum pa_io_event_flags events, void *userdata), void *userdata) {
+int pa_create_io_events(snd_pcm_t *pcm_handle, pa_mainloop_api* m, pa_io_event ***io_events, unsigned *n_io_events, void (*cb)(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags events, void *userdata), void *userdata) {
unsigned i;
struct pollfd *pfds, *ppfd;
- struct pa_io_event **ios;
+ pa_io_event **ios;
assert(pcm_handle && m && io_events && n_io_events && cb);
*n_io_events = snd_pcm_poll_descriptors_count(pcm_handle);
}
/* Free the memory allocated by pa_create_io_events() */
-void pa_free_io_events(struct pa_mainloop_api* m, struct pa_io_event **io_events, unsigned n_io_events) {
+void pa_free_io_events(pa_mainloop_api* m, pa_io_event **io_events, unsigned n_io_events) {
unsigned i;
- struct pa_io_event **ios;
+ pa_io_event **ios;
assert(m && io_events);
for (ios = io_events, i = 0; i < n_io_events; i++, ios++)
#include "sample.h"
#include "mainloop-api.h"
-int pa_alsa_set_hw_params(snd_pcm_t *pcm_handle, const struct pa_sample_spec *ss, uint32_t *periods, snd_pcm_uframes_t *period_size);
+int pa_alsa_set_hw_params(snd_pcm_t *pcm_handle, const pa_sample_spec *ss, uint32_t *periods, snd_pcm_uframes_t *period_size);
-int pa_create_io_events(snd_pcm_t *pcm_handle, struct pa_mainloop_api *m, struct pa_io_event ***io_events, unsigned *n_io_events, void (*cb)(struct pa_mainloop_api*a, struct pa_io_event *e, int fd, enum pa_io_event_flags events, void *userdata), void *userdata);
-void pa_free_io_events(struct pa_mainloop_api* m, struct pa_io_event **io_sources, unsigned n_io_sources);
+int pa_create_io_events(snd_pcm_t *pcm_handle, pa_mainloop_api *m, pa_io_event ***io_events, unsigned *n_io_events, void (*cb)(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags events, void *userdata), void *userdata);
+void pa_free_io_events(pa_mainloop_api* m, pa_io_event **io_sources, unsigned n_io_sources);
#endif
size_t length;
};
-int pa_authkey_prop_get(struct pa_core *c, const char *name, void *data, size_t len) {
+int pa_authkey_prop_get(pa_core *c, const char *name, void *data, size_t len) {
struct authkey_data *a;
assert(c && name && data && len > 0);
return 0;
}
-int pa_authkey_prop_put(struct pa_core *c, const char *name, const void *data, size_t len) {
+int pa_authkey_prop_put(pa_core *c, const char *name, const void *data, size_t len) {
struct authkey_data *a;
assert(c && name);
return 0;
}
-void pa_authkey_prop_ref(struct pa_core *c, const char *name) {
+void pa_authkey_prop_ref(pa_core *c, const char *name) {
struct authkey_data *a;
assert(c && name);
a->ref++;
}
-void pa_authkey_prop_unref(struct pa_core *c, const char *name) {
+void pa_authkey_prop_unref(pa_core *c, const char *name) {
struct authkey_data *a;
assert(c && name);
* several modules. */
/* Return the data of the specified authorization key property. Doesn't alter the refernce count of the key */
-int pa_authkey_prop_get(struct pa_core *c, const char *name, void *data, size_t len);
+int pa_authkey_prop_get(pa_core *c, const char *name, void *data, size_t len);
/* Store data in the specified authorization key property. The initial reference count is set to 1 */
-int pa_authkey_prop_put(struct pa_core *c, const char *name, const void *data, size_t len);
+int pa_authkey_prop_put(pa_core *c, const char *name, const void *data, size_t len);
/* Increase the reference count of the specified authorization key */
-void pa_authkey_prop_ref(struct pa_core *c, const char *name);
+void pa_authkey_prop_ref(pa_core *c, const char *name);
/* Decrease the reference count of the specified authorization key */
-void pa_authkey_prop_unref(struct pa_core *c, const char *name);
+void pa_authkey_prop_unref(pa_core *c, const char *name);
#endif
#include "scache.h"
#include "subscribe.h"
-static void entry_free(struct pa_autoload_entry *e) {
+static void entry_free(pa_autoload_entry *e) {
assert(e);
pa_subscription_post(e->core, PA_SUBSCRIPTION_EVENT_AUTOLOAD|PA_SUBSCRIPTION_EVENT_REMOVE, PA_INVALID_INDEX);
pa_xfree(e->name);
pa_xfree(e);
}
-static void entry_remove_and_free(struct pa_autoload_entry *e) {
+static void entry_remove_and_free(pa_autoload_entry *e) {
assert(e && e->core);
pa_idxset_remove_by_data(e->core->autoload_idxset, e, NULL);
entry_free(e);
}
-static struct pa_autoload_entry* entry_new(struct pa_core *c, const char *name) {
- struct pa_autoload_entry *e = NULL;
+static pa_autoload_entry* entry_new(pa_core *c, const char *name) {
+ pa_autoload_entry *e = NULL;
assert(c && name);
if (c->autoload_hashmap && (e = pa_hashmap_get(c->autoload_hashmap, name)))
return NULL;
- e = pa_xmalloc(sizeof(struct pa_autoload_entry));
+ e = pa_xmalloc(sizeof(pa_autoload_entry));
e->core = c;
e->name = pa_xstrdup(name);
e->module = e->argument = NULL;
return e;
}
-int pa_autoload_add(struct pa_core *c, const char*name, enum pa_namereg_type type, const char*module, const char *argument, uint32_t *index) {
- struct pa_autoload_entry *e = NULL;
+int pa_autoload_add(pa_core *c, const char*name, pa_namereg_type type, const char*module, const char *argument, uint32_t *idx) {
+ pa_autoload_entry *e = NULL;
assert(c && name && module && (type == PA_NAMEREG_SINK || type == PA_NAMEREG_SOURCE));
if (!(e = entry_new(c, name)))
e->argument = pa_xstrdup(argument);
e->type = type;
- if (index)
- *index = e->index;
+ if (idx)
+ *idx = e->index;
return 0;
}
-int pa_autoload_remove_by_name(struct pa_core *c, const char*name, enum pa_namereg_type type) {
- struct pa_autoload_entry *e;
+int pa_autoload_remove_by_name(pa_core *c, const char*name, pa_namereg_type type) {
+ pa_autoload_entry *e;
assert(c && name && type);
if (!c->autoload_hashmap || !(e = pa_hashmap_get(c->autoload_hashmap, name)) || e->type != type)
return 0;
}
-int pa_autoload_remove_by_index(struct pa_core *c, uint32_t index) {
- struct pa_autoload_entry *e;
- assert(c && index != PA_IDXSET_INVALID);
+int pa_autoload_remove_by_index(pa_core *c, uint32_t idx) {
+ pa_autoload_entry *e;
+ assert(c && idx != PA_IDXSET_INVALID);
- if (!c->autoload_idxset || !(e = pa_idxset_get_by_index(c->autoload_idxset, index)))
+ if (!c->autoload_idxset || !(e = pa_idxset_get_by_index(c->autoload_idxset, idx)))
return -1;
entry_remove_and_free(e);
return 0;
}
-void pa_autoload_request(struct pa_core *c, const char *name, enum pa_namereg_type type) {
- struct pa_autoload_entry *e;
- struct pa_module *m;
+void pa_autoload_request(pa_core *c, const char *name, pa_namereg_type type) {
+ pa_autoload_entry *e;
+ pa_module *m;
assert(c && name);
if (!c->autoload_hashmap || !(e = pa_hashmap_get(c->autoload_hashmap, name)) || (e->type != type))
e->in_action = 0;
}
-static void free_func(void *p, void *userdata) {
- struct pa_autoload_entry *e = p;
+static void free_func(void *p, PA_GCC_UNUSED void *userdata) {
+ pa_autoload_entry *e = p;
pa_idxset_remove_by_data(e->core->autoload_idxset, e, NULL);
entry_free(e);
}
-void pa_autoload_free(struct pa_core *c) {
+void pa_autoload_free(pa_core *c) {
if (c->autoload_hashmap) {
pa_hashmap_free(c->autoload_hashmap, free_func, NULL);
c->autoload_hashmap = NULL;
}
}
-const struct pa_autoload_entry* pa_autoload_get_by_name(struct pa_core *c, const char*name, enum pa_namereg_type type) {
- struct pa_autoload_entry *e;
+const pa_autoload_entry* pa_autoload_get_by_name(pa_core *c, const char*name, pa_namereg_type type) {
+ pa_autoload_entry *e;
assert(c && name);
if (!c->autoload_hashmap || !(e = pa_hashmap_get(c->autoload_hashmap, name)) || e->type != type)
return e;
}
-const struct pa_autoload_entry* pa_autoload_get_by_index(struct pa_core *c, uint32_t index) {
- struct pa_autoload_entry *e;
- assert(c && index != PA_IDXSET_INVALID);
+const pa_autoload_entry* pa_autoload_get_by_index(pa_core *c, uint32_t idx) {
+ pa_autoload_entry *e;
+ assert(c && idx != PA_IDXSET_INVALID);
- if (!c->autoload_idxset || !(e = pa_idxset_get_by_index(c->autoload_idxset, index)))
+ if (!c->autoload_idxset || !(e = pa_idxset_get_by_index(c->autoload_idxset, idx)))
return NULL;
return e;
* specified module is loaded. */
/* An autoload entry, or "ghost" sink/source */
-struct pa_autoload_entry {
- struct pa_core *core;
+typedef struct pa_autoload_entry {
+ pa_core *core;
uint32_t index;
char *name;
- enum pa_namereg_type type; /* Type of the autoload entry */
+ pa_namereg_type type; /* Type of the autoload entry */
int in_action; /* Currently loaded */
char *module, *argument;
-};
+} pa_autoload_entry;
/* Add a new autoload entry of the given time, with the speicified
* sink/source name, module name and argument. Return the entry's
* index in *index */
-int pa_autoload_add(struct pa_core *c, const char*name, enum pa_namereg_type type, const char*module, const char *argument, uint32_t *index);
+int pa_autoload_add(pa_core *c, const char*name, pa_namereg_type type, const char*module, const char *argument, uint32_t *idx);
/* Free all autoload entries */
-void pa_autoload_free(struct pa_core *c);
-int pa_autoload_remove_by_name(struct pa_core *c, const char*name, enum pa_namereg_type type);
-int pa_autoload_remove_by_index(struct pa_core *c, uint32_t index);
+void pa_autoload_free(pa_core *c);
+int pa_autoload_remove_by_name(pa_core *c, const char*name, pa_namereg_type type);
+int pa_autoload_remove_by_index(pa_core *c, uint32_t idx);
/* Request an autoload entry by its name, effectively causing a module to be loaded */
-void pa_autoload_request(struct pa_core *c, const char *name, enum pa_namereg_type type);
+void pa_autoload_request(pa_core *c, const char *name, pa_namereg_type type);
-const struct pa_autoload_entry* pa_autoload_get_by_name(struct pa_core *c, const char*name, enum pa_namereg_type type);
-const struct pa_autoload_entry* pa_autoload_get_by_index(struct pa_core *c, uint32_t index);
+const pa_autoload_entry* pa_autoload_get_by_name(pa_core *c, const char*name, pa_namereg_type type);
+const pa_autoload_entry* pa_autoload_get_by_index(pa_core *c, uint32_t idx);
#endif
struct command {
const char *name;
- int (*proc) (struct pa_core *c, struct pa_tokenizer*t, struct pa_strbuf *buf, int *fail);
+ int (*proc) (pa_core *c, pa_tokenizer*t, pa_strbuf *buf, int *fail);
const char *help;
unsigned args;
};
#define NOFAIL_META ".nofail"
/* Prototypes for all available commands */
-static int pa_cli_command_exit(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_help(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_modules(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_clients(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_sinks(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_sources(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_sink_inputs(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_source_outputs(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_stat(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_info(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_load(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_unload(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_sink_volume(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_sink_input_volume(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_sink_default(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_source_default(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_kill_client(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_kill_sink_input(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_kill_source_output(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_scache_play(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_scache_remove(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_scache_list(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_scache_load(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_scache_load_dir(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_play_file(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_autoload_list(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_autoload_add(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_autoload_remove(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_dump(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
-static int pa_cli_command_list_props(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail);
+static int pa_cli_command_exit(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_help(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_modules(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_clients(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_sinks(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_sources(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_sink_inputs(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_source_outputs(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_stat(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_info(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_load(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_unload(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_sink_volume(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_sink_input_volume(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_sink_default(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_source_default(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_kill_client(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_kill_sink_input(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_kill_source_output(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_scache_play(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_scache_remove(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_scache_list(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_scache_load(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_scache_load_dir(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_play_file(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_autoload_list(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_autoload_add(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_autoload_remove(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_dump(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
+static int pa_cli_command_list_props(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail);
/* A method table for all available commands */
static const char linebreak[] = "\n\r";
static uint32_t parse_index(const char *n) {
- uint32_t index;
+ uint32_t idx;
- if (pa_atou(n, &index) < 0)
+ if (pa_atou(n, &idx) < 0)
return (uint32_t) PA_IDXSET_INVALID;
- return index;
+ return idx;
}
-static int pa_cli_command_exit(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_exit(pa_core *c, pa_tokenizer *t, PA_GCC_UNUSED pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
assert(c && c->mainloop && t);
c->mainloop->quit(c->mainloop, 0);
return 0;
}
-static int pa_cli_command_help(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_help(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
const struct command*command;
assert(c && t && buf);
return 0;
}
-static int pa_cli_command_modules(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_modules(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
char *s;
assert(c && t);
s = pa_module_list_to_string(c);
return 0;
}
-static int pa_cli_command_clients(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_clients(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
char *s;
assert(c && t);
s = pa_client_list_to_string(c);
return 0;
}
-static int pa_cli_command_sinks(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_sinks(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
char *s;
assert(c && t);
s = pa_sink_list_to_string(c);
return 0;
}
-static int pa_cli_command_sources(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_sources(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
char *s;
assert(c && t);
s = pa_source_list_to_string(c);
return 0;
}
-static int pa_cli_command_sink_inputs(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_sink_inputs(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
char *s;
assert(c && t);
s = pa_sink_input_list_to_string(c);
return 0;
}
-static int pa_cli_command_source_outputs(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_source_outputs(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
char *s;
assert(c && t);
s = pa_source_output_list_to_string(c);
return 0;
}
-static int pa_cli_command_stat(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_stat(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
char s[256];
assert(c && t);
return 0;
}
-static int pa_cli_command_info(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_info(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail) {
assert(c && t);
pa_cli_command_stat(c, t, buf, fail);
pa_cli_command_modules(c, t, buf, fail);
return 0;
}
-static int pa_cli_command_load(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
- struct pa_module *m;
+static int pa_cli_command_load(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
+ pa_module *m;
const char *name;
assert(c && t);
return 0;
}
-static int pa_cli_command_unload(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
- struct pa_module *m;
- uint32_t index;
+static int pa_cli_command_unload(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
+ pa_module *m;
+ uint32_t idx;
const char *i;
char *e;
assert(c && t);
return -1;
}
- index = (uint32_t) strtoul(i, &e, 10);
- if (*e || !(m = pa_idxset_get_by_index(c->modules, index))) {
+ idx = (uint32_t) strtoul(i, &e, 10);
+ if (*e || !(m = pa_idxset_get_by_index(c->modules, idx))) {
pa_strbuf_puts(buf, "Invalid module index.\n");
return -1;
}
return 0;
}
-static int pa_cli_command_sink_volume(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_sink_volume(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
const char *n, *v;
- struct pa_sink *sink;
+ pa_sink *sink;
uint32_t volume;
if (!(n = pa_tokenizer_get(t, 1))) {
return 0;
}
-static int pa_cli_command_sink_input_volume(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_sink_input_volume(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
const char *n, *v;
- struct pa_sink_input *si;
+ pa_sink_input *si;
uint32_t volume;
- uint32_t index;
+ uint32_t idx;
if (!(n = pa_tokenizer_get(t, 1))) {
pa_strbuf_puts(buf, "You need to specify a sink input by its index.\n");
return -1;
}
- if ((index = parse_index(n)) == PA_IDXSET_INVALID) {
+ if ((idx = parse_index(n)) == PA_IDXSET_INVALID) {
pa_strbuf_puts(buf, "Failed to parse index.\n");
return -1;
}
return -1;
}
- if (!(si = pa_idxset_get_by_index(c->sink_inputs, (uint32_t) index))) {
+ if (!(si = pa_idxset_get_by_index(c->sink_inputs, (uint32_t) idx))) {
pa_strbuf_puts(buf, "No sink input found with this index.\n");
return -1;
}
return 0;
}
-static int pa_cli_command_sink_default(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_sink_default(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
const char *n;
assert(c && t);
return 0;
}
-static int pa_cli_command_source_default(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_source_default(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
const char *n;
assert(c && t);
return 0;
}
-static int pa_cli_command_kill_client(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_kill_client(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
const char *n;
- struct pa_client *client;
- uint32_t index;
+ pa_client *client;
+ uint32_t idx;
assert(c && t);
if (!(n = pa_tokenizer_get(t, 1))) {
return -1;
}
- if ((index = parse_index(n)) == PA_IDXSET_INVALID) {
+ if ((idx = parse_index(n)) == PA_IDXSET_INVALID) {
pa_strbuf_puts(buf, "Failed to parse index.\n");
return -1;
}
- if (!(client = pa_idxset_get_by_index(c->clients, index))) {
+ if (!(client = pa_idxset_get_by_index(c->clients, idx))) {
pa_strbuf_puts(buf, "No client found by this index.\n");
return -1;
}
return 0;
}
-static int pa_cli_command_kill_sink_input(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_kill_sink_input(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
const char *n;
- struct pa_sink_input *sink_input;
- uint32_t index;
+ pa_sink_input *sink_input;
+ uint32_t idx;
assert(c && t);
if (!(n = pa_tokenizer_get(t, 1))) {
return -1;
}
- if ((index = parse_index(n)) == PA_IDXSET_INVALID) {
+ if ((idx = parse_index(n)) == PA_IDXSET_INVALID) {
pa_strbuf_puts(buf, "Failed to parse index.\n");
return -1;
}
- if (!(sink_input = pa_idxset_get_by_index(c->sink_inputs, index))) {
+ if (!(sink_input = pa_idxset_get_by_index(c->sink_inputs, idx))) {
pa_strbuf_puts(buf, "No sink input found by this index.\n");
return -1;
}
return 0;
}
-static int pa_cli_command_kill_source_output(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_kill_source_output(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
const char *n;
- struct pa_source_output *source_output;
- uint32_t index;
+ pa_source_output *source_output;
+ uint32_t idx;
assert(c && t);
if (!(n = pa_tokenizer_get(t, 1))) {
return -1;
}
- if ((index = parse_index(n)) == PA_IDXSET_INVALID) {
+ if ((idx = parse_index(n)) == PA_IDXSET_INVALID) {
pa_strbuf_puts(buf, "Failed to parse index.\n");
return -1;
}
- if (!(source_output = pa_idxset_get_by_index(c->source_outputs, index))) {
+ if (!(source_output = pa_idxset_get_by_index(c->source_outputs, idx))) {
pa_strbuf_puts(buf, "No source output found by this index.\n");
return -1;
}
return 0;
}
-static int pa_cli_command_scache_list(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_scache_list(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
char *s;
assert(c && t);
s = pa_scache_list_to_string(c);
return 0;
}
-static int pa_cli_command_scache_play(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_scache_play(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail) {
const char *n, *sink_name;
- struct pa_sink *sink;
+ pa_sink *sink;
assert(c && t && buf && fail);
if (!(n = pa_tokenizer_get(t, 1)) || !(sink_name = pa_tokenizer_get(t, 2))) {
return 0;
}
-static int pa_cli_command_scache_remove(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_scache_remove(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail) {
const char *n;
assert(c && t && buf && fail);
return 0;
}
-static int pa_cli_command_scache_load(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_scache_load(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail) {
const char *fname, *n;
int r;
assert(c && t && buf && fail);
return 0;
}
-static int pa_cli_command_scache_load_dir(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_scache_load_dir(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail) {
const char *pname;
assert(c && t && buf && fail);
return 0;
}
-static int pa_cli_command_play_file(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_play_file(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail) {
const char *fname, *sink_name;
- struct pa_sink *sink;
+ pa_sink *sink;
assert(c && t && buf && fail);
if (!(fname = pa_tokenizer_get(t, 1)) || !(sink_name = pa_tokenizer_get(t, 2))) {
return pa_play_file(sink, fname, PA_VOLUME_NORM);
}
-static int pa_cli_command_autoload_add(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_autoload_add(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail) {
const char *a, *b;
assert(c && t && buf && fail);
return 0;
}
-static int pa_cli_command_autoload_remove(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_autoload_remove(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, int *fail) {
const char *name;
assert(c && t && buf && fail);
return 0;
}
-static int pa_cli_command_autoload_list(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_autoload_list(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
char *s;
assert(c && t);
s = pa_autoload_list_to_string(c);
return 0;
}
-static int pa_cli_command_list_props(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
+static int pa_cli_command_list_props(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
assert(c && t);
pa_property_dump(c, buf);
return 0;
}
-static int pa_cli_command_dump(struct pa_core *c, struct pa_tokenizer *t, struct pa_strbuf *buf, int *fail) {
- struct pa_module *m;
- struct pa_sink *s;
+static int pa_cli_command_dump(pa_core *c, pa_tokenizer *t, pa_strbuf *buf, PA_GCC_UNUSED int *fail) {
+ pa_module *m;
+ pa_sink *s;
int nl;
const char *p;
- uint32_t index;
+ uint32_t idx;
char txt[256];
time_t now;
void *i;
- struct pa_autoload_entry *a;
+ pa_autoload_entry *a;
assert(c && t);
#endif
- for (m = pa_idxset_first(c->modules, &index); m; m = pa_idxset_next(c->modules, &index)) {
+ for (m = pa_idxset_first(c->modules, &idx); m; m = pa_idxset_next(c->modules, &idx)) {
if (m->auto_unload)
continue;
nl = 0;
- for (s = pa_idxset_first(c->sinks, &index); s; s = pa_idxset_next(c->sinks, &index)) {
+ for (s = pa_idxset_first(c->sinks, &idx); s; s = pa_idxset_next(c->sinks, &idx)) {
if (s->volume == PA_VOLUME_NORM)
continue;
}
-int pa_cli_command_execute_line(struct pa_core *c, const char *s, struct pa_strbuf *buf, int *fail) {
+int pa_cli_command_execute_line(pa_core *c, const char *s, pa_strbuf *buf, int *fail) {
const char *cs;
cs = s+strspn(s, whitespace);
for (command = commands; command->name; command++)
if (strlen(command->name) == l && !strncmp(cs, command->name, l)) {
int ret;
- struct pa_tokenizer *t = pa_tokenizer_new(cs, command->args);
+ pa_tokenizer *t = pa_tokenizer_new(cs, command->args);
assert(t);
ret = command->proc(c, t, buf, fail);
pa_tokenizer_free(t);
return 0;
}
-int pa_cli_command_execute_file(struct pa_core *c, const char *fn, struct pa_strbuf *buf, int *fail) {
+int pa_cli_command_execute_file(pa_core *c, const char *fn, pa_strbuf *buf, int *fail) {
char line[256];
FILE *f = NULL;
int ret = -1;
return ret;
}
-int pa_cli_command_execute(struct pa_core *c, const char *s, struct pa_strbuf *buf, int *fail) {
+int pa_cli_command_execute(pa_core *c, const char *s, pa_strbuf *buf, int *fail) {
const char *p;
assert(c && s && buf && fail);
* buffer *buf. If *fail is non-zero the function will return -1 when
* one or more of the executed commands failed. *fail
* may be modified by the function call. */
-int pa_cli_command_execute_line(struct pa_core *c, const char *s, struct pa_strbuf *buf, int *fail);
+int pa_cli_command_execute_line(pa_core *c, const char *s, pa_strbuf *buf, int *fail);
/* Execute a whole file of CLI commands */
-int pa_cli_command_execute_file(struct pa_core *c, const char *fn, struct pa_strbuf *buf, int *fail);
+int pa_cli_command_execute_file(pa_core *c, const char *fn, pa_strbuf *buf, int *fail);
/* Split the specified string into lines and run pa_cli_command_execute_line() for each. */
-int pa_cli_command_execute(struct pa_core *c, const char *s, struct pa_strbuf *buf, int *fail);
+int pa_cli_command_execute(pa_core *c, const char *s, pa_strbuf *buf, int *fail);
#endif
#include "autoload.h"
#include "xmalloc.h"
-char *pa_module_list_to_string(struct pa_core *c) {
- struct pa_strbuf *s;
- struct pa_module *m;
- uint32_t index = PA_IDXSET_INVALID;
+char *pa_module_list_to_string(pa_core *c) {
+ pa_strbuf *s;
+ pa_module *m;
+ uint32_t idx = PA_IDXSET_INVALID;
assert(c);
s = pa_strbuf_new();
assert(s);
- pa_strbuf_printf(s, "%u module(s) loaded.\n", pa_idxset_ncontents(c->modules));
+ pa_strbuf_printf(s, "%u module(s) loaded.\n", pa_idxset_size(c->modules));
- for (m = pa_idxset_first(c->modules, &index); m; m = pa_idxset_next(c->modules, &index))
+ for (m = pa_idxset_first(c->modules, &idx); m; m = pa_idxset_next(c->modules, &idx))
pa_strbuf_printf(s, " index: %u\n\tname: <%s>\n\targument: <%s>\n\tused: %i\n\tauto unload: %s\n", m->index, m->name, m->argument, m->n_used, m->auto_unload ? "yes" : "no");
return pa_strbuf_tostring_free(s);
}
-char *pa_client_list_to_string(struct pa_core *c) {
- struct pa_strbuf *s;
- struct pa_client *client;
- uint32_t index = PA_IDXSET_INVALID;
+char *pa_client_list_to_string(pa_core *c) {
+ pa_strbuf *s;
+ pa_client *client;
+ uint32_t idx = PA_IDXSET_INVALID;
char tid[5];
assert(c);
s = pa_strbuf_new();
assert(s);
- pa_strbuf_printf(s, "%u client(s) logged in.\n", pa_idxset_ncontents(c->clients));
+ pa_strbuf_printf(s, "%u client(s) logged in.\n", pa_idxset_size(c->clients));
- for (client = pa_idxset_first(c->clients, &index); client; client = pa_idxset_next(c->clients, &index)) {
+ for (client = pa_idxset_first(c->clients, &idx); client; client = pa_idxset_next(c->clients, &idx)) {
pa_strbuf_printf(s, " index: %u\n\tname: <%s>\n\ttype: <%s>\n", client->index, client->name, pa_typeid_to_string(client->typeid, tid, sizeof(tid)));
if (client->owner)
return pa_strbuf_tostring_free(s);
}
-char *pa_sink_list_to_string(struct pa_core *c) {
- struct pa_strbuf *s;
- struct pa_sink *sink;
- uint32_t index = PA_IDXSET_INVALID;
+char *pa_sink_list_to_string(pa_core *c) {
+ pa_strbuf *s;
+ pa_sink *sink;
+ uint32_t idx = PA_IDXSET_INVALID;
char tid[5];
assert(c);
s = pa_strbuf_new();
assert(s);
- pa_strbuf_printf(s, "%u sink(s) available.\n", pa_idxset_ncontents(c->sinks));
+ pa_strbuf_printf(s, "%u sink(s) available.\n", pa_idxset_size(c->sinks));
- for (sink = pa_idxset_first(c->sinks, &index); sink; sink = pa_idxset_next(c->sinks, &index)) {
+ for (sink = pa_idxset_first(c->sinks, &idx); sink; sink = pa_idxset_next(c->sinks, &idx)) {
char ss[PA_SAMPLE_SPEC_SNPRINT_MAX];
pa_sample_spec_snprint(ss, sizeof(ss), &sink->sample_spec);
assert(sink->monitor_source);
pa_typeid_to_string(sink->typeid, tid, sizeof(tid)),
(unsigned) sink->volume,
pa_volume_to_dB(sink->volume),
- (float) pa_sink_get_latency(sink),
+ (double) pa_sink_get_latency(sink),
sink->monitor_source->index,
ss);
return pa_strbuf_tostring_free(s);
}
-char *pa_source_list_to_string(struct pa_core *c) {
- struct pa_strbuf *s;
- struct pa_source *source;
- uint32_t index = PA_IDXSET_INVALID;
+char *pa_source_list_to_string(pa_core *c) {
+ pa_strbuf *s;
+ pa_source *source;
+ uint32_t idx = PA_IDXSET_INVALID;
char tid[5];
assert(c);
s = pa_strbuf_new();
assert(s);
- pa_strbuf_printf(s, "%u source(s) available.\n", pa_idxset_ncontents(c->sources));
+ pa_strbuf_printf(s, "%u source(s) available.\n", pa_idxset_size(c->sources));
- for (source = pa_idxset_first(c->sources, &index); source; source = pa_idxset_next(c->sources, &index)) {
+ for (source = pa_idxset_first(c->sources, &idx); source; source = pa_idxset_next(c->sources, &idx)) {
char ss[PA_SAMPLE_SPEC_SNPRINT_MAX];
pa_sample_spec_snprint(ss, sizeof(ss), &source->sample_spec);
pa_strbuf_printf(s, " %c index: %u\n\tname: <%s>\n\ttype: <%s>\n\tlatency: <%0.0f usec>\n\tsample_spec: <%s>\n",
source->index,
source->name,
pa_typeid_to_string(source->typeid, tid, sizeof(tid)),
- (float) pa_source_get_latency(source),
+ (double) pa_source_get_latency(source),
ss);
if (source->monitor_of)
}
-char *pa_source_output_list_to_string(struct pa_core *c) {
- struct pa_strbuf *s;
- struct pa_source_output *o;
- uint32_t index = PA_IDXSET_INVALID;
+char *pa_source_output_list_to_string(pa_core *c) {
+ pa_strbuf *s;
+ pa_source_output *o;
+ uint32_t idx = PA_IDXSET_INVALID;
char tid[5];
static const char* const state_table[] = {
"RUNNING",
s = pa_strbuf_new();
assert(s);
- pa_strbuf_printf(s, "%u source outputs(s) available.\n", pa_idxset_ncontents(c->source_outputs));
+ pa_strbuf_printf(s, "%u source outputs(s) available.\n", pa_idxset_size(c->source_outputs));
- for (o = pa_idxset_first(c->source_outputs, &index); o; o = pa_idxset_next(c->source_outputs, &index)) {
+ for (o = pa_idxset_first(c->source_outputs, &idx); o; o = pa_idxset_next(c->source_outputs, &idx)) {
char ss[PA_SAMPLE_SPEC_SNPRINT_MAX];
const char *rm;
pa_sample_spec_snprint(ss, sizeof(ss), &o->sample_spec);
return pa_strbuf_tostring_free(s);
}
-char *pa_sink_input_list_to_string(struct pa_core *c) {
- struct pa_strbuf *s;
- struct pa_sink_input *i;
- uint32_t index = PA_IDXSET_INVALID;
+char *pa_sink_input_list_to_string(pa_core *c) {
+ pa_strbuf *s;
+ pa_sink_input *i;
+ uint32_t idx = PA_IDXSET_INVALID;
char tid[5];
static const char* const state_table[] = {
"RUNNING",
s = pa_strbuf_new();
assert(s);
- pa_strbuf_printf(s, "%u sink input(s) available.\n", pa_idxset_ncontents(c->sink_inputs));
+ pa_strbuf_printf(s, "%u sink input(s) available.\n", pa_idxset_size(c->sink_inputs));
- for (i = pa_idxset_first(c->sink_inputs, &index); i; i = pa_idxset_next(c->sink_inputs, &index)) {
+ for (i = pa_idxset_first(c->sink_inputs, &idx); i; i = pa_idxset_next(c->sink_inputs, &idx)) {
char ss[PA_SAMPLE_SPEC_SNPRINT_MAX];
const char *rm;
i->sink->index, i->sink->name,
(unsigned) i->volume,
pa_volume_to_dB(i->volume),
- (float) pa_sink_input_get_latency(i),
+ (double) pa_sink_input_get_latency(i),
ss,
rm);
return pa_strbuf_tostring_free(s);
}
-char *pa_scache_list_to_string(struct pa_core *c) {
- struct pa_strbuf *s;
+char *pa_scache_list_to_string(pa_core *c) {
+ pa_strbuf *s;
assert(c);
s = pa_strbuf_new();
assert(s);
- pa_strbuf_printf(s, "%u cache entries available.\n", c->scache ? pa_idxset_ncontents(c->scache) : 0);
+ pa_strbuf_printf(s, "%u cache entries available.\n", c->scache ? pa_idxset_size(c->scache) : 0);
if (c->scache) {
- struct pa_scache_entry *e;
- uint32_t index = PA_IDXSET_INVALID;
+ pa_scache_entry *e;
+ uint32_t idx = PA_IDXSET_INVALID;
- for (e = pa_idxset_first(c->scache, &index); e; e = pa_idxset_next(c->scache, &index)) {
+ for (e = pa_idxset_first(c->scache, &idx); e; e = pa_idxset_next(c->scache, &idx)) {
double l = 0;
char ss[PA_SAMPLE_SPEC_SNPRINT_MAX] = "n/a";
return pa_strbuf_tostring_free(s);
}
-char *pa_autoload_list_to_string(struct pa_core *c) {
- struct pa_strbuf *s;
+char *pa_autoload_list_to_string(pa_core *c) {
+ pa_strbuf *s;
assert(c);
s = pa_strbuf_new();
assert(s);
- pa_strbuf_printf(s, "%u autoload entries available.\n", c->autoload_hashmap ? pa_hashmap_ncontents(c->autoload_hashmap) : 0);
+ pa_strbuf_printf(s, "%u autoload entries available.\n", c->autoload_hashmap ? pa_hashmap_size(c->autoload_hashmap) : 0);
if (c->autoload_hashmap) {
- struct pa_autoload_entry *e;
+ pa_autoload_entry *e;
void *state = NULL;
while ((e = pa_hashmap_iterate(c->autoload_hashmap, &state, NULL))) {
return pa_strbuf_tostring_free(s);
}
-char *pa_full_status_string(struct pa_core *c) {
- struct pa_strbuf *s;
+char *pa_full_status_string(pa_core *c) {
+ pa_strbuf *s;
int i;
s = pa_strbuf_new();
/* Some functions to generate pretty formatted listings of
* entities. The returned strings have to be freed manually. */
-char *pa_sink_input_list_to_string(struct pa_core *c);
-char *pa_source_output_list_to_string(struct pa_core *c);
-char *pa_sink_list_to_string(struct pa_core *core);
-char *pa_source_list_to_string(struct pa_core *c);
-char *pa_client_list_to_string(struct pa_core *c);
-char *pa_module_list_to_string(struct pa_core *c);
-char *pa_scache_list_to_string(struct pa_core *c);
-char *pa_autoload_list_to_string(struct pa_core *c);
-
-char *pa_full_status_string(struct pa_core *c);
+char *pa_sink_input_list_to_string(pa_core *c);
+char *pa_source_output_list_to_string(pa_core *c);
+char *pa_sink_list_to_string(pa_core *core);
+char *pa_source_list_to_string(pa_core *c);
+char *pa_client_list_to_string(pa_core *c);
+char *pa_module_list_to_string(pa_core *c);
+char *pa_scache_list_to_string(pa_core *c);
+char *pa_autoload_list_to_string(pa_core *c);
+
+char *pa_full_status_string(pa_core *c);
#endif
#define PA_TYPEID_CLI PA_TYPEID_MAKE('C', 'L', 'I', '_')
struct pa_cli {
- struct pa_core *core;
- struct pa_ioline *line;
+ pa_core *core;
+ pa_ioline *line;
- void (*eof_callback)(struct pa_cli *c, void *userdata);
+ void (*eof_callback)(pa_cli *c, void *userdata);
void *userdata;
- struct pa_client *client;
+ pa_client *client;
int fail, kill_requested, defer_kill;
};
-static void line_callback(struct pa_ioline *line, const char *s, void *userdata);
-static void client_kill(struct pa_client *c);
+static void line_callback(pa_ioline *line, const char *s, void *userdata);
+static void client_kill(pa_client *c);
-struct pa_cli* pa_cli_new(struct pa_core *core, struct pa_iochannel *io, struct pa_module *m) {
+pa_cli* pa_cli_new(pa_core *core, pa_iochannel *io, pa_module *m) {
char cname[256];
- struct pa_cli *c;
+ pa_cli *c;
assert(io);
- c = pa_xmalloc(sizeof(struct pa_cli));
+ c = pa_xmalloc(sizeof(pa_cli));
c->core = core;
c->line = pa_ioline_new(io);
assert(c->line);
return c;
}
-void pa_cli_free(struct pa_cli *c) {
+void pa_cli_free(pa_cli *c) {
assert(c);
pa_ioline_close(c->line);
pa_ioline_unref(c->line);
pa_xfree(c);
}
-static void client_kill(struct pa_client *client) {
- struct pa_cli *c;
+static void client_kill(pa_client *client) {
+ pa_cli *c;
assert(client && client->userdata);
c = client->userdata;
}
}
-static void line_callback(struct pa_ioline *line, const char *s, void *userdata) {
- struct pa_strbuf *buf;
- struct pa_cli *c = userdata;
+static void line_callback(pa_ioline *line, const char *s, void *userdata) {
+ pa_strbuf *buf;
+ pa_cli *c = userdata;
char *p;
assert(line && c);
pa_ioline_puts(line, PROMPT);
}
-void pa_cli_set_eof_callback(struct pa_cli *c, void (*cb)(struct pa_cli*c, void *userdata), void *userdata) {
+void pa_cli_set_eof_callback(pa_cli *c, void (*cb)(pa_cli*c, void *userdata), void *userdata) {
assert(c);
c->eof_callback = cb;
c->userdata = userdata;
#include "core.h"
#include "module.h"
-struct pa_cli;
+typedef struct pa_cli pa_cli;
/* Create a new command line session on the specified io channel owned by the specified module */
-struct pa_cli* pa_cli_new(struct pa_core *core, struct pa_iochannel *io, struct pa_module *m);
-void pa_cli_free(struct pa_cli *cli);
+pa_cli* pa_cli_new(pa_core *core, pa_iochannel *io, pa_module *m);
+void pa_cli_free(pa_cli *cli);
/* Set a callback function that is called whenever the command line session is terminated */
-void pa_cli_set_eof_callback(struct pa_cli *cli, void (*cb)(struct pa_cli*c, void *userdata), void *userdata);
+void pa_cli_set_eof_callback(pa_cli *cli, void (*cb)(pa_cli*c, void *userdata), void *userdata);
#endif
#include "xmalloc.h"
#include "util.h"
-int pa_client_conf_from_x11(struct pa_client_conf *c, const char *dname) {
+int pa_client_conf_from_x11(pa_client_conf *c, const char *dname) {
Display *d = NULL;
int ret = -1;
char t[1024];
/* Load client configuration data from the specified X11 display,
* overwriting the current settings in *c */
-int pa_client_conf_from_x11(struct pa_client_conf *c, const char *display);
+int pa_client_conf_from_x11(pa_client_conf *c, const char *display);
#endif
#define ENV_DAEMON_BINARY "POLYP_BINARY"
#define ENV_COOKIE_FILE "POLYP_COOKIE"
-static const struct pa_client_conf default_conf = {
+static const pa_client_conf default_conf = {
.daemon_binary = NULL,
.extra_arguments = NULL,
.default_sink = NULL,
.cookie_valid = 0
};
-struct pa_client_conf *pa_client_conf_new(void) {
- struct pa_client_conf *c = pa_xmemdup(&default_conf, sizeof(default_conf));
+pa_client_conf *pa_client_conf_new(void) {
+ pa_client_conf *c = pa_xmemdup(&default_conf, sizeof(default_conf));
c->daemon_binary = pa_xstrdup(POLYPAUDIO_BINARY);
c->extra_arguments = pa_xstrdup("--log-target=syslog --exit-idle-time=5");
return c;
}
-void pa_client_conf_free(struct pa_client_conf *c) {
+void pa_client_conf_free(pa_client_conf *c) {
assert(c);
pa_xfree(c->daemon_binary);
pa_xfree(c->extra_arguments);
pa_xfree(c->cookie_file);
pa_xfree(c);
}
-int pa_client_conf_load(struct pa_client_conf *c, const char *filename) {
+int pa_client_conf_load(pa_client_conf *c, const char *filename) {
FILE *f = NULL;
char *fn = NULL;
int r = -1;
/* Prepare the configuration parse table */
- struct pa_config_item table[] = {
+ pa_config_item table[] = {
{ "daemon-binary", pa_config_parse_string, NULL },
{ "extra-arguments", pa_config_parse_string, NULL },
{ "default-sink", pa_config_parse_string, NULL },
return r;
}
-int pa_client_conf_env(struct pa_client_conf *c) {
+int pa_client_conf_env(pa_client_conf *c) {
char *e;
if ((e = getenv(ENV_DEFAULT_SINK))) {
return 0;
}
-int pa_client_conf_load_cookie(struct pa_client_conf* c) {
+int pa_client_conf_load_cookie(pa_client_conf* c) {
assert(c);
c->cookie_valid = 0;
/* A structure containing configuration data for polypaudio clients. */
-struct pa_client_conf {
+typedef struct pa_client_conf {
char *daemon_binary, *extra_arguments, *default_sink, *default_source, *default_server, *cookie_file;
int autospawn;
uint8_t cookie[PA_NATIVE_COOKIE_LENGTH];
int cookie_valid; /* non-zero, when cookie is valid */
-};
+} pa_client_conf;
/* Create a new configuration data object and reset it to defaults */
-struct pa_client_conf *pa_client_conf_new(void);
-void pa_client_conf_free(struct pa_client_conf *c);
+pa_client_conf *pa_client_conf_new(void);
+void pa_client_conf_free(pa_client_conf *c);
/* Load the configuration data from the speicified file, overwriting
* the current settings in *c. When the filename is NULL, the
* default client configuration file name is used. */
-int pa_client_conf_load(struct pa_client_conf *c, const char *filename);
+int pa_client_conf_load(pa_client_conf *c, const char *filename);
/* Load the configuration data from the environment of the current
process, overwriting the current settings in *c. */
-int pa_client_conf_env(struct pa_client_conf *c);
+int pa_client_conf_env(pa_client_conf *c);
/* Load cookie data from c->cookie_file into c->cookie */
-int pa_client_conf_load_cookie(struct pa_client_conf* c);
+int pa_client_conf_load_cookie(pa_client_conf* c);
#endif
#include "subscribe.h"
#include "log.h"
-struct pa_client *pa_client_new(struct pa_core *core, pa_typeid_t typeid, const char *name) {
- struct pa_client *c;
+pa_client *pa_client_new(pa_core *core, pa_typeid_t typeid, const char *name) {
+ pa_client *c;
int r;
assert(core);
- c = pa_xmalloc(sizeof(struct pa_client));
+ c = pa_xmalloc(sizeof(pa_client));
c->name = pa_xstrdup(name);
c->owner = NULL;
c->core = core;
return c;
}
-void pa_client_free(struct pa_client *c) {
+void pa_client_free(pa_client *c) {
assert(c && c->core);
pa_idxset_remove_by_data(c->core->clients, c, NULL);
}
-void pa_client_kill(struct pa_client *c) {
+void pa_client_kill(pa_client *c) {
assert(c);
if (!c->kill) {
pa_log_warn(__FILE__": kill() operation not implemented for client %u\n", c->index);
c->kill(c);
}
-void pa_client_set_name(struct pa_client *c, const char *name) {
+void pa_client_set_name(pa_client *c, const char *name) {
assert(c);
pa_xfree(c->name);
c->name = pa_xstrdup(name);
* attached. That way the user may generate a listing of all connected
* clients easily and kill them if he wants.*/
+typedef struct pa_client pa_client;
+
struct pa_client {
uint32_t index;
pa_typeid_t typeid;
- struct pa_module *owner;
+ pa_module *owner;
char *name;
- struct pa_core *core;
+ pa_core *core;
- void (*kill)(struct pa_client *c);
+ void (*kill)(pa_client *c);
void *userdata;
};
-struct pa_client *pa_client_new(struct pa_core *c, pa_typeid_t typeid, const char *name);
+pa_client *pa_client_new(pa_core *c, pa_typeid_t typeid, const char *name);
/* This function should be called only by the code that created the client */
-void pa_client_free(struct pa_client *c);
+void pa_client_free(pa_client *c);
/* Code that didn't create the client should call this function to
* request destruction of the client */
-void pa_client_kill(struct pa_client *c);
+void pa_client_kill(pa_client *c);
/* Rename the client */
-void pa_client_set_name(struct pa_client *c, const char *name);
+void pa_client_set_name(pa_client *c, const char *name);
#endif
" -n Don't load default script file\n", e);
}
-int pa_cmdline_parse(struct pa_daemon_conf *conf, int argc, char *const argv [], int *d) {
- struct pa_strbuf *buf = NULL;
+int pa_cmdline_parse(pa_daemon_conf *conf, int argc, char *const argv [], int *d) {
+ pa_strbuf *buf = NULL;
int c;
assert(conf && argc && argv);
/* Parese the command line and store its data in *c. Return the index
* of the first unparsed argument in *d. */
-int pa_cmdline_parse(struct pa_daemon_conf*c, int argc, char *const argv [], int *d);
+int pa_cmdline_parse(pa_daemon_conf*c, int argc, char *const argv [], int *d);
/* Show the command line help. The command name is extracted from
* argv[0] which should be passed in argv0. */
#define COMMENTS "#;\n"
/* Run the user supplied parser for an assignment */
-static int next_assignment(const char *filename, unsigned line, const struct pa_config_item *t, const char *lvalue, const char *rvalue, void *userdata) {
+static int next_assignment(const char *filename, unsigned line, const pa_config_item *t, const char *lvalue, const char *rvalue, void *userdata) {
assert(filename && t && lvalue && rvalue);
for (; t->parse; t++)
}
/* Parse a variable assignment line */
-static int parse_line(const char *filename, unsigned line, const struct pa_config_item *t, char *l, void *userdata) {
+static int parse_line(const char *filename, unsigned line, const pa_config_item *t, char *l, void *userdata) {
char *e, *c, *b = l+strspn(l, WHITESPACE);
if ((c = strpbrk(b, COMMENTS)))
}
/* Go through the file and parse each line */
-int pa_config_parse(const char *filename, FILE *f, const struct pa_config_item *t, void *userdata) {
+int pa_config_parse(const char *filename, FILE *f, const pa_config_item *t, void *userdata) {
int r = -1;
unsigned line = 0;
int do_close = !f;
return r;
}
-int pa_config_parse_int(const char *filename, unsigned line, const char *lvalue, const char *rvalue, void *data, void *userdata) {
+int pa_config_parse_int(const char *filename, unsigned line, const char *lvalue, const char *rvalue, void *data, PA_GCC_UNUSED void *userdata) {
int *i = data;
int32_t k;
assert(filename && lvalue && rvalue && data);
return 0;
}
-int pa_config_parse_bool(const char *filename, unsigned line, const char *lvalue, const char *rvalue, void *data, void *userdata) {
+int pa_config_parse_bool(const char *filename, unsigned line, const char *lvalue, const char *rvalue, void *data, PA_GCC_UNUSED void *userdata) {
int *b = data, k;
assert(filename && lvalue && rvalue && data);
return 0;
}
-int pa_config_parse_string(const char *filename, unsigned line, const char *lvalue, const char *rvalue, void *data, void *userdata) {
+int pa_config_parse_string(const char *filename, PA_GCC_UNUSED unsigned line, const char *lvalue, const char *rvalue, void *data, PA_GCC_UNUSED void *userdata) {
char **s = data;
assert(filename && lvalue && rvalue && data);
* files consisting of variable assignments only. */
/* Wraps info for parsing a specific configuration variable */
-struct pa_config_item {
+typedef struct pa_config_item {
const char *lvalue; /* name of the variable */
int (*parse)(const char *filename, unsigned line, const char *lvalue, const char *rvalue, void *data, void *userdata); /* Function that is called to parse the variable's value */
void *data; /* Where to store the variable's data */
-};
+} pa_config_item;
/* The configuration file parsing routine. Expects a table of
* pa_config_items in *t that is terminated by an item where lvalue is
* NULL */
-int pa_config_parse(const char *filename, FILE *f, const struct pa_config_item *t, void *userdata);
+int pa_config_parse(const char *filename, FILE *f, const pa_config_item *t, void *userdata);
/* Generic parsers for integers, booleans and strings */
int pa_config_parse_int(const char *filename, unsigned line, const char *lvalue, const char *rvalue, void *data, void *userdata);
#include "props.h"
#include "random.h"
-struct pa_core* pa_core_new(struct pa_mainloop_api *m) {
- struct pa_core* c;
- c = pa_xmalloc(sizeof(struct pa_core));
+pa_core* pa_core_new(pa_mainloop_api *m) {
+ pa_core* c;
+ c = pa_xmalloc(sizeof(pa_core));
c->mainloop = m;
c->clients = pa_idxset_new(NULL, NULL);
return c;
}
-void pa_core_free(struct pa_core *c) {
+void pa_core_free(pa_core *c) {
assert(c);
pa_module_unload_all(c);
pa_xfree(c);
}
-static void quit_callback(struct pa_mainloop_api*m, struct pa_time_event *e, const struct timeval *tv, void *userdata) {
- struct pa_core *c = userdata;
+static void quit_callback(pa_mainloop_api*m, pa_time_event *e, PA_GCC_UNUSED const struct timeval *tv, void *userdata) {
+ pa_core *c = userdata;
assert(c->quit_event = e);
m->quit(m, 0);
}
-void pa_core_check_quit(struct pa_core *c) {
+void pa_core_check_quit(pa_core *c) {
assert(c);
- if (!c->quit_event && c->exit_idle_time >= 0 && pa_idxset_ncontents(c->clients) == 0) {
+ if (!c->quit_event && c->exit_idle_time >= 0 && pa_idxset_size(c->clients) == 0) {
struct timeval tv;
pa_gettimeofday(&tv);
tv.tv_sec+= c->exit_idle_time;
c->quit_event = c->mainloop->time_new(c->mainloop, &tv, quit_callback, c);
- } else if (c->quit_event && pa_idxset_ncontents(c->clients) > 0) {
+ } else if (c->quit_event && pa_idxset_size(c->clients) > 0) {
c->mainloop->time_free(c->quit_event);
c->quit_event = NULL;
}
USA.
***/
+typedef struct pa_core pa_core;
+
#include "idxset.h"
#include "hashmap.h"
#include "mainloop-api.h"
#include "sample.h"
#include "memblock.h"
#include "resampler.h"
+#include "queue.h"
+#include "subscribe.h"
/* The core structure of polypaudio. Every polypaudio daemon contains
* exactly one of these. It is used for storing kind of global
* polypaudio. Not cryptographically secure in any way. */
uint32_t cookie;
- struct pa_mainloop_api *mainloop;
+ pa_mainloop_api *mainloop;
/* idxset of all kinds of entities */
- struct pa_idxset *clients, *sinks, *sources, *sink_inputs, *source_outputs, *modules, *scache, *autoload_idxset;
+ pa_idxset *clients, *sinks, *sources, *sink_inputs, *source_outputs, *modules, *scache, *autoload_idxset;
/* Some hashmaps for all sorts of entities */
- struct pa_hashmap *namereg, *autoload_hashmap, *properties;
+ pa_hashmap *namereg, *autoload_hashmap, *properties;
/* The name of the default sink/source */
char *default_source_name, *default_sink_name;
- struct pa_sample_spec default_sample_spec;
- struct pa_time_event *module_auto_unload_event;
- struct pa_defer_event *module_defer_unload_event;
+ pa_sample_spec default_sample_spec;
+ pa_time_event *module_auto_unload_event;
+ pa_defer_event *module_defer_unload_event;
- struct pa_defer_event *subscription_defer_event;
- struct pa_queue *subscription_event_queue;
- struct pa_subscription *subscriptions;
+ pa_defer_event *subscription_defer_event;
+ pa_queue *subscription_event_queue;
+ pa_subscription *subscriptions;
- struct pa_memblock_stat *memblock_stat;
+ pa_memblock_stat *memblock_stat;
int disallow_module_loading, running_as_daemon;
int exit_idle_time, module_idle_time, scache_idle_time;
- struct pa_time_event *quit_event;
+ pa_time_event *quit_event;
- struct pa_time_event *scache_auto_unload_event;
+ pa_time_event *scache_auto_unload_event;
- enum pa_resample_method resample_method;
+ pa_resample_method resample_method;
};
-struct pa_core* pa_core_new(struct pa_mainloop_api *m);
-void pa_core_free(struct pa_core*c);
+pa_core* pa_core_new(pa_mainloop_api *m);
+void pa_core_free(pa_core*c);
/* Check whether noone is connected to this core */
-void pa_core_check_quit(struct pa_core *c);
+void pa_core_check_quit(pa_core *c);
#endif
#include "cpulimit.h"
#include "mainloop.h"
+#include "gccmacro.h"
#ifdef TEST2
#include "mainloop-signal.h"
#ifdef TEST2
-static void func(struct pa_mainloop_api *m, struct pa_signal_event *e, int sig, void *userdata) {
+static void func(pa_mainloop_api *m, PA_GCC_UNUSED pa_signal_event *e, PA_GCC_UNUSED int sig, PA_GCC_UNUSED void *userdata) {
time_t now;
time(&now);
#endif
-int main() {
- struct pa_mainloop *m;
+int main(PA_GCC_UNUSED int argc, PA_GCC_UNUSED char *argv[]) {
+ pa_mainloop *m;
m = pa_mainloop_new();
assert(m);
#include <config.h>
#endif
+#include "cpulimit.h"
+#include "util.h"
+#include "log.h"
+
#ifdef HAVE_SIGXCPU
#include <errno.h>
#include <sys/resource.h>
#endif
-#include "cpulimit.h"
-#include "util.h"
-#include "log.h"
-
-
/* This module implements a watchdog that makes sure that the current
* process doesn't consume more than 70% CPU time for 10 seconds. This
* is very useful when using SCHED_FIFO scheduling which effectively
static int the_pipe[2] = {-1, -1};
/* Main event loop and IO event for the FIFO */
-static struct pa_mainloop_api *api = NULL;
-static struct pa_io_event *io_event = NULL;
+static pa_mainloop_api *api = NULL;
+static pa_io_event *io_event = NULL;
/* Saved sigaction struct for SIGXCPU */
static struct sigaction sigaction_prev;
}
/* Callback for IO events on the FIFO */
-static void callback(struct pa_mainloop_api*m, struct pa_io_event*e, int fd, enum pa_io_event_flags f, void *userdata) {
+static void callback(pa_mainloop_api*m, pa_io_event*e, int fd, pa_io_event_flags f, void *userdata) {
char c;
assert(m && e && f == PA_IO_EVENT_INPUT && e == io_event && fd == the_pipe[0]);
read(the_pipe[0], &c, sizeof(c));
}
/* Initializes CPU load limiter */
-int pa_cpu_limit_init(struct pa_mainloop_api *m) {
+int pa_cpu_limit_init(pa_mainloop_api *m) {
struct sigaction sa;
assert(m && !api && !io_event && the_pipe[0] == -1 && the_pipe[1] == -1 && !installed);
#else /* HAVE_SIGXCPU */
-struct pa_mainloop_api;
-
-int pa_cpu_limit_init(struct pa_mainloop_api *m) {
+int pa_cpu_limit_init(PA_GCC_UNUSED pa_mainloop_api *m) {
return 0;
}
* CPU time. This is build around setrlimit() and SIGXCPU. It is handy
* in case of using SCHED_FIFO which may freeze the whole machine */
-int pa_cpu_limit_init(struct pa_mainloop_api *m);
+int pa_cpu_limit_init(pa_mainloop_api *m);
void pa_cpu_limit_done(void);
#endif
#define ENV_CONFIG_FILE "POLYP_CONFIG"
#define ENV_DL_SEARCH_PATH "POLYP_DLPATH"
-static const struct pa_daemon_conf default_conf = {
+static const pa_daemon_conf default_conf = {
.cmd = PA_CMD_DAEMON,
.daemonize = 0,
.fail = 1,
.use_pid_file = 1
};
-struct pa_daemon_conf* pa_daemon_conf_new(void) {
+pa_daemon_conf* pa_daemon_conf_new(void) {
FILE *f;
- struct pa_daemon_conf *c = pa_xmemdup(&default_conf, sizeof(default_conf));
+ pa_daemon_conf *c = pa_xmemdup(&default_conf, sizeof(default_conf));
if ((f = pa_open_config_file(DEFAULT_SCRIPT_FILE, DEFAULT_SCRIPT_FILE_USER, ENV_SCRIPT_FILE, &c->default_script_file)))
fclose(f);
return c;
}
-void pa_daemon_conf_free(struct pa_daemon_conf *c) {
+void pa_daemon_conf_free(pa_daemon_conf *c) {
assert(c);
pa_xfree(c->script_commands);
pa_xfree(c->dl_search_path);
pa_xfree(c);
}
-int pa_daemon_conf_set_log_target(struct pa_daemon_conf *c, const char *string) {
+int pa_daemon_conf_set_log_target(pa_daemon_conf *c, const char *string) {
assert(c && string);
if (!strcmp(string, "auto"))
return 0;
}
-int pa_daemon_conf_set_log_level(struct pa_daemon_conf *c, const char *string) {
+int pa_daemon_conf_set_log_level(pa_daemon_conf *c, const char *string) {
uint32_t u;
assert(c && string);
if (u >= PA_LOG_LEVEL_MAX)
return -1;
- c->log_level = (enum pa_log_level) u;
+ c->log_level = (pa_log_level) u;
} else if (pa_startswith(string, "debug"))
c->log_level = PA_LOG_DEBUG;
else if (pa_startswith(string, "info"))
return 0;
}
-int pa_daemon_conf_set_resample_method(struct pa_daemon_conf *c, const char *string) {
+int pa_daemon_conf_set_resample_method(pa_daemon_conf *c, const char *string) {
int m;
assert(c && string);
return 0;
}
-static int parse_log_target(const char *filename, unsigned line, const char *lvalue, const char *rvalue, void *data, void *userdata) {
- struct pa_daemon_conf *c = data;
+static int parse_log_target(const char *filename, unsigned line, const char *lvalue, const char *rvalue, void *data, PA_GCC_UNUSED void *userdata) {
+ pa_daemon_conf *c = data;
assert(filename && lvalue && rvalue && data);
if (pa_daemon_conf_set_log_target(c, rvalue) < 0) {
return 0;
}
-static int parse_log_level(const char *filename, unsigned line, const char *lvalue, const char *rvalue, void *data, void *userdata) {
- struct pa_daemon_conf *c = data;
+static int parse_log_level(const char *filename, unsigned line, const char *lvalue, const char *rvalue, void *data, PA_GCC_UNUSED void *userdata) {
+ pa_daemon_conf *c = data;
assert(filename && lvalue && rvalue && data);
if (pa_daemon_conf_set_log_level(c, rvalue) < 0) {
return 0;
}
-static int parse_resample_method(const char *filename, unsigned line, const char *lvalue, const char *rvalue, void *data, void *userdata) {
- struct pa_daemon_conf *c = data;
+static int parse_resample_method(const char *filename, unsigned line, const char *lvalue, const char *rvalue, void *data, PA_GCC_UNUSED void *userdata) {
+ pa_daemon_conf *c = data;
assert(filename && lvalue && rvalue && data);
if (pa_daemon_conf_set_resample_method(c, rvalue) < 0) {
return 0;
}
-int pa_daemon_conf_load(struct pa_daemon_conf *c, const char *filename) {
+int pa_daemon_conf_load(pa_daemon_conf *c, const char *filename) {
int r = -1;
FILE *f = NULL;
- struct pa_config_item table[] = {
+ pa_config_item table[] = {
{ "daemonize", pa_config_parse_bool, NULL },
{ "fail", pa_config_parse_bool, NULL },
{ "high-priority", pa_config_parse_bool, NULL },
return r;
}
-int pa_daemon_conf_env(struct pa_daemon_conf *c) {
+int pa_daemon_conf_env(pa_daemon_conf *c) {
char *e;
if ((e = getenv(ENV_DL_SEARCH_PATH))) {
[PA_LOG_ERROR] = "error"
};
-char *pa_daemon_conf_dump(struct pa_daemon_conf *c) {
- struct pa_strbuf *s = pa_strbuf_new();
+char *pa_daemon_conf_dump(pa_daemon_conf *c) {
+ pa_strbuf *s = pa_strbuf_new();
if (c->config_file)
pa_strbuf_printf(s, "### Read from configuration file: %s ###\n", c->config_file);
#include "log.h"
/* The actual command to execute */
-enum pa_daemon_conf_cmd {
+typedef enum pa_daemon_conf_cmd {
PA_CMD_DAEMON, /* the default */
PA_CMD_HELP,
PA_CMD_VERSION,
PA_CMD_DUMP_MODULES,
PA_CMD_KILL,
PA_CMD_CHECK
-};
+} pa_daemon_conf_cmd;
/* A structure containing configuration data for the Polypaudio server . */
-struct pa_daemon_conf {
- enum pa_daemon_conf_cmd cmd;
+typedef struct pa_daemon_conf {
+ pa_daemon_conf_cmd cmd;
int daemonize,
fail,
high_priority,
auto_log_target,
use_pid_file;
char *script_commands, *dl_search_path, *default_script_file;
- enum pa_log_target log_target;
- enum pa_log_level log_level;
+ pa_log_target log_target;
+ pa_log_level log_level;
int resample_method;
char *config_file;
-};
+} pa_daemon_conf;
/* Allocate a new structure and fill it with sane defaults */
-struct pa_daemon_conf* pa_daemon_conf_new(void);
-void pa_daemon_conf_free(struct pa_daemon_conf*c);
+pa_daemon_conf* pa_daemon_conf_new(void);
+void pa_daemon_conf_free(pa_daemon_conf*c);
/* Load configuration data from the specified file overwriting the
* current settings in *c. If filename is NULL load the default daemon
* configuration file */
-int pa_daemon_conf_load(struct pa_daemon_conf *c, const char *filename);
+int pa_daemon_conf_load(pa_daemon_conf *c, const char *filename);
/* Pretty print the current configuration data of the daemon. The
* returned string has to be freed manually. The output of this
* function may be parsed with pa_daemon_conf_load(). */
-char *pa_daemon_conf_dump(struct pa_daemon_conf *c);
+char *pa_daemon_conf_dump(pa_daemon_conf *c);
/* Load the configuration data from the process' environment
* overwriting the current settings in *c. */
-int pa_daemon_conf_env(struct pa_daemon_conf *c);
+int pa_daemon_conf_env(pa_daemon_conf *c);
/* Set these configuration variables in the structure by passing a string */
-int pa_daemon_conf_set_log_target(struct pa_daemon_conf *c, const char *string);
-int pa_daemon_conf_set_log_level(struct pa_daemon_conf *c, const char *string);
-int pa_daemon_conf_set_resample_method(struct pa_daemon_conf *c, const char *string);
+int pa_daemon_conf_set_log_target(pa_daemon_conf *c, const char *string);
+int pa_daemon_conf_set_log_level(pa_daemon_conf *c, const char *string);
+int pa_daemon_conf_set_resample_method(pa_daemon_conf *c, const char *string);
#endif
#define PREFIX "module-"
-static void short_info(const char *name, const char *path, struct pa_modinfo *i) {
+static void short_info(const char *name, PA_GCC_UNUSED const char *path, pa_modinfo *i) {
assert(name && i);
printf("%-40s%s\n", name, i->description ? i->description : "n/a");
}
-static void long_info(const char *name, const char *path, struct pa_modinfo *i) {
+static void long_info(const char *name, const char *path, pa_modinfo *i) {
static int nl = 0;
assert(name && i);
printf("Path: %s\n", path);
}
-static void show_info(const char *name, const char *path, void (*info)(const char *name, const char *path, struct pa_modinfo*i)) {
- struct pa_modinfo *i;
+static void show_info(const char *name, const char *path, void (*info)(const char *name, const char *path, pa_modinfo*i)) {
+ pa_modinfo *i;
if ((i = pa_modinfo_get_by_name(path ? path : name))) {
info(name, path, i);
static int callback(const char *path, lt_ptr data) {
const char *e;
- struct pa_daemon_conf *c = (data);
+ pa_daemon_conf *c = (data);
e = pa_path_get_filename(path);
return 0;
}
-void pa_dump_modules(struct pa_daemon_conf *c, int argc, char * const argv[]) {
+void pa_dump_modules(pa_daemon_conf *c, int argc, char * const argv[]) {
if (argc > 0) {
int i;
for (i = 0; i < argc; i++)
/* Dump all available modules to STDOUT. If argc > 0 print information
* about the modules specified in argv[] instead. */
-void pa_dump_modules(struct pa_daemon_conf *c, int argc, char * const argv[]);
+void pa_dump_modules(pa_daemon_conf *c, int argc, char * const argv[]);
#endif
unsigned n_allocated, n_entries;
};
-struct pa_dynarray* pa_dynarray_new(void) {
- struct pa_dynarray *a;
- a = pa_xmalloc(sizeof(struct pa_dynarray));
+pa_dynarray* pa_dynarray_new(void) {
+ pa_dynarray *a;
+ a = pa_xnew(pa_dynarray, 1);
a->data = NULL;
a->n_entries = 0;
a->n_allocated = 0;
return a;
}
-void pa_dynarray_free(struct pa_dynarray* a, void (*func)(void *p, void *userdata), void *userdata) {
+void pa_dynarray_free(pa_dynarray* a, void (*func)(void *p, void *userdata), void *userdata) {
unsigned i;
assert(a);
pa_xfree(a);
}
-void pa_dynarray_put(struct pa_dynarray*a, unsigned i, void *p) {
+void pa_dynarray_put(pa_dynarray*a, unsigned i, void *p) {
assert(a);
if (i >= a->n_allocated) {
a->n_entries = i+1;
}
-unsigned pa_dynarray_append(struct pa_dynarray*a, void *p) {
+unsigned pa_dynarray_append(pa_dynarray*a, void *p) {
unsigned i = a->n_entries;
pa_dynarray_put(a, i, p);
return i;
}
-void *pa_dynarray_get(struct pa_dynarray*a, unsigned i) {
+void *pa_dynarray_get(pa_dynarray*a, unsigned i) {
assert(a);
if (i >= a->n_allocated)
return NULL;
return a->data[i];
}
-unsigned pa_dynarray_ncontents(struct pa_dynarray*a) {
+unsigned pa_dynarray_size(pa_dynarray*a) {
assert(a);
return a->n_entries;
}
USA.
***/
-struct pa_dynarray;
+typedef struct pa_dynarray pa_dynarray;
/* Implementation of a simple dynamically sized array. The array
* expands if required, but doesn't shrink if possible. Memory
* management of the array's entries is the user's job. */
-struct pa_dynarray* pa_dynarray_new(void);
+pa_dynarray* pa_dynarray_new(void);
/* Free the array calling the specified function for every entry in
* the array. The function may be NULL. */
-void pa_dynarray_free(struct pa_dynarray* a, void (*func)(void *p, void *userdata), void *userdata);
+void pa_dynarray_free(pa_dynarray* a, void (*func)(void *p, void *userdata), void *userdata);
/* Store p at position i in the array */
-void pa_dynarray_put(struct pa_dynarray*a, unsigned i, void *p);
+void pa_dynarray_put(pa_dynarray*a, unsigned i, void *p);
/* Store p a the first free position in the array. Returns the index
* of that entry. If entries are removed from the array their position
* are not filled any more by this function. */
-unsigned pa_dynarray_append(struct pa_dynarray*a, void *p);
+unsigned pa_dynarray_append(pa_dynarray*a, void *p);
-void *pa_dynarray_get(struct pa_dynarray*a, unsigned i);
+void *pa_dynarray_get(pa_dynarray*a, unsigned i);
-unsigned pa_dynarray_ncontents(struct pa_dynarray*a);
+unsigned pa_dynarray_size(pa_dynarray*a);
#endif
-#ifndef foogccprintfhfoo
-#define foogccprintfhfoo
+#ifndef foogccmacrohfoo
+#define foogccmacrohfoo
/* $Id$ */
USA.
***/
-/* If we're in GNU C, use some magic for detecting invalid format strings */
-
#ifdef __GNUC__
#define PA_GCC_PRINTF_ATTR(a,b) __attribute__ ((format (printf, a, b)))
#else
+/** If we're in GNU C, use some magic for detecting invalid format strings */
#define PA_GCC_PRINTF_ATTR(a,b)
#endif
+#if defined(__GNUC__) && (__GNUC__ >= 4)
+#define PA_GCC_SENTINEL __attribute__ ((sentinel))
+#else
+/** Macro for usage of GCC's sentinel compilation warnings */
+#define PA_GCC_SENTINEL
+#endif
+
+#ifdef __GNUC__
+#define PA_GCC_NORETURN __attribute__((noreturn))
+#else
+/** Macro for no-return functions */
+#define PA_GCC_NORETURN
+#endif
+
+#ifdef __GNUC__
+#define PA_GCC_UNUSED __attribute__ ((unused))
+#else
+/** Macro for not used parameter */
+#define PA_GCC_UNUSED
+#endif
+
#endif
#include "glib-mainloop.h"
#include "idxset.h"
#include "xmalloc.h"
+#include "glib.h"
+#include "util.h"
-struct pa_io_event {
- struct pa_glib_mainloop *mainloop;
+struct pa_io_event {
+ pa_glib_mainloop *mainloop;
int dead;
GIOChannel *io_channel;
GSource *source;
GIOCondition io_condition;
int fd;
- void (*callback) (struct pa_mainloop_api*m, struct pa_io_event *e, int fd, enum pa_io_event_flags f, void *userdata);
+ void (*callback) (pa_mainloop_api*m, pa_io_event *e, int fd, pa_io_event_flags f, void *userdata);
void *userdata;
- void (*destroy_callback) (struct pa_mainloop_api *m, struct pa_io_event*e, void *userdata);
- struct pa_io_event *next, *prev;
+ void (*destroy_callback) (pa_mainloop_api *m, pa_io_event*e, void *userdata);
+ pa_io_event *next, *prev;
};
struct pa_time_event {
- struct pa_glib_mainloop *mainloop;
+ pa_glib_mainloop *mainloop;
int dead;
GSource *source;
struct timeval timeval;
- void (*callback) (struct pa_mainloop_api*m, struct pa_time_event *e, const struct timeval *tv, void *userdata);
+ void (*callback) (pa_mainloop_api*m, pa_time_event *e, const struct timeval *tv, void *userdata);
void *userdata;
- void (*destroy_callback) (struct pa_mainloop_api *m, struct pa_time_event*e, void *userdata);
- struct pa_time_event *next, *prev;
+ void (*destroy_callback) (pa_mainloop_api *m, pa_time_event*e, void *userdata);
+ pa_time_event *next, *prev;
};
struct pa_defer_event {
- struct pa_glib_mainloop *mainloop;
+ pa_glib_mainloop *mainloop;
int dead;
GSource *source;
- void (*callback) (struct pa_mainloop_api*m, struct pa_defer_event *e, void *userdata);
+ void (*callback) (pa_mainloop_api*m, pa_defer_event *e, void *userdata);
void *userdata;
- void (*destroy_callback) (struct pa_mainloop_api *m, struct pa_defer_event*e, void *userdata);
- struct pa_defer_event *next, *prev;
+ void (*destroy_callback) (pa_mainloop_api *m, pa_defer_event*e, void *userdata);
+ pa_defer_event *next, *prev;
};
struct pa_glib_mainloop {
GMainContext *glib_main_context;
- struct pa_mainloop_api api;
+ pa_mainloop_api api;
GSource *cleanup_source;
- struct pa_io_event *io_events, *dead_io_events;
- struct pa_time_event *time_events, *dead_time_events;
- struct pa_defer_event *defer_events, *dead_defer_events;
+ pa_io_event *io_events, *dead_io_events;
+ pa_time_event *time_events, *dead_time_events;
+ pa_defer_event *defer_events, *dead_defer_events;
};
-static void schedule_free_dead_events(struct pa_glib_mainloop *g);
+static void schedule_free_dead_events(pa_glib_mainloop *g);
-static void glib_io_enable(struct pa_io_event*e, enum pa_io_event_flags f);
+static void glib_io_enable(pa_io_event*e, pa_io_event_flags f);
-static struct pa_io_event* glib_io_new(struct pa_mainloop_api*m, int fd, enum pa_io_event_flags f, void (*callback) (struct pa_mainloop_api*m, struct pa_io_event*e, int fd, enum pa_io_event_flags f, void *userdata), void *userdata) {
- struct pa_io_event *e;
- struct pa_glib_mainloop *g;
+static pa_io_event* glib_io_new(pa_mainloop_api*m, int fd, pa_io_event_flags f, void (*callback) (pa_mainloop_api*m, pa_io_event*e, int fd, pa_io_event_flags f, void *userdata), void *userdata) {
+ pa_io_event *e;
+ pa_glib_mainloop *g;
assert(m && m->userdata && fd >= 0 && callback);
g = m->userdata;
- e = pa_xmalloc(sizeof(struct pa_io_event));
+ e = pa_xmalloc(sizeof(pa_io_event));
e->mainloop = m->userdata;
e->dead = 0;
e->fd = fd;
/* The callback GLIB calls whenever an IO condition is met */
static gboolean io_cb(GIOChannel *source, GIOCondition condition, gpointer data) {
- struct pa_io_event *e = data;
- enum pa_io_event_flags f;
+ pa_io_event *e = data;
+ pa_io_event_flags f;
assert(source && e && e->io_channel == source);
f = (condition & G_IO_IN ? PA_IO_EVENT_INPUT : 0) |
return TRUE;
}
-static void glib_io_enable(struct pa_io_event*e, enum pa_io_event_flags f) {
+static void glib_io_enable(pa_io_event*e, pa_io_event_flags f) {
GIOCondition c;
assert(e && !e->dead);
e->io_condition = c;
}
-static void glib_io_free(struct pa_io_event*e) {
+static void glib_io_free(pa_io_event*e) {
assert(e && !e->dead);
if (e->source) {
schedule_free_dead_events(e->mainloop);
}
-static void glib_io_set_destroy(struct pa_io_event*e, void (*callback)(struct pa_mainloop_api*m, struct pa_io_event *e, void *userdata)) {
+static void glib_io_set_destroy(pa_io_event*e, void (*callback)(pa_mainloop_api*m, pa_io_event *e, void *userdata)) {
assert(e);
e->destroy_callback = callback;
}
/* Time sources */
-static void glib_time_restart(struct pa_time_event*e, const struct timeval *tv);
+static void glib_time_restart(pa_time_event*e, const struct timeval *tv);
-static struct pa_time_event* glib_time_new(struct pa_mainloop_api*m, const struct timeval *tv, void (*callback) (struct pa_mainloop_api*m, struct pa_time_event*e, const struct timeval *tv, void *userdata), void *userdata) {
- struct pa_glib_mainloop *g;
- struct pa_time_event *e;
+static pa_time_event* glib_time_new(pa_mainloop_api*m, const struct timeval *tv, void (*callback) (pa_mainloop_api*m, pa_time_event*e, const struct timeval *tv, void *userdata), void *userdata) {
+ pa_glib_mainloop *g;
+ pa_time_event *e;
assert(m && m->userdata && tv && callback);
g = m->userdata;
- e = pa_xmalloc(sizeof(struct pa_time_event));
+ e = pa_xmalloc(sizeof(pa_time_event));
e->mainloop = g;
e->dead = 0;
e->callback = callback;
}
static gboolean time_cb(gpointer data) {
- struct pa_time_event* e = data;
+ pa_time_event* e = data;
assert(e && e->mainloop && e->source);
g_source_unref(e->source);
return FALSE;
}
-static void glib_time_restart(struct pa_time_event*e, const struct timeval *tv) {
+static void glib_time_restart(pa_time_event*e, const struct timeval *tv) {
struct timeval now;
assert(e && e->mainloop && !e->dead);
e->source = NULL;
}
-static void glib_time_free(struct pa_time_event *e) {
+static void glib_time_free(pa_time_event *e) {
assert(e && e->mainloop && !e->dead);
if (e->source) {
schedule_free_dead_events(e->mainloop);
}
-static void glib_time_set_destroy(struct pa_time_event *e, void (*callback)(struct pa_mainloop_api*m, struct pa_time_event*e, void *userdata)) {
+static void glib_time_set_destroy(pa_time_event *e, void (*callback)(pa_mainloop_api*m, pa_time_event*e, void *userdata)) {
assert(e);
e->destroy_callback = callback;
}
/* Deferred sources */
-static void glib_defer_enable(struct pa_defer_event *e, int b);
+static void glib_defer_enable(pa_defer_event *e, int b);
-static struct pa_defer_event* glib_defer_new(struct pa_mainloop_api*m, void (*callback) (struct pa_mainloop_api*m, struct pa_defer_event *e, void *userdata), void *userdata) {
- struct pa_defer_event *e;
- struct pa_glib_mainloop *g;
+static pa_defer_event* glib_defer_new(pa_mainloop_api*m, void (*callback) (pa_mainloop_api*m, pa_defer_event *e, void *userdata), void *userdata) {
+ pa_defer_event *e;
+ pa_glib_mainloop *g;
assert(m && m->userdata && callback);
g = m->userdata;
- e = pa_xmalloc(sizeof(struct pa_defer_event));
+ e = pa_xmalloc(sizeof(pa_defer_event));
e->mainloop = g;
e->dead = 0;
e->callback = callback;
}
static gboolean idle_cb(gpointer data) {
- struct pa_defer_event* e = data;
+ pa_defer_event* e = data;
assert(e && e->mainloop && e->source);
e->callback(&e->mainloop->api, e, e->userdata);
return TRUE;
}
-static void glib_defer_enable(struct pa_defer_event *e, int b) {
+static void glib_defer_enable(pa_defer_event *e, int b) {
assert(e && e->mainloop);
if (e->source && !b) {
}
}
-static void glib_defer_free(struct pa_defer_event *e) {
+static void glib_defer_free(pa_defer_event *e) {
assert(e && e->mainloop && !e->dead);
if (e->source) {
schedule_free_dead_events(e->mainloop);
}
-static void glib_defer_set_destroy(struct pa_defer_event *e, void (*callback)(struct pa_mainloop_api *m, struct pa_defer_event *e, void *userdata)) {
+static void glib_defer_set_destroy(pa_defer_event *e, void (*callback)(pa_mainloop_api *m, pa_defer_event *e, void *userdata)) {
assert(e);
e->destroy_callback = callback;
}
/* quit() */
-static void glib_quit(struct pa_mainloop_api*a, int retval) {
- struct pa_glib_mainloop *g;
+static void glib_quit(pa_mainloop_api*a, PA_GCC_UNUSED int retval) {
+ pa_glib_mainloop *g;
assert(a && a->userdata);
g = a->userdata;
/* NOOP */
}
-static const struct pa_mainloop_api vtable = {
+static const pa_mainloop_api vtable = {
.userdata = NULL,
.io_new = glib_io_new,
.quit = glib_quit,
};
-struct pa_glib_mainloop *pa_glib_mainloop_new(GMainContext *c) {
- struct pa_glib_mainloop *g;
+pa_glib_mainloop *pa_glib_mainloop_new(GMainContext *c) {
+ pa_glib_mainloop *g;
- g = pa_xmalloc(sizeof(struct pa_glib_mainloop));
+ g = pa_xmalloc(sizeof(pa_glib_mainloop));
if (c) {
g->glib_main_context = c;
g_main_context_ref(c);
return g;
}
-static void free_io_events(struct pa_io_event *e) {
+static void free_io_events(pa_io_event *e) {
while (e) {
- struct pa_io_event *r = e;
+ pa_io_event *r = e;
e = r->next;
if (r->source) {
}
}
-static void free_time_events(struct pa_time_event *e) {
+static void free_time_events(pa_time_event *e) {
while (e) {
- struct pa_time_event *r = e;
+ pa_time_event *r = e;
e = r->next;
if (r->source) {
}
}
-static void free_defer_events(struct pa_defer_event *e) {
+static void free_defer_events(pa_defer_event *e) {
while (e) {
- struct pa_defer_event *r = e;
+ pa_defer_event *r = e;
e = r->next;
if (r->source) {
}
}
-void pa_glib_mainloop_free(struct pa_glib_mainloop* g) {
+void pa_glib_mainloop_free(pa_glib_mainloop* g) {
assert(g);
free_io_events(g->io_events);
pa_xfree(g);
}
-struct pa_mainloop_api* pa_glib_mainloop_get_api(struct pa_glib_mainloop *g) {
+pa_mainloop_api* pa_glib_mainloop_get_api(pa_glib_mainloop *g) {
assert(g);
return &g->api;
}
static gboolean free_dead_events(gpointer p) {
- struct pa_glib_mainloop *g = p;
+ pa_glib_mainloop *g = p;
assert(g);
free_io_events(g->dead_io_events);
return FALSE;
}
-static void schedule_free_dead_events(struct pa_glib_mainloop *g) {
+static void schedule_free_dead_events(pa_glib_mainloop *g) {
assert(g && g->glib_main_context);
if (g->cleanup_source)
PA_C_DECL_BEGIN
-/** \struct pa_glib_mainloop
+/** \pa_glib_mainloop
* An opaque GLIB main loop object */
-struct pa_glib_mainloop;
+typedef struct pa_glib_mainloop pa_glib_mainloop;
/** Create a new GLIB main loop object for the specified GLIB main loop context. If c is NULL the default context is used. */
#if GLIB_MAJOR_VERSION >= 2
-struct pa_glib_mainloop *pa_glib_mainloop_new(GMainContext *c);
+pa_glib_mainloop *pa_glib_mainloop_new(GMainContext *c);
#else
-struct pa_glib_mainloop *pa_glib_mainloop_new(void);
+pa_glib_mainloop *pa_glib_mainloop_new(void);
#endif
/** Free the GLIB main loop object */
-void pa_glib_mainloop_free(struct pa_glib_mainloop* g);
+void pa_glib_mainloop_free(pa_glib_mainloop* g);
/** Return the abstract main loop API vtable for the GLIB main loop object */
-struct pa_mainloop_api* pa_glib_mainloop_get_api(struct pa_glib_mainloop *g);
+pa_mainloop_api* pa_glib_mainloop_get_api(pa_glib_mainloop *g);
PA_C_DECL_END
#include "glib-mainloop.h"
#include "idxset.h"
#include "xmalloc.h"
+#include "util.h"
/* A mainloop implementation based on GLIB 1.2 */
struct pa_io_event {
- struct pa_glib_mainloop *mainloop;
+ pa_glib_mainloop *mainloop;
int dead;
GIOChannel *io_channel;
guint source;
GIOCondition io_condition;
int fd;
- void (*callback) (struct pa_mainloop_api*m, struct pa_io_event *e, int fd, enum pa_io_event_flags f, void *userdata);
+ void (*callback) (pa_mainloop_api*m, pa_io_event *e, int fd, pa_io_event_flags f, void *userdata);
void *userdata;
- void (*destroy_callback) (struct pa_mainloop_api *m, struct pa_io_event*e, void *userdata);
- struct pa_io_event *next, *prev;
+ void (*destroy_callback) (pa_mainloop_api *m, pa_io_event*e, void *userdata);
+ pa_io_event *next, *prev;
};
struct pa_time_event {
- struct pa_glib_mainloop *mainloop;
+ pa_glib_mainloop *mainloop;
int dead;
guint source;
struct timeval timeval;
- void (*callback) (struct pa_mainloop_api*m, struct pa_time_event *e, const struct timeval *tv, void *userdata);
+ void (*callback) (pa_mainloop_api*m, pa_time_event *e, const struct timeval *tv, void *userdata);
void *userdata;
- void (*destroy_callback) (struct pa_mainloop_api *m, struct pa_time_event*e, void *userdata);
- struct pa_time_event *next, *prev;
+ void (*destroy_callback) (pa_mainloop_api *m, pa_time_event*e, void *userdata);
+ pa_time_event *next, *prev;
};
struct pa_defer_event {
- struct pa_glib_mainloop *mainloop;
+ pa_glib_mainloop *mainloop;
int dead;
guint source;
- void (*callback) (struct pa_mainloop_api*m, struct pa_defer_event *e, void *userdata);
+ void (*callback) (pa_mainloop_api*m, pa_defer_event *e, void *userdata);
void *userdata;
- void (*destroy_callback) (struct pa_mainloop_api *m, struct pa_defer_event*e, void *userdata);
- struct pa_defer_event *next, *prev;
+ void (*destroy_callback) (pa_mainloop_api *m, pa_defer_event*e, void *userdata);
+ pa_defer_event *next, *prev;
};
struct pa_glib_mainloop {
- struct pa_mainloop_api api;
+ pa_mainloop_api api;
guint cleanup_source;
- struct pa_io_event *io_events, *dead_io_events;
- struct pa_time_event *time_events, *dead_time_events;
- struct pa_defer_event *defer_events, *dead_defer_events;
+ pa_io_event *io_events, *dead_io_events;
+ pa_time_event *time_events, *dead_time_events;
+ pa_defer_event *defer_events, *dead_defer_events;
};
-static void schedule_free_dead_events(struct pa_glib_mainloop *g);
+static void schedule_free_dead_events(pa_glib_mainloop *g);
-static void glib_io_enable(struct pa_io_event*e, enum pa_io_event_flags f);
+static void glib_io_enable(pa_io_event*e, pa_io_event_flags f);
-static struct pa_io_event* glib_io_new(struct pa_mainloop_api*m, int fd, enum pa_io_event_flags f, void (*callback) (struct pa_mainloop_api*m, struct pa_io_event*e, int fd, enum pa_io_event_flags f, void *userdata), void *userdata) {
- struct pa_io_event *e;
- struct pa_glib_mainloop *g;
+static pa_io_event* glib_io_new(pa_mainloop_api*m, int fd, pa_io_event_flags f, void (*callback) (pa_mainloop_api*m, pa_io_event*e, int fd, pa_io_event_flags f, void *userdata), void *userdata) {
+ pa_io_event *e;
+ pa_glib_mainloop *g;
assert(m && m->userdata && fd >= 0 && callback);
g = m->userdata;
- e = pa_xmalloc(sizeof(struct pa_io_event));
+ e = pa_xmalloc(sizeof(pa_io_event));
e->mainloop = m->userdata;
e->dead = 0;
e->fd = fd;
}
static gboolean io_cb(GIOChannel *source, GIOCondition condition, gpointer data) {
- struct pa_io_event *e = data;
- enum pa_io_event_flags f;
+ pa_io_event *e = data;
+ pa_io_event_flags f;
assert(source && e && e->io_channel == source);
f = (condition & G_IO_IN ? PA_IO_EVENT_INPUT : 0) |
return TRUE;
}
-static void glib_io_enable(struct pa_io_event*e, enum pa_io_event_flags f) {
+static void glib_io_enable(pa_io_event*e, pa_io_event_flags f) {
GIOCondition c;
assert(e && !e->dead);
e->io_condition = c;
}
-static void glib_io_free(struct pa_io_event*e) {
+static void glib_io_free(pa_io_event*e) {
assert(e && !e->dead);
if (e->source != (guint) -1) {
schedule_free_dead_events(e->mainloop);
}
-static void glib_io_set_destroy(struct pa_io_event*e, void (*callback)(struct pa_mainloop_api*m, struct pa_io_event *e, void *userdata)) {
+static void glib_io_set_destroy(pa_io_event*e, void (*callback)(pa_mainloop_api*m, pa_io_event *e, void *userdata)) {
assert(e);
e->destroy_callback = callback;
}
/* Time sources */
-static void glib_time_restart(struct pa_time_event*e, const struct timeval *tv);
+static void glib_time_restart(pa_time_event*e, const struct timeval *tv);
-static struct pa_time_event* glib_time_new(struct pa_mainloop_api*m, const struct timeval *tv, void (*callback) (struct pa_mainloop_api*m, struct pa_time_event*e, const struct timeval *tv, void *userdata), void *userdata) {
- struct pa_glib_mainloop *g;
- struct pa_time_event *e;
+static pa_time_event* glib_time_new(pa_mainloop_api*m, const struct timeval *tv, void (*callback) (pa_mainloop_api*m, pa_time_event*e, const struct timeval *tv, void *userdata), void *userdata) {
+ pa_glib_mainloop *g;
+ pa_time_event *e;
assert(m && m->userdata && tv && callback);
g = m->userdata;
- e = pa_xmalloc(sizeof(struct pa_time_event));
+ e = pa_xmalloc(sizeof(pa_time_event));
e->mainloop = g;
e->dead = 0;
e->callback = callback;
}
static gboolean time_cb(gpointer data) {
- struct pa_time_event* e = data;
+ pa_time_event* e = data;
assert(e && e->mainloop && e->source != (guint) -1);
g_source_remove(e->source);
return FALSE;
}
-static void glib_time_restart(struct pa_time_event*e, const struct timeval *tv) {
+static void glib_time_restart(pa_time_event*e, const struct timeval *tv) {
struct timeval now;
assert(e && e->mainloop && !e->dead);
e->source = (guint) -1;
}
-static void glib_time_free(struct pa_time_event *e) {
+static void glib_time_free(pa_time_event *e) {
assert(e && e->mainloop && !e->dead);
if (e->source != (guint) -1) {
schedule_free_dead_events(e->mainloop);
}
-static void glib_time_set_destroy(struct pa_time_event *e, void (*callback)(struct pa_mainloop_api*m, struct pa_time_event*e, void *userdata)) {
+static void glib_time_set_destroy(pa_time_event *e, void (*callback)(pa_mainloop_api*m, pa_time_event*e, void *userdata)) {
assert(e);
e->destroy_callback = callback;
}
/* Deferred sources */
-static void glib_defer_enable(struct pa_defer_event *e, int b);
+static void glib_defer_enable(pa_defer_event *e, int b);
-static struct pa_defer_event* glib_defer_new(struct pa_mainloop_api*m, void (*callback) (struct pa_mainloop_api*m, struct pa_defer_event *e, void *userdata), void *userdata) {
- struct pa_defer_event *e;
- struct pa_glib_mainloop *g;
+static pa_defer_event* glib_defer_new(pa_mainloop_api*m, void (*callback) (pa_mainloop_api*m, pa_defer_event *e, void *userdata), void *userdata) {
+ pa_defer_event *e;
+ pa_glib_mainloop *g;
assert(m && m->userdata && callback);
g = m->userdata;
- e = pa_xmalloc(sizeof(struct pa_defer_event));
+ e = pa_xmalloc(sizeof(pa_defer_event));
e->mainloop = g;
e->dead = 0;
e->callback = callback;
}
static gboolean idle_cb(gpointer data) {
- struct pa_defer_event* e = data;
+ pa_defer_event* e = data;
assert(e && e->mainloop && e->source != (guint) -1);
e->callback(&e->mainloop->api, e, e->userdata);
return TRUE;
}
-static void glib_defer_enable(struct pa_defer_event *e, int b) {
+static void glib_defer_enable(pa_defer_event *e, int b) {
assert(e && e->mainloop);
if (e->source != (guint) -1 && !b) {
}
}
-static void glib_defer_free(struct pa_defer_event *e) {
+static void glib_defer_free(pa_defer_event *e) {
assert(e && e->mainloop && !e->dead);
if (e->source != (guint) -1) {
schedule_free_dead_events(e->mainloop);
}
-static void glib_defer_set_destroy(struct pa_defer_event *e, void (*callback)(struct pa_mainloop_api *m, struct pa_defer_event *e, void *userdata)) {
+static void glib_defer_set_destroy(pa_defer_event *e, void (*callback)(pa_mainloop_api *m, pa_defer_event *e, void *userdata)) {
assert(e);
e->destroy_callback = callback;
}
/* quit() */
-static void glib_quit(struct pa_mainloop_api*a, int retval) {
- struct pa_glib_mainloop *g;
+static void glib_quit(pa_mainloop_api*a, PA_GCC_UNUSED int retval) {
+ pa_glib_mainloop *g;
assert(a && a->userdata);
g = a->userdata;
/* NOOP */
}
-static const struct pa_mainloop_api vtable = {
+static const pa_mainloop_api vtable = {
.userdata = NULL,
.io_new = glib_io_new,
.quit = glib_quit,
};
-struct pa_glib_mainloop *pa_glib_mainloop_new(void) {
- struct pa_glib_mainloop *g;
+pa_glib_mainloop *pa_glib_mainloop_new(void) {
+ pa_glib_mainloop *g;
- g = pa_xmalloc(sizeof(struct pa_glib_mainloop));
+ g = pa_xmalloc(sizeof(pa_glib_mainloop));
g->api = vtable;
g->api.userdata = g;
return g;
}
-static void free_io_events(struct pa_io_event *e) {
+static void free_io_events(pa_io_event *e) {
while (e) {
- struct pa_io_event *r = e;
+ pa_io_event *r = e;
e = r->next;
if (r->source != (guint) -1)
}
}
-static void free_time_events(struct pa_time_event *e) {
+static void free_time_events(pa_time_event *e) {
while (e) {
- struct pa_time_event *r = e;
+ pa_time_event *r = e;
e = r->next;
if (r->source != (guint) -1)
}
}
-static void free_defer_events(struct pa_defer_event *e) {
+static void free_defer_events(pa_defer_event *e) {
while (e) {
- struct pa_defer_event *r = e;
+ pa_defer_event *r = e;
e = r->next;
if (r->source != (guint) -1)
}
}
-void pa_glib_mainloop_free(struct pa_glib_mainloop* g) {
+void pa_glib_mainloop_free(pa_glib_mainloop* g) {
assert(g);
free_io_events(g->io_events);
pa_xfree(g);
}
-struct pa_mainloop_api* pa_glib_mainloop_get_api(struct pa_glib_mainloop *g) {
+pa_mainloop_api* pa_glib_mainloop_get_api(pa_glib_mainloop *g) {
assert(g);
return &g->api;
}
static gboolean free_dead_events(gpointer p) {
- struct pa_glib_mainloop *g = p;
+ pa_glib_mainloop *g = p;
assert(g);
free_io_events(g->dead_io_events);
return FALSE;
}
-static void schedule_free_dead_events(struct pa_glib_mainloop *g) {
+static void schedule_free_dead_events(pa_glib_mainloop *g) {
assert(g);
if (g->cleanup_source != (guint) -1)
int (*compare_func) (const void*a, const void*b);
};
-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 = pa_xmalloc(sizeof(struct pa_hashmap));
+pa_hashmap *pa_hashmap_new(unsigned (*hash_func) (const void *p), int (*compare_func) (const void*a, const void*b)) {
+ pa_hashmap *h;
+ h = pa_xmalloc(sizeof(pa_hashmap));
h->data = pa_xmalloc0(sizeof(struct hashmap_entry*)*(h->size = BUCKETS));
h->first_entry = NULL;
h->n_entries = 0;
return h;
}
-static void remove(struct pa_hashmap *h, struct hashmap_entry *e) {
+static void remove(pa_hashmap *h, struct hashmap_entry *e) {
assert(e);
if (e->next)
h->n_entries--;
}
-void pa_hashmap_free(struct pa_hashmap*h, void (*free_func)(void *p, void *userdata), void *userdata) {
+void pa_hashmap_free(pa_hashmap*h, void (*free_func)(void *p, void *userdata), void *userdata) {
assert(h);
while (h->first_entry) {
pa_xfree(h);
}
-static struct hashmap_entry *get(struct pa_hashmap *h, unsigned hash, const void *key) {
+static struct hashmap_entry *get(pa_hashmap *h, unsigned hash, const void *key) {
struct hashmap_entry *e;
assert(h && hash < h->size);
return NULL;
}
-int pa_hashmap_put(struct pa_hashmap *h, const void *key, void *value) {
+int pa_hashmap_put(pa_hashmap *h, const void *key, void *value) {
struct hashmap_entry *e;
unsigned hash;
assert(h);
return 0;
}
-void* pa_hashmap_get(struct pa_hashmap *h, const void *key) {
+void* pa_hashmap_get(pa_hashmap *h, const void *key) {
unsigned hash;
struct hashmap_entry *e;
assert(h && key);
return e->value;
}
-void* pa_hashmap_remove(struct pa_hashmap *h, const void *key) {
+void* pa_hashmap_remove(pa_hashmap *h, const void *key) {
struct hashmap_entry *e;
unsigned hash;
void *data;
return data;
}
-unsigned pa_hashmap_ncontents(struct pa_hashmap *h) {
+unsigned pa_hashmap_size(pa_hashmap *h) {
return h->n_entries;
}
-void *pa_hashmap_iterate(struct pa_hashmap *h, void **state, const void **key) {
+void *pa_hashmap_iterate(pa_hashmap *h, void **state, const void **key) {
assert(h && state);
if (!*state)
* user's job. It's a good idea to have the key pointer point to a
* string in the value data. */
-struct pa_hashmap;
+typedef struct pa_hashmap pa_hashmap;
/* Create a new hashmap. Use the specified functions for hashing and comparing objects in the map */
-struct pa_hashmap *pa_hashmap_new(unsigned (*hash_func) (const void *p), int (*compare_func) (const void*a, const void*b));
+pa_hashmap *pa_hashmap_new(unsigned (*hash_func) (const void *p), int (*compare_func) (const void*a, const void*b));
/* Free the hash table. Calls the specified function for every value in the table. The function may be NULL */
-void pa_hashmap_free(struct pa_hashmap*, void (*free_func)(void *p, void *userdata), void *userdata);
+void pa_hashmap_free(pa_hashmap*, void (*free_func)(void *p, void *userdata), void *userdata);
/* Returns non-zero when the entry already exists */
-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_put(pa_hashmap *h, const void *key, void *value);
+void* pa_hashmap_get(pa_hashmap *h, const void *key);
/* Returns the data of the entry while removing */
-void* pa_hashmap_remove(struct pa_hashmap *h, const void *key);
+void* pa_hashmap_remove(pa_hashmap *h, const void *key);
-unsigned pa_hashmap_ncontents(struct pa_hashmap *h);
+unsigned pa_hashmap_size(pa_hashmap *h);
/* May be used to iterate through the hashmap. Initially the opaque
pointer *state has to be set to NULL. The hashmap may not be
modified during iteration. The key of the entry is returned in
*key, if key is non-NULL. After the last entry in the hashmap NULL
is returned. */
-void *pa_hashmap_iterate(struct pa_hashmap *h, void **state, const void**key);
+void *pa_hashmap_iterate(pa_hashmap *h, void **state, const void**key);
#endif
#define HOWL_PROPERTY "howl"
-struct pa_howl_wrapper {
- struct pa_core *core;
+pa_howl_wrapper {
+ pa_core *core;
int ref;
- struct pa_io_event *io_event;
+ pa_io_event *io_event;
sw_discovery discovery;
};
-static void howl_io_event(struct pa_mainloop_api*m, struct pa_io_event *e, int fd, enum pa_io_event_flags f, void *userdata) {
- struct pa_howl_wrapper *w = userdata;
+static void howl_io_event(pa_mainloop_api*m, pa_io_event *e, int fd, pa_io_event_flags f, void *userdata) {
+ pa_howl_wrapper *w = userdata;
assert(m && e && fd >= 0 && w && w->ref >= 1);
if (f & (PA_IO_EVENT_HANGUP|PA_IO_EVENT_ERROR))
w->io_event = NULL;
}
-static struct pa_howl_wrapper* howl_wrapper_new(struct pa_core *c) {
- struct pa_howl_wrapper *h;
+static pa_howl_wrapper* howl_wrapper_new(pa_core *c) {
+ pa_howl_wrapper *h;
sw_discovery session;
assert(c);
return NULL;
}
- h = pa_xmalloc(sizeof(struct pa_howl_wrapper));
+ h = pa_xmalloc(sizeof(pa_howl_wrapper));
h->core = c;
h->ref = 1;
h->discovery = session;
return h;
}
-static void howl_wrapper_free(struct pa_howl_wrapper *h) {
+static void howl_wrapper_free(pa_howl_wrapper *h) {
assert(h);
sw_discovery_fina(h->discovery);
pa_xfree(h);
}
-struct pa_howl_wrapper* pa_howl_wrapper_get(struct pa_core *c) {
- struct pa_howl_wrapper *h;
+pa_howl_wrapper* pa_howl_wrapper_get(pa_core *c) {
+ pa_howl_wrapper *h;
assert(c);
if ((h = pa_property_get(c, HOWL_PROPERTY)))
return howl_wrapper_new(c);
}
-struct pa_howl_wrapper* pa_howl_wrapper_ref(struct pa_howl_wrapper *h) {
+pa_howl_wrapper* pa_howl_wrapper_ref(pa_howl_wrapper *h) {
assert(h && h->ref >= 1);
h->ref++;
return h;
}
-void pa_howl_wrapper_unref(struct pa_howl_wrapper *h) {
+void pa_howl_wrapper_unref(pa_howl_wrapper *h) {
assert(h && h->ref >= 1);
if (!(--h->ref))
howl_wrapper_free(h);
}
-sw_discovery pa_howl_wrapper_get_discovery(struct pa_howl_wrapper *h) {
+sw_discovery pa_howl_wrapper_get_discovery(pa_howl_wrapper *h) {
assert(h && h->ref >= 1);
return h->discovery;
#include "core.h"
-struct pa_howl_wrapper;
+pa_howl_wrapper;
-struct pa_howl_wrapper* pa_howl_wrapper_get(struct pa_core *c);
-struct pa_howl_wrapper* pa_howl_wrapper_ref(struct pa_howl_wrapper *h);
-void pa_howl_wrapper_unref(struct pa_howl_wrapper *h);
+pa_howl_wrapper* pa_howl_wrapper_get(pa_core *c);
+pa_howl_wrapper* pa_howl_wrapper_ref(pa_howl_wrapper *h);
+void pa_howl_wrapper_unref(pa_howl_wrapper *h);
-sw_discovery pa_howl_wrapper_get_discovery(struct pa_howl_wrapper *h);
+sw_discovery pa_howl_wrapper_get_discovery(pa_howl_wrapper *h);
#endif
#include "idxset.h"
#include "xmalloc.h"
-struct idxset_entry {
+typedef struct idxset_entry {
void *data;
uint32_t index;
unsigned hash_value;
struct idxset_entry *hash_prev, *hash_next;
struct idxset_entry* iterate_prev, *iterate_next;
-};
+} idxset_entry;
struct pa_idxset {
unsigned (*hash_func) (const void *p);
int (*compare_func)(const void *a, const void *b);
unsigned hash_table_size, n_entries;
- struct idxset_entry **hash_table, **array, *iterate_list_head, *iterate_list_tail;
+ idxset_entry **hash_table, **array, *iterate_list_head, *iterate_list_tail;
uint32_t index, start_index, array_size;
};
return a != b;
}
-struct pa_idxset* pa_idxset_new(unsigned (*hash_func) (const void *p), int (*compare_func) (const void*a, const void*b)) {
- struct pa_idxset *s;
+pa_idxset* pa_idxset_new(unsigned (*hash_func) (const void *p), int (*compare_func) (const void*a, const void*b)) {
+ pa_idxset *s;
- s = pa_xmalloc(sizeof(struct pa_idxset));
+ s = pa_xnew(pa_idxset, 1);
s->hash_func = hash_func ? hash_func : pa_idxset_trivial_hash_func;
s->compare_func = compare_func ? compare_func : pa_idxset_trivial_compare_func;
s->hash_table_size = 1023;
- s->hash_table = pa_xmalloc0(sizeof(struct idxset_entry*)*s->hash_table_size);
+ s->hash_table = pa_xmalloc0(sizeof(idxset_entry*)*s->hash_table_size);
s->array = NULL;
s->array_size = 0;
s->index = 0;
return s;
}
-void pa_idxset_free(struct pa_idxset *s, void (*free_func) (void *p, void *userdata), void *userdata) {
+void pa_idxset_free(pa_idxset *s, void (*free_func) (void *p, void *userdata), void *userdata) {
assert(s);
while (s->iterate_list_head) {
- struct idxset_entry *e = s->iterate_list_head;
+ idxset_entry *e = s->iterate_list_head;
s->iterate_list_head = s->iterate_list_head->iterate_next;
if (free_func)
pa_xfree(s);
}
-static struct idxset_entry* hash_scan(struct pa_idxset *s, struct idxset_entry* e, const void *p) {
+static idxset_entry* hash_scan(pa_idxset *s, idxset_entry* e, const void *p) {
assert(p);
assert(s->compare_func);
return NULL;
}
-static void extend_array(struct pa_idxset *s, uint32_t index) {
+static void extend_array(pa_idxset *s, uint32_t idx) {
uint32_t i, j, l;
- struct idxset_entry** n;
- assert(index >= s->start_index);
+ idxset_entry** n;
+ assert(idx >= s->start_index);
- if (index < s->start_index + s->array_size)
+ if (idx < s->start_index + s->array_size)
return;
for (i = 0; i < s->array_size; i++)
if (s->array[i])
break;
- l = index - s->start_index - i + 100;
- n = pa_xmalloc0(sizeof(struct hash_table_entry*)*l);
+ l = idx - s->start_index - i + 100;
+ n = pa_xnew0(idxset_entry*, l);
for (j = 0; j < s->array_size-i; j++)
n[j] = s->array[i+j];
s->start_index += i;
}
-static struct idxset_entry** array_index(struct pa_idxset*s, uint32_t index) {
- if (index >= s->start_index + s->array_size)
+static idxset_entry** array_index(pa_idxset*s, uint32_t idx) {
+ if (idx >= s->start_index + s->array_size)
return NULL;
- if (index < s->start_index)
+ if (idx < s->start_index)
return NULL;
- return s->array + (index - s->start_index);
+ return s->array + (idx - s->start_index);
}
-int pa_idxset_put(struct pa_idxset*s, void *p, uint32_t *index) {
+int pa_idxset_put(pa_idxset*s, void *p, uint32_t *idx) {
unsigned h;
- struct idxset_entry *e, **a;
+ idxset_entry *e, **a;
assert(s && p);
assert(s->hash_func);
assert(s->hash_table);
if ((e = hash_scan(s, s->hash_table[h], p))) {
- if (index)
- *index = e->index;
+ if (idx)
+ *idx = e->index;
return -1;
}
- e = pa_xmalloc(sizeof(struct idxset_entry));
+ e = pa_xmalloc(sizeof(idxset_entry));
e->data = p;
e->index = s->index++;
e->hash_value = h;
s->n_entries++;
assert(s->n_entries >= 1);
- if (index)
- *index = e->index;
+ if (idx)
+ *idx = e->index;
return 0;
}
-void* pa_idxset_get_by_index(struct pa_idxset*s, uint32_t index) {
- struct idxset_entry **a;
+void* pa_idxset_get_by_index(pa_idxset*s, uint32_t idx) {
+ idxset_entry **a;
assert(s);
- if (!(a = array_index(s, index)))
+ if (!(a = array_index(s, idx)))
return NULL;
if (!*a)
return (*a)->data;
}
-void* pa_idxset_get_by_data(struct pa_idxset*s, const void *p, uint32_t *index) {
+void* pa_idxset_get_by_data(pa_idxset*s, const void *p, uint32_t *idx) {
unsigned h;
- struct idxset_entry *e;
+ idxset_entry *e;
assert(s && p);
assert(s->hash_func);
if (!(e = hash_scan(s, s->hash_table[h], p)))
return NULL;
- if (index)
- *index = e->index;
+ if (idx)
+ *idx = e->index;
return e->data;
}
-static void remove_entry(struct pa_idxset *s, struct idxset_entry *e) {
- struct idxset_entry **a;
+static void remove_entry(pa_idxset *s, idxset_entry *e) {
+ idxset_entry **a;
assert(s && e);
/* Remove from array */
s->n_entries--;
}
-void* pa_idxset_remove_by_index(struct pa_idxset*s, uint32_t index) {
- struct idxset_entry **a;
+void* pa_idxset_remove_by_index(pa_idxset*s, uint32_t idx) {
+ idxset_entry **a;
void *data;
assert(s);
- if (!(a = array_index(s, index)))
+ if (!(a = array_index(s, idx)))
return NULL;
data = (*a)->data;
return data;
}
-void* pa_idxset_remove_by_data(struct pa_idxset*s, const void *data, uint32_t *index) {
- struct idxset_entry *e;
+void* pa_idxset_remove_by_data(pa_idxset*s, const void *data, uint32_t *idx) {
+ idxset_entry *e;
unsigned h;
void *r;
return NULL;
r = e->data;
- if (index)
- *index = e->index;
+ if (idx)
+ *idx = e->index;
remove_entry(s, e);
return r;
}
-void* pa_idxset_rrobin(struct pa_idxset *s, uint32_t *index) {
- struct idxset_entry **a, *e = NULL;
- assert(s && index);
+void* pa_idxset_rrobin(pa_idxset *s, uint32_t *idx) {
+ idxset_entry **a, *e = NULL;
+ assert(s && idx);
- if ((a = array_index(s, *index)) && *a)
+ if ((a = array_index(s, *idx)) && *a)
e = (*a)->iterate_next;
if (!e)
if (!e)
return NULL;
- *index = e->index;
+ *idx = e->index;
return e->data;
}
-void* pa_idxset_first(struct pa_idxset *s, uint32_t *index) {
+void* pa_idxset_first(pa_idxset *s, uint32_t *idx) {
assert(s);
if (!s->iterate_list_head)
return NULL;
- if (index)
- *index = s->iterate_list_head->index;
+ if (idx)
+ *idx = s->iterate_list_head->index;
return s->iterate_list_head->data;
}
-void *pa_idxset_next(struct pa_idxset *s, uint32_t *index) {
- struct idxset_entry **a, *e = NULL;
- assert(s && index);
+void *pa_idxset_next(pa_idxset *s, uint32_t *idx) {
+ idxset_entry **a, *e = NULL;
+ assert(s && idx);
- if ((a = array_index(s, *index)) && *a)
+ if ((a = array_index(s, *idx)) && *a)
e = (*a)->iterate_next;
if (e) {
- *index = e->index;
+ *idx = e->index;
return e->data;
} else {
- *index = PA_IDXSET_INVALID;
+ *idx = PA_IDXSET_INVALID;
return NULL;
}
}
-int pa_idxset_foreach(struct pa_idxset*s, int (*func)(void *p, uint32_t index, int *del, void*userdata), void *userdata) {
- struct idxset_entry *e;
+int pa_idxset_foreach(pa_idxset*s, int (*func)(void *p, uint32_t idx, int *del, void*userdata), void *userdata) {
+ idxset_entry *e;
assert(s && func);
e = s->iterate_list_head;
while (e) {
int del = 0, r;
- struct idxset_entry *n = e->iterate_next;
+ idxset_entry *n = e->iterate_next;
r = func(e->data, e->index, &del, userdata);
return 0;
}
-unsigned pa_idxset_ncontents(struct pa_idxset*s) {
+unsigned pa_idxset_size(pa_idxset*s) {
assert(s);
return s->n_entries;
}
-int pa_idxset_isempty(struct pa_idxset *s) {
+int pa_idxset_isempty(pa_idxset *s) {
assert(s);
return s->n_entries == 0;
}
unsigned pa_idxset_string_hash_func(const void *p);
int pa_idxset_string_compare_func(const void *a, const void *b);
-struct pa_idxset;
+typedef struct pa_idxset pa_idxset;
/* Instantiate a new idxset with the specified hash and comparison functions */
-struct pa_idxset* pa_idxset_new(unsigned (*hash_func) (const void *p), int (*compare_func) (const void*a, const void*b));
+pa_idxset* pa_idxset_new(unsigned (*hash_func) (const void *p), int (*compare_func) (const void*a, const void*b));
/* Free the idxset. When the idxset is not empty the specified function is called for every entry contained */
-void pa_idxset_free(struct pa_idxset *s, void (*free_func) (void *p, void *userdata), void *userdata);
+void pa_idxset_free(pa_idxset *s, void (*free_func) (void *p, void *userdata), void *userdata);
-/* Store a new item in the idxset. The index of the item is returned in *index */
-int pa_idxset_put(struct pa_idxset*s, void *p, uint32_t *index);
+/* Store a new item in the idxset. The index of the item is returned in *idx */
+int pa_idxset_put(pa_idxset*s, void *p, uint32_t *idx);
-/* Get the entry by its index */
-void* pa_idxset_get_by_index(struct pa_idxset*s, uint32_t index);
+/* Get the entry by its idx */
+void* pa_idxset_get_by_index(pa_idxset*s, uint32_t idx);
-/* Get the entry by its data. The index is returned in *index */
-void* pa_idxset_get_by_data(struct pa_idxset*s, const void *p, uint32_t *index);
+/* Get the entry by its data. The idx is returned in *index */
+void* pa_idxset_get_by_data(pa_idxset*s, const void *p, uint32_t *idx);
/* Similar to pa_idxset_get_by_index(), but removes the entry from the idxset. */
-void* pa_idxset_remove_by_index(struct pa_idxset*s, uint32_t index);
+void* pa_idxset_remove_by_index(pa_idxset*s, uint32_t idx);
/* Similar to pa_idxset_get_by_data(), but removes the entry from the idxset */
-void* pa_idxset_remove_by_data(struct pa_idxset*s, const void *p, uint32_t *index);
+void* pa_idxset_remove_by_data(pa_idxset*s, const void *p, uint32_t *idx);
/* This may be used to iterate through all entries. When called with
an invalid index value it returns the first entry, otherwise the
- next following. The function is best called with *index =
+ next following. The function is best called with *idx =
PA_IDXSET_VALID first. It is safe to manipulate the idxset between
the calls. It is not guaranteed that all entries have already been
returned before the an entry is returned the second time.*/
-void* pa_idxset_rrobin(struct pa_idxset *s, uint32_t *index);
+void* pa_idxset_rrobin(pa_idxset *s, uint32_t *idx);
-/* Return the oldest entry in the idxset. Fill in its index in *index. */
-void* pa_idxset_first(struct pa_idxset *s, uint32_t *index);
+/* Return the oldest entry in the idxset. Fill in its index in *idx. */
+void* pa_idxset_first(pa_idxset *s, uint32_t *idx);
-/* Return the entry following the entry indexed by *index. After the
+/* Return the entry following the entry indexed by *idx. After the
* call *index contains the index of the returned
* object. pa_idxset_first() and pa_idxset_next() may be used to
* iterate through the set.*/
-void *pa_idxset_next(struct pa_idxset *s, uint32_t *index);
+void *pa_idxset_next(pa_idxset *s, uint32_t *idx);
/* Call a function for every item in the set. If the callback function
returns -1, the loop is terminated. If *del is set to non-zero that
specific item is removed. It is not safe to call any other
functions on the idxset while pa_idxset_foreach is executed. */
-int pa_idxset_foreach(struct pa_idxset*s, int (*func)(void *p, uint32_t index, int *del, void*userdata), void *userdata);
+int pa_idxset_foreach(pa_idxset*s, int (*func)(void *p, uint32_t idx, int *del, void*userdata), void *userdata);
-unsigned pa_idxset_ncontents(struct pa_idxset*s);
-int pa_idxset_isempty(struct pa_idxset *s);
+unsigned pa_idxset_size(pa_idxset*s);
+
+int pa_idxset_isempty(pa_idxset *s);
#endif
struct pa_iochannel {
int ifd, ofd;
- struct pa_mainloop_api* mainloop;
+ pa_mainloop_api* mainloop;
- void (*callback)(struct pa_iochannel*io, void *userdata);
+ pa_iochannel_callback_t callback;
void*userdata;
int readable;
int no_close;
- struct pa_io_event* input_event, *output_event;
+ pa_io_event* input_event, *output_event;
};
-static void enable_mainloop_sources(struct pa_iochannel *io) {
+static void enable_mainloop_sources(pa_iochannel *io) {
assert(io);
if (io->input_event == io->output_event && io->input_event) {
- enum pa_io_event_flags f = PA_IO_EVENT_NULL;
+ pa_io_event_flags f = PA_IO_EVENT_NULL;
assert(io->input_event);
if (!io->readable)
}
}
-static void callback(struct pa_mainloop_api* m, struct pa_io_event *e, int fd, enum pa_io_event_flags f, void *userdata) {
- struct pa_iochannel *io = userdata;
+static void callback(pa_mainloop_api* m, pa_io_event *e, int fd, pa_io_event_flags f, void *userdata) {
+ pa_iochannel *io = userdata;
int changed = 0;
- assert(m && e && fd >= 0 && userdata);
+
+ assert(m);
+ assert(e);
+ assert(fd >= 0);
+ assert(userdata);
if ((f & (PA_IO_EVENT_HANGUP|PA_IO_EVENT_ERROR)) && !io->hungup) {
io->hungup = 1;
if (io->output_event == e)
io->output_event = NULL;
- }
-
- if (e == io->output_event) {
+ } else if (e == io->output_event) {
io->mainloop->io_free(io->output_event);
io->output_event = NULL;
}
}
}
-struct pa_iochannel* pa_iochannel_new(struct pa_mainloop_api*m, int ifd, int ofd) {
- struct pa_iochannel *io;
- assert(m && (ifd >= 0 || ofd >= 0));
+pa_iochannel* pa_iochannel_new(pa_mainloop_api*m, int ifd, int ofd) {
+ pa_iochannel *io;
+
+ assert(m);
+ assert(ifd >= 0 || ofd >= 0);
- io = pa_xmalloc(sizeof(struct pa_iochannel));
+ io = pa_xnew(pa_iochannel, 1);
io->ifd = ifd;
io->ofd = ofd;
io->mainloop = m;
return io;
}
-void pa_iochannel_free(struct pa_iochannel*io) {
+void pa_iochannel_free(pa_iochannel*io) {
assert(io);
if (io->input_event)
io->mainloop->io_free(io->input_event);
+
if (io->output_event && (io->output_event != io->input_event))
io->mainloop->io_free(io->output_event);
if (!io->no_close) {
if (io->ifd >= 0)
+
close(io->ifd);
if (io->ofd >= 0 && io->ofd != io->ifd)
close(io->ofd);
pa_xfree(io);
}
-int pa_iochannel_is_readable(struct pa_iochannel*io) {
+int pa_iochannel_is_readable(pa_iochannel*io) {
assert(io);
+
return io->readable || io->hungup;
}
-int pa_iochannel_is_writable(struct pa_iochannel*io) {
+int pa_iochannel_is_writable(pa_iochannel*io) {
assert(io);
+
return io->writable && !io->hungup;
}
-int pa_iochannel_is_hungup(struct pa_iochannel*io) {
+int pa_iochannel_is_hungup(pa_iochannel*io) {
assert(io);
+
return io->hungup;
}
-ssize_t pa_iochannel_write(struct pa_iochannel*io, const void*data, size_t l) {
+ssize_t pa_iochannel_write(pa_iochannel*io, const void*data, size_t l) {
ssize_t r;
- assert(io && data && l && io->ofd >= 0);
+
+ assert(io);
+ assert(data);
+ assert(l);
+ assert(io->ofd >= 0);
#ifdef OS_IS_WIN32
r = send(io->ofd, data, l, 0);
return r;
}
-ssize_t pa_iochannel_read(struct pa_iochannel*io, void*data, size_t l) {
+ssize_t pa_iochannel_read(pa_iochannel*io, void*data, size_t l) {
ssize_t r;
- assert(io && data && io->ifd >= 0);
+
+ assert(io);
+ assert(data);
+ assert(io->ifd >= 0);
#ifdef OS_IS_WIN32
r = recv(io->ifd, data, l, 0);
if (r < 0)
#endif
r = read(io->ifd, data, l);
+
if (r >= 0) {
io->readable = 0;
enable_mainloop_sources(io);
return r;
}
-void pa_iochannel_set_callback(struct pa_iochannel*io, void (*callback)(struct pa_iochannel*io, void *userdata), void *userdata) {
+void pa_iochannel_set_callback(pa_iochannel*io, pa_iochannel_callback_t _callback, void *userdata) {
assert(io);
- io->callback = callback;
+
+ io->callback = _callback;
io->userdata = userdata;
}
-void pa_iochannel_set_noclose(struct pa_iochannel*io, int b) {
+void pa_iochannel_set_noclose(pa_iochannel*io, int b) {
assert(io);
+
io->no_close = b;
}
-void pa_iochannel_socket_peer_to_string(struct pa_iochannel*io, char*s, size_t l) {
- assert(io && s && l);
+void pa_iochannel_socket_peer_to_string(pa_iochannel*io, char*s, size_t l) {
+ assert(io);
+ assert(s);
+ assert(l);
+
pa_socket_peer_to_string(io->ifd, s, l);
}
-int pa_iochannel_socket_set_rcvbuf(struct pa_iochannel *io, size_t l) {
+int pa_iochannel_socket_set_rcvbuf(pa_iochannel *io, size_t l) {
assert(io);
+
return pa_socket_set_rcvbuf(io->ifd, l);
}
-int pa_iochannel_socket_set_sndbuf(struct pa_iochannel *io, size_t l) {
+int pa_iochannel_socket_set_sndbuf(pa_iochannel *io, size_t l) {
assert(io);
+
return pa_socket_set_sndbuf(io->ofd, l);
}
-
-struct pa_mainloop_api* pa_iochannel_get_mainloop_api(struct pa_iochannel *io) {
+pa_mainloop_api* pa_iochannel_get_mainloop_api(pa_iochannel *io) {
assert(io);
+
return io->mainloop;
}
* reached. Otherwise strange things may happen when an EOF is
* reached. */
-struct pa_iochannel;
+typedef struct pa_iochannel pa_iochannel;
/* Create a new IO channel for the specified file descriptors for
input resp. output. It is safe to pass the same file descriptor for
both parameters (in case of full-duplex channels). For a simplex
channel specify -1 for the other direction. */
-struct pa_iochannel* pa_iochannel_new(struct pa_mainloop_api*m, int ifd, int ofd);
-void pa_iochannel_free(struct pa_iochannel*io);
+pa_iochannel* pa_iochannel_new(pa_mainloop_api*m, int ifd, int ofd);
+void pa_iochannel_free(pa_iochannel*io);
-ssize_t pa_iochannel_write(struct pa_iochannel*io, const void*data, size_t l);
-ssize_t pa_iochannel_read(struct pa_iochannel*io, void*data, size_t l);
+ssize_t pa_iochannel_write(pa_iochannel*io, const void*data, size_t l);
+ssize_t pa_iochannel_read(pa_iochannel*io, void*data, size_t l);
-int pa_iochannel_is_readable(struct pa_iochannel*io);
-int pa_iochannel_is_writable(struct pa_iochannel*io);
-int pa_iochannel_is_hungup(struct pa_iochannel*io);
+int pa_iochannel_is_readable(pa_iochannel*io);
+int pa_iochannel_is_writable(pa_iochannel*io);
+int pa_iochannel_is_hungup(pa_iochannel*io);
/* Don't close the file descirptors when the io channel is freed. By
* default the file descriptors are closed. */
-void pa_iochannel_set_noclose(struct pa_iochannel*io, int b);
+void pa_iochannel_set_noclose(pa_iochannel*io, int b);
/* Set the callback function that is called whenever data becomes available for read or write */
-void pa_iochannel_set_callback(struct pa_iochannel*io, void (*callback)(struct pa_iochannel*io, void *userdata), void *userdata);
+typedef void (*pa_iochannel_callback_t)(pa_iochannel*io, void *userdata);
+void pa_iochannel_set_callback(pa_iochannel*io, pa_iochannel_callback_t callback, void *userdata);
/* In case the file descriptor is a socket, return a pretty-printed string in *s which describes the peer connected */
-void pa_iochannel_socket_peer_to_string(struct pa_iochannel*io, char*s, size_t l);
+void pa_iochannel_socket_peer_to_string(pa_iochannel*io, char*s, size_t l);
/* Use setsockopt() to tune the recieve and send buffers of TCP sockets */
-int pa_iochannel_socket_set_rcvbuf(struct pa_iochannel*io, size_t l);
-int pa_iochannel_socket_set_sndbuf(struct pa_iochannel*io, size_t l);
+int pa_iochannel_socket_set_rcvbuf(pa_iochannel*io, size_t l);
+int pa_iochannel_socket_set_sndbuf(pa_iochannel*io, size_t l);
-struct pa_mainloop_api* pa_iochannel_get_mainloop_api(struct pa_iochannel *io);
+pa_mainloop_api* pa_iochannel_get_mainloop_api(pa_iochannel *io);
#endif
#define READ_SIZE (1024)
struct pa_ioline {
- struct pa_iochannel *io;
- struct pa_defer_event *defer_event;
- struct pa_mainloop_api *mainloop;
+ pa_iochannel *io;
+ pa_defer_event *defer_event;
+ pa_mainloop_api *mainloop;
int ref;
int dead;
char *rbuf;
size_t rbuf_length, rbuf_index, rbuf_valid_length;
- void (*callback)(struct pa_ioline*io, const char *s, void *userdata);
+ void (*callback)(pa_ioline*io, const char *s, void *userdata);
void *userdata;
int defer_close;
};
-static void io_callback(struct pa_iochannel*io, void *userdata);
-static void defer_callback(struct pa_mainloop_api*m, struct pa_defer_event*e, void *userdata);
+static void io_callback(pa_iochannel*io, void *userdata);
+static void defer_callback(pa_mainloop_api*m, pa_defer_event*e, void *userdata);
-struct pa_ioline* pa_ioline_new(struct pa_iochannel *io) {
- struct pa_ioline *l;
+pa_ioline* pa_ioline_new(pa_iochannel *io) {
+ pa_ioline *l;
assert(io);
- l = pa_xmalloc(sizeof(struct pa_ioline));
+ l = pa_xmalloc(sizeof(pa_ioline));
l->io = io;
l->dead = 0;
return l;
}
-static void ioline_free(struct pa_ioline *l) {
+static void ioline_free(pa_ioline *l) {
assert(l);
if (l->io)
pa_xfree(l);
}
-void pa_ioline_unref(struct pa_ioline *l) {
+void pa_ioline_unref(pa_ioline *l) {
assert(l && l->ref >= 1);
if ((--l->ref) <= 0)
ioline_free(l);
}
-struct pa_ioline* pa_ioline_ref(struct pa_ioline *l) {
+pa_ioline* pa_ioline_ref(pa_ioline *l) {
assert(l && l->ref >= 1);
l->ref++;
return l;
}
-void pa_ioline_close(struct pa_ioline *l) {
+void pa_ioline_close(pa_ioline *l) {
assert(l && l->ref >= 1);
l->dead = 1;
}
}
-void pa_ioline_puts(struct pa_ioline *l, const char *c) {
+void pa_ioline_puts(pa_ioline *l, const char *c) {
size_t len;
assert(l && c && l->ref >= 1 && !l->dead);
pa_ioline_unref(l);
}
-void pa_ioline_set_callback(struct pa_ioline*l, void (*callback)(struct pa_ioline*io, const char *s, void *userdata), void *userdata) {
+void pa_ioline_set_callback(pa_ioline*l, void (*callback)(pa_ioline*io, const char *s, void *userdata), void *userdata) {
assert(l && l->ref >= 1);
l->callback = callback;
l->userdata = userdata;
}
-static void failure(struct pa_ioline *l) {
+static void failure(pa_ioline *l) {
assert(l && l->ref >= 1 && !l->dead);
pa_ioline_close(l);
}
}
-static void scan_for_lines(struct pa_ioline *l, size_t skip) {
+static void scan_for_lines(pa_ioline *l, size_t skip) {
assert(l && l->ref >= 1 && skip < l->rbuf_valid_length);
while (!l->dead && l->rbuf_valid_length > skip) {
l->rbuf_index = l->rbuf_valid_length = 0;
}
-static int do_write(struct pa_ioline *l);
+static int do_write(pa_ioline *l);
-static int do_read(struct pa_ioline *l) {
+static int do_read(pa_ioline *l) {
assert(l && l->ref >= 1);
while (!l->dead && pa_iochannel_is_readable(l->io)) {
}
/* Try to flush the buffer */
-static int do_write(struct pa_ioline *l) {
+static int do_write(pa_ioline *l) {
ssize_t r;
assert(l && l->ref >= 1);
}
/* Try to flush read/write data */
-static void do_work(struct pa_ioline *l) {
+static void do_work(pa_ioline *l) {
assert(l && l->ref >= 1);
pa_ioline_ref(l);
pa_ioline_unref(l);
}
-static void io_callback(struct pa_iochannel*io, void *userdata) {
- struct pa_ioline *l = userdata;
+static void io_callback(pa_iochannel*io, void *userdata) {
+ pa_ioline *l = userdata;
assert(io && l && l->ref >= 1);
do_work(l);
}
-static void defer_callback(struct pa_mainloop_api*m, struct pa_defer_event*e, void *userdata) {
- struct pa_ioline *l = userdata;
+static void defer_callback(pa_mainloop_api*m, pa_defer_event*e, void *userdata) {
+ pa_ioline *l = userdata;
assert(l && l->ref >= 1 && l->mainloop == m && l->defer_event == e);
do_work(l);
}
-void pa_ioline_defer_close(struct pa_ioline *l) {
+void pa_ioline_defer_close(pa_ioline *l) {
assert(l);
l->defer_close = 1;
l->mainloop->defer_enable(l->defer_event, 1);
}
-void pa_ioline_printf(struct pa_ioline *s, const char *format, ...) {
+void pa_ioline_printf(pa_ioline *s, const char *format, ...) {
char *t;
va_list ap;
* callback function is called whenever a new line has been recieved
* from the client */
-struct pa_ioline;
+typedef struct pa_ioline pa_ioline;
-struct pa_ioline* pa_ioline_new(struct pa_iochannel *io);
-void pa_ioline_unref(struct pa_ioline *l);
-struct pa_ioline* pa_ioline_ref(struct pa_ioline *l);
-void pa_ioline_close(struct pa_ioline *l);
+pa_ioline* pa_ioline_new(pa_iochannel *io);
+void pa_ioline_unref(pa_ioline *l);
+pa_ioline* pa_ioline_ref(pa_ioline *l);
+void pa_ioline_close(pa_ioline *l);
/* Write a string to the channel */
-void pa_ioline_puts(struct pa_ioline *s, const char *c);
+void pa_ioline_puts(pa_ioline *s, const char *c);
/* Write a string to the channel */
-void pa_ioline_printf(struct pa_ioline *s, const char *format, ...) PA_GCC_PRINTF_ATTR(2,3);
+void pa_ioline_printf(pa_ioline *s, const char *format, ...) PA_GCC_PRINTF_ATTR(2,3);
/* Set the callback function that is called for every recieved line */
-void pa_ioline_set_callback(struct pa_ioline*io, void (*callback)(struct pa_ioline*io, const char *s, void *userdata), void *userdata);
+void pa_ioline_set_callback(pa_ioline*io, void (*callback)(pa_ioline*io, const char *s, void *userdata), void *userdata);
/* Make sure to close the ioline object as soon as the send buffer is emptied */
-void pa_ioline_defer_close(struct pa_ioline *io);
+void pa_ioline_defer_close(pa_ioline *io);
#endif
#define ENV_LOGLEVEL "POLYP_LOG"
static char *log_ident = NULL;
-static enum pa_log_target log_target = PA_LOG_STDERR;
-static void (*user_log_func)(enum pa_log_level l, const char *s) = NULL;
-static enum pa_log_level maximal_level = PA_LOG_NOTICE;
+static pa_log_target log_target = PA_LOG_STDERR;
+static void (*user_log_func)(pa_log_level l, const char *s) = NULL;
+static pa_log_level maximal_level = PA_LOG_NOTICE;
#ifdef HAVE_SYSLOG_H
static const int level_to_syslog[] = {
log_ident = pa_xstrdup(p);
}
-void pa_log_set_maximal_level(enum pa_log_level l) {
+void pa_log_set_maximal_level(pa_log_level l) {
assert(l < PA_LOG_LEVEL_MAX);
maximal_level = l;
}
-void pa_log_set_target(enum pa_log_target t, void (*func)(enum pa_log_level l, const char*s)) {
+void pa_log_set_target(pa_log_target t, void (*func)(pa_log_level l, const char*s)) {
assert(t == PA_LOG_USER || !func);
log_target = t;
user_log_func = func;
}
-void pa_log_levelv(enum pa_log_level level, const char *format, va_list ap) {
+void pa_log_with_levelv(pa_log_level level, const char *format, va_list ap) {
const char *e;
assert(level < PA_LOG_LEVEL_MAX);
}
-void pa_log_level(enum pa_log_level level, const char *format, ...) {
+void pa_log_with_level(pa_log_level level, const char *format, ...) {
va_list ap;
va_start(ap, format);
- pa_log_levelv(level, format, ap);
+ pa_log_with_levelv(level, format, ap);
va_end(ap);
}
void pa_log_debug(const char *format, ...) {
va_list ap;
va_start(ap, format);
- pa_log_levelv(PA_LOG_DEBUG, format, ap);
+ pa_log_with_levelv(PA_LOG_DEBUG, format, ap);
va_end(ap);
}
void pa_log_info(const char *format, ...) {
va_list ap;
va_start(ap, format);
- pa_log_levelv(PA_LOG_INFO, format, ap);
+ pa_log_with_levelv(PA_LOG_INFO, format, ap);
va_end(ap);
}
void pa_log_notice(const char *format, ...) {
va_list ap;
va_start(ap, format);
- pa_log_levelv(PA_LOG_INFO, format, ap);
+ pa_log_with_levelv(PA_LOG_INFO, format, ap);
va_end(ap);
}
void pa_log_warn(const char *format, ...) {
va_list ap;
va_start(ap, format);
- pa_log_levelv(PA_LOG_WARN, format, ap);
+ pa_log_with_levelv(PA_LOG_WARN, format, ap);
va_end(ap);
}
void pa_log_error(const char *format, ...) {
va_list ap;
va_start(ap, format);
- pa_log_levelv(PA_LOG_ERROR, format, ap);
+ pa_log_with_levelv(PA_LOG_ERROR, format, ap);
va_end(ap);
}
***/
#include <stdarg.h>
-#include "gcc-printf.h"
+#include "gccmacro.h"
/* A simple logging subsystem */
/* Where to log to */
-enum pa_log_target {
+typedef enum pa_log_target {
PA_LOG_STDERR, /* default */
PA_LOG_SYSLOG,
PA_LOG_USER, /* to user specified function */
PA_LOG_NULL /* to /dev/null */
-};
+} pa_log_target;
-enum pa_log_level {
+typedef enum pa_log_level {
PA_LOG_ERROR = 0, /* Error messages */
PA_LOG_WARN = 1, /* Warning messages */
PA_LOG_NOTICE = 2, /* Notice messages */
PA_LOG_INFO = 3, /* Info messages */
PA_LOG_DEBUG = 4, /* debug message */
PA_LOG_LEVEL_MAX
-};
+} pa_log_level;
-/* Set an identifcation for the current daemon. Used when logging to syslog. */
+/* Set an identification for the current daemon. Used when logging to syslog. */
void pa_log_set_ident(const char *p);
/* Set another log target. If t is PA_LOG_USER you may specify a function that is called every log string */
-void pa_log_set_target(enum pa_log_target t, void (*func)(enum pa_log_level, const char*s));
+void pa_log_set_target(pa_log_target t, void (*func)(pa_log_level, const char*s));
/* Minimal log level */
-void pa_log_set_maximal_level(enum pa_log_level l);
+void pa_log_set_maximal_level(pa_log_level l);
/* Do a log line */
void pa_log_debug(const char *format, ...) PA_GCC_PRINTF_ATTR(1,2);
void pa_log_warn(const char *format, ...) PA_GCC_PRINTF_ATTR(1,2);
void pa_log_error(const char *format, ...) PA_GCC_PRINTF_ATTR(1,2);
-void pa_log_level(enum pa_log_level level, const char *format, ...) PA_GCC_PRINTF_ATTR(2,3);
+void pa_log_with_level(pa_log_level level, const char *format, ...) PA_GCC_PRINTF_ATTR(2,3);
-void pa_log_levelv(enum pa_log_level level, const char *format, va_list ap);
+void pa_log_with_levelv(pa_log_level level, const char *format, va_list ap);
#define pa_log pa_log_error
#ifdef OS_IS_WIN32
-static void message_cb(struct pa_mainloop_api*a, struct pa_defer_event *e, void *userdata) {
+static void message_cb(pa_mainloop_api*a, pa_defer_event *e, void *userdata) {
MSG msg;
while(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
#endif
-static void signal_callback(struct pa_mainloop_api*m, struct pa_signal_event *e, int sig, void *userdata) {
+static void signal_callback(pa_mainloop_api*m, PA_GCC_UNUSED pa_signal_event *e, int sig, void *userdata) {
pa_log_info(__FILE__": Got signal %s.\n", pa_strsignal(sig));
switch (sig) {
}
int main(int argc, char *argv[]) {
- struct pa_core *c;
- struct pa_strbuf *buf = NULL;
- struct pa_daemon_conf *conf;
- struct pa_mainloop *mainloop;
+ pa_core *c;
+ pa_strbuf *buf = NULL;
+ pa_daemon_conf *conf;
+ pa_mainloop *mainloop;
- char *s;
+ char *s;
int r, retval = 1, d = 0;
int daemon_pipe[2] = { -1, -1 };
int suid_root;
#endif
#ifdef OS_IS_WIN32
- struct pa_defer_event *defer;
+ pa_defer_event *defer;
#endif
pa_limit_caps();
goto finish;
case PA_CMD_DUMP_CONF: {
- char *s = pa_daemon_conf_dump(conf);
+ s = pa_daemon_conf_dump(conf);
fputs(s, stdout);
pa_xfree(s);
retval = 0;
if (conf->daemonize)
pa_loop_write(daemon_pipe[1], &retval, sizeof(retval));
#endif
- } else if (!c->modules || pa_idxset_ncontents(c->modules) == 0) {
+ } else if (!c->modules || pa_idxset_size(c->modules) == 0) {
pa_log(__FILE__": daemon startup without any loaded modules, refusing to work.\n");
#ifdef HAVE_FORK
if (conf->daemonize)
#include "mainloop-api.h"
#include "xmalloc.h"
+#include "gccmacro.h"
struct once_info {
- void (*callback)(struct pa_mainloop_api*m, void *userdata);
+ void (*callback)(pa_mainloop_api*m, void *userdata);
void *userdata;
};
-static void once_callback(struct pa_mainloop_api *m, struct pa_defer_event *e, void *userdata) {
+static void once_callback(pa_mainloop_api *m, pa_defer_event *e, void *userdata) {
struct once_info *i = userdata;
assert(m && i && i->callback);
m->defer_free(e);
}
-static void free_callback(struct pa_mainloop_api *m, struct pa_defer_event *e, void *userdata) {
+static void free_callback(pa_mainloop_api *m, PA_GCC_UNUSED pa_defer_event *e, void *userdata) {
struct once_info *i = userdata;
assert(m && i);
pa_xfree(i);
}
-void pa_mainloop_api_once(struct pa_mainloop_api* m, void (*callback)(struct pa_mainloop_api *m, void *userdata), void *userdata) {
+void pa_mainloop_api_once(pa_mainloop_api* m, void (*callback)(pa_mainloop_api *m, void *userdata), void *userdata) {
struct once_info *i;
- struct pa_defer_event *e;
+ pa_defer_event *e;
assert(m && callback);
- i = pa_xmalloc(sizeof(struct once_info));
+ i = pa_xnew(struct once_info, 1);
i->callback = callback;
i->userdata = userdata;
PA_C_DECL_BEGIN
/** A bitmask for IO events */
-enum pa_io_event_flags {
+typedef enum pa_io_event_flags {
PA_IO_EVENT_NULL = 0, /**< No event */
PA_IO_EVENT_INPUT = 1, /**< Input event */
PA_IO_EVENT_OUTPUT = 2, /**< Output event */
PA_IO_EVENT_HANGUP = 4, /**< Hangup event */
PA_IO_EVENT_ERROR = 8 /**< Error event */
-};
+} pa_io_event_flags;
-/** \struct pa_io_event
+/** \pa_io_event
* An opaque IO event source object */
-struct pa_io_event;
+typedef struct pa_io_event pa_io_event;
-/** \struct pa_defer_event
+/** \pa_defer_event
* An opaque deferred event source object. Events of this type are triggered once in every main loop iteration */
-struct pa_defer_event;
+typedef struct pa_defer_event pa_defer_event;
-/** \struct pa_time_event
+/** \pa_time_event
* An opaque timer event source object */
-struct pa_time_event;
+typedef struct pa_time_event pa_time_event;
/** An abstract mainloop API vtable */
-struct pa_mainloop_api {
+typedef struct pa_mainloop_api pa_mainloop_api;
+
+struct pa_mainloop_api {
/** A pointer to some private, arbitrary data of the main loop implementation */
void *userdata;
/** Create a new IO event source object */
- struct pa_io_event* (*io_new)(struct pa_mainloop_api*a, int fd, enum pa_io_event_flags events, void (*callback) (struct pa_mainloop_api*a, struct pa_io_event* e, int fd, enum pa_io_event_flags events, void *userdata), void *userdata);
+ pa_io_event* (*io_new)(pa_mainloop_api*a, int fd, pa_io_event_flags events, void (*callback) (pa_mainloop_api*a, pa_io_event* e, int fd, pa_io_event_flags events, void *userdata), void *userdata);
/** Enable or disable IO events on this object */
- void (*io_enable)(struct pa_io_event* e, enum pa_io_event_flags events);
+ void (*io_enable)(pa_io_event* e, pa_io_event_flags events);
/** Free a IO event source object */
- void (*io_free)(struct pa_io_event* e);
+ void (*io_free)(pa_io_event* e);
/** Set a function that is called when the IO event source is destroyed. Use this to free the userdata argument if required */
- void (*io_set_destroy)(struct pa_io_event *e, void (*callback) (struct pa_mainloop_api*a, struct pa_io_event *e, void *userdata));
+ void (*io_set_destroy)(pa_io_event *e, void (*callback) (pa_mainloop_api*a, pa_io_event *e, void *userdata));
/** Create a new timer event source object for the specified Unix time */
- struct pa_time_event* (*time_new)(struct pa_mainloop_api*a, const struct timeval *tv, void (*callback) (struct pa_mainloop_api*a, struct pa_time_event* e, const struct timeval *tv, void *userdata), void *userdata);
+ pa_time_event* (*time_new)(pa_mainloop_api*a, const struct timeval *tv, void (*callback) (pa_mainloop_api*a, pa_time_event* e, const struct timeval *tv, void *userdata), void *userdata);
/** Restart a running or expired timer event source with a new Unix time */
- void (*time_restart)(struct pa_time_event* e, const struct timeval *tv);
+ void (*time_restart)(pa_time_event* e, const struct timeval *tv);
/** Free a deferred timer event source object */
- void (*time_free)(struct pa_time_event* e);
+ void (*time_free)(pa_time_event* e);
/** Set a function that is called when the timer event source is destroyed. Use this to free the userdata argument if required */
- void (*time_set_destroy)(struct pa_time_event *e, void (*callback) (struct pa_mainloop_api*a, struct pa_time_event *e, void *userdata));
+ void (*time_set_destroy)(pa_time_event *e, void (*callback) (pa_mainloop_api*a, pa_time_event *e, void *userdata));
/** Create a new deferred event source object */
- struct pa_defer_event* (*defer_new)(struct pa_mainloop_api*a, void (*callback) (struct pa_mainloop_api*a, struct pa_defer_event* e, void *userdata), void *userdata);
+ pa_defer_event* (*defer_new)(pa_mainloop_api*a, void (*callback) (pa_mainloop_api*a, pa_defer_event* e, void *userdata), void *userdata);
/** Enable or disable a deferred event source temporarily */
- void (*defer_enable)(struct pa_defer_event* e, int b);
+ void (*defer_enable)(pa_defer_event* e, int b);
/** Free a deferred event source object */
- void (*defer_free)(struct pa_defer_event* e);
+ void (*defer_free)(pa_defer_event* e);
/** Set a function that is called when the deferred event source is destroyed. Use this to free the userdata argument if required */
- void (*defer_set_destroy)(struct pa_defer_event *e, void (*callback) (struct pa_mainloop_api*a, struct pa_defer_event *e, void *userdata));
+ void (*defer_set_destroy)(pa_defer_event *e, void (*callback) (pa_mainloop_api*a, pa_defer_event *e, void *userdata));
/** Exit the main loop and return the specfied retval*/
- void (*quit)(struct pa_mainloop_api*a, int retval);
+ void (*quit)(pa_mainloop_api*a, int retval);
};
/** Run the specified callback function once from the main loop using an anonymous defer event. */
-void pa_mainloop_api_once(struct pa_mainloop_api*m, void (*callback)(struct pa_mainloop_api*m, void *userdata), void *userdata);
+void pa_mainloop_api_once(pa_mainloop_api*m, void (*callback)(pa_mainloop_api*m, void *userdata), void *userdata);
PA_C_DECL_END
#include "util.h"
#include "xmalloc.h"
#include "log.h"
+#include "gccmacro.h"
struct pa_signal_event {
int sig;
#else
void (*saved_handler)(int sig);
#endif
- void (*callback) (struct pa_mainloop_api*a, struct pa_signal_event *e, int signal, void *userdata);
+ void (*callback) (pa_mainloop_api*a, pa_signal_event *e, int sig, void *userdata);
void *userdata;
- void (*destroy_callback) (struct pa_mainloop_api*a, struct pa_signal_event*e, void *userdata);
- struct pa_signal_event *previous, *next;
+ void (*destroy_callback) (pa_mainloop_api*a, pa_signal_event*e, void *userdata);
+ pa_signal_event *previous, *next;
};
-static struct pa_mainloop_api *api = NULL;
+static pa_mainloop_api *api = NULL;
static int signal_pipe[2] = { -1, -1 };
-static struct pa_io_event* io_event = NULL;
-static struct pa_defer_event *defer_event = NULL;
-static struct pa_signal_event *signals = NULL;
+static pa_io_event* io_event = NULL;
+static pa_defer_event *defer_event = NULL;
+static pa_signal_event *signals = NULL;
#ifdef OS_IS_WIN32
static unsigned int waiting_signals = 0;
#endif
}
-static void dispatch(struct pa_mainloop_api*a, int sig) {
- struct pa_signal_event*s;
+static void dispatch(pa_mainloop_api*a, int sig) {
+ pa_signal_event*s;
for (s = signals; s; s = s->next)
if (s->sig == sig) {
}
}
-static void defer(struct pa_mainloop_api*a, struct pa_defer_event*e, void *userdata) {
+static void defer(pa_mainloop_api*a, PA_GCC_UNUSED pa_defer_event*e, PA_GCC_UNUSED void *userdata) {
ssize_t r;
int sig;
unsigned int sigs;
}
}
-static void callback(struct pa_mainloop_api*a, struct pa_io_event*e, int fd, enum pa_io_event_flags f, void *userdata) {
+static void callback(pa_mainloop_api*a, pa_io_event*e, int fd, pa_io_event_flags f, PA_GCC_UNUSED void *userdata) {
ssize_t r;
int sig;
assert(a && e && f == PA_IO_EVENT_INPUT && e == io_event && fd == signal_pipe[0]);
dispatch(a, sig);
}
-int pa_signal_init(struct pa_mainloop_api *a) {
+int pa_signal_init(pa_mainloop_api *a) {
assert(!api && a && signal_pipe[0] == -1 && signal_pipe[1] == -1 && !io_event && !defer_event);
#ifdef OS_IS_WIN32
api = NULL;
}
-struct pa_signal_event* pa_signal_new(int sig, void (*callback) (struct pa_mainloop_api *api, struct pa_signal_event*e, int sig, void *userdata), void *userdata) {
- struct pa_signal_event *e = NULL;
+pa_signal_event* pa_signal_new(int sig, void (*_callback) (pa_mainloop_api *api, pa_signal_event*e, int sig, void *userdata), void *userdata) {
+ pa_signal_event *e = NULL;
#ifdef HAVE_SIGACTION
struct sigaction sa;
#endif
- assert(sig > 0 && callback);
+ assert(sig > 0 && _callback);
for (e = signals; e; e = e->next)
if (e->sig == sig)
goto fail;
- e = pa_xmalloc(sizeof(struct pa_signal_event));
+ e = pa_xmalloc(sizeof(pa_signal_event));
e->sig = sig;
- e->callback = callback;
+ e->callback = _callback;
e->userdata = userdata;
e->destroy_callback = NULL;
return NULL;
}
-void pa_signal_free(struct pa_signal_event *e) {
+void pa_signal_free(pa_signal_event *e) {
assert(e);
if (e->next)
pa_xfree(e);
}
-void pa_signal_set_destroy(struct pa_signal_event *e, void (*callback) (struct pa_mainloop_api *api, struct pa_signal_event*e, void *userdata)) {
+void pa_signal_set_destroy(pa_signal_event *e, void (*_callback) (pa_mainloop_api *api, pa_signal_event*e, void *userdata)) {
assert(e);
- e->destroy_callback = callback;
+ e->destroy_callback = _callback;
}
*/
/** Initialize the UNIX signal subsystem and bind it to the specified main loop */
-int pa_signal_init(struct pa_mainloop_api *api);
+int pa_signal_init(pa_mainloop_api *api);
/** Cleanup the signal subsystem */
void pa_signal_done(void);
-/** \struct pa_signal_event
+/** \pa_signal_event
* An opaque UNIX signal event source object */
-struct pa_signal_event;
+typedef struct pa_signal_event pa_signal_event;
/** Create a new UNIX signal event source object */
-struct pa_signal_event* pa_signal_new(int signal, void (*callback) (struct pa_mainloop_api *api, struct pa_signal_event*e, int signal, void *userdata), void *userdata);
+pa_signal_event* pa_signal_new(int sig, void (*callback) (pa_mainloop_api *api, pa_signal_event*e, int sig, void *userdata), void *userdata);
/** Free a UNIX signal event source object */
-void pa_signal_free(struct pa_signal_event *e);
+void pa_signal_free(pa_signal_event *e);
/** Set a function that is called when the signal event source is destroyed. Use this to free the userdata argument if required */
-void pa_signal_set_destroy(struct pa_signal_event *e, void (*callback) (struct pa_mainloop_api *api, struct pa_signal_event*e, void *userdata));
+void pa_signal_set_destroy(pa_signal_event *e, void (*callback) (pa_mainloop_api *api, pa_signal_event*e, void *userdata));
PA_C_DECL_END
#include <sys/time.h>
#include <assert.h>
+#include "util.h"
+#include "gccmacro.h"
+
#ifdef GLIB_MAIN_LOOP
#include <glib.h>
#include "glib-mainloop.h"
+
static GMainLoop* glib_main_loop = NULL;
#if GLIB_MAJOR_VERSION >= 2
#include "mainloop.h"
#endif /* GLIB_MAIN_LOOP */
-static struct pa_defer_event *de;
+static pa_defer_event *de;
-static void iocb(struct pa_mainloop_api*a, struct pa_io_event *e, int fd, enum pa_io_event_flags f, void *userdata) {
+static void iocb(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags f, void *userdata) {
unsigned char c;
read(fd, &c, sizeof(c));
fprintf(stderr, "IO EVENT: %c\n", c < 32 ? '.' : c);
a->defer_enable(de, 1);
}
-static void dcb(struct pa_mainloop_api*a, struct pa_defer_event *e, void *userdata) {
+static void dcb(pa_mainloop_api*a, pa_defer_event *e, void *userdata) {
fprintf(stderr, "DEFER EVENT\n");
a->defer_enable(e, 0);
}
-static void tcb(struct pa_mainloop_api*a, struct pa_time_event *e, const struct timeval *tv, void *userdata) {
+static void tcb(pa_mainloop_api*a, pa_time_event *e, const struct timeval *tv, void *userdata) {
fprintf(stderr, "TIME EVENT\n");
#if defined(GLIB_MAIN_LOOP) && defined(GLIB20)
#endif
}
-int main(int argc, char *argv[]) {
- struct pa_mainloop_api *a;
- struct pa_io_event *ioe;
- struct pa_time_event *te;
+int main(PA_GCC_UNUSED int argc, PA_GCC_UNUSED char *argv[]) {
+ pa_mainloop_api *a;
+ pa_io_event *ioe;
+ pa_time_event *te;
struct timeval tv;
#ifdef GLIB_MAIN_LOOP
- struct pa_glib_mainloop *g;
+ pa_glib_mainloop *g;
#ifdef GLIB20
glib_main_loop = g_main_loop_new(NULL, FALSE);
a = pa_glib_mainloop_get_api(g);
assert(a);
#else /* GLIB_MAIN_LOOP */
- struct pa_mainloop *m;
+ pa_mainloop *m;
m = pa_mainloop_new();
assert(m);
#include "log.h"
struct pa_io_event {
- struct pa_mainloop *mainloop;
+ pa_mainloop *mainloop;
int dead;
int fd;
- enum pa_io_event_flags events;
- void (*callback) (struct pa_mainloop_api*a, struct pa_io_event *e, int fd, enum pa_io_event_flags f, void *userdata);
+ pa_io_event_flags events;
+ void (*callback) (pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags f, void *userdata);
struct pollfd *pollfd;
void *userdata;
- void (*destroy_callback) (struct pa_mainloop_api*a, struct pa_io_event *e, void *userdata);
+ void (*destroy_callback) (pa_mainloop_api*a, pa_io_event *e, void *userdata);
};
struct pa_time_event {
- struct pa_mainloop *mainloop;
+ pa_mainloop *mainloop;
int dead;
int enabled;
struct timeval timeval;
- void (*callback)(struct pa_mainloop_api*a, struct pa_time_event *e, const struct timeval*tv, void *userdata);
+ void (*callback)(pa_mainloop_api*a, pa_time_event *e, const struct timeval*tv, void *userdata);
void *userdata;
- void (*destroy_callback) (struct pa_mainloop_api*a, struct pa_time_event *e, void *userdata);
+ void (*destroy_callback) (pa_mainloop_api*a, pa_time_event *e, void *userdata);
};
struct pa_defer_event {
- struct pa_mainloop *mainloop;
+ pa_mainloop *mainloop;
int dead;
int enabled;
- void (*callback)(struct pa_mainloop_api*a, struct pa_defer_event*e, void *userdata);
+ void (*callback)(pa_mainloop_api*a, pa_defer_event*e, void *userdata);
void *userdata;
- void (*destroy_callback) (struct pa_mainloop_api*a, struct pa_defer_event *e, void *userdata);
+ void (*destroy_callback) (pa_mainloop_api*a, pa_defer_event *e, void *userdata);
};
struct pa_mainloop {
- struct pa_idxset *io_events, *time_events, *defer_events;
+ pa_idxset *io_events, *time_events, *defer_events;
int io_events_scan_dead, defer_events_scan_dead, time_events_scan_dead;
struct pollfd *pollfds;
int rebuild_pollfds;
int quit, running, retval;
- struct pa_mainloop_api api;
+ pa_mainloop_api api;
int deferred_pending;
};
/* IO events */
-static struct pa_io_event* mainloop_io_new(struct pa_mainloop_api*a, int fd, enum pa_io_event_flags events, void (*callback) (struct pa_mainloop_api*a, struct pa_io_event *e, int fd, enum pa_io_event_flags events, void *userdata), void *userdata) {
- struct pa_mainloop *m;
- struct pa_io_event *e;
+static pa_io_event* mainloop_io_new(pa_mainloop_api*a, int fd, pa_io_event_flags events, void (*callback) (pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags events, void *userdata), void *userdata) {
+ pa_mainloop *m;
+ pa_io_event *e;
assert(a && a->userdata && fd >= 0 && callback);
m = a->userdata;
assert(a == &m->api);
- e = pa_xmalloc(sizeof(struct pa_io_event));
+ e = pa_xmalloc(sizeof(pa_io_event));
e->mainloop = m;
e->dead = 0;
return e;
}
-static void mainloop_io_enable(struct pa_io_event *e, enum pa_io_event_flags events) {
+static void mainloop_io_enable(pa_io_event *e, pa_io_event_flags events) {
assert(e && e->mainloop);
e->events = events;
POLLERR | POLLHUP;
}
-static void mainloop_io_free(struct pa_io_event *e) {
+static void mainloop_io_free(pa_io_event *e) {
assert(e && e->mainloop);
e->dead = e->mainloop->io_events_scan_dead = e->mainloop->rebuild_pollfds = 1;
}
-static void mainloop_io_set_destroy(struct pa_io_event *e, void (*callback)(struct pa_mainloop_api*a, struct pa_io_event *e, void *userdata)) {
+static void mainloop_io_set_destroy(pa_io_event *e, void (*callback)(pa_mainloop_api*a, pa_io_event *e, void *userdata)) {
assert(e);
e->destroy_callback = callback;
}
/* Defer events */
-static struct pa_defer_event* mainloop_defer_new(struct pa_mainloop_api*a, void (*callback) (struct pa_mainloop_api*a, struct pa_defer_event *e, void *userdata), void *userdata) {
- struct pa_mainloop *m;
- struct pa_defer_event *e;
+static pa_defer_event* mainloop_defer_new(pa_mainloop_api*a, void (*callback) (pa_mainloop_api*a, pa_defer_event *e, void *userdata), void *userdata) {
+ pa_mainloop *m;
+ pa_defer_event *e;
assert(a && a->userdata && callback);
m = a->userdata;
assert(a == &m->api);
- e = pa_xmalloc(sizeof(struct pa_defer_event));
+ e = pa_xmalloc(sizeof(pa_defer_event));
e->mainloop = m;
e->dead = 0;
return e;
}
-static void mainloop_defer_enable(struct pa_defer_event *e, int b) {
+static void mainloop_defer_enable(pa_defer_event *e, int b) {
assert(e);
if (e->enabled && !b) {
e->enabled = b;
}
-static void mainloop_defer_free(struct pa_defer_event *e) {
+static void mainloop_defer_free(pa_defer_event *e) {
assert(e);
e->dead = e->mainloop->defer_events_scan_dead = 1;
}
}
-static void mainloop_defer_set_destroy(struct pa_defer_event *e, void (*callback)(struct pa_mainloop_api*a, struct pa_defer_event *e, void *userdata)) {
+static void mainloop_defer_set_destroy(pa_defer_event *e, void (*callback)(pa_mainloop_api*a, pa_defer_event *e, void *userdata)) {
assert(e);
e->destroy_callback = callback;
}
/* Time events */
-static struct pa_time_event* mainloop_time_new(struct pa_mainloop_api*a, const struct timeval *tv, void (*callback) (struct pa_mainloop_api*a, struct pa_time_event*e, const struct timeval *tv, void *userdata), void *userdata) {
- struct pa_mainloop *m;
- struct pa_time_event *e;
+static pa_time_event* mainloop_time_new(pa_mainloop_api*a, const struct timeval *tv, void (*callback) (pa_mainloop_api*a, pa_time_event*e, const struct timeval *tv, void *userdata), void *userdata) {
+ pa_mainloop *m;
+ pa_time_event *e;
assert(a && a->userdata && callback);
m = a->userdata;
assert(a == &m->api);
- e = pa_xmalloc(sizeof(struct pa_time_event));
+ e = pa_xmalloc(sizeof(pa_time_event));
e->mainloop = m;
e->dead = 0;
return e;
}
-static void mainloop_time_restart(struct pa_time_event *e, const struct timeval *tv) {
+static void mainloop_time_restart(pa_time_event *e, const struct timeval *tv) {
assert(e);
if (tv) {
e->enabled = 0;
}
-static void mainloop_time_free(struct pa_time_event *e) {
+static void mainloop_time_free(pa_time_event *e) {
assert(e);
e->dead = e->mainloop->time_events_scan_dead = 1;
}
-static void mainloop_time_set_destroy(struct pa_time_event *e, void (*callback)(struct pa_mainloop_api*a, struct pa_time_event *e, void *userdata)) {
+static void mainloop_time_set_destroy(pa_time_event *e, void (*callback)(pa_mainloop_api*a, pa_time_event *e, void *userdata)) {
assert(e);
e->destroy_callback = callback;
}
/* quit() */
-static void mainloop_quit(struct pa_mainloop_api*a, int retval) {
- struct pa_mainloop *m;
+static void mainloop_quit(pa_mainloop_api*a, int retval) {
+ pa_mainloop *m;
assert(a && a->userdata);
m = a->userdata;
assert(a == &m->api);
m->retval = retval;
}
-static const struct pa_mainloop_api vtable = {
+static const pa_mainloop_api vtable = {
.userdata = NULL,
.io_new= mainloop_io_new,
.quit = mainloop_quit,
};
-struct pa_mainloop *pa_mainloop_new(void) {
- struct pa_mainloop *m;
+pa_mainloop *pa_mainloop_new(void) {
+ pa_mainloop *m;
- m = pa_xmalloc(sizeof(struct pa_mainloop));
+ m = pa_xmalloc(sizeof(pa_mainloop));
m->io_events = pa_idxset_new(NULL, NULL);
m->defer_events = pa_idxset_new(NULL, NULL);
return m;
}
-static int io_foreach(void *p, uint32_t index, int *del, void*userdata) {
- struct pa_io_event *e = p;
+static int io_foreach(void *p, uint32_t PA_GCC_UNUSED idx, int *del, void*userdata) {
+ pa_io_event *e = p;
int *all = userdata;
assert(e && del && all);
return 0;
}
-static int time_foreach(void *p, uint32_t index, int *del, void*userdata) {
- struct pa_time_event *e = p;
+static int time_foreach(void *p, uint32_t PA_GCC_UNUSED idx, int *del, void*userdata) {
+ pa_time_event *e = p;
int *all = userdata;
assert(e && del && all);
return 0;
}
-static int defer_foreach(void *p, uint32_t index, int *del, void*userdata) {
- struct pa_defer_event *e = p;
+static int defer_foreach(void *p, PA_GCC_UNUSED uint32_t idx, int *del, void*userdata) {
+ pa_defer_event *e = p;
int *all = userdata;
assert(e && del && all);
return 0;
}
-void pa_mainloop_free(struct pa_mainloop* m) {
+void pa_mainloop_free(pa_mainloop* m) {
int all = 1;
assert(m);
pa_xfree(m);
}
-static void scan_dead(struct pa_mainloop *m) {
+static void scan_dead(pa_mainloop *m) {
int all = 0;
assert(m);
m->io_events_scan_dead = m->time_events_scan_dead = m->defer_events_scan_dead = 0;
}
-static void rebuild_pollfds(struct pa_mainloop *m) {
- struct pa_io_event*e;
+static void rebuild_pollfds(pa_mainloop *m) {
+ pa_io_event*e;
struct pollfd *p;
- uint32_t index = PA_IDXSET_INVALID;
+ uint32_t idx = PA_IDXSET_INVALID;
unsigned l;
- l = pa_idxset_ncontents(m->io_events);
+ l = pa_idxset_size(m->io_events);
if (m->max_pollfds < l) {
m->pollfds = pa_xrealloc(m->pollfds, sizeof(struct pollfd)*l);
m->max_pollfds = l;
m->n_pollfds = 0;
p = m->pollfds;
- for (e = pa_idxset_first(m->io_events, &index); e; e = pa_idxset_next(m->io_events, &index)) {
+ for (e = pa_idxset_first(m->io_events, &idx); e; e = pa_idxset_next(m->io_events, &idx)) {
if (e->dead) {
e->pollfd = NULL;
continue;
}
}
-static int dispatch_pollfds(struct pa_mainloop *m) {
- uint32_t index = PA_IDXSET_INVALID;
- struct pa_io_event *e;
+static int dispatch_pollfds(pa_mainloop *m) {
+ uint32_t idx = PA_IDXSET_INVALID;
+ pa_io_event *e;
int r = 0;
- for (e = pa_idxset_first(m->io_events, &index); e && !m->quit; e = pa_idxset_next(m->io_events, &index)) {
+ for (e = pa_idxset_first(m->io_events, &idx); e && !m->quit; e = pa_idxset_next(m->io_events, &idx)) {
if (e->dead || !e->pollfd || !e->pollfd->revents)
continue;
return r;
}
-static int dispatch_defer(struct pa_mainloop *m) {
- uint32_t index;
- struct pa_defer_event *e;
+static int dispatch_defer(pa_mainloop *m) {
+ uint32_t idx;
+ pa_defer_event *e;
int r = 0;
if (!m->deferred_pending)
return 0;
- for (e = pa_idxset_first(m->defer_events, &index); e && !m->quit; e = pa_idxset_next(m->defer_events, &index)) {
+ for (e = pa_idxset_first(m->defer_events, &idx); e && !m->quit; e = pa_idxset_next(m->defer_events, &idx)) {
if (e->dead || !e->enabled)
continue;
return r;
}
-static int calc_next_timeout(struct pa_mainloop *m) {
- uint32_t index;
- struct pa_time_event *e;
+static int calc_next_timeout(pa_mainloop *m) {
+ uint32_t idx;
+ pa_time_event *e;
struct timeval now;
int t = -1;
int got_time = 0;
if (pa_idxset_isempty(m->time_events))
return -1;
- for (e = pa_idxset_first(m->time_events, &index); e; e = pa_idxset_next(m->time_events, &index)) {
+ for (e = pa_idxset_first(m->time_events, &idx); e; e = pa_idxset_next(m->time_events, &idx)) {
int tmp;
if (e->dead || !e->enabled)
return t;
}
-static int dispatch_timeout(struct pa_mainloop *m) {
- uint32_t index;
- struct pa_time_event *e;
+static int dispatch_timeout(pa_mainloop *m) {
+ uint32_t idx;
+ pa_time_event *e;
struct timeval now;
int got_time = 0;
int r = 0;
if (pa_idxset_isempty(m->time_events))
return 0;
- for (e = pa_idxset_first(m->time_events, &index); e && !m->quit; e = pa_idxset_next(m->time_events, &index)) {
+ for (e = pa_idxset_first(m->time_events, &idx); e && !m->quit; e = pa_idxset_next(m->time_events, &idx)) {
if (e->dead || !e->enabled)
continue;
return r;
}
-int pa_mainloop_iterate(struct pa_mainloop *m, int block, int *retval) {
+int pa_mainloop_iterate(pa_mainloop *m, int block, int *retval) {
int r, t, dispatched = 0;
assert(m && !m->running);
return -2;
}
-int pa_mainloop_run(struct pa_mainloop *m, int *retval) {
+int pa_mainloop_run(pa_mainloop *m, int *retval) {
int r;
while ((r = pa_mainloop_iterate(m, 1, retval)) >= 0);
return 0;
}
-void pa_mainloop_quit(struct pa_mainloop *m, int r) {
+void pa_mainloop_quit(pa_mainloop *m, int r) {
assert(m);
m->quit = r;
}
-struct pa_mainloop_api* pa_mainloop_get_api(struct pa_mainloop*m) {
+pa_mainloop_api* pa_mainloop_get_api(pa_mainloop*m) {
assert(m);
return &m->api;
}
-int pa_mainloop_deferred_pending(struct pa_mainloop *m) {
+int pa_mainloop_deferred_pending(pa_mainloop *m) {
assert(m);
return m->deferred_pending > 0;
}
-void pa_mainloop_dump(struct pa_mainloop *m) {
+#if 0
+void pa_mainloop_dump(pa_mainloop *m) {
assert(m);
pa_log(__FILE__": Dumping mainloop sources START\n");
{
- uint32_t index = PA_IDXSET_INVALID;
- struct pa_io_event *e;
- for (e = pa_idxset_first(m->io_events, &index); e; e = pa_idxset_next(m->io_events, &index)) {
+ uint32_t idx = PA_IDXSET_INVALID;
+ pa_io_event *e;
+ for (e = pa_idxset_first(m->io_events, &idx); e; e = pa_idxset_next(m->io_events, &idx)) {
if (e->dead)
continue;
}
}
{
- uint32_t index = PA_IDXSET_INVALID;
- struct pa_defer_event *e;
- for (e = pa_idxset_first(m->defer_events, &index); e; e = pa_idxset_next(m->defer_events, &index)) {
+ uint32_t idx = PA_IDXSET_INVALID;
+ pa_defer_event *e;
+ for (e = pa_idxset_first(m->defer_events, &idx); e; e = pa_idxset_next(m->defer_events, &idx)) {
if (e->dead)
continue;
}
}
{
- uint32_t index = PA_IDXSET_INVALID;
- struct pa_time_event *e;
- for (e = pa_idxset_first(m->time_events, &index); e; e = pa_idxset_next(m->time_events, &index)) {
+ uint32_t idx = PA_IDXSET_INVALID;
+ pa_time_event *e;
+ for (e = pa_idxset_first(m->time_events, &idx); e; e = pa_idxset_next(m->time_events, &idx)) {
if (e->dead)
continue;
pa_log(__FILE__": Dumping mainloop sources STOP\n");
}
+#endif
* defined in \ref mainloop-api.h. This implementation is thread safe
* as long as you access the main loop object from a single thread only.*/
-/** \struct pa_mainloop
+/** \pa_mainloop
* An opaque main loop object
*/
-struct pa_mainloop;
+typedef struct pa_mainloop pa_mainloop;
/** Allocate a new main loop object */
-struct pa_mainloop *pa_mainloop_new(void);
+pa_mainloop *pa_mainloop_new(void);
/** Free a main loop object */
-void pa_mainloop_free(struct pa_mainloop* m);
+void pa_mainloop_free(pa_mainloop* m);
/** Run a single iteration of the main loop. Returns a negative value
on error or exit request. If block is nonzero, block for events if
none are queued. Optionally return the return value as specified with
the main loop's quit() routine in the integer variable retval points
to. On success returns the number of source dispatched in this iteration. */
-int pa_mainloop_iterate(struct pa_mainloop *m, int block, int *retval);
+int pa_mainloop_iterate(pa_mainloop *m, int block, int *retval);
/** Run unlimited iterations of the main loop object until the main loop's quit() routine is called. */
-int pa_mainloop_run(struct pa_mainloop *m, int *retval);
+int pa_mainloop_run(pa_mainloop *m, int *retval);
/** Return the abstract main loop abstraction layer vtable for this main loop. This calls pa_mainloop_iterate() iteratively.*/
-struct pa_mainloop_api* pa_mainloop_get_api(struct pa_mainloop*m);
+pa_mainloop_api* pa_mainloop_get_api(pa_mainloop*m);
/** Return non-zero when there are any deferred events pending. \since 0.5 */
-int pa_mainloop_deferred_pending(struct pa_mainloop *m);
+int pa_mainloop_deferred_pending(pa_mainloop *m);
+
+/** Shutdown the main loop */
+void pa_mainloop_quit(pa_mainloop *m, int r);
PA_C_DECL_END
#include "util.h"
#include "mcalign.h"
+#include "gccmacro.h"
/* A simple program for testing pa_mcalign */
-int main(int argc, char *argv[]) {
- struct pa_mcalign *a = pa_mcalign_new(11, NULL);
- struct pa_memchunk c;
+int main(PA_GCC_UNUSED int argc, PA_GCC_UNUSED char *argv[]) {
+ pa_mcalign *a = pa_mcalign_new(11, NULL);
+ pa_memchunk c;
pa_memchunk_reset(&c);
}
for (;;) {
- struct pa_memchunk t;
+ pa_memchunk t;
if (pa_mcalign_pop(a, &t) < 0)
break;
struct pa_mcalign {
size_t base;
- struct pa_memchunk leftover, current;
- struct pa_memblock_stat *memblock_stat;
+ pa_memchunk leftover, current;
+ pa_memblock_stat *memblock_stat;
};
-struct pa_mcalign *pa_mcalign_new(size_t base, struct pa_memblock_stat *s) {
- struct pa_mcalign *m;
+pa_mcalign *pa_mcalign_new(size_t base, pa_memblock_stat *s) {
+ pa_mcalign *m;
assert(base);
- m = pa_xmalloc(sizeof(struct pa_mcalign));
+ m = pa_xnew(pa_mcalign, 1);
m->base = base;
pa_memchunk_reset(&m->leftover);
pa_memchunk_reset(&m->current);
return m;
}
-void pa_mcalign_free(struct pa_mcalign *m) {
+void pa_mcalign_free(pa_mcalign *m) {
assert(m);
if (m->leftover.memblock)
pa_xfree(m);
}
-void pa_mcalign_push(struct pa_mcalign *m, const struct pa_memchunk *c) {
+void pa_mcalign_push(pa_mcalign *m, const pa_memchunk *c) {
assert(m && c && c->memblock && c->length);
/* Append to the leftover memory block */
}
}
-int pa_mcalign_pop(struct pa_mcalign *m, struct pa_memchunk *c) {
+int pa_mcalign_pop(pa_mcalign *m, pa_memchunk *c) {
assert(m && c);
/* First test if there's a leftover memory block available */
* 0, the memchunk *c is valid and aligned to the granularity. Some
* pseudocode illustrating this:
*
- * struct pa_mcalign *a = pa_mcalign_new(4, NULL);
+ * pa_mcalign *a = pa_mcalign_new(4, NULL);
*
* for (;;) {
- * struct pa_memchunk input;
+ * pa_memchunk input;
*
* ... fill input ...
*
* pa_memblock_unref(input.memblock);
*
* for (;;) {
- * struct pa_memchunk output;
+ * pa_memchunk output;
*
* if (pa_mcalign_pop(m, &output) < 0)
* break;
* pa_memchunk_free(a);
* */
-struct pa_mcalign;
+typedef struct pa_mcalign pa_mcalign;
-struct pa_mcalign *pa_mcalign_new(size_t base, struct pa_memblock_stat *s);
-void pa_mcalign_free(struct pa_mcalign *m);
+pa_mcalign *pa_mcalign_new(size_t base, pa_memblock_stat *s);
+void pa_mcalign_free(pa_mcalign *m);
/* Push a new memchunk into the aligner. The caller of this routine
* has to free the memchunk by himself. */
-void pa_mcalign_push(struct pa_mcalign *m, const struct pa_memchunk *c);
+void pa_mcalign_push(pa_mcalign *m, const pa_memchunk *c);
/* Pop a new memchunk from the aligner. Returns 0 when sucessful,
* nonzero otherwise. */
-int pa_mcalign_pop(struct pa_mcalign *m, struct pa_memchunk *c);
+int pa_mcalign_pop(pa_mcalign *m, pa_memchunk *c);
#endif
#include "memblock.h"
#include "xmalloc.h"
-static void stat_add(struct pa_memblock*m, struct pa_memblock_stat *s) {
+static void stat_add(pa_memblock*m, pa_memblock_stat *s) {
assert(m);
if (!s) {
s->allocated_size += m->length;
}
-static void stat_remove(struct pa_memblock *m) {
+static void stat_remove(pa_memblock *m) {
assert(m);
if (!m->stat)
m->stat = NULL;
}
-struct pa_memblock *pa_memblock_new(size_t length, struct pa_memblock_stat*s) {
- struct pa_memblock *b = pa_xmalloc(sizeof(struct pa_memblock)+length);
+pa_memblock *pa_memblock_new(size_t length, pa_memblock_stat*s) {
+ pa_memblock *b = pa_xmalloc(sizeof(pa_memblock)+length);
b->type = PA_MEMBLOCK_APPENDED;
b->ref = 1;
b->length = length;
return b;
}
-struct pa_memblock *pa_memblock_new_dynamic(void *d, size_t length, struct pa_memblock_stat*s) {
- struct pa_memblock *b = pa_xmalloc(sizeof(struct pa_memblock));
+pa_memblock *pa_memblock_new_dynamic(void *d, size_t length, pa_memblock_stat*s) {
+ pa_memblock *b = pa_xmalloc(sizeof(pa_memblock));
b->type = PA_MEMBLOCK_DYNAMIC;
b->ref = 1;
b->length = length;
return b;
}
-struct pa_memblock *pa_memblock_new_fixed(void *d, size_t length, int read_only, struct pa_memblock_stat*s) {
- struct pa_memblock *b = pa_xmalloc(sizeof(struct pa_memblock));
+pa_memblock *pa_memblock_new_fixed(void *d, size_t length, int read_only, pa_memblock_stat*s) {
+ pa_memblock *b = pa_xmalloc(sizeof(pa_memblock));
b->type = PA_MEMBLOCK_FIXED;
b->ref = 1;
b->length = length;
return b;
}
-struct pa_memblock *pa_memblock_new_user(void *d, size_t length, void (*free_cb)(void *p), int read_only, struct pa_memblock_stat*s) {
- struct pa_memblock *b;
+pa_memblock *pa_memblock_new_user(void *d, size_t length, void (*free_cb)(void *p), int read_only, pa_memblock_stat*s) {
+ pa_memblock *b;
assert(d && length && free_cb);
- b = pa_xmalloc(sizeof(struct pa_memblock));
+ b = pa_xmalloc(sizeof(pa_memblock));
b->type = PA_MEMBLOCK_USER;
b->ref = 1;
b->length = length;
return b;
}
-struct pa_memblock* pa_memblock_ref(struct pa_memblock*b) {
+pa_memblock* pa_memblock_ref(pa_memblock*b) {
assert(b && b->ref >= 1);
b->ref++;
return b;
}
-void pa_memblock_unref(struct pa_memblock*b) {
+void pa_memblock_unref(pa_memblock*b) {
assert(b && b->ref >= 1);
if ((--(b->ref)) == 0) {
}
}
-void pa_memblock_unref_fixed(struct pa_memblock *b) {
+void pa_memblock_unref_fixed(pa_memblock *b) {
assert(b && b->ref >= 1 && b->type == PA_MEMBLOCK_FIXED);
if (b->ref == 1)
}
}
-struct pa_memblock_stat* pa_memblock_stat_new(void) {
- struct pa_memblock_stat *s;
+pa_memblock_stat* pa_memblock_stat_new(void) {
+ pa_memblock_stat *s;
- s = pa_xmalloc(sizeof(struct pa_memblock_stat));
+ s = pa_xmalloc(sizeof(pa_memblock_stat));
s->ref = 1;
s->total = s->total_size = s->allocated = s->allocated_size = 0;
return s;
}
-void pa_memblock_stat_unref(struct pa_memblock_stat *s) {
+void pa_memblock_stat_unref(pa_memblock_stat *s) {
assert(s && s->ref >= 1);
if (!(--(s->ref))) {
}
}
-struct pa_memblock_stat * pa_memblock_stat_ref(struct pa_memblock_stat *s) {
+pa_memblock_stat * pa_memblock_stat_ref(pa_memblock_stat *s) {
assert(s);
s->ref++;
return s;
* memory blocks. */
/* The type of memory this block points to */
-enum pa_memblock_type {
+typedef enum {
PA_MEMBLOCK_FIXED, /* data is a pointer to fixed memory that needs not to be freed */
PA_MEMBLOCK_APPENDED, /* The most common kind: the data is appended to the memory block */
PA_MEMBLOCK_DYNAMIC, /* data is a pointer to some memory allocated with pa_xmalloc() */
PA_MEMBLOCK_USER /* User supplied memory, to be freed with free_cb */
-};
+} pa_memblock_type ;
/* A structure of keeping memory block statistics */
-struct pa_memblock_stat;
+/* Maintains statistics about memory blocks */
+typedef struct pa_memblock_stat {
+ int ref;
+ unsigned total;
+ unsigned total_size;
+ unsigned allocated;
+ unsigned allocated_size;
+} pa_memblock_stat;
-struct pa_memblock {
- enum pa_memblock_type type;
+typedef struct pa_memblock {
+ pa_memblock_type type;
unsigned ref; /* the reference counter */
int read_only; /* boolean */
size_t length;
void *data;
void (*free_cb)(void *p); /* If type == PA_MEMBLOCK_USER this points to a function for freeing this memory block */
- struct pa_memblock_stat *stat;
-};
+ pa_memblock_stat *stat;
+} pa_memblock;
/* Allocate a new memory block of type PA_MEMBLOCK_APPENDED */
-struct pa_memblock *pa_memblock_new(size_t length, struct pa_memblock_stat*s);
+pa_memblock *pa_memblock_new(size_t length, pa_memblock_stat*s);
/* Allocate a new memory block of type PA_MEMBLOCK_DYNAMIC. The pointer data is to be maintained be the memory block */
-struct pa_memblock *pa_memblock_new_dynamic(void *data, size_t length, struct pa_memblock_stat*s);
+pa_memblock *pa_memblock_new_dynamic(void *data, size_t length, pa_memblock_stat*s);
/* Allocate a new memory block of type PA_MEMBLOCK_FIXED */
-struct pa_memblock *pa_memblock_new_fixed(void *data, size_t length, int read_only, struct pa_memblock_stat*s);
+pa_memblock *pa_memblock_new_fixed(void *data, size_t length, int read_only, pa_memblock_stat*s);
/* Allocate a new memory block of type PA_MEMBLOCK_USER */
-struct pa_memblock *pa_memblock_new_user(void *data, size_t length, void (*free_cb)(void *p), int read_only, struct pa_memblock_stat*s);
+pa_memblock *pa_memblock_new_user(void *data, size_t length, void (*free_cb)(void *p), int read_only, pa_memblock_stat*s);
-void pa_memblock_unref(struct pa_memblock*b);
-struct pa_memblock* pa_memblock_ref(struct pa_memblock*b);
+void pa_memblock_unref(pa_memblock*b);
+pa_memblock* pa_memblock_ref(pa_memblock*b);
/* This special unref function has to be called by the owner of the
memory of a static memory block when he wants to release all
references to the memory. This causes the memory to be copied and
converted into a PA_MEMBLOCK_DYNAMIC type memory block */
-void pa_memblock_unref_fixed(struct pa_memblock*b);
+void pa_memblock_unref_fixed(pa_memblock*b);
-/* Matinatins statistics about memory blocks */
-struct pa_memblock_stat {
- int ref;
- unsigned total;
- unsigned total_size;
- unsigned allocated;
- unsigned allocated_size;
-};
-struct pa_memblock_stat* pa_memblock_stat_new(void);
-void pa_memblock_stat_unref(struct pa_memblock_stat *s);
-struct pa_memblock_stat * pa_memblock_stat_ref(struct pa_memblock_stat *s);
+pa_memblock_stat* pa_memblock_stat_new(void);
+void pa_memblock_stat_unref(pa_memblock_stat *s);
+pa_memblock_stat * pa_memblock_stat_ref(pa_memblock_stat *s);
#endif
struct memblock_list {
struct memblock_list *next, *prev;
- struct pa_memchunk chunk;
+ pa_memchunk chunk;
};
struct pa_memblockq {
struct memblock_list *blocks, *blocks_tail;
unsigned n_blocks;
size_t current_length, maxlength, tlength, base, prebuf, orig_prebuf, minreq;
- struct pa_mcalign *mcalign;
- struct pa_memblock_stat *memblock_stat;
+ pa_mcalign *mcalign;
+ pa_memblock_stat *memblock_stat;
};
-struct pa_memblockq* pa_memblockq_new(size_t maxlength, size_t tlength, size_t base, size_t prebuf, size_t minreq, struct pa_memblock_stat *s) {
- struct pa_memblockq* bq;
+pa_memblockq* pa_memblockq_new(size_t maxlength, size_t tlength, size_t base, size_t prebuf, size_t minreq, pa_memblock_stat *s) {
+ pa_memblockq* bq;
assert(maxlength && base && maxlength);
- bq = pa_xmalloc(sizeof(struct pa_memblockq));
+ bq = pa_xmalloc(sizeof(pa_memblockq));
bq->blocks = bq->blocks_tail = 0;
bq->n_blocks = 0;
return bq;
}
-void pa_memblockq_free(struct pa_memblockq* bq) {
+void pa_memblockq_free(pa_memblockq* bq) {
assert(bq);
pa_memblockq_flush(bq);
pa_xfree(bq);
}
-void pa_memblockq_push(struct pa_memblockq* bq, const struct pa_memchunk *chunk, size_t delta) {
+void pa_memblockq_push(pa_memblockq* bq, const pa_memchunk *chunk, size_t delta) {
struct memblock_list *q;
assert(bq && chunk && chunk->memblock && chunk->length && (chunk->length % bq->base) == 0);
pa_memblockq_shorten(bq, bq->maxlength);
}
-int pa_memblockq_peek(struct pa_memblockq* bq, struct pa_memchunk *chunk) {
+int pa_memblockq_peek(pa_memblockq* bq, pa_memchunk *chunk) {
assert(bq && chunk);
if (!bq->blocks || bq->current_length < bq->prebuf)
return 0;
}
-void pa_memblockq_drop(struct pa_memblockq *bq, const struct pa_memchunk *chunk, size_t length) {
+void pa_memblockq_drop(pa_memblockq *bq, const pa_memchunk *chunk, size_t length) {
assert(bq && chunk && length);
- if (!bq->blocks || memcmp(&bq->blocks->chunk, chunk, sizeof(struct pa_memchunk)))
+ if (!bq->blocks || memcmp(&bq->blocks->chunk, chunk, sizeof(pa_memchunk)))
return;
assert(length <= bq->blocks->chunk.length);
pa_memblockq_skip(bq, length);
}
-static void remove_block(struct pa_memblockq *bq, struct memblock_list *q) {
+static void remove_block(pa_memblockq *bq, struct memblock_list *q) {
assert(bq && q);
if (q->prev)
bq->n_blocks--;
}
-void pa_memblockq_skip(struct pa_memblockq *bq, size_t length) {
+void pa_memblockq_skip(pa_memblockq *bq, size_t length) {
assert(bq && length && (length % bq->base) == 0);
while (length > 0) {
}
}
-void pa_memblockq_shorten(struct pa_memblockq *bq, size_t length) {
+void pa_memblockq_shorten(pa_memblockq *bq, size_t length) {
size_t l;
assert(bq);
}
-void pa_memblockq_empty(struct pa_memblockq *bq) {
+void pa_memblockq_empty(pa_memblockq *bq) {
assert(bq);
pa_memblockq_shorten(bq, 0);
}
-int pa_memblockq_is_readable(struct pa_memblockq *bq) {
+int pa_memblockq_is_readable(pa_memblockq *bq) {
assert(bq);
return bq->current_length && (bq->current_length >= bq->prebuf);
}
-int pa_memblockq_is_writable(struct pa_memblockq *bq, size_t length) {
+int pa_memblockq_is_writable(pa_memblockq *bq, size_t length) {
assert(bq);
return bq->current_length + length <= bq->tlength;
}
-uint32_t pa_memblockq_get_length(struct pa_memblockq *bq) {
+uint32_t pa_memblockq_get_length(pa_memblockq *bq) {
assert(bq);
return bq->current_length;
}
-uint32_t pa_memblockq_missing(struct pa_memblockq *bq) {
+uint32_t pa_memblockq_missing(pa_memblockq *bq) {
size_t l;
assert(bq);
return (l >= bq->minreq) ? l : 0;
}
-void pa_memblockq_push_align(struct pa_memblockq* bq, const struct pa_memchunk *chunk, size_t delta) {
- struct pa_memchunk rchunk;
+void pa_memblockq_push_align(pa_memblockq* bq, const pa_memchunk *chunk, size_t delta) {
+ pa_memchunk rchunk;
assert(bq && chunk && bq->base);
if (bq->base == 1) {
}
}
-uint32_t pa_memblockq_get_minreq(struct pa_memblockq *bq) {
+uint32_t pa_memblockq_get_minreq(pa_memblockq *bq) {
assert(bq);
return bq->minreq;
}
-void pa_memblockq_prebuf_disable(struct pa_memblockq *bq) {
+void pa_memblockq_prebuf_disable(pa_memblockq *bq) {
assert(bq);
bq->prebuf = 0;
}
-void pa_memblockq_prebuf_reenable(struct pa_memblockq *bq) {
+void pa_memblockq_prebuf_reenable(pa_memblockq *bq) {
assert(bq);
bq->prebuf = bq->orig_prebuf;
}
-void pa_memblockq_seek(struct pa_memblockq *bq, size_t length) {
+void pa_memblockq_seek(pa_memblockq *bq, size_t length) {
assert(bq);
if (!length)
}
}
-void pa_memblockq_flush(struct pa_memblockq *bq) {
+void pa_memblockq_flush(pa_memblockq *bq) {
struct memblock_list *l;
assert(bq);
bq->current_length = 0;
}
-uint32_t pa_memblockq_get_tlength(struct pa_memblockq *bq) {
+uint32_t pa_memblockq_get_tlength(pa_memblockq *bq) {
assert(bq);
return bq->tlength;
}
* type doesn't need to copy any data around, it just maintains
* references to reference counted memory blocks. */
-struct pa_memblockq;
+typedef struct pa_memblockq pa_memblockq;
/* Parameters:
- maxlength: maximum length of queue. If more data is pushed into the queue, data from the front is dropped
- prebuf: before passing the first byte out, make sure that enough bytes are in the queue
- minreq: pa_memblockq_missing() will only return values greater than this value
*/
-struct pa_memblockq* pa_memblockq_new(size_t maxlength,
+pa_memblockq* pa_memblockq_new(size_t maxlength,
size_t tlength,
size_t base,
size_t prebuf,
size_t minreq,
- struct pa_memblock_stat *s);
-void pa_memblockq_free(struct pa_memblockq*bq);
+ pa_memblock_stat *s);
+void pa_memblockq_free(pa_memblockq*bq);
/* Push a new memory chunk into the queue. Optionally specify a value for future cancellation. */
-void pa_memblockq_push(struct pa_memblockq* bq, const struct pa_memchunk *chunk, size_t delta);
+void pa_memblockq_push(pa_memblockq* bq, const pa_memchunk *chunk, size_t delta);
/* Same as pa_memblockq_push(), however chunks are filtered through a mcalign object, and thus aligned to multiples of base */
-void pa_memblockq_push_align(struct pa_memblockq* bq, const struct pa_memchunk *chunk, size_t delta);
+void pa_memblockq_push_align(pa_memblockq* bq, const pa_memchunk *chunk, size_t delta);
/* Return a copy of the next memory chunk in the queue. It is not removed from the queue */
-int pa_memblockq_peek(struct pa_memblockq* bq, struct pa_memchunk *chunk);
+int pa_memblockq_peek(pa_memblockq* bq, pa_memchunk *chunk);
/* Drop the specified bytes from the queue, only valid aufter pa_memblockq_peek() */
-void pa_memblockq_drop(struct pa_memblockq *bq, const struct pa_memchunk *chunk, size_t length);
+void pa_memblockq_drop(pa_memblockq *bq, const pa_memchunk *chunk, size_t length);
/* Drop the specified bytes from the queue */
-void pa_memblockq_skip(struct pa_memblockq *bq, size_t length);
+void pa_memblockq_skip(pa_memblockq *bq, size_t length);
/* Shorten the pa_memblockq to the specified length by dropping data at the end of the queue */
-void pa_memblockq_shorten(struct pa_memblockq *bq, size_t length);
+void pa_memblockq_shorten(pa_memblockq *bq, size_t length);
/* Empty the pa_memblockq */
-void pa_memblockq_empty(struct pa_memblockq *bq);
+void pa_memblockq_empty(pa_memblockq *bq);
/* Test if the pa_memblockq is currently readable, that is, more data than base */
-int pa_memblockq_is_readable(struct pa_memblockq *bq);
+int pa_memblockq_is_readable(pa_memblockq *bq);
/* Test if the pa_memblockq is currently writable for the specified amount of bytes */
-int pa_memblockq_is_writable(struct pa_memblockq *bq, size_t length);
+int pa_memblockq_is_writable(pa_memblockq *bq, size_t length);
/* Return the length of the queue in bytes */
-uint32_t pa_memblockq_get_length(struct pa_memblockq *bq);
+uint32_t pa_memblockq_get_length(pa_memblockq *bq);
/* Return how many bytes are missing in queue to the specified fill amount */
-uint32_t pa_memblockq_missing(struct pa_memblockq *bq);
+uint32_t pa_memblockq_missing(pa_memblockq *bq);
/* Returns the minimal request value */
-uint32_t pa_memblockq_get_minreq(struct pa_memblockq *bq);
+uint32_t pa_memblockq_get_minreq(pa_memblockq *bq);
/* Force disabling of pre-buf even when the pre-buffer is not yet filled */
-void pa_memblockq_prebuf_disable(struct pa_memblockq *bq);
+void pa_memblockq_prebuf_disable(pa_memblockq *bq);
/* Reenable pre-buf to the initial level */
-void pa_memblockq_prebuf_reenable(struct pa_memblockq *bq);
+void pa_memblockq_prebuf_reenable(pa_memblockq *bq);
/* Manipulate the write pointer */
-void pa_memblockq_seek(struct pa_memblockq *bq, size_t delta);
+void pa_memblockq_seek(pa_memblockq *bq, size_t delta);
/* Flush the queue */
-void pa_memblockq_flush(struct pa_memblockq *bq);
+void pa_memblockq_flush(pa_memblockq *bq);
/* Get Target length */
-uint32_t pa_memblockq_get_tlength(struct pa_memblockq *bq);
+uint32_t pa_memblockq_get_tlength(pa_memblockq *bq);
#endif
#include "memchunk.h"
#include "xmalloc.h"
-void pa_memchunk_make_writable(struct pa_memchunk *c, struct pa_memblock_stat *s, size_t min) {
- struct pa_memblock *n;
+void pa_memchunk_make_writable(pa_memchunk *c, pa_memblock_stat *s, size_t min) {
+ pa_memblock *n;
size_t l;
assert(c && c->memblock && c->memblock->ref >= 1);
c->index = 0;
}
-void pa_memchunk_reset(struct pa_memchunk *c) {
+void pa_memchunk_reset(pa_memchunk *c) {
assert(c);
c->memblock = NULL;
#include "memblock.h"
-/* A memchunk is a part of a memblock. In contrast to the memblock, a
+/* A memchunk describes a part of a memblock. In contrast to the memblock, a
* memchunk is not allocated dynamically or reference counted, instead
* it is usually stored on the stack and copied around */
-struct pa_memchunk {
- struct pa_memblock *memblock;
+typedef struct pa_memchunk {
+ pa_memblock *memblock;
size_t index, length;
-};
+} pa_memchunk;
/* Make a memchunk writable, i.e. make sure that the caller may have
* exclusive access to the memblock and it is not read_only. If needed
* the memblock in the structure is replaced by a copy. */
-void pa_memchunk_make_writable(struct pa_memchunk *c, struct pa_memblock_stat *s, size_t min);
+void pa_memchunk_make_writable(pa_memchunk *c, pa_memblock_stat *s, size_t min);
/* Invalidate a memchunk. This does not free the cotaining memblock,
* but sets all members to zero. */
-void pa_memchunk_reset(struct pa_memchunk *c);
+void pa_memchunk_reset(pa_memchunk *c);
#endif
#include "xmalloc.h"
#include "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[]) {
+static int add_key_value(pa_hashmap *map, char *key, char *value, const char* const valid_keys[]) {
struct entry *e;
assert(map && key && value);
return 0;
}
-struct pa_modargs *pa_modargs_new(const char *args, const char* const* valid_keys) {
- struct pa_hashmap *map = NULL;
+pa_modargs *pa_modargs_new(const char *args, const char* const* valid_keys) {
+ pa_hashmap *map = NULL;
map = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
assert(map);
goto fail;
}
- return (struct pa_modargs*) map;
+ return (pa_modargs*) map;
fail:
if (map)
- pa_modargs_free((struct pa_modargs*) map);
+ pa_modargs_free((pa_modargs*) map);
return NULL;
}
-static void free_func(void *p, void*userdata) {
+static void free_func(void *p, PA_GCC_UNUSED void*userdata) {
struct entry *e = p;
assert(e);
pa_xfree(e->key);
pa_xfree(e);
}
-void pa_modargs_free(struct pa_modargs*ma) {
- struct pa_hashmap *map = (struct pa_hashmap*) ma;
+void pa_modargs_free(pa_modargs*ma) {
+ pa_hashmap *map = (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;
+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)))
return e->value;
}
-int pa_modargs_get_value_u32(struct pa_modargs *ma, const char *key, uint32_t *value) {
+int pa_modargs_get_value_u32(pa_modargs *ma, const char *key, uint32_t *value) {
const char *v;
assert(ma && key && value);
return 0;
}
-int pa_modargs_get_value_s32(struct pa_modargs *ma, const char *key, int32_t *value) {
+int pa_modargs_get_value_s32(pa_modargs *ma, const char *key, int32_t *value) {
const char *v;
assert(ma && key && value);
return 0;
}
-int pa_modargs_get_value_boolean(struct pa_modargs *ma, const char *key, int *value) {
+int pa_modargs_get_value_boolean(pa_modargs *ma, const char *key, int *value) {
const char *v;
int r;
assert(ma && key && value);
return 0;
}
-int pa_modargs_get_sample_spec(struct pa_modargs *ma, struct pa_sample_spec *rss) {
+int pa_modargs_get_sample_spec(pa_modargs *ma, pa_sample_spec *rss) {
const char *format;
uint32_t channels;
- struct pa_sample_spec ss;
+ pa_sample_spec ss;
assert(ma && rss);
/* DEBUG_TRAP;*/
#include "sample.h"
#include "core.h"
-struct pa_modargs;
+typedef struct pa_modargs pa_modargs;
/* A generic parser for module arguments */
/* Parse the string args. The NULL-terminated array keys contains all valid arguments. */
-struct pa_modargs *pa_modargs_new(const char *args, const char* const keys[]);
-void pa_modargs_free(struct pa_modargs*ma);
+pa_modargs *pa_modargs_new(const char *args, const char* const keys[]);
+void pa_modargs_free(pa_modargs*ma);
/* Return the module argument for the specified name as a string. If
* the argument was not specified, return def instead.*/
-const char *pa_modargs_get_value(struct pa_modargs *ma, const char *key, const char *def);
+const char *pa_modargs_get_value(pa_modargs *ma, const char *key, const char *def);
/* Return a module argument as unsigned 32bit value in *value */
-int pa_modargs_get_value_u32(struct pa_modargs *ma, const char *key, uint32_t *value);
-int pa_modargs_get_value_s32(struct pa_modargs *ma, const char *key, int32_t *value);
-int pa_modargs_get_value_boolean(struct pa_modargs *ma, const char *key, int *value);
+int pa_modargs_get_value_u32(pa_modargs *ma, const char *key, uint32_t *value);
+int pa_modargs_get_value_s32(pa_modargs *ma, const char *key, int32_t *value);
+int pa_modargs_get_value_boolean(pa_modargs *ma, const char *key, int *value);
/* Return sample spec data from the three arguments "rate", "format" and "channels" */
-int pa_modargs_get_sample_spec(struct pa_modargs *ma, struct pa_sample_spec *ss);
+int pa_modargs_get_sample_spec(pa_modargs *ma, pa_sample_spec *ss);
#endif
#define PA_SYMBOL_USAGE "pa__get_usage"
#define PA_SYMBOL_VERSION "pa__get_version"
-struct pa_modinfo *pa_modinfo_get_by_handle(lt_dlhandle dl) {
- struct pa_modinfo *i;
+pa_modinfo *pa_modinfo_get_by_handle(lt_dlhandle dl) {
+ pa_modinfo *i;
const char* (*func)(void);
assert(dl);
- i = pa_xmalloc0(sizeof(struct pa_modinfo));
+ i = pa_xmalloc0(sizeof(pa_modinfo));
if ((func = (const char* (*)(void)) lt_dlsym(dl, PA_SYMBOL_AUTHOR)))
i->author = pa_xstrdup(func());
return i;
}
-struct pa_modinfo *pa_modinfo_get_by_name(const char *name) {
+pa_modinfo *pa_modinfo_get_by_name(const char *name) {
lt_dlhandle dl;
- struct pa_modinfo *i;
+ pa_modinfo *i;
assert(name);
if (!(dl = lt_dlopenext(name))) {
return i;
}
-void pa_modinfo_free(struct pa_modinfo *i) {
+void pa_modinfo_free(pa_modinfo *i) {
assert(i);
pa_xfree(i->author);
pa_xfree(i->description);
/* Some functions for reading module meta data from Polypaudio modules */
-struct pa_modinfo {
+typedef struct pa_modinfo {
char *author;
char *description;
char *usage;
char *version;
-};
+} pa_modinfo;
/* Read meta data from an libtool handle */
-struct pa_modinfo *pa_modinfo_get_by_handle(lt_dlhandle dl);
+pa_modinfo *pa_modinfo_get_by_handle(lt_dlhandle dl);
/* Read meta data from a module file */
-struct pa_modinfo *pa_modinfo_get_by_name(const char *name);
+pa_modinfo *pa_modinfo_get_by_name(const char *name);
/* Free meta data */
-void pa_modinfo_free(struct pa_modinfo *i);
+void pa_modinfo_free(pa_modinfo *i);
#endif
struct userdata {
snd_pcm_t *pcm_handle;
- struct pa_sink *sink;
- struct pa_io_event **io_events;
+ pa_sink *sink;
+ pa_io_event **io_events;
unsigned n_io_events;
size_t frame_size, fragment_size;
- struct pa_memchunk memchunk, silence;
- struct pa_module *module;
+ pa_memchunk memchunk, silence;
+ pa_module *module;
};
static const char* const valid_modargs[] = {
static void update_usage(struct userdata *u) {
pa_module_set_used(u->module,
- (u->sink ? pa_idxset_ncontents(u->sink->inputs) : 0) +
- (u->sink ? pa_idxset_ncontents(u->sink->monitor_source->outputs) : 0));
+ (u->sink ? pa_idxset_size(u->sink->inputs) : 0) +
+ (u->sink ? pa_idxset_size(u->sink->monitor_source->outputs) : 0));
}
static void xrun_recovery(struct userdata *u) {
update_usage(u);
for (;;) {
- struct pa_memchunk *memchunk = NULL;
+ pa_memchunk *memchunk = NULL;
snd_pcm_sframes_t frames;
if (u->memchunk.memblock)
}
}
-static void io_callback(struct pa_mainloop_api*a, struct pa_io_event *e, int fd, enum pa_io_event_flags f, void *userdata) {
+static void io_callback(pa_mainloop_api*a, pa_io_event *e, PA_GCC_UNUSED int fd, PA_GCC_UNUSED pa_io_event_flags f, void *userdata) {
struct userdata *u = userdata;
assert(u && a && e);
do_write(u);
}
-static pa_usec_t sink_get_latency_cb(struct pa_sink *s) {
+static pa_usec_t sink_get_latency_cb(pa_sink *s) {
pa_usec_t r = 0;
struct userdata *u = s->userdata;
snd_pcm_sframes_t frames;
return r;
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
- struct pa_modargs *ma = NULL;
+int pa__init(pa_core *c, pa_module*m) {
+ pa_modargs *ma = NULL;
int ret = -1;
struct userdata *u = NULL;
const char *dev;
- struct pa_sample_spec ss;
+ pa_sample_spec ss;
uint32_t periods, fragsize;
snd_pcm_uframes_t period_size;
size_t frame_size;
goto finish;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata *u;
assert(c && m);
struct userdata {
snd_pcm_t *pcm_handle;
- struct pa_source *source;
- struct pa_io_event **io_events;
+ pa_source *source;
+ pa_io_event **io_events;
unsigned n_io_events;
size_t frame_size, fragment_size;
- struct pa_memchunk memchunk;
- struct pa_module *module;
+ pa_memchunk memchunk;
+ pa_module *module;
};
static const char* const valid_modargs[] = {
static void update_usage(struct userdata *u) {
pa_module_set_used(u->module,
- (u->source ? pa_idxset_ncontents(u->source->outputs) : 0));
+ (u->source ? pa_idxset_size(u->source->outputs) : 0));
}
static void xrun_recovery(struct userdata *u) {
update_usage(u);
for (;;) {
- struct pa_memchunk post_memchunk;
+ pa_memchunk post_memchunk;
snd_pcm_sframes_t frames;
size_t l;
}
}
-static void io_callback(struct pa_mainloop_api*a, struct pa_io_event *e, int fd, enum pa_io_event_flags f, void *userdata) {
+static void io_callback(pa_mainloop_api*a, pa_io_event *e, PA_GCC_UNUSED int fd, PA_GCC_UNUSED pa_io_event_flags f, void *userdata) {
struct userdata *u = userdata;
assert(u && a && e);
do_read(u);
}
-static pa_usec_t source_get_latency_cb(struct pa_source *s) {
+static pa_usec_t source_get_latency_cb(pa_source *s) {
struct userdata *u = s->userdata;
snd_pcm_sframes_t frames;
assert(s && u && u->source);
return pa_bytes_to_usec(frames * u->frame_size, &s->sample_spec);
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
- struct pa_modargs *ma = NULL;
+int pa__init(pa_core *c, pa_module*m) {
+ pa_modargs *ma = NULL;
int ret = -1;
struct userdata *u = NULL;
const char *dev;
- struct pa_sample_spec ss;
+ pa_sample_spec ss;
unsigned periods, fragsize;
snd_pcm_uframes_t period_size;
size_t frame_size;
goto finish;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata *u;
assert(c && m);
PA_MODULE_VERSION(PACKAGE_VERSION)
PA_MODULE_USAGE("No arguments")
-static void eof_cb(struct pa_cli*c, void *userdata) {
- struct pa_module *m = userdata;
+static void eof_cb(pa_cli*c, void *userdata) {
+ pa_module *m = userdata;
assert(c && m);
pa_module_unload_request(m);
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
- struct pa_iochannel *io;
+int pa__init(pa_core *c, pa_module*m) {
+ pa_iochannel *io;
assert(c && m);
if (c->running_as_daemon) {
return 0;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
assert(c && m);
if (c->running_as_daemon == 0) {
struct output {
struct userdata *userdata;
- struct pa_sink_input *sink_input;
+ pa_sink_input *sink_input;
size_t counter;
- struct pa_memblockq *memblockq;
+ pa_memblockq *memblockq;
pa_usec_t total_latency;
PA_LLIST_FIELDS(struct output);
};
struct userdata {
- struct pa_module *module;
- struct pa_core *core;
- struct pa_sink *sink;
+ pa_module *module;
+ pa_core *core;
+ pa_sink *sink;
unsigned n_outputs;
struct output *master;
- struct pa_time_event *time_event;
+ pa_time_event *time_event;
uint32_t adjust_time;
PA_LLIST_HEAD(struct output, outputs);
static void update_usage(struct userdata *u) {
pa_module_set_used(u->module,
- (u->sink ? pa_idxset_ncontents(u->sink->inputs) : 0) +
- (u->sink ? pa_idxset_ncontents(u->sink->monitor_source->outputs) : 0));
+ (u->sink ? pa_idxset_size(u->sink->inputs) : 0) +
+ (u->sink ? pa_idxset_size(u->sink->monitor_source->outputs) : 0));
}
}
static void request_memblock(struct userdata *u) {
- struct pa_memchunk chunk;
+ pa_memchunk chunk;
struct output *o;
assert(u && u->sink);
pa_memblock_unref(chunk.memblock);
}
-static void time_callback(struct pa_mainloop_api*a, struct pa_time_event* e, const struct timeval *tv, void *userdata) {
+static void time_callback(pa_mainloop_api*a, pa_time_event* e, PA_GCC_UNUSED const struct timeval *tv, void *userdata) {
struct userdata *u = userdata;
struct timeval n;
assert(u && a && u->time_event == e);
u->sink->core->mainloop->time_restart(e, &n);
}
-static int sink_input_peek_cb(struct pa_sink_input *i, struct pa_memchunk *chunk) {
+static int sink_input_peek_cb(pa_sink_input *i, pa_memchunk *chunk) {
struct output *o = i->userdata;
assert(i && o && o->sink_input && chunk);
return pa_memblockq_peek(o->memblockq, chunk);
}
-static void sink_input_drop_cb(struct pa_sink_input *i, const struct pa_memchunk *chunk, size_t length) {
+static void sink_input_drop_cb(pa_sink_input *i, const pa_memchunk *chunk, size_t length) {
struct output *o = i->userdata;
assert(i && o && o->sink_input && chunk && length);
o->counter += length;
}
-static void sink_input_kill_cb(struct pa_sink_input *i) {
+static void sink_input_kill_cb(pa_sink_input *i) {
struct output *o = i->userdata;
assert(i && o && o->sink_input);
pa_module_unload_request(o->userdata->module);
clear_up(o->userdata);
}
-static pa_usec_t sink_input_get_latency_cb(struct pa_sink_input *i) {
+static pa_usec_t sink_input_get_latency_cb(pa_sink_input *i) {
struct output *o = i->userdata;
assert(i && o && o->sink_input);
return pa_bytes_to_usec(pa_memblockq_get_length(o->memblockq), &i->sample_spec);
}
-static pa_usec_t sink_get_latency_cb(struct pa_sink *s) {
+static pa_usec_t sink_get_latency_cb(pa_sink *s) {
struct userdata *u = s->userdata;
assert(s && u && u->sink && u->master);
return pa_sink_input_get_latency(u->master->sink_input);
}
-static struct output *output_new(struct userdata *u, struct pa_sink *sink, int resample_method) {
+static struct output *output_new(struct userdata *u, pa_sink *sink, int resample_method) {
struct output *o = NULL;
char t[256];
assert(u && sink && u->sink);
}
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
+int pa__init(pa_core *c, pa_module*m) {
struct userdata *u;
- struct pa_modargs *ma = NULL;
+ pa_modargs *ma = NULL;
const char *master_name, *slaves, *rm;
- struct pa_sink *master_sink;
+ pa_sink *master_sink;
char *n = NULL;
const char*split_state;
struct timeval tv;
split_state = NULL;
while ((n = pa_split(slaves, ",", &split_state))) {
- struct pa_sink *slave_sink;
+ pa_sink *slave_sink;
if (!(slave_sink = pa_namereg_get(c, n, PA_NAMEREG_SINK, 1))) {
pa_log(__FILE__": invalid slave sink '%s'\n", n);
return -1;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata *u;
assert(c && m);
int pa__init(struct pa_core *c, struct pa_module*m);
void pa__done(struct pa_core *c, struct pa_module*m);
+const char* pa__get_author(void);
+const char* pa__get_description(void);
+const char* pa__get_usage(void);
+const char* pa__get_version(void);
+
#endif
NULL,
};
-int pa__init(struct pa_core *c, struct pa_module*m) {
- struct pa_modargs *ma = NULL;
+int pa__init(pa_core *c, pa_module*m) {
+ pa_modargs *ma = NULL;
int ret = -1, fd = -1;
char x = 1;
assert(c && m);
return ret;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
assert(c && m);
}
NULL,
};
-int pa__init(struct pa_core *c, struct pa_module*m) {
- struct pa_modargs *ma = NULL;
+int pa__init(pa_core *c, pa_module*m) {
+ pa_modargs *ma = NULL;
int ret = -1;
uint32_t pid = 0;
assert(c && m);
return ret;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
assert(c && m);
}
#define PA_TYPEID_ESOUND_SINK PA_TYPEID_MAKE('E', 'S', 'D', 'S')
struct userdata {
- struct pa_core *core;
+ pa_core *core;
- struct pa_sink *sink;
- struct pa_iochannel *io;
- struct pa_socket_client *client;
+ pa_sink *sink;
+ pa_iochannel *io;
+ pa_socket_client *client;
- struct pa_defer_event *defer_event;
+ pa_defer_event *defer_event;
- struct pa_memchunk memchunk;
- struct pa_module *module;
+ pa_memchunk memchunk;
+ pa_module *module;
void *write_data;
size_t write_length, write_index;
u->write_index = u->write_length = 0;
}
} else if (u->state == STATE_RUNNING) {
- pa_module_set_used(u->module, pa_idxset_ncontents(u->sink->inputs) + pa_idxset_ncontents(u->sink->monitor_source->outputs));
+ pa_module_set_used(u->module, pa_idxset_size(u->sink->inputs) + pa_idxset_size(u->sink->monitor_source->outputs));
if (!u->memchunk.length)
if (pa_sink_render(u->sink, 8192, &u->memchunk) < 0)
cancel(u);
}
-static void notify_cb(struct pa_sink*s) {
+static void notify_cb(pa_sink*s) {
struct userdata *u = s->userdata;
assert(s && u);
u->core->mainloop->defer_enable(u->defer_event, 1);
}
-static pa_usec_t get_latency_cb(struct pa_sink *s) {
+static pa_usec_t get_latency_cb(pa_sink *s) {
struct userdata *u = s->userdata;
assert(s && u);
(u->memchunk.memblock ? pa_bytes_to_usec(u->memchunk.length, &s->sample_spec) : 0);
}
-static void defer_callback(struct pa_mainloop_api *m, struct pa_defer_event*e, void *userdata) {
+static void defer_callback(PA_GCC_UNUSED pa_mainloop_api *m, PA_GCC_UNUSED pa_defer_event*e, void *userdata) {
struct userdata *u = userdata;
assert(u);
do_work(u);
}
-static void io_callback(struct pa_iochannel *io, void*userdata) {
+static void io_callback(PA_GCC_UNUSED pa_iochannel *io, void*userdata) {
struct userdata *u = userdata;
assert(u);
do_work(u);
}
-static void on_connection(struct pa_socket_client *c, struct pa_iochannel*io, void *userdata) {
+static void on_connection(PA_GCC_UNUSED pa_socket_client *c, pa_iochannel*io, void *userdata) {
struct userdata *u = userdata;
pa_socket_client_unref(u->client);
pa_iochannel_set_callback(u->io, io_callback, u);
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
+int pa__init(pa_core *c, pa_module*m) {
struct userdata *u = NULL;
const char *p;
- struct pa_sample_spec ss;
- struct pa_modargs *ma = NULL;
+ pa_sample_spec ss;
+ pa_modargs *ma = NULL;
assert(c && m);
if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
return -1;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata *u;
assert(c && m);
struct userdata {
int lirc_fd;
- struct pa_io_event *io;
+ pa_io_event *io;
struct lirc_config *config;
char *sink_name;
- struct pa_module *module;
+ pa_module *module;
float mute_toggle_save;
};
static int lirc_in_use = 0;
-static void io_callback(struct pa_mainloop_api *io, struct pa_io_event *e, int fd, enum pa_io_event_flags events, void*userdata) {
+static void io_callback(pa_mainloop_api *io, PA_GCC_UNUSED pa_io_event *e, PA_GCC_UNUSED int fd, pa_io_event_flags events, void*userdata) {
struct userdata *u = userdata;
char *name = NULL, *code = NULL;
assert(io);
if (volchange == INVALID)
pa_log_warn(__FILE__": recieved unknown IR code '%s'\n", name);
else {
- struct pa_sink *s;
+ pa_sink *s;
if (!(s = pa_namereg_get(u->module->core, u->sink_name, PA_NAMEREG_SINK, 1)))
pa_log(__FILE__": failed to get sink '%s'\n", u->sink_name);
free(code);
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
- struct pa_modargs *ma = NULL;
+int pa__init(pa_core *c, pa_module*m) {
+ pa_modargs *ma = NULL;
struct userdata *u;
assert(c && m);
return -1;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata *u;
assert(c);
assert(m);
struct userdata {
struct rule *rules;
- struct pa_subscription *subscription;
+ pa_subscription *subscription;
};
static int load_rules(struct userdata *u, const char *filename) {
return ret;
}
-static void callback(struct pa_core *c, enum pa_subscription_event_type t, uint32_t index, void *userdata) {
+static void callback(pa_core *c, pa_subscription_event_type t, uint32_t idx, void *userdata) {
struct userdata *u = userdata;
- struct pa_sink_input *si;
+ pa_sink_input *si;
struct rule *r;
assert(c && u);
if (t != (PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_NEW))
return;
- if (!(si = pa_idxset_get_by_index(c->sink_inputs, index)))
+ if (!(si = pa_idxset_get_by_index(c->sink_inputs, idx)))
return;
if (!si->name)
}
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
- struct pa_modargs *ma = NULL;
+int pa__init(pa_core *c, pa_module*m) {
+ pa_modargs *ma = NULL;
struct userdata *u;
assert(c && m);
return -1;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata* u;
struct rule *r, *n;
assert(c && m);
struct userdata {
int fd;
- struct pa_io_event *io;
+ pa_io_event *io;
char *sink_name;
- struct pa_module *module;
+ pa_module *module;
float mute_toggle_save;
};
-static void io_callback(struct pa_mainloop_api *io, struct pa_io_event *e, int fd, enum pa_io_event_flags events, void*userdata) {
+static void io_callback(pa_mainloop_api *io, PA_GCC_UNUSED pa_io_event *e, PA_GCC_UNUSED int fd, pa_io_event_flags events, void*userdata) {
struct userdata *u = userdata;
assert(io);
assert(u);
}
if (events & PA_IO_EVENT_INPUT) {
- struct input_event e;
+ struct input_event ev;
- if (pa_loop_read(u->fd, &e, sizeof(e)) <= 0) {
+ if (pa_loop_read(u->fd, &ev, sizeof(ev)) <= 0) {
pa_log(__FILE__": failed to read from event device: %s\n", strerror(errno));
goto fail;
}
- if (e.type == EV_KEY && (e.value == 1 || e.value == 2)) {
+ if (ev.type == EV_KEY && (ev.value == 1 || ev.value == 2)) {
enum { INVALID, UP, DOWN, MUTE_TOGGLE } volchange = INVALID;
- pa_log_debug(__FILE__": key code=%u, value=%u\n", e.code, e.value);
+ pa_log_debug(__FILE__": key code=%u, value=%u\n", ev.code, ev.value);
- switch (e.code) {
+ switch (ev.code) {
case KEY_VOLUMEDOWN: volchange = DOWN; break;
case KEY_VOLUMEUP: volchange = UP; break;
case KEY_MUTE: volchange = MUTE_TOGGLE; break;
}
if (volchange != INVALID) {
- struct pa_sink *s;
+ pa_sink *s;
if (!(s = pa_namereg_get(u->module->core, u->sink_name, PA_NAMEREG_SINK, 1)))
pa_log(__FILE__": failed to get sink '%s'\n", u->sink_name);
#define test_bit(bit, array) (array[bit/8] & (1<<(bit%8)))
-int pa__init(struct pa_core *c, struct pa_module*m) {
- struct pa_modargs *ma = NULL;
+int pa__init(pa_core *c, pa_module*m) {
+ pa_modargs *ma = NULL;
struct userdata *u;
int version;
struct _input_id input_id;
return -1;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata *u;
assert(c);
assert(m);
NULL,
};
-int pa__init(struct pa_core *c, struct pa_module*m) {
- struct pa_iochannel *io;
- struct pa_modargs *ma;
+int pa__init(pa_core *c, pa_module*m) {
+ pa_iochannel *io;
+ pa_modargs *ma;
int fd, r = -1;
assert(c && m);
return r;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
assert(c && m);
pa_protocol_native_free(m->userdata);
#define PA_TYPEID_NULL PA_TYPEID_MAKE('N', 'U', 'L', 'L')
struct userdata {
- struct pa_core *core;
- struct pa_module *module;
- struct pa_sink *sink;
- struct pa_time_event *time_event;
+ pa_core *core;
+ pa_module *module;
+ pa_sink *sink;
+ pa_time_event *time_event;
size_t block_size;
};
NULL
};
-static void time_callback(struct pa_mainloop_api *m, struct pa_time_event*e, const struct timeval *tv, void *userdata) {
+static void time_callback(pa_mainloop_api *m, pa_time_event*e, const struct timeval *tv, void *userdata) {
struct userdata *u = userdata;
- struct pa_memchunk chunk;
+ pa_memchunk chunk;
struct timeval ntv = *tv;
size_t l;
m->time_restart(e, &ntv);
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
+int pa__init(pa_core *c, pa_module*m) {
struct userdata *u = NULL;
- struct pa_sample_spec ss;
- struct pa_modargs *ma = NULL;
+ pa_sample_spec ss;
+ pa_modargs *ma = NULL;
struct timeval tv;
assert(c && m);
return -1;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata *u;
assert(c && m);
#define PA_TYPEID_OSS_MMAP PA_TYPEID_MAKE('O', 'S', 'S', 'M')
struct userdata {
- struct pa_sink *sink;
- struct pa_source *source;
- struct pa_core *core;
- struct pa_sample_spec sample_spec;
+ pa_sink *sink;
+ pa_source *source;
+ pa_core *core;
+ pa_sample_spec sample_spec;
size_t in_fragment_size, out_fragment_size, in_fragments, out_fragments, out_fill;
void *in_mmap, *out_mmap;
size_t in_mmap_length, out_mmap_length;
- struct pa_io_event *io_event;
+ pa_io_event *io_event;
- struct pa_memblock **in_memblocks, **out_memblocks;
+ pa_memblock **in_memblocks, **out_memblocks;
unsigned out_current, in_current;
- struct pa_module *module;
+ pa_module *module;
};
static const char* const valid_modargs[] = {
static void update_usage(struct userdata *u) {
pa_module_set_used(u->module,
- (u->sink ? pa_idxset_ncontents(u->sink->inputs) : 0) +
- (u->sink ? pa_idxset_ncontents(u->sink->monitor_source->outputs) : 0) +
- (u->source ? pa_idxset_ncontents(u->source->outputs) : 0));
+ (u->sink ? pa_idxset_size(u->sink->inputs) : 0) +
+ (u->sink ? pa_idxset_size(u->sink->monitor_source->outputs) : 0) +
+ (u->source ? pa_idxset_size(u->source->outputs) : 0));
}
static void out_fill_memblocks(struct userdata *u, unsigned n) {
assert(u && u->out_memblocks);
while (n > 0) {
- struct pa_memchunk chunk;
+ pa_memchunk chunk;
if (u->out_memblocks[u->out_current])
pa_memblock_unref_fixed(u->out_memblocks[u->out_current]);
assert(u && u->in_memblocks);
while (n > 0) {
- struct pa_memchunk chunk;
+ pa_memchunk chunk;
if (!u->in_memblocks[u->in_current]) {
chunk.memblock = u->in_memblocks[u->in_current] = pa_memblock_new_fixed((uint8_t*) u->in_mmap+u->in_fragment_size*u->in_current, u->in_fragment_size, 1, u->core->memblock_stat);
in_clear_memblocks(u, u->in_fragments/2);
}
-static void io_callback(struct pa_mainloop_api *m, struct pa_io_event *e, int fd, enum pa_io_event_flags f, void *userdata) {
+static void io_callback(pa_mainloop_api *m, pa_io_event *e, PA_GCC_UNUSED int fd, pa_io_event_flags f, void *userdata) {
struct userdata *u = userdata;
assert (u && u->core->mainloop == m && u->io_event == e);
do_write(u);
}
-static pa_usec_t sink_get_latency_cb(struct pa_sink *s) {
+static pa_usec_t sink_get_latency_cb(pa_sink *s) {
struct userdata *u = s->userdata;
assert(s && u);
return pa_bytes_to_usec(u->out_fill, &s->sample_spec);
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
+int pa__init(pa_core *c, pa_module*m) {
struct audio_buf_info info;
struct userdata *u = NULL;
const char *p;
int mode, caps;
int enable_bits = 0, zero = 0;
int playback = 1, record = 1;
- struct pa_modargs *ma = NULL;
+ pa_modargs *ma = NULL;
assert(c && m);
m->userdata = u = pa_xmalloc0(sizeof(struct userdata));
pa_source_set_owner(u->source, m);
u->source->description = pa_sprintf_malloc("Open Sound System PCM/mmap() on '%s'", p);
- u->in_memblocks = pa_xmalloc0(sizeof(struct pa_memblock *)*u->in_fragments);
+ u->in_memblocks = pa_xmalloc0(sizeof(pa_memblock *)*u->in_fragments);
enable_bits |= PCM_ENABLE_INPUT;
}
return -1;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata *u;
assert(c && m);
#define PA_TYPEID_OSS PA_TYPEID_MAKE('O', 'S', 'S', '_')
struct userdata {
- struct pa_sink *sink;
- struct pa_source *source;
- struct pa_iochannel *io;
- struct pa_core *core;
+ pa_sink *sink;
+ pa_source *source;
+ pa_iochannel *io;
+ pa_core *core;
- struct pa_memchunk memchunk, silence;
+ pa_memchunk memchunk, silence;
uint32_t in_fragment_size, out_fragment_size, sample_size;
int use_getospace, use_getispace;
int fd;
- struct pa_module *module;
+ pa_module *module;
};
static const char* const valid_modargs[] = {
static void update_usage(struct userdata *u) {
pa_module_set_used(u->module,
- (u->sink ? pa_idxset_ncontents(u->sink->inputs) : 0) +
- (u->sink ? pa_idxset_ncontents(u->sink->monitor_source->outputs) : 0) +
- (u->source ? pa_idxset_ncontents(u->source->outputs) : 0));
+ (u->sink ? pa_idxset_size(u->sink->inputs) : 0) +
+ (u->sink ? pa_idxset_size(u->sink->monitor_source->outputs) : 0) +
+ (u->source ? pa_idxset_size(u->source->outputs) : 0));
}
static void do_write(struct userdata *u) {
- struct pa_memchunk *memchunk;
+ pa_memchunk *memchunk;
ssize_t r;
size_t l;
int loop = 0;
}
static void do_read(struct userdata *u) {
- struct pa_memchunk memchunk;
+ pa_memchunk memchunk;
ssize_t r;
size_t l;
int loop = 0;
} while (loop && l > 0);
}
-static void io_callback(struct pa_iochannel *io, void*userdata) {
+static void io_callback(PA_GCC_UNUSED pa_iochannel *io, void*userdata) {
struct userdata *u = userdata;
assert(u);
do_write(u);
do_read(u);
}
-static pa_usec_t sink_get_latency_cb(struct pa_sink *s) {
+static pa_usec_t sink_get_latency_cb(pa_sink *s) {
pa_usec_t r = 0;
int arg;
struct userdata *u = s->userdata;
return r;
}
-static pa_usec_t source_get_latency_cb(struct pa_source *s) {
+static pa_usec_t source_get_latency_cb(pa_source *s) {
struct userdata *u = s->userdata;
audio_buf_info info;
assert(s && u && u->source);
return pa_bytes_to_usec(info.bytes, &s->sample_spec);
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
+int pa__init(pa_core *c, pa_module*m) {
struct audio_buf_info info;
struct userdata *u = NULL;
const char *p;
int nfrags, frag_size, in_frag_size, out_frag_size;
int mode;
int record = 1, playback = 1;
- struct pa_sample_spec ss;
- struct pa_modargs *ma = NULL;
+ pa_sample_spec ss;
+ pa_modargs *ma = NULL;
assert(c && m);
if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
return -1;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata *u;
assert(c && m);
#define PA_TYPEID_PIPE PA_TYPEID_MAKE('P', 'I', 'P', 'E')
struct userdata {
- struct pa_core *core;
+ pa_core *core;
char *filename;
- struct pa_sink *sink;
- struct pa_iochannel *io;
- struct pa_defer_event *defer_event;
+ pa_sink *sink;
+ pa_iochannel *io;
+ pa_defer_event *defer_event;
- struct pa_memchunk memchunk;
- struct pa_module *module;
+ pa_memchunk memchunk;
+ pa_module *module;
};
static const char* const valid_modargs[] = {
if (!pa_iochannel_is_writable(u->io))
return;
- pa_module_set_used(u->module, pa_idxset_ncontents(u->sink->inputs) + pa_idxset_ncontents(u->sink->monitor_source->outputs));
+ pa_module_set_used(u->module, pa_idxset_size(u->sink->inputs) + pa_idxset_size(u->sink->monitor_source->outputs));
if (!u->memchunk.length)
if (pa_sink_render(u->sink, PIPE_BUF, &u->memchunk) < 0)
}
}
-static void notify_cb(struct pa_sink*s) {
+static void notify_cb(pa_sink*s) {
struct userdata *u = s->userdata;
assert(s && u);
u->core->mainloop->defer_enable(u->defer_event, 1);
}
-static pa_usec_t get_latency_cb(struct pa_sink *s) {
+static pa_usec_t get_latency_cb(pa_sink *s) {
struct userdata *u = s->userdata;
assert(s && u);
return u->memchunk.memblock ? pa_bytes_to_usec(u->memchunk.length, &s->sample_spec) : 0;
}
-static void defer_callback(struct pa_mainloop_api *m, struct pa_defer_event*e, void *userdata) {
+static void defer_callback(PA_GCC_UNUSED pa_mainloop_api *m, PA_GCC_UNUSED pa_defer_event*e, void *userdata) {
struct userdata *u = userdata;
assert(u);
do_write(u);
}
-static void io_callback(struct pa_iochannel *io, void*userdata) {
+static void io_callback(PA_GCC_UNUSED pa_iochannel *io, void*userdata) {
struct userdata *u = userdata;
assert(u);
do_write(u);
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
+int pa__init(pa_core *c, pa_module*m) {
struct userdata *u = NULL;
struct stat st;
const char *p;
int fd = -1;
- struct pa_sample_spec ss;
- struct pa_modargs *ma = NULL;
+ pa_sample_spec ss;
+ pa_modargs *ma = NULL;
assert(c && m);
if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
return -1;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata *u;
assert(c && m);
#define PA_TYPEID_PIPE PA_TYPEID_MAKE('P', 'I', 'P', 'E')
struct userdata {
- struct pa_core *core;
+ pa_core *core;
char *filename;
- struct pa_source *source;
- struct pa_iochannel *io;
- struct pa_module *module;
- struct pa_memchunk chunk;
+ pa_source *source;
+ pa_iochannel *io;
+ pa_module *module;
+ pa_memchunk chunk;
};
static const char* const valid_modargs[] = {
static void do_read(struct userdata *u) {
ssize_t r;
- struct pa_memchunk chunk;
+ pa_memchunk chunk;
assert(u);
if (!pa_iochannel_is_readable(u->io))
return;
- pa_module_set_used(u->module, pa_idxset_ncontents(u->source->outputs));
+ pa_module_set_used(u->module, pa_idxset_size(u->source->outputs));
if (!u->chunk.memblock) {
u->chunk.memblock = pa_memblock_new(1024, u->core->memblock_stat);
}
}
-static void io_callback(struct pa_iochannel *io, void*userdata) {
+static void io_callback(PA_GCC_UNUSED pa_iochannel *io, void*userdata) {
struct userdata *u = userdata;
assert(u);
do_read(u);
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
+int pa__init(pa_core *c, pa_module*m) {
struct userdata *u = NULL;
struct stat st;
const char *p;
int fd = -1;
- struct pa_sample_spec ss;
- struct pa_modargs *ma = NULL;
+ pa_sample_spec ss;
+ pa_modargs *ma = NULL;
assert(c && m);
if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
return -1;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata *u;
assert(c && m);
NULL
};
-static struct pa_socket_server *create_socket_server(struct pa_core *c, struct pa_modargs *ma) {
- struct pa_socket_server *s;
+static pa_socket_server *create_socket_server(pa_core *c, pa_modargs *ma) {
+ pa_socket_server *s;
#if defined(USE_TCP_SOCKETS) || defined(USE_TCP6_SOCKETS)
int loopback = 1;
uint32_t port = IPV4_PORT;
}
#ifdef USE_TCP6_SOCKETS
- if (!(s = pa_socket_server_new_ipv6(c->mainloop, loopback ? (uint8_t*) &in6addr_loopback : (uint8_t*) &in6addr_any, port)))
+ if (!(s = pa_socket_server_new_ipv6(c->mainloop, loopback ? (const uint8_t*) &in6addr_loopback : (const uint8_t*) &in6addr_any, port)))
return NULL;
#else
if (!(s = pa_socket_server_new_ipv4(c->mainloop, loopback ? INADDR_LOOPBACK : INADDR_ANY, port, TCPWRAP_SERVICE)))
return s;
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
- struct pa_socket_server *s;
- struct pa_modargs *ma = NULL;
+int pa__init(pa_core *c, pa_module*m) {
+ pa_socket_server *s;
+ pa_modargs *ma = NULL;
int ret = -1;
assert(c && m);
return ret;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
assert(c && m);
#if defined(USE_PROTOCOL_ESOUND)
#define PA_TYPEID_SINE PA_TYPEID_MAKE('S', 'I', 'N', 'E')
struct userdata {
- struct pa_core *core;
- struct pa_module *module;
- struct pa_sink_input *sink_input;
- struct pa_memblock *memblock;
+ pa_core *core;
+ pa_module *module;
+ pa_sink_input *sink_input;
+ pa_memblock *memblock;
size_t peek_index;
};
NULL,
};
-static int sink_input_peek(struct pa_sink_input *i, struct pa_memchunk *chunk) {
+static int sink_input_peek(pa_sink_input *i, pa_memchunk *chunk) {
struct userdata *u;
assert(i && chunk && i->userdata);
u = i->userdata;
return 0;
}
-static void sink_input_drop(struct pa_sink_input *i, const struct pa_memchunk *chunk, size_t length) {
+static void sink_input_drop(pa_sink_input *i, const pa_memchunk *chunk, size_t length) {
struct userdata *u;
assert(i && chunk && length && i->userdata);
u = i->userdata;
u->peek_index = 0;
}
-static void sink_input_kill(struct pa_sink_input *i) {
+static void sink_input_kill(pa_sink_input *i) {
struct userdata *u;
assert(i && i->userdata);
u = i->userdata;
f[i] = (float) sin((double) i/l*M_PI*2*freq)/2;
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
- struct pa_modargs *ma = NULL;
+int pa__init(pa_core *c, pa_module*m) {
+ pa_modargs *ma = NULL;
struct userdata *u;
- struct pa_sink *sink;
+ pa_sink *sink;
const char *sink_name;
- struct pa_sample_spec ss;
+ pa_sample_spec ss;
uint32_t frequency;
char t[256];
return -1;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata *u = m->userdata;
assert(c && m);
#define PA_TYPEID_SOLARIS PA_TYPEID_MAKE('S', 'L', 'R', 'S')
struct userdata {
- struct pa_sink *sink;
- struct pa_source *source;
- struct pa_iochannel *io;
- struct pa_core *core;
+ pa_sink *sink;
+ pa_source *source;
+ pa_iochannel *io;
+ pa_core *core;
- struct pa_memchunk memchunk, silence;
+ pa_memchunk memchunk, silence;
uint32_t sample_size;
unsigned int written_bytes, read_bytes;
int fd;
- struct pa_module *module;
+ pa_module *module;
};
static const char* const valid_modargs[] = {
static void update_usage(struct userdata *u) {
pa_module_set_used(u->module,
- (u->sink ? pa_idxset_ncontents(u->sink->inputs) : 0) +
- (u->sink ? pa_idxset_ncontents(u->sink->monitor_source->outputs) : 0) +
- (u->source ? pa_idxset_ncontents(u->source->outputs) : 0));
+ (u->sink ? pa_idxset_size(u->sink->inputs) : 0) +
+ (u->sink ? pa_idxset_size(u->sink->monitor_source->outputs) : 0) +
+ (u->source ? pa_idxset_size(u->source->outputs) : 0));
}
static void do_write(struct userdata *u) {
- struct pa_memchunk *memchunk;
+ pa_memchunk *memchunk;
ssize_t r;
assert(u);
}
static void do_read(struct userdata *u) {
- struct pa_memchunk memchunk;
+ pa_memchunk memchunk;
int err, l;
ssize_t r;
assert(u);
u->read_bytes += r;
}
-static void io_callback(struct pa_iochannel *io, void*userdata) {
+static void io_callback(pa_iochannel *io, void*userdata) {
struct userdata *u = userdata;
assert(u);
do_write(u);
do_read(u);
}
-static pa_usec_t sink_get_latency_cb(struct pa_sink *s) {
+static pa_usec_t sink_get_latency_cb(pa_sink *s) {
pa_usec_t r = 0;
audio_info_t info;
int err;
return r;
}
-static pa_usec_t source_get_latency_cb(struct pa_source *s) {
+static pa_usec_t source_get_latency_cb(pa_source *s) {
pa_usec_t r = 0;
struct userdata *u = s->userdata;
audio_info_t info;
return r;
}
-static int pa_solaris_auto_format(int fd, int mode, struct pa_sample_spec *ss) {
+static int pa_solaris_auto_format(int fd, int mode, pa_sample_spec *ss) {
audio_info_t info;
AUDIO_INITINFO(&info);
return 0;
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
+int pa__init(pa_core *c, pa_module*m) {
struct userdata *u = NULL;
const char *p;
int fd = -1;
int buffer_size;
int mode;
int record = 1, playback = 1;
- struct pa_sample_spec ss;
- struct pa_modargs *ma = NULL;
+ pa_sample_spec ss;
+ pa_modargs *ma = NULL;
assert(c && m);
if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
return -1;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata *u;
assert(c && m);
NULL,
};
-static void command_stream_killed(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
+static void command_stream_killed(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
#ifdef TUNNEL_SINK
-static void command_request(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
+static void command_request(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
#endif
-static const struct pa_pdispatch_command command_table[PA_COMMAND_MAX] = {
+static const pa_pdispatch_callback command_table[PA_COMMAND_MAX] = {
#ifdef TUNNEL_SINK
- [PA_COMMAND_REQUEST] = { command_request },
+ [PA_COMMAND_REQUEST] = command_request,
#endif
- [PA_COMMAND_PLAYBACK_STREAM_KILLED] = { command_stream_killed },
- [PA_COMMAND_RECORD_STREAM_KILLED] = { command_stream_killed },
+ [PA_COMMAND_PLAYBACK_STREAM_KILLED] = command_stream_killed,
+ [PA_COMMAND_RECORD_STREAM_KILLED] = command_stream_killed
};
struct userdata {
- struct pa_socket_client *client;
- struct pa_pstream *pstream;
- struct pa_pdispatch *pdispatch;
+ pa_socket_client *client;
+ pa_pstream *pstream;
+ pa_pdispatch *pdispatch;
char *server_name;
#ifdef TUNNEL_SINK
char *sink_name;
- struct pa_sink *sink;
+ pa_sink *sink;
uint32_t requested_bytes;
#else
char *source_name;
- struct pa_source *source;
+ pa_source *source;
#endif
- struct pa_module *module;
- struct pa_core *core;
+ pa_module *module;
+ pa_core *core;
uint8_t auth_cookie[PA_NATIVE_COOKIE_LENGTH];
pa_usec_t host_latency;
- struct pa_time_event *time_event;
+ pa_time_event *time_event;
int auth_cookie_in_property;
};
pa_module_unload_request(u->module);
}
-static void command_stream_killed(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_stream_killed(pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
struct userdata *u = userdata;
assert(pd && t && u && u->pdispatch == pd);
#ifdef TUNNEL_SINK
static void send_prebuf_request(struct userdata *u) {
- struct pa_tagstruct *t;
+ pa_tagstruct *t;
t = pa_tagstruct_new(NULL, 0);
pa_tagstruct_putu32(t, PA_COMMAND_PREBUF_PLAYBACK_STREAM);
return;
while (u->requested_bytes > 0) {
- struct pa_memchunk chunk;
+ pa_memchunk chunk;
if (pa_sink_render(u->sink, u->requested_bytes, &chunk) < 0) {
}
}
-static void command_request(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_request(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
struct userdata *u = userdata;
uint32_t bytes, channel;
assert(pd && command == PA_COMMAND_REQUEST && t && u && u->pdispatch == pd);
#endif
-static void stream_get_latency_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void stream_get_latency_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
struct userdata *u = userdata;
pa_usec_t buffer_usec, sink_usec, source_usec, transport_usec;
int playing;
}
static void request_latency(struct userdata *u) {
- struct pa_tagstruct *t;
+ pa_tagstruct *t;
struct timeval now;
uint32_t tag;
assert(u);
pa_pdispatch_register_reply(u->pdispatch, tag, DEFAULT_TIMEOUT, stream_get_latency_callback, u);
}
-static void create_stream_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void create_stream_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
struct userdata *u = userdata;
assert(pd && u && u->pdispatch == pd);
#endif
}
-static void setup_complete_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void setup_complete_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct userdata *u = userdata;
- struct pa_tagstruct *reply;
+ pa_tagstruct *reply;
char name[256], un[128], hn[128];
assert(pd && u && u->pdispatch == pd);
pa_pdispatch_register_reply(u->pdispatch, tag, DEFAULT_TIMEOUT, create_stream_callback, u);
}
-static void pstream_die_callback(struct pa_pstream *p, void *userdata) {
+static void pstream_die_callback(pa_pstream *p, void *userdata) {
struct userdata *u = userdata;
assert(p && u);
}
-static void pstream_packet_callback(struct pa_pstream *p, struct pa_packet *packet, void *userdata) {
+static void pstream_packet_callback(pa_pstream *p, pa_packet *packet, void *userdata) {
struct userdata *u = userdata;
assert(p && packet && u);
}
#ifndef TUNNEL_SINK
-static void pstream_memblock_callback(struct pa_pstream *p, uint32_t channel, uint32_t delta, const struct pa_memchunk *chunk, void *userdata) {
+static void pstream_memblock_callback(pa_pstream *p, uint32_t channel, uint32_t delta, const pa_memchunk *chunk, void *userdata) {
struct userdata *u = userdata;
assert(p && chunk && u);
}
#endif
-static void on_connection(struct pa_socket_client *sc, struct pa_iochannel *io, void *userdata) {
+static void on_connection(pa_socket_client *sc, pa_iochannel *io, void *userdata) {
struct userdata *u = userdata;
- struct pa_tagstruct *t;
+ pa_tagstruct *t;
uint32_t tag;
assert(sc && u && u->client == sc);
}
#ifdef TUNNEL_SINK
-static void sink_notify(struct pa_sink*sink) {
+static void sink_notify(pa_sink*sink) {
struct userdata *u;
assert(sink && sink->userdata);
u = sink->userdata;
send_bytes(u);
}
-static pa_usec_t sink_get_latency(struct pa_sink *sink) {
+static pa_usec_t sink_get_latency(pa_sink *sink) {
struct userdata *u;
uint32_t l;
pa_usec_t usec = 0;
return usec;
}
#else
-static pa_usec_t source_get_latency(struct pa_source *source) {
+static pa_usec_t source_get_latency(pa_source *source) {
struct userdata *u;
assert(source && source->userdata);
u = source->userdata;
}
#endif
-static void timeout_callback(struct pa_mainloop_api *m, struct pa_time_event*e, const struct timeval *tv, void *userdata) {
+static void timeout_callback(pa_mainloop_api *m, pa_time_event*e, PA_GCC_UNUSED const struct timeval *tv, void *userdata) {
struct userdata *u = userdata;
struct timeval ntv;
assert(m && e && u);
return 0;
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
- struct pa_modargs *ma = NULL;
+int pa__init(pa_core *c, pa_module*m) {
+ pa_modargs *ma = NULL;
struct userdata *u = NULL;
- struct pa_sample_spec ss;
+ pa_sample_spec ss;
struct timeval ntv;
assert(c && m);
return -1;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata* u;
assert(c && m);
#define DEFAULT_SOURCE_NAME "wave_input"
struct userdata {
- struct pa_sink *sink;
- struct pa_source *source;
- struct pa_core *core;
- struct pa_time_event *event;
- struct pa_defer_event *defer;
+ pa_sink *sink;
+ pa_source *source;
+ pa_core *core;
+ pa_time_event *event;
+ pa_defer_event *defer;
pa_usec_t poll_timeout;
uint32_t fragments, fragment_size;
int cur_ohdr, cur_ihdr;
unsigned int oremain;
WAVEHDR *ohdrs, *ihdrs;
- struct pa_memchunk silence;
+ pa_memchunk silence;
HWAVEOUT hwo;
HWAVEIN hwi;
- struct pa_module *module;
+ pa_module *module;
CRITICAL_SECTION crit;
};
static void update_usage(struct userdata *u) {
pa_module_set_used(u->module,
- (u->sink ? pa_idxset_ncontents(u->sink->inputs) : 0) +
- (u->sink ? pa_idxset_ncontents(u->sink->monitor_source->outputs) : 0) +
- (u->source ? pa_idxset_ncontents(u->source->outputs) : 0));
+ (u->sink ? pa_idxset_size(u->sink->inputs) : 0) +
+ (u->sink ? pa_idxset_size(u->sink->monitor_source->outputs) : 0) +
+ (u->source ? pa_idxset_size(u->source->outputs) : 0));
}
static void do_write(struct userdata *u)
{
uint32_t free_frags, remain;
- struct pa_memchunk memchunk, *cur_chunk;
+ pa_memchunk memchunk, *cur_chunk;
WAVEHDR *hdr;
MMRESULT res;
static void do_read(struct userdata *u)
{
uint32_t free_frags;
- struct pa_memchunk memchunk;
+ pa_memchunk memchunk;
WAVEHDR *hdr;
MMRESULT res;
}
}
-static void poll_cb(struct pa_mainloop_api*a, struct pa_time_event *e, const struct timeval *tv, void *userdata) {
+static void poll_cb(pa_mainloop_api*a, pa_time_event *e, const struct timeval *tv, void *userdata) {
struct userdata *u = userdata;
struct timeval ntv;
a->time_restart(e, &ntv);
}
-static void defer_cb(struct pa_mainloop_api*a, struct pa_defer_event *e, void *userdata) {
+static void defer_cb(pa_mainloop_api*a, pa_defer_event *e, void *userdata) {
struct userdata *u = userdata;
assert(u);
LeaveCriticalSection(&u->crit);
}
-static pa_usec_t sink_get_latency_cb(struct pa_sink *s) {
+static pa_usec_t sink_get_latency_cb(pa_sink *s) {
struct userdata *u = s->userdata;
uint32_t free_frags;
MMTIME mmt;
}
}
-static pa_usec_t source_get_latency_cb(struct pa_source *s) {
+static pa_usec_t source_get_latency_cb(pa_source *s) {
pa_usec_t r = 0;
struct userdata *u = s->userdata;
uint32_t free_frags;
return r;
}
-static void notify_sink_cb(struct pa_sink *s) {
+static void notify_sink_cb(pa_sink *s) {
struct userdata *u = s->userdata;
assert(u);
u->core->mainloop->defer_enable(u->defer, 1);
}
-static void notify_source_cb(struct pa_source *s) {
+static void notify_source_cb(pa_source *s) {
struct userdata *u = s->userdata;
assert(u);
u->core->mainloop->defer_enable(u->defer, 1);
}
-static int ss_to_waveformat(struct pa_sample_spec *ss, LPWAVEFORMATEX wf) {
+static int ss_to_waveformat(pa_sample_spec *ss, LPWAVEFORMATEX wf) {
wf->wFormatTag = WAVE_FORMAT_PCM;
if (ss->channels > 2) {
return 0;
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
+int pa__init(pa_core *c, pa_module*m) {
struct userdata *u = NULL;
HWAVEOUT hwo = INVALID_HANDLE_VALUE;
HWAVEIN hwi = INVALID_HANDLE_VALUE;
WAVEFORMATEX wf;
int nfrags, frag_size;
int record = 1, playback = 1;
- struct pa_sample_spec ss;
- struct pa_modargs *ma = NULL;
+ pa_sample_spec ss;
+ pa_modargs *ma = NULL;
unsigned int i;
struct timeval tv;
return -1;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata *u;
unsigned int i;
PA_MODULE_USAGE("sink=<sink to connect to> sample=<sample name> display=<X11 display>")
struct userdata {
- struct pa_core *core;
+ pa_core *core;
int xkb_event_base;
char *sink_name;
char *scache_item;
Display *display;
- struct pa_x11_wrapper *x11_wrapper;
- struct pa_x11_client *x11_client;
+ pa_x11_wrapper *x11_wrapper;
+ pa_x11_client *x11_client;
};
static const char* const valid_modargs[] = {
};
static int ring_bell(struct userdata *u, int percent) {
- struct pa_sink *s;
+ pa_sink *s;
assert(u);
if (!(s = pa_namereg_get(u->core, u->sink_name, PA_NAMEREG_SINK, 1))) {
return 0;
}
-static int x11_event_callback(struct pa_x11_wrapper *w, XEvent *e, void *userdata) {
+static int x11_event_callback(pa_x11_wrapper *w, XEvent *e, void *userdata) {
XkbBellNotifyEvent *bne;
struct userdata *u = userdata;
assert(w && e && u && u->x11_wrapper == w);
return 1;
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
+int pa__init(pa_core *c, pa_module*m) {
struct userdata *u = NULL;
- struct pa_modargs *ma = NULL;
+ pa_modargs *ma = NULL;
int major, minor;
unsigned int auto_ctrls, auto_values;
assert(c && m);
return -1;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata *u = m->userdata;
assert(c && m && u);
};
struct userdata {
- struct pa_core *core;
- struct pa_x11_wrapper *x11_wrapper;
+ pa_core *core;
+ pa_x11_wrapper *x11_wrapper;
Display *display;
char *id;
uint8_t auth_cookie[PA_NATIVE_COOKIE_LENGTH];
return 0;
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
+int pa__init(pa_core *c, pa_module*m) {
struct userdata *u;
- struct pa_modargs *ma = NULL;
+ pa_modargs *ma = NULL;
char hn[256], un[128];
char hx[PA_NATIVE_COOKIE_LENGTH*2+1];
const char *t;
char *s;
- struct pa_strlist *l;
+ pa_strlist *l;
if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
pa_log(__FILE__": failed to parse module arguments\n");
return -1;
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata*u;
assert(c && m);
struct {
int valid;
- enum pa_namereg_type type;
+ pa_namereg_type type;
uint32_t index;
} loaded;
struct {
int valid;
- enum pa_namereg_type type;
+ pa_namereg_type type;
uint32_t index;
} autoload;
};
struct userdata {
- struct pa_core *core;
- struct pa_howl_wrapper *howl_wrapper;
- struct pa_hashmap *services;
- struct pa_dynarray *sink_dynarray, *source_dynarray, *autoload_dynarray;
- struct pa_subscription *subscription;
+ pa_core *core;
+ pa_howl_wrapper *howl_wrapper;
+ pa_hashmap *services;
+ pa_dynarray *sink_dynarray, *source_dynarray, *autoload_dynarray;
+ pa_subscription *subscription;
uint16_t port;
sw_discovery_oid server_oid;
return SW_OKAY;
}
-static void get_service_data(struct userdata *u, struct service *s, struct pa_sample_spec *ret_ss, char **ret_description, pa_typeid_t *ret_typeid) {
+static void get_service_data(struct userdata *u, struct service *s, pa_sample_spec *ret_ss, char **ret_description, pa_typeid_t *ret_typeid) {
assert(u && s && s->loaded.valid && ret_ss && ret_description && ret_typeid);
if (s->loaded.type == PA_NAMEREG_SINK) {
- struct pa_sink *sink = pa_idxset_get_by_index(u->core->sinks, s->loaded.index);
+ pa_sink *sink = pa_idxset_get_by_index(u->core->sinks, s->loaded.index);
assert(sink);
*ret_ss = sink->sample_spec;
*ret_description = sink->description;
*ret_typeid = sink->typeid;
} else if (s->loaded.type == PA_NAMEREG_SOURCE) {
- struct pa_source *source = pa_idxset_get_by_index(u->core->sources, s->loaded.index);
+ pa_source *source = pa_idxset_get_by_index(u->core->sources, s->loaded.index);
assert(source);
*ret_ss = source->sample_spec;
*ret_description = source->description;
assert(0);
}
-static void txt_record_server_data(struct pa_core *c, sw_text_record t) {
+static void txt_record_server_data(pa_core *c, sw_text_record t) {
char s[256];
assert(c);
if (s->loaded.valid) {
char z[64], *description;
pa_typeid_t typeid;
- struct pa_sample_spec ss;
+ pa_sample_spec ss;
get_service_data(u, s, &ss, &description, &typeid);
return s;
}
-static int publish_sink(struct userdata *u, struct pa_sink *s) {
+static int publish_sink(struct userdata *u, pa_sink *s) {
struct service *svc;
assert(u && s);
return publish_service(u, svc);
}
-static int publish_source(struct userdata *u, struct pa_source *s) {
+static int publish_source(struct userdata *u, pa_source *s) {
struct service *svc;
assert(u && s);
return publish_service(u, svc);
}
-static int publish_autoload(struct userdata *u, struct pa_autoload_entry *s) {
+static int publish_autoload(struct userdata *u, pa_autoload_entry *s) {
struct service *svc;
assert(u && s);
return publish_service(u, svc);
}
-static void subscribe_callback(struct pa_core *c, enum pa_subscription_event_type t, uint32_t index, void *userdata) {
+static void subscribe_callback(pa_core *c, pa_subscription_event_type t, uint32_t index, void *userdata) {
struct userdata *u = userdata;
assert(u && c);
switch (t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK)
case PA_SUBSCRIPTION_EVENT_SINK: {
if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
- struct pa_sink *sink;
+ pa_sink *sink;
if ((sink = pa_idxset_get_by_index(c->sinks, index))) {
if (publish_sink(u, sink) < 0)
case PA_SUBSCRIPTION_EVENT_SOURCE:
if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
- struct pa_source *source;
+ pa_source *source;
if ((source = pa_idxset_get_by_index(c->sources, index))) {
if (publish_source(u, source) < 0)
case PA_SUBSCRIPTION_EVENT_AUTOLOAD:
if ((t & PA_SUBSCRIPTION_EVENT_TYPE_MASK) == PA_SUBSCRIPTION_EVENT_NEW) {
- struct pa_autoload_entry *autoload;
+ pa_autoload_entry *autoload;
if ((autoload = pa_idxset_get_by_index(c->autoload_idxset, index))) {
if (publish_autoload(u, autoload) < 0)
}
}
-int pa__init(struct pa_core *c, struct pa_module*m) {
+int pa__init(pa_core *c, pa_module*m) {
struct userdata *u;
uint32_t index, port = PA_NATIVE_DEFAULT_PORT;
- struct pa_sink *sink;
- struct pa_source *source;
- struct pa_autoload_entry *autoload;
- struct pa_modargs *ma = NULL;
+ pa_sink *sink;
+ pa_source *source;
+ pa_autoload_entry *autoload;
+ pa_modargs *ma = NULL;
char t[256], hn[256];
int free_txt = 0;
sw_text_record txt;
pa_xfree(s);
}
-void pa__done(struct pa_core *c, struct pa_module*m) {
+void pa__done(pa_core *c, pa_module*m) {
struct userdata*u;
assert(c && m);
#include "xmalloc.h"
#include "subscribe.h"
#include "log.h"
+#include "util.h"
#define PA_SYMBOL_INIT "pa__init"
#define PA_SYMBOL_DONE "pa__done"
#define UNLOAD_POLL_TIME 2
-static void timeout_callback(struct pa_mainloop_api *m, struct pa_time_event*e, const struct timeval *tv, void *userdata) {
- struct pa_core *c = userdata;
+static void timeout_callback(pa_mainloop_api *m, pa_time_event*e, PA_GCC_UNUSED const struct timeval *tv, void *userdata) {
+ pa_core *c = userdata;
struct timeval ntv;
assert(c && c->mainloop == m && c->module_auto_unload_event == e);
m->time_restart(e, &ntv);
}
-struct pa_module* pa_module_load(struct pa_core *c, const char *name, const char *argument) {
- struct pa_module *m = NULL;
+pa_module* pa_module_load(pa_core *c, const char *name, const char *argument) {
+ pa_module *m = NULL;
int r;
assert(c && name);
if (c->disallow_module_loading)
goto fail;
- m = pa_xmalloc(sizeof(struct pa_module));
+ m = pa_xmalloc(sizeof(pa_module));
m->name = pa_xstrdup(name);
m->argument = pa_xstrdup(argument);
goto fail;
}
- if (!(m->init = (int (*)(struct pa_core *c, struct pa_module*m)) lt_dlsym(m->dl, PA_SYMBOL_INIT))) {
+ if (!(m->init = (int (*)(pa_core *_c, pa_module*_m)) lt_dlsym(m->dl, PA_SYMBOL_INIT))) {
pa_log(__FILE__": Failed to load module \"%s\": symbol \""PA_SYMBOL_INIT"\" not found.\n", name);
goto fail;
}
- if (!(m->done = (void (*)(struct pa_core *c, struct pa_module*m)) lt_dlsym(m->dl, PA_SYMBOL_DONE))) {
+ if (!(m->done = (void (*)(pa_core *_c, pa_module*_m)) lt_dlsym(m->dl, PA_SYMBOL_DONE))) {
pa_log(__FILE__": Failed to load module \"%s\": symbol \""PA_SYMBOL_DONE"\" not found.\n", name);
goto fail;
}
return NULL;
}
-static void pa_module_free(struct pa_module *m) {
+static void pa_module_free(pa_module *m) {
assert(m && m->done && m->core);
if (m->core->disallow_module_loading)
pa_xfree(m);
}
-void pa_module_unload(struct pa_core *c, struct pa_module *m) {
+void pa_module_unload(pa_core *c, pa_module *m) {
assert(c && m);
assert(c->modules);
pa_module_free(m);
}
-void pa_module_unload_by_index(struct pa_core *c, uint32_t index) {
- struct pa_module *m;
- assert(c && index != PA_IDXSET_INVALID);
+void pa_module_unload_by_index(pa_core *c, uint32_t idx) {
+ pa_module *m;
+ assert(c && idx != PA_IDXSET_INVALID);
assert(c->modules);
- if (!(m = pa_idxset_remove_by_index(c->modules, index)))
+ if (!(m = pa_idxset_remove_by_index(c->modules, idx)))
return;
pa_module_free(m);
}
-static void free_callback(void *p, void *userdata) {
- struct pa_module *m = p;
+static void free_callback(void *p, PA_GCC_UNUSED void *userdata) {
+ pa_module *m = p;
assert(m);
pa_module_free(m);
}
-void pa_module_unload_all(struct pa_core *c) {
+void pa_module_unload_all(pa_core *c) {
assert(c);
if (!c->modules)
}
}
-static int unused_callback(void *p, uint32_t index, int *del, void *userdata) {
- struct pa_module *m = p;
+static int unused_callback(void *p, PA_GCC_UNUSED uint32_t idx, int *del, void *userdata) {
+ pa_module *m = p;
time_t *now = userdata;
assert(p && del && now);
return 0;
}
-void pa_module_unload_unused(struct pa_core *c) {
+void pa_module_unload_unused(pa_core *c) {
time_t now;
assert(c);
pa_idxset_foreach(c->modules, unused_callback, &now);
}
-static int unload_callback(void *p, uint32_t index, int *del, void *userdata) {
- struct pa_module *m = p;
+static int unload_callback(void *p, PA_GCC_UNUSED uint32_t idx, int *del, PA_GCC_UNUSED void *userdata) {
+ pa_module *m = p;
assert(m);
if (m->unload_requested) {
return 0;
}
-static void defer_cb(struct pa_mainloop_api*api, struct pa_defer_event *e, void *userdata) {
- struct pa_core *core = userdata;
+static void defer_cb(pa_mainloop_api*api, pa_defer_event *e, void *userdata) {
+ pa_core *core = userdata;
api->defer_enable(e, 0);
if (!core->modules)
}
-void pa_module_unload_request(struct pa_module *m) {
+void pa_module_unload_request(pa_module *m) {
assert(m);
m->unload_requested = 1;
m->core->mainloop->defer_enable(m->core->module_defer_unload_event, 1);
}
-void pa_module_set_used(struct pa_module*m, int used) {
+void pa_module_set_used(pa_module*m, int used) {
assert(m);
if (m->n_used != used)
m->n_used = used;
}
-struct pa_modinfo *pa_module_get_info(struct pa_module *m) {
+pa_modinfo *pa_module_get_info(pa_module *m) {
assert(m);
return pa_modinfo_get_by_handle(m->dl);
#include "core.h"
#include "modinfo.h"
+typedef struct pa_module pa_module;
+
struct pa_module {
- struct pa_core *core;
+ pa_core *core;
char *name, *argument;
uint32_t index;
lt_dlhandle dl;
- int (*init)(struct pa_core *c, struct pa_module*m);
- void (*done)(struct pa_core *c, struct pa_module*m);
+ int (*init)(pa_core *c, pa_module*m);
+ void (*done)(pa_core *c, pa_module*m);
void *userdata;
int unload_requested;
};
-struct pa_module* pa_module_load(struct pa_core *c, const char *name, const char*argument);
-/* void pa_module_unload(struct pa_core *c, struct pa_module *m); */
-/* void pa_module_unload_by_index(struct pa_core *c, uint32_t index); */
+pa_module* pa_module_load(pa_core *c, const char *name, const char*argument);
+void pa_module_unload(pa_core *c, pa_module *m);
+void pa_module_unload_by_index(pa_core *c, uint32_t idx);
-void pa_module_unload_all(struct pa_core *c);
-void pa_module_unload_unused(struct pa_core *c);
+void pa_module_unload_all(pa_core *c);
+void pa_module_unload_unused(pa_core *c);
-void pa_module_unload_request(struct pa_module *m);
+void pa_module_unload_request(pa_module *m);
-void pa_module_set_used(struct pa_module*m, int used);
+void pa_module_set_used(pa_module*m, int used);
#define PA_MODULE_AUTHOR(s) const char * pa__get_author(void) { return s; }
#define PA_MODULE_DESCRIPTION(s) const char * pa__get_description(void) { return s; }
#define PA_MODULE_USAGE(s) const char * pa__get_usage(void) { return s; }
#define PA_MODULE_VERSION(s) const char * pa__get_version(void) { return s; }
-struct pa_modinfo *pa_module_get_info(struct pa_module *m);
+pa_modinfo *pa_module_get_info(pa_module *m);
#endif
#include "util.h"
struct namereg_entry {
- enum pa_namereg_type type;
+ pa_namereg_type type;
char *name;
void *data;
};
-void pa_namereg_free(struct pa_core *c) {
+void pa_namereg_free(pa_core *c) {
assert(c);
if (!c->namereg)
return;
- assert(pa_hashmap_ncontents(c->namereg) == 0);
+ assert(pa_hashmap_size(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) {
+const char *pa_namereg_register(pa_core *c, const char *name, pa_namereg_type type, void *data, int fail) {
struct namereg_entry *e;
char *n = NULL;
int r;
}
-void pa_namereg_unregister(struct pa_core *c, const char *name) {
+void pa_namereg_unregister(pa_core *c, const char *name) {
struct namereg_entry *e;
assert(c && name);
pa_xfree(e);
}
-void* pa_namereg_get(struct pa_core *c, const char *name, enum pa_namereg_type type, int autoload) {
+void* pa_namereg_get(pa_core *c, const char *name, pa_namereg_type type, int autoload) {
struct namereg_entry *e;
- uint32_t index;
+ uint32_t idx;
assert(c);
if (!name) {
if (e->type == e->type)
return e->data;
- if (pa_atou(name, &index) < 0) {
+ if (pa_atou(name, &idx) < 0) {
if (autoload) {
pa_autoload_request(c, name, type);
}
if (type == PA_NAMEREG_SINK)
- return pa_idxset_get_by_index(c->sinks, index);
+ return pa_idxset_get_by_index(c->sinks, idx);
else if (type == PA_NAMEREG_SOURCE)
- return pa_idxset_get_by_index(c->sources, index);
+ return pa_idxset_get_by_index(c->sources, idx);
else if (type == PA_NAMEREG_SAMPLE && c->scache)
- return pa_idxset_get_by_index(c->scache, index);
+ return pa_idxset_get_by_index(c->scache, idx);
return NULL;
}
-void pa_namereg_set_default(struct pa_core*c, const char *name, enum pa_namereg_type type) {
+void pa_namereg_set_default(pa_core*c, const char *name, pa_namereg_type type) {
char **s;
assert(c && (type == PA_NAMEREG_SINK || type == PA_NAMEREG_SOURCE));
pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_SERVER|PA_SUBSCRIPTION_EVENT_CHANGE, PA_INVALID_INDEX);
}
-const char *pa_namereg_get_default_sink_name(struct pa_core *c) {
- struct pa_sink *s;
+const char *pa_namereg_get_default_sink_name(pa_core *c) {
+ pa_sink *s;
assert(c);
if (c->default_sink_name)
return NULL;
}
-const char *pa_namereg_get_default_source_name(struct pa_core *c) {
- struct pa_source *s;
- uint32_t index;
+const char *pa_namereg_get_default_source_name(pa_core *c) {
+ pa_source *s;
+ uint32_t idx;
assert(c);
if (c->default_source_name)
return c->default_source_name;
- for (s = pa_idxset_first(c->sources, &index); s; s = pa_idxset_next(c->sources, &index))
+ for (s = pa_idxset_first(c->sources, &idx); s; s = pa_idxset_next(c->sources, &idx))
if (!s->monitor_of) {
pa_namereg_set_default(c, s->name, PA_NAMEREG_SOURCE);
break;
#include "core.h"
-enum pa_namereg_type {
+typedef enum pa_namereg_type {
PA_NAMEREG_SINK,
PA_NAMEREG_SOURCE,
PA_NAMEREG_SAMPLE
-};
+} pa_namereg_type ;
-void pa_namereg_free(struct pa_core *c);
+void pa_namereg_free(pa_core *c);
-const char *pa_namereg_register(struct pa_core *c, const char *name, enum pa_namereg_type type, void *data, int fail);
-void pa_namereg_unregister(struct pa_core *c, const char *name);
-void* pa_namereg_get(struct pa_core *c, const char *name, enum pa_namereg_type type, int autoload);
-void pa_namereg_set_default(struct pa_core*c, const char *name, enum pa_namereg_type type);
+const char *pa_namereg_register(pa_core *c, const char *name, pa_namereg_type type, void *data, int fail);
+void pa_namereg_unregister(pa_core *c, const char *name);
+void* pa_namereg_get(pa_core *c, const char *name, pa_namereg_type type, int autoload);
+void pa_namereg_set_default(pa_core*c, const char *name, pa_namereg_type type);
-const char *pa_namereg_get_default_sink_name(struct pa_core *c);
-const char *pa_namereg_get_default_source_name(struct pa_core *c);
+const char *pa_namereg_get_default_sink_name(pa_core *c);
+const char *pa_namereg_get_default_source_name(pa_core *c);
#endif
return fd;
}
-int pa_oss_auto_format(int fd, struct pa_sample_spec *ss) {
+int pa_oss_auto_format(int fd, pa_sample_spec *ss) {
int format, channels, speed, reqformat;
static const int format_trans[PA_SAMPLE_MAX] = {
[PA_SAMPLE_U8] = AFMT_U8,
#include "sample.h"
int pa_oss_open(const char *device, int *mode, int* pcaps);
-int pa_oss_auto_format(int fd, struct pa_sample_spec *ss);
+int pa_oss_auto_format(int fd, pa_sample_spec *ss);
int pa_oss_set_fragments(int fd, int frags, int frag_size);
#include <polyp/polyplib-browser.h>
#include <polyp/typeid.h>
-static void exit_signal_callback(struct pa_mainloop_api*m, struct pa_signal_event *e, int sig, void *userdata) {
+static void exit_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
fprintf(stderr, "Got signal, exiting\n");
m->quit(m, 0);
}
-static void dump_server(const struct pa_browse_info *i) {
+static void dump_server(const pa_browse_info *i) {
char t[16];
if (i->cookie)
i->cookie ? t : "n/a");
}
-static void dump_device(const struct pa_browse_info *i) {
+static void dump_device(const pa_browse_info *i) {
char t[16], ss[PA_SAMPLE_SPEC_SNPRINT_MAX];
if (i->sample_spec)
}
-static void browser_callback(struct pa_browser *b, enum pa_browse_opcode c, const struct pa_browse_info *i, void *userdata) {
+static void browser_callback(pa_browser *b, pa_browse_opcode c, const pa_browse_info *i, void *userdata) {
assert(b && i);
switch (c) {
int main(int argc, char *argv[]) {
- struct pa_mainloop *mainloop = NULL;
- struct pa_browser *browser = NULL;
+ pa_mainloop *mainloop = NULL;
+ pa_browser *browser = NULL;
int ret = 1, r;
if (!(mainloop = pa_mainloop_new()))
#include <polyp/polyplib-simple.h>
#include <polyp/polyplib-error.h>
+#include "gccmacro.h"
#define BUFSIZE 1024
-int main(int argc, char*argv[]) {
+int main(PA_GCC_UNUSED int argc, char*argv[]) {
/* The Sample format to use */
- static const struct pa_sample_spec ss = {
+ static const pa_sample_spec ss = {
.format = PA_SAMPLE_S16LE,
.rate = 44100,
.channels = 2
};
- struct pa_simple *s = NULL;
+ pa_simple *s = NULL;
int ret = 1;
int error;
static enum { RECORD, PLAYBACK } mode = PLAYBACK;
-static struct pa_context *context = NULL;
-static struct pa_stream *stream = NULL;
-static struct pa_mainloop_api *mainloop_api = NULL;
+static pa_context *context = NULL;
+static pa_stream *stream = NULL;
+static pa_mainloop_api *mainloop_api = NULL;
static void *buffer = NULL;
static size_t buffer_length = 0, buffer_index = 0;
-static struct pa_io_event* stdio_event = NULL;
+static pa_io_event* stdio_event = NULL;
static char *stream_name = NULL, *client_name = NULL, *device = NULL;
static int verbose = 0;
static pa_volume_t volume = PA_VOLUME_NORM;
-static struct pa_sample_spec sample_spec = {
+static pa_sample_spec sample_spec = {
.format = PA_SAMPLE_S16LE,
.rate = 44100,
.channels = 2
}
/* This is called whenever new data may be written to the stream */
-static void stream_write_callback(struct pa_stream *s, size_t length, void *userdata) {
+static void stream_write_callback(pa_stream *s, size_t length, void *userdata) {
assert(s && length);
if (stdio_event)
}
/* This is called whenever new data may is available */
-static void stream_read_callback(struct pa_stream *s, const void*data, size_t length, void *userdata) {
+static void stream_read_callback(pa_stream *s, const void*data, size_t length, void *userdata) {
assert(s && data && length);
if (stdio_event)
}
/* This routine is called whenever the stream state changes */
-static void stream_state_callback(struct pa_stream *s, void *userdata) {
+static void stream_state_callback(pa_stream *s, void *userdata) {
assert(s);
switch (pa_stream_get_state(s)) {
}
/* This is called whenever the context status changes */
-static void context_state_callback(struct pa_context *c, void *userdata) {
+static void context_state_callback(pa_context *c, void *userdata) {
assert(c);
switch (pa_context_get_state(c)) {
}
/* Connection draining complete */
-static void context_drain_complete(struct pa_context*c, void *userdata) {
+static void context_drain_complete(pa_context*c, void *userdata) {
pa_context_disconnect(c);
}
/* Stream draining complete */
-static void stream_drain_complete(struct pa_stream*s, int success, void *userdata) {
- struct pa_operation *o;
+static void stream_drain_complete(pa_stream*s, int success, void *userdata) {
+ pa_operation *o;
if (!success) {
fprintf(stderr, "Failed to drain stream: %s\n", pa_strerror(pa_context_errno(context)));
}
/* New data on STDIN **/
-static void stdin_callback(struct pa_mainloop_api*a, struct pa_io_event *e, int fd, enum pa_io_event_flags f, void *userdata) {
+static void stdin_callback(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags f, void *userdata) {
size_t l, w = 0;
ssize_t r;
assert(a == mainloop_api && e && stdio_event == e);
}
/* Some data may be written to STDOUT */
-static void stdout_callback(struct pa_mainloop_api*a, struct pa_io_event *e, int fd, enum pa_io_event_flags f, void *userdata) {
+static void stdout_callback(pa_mainloop_api*a, pa_io_event *e, int fd, pa_io_event_flags f, void *userdata) {
ssize_t r;
assert(a == mainloop_api && e && stdio_event == e);
}
/* UNIX signal to quit recieved */
-static void exit_signal_callback(struct pa_mainloop_api*m, struct pa_signal_event *e, int sig, void *userdata) {
+static void exit_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
if (verbose)
fprintf(stderr, "Got signal, exiting.\n");
quit(0);
}
/* Show the current latency */
-static void stream_get_latency_callback(struct pa_stream *s, const struct pa_latency_info *i, void *userdata) {
+static void stream_get_latency_callback(pa_stream *s, const pa_latency_info *i, void *userdata) {
pa_usec_t total;
int negative = 0;
assert(s);
}
/* Someone requested that the latency is shown */
-static void sigusr1_signal_callback(struct pa_mainloop_api*m, struct pa_signal_event *e, int sig, void *userdata) {
+static void sigusr1_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
fprintf(stderr, "Got SIGUSR1, requesting latency.\n");
pa_operation_unref(pa_stream_get_latency_info(stream, stream_get_latency_callback, NULL));
}
};
int main(int argc, char *argv[]) {
- struct pa_mainloop* m = NULL;
+ pa_mainloop* m = NULL;
int ret = 1, r, c;
char *bn, *server = NULL;
#include "packet.h"
#include "xmalloc.h"
-struct pa_packet* pa_packet_new(size_t length) {
- struct pa_packet *p;
+pa_packet* pa_packet_new(size_t length) {
+ pa_packet *p;
assert(length);
- p = pa_xmalloc(sizeof(struct pa_packet)+length);
+ p = pa_xmalloc(sizeof(pa_packet)+length);
p->ref = 1;
p->length = length;
p->data = (uint8_t*) (p+1);
return p;
}
-struct pa_packet* pa_packet_new_dynamic(uint8_t* data, size_t length) {
- struct pa_packet *p;
+pa_packet* pa_packet_new_dynamic(uint8_t* data, size_t length) {
+ pa_packet *p;
assert(data && length);
- p = pa_xmalloc(sizeof(struct pa_packet));
+ p = pa_xmalloc(sizeof(pa_packet));
p->ref = 1;
p->length = length;
p->data = data;
return p;
}
-struct pa_packet* pa_packet_ref(struct pa_packet *p) {
+pa_packet* pa_packet_ref(pa_packet *p) {
assert(p && p->ref >= 1);
p->ref++;
return p;
}
-void pa_packet_unref(struct pa_packet *p) {
+void pa_packet_unref(pa_packet *p) {
assert(p && p->ref >= 1);
p->ref--;
#include <sys/types.h>
#include <inttypes.h>
-struct pa_packet {
+typedef struct pa_packet {
enum { PA_PACKET_APPENDED, PA_PACKET_DYNAMIC } type;
unsigned ref;
size_t length;
uint8_t *data;
-};
+} pa_packet;
-struct pa_packet* pa_packet_new(size_t length);
-struct pa_packet* pa_packet_new_dynamic(uint8_t* data, size_t length);
+pa_packet* pa_packet_new(size_t length);
+pa_packet* pa_packet_new_dynamic(uint8_t* data, size_t length);
-struct pa_packet* pa_packet_ref(struct pa_packet *p);
-void pa_packet_unref(struct pa_packet *p);
+pa_packet* pa_packet_ref(pa_packet *p);
+void pa_packet_unref(pa_packet *p);
#endif
#include "log.h"
#include "pid.h"
-int main() {
+int main(PA_GCC_UNUSED int main, PA_GCC_UNUSED char*argv[]) {
pid_t pid ;
int fd = -1;
int ret = 1, i;
#define BUFSIZE 1024
-static struct pa_context *context = NULL;
-static struct pa_mainloop_api *mainloop_api = NULL;
+static pa_context *context = NULL;
+static pa_mainloop_api *mainloop_api = NULL;
static char *device = NULL, *sample_name = NULL;
static SNDFILE *sndfile = NULL;
-static struct pa_stream *sample_stream = NULL;
-static struct pa_sample_spec sample_spec;
+static pa_stream *sample_stream = NULL;
+static pa_sample_spec sample_spec;
static size_t sample_length = 0;
static int actions = 1;
}
-static void context_drain_complete(struct pa_context *c, void *userdata) {
+static void context_drain_complete(pa_context *c, void *userdata) {
pa_context_disconnect(c);
}
static void drain(void) {
- struct pa_operation *o;
+ pa_operation *o;
if (!(o = pa_context_drain(context, context_drain_complete, NULL)))
pa_context_disconnect(context);
else
drain();
}
-static void stat_callback(struct pa_context *c, const struct pa_stat_info *i, void *userdata) {
+static void stat_callback(pa_context *c, const pa_stat_info *i, void *userdata) {
char s[128];
if (!i) {
fprintf(stderr, "Failed to get statistics: %s\n", pa_strerror(pa_context_errno(c)));
complete_action();
}
-static void get_server_info_callback(struct pa_context *c, const struct pa_server_info *i, void *useerdata) {
+static void get_server_info_callback(pa_context *c, const pa_server_info *i, void *useerdata) {
char s[PA_SAMPLE_SPEC_SNPRINT_MAX];
if (!i) {
complete_action();
}
-static void get_sink_info_callback(struct pa_context *c, const struct pa_sink_info *i, int is_last, void *userdata) {
+static void get_sink_info_callback(pa_context *c, const pa_sink_info *i, int is_last, void *userdata) {
char s[PA_SAMPLE_SPEC_SNPRINT_MAX], tid[5];
if (is_last < 0) {
}
-static void get_source_info_callback(struct pa_context *c, const struct pa_source_info *i, int is_last, void *userdata) {
+static void get_source_info_callback(pa_context *c, const pa_source_info *i, int is_last, void *userdata) {
char s[PA_SAMPLE_SPEC_SNPRINT_MAX], t[32], tid[5];
if (is_last < 0) {
}
-static void get_module_info_callback(struct pa_context *c, const struct pa_module_info *i, int is_last, void *userdata) {
+static void get_module_info_callback(pa_context *c, const pa_module_info *i, int is_last, void *userdata) {
char t[32];
if (is_last < 0) {
i->auto_unload ? "yes" : "no");
}
-static void get_client_info_callback(struct pa_context *c, const struct pa_client_info *i, int is_last, void *userdata) {
+static void get_client_info_callback(pa_context *c, const pa_client_info *i, int is_last, void *userdata) {
char t[32], tid[5];
if (is_last < 0) {
i->owner_module != PA_INVALID_INDEX ? t : "n/a");
}
-static void get_sink_input_info_callback(struct pa_context *c, const struct pa_sink_input_info *i, int is_last, void *userdata) {
+static void get_sink_input_info_callback(pa_context *c, const pa_sink_input_info *i, int is_last, void *userdata) {
char t[32], k[32], s[PA_SAMPLE_SPEC_SNPRINT_MAX], tid[5];
if (is_last < 0) {
}
-static void get_source_output_info_callback(struct pa_context *c, const struct pa_source_output_info *i, int is_last, void *userdata) {
+static void get_source_output_info_callback(pa_context *c, const pa_source_output_info *i, int is_last, void *userdata) {
char t[32], k[32], s[PA_SAMPLE_SPEC_SNPRINT_MAX], tid[5];
if (is_last < 0) {
i->resample_method ? i->resample_method : "n/a");
}
-static void get_sample_info_callback(struct pa_context *c, const struct pa_sample_info *i, int is_last, void *userdata) {
+static void get_sample_info_callback(pa_context *c, const pa_sample_info *i, int is_last, void *userdata) {
char t[32], s[PA_SAMPLE_SPEC_SNPRINT_MAX];
if (is_last < 0) {
i->filename ? i->filename : "n/a");
}
-static void get_autoload_info_callback(struct pa_context *c, const struct pa_autoload_info *i, int is_last, void *userdata) {
+static void get_autoload_info_callback(pa_context *c, const pa_autoload_info *i, int is_last, void *userdata) {
if (is_last < 0) {
fprintf(stderr, "Failed to get autoload information: %s\n", pa_strerror(pa_context_errno(c)));
quit(1);
i->argument);
}
-static void simple_callback(struct pa_context *c, int success, void *userdata) {
+static void simple_callback(pa_context *c, int success, void *userdata) {
if (!success) {
fprintf(stderr, "Failure: %s\n", pa_strerror(pa_context_errno(c)));
quit(1);
complete_action();
}
-static void stream_state_callback(struct pa_stream *s, void *userdata) {
+static void stream_state_callback(pa_stream *s, void *userdata) {
assert(s);
switch (pa_stream_get_state(s)) {
}
}
-static void stream_write_callback(struct pa_stream *s, size_t length, void *userdata) {
+static void stream_write_callback(pa_stream *s, size_t length, void *userdata) {
sf_count_t l;
float *d;
assert(s && length && sndfile);
}
}
-static void context_state_callback(struct pa_context *c, void *userdata) {
+static void context_state_callback(pa_context *c, void *userdata) {
assert(c);
switch (pa_context_get_state(c)) {
case PA_CONTEXT_CONNECTING:
}
}
-static void exit_signal_callback(struct pa_mainloop_api *m, struct pa_signal_event *e, int sig, void *userdata) {
+static void exit_signal_callback(pa_mainloop_api *m, pa_signal_event *e, int sig, void *userdata) {
fprintf(stderr, "Got SIGINT, exiting.\n");
quit(0);
}
enum { ARG_VERSION = 256 };
int main(int argc, char *argv[]) {
- struct pa_mainloop* m = NULL;
+ pa_mainloop* m = NULL;
char tmp[PATH_MAX];
int ret = 1, r, c;
char *server = NULL, *client_name = NULL, *bn;
#error Invalid Polypaudio API version
#endif
-static struct pa_context *context = NULL;
-static struct pa_stream *stream = NULL;
-static struct pa_mainloop_api *mainloop_api = NULL;
+static pa_context *context = NULL;
+static pa_stream *stream = NULL;
+static pa_mainloop_api *mainloop_api = NULL;
static char *stream_name = NULL, *client_name = NULL, *device = NULL;
static SNDFILE* sndfile = NULL;
-static struct pa_sample_spec sample_spec = { 0, 0, 0 };
+static pa_sample_spec sample_spec = { 0, 0, 0 };
-static sf_count_t (*readf_function)(SNDFILE *sndfile, void *ptr, sf_count_t frames);
+static sf_count_t (*readf_function)(SNDFILE *_sndfile, void *ptr, sf_count_t frames);
/* A shortcut for terminating the application */
static void quit(int ret) {
}
/* Connection draining complete */
-static void context_drain_complete(struct pa_context*c, void *userdata) {
+static void context_drain_complete(pa_context*c, void *userdata) {
pa_context_disconnect(c);
}
/* Stream draining complete */
-static void stream_drain_complete(struct pa_stream*s, int success, void *userdata) {
- struct pa_operation *o;
+static void stream_drain_complete(pa_stream*s, int success, void *userdata) {
+ pa_operation *o;
if (!success) {
fprintf(stderr, "Failed to drain stream: %s\n", pa_strerror(pa_context_errno(context)));
}
/* This is called whenever new data may be written to the stream */
-static void stream_write_callback(struct pa_stream *s, size_t length, void *userdata) {
+static void stream_write_callback(pa_stream *s, size_t length, void *userdata) {
size_t k;
sf_count_t f, n;
void *data;
}
/* This routine is called whenever the stream state changes */
-static void stream_state_callback(struct pa_stream *s, void *userdata) {
+static void stream_state_callback(pa_stream *s, void *userdata) {
assert(s);
switch (pa_stream_get_state(s)) {
}
/* This is called whenever the context status changes */
-static void context_state_callback(struct pa_context *c, void *userdata) {
+static void context_state_callback(pa_context *c, void *userdata) {
assert(c);
switch (pa_context_get_state(c)) {
}
/* UNIX signal to quit recieved */
-static void exit_signal_callback(struct pa_mainloop_api*m, struct pa_signal_event *e, int sig, void *userdata) {
+static void exit_signal_callback(pa_mainloop_api*m, pa_signal_event *e, int sig, void *userdata) {
if (verbose)
fprintf(stderr, "Got SIGINT, exiting.\n");
quit(0);
};
int main(int argc, char *argv[]) {
- struct pa_mainloop* m = NULL;
+ pa_mainloop* m = NULL;
int ret = 1, r, c;
- char *bn, *server = NULL, *filename;
+ char *bn, *server = NULL;
+ const char *filename;
SF_INFO sfinfo;
static const struct option long_options[] = {
case SF_FORMAT_ULAW:
case SF_FORMAT_ALAW:
sample_spec.format = PA_SAMPLE_S16NE;
- readf_function = (sf_count_t (*)(SNDFILE *sndfile, void *ptr, sf_count_t frames)) sf_readf_short;
+ readf_function = (sf_count_t (*)(SNDFILE *_sndfile, void *ptr, sf_count_t frames)) sf_readf_short;
break;
case SF_FORMAT_FLOAT:
default:
sample_spec.format = PA_SAMPLE_FLOAT32NE;
- readf_function = (sf_count_t (*)(SNDFILE *sndfile, void *ptr, sf_count_t frames)) sf_readf_float;
+ readf_function = (sf_count_t (*)(SNDFILE *_sndfile, void *ptr, sf_count_t frames)) sf_readf_float;
break;
}
#include <polyp/polyplib-simple.h>
#include <polyp/polyplib-error.h>
+#include "gccmacro.h"
#define BUFSIZE 1024
break;
ret += r;
- data = (uint8_t*) data + r;
+ data = (const uint8_t*) data + r;
size -= r;
}
return ret;
}
-int main(int argc, char*argv[]) {
+int main(PA_GCC_UNUSED int argc, char*argv[]) {
/* The sample type to use */
- static const struct pa_sample_spec ss = {
+ static const pa_sample_spec ss = {
.format = PA_SAMPLE_S16LE,
.rate = 44100,
.channels = 2
};
- struct pa_simple *s = NULL;
+ pa_simple *s = NULL;
int ret = 1;
int error;
}
}
-int pa_parse_address(const char *name, struct pa_parsed_address *ret_p) {
+int pa_parse_address(const char *name, pa_parsed_address *ret_p) {
const char *p;
assert(name && ret_p);
- memset(ret_p, 0, sizeof(struct pa_parsed_address));
+ memset(ret_p, 0, sizeof(pa_parsed_address));
ret_p->type = PA_PARSED_ADDRESS_TCP_AUTO;
if (*name == '{') {
#include <inttypes.h>
-enum pa_parsed_address_type {
+typedef enum pa_parsed_address_type {
PA_PARSED_ADDRESS_UNIX,
PA_PARSED_ADDRESS_TCP4,
PA_PARSED_ADDRESS_TCP6,
PA_PARSED_ADDRESS_TCP_AUTO
-};
+} pa_parsed_address_type;
-struct pa_parsed_address {
- enum pa_parsed_address_type type;
+typedef struct pa_parsed_address {
+ pa_parsed_address_type type;
char *path_or_host;
uint16_t port;
-};
+} pa_parsed_address;
-int pa_parse_address(const char *a, struct pa_parsed_address *ret_p);
+int pa_parse_address(const char *a, pa_parsed_address *ret_p);
#endif
}
case EXPORT: {
- struct pa_client_conf *c = pa_client_conf_new();
+ pa_client_conf *conf = pa_client_conf_new();
uint8_t cookie[PA_NATIVE_COOKIE_LENGTH];
char hx[PA_NATIVE_COOKIE_LENGTH*2+1];
- assert(c);
+ assert(conf);
- if (pa_client_conf_load(c, NULL) < 0) {
+ if (pa_client_conf_load(conf, NULL) < 0) {
fprintf(stderr, "Failed to load client configuration file.\n");
goto finish;
}
- if (pa_client_conf_env(c) < 0) {
+ if (pa_client_conf_env(conf) < 0) {
fprintf(stderr, "Failed to read environment configuration data.\n");
goto finish;
}
if (server)
pa_x11_set_prop(d, "POLYP_SERVER", server);
- else if (c->default_server)
- pa_x11_set_prop(d, "POLYP_SERVER", c->default_server);
+ else if (conf->default_server)
+ pa_x11_set_prop(d, "POLYP_SERVER", conf->default_server);
else {
char hn[256];
if (!pa_get_fqdn(hn, sizeof(hn))) {
if (sink)
pa_x11_set_prop(d, "POLYP_SINK", sink);
- else if (c->default_sink)
- pa_x11_set_prop(d, "POLYP_SINK", c->default_sink);
+ else if (conf->default_sink)
+ pa_x11_set_prop(d, "POLYP_SINK", conf->default_sink);
if (source)
pa_x11_set_prop(d, "POLYP_SOURCE", source);
- if (c->default_source)
- pa_x11_set_prop(d, "POLYP_SOURCE", c->default_source);
+ if (conf->default_source)
+ pa_x11_set_prop(d, "POLYP_SOURCE", conf->default_source);
- pa_client_conf_free(c);
+ pa_client_conf_free(conf);
if (pa_authkey_load_auto(cookie_file, cookie, sizeof(cookie)) < 0) {
fprintf(stderr, "Failed to load cookie data\n");
#endif
struct reply_info {
- struct pa_pdispatch *pdispatch;
+ pa_pdispatch *pdispatch;
PA_LLIST_FIELDS(struct reply_info);
- void (*callback)(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
+ pa_pdispatch_callback callback;
void *userdata;
uint32_t tag;
- struct pa_time_event *time_event;
+ pa_time_event *time_event;
};
struct pa_pdispatch {
int ref;
- struct pa_mainloop_api *mainloop;
- const struct pa_pdispatch_command *command_table;
+ pa_mainloop_api *mainloop;
+ const pa_pdispatch_callback *callback_table;
unsigned n_commands;
PA_LLIST_HEAD(struct reply_info, replies);
- void (*drain_callback)(struct pa_pdispatch *pd, void *userdata);
+ pa_pdispatch_drain_callback drain_callback;
void *drain_userdata;
};
pa_xfree(r);
}
-struct pa_pdispatch* pa_pdispatch_new(struct pa_mainloop_api *mainloop, const struct pa_pdispatch_command*table, unsigned entries) {
- struct pa_pdispatch *pd;
+pa_pdispatch* pa_pdispatch_new(pa_mainloop_api *mainloop, const pa_pdispatch_callback*table, unsigned entries) {
+ pa_pdispatch *pd;
assert(mainloop);
assert((entries && table) || (!entries && !table));
- pd = pa_xmalloc(sizeof(struct pa_pdispatch));
+ pd = pa_xmalloc(sizeof(pa_pdispatch));
pd->ref = 1;
pd->mainloop = mainloop;
- pd->command_table = table;
+ pd->callback_table = table;
pd->n_commands = entries;
- PA_LLIST_HEAD_INIT(struct pa_reply_info, pd->replies);
+ PA_LLIST_HEAD_INIT(pa_reply_info, pd->replies);
pd->drain_callback = NULL;
pd->drain_userdata = NULL;
return pd;
}
-void pdispatch_free(struct pa_pdispatch *pd) {
+static void pdispatch_free(pa_pdispatch *pd) {
assert(pd);
while (pd->replies)
pa_xfree(pd);
}
-static void run_action(struct pa_pdispatch *pd, struct reply_info *r, uint32_t command, struct pa_tagstruct *ts) {
- void (*callback)(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
+static void run_action(pa_pdispatch *pd, struct reply_info *r, uint32_t command, pa_tagstruct *ts) {
+ pa_pdispatch_callback callback;
void *userdata;
uint32_t tag;
assert(r);
pa_pdispatch_unref(pd);
}
-int pa_pdispatch_run(struct pa_pdispatch *pd, struct pa_packet*packet, void *userdata) {
+int pa_pdispatch_run(pa_pdispatch *pd, pa_packet*packet, void *userdata) {
uint32_t tag, command;
- struct pa_tagstruct *ts = NULL;
+ pa_tagstruct *ts = NULL;
int ret = -1;
assert(pd && packet && packet->data);
if (r)
run_action(pd, r, command, ts);
- } else if (pd->command_table && (command < pd->n_commands) && pd->command_table[command].proc) {
- const struct pa_pdispatch_command *c = pd->command_table+command;
+ } else if (pd->callback_table && (command < pd->n_commands) && pd->callback_table[command]) {
+ const pa_pdispatch_callback *c = pd->callback_table+command;
- c->proc(pd, command, tag, ts, userdata);
+ (*c)(pd, command, tag, ts, userdata);
} else {
pa_log(__FILE__": Recieved unsupported command %u\n", command);
goto finish;
return ret;
}
-static void timeout_callback(struct pa_mainloop_api*m, struct pa_time_event*e, const struct timeval *tv, void *userdata) {
+static void timeout_callback(pa_mainloop_api*m, pa_time_event*e, PA_GCC_UNUSED const struct timeval *tv, void *userdata) {
struct reply_info*r = userdata;
assert(r && r->time_event == e && r->pdispatch && r->pdispatch->mainloop == m && r->callback);
run_action(r->pdispatch, r, PA_COMMAND_TIMEOUT, NULL);
}
-void pa_pdispatch_register_reply(struct pa_pdispatch *pd, uint32_t tag, int timeout, void (*cb)(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata), void *userdata) {
+void pa_pdispatch_register_reply(pa_pdispatch *pd, uint32_t tag, int timeout, pa_pdispatch_callback cb, void *userdata) {
struct reply_info *r;
struct timeval tv;
assert(pd && pd->ref >= 1 && cb);
PA_LLIST_PREPEND(struct reply_info, pd->replies, r);
}
-int pa_pdispatch_is_pending(struct pa_pdispatch *pd) {
+int pa_pdispatch_is_pending(pa_pdispatch *pd) {
assert(pd);
return !!pd->replies;
}
-void pa_pdispatch_set_drain_callback(struct pa_pdispatch *pd, void (*cb)(struct pa_pdispatch *pd, void *userdata), void *userdata) {
+void pa_pdispatch_set_drain_callback(pa_pdispatch *pd, void (*cb)(pa_pdispatch *pd, void *userdata), void *userdata) {
assert(pd);
assert(!cb || pa_pdispatch_is_pending(pd));
pd->drain_userdata = userdata;
}
-void pa_pdispatch_unregister_reply(struct pa_pdispatch *pd, void *userdata) {
+void pa_pdispatch_unregister_reply(pa_pdispatch *pd, void *userdata) {
struct reply_info *r, *n;
assert(pd);
}
}
-void pa_pdispatch_unref(struct pa_pdispatch *pd) {
+void pa_pdispatch_unref(pa_pdispatch *pd) {
assert(pd && pd->ref >= 1);
if (!(--(pd->ref)))
pdispatch_free(pd);
}
-struct pa_pdispatch* pa_pdispatch_ref(struct pa_pdispatch *pd) {
+pa_pdispatch* pa_pdispatch_ref(pa_pdispatch *pd) {
assert(pd && pd->ref >= 1);
pd->ref++;
return pd;
#include "packet.h"
#include "mainloop-api.h"
-struct pa_pdispatch;
+typedef struct pa_pdispatch pa_pdispatch;
-struct pa_pdispatch_command {
- void (*proc)(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-};
+typedef void (*pa_pdispatch_callback)(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
-struct pa_pdispatch* pa_pdispatch_new(struct pa_mainloop_api *m, const struct pa_pdispatch_command*table, unsigned entries);
-void pa_pdispatch_unref(struct pa_pdispatch *pd);
-struct pa_pdispatch* pa_pdispatch_ref(struct pa_pdispatch *pd);
+pa_pdispatch* pa_pdispatch_new(pa_mainloop_api *m, const pa_pdispatch_callback*table, unsigned entries);
+void pa_pdispatch_unref(pa_pdispatch *pd);
+pa_pdispatch* pa_pdispatch_ref(pa_pdispatch *pd);
-int pa_pdispatch_run(struct pa_pdispatch *pd, struct pa_packet*p, void *userdata);
+int pa_pdispatch_run(pa_pdispatch *pd, pa_packet*p, void *userdata);
-void pa_pdispatch_register_reply(struct pa_pdispatch *pd, uint32_t tag, int timeout, void (*cb)(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata), void *userdata);
+void pa_pdispatch_register_reply(pa_pdispatch *pd, uint32_t tag, int timeout, pa_pdispatch_callback callback, void *userdata);
-int pa_pdispatch_is_pending(struct pa_pdispatch *pd);
+int pa_pdispatch_is_pending(pa_pdispatch *pd);
-void pa_pdispatch_set_drain_callback(struct pa_pdispatch *pd, void (*cb)(struct pa_pdispatch *pd, void *userdata), void *userdata);
+typedef void (*pa_pdispatch_drain_callback)(pa_pdispatch *pd, void *userdata);
+void pa_pdispatch_set_drain_callback(pa_pdispatch *pd, pa_pdispatch_drain_callback callback, void *userdata);
/* Remove all reply slots with the give userdata parameter */
-void pa_pdispatch_unregister_reply(struct pa_pdispatch *pd, void *userdata);
+void pa_pdispatch_unregister_reply(pa_pdispatch *pd, void *userdata);
#endif
#include "play-memchunk.h"
#include "sink-input.h"
#include "xmalloc.h"
+#include "gccmacro.h"
#define PA_TYPEID_MEMCHUNK PA_TYPEID_MAKE('M', 'C', 'N', 'K')
-static void sink_input_kill(struct pa_sink_input *i) {
- struct pa_memchunk *c;
+static void sink_input_kill(pa_sink_input *i) {
+ pa_memchunk *c;
assert(i && i->userdata);
c = i->userdata;
}
-static int sink_input_peek(struct pa_sink_input *i, struct pa_memchunk *chunk) {
- struct pa_memchunk *c;
+static int sink_input_peek(pa_sink_input *i, pa_memchunk *chunk) {
+ pa_memchunk *c;
assert(i && chunk && i->userdata);
c = i->userdata;
return 0;
}
-static void si_kill(struct pa_mainloop_api *m, void *i) {
+static void si_kill(PA_GCC_UNUSED pa_mainloop_api *m, void *i) {
sink_input_kill(i);
}
-static void sink_input_drop(struct pa_sink_input *i, const struct pa_memchunk*chunk, size_t length) {
- struct pa_memchunk *c;
+static void sink_input_drop(pa_sink_input *i, const pa_memchunk*chunk, size_t length) {
+ pa_memchunk *c;
assert(i && length && i->userdata);
c = i->userdata;
pa_mainloop_api_once(i->sink->core->mainloop, si_kill, i);
}
-int pa_play_memchunk(struct pa_sink *sink, const char *name, const struct pa_sample_spec *ss, const struct pa_memchunk *chunk, pa_volume_t volume) {
- struct pa_sink_input *si;
- struct pa_memchunk *nchunk;
+int pa_play_memchunk(pa_sink *sink, const char *name, const pa_sample_spec *ss, const pa_memchunk *chunk, pa_volume_t volume) {
+ pa_sink_input *si;
+ pa_memchunk *nchunk;
assert(sink && chunk);
si->drop = sink_input_drop;
si->kill = sink_input_kill;
- si->userdata = nchunk = pa_xmalloc(sizeof(struct pa_memchunk));
+ si->userdata = nchunk = pa_xmalloc(sizeof(pa_memchunk));
*nchunk = *chunk;
pa_memblock_ref(chunk->memblock);
#include "sink.h"
#include "memchunk.h"
-int pa_play_memchunk(struct pa_sink *sink, const char *name, const struct pa_sample_spec *ss, const struct pa_memchunk *chunk, pa_volume_t volume);
+int pa_play_memchunk(pa_sink *sink, const char *name, const pa_sample_spec *ss, const pa_memchunk *chunk, pa_volume_t volume);
#endif
#define SERVICE_NAME_SOURCE "_polypaudio-source._tcp."
#define SERVICE_NAME_SERVER "_polypaudio-server._tcp."
-struct pa_browser {
+pa_browser {
int ref;
- struct pa_mainloop_api *mainloop;
+ pa_mainloop_api *mainloop;
- void (*callback)(struct pa_browser *z, enum pa_browse_opcode c, const struct pa_browse_info *i, void *userdata);
+ void (*callback)(pa_browser *z, pa_browse_opcode c, const pa_browse_info *i, void *userdata);
void *callback_userdata;
sw_discovery discovery;
- struct pa_io_event *io_event;
+ pa_io_event *io_event;
};
-static void io_callback(struct pa_mainloop_api*a, struct pa_io_event*e, int fd, enum pa_io_event_flags events, void *userdata) {
- struct pa_browser *b = userdata;
+static void io_callback(pa_mainloop_api*a, pa_io_event*e, int fd, pa_io_event_flags events, void *userdata) {
+ pa_browser *b = userdata;
assert(a && b && b->mainloop == a);
if (events != PA_IO_EVENT_INPUT || sw_discovery_read_socket(b->discovery) != SW_OKAY) {
sw_ulong text_record_len,
sw_opaque extra) {
- struct pa_browser *b = extra;
- struct pa_browse_info i;
+ pa_browser *b = extra;
+ pa_browse_info i;
char ip[256], a[256];
- enum pa_browse_opcode opcode;
+ pa_browse_opcode opcode;
int device_found = 0;
uint32_t cookie;
pa_typeid_t typeid;
- struct pa_sample_spec ss;
+ pa_sample_spec ss;
int ss_valid = 0;
sw_text_record_iterator iterator;
int free_iterator = 0;
sw_const_string domain,
sw_opaque extra) {
- struct pa_browser *b = extra;
+ pa_browser *b = extra;
assert(b);
switch (status) {
case SW_DISCOVERY_BROWSE_REMOVE_SERVICE:
if (b->callback) {
- struct pa_browse_info i;
+ pa_browse_info i;
memset(&i, 0, sizeof(i));
i.name = name;
b->callback(b, PA_BROWSE_REMOVE, &i, b->callback_userdata);
return SW_OKAY;
}
-struct pa_browser *pa_browser_new(struct pa_mainloop_api *mainloop) {
- struct pa_browser *b;
+pa_browser *pa_browser_new(pa_mainloop_api *mainloop) {
+ pa_browser *b;
sw_discovery_oid oid;
- b = pa_xmalloc(sizeof(struct pa_browser));
+ b = pa_xmalloc(sizeof(pa_browser));
b->mainloop = mainloop;
b->ref = 1;
b->callback = NULL;
return b;
}
-static void browser_free(struct pa_browser *b) {
+static void browser_free(pa_browser *b) {
assert(b && b->mainloop);
if (b->io_event)
pa_xfree(b);
}
-struct pa_browser *pa_browser_ref(struct pa_browser *b) {
+pa_browser *pa_browser_ref(pa_browser *b) {
assert(b && b->ref >= 1);
b->ref++;
return b;
}
-void pa_browser_unref(struct pa_browser *b) {
+void pa_browser_unref(pa_browser *b) {
assert(b && b->ref >= 1);
if ((-- (b->ref)) <= 0)
browser_free(b);
}
-void pa_browser_set_callback(struct pa_browser *b, void (*cb)(struct pa_browser *z, enum pa_browse_opcode c, const struct pa_browse_info *i, void* userdata), void *userdata) {
+void pa_browser_set_callback(pa_browser *b, void (*cb)(pa_browser *z, pa_browse_opcode c, const pa_browse_info *i, void* userdata), void *userdata) {
assert(b);
b->callback = cb;
PA_C_DECL_BEGIN
-struct pa_browser;
+pa_browser;
-enum pa_browse_opcode {
+pa_browse_opcode {
PA_BROWSE_NEW_SERVER,
PA_BROWSE_NEW_SINK,
PA_BROWSE_NEW_SOURCE,
PA_BROWSE_REMOVE
};
-struct pa_browser *pa_browser_new(struct pa_mainloop_api *mainloop);
-struct pa_browser *pa_browser_ref(struct pa_browser *z);
-void pa_browser_unref(struct pa_browser *z);
+pa_browser *pa_browser_new(pa_mainloop_api *mainloop);
+pa_browser *pa_browser_ref(pa_browser *z);
+void pa_browser_unref(pa_browser *z);
-struct pa_browse_info {
+pa_browse_info {
/* Unique service name */
const char *name; /* always available */
const char *device; /* always available when this information is of a sink/source */
const char *description; /* optional */
const pa_typeid_t *typeid; /* optional */
- const struct pa_sample_spec *sample_spec; /* optional */
+ const pa_sample_spec *sample_spec; /* optional */
};
-void pa_browser_set_callback(struct pa_browser *z, void (*cb)(struct pa_browser *z, enum pa_browse_opcode c, const struct pa_browse_info *i, void *userdata), void *userdata);
+void pa_browser_set_callback(pa_browser *z, void (*cb)(pa_browser *z, pa_browse_opcode c, const pa_browse_info *i, void *userdata), void *userdata);
PA_C_DECL_END
#include "polyplib-internal.h"
#include "polyplib-context.h"
+#include "polyplib-version.h"
#include "native-common.h"
#include "pdispatch.h"
#include "pstream.h"
#define AUTOSPAWN_LOCK "autospawn.lock"
-static const struct pa_pdispatch_command command_table[PA_COMMAND_MAX] = {
- [PA_COMMAND_REQUEST] = { pa_command_request },
- [PA_COMMAND_PLAYBACK_STREAM_KILLED] = { pa_command_stream_killed },
- [PA_COMMAND_RECORD_STREAM_KILLED] = { pa_command_stream_killed },
- [PA_COMMAND_SUBSCRIBE_EVENT] = { pa_command_subscribe_event },
+static const pa_pdispatch_callback command_table[PA_COMMAND_MAX] = {
+ [PA_COMMAND_REQUEST] = pa_command_request,
+ [PA_COMMAND_PLAYBACK_STREAM_KILLED] = pa_command_stream_killed,
+ [PA_COMMAND_RECORD_STREAM_KILLED] = pa_command_stream_killed,
+ [PA_COMMAND_SUBSCRIBE_EVENT] = pa_command_subscribe_event
};
-static void unlock_autospawn_lock_file(struct pa_context *c) {
+static void unlock_autospawn_lock_file(pa_context *c) {
assert(c);
if (c->autospawn_lock_fd >= 0) {
}
}
-struct pa_context *pa_context_new(struct pa_mainloop_api *mainloop, const char *name) {
- struct pa_context *c;
+pa_context *pa_context_new(pa_mainloop_api *mainloop, const char *name) {
+ pa_context *c;
assert(mainloop && name);
- c = pa_xmalloc(sizeof(struct pa_context));
+ c = pa_xmalloc(sizeof(pa_context));
c->ref = 1;
c->name = pa_xstrdup(name);
c->mainloop = mainloop;
c->record_streams = pa_dynarray_new();
assert(c->playback_streams && c->record_streams);
- PA_LLIST_HEAD_INIT(struct pa_stream, c->streams);
- PA_LLIST_HEAD_INIT(struct pa_operation, c->operations);
+ PA_LLIST_HEAD_INIT(pa_stream, c->streams);
+ PA_LLIST_HEAD_INIT(pa_operation, c->operations);
c->error = PA_ERROR_OK;
c->state = PA_CONTEXT_UNCONNECTED;
return c;
}
-static void context_free(struct pa_context *c) {
+static void context_free(pa_context *c) {
assert(c);
unlock_autospawn_lock_file(c);
pa_xfree(c);
}
-struct pa_context* pa_context_ref(struct pa_context *c) {
+pa_context* pa_context_ref(pa_context *c) {
assert(c && c->ref >= 1);
c->ref++;
return c;
}
-void pa_context_unref(struct pa_context *c) {
+void pa_context_unref(pa_context *c) {
assert(c && c->ref >= 1);
if ((--(c->ref)) == 0)
context_free(c);
}
-void pa_context_set_state(struct pa_context *c, enum pa_context_state st) {
+void pa_context_set_state(pa_context *c, pa_context_state st) {
assert(c);
if (c->state == st)
pa_context_ref(c);
if (st == PA_CONTEXT_FAILED || st == PA_CONTEXT_TERMINATED) {
- struct pa_stream *s;
+ pa_stream *s;
s = c->streams ? pa_stream_ref(c->streams) : NULL;
while (s) {
- struct pa_stream *n = s->next ? pa_stream_ref(s->next) : NULL;
+ pa_stream *n = s->next ? pa_stream_ref(s->next) : NULL;
pa_stream_set_state(s, st == PA_CONTEXT_FAILED ? PA_STREAM_FAILED : PA_STREAM_TERMINATED);
pa_stream_unref(s);
s = n;
pa_context_unref(c);
}
-void pa_context_fail(struct pa_context *c, int error) {
+void pa_context_fail(pa_context *c, int error) {
assert(c);
c->error = error;
pa_context_set_state(c, PA_CONTEXT_FAILED);
}
-static void pstream_die_callback(struct pa_pstream *p, void *userdata) {
- struct pa_context *c = userdata;
+static void pstream_die_callback(pa_pstream *p, void *userdata) {
+ pa_context *c = userdata;
assert(p && c);
pa_context_fail(c, PA_ERROR_CONNECTIONTERMINATED);
}
-static void pstream_packet_callback(struct pa_pstream *p, struct pa_packet *packet, void *userdata) {
- struct pa_context *c = userdata;
+static void pstream_packet_callback(pa_pstream *p, pa_packet *packet, void *userdata) {
+ pa_context *c = userdata;
assert(p && packet && c);
pa_context_ref(c);
pa_context_unref(c);
}
-static void pstream_memblock_callback(struct pa_pstream *p, uint32_t channel, uint32_t delta, const struct pa_memchunk *chunk, void *userdata) {
- struct pa_context *c = userdata;
- struct pa_stream *s;
+static void pstream_memblock_callback(pa_pstream *p, uint32_t channel, PA_GCC_UNUSED uint32_t delta, const pa_memchunk *chunk, void *userdata) {
+ pa_context *c = userdata;
+ pa_stream *s;
assert(p && chunk && c && chunk->memblock && chunk->memblock->data);
pa_context_ref(c);
pa_mcalign_push(s->mcalign, chunk);
for (;;) {
- struct pa_memchunk t;
+ pa_memchunk t;
if (pa_mcalign_pop(s->mcalign, &t) < 0)
break;
pa_context_unref(c);
}
-int pa_context_handle_error(struct pa_context *c, uint32_t command, struct pa_tagstruct *t) {
+int pa_context_handle_error(pa_context *c, uint32_t command, pa_tagstruct *t) {
assert(c);
if (command == PA_COMMAND_ERROR) {
return 0;
}
-static void setup_complete_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_context *c = userdata;
+static void setup_complete_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_context *c = userdata;
assert(pd && c && (c->state == PA_CONTEXT_AUTHORIZING || c->state == PA_CONTEXT_SETTING_NAME));
pa_context_ref(c);
switch(c->state) {
case PA_CONTEXT_AUTHORIZING: {
- struct pa_tagstruct *t;
- t = pa_tagstruct_new(NULL, 0);
- assert(t);
- pa_tagstruct_putu32(t, PA_COMMAND_SET_CLIENT_NAME);
- pa_tagstruct_putu32(t, tag = c->ctag++);
- pa_tagstruct_puts(t, c->name);
- pa_pstream_send_tagstruct(c->pstream, t);
+ pa_tagstruct *reply;
+ reply = pa_tagstruct_new(NULL, 0);
+ pa_tagstruct_putu32(reply, PA_COMMAND_SET_CLIENT_NAME);
+ pa_tagstruct_putu32(reply, tag = c->ctag++);
+ pa_tagstruct_puts(reply, c->name);
+ pa_pstream_send_tagstruct(c->pstream, reply);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, setup_complete_callback, c);
pa_context_set_state(c, PA_CONTEXT_SETTING_NAME);
pa_context_unref(c);
}
-static void setup_context(struct pa_context *c, struct pa_iochannel *io) {
- struct pa_tagstruct *t;
+static void setup_context(pa_context *c, pa_iochannel *io) {
+ pa_tagstruct *t;
uint32_t tag;
assert(c && io);
pa_context_unref(c);
}
-static void on_connection(struct pa_socket_client *client, struct pa_iochannel*io, void *userdata);
+static void on_connection(pa_socket_client *client, pa_iochannel*io, void *userdata);
#ifndef OS_IS_WIN32
-static int context_connect_spawn(struct pa_context *c) {
+static int context_connect_spawn(pa_context *c) {
pid_t pid;
int status, r;
int fds[2] = { -1, -1} ;
- struct pa_iochannel *io;
+ pa_iochannel *io;
pa_context_ref(c);
char t[128];
const char *state = NULL;
#define MAX_ARGS 64
- char *argv[MAX_ARGS+1];
+ const char * argv[MAX_ARGS+1];
int n;
/* Not required, since fds[0] has CLOEXEC enabled anyway */
argv[n++] = NULL;
- execv(argv[0], argv);
+ execv(argv[0], (char * const *) argv);
_exit(1);
#undef MAX_ARGS
}
#endif /* OS_IS_WIN32 */
-static int try_next_connection(struct pa_context *c) {
+static int try_next_connection(pa_context *c) {
char *u = NULL;
int r = -1;
assert(c && !c->client);
return r;
}
-static void on_connection(struct pa_socket_client *client, struct pa_iochannel*io, void *userdata) {
- struct pa_context *c = userdata;
+static void on_connection(pa_socket_client *client, pa_iochannel*io, void *userdata) {
+ pa_context *c = userdata;
assert(client && c && c->state == PA_CONTEXT_CONNECTING);
pa_context_ref(c);
pa_context_unref(c);
}
-int pa_context_connect(struct pa_context *c, const char *server, int spawn, const struct pa_spawn_api *api) {
+int pa_context_connect(pa_context *c, const char *server, int spawn, const pa_spawn_api *api) {
int r = -1;
assert(c && c->ref >= 1 && c->state == PA_CONTEXT_UNCONNECTED);
return r;
}
-void pa_context_disconnect(struct pa_context *c) {
+void pa_context_disconnect(pa_context *c) {
assert(c);
pa_context_set_state(c, PA_CONTEXT_TERMINATED);
}
-enum pa_context_state pa_context_get_state(struct pa_context *c) {
+pa_context_state pa_context_get_state(pa_context *c) {
assert(c && c->ref >= 1);
return c->state;
}
-int pa_context_errno(struct pa_context *c) {
+int pa_context_errno(pa_context *c) {
assert(c && c->ref >= 1);
return c->error;
}
-void pa_context_set_state_callback(struct pa_context *c, void (*cb)(struct pa_context *c, void *userdata), void *userdata) {
+void pa_context_set_state_callback(pa_context *c, void (*cb)(pa_context *c, void *userdata), void *userdata) {
assert(c && c->ref >= 1);
c->state_callback = cb;
c->state_userdata = userdata;
}
-int pa_context_is_pending(struct pa_context *c) {
+int pa_context_is_pending(pa_context *c) {
assert(c && c->ref >= 1);
/* pa_log("pstream: %i\n", pa_pstream_is_pending(c->pstream)); */
c->client;
}
-static void set_dispatch_callbacks(struct pa_operation *o);
+static void set_dispatch_callbacks(pa_operation *o);
-static void pdispatch_drain_callback(struct pa_pdispatch*pd, void *userdata) {
+static void pdispatch_drain_callback(PA_GCC_UNUSED pa_pdispatch*pd, void *userdata) {
set_dispatch_callbacks(userdata);
}
-static void pstream_drain_callback(struct pa_pstream *s, void *userdata) {
+static void pstream_drain_callback(PA_GCC_UNUSED pa_pstream *s, void *userdata) {
set_dispatch_callbacks(userdata);
}
-static void set_dispatch_callbacks(struct pa_operation *o) {
+static void set_dispatch_callbacks(pa_operation *o) {
int done = 1;
assert(o && o->context && o->context->ref >= 1 && o->ref >= 1 && o->context->state == PA_CONTEXT_READY);
pa_operation_ref(o);
else {
if (o->callback) {
- void (*cb)(struct pa_context *c, void *userdata);
- cb = (void (*)(struct pa_context*, void*)) o->callback;
+ void (*cb)(pa_context *c, void *userdata);
+ cb = (void (*)(pa_context*, void*)) o->callback;
cb(o->context, o->userdata);
}
pa_operation_unref(o);
}
-struct pa_operation* pa_context_drain(struct pa_context *c, void (*cb) (struct pa_context*c, void *userdata), void *userdata) {
- struct pa_operation *o;
+pa_operation* pa_context_drain(pa_context *c, void (*cb) (pa_context*c, void *userdata), void *userdata) {
+ pa_operation *o;
assert(c && c->ref >= 1);
if (c->state != PA_CONTEXT_READY)
o = pa_operation_new(c, NULL);
assert(o);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
set_dispatch_callbacks(pa_operation_ref(o));
return o;
}
-void pa_context_exit_daemon(struct pa_context *c) {
- struct pa_tagstruct *t;
+void pa_context_exit_daemon(pa_context *c) {
+ pa_tagstruct *t;
assert(c && c->ref >= 1);
t = pa_tagstruct_new(NULL, 0);
pa_pstream_send_tagstruct(c->pstream, t);
}
-void pa_context_simple_ack_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_operation *o = userdata;
+void pa_context_simple_ack_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_operation *o = userdata;
int success = 1;
assert(pd && o && o->context && o->ref >= 1);
}
if (o->callback) {
- void (*cb)(struct pa_context *c, int success, void *userdata) = o->callback;
+ void (*cb)(pa_context *c, int _success, void *_userdata) = (void (*)(pa_context *c, int _success, void *_userdata)) o->callback;
cb(o->context, success, o->userdata);
}
pa_operation_unref(o);
}
-struct pa_operation* pa_context_send_simple_command(struct pa_context *c, uint32_t command, void (*internal_callback)(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata), void (*cb)(), void *userdata) {
- struct pa_tagstruct *t;
- struct pa_operation *o;
+pa_operation* pa_context_send_simple_command(pa_context *c, uint32_t command, void (*internal_callback)(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata), void (*cb)(void), void *userdata) {
+ pa_tagstruct *t;
+ pa_operation *o;
uint32_t tag;
assert(c && cb);
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_set_default_sink(struct pa_context *c, const char *name, void(*cb)(struct pa_context*c, int success, void *userdata), void *userdata) {
- struct pa_tagstruct *t;
- struct pa_operation *o;
+pa_operation* pa_context_set_default_sink(pa_context *c, const char *name, void(*cb)(pa_context*c, int success, void *userdata), void *userdata) {
+ pa_tagstruct *t;
+ pa_operation *o;
uint32_t tag;
assert(c && cb);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_set_default_source(struct pa_context *c, const char *name, void(*cb)(struct pa_context*c, int success, void *userdata), void *userdata) {
- struct pa_tagstruct *t;
- struct pa_operation *o;
+pa_operation* pa_context_set_default_source(pa_context *c, const char *name, void(*cb)(pa_context*c, int success, void *userdata), void *userdata) {
+ pa_tagstruct *t;
+ pa_operation *o;
uint32_t tag;
assert(c && cb);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
return pa_operation_ref(o);
}
-int pa_context_is_local(struct pa_context *c) {
+int pa_context_is_local(pa_context *c) {
assert(c);
return c->local;
}
-struct pa_operation* pa_context_set_name(struct pa_context *c, const char *name, void(*cb)(struct pa_context*c, int success, void *userdata), void *userdata) {
- struct pa_tagstruct *t;
- struct pa_operation *o;
+pa_operation* pa_context_set_name(pa_context *c, const char *name, void(*cb)(pa_context*c, int success, void *userdata), void *userdata) {
+ pa_tagstruct *t;
+ pa_operation *o;
uint32_t tag;
assert(c && name && cb);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
return PACKAGE_VERSION;
}
-const char* pa_context_get_server(struct pa_context *c) {
+const char* pa_context_get_server(pa_context *c) {
if (!c->server)
return NULL;
PA_C_DECL_BEGIN
-/** \struct pa_context
+/** \pa_context
* An opaque connection context to a daemon */
-struct pa_context;
+typedef struct pa_context pa_context;
/** Instantiate a new connection context with an abstract mainloop API
* and an application name */
-struct pa_context *pa_context_new(struct pa_mainloop_api *mainloop, const char *name);
+pa_context *pa_context_new(pa_mainloop_api *mainloop, const char *name);
/** Decrease the reference counter of the context by one */
-void pa_context_unref(struct pa_context *c);
+void pa_context_unref(pa_context *c);
/** Increase the reference counter of the context by one */
-struct pa_context* pa_context_ref(struct pa_context *c);
+pa_context* pa_context_ref(pa_context *c);
+
+typedef void (*pa_context_state_callback)(pa_context *c, void *userdata);
/** Set a callback function that is called whenever the context status changes */
-void pa_context_set_state_callback(struct pa_context *c, void (*cb)(struct pa_context *c, void *userdata), void *userdata);
+void pa_context_set_state_callback(pa_context *c, pa_context_state_callback callback, void *userdata);
/** Return the error number of the last failed operation */
-int pa_context_errno(struct pa_context *c);
+int pa_context_errno(pa_context *c);
/** Return non-zero if some data is pending to be written to the connection */
-int pa_context_is_pending(struct pa_context *c);
+int pa_context_is_pending(pa_context *c);
/** Return the current context status */
-enum pa_context_state pa_context_get_state(struct pa_context *c);
+pa_context_state pa_context_get_state(pa_context *c);
/** Connect the context to the specified server. If server is NULL,
connect to the default server. This routine may but will not always
and no specific server is specified or accessible a new daemon is
spawned. If api is non-NULL, the functions specified in the structure
are used when forking a new child process. */
-int pa_context_connect(struct pa_context *c, const char *server, int spawn, const struct pa_spawn_api *api);
+int pa_context_connect(pa_context *c, const char *server, int spawn, const pa_spawn_api *api);
/** Terminate the context connection immediately */
-void pa_context_disconnect(struct pa_context *c);
+void pa_context_disconnect(pa_context *c);
/** Drain the context. If there is nothing to drain, the function returns NULL */
-struct pa_operation* pa_context_drain(struct pa_context *c, void (*cb) (struct pa_context*c, void *userdata), void *userdata);
+pa_operation* pa_context_drain(pa_context *c, void (*cb) (pa_context*c, void *userdata), void *userdata);
/** Tell the daemon to exit. No operation object is returned as the
* connection is terminated when the daemon quits, thus this operation
* would never complete. */
-void pa_context_exit_daemon(struct pa_context *c);
+void pa_context_exit_daemon(pa_context *c);
/** Set the name of the default sink. \since 0.4 */
-struct pa_operation* pa_context_set_default_sink(struct pa_context *c, const char *name, void(*cb)(struct pa_context*c, int success, void *userdata), void *userdata);
+pa_operation* pa_context_set_default_sink(pa_context *c, const char *name, void(*cb)(pa_context*c, int success, void *userdata), void *userdata);
/** Set the name of the default source. \since 0.4 */
-struct pa_operation* pa_context_set_default_source(struct pa_context *c, const char *name, void(*cb)(struct pa_context*c, int success, void *userdata), void *userdata);
+pa_operation* pa_context_set_default_source(pa_context *c, const char *name, void(*cb)(pa_context*c, int success, void *userdata), void *userdata);
/** Returns 1 when the connection is to a local daemon. Returns negative when no connection has been made yet. \since 0.5 */
-int pa_context_is_local(struct pa_context *c);
+int pa_context_is_local(pa_context *c);
/** Set a different application name for context on the server. \since 0.5 */
-struct pa_operation* pa_context_set_name(struct pa_context *c, const char *name, void(*cb)(struct pa_context*c, int success, void *userdata), void *userdata);
+pa_operation* pa_context_set_name(pa_context *c, const char *name, void(*cb)(pa_context*c, int success, void *userdata), void *userdata);
/** Return the server name this context is connected to. \since 0.7 */
-const char* pa_context_get_server(struct pa_context *c);
+const char* pa_context_get_server(pa_context *c);
PA_C_DECL_END
PA_C_DECL_BEGIN
/** The state of a connection context */
-enum pa_context_state {
+typedef enum pa_context_state {
PA_CONTEXT_UNCONNECTED, /**< The context hasn't been connected yet */
PA_CONTEXT_CONNECTING, /**< A connection is being established */
PA_CONTEXT_AUTHORIZING, /**< The client is authorizing itself to the daemon */
PA_CONTEXT_READY, /**< The connection is established, the context is ready to execute operations */
PA_CONTEXT_FAILED, /**< The connection failed or was disconnected */
PA_CONTEXT_TERMINATED /**< The connection was terminated cleanly */
-};
+} pa_context_state;
/** The state of a stream */
-enum pa_stream_state {
+typedef enum pa_stream_state {
PA_STREAM_DISCONNECTED, /**< The stream is not yet connected to any sink or source */
PA_STREAM_CREATING, /**< The stream is being created */
PA_STREAM_READY, /**< The stream is established, you may pass audio data to it now */
PA_STREAM_FAILED, /**< An error occured that made the stream invalid */
PA_STREAM_TERMINATED /**< The stream has been terminated cleanly */
-};
+} pa_stream_state;
/** The state of an operation */
-enum pa_operation_state {
+typedef enum pa_operation_state {
PA_OPERATION_RUNNING, /**< The operation is still running */
PA_OPERATION_DONE, /**< The operation has been completed */
PA_OPERATION_CANCELED /**< The operation has been canceled */
-};
+} pa_operation_state;
/** An invalid index */
#define PA_INVALID_INDEX ((uint32_t) -1)
/** The direction of a pa_stream object */
-enum pa_stream_direction {
+typedef enum pa_stream_direction {
PA_STREAM_NODIRECTION, /**< Invalid direction */
PA_STREAM_PLAYBACK, /**< Playback stream */
PA_STREAM_RECORD, /**< Record stream */
PA_STREAM_UPLOAD /**< Sample upload stream */
-};
+} pa_stream_direction;
/** Some special flags for stream connections. \since 0.6 */
-enum pa_stream_flags {
+typedef enum pa_stream_flags {
PA_STREAM_START_CORKED = 1, /**< Create the stream corked, requiring an explicit pa_stream_cork() call to uncork it. */
PA_STREAM_INTERPOLATE_LATENCY = 2 /**< Interpolate the latency for
* this stream. When enabled,
* information. This is
* especially useful on long latency
* network connections. */
-};
+} pa_stream_flags;
/** Playback and record buffer metrics */
-struct pa_buffer_attr{
+typedef struct pa_buffer_attr {
uint32_t maxlength; /**< Maximum length of the buffer */
uint32_t tlength; /**< Playback only: target length of the buffer. The server tries to assure that at least tlength bytes are always available in the buffer */
uint32_t prebuf; /**< Playback only: pre-buffering. The server does not start with playback before at least prebug bytes are available in the buffer */
uint32_t minreq; /**< Playback only: minimum request. The server does not request less than minreq bytes from the client, instead waints until the buffer is free enough to request more bytes at once */
uint32_t fragsize; /**< Recording only: fragment size. The server sends data in blocks of fragsize bytes size. Large values deminish interactivity with other operations on the connection context but decrease control overhead. */
-};
+} pa_buffer_attr;
/** Error values as used by pa_context_errno(). Use pa_strerror() to convert these values to human readable strings */
enum {
};
/** Subscription event mask, as used by pa_context_subscribe() */
-enum pa_subscription_mask {
+typedef enum pa_subscription_mask {
PA_SUBSCRIPTION_MASK_NULL = 0, /**< No events */
PA_SUBSCRIPTION_MASK_SINK = 1, /**< Sink events */
PA_SUBSCRIPTION_MASK_SOURCE = 2, /**< Source events */
PA_SUBSCRIPTION_MASK_SAMPLE_CACHE = 64, /**< Sample cache events */
PA_SUBSCRIPTION_MASK_SERVER = 128, /**< Other global server changes. \since 0.4 */
PA_SUBSCRIPTION_MASK_AUTOLOAD = 256 /**< Autoload table events. \since 0.5 */
-};
+} pa_subscription_mask;
/** Subscription event types, as used by pa_context_subscribe() */
-enum pa_subscription_event_type {
+typedef enum pa_subscription_event_type {
PA_SUBSCRIPTION_EVENT_SINK = 0, /**< Event type: Sink */
PA_SUBSCRIPTION_EVENT_SOURCE = 1, /**< Event type: Source */
PA_SUBSCRIPTION_EVENT_SINK_INPUT = 2, /**< Event type: Sink input */
PA_SUBSCRIPTION_EVENT_CHANGE = 16, /**< A property of the object was modified */
PA_SUBSCRIPTION_EVENT_REMOVE = 32, /**< An object was removed */
PA_SUBSCRIPTION_EVENT_TYPE_MASK = 16+32 /**< A mask to extract the event operation from an event value */
-};
+} pa_subscription_event_type;
/** Return one if an event type t matches an event mask bitfield */
#define pa_subscription_match_flags(m, t) (!!((m) & (1 << ((t) & PA_SUBSCRIPTION_EVENT_FACILITY_MASK))))
* source_usec+buffer_usec+transport_usec-sink_usec. (Take care of
* sign issues!) When connected to a monitor source sink_usec contains
* the latency of the owning sink.*/
-struct pa_latency_info {
+typedef struct pa_latency_info {
pa_usec_t buffer_usec; /**< Time in usecs the current buffer takes to play. For both playback and record streams. */
pa_usec_t sink_usec; /**< Time in usecs a sample takes to be played on the sink. For playback streams and record streams connected to a monitor source. */
pa_usec_t source_usec; /**< Time in usecs a sample takes from being recorded to being delivered to the application. Only for record streams. \since 0.5*/
* 0.5 */
struct timeval timestamp; /**< The time when this latency info was current */
uint64_t counter; /**< The byte counter current when the latency info was requested. \since 0.6 */
-};
+} pa_latency_info;
/** A structure for the spawn api. This may be used to integrate auto
* spawned daemons into your application. For more information see
* block or ignore SIGCHLD signals, since this cannot be done in a
* thread compatible way. You might have to do this in
* prefork/postfork. \since 0.4 */
-struct pa_spawn_api {
+typedef struct pa_spawn_api {
void (*prefork)(void); /**< Is called just before the fork in the parent process. May be NULL. */
void (*postfork)(void); /**< Is called immediately after the fork in the parent process. May be NULL.*/
void (*atfork)(void); /**< Is called immediately after the
* unconditionally, since a UNIX socket
* (created using socketpair()) is
* passed to the new process. */
-};
+} pa_spawn_api;
PA_C_DECL_END
int ref;
char *name;
- struct pa_mainloop_api* mainloop;
+ pa_mainloop_api* mainloop;
- struct pa_socket_client *client;
- struct pa_pstream *pstream;
- struct pa_pdispatch *pdispatch;
+ pa_socket_client *client;
+ pa_pstream *pstream;
+ pa_pdispatch *pdispatch;
- struct pa_dynarray *record_streams, *playback_streams;
- PA_LLIST_HEAD(struct pa_stream, streams);
- PA_LLIST_HEAD(struct pa_operation, operations);
+ pa_dynarray *record_streams, *playback_streams;
+ PA_LLIST_HEAD(pa_stream, streams);
+ PA_LLIST_HEAD(pa_operation, operations);
uint32_t ctag;
uint32_t error;
- enum pa_context_state state;
+ pa_context_state state;
- void (*state_callback)(struct pa_context*c, void *userdata);
+ void (*state_callback)(pa_context*c, void *userdata);
void *state_userdata;
- void (*subscribe_callback)(struct pa_context *c, enum pa_subscription_event_type t, uint32_t index, void *userdata);
+ void (*subscribe_callback)(pa_context *c, pa_subscription_event_type t, uint32_t idx, void *userdata);
void *subscribe_userdata;
- struct pa_memblock_stat *memblock_stat;
+ pa_memblock_stat *memblock_stat;
int local;
int do_autospawn;
int autospawn_lock_fd;
- struct pa_spawn_api spawn_api;
+ pa_spawn_api spawn_api;
- struct pa_strlist *server_list;
+ pa_strlist *server_list;
char *server;
- struct pa_client_conf *conf;
+ pa_client_conf *conf;
};
struct pa_stream {
int ref;
- struct pa_context *context;
- struct pa_mainloop_api *mainloop;
- PA_LLIST_FIELDS(struct pa_stream);
+ pa_context *context;
+ pa_mainloop_api *mainloop;
+ PA_LLIST_FIELDS(pa_stream);
char *name;
- struct pa_buffer_attr buffer_attr;
- struct pa_sample_spec sample_spec;
+ pa_buffer_attr buffer_attr;
+ pa_sample_spec sample_spec;
uint32_t channel;
int channel_valid;
uint32_t device_index;
- enum pa_stream_direction direction;
+ pa_stream_direction direction;
uint32_t requested_bytes;
uint64_t counter;
pa_usec_t previous_time;
pa_usec_t previous_ipol_time;
- enum pa_stream_state state;
- struct pa_mcalign *mcalign;
+ pa_stream_state state;
+ pa_mcalign *mcalign;
int interpolate;
int corked;
uint32_t ipol_usec;
struct timeval ipol_timestamp;
- struct pa_time_event *ipol_event;
+ pa_time_event *ipol_event;
int ipol_requested;
- void (*state_callback)(struct pa_stream*c, void *userdata);
+ void (*state_callback)(pa_stream*c, void *userdata);
void *state_userdata;
- void (*read_callback)(struct pa_stream *p, const void*data, size_t length, void *userdata);
+ void (*read_callback)(pa_stream *p, const void*data, size_t length, void *userdata);
void *read_userdata;
- void (*write_callback)(struct pa_stream *p, size_t length, void *userdata);
+ void (*write_callback)(pa_stream *p, size_t length, void *userdata);
void *write_userdata;
};
+typedef void (*pa_operation_callback)(void);
+
struct pa_operation {
int ref;
- struct pa_context *context;
- struct pa_stream *stream;
- PA_LLIST_FIELDS(struct pa_operation);
+ pa_context *context;
+ pa_stream *stream;
+ PA_LLIST_FIELDS(pa_operation);
- enum pa_operation_state state;
+ pa_operation_state state;
void *userdata;
- void (*callback)();
+ pa_operation_callback callback;
};
-void pa_command_request(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-void pa_command_stream_killed(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-void pa_command_subscribe_event(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
+void pa_command_request(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+void pa_command_stream_killed(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+void pa_command_subscribe_event(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
-struct pa_operation *pa_operation_new(struct pa_context *c, struct pa_stream *s);
-void pa_operation_done(struct pa_operation *o);
+pa_operation *pa_operation_new(pa_context *c, pa_stream *s);
+void pa_operation_done(pa_operation *o);
-void pa_create_stream_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-void pa_stream_disconnect_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-void pa_context_simple_ack_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-void pa_stream_simple_ack_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
+void pa_create_stream_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+void pa_stream_disconnect_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+void pa_context_simple_ack_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+void pa_stream_simple_ack_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
-void pa_context_fail(struct pa_context *c, int error);
-void pa_context_set_state(struct pa_context *c, enum pa_context_state st);
-int pa_context_handle_error(struct pa_context *c, uint32_t command, struct pa_tagstruct *t);
-struct pa_operation* pa_context_send_simple_command(struct pa_context *c, uint32_t command, void (*internal_callback)(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata), void (*cb)(), void *userdata);
+void pa_context_fail(pa_context *c, int error);
+void pa_context_set_state(pa_context *c, pa_context_state st);
+int pa_context_handle_error(pa_context *c, uint32_t command, pa_tagstruct *t);
+pa_operation* pa_context_send_simple_command(pa_context *c, uint32_t command, void (*internal_callback)(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata), void (*cb)(void), void *userdata);
-void pa_stream_set_state(struct pa_stream *s, enum pa_stream_state st);
+void pa_stream_set_state(pa_stream *s, pa_stream_state st);
-void pa_stream_trash_ipol(struct pa_stream *s);
+void pa_stream_trash_ipol(pa_stream *s);
#endif
#include "polyplib-context.h"
#include "polyplib-internal.h"
#include "pstream-util.h"
+#include "gccmacro.h"
/*** Statistics ***/
-static void context_stat_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_operation *o = userdata;
- struct pa_stat_info i, *p = &i;
+static void context_stat_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_operation *o = userdata;
+ pa_stat_info i, *p = &i;
assert(pd && o && o->context && o->ref >= 1);
if (command != PA_COMMAND_REPLY) {
}
if (o->callback) {
- void (*cb)(struct pa_context *s, const struct pa_stat_info*i, void *userdata) = o->callback;
+ void (*cb)(pa_context *s, const pa_stat_info*_i, void *_userdata) = (void (*)(pa_context *s, const pa_stat_info*_i, void *_userdata)) o->callback;
cb(o->context, p, o->userdata);
}
pa_operation_unref(o);
}
-struct pa_operation* pa_context_stat(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_stat_info*i, void *userdata), void *userdata) {
- return pa_context_send_simple_command(c, PA_COMMAND_STAT, context_stat_callback, cb, userdata);
+pa_operation* pa_context_stat(pa_context *c, void (*cb)(pa_context *c, const pa_stat_info*i, void *userdata), void *userdata) {
+ return pa_context_send_simple_command(c, PA_COMMAND_STAT, context_stat_callback, (pa_operation_callback) cb, userdata);
}
/*** Server Info ***/
-static void context_get_server_info_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_operation *o = userdata;
- struct pa_server_info i, *p = &i;
+static void context_get_server_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_operation *o = userdata;
+ pa_server_info i, *p = &i;
assert(pd && o && o->context && o->ref >= 1);
if (command != PA_COMMAND_REPLY) {
}
if (o->callback) {
- void (*cb)(struct pa_context *s, const struct pa_server_info*i, void *userdata) = o->callback;
+ void (*cb)(pa_context *s, const pa_server_info*_i, void *_userdata) = (void (*)(pa_context *s, const pa_server_info*_i, void *_userdata)) o->callback;
cb(o->context, p, o->userdata);
}
pa_operation_unref(o);
}
-struct pa_operation* pa_context_get_server_info(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_server_info*i, void *userdata), void *userdata) {
- return pa_context_send_simple_command(c, PA_COMMAND_GET_SERVER_INFO, context_get_server_info_callback, cb, userdata);
+pa_operation* pa_context_get_server_info(pa_context *c, void (*cb)(pa_context *c, const pa_server_info*i, void *userdata), void *userdata) {
+ return pa_context_send_simple_command(c, PA_COMMAND_GET_SERVER_INFO, context_get_server_info_callback, (pa_operation_callback) cb, userdata);
}
/*** Sink Info ***/
-static void context_get_sink_info_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_operation *o = userdata;
+static void context_get_sink_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_operation *o = userdata;
int eof = 1;
assert(pd && o && o->context && o->ref >= 1);
} else {
while (!pa_tagstruct_eof(t)) {
- struct pa_sink_info i;
+ pa_sink_info i;
if (pa_tagstruct_getu32(t, &i.index) < 0 ||
pa_tagstruct_gets(t, &i.name) < 0 ||
}
if (o->callback) {
- void (*cb)(struct pa_context *s, const struct pa_sink_info*i, int eof, void *userdata) = o->callback;
+ void (*cb)(pa_context *s, const pa_sink_info*_i, int _eof, void *_userdata) = (void (*)(pa_context *s, const pa_sink_info*_i, int _eof, void *_userdata)) o->callback;
cb(o->context, &i, 0, o->userdata);
}
}
}
if (o->callback) {
- void (*cb)(struct pa_context *s, const struct pa_sink_info*i, int eof, void *userdata) = o->callback;
+ void (*cb)(pa_context *s, const pa_sink_info*_i, int _eof, void *_userdata) = (void (*)(pa_context *s, const pa_sink_info*_i, int _eof, void *_userdata)) o->callback;
cb(o->context, NULL, eof, o->userdata);
}
pa_operation_unref(o);
}
-struct pa_operation* pa_context_get_sink_info_list(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_sink_info *i, int is_last, void *userdata), void *userdata) {
- return pa_context_send_simple_command(c, PA_COMMAND_GET_SINK_INFO_LIST, context_get_sink_info_callback, cb, userdata);
+pa_operation* pa_context_get_sink_info_list(pa_context *c, void (*cb)(pa_context *c, const pa_sink_info *i, int is_last, void *userdata), void *userdata) {
+ return pa_context_send_simple_command(c, PA_COMMAND_GET_SINK_INFO_LIST, context_get_sink_info_callback, (pa_operation_callback) cb, userdata);
}
-struct pa_operation* pa_context_get_sink_info_by_index(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, const struct pa_sink_info *i, int is_last, void *userdata), void *userdata) {
- struct pa_tagstruct *t;
- struct pa_operation *o;
+pa_operation* pa_context_get_sink_info_by_index(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, const pa_sink_info *i, int is_last, void *userdata), void *userdata) {
+ pa_tagstruct *t;
+ pa_operation *o;
uint32_t tag;
assert(c && cb);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
pa_tagstruct_putu32(t, PA_COMMAND_GET_SINK_INFO);
pa_tagstruct_putu32(t, tag = c->ctag++);
- pa_tagstruct_putu32(t, index);
+ pa_tagstruct_putu32(t, idx);
pa_tagstruct_puts(t, NULL);
pa_pstream_send_tagstruct(c->pstream, t);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_sink_info_callback, o);
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_get_sink_info_by_name(struct pa_context *c, const char *name, void (*cb)(struct pa_context *c, const struct pa_sink_info *i, int is_last, void *userdata), void *userdata) {
- struct pa_tagstruct *t;
- struct pa_operation *o;
+pa_operation* pa_context_get_sink_info_by_name(pa_context *c, const char *name, void (*cb)(pa_context *c, const pa_sink_info *i, int is_last, void *userdata), void *userdata) {
+ pa_tagstruct *t;
+ pa_operation *o;
uint32_t tag;
assert(c && cb);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
/*** Source info ***/
-static void context_get_source_info_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_operation *o = userdata;
+static void context_get_source_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_operation *o = userdata;
int eof = 1;
assert(pd && o && o->context && o->ref >= 1);
} else {
while (!pa_tagstruct_eof(t)) {
- struct pa_source_info i;
+ pa_source_info i;
if (pa_tagstruct_getu32(t, &i.index) < 0 ||
pa_tagstruct_gets(t, &i.name) < 0 ||
}
if (o->callback) {
- void (*cb)(struct pa_context *s, const struct pa_source_info*i, int eof, void *userdata) = o->callback;
+ void (*cb)(pa_context *s, const pa_source_info*_i, int _eof, void *_userdata) = (void (*)(pa_context *s, const pa_source_info*_i, int _eof, void *_userdata)) o->callback;
cb(o->context, &i, 0, o->userdata);
}
}
}
if (o->callback) {
- void (*cb)(struct pa_context *s, const struct pa_source_info*i, int eof, void *userdata) = o->callback;
+ void (*cb)(pa_context *s, const pa_source_info*_i, int _eof, void *_userdata) = (void (*)(pa_context *s, const pa_source_info*_i, int _eof, void *_userdata)) o->callback;
cb(o->context, NULL, eof, o->userdata);
}
pa_operation_unref(o);
}
-struct pa_operation* pa_context_get_source_info_list(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_source_info *i, int is_last, void *userdata), void *userdata) {
- return pa_context_send_simple_command(c, PA_COMMAND_GET_SOURCE_INFO_LIST, context_get_source_info_callback, cb, userdata);
+pa_operation* pa_context_get_source_info_list(pa_context *c, void (*cb)(pa_context *c, const pa_source_info *i, int is_last, void *userdata), void *userdata) {
+ return pa_context_send_simple_command(c, PA_COMMAND_GET_SOURCE_INFO_LIST, context_get_source_info_callback, (pa_operation_callback) cb, userdata);
}
-struct pa_operation* pa_context_get_source_info_by_index(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, const struct pa_source_info *i, int is_last, void *userdata), void *userdata) {
- struct pa_tagstruct *t;
- struct pa_operation *o;
+pa_operation* pa_context_get_source_info_by_index(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, const pa_source_info *i, int is_last, void *userdata), void *userdata) {
+ pa_tagstruct *t;
+ pa_operation *o;
uint32_t tag;
assert(c && cb);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
pa_tagstruct_putu32(t, PA_COMMAND_GET_SOURCE_INFO);
pa_tagstruct_putu32(t, tag = c->ctag++);
- pa_tagstruct_putu32(t, index);
+ pa_tagstruct_putu32(t, idx);
pa_tagstruct_puts(t, NULL);
pa_pstream_send_tagstruct(c->pstream, t);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_source_info_callback, o);
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_get_source_info_by_name(struct pa_context *c, const char *name, void (*cb)(struct pa_context *c, const struct pa_source_info *i, int is_last, void *userdata), void *userdata) {
- struct pa_tagstruct *t;
- struct pa_operation *o;
+pa_operation* pa_context_get_source_info_by_name(pa_context *c, const char *name, void (*cb)(pa_context *c, const pa_source_info *i, int is_last, void *userdata), void *userdata) {
+ pa_tagstruct *t;
+ pa_operation *o;
uint32_t tag;
assert(c && cb);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
/*** Client info ***/
-static void context_get_client_info_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_operation *o = userdata;
+static void context_get_client_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_operation *o = userdata;
int eof = 1;
assert(pd && o && o->context && o->ref >= 1);
} else {
while (!pa_tagstruct_eof(t)) {
- struct pa_client_info i;
+ pa_client_info i;
if (pa_tagstruct_getu32(t, &i.index) < 0 ||
pa_tagstruct_gets(t, &i.name) < 0 ||
}
if (o->callback) {
- void (*cb)(struct pa_context *s, const struct pa_client_info*i, int eof, void *userdata) = o->callback;
+ void (*cb)(pa_context *s, const pa_client_info*_i, int _eof, void *_userdata) = (void (*)(pa_context *s, const pa_client_info*_i, int _eof, void *_userdata)) o->callback;
cb(o->context, &i, 0, o->userdata);
}
}
}
if (o->callback) {
- void (*cb)(struct pa_context *s, const struct pa_client_info*i, int eof, void *userdata) = o->callback;
+ void (*cb)(pa_context *s, const pa_client_info*_i, int _eof, void *_userdata) = (void (*)(pa_context *s, const pa_client_info*_i, int _eof, void *_userdata)) o->callback;
cb(o->context, NULL, eof, o->userdata);
}
pa_operation_unref(o);
}
-struct pa_operation* pa_context_get_client_info(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, const struct pa_client_info*i, int is_last, void *userdata), void *userdata) {
- struct pa_tagstruct *t;
- struct pa_operation *o;
+pa_operation* pa_context_get_client_info(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, const pa_client_info*i, int is_last, void *userdata), void *userdata) {
+ pa_tagstruct *t;
+ pa_operation *o;
uint32_t tag;
assert(c && cb);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
pa_tagstruct_putu32(t, PA_COMMAND_GET_CLIENT_INFO);
pa_tagstruct_putu32(t, tag = c->ctag++);
- pa_tagstruct_putu32(t, index);
+ pa_tagstruct_putu32(t, idx);
pa_pstream_send_tagstruct(c->pstream, t);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_client_info_callback, o);
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_get_client_info_list(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_client_info*i, int is_last, void *userdata), void *userdata) {
- return pa_context_send_simple_command(c, PA_COMMAND_GET_CLIENT_INFO_LIST, context_get_client_info_callback, cb, userdata);
+pa_operation* pa_context_get_client_info_list(pa_context *c, void (*cb)(pa_context *c, const pa_client_info*i, int is_last, void *userdata), void *userdata) {
+ return pa_context_send_simple_command(c, PA_COMMAND_GET_CLIENT_INFO_LIST, context_get_client_info_callback, (pa_operation_callback) cb, userdata);
}
/*** Module info ***/
-static void context_get_module_info_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_operation *o = userdata;
+static void context_get_module_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_operation *o = userdata;
int eof = 1;
assert(pd && o && o->context && o->ref >= 1);
} else {
while (!pa_tagstruct_eof(t)) {
- struct pa_module_info i;
+ pa_module_info i;
if (pa_tagstruct_getu32(t, &i.index) < 0 ||
pa_tagstruct_gets(t, &i.name) < 0 ||
}
if (o->callback) {
- void (*cb)(struct pa_context *s, const struct pa_module_info*i, int eof, void *userdata) = o->callback;
+ void (*cb)(pa_context *s, const pa_module_info*_i, int _eof, void *_userdata) = (void (*)(pa_context *s, const pa_module_info*_i, int _eof, void *_userdata)) o->callback;
cb(o->context, &i, 0, o->userdata);
}
}
}
if (o->callback) {
- void (*cb)(struct pa_context *s, const struct pa_module_info*i, int eof, void *userdata) = o->callback;
+ void (*cb)(pa_context *s, const pa_module_info*_i, int _eof, void *_userdata) = (void (*)(pa_context *s, const pa_module_info*_i, int _eof, void *_userdata)) o->callback;
cb(o->context, NULL, eof, o->userdata);
}
pa_operation_unref(o);
}
-struct pa_operation* pa_context_get_module_info(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, const struct pa_module_info*i, int is_last, void *userdata), void *userdata) {
- struct pa_tagstruct *t;
- struct pa_operation *o;
+pa_operation* pa_context_get_module_info(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, const pa_module_info*i, int is_last, void *userdata), void *userdata) {
+ pa_tagstruct *t;
+ pa_operation *o;
uint32_t tag;
assert(c && cb);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
pa_tagstruct_putu32(t, PA_COMMAND_GET_MODULE_INFO);
pa_tagstruct_putu32(t, tag = c->ctag++);
- pa_tagstruct_putu32(t, index);
+ pa_tagstruct_putu32(t, idx);
pa_pstream_send_tagstruct(c->pstream, t);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_module_info_callback, o);
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_get_module_info_list(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_module_info*i, int is_last, void *userdata), void *userdata) {
- return pa_context_send_simple_command(c, PA_COMMAND_GET_MODULE_INFO_LIST, context_get_module_info_callback, cb, userdata);
+pa_operation* pa_context_get_module_info_list(pa_context *c, void (*cb)(pa_context *c, const pa_module_info*i, int is_last, void *userdata), void *userdata) {
+ return pa_context_send_simple_command(c, PA_COMMAND_GET_MODULE_INFO_LIST, context_get_module_info_callback, (pa_operation_callback) cb, userdata);
}
/*** Sink input info ***/
-static void context_get_sink_input_info_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_operation *o = userdata;
+static void context_get_sink_input_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_operation *o = userdata;
int eof = 1;
assert(pd && o && o->context && o->ref >= 1);
} else {
while (!pa_tagstruct_eof(t)) {
- struct pa_sink_input_info i;
+ pa_sink_input_info i;
if (pa_tagstruct_getu32(t, &i.index) < 0 ||
pa_tagstruct_gets(t, &i.name) < 0 ||
}
if (o->callback) {
- void (*cb)(struct pa_context *s, const struct pa_sink_input_info*i, int eof, void *userdata) = o->callback;
+ void (*cb)(pa_context *s, const pa_sink_input_info*_i, int _eof, void *_userdata) = (void (*)(pa_context *s, const pa_sink_input_info*_i, int _eof, void *_userdata)) o->callback;
cb(o->context, &i, 0, o->userdata);
}
}
}
if (o->callback) {
- void (*cb)(struct pa_context *s, const struct pa_sink_input_info*i, int eof, void *userdata) = o->callback;
+ void (*cb)(pa_context *s, const pa_sink_input_info*_i, int _eof, void *_userdata) = (void (*)(pa_context *s, const pa_sink_input_info*_i, int _eof, void *_userdata)) o->callback;
cb(o->context, NULL, eof, o->userdata);
}
pa_operation_unref(o);
}
-struct pa_operation* pa_context_get_sink_input_info(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, const struct pa_sink_input_info*i, int is_last, void *userdata), void *userdata) {
- struct pa_tagstruct *t;
- struct pa_operation *o;
+pa_operation* pa_context_get_sink_input_info(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, const pa_sink_input_info*i, int is_last, void *userdata), void *userdata) {
+ pa_tagstruct *t;
+ pa_operation *o;
uint32_t tag;
assert(c && cb);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
pa_tagstruct_putu32(t, PA_COMMAND_GET_SINK_INPUT_INFO);
pa_tagstruct_putu32(t, tag = c->ctag++);
- pa_tagstruct_putu32(t, index);
+ pa_tagstruct_putu32(t, idx);
pa_pstream_send_tagstruct(c->pstream, t);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_sink_input_info_callback, o);
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_get_sink_input_info_list(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_sink_input_info*i, int is_last, void *userdata), void *userdata) {
- return pa_context_send_simple_command(c, PA_COMMAND_GET_SINK_INPUT_INFO_LIST, context_get_sink_input_info_callback, cb, userdata);
+pa_operation* pa_context_get_sink_input_info_list(pa_context *c, void (*cb)(pa_context *c, const pa_sink_input_info*i, int is_last, void *userdata), void *userdata) {
+ return pa_context_send_simple_command(c, PA_COMMAND_GET_SINK_INPUT_INFO_LIST, context_get_sink_input_info_callback, (pa_operation_callback) cb, userdata);
}
/*** Source output info ***/
-static void context_get_source_output_info_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_operation *o = userdata;
+static void context_get_source_output_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_operation *o = userdata;
int eof = 1;
assert(pd && o && o->context && o->ref >= 1);
} else {
while (!pa_tagstruct_eof(t)) {
- struct pa_source_output_info i;
+ pa_source_output_info i;
if (pa_tagstruct_getu32(t, &i.index) < 0 ||
pa_tagstruct_gets(t, &i.name) < 0 ||
}
if (o->callback) {
- void (*cb)(struct pa_context *s, const struct pa_source_output_info*i, int eof, void *userdata) = o->callback;
+ void (*cb)(pa_context *s, const pa_source_output_info*_i, int _eof, void *_userdata) = (void (*)(pa_context *s, const pa_source_output_info*_i, int _eof, void *_userdata)) o->callback;
cb(o->context, &i, 0, o->userdata);
}
}
}
if (o->callback) {
- void (*cb)(struct pa_context *s, const struct pa_source_output_info*i, int eof, void *userdata) = o->callback;
+ void (*cb)(pa_context *s, const pa_source_output_info*_i, int _eof, void *_userdata) = (void (*)(pa_context *s, const pa_source_output_info*_i, int _eof, void *_userdata))o->callback;
cb(o->context, NULL, eof, o->userdata);
}
pa_operation_unref(o);
}
-struct pa_operation* pa_context_get_source_output_info(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, const struct pa_source_output_info*i, int is_last, void *userdata), void *userdata) {
- struct pa_tagstruct *t;
- struct pa_operation *o;
+pa_operation* pa_context_get_source_output_info(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, const pa_source_output_info*i, int is_last, void *userdata), void *userdata) {
+ pa_tagstruct *t;
+ pa_operation *o;
uint32_t tag;
assert(c && cb);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
pa_tagstruct_putu32(t, PA_COMMAND_GET_SOURCE_OUTPUT_INFO);
pa_tagstruct_putu32(t, tag = c->ctag++);
- pa_tagstruct_putu32(t, index);
+ pa_tagstruct_putu32(t, idx);
pa_pstream_send_tagstruct(c->pstream, t);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_source_output_info_callback, o);
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_get_source_output_info_list(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_source_output_info*i, int is_last, void *userdata), void *userdata) {
- return pa_context_send_simple_command(c, PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST, context_get_source_output_info_callback, cb, userdata);
+pa_operation* pa_context_get_source_output_info_list(pa_context *c, void (*cb)(pa_context *c, const pa_source_output_info*i, int is_last, void *userdata), void *userdata) {
+ return pa_context_send_simple_command(c, PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST, context_get_source_output_info_callback, (pa_operation_callback) cb, userdata);
}
/*** Volume manipulation ***/
-struct pa_operation* pa_context_set_sink_volume_by_index(struct pa_context *c, uint32_t index, pa_volume_t volume, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata) {
- struct pa_operation *o;
- struct pa_tagstruct *t;
+pa_operation* pa_context_set_sink_volume_by_index(pa_context *c, uint32_t idx, pa_volume_t volume, void (*cb)(pa_context *c, int success, void *userdata), void *userdata) {
+ pa_operation *o;
+ pa_tagstruct *t;
uint32_t tag;
- assert(c && index != PA_INVALID_INDEX);
+ assert(c && idx != PA_INVALID_INDEX);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
pa_tagstruct_putu32(t, PA_COMMAND_SET_SINK_VOLUME);
pa_tagstruct_putu32(t, tag = c->ctag++);
- pa_tagstruct_putu32(t, index);
+ pa_tagstruct_putu32(t, idx);
pa_tagstruct_puts(t, NULL);
pa_tagstruct_putu32(t, volume);
pa_pstream_send_tagstruct(c->pstream, t);
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_set_sink_volume_by_name(struct pa_context *c, const char *name, pa_volume_t volume, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata) {
- struct pa_operation *o;
- struct pa_tagstruct *t;
+pa_operation* pa_context_set_sink_volume_by_name(pa_context *c, const char *name, pa_volume_t volume, void (*cb)(pa_context *c, int success, void *userdata), void *userdata) {
+ pa_operation *o;
+ pa_tagstruct *t;
uint32_t tag;
assert(c && name);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_set_sink_input_volume(struct pa_context *c, uint32_t index, pa_volume_t volume, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata) {
- struct pa_operation *o;
- struct pa_tagstruct *t;
+pa_operation* pa_context_set_sink_input_volume(pa_context *c, uint32_t idx, pa_volume_t volume, void (*cb)(pa_context *c, int success, void *userdata), void *userdata) {
+ pa_operation *o;
+ pa_tagstruct *t;
uint32_t tag;
- assert(c && index != PA_INVALID_INDEX);
+ assert(c && idx != PA_INVALID_INDEX);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
pa_tagstruct_putu32(t, PA_COMMAND_SET_SINK_INPUT_VOLUME);
pa_tagstruct_putu32(t, tag = c->ctag++);
- pa_tagstruct_putu32(t, index);
+ pa_tagstruct_putu32(t, idx);
pa_tagstruct_putu32(t, volume);
pa_pstream_send_tagstruct(c->pstream, t);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, o);
/** Sample Cache **/
-static void context_get_sample_info_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_operation *o = userdata;
+static void context_get_sample_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_operation *o = userdata;
int eof = 1;
assert(pd && o && o->context && o->ref >= 1);
} else {
while (!pa_tagstruct_eof(t)) {
- struct pa_sample_info i;
+ pa_sample_info i;
if (pa_tagstruct_getu32(t, &i.index) < 0 ||
pa_tagstruct_gets(t, &i.name) < 0 ||
}
if (o->callback) {
- void (*cb)(struct pa_context *s, const struct pa_sample_info*i, int eof, void *userdata) = o->callback;
+ void (*cb)(pa_context *s, const pa_sample_info*_i, int _eof, void *_userdata) = (void (*)(pa_context *s, const pa_sample_info*_i, int _eof, void *_userdata)) o->callback;
cb(o->context, &i, 0, o->userdata);
}
}
}
if (o->callback) {
- void (*cb)(struct pa_context *s, const struct pa_sample_info*i, int eof, void *userdata) = o->callback;
+ void (*cb)(pa_context *s, const pa_sample_info*_i, int _eof, void *_userdata) = (void (*)(pa_context *s, const pa_sample_info*_i, int _eof, void *_userdata)) o->callback;
cb(o->context, NULL, eof, o->userdata);
}
pa_operation_unref(o);
}
-struct pa_operation* pa_context_get_sample_info_by_name(struct pa_context *c, const char *name, void (*cb)(struct pa_context *c, const struct pa_sample_info *i, int is_last, void *userdata), void *userdata) {
- struct pa_tagstruct *t;
- struct pa_operation *o;
+pa_operation* pa_context_get_sample_info_by_name(pa_context *c, const char *name, void (*cb)(pa_context *c, const pa_sample_info *i, int is_last, void *userdata), void *userdata) {
+ pa_tagstruct *t;
+ pa_operation *o;
uint32_t tag;
assert(c && cb && name);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_get_sample_info_by_index(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, const struct pa_sample_info *i, int is_last, void *userdata), void *userdata) {
- struct pa_tagstruct *t;
- struct pa_operation *o;
+pa_operation* pa_context_get_sample_info_by_index(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, const pa_sample_info *i, int is_last, void *userdata), void *userdata) {
+ pa_tagstruct *t;
+ pa_operation *o;
uint32_t tag;
assert(c && cb);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
pa_tagstruct_putu32(t, PA_COMMAND_GET_SAMPLE_INFO);
pa_tagstruct_putu32(t, tag = c->ctag++);
- pa_tagstruct_putu32(t, index);
+ pa_tagstruct_putu32(t, idx);
pa_tagstruct_puts(t, NULL);
pa_pstream_send_tagstruct(c->pstream, t);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_sample_info_callback, o);
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_get_sample_info_list(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_sample_info *i, int is_last, void *userdata), void *userdata) {
- return pa_context_send_simple_command(c, PA_COMMAND_GET_SAMPLE_INFO_LIST, context_get_sample_info_callback, cb, userdata);
+pa_operation* pa_context_get_sample_info_list(pa_context *c, void (*cb)(pa_context *c, const pa_sample_info *i, int is_last, void *userdata), void *userdata) {
+ return pa_context_send_simple_command(c, PA_COMMAND_GET_SAMPLE_INFO_LIST, context_get_sample_info_callback, (pa_operation_callback) cb, userdata);
}
-static struct pa_operation* command_kill(struct pa_context *c, uint32_t command, uint32_t index, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata) {
- struct pa_operation *o;
- struct pa_tagstruct *t;
+static pa_operation* command_kill(pa_context *c, uint32_t command, uint32_t idx, void (*cb)(pa_context *c, int success, void *userdata), void *userdata) {
+ pa_operation *o;
+ pa_tagstruct *t;
uint32_t tag;
- assert(c && index != PA_INVALID_INDEX);
+ assert(c && idx != PA_INVALID_INDEX);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
pa_tagstruct_putu32(t, command);
pa_tagstruct_putu32(t, tag = c->ctag++);
- pa_tagstruct_putu32(t, index);
+ pa_tagstruct_putu32(t, idx);
pa_pstream_send_tagstruct(c->pstream, t);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, o);
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_kill_client(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata) {
- return command_kill(c, PA_COMMAND_KILL_CLIENT, index, cb, userdata);
+pa_operation* pa_context_kill_client(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, int success, void *userdata), void *userdata) {
+ return command_kill(c, PA_COMMAND_KILL_CLIENT, idx, cb, userdata);
}
-struct pa_operation* pa_context_kill_sink_input(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata) {
- return command_kill(c, PA_COMMAND_KILL_SINK_INPUT, index, cb, userdata);
+pa_operation* pa_context_kill_sink_input(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, int success, void *userdata), void *userdata) {
+ return command_kill(c, PA_COMMAND_KILL_SINK_INPUT, idx, cb, userdata);
}
-struct pa_operation* pa_context_kill_source_output(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata) {
- return command_kill(c, PA_COMMAND_KILL_SOURCE_OUTPUT, index, cb, userdata);
+pa_operation* pa_context_kill_source_output(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, int success, void *userdata), void *userdata) {
+ return command_kill(c, PA_COMMAND_KILL_SOURCE_OUTPUT, idx, cb, userdata);
}
-static void load_module_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_operation *o = userdata;
- uint32_t index = -1;
+static void load_module_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_operation *o = userdata;
+ uint32_t idx = -1;
assert(pd && o && o->context && o->ref >= 1);
if (command != PA_COMMAND_REPLY) {
if (pa_context_handle_error(o->context, command, t) < 0)
goto finish;
- } else if (pa_tagstruct_getu32(t, &index) < 0 ||
+ } else if (pa_tagstruct_getu32(t, &idx) < 0 ||
!pa_tagstruct_eof(t)) {
pa_context_fail(o->context, PA_ERROR_PROTOCOL);
goto finish;
}
if (o->callback) {
- void (*cb)(struct pa_context *c, uint32_t index, void *userdata) = o->callback;
- cb(o->context, index, o->userdata);
+ void (*cb)(pa_context *c, uint32_t _idx, void *_userdata) = (void (*)(pa_context *c, uint32_t _idx, void *_userdata)) o->callback;
+ cb(o->context, idx, o->userdata);
}
finish:
pa_operation_unref(o);
}
-struct pa_operation* pa_context_load_module(struct pa_context *c, const char*name, const char *argument, void (*cb)(struct pa_context *c, uint32_t index, void *userdata), void *userdata) {
- struct pa_operation *o;
- struct pa_tagstruct *t;
+pa_operation* pa_context_load_module(pa_context *c, const char*name, const char *argument, void (*cb)(pa_context *c, uint32_t idx, void *userdata), void *userdata) {
+ pa_operation *o;
+ pa_tagstruct *t;
uint32_t tag;
assert(c && name && argument);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_unload_module(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata) {
- return command_kill(c, PA_COMMAND_UNLOAD_MODULE, index, cb, userdata);
+pa_operation* pa_context_unload_module(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, int success, void *userdata), void *userdata) {
+ return command_kill(c, PA_COMMAND_UNLOAD_MODULE, idx, cb, userdata);
}
/*** Autoload stuff ***/
-static void context_get_autoload_info_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_operation *o = userdata;
+static void context_get_autoload_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_operation *o = userdata;
int eof = 1;
assert(pd && o && o->context && o->ref >= 1);
} else {
while (!pa_tagstruct_eof(t)) {
- struct pa_autoload_info i;
+ pa_autoload_info i;
if (pa_tagstruct_getu32(t, &i.index) < 0 ||
pa_tagstruct_gets(t, &i.name) < 0 ||
}
if (o->callback) {
- void (*cb)(struct pa_context *s, const struct pa_autoload_info*i, int eof, void *userdata) = o->callback;
+ void (*cb)(pa_context *s, const pa_autoload_info*_i, int _eof, void *_userdata) = (void (*)(pa_context *s, const pa_autoload_info*_i, int _eof, void *_userdata)) o->callback;
cb(o->context, &i, 0, o->userdata);
}
}
}
if (o->callback) {
- void (*cb)(struct pa_context *s, const struct pa_autoload_info*i, int eof, void *userdata) = o->callback;
+ void (*cb)(pa_context *s, const pa_autoload_info*_i, int _eof, void *_userdata) = (void (*)(pa_context *s, const pa_autoload_info*_i, int _eof, void *_userdata)) o->callback;
cb(o->context, NULL, eof, o->userdata);
}
pa_operation_unref(o);
}
-struct pa_operation* pa_context_get_autoload_info_by_name(struct pa_context *c, const char *name, enum pa_autoload_type type, void (*cb)(struct pa_context *c, const struct pa_autoload_info *i, int is_last, void *userdata), void *userdata) {
- struct pa_tagstruct *t;
- struct pa_operation *o;
+pa_operation* pa_context_get_autoload_info_by_name(pa_context *c, const char *name, pa_autoload_type type, void (*cb)(pa_context *c, const pa_autoload_info *i, int is_last, void *userdata), void *userdata) {
+ pa_tagstruct *t;
+ pa_operation *o;
uint32_t tag;
assert(c && cb && name);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_get_autoload_info_by_index(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, const struct pa_autoload_info *i, int is_last, void *userdata), void *userdata) {
- struct pa_tagstruct *t;
- struct pa_operation *o;
+pa_operation* pa_context_get_autoload_info_by_index(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, const pa_autoload_info *i, int is_last, void *userdata), void *userdata) {
+ pa_tagstruct *t;
+ pa_operation *o;
uint32_t tag;
- assert(c && cb && index != PA_INVALID_INDEX);
+ assert(c && cb && idx != PA_INVALID_INDEX);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
pa_tagstruct_putu32(t, PA_COMMAND_GET_AUTOLOAD_INFO);
pa_tagstruct_putu32(t, tag = c->ctag++);
- pa_tagstruct_putu32(t, index);
+ pa_tagstruct_putu32(t, idx);
pa_pstream_send_tagstruct(c->pstream, t);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, context_get_autoload_info_callback, o);
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_get_autoload_info_list(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_autoload_info *i, int is_last, void *userdata), void *userdata) {
- return pa_context_send_simple_command(c, PA_COMMAND_GET_AUTOLOAD_INFO_LIST, context_get_autoload_info_callback, cb, userdata);
+pa_operation* pa_context_get_autoload_info_list(pa_context *c, void (*cb)(pa_context *c, const pa_autoload_info *i, int is_last, void *userdata), void *userdata) {
+ return pa_context_send_simple_command(c, PA_COMMAND_GET_AUTOLOAD_INFO_LIST, context_get_autoload_info_callback, (pa_operation_callback) cb, userdata);
}
-static void context_add_autoload_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_operation *o = userdata;
- uint32_t index;
+static void context_add_autoload_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_operation *o = userdata;
+ uint32_t idx;
assert(pd && o && o->context && o->ref >= 1);
if (command != PA_COMMAND_REPLY) {
if (pa_context_handle_error(o->context, command, t) < 0)
goto finish;
- index = PA_INVALID_INDEX;
- } else if (pa_tagstruct_getu32(t, &index) ||
+ idx = PA_INVALID_INDEX;
+ } else if (pa_tagstruct_getu32(t, &idx) ||
!pa_tagstruct_eof(t)) {
pa_context_fail(o->context, PA_ERROR_PROTOCOL);
goto finish;
}
if (o->callback) {
- void (*cb)(struct pa_context *s, uint32_t index, void *userdata) = o->callback;
- cb(o->context, index, o->userdata);
+ void (*cb)(pa_context *s, uint32_t _idx, void *_userdata) = (void (*)(pa_context *s, uint32_t _idx, void *_userdata)) o->callback;
+ cb(o->context, idx, o->userdata);
}
}
-struct pa_operation* pa_context_add_autoload(struct pa_context *c, const char *name, enum pa_autoload_type type, const char *module, const char*argument, void (*cb)(struct pa_context *c, int success, void *userdata), void* userdata) {
- struct pa_operation *o;
- struct pa_tagstruct *t;
+pa_operation* pa_context_add_autoload(pa_context *c, const char *name, pa_autoload_type type, const char *module, const char*argument, void (*cb)(pa_context *c, int success, void *userdata), void* userdata) {
+ pa_operation *o;
+ pa_tagstruct *t;
uint32_t tag;
assert(c && name && module && argument);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_remove_autoload_by_name(struct pa_context *c, const char *name, enum pa_autoload_type type, void (*cb)(struct pa_context *c, int success, void *userdata), void* userdata) {
- struct pa_operation *o;
- struct pa_tagstruct *t;
+pa_operation* pa_context_remove_autoload_by_name(pa_context *c, const char *name, pa_autoload_type type, void (*cb)(pa_context *c, int success, void *userdata), void* userdata) {
+ pa_operation *o;
+ pa_tagstruct *t;
uint32_t tag;
assert(c && name);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_remove_autoload_by_index(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, int success, void *userdata), void* userdata) {
- struct pa_operation *o;
- struct pa_tagstruct *t;
+pa_operation* pa_context_remove_autoload_by_index(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, int success, void *userdata), void* userdata) {
+ pa_operation *o;
+ pa_tagstruct *t;
uint32_t tag;
- assert(c && index != PA_INVALID_INDEX);
+ assert(c && idx != PA_INVALID_INDEX);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
pa_tagstruct_putu32(t, PA_COMMAND_REMOVE_AUTOLOAD);
pa_tagstruct_putu32(t, tag = c->ctag++);
- pa_tagstruct_putu32(t, index);
+ pa_tagstruct_putu32(t, idx);
pa_pstream_send_tagstruct(c->pstream, t);
pa_pdispatch_register_reply(c->pdispatch, tag, DEFAULT_TIMEOUT, pa_context_simple_ack_callback, o);
PA_C_DECL_BEGIN
/** Stores information about sinks */
-struct pa_sink_info {
+typedef struct pa_sink_info {
const char *name; /**< Name of the sink */
uint32_t index; /**< Index of the sink */
const char *description; /**< Description of this sink */
- struct pa_sample_spec sample_spec; /**< Sample spec of this sink */
+ pa_sample_spec sample_spec; /**< Sample spec of this sink */
uint32_t owner_module; /**< Index of the owning module of this sink, or PA_INVALID_INDEX */
pa_volume_t volume; /**< Volume of the sink */
uint32_t monitor_source; /**< Index of the monitor source connected to this sink */
const char *monitor_source_name; /**< The name of the monitor source */
pa_usec_t latency; /**< Length of filled playback buffer of this sink */
pa_typeid_t _typeid; /**< Implementation type. \since 0.8 */
-};
+} pa_sink_info;
/** Get information about a sink by its name */
-struct pa_operation* pa_context_get_sink_info_by_name(struct pa_context *c, const char *name, void (*cb)(struct pa_context *c, const struct pa_sink_info *i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_sink_info_by_name(pa_context *c, const char *name, void (*cb)(pa_context *c, const pa_sink_info *i, int is_last, void *userdata), void *userdata);
/** Get information about a sink by its index */
-struct pa_operation* pa_context_get_sink_info_by_index(struct pa_context *c, uint32_t id, void (*cb)(struct pa_context *c, const struct pa_sink_info *i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_sink_info_by_index(pa_context *c, uint32_t id, void (*cb)(pa_context *c, const pa_sink_info *i, int is_last, void *userdata), void *userdata);
/** Get the complete sink list */
-struct pa_operation* pa_context_get_sink_info_list(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_sink_info *i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_sink_info_list(pa_context *c, void (*cb)(pa_context *c, const pa_sink_info *i, int is_last, void *userdata), void *userdata);
/** Stores information about sources */
-struct pa_source_info {
+typedef struct pa_source_info {
const char *name ; /**< Name of the source */
uint32_t index; /**< Index of the source */
const char *description; /**< Description of this source */
- struct pa_sample_spec sample_spec; /**< Sample spec of this source */
+ pa_sample_spec sample_spec; /**< Sample spec of this source */
uint32_t owner_module; /**< Owning module index, or PA_INVALID_INDEX */
uint32_t monitor_of_sink; /**< If this is a monitor source the index of the owning sink, otherwise PA_INVALID_INDEX */
const char *monitor_of_sink_name; /**< Name of the owning sink, or PA_INVALID_INDEX */
pa_usec_t latency; /**< Length of filled record buffer of this source. \since 0.5 */
pa_typeid_t _typeid; /**< Implementation type. \since 0.8 */
-};
+} pa_source_info;
/** Get information about a source by its name */
-struct pa_operation* pa_context_get_source_info_by_name(struct pa_context *c, const char *name, void (*cb)(struct pa_context *c, const struct pa_source_info *i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_source_info_by_name(pa_context *c, const char *name, void (*cb)(pa_context *c, const pa_source_info *i, int is_last, void *userdata), void *userdata);
/** Get information about a source by its index */
-struct pa_operation* pa_context_get_source_info_by_index(struct pa_context *c, uint32_t id, void (*cb)(struct pa_context *c, const struct pa_source_info *i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_source_info_by_index(pa_context *c, uint32_t id, void (*cb)(pa_context *c, const pa_source_info *i, int is_last, void *userdata), void *userdata);
/** Get the complete source list */
-struct pa_operation* pa_context_get_source_info_list(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_source_info *i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_source_info_list(pa_context *c, void (*cb)(pa_context *c, const pa_source_info *i, int is_last, void *userdata), void *userdata);
/** Server information */
-struct pa_server_info {
+typedef struct pa_server_info {
const char *user_name; /**< User name of the daemon process */
const char *host_name; /**< Host name the daemon is running on */
const char *server_version; /**< Version string of the daemon */
const char *server_name; /**< Server package name (usually "polypaudio") */
- struct pa_sample_spec sample_spec; /**< Default sample specification */
+ pa_sample_spec sample_spec; /**< Default sample specification */
const char *default_sink_name; /**< Name of default sink. \since 0.4 */
const char *default_source_name; /**< Name of default sink. \since 0.4*/
uint32_t cookie; /**< A random cookie for identifying this instance of polypaudio. \since 0.8 */
-};
+} pa_server_info;
/** Get some information about the server */
-struct pa_operation* pa_context_get_server_info(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_server_info*i, void *userdata), void *userdata);
+pa_operation* pa_context_get_server_info(pa_context *c, void (*cb)(pa_context *c, const pa_server_info*i, void *userdata), void *userdata);
/** Stores information about modules */
-struct pa_module_info {
+typedef struct pa_module_info {
uint32_t index; /**< Index of the module */
const char*name, /**< Name of the module */
*argument; /**< Argument string of the module */
uint32_t n_used; /**< Usage counter or PA_INVALID_INDEX */
int auto_unload; /**< Non-zero if this is an autoloaded module */
-};
+} pa_module_info;
/** Get some information about a module by its index */
-struct pa_operation* pa_context_get_module_info(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, const struct pa_module_info*i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_module_info(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, const pa_module_info*i, int is_last, void *userdata), void *userdata);
/** Get the complete list of currently loaded modules */
-struct pa_operation* pa_context_get_module_info_list(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_module_info*i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_module_info_list(pa_context *c, void (*cb)(pa_context *c, const pa_module_info*i, int is_last, void *userdata), void *userdata);
/** Stores information about clients */
-struct pa_client_info {
+typedef struct pa_client_info {
uint32_t index; /**< Index of this client */
const char *name; /**< Name of this client */
uint32_t owner_module; /**< Index of the owning module, or PA_INVALID_INDEX */
pa_typeid_t _typeid; /**< Implementation type. \since 0.8 */
-};
+} pa_client_info;
/** Get information about a client by its index */
-struct pa_operation* pa_context_get_client_info(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, const struct pa_client_info*i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_client_info(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, const pa_client_info*i, int is_last, void *userdata), void *userdata);
/** Get the complete client list */
-struct pa_operation* pa_context_get_client_info_list(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_client_info*i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_client_info_list(pa_context *c, void (*cb)(pa_context *c, const pa_client_info*i, int is_last, void *userdata), void *userdata);
/** Stores information about sink inputs */
-struct pa_sink_input_info {
+typedef struct pa_sink_input_info {
uint32_t index; /**< Index of the sink input */
const char *name; /**< Name of the sink input */
uint32_t owner_module; /**< Index of the module this sink input belongs to, or PA_INVALID_INDEX when it does not belong to any module */
uint32_t client; /**< Index of the client this sink input belongs to, or PA_INVALID_INDEX when it does not belong to any client */
uint32_t sink; /**< Index of the connected sink */
- struct pa_sample_spec sample_spec; /**< The sample specification of the sink input */
+ pa_sample_spec sample_spec; /**< The sample specification of the sink input */
pa_volume_t volume; /**< The volume of this sink input */
pa_usec_t buffer_usec; /**< Latency due to buffering in sink input, see pa_latency_info for details */
pa_usec_t sink_usec; /**< Latency of the sink device, see pa_latency_info for details */
const char *resample_method; /**< Thre resampling method used by this sink input. \since 0.7 */
pa_typeid_t _typeid; /**< Implementation type. \since 0.8 */
-};
+} pa_sink_input_info;
/** Get some information about a sink input by its index */
-struct pa_operation* pa_context_get_sink_input_info(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, const struct pa_sink_input_info*i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_sink_input_info(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, const pa_sink_input_info*i, int is_last, void *userdata), void *userdata);
/** Get the complete sink input list */
-struct pa_operation* pa_context_get_sink_input_info_list(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_sink_input_info*i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_sink_input_info_list(pa_context *c, void (*cb)(pa_context *c, const pa_sink_input_info*i, int is_last, void *userdata), void *userdata);
/** Stores information about source outputs */
-struct pa_source_output_info {
+typedef struct pa_source_output_info {
uint32_t index; /**< Index of the sink input */
const char *name; /**< Name of the sink input */
uint32_t owner_module; /**< Index of the module this sink input belongs to, or PA_INVALID_INDEX when it does not belong to any module */
uint32_t client; /**< Index of the client this sink input belongs to, or PA_INVALID_INDEX when it does not belong to any client */
uint32_t source; /**< Index of the connected source */
- struct pa_sample_spec sample_spec; /**< The sample specification of the source output */
+ pa_sample_spec sample_spec; /**< The sample specification of the source output */
pa_usec_t buffer_usec; /**< Latency due to buffering in the source output, see pa_latency_info for details. \since 0.5 */
pa_usec_t source_usec; /**< Latency of the source device, see pa_latency_info for details. \since 0.5 */
const char *resample_method; /**< Thre resampling method used by this source output. \since 0.7 */
pa_typeid_t _typeid; /**< Implementation type. \since 0.8 */
-};
+} pa_source_output_info;
/** Get information about a source output by its index */
-struct pa_operation* pa_context_get_source_output_info(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, const struct pa_source_output_info*i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_source_output_info(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, const pa_source_output_info*i, int is_last, void *userdata), void *userdata);
/** Get the complete list of source outputs */
-struct pa_operation* pa_context_get_source_output_info_list(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_source_output_info*i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_source_output_info_list(pa_context *c, void (*cb)(pa_context *c, const pa_source_output_info*i, int is_last, void *userdata), void *userdata);
/** Set the volume of a sink device specified by its index */
-struct pa_operation* pa_context_set_sink_volume_by_index(struct pa_context *c, uint32_t index, pa_volume_t volume, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata);
+pa_operation* pa_context_set_sink_volume_by_index(pa_context *c, uint32_t idx, pa_volume_t volume, void (*cb)(pa_context *c, int success, void *userdata), void *userdata);
/** Set the volume of a sink device specified by its name */
-struct pa_operation* pa_context_set_sink_volume_by_name(struct pa_context *c, const char *name, pa_volume_t volume, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata);
+pa_operation* pa_context_set_sink_volume_by_name(pa_context *c, const char *name, pa_volume_t volume, void (*cb)(pa_context *c, int success, void *userdata), void *userdata);
/** Set the volume of a sink input stream */
-struct pa_operation* pa_context_set_sink_input_volume(struct pa_context *c, uint32_t index, pa_volume_t volume, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata);
+pa_operation* pa_context_set_sink_input_volume(pa_context *c, uint32_t idx, pa_volume_t volume, void (*cb)(pa_context *c, int success, void *userdata), void *userdata);
/** Memory block statistics */
-struct pa_stat_info {
+typedef struct pa_stat_info {
uint32_t memblock_total; /**< Currently allocated memory blocks */
uint32_t memblock_total_size; /**< Currentl total size of allocated memory blocks */
uint32_t memblock_allocated; /**< Allocated memory blocks during the whole lifetime of the daemon */
uint32_t memblock_allocated_size; /**< Total size of all memory blocks allocated during the whole lifetime of the daemon */
uint32_t scache_size; /**< Total size of all sample cache entries. \since 0.4 */
-};
+} pa_stat_info;
/** Get daemon memory block statistics */
-struct pa_operation* pa_context_stat(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_stat_info *i, void *userdata), void *userdata);
+pa_operation* pa_context_stat(pa_context *c, void (*cb)(pa_context *c, const pa_stat_info *i, void *userdata), void *userdata);
/** Stores information about sample cache entries */
-struct pa_sample_info {
+typedef struct pa_sample_info {
uint32_t index; /**< Index of this entry */
const char *name; /**< Name of this entry */
pa_volume_t volume; /**< Default volume of this entry */
- struct pa_sample_spec sample_spec; /**< Sample specification of the sampel */
+ pa_sample_spec sample_spec; /**< Sample specification of the sampel */
pa_usec_t duration; /**< Duration of this entry */
uint32_t bytes; /**< Length of this sample in bytes. \since 0.4 */
int lazy; /**< Non-zero when this is a lazy cache entry. \since 0.5 */
const char *filename; /**< In case this is a lazy cache entry, the filename for the sound file to be loaded on demand. \since 0.5 */
-};
+} pa_sample_info;
/** Get information about a sample by its name */
-struct pa_operation* pa_context_get_sample_info_by_name(struct pa_context *c, const char *name, void (*cb)(struct pa_context *c, const struct pa_sample_info *i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_sample_info_by_name(pa_context *c, const char *name, void (*cb)(pa_context *c, const pa_sample_info *i, int is_last, void *userdata), void *userdata);
/** Get information about a sample by its index */
-struct pa_operation* pa_context_get_sample_info_by_index(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, const struct pa_sample_info *i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_sample_info_by_index(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, const pa_sample_info *i, int is_last, void *userdata), void *userdata);
/** Get the complete list of samples stored in the daemon. */
-struct pa_operation* pa_context_get_sample_info_list(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_sample_info *i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_sample_info_list(pa_context *c, void (*cb)(pa_context *c, const pa_sample_info *i, int is_last, void *userdata), void *userdata);
/** Kill a client. \since 0.5 */
-struct pa_operation* pa_context_kill_client(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata);
+pa_operation* pa_context_kill_client(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, int success, void *userdata), void *userdata);
/** Kill a sink input. \since 0.5 */
-struct pa_operation* pa_context_kill_sink_input(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata);
+pa_operation* pa_context_kill_sink_input(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, int success, void *userdata), void *userdata);
/** Kill a source output. \since 0.5 */
-struct pa_operation* pa_context_kill_source_output(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata);
+pa_operation* pa_context_kill_source_output(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, int success, void *userdata), void *userdata);
/** Load a module. \since 0.5 */
-struct pa_operation* pa_context_load_module(struct pa_context *c, const char*name, const char *argument, void (*cb)(struct pa_context *c, uint32_t index, void *userdata), void *userdata);
+pa_operation* pa_context_load_module(pa_context *c, const char*name, const char *argument, void (*cb)(pa_context *c, uint32_t idx, void *userdata), void *userdata);
/** Unload a module. \since 0.5 */
-struct pa_operation* pa_context_unload_module(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata);
+pa_operation* pa_context_unload_module(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, int success, void *userdata), void *userdata);
/** Type of an autoload entry. \since 0.5 */
-enum pa_autoload_type {
+typedef enum pa_autoload_type {
PA_AUTOLOAD_SINK = 0,
PA_AUTOLOAD_SOURCE = 1
-};
+} pa_autoload_type;
/** Stores information about autoload entries. \since 0.5 */
-struct pa_autoload_info {
+typedef struct pa_autoload_info {
uint32_t index; /**< Index of this autoload entry */
const char *name; /**< Name of the sink or source */
- enum pa_autoload_type type; /**< Type of the autoload entry */
+ pa_autoload_type type; /**< Type of the autoload entry */
const char *module; /**< Module name to load */
const char *argument; /**< Argument string for module */
-};
+} pa_autoload_info;
/** Get info about a specific autoload entry. \since 0.6 */
-struct pa_operation* pa_context_get_autoload_info_by_name(struct pa_context *c, const char *name, enum pa_autoload_type type, void (*cb)(struct pa_context *c, const struct pa_autoload_info *i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_autoload_info_by_name(pa_context *c, const char *name, pa_autoload_type type, void (*cb)(pa_context *c, const pa_autoload_info *i, int is_last, void *userdata), void *userdata);
/** Get info about a specific autoload entry. \since 0.6 */
-struct pa_operation* pa_context_get_autoload_info_by_index(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, const struct pa_autoload_info *i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_autoload_info_by_index(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, const pa_autoload_info *i, int is_last, void *userdata), void *userdata);
/** Get the complete list of autoload entries. \since 0.5 */
-struct pa_operation* pa_context_get_autoload_info_list(struct pa_context *c, void (*cb)(struct pa_context *c, const struct pa_autoload_info *i, int is_last, void *userdata), void *userdata);
+pa_operation* pa_context_get_autoload_info_list(pa_context *c, void (*cb)(pa_context *c, const pa_autoload_info *i, int is_last, void *userdata), void *userdata);
/** Add a new autoload entry. \since 0.5 */
-struct pa_operation* pa_context_add_autoload(struct pa_context *c, const char *name, enum pa_autoload_type type, const char *module, const char*argument, void (*cb)(struct pa_context *c, int index, void *userdata), void* userdata);
+pa_operation* pa_context_add_autoload(pa_context *c, const char *name, pa_autoload_type type, const char *module, const char*argument, void (*cb)(pa_context *c, int idx, void *userdata), void* userdata);
/** Remove an autoload entry. \since 0.6 */
-struct pa_operation* pa_context_remove_autoload_by_name(struct pa_context *c, const char *name, enum pa_autoload_type type, void (*cb)(struct pa_context *c, int success, void *userdata), void* userdata);
+pa_operation* pa_context_remove_autoload_by_name(pa_context *c, const char *name, pa_autoload_type type, void (*cb)(pa_context *c, int success, void *userdata), void* userdata);
/** Remove an autoload entry. \since 0.6 */
-struct pa_operation* pa_context_remove_autoload_by_index(struct pa_context *c, uint32_t index, void (*cb)(struct pa_context *c, int success, void *userdata), void* userdata);
+pa_operation* pa_context_remove_autoload_by_index(pa_context *c, uint32_t idx, void (*cb)(pa_context *c, int success, void *userdata), void* userdata);
PA_C_DECL_END
#include "polyplib-internal.h"
#include "polyplib-operation.h"
-struct pa_operation *pa_operation_new(struct pa_context *c, struct pa_stream *s) {
- struct pa_operation *o;
+pa_operation *pa_operation_new(pa_context *c, pa_stream *s) {
+ pa_operation *o;
assert(c);
- o = pa_xmalloc(sizeof(struct pa_operation));
+ o = pa_xmalloc(sizeof(pa_operation));
o->ref = 1;
o->context = pa_context_ref(c);
o->stream = s ? pa_stream_ref(s) : NULL;
o->userdata = NULL;
o->callback = NULL;
- PA_LLIST_PREPEND(struct pa_operation, o->context->operations, o);
+ PA_LLIST_PREPEND(pa_operation, o->context->operations, o);
return pa_operation_ref(o);
}
-struct pa_operation *pa_operation_ref(struct pa_operation *o) {
+pa_operation *pa_operation_ref(pa_operation *o) {
assert(o && o->ref >= 1);
o->ref++;
return o;
}
-void pa_operation_unref(struct pa_operation *o) {
+void pa_operation_unref(pa_operation *o) {
assert(o && o->ref >= 1);
if ((--(o->ref)) == 0) {
}
}
-static void operation_set_state(struct pa_operation *o, enum pa_operation_state st) {
+static void operation_set_state(pa_operation *o, pa_operation_state st) {
assert(o && o->ref >= 1);
if (st == o->state)
o->state = st;
if ((o->state == PA_OPERATION_DONE) || (o->state == PA_OPERATION_CANCELED)) {
- PA_LLIST_REMOVE(struct pa_operation, o->context->operations, o);
+ PA_LLIST_REMOVE(pa_operation, o->context->operations, o);
pa_context_unref(o->context);
if (o->stream)
pa_stream_unref(o->stream);
}
}
-void pa_operation_cancel(struct pa_operation *o) {
+void pa_operation_cancel(pa_operation *o) {
assert(o && o->ref >= 1);
operation_set_state(o, PA_OPERATION_CANCELED);
}
-void pa_operation_done(struct pa_operation *o) {
+void pa_operation_done(pa_operation *o) {
assert(o && o->ref >= 1);
operation_set_state(o, PA_OPERATION_DONE);
}
-enum pa_operation_state pa_operation_get_state(struct pa_operation *o) {
+pa_operation_state pa_operation_get_state(pa_operation *o) {
assert(o && o->ref >= 1);
return o->state;
}
PA_C_DECL_BEGIN
-/** \struct pa_operation
+/** \pa_operation
* An asynchronous operation object */
-struct pa_operation;
+typedef struct pa_operation pa_operation;
/** Increase the reference count by one */
-struct pa_operation *pa_operation_ref(struct pa_operation *o);
+pa_operation *pa_operation_ref(pa_operation *o);
/** Decrease the reference count by one */
-void pa_operation_unref(struct pa_operation *o);
+void pa_operation_unref(pa_operation *o);
/** Cancel the operation. Beware! This will not necessarily cancel the execution of the operation on the server side. */
-void pa_operation_cancel(struct pa_operation *o);
+void pa_operation_cancel(pa_operation *o);
/** Return the current status of the operation */
-enum pa_operation_state pa_operation_get_state(struct pa_operation *o);
+pa_operation_state pa_operation_get_state(pa_operation *o);
PA_C_DECL_END
#include "polyplib-internal.h"
#include "pstream-util.h"
-void pa_stream_connect_upload(struct pa_stream *s, size_t length) {
- struct pa_tagstruct *t;
+void pa_stream_connect_upload(pa_stream *s, size_t length) {
+ pa_tagstruct *t;
uint32_t tag;
assert(s && length);
pa_stream_unref(s);
}
-void pa_stream_finish_upload(struct pa_stream *s) {
- struct pa_tagstruct *t;
+void pa_stream_finish_upload(pa_stream *s) {
+ pa_tagstruct *t;
uint32_t tag;
assert(s);
pa_stream_unref(s);
}
-struct pa_operation * pa_context_play_sample(struct pa_context *c, const char *name, const char *dev, uint32_t volume, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata) {
- struct pa_operation *o;
- struct pa_tagstruct *t;
+pa_operation * pa_context_play_sample(pa_context *c, const char *name, const char *dev, uint32_t volume, void (*cb)(pa_context *c, int success, void *userdata), void *userdata) {
+ pa_operation *o;
+ pa_tagstruct *t;
uint32_t tag;
assert(c && name && *name && (!dev || *dev));
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
if (!dev)
return pa_operation_ref(o);
}
-struct pa_operation* pa_context_remove_sample(struct pa_context *c, const char *name, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata) {
- struct pa_operation *o;
- struct pa_tagstruct *t;
+pa_operation* pa_context_remove_sample(pa_context *c, const char *name, void (*cb)(pa_context *c, int success, void *userdata), void *userdata) {
+ pa_operation *o;
+ pa_tagstruct *t;
uint32_t tag;
assert(c && name);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
PA_C_DECL_BEGIN
/** Make this stream a sample upload stream */
-void pa_stream_connect_upload(struct pa_stream *s, size_t length);
+void pa_stream_connect_upload(pa_stream *s, size_t length);
/** Finish the sample upload, the stream name will become the sample name. You cancel a sample upload by issuing pa_stream_disconnect() */
-void pa_stream_finish_upload(struct pa_stream *s);
+void pa_stream_finish_upload(pa_stream *s);
/** Play a sample from the sample cache to the specified device. If the latter is NULL use the default sink. Returns an operation object */
-struct pa_operation* pa_context_play_sample(struct pa_context *c, const char *name, const char *dev, uint32_t volume, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata);
+pa_operation* pa_context_play_sample(pa_context *c, const char *name, const char *dev, uint32_t volume, void (*cb)(pa_context *c, int success, void *userdata), void *userdata);
/** Remove a sample from the sample cache. Returns an operation object which may be used to cancel the operation while it is running */
-struct pa_operation* pa_context_remove_sample(struct pa_context *c, const char *name, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata);
+pa_operation* pa_context_remove_sample(pa_context *c, const char *name, void (*cb)(pa_context *c, int success, void *userdata), void *userdata);
PA_C_DECL_END
#include "log.h"
struct pa_simple {
- struct pa_mainloop *mainloop;
- struct pa_context *context;
- struct pa_stream *stream;
- enum pa_stream_direction direction;
+ pa_mainloop *mainloop;
+ pa_context *context;
+ pa_stream *stream;
+ pa_stream_direction direction;
int dead;
pa_usec_t latency;
};
-static void read_callback(struct pa_stream *s, const void*data, size_t length, void *userdata);
+static void read_callback(pa_stream *s, const void*data, size_t length, void *userdata);
-static int check_error(struct pa_simple *p, int *perror) {
- enum pa_context_state cst;
- enum pa_stream_state sst;
+static int check_error(pa_simple *p, int *rerror) {
+ pa_context_state cst;
+ pa_stream_state sst;
assert(p);
if ((cst = pa_context_get_state(p->context)) == PA_CONTEXT_FAILED)
return 0;
fail:
- if (perror)
- *perror = pa_context_errno(p->context);
+ if (rerror)
+ *rerror = pa_context_errno(p->context);
p->dead = 1;
return -1;
}
-static int iterate(struct pa_simple *p, int block, int *perror) {
+static int iterate(pa_simple *p, int block, int *rerror) {
assert(p && p->context && p->mainloop);
- if (check_error(p, perror) < 0)
+ if (check_error(p, rerror) < 0)
return -1;
if (!block && !pa_context_is_pending(p->context))
do {
if (pa_mainloop_iterate(p->mainloop, 1, NULL) < 0) {
- if (perror)
- *perror = PA_ERROR_INTERNAL;
+ if (rerror)
+ *rerror = PA_ERROR_INTERNAL;
return -1;
}
- if (check_error(p, perror) < 0)
+ if (check_error(p, rerror) < 0)
return -1;
} while (pa_context_is_pending(p->context));
while (pa_mainloop_deferred_pending(p->mainloop)) {
if (pa_mainloop_iterate(p->mainloop, 0, NULL) < 0) {
- if (perror)
- *perror = PA_ERROR_INTERNAL;
+ if (rerror)
+ *rerror = PA_ERROR_INTERNAL;
return -1;
}
- if (check_error(p, perror) < 0)
+ if (check_error(p, rerror) < 0)
return -1;
}
return 0;
}
-struct pa_simple* pa_simple_new(
+pa_simple* pa_simple_new(
const char *server,
const char *name,
- enum pa_stream_direction dir,
+ pa_stream_direction dir,
const char *dev,
const char *stream_name,
- const struct pa_sample_spec *ss,
- const struct pa_buffer_attr *attr,
+ const pa_sample_spec *ss,
+ const pa_buffer_attr *attr,
pa_volume_t volume,
- int *perror) {
+ int *rerror) {
- struct pa_simple *p;
+ pa_simple *p;
int error = PA_ERROR_INTERNAL;
assert(ss && (dir == PA_STREAM_PLAYBACK || dir == PA_STREAM_RECORD));
- p = pa_xmalloc(sizeof(struct pa_simple));
+ p = pa_xmalloc(sizeof(pa_simple));
p->context = NULL;
p->stream = NULL;
p->mainloop = pa_mainloop_new();
return p;
fail:
- if (perror)
- *perror = error;
+ if (rerror)
+ *rerror = error;
pa_simple_free(p);
return NULL;
}
-void pa_simple_free(struct pa_simple *s) {
+void pa_simple_free(pa_simple *s) {
assert(s);
pa_xfree(s->read_data);
pa_xfree(s);
}
-int pa_simple_write(struct pa_simple *p, const void*data, size_t length, int *perror) {
+int pa_simple_write(pa_simple *p, const void*data, size_t length, int *rerror) {
assert(p && data && p->direction == PA_STREAM_PLAYBACK);
if (p->dead) {
- if (perror)
- *perror = pa_context_errno(p->context);
+ if (rerror)
+ *rerror = pa_context_errno(p->context);
return -1;
}
size_t l;
while (!(l = pa_stream_writable_size(p->stream)))
- if (iterate(p, 1, perror) < 0)
+ if (iterate(p, 1, rerror) < 0)
return -1;
if (l > length)
l = length;
pa_stream_write(p->stream, data, l, NULL, 0);
- data = (uint8_t*) data + l;
+ data = (const uint8_t*) data + l;
length -= l;
}
/* Make sure that no data is pending for write */
- if (iterate(p, 0, perror) < 0)
+ if (iterate(p, 0, rerror) < 0)
return -1;
return 0;
}
-static void read_callback(struct pa_stream *s, const void*data, size_t length, void *userdata) {
- struct pa_simple *p = userdata;
+static void read_callback(pa_stream *s, const void*data, size_t length, void *userdata) {
+ pa_simple *p = userdata;
assert(s && data && length && p);
if (p->read_data) {
p->read_index = 0;
}
-int pa_simple_read(struct pa_simple *p, void*data, size_t length, int *perror) {
+int pa_simple_read(pa_simple *p, void*data, size_t length, int *rerror) {
assert(p && data && p->direction == PA_STREAM_RECORD);
if (p->dead) {
- if (perror)
- *perror = pa_context_errno(p->context);
+ if (rerror)
+ *rerror = pa_context_errno(p->context);
return -1;
}
assert(!p->read_data);
}
- if (iterate(p, 1, perror) < 0)
+ if (iterate(p, 1, rerror) < 0)
return -1;
}
return 0;
}
-static void drain_or_flush_complete(struct pa_stream *s, int success, void *userdata) {
- struct pa_simple *p = userdata;
+static void drain_or_flush_complete(pa_stream *s, int success, void *userdata) {
+ pa_simple *p = userdata;
assert(s && p);
if (!success)
p->dead = 1;
}
-int pa_simple_drain(struct pa_simple *p, int *perror) {
- struct pa_operation *o;
+int pa_simple_drain(pa_simple *p, int *rerror) {
+ pa_operation *o;
assert(p && p->direction == PA_STREAM_PLAYBACK);
if (p->dead) {
- if (perror)
- *perror = pa_context_errno(p->context);
+ if (rerror)
+ *rerror = pa_context_errno(p->context);
return -1;
}
o = pa_stream_drain(p->stream, drain_or_flush_complete, p);
while (pa_operation_get_state(o) == PA_OPERATION_RUNNING) {
- if (iterate(p, 1, perror) < 0) {
+ if (iterate(p, 1, rerror) < 0) {
pa_operation_cancel(o);
pa_operation_unref(o);
return -1;
pa_operation_unref(o);
- if (p->dead && perror)
- *perror = pa_context_errno(p->context);
+ if (p->dead && rerror)
+ *rerror = pa_context_errno(p->context);
return p->dead ? -1 : 0;
}
-static void latency_complete(struct pa_stream *s, const struct pa_latency_info *l, void *userdata) {
- struct pa_simple *p = userdata;
+static void latency_complete(pa_stream *s, const pa_latency_info *l, void *userdata) {
+ pa_simple *p = userdata;
assert(s && p);
if (!l)
}
}
-pa_usec_t pa_simple_get_playback_latency(struct pa_simple *p, int *perror) {
- struct pa_operation *o;
+pa_usec_t pa_simple_get_playback_latency(pa_simple *p, int *rerror) {
+ pa_operation *o;
assert(p && p->direction == PA_STREAM_PLAYBACK);
if (p->dead) {
- if (perror)
- *perror = pa_context_errno(p->context);
+ if (rerror)
+ *rerror = pa_context_errno(p->context);
return (pa_usec_t) -1;
}
while (pa_operation_get_state(o) == PA_OPERATION_RUNNING) {
- if (iterate(p, 1, perror) < 0) {
+ if (iterate(p, 1, rerror) < 0) {
pa_operation_cancel(o);
pa_operation_unref(o);
return -1;
pa_operation_unref(o);
- if (p->dead && perror)
- *perror = pa_context_errno(p->context);
+ if (p->dead && rerror)
+ *rerror = pa_context_errno(p->context);
return p->dead ? (pa_usec_t) -1 : p->latency;
}
-int pa_simple_flush(struct pa_simple *p, int *perror) {
- struct pa_operation *o;
+int pa_simple_flush(pa_simple *p, int *rerror) {
+ pa_operation *o;
assert(p && p->direction == PA_STREAM_PLAYBACK);
if (p->dead) {
- if (perror)
- *perror = pa_context_errno(p->context);
+ if (rerror)
+ *rerror = pa_context_errno(p->context);
return -1;
}
o = pa_stream_flush(p->stream, drain_or_flush_complete, p);
while (pa_operation_get_state(o) == PA_OPERATION_RUNNING) {
- if (iterate(p, 1, perror) < 0) {
+ if (iterate(p, 1, rerror) < 0) {
pa_operation_cancel(o);
pa_operation_unref(o);
return -1;
pa_operation_unref(o);
- if (p->dead && perror)
- *perror = pa_context_errno(p->context);
+ if (p->dead && rerror)
+ *rerror = pa_context_errno(p->context);
return p->dead ? -1 : 0;
}
PA_C_DECL_BEGIN
-/** \struct pa_simple
+/** \pa_simple
* An opaque simple connection object */
-struct pa_simple;
+typedef struct pa_simple pa_simple;
/** Create a new connection to the server */
-struct pa_simple* pa_simple_new(
+pa_simple* pa_simple_new(
const char *server, /**< Server name, or NULL for default */
const char *name, /**< A descriptive name for this client (application name, ...) */
- enum pa_stream_direction dir, /**< Open this stream for recording or playback? */
+ pa_stream_direction dir, /**< Open this stream for recording or playback? */
const char *dev, /**< Sink (resp. source) name, or NULL for default */
const char *stream_name, /**< A descriptive name for this client (application name, song title, ...) */
- const struct pa_sample_spec *ss, /**< The sample type to use */
- const struct pa_buffer_attr *attr, /**< Buffering attributes, or NULL for default */
+ const pa_sample_spec *ss, /**< The sample type to use */
+ const pa_buffer_attr *attr, /**< Buffering attributes, or NULL for default */
pa_volume_t volume, /**< Initial volume. Only for playback streams. \since 0.5 */
int *error /**< A pointer where the error code is stored when the routine returns NULL. It is OK to pass NULL here. */
);
/** Close and free the connection to the server. The connection objects becomes invalid when this is called. */
-void pa_simple_free(struct pa_simple *s);
+void pa_simple_free(pa_simple *s);
/** Write some data to the server */
-int pa_simple_write(struct pa_simple *s, const void*data, size_t length, int *error);
+int pa_simple_write(pa_simple *s, const void*data, size_t length, int *error);
/** Wait until all data already written is played by the daemon */
-int pa_simple_drain(struct pa_simple *s, int *error);
+int pa_simple_drain(pa_simple *s, int *error);
/** Read some data from the server */
-int pa_simple_read(struct pa_simple *s, void*data, size_t length, int *error);
+int pa_simple_read(pa_simple *s, void*data, size_t length, int *error);
/** Return the playback latency. \since 0.5 */
-pa_usec_t pa_simple_get_playback_latency(struct pa_simple *s, int *perror);
+pa_usec_t pa_simple_get_playback_latency(pa_simple *s, int *error);
/** Flush the playback buffer. \since 0.5 */
-int pa_simple_flush(struct pa_simple *s, int *perror);
+int pa_simple_flush(pa_simple *s, int *error);
PA_C_DECL_END
#define LATENCY_IPOL_INTERVAL_USEC (10000L)
-struct pa_stream *pa_stream_new(struct pa_context *c, const char *name, const struct pa_sample_spec *ss) {
- struct pa_stream *s;
+pa_stream *pa_stream_new(pa_context *c, const char *name, const pa_sample_spec *ss) {
+ pa_stream *s;
assert(c && ss);
- s = pa_xmalloc(sizeof(struct pa_stream));
+ s = pa_xmalloc(sizeof(pa_stream));
s->ref = 1;
s->context = c;
s->mainloop = c->mainloop;
s->ipol_event = NULL;
s->ipol_requested = 0;
- PA_LLIST_PREPEND(struct pa_stream, c->streams, s);
+ PA_LLIST_PREPEND(pa_stream, c->streams, s);
return pa_stream_ref(s);
}
-static void stream_free(struct pa_stream *s) {
+static void stream_free(pa_stream *s) {
assert(s);
if (s->ipol_event) {
pa_xfree(s);
}
-void pa_stream_unref(struct pa_stream *s) {
+void pa_stream_unref(pa_stream *s) {
assert(s && s->ref >= 1);
if (--(s->ref) == 0)
stream_free(s);
}
-struct pa_stream* pa_stream_ref(struct pa_stream *s) {
+pa_stream* pa_stream_ref(pa_stream *s) {
assert(s && s->ref >= 1);
s->ref++;
return s;
}
-enum pa_stream_state pa_stream_get_state(struct pa_stream *s) {
+pa_stream_state pa_stream_get_state(pa_stream *s) {
assert(s && s->ref >= 1);
return s->state;
}
-struct pa_context* pa_stream_get_context(struct pa_stream *s) {
+pa_context* pa_stream_get_context(pa_stream *s) {
assert(s && s->ref >= 1);
return s->context;
}
-uint32_t pa_stream_get_index(struct pa_stream *s) {
+uint32_t pa_stream_get_index(pa_stream *s) {
assert(s && s->ref >= 1);
return s->device_index;
}
-void pa_stream_set_state(struct pa_stream *s, enum pa_stream_state st) {
+void pa_stream_set_state(pa_stream *s, pa_stream_state st) {
assert(s && s->ref >= 1);
if (s->state == st)
if (s->channel_valid)
pa_dynarray_put((s->direction == PA_STREAM_PLAYBACK) ? s->context->playback_streams : s->context->record_streams, s->channel, NULL);
- PA_LLIST_REMOVE(struct pa_stream, s->context->streams, s);
+ PA_LLIST_REMOVE(pa_stream, s->context->streams, s);
pa_stream_unref(s);
}
pa_stream_unref(s);
}
-void pa_command_stream_killed(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_context *c = userdata;
- struct pa_stream *s;
+void pa_command_stream_killed(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_context *c = userdata;
+ pa_stream *s;
uint32_t channel;
assert(pd && (command == PA_COMMAND_PLAYBACK_STREAM_KILLED || command == PA_COMMAND_RECORD_STREAM_KILLED) && t && c);
pa_context_unref(c);
}
-void pa_command_request(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_stream *s;
- struct pa_context *c = userdata;
+void pa_command_request(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_stream *s;
+ pa_context *c = userdata;
uint32_t bytes, channel;
assert(pd && command == PA_COMMAND_REQUEST && t && c);
pa_context_unref(c);
}
-static void ipol_callback(struct pa_mainloop_api *m, struct pa_time_event *e, const struct timeval *tv, void *userdata) {
+static void ipol_callback(pa_mainloop_api *m, pa_time_event *e, PA_GCC_UNUSED const struct timeval *tv, void *userdata) {
struct timeval tv2;
- struct pa_stream *s = userdata;
+ pa_stream *s = userdata;
pa_stream_ref(s);
}
-void pa_create_stream_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_stream *s = userdata;
+void pa_create_stream_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_stream *s = userdata;
assert(pd && s && s->state == PA_STREAM_CREATING);
pa_stream_ref(s);
pa_stream_unref(s);
}
-static void create_stream(struct pa_stream *s, const char *dev, const struct pa_buffer_attr *attr, enum pa_stream_flags flags, pa_volume_t volume) {
- struct pa_tagstruct *t;
+static void create_stream(pa_stream *s, const char *dev, const pa_buffer_attr *attr, pa_stream_flags flags, pa_volume_t volume) {
+ pa_tagstruct *t;
uint32_t tag;
assert(s && s->ref >= 1 && s->state == PA_STREAM_DISCONNECTED);
pa_stream_unref(s);
}
-void pa_stream_connect_playback(struct pa_stream *s, const char *dev, const struct pa_buffer_attr *attr, enum pa_stream_flags flags, pa_volume_t volume) {
+void pa_stream_connect_playback(pa_stream *s, const char *dev, const pa_buffer_attr *attr, pa_stream_flags flags, pa_volume_t volume) {
assert(s && s->context->state == PA_CONTEXT_READY && s->ref >= 1);
s->direction = PA_STREAM_PLAYBACK;
create_stream(s, dev, attr, flags, volume);
}
-void pa_stream_connect_record(struct pa_stream *s, const char *dev, const struct pa_buffer_attr *attr, enum pa_stream_flags flags) {
+void pa_stream_connect_record(pa_stream *s, const char *dev, const pa_buffer_attr *attr, pa_stream_flags flags) {
assert(s && s->context->state == PA_CONTEXT_READY && s->ref >= 1);
s->direction = PA_STREAM_RECORD;
create_stream(s, dev, attr, flags, 0);
}
-void pa_stream_write(struct pa_stream *s, const void *data, size_t length, void (*free_cb)(void *p), size_t delta) {
- struct pa_memchunk chunk;
+void pa_stream_write(pa_stream *s, const void *data, size_t length, void (*free_cb)(void *p), size_t delta) {
+ pa_memchunk chunk;
assert(s && s->context && data && length && s->state == PA_STREAM_READY && s->ref >= 1);
if (free_cb) {
s->counter += length;
}
-size_t pa_stream_writable_size(struct pa_stream *s) {
+size_t pa_stream_writable_size(pa_stream *s) {
assert(s && s->ref >= 1);
return s->state == PA_STREAM_READY ? s->requested_bytes : 0;
}
-struct pa_operation * pa_stream_drain(struct pa_stream *s, void (*cb) (struct pa_stream*s, int success, void *userdata), void *userdata) {
- struct pa_operation *o;
- struct pa_tagstruct *t;
+pa_operation * pa_stream_drain(pa_stream *s, void (*cb) (pa_stream*s, int success, void *userdata), void *userdata) {
+ pa_operation *o;
+ pa_tagstruct *t;
uint32_t tag;
assert(s && s->ref >= 1 && s->state == PA_STREAM_READY);
o = pa_operation_new(s->context, s);
assert(o);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
return pa_operation_ref(o);
}
-static void stream_get_latency_info_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_operation *o = userdata;
- struct pa_latency_info i, *p = NULL;
+static void stream_get_latency_info_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_operation *o = userdata;
+ pa_latency_info i, *p = NULL;
struct timeval local, remote, now;
assert(pd && o && o->stream && o->context);
}
if (o->callback) {
- void (*cb)(struct pa_stream *s, const struct pa_latency_info *i, void *userdata) = o->callback;
+ void (*cb)(pa_stream *s, const pa_latency_info *_i, void *_userdata) = (void (*)(pa_stream *s, const pa_latency_info *_i, void *_userdata)) o->callback;
cb(o->stream, p, o->userdata);
}
pa_operation_unref(o);
}
-struct pa_operation* pa_stream_get_latency_info(struct pa_stream *s, void (*cb)(struct pa_stream *p, const struct pa_latency_info*i, void *userdata), void *userdata) {
+pa_operation* pa_stream_get_latency_info(pa_stream *s, void (*cb)(pa_stream *p, const pa_latency_info*i, void *userdata), void *userdata) {
uint32_t tag;
- struct pa_operation *o;
- struct pa_tagstruct *t;
+ pa_operation *o;
+ pa_tagstruct *t;
struct timeval now;
assert(s && s->direction != PA_STREAM_UPLOAD);
o = pa_operation_new(s->context, s);
assert(o);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
return pa_operation_ref(o);
}
-void pa_stream_disconnect_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_stream *s = userdata;
+void pa_stream_disconnect_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_stream *s = userdata;
assert(pd && s && s->ref >= 1);
pa_stream_ref(s);
pa_stream_unref(s);
}
-void pa_stream_disconnect(struct pa_stream *s) {
- struct pa_tagstruct *t;
+void pa_stream_disconnect(pa_stream *s) {
+ pa_tagstruct *t;
uint32_t tag;
assert(s && s->ref >= 1);
pa_stream_unref(s);
}
-void pa_stream_set_read_callback(struct pa_stream *s, void (*cb)(struct pa_stream *p, const void*data, size_t length, void *userdata), void *userdata) {
+void pa_stream_set_read_callback(pa_stream *s, void (*cb)(pa_stream *p, const void*data, size_t length, void *userdata), void *userdata) {
assert(s && s->ref >= 1);
s->read_callback = cb;
s->read_userdata = userdata;
}
-void pa_stream_set_write_callback(struct pa_stream *s, void (*cb)(struct pa_stream *p, size_t length, void *userdata), void *userdata) {
+void pa_stream_set_write_callback(pa_stream *s, void (*cb)(pa_stream *p, size_t length, void *userdata), void *userdata) {
assert(s && s->ref >= 1);
s->write_callback = cb;
s->write_userdata = userdata;
}
-void pa_stream_set_state_callback(struct pa_stream *s, void (*cb)(struct pa_stream *s, void *userdata), void *userdata) {
+void pa_stream_set_state_callback(pa_stream *s, void (*cb)(pa_stream *s, void *userdata), void *userdata) {
assert(s && s->ref >= 1);
s->state_callback = cb;
s->state_userdata = userdata;
}
-void pa_stream_simple_ack_callback(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_operation *o = userdata;
+void pa_stream_simple_ack_callback(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_operation *o = userdata;
int success = 1;
assert(pd && o && o->context && o->ref >= 1);
}
if (o->callback) {
- void (*cb)(struct pa_stream *s, int success, void *userdata) = o->callback;
+ void (*cb)(pa_stream *s, int _success, void *_userdata) = (void (*)(pa_stream *s, int _success, void *_userdata)) o->callback;
cb(o->stream, success, o->userdata);
}
pa_operation_unref(o);
}
-struct pa_operation* pa_stream_cork(struct pa_stream *s, int b, void (*cb) (struct pa_stream*s, int success, void *userdata), void *userdata) {
- struct pa_operation *o;
- struct pa_tagstruct *t;
+pa_operation* pa_stream_cork(pa_stream *s, int b, void (*cb) (pa_stream*s, int success, void *userdata), void *userdata) {
+ pa_operation *o;
+ pa_tagstruct *t;
uint32_t tag;
assert(s && s->ref >= 1 && s->state == PA_STREAM_READY);
o = pa_operation_new(s->context, s);
assert(o);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
return pa_operation_ref(o);
}
-struct pa_operation* pa_stream_send_simple_command(struct pa_stream *s, uint32_t command, void (*cb)(struct pa_stream *s, int success, void *userdata), void *userdata) {
- struct pa_tagstruct *t;
- struct pa_operation *o;
+static pa_operation* stream_send_simple_command(pa_stream *s, uint32_t command, void (*cb)(pa_stream *s, int success, void *userdata), void *userdata) {
+ pa_tagstruct *t;
+ pa_operation *o;
uint32_t tag;
assert(s && s->ref >= 1 && s->state == PA_STREAM_READY);
o = pa_operation_new(s->context, s);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
return pa_operation_ref(o);
}
-struct pa_operation* pa_stream_flush(struct pa_stream *s, void (*cb)(struct pa_stream *s, int success, void *userdata), void *userdata) {
- struct pa_operation *o;
- o = pa_stream_send_simple_command(s, s->direction == PA_STREAM_PLAYBACK ? PA_COMMAND_FLUSH_PLAYBACK_STREAM : PA_COMMAND_FLUSH_RECORD_STREAM, cb, userdata);
+pa_operation* pa_stream_flush(pa_stream *s, void (*cb)(pa_stream *s, int success, void *userdata), void *userdata) {
+ pa_operation *o;
+ o = stream_send_simple_command(s, s->direction == PA_STREAM_PLAYBACK ? PA_COMMAND_FLUSH_PLAYBACK_STREAM : PA_COMMAND_FLUSH_RECORD_STREAM, cb, userdata);
pa_operation_unref(pa_stream_get_latency_info(s, NULL, NULL));
return o;
}
-struct pa_operation* pa_stream_prebuf(struct pa_stream *s, void (*cb)(struct pa_stream *s, int success, void *userdata), void *userdata) {
- struct pa_operation *o;
- o = pa_stream_send_simple_command(s, PA_COMMAND_PREBUF_PLAYBACK_STREAM, cb, userdata);
+pa_operation* pa_stream_prebuf(pa_stream *s, void (*cb)(pa_stream *s, int success, void *userdata), void *userdata) {
+ pa_operation *o;
+ o = stream_send_simple_command(s, PA_COMMAND_PREBUF_PLAYBACK_STREAM, cb, userdata);
pa_operation_unref(pa_stream_get_latency_info(s, NULL, NULL));
return o;
}
-struct pa_operation* pa_stream_trigger(struct pa_stream *s, void (*cb)(struct pa_stream *s, int success, void *userdata), void *userdata) {
- struct pa_operation *o;
- o = pa_stream_send_simple_command(s, PA_COMMAND_TRIGGER_PLAYBACK_STREAM, cb, userdata);
+pa_operation* pa_stream_trigger(pa_stream *s, void (*cb)(pa_stream *s, int success, void *userdata), void *userdata) {
+ pa_operation *o;
+ o = stream_send_simple_command(s, PA_COMMAND_TRIGGER_PLAYBACK_STREAM, cb, userdata);
pa_operation_unref(pa_stream_get_latency_info(s, NULL, NULL));
return o;
}
-struct pa_operation* pa_stream_set_name(struct pa_stream *s, const char *name, void(*cb)(struct pa_stream*c, int success, void *userdata), void *userdata) {
- struct pa_operation *o;
- struct pa_tagstruct *t;
+pa_operation* pa_stream_set_name(pa_stream *s, const char *name, void(*cb)(pa_stream*c, int success, void *userdata), void *userdata) {
+ pa_operation *o;
+ pa_tagstruct *t;
uint32_t tag;
assert(s && s->ref >= 1 && s->state == PA_STREAM_READY && name && s->direction != PA_STREAM_UPLOAD);
o = pa_operation_new(s->context, s);
assert(o);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
return pa_operation_ref(o);
}
-uint64_t pa_stream_get_counter(struct pa_stream *s) {
+uint64_t pa_stream_get_counter(pa_stream *s) {
assert(s);
return s->counter;
}
-pa_usec_t pa_stream_get_time(struct pa_stream *s, const struct pa_latency_info *i) {
+pa_usec_t pa_stream_get_time(pa_stream *s, const pa_latency_info *i) {
pa_usec_t usec;
assert(s);
return usec;
}
-static pa_usec_t time_counter_diff(struct pa_stream *s, pa_usec_t t, pa_usec_t c, int *negative) {
+static pa_usec_t time_counter_diff(pa_stream *s, pa_usec_t t, pa_usec_t c, int *negative) {
assert(s);
if (negative)
return c-t;
}
-pa_usec_t pa_stream_get_latency(struct pa_stream *s, const struct pa_latency_info *i, int *negative) {
+pa_usec_t pa_stream_get_latency(pa_stream *s, const pa_latency_info *i, int *negative) {
pa_usec_t t, c;
assert(s && i);
return time_counter_diff(s, t, c, negative);
}
-const struct pa_sample_spec* pa_stream_get_sample_spec(struct pa_stream *s) {
+const pa_sample_spec* pa_stream_get_sample_spec(pa_stream *s) {
assert(s);
return &s->sample_spec;
}
-void pa_stream_trash_ipol(struct pa_stream *s) {
+void pa_stream_trash_ipol(pa_stream *s) {
assert(s);
if (!s->interpolate)
s->ipol_usec = 0;
}
-pa_usec_t pa_stream_get_interpolated_time(struct pa_stream *s) {
+pa_usec_t pa_stream_get_interpolated_time(pa_stream *s) {
pa_usec_t usec;
assert(s && s->interpolate);
return usec;
}
-pa_usec_t pa_stream_get_interpolated_latency(struct pa_stream *s, int *negative) {
+pa_usec_t pa_stream_get_interpolated_latency(pa_stream *s, int *negative) {
pa_usec_t t, c;
assert(s && s->interpolate);
PA_C_DECL_BEGIN
-/** \struct pa_stream
+/** \pa_stream
* An opaque stream for playback or recording */
-struct pa_stream;
+typedef struct pa_stream pa_stream;
/** Create a new, unconnected stream with the specified name and sample type */
-struct pa_stream* pa_stream_new(struct pa_context *c, const char *name, const struct pa_sample_spec *ss);
+pa_stream* pa_stream_new(pa_context *c, const char *name, const pa_sample_spec *ss);
/** Decrease the reference counter by one */
-void pa_stream_unref(struct pa_stream *s);
+void pa_stream_unref(pa_stream *s);
/** Increase the reference counter by one */
-struct pa_stream *pa_stream_ref(struct pa_stream *s);
+pa_stream *pa_stream_ref(pa_stream *s);
/** Return the current state of the stream */
-enum pa_stream_state pa_stream_get_state(struct pa_stream *p);
+pa_stream_state pa_stream_get_state(pa_stream *p);
/** Return the context this stream is attached to */
-struct pa_context* pa_stream_get_context(struct pa_stream *p);
+pa_context* pa_stream_get_context(pa_stream *p);
/** Return the device (sink input or source output) index this stream is connected to */
-uint32_t pa_stream_get_index(struct pa_stream *s);
+uint32_t pa_stream_get_index(pa_stream *s);
/** Connect the stream to a sink */
-void pa_stream_connect_playback(struct pa_stream *s, const char *dev, const struct pa_buffer_attr *attr, enum pa_stream_flags flags, pa_volume_t volume);
+void pa_stream_connect_playback(pa_stream *s, const char *dev, const pa_buffer_attr *attr, pa_stream_flags flags, pa_volume_t volume);
/** Connect the stream to a source */
-void pa_stream_connect_record(struct pa_stream *s, const char *dev, const struct pa_buffer_attr *attr, enum pa_stream_flags flags);
+void pa_stream_connect_record(pa_stream *s, const char *dev, const pa_buffer_attr *attr, pa_stream_flags flags);
/** Disconnect a stream from a source/sink */
-void pa_stream_disconnect(struct pa_stream *s);
+void pa_stream_disconnect(pa_stream *s);
/** Write some data to the server (for playback sinks), if free_cb is
* non-NULL this routine is called when all data has been written out
* and an internal reference to the specified data is kept, the data
* is not copied. If NULL, the data is copied into an internal
* buffer. */
-void pa_stream_write(struct pa_stream *p /**< The stream to use */,
+void pa_stream_write(pa_stream *p /**< The stream to use */,
const void *data /**< The data to write */,
size_t length /**< The length of the data to write */,
void (*free_cb)(void *p) /**< A cleanup routine for the data or NULL to request an internal copy */,
upload streams. */);
/** Return the amount of bytes that may be written using pa_stream_write() */
-size_t pa_stream_writable_size(struct pa_stream *p);
+size_t pa_stream_writable_size(pa_stream *p);
/** Drain a playback stream */
-struct pa_operation* pa_stream_drain(struct pa_stream *s, void (*cb) (struct pa_stream*s, int success, void *userdata), void *userdata);
+pa_operation* pa_stream_drain(pa_stream *s, void (*cb) (pa_stream*s, int success, void *userdata), void *userdata);
/** Get the playback latency of a stream */
-struct pa_operation* pa_stream_get_latency_info(struct pa_stream *p, void (*cb)(struct pa_stream *p, const struct pa_latency_info *i, void *userdata), void *userdata);
+pa_operation* pa_stream_get_latency_info(pa_stream *p, void (*cb)(pa_stream *p, const pa_latency_info *i, void *userdata), void *userdata);
/** Set the callback function that is called whenever the state of the stream changes */
-void pa_stream_set_state_callback(struct pa_stream *s, void (*cb)(struct pa_stream *s, void *userdata), void *userdata);
+void pa_stream_set_state_callback(pa_stream *s, void (*cb)(pa_stream *s, void *userdata), void *userdata);
/** Set the callback function that is called when new data may be
* written to the stream. */
-void pa_stream_set_write_callback(struct pa_stream *p, void (*cb)(struct pa_stream *p, size_t length, void *userdata), void *userdata);
+void pa_stream_set_write_callback(pa_stream *p, void (*cb)(pa_stream *p, size_t length, void *userdata), void *userdata);
/** Set the callback function that is called when new data is available from the stream */
-void pa_stream_set_read_callback(struct pa_stream *p, void (*cb)(struct pa_stream *p, const void*data, size_t length, void *userdata), void *userdata);
+void pa_stream_set_read_callback(pa_stream *p, void (*cb)(pa_stream *p, const void*data, size_t length, void *userdata), void *userdata);
/** Pause (or resume) playback of this stream temporarily. Available on both playback and recording streams. \since 0.3 */
-struct pa_operation* pa_stream_cork(struct pa_stream *s, int b, void (*cb) (struct pa_stream*s, int success, void *userdata), void *userdata);
+pa_operation* pa_stream_cork(pa_stream *s, int b, void (*cb) (pa_stream*s, int success, void *userdata), void *userdata);
/** Flush the playback buffer of this stream. Most of the time you're
* better off using the parameter delta of pa_stream_write() instead of this
* function. Available on both playback and recording streams. \since 0.3 */
-struct pa_operation* pa_stream_flush(struct pa_stream *s, void (*cb)(struct pa_stream *s, int success, void *userdata), void *userdata);
+pa_operation* pa_stream_flush(pa_stream *s, void (*cb)(pa_stream *s, int success, void *userdata), void *userdata);
/** Reenable prebuffering. Available for playback streams only. \since 0.6 */
-struct pa_operation* pa_stream_prebuf(struct pa_stream *s, void (*cb)(struct pa_stream *s, int success, void *userdata), void *userdata);
+pa_operation* pa_stream_prebuf(pa_stream *s, void (*cb)(pa_stream *s, int success, void *userdata), void *userdata);
/** Request immediate start of playback on this stream. This disables
* prebuffering as specified in the pa_buffer_attr structure. Available for playback streams only. \since
* 0.3 */
-struct pa_operation* pa_stream_trigger(struct pa_stream *s, void (*cb)(struct pa_stream *s, int success, void *userdata), void *userdata);
+pa_operation* pa_stream_trigger(pa_stream *s, void (*cb)(pa_stream *s, int success, void *userdata), void *userdata);
/** Rename the stream. \since 0.5 */
-struct pa_operation* pa_stream_set_name(struct pa_stream *s, const char *name, void(*cb)(struct pa_stream*c, int success, void *userdata), void *userdata);
+pa_operation* pa_stream_set_name(pa_stream *s, const char *name, void(*cb)(pa_stream*c, int success, void *userdata), void *userdata);
/** Return the total number of bytes written to/read from the
* stream. This counter is not reset on pa_stream_flush(), you may do
* this yourself using pa_stream_reset_counter(). \since 0.6 */
-uint64_t pa_stream_get_counter(struct pa_stream *s);
+uint64_t pa_stream_get_counter(pa_stream *s);
/** Return the current playback/recording time. This is based on the
* counter accessible with pa_stream_get_counter(). This function
* requires a pa_latency_info structure as argument, which should be
* acquired using pa_stream_get_latency(). \since 0.6 */
-pa_usec_t pa_stream_get_time(struct pa_stream *s, const struct pa_latency_info *i);
+pa_usec_t pa_stream_get_time(pa_stream *s, const pa_latency_info *i);
/** Return the total stream latency. Thus function requires a
* pa_latency_info structure as argument, which should be aquired
* using pa_stream_get_latency(). In case the stream is a monitoring
* stream the result can be negative, i.e. the captured samples are
* not yet played. In this case *negative is set to 1. \since 0.6 */
-pa_usec_t pa_stream_get_latency(struct pa_stream *s, const struct pa_latency_info *i, int *negative);
+pa_usec_t pa_stream_get_latency(pa_stream *s, const pa_latency_info *i, int *negative);
/** Return the interpolated playback/recording time. Requires the
* PA_STREAM_INTERPOLATE_LATENCY bit set when creating the stream. In
* contrast to pa_stream_get_latency() this function doesn't require
* a whole roundtrip for response. \since 0.6 */
-pa_usec_t pa_stream_get_interpolated_time(struct pa_stream *s);
+pa_usec_t pa_stream_get_interpolated_time(pa_stream *s);
/** Return the interpolated playback/recording latency. Requires the
* PA_STREAM_INTERPOLATE_LATENCY bit set when creating the
* stream. \since 0.6 */
-pa_usec_t pa_stream_get_interpolated_latency(struct pa_stream *s, int *negative);
+pa_usec_t pa_stream_get_interpolated_latency(pa_stream *s, int *negative);
/** Return a pointer to the streams sample specification. \since 0.6 */
-const struct pa_sample_spec* pa_stream_get_sample_spec(struct pa_stream *s);
+const pa_sample_spec* pa_stream_get_sample_spec(pa_stream *s);
PA_C_DECL_END
#include "polyplib-subscribe.h"
#include "polyplib-internal.h"
#include "pstream-util.h"
+#include "gccmacro.h"
-void pa_command_subscribe_event(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
- struct pa_context *c = userdata;
- enum pa_subscription_event_type e;
+void pa_command_subscribe_event(pa_pdispatch *pd, uint32_t command, PA_GCC_UNUSED uint32_t tag, pa_tagstruct *t, void *userdata) {
+ pa_context *c = userdata;
+ pa_subscription_event_type e;
uint32_t index;
assert(pd && command == PA_COMMAND_SUBSCRIBE_EVENT && t && c);
}
-struct pa_operation* pa_context_subscribe(struct pa_context *c, enum pa_subscription_mask m, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata) {
- struct pa_operation *o;
- struct pa_tagstruct *t;
+pa_operation* pa_context_subscribe(pa_context *c, pa_subscription_mask m, void (*cb)(pa_context *c, int success, void *userdata), void *userdata) {
+ pa_operation *o;
+ pa_tagstruct *t;
uint32_t tag;
assert(c);
o = pa_operation_new(c, NULL);
- o->callback = cb;
+ o->callback = (pa_operation_callback) cb;
o->userdata = userdata;
t = pa_tagstruct_new(NULL, 0);
return pa_operation_ref(o);
}
-void pa_context_set_subscribe_callback(struct pa_context *c, void (*cb)(struct pa_context *c, enum pa_subscription_event_type t, uint32_t index, void *userdata), void *userdata) {
+void pa_context_set_subscribe_callback(pa_context *c, void (*cb)(pa_context *c, pa_subscription_event_type t, uint32_t index, void *userdata), void *userdata) {
assert(c);
c->subscribe_callback = cb;
c->subscribe_userdata = userdata;
PA_C_DECL_BEGIN
/** Enable event notification */
-struct pa_operation* pa_context_subscribe(struct pa_context *c, enum pa_subscription_mask m, void (*cb)(struct pa_context *c, int success, void *userdata), void *userdata);
+pa_operation* pa_context_subscribe(pa_context *c, pa_subscription_mask m, void (*cb)(pa_context *c, int success, void *userdata), void *userdata);
/** Set the context specific call back function that is called whenever the state of the daemon changes */
-void pa_context_set_subscribe_callback(struct pa_context *c, void (*cb)(struct pa_context *c, enum pa_subscription_event_type t, uint32_t index, void *userdata), void *userdata);
+void pa_context_set_subscribe_callback(pa_context *c, void (*cb)(pa_context *c, pa_subscription_event_type t, uint32_t index, void *userdata), void *userdata);
PA_C_DECL_END
#include "props.h"
#include "log.h"
-struct pa_property {
+typedef struct pa_property {
char *name; /* Points to memory allocated by the property subsystem */
void *data; /* Points to memory maintained by the caller */
-};
+} pa_property;
/* Allocate a new property object */
-static struct pa_property* property_new(const char *name, void *data) {
- struct pa_property* p;
+static pa_property* property_new(const char *name, void *data) {
+ pa_property* p;
assert(name && data);
- p = pa_xmalloc(sizeof(struct pa_property));
+ p = pa_xmalloc(sizeof(pa_property));
p->name = pa_xstrdup(name);
p->data = data;
}
/* Free a property object */
-static void property_free(struct pa_property *p) {
+static void property_free(pa_property *p) {
assert(p);
pa_xfree(p->name);
pa_xfree(p);
}
-void* pa_property_get(struct pa_core *c, const char *name) {
- struct pa_property *p;
+void* pa_property_get(pa_core *c, const char *name) {
+ pa_property *p;
assert(c && name && c->properties);
if (!(p = pa_hashmap_get(c->properties, name)))
return p->data;
}
-int pa_property_set(struct pa_core *c, const char *name, void *data) {
- struct pa_property *p;
+int pa_property_set(pa_core *c, const char *name, void *data) {
+ pa_property *p;
assert(c && name && data && c->properties);
if (pa_hashmap_get(c->properties, name))
return 0;
}
-int pa_property_remove(struct pa_core *c, const char *name) {
- struct pa_property *p;
+int pa_property_remove(pa_core *c, const char *name) {
+ pa_property *p;
assert(c && name && c->properties);
if (!(p = pa_hashmap_remove(c->properties, name)))
return 0;
}
-void pa_property_init(struct pa_core *c) {
+void pa_property_init(pa_core *c) {
assert(c);
c->properties = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
}
-void pa_property_cleanup(struct pa_core *c) {
+void pa_property_cleanup(pa_core *c) {
assert(c);
if (!c->properties)
return;
- assert(!pa_hashmap_ncontents(c->properties));
+ assert(!pa_hashmap_size(c->properties));
pa_hashmap_free(c->properties, NULL, NULL);
c->properties = NULL;
}
-void pa_property_dump(struct pa_core *c, struct pa_strbuf *s) {
+void pa_property_dump(pa_core *c, pa_strbuf *s) {
void *state = NULL;
- struct pa_property *p;
+ pa_property *p;
assert(c && s);
while ((p = pa_hashmap_iterate(c->properties, &state, NULL)))
pa_strbuf_printf(s, "[%s] -> [%p]\n", p->name, p->data);
}
-int pa_property_replace(struct pa_core *c, const char *name, void *data) {
+int pa_property_replace(pa_core *c, const char *name, void *data) {
assert(c && name);
pa_property_remove(c, name);
* reference counting themselves. */
/* Return a pointer to the value of the specified property. */
-void* pa_property_get(struct pa_core *c, const char *name);
+void* pa_property_get(pa_core *c, const char *name);
/* Set the property 'name' to 'data'. This function fails in case a
* property by this name already exists. The property data is not
* copied or reference counted. This is the caller's job. */
-int pa_property_set(struct pa_core *c, const char *name, void *data);
+int pa_property_set(pa_core *c, const char *name, void *data);
/* Remove the specified property. Return non-zero on failure */
-int pa_property_remove(struct pa_core *c, const char *name);
+int pa_property_remove(pa_core *c, const char *name);
/* A combination of pa_property_remove() and pa_property_set() */
-int pa_property_replace(struct pa_core *c, const char *name, void *data);
+int pa_property_replace(pa_core *c, const char *name, void *data);
/* Free all memory used by the property system */
-void pa_property_cleanup(struct pa_core *c);
+void pa_property_cleanup(pa_core *c);
/* Initialize the properties subsystem */
-void pa_property_init(struct pa_core *c);
+void pa_property_init(pa_core *c);
/* Dump the current set of properties */
-void pa_property_dump(struct pa_core *c, struct pa_strbuf *s);
+void pa_property_dump(pa_core *c, pa_strbuf *s);
#endif
#define MAX_CONNECTIONS 25
struct pa_protocol_cli {
- struct pa_module *module;
- struct pa_core *core;
- struct pa_socket_server*server;
- struct pa_idxset *connections;
+ pa_module *module;
+ pa_core *core;
+ pa_socket_server*server;
+ pa_idxset *connections;
};
-static void cli_eof_cb(struct pa_cli*c, void*userdata) {
- struct pa_protocol_cli *p = userdata;
+static void cli_eof_cb(pa_cli*c, void*userdata) {
+ pa_protocol_cli *p = userdata;
assert(p);
pa_idxset_remove_by_data(p->connections, c, NULL);
pa_cli_free(c);
}
-static void on_connection(struct pa_socket_server*s, struct pa_iochannel *io, void *userdata) {
- struct pa_protocol_cli *p = userdata;
- struct pa_cli *c;
+static void on_connection(pa_socket_server*s, pa_iochannel *io, void *userdata) {
+ pa_protocol_cli *p = userdata;
+ pa_cli *c;
assert(s && io && p);
- if (pa_idxset_ncontents(p->connections)+1 > MAX_CONNECTIONS) {
+ if (pa_idxset_size(p->connections)+1 > MAX_CONNECTIONS) {
pa_log(__FILE__": Warning! Too many connections (%u), dropping incoming connection.\n", MAX_CONNECTIONS);
pa_iochannel_free(io);
return;
pa_idxset_put(p->connections, c, NULL);
}
-struct pa_protocol_cli* pa_protocol_cli_new(struct pa_core *core, struct pa_socket_server *server, struct pa_module *m, struct pa_modargs *ma) {
- struct pa_protocol_cli* p;
+pa_protocol_cli* pa_protocol_cli_new(pa_core *core, pa_socket_server *server, pa_module *m, PA_GCC_UNUSED pa_modargs *ma) {
+ pa_protocol_cli* p;
assert(core && server);
- p = pa_xmalloc(sizeof(struct pa_protocol_cli));
+ p = pa_xmalloc(sizeof(pa_protocol_cli));
p->module = m;
p->core = core;
p->server = server;
return p;
}
-static void free_connection(void *p, void *userdata) {
+static void free_connection(void *p, PA_GCC_UNUSED void *userdata) {
assert(p);
pa_cli_free(p);
}
-void pa_protocol_cli_free(struct pa_protocol_cli *p) {
+void pa_protocol_cli_free(pa_protocol_cli *p) {
assert(p);
pa_idxset_free(p->connections, free_connection, NULL);
#include "module.h"
#include "modargs.h"
-struct pa_protocol_cli;
+typedef struct pa_protocol_cli pa_protocol_cli;
-struct pa_protocol_cli* pa_protocol_cli_new(struct pa_core *core, struct pa_socket_server *server, struct pa_module *m, struct pa_modargs *ma);
-void pa_protocol_cli_free(struct pa_protocol_cli *n);
+pa_protocol_cli* pa_protocol_cli_new(pa_core *core, pa_socket_server *server, pa_module *m, pa_modargs *ma);
+void pa_protocol_cli_free(pa_protocol_cli *n);
#endif
#include "namereg.h"
#include "xmalloc.h"
#include "log.h"
+#include "util.h"
/* Don't accept more connection than this */
#define MAX_CONNECTIONS 10
struct connection {
uint32_t index;
int dead;
- struct pa_protocol_esound *protocol;
- struct pa_iochannel *io;
- struct pa_client *client;
+ pa_protocol_esound *protocol;
+ pa_iochannel *io;
+ pa_client *client;
int authorized, swap_byte_order;
void *write_data;
size_t write_data_alloc, write_data_index, write_data_length;
size_t read_data_alloc, read_data_length;
esd_proto_t request;
esd_client_state_t state;
- struct pa_sink_input *sink_input;
- struct pa_source_output *source_output;
- struct pa_memblockq *input_memblockq, *output_memblockq;
- struct pa_defer_event *defer_event;
+ pa_sink_input *sink_input;
+ pa_source_output *source_output;
+ pa_memblockq *input_memblockq, *output_memblockq;
+ pa_defer_event *defer_event;
struct {
- struct pa_memblock *current_memblock;
+ pa_memblock *current_memblock;
size_t memblock_index, fragment_size;
} playback;
struct {
- struct pa_memchunk memchunk;
+ pa_memchunk memchunk;
char *name;
- struct pa_sample_spec sample_spec;
+ pa_sample_spec sample_spec;
} scache;
- struct pa_time_event *auth_timeout_event;
+ pa_time_event *auth_timeout_event;
};
struct pa_protocol_esound {
int public;
- struct pa_module *module;
- struct pa_core *core;
- struct pa_socket_server *server;
- struct pa_idxset *connections;
+ pa_module *module;
+ pa_core *core;
+ pa_socket_server *server;
+ pa_idxset *connections;
char *sink_name, *source_name;
unsigned n_player;
uint8_t esd_key[ESD_KEY_LEN];
const char *description;
} esd_proto_handler_info_t;
-static void sink_input_drop_cb(struct pa_sink_input *i, const struct pa_memchunk *chunk, size_t length);
-static int sink_input_peek_cb(struct pa_sink_input *i, struct pa_memchunk *chunk);
-static void sink_input_kill_cb(struct pa_sink_input *i);
-static pa_usec_t sink_input_get_latency_cb(struct pa_sink_input *i);
-static pa_usec_t source_output_get_latency_cb(struct pa_source_output *o);
+static void sink_input_drop_cb(pa_sink_input *i, const pa_memchunk *chunk, size_t length);
+static int sink_input_peek_cb(pa_sink_input *i, pa_memchunk *chunk);
+static void sink_input_kill_cb(pa_sink_input *i);
+static pa_usec_t sink_input_get_latency_cb(pa_sink_input *i);
+static pa_usec_t source_output_get_latency_cb(pa_source_output *o);
-static void source_output_push_cb(struct pa_source_output *o, const struct pa_memchunk *chunk);
-static void source_output_kill_cb(struct pa_source_output *o);
+static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk);
+static void source_output_kill_cb(pa_source_output *o);
static int esd_proto_connect(struct connection *c, esd_proto_t request, const void *data, size_t length);
static int esd_proto_stream_play(struct connection *c, esd_proto_t request, const void *data, size_t length);
return (uint8_t*) c->write_data+i;
}
-static void format_esd2native(int format, int swap_bytes, struct pa_sample_spec *ss) {
+static void format_esd2native(int format, int swap_bytes, pa_sample_spec *ss) {
assert(ss);
ss->channels = ((format & ESD_MASK_CHAN) == ESD_STEREO) ? 2 : 1;
ss->format = PA_SAMPLE_U8;
}
-static int format_native2esd(struct pa_sample_spec *ss) {
+static int format_native2esd(pa_sample_spec *ss) {
int format = 0;
format = (ss->format == PA_SAMPLE_U8) ? ESD_BITS8 : ESD_BITS16;
/*** esound commands ***/
-static int esd_proto_connect(struct connection *c, esd_proto_t request, const void *data, size_t length) {
+static int esd_proto_connect(struct connection *c, PA_GCC_UNUSED esd_proto_t request, const void *data, size_t length) {
uint32_t ekey;
int *ok;
assert(length == (ESD_KEY_LEN + sizeof(uint32_t)));
}
}
- ekey = *(uint32_t*)((uint8_t*) data+ESD_KEY_LEN);
+ ekey = *(const uint32_t*)((const uint8_t*) data+ESD_KEY_LEN);
if (ekey == ESD_ENDIAN_KEY)
c->swap_byte_order = 0;
else if (ekey == ESD_SWAP_ENDIAN_KEY)
return 0;
}
-static int esd_proto_stream_play(struct connection *c, esd_proto_t request, const void *data, size_t length) {
+static int esd_proto_stream_play(struct connection *c, PA_GCC_UNUSED esd_proto_t request, const void *data, size_t length) {
char name[ESD_NAME_MAX];
int format, rate;
- struct pa_sink *sink;
- struct pa_sample_spec ss;
+ pa_sink *sink;
+ pa_sample_spec ss;
size_t l;
assert(c && length == (sizeof(int)*2+ESD_NAME_MAX));
- format = maybe_swap_endian_32(c->swap_byte_order, *(int*)data);
- rate = maybe_swap_endian_32(c->swap_byte_order, *((int*)data + 1));
+ format = maybe_swap_endian_32(c->swap_byte_order, *(const int*)data);
+ rate = maybe_swap_endian_32(c->swap_byte_order, *((const int*)data + 1));
ss.rate = rate;
format_esd2native(format, c->swap_byte_order, &ss);
return -1;
}
- strncpy(name, (char*) data + sizeof(int)*2, sizeof(name));
+ strncpy(name, (const char*) data + sizeof(int)*2, sizeof(name));
name[sizeof(name)-1] = 0;
pa_client_set_name(c->client, name);
static int esd_proto_stream_record(struct connection *c, esd_proto_t request, const void *data, size_t length) {
char name[ESD_NAME_MAX];
int format, rate;
- struct pa_source *source;
- struct pa_sample_spec ss;
+ pa_source *source;
+ pa_sample_spec ss;
size_t l;
assert(c && length == (sizeof(int)*2+ESD_NAME_MAX));
- format = maybe_swap_endian_32(c->swap_byte_order, *(int*)data);
- rate = maybe_swap_endian_32(c->swap_byte_order, *((int*)data + 1));
+ format = maybe_swap_endian_32(c->swap_byte_order, *(const int*)data);
+ rate = maybe_swap_endian_32(c->swap_byte_order, *((const int*)data + 1));
ss.rate = rate;
format_esd2native(format, c->swap_byte_order, &ss);
}
if (request == ESD_PROTO_STREAM_MON) {
- struct pa_sink* sink;
+ pa_sink* sink;
if (!(sink = pa_namereg_get(c->protocol->core, c->protocol->sink_name, PA_NAMEREG_SINK, 1))) {
pa_log(__FILE__": no such sink.\n");
}
}
- strncpy(name, (char*) data + sizeof(int)*2, sizeof(name));
+ strncpy(name, (const char*) data + sizeof(int)*2, sizeof(name));
name[sizeof(name)-1] = 0;
pa_client_set_name(c->client, name);
return 0;
}
-static int esd_proto_get_latency(struct connection *c, esd_proto_t request, const void *data, size_t length) {
- struct pa_sink *sink;
+static int esd_proto_get_latency(struct connection *c, PA_GCC_UNUSED esd_proto_t request, const void *data, size_t length) {
+ pa_sink *sink;
int latency, *lag;
assert(c && !data && length == 0);
return 0;
}
-static int esd_proto_server_info(struct connection *c, esd_proto_t request, const void *data, size_t length) {
+static int esd_proto_server_info(struct connection *c, PA_GCC_UNUSED esd_proto_t request, const void *data, size_t length) {
int rate = 44100, format = ESD_STEREO|ESD_BITS16;
int *response;
- struct pa_sink *sink;
+ pa_sink *sink;
assert(c && data && length == sizeof(int));
if ((sink = pa_namereg_get(c->protocol->core, c->protocol->sink_name, PA_NAMEREG_SINK, 1))) {
uint8_t *response;
size_t t, k, s;
struct connection *conn;
- size_t index = PA_IDXSET_INVALID;
+ size_t idx = PA_IDXSET_INVALID;
unsigned nsamples;
assert(c && data && length == sizeof(int));
k = sizeof(int)*5+ESD_NAME_MAX;
s = sizeof(int)*6+ESD_NAME_MAX;
- nsamples = c->protocol->core->scache ? pa_idxset_ncontents(c->protocol->core->scache) : 0;
+ nsamples = c->protocol->core->scache ? pa_idxset_size(c->protocol->core->scache) : 0;
response = connection_write(c, (t = s*(nsamples+1) + k*(c->protocol->n_player+1)));
assert(k);
- for (conn = pa_idxset_first(c->protocol->connections, &index); conn; conn = pa_idxset_next(c->protocol->connections, &index)) {
+ for (conn = pa_idxset_first(c->protocol->connections, &idx); conn; conn = pa_idxset_next(c->protocol->connections, &idx)) {
int format = ESD_BITS16 | ESD_STEREO, rate = 44100, volume = 0xFF;
if (conn->state != ESD_STREAMING_DATA)
t -= k;
if (nsamples) {
- struct pa_scache_entry *ce;
+ pa_scache_entry *ce;
- index = PA_IDXSET_INVALID;
- for (ce = pa_idxset_first(c->protocol->core->scache, &index); ce; ce = pa_idxset_next(c->protocol->core->scache, &index)) {
+ idx = PA_IDXSET_INVALID;
+ for (ce = pa_idxset_first(c->protocol->core->scache, &idx); ce; ce = pa_idxset_next(c->protocol->core->scache, &idx)) {
assert(t >= s*2);
/* id */
return 0;
}
-static int esd_proto_stream_pan(struct connection *c, esd_proto_t request, const void *data, size_t length) {
+static int esd_proto_stream_pan(struct connection *c, PA_GCC_UNUSED esd_proto_t request, const void *data, size_t length) {
int *ok;
- uint32_t index, volume;
+ uint32_t idx, volume;
struct connection *conn;
assert(c && data && length == sizeof(int)*3);
- index = (uint32_t) maybe_swap_endian_32(c->swap_byte_order, *(int*)data)-1;
- volume = (uint32_t) maybe_swap_endian_32(c->swap_byte_order, *((int*)data + 1));
+ idx = (uint32_t) maybe_swap_endian_32(c->swap_byte_order, *(const int*)data)-1;
+ volume = (uint32_t) maybe_swap_endian_32(c->swap_byte_order, *((const int*)data + 1));
volume = (volume*0x100)/0xFF;
ok = connection_write(c, sizeof(int));
assert(ok);
- if ((conn = pa_idxset_get_by_index(c->protocol->connections, index))) {
+ if ((conn = pa_idxset_get_by_index(c->protocol->connections, idx))) {
assert(conn->sink_input);
conn->sink_input->volume = volume;
*ok = 1;
return 0;
}
-static int esd_proto_sample_cache(struct connection *c, esd_proto_t request, const void *data, size_t length) {
- struct pa_sample_spec ss;
+static int esd_proto_sample_cache(struct connection *c, PA_GCC_UNUSED esd_proto_t request, const void *data, size_t length) {
+ pa_sample_spec ss;
int format, rate;
size_t sc_length;
- uint32_t index;
+ uint32_t idx;
int *ok;
char name[ESD_NAME_MAX+sizeof(SCACHE_PREFIX)-1];
assert(c && data && length == (ESD_NAME_MAX+3*sizeof(int)));
- format = maybe_swap_endian_32(c->swap_byte_order, *(int*)data);
- rate = maybe_swap_endian_32(c->swap_byte_order, *((int*)data + 1));
+ format = maybe_swap_endian_32(c->swap_byte_order, *(const int*)data);
+ rate = maybe_swap_endian_32(c->swap_byte_order, *((const int*)data + 1));
ss.rate = rate;
format_esd2native(format, c->swap_byte_order, &ss);
- sc_length = (size_t) maybe_swap_endian_32(c->swap_byte_order, (*((int*)data + 2)));
+ sc_length = (size_t) maybe_swap_endian_32(c->swap_byte_order, (*((const int*)data + 2)));
if (sc_length >= MAX_CACHE_SAMPLE_SIZE)
return -1;
strcpy(name, SCACHE_PREFIX);
- strncpy(name+sizeof(SCACHE_PREFIX)-1, (char*) data+3*sizeof(int), ESD_NAME_MAX);
+ strncpy(name+sizeof(SCACHE_PREFIX)-1, (const char*) data+3*sizeof(int), ESD_NAME_MAX);
name[sizeof(name)-1] = 0;
assert(!c->scache.memchunk.memblock);
c->state = ESD_CACHING_SAMPLE;
- pa_scache_add_item(c->protocol->core, c->scache.name, NULL, NULL, &index);
+ pa_scache_add_item(c->protocol->core, c->scache.name, NULL, NULL, &idx);
ok = connection_write(c, sizeof(int));
assert(ok);
- *ok = index+1;
+ *ok = idx+1;
return 0;
}
-static int esd_proto_sample_get_id(struct connection *c, esd_proto_t request, const void *data, size_t length) {
+static int esd_proto_sample_get_id(struct connection *c, PA_GCC_UNUSED esd_proto_t request, const void *data, size_t length) {
int *ok;
- uint32_t index;
+ uint32_t idx;
char name[ESD_NAME_MAX+sizeof(SCACHE_PREFIX)-1];
assert(c && data && length == ESD_NAME_MAX);
strncpy(name+sizeof(SCACHE_PREFIX)-1, data, ESD_NAME_MAX);
name[sizeof(name)-1] = 0;
- if ((index = pa_scache_get_id_by_name(c->protocol->core, name)) != PA_IDXSET_INVALID)
- *ok = (int) index +1;
+ if ((idx = pa_scache_get_id_by_name(c->protocol->core, name)) != PA_IDXSET_INVALID)
+ *ok = (int) idx +1;
return 0;
}
static int esd_proto_sample_free_or_play(struct connection *c, esd_proto_t request, const void *data, size_t length) {
int *ok;
const char *name;
- uint32_t index;
+ uint32_t idx;
assert(c && data && length == sizeof(int));
- index = (uint32_t) maybe_swap_endian_32(c->swap_byte_order, *(int*)data)-1;
+ idx = (uint32_t) maybe_swap_endian_32(c->swap_byte_order, *(const int*)data)-1;
ok = connection_write(c, sizeof(int));
assert(ok);
*ok = 0;
- if ((name = pa_scache_get_name_by_id(c->protocol->core, index))) {
+ if ((name = pa_scache_get_name_by_id(c->protocol->core, idx))) {
if (request == ESD_PROTO_SAMPLE_PLAY) {
- struct pa_sink *sink;
+ pa_sink *sink;
if ((sink = pa_namereg_get(c->protocol->core, c->protocol->sink_name, PA_NAMEREG_SINK, 1)))
if (pa_scache_play_item(c->protocol->core, name, sink, PA_VOLUME_NORM) >= 0)
- *ok = (int) index+1;
+ *ok = (int) idx+1;
} else {
assert(request == ESD_PROTO_SAMPLE_FREE);
if (pa_scache_remove_item(c->protocol->core, name) >= 0)
- *ok = (int) index+1;
+ *ok = (int) idx+1;
}
}
return 0;
}
-static int esd_proto_standby_or_resume(struct connection *c, esd_proto_t request, const void *data, size_t length) {
+static int esd_proto_standby_or_resume(struct connection *c, PA_GCC_UNUSED esd_proto_t request, PA_GCC_UNUSED const void *data, PA_GCC_UNUSED size_t length) {
int *ok;
ok = connection_write(c, sizeof(int)*2);
assert(ok);
/*** client callbacks ***/
-static void client_kill_cb(struct pa_client *c) {
+static void client_kill_cb(pa_client *c) {
assert(c && c->userdata);
connection_free(c->userdata);
}
assert(c->scache.memchunk.index <= c->scache.memchunk.length);
if (c->scache.memchunk.index == c->scache.memchunk.length) {
- uint32_t index;
+ uint32_t idx;
int *ok;
c->scache.memchunk.index = 0;
- pa_scache_add_item(c->protocol->core, c->scache.name, &c->scache.sample_spec, &c->scache.memchunk, &index);
+ pa_scache_add_item(c->protocol->core, c->scache.name, &c->scache.sample_spec, &c->scache.memchunk, &idx);
pa_memblock_unref(c->scache.memchunk.memblock);
c->scache.memchunk.memblock = NULL;
ok = connection_write(c, sizeof(int));
assert(ok);
- *ok = index+1;
+ *ok = idx+1;
}
} else if (c->state == ESD_STREAMING_DATA && c->sink_input) {
- struct pa_memchunk chunk;
+ pa_memchunk chunk;
ssize_t r;
size_t l;
c->write_data_length = c->write_data_index = 0;
} else if (c->state == ESD_STREAMING_DATA && c->source_output) {
- struct pa_memchunk chunk;
+ pa_memchunk chunk;
ssize_t r;
assert(c->output_memblockq);
connection_free(c);
}
-static void io_callback(struct pa_iochannel*io, void *userdata) {
+static void io_callback(pa_iochannel*io, void *userdata) {
struct connection *c = userdata;
assert(io && c && c->io == io);
/*** defer callback ***/
-static void defer_callback(struct pa_mainloop_api*a, struct pa_defer_event *e, void *userdata) {
+static void defer_callback(pa_mainloop_api*a, pa_defer_event *e, void *userdata) {
struct connection *c = userdata;
assert(a && c && c->defer_event == e);
/*** sink_input callbacks ***/
-static int sink_input_peek_cb(struct pa_sink_input *i, struct pa_memchunk *chunk) {
+static int sink_input_peek_cb(pa_sink_input *i, pa_memchunk *chunk) {
struct connection*c;
assert(i && i->userdata && chunk);
c = i->userdata;
return 0;
}
-static void sink_input_drop_cb(struct pa_sink_input *i, const struct pa_memchunk *chunk, size_t length) {
+static void sink_input_drop_cb(pa_sink_input *i, const pa_memchunk *chunk, size_t length) {
struct connection*c = i->userdata;
assert(i && c && length);
/* assert(pa_memblockq_get_length(c->input_memblockq) > 2048); */
}
-static void sink_input_kill_cb(struct pa_sink_input *i) {
+static void sink_input_kill_cb(pa_sink_input *i) {
assert(i && i->userdata);
connection_free((struct connection *) i->userdata);
}
-static pa_usec_t sink_input_get_latency_cb(struct pa_sink_input *i) {
+static pa_usec_t sink_input_get_latency_cb(pa_sink_input *i) {
struct connection*c = i->userdata;
assert(i && c);
return pa_bytes_to_usec(pa_memblockq_get_length(c->input_memblockq), &c->sink_input->sample_spec);
/*** source_output callbacks ***/
-static void source_output_push_cb(struct pa_source_output *o, const struct pa_memchunk *chunk) {
+static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk) {
struct connection *c = o->userdata;
assert(o && c && chunk);
c->protocol->core->mainloop->defer_enable(c->defer_event, 1);
}
-static void source_output_kill_cb(struct pa_source_output *o) {
+static void source_output_kill_cb(pa_source_output *o) {
assert(o && o->userdata);
connection_free((struct connection *) o->userdata);
}
-static pa_usec_t source_output_get_latency_cb(struct pa_source_output *o) {
+static pa_usec_t source_output_get_latency_cb(pa_source_output *o) {
struct connection*c = o->userdata;
assert(o && c);
return pa_bytes_to_usec(pa_memblockq_get_length(c->output_memblockq), &c->source_output->sample_spec);
/*** socket server callback ***/
-static void auth_timeout(struct pa_mainloop_api*m, struct pa_time_event *e, const struct timeval *tv, void *userdata) {
+static void auth_timeout(pa_mainloop_api*m, pa_time_event *e, const struct timeval *tv, void *userdata) {
struct connection *c = userdata;
assert(m && tv && c && c->auth_timeout_event == e);
connection_free(c);
}
-static void on_connection(struct pa_socket_server*s, struct pa_iochannel *io, void *userdata) {
+static void on_connection(pa_socket_server*s, pa_iochannel *io, void *userdata) {
struct connection *c;
- struct pa_protocol_esound *p = userdata;
+ pa_protocol_esound *p = userdata;
char cname[256];
assert(s && io && p);
- if (pa_idxset_ncontents(p->connections)+1 > MAX_CONNECTIONS) {
+ if (pa_idxset_size(p->connections)+1 > MAX_CONNECTIONS) {
pa_log(__FILE__": Warning! Too many connections (%u), dropping incoming connection.\n", MAX_CONNECTIONS);
pa_iochannel_free(io);
return;
/*** entry points ***/
-struct pa_protocol_esound* pa_protocol_esound_new(struct pa_core*core, struct pa_socket_server *server, struct pa_module *m, struct pa_modargs *ma) {
- struct pa_protocol_esound *p;
+pa_protocol_esound* pa_protocol_esound_new(pa_core*core, pa_socket_server *server, pa_module *m, pa_modargs *ma) {
+ pa_protocol_esound *p;
int public = 0;
assert(core && server && ma);
- p = pa_xmalloc(sizeof(struct pa_protocol_esound));
+ p = pa_xmalloc(sizeof(pa_protocol_esound));
if (pa_modargs_get_value_boolean(ma, "public", &public) < 0) {
pa_log(__FILE__": public= expects a boolean argument.\n");
return p;
}
-void pa_protocol_esound_free(struct pa_protocol_esound *p) {
+void pa_protocol_esound_free(pa_protocol_esound *p) {
struct connection *c;
assert(p);
#include "module.h"
#include "modargs.h"
-struct pa_protocol_esound;
+typedef struct pa_protocol_esound pa_protocol_esound;
-struct pa_protocol_esound* pa_protocol_esound_new(struct pa_core*core, struct pa_socket_server *server, struct pa_module *m, struct pa_modargs *ma);
-void pa_protocol_esound_free(struct pa_protocol_esound *p);
+pa_protocol_esound* pa_protocol_esound_new(pa_core*core, pa_socket_server *server, pa_module *m, pa_modargs *ma);
+void pa_protocol_esound_free(pa_protocol_esound *p);
#endif
#define URL_STATUS "/status"
struct connection {
- struct pa_protocol_http *protocol;
- struct pa_ioline *line;
+ pa_protocol_http *protocol;
+ pa_ioline *line;
enum { REQUEST_LINE, MIME_HEADER, DATA } state;
char *url;
};
struct pa_protocol_http {
- struct pa_module *module;
- struct pa_core *core;
- struct pa_socket_server*server;
- struct pa_idxset *connections;
+ pa_module *module;
+ pa_core *core;
+ pa_socket_server*server;
+ pa_idxset *connections;
};
static void http_response(struct connection *c, int code, const char *msg, const char *mime) {
pa_xfree(c);
}
-static void line_callback(struct pa_ioline *line, const char *s, void *userdata) {
+static void line_callback(pa_ioline *line, const char *s, void *userdata) {
struct connection *c = userdata;
assert(line);
assert(c);
pa_ioline_defer_close(c->line);
} else if (!strcmp(c->url, URL_STATUS)) {
- char *s;
+ char *r;
http_response(c, 200, "OK", "text/plain");
- s = pa_full_status_string(c->protocol->core);
- pa_ioline_puts(c->line, s);
- pa_xfree(s);
+ r = pa_full_status_string(c->protocol->core);
+ pa_ioline_puts(c->line, r);
+ pa_xfree(r);
pa_ioline_defer_close(c->line);
} else
internal_server_error(c);
}
-static void on_connection(struct pa_socket_server*s, struct pa_iochannel *io, void *userdata) {
- struct pa_protocol_http *p = userdata;
+static void on_connection(pa_socket_server*s, pa_iochannel *io, void *userdata) {
+ pa_protocol_http *p = userdata;
struct connection *c;
assert(s && io && p);
- if (pa_idxset_ncontents(p->connections)+1 > MAX_CONNECTIONS) {
+ if (pa_idxset_size(p->connections)+1 > MAX_CONNECTIONS) {
pa_log_warn(__FILE__": Warning! Too many connections (%u), dropping incoming connection.\n", MAX_CONNECTIONS);
pa_iochannel_free(io);
return;
pa_idxset_put(p->connections, c, NULL);
}
-struct pa_protocol_http* pa_protocol_http_new(struct pa_core *core, struct pa_socket_server *server, struct pa_module *m, struct pa_modargs *ma) {
- struct pa_protocol_http* p;
+pa_protocol_http* pa_protocol_http_new(pa_core *core, pa_socket_server *server, pa_module *m, PA_GCC_UNUSED pa_modargs *ma) {
+ pa_protocol_http* p;
assert(core && server);
- p = pa_xmalloc(sizeof(struct pa_protocol_http));
+ p = pa_xmalloc(sizeof(pa_protocol_http));
p->module = m;
p->core = core;
p->server = server;
return p;
}
-static void free_connection(void *p, void *userdata) {
+static void free_connection(void *p, PA_GCC_UNUSED void *userdata) {
assert(p);
connection_free(p, 0);
}
-void pa_protocol_http_free(struct pa_protocol_http *p) {
+void pa_protocol_http_free(pa_protocol_http *p) {
assert(p);
pa_idxset_free(p->connections, free_connection, NULL);
#include "module.h"
#include "modargs.h"
-struct pa_protocol_http;
+typedef struct pa_protocol_http pa_protocol_http;
-struct pa_protocol_http* pa_protocol_http_new(struct pa_core *core, struct pa_socket_server *server, struct pa_module *m, struct pa_modargs *ma);
-void pa_protocol_http_free(struct pa_protocol_http *n);
+pa_protocol_http* pa_protocol_http_new(pa_core *core, pa_socket_server *server, pa_module *m, pa_modargs *ma);
+void pa_protocol_http_free(pa_protocol_http *n);
#endif
struct record_stream {
struct connection *connection;
uint32_t index;
- struct pa_source_output *source_output;
- struct pa_memblockq *memblockq;
+ pa_source_output *source_output;
+ pa_memblockq *memblockq;
size_t fragment_size;
};
int type;
struct connection *connection;
uint32_t index;
- struct pa_sink_input *sink_input;
- struct pa_memblockq *memblockq;
+ pa_sink_input *sink_input;
+ pa_memblockq *memblockq;
size_t requested_bytes;
int drain_request;
uint32_t drain_tag;
int type;
struct connection *connection;
uint32_t index;
- struct pa_memchunk memchunk;
+ pa_memchunk memchunk;
size_t length;
char *name;
- struct pa_sample_spec sample_spec;
+ pa_sample_spec sample_spec;
};
struct output_stream {
struct connection {
int authorized;
- struct pa_protocol_native *protocol;
- struct pa_client *client;
- struct pa_pstream *pstream;
- struct pa_pdispatch *pdispatch;
- struct pa_idxset *record_streams, *output_streams;
+ pa_protocol_native *protocol;
+ pa_client *client;
+ pa_pstream *pstream;
+ pa_pdispatch *pdispatch;
+ pa_idxset *record_streams, *output_streams;
uint32_t rrobin_index;
- struct pa_subscription *subscription;
- struct pa_time_event *auth_timeout_event;
+ pa_subscription *subscription;
+ pa_time_event *auth_timeout_event;
};
struct pa_protocol_native {
- struct pa_module *module;
+ pa_module *module;
int public;
- struct pa_core *core;
- struct pa_socket_server *server;
- struct pa_idxset *connections;
+ pa_core *core;
+ pa_socket_server *server;
+ pa_idxset *connections;
uint8_t auth_cookie[PA_NATIVE_COOKIE_LENGTH];
int auth_cookie_in_property;
};
-static int sink_input_peek_cb(struct pa_sink_input *i, struct pa_memchunk *chunk);
-static void sink_input_drop_cb(struct pa_sink_input *i, const struct pa_memchunk *chunk, size_t length);
-static void sink_input_kill_cb(struct pa_sink_input *i);
-static pa_usec_t sink_input_get_latency_cb(struct pa_sink_input *i);
+static int sink_input_peek_cb(pa_sink_input *i, pa_memchunk *chunk);
+static void sink_input_drop_cb(pa_sink_input *i, const pa_memchunk *chunk, size_t length);
+static void sink_input_kill_cb(pa_sink_input *i);
+static pa_usec_t sink_input_get_latency_cb(pa_sink_input *i);
static void request_bytes(struct playback_stream*s);
-static void source_output_kill_cb(struct pa_source_output *o);
-static void source_output_push_cb(struct pa_source_output *o, const struct pa_memchunk *chunk);
-static pa_usec_t source_output_get_latency_cb(struct pa_source_output *o);
-
-static void command_exit(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_create_playback_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_drain_playback_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_create_record_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_delete_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_auth(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_set_client_name(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_lookup(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_stat(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_get_playback_latency(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_get_record_latency(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_create_upload_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_finish_upload_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_play_sample(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_remove_sample(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_get_info(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_get_info_list(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_get_server_info(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_subscribe(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_set_volume(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_cork_playback_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_flush_or_trigger_playback_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_set_default_sink_or_source(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_set_stream_name(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_kill(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_load_module(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_unload_module(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_add_autoload(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_remove_autoload(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_get_autoload_info(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_get_autoload_info_list(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_cork_record_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-static void command_flush_record_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata);
-
-static const struct pa_pdispatch_command command_table[PA_COMMAND_MAX] = {
- [PA_COMMAND_ERROR] = { NULL },
- [PA_COMMAND_TIMEOUT] = { NULL },
- [PA_COMMAND_REPLY] = { NULL },
- [PA_COMMAND_CREATE_PLAYBACK_STREAM] = { command_create_playback_stream },
- [PA_COMMAND_DELETE_PLAYBACK_STREAM] = { command_delete_stream },
- [PA_COMMAND_DRAIN_PLAYBACK_STREAM] = { command_drain_playback_stream },
- [PA_COMMAND_CREATE_RECORD_STREAM] = { command_create_record_stream },
- [PA_COMMAND_DELETE_RECORD_STREAM] = { command_delete_stream },
- [PA_COMMAND_AUTH] = { command_auth },
- [PA_COMMAND_REQUEST] = { NULL },
- [PA_COMMAND_EXIT] = { command_exit },
- [PA_COMMAND_SET_CLIENT_NAME] = { command_set_client_name },
- [PA_COMMAND_LOOKUP_SINK] = { command_lookup },
- [PA_COMMAND_LOOKUP_SOURCE] = { command_lookup },
- [PA_COMMAND_STAT] = { command_stat },
- [PA_COMMAND_GET_PLAYBACK_LATENCY] = { command_get_playback_latency },
- [PA_COMMAND_GET_RECORD_LATENCY] = { command_get_record_latency },
- [PA_COMMAND_CREATE_UPLOAD_STREAM] = { command_create_upload_stream },
- [PA_COMMAND_DELETE_UPLOAD_STREAM] = { command_delete_stream },
- [PA_COMMAND_FINISH_UPLOAD_STREAM] = { command_finish_upload_stream },
- [PA_COMMAND_PLAY_SAMPLE] = { command_play_sample },
- [PA_COMMAND_REMOVE_SAMPLE] = { command_remove_sample },
- [PA_COMMAND_GET_SINK_INFO] = { command_get_info },
- [PA_COMMAND_GET_SOURCE_INFO] = { command_get_info },
- [PA_COMMAND_GET_CLIENT_INFO] = { command_get_info },
- [PA_COMMAND_GET_MODULE_INFO] = { command_get_info },
- [PA_COMMAND_GET_SINK_INPUT_INFO] = { command_get_info },
- [PA_COMMAND_GET_SOURCE_OUTPUT_INFO] = { command_get_info },
- [PA_COMMAND_GET_SAMPLE_INFO] = { command_get_info },
- [PA_COMMAND_GET_SINK_INFO_LIST] = { command_get_info_list },
- [PA_COMMAND_GET_SOURCE_INFO_LIST] = { command_get_info_list },
- [PA_COMMAND_GET_MODULE_INFO_LIST] = { command_get_info_list },
- [PA_COMMAND_GET_CLIENT_INFO_LIST] = { command_get_info_list },
- [PA_COMMAND_GET_SINK_INPUT_INFO_LIST] = { command_get_info_list },
- [PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST] = { command_get_info_list },
- [PA_COMMAND_GET_SAMPLE_INFO_LIST] = { command_get_info_list },
- [PA_COMMAND_GET_SERVER_INFO] = { command_get_server_info },
- [PA_COMMAND_SUBSCRIBE] = { command_subscribe },
-
- [PA_COMMAND_SET_SINK_VOLUME] = { command_set_volume },
- [PA_COMMAND_SET_SINK_INPUT_VOLUME] = { command_set_volume },
+static void source_output_kill_cb(pa_source_output *o);
+static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk);
+static pa_usec_t source_output_get_latency_cb(pa_source_output *o);
+
+static void command_exit(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_create_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_drain_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_create_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_delete_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_auth(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_set_client_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_lookup(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_stat(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_get_playback_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_get_record_latency(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_create_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_finish_upload_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_play_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_remove_sample(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_get_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_get_info_list(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_get_server_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_subscribe(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_set_volume(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_cork_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_flush_or_trigger_playback_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_set_default_sink_or_source(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_set_stream_name(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_kill(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_load_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_unload_module(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_add_autoload(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_remove_autoload(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_get_autoload_info(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_get_autoload_info_list(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_cork_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+static void command_flush_record_stream(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata);
+
+static const pa_pdispatch_callback command_table[PA_COMMAND_MAX] = {
+ [PA_COMMAND_ERROR] = NULL,
+ [PA_COMMAND_TIMEOUT] = NULL,
+ [PA_COMMAND_REPLY] = NULL,
+ [PA_COMMAND_CREATE_PLAYBACK_STREAM] = command_create_playback_stream,
+ [PA_COMMAND_DELETE_PLAYBACK_STREAM] = command_delete_stream,
+ [PA_COMMAND_DRAIN_PLAYBACK_STREAM] = command_drain_playback_stream,
+ [PA_COMMAND_CREATE_RECORD_STREAM] = command_create_record_stream,
+ [PA_COMMAND_DELETE_RECORD_STREAM] = command_delete_stream,
+ [PA_COMMAND_AUTH] = command_auth,
+ [PA_COMMAND_REQUEST] = NULL,
+ [PA_COMMAND_EXIT] = command_exit,
+ [PA_COMMAND_SET_CLIENT_NAME] = command_set_client_name,
+ [PA_COMMAND_LOOKUP_SINK] = command_lookup,
+ [PA_COMMAND_LOOKUP_SOURCE] = command_lookup,
+ [PA_COMMAND_STAT] = command_stat,
+ [PA_COMMAND_GET_PLAYBACK_LATENCY] = command_get_playback_latency,
+ [PA_COMMAND_GET_RECORD_LATENCY] = command_get_record_latency,
+ [PA_COMMAND_CREATE_UPLOAD_STREAM] = command_create_upload_stream,
+ [PA_COMMAND_DELETE_UPLOAD_STREAM] = command_delete_stream,
+ [PA_COMMAND_FINISH_UPLOAD_STREAM] = command_finish_upload_stream,
+ [PA_COMMAND_PLAY_SAMPLE] = command_play_sample,
+ [PA_COMMAND_REMOVE_SAMPLE] = command_remove_sample,
+ [PA_COMMAND_GET_SINK_INFO] = command_get_info,
+ [PA_COMMAND_GET_SOURCE_INFO] = command_get_info,
+ [PA_COMMAND_GET_CLIENT_INFO] = command_get_info,
+ [PA_COMMAND_GET_MODULE_INFO] = command_get_info,
+ [PA_COMMAND_GET_SINK_INPUT_INFO] = command_get_info,
+ [PA_COMMAND_GET_SOURCE_OUTPUT_INFO] = command_get_info,
+ [PA_COMMAND_GET_SAMPLE_INFO] = command_get_info,
+ [PA_COMMAND_GET_SINK_INFO_LIST] = command_get_info_list,
+ [PA_COMMAND_GET_SOURCE_INFO_LIST] = command_get_info_list,
+ [PA_COMMAND_GET_MODULE_INFO_LIST] = command_get_info_list,
+ [PA_COMMAND_GET_CLIENT_INFO_LIST] = command_get_info_list,
+ [PA_COMMAND_GET_SINK_INPUT_INFO_LIST] = command_get_info_list,
+ [PA_COMMAND_GET_SOURCE_OUTPUT_INFO_LIST] = command_get_info_list,
+ [PA_COMMAND_GET_SAMPLE_INFO_LIST] = command_get_info_list,
+ [PA_COMMAND_GET_SERVER_INFO] = command_get_server_info,
+ [PA_COMMAND_SUBSCRIBE] = command_subscribe,
+
+ [PA_COMMAND_SET_SINK_VOLUME] = command_set_volume,
+ [PA_COMMAND_SET_SINK_INPUT_VOLUME] = command_set_volume,
- [PA_COMMAND_CORK_PLAYBACK_STREAM] = { command_cork_playback_stream },
- [PA_COMMAND_FLUSH_PLAYBACK_STREAM] = { command_flush_or_trigger_playback_stream },
- [PA_COMMAND_TRIGGER_PLAYBACK_STREAM] = { command_flush_or_trigger_playback_stream },
- [PA_COMMAND_PREBUF_PLAYBACK_STREAM] = { command_flush_or_trigger_playback_stream },
+ [PA_COMMAND_CORK_PLAYBACK_STREAM] = command_cork_playback_stream,
+ [PA_COMMAND_FLUSH_PLAYBACK_STREAM] = command_flush_or_trigger_playback_stream,
+ [PA_COMMAND_TRIGGER_PLAYBACK_STREAM] = command_flush_or_trigger_playback_stream,
+ [PA_COMMAND_PREBUF_PLAYBACK_STREAM] = command_flush_or_trigger_playback_stream,
- [PA_COMMAND_CORK_RECORD_STREAM] = { command_cork_record_stream },
- [PA_COMMAND_FLUSH_RECORD_STREAM] = { command_flush_record_stream },
+ [PA_COMMAND_CORK_RECORD_STREAM] = command_cork_record_stream,
+ [PA_COMMAND_FLUSH_RECORD_STREAM] = command_flush_record_stream,
- [PA_COMMAND_SET_DEFAULT_SINK] = { command_set_default_sink_or_source },
- [PA_COMMAND_SET_DEFAULT_SOURCE] = { command_set_default_sink_or_source },
- [PA_COMMAND_SET_PLAYBACK_STREAM_NAME] = { command_set_stream_name },
- [PA_COMMAND_SET_RECORD_STREAM_NAME] = { command_set_stream_name },
- [PA_COMMAND_KILL_CLIENT] = { command_kill },
- [PA_COMMAND_KILL_SINK_INPUT] = { command_kill },
- [PA_COMMAND_KILL_SOURCE_OUTPUT] = { command_kill },
- [PA_COMMAND_LOAD_MODULE] = { command_load_module },
- [PA_COMMAND_UNLOAD_MODULE] = { command_unload_module },
- [PA_COMMAND_GET_AUTOLOAD_INFO] = { command_get_autoload_info },
- [PA_COMMAND_GET_AUTOLOAD_INFO_LIST] = { command_get_autoload_info_list },
- [PA_COMMAND_ADD_AUTOLOAD] = { command_add_autoload },
- [PA_COMMAND_REMOVE_AUTOLOAD] = { command_remove_autoload },
+ [PA_COMMAND_SET_DEFAULT_SINK] = command_set_default_sink_or_source,
+ [PA_COMMAND_SET_DEFAULT_SOURCE] = command_set_default_sink_or_source,
+ [PA_COMMAND_SET_PLAYBACK_STREAM_NAME] = command_set_stream_name,
+ [PA_COMMAND_SET_RECORD_STREAM_NAME] = command_set_stream_name,
+ [PA_COMMAND_KILL_CLIENT] = command_kill,
+ [PA_COMMAND_KILL_SINK_INPUT] = command_kill,
+ [PA_COMMAND_KILL_SOURCE_OUTPUT] = command_kill,
+ [PA_COMMAND_LOAD_MODULE] = command_load_module,
+ [PA_COMMAND_UNLOAD_MODULE] = command_unload_module,
+ [PA_COMMAND_GET_AUTOLOAD_INFO] = command_get_autoload_info,
+ [PA_COMMAND_GET_AUTOLOAD_INFO_LIST] = command_get_autoload_info_list,
+ [PA_COMMAND_ADD_AUTOLOAD] = command_add_autoload,
+ [PA_COMMAND_REMOVE_AUTOLOAD] = command_remove_autoload,
};
/* structure management */
-static struct upload_stream* upload_stream_new(struct connection *c, const struct pa_sample_spec *ss, const char *name, size_t length) {
+static struct upload_stream* upload_stream_new(struct connection *c, const pa_sample_spec *ss, const char *name, size_t length) {
struct upload_stream *s;
assert(c && ss && name && length);
pa_xfree(o);
}
-static struct record_stream* record_stream_new(struct connection *c, struct pa_source *source, const struct pa_sample_spec *ss, const char *name, size_t maxlength, size_t fragment_size) {
+static struct record_stream* record_stream_new(struct connection *c, pa_source *source, const pa_sample_spec *ss, const char *name, size_t maxlength, size_t fragment_size) {
struct record_stream *s;
- struct pa_source_output *source_output;
+ pa_source_output *source_output;
size_t base;
assert(c && source && ss && name && maxlength);
pa_xfree(r);
}
-static struct playback_stream* playback_stream_new(struct connection *c, struct pa_sink *sink, const struct pa_sample_spec *ss, const char *name,
+static struct playback_stream* playback_stream_new(struct connection *c, pa_sink *sink, const pa_sample_spec *ss, const char *name,
size_t maxlength,
size_t tlength,
size_t prebuf,
size_t minreq,
pa_volume_t volume) {
struct playback_stream *s;
- struct pa_sink_input *sink_input;
+ pa_sink_input *sink_input;
assert(c && sink && ss && name && maxlength);
if (!(sink_input = pa_sink_input_new(sink, PA_TYPEID_NATIVE, name, ss, 0, -1)))
}
static void request_bytes(struct playback_stream *s) {
- struct pa_tagstruct *t;
+ pa_tagstruct *t;
size_t l;
assert(s);
start = PA_IDXSET_INVALID;
for (;;) {
- struct pa_memchunk chunk;
+ pa_memchunk chunk;
if (!(r = pa_idxset_rrobin(c->record_streams, &c->rrobin_index)))
return;
return;
if (pa_memblockq_peek(r->memblockq, &chunk) >= 0) {
- struct pa_memchunk schunk = chunk;
+ pa_memchunk schunk = chunk;
if (schunk.length > r->fragment_size)
schunk.length = r->fragment_size;
}
static void send_playback_stream_killed(struct playback_stream *p) {
- struct pa_tagstruct *t;
+ pa_tagstruct *t;
assert(p);
t = pa_tagstruct_new(NULL, 0);
}
static void send_record_stream_killed(struct record_stream *r) {
- struct pa_tagstruct *t;
+ pa_tagstruct *t;
assert(r);
t = pa_tagstruct_new(NULL, 0);
/*** sinkinput callbacks ***/
-static int sink_input_peek_cb(struct pa_sink_input *i, struct pa_memchunk *chunk) {
+static int sink_input_peek_cb(pa_sink_input *i, pa_memchunk *chunk) {
struct playback_stream *s;
assert(i && i->userdata && chunk);
s = i->userdata;
return 0;
}
-static void sink_input_drop_cb(struct pa_sink_input *i, const struct pa_memchunk *chunk, size_t length) {
+static void sink_input_drop_cb(pa_sink_input *i, const pa_memchunk *chunk, size_t length) {
struct playback_stream *s;
assert(i && i->userdata && length);
s = i->userdata;
/* pa_log(__FILE__": after_drop: %u\n", pa_memblockq_get_length(s->memblockq)); */
}
-static void sink_input_kill_cb(struct pa_sink_input *i) {
+static void sink_input_kill_cb(pa_sink_input *i) {
assert(i && i->userdata);
send_playback_stream_killed((struct playback_stream *) i->userdata);
playback_stream_free((struct playback_stream *) i->userdata);
}
-static pa_usec_t sink_input_get_latency_cb(struct pa_sink_input *i) {
+static pa_usec_t sink_input_get_latency_cb(pa_sink_input *i) {
struct playback_stream *s;
assert(i && i->userdata);
s = i->userdata;
/*** source_output callbacks ***/
-static void source_output_push_cb(struct pa_source_output *o, const struct pa_memchunk *chunk) {
+static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk) {
struct record_stream *s;
assert(o && o->userdata && chunk);
s = o->userdata;
send_memblock(s->connection);
}
-static void source_output_kill_cb(struct pa_source_output *o) {
+static void source_output_kill_cb(pa_source_output *o) {
assert(o && o->userdata);
send_record_stream_killed((struct record_stream *) o->userdata);
record_stream_free((struct record_stream *) o->userdata);
}
-static pa_usec_t source_output_get_latency_cb(struct pa_source_output *o) {
+static pa_usec_t source_output_get_latency_cb(pa_source_output *o) {
struct record_stream *s;
assert(o && o->userdata);
s = o->userdata;
connection_free(c);
}
-static void command_create_playback_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_create_playback_stream(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
struct playback_stream *s;
size_t maxlength, tlength, prebuf, minreq;
uint32_t sink_index;
const char *name, *sink_name;
- struct pa_sample_spec ss;
- struct pa_tagstruct *reply;
- struct pa_sink *sink;
+ pa_sample_spec ss;
+ pa_tagstruct *reply;
+ pa_sink *sink;
pa_volume_t volume;
int corked;
assert(c && t && c->protocol && c->protocol->core);
request_bytes(s);
}
-static void command_delete_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_delete_stream(PA_GCC_UNUSED pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
uint32_t channel;
assert(c && t);
pa_pstream_send_simple_ack(c->pstream, tag);
}
-static void command_create_record_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_create_record_stream(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
struct record_stream *s;
size_t maxlength, fragment_size;
uint32_t source_index;
const char *name, *source_name;
- struct pa_sample_spec ss;
- struct pa_tagstruct *reply;
- struct pa_source *source;
+ pa_sample_spec ss;
+ pa_tagstruct *reply;
+ pa_source *source;
int corked;
assert(c && t && c->protocol && c->protocol->core);
pa_pstream_send_tagstruct(c->pstream, reply);
}
-static void command_exit(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_exit(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
assert(c && t);
return;
}
-static void command_auth(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_auth(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
const void*cookie;
assert(c && t);
return;
}
-static void command_set_client_name(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_set_client_name(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
const char *name;
assert(c && t);
return;
}
-static void command_lookup(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_lookup(PA_GCC_UNUSED pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
const char *name;
- uint32_t index = PA_IDXSET_INVALID;
+ uint32_t idx = PA_IDXSET_INVALID;
assert(c && t);
if (pa_tagstruct_gets(t, &name) < 0 || !name ||
}
if (command == PA_COMMAND_LOOKUP_SINK) {
- struct pa_sink *sink;
+ pa_sink *sink;
if ((sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK, 1)))
- index = sink->index;
+ idx = sink->index;
} else {
- struct pa_source *source;
+ pa_source *source;
assert(command == PA_COMMAND_LOOKUP_SOURCE);
if ((source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE, 1)))
- index = source->index;
+ idx = source->index;
}
- if (index == PA_IDXSET_INVALID)
+ if (idx == PA_IDXSET_INVALID)
pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY);
else {
- struct pa_tagstruct *reply;
+ pa_tagstruct *reply;
reply = pa_tagstruct_new(NULL, 0);
assert(reply);
pa_tagstruct_putu32(reply, PA_COMMAND_REPLY);
pa_tagstruct_putu32(reply, tag);
- pa_tagstruct_putu32(reply, index);
+ pa_tagstruct_putu32(reply, idx);
pa_pstream_send_tagstruct(c->pstream, reply);
}
}
-static void command_drain_playback_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_drain_playback_stream(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- uint32_t index;
+ uint32_t idx;
struct playback_stream *s;
assert(c && t);
- if (pa_tagstruct_getu32(t, &index) < 0 ||
+ if (pa_tagstruct_getu32(t, &idx) < 0 ||
!pa_tagstruct_eof(t)) {
protocol_error(c);
return;
return;
}
- if (!(s = pa_idxset_get_by_index(c->output_streams, index)) || s->type != PLAYBACK_STREAM) {
+ if (!(s = pa_idxset_get_by_index(c->output_streams, idx)) || s->type != PLAYBACK_STREAM) {
pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY);
return;
}
}
}
-static void command_stat(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_stat(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- struct pa_tagstruct *reply;
+ pa_tagstruct *reply;
assert(c && t);
if (!pa_tagstruct_eof(t)) {
pa_pstream_send_tagstruct(c->pstream, reply);
}
-static void command_get_playback_latency(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_get_playback_latency(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- struct pa_tagstruct *reply;
+ pa_tagstruct *reply;
struct playback_stream *s;
struct timeval tv, now;
uint64_t counter;
- uint32_t index;
+ uint32_t idx;
assert(c && t);
- if (pa_tagstruct_getu32(t, &index) < 0 ||
+ if (pa_tagstruct_getu32(t, &idx) < 0 ||
pa_tagstruct_get_timeval(t, &tv) < 0 ||
pa_tagstruct_getu64(t, &counter) < 0 ||
!pa_tagstruct_eof(t)) {
return;
}
- if (!(s = pa_idxset_get_by_index(c->output_streams, index)) || s->type != PLAYBACK_STREAM) {
+ if (!(s = pa_idxset_get_by_index(c->output_streams, idx)) || s->type != PLAYBACK_STREAM) {
pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY);
return;
}
pa_pstream_send_tagstruct(c->pstream, reply);
}
-static void command_get_record_latency(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_get_record_latency(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- struct pa_tagstruct *reply;
+ pa_tagstruct *reply;
struct record_stream *s;
struct timeval tv, now;
uint64_t counter;
- uint32_t index;
+ uint32_t idx;
assert(c && t);
- if (pa_tagstruct_getu32(t, &index) < 0 ||
+ if (pa_tagstruct_getu32(t, &idx) < 0 ||
pa_tagstruct_get_timeval(t, &tv) < 0 ||
pa_tagstruct_getu64(t, &counter) < 0 ||
!pa_tagstruct_eof(t)) {
return;
}
- if (!(s = pa_idxset_get_by_index(c->record_streams, index))) {
+ if (!(s = pa_idxset_get_by_index(c->record_streams, idx))) {
pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY);
return;
}
}
-static void command_create_upload_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_create_upload_stream(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
struct upload_stream *s;
size_t length;
const char *name;
- struct pa_sample_spec ss;
- struct pa_tagstruct *reply;
+ pa_sample_spec ss;
+ pa_tagstruct *reply;
assert(c && t && c->protocol && c->protocol->core);
if (pa_tagstruct_gets(t, &name) < 0 || !name ||
pa_pstream_send_tagstruct(c->pstream, reply);
}
-static void command_finish_upload_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_finish_upload_stream(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
uint32_t channel;
struct upload_stream *s;
- uint32_t index;
+ uint32_t idx;
assert(c && t);
if (pa_tagstruct_getu32(t, &channel) < 0 ||
return;
}
- pa_scache_add_item(c->protocol->core, s->name, &s->sample_spec, &s->memchunk, &index);
+ pa_scache_add_item(c->protocol->core, s->name, &s->sample_spec, &s->memchunk, &idx);
pa_pstream_send_simple_ack(c->pstream, tag);
upload_stream_free(s);
}
-static void command_play_sample(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_play_sample(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
uint32_t sink_index, volume;
- struct pa_sink *sink;
+ pa_sink *sink;
const char *name, *sink_name;
assert(c && t);
pa_pstream_send_simple_ack(c->pstream, tag);
}
-static void command_remove_sample(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_remove_sample(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
const char *name;
assert(c && t);
pa_pstream_send_simple_ack(c->pstream, tag);
}
-static void sink_fill_tagstruct(struct pa_tagstruct *t, struct pa_sink *sink) {
+static void sink_fill_tagstruct(pa_tagstruct *t, pa_sink *sink) {
assert(t && sink);
pa_tagstruct_putu32(t, sink->index);
pa_tagstruct_puts(t, sink->name);
pa_tagstruct_putu32(t, sink->typeid);
}
-static void source_fill_tagstruct(struct pa_tagstruct *t, struct pa_source *source) {
+static void source_fill_tagstruct(pa_tagstruct *t, pa_source *source) {
assert(t && source);
pa_tagstruct_putu32(t, source->index);
pa_tagstruct_puts(t, source->name);
pa_tagstruct_putu32(t, source->typeid);
}
-static void client_fill_tagstruct(struct pa_tagstruct *t, struct pa_client *client) {
+static void client_fill_tagstruct(pa_tagstruct *t, pa_client *client) {
assert(t && client);
pa_tagstruct_putu32(t, client->index);
pa_tagstruct_puts(t, client->name);
pa_tagstruct_putu32(t, client->typeid);
}
-static void module_fill_tagstruct(struct pa_tagstruct *t, struct pa_module *module) {
+static void module_fill_tagstruct(pa_tagstruct *t, pa_module *module) {
assert(t && module);
pa_tagstruct_putu32(t, module->index);
pa_tagstruct_puts(t, module->name);
pa_tagstruct_put_boolean(t, module->auto_unload);
}
-static void sink_input_fill_tagstruct(struct pa_tagstruct *t, struct pa_sink_input *s) {
+static void sink_input_fill_tagstruct(pa_tagstruct *t, pa_sink_input *s) {
assert(t && s);
pa_tagstruct_putu32(t, s->index);
pa_tagstruct_puts(t, s->name);
pa_tagstruct_putu32(t, s->typeid);
}
-static void source_output_fill_tagstruct(struct pa_tagstruct *t, struct pa_source_output *s) {
+static void source_output_fill_tagstruct(pa_tagstruct *t, pa_source_output *s) {
assert(t && s);
pa_tagstruct_putu32(t, s->index);
pa_tagstruct_puts(t, s->name);
pa_tagstruct_putu32(t, s->typeid);
}
-static void scache_fill_tagstruct(struct pa_tagstruct *t, struct pa_scache_entry *e) {
+static void scache_fill_tagstruct(pa_tagstruct *t, pa_scache_entry *e) {
assert(t && e);
pa_tagstruct_putu32(t, e->index);
pa_tagstruct_puts(t, e->name);
pa_tagstruct_puts(t, e->filename);
}
-static void command_get_info(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_get_info(PA_GCC_UNUSED pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- uint32_t index;
- struct pa_sink *sink = NULL;
- struct pa_source *source = NULL;
- struct pa_client *client = NULL;
- struct pa_module *module = NULL;
- struct pa_sink_input *si = NULL;
- struct pa_source_output *so = NULL;
- struct pa_scache_entry *sce = NULL;
+ uint32_t idx;
+ pa_sink *sink = NULL;
+ pa_source *source = NULL;
+ pa_client *client = NULL;
+ pa_module *module = NULL;
+ pa_sink_input *si = NULL;
+ pa_source_output *so = NULL;
+ pa_scache_entry *sce = NULL;
const char *name;
- struct pa_tagstruct *reply;
+ pa_tagstruct *reply;
assert(c && t);
- if (pa_tagstruct_getu32(t, &index) < 0 ||
+ if (pa_tagstruct_getu32(t, &idx) < 0 ||
(command != PA_COMMAND_GET_CLIENT_INFO &&
command != PA_COMMAND_GET_MODULE_INFO &&
command != PA_COMMAND_GET_SINK_INPUT_INFO &&
}
if (command == PA_COMMAND_GET_SINK_INFO) {
- if (index != (uint32_t) -1)
- sink = pa_idxset_get_by_index(c->protocol->core->sinks, index);
+ if (idx != (uint32_t) -1)
+ sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
else
sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK, 1);
} else if (command == PA_COMMAND_GET_SOURCE_INFO) {
- if (index != (uint32_t) -1)
- source = pa_idxset_get_by_index(c->protocol->core->sources, index);
+ if (idx != (uint32_t) -1)
+ source = pa_idxset_get_by_index(c->protocol->core->sources, idx);
else
source = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SOURCE, 1);
} else if (command == PA_COMMAND_GET_CLIENT_INFO)
- client = pa_idxset_get_by_index(c->protocol->core->clients, index);
+ client = pa_idxset_get_by_index(c->protocol->core->clients, idx);
else if (command == PA_COMMAND_GET_MODULE_INFO)
- module = pa_idxset_get_by_index(c->protocol->core->modules, index);
+ module = pa_idxset_get_by_index(c->protocol->core->modules, idx);
else if (command == PA_COMMAND_GET_SINK_INPUT_INFO)
- si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, index);
+ si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
else if (command == PA_COMMAND_GET_SOURCE_OUTPUT_INFO)
- so = pa_idxset_get_by_index(c->protocol->core->source_outputs, index);
+ so = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx);
else {
assert(command == PA_COMMAND_GET_SAMPLE_INFO);
- if (index != (uint32_t) -1)
- sce = pa_idxset_get_by_index(c->protocol->core->scache, index);
+ if (idx != (uint32_t) -1)
+ sce = pa_idxset_get_by_index(c->protocol->core->scache, idx);
else
sce = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SAMPLE, 0);
}
pa_pstream_send_tagstruct(c->pstream, reply);
}
-static void command_get_info_list(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_get_info_list(PA_GCC_UNUSED pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- struct pa_idxset *i;
- uint32_t index;
+ pa_idxset *i;
+ uint32_t idx;
void *p;
- struct pa_tagstruct *reply;
+ pa_tagstruct *reply;
assert(c && t);
if (!pa_tagstruct_eof(t)) {
}
if (i) {
- for (p = pa_idxset_first(i, &index); p; p = pa_idxset_next(i, &index)) {
+ for (p = pa_idxset_first(i, &idx); p; p = pa_idxset_next(i, &idx)) {
if (command == PA_COMMAND_GET_SINK_INFO_LIST)
sink_fill_tagstruct(reply, p);
else if (command == PA_COMMAND_GET_SOURCE_INFO_LIST)
pa_pstream_send_tagstruct(c->pstream, reply);
}
-static void command_get_server_info(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_get_server_info(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- struct pa_tagstruct *reply;
+ pa_tagstruct *reply;
char txt[256];
const char *n;
assert(c && t);
pa_pstream_send_tagstruct(c->pstream, reply);
}
-static void subscription_cb(struct pa_core *core, enum pa_subscription_event_type e, uint32_t index, void *userdata) {
- struct pa_tagstruct *t;
+static void subscription_cb(pa_core *core, pa_subscription_event_type e, uint32_t idx, void *userdata) {
+ pa_tagstruct *t;
struct connection *c = userdata;
assert(c && core);
pa_tagstruct_putu32(t, PA_COMMAND_SUBSCRIBE_EVENT);
pa_tagstruct_putu32(t, (uint32_t) -1);
pa_tagstruct_putu32(t, e);
- pa_tagstruct_putu32(t, index);
+ pa_tagstruct_putu32(t, idx);
pa_pstream_send_tagstruct(c->pstream, t);
}
-static void command_subscribe(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_subscribe(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- enum pa_subscription_mask m;
+ pa_subscription_mask m;
assert(c && t);
if (pa_tagstruct_getu32(t, &m) < 0 ||
pa_pstream_send_simple_ack(c->pstream, tag);
}
-static void command_set_volume(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_set_volume(PA_GCC_UNUSED pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- uint32_t index, volume;
- struct pa_sink *sink = NULL;
- struct pa_sink_input *si = NULL;
+ uint32_t idx, volume;
+ pa_sink *sink = NULL;
+ pa_sink_input *si = NULL;
const char *name = NULL;
assert(c && t);
- if (pa_tagstruct_getu32(t, &index) < 0 ||
+ if (pa_tagstruct_getu32(t, &idx) < 0 ||
(command == PA_COMMAND_SET_SINK_VOLUME && pa_tagstruct_gets(t, &name) < 0) ||
pa_tagstruct_getu32(t, &volume) ||
!pa_tagstruct_eof(t)) {
}
if (command == PA_COMMAND_SET_SINK_VOLUME) {
- if (index != (uint32_t) -1)
- sink = pa_idxset_get_by_index(c->protocol->core->sinks, index);
+ if (idx != (uint32_t) -1)
+ sink = pa_idxset_get_by_index(c->protocol->core->sinks, idx);
else
sink = pa_namereg_get(c->protocol->core, name, PA_NAMEREG_SINK, 1);
} else {
assert(command == PA_COMMAND_SET_SINK_INPUT_VOLUME);
- si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, index);
+ si = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx);
}
if (!si && !sink) {
pa_pstream_send_simple_ack(c->pstream, tag);
}
-static void command_cork_playback_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_cork_playback_stream(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- uint32_t index;
+ uint32_t idx;
int b;
struct playback_stream *s;
assert(c && t);
- if (pa_tagstruct_getu32(t, &index) < 0 ||
+ if (pa_tagstruct_getu32(t, &idx) < 0 ||
pa_tagstruct_get_boolean(t, &b) < 0 ||
!pa_tagstruct_eof(t)) {
protocol_error(c);
return;
}
- if (!(s = pa_idxset_get_by_index(c->output_streams, index)) || s->type != PLAYBACK_STREAM) {
+ if (!(s = pa_idxset_get_by_index(c->output_streams, idx)) || s->type != PLAYBACK_STREAM) {
pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY);
return;
}
pa_pstream_send_simple_ack(c->pstream, tag);
}
-static void command_flush_or_trigger_playback_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_flush_or_trigger_playback_stream(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- uint32_t index;
+ uint32_t idx;
struct playback_stream *s;
assert(c && t);
- if (pa_tagstruct_getu32(t, &index) < 0 ||
+ if (pa_tagstruct_getu32(t, &idx) < 0 ||
!pa_tagstruct_eof(t)) {
protocol_error(c);
return;
return;
}
- if (!(s = pa_idxset_get_by_index(c->output_streams, index)) || s->type != PLAYBACK_STREAM) {
+ if (!(s = pa_idxset_get_by_index(c->output_streams, idx)) || s->type != PLAYBACK_STREAM) {
pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY);
return;
}
request_bytes(s);
}
-static void command_cork_record_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_cork_record_stream(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- uint32_t index;
+ uint32_t idx;
struct record_stream *s;
int b;
assert(c && t);
- if (pa_tagstruct_getu32(t, &index) < 0 ||
+ if (pa_tagstruct_getu32(t, &idx) < 0 ||
pa_tagstruct_get_boolean(t, &b) < 0 ||
!pa_tagstruct_eof(t)) {
protocol_error(c);
return;
}
- if (!(s = pa_idxset_get_by_index(c->record_streams, index))) {
+ if (!(s = pa_idxset_get_by_index(c->record_streams, idx))) {
pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY);
return;
}
pa_pstream_send_simple_ack(c->pstream, tag);
}
-static void command_flush_record_stream(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_flush_record_stream(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- uint32_t index;
+ uint32_t idx;
struct record_stream *s;
assert(c && t);
- if (pa_tagstruct_getu32(t, &index) < 0 ||
+ if (pa_tagstruct_getu32(t, &idx) < 0 ||
!pa_tagstruct_eof(t)) {
protocol_error(c);
return;
return;
}
- if (!(s = pa_idxset_get_by_index(c->record_streams, index))) {
+ if (!(s = pa_idxset_get_by_index(c->record_streams, idx))) {
pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY);
return;
}
pa_pstream_send_simple_ack(c->pstream, tag);
}
-static void command_set_default_sink_or_source(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_set_default_sink_or_source(PA_GCC_UNUSED pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- uint32_t index;
+ uint32_t idx;
const char *s;
assert(c && t);
- if (pa_tagstruct_getu32(t, &index) < 0 ||
+ if (pa_tagstruct_getu32(t, &idx) < 0 ||
pa_tagstruct_gets(t, &s) < 0 || !s ||
!pa_tagstruct_eof(t)) {
protocol_error(c);
pa_pstream_send_simple_ack(c->pstream, tag);
}
-static void command_set_stream_name(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_set_stream_name(PA_GCC_UNUSED pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- uint32_t index;
+ uint32_t idx;
const char *name;
assert(c && t);
- if (pa_tagstruct_getu32(t, &index) < 0 ||
+ if (pa_tagstruct_getu32(t, &idx) < 0 ||
pa_tagstruct_gets(t, &name) < 0 || !name ||
!pa_tagstruct_eof(t)) {
protocol_error(c);
if (command == PA_COMMAND_SET_PLAYBACK_STREAM_NAME) {
struct playback_stream *s;
- if (!(s = pa_idxset_get_by_index(c->output_streams, index)) || s->type != PLAYBACK_STREAM) {
+ if (!(s = pa_idxset_get_by_index(c->output_streams, idx)) || s->type != PLAYBACK_STREAM) {
pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY);
return;
}
} else {
struct record_stream *s;
- if (!(s = pa_idxset_get_by_index(c->record_streams, index))) {
+ if (!(s = pa_idxset_get_by_index(c->record_streams, idx))) {
pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY);
return;
}
pa_pstream_send_simple_ack(c->pstream, tag);
}
-static void command_kill(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_kill(PA_GCC_UNUSED pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- uint32_t index;
+ uint32_t idx;
assert(c && t);
- if (pa_tagstruct_getu32(t, &index) < 0 ||
+ if (pa_tagstruct_getu32(t, &idx) < 0 ||
!pa_tagstruct_eof(t)) {
protocol_error(c);
return;
}
if (command == PA_COMMAND_KILL_CLIENT) {
- struct pa_client *client;
+ pa_client *client;
- if (!(client = pa_idxset_get_by_index(c->protocol->core->clients, index))) {
+ if (!(client = pa_idxset_get_by_index(c->protocol->core->clients, idx))) {
pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY);
return;
}
pa_client_kill(client);
} else if (command == PA_COMMAND_KILL_SINK_INPUT) {
- struct pa_sink_input *s;
+ pa_sink_input *s;
- if (!(s = pa_idxset_get_by_index(c->protocol->core->sink_inputs, index))) {
+ if (!(s = pa_idxset_get_by_index(c->protocol->core->sink_inputs, idx))) {
pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY);
return;
}
pa_sink_input_kill(s);
} else {
- struct pa_source_output *s;
+ pa_source_output *s;
assert(command == PA_COMMAND_KILL_SOURCE_OUTPUT);
- if (!(s = pa_idxset_get_by_index(c->protocol->core->source_outputs, index))) {
+ if (!(s = pa_idxset_get_by_index(c->protocol->core->source_outputs, idx))) {
pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY);
return;
}
pa_pstream_send_simple_ack(c->pstream, tag);
}
-static void command_load_module(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_load_module(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- struct pa_module *m;
+ pa_module *m;
const char *name, *argument;
- struct pa_tagstruct *reply;
+ pa_tagstruct *reply;
assert(c && t);
if (pa_tagstruct_gets(t, &name) < 0 || !name ||
pa_pstream_send_tagstruct(c->pstream, reply);
}
-static void command_unload_module(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_unload_module(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- uint32_t index;
- struct pa_module *m;
+ uint32_t idx;
+ pa_module *m;
assert(c && t);
- if (pa_tagstruct_getu32(t, &index) < 0 ||
+ if (pa_tagstruct_getu32(t, &idx) < 0 ||
!pa_tagstruct_eof(t)) {
protocol_error(c);
return;
return;
}
- if (!(m = pa_idxset_get_by_index(c->protocol->core->modules, index))) {
+ if (!(m = pa_idxset_get_by_index(c->protocol->core->modules, idx))) {
pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY);
return;
}
pa_pstream_send_simple_ack(c->pstream, tag);
}
-static void command_add_autoload(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_add_autoload(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
const char *name, *module, *argument;
uint32_t type;
- uint32_t index;
- struct pa_tagstruct *reply;
+ uint32_t idx;
+ pa_tagstruct *reply;
assert(c && t);
if (pa_tagstruct_gets(t, &name) < 0 || !name ||
return;
}
- if (pa_autoload_add(c->protocol->core, name, type == 0 ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE, module, argument, &index) < 0) {
+ if (pa_autoload_add(c->protocol->core, name, type == 0 ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE, module, argument, &idx) < 0) {
pa_pstream_send_error(c->pstream, tag, PA_ERROR_EXIST);
return;
}
reply = pa_tagstruct_new(NULL, 0);
pa_tagstruct_putu32(reply, PA_COMMAND_REPLY);
pa_tagstruct_putu32(reply, tag);
- pa_tagstruct_putu32(reply, index);
+ pa_tagstruct_putu32(reply, idx);
pa_pstream_send_tagstruct(c->pstream, reply);
}
-static void command_remove_autoload(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_remove_autoload(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
const char *name = NULL;
- uint32_t type, index = PA_IDXSET_INVALID;
+ uint32_t type, idx = PA_IDXSET_INVALID;
int r;
assert(c && t);
- if ((pa_tagstruct_getu32(t, &index) < 0 &&
+ if ((pa_tagstruct_getu32(t, &idx) < 0 &&
(pa_tagstruct_gets(t, &name) < 0 ||
pa_tagstruct_getu32(t, &type) < 0)) ||
- (!name && index == PA_IDXSET_INVALID) ||
+ (!name && idx == PA_IDXSET_INVALID) ||
(name && type > 1) ||
!pa_tagstruct_eof(t)) {
protocol_error(c);
if (name)
r = pa_autoload_remove_by_name(c->protocol->core, name, type == 0 ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE);
else
- r = pa_autoload_remove_by_index(c->protocol->core, index);
+ r = pa_autoload_remove_by_index(c->protocol->core, idx);
if (r < 0) {
pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY);
pa_pstream_send_simple_ack(c->pstream, tag);
}
-static void autoload_fill_tagstruct(struct pa_tagstruct *t, const struct pa_autoload_entry *e) {
+static void autoload_fill_tagstruct(pa_tagstruct *t, const pa_autoload_entry *e) {
assert(t && e);
pa_tagstruct_putu32(t, e->index);
pa_tagstruct_puts(t, e->argument);
}
-static void command_get_autoload_info(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_get_autoload_info(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- const struct pa_autoload_entry *a = NULL;
- uint32_t type, index;
+ const pa_autoload_entry *a = NULL;
+ uint32_t type, idx;
const char *name;
- struct pa_tagstruct *reply;
+ pa_tagstruct *reply;
assert(c && t);
- if ((pa_tagstruct_getu32(t, &index) < 0 &&
+ if ((pa_tagstruct_getu32(t, &idx) < 0 &&
(pa_tagstruct_gets(t, &name) < 0 ||
pa_tagstruct_getu32(t, &type) < 0)) ||
- (!name && index == PA_IDXSET_INVALID) ||
+ (!name && idx == PA_IDXSET_INVALID) ||
(name && type > 1) ||
!pa_tagstruct_eof(t)) {
protocol_error(c);
if (name)
a = pa_autoload_get_by_name(c->protocol->core, name, type == 0 ? PA_NAMEREG_SINK : PA_NAMEREG_SOURCE);
else
- a = pa_autoload_get_by_index(c->protocol->core, index);
+ a = pa_autoload_get_by_index(c->protocol->core, idx);
if (!a) {
pa_pstream_send_error(c->pstream, tag, PA_ERROR_NOENTITY);
pa_pstream_send_tagstruct(c->pstream, reply);
}
-static void command_get_autoload_info_list(struct pa_pdispatch *pd, uint32_t command, uint32_t tag, struct pa_tagstruct *t, void *userdata) {
+static void command_get_autoload_info_list(PA_GCC_UNUSED pa_pdispatch *pd, PA_GCC_UNUSED uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct connection *c = userdata;
- struct pa_tagstruct *reply;
+ pa_tagstruct *reply;
assert(c && t);
if (!pa_tagstruct_eof(t)) {
pa_tagstruct_putu32(reply, tag);
if (c->protocol->core->autoload_hashmap) {
- struct pa_autoload_entry *a;
+ pa_autoload_entry *a;
void *state = NULL;
while ((a = pa_hashmap_iterate(c->protocol->core->autoload_hashmap, &state, NULL)))
/*** pstream callbacks ***/
-static void pstream_packet_callback(struct pa_pstream *p, struct pa_packet *packet, void *userdata) {
+static void pstream_packet_callback(pa_pstream *p, pa_packet *packet, void *userdata) {
struct connection *c = userdata;
assert(p && packet && packet->data && c);
}
}
-static void pstream_memblock_callback(struct pa_pstream *p, uint32_t channel, uint32_t delta, const struct pa_memchunk *chunk, void *userdata) {
+static void pstream_memblock_callback(pa_pstream *p, uint32_t channel, uint32_t delta, const pa_memchunk *chunk, void *userdata) {
struct connection *c = userdata;
struct output_stream *stream;
assert(p && chunk && userdata);
}
if (stream->type == PLAYBACK_STREAM) {
- struct playback_stream *p = (struct playback_stream*) stream;
- if (chunk->length >= p->requested_bytes)
- p->requested_bytes = 0;
+ struct playback_stream *ps = (struct playback_stream*) stream;
+ if (chunk->length >= ps->requested_bytes)
+ ps->requested_bytes = 0;
else
- p->requested_bytes -= chunk->length;
+ ps->requested_bytes -= chunk->length;
- pa_memblockq_push_align(p->memblockq, chunk, delta);
- assert(p->sink_input);
+ pa_memblockq_push_align(ps->memblockq, chunk, delta);
+ assert(ps->sink_input);
/* pa_log(__FILE__": after_recv: %u\n", pa_memblockq_get_length(p->memblockq)); */
- pa_sink_notify(p->sink_input->sink);
+ pa_sink_notify(ps->sink_input->sink);
/* pa_log(__FILE__": Recieved %u bytes.\n", chunk->length); */
} else {
}
}
-static void pstream_die_callback(struct pa_pstream *p, void *userdata) {
+static void pstream_die_callback(pa_pstream *p, void *userdata) {
struct connection *c = userdata;
assert(p && c);
connection_free(c);
}
-static void pstream_drain_callback(struct pa_pstream *p, void *userdata) {
+static void pstream_drain_callback(pa_pstream *p, void *userdata) {
struct connection *c = userdata;
assert(p && c);
/*** client callbacks ***/
-static void client_kill_cb(struct pa_client *c) {
+static void client_kill_cb(pa_client *c) {
assert(c && c->userdata);
connection_free(c->userdata);
}
/*** socket server callbacks ***/
-static void auth_timeout(struct pa_mainloop_api*m, struct pa_time_event *e, const struct timeval *tv, void *userdata) {
+static void auth_timeout(pa_mainloop_api*m, pa_time_event *e, const struct timeval *tv, void *userdata) {
struct connection *c = userdata;
assert(m && tv && c && c->auth_timeout_event == e);
connection_free(c);
}
-static void on_connection(struct pa_socket_server*s, struct pa_iochannel *io, void *userdata) {
- struct pa_protocol_native *p = userdata;
+static void on_connection(PA_GCC_UNUSED pa_socket_server*s, pa_iochannel *io, void *userdata) {
+ pa_protocol_native *p = userdata;
struct connection *c;
assert(io && p);
- if (pa_idxset_ncontents(p->connections)+1 > MAX_CONNECTIONS) {
+ if (pa_idxset_size(p->connections)+1 > MAX_CONNECTIONS) {
pa_log_warn(__FILE__": Warning! Too many connections (%u), dropping incoming connection.\n", MAX_CONNECTIONS);
pa_iochannel_free(io);
return;
/*** module entry points ***/
-static int load_key(struct pa_protocol_native*p, const char*fn) {
+static int load_key(pa_protocol_native*p, const char*fn) {
assert(p);
p->auth_cookie_in_property = 0;
return 0;
}
-static struct pa_protocol_native* protocol_new_internal(struct pa_core *c, struct pa_module *m, struct pa_modargs *ma) {
- struct pa_protocol_native *p;
+static pa_protocol_native* protocol_new_internal(pa_core *c, pa_module *m, pa_modargs *ma) {
+ pa_protocol_native *p;
int public = 0;
assert(c && ma);
return NULL;
}
- p = pa_xmalloc(sizeof(struct pa_protocol_native));
+ p = pa_xmalloc(sizeof(pa_protocol_native));
p->core = c;
p->module = m;
p->public = public;
return p;
}
-struct pa_protocol_native* pa_protocol_native_new(struct pa_core *core, struct pa_socket_server *server, struct pa_module *m, struct pa_modargs *ma) {
+pa_protocol_native* pa_protocol_native_new(pa_core *core, pa_socket_server *server, pa_module *m, pa_modargs *ma) {
char t[256];
- struct pa_protocol_native *p;
+ pa_protocol_native *p;
if (!(p = protocol_new_internal(core, m, ma)))
return NULL;
pa_socket_server_set_callback(p->server, on_connection, p);
if (pa_socket_server_get_address(p->server, t, sizeof(t))) {
- struct pa_strlist *l;
+ pa_strlist *l;
l = pa_property_get(core, PA_NATIVE_SERVER_PROPERTY_NAME);
l = pa_strlist_prepend(l, t);
pa_property_replace(core, PA_NATIVE_SERVER_PROPERTY_NAME, l);
return p;
}
-void pa_protocol_native_free(struct pa_protocol_native *p) {
+void pa_protocol_native_free(pa_protocol_native *p) {
struct connection *c;
assert(p);
char t[256];
if (pa_socket_server_get_address(p->server, t, sizeof(t))) {
- struct pa_strlist *l;
+ pa_strlist *l;
l = pa_property_get(p->core, PA_NATIVE_SERVER_PROPERTY_NAME);
l = pa_strlist_remove(l, t);
pa_xfree(p);
}
-struct pa_protocol_native* pa_protocol_native_new_iochannel(struct pa_core*core, struct pa_iochannel *io, struct pa_module *m, struct pa_modargs *ma) {
- struct pa_protocol_native *p;
+pa_protocol_native* pa_protocol_native_new_iochannel(pa_core*core, pa_iochannel *io, pa_module *m, pa_modargs *ma) {
+ pa_protocol_native *p;
if (!(p = protocol_new_internal(core, m, ma)))
return NULL;
#include "module.h"
#include "modargs.h"
-struct pa_protocol_native;
+typedef struct pa_protocol_native pa_protocol_native;
-struct pa_protocol_native* pa_protocol_native_new(struct pa_core*core, struct pa_socket_server *server, struct pa_module *m, struct pa_modargs *ma);
-void pa_protocol_native_free(struct pa_protocol_native *n);
+pa_protocol_native* pa_protocol_native_new(pa_core*core, pa_socket_server *server, pa_module *m, pa_modargs *ma);
+void pa_protocol_native_free(pa_protocol_native *n);
-struct pa_protocol_native* pa_protocol_native_new_iochannel(struct pa_core*core, struct pa_iochannel *io, struct pa_module *m, struct pa_modargs *ma);
+pa_protocol_native* pa_protocol_native_new_iochannel(pa_core*core, pa_iochannel *io, pa_module *m, pa_modargs *ma);
#endif
#define PA_TYPEID_SIMPLE PA_TYPEID_MAKE('S', 'M', 'P', 'L')
struct connection {
- struct pa_protocol_simple *protocol;
- struct pa_iochannel *io;
- struct pa_sink_input *sink_input;
- struct pa_source_output *source_output;
- struct pa_client *client;
- struct pa_memblockq *input_memblockq, *output_memblockq;
- struct pa_defer_event *defer_event;
+ pa_protocol_simple *protocol;
+ pa_iochannel *io;
+ pa_sink_input *sink_input;
+ pa_source_output *source_output;
+ pa_client *client;
+ pa_memblockq *input_memblockq, *output_memblockq;
+ pa_defer_event *defer_event;
struct {
- struct pa_memblock *current_memblock;
+ pa_memblock *current_memblock;
size_t memblock_index, fragment_size;
} playback;
};
struct pa_protocol_simple {
- struct pa_module *module;
- struct pa_core *core;
- struct pa_socket_server*server;
- struct pa_idxset *connections;
+ pa_module *module;
+ pa_core *core;
+ pa_socket_server*server;
+ pa_idxset *connections;
enum {
RECORD = 1,
PLAYBACK = 2,
DUPLEX = 3
} mode;
- struct pa_sample_spec sample_spec;
+ pa_sample_spec sample_spec;
char *source_name, *sink_name;
};
}
static int do_read(struct connection *c) {
- struct pa_memchunk chunk;
+ pa_memchunk chunk;
ssize_t r;
size_t l;
}
static int do_write(struct connection *c) {
- struct pa_memchunk chunk;
+ pa_memchunk chunk;
ssize_t r;
if (!c->source_output)
/*** sink_input callbacks ***/
-static int sink_input_peek_cb(struct pa_sink_input *i, struct pa_memchunk *chunk) {
+static int sink_input_peek_cb(pa_sink_input *i, pa_memchunk *chunk) {
struct connection*c;
assert(i && i->userdata && chunk);
c = i->userdata;
return 0;
}
-static void sink_input_drop_cb(struct pa_sink_input *i, const struct pa_memchunk *chunk, size_t length) {
+static void sink_input_drop_cb(pa_sink_input *i, const pa_memchunk *chunk, size_t length) {
struct connection*c = i->userdata;
assert(i && c && length);
c->protocol->core->mainloop->defer_enable(c->defer_event, 1);
}
-static void sink_input_kill_cb(struct pa_sink_input *i) {
+static void sink_input_kill_cb(pa_sink_input *i) {
assert(i && i->userdata);
connection_free((struct connection *) i->userdata);
}
-static pa_usec_t sink_input_get_latency_cb(struct pa_sink_input *i) {
+static pa_usec_t sink_input_get_latency_cb(pa_sink_input *i) {
struct connection*c = i->userdata;
assert(i && c);
return pa_bytes_to_usec(pa_memblockq_get_length(c->input_memblockq), &c->sink_input->sample_spec);
/*** source_output callbacks ***/
-static void source_output_push_cb(struct pa_source_output *o, const struct pa_memchunk *chunk) {
+static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk) {
struct connection *c = o->userdata;
assert(o && c && chunk);
c->protocol->core->mainloop->defer_enable(c->defer_event, 1);
}
-static void source_output_kill_cb(struct pa_source_output *o) {
+static void source_output_kill_cb(pa_source_output *o) {
assert(o && o->userdata);
connection_free((struct connection *) o->userdata);
}
-static pa_usec_t source_output_get_latency_cb(struct pa_source_output *o) {
+static pa_usec_t source_output_get_latency_cb(pa_source_output *o) {
struct connection*c = o->userdata;
assert(o && c);
return pa_bytes_to_usec(pa_memblockq_get_length(c->output_memblockq), &c->source_output->sample_spec);
/*** client callbacks ***/
-static void client_kill_cb(struct pa_client *c) {
+static void client_kill_cb(pa_client *c) {
assert(c && c->userdata);
connection_free((struct connection *) c->userdata);
}
/*** pa_iochannel callbacks ***/
-static void io_callback(struct pa_iochannel*io, void *userdata) {
+static void io_callback(pa_iochannel*io, void *userdata) {
struct connection *c = userdata;
assert(io && c && c->io == io);
/*** fixed callback ***/
-static void defer_callback(struct pa_mainloop_api*a, struct pa_defer_event *e, void *userdata) {
+static void defer_callback(pa_mainloop_api*a, pa_defer_event *e, void *userdata) {
struct connection *c = userdata;
assert(a && c && c->defer_event == e);
/*** socket_server callbacks ***/
-static void on_connection(struct pa_socket_server*s, struct pa_iochannel *io, void *userdata) {
- struct pa_protocol_simple *p = userdata;
+static void on_connection(pa_socket_server*s, pa_iochannel *io, void *userdata) {
+ pa_protocol_simple *p = userdata;
struct connection *c = NULL;
char cname[256];
assert(s && io && p);
- if (pa_idxset_ncontents(p->connections)+1 > MAX_CONNECTIONS) {
+ if (pa_idxset_size(p->connections)+1 > MAX_CONNECTIONS) {
pa_log(__FILE__": Warning! Too many connections (%u), dropping incoming connection.\n", MAX_CONNECTIONS);
pa_iochannel_free(io);
return;
c->client->userdata = c;
if (p->mode & PLAYBACK) {
- struct pa_sink *sink;
+ pa_sink *sink;
size_t l;
if (!(sink = pa_namereg_get(p->core, p->sink_name, PA_NAMEREG_SINK, 1))) {
}
if (p->mode & RECORD) {
- struct pa_source *source;
+ pa_source *source;
size_t l;
if (!(source = pa_namereg_get(p->core, p->source_name, PA_NAMEREG_SOURCE, 1))) {
connection_free(c);
}
-struct pa_protocol_simple* pa_protocol_simple_new(struct pa_core *core, struct pa_socket_server *server, struct pa_module *m, struct pa_modargs *ma) {
- struct pa_protocol_simple* p = NULL;
+pa_protocol_simple* pa_protocol_simple_new(pa_core *core, pa_socket_server *server, pa_module *m, pa_modargs *ma) {
+ pa_protocol_simple* p = NULL;
int enable;
assert(core && server && ma);
- p = pa_xmalloc0(sizeof(struct pa_protocol_simple));
+ p = pa_xmalloc0(sizeof(pa_protocol_simple));
p->module = m;
p->core = core;
p->server = server;
}
-void pa_protocol_simple_free(struct pa_protocol_simple *p) {
+void pa_protocol_simple_free(pa_protocol_simple *p) {
struct connection *c;
assert(p);
#include "core.h"
#include "modargs.h"
-struct pa_protocol_simple;
+typedef struct pa_protocol_simple pa_protocol_simple;
-struct pa_protocol_simple* pa_protocol_simple_new(struct pa_core *core, struct pa_socket_server *server, struct pa_module *m, struct pa_modargs *ma);
-void pa_protocol_simple_free(struct pa_protocol_simple *n);
+pa_protocol_simple* pa_protocol_simple_new(pa_core *core, pa_socket_server *server, pa_module *m, pa_modargs *ma);
+void pa_protocol_simple_free(pa_protocol_simple *n);
#endif
#include "native-common.h"
#include "pstream-util.h"
-void pa_pstream_send_tagstruct(struct pa_pstream *p, struct pa_tagstruct *t) {
+void pa_pstream_send_tagstruct(pa_pstream *p, pa_tagstruct *t) {
size_t length;
uint8_t *data;
- struct pa_packet *packet;
+ pa_packet *packet;
assert(p);
assert(t);
pa_packet_unref(packet);
}
-void pa_pstream_send_error(struct pa_pstream *p, uint32_t tag, uint32_t error) {
- struct pa_tagstruct *t = pa_tagstruct_new(NULL, 0);
+void pa_pstream_send_error(pa_pstream *p, uint32_t tag, uint32_t error) {
+ pa_tagstruct *t = pa_tagstruct_new(NULL, 0);
assert(t);
pa_tagstruct_putu32(t, PA_COMMAND_ERROR);
pa_tagstruct_putu32(t, tag);
pa_pstream_send_tagstruct(p, t);
}
-void pa_pstream_send_simple_ack(struct pa_pstream *p, uint32_t tag) {
- struct pa_tagstruct *t = pa_tagstruct_new(NULL, 0);
+void pa_pstream_send_simple_ack(pa_pstream *p, uint32_t tag) {
+ pa_tagstruct *t = pa_tagstruct_new(NULL, 0);
assert(t);
pa_tagstruct_putu32(t, PA_COMMAND_REPLY);
pa_tagstruct_putu32(t, tag);
#include "tagstruct.h"
/* The tagstruct is freed!*/
-void pa_pstream_send_tagstruct(struct pa_pstream *p, struct pa_tagstruct *t);
+void pa_pstream_send_tagstruct(pa_pstream *p, pa_tagstruct *t);
-void pa_pstream_send_error(struct pa_pstream *p, uint32_t tag, uint32_t error);
-void pa_pstream_send_simple_ack(struct pa_pstream *p, uint32_t tag);
+void pa_pstream_send_error(pa_pstream *p, uint32_t tag, uint32_t error);
+void pa_pstream_send_simple_ack(pa_pstream *p, uint32_t tag);
#endif
#include "xmalloc.h"
#include "log.h"
-enum pa_pstream_descriptor_index {
+typedef enum pa_pstream_descriptor_index {
PA_PSTREAM_DESCRIPTOR_LENGTH,
PA_PSTREAM_DESCRIPTOR_CHANNEL,
PA_PSTREAM_DESCRIPTOR_DELTA,
PA_PSTREAM_DESCRIPTOR_MAX
-};
+} pa_pstream_descriptor_index;
typedef uint32_t pa_pstream_descriptor[PA_PSTREAM_DESCRIPTOR_MAX];
enum { PA_PSTREAM_ITEM_PACKET, PA_PSTREAM_ITEM_MEMBLOCK } type;
/* memblock info */
- struct pa_memchunk chunk;
+ pa_memchunk chunk;
uint32_t channel;
uint32_t delta;
/* packet info */
- struct pa_packet *packet;
+ pa_packet *packet;
};
struct pa_pstream {
int ref;
- struct pa_mainloop_api *mainloop;
- struct pa_defer_event *defer_event;
- struct pa_iochannel *io;
- struct pa_queue *send_queue;
+ pa_mainloop_api *mainloop;
+ pa_defer_event *defer_event;
+ pa_iochannel *io;
+ pa_queue *send_queue;
int dead;
- void (*die_callback) (struct pa_pstream *p, void *userdata);
+ void (*die_callback) (pa_pstream *p, void *userdata);
void *die_callback_userdata;
struct {
} write;
struct {
- struct pa_memblock *memblock;
- struct pa_packet *packet;
+ pa_memblock *memblock;
+ pa_packet *packet;
pa_pstream_descriptor descriptor;
void *data;
size_t index;
} read;
- void (*recieve_packet_callback) (struct pa_pstream *p, struct pa_packet *packet, void *userdata);
+ void (*recieve_packet_callback) (pa_pstream *p, pa_packet *packet, void *userdata);
void *recieve_packet_callback_userdata;
- void (*recieve_memblock_callback) (struct pa_pstream *p, uint32_t channel, uint32_t delta, const struct pa_memchunk *chunk, void *userdata);
+ void (*recieve_memblock_callback) (pa_pstream *p, uint32_t channel, uint32_t delta, const pa_memchunk *chunk, void *userdata);
void *recieve_memblock_callback_userdata;
- void (*drain_callback)(struct pa_pstream *p, void *userdata);
+ void (*drain_callback)(pa_pstream *p, void *userdata);
void *drain_userdata;
- struct pa_memblock_stat *memblock_stat;
+ pa_memblock_stat *memblock_stat;
};
-static void do_write(struct pa_pstream *p);
-static void do_read(struct pa_pstream *p);
+static void do_write(pa_pstream *p);
+static void do_read(pa_pstream *p);
-static void do_something(struct pa_pstream *p) {
+static void do_something(pa_pstream *p) {
assert(p);
p->mainloop->defer_enable(p->defer_event, 0);
pa_pstream_unref(p);
}
-static void io_callback(struct pa_iochannel*io, void *userdata) {
- struct pa_pstream *p = userdata;
+static void io_callback(pa_iochannel*io, void *userdata) {
+ pa_pstream *p = userdata;
assert(p && p->io == io);
do_something(p);
}
-static void defer_callback(struct pa_mainloop_api *m, struct pa_defer_event *e, void*userdata) {
- struct pa_pstream *p = userdata;
+static void defer_callback(pa_mainloop_api *m, pa_defer_event *e, void*userdata) {
+ pa_pstream *p = userdata;
assert(p && p->defer_event == e && p->mainloop == m);
do_something(p);
}
-struct pa_pstream *pa_pstream_new(struct pa_mainloop_api *m, struct pa_iochannel *io, struct pa_memblock_stat *s) {
- struct pa_pstream *p;
+pa_pstream *pa_pstream_new(pa_mainloop_api *m, pa_iochannel *io, pa_memblock_stat *s) {
+ pa_pstream *p;
assert(io);
- p = pa_xmalloc(sizeof(struct pa_pstream));
+ p = pa_xmalloc(sizeof(pa_pstream));
p->ref = 1;
p->io = io;
pa_iochannel_set_callback(io, io_callback, p);
return p;
}
-static void item_free(void *item, void *p) {
+static void item_free(void *item, PA_GCC_UNUSED void *p) {
struct item_info *i = item;
assert(i);
pa_xfree(i);
}
-static void pstream_free(struct pa_pstream *p) {
+static void pstream_free(pa_pstream *p) {
assert(p);
pa_pstream_close(p);
pa_xfree(p);
}
-void pa_pstream_send_packet(struct pa_pstream*p, struct pa_packet *packet) {
+void pa_pstream_send_packet(pa_pstream*p, pa_packet *packet) {
struct item_info *i;
assert(p && packet && p->ref >= 1);
p->mainloop->defer_enable(p->defer_event, 1);
}
-void pa_pstream_send_memblock(struct pa_pstream*p, uint32_t channel, uint32_t delta, const struct pa_memchunk *chunk) {
+void pa_pstream_send_memblock(pa_pstream*p, uint32_t channel, uint32_t delta, const pa_memchunk *chunk) {
struct item_info *i;
assert(p && channel != (uint32_t) -1 && chunk && p->ref >= 1);
p->mainloop->defer_enable(p->defer_event, 1);
}
-void pa_pstream_set_recieve_packet_callback(struct pa_pstream *p, void (*callback) (struct pa_pstream *p, struct pa_packet *packet, void *userdata), void *userdata) {
+void pa_pstream_set_recieve_packet_callback(pa_pstream *p, void (*callback) (pa_pstream *p, pa_packet *packet, void *userdata), void *userdata) {
assert(p && callback);
p->recieve_packet_callback = callback;
p->recieve_packet_callback_userdata = userdata;
}
-void pa_pstream_set_recieve_memblock_callback(struct pa_pstream *p, void (*callback) (struct pa_pstream *p, uint32_t channel, uint32_t delta, const struct pa_memchunk *chunk, void *userdata), void *userdata) {
+void pa_pstream_set_recieve_memblock_callback(pa_pstream *p, void (*callback) (pa_pstream *p, uint32_t channel, uint32_t delta, const pa_memchunk *chunk, void *userdata), void *userdata) {
assert(p && callback);
p->recieve_memblock_callback = callback;
p->recieve_memblock_callback_userdata = userdata;
}
-static void prepare_next_write_item(struct pa_pstream *p) {
+static void prepare_next_write_item(pa_pstream *p) {
assert(p);
if (!(p->write.current = pa_queue_pop(p->send_queue)))
}
}
-static void do_write(struct pa_pstream *p) {
+static void do_write(pa_pstream *p) {
void *d;
size_t l;
ssize_t r;
p->die_callback(p, p->die_callback_userdata);
}
-static void do_read(struct pa_pstream *p) {
+static void do_read(pa_pstream *p) {
void *d;
- size_t l;
+ size_t l;
ssize_t r;
assert(p);
/* Frame payload available */
if (p->read.memblock && p->recieve_memblock_callback) { /* Is this memblock data? Than pass it to the user */
- size_t l;
-
l = (p->read.index - r) < PA_PSTREAM_DESCRIPTOR_SIZE ? p->read.index - PA_PSTREAM_DESCRIPTOR_SIZE : (size_t) r;
if (l > 0) {
- struct pa_memchunk chunk;
+ pa_memchunk chunk;
chunk.memblock = p->read.memblock;
chunk.index = p->read.index - PA_PSTREAM_DESCRIPTOR_SIZE - l;
}
-void pa_pstream_set_die_callback(struct pa_pstream *p, void (*callback)(struct pa_pstream *p, void *userdata), void *userdata) {
+void pa_pstream_set_die_callback(pa_pstream *p, void (*callback)(pa_pstream *p, void *userdata), void *userdata) {
assert(p && callback);
p->die_callback = callback;
p->die_callback_userdata = userdata;
}
-int pa_pstream_is_pending(struct pa_pstream *p) {
+int pa_pstream_is_pending(pa_pstream *p) {
assert(p);
if (p->dead)
return p->write.current || !pa_queue_is_empty(p->send_queue);
}
-void pa_pstream_set_drain_callback(struct pa_pstream *p, void (*cb)(struct pa_pstream *p, void *userdata), void *userdata) {
+void pa_pstream_set_drain_callback(pa_pstream *p, void (*cb)(pa_pstream *p, void *userdata), void *userdata) {
assert(p);
p->drain_callback = cb;
p->drain_userdata = userdata;
}
-void pa_pstream_unref(struct pa_pstream*p) {
+void pa_pstream_unref(pa_pstream*p) {
assert(p && p->ref >= 1);
if (!(--(p->ref)))
pstream_free(p);
}
-struct pa_pstream* pa_pstream_ref(struct pa_pstream*p) {
+pa_pstream* pa_pstream_ref(pa_pstream*p) {
assert(p && p->ref >= 1);
p->ref++;
return p;
}
-void pa_pstream_close(struct pa_pstream *p) {
+void pa_pstream_close(pa_pstream *p) {
assert(p);
p->dead = 1;
#include "mainloop-api.h"
#include "memchunk.h"
-struct pa_pstream;
+typedef struct pa_pstream pa_pstream;
-struct pa_pstream* pa_pstream_new(struct pa_mainloop_api *m, struct pa_iochannel *io, struct pa_memblock_stat *s);
-void pa_pstream_unref(struct pa_pstream*p);
-struct pa_pstream* pa_pstream_ref(struct pa_pstream*p);
+pa_pstream* pa_pstream_new(pa_mainloop_api *m, pa_iochannel *io, pa_memblock_stat *s);
+void pa_pstream_unref(pa_pstream*p);
+pa_pstream* pa_pstream_ref(pa_pstream*p);
-void pa_pstream_send_packet(struct pa_pstream*p, struct pa_packet *packet);
-void pa_pstream_send_memblock(struct pa_pstream*p, uint32_t channel, uint32_t delta, const struct pa_memchunk *chunk);
+void pa_pstream_send_packet(pa_pstream*p, pa_packet *packet);
+void pa_pstream_send_memblock(pa_pstream*p, uint32_t channel, uint32_t delta, const pa_memchunk *chunk);
-void pa_pstream_set_recieve_packet_callback(struct pa_pstream *p, void (*callback) (struct pa_pstream *p, struct pa_packet *packet, void *userdata), void *userdata);
-void pa_pstream_set_recieve_memblock_callback(struct pa_pstream *p, void (*callback) (struct pa_pstream *p, uint32_t channel, uint32_t delta, const struct pa_memchunk *chunk, void *userdata), void *userdata);
-void pa_pstream_set_drain_callback(struct pa_pstream *p, void (*cb)(struct pa_pstream *p, void *userdata), void *userdata);
+void pa_pstream_set_recieve_packet_callback(pa_pstream *p, void (*callback) (pa_pstream *p, pa_packet *packet, void *userdata), void *userdata);
+void pa_pstream_set_recieve_memblock_callback(pa_pstream *p, void (*callback) (pa_pstream *p, uint32_t channel, uint32_t delta, const pa_memchunk *chunk, void *userdata), void *userdata);
+void pa_pstream_set_drain_callback(pa_pstream *p, void (*cb)(pa_pstream *p, void *userdata), void *userdata);
-void pa_pstream_set_die_callback(struct pa_pstream *p, void (*callback)(struct pa_pstream *p, void *userdata), void *userdata);
+void pa_pstream_set_die_callback(pa_pstream *p, void (*callback)(pa_pstream *p, void *userdata), void *userdata);
-int pa_pstream_is_pending(struct pa_pstream *p);
+int pa_pstream_is_pending(pa_pstream *p);
-void pa_pstream_close(struct pa_pstream *p);
+void pa_pstream_close(pa_pstream *p);
#endif
unsigned length;
};
-struct pa_queue* pa_queue_new(void) {
- struct pa_queue *q = pa_xmalloc(sizeof(struct pa_queue));
+pa_queue* pa_queue_new(void) {
+ pa_queue *q = pa_xnew(pa_queue, 1);
q->front = q->back = NULL;
q->length = 0;
return q;
}
-void pa_queue_free(struct pa_queue* q, void (*destroy)(void *p, void *userdata), void *userdata) {
+void pa_queue_free(pa_queue* q, void (*destroy)(void *p, void *userdata), void *userdata) {
struct queue_entry *e;
assert(q);
pa_xfree(q);
}
-void pa_queue_push(struct pa_queue *q, void *p) {
+void pa_queue_push(pa_queue *q, void *p) {
struct queue_entry *e;
- e = pa_xmalloc(sizeof(struct queue_entry));
+ e = pa_xnew(struct queue_entry, 1);
e->data = p;
e->next = NULL;
q->length++;
}
-void* pa_queue_pop(struct pa_queue *q) {
+void* pa_queue_pop(pa_queue *q) {
void *p;
struct queue_entry *e;
assert(q);
return p;
}
-int pa_queue_is_empty(struct pa_queue *q) {
+int pa_queue_is_empty(pa_queue *q) {
assert(q);
return q->length == 0;
}
USA.
***/
-struct pa_queue;
+typedef struct pa_queue pa_queue;
/* A simple implementation of the abstract data type queue. Stores
* pointers as members. The memory has to be managed by the caller. */
-struct pa_queue* pa_queue_new(void);
+pa_queue* pa_queue_new(void);
/* Free the queue and run the specified callback function for every remaining entry. The callback function may be NULL. */
-void pa_queue_free(struct pa_queue* q, void (*destroy)(void *p, void *userdata), void *userdata);
+void pa_queue_free(pa_queue* q, void (*destroy)(void *p, void *userdata), void *userdata);
-void pa_queue_push(struct pa_queue *q, void *p);
-void* pa_queue_pop(struct pa_queue *q);
+void pa_queue_push(pa_queue *q, void *p);
+void* pa_queue_pop(pa_queue *q);
-int pa_queue_is_empty(struct pa_queue *q);
+int pa_queue_is_empty(pa_queue *q);
#endif
#include "log.h"
struct pa_resampler {
- struct pa_sample_spec i_ss, o_ss;
+ pa_sample_spec i_ss, o_ss;
size_t i_fz, o_fz;
- struct pa_memblock_stat *memblock_stat;
+ pa_memblock_stat *memblock_stat;
void *impl_data;
int channels;
- enum pa_resample_method resample_method;
+ pa_resample_method resample_method;
- void (*impl_free)(struct pa_resampler *r);
- void (*impl_set_input_rate)(struct pa_resampler *r, uint32_t rate);
- void (*impl_run)(struct pa_resampler *r, const struct pa_memchunk *in, struct pa_memchunk *out);
+ void (*impl_free)(pa_resampler *r);
+ void (*impl_set_input_rate)(pa_resampler *r, uint32_t rate);
+ void (*impl_run)(pa_resampler *r, const pa_memchunk *in, pa_memchunk *out);
};
struct impl_libsamplerate {
unsigned i_counter;
};
-static int libsamplerate_init(struct pa_resampler*r);
-static int trivial_init(struct pa_resampler*r);
+static int libsamplerate_init(pa_resampler*r);
+static int trivial_init(pa_resampler*r);
-struct pa_resampler* pa_resampler_new(const struct pa_sample_spec *a, const struct pa_sample_spec *b, struct pa_memblock_stat *s, enum pa_resample_method resample_method) {
- struct pa_resampler *r = NULL;
+pa_resampler* pa_resampler_new(const pa_sample_spec *a, const pa_sample_spec *b, pa_memblock_stat *s, pa_resample_method resample_method) {
+ pa_resampler *r = NULL;
assert(a && b && pa_sample_spec_valid(a) && pa_sample_spec_valid(b) && resample_method != PA_RESAMPLER_INVALID);
if (a->channels != b->channels && a->channels != 1 && b->channels != 1)
goto fail;
- r = pa_xmalloc(sizeof(struct pa_resampler));
+ r = pa_xmalloc(sizeof(pa_resampler));
r->impl_data = NULL;
r->memblock_stat = s;
r->resample_method = resample_method;
return NULL;
}
-void pa_resampler_free(struct pa_resampler *r) {
+void pa_resampler_free(pa_resampler *r) {
assert(r);
if (r->impl_free)
pa_xfree(r);
}
-void pa_resampler_set_input_rate(struct pa_resampler *r, uint32_t rate) {
+void pa_resampler_set_input_rate(pa_resampler *r, uint32_t rate) {
assert(r && rate);
r->i_ss.rate = rate;
r->impl_set_input_rate(r, rate);
}
-void pa_resampler_run(struct pa_resampler *r, const struct pa_memchunk *in, struct pa_memchunk *out) {
+void pa_resampler_run(pa_resampler *r, const pa_memchunk *in, pa_memchunk *out) {
assert(r && in && out && r->impl_run);
r->impl_run(r, in, out);
}
-size_t pa_resampler_request(struct pa_resampler *r, size_t out_length) {
+size_t pa_resampler_request(pa_resampler *r, size_t out_length) {
assert(r && (out_length % r->o_fz) == 0);
return (((out_length / r->o_fz)*r->i_ss.rate)/r->o_ss.rate) * r->i_fz;
}
-enum pa_resample_method pa_resampler_get_method(struct pa_resampler *r) {
+pa_resample_method pa_resampler_get_method(pa_resampler *r) {
assert(r);
return r->resample_method;
}
/* Parse a libsamplrate compatible resampling implementation */
-enum pa_resample_method pa_parse_resample_method(const char *string) {
+pa_resample_method pa_parse_resample_method(const char *string) {
assert(string);
if (!strcmp(string, "src-sinc-best-quality"))
/*** libsamplerate based implementation ***/
-static void libsamplerate_free(struct pa_resampler *r) {
+static void libsamplerate_free(pa_resampler *r) {
struct impl_libsamplerate *i;
assert(r && r->impl_data);
i = r->impl_data;
pa_xfree(i);
}
-static void libsamplerate_run(struct pa_resampler *r, const struct pa_memchunk *in, struct pa_memchunk *out) {
+static void libsamplerate_run(pa_resampler *r, const pa_memchunk *in, pa_memchunk *out) {
unsigned i_nchannels, o_nchannels, ins, ons, eff_ins, eff_ons;
float *cbuf;
struct impl_libsamplerate *i;
}
}
-static void libsamplerate_set_input_rate(struct pa_resampler *r, uint32_t rate) {
+static void libsamplerate_set_input_rate(pa_resampler *r, uint32_t rate) {
int ret;
struct impl_libsamplerate *i;
assert(r && rate > 0 && r->impl_data);
assert(ret == 0);
}
-static int libsamplerate_init(struct pa_resampler *r) {
+static int libsamplerate_init(pa_resampler *r) {
struct impl_libsamplerate *i = NULL;
int err;
/* Trivial implementation */
-static void trivial_run(struct pa_resampler *r, const struct pa_memchunk *in, struct pa_memchunk *out) {
+static void trivial_run(pa_resampler *r, const pa_memchunk *in, pa_memchunk *out) {
size_t fz;
unsigned nframes;
struct impl_trivial *i;
}
}
-static void trivial_free(struct pa_resampler *r) {
+static void trivial_free(pa_resampler *r) {
assert(r);
pa_xfree(r->impl_data);
}
-static void trivial_set_input_rate(struct pa_resampler *r, uint32_t rate) {
+static void trivial_set_input_rate(pa_resampler *r, uint32_t rate) {
struct impl_trivial *i;
assert(r && rate > 0 && r->impl_data);
i = r->impl_data;
i->o_counter = 0;
}
-static int trivial_init(struct pa_resampler*r) {
+static int trivial_init(pa_resampler*r) {
struct impl_trivial *i;
assert(r && r->i_ss.format == r->o_ss.format && r->i_ss.channels == r->o_ss.channels);
return 0;
}
-const char *pa_resample_method_to_string(enum pa_resample_method m) {
+const char *pa_resample_method_to_string(pa_resample_method m) {
static const char * const resample_methods[] = {
"src-sinc-best-quality",
"src-sinc-medium-quality",
#include "memblock.h"
#include "memchunk.h"
-struct pa_resampler;
+typedef struct pa_resampler pa_resampler;
-enum pa_resample_method {
+typedef enum pa_resample_method {
PA_RESAMPLER_INVALID = -1,
PA_RESAMPLER_SRC_SINC_BEST_QUALITY = SRC_SINC_BEST_QUALITY,
PA_RESAMPLER_SRC_SINC_MEDIUM_QUALITY = SRC_SINC_MEDIUM_QUALITY,
PA_RESAMPLER_SRC_LINEAR = SRC_LINEAR,
PA_RESAMPLER_TRIVIAL,
PA_RESAMPLER_MAX
-};
+} pa_resample_method;
-struct pa_resampler* pa_resampler_new(const struct pa_sample_spec *a, const struct pa_sample_spec *b, struct pa_memblock_stat *s, int resample_method);
-void pa_resampler_free(struct pa_resampler *r);
+pa_resampler* pa_resampler_new(const pa_sample_spec *a, const pa_sample_spec *b, pa_memblock_stat *s, int resample_method);
+void pa_resampler_free(pa_resampler *r);
/* Returns the size of an input memory block which is required to return the specified amount of output data */
-size_t pa_resampler_request(struct pa_resampler *r, size_t out_length);
+size_t pa_resampler_request(pa_resampler *r, size_t out_length);
/* Pass the specified memory chunk to the resampler and return the newly resampled data */
-void pa_resampler_run(struct pa_resampler *r, const struct pa_memchunk *in, struct pa_memchunk *out);
+void pa_resampler_run(pa_resampler *r, const pa_memchunk *in, pa_memchunk *out);
/* Change the input rate of the resampler object */
-void pa_resampler_set_input_rate(struct pa_resampler *r, uint32_t rate);
+void pa_resampler_set_input_rate(pa_resampler *r, uint32_t rate);
/* Return the resampling method of the resampler object */
-enum pa_resample_method pa_resampler_get_method(struct pa_resampler *r);
+pa_resample_method pa_resampler_get_method(pa_resampler *r);
/* Try to parse the resampler method */
-enum pa_resample_method pa_parse_resample_method(const char *string);
+pa_resample_method pa_parse_resample_method(const char *string);
/* return a human readable string for the specified resampling method. Inverse of pa_parse_resample_method() */
-const char *pa_resample_method_to_string(enum pa_resample_method m);
+const char *pa_resample_method_to_string(pa_resample_method m);
#endif
#include "sample-util.h"
-struct pa_memblock *pa_silence_memblock(struct pa_memblock* b, const struct pa_sample_spec *spec) {
+pa_memblock *pa_silence_memblock(pa_memblock* b, const pa_sample_spec *spec) {
assert(b && b->data && spec);
pa_silence_memory(b->data, b->length, spec);
return b;
}
-void pa_silence_memchunk(struct pa_memchunk *c, const struct pa_sample_spec *spec) {
+void pa_silence_memchunk(pa_memchunk *c, const pa_sample_spec *spec) {
assert(c && c->memblock && c->memblock->data && spec && c->length);
pa_silence_memory((uint8_t*) c->memblock->data+c->index, c->length, spec);
}
-void pa_silence_memory(void *p, size_t length, const struct pa_sample_spec *spec) {
+void pa_silence_memory(void *p, size_t length, const pa_sample_spec *spec) {
uint8_t c = 0;
assert(p && length && spec);
memset(p, c, length);
}
-size_t pa_mix(struct pa_mix_info channels[], unsigned nchannels, void *data, size_t length, const struct pa_sample_spec *spec, pa_volume_t volume) {
+size_t pa_mix(pa_mix_info channels[], unsigned nchannels, void *data, size_t length, const pa_sample_spec *spec, pa_volume_t volume) {
assert(channels && data && length && spec);
if (spec->format == PA_SAMPLE_S16NE) {
size_t d;
for (d = 0;; d += sizeof(float)) {
- pa_volume_t sum = 0;
+ float sum = 0;
unsigned c;
if (d >= length)
}
-void pa_volume_memchunk(struct pa_memchunk*c, const struct pa_sample_spec *spec, pa_volume_t volume) {
+void pa_volume_memchunk(pa_memchunk*c, const pa_sample_spec *spec, pa_volume_t volume) {
assert(c && spec && (c->length % pa_frame_size(spec) == 0));
if (volume == PA_VOLUME_NORM)
#include "memchunk.h"
-struct pa_memblock *pa_silence_memblock(struct pa_memblock* b, const struct pa_sample_spec *spec);
-void pa_silence_memchunk(struct pa_memchunk *c, const struct pa_sample_spec *spec);
-void pa_silence_memory(void *p, size_t length, const struct pa_sample_spec *spec);
+pa_memblock *pa_silence_memblock(pa_memblock* b, const pa_sample_spec *spec);
+void pa_silence_memchunk(pa_memchunk *c, const pa_sample_spec *spec);
+void pa_silence_memory(void *p, size_t length, const pa_sample_spec *spec);
-struct pa_mix_info {
- struct pa_memchunk chunk;
+typedef struct pa_mix_info {
+ pa_memchunk chunk;
pa_volume_t volume;
void *userdata;
-};
+} pa_mix_info ;
-size_t pa_mix(struct pa_mix_info channels[], unsigned nchannels, void *data, size_t length, const struct pa_sample_spec *spec, pa_volume_t volume);
+size_t pa_mix(pa_mix_info channels[], unsigned nchannels, void *data, size_t length, const pa_sample_spec *spec, pa_volume_t volume);
-void pa_volume_memchunk(struct pa_memchunk*c, const struct pa_sample_spec *spec, pa_volume_t volume);
+void pa_volume_memchunk(pa_memchunk*c, const pa_sample_spec *spec, pa_volume_t volume);
#endif
#include "sample.h"
-size_t pa_frame_size(const struct pa_sample_spec *spec) {
+size_t pa_frame_size(const pa_sample_spec *spec) {
size_t b = 1;
assert(spec);
return b * spec->channels;
}
-size_t pa_bytes_per_second(const struct pa_sample_spec *spec) {
+size_t pa_bytes_per_second(const pa_sample_spec *spec) {
assert(spec);
return spec->rate*pa_frame_size(spec);
}
-pa_usec_t pa_bytes_to_usec(uint64_t length, const struct pa_sample_spec *spec) {
+pa_usec_t pa_bytes_to_usec(uint64_t length, const pa_sample_spec *spec) {
assert(spec);
return (pa_usec_t) (((double) length/pa_frame_size(spec)*1000000)/spec->rate);
}
-int pa_sample_spec_valid(const struct pa_sample_spec *spec) {
+int pa_sample_spec_valid(const pa_sample_spec *spec) {
assert(spec);
if (spec->rate <= 0 || spec->channels <= 0)
return 1;
}
-int pa_sample_spec_equal(const struct pa_sample_spec*a, const struct pa_sample_spec*b) {
+int pa_sample_spec_equal(const pa_sample_spec*a, const pa_sample_spec*b) {
assert(a && b);
return (a->format == b->format) && (a->rate == b->rate) && (a->channels == b->channels);
}
-const char *pa_sample_format_to_string(enum pa_sample_format f) {
+const char *pa_sample_format_to_string(pa_sample_format f) {
static const char* const table[]= {
[PA_SAMPLE_U8] = "U8",
[PA_SAMPLE_ALAW] = "ALAW",
return table[f];
}
-char *pa_sample_spec_snprint(char *s, size_t l, const struct pa_sample_spec *spec) {
+char *pa_sample_spec_snprint(char *s, size_t l, const pa_sample_spec *spec) {
assert(s && l && spec);
if (!pa_sample_spec_valid(spec))
snprintf(s, l, "%u B", (unsigned) v);
}
-enum pa_sample_format pa_parse_sample_format(const char *format) {
+pa_sample_format pa_parse_sample_format(const char *format) {
if (strcasecmp(format, "s16le") == 0)
return PA_SAMPLE_S16LE;
PA_C_DECL_BEGIN
/** Sample format */
-enum pa_sample_format {
+typedef enum pa_sample_format {
PA_SAMPLE_U8, /**< Unsigned 8 Bit PCM */
PA_SAMPLE_ALAW, /**< 8 Bit a-Law */
PA_SAMPLE_ULAW, /**< 8 Bit mu-Law */
PA_SAMPLE_FLOAT32BE, /**< 32 Bit IEEE floating point, big endian, range -1..1 */
PA_SAMPLE_MAX, /**< Upper limit of valid sample types */
PA_SAMPLE_INVALID = -1 /**< An invalid value */
-};
+} pa_sample_format;
#ifdef WORDS_BIGENDIAN
/** Signed 16 Bit PCM, native endian */
#define PA_SAMPLE_FLOAT32 PA_SAMPLE_FLOAT32NE
/** A sample format and attribute specification */
-struct pa_sample_spec {
- enum pa_sample_format format; /**< The sample format */
+typedef struct pa_sample_spec {
+ pa_sample_format format; /**< The sample format */
uint32_t rate; /**< The sample rate. (e.g. 44100) */
uint8_t channels; /**< Audio channels. (1 for mono, 2 for stereo, ...) */
-};
+} pa_sample_spec;
/** Type for usec specifications (unsigned). May be either 32 or 64 bit, depending on the architecture */
typedef uint64_t pa_usec_t;
/** Return the amount of bytes playback of a second of audio with the specified sample type takes */
-size_t pa_bytes_per_second(const struct pa_sample_spec *spec);
+size_t pa_bytes_per_second(const pa_sample_spec *spec);
/** Return the size of a frame with the specific sample type */
-size_t pa_frame_size(const struct pa_sample_spec *spec);
+size_t pa_frame_size(const pa_sample_spec *spec);
/** Calculate the time the specified bytes take to play with the specified sample type */
-pa_usec_t pa_bytes_to_usec(uint64_t length, const struct pa_sample_spec *spec);
+pa_usec_t pa_bytes_to_usec(uint64_t length, const pa_sample_spec *spec);
/** Return non-zero when the sample type specification is valid */
-int pa_sample_spec_valid(const struct pa_sample_spec *spec);
+int pa_sample_spec_valid(const pa_sample_spec *spec);
/** Return non-zero when the two sample type specifications match */
-int pa_sample_spec_equal(const struct pa_sample_spec*a, const struct pa_sample_spec*b);
+int pa_sample_spec_equal(const pa_sample_spec*a, const pa_sample_spec*b);
/* Return a descriptive string for the specified sample format. \since 0.8 */
-const char *pa_sample_format_to_string(enum pa_sample_format f);
+const char *pa_sample_format_to_string(pa_sample_format f);
/** Maximum required string length for pa_sample_spec_snprint() */
#define PA_SAMPLE_SPEC_SNPRINT_MAX 32
/** Pretty print a sample type specification to a string */
-char* pa_sample_spec_snprint(char *s, size_t l, const struct pa_sample_spec *spec);
+char* pa_sample_spec_snprint(char *s, size_t l, const pa_sample_spec *spec);
/** Volume specification: 0: silence; < 256: diminished volume; 256: normal volume; > 256 amplified volume */
typedef uint32_t pa_volume_t;
void pa_bytes_snprint(char *s, size_t l, unsigned v);
/** Parse a sample format text. Inverse of pa_sample_format_to_string() */
-enum pa_sample_format pa_parse_sample_format(const char *format);
+pa_sample_format pa_parse_sample_format(const char *format);
PA_C_DECL_END
#define UNLOAD_POLL_TIME 2
-static void timeout_callback(struct pa_mainloop_api *m, struct pa_time_event*e, const struct timeval *tv, void *userdata) {
- struct pa_core *c = userdata;
+static void timeout_callback(pa_mainloop_api *m, pa_time_event*e, PA_GCC_UNUSED const struct timeval *tv, void *userdata) {
+ pa_core *c = userdata;
struct timeval ntv;
assert(c && c->mainloop == m && c->scache_auto_unload_event == e);
m->time_restart(e, &ntv);
}
-static void free_entry(struct pa_scache_entry *e) {
+static void free_entry(pa_scache_entry *e) {
assert(e);
pa_namereg_unregister(e->core, e->name);
pa_subscription_post(e->core, PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE|PA_SUBSCRIPTION_EVENT_REMOVE, e->index);
pa_xfree(e);
}
-static struct pa_scache_entry* scache_add_item(struct pa_core *c, const char *name) {
- struct pa_scache_entry *e;
+static pa_scache_entry* scache_add_item(pa_core *c, const char *name) {
+ pa_scache_entry *e;
assert(c && name);
if ((e = pa_namereg_get(c, name, PA_NAMEREG_SAMPLE, 0))) {
pa_subscription_post(c, PA_SUBSCRIPTION_EVENT_SAMPLE_CACHE|PA_SUBSCRIPTION_EVENT_CHANGE, e->index);
} else {
- e = pa_xmalloc(sizeof(struct pa_scache_entry));
+ e = pa_xmalloc(sizeof(pa_scache_entry));
if (!pa_namereg_register(c, name, PA_NAMEREG_SAMPLE, e, 1)) {
pa_xfree(e);
e->lazy = 0;
e->last_used_time = 0;
- memset(&e->sample_spec, 0, sizeof(struct pa_sample_spec));
+ memset(&e->sample_spec, 0, sizeof(pa_sample_spec));
return e;
}
-int pa_scache_add_item(struct pa_core *c, const char *name, struct pa_sample_spec *ss, struct pa_memchunk *chunk, uint32_t *index) {
- struct pa_scache_entry *e;
+int pa_scache_add_item(pa_core *c, const char *name, pa_sample_spec *ss, pa_memchunk *chunk, uint32_t *idx) {
+ pa_scache_entry *e;
assert(c && name);
if (!(e = scache_add_item(c, name)))
pa_memblock_ref(e->memchunk.memblock);
}
- if (index)
- *index = e->index;
+ if (idx)
+ *idx = e->index;
return 0;
}
-int pa_scache_add_file(struct pa_core *c, const char *name, const char *filename, uint32_t *index) {
- struct pa_sample_spec ss;
- struct pa_memchunk chunk;
+int pa_scache_add_file(pa_core *c, const char *name, const char *filename, uint32_t *idx) {
+ pa_sample_spec ss;
+ pa_memchunk chunk;
int r;
#ifdef OS_IS_WIN32
if (pa_sound_file_load(filename, &ss, &chunk, c->memblock_stat) < 0)
return -1;
- r = pa_scache_add_item(c, name, &ss, &chunk, index);
+ r = pa_scache_add_item(c, name, &ss, &chunk, idx);
pa_memblock_unref(chunk.memblock);
return r;
}
-int pa_scache_add_file_lazy(struct pa_core *c, const char *name, const char *filename, uint32_t *index) {
- struct pa_scache_entry *e;
+int pa_scache_add_file_lazy(pa_core *c, const char *name, const char *filename, uint32_t *idx) {
+ pa_scache_entry *e;
#ifdef OS_IS_WIN32
char buf[MAX_PATH];
c->scache_auto_unload_event = c->mainloop->time_new(c->mainloop, &ntv, timeout_callback, c);
}
+ if (idx)
+ *idx = e->index;
+
return 0;
}
-int pa_scache_remove_item(struct pa_core *c, const char *name) {
- struct pa_scache_entry *e;
+int pa_scache_remove_item(pa_core *c, const char *name) {
+ pa_scache_entry *e;
assert(c && name);
if (!(e = pa_namereg_get(c, name, PA_NAMEREG_SAMPLE, 0)))
return 0;
}
-static void free_cb(void *p, void *userdata) {
- struct pa_scache_entry *e = p;
+static void free_cb(void *p, PA_GCC_UNUSED void *userdata) {
+ pa_scache_entry *e = p;
assert(e);
free_entry(e);
}
-void pa_scache_free(struct pa_core *c) {
+void pa_scache_free(pa_core *c) {
assert(c);
if (c->scache) {
c->mainloop->time_free(c->scache_auto_unload_event);
}
-int pa_scache_play_item(struct pa_core *c, const char *name, struct pa_sink *sink, uint32_t volume) {
- struct pa_scache_entry *e;
+int pa_scache_play_item(pa_core *c, const char *name, pa_sink *sink, uint32_t volume) {
+ pa_scache_entry *e;
char *t;
assert(c && name && sink);
return 0;
}
-const char * pa_scache_get_name_by_id(struct pa_core *c, uint32_t id) {
- struct pa_scache_entry *e;
+const char * pa_scache_get_name_by_id(pa_core *c, uint32_t id) {
+ pa_scache_entry *e;
assert(c && id != PA_IDXSET_INVALID);
if (!c->scache || !(e = pa_idxset_get_by_index(c->scache, id)))
return e->name;
}
-uint32_t pa_scache_get_id_by_name(struct pa_core *c, const char *name) {
- struct pa_scache_entry *e;
+uint32_t pa_scache_get_id_by_name(pa_core *c, const char *name) {
+ pa_scache_entry *e;
assert(c && name);
if (!(e = pa_namereg_get(c, name, PA_NAMEREG_SAMPLE, 0)))
return e->index;
}
-uint32_t pa_scache_total_size(struct pa_core *c) {
- struct pa_scache_entry *e;
- uint32_t index, sum = 0;
+uint32_t pa_scache_total_size(pa_core *c) {
+ pa_scache_entry *e;
+ uint32_t idx, sum = 0;
assert(c);
- if (!c->scache || !pa_idxset_ncontents(c->scache))
+ if (!c->scache || !pa_idxset_size(c->scache))
return 0;
- for (e = pa_idxset_first(c->scache, &index); e; e = pa_idxset_next(c->scache, &index))
+ for (e = pa_idxset_first(c->scache, &idx); e; e = pa_idxset_next(c->scache, &idx))
if (e->memchunk.memblock)
sum += e->memchunk.length;
return sum;
}
-void pa_scache_unload_unused(struct pa_core *c) {
- struct pa_scache_entry *e;
+void pa_scache_unload_unused(pa_core *c) {
+ pa_scache_entry *e;
time_t now;
- uint32_t index;
+ uint32_t idx;
assert(c);
- if (!c->scache || !pa_idxset_ncontents(c->scache))
+ if (!c->scache || !pa_idxset_size(c->scache))
return;
time(&now);
- for (e = pa_idxset_first(c->scache, &index); e; e = pa_idxset_next(c->scache, &index)) {
+ for (e = pa_idxset_first(c->scache, &idx); e; e = pa_idxset_next(c->scache, &idx)) {
if (!e->lazy || !e->memchunk.memblock)
continue;
}
}
-static void add_file(struct pa_core *c, const char *pathname) {
+static void add_file(pa_core *c, const char *pathname) {
struct stat st;
const char *e;
pa_scache_add_file_lazy(c, e, pathname, NULL);
}
-int pa_scache_add_directory_lazy(struct pa_core *c, const char *pathname) {
+int pa_scache_add_directory_lazy(pa_core *c, const char *pathname) {
DIR *dir;
assert(c && pathname);
#include "memchunk.h"
#include "sink.h"
-struct pa_scache_entry {
- struct pa_core *core;
+typedef struct pa_scache_entry {
+ pa_core *core;
uint32_t index;
char *name;
uint32_t volume;
- struct pa_sample_spec sample_spec;
- struct pa_memchunk memchunk;
+ pa_sample_spec sample_spec;
+ pa_memchunk memchunk;
char *filename;
int lazy;
time_t last_used_time;
-};
+} pa_scache_entry;
-int pa_scache_add_item(struct pa_core *c, const char *name, struct pa_sample_spec *ss, struct pa_memchunk *chunk, uint32_t *index);
-int pa_scache_add_file(struct pa_core *c, const char *name, const char *filename, uint32_t *index);
-int pa_scache_add_file_lazy(struct pa_core *c, const char *name, const char *filename, uint32_t *index);
+int pa_scache_add_item(pa_core *c, const char *name, pa_sample_spec *ss, pa_memchunk *chunk, uint32_t *idx);
+int pa_scache_add_file(pa_core *c, const char *name, const char *filename, uint32_t *idx);
+int pa_scache_add_file_lazy(pa_core *c, const char *name, const char *filename, uint32_t *idx);
-int pa_scache_add_directory_lazy(struct pa_core *c, const char *pathname);
+int pa_scache_add_directory_lazy(pa_core *c, const char *pathname);
-int pa_scache_remove_item(struct pa_core *c, const char *name);
-int pa_scache_play_item(struct pa_core *c, const char *name, struct pa_sink *sink, uint32_t volume);
-void pa_scache_free(struct pa_core *c);
+int pa_scache_remove_item(pa_core *c, const char *name);
+int pa_scache_play_item(pa_core *c, const char *name, pa_sink *sink, uint32_t volume);
+void pa_scache_free(pa_core *c);
-const char *pa_scache_get_name_by_id(struct pa_core *c, uint32_t id);
-uint32_t pa_scache_get_id_by_name(struct pa_core *c, const char *name);
+const char *pa_scache_get_name_by_id(pa_core *c, uint32_t id);
+uint32_t pa_scache_get_id_by_name(pa_core *c, const char *name);
-uint32_t pa_scache_total_size(struct pa_core *c);
+uint32_t pa_scache_total_size(pa_core *c);
-void pa_scache_unload_unused(struct pa_core *c);
+void pa_scache_unload_unused(pa_core *c);
#endif
#include <config.h>
#endif
-#include "sconv-s16be.h"
-
#define INT16_FROM INT16_FROM_BE
#define INT16_TO INT16_TO_BE
#define pa_sconv_s16le_to_float32ne pa_sconv_s16be_to_float32ne
#define pa_sconv_s16le_from_float32ne pa_sconv_s16be_from_float32ne
+#include "sconv-s16le.h"
#include "sconv-s16le.c"
#include "endianmacros.h"
#include "sconv.h"
+#include "sconv-s16le.h"
#include "log.h"
#ifndef INT16_FROM
float sum = 0;
for (i = 0; i < an; i++)
- sum += (float) st_ulaw2linear16(*ca++) / 0x7FFF;
+ sum += st_ulaw2linear16(*ca++) * 1.0F / 0x7FFF;
if (sum > 1)
sum = 1;
float sum = 0;
for (i = 0; i < an; i++)
- sum += (float) st_alaw2linear16(*ca++) / 0x7FFF;
+ sum += st_alaw2linear16(*ca++) * 1.0F / 0x7FFF;
if (sum > 1)
sum = 1;
}
-pa_convert_to_float32ne_func_t pa_get_convert_to_float32ne_function(enum pa_sample_format f) {
+pa_convert_to_float32ne_func_t pa_get_convert_to_float32ne_function(pa_sample_format f) {
switch(f) {
case PA_SAMPLE_U8:
return u8_to_float32ne;
}
}
-pa_convert_from_float32ne_func_t pa_get_convert_from_float32ne_function(enum pa_sample_format f) {
+pa_convert_from_float32ne_func_t pa_get_convert_from_float32ne_function(pa_sample_format f) {
switch(f) {
case PA_SAMPLE_U8:
return u8_from_float32ne;
typedef void (*pa_convert_to_float32ne_func_t)(unsigned n, const void *a, unsigned an, float *b);
typedef void (*pa_convert_from_float32ne_func_t)(unsigned n, const float *a, void *b, unsigned bn);
-pa_convert_to_float32ne_func_t pa_get_convert_to_float32ne_function(enum pa_sample_format f);
-pa_convert_from_float32ne_func_t pa_get_convert_from_float32ne_function(enum pa_sample_format f);
+pa_convert_to_float32ne_func_t pa_get_convert_to_float32ne_function(pa_sample_format f);
+pa_convert_from_float32ne_func_t pa_get_convert_from_float32ne_function(pa_sample_format f);
#endif
#define CONVERT_BUFFER_LENGTH 4096
-struct pa_sink_input* pa_sink_input_new(struct pa_sink *s, pa_typeid_t typeid, const char *name, const struct pa_sample_spec *spec, int variable_rate, int resample_method) {
- struct pa_sink_input *i;
- struct pa_resampler *resampler = NULL;
+pa_sink_input* pa_sink_input_new(pa_sink *s, pa_typeid_t typeid, const char *name, const pa_sample_spec *spec, int variable_rate, int resample_method) {
+ pa_sink_input *i;
+ pa_resampler *resampler = NULL;
int r;
char st[256];
assert(s && spec && s->state == PA_SINK_RUNNING);
- if (pa_idxset_ncontents(s->inputs) >= PA_MAX_INPUTS_PER_SINK) {
+ if (pa_idxset_size(s->inputs) >= PA_MAX_INPUTS_PER_SINK) {
pa_log(__FILE__": Failed to create sink input: too many inputs per sink.\n");
return NULL;
}
if (!(resampler = pa_resampler_new(spec, &s->sample_spec, s->core->memblock_stat, resample_method)))
return NULL;
- i = pa_xmalloc(sizeof(struct pa_sink_input));
+ i = pa_xmalloc(sizeof(pa_sink_input));
i->ref = 1;
i->state = PA_SINK_INPUT_RUNNING;
i->name = pa_xstrdup(name);
return i;
}
-void pa_sink_input_disconnect(struct pa_sink_input *i) {
+void pa_sink_input_disconnect(pa_sink_input *i) {
assert(i && i->state != PA_SINK_INPUT_DISCONNECTED && i->sink && i->sink->core);
pa_idxset_remove_by_data(i->sink->core->sink_inputs, i, NULL);
i->state = PA_SINK_INPUT_DISCONNECTED;
}
-static void sink_input_free(struct pa_sink_input* i) {
+static void sink_input_free(pa_sink_input* i) {
assert(i);
if (i->state != PA_SINK_INPUT_DISCONNECTED)
pa_xfree(i);
}
-void pa_sink_input_unref(struct pa_sink_input *i) {
+void pa_sink_input_unref(pa_sink_input *i) {
assert(i && i->ref >= 1);
if (!(--i->ref))
sink_input_free(i);
}
-struct pa_sink_input* pa_sink_input_ref(struct pa_sink_input *i) {
+pa_sink_input* pa_sink_input_ref(pa_sink_input *i) {
assert(i && i->ref >= 1);
i->ref++;
return i;
}
-void pa_sink_input_kill(struct pa_sink_input*i) {
+void pa_sink_input_kill(pa_sink_input*i) {
assert(i && i->ref >= 1);
if (i->kill)
i->kill(i);
}
-pa_usec_t pa_sink_input_get_latency(struct pa_sink_input *i) {
+pa_usec_t pa_sink_input_get_latency(pa_sink_input *i) {
pa_usec_t r = 0;
assert(i && i->ref >= 1);
return r;
}
-int pa_sink_input_peek(struct pa_sink_input *i, struct pa_memchunk *chunk) {
+int pa_sink_input_peek(pa_sink_input *i, pa_memchunk *chunk) {
int ret = -1;
assert(i && chunk && i->ref >= 1);
}
while (!i->resampled_chunk.memblock) {
- struct pa_memchunk tchunk;
+ pa_memchunk tchunk;
size_t l;
if ((ret = i->peek(i, &tchunk)) < 0)
return ret;
}
-void pa_sink_input_drop(struct pa_sink_input *i, const struct pa_memchunk *chunk, size_t length) {
+void pa_sink_input_drop(pa_sink_input *i, const pa_memchunk *chunk, size_t length) {
assert(i && length && i->ref >= 1);
if (!i->resampler) {
}
}
-void pa_sink_input_set_volume(struct pa_sink_input *i, pa_volume_t volume) {
+void pa_sink_input_set_volume(pa_sink_input *i, pa_volume_t volume) {
assert(i && i->sink && i->sink->core && i->ref >= 1);
if (i->volume != volume) {
}
}
-void pa_sink_input_cork(struct pa_sink_input *i, int b) {
+void pa_sink_input_cork(pa_sink_input *i, int b) {
int n;
assert(i && i->ref >= 1);
pa_sink_notify(i->sink);
}
-void pa_sink_input_set_rate(struct pa_sink_input *i, uint32_t rate) {
+void pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate) {
assert(i && i->resampler && i->ref >= 1);
if (i->sample_spec.rate == rate)
pa_resampler_set_input_rate(i->resampler, rate);
}
-void pa_sink_input_set_name(struct pa_sink_input *i, const char *name) {
+void pa_sink_input_set_name(pa_sink_input *i, const char *name) {
assert(i && i->ref >= 1);
pa_xfree(i->name);
pa_subscription_post(i->sink->core, PA_SUBSCRIPTION_EVENT_SINK_INPUT|PA_SUBSCRIPTION_EVENT_CHANGE, i->index);
}
-enum pa_resample_method pa_sink_input_get_resample_method(struct pa_sink_input *i) {
+pa_resample_method pa_sink_input_get_resample_method(pa_sink_input *i) {
assert(i && i->ref >= 1);
if (!i->resampler)
#include <inttypes.h>
+typedef struct pa_sink_input pa_sink_input;
+
#include "sink.h"
#include "sample.h"
#include "memblockq.h"
#include "module.h"
#include "client.h"
-enum pa_sink_input_state {
+typedef enum {
PA_SINK_INPUT_RUNNING,
PA_SINK_INPUT_CORKED,
PA_SINK_INPUT_DISCONNECTED
-};
+} pa_sink_input_state ;
struct pa_sink_input {
int ref;
- enum pa_sink_input_state state;
+ pa_sink_input_state state;
uint32_t index;
pa_typeid_t typeid;
char *name;
- struct pa_module *owner;
- struct pa_client *client;
- struct pa_sink *sink;
- struct pa_sample_spec sample_spec;
+ pa_module *owner;
+ pa_client *client;
+ pa_sink *sink;
+ pa_sample_spec sample_spec;
uint32_t volume;
- int (*peek) (struct pa_sink_input *i, struct pa_memchunk *chunk);
- void (*drop) (struct pa_sink_input *i, const struct pa_memchunk *chunk, size_t length);
- void (*kill) (struct pa_sink_input *i);
- pa_usec_t (*get_latency) (struct pa_sink_input *i);
- void (*underrun) (struct pa_sink_input *i);
+ int (*peek) (pa_sink_input *i, pa_memchunk *chunk);
+ void (*drop) (pa_sink_input *i, const pa_memchunk *chunk, size_t length);
+ void (*kill) (pa_sink_input *i);
+ pa_usec_t (*get_latency) (pa_sink_input *i);
+ void (*underrun) (pa_sink_input *i);
void *userdata;
int playing;
- struct pa_memchunk resampled_chunk;
- struct pa_resampler *resampler;
+ pa_memchunk resampled_chunk;
+ pa_resampler *resampler;
};
-struct pa_sink_input* pa_sink_input_new(struct pa_sink *s, pa_typeid_t typeid, const char *name, const struct pa_sample_spec *spec, int variable_rate, int resample_method);
-void pa_sink_input_unref(struct pa_sink_input* i);
-struct pa_sink_input* pa_sink_input_ref(struct pa_sink_input* i);
+pa_sink_input* pa_sink_input_new(pa_sink *s, pa_typeid_t typeid, const char *name, const pa_sample_spec *spec, int variable_rate, int resample_method);
+void pa_sink_input_unref(pa_sink_input* i);
+pa_sink_input* pa_sink_input_ref(pa_sink_input* i);
/* To be called by the implementing module only */
-void pa_sink_input_disconnect(struct pa_sink_input* i);
+void pa_sink_input_disconnect(pa_sink_input* i);
/* External code may request disconnection with this funcion */
-void pa_sink_input_kill(struct pa_sink_input*i);
+void pa_sink_input_kill(pa_sink_input*i);
-pa_usec_t pa_sink_input_get_latency(struct pa_sink_input *i);
+pa_usec_t pa_sink_input_get_latency(pa_sink_input *i);
-int pa_sink_input_peek(struct pa_sink_input *i, struct pa_memchunk *chunk);
-void pa_sink_input_drop(struct pa_sink_input *i, const struct pa_memchunk *chunk, size_t length);
+int pa_sink_input_peek(pa_sink_input *i, pa_memchunk *chunk);
+void pa_sink_input_drop(pa_sink_input *i, const pa_memchunk *chunk, size_t length);
-void pa_sink_input_set_volume(struct pa_sink_input *i, pa_volume_t volume);
+void pa_sink_input_set_volume(pa_sink_input *i, pa_volume_t volume);
-void pa_sink_input_cork(struct pa_sink_input *i, int b);
+void pa_sink_input_cork(pa_sink_input *i, int b);
-void pa_sink_input_set_rate(struct pa_sink_input *i, uint32_t rate);
+void pa_sink_input_set_rate(pa_sink_input *i, uint32_t rate);
-void pa_sink_input_set_name(struct pa_sink_input *i, const char *name);
+void pa_sink_input_set_name(pa_sink_input *i, const char *name);
-enum pa_resample_method pa_sink_input_get_resample_method(struct pa_sink_input *i);
+pa_resample_method pa_sink_input_get_resample_method(pa_sink_input *i);
#endif
#include "xmalloc.h"
#include "subscribe.h"
#include "log.h"
+#include "polyplib-introspect.h"
#define MAX_MIX_CHANNELS 32
-struct pa_sink* pa_sink_new(struct pa_core *core, pa_typeid_t typeid, const char *name, int fail, const struct pa_sample_spec *spec) {
- struct pa_sink *s;
+pa_sink* pa_sink_new(pa_core *core, pa_typeid_t typeid, const char *name, int fail, const pa_sample_spec *spec) {
+ pa_sink *s;
char *n = NULL;
char st[256];
int r;
assert(core && name && *name && spec);
- s = pa_xmalloc(sizeof(struct pa_sink));
+ s = pa_xmalloc(sizeof(pa_sink));
if (!(name = pa_namereg_register(core, name, PA_NAMEREG_SINK, s, fail))) {
pa_xfree(s);
return s;
}
-void pa_sink_disconnect(struct pa_sink* s) {
- struct pa_sink_input *i, *j = NULL;
+void pa_sink_disconnect(pa_sink* s) {
+ pa_sink_input *i, *j = NULL;
assert(s && s->state == PA_SINK_RUNNING);
pa_namereg_unregister(s->core, s->name);
s->state = PA_SINK_DISCONNECTED;
}
-static void sink_free(struct pa_sink *s) {
+static void sink_free(pa_sink *s) {
assert(s && s->ref == 0);
if (s->state != PA_SINK_DISCONNECTED)
pa_xfree(s);
}
-void pa_sink_unref(struct pa_sink*s) {
+void pa_sink_unref(pa_sink*s) {
assert(s && s->ref >= 1);
if (!(--s->ref))
sink_free(s);
}
-struct pa_sink* pa_sink_ref(struct pa_sink *s) {
+pa_sink* pa_sink_ref(pa_sink *s) {
assert(s && s->ref >= 1);
s->ref++;
return s;
}
-void pa_sink_notify(struct pa_sink*s) {
+void pa_sink_notify(pa_sink*s) {
assert(s && s->ref >= 1);
if (s->notify)
s->notify(s);
}
-static unsigned fill_mix_info(struct pa_sink *s, struct pa_mix_info *info, unsigned maxinfo) {
- uint32_t index = PA_IDXSET_INVALID;
- struct pa_sink_input *i;
+static unsigned fill_mix_info(pa_sink *s, pa_mix_info *info, unsigned maxinfo) {
+ uint32_t idx = PA_IDXSET_INVALID;
+ pa_sink_input *i;
unsigned n = 0;
assert(s && s->ref >= 1 && info);
- for (i = pa_idxset_first(s->inputs, &index); maxinfo > 0 && i; i = pa_idxset_next(s->inputs, &index)) {
+ for (i = pa_idxset_first(s->inputs, &idx); maxinfo > 0 && i; i = pa_idxset_next(s->inputs, &idx)) {
pa_sink_input_ref(i);
if (pa_sink_input_peek(i, &info->chunk) < 0) {
return n;
}
-static void inputs_drop(struct pa_sink *s, struct pa_mix_info *info, unsigned maxinfo, size_t length) {
+static void inputs_drop(pa_sink *s, pa_mix_info *info, unsigned maxinfo, size_t length) {
assert(s && s->ref >= 1 && info);
for (; maxinfo > 0; maxinfo--, info++) {
- struct pa_sink_input *i = info->userdata;
+ pa_sink_input *i = info->userdata;
assert(i && info->chunk.memblock);
pa_sink_input_drop(i, &info->chunk, length);
}
}
-int pa_sink_render(struct pa_sink*s, size_t length, struct pa_memchunk *result) {
- struct pa_mix_info info[MAX_MIX_CHANNELS];
+int pa_sink_render(pa_sink*s, size_t length, pa_memchunk *result) {
+ pa_mix_info info[MAX_MIX_CHANNELS];
unsigned n;
size_t l;
int r = -1;
if (n == 1) {
uint32_t volume = PA_VOLUME_NORM;
- struct pa_sink_input *i = info[0].userdata;
+ pa_sink_input *i = info[0].userdata;
assert(i);
*result = info[0].chunk;
pa_memblock_ref(result->memblock);
return r;
}
-int pa_sink_render_into(struct pa_sink*s, struct pa_memchunk *target) {
- struct pa_mix_info info[MAX_MIX_CHANNELS];
+int pa_sink_render_into(pa_sink*s, pa_memchunk *target) {
+ pa_mix_info info[MAX_MIX_CHANNELS];
unsigned n;
size_t l;
int r = -1;
if (n == 1) {
uint32_t volume = PA_VOLUME_NORM;
- struct pa_sink_info *i = info[0].userdata;
- assert(i);
l = target->length;
if (l > info[0].chunk.length)
return r;
}
-void pa_sink_render_into_full(struct pa_sink *s, struct pa_memchunk *target) {
- struct pa_memchunk chunk;
+void pa_sink_render_into_full(pa_sink *s, pa_memchunk *target) {
+ pa_memchunk chunk;
size_t l, d;
assert(s && s->ref >= 1 && target && target->memblock && target->length && target->memblock->data);
pa_sink_unref(s);
}
-void pa_sink_render_full(struct pa_sink *s, size_t length, struct pa_memchunk *result) {
+void pa_sink_render_full(pa_sink *s, size_t length, pa_memchunk *result) {
assert(s && s->ref >= 1 && length && result);
/*** This needs optimization ***/
pa_sink_render_into_full(s, result);
}
-pa_usec_t pa_sink_get_latency(struct pa_sink *s) {
+pa_usec_t pa_sink_get_latency(pa_sink *s) {
assert(s && s->ref >= 1);
if (!s->get_latency)
return s->get_latency(s);
}
-void pa_sink_set_owner(struct pa_sink *s, struct pa_module *m) {
+void pa_sink_set_owner(pa_sink *s, pa_module *m) {
assert(s && s->ref >= 1);
s->owner = m;
pa_source_set_owner(s->monitor_source, m);
}
-void pa_sink_set_volume(struct pa_sink *s, pa_volume_t volume) {
+void pa_sink_set_volume(pa_sink *s, pa_volume_t volume) {
assert(s && s->ref >= 1);
if (s->volume != volume) {
USA.
***/
-struct pa_sink;
-
#include <inttypes.h>
+typedef struct pa_sink pa_sink;
+
#include "core.h"
#include "sample.h"
#include "idxset.h"
#include "source.h"
#include "typeid.h"
+#include "module.h"
#define PA_MAX_INPUTS_PER_SINK 6
-enum pa_sink_state {
+typedef enum pa_sink_state {
PA_SINK_RUNNING,
PA_SINK_DISCONNECTED
-};
+} pa_sink_state;
struct pa_sink {
int ref;
- enum pa_sink_state state;
+ pa_sink_state state;
uint32_t index;
pa_typeid_t typeid;
char *name, *description;
- struct pa_module *owner;
- struct pa_core *core;
- struct pa_sample_spec sample_spec;
- struct pa_idxset *inputs;
+ pa_module *owner;
+ pa_core *core;
+ pa_sample_spec sample_spec;
+ pa_idxset *inputs;
- struct pa_source *monitor_source;
+ pa_source *monitor_source;
pa_volume_t volume;
- void (*notify)(struct pa_sink*sink);
- pa_usec_t (*get_latency)(struct pa_sink *s);
+ void (*notify)(pa_sink*sink);
+ pa_usec_t (*get_latency)(pa_sink *s);
void *userdata;
};
-struct pa_sink* pa_sink_new(struct pa_core *core, pa_typeid_t typeid, const char *name, int fail, const struct pa_sample_spec *spec);
-void pa_sink_disconnect(struct pa_sink* s);
-void pa_sink_unref(struct pa_sink*s);
-struct pa_sink* pa_sink_ref(struct pa_sink *s);
+pa_sink* pa_sink_new(pa_core *core, pa_typeid_t typeid, const char *name, int fail, const pa_sample_spec *spec);
+void pa_sink_disconnect(pa_sink* s);
+void pa_sink_unref(pa_sink*s);
+pa_sink* pa_sink_ref(pa_sink *s);
-int pa_sink_render(struct pa_sink*s, size_t length, struct pa_memchunk *result);
-void pa_sink_render_full(struct pa_sink *s, size_t length, struct pa_memchunk *result);
-int pa_sink_render_into(struct pa_sink*s, struct pa_memchunk *target);
-void pa_sink_render_into_full(struct pa_sink *s, struct pa_memchunk *target);
+int pa_sink_render(pa_sink*s, size_t length, pa_memchunk *result);
+void pa_sink_render_full(pa_sink *s, size_t length, pa_memchunk *result);
+int pa_sink_render_into(pa_sink*s, pa_memchunk *target);
+void pa_sink_render_into_full(pa_sink *s, pa_memchunk *target);
-pa_usec_t pa_sink_get_latency(struct pa_sink *s);
+pa_usec_t pa_sink_get_latency(pa_sink *s);
-void pa_sink_notify(struct pa_sink*s);
+void pa_sink_notify(pa_sink*s);
-void pa_sink_set_owner(struct pa_sink *sink, struct pa_module *m);
+void pa_sink_set_owner(pa_sink *sink, pa_module *m);
-void pa_sink_set_volume(struct pa_sink *sink, pa_volume_t volume);
+void pa_sink_set_volume(pa_sink *sink, pa_volume_t volume);
#endif
struct pa_socket_client {
int ref;
- struct pa_mainloop_api *mainloop;
+ pa_mainloop_api *mainloop;
int fd;
- struct pa_io_event *io_event;
- struct pa_time_event *timeout_event;
- struct pa_defer_event *defer_event;
- void (*callback)(struct pa_socket_client*c, struct pa_iochannel *io, void *userdata);
+ pa_io_event *io_event;
+ pa_time_event *timeout_event;
+ pa_defer_event *defer_event;
+ void (*callback)(pa_socket_client*c, pa_iochannel *io, void *userdata);
void *userdata;
int local;
#ifdef HAVE_LIBASYNCNS
asyncns_t *asyncns;
asyncns_query_t * asyncns_query;
- struct pa_io_event *asyncns_io_event;
+ pa_io_event *asyncns_io_event;
#endif
};
-static struct pa_socket_client*pa_socket_client_new(struct pa_mainloop_api *m) {
- struct pa_socket_client *c;
+static pa_socket_client*pa_socket_client_new(pa_mainloop_api *m) {
+ pa_socket_client *c;
assert(m);
- c = pa_xmalloc(sizeof(struct pa_socket_client));
+ c = pa_xmalloc(sizeof(pa_socket_client));
c->ref = 1;
c->mainloop = m;
c->fd = -1;
return c;
}
-static void free_events(struct pa_socket_client *c) {
+static void free_events(pa_socket_client *c) {
assert(c);
if (c->io_event) {
}
}
-static void do_call(struct pa_socket_client *c) {
- struct pa_iochannel *io = NULL;
+static void do_call(pa_socket_client *c) {
+ pa_iochannel *io = NULL;
int error;
socklen_t lerror;
assert(c && c->callback);
pa_socket_client_unref(c);
}
-static void connect_fixed_cb(struct pa_mainloop_api *m, struct pa_defer_event *e, void *userdata) {
- struct pa_socket_client *c = userdata;
+static void connect_fixed_cb(pa_mainloop_api *m, pa_defer_event *e, void *userdata) {
+ pa_socket_client *c = userdata;
assert(m && c && c->defer_event == e);
do_call(c);
}
-static void connect_io_cb(struct pa_mainloop_api*m, struct pa_io_event *e, int fd, enum pa_io_event_flags f, void *userdata) {
- struct pa_socket_client *c = userdata;
+static void connect_io_cb(pa_mainloop_api*m, pa_io_event *e, int fd, PA_GCC_UNUSED pa_io_event_flags f, void *userdata) {
+ pa_socket_client *c = userdata;
assert(m && c && c->io_event == e && fd >= 0);
do_call(c);
}
-static int do_connect(struct pa_socket_client *c, const struct sockaddr *sa, socklen_t len) {
+static int do_connect(pa_socket_client *c, const struct sockaddr *sa, socklen_t len) {
int r;
assert(c && sa && len);
return 0;
}
-struct pa_socket_client* pa_socket_client_new_ipv4(struct pa_mainloop_api *m, uint32_t address, uint16_t port) {
+pa_socket_client* pa_socket_client_new_ipv4(pa_mainloop_api *m, uint32_t address, uint16_t port) {
struct sockaddr_in sa;
assert(m && port > 0);
#ifdef HAVE_SYS_UN_H
-struct pa_socket_client* pa_socket_client_new_unix(struct pa_mainloop_api *m, const char *filename) {
+pa_socket_client* pa_socket_client_new_unix(pa_mainloop_api *m, const char *filename) {
struct sockaddr_un sa;
assert(m && filename);
#else /* HAVE_SYS_UN_H */
-struct pa_socket_client* pa_socket_client_new_unix(struct pa_mainloop_api *m, const char *filename) {
+pa_socket_client* pa_socket_client_new_unix(pa_mainloop_api *m, const char *filename) {
return NULL;
}
#endif /* HAVE_SYS_UN_H */
-static int sockaddr_prepare(struct pa_socket_client *c, const struct sockaddr *sa, size_t salen) {
+static int sockaddr_prepare(pa_socket_client *c, const struct sockaddr *sa, size_t salen) {
assert(c);
assert(sa);
assert(salen);
return 0;
}
-struct pa_socket_client* pa_socket_client_new_sockaddr(struct pa_mainloop_api *m, const struct sockaddr *sa, size_t salen) {
- struct pa_socket_client *c;
+pa_socket_client* pa_socket_client_new_sockaddr(pa_mainloop_api *m, const struct sockaddr *sa, size_t salen) {
+ pa_socket_client *c;
assert(m && sa);
c = pa_socket_client_new(m);
assert(c);
}
-void socket_client_free(struct pa_socket_client *c) {
+static void socket_client_free(pa_socket_client *c) {
assert(c && c->mainloop);
pa_xfree(c);
}
-void pa_socket_client_unref(struct pa_socket_client *c) {
+void pa_socket_client_unref(pa_socket_client *c) {
assert(c && c->ref >= 1);
if (!(--(c->ref)))
socket_client_free(c);
}
-struct pa_socket_client* pa_socket_client_ref(struct pa_socket_client *c) {
+pa_socket_client* pa_socket_client_ref(pa_socket_client *c) {
assert(c && c->ref >= 1);
c->ref++;
return c;
}
-void pa_socket_client_set_callback(struct pa_socket_client *c, void (*on_connection)(struct pa_socket_client *c, struct pa_iochannel*io, void *userdata), void *userdata) {
+void pa_socket_client_set_callback(pa_socket_client *c, void (*on_connection)(pa_socket_client *c, pa_iochannel*io, void *userdata), void *userdata) {
assert(c);
c->callback = on_connection;
c->userdata = userdata;
}
-struct pa_socket_client* pa_socket_client_new_ipv6(struct pa_mainloop_api *m, uint8_t address[16], uint16_t port) {
+pa_socket_client* pa_socket_client_new_ipv6(pa_mainloop_api *m, uint8_t address[16], uint16_t port) {
struct sockaddr_in6 sa;
memset(&sa, 0, sizeof(sa));
#ifdef HAVE_LIBASYNCNS
-static void asyncns_cb(struct pa_mainloop_api*m, struct pa_io_event *e, int fd, enum pa_io_event_flags f, void *userdata) {
- struct pa_socket_client *c = userdata;
+static void asyncns_cb(pa_mainloop_api*m, pa_io_event *e, int fd, PA_GCC_UNUSED pa_io_event_flags f, void *userdata) {
+ pa_socket_client *c = userdata;
struct addrinfo *res = NULL;
int ret;
assert(m && c && c->asyncns_io_event == e && fd >= 0);
#endif
-static void timeout_cb(struct pa_mainloop_api *m, struct pa_time_event *e, const struct timeval *tv, void *userdata) {
- struct pa_socket_client *c = userdata;
+static void timeout_cb(pa_mainloop_api *m, pa_time_event *e, const struct timeval *tv, void *userdata) {
+ pa_socket_client *c = userdata;
assert(m);
assert(e);
assert(tv);
do_call(c);
}
-static void start_timeout(struct pa_socket_client *c) {
+static void start_timeout(pa_socket_client *c) {
struct timeval tv;
assert(c);
assert(!c->timeout_event);
c->timeout_event = c->mainloop->time_new(c->mainloop, &tv, timeout_cb, c);
}
-struct pa_socket_client* pa_socket_client_new_string(struct pa_mainloop_api *m, const char*name, uint16_t default_port) {
- struct pa_socket_client *c = NULL;
- struct pa_parsed_address a;
+pa_socket_client* pa_socket_client_new_string(pa_mainloop_api *m, const char*name, uint16_t default_port) {
+ pa_socket_client *c = NULL;
+ pa_parsed_address a;
assert(m && name);
if (pa_parse_address(name, &a) < 0)
/* Return non-zero when the target sockaddr is considered
local. "local" means UNIX socket or TCP socket on localhost. Other
local IP addresses are not considered local. */
-int pa_socket_client_is_local(struct pa_socket_client *c) {
+int pa_socket_client_is_local(pa_socket_client *c) {
assert(c);
return c->local;
}
struct sockaddr;
-struct pa_socket_client;
+typedef struct pa_socket_client pa_socket_client;
-struct pa_socket_client* pa_socket_client_new_ipv4(struct pa_mainloop_api *m, uint32_t address, uint16_t port);
-struct pa_socket_client* pa_socket_client_new_ipv6(struct pa_mainloop_api *m, uint8_t address[16], uint16_t port);
-struct pa_socket_client* pa_socket_client_new_unix(struct pa_mainloop_api *m, const char *filename);
-struct pa_socket_client* pa_socket_client_new_sockaddr(struct pa_mainloop_api *m, const struct sockaddr *sa, size_t salen);
-struct pa_socket_client* pa_socket_client_new_string(struct pa_mainloop_api *m, const char *a, uint16_t default_port);
+pa_socket_client* pa_socket_client_new_ipv4(pa_mainloop_api *m, uint32_t address, uint16_t port);
+pa_socket_client* pa_socket_client_new_ipv6(pa_mainloop_api *m, uint8_t address[16], uint16_t port);
+pa_socket_client* pa_socket_client_new_unix(pa_mainloop_api *m, const char *filename);
+pa_socket_client* pa_socket_client_new_sockaddr(pa_mainloop_api *m, const struct sockaddr *sa, size_t salen);
+pa_socket_client* pa_socket_client_new_string(pa_mainloop_api *m, const char *a, uint16_t default_port);
-void pa_socket_client_unref(struct pa_socket_client *c);
-struct pa_socket_client* pa_socket_client_ref(struct pa_socket_client *c);
+void pa_socket_client_unref(pa_socket_client *c);
+pa_socket_client* pa_socket_client_ref(pa_socket_client *c);
-void pa_socket_client_set_callback(struct pa_socket_client *c, void (*on_connection)(struct pa_socket_client *c, struct pa_iochannel*io, void *userdata), void *userdata);
+void pa_socket_client_set_callback(pa_socket_client *c, void (*on_connection)(pa_socket_client *c, pa_iochannel*io, void *userdata), void *userdata);
-int pa_socket_client_is_local(struct pa_socket_client *c);
+int pa_socket_client_is_local(pa_socket_client *c);
#endif
char *filename;
char *tcpwrap_service;
- void (*on_connection)(struct pa_socket_server*s, struct pa_iochannel *io, void *userdata);
+ void (*on_connection)(pa_socket_server*s, pa_iochannel *io, void *userdata);
void *userdata;
- struct pa_io_event *io_event;
- struct pa_mainloop_api *mainloop;
+ pa_io_event *io_event;
+ pa_mainloop_api *mainloop;
enum { SOCKET_SERVER_GENERIC, SOCKET_SERVER_IPV4, SOCKET_SERVER_UNIX, SOCKET_SERVER_IPV6 } type;
};
-static void callback(struct pa_mainloop_api *mainloop, struct pa_io_event *e, int fd, enum pa_io_event_flags f, void *userdata) {
- struct pa_socket_server *s = userdata;
- struct pa_iochannel *io;
+static void callback(pa_mainloop_api *mainloop, pa_io_event *e, int fd, PA_GCC_UNUSED pa_io_event_flags f, void *userdata) {
+ pa_socket_server *s = userdata;
+ pa_iochannel *io;
int nfd;
assert(s && s->mainloop == mainloop && s->io_event == e && e && fd >= 0 && fd == s->fd);
pa_socket_server_unref(s);
}
-struct pa_socket_server* pa_socket_server_new(struct pa_mainloop_api *m, int fd) {
- struct pa_socket_server *s;
+pa_socket_server* pa_socket_server_new(pa_mainloop_api *m, int fd) {
+ pa_socket_server *s;
assert(m && fd >= 0);
- s = pa_xmalloc(sizeof(struct pa_socket_server));
+ s = pa_xmalloc(sizeof(pa_socket_server));
s->ref = 1;
s->fd = fd;
s->filename = NULL;
return s;
}
-struct pa_socket_server* pa_socket_server_ref(struct pa_socket_server *s) {
+pa_socket_server* pa_socket_server_ref(pa_socket_server *s) {
assert(s && s->ref >= 1);
s->ref++;
return s;
#ifdef HAVE_SYS_UN_H
-struct pa_socket_server* pa_socket_server_new_unix(struct pa_mainloop_api *m, const char *filename) {
+pa_socket_server* pa_socket_server_new_unix(pa_mainloop_api *m, const char *filename) {
int fd = -1;
struct sockaddr_un sa;
- struct pa_socket_server *s;
+ pa_socket_server *s;
assert(m && filename);
#else /* HAVE_SYS_UN_H */
-struct pa_socket_server* pa_socket_server_new_unix(struct pa_mainloop_api *m, const char *filename) {
+pa_socket_server* pa_socket_server_new_unix(pa_mainloop_api *m, const char *filename) {
return NULL;
}
#endif /* HAVE_SYS_UN_H */
-struct pa_socket_server* pa_socket_server_new_ipv4(struct pa_mainloop_api *m, uint32_t address, uint16_t port, const char *tcpwrap_service) {
- struct pa_socket_server *ss;
+pa_socket_server* pa_socket_server_new_ipv4(pa_mainloop_api *m, uint32_t address, uint16_t port, const char *tcpwrap_service) {
+ pa_socket_server *ss;
int fd = -1;
struct sockaddr_in sa;
int on = 1;
return NULL;
}
-struct pa_socket_server* pa_socket_server_new_ipv6(struct pa_mainloop_api *m, uint8_t address[16], uint16_t port) {
- struct pa_socket_server *ss;
+pa_socket_server* pa_socket_server_new_ipv6(pa_mainloop_api *m, const uint8_t address[16], uint16_t port) {
+ pa_socket_server *ss;
int fd = -1;
struct sockaddr_in6 sa;
int on = 1;
return NULL;
}
-static void socket_server_free(struct pa_socket_server*s) {
+static void socket_server_free(pa_socket_server*s) {
assert(s);
close(s->fd);
pa_xfree(s);
}
-void pa_socket_server_unref(struct pa_socket_server *s) {
+void pa_socket_server_unref(pa_socket_server *s) {
assert(s && s->ref >= 1);
if (!(--(s->ref)))
socket_server_free(s);
}
-void pa_socket_server_set_callback(struct pa_socket_server*s, void (*on_connection)(struct pa_socket_server*s, struct pa_iochannel *io, void *userdata), void *userdata) {
+void pa_socket_server_set_callback(pa_socket_server*s, void (*on_connection)(pa_socket_server*s, pa_iochannel *io, void *userdata), void *userdata) {
assert(s && s->ref >= 1);
s->on_connection = on_connection;
}
-char *pa_socket_server_get_address(struct pa_socket_server *s, char *c, size_t l) {
+char *pa_socket_server_get_address(pa_socket_server *s, char *c, size_t l) {
assert(s && c && l > 0);
switch (s->type) {
/* It is safe to destroy the calling socket_server object from the callback */
-struct pa_socket_server;
+typedef struct pa_socket_server pa_socket_server;
-struct pa_socket_server* pa_socket_server_new(struct pa_mainloop_api *m, int fd);
-struct pa_socket_server* pa_socket_server_new_unix(struct pa_mainloop_api *m, const char *filename);
-struct pa_socket_server* pa_socket_server_new_ipv4(struct pa_mainloop_api *m, uint32_t address, uint16_t port, const char *tcpwrap_service);
-struct pa_socket_server* pa_socket_server_new_ipv6(struct pa_mainloop_api *m, uint8_t address[16], uint16_t port);
+pa_socket_server* pa_socket_server_new(pa_mainloop_api *m, int fd);
+pa_socket_server* pa_socket_server_new_unix(pa_mainloop_api *m, const char *filename);
+pa_socket_server* pa_socket_server_new_ipv4(pa_mainloop_api *m, uint32_t address, uint16_t port, const char *tcpwrap_service);
+pa_socket_server* pa_socket_server_new_ipv6(pa_mainloop_api *m, const uint8_t address[16], uint16_t port);
-void pa_socket_server_unref(struct pa_socket_server*s);
-struct pa_socket_server* pa_socket_server_ref(struct pa_socket_server *s);
+void pa_socket_server_unref(pa_socket_server*s);
+pa_socket_server* pa_socket_server_ref(pa_socket_server *s);
-void pa_socket_server_set_callback(struct pa_socket_server*s, void (*on_connection)(struct pa_socket_server*s, struct pa_iochannel *io, void *userdata), void *userdata);
+void pa_socket_server_set_callback(pa_socket_server*s, void (*on_connection)(pa_socket_server*s, pa_iochannel *io, void *userdata), void *userdata);
-char *pa_socket_server_get_address(struct pa_socket_server *s, char *c, size_t l);
+char *pa_socket_server_get_address(pa_socket_server *s, char *c, size_t l);
#endif
struct userdata {
SNDFILE *sndfile;
- struct pa_sink_input *sink_input;
- struct pa_memchunk memchunk;
+ pa_sink_input *sink_input;
+ pa_memchunk memchunk;
sf_count_t (*readf_function)(SNDFILE *sndfile, void *ptr, sf_count_t frames);
};
pa_xfree(u);
}
-static void sink_input_kill(struct pa_sink_input *i) {
+static void sink_input_kill(pa_sink_input *i) {
assert(i && i->userdata);
free_userdata(i->userdata);
}
-static void si_kill(struct pa_mainloop_api *m, void *i) {
+static void si_kill(PA_GCC_UNUSED pa_mainloop_api *m, void *i) {
sink_input_kill(i);
}
-static int sink_input_peek(struct pa_sink_input *i, struct pa_memchunk *chunk) {
+static int sink_input_peek(pa_sink_input *i, pa_memchunk *chunk) {
struct userdata *u;
assert(i && chunk && i->userdata);
u = i->userdata;
return 0;
}
-static void sink_input_drop(struct pa_sink_input *i, const struct pa_memchunk*chunk, size_t length) {
+static void sink_input_drop(pa_sink_input *i, const pa_memchunk*chunk, size_t length) {
struct userdata *u;
assert(i && chunk && length && i->userdata);
u = i->userdata;
}
}
-int pa_play_file(struct pa_sink *sink, const char *fname, pa_volume_t volume) {
+int pa_play_file(pa_sink *sink, const char *fname, pa_volume_t volume) {
struct userdata *u = NULL;
SF_INFO sfinfo;
- struct pa_sample_spec ss;
+ pa_sample_spec ss;
assert(sink && fname);
if (volume <= 0)
#include "sink.h"
-int pa_play_file(struct pa_sink *sink, const char *fname, pa_volume_t volume);
+int pa_play_file(pa_sink *sink, const char *fname, pa_volume_t volume);
#endif
#define MAX_FILE_SIZE (1024*1024)
-int pa_sound_file_load(const char *fname, struct pa_sample_spec *ss, struct pa_memchunk *chunk, struct pa_memblock_stat *s) {
+int pa_sound_file_load(const char *fname, pa_sample_spec *ss, pa_memchunk *chunk, pa_memblock_stat *s) {
SNDFILE*sf = NULL;
SF_INFO sfinfo;
int ret = -1;
int pa_sound_file_too_big_to_cache(const char *fname) {
SNDFILE*sf = NULL;
SF_INFO sfinfo;
- struct pa_sample_spec ss;
+ pa_sample_spec ss;
if (!(sf = sf_open(fname, SFM_READ, &sfinfo))) {
pa_log(__FILE__": Failed to open file %s\n", fname);
#include "memchunk.h"
#include "sample.h"
-int pa_sound_file_load(const char *fname, struct pa_sample_spec *ss, struct pa_memchunk *chunk, struct pa_memblock_stat *s);
+int pa_sound_file_load(const char *fname, pa_sample_spec *ss, pa_memchunk *chunk, pa_memblock_stat *s);
int pa_sound_file_too_big_to_cache(const char *fname);
#include "subscribe.h"
#include "log.h"
-struct pa_source_output* pa_source_output_new(struct pa_source *s, pa_typeid_t typeid, const char *name, const struct pa_sample_spec *spec, int resample_method) {
- struct pa_source_output *o;
- struct pa_resampler *resampler = NULL;
+pa_source_output* pa_source_output_new(pa_source *s, pa_typeid_t typeid, const char *name, const pa_sample_spec *spec, int resample_method) {
+ pa_source_output *o;
+ pa_resampler *resampler = NULL;
int r;
char st[256];
assert(s && spec);
- if (pa_idxset_ncontents(s->outputs) >= PA_MAX_OUTPUTS_PER_SOURCE) {
+ if (pa_idxset_size(s->outputs) >= PA_MAX_OUTPUTS_PER_SOURCE) {
pa_log(__FILE__": Failed to create source output: too many outputs per source.\n");
return NULL;
}
if (!(resampler = pa_resampler_new(&s->sample_spec, spec, s->core->memblock_stat, resample_method)))
return NULL;
- o = pa_xmalloc(sizeof(struct pa_source_output));
+ o = pa_xmalloc(sizeof(pa_source_output));
o->ref = 1;
o->state = PA_SOURCE_OUTPUT_RUNNING;
o->name = pa_xstrdup(name);
return o;
}
-void pa_source_output_disconnect(struct pa_source_output*o) {
+void pa_source_output_disconnect(pa_source_output*o) {
assert(o && o->state != PA_SOURCE_OUTPUT_DISCONNECTED && o->source && o->source->core);
pa_idxset_remove_by_data(o->source->core->source_outputs, o, NULL);
o->state = PA_SOURCE_OUTPUT_DISCONNECTED;
}
-static void source_output_free(struct pa_source_output* o) {
+static void source_output_free(pa_source_output* o) {
assert(o);
if (o->state != PA_SOURCE_OUTPUT_DISCONNECTED)
}
-void pa_source_output_unref(struct pa_source_output* o) {
+void pa_source_output_unref(pa_source_output* o) {
assert(o && o->ref >= 1);
if (!(--o->ref))
source_output_free(o);
}
-struct pa_source_output* pa_source_output_ref(struct pa_source_output *o) {
+pa_source_output* pa_source_output_ref(pa_source_output *o) {
assert(o && o->ref >= 1);
o->ref++;
return o;
}
-void pa_source_output_kill(struct pa_source_output*o) {
+void pa_source_output_kill(pa_source_output*o) {
assert(o && o->ref >= 1);
if (o->kill)
o->kill(o);
}
-void pa_source_output_push(struct pa_source_output *o, const struct pa_memchunk *chunk) {
- struct pa_memchunk rchunk;
+void pa_source_output_push(pa_source_output *o, const pa_memchunk *chunk) {
+ pa_memchunk rchunk;
assert(o && chunk && chunk->length && o->push);
if (o->state == PA_SOURCE_OUTPUT_CORKED)
pa_memblock_unref(rchunk.memblock);
}
-void pa_source_output_set_name(struct pa_source_output *o, const char *name) {
+void pa_source_output_set_name(pa_source_output *o, const char *name) {
assert(o && o->ref >= 1);
pa_xfree(o->name);
o->name = pa_xstrdup(name);
pa_subscription_post(o->source->core, PA_SUBSCRIPTION_EVENT_SOURCE_OUTPUT|PA_SUBSCRIPTION_EVENT_CHANGE, o->index);
}
-pa_usec_t pa_source_output_get_latency(struct pa_source_output *o) {
+pa_usec_t pa_source_output_get_latency(pa_source_output *o) {
assert(o && o->ref >= 1);
if (o->get_latency)
return 0;
}
-void pa_source_output_cork(struct pa_source_output *o, int b) {
+void pa_source_output_cork(pa_source_output *o, int b) {
assert(o && o->ref >= 1);
if (o->state == PA_SOURCE_OUTPUT_DISCONNECTED)
o->state = b ? PA_SOURCE_OUTPUT_CORKED : PA_SOURCE_OUTPUT_RUNNING;
}
-enum pa_resample_method pa_source_output_get_resample_method(struct pa_source_output *o) {
+pa_resample_method pa_source_output_get_resample_method(pa_source_output *o) {
assert(o && o->ref >= 1);
if (!o->resampler)
#include <inttypes.h>
+typedef struct pa_source_output pa_source_output;
+
#include "source.h"
#include "sample.h"
#include "memblockq.h"
#include "module.h"
#include "client.h"
-enum pa_source_output_state {
+typedef enum {
PA_SOURCE_OUTPUT_RUNNING,
PA_SOURCE_OUTPUT_CORKED,
PA_SOURCE_OUTPUT_DISCONNECTED
-};
+} pa_source_output_state;
struct pa_source_output {
int ref;
- enum pa_source_output_state state;
+ pa_source_output_state state;
uint32_t index;
pa_typeid_t typeid;
char *name;
- struct pa_module *owner;
- struct pa_client *client;
- struct pa_source *source;
- struct pa_sample_spec sample_spec;
+ pa_module *owner;
+ pa_client *client;
+ pa_source *source;
+ pa_sample_spec sample_spec;
- void (*push)(struct pa_source_output *o, const struct pa_memchunk *chunk);
- void (*kill)(struct pa_source_output* o);
- pa_usec_t (*get_latency) (struct pa_source_output *i);
+ void (*push)(pa_source_output *o, const pa_memchunk *chunk);
+ void (*kill)(pa_source_output* o);
+ pa_usec_t (*get_latency) (pa_source_output *i);
- struct pa_resampler* resampler;
+ pa_resampler* resampler;
void *userdata;
};
-struct pa_source_output* pa_source_output_new(struct pa_source *s, pa_typeid_t typeid, const char *name, const struct pa_sample_spec *spec, int resample_method);
-void pa_source_output_unref(struct pa_source_output* o);
-struct pa_source_output* pa_source_output_ref(struct pa_source_output *o);
+pa_source_output* pa_source_output_new(pa_source *s, pa_typeid_t typeid, const char *name, const pa_sample_spec *spec, int resample_method);
+void pa_source_output_unref(pa_source_output* o);
+pa_source_output* pa_source_output_ref(pa_source_output *o);
/* To be called by the implementing module only */
-void pa_source_output_disconnect(struct pa_source_output*o);
+void pa_source_output_disconnect(pa_source_output*o);
/* External code may request disconnection with this funcion */
-void pa_source_output_kill(struct pa_source_output*o);
+void pa_source_output_kill(pa_source_output*o);
-void pa_source_output_push(struct pa_source_output *o, const struct pa_memchunk *chunk);
+void pa_source_output_push(pa_source_output *o, const pa_memchunk *chunk);
-void pa_source_output_set_name(struct pa_source_output *i, const char *name);
+void pa_source_output_set_name(pa_source_output *i, const char *name);
-pa_usec_t pa_source_output_get_latency(struct pa_source_output *i);
+pa_usec_t pa_source_output_get_latency(pa_source_output *i);
-void pa_source_output_cork(struct pa_source_output *i, int b);
+void pa_source_output_cork(pa_source_output *i, int b);
-enum pa_resample_method pa_source_output_get_resample_method(struct pa_source_output *o);
+pa_resample_method pa_source_output_get_resample_method(pa_source_output *o);
#endif
#include "subscribe.h"
#include "log.h"
-struct pa_source* pa_source_new(struct pa_core *core, pa_typeid_t typeid, const char *name, int fail, const struct pa_sample_spec *spec) {
- struct pa_source *s;
+pa_source* pa_source_new(pa_core *core, pa_typeid_t typeid, const char *name, int fail, const pa_sample_spec *spec) {
+ pa_source *s;
char st[256];
int r;
assert(core && spec && name && *name);
- s = pa_xmalloc(sizeof(struct pa_source));
+ s = pa_xmalloc(sizeof(pa_source));
if (!(name = pa_namereg_register(core, name, PA_NAMEREG_SOURCE, s, fail))) {
pa_xfree(s);
return s;
}
-void pa_source_disconnect(struct pa_source *s) {
- struct pa_source_output *o, *j = NULL;
+void pa_source_disconnect(pa_source *s) {
+ pa_source_output *o, *j = NULL;
assert(s && s->state == PA_SOURCE_RUNNING);
pa_namereg_unregister(s->core, s->name);
s->state = PA_SOURCE_DISCONNECTED;
}
-static void source_free(struct pa_source *s) {
+static void source_free(pa_source *s) {
assert(s && !s->ref);
if (s->state != PA_SOURCE_DISCONNECTED)
pa_xfree(s);
}
-void pa_source_unref(struct pa_source *s) {
+void pa_source_unref(pa_source *s) {
assert(s && s->ref >= 1);
if (!(--s->ref))
source_free(s);
}
-struct pa_source* pa_source_ref(struct pa_source *s) {
+pa_source* pa_source_ref(pa_source *s) {
assert(s && s->ref >= 1);
s->ref++;
return s;
}
-void pa_source_notify(struct pa_source*s) {
+void pa_source_notify(pa_source*s) {
assert(s && s->ref >= 1);
if (s->notify)
s->notify(s);
}
-static int do_post(void *p, uint32_t index, int *del, void*userdata) {
- const struct pa_memchunk *chunk = userdata;
- struct pa_source_output *o = p;
+static int do_post(void *p, PA_GCC_UNUSED uint32_t idx, int *del, void*userdata) {
+ const pa_memchunk *chunk = userdata;
+ pa_source_output *o = p;
assert(o && o->push && del && chunk);
pa_source_output_push(o, chunk);
return 0;
}
-void pa_source_post(struct pa_source*s, const struct pa_memchunk *chunk) {
+void pa_source_post(pa_source*s, const pa_memchunk *chunk) {
assert(s && s->ref >= 1 && chunk);
pa_source_ref(s);
pa_source_unref(s);
}
-void pa_source_set_owner(struct pa_source *s, struct pa_module *m) {
+void pa_source_set_owner(pa_source *s, pa_module *m) {
assert(s);
s->owner = m;
}
-pa_usec_t pa_source_get_latency(struct pa_source *s) {
+pa_usec_t pa_source_get_latency(pa_source *s) {
assert(s && s->ref >= 1);
if (!s->get_latency)
USA.
***/
-struct pa_source;
+typedef struct pa_source pa_source;
#include <inttypes.h>
#include "core.h"
#include "memchunk.h"
#include "sink.h"
#include "typeid.h"
+#include "module.h"
#define PA_MAX_OUTPUTS_PER_SOURCE 16
-enum pa_source_state {
+typedef enum pa_source_state {
PA_SOURCE_RUNNING,
PA_SOURCE_DISCONNECTED
-};
+} pa_source_state;
struct pa_source {
int ref;
- enum pa_source_state state;
+ pa_source_state state;
uint32_t index;
pa_typeid_t typeid;
char *name, *description;
- struct pa_module *owner;
- struct pa_core *core;
- struct pa_sample_spec sample_spec;
- struct pa_idxset *outputs;
- struct pa_sink *monitor_of;
+ pa_module *owner;
+ pa_core *core;
+ pa_sample_spec sample_spec;
+ pa_idxset *outputs;
+ pa_sink *monitor_of;
- void (*notify)(struct pa_source*source);
- pa_usec_t (*get_latency)(struct pa_source *s);
+ void (*notify)(pa_source*source);
+ pa_usec_t (*get_latency)(pa_source *s);
void *userdata;
};
-struct pa_source* pa_source_new(struct pa_core *core, pa_typeid_t typeid, const char *name, int fail, const struct pa_sample_spec *spec);
-void pa_source_disconnect(struct pa_source *s);
-void pa_source_unref(struct pa_source *s);
-struct pa_source* pa_source_ref(struct pa_source *c);
+pa_source* pa_source_new(pa_core *core, pa_typeid_t typeid, const char *name, int fail, const pa_sample_spec *spec);
+void pa_source_disconnect(pa_source *s);
+void pa_source_unref(pa_source *s);
+pa_source* pa_source_ref(pa_source *c);
/* Pass a new memory block to all output streams */
-void pa_source_post(struct pa_source*s, const struct pa_memchunk *b);
+void pa_source_post(pa_source*s, const pa_memchunk *b);
-void pa_source_notify(struct pa_source *s);
+void pa_source_notify(pa_source *s);
-void pa_source_set_owner(struct pa_source *s, struct pa_module *m);
+void pa_source_set_owner(pa_source *s, pa_module *m);
-pa_usec_t pa_source_get_latency(struct pa_source *s);
+pa_usec_t pa_source_get_latency(pa_source *s);
#endif
struct chunk *head, *tail;
};
-struct pa_strbuf *pa_strbuf_new(void) {
- struct pa_strbuf *sb = pa_xmalloc(sizeof(struct pa_strbuf));
+pa_strbuf *pa_strbuf_new(void) {
+ pa_strbuf *sb = pa_xmalloc(sizeof(pa_strbuf));
sb->length = 0;
sb->head = sb->tail = NULL;
return sb;
}
-void pa_strbuf_free(struct pa_strbuf *sb) {
+void pa_strbuf_free(pa_strbuf *sb) {
assert(sb);
while (sb->head) {
struct chunk *c = sb->head;
/* Make a C string from the string buffer. The caller has to free
* string with pa_xfree(). */
-char *pa_strbuf_tostring(struct pa_strbuf *sb) {
+char *pa_strbuf_tostring(pa_strbuf *sb) {
char *t, *e;
struct chunk *c;
assert(sb);
}
/* Combination of pa_strbuf_free() and pa_strbuf_tostring() */
-char *pa_strbuf_tostring_free(struct pa_strbuf *sb) {
+char *pa_strbuf_tostring_free(pa_strbuf *sb) {
char *t;
assert(sb);
t = pa_strbuf_tostring(sb);
}
/* Append a string to the string buffer */
-void pa_strbuf_puts(struct pa_strbuf *sb, const char *t) {
+void pa_strbuf_puts(pa_strbuf *sb, const char *t) {
assert(sb && t);
pa_strbuf_putsn(sb, t, strlen(t));
}
/* Append a new chunk to the linked list */
-static void append(struct pa_strbuf *sb, struct chunk *c) {
+static void append(pa_strbuf *sb, struct chunk *c) {
assert(sb && c);
if (sb->tail) {
}
/* Append up to l bytes of a string to the string buffer */
-void pa_strbuf_putsn(struct pa_strbuf *sb, const char *t, size_t l) {
+void pa_strbuf_putsn(pa_strbuf *sb, const char *t, size_t l) {
struct chunk *c;
assert(sb && t);
/* Append a printf() style formatted string to the string buffer. */
/* The following is based on an example from the GNU libc documentation */
-int pa_strbuf_printf(struct pa_strbuf *sb, const char *format, ...) {
+int pa_strbuf_printf(pa_strbuf *sb, const char *format, ...) {
int size = 100;
struct chunk *c = NULL;
USA.
***/
-#include "gcc-printf.h"
+#include "gccmacro.h"
-struct pa_strbuf;
+typedef struct pa_strbuf pa_strbuf;
-struct pa_strbuf *pa_strbuf_new(void);
-void pa_strbuf_free(struct pa_strbuf *sb);
-char *pa_strbuf_tostring(struct pa_strbuf *sb);
-char *pa_strbuf_tostring_free(struct pa_strbuf *sb);
+pa_strbuf *pa_strbuf_new(void);
+void pa_strbuf_free(pa_strbuf *sb);
+char *pa_strbuf_tostring(pa_strbuf *sb);
+char *pa_strbuf_tostring_free(pa_strbuf *sb);
-int pa_strbuf_printf(struct pa_strbuf *sb, const char *format, ...) PA_GCC_PRINTF_ATTR(2,3);
-void pa_strbuf_puts(struct pa_strbuf *sb, const char *t);
-void pa_strbuf_putsn(struct pa_strbuf *sb, const char *t, size_t m);
+int pa_strbuf_printf(pa_strbuf *sb, const char *format, ...) PA_GCC_PRINTF_ATTR(2,3);
+void pa_strbuf_puts(pa_strbuf *sb, const char *t);
+void pa_strbuf_putsn(pa_strbuf *sb, const char *t, size_t m);
#endif
#include "strlist.h"
#include "xmalloc.h"
+#include "gccmacro.h"
-int main(int argc, char* argv[]) {
+int main(PA_GCC_UNUSED int argc, PA_GCC_UNUSED char* argv[]) {
char *t, *u;
- struct pa_strlist *l = NULL;
+ pa_strlist *l = NULL;
l = pa_strlist_prepend(l, "e");
l = pa_strlist_prepend(l, "d");
#include "util.h"
struct pa_strlist {
- struct pa_strlist *next;
+ pa_strlist *next;
char *str;
};
-struct pa_strlist* pa_strlist_prepend(struct pa_strlist *l, const char *s) {
- struct pa_strlist *n;
+pa_strlist* pa_strlist_prepend(pa_strlist *l, const char *s) {
+ pa_strlist *n;
assert(s);
- n = pa_xmalloc(sizeof(struct pa_strlist));
+ n = pa_xmalloc(sizeof(pa_strlist));
n->str = pa_xstrdup(s);
n->next = l;
return n;
}
-char *pa_strlist_tostring(struct pa_strlist *l) {
+char *pa_strlist_tostring(pa_strlist *l) {
int first = 1;
- struct pa_strbuf *b;
+ pa_strbuf *b;
b = pa_strbuf_new();
for (; l; l = l->next) {
return pa_strbuf_tostring_free(b);
}
-struct pa_strlist* pa_strlist_remove(struct pa_strlist *l, const char *s) {
- struct pa_strlist *ret = l, *prev = NULL;
+pa_strlist* pa_strlist_remove(pa_strlist *l, const char *s) {
+ pa_strlist *ret = l, *prev = NULL;
assert(l && s);
while (l) {
if (!strcmp(l->str, s)) {
- struct pa_strlist *n = l->next;
+ pa_strlist *n = l->next;
if (!prev) {
assert(ret == l);
return ret;
}
-void pa_strlist_free(struct pa_strlist *l) {
+void pa_strlist_free(pa_strlist *l) {
while (l) {
- struct pa_strlist *c = l;
+ pa_strlist *c = l;
l = l->next;
pa_xfree(c->str);
}
}
-struct pa_strlist* pa_strlist_pop(struct pa_strlist *l, char **s) {
- struct pa_strlist *r;
+pa_strlist* pa_strlist_pop(pa_strlist *l, char **s) {
+ pa_strlist *r;
assert(s);
if (!l) {
return r;
}
-struct pa_strlist* pa_strlist_parse(const char *s) {
- struct pa_strlist *head = NULL, *p = NULL;
+pa_strlist* pa_strlist_parse(const char *s) {
+ pa_strlist *head = NULL, *p = NULL;
const char *state = NULL;
char *r;
while ((r = pa_split_spaces(s, &state))) {
- struct pa_strlist *n;
+ pa_strlist *n;
- n = pa_xmalloc(sizeof(struct pa_strlist));
+ n = pa_xmalloc(sizeof(pa_strlist));
n->str = r;
n->next = NULL;
USA.
***/
-struct pa_strlist;
+typedef struct pa_strlist pa_strlist;
/* Add the specified server string to the list, return the new linked list head */
-struct pa_strlist* pa_strlist_prepend(struct pa_strlist *l, const char *s);
+pa_strlist* pa_strlist_prepend(pa_strlist *l, const char *s);
/* Remove the specified string from the list, return the new linked list head */
-struct pa_strlist* pa_strlist_remove(struct pa_strlist *l, const char *s);
+pa_strlist* pa_strlist_remove(pa_strlist *l, const char *s);
/* Make a whitespace separated string of all server stringes. Returned memory has to be freed with pa_xfree() */
-char *pa_strlist_tostring(struct pa_strlist *l);
+char *pa_strlist_tostring(pa_strlist *l);
/* Free the entire list */
-void pa_strlist_free(struct pa_strlist *l);
+void pa_strlist_free(pa_strlist *l);
/* Return the next entry in the list in *string and remove it from
* the list. Returns the new list head. The memory *string points to
* has to be freed with pa_xfree() */
-struct pa_strlist* pa_strlist_pop(struct pa_strlist *l, char **s);
+pa_strlist* pa_strlist_pop(pa_strlist *l, char **s);
/* Parse a whitespace separated server list */
-struct pa_strlist* pa_strlist_parse(const char *s);
+pa_strlist* pa_strlist_parse(const char *s);
#endif
* called from within the stack frame the entity was created in. */
struct pa_subscription {
- struct pa_core *core;
+ pa_core *core;
int dead;
- void (*callback)(struct pa_core *c, enum pa_subscription_event_type t, uint32_t index, void *userdata);
+ void (*callback)(pa_core *c, pa_subscription_event_type t, uint32_t index, void *userdata);
void *userdata;
- enum pa_subscription_mask mask;
+ pa_subscription_mask mask;
- struct pa_subscription *prev, *next;
+ pa_subscription *prev, *next;
};
struct pa_subscription_event {
- enum pa_subscription_event_type type;
+ pa_subscription_event_type type;
uint32_t index;
};
-static void sched_event(struct pa_core *c);
+static void sched_event(pa_core *c);
/* Allocate a new subscription object for the given subscription mask. Use the specified callback function and user data */
-struct pa_subscription* pa_subscription_new(struct pa_core *c, enum pa_subscription_mask m, void (*callback)(struct pa_core *c, enum pa_subscription_event_type t, uint32_t index, void *userdata), void *userdata) {
- struct pa_subscription *s;
+pa_subscription* pa_subscription_new(pa_core *c, pa_subscription_mask m, void (*callback)(pa_core *c, pa_subscription_event_type t, uint32_t index, void *userdata), void *userdata) {
+ pa_subscription *s;
assert(c);
- s = pa_xmalloc(sizeof(struct pa_subscription));
+ s = pa_xmalloc(sizeof(pa_subscription));
s->core = c;
s->dead = 0;
s->callback = callback;
}
/* Free a subscription object, effectively marking it for deletion */
-void pa_subscription_free(struct pa_subscription*s) {
+void pa_subscription_free(pa_subscription*s) {
assert(s && !s->dead);
s->dead = 1;
sched_event(s->core);
}
-static void free_item(struct pa_subscription *s) {
+static void free_item(pa_subscription *s) {
assert(s && s->core);
if (s->prev)
}
/* Free all subscription objects */
-void pa_subscription_free_all(struct pa_core *c) {
- struct pa_subscription_event *e;
+void pa_subscription_free_all(pa_core *c) {
+ pa_subscription_event *e;
assert(c);
while (c->subscriptions)
}
}
-/*static void dump_event(struct pa_subscription_event*e) {
+/*static void dump_event(pa_subscription_event*e) {
switch (e->type & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) {
case PA_SUBSCRIPTION_EVENT_SINK:
pa_log(__FILE__": SINK_EVENT");
}*/
/* Deferred callback for dispatching subscirption events */
-static void defer_cb(struct pa_mainloop_api *m, struct pa_defer_event *e, void *userdata) {
- struct pa_core *c = userdata;
- struct pa_subscription *s;
- assert(c && c->subscription_defer_event == e && c->mainloop == m);
+static void defer_cb(pa_mainloop_api *m, pa_defer_event *de, void *userdata) {
+ pa_core *c = userdata;
+ pa_subscription *s;
+ assert(c && c->subscription_defer_event == de && c->mainloop == m);
c->mainloop->defer_enable(c->subscription_defer_event, 0);
/* Dispatch queued events */
if (c->subscription_event_queue) {
- struct pa_subscription_event *e;
+ pa_subscription_event *e;
while ((e = pa_queue_pop(c->subscription_event_queue))) {
- struct pa_subscription *s;
for (s = c->subscriptions; s; s = s->next) {
s = c->subscriptions;
while (s) {
- struct pa_subscription *n = s->next;
+ pa_subscription *n = s->next;
if (s->dead)
free_item(s);
s = n;
}
/* Schedule an mainloop event so that a pending subscription event is dispatched */
-static void sched_event(struct pa_core *c) {
+static void sched_event(pa_core *c) {
assert(c);
if (!c->subscription_defer_event) {
}
/* Append a new subscription event to the subscription event queue and schedule a main loop event */
-void pa_subscription_post(struct pa_core *c, enum pa_subscription_event_type t, uint32_t index) {
- struct pa_subscription_event *e;
+void pa_subscription_post(pa_core *c, pa_subscription_event_type t, uint32_t index) {
+ pa_subscription_event *e;
assert(c);
- e = pa_xmalloc(sizeof(struct pa_subscription_event));
+ e = pa_xmalloc(sizeof(pa_subscription_event));
e->type = t;
e->index = index;
USA.
***/
+typedef struct pa_subscription pa_subscription;
+typedef struct pa_subscription_event pa_subscription_event;
+
#include "core.h"
#include "native-common.h"
-struct pa_subscription;
-struct pa_subscription_event;
-
-struct pa_subscription* pa_subscription_new(struct pa_core *c, enum pa_subscription_mask m, void (*callback)(struct pa_core *c, enum pa_subscription_event_type t, uint32_t index, void *userdata), void *userdata);
-void pa_subscription_free(struct pa_subscription*s);
-void pa_subscription_free_all(struct pa_core *c);
+pa_subscription* pa_subscription_new(pa_core *c, pa_subscription_mask m, void (*callback)(pa_core *c, pa_subscription_event_type t, uint32_t index, void *userdata), void *userdata);
+void pa_subscription_free(pa_subscription*s);
+void pa_subscription_free_all(pa_core *c);
-void pa_subscription_post(struct pa_core *c, enum pa_subscription_event_type t, uint32_t index);
+void pa_subscription_post(pa_core *c, pa_subscription_event_type t, uint32_t idx);
#endif
int dynamic;
};
-struct pa_tagstruct *pa_tagstruct_new(const uint8_t* data, size_t length) {
- struct pa_tagstruct*t;
+pa_tagstruct *pa_tagstruct_new(const uint8_t* data, size_t length) {
+ pa_tagstruct*t;
assert(!data || (data && length));
- t = pa_xmalloc(sizeof(struct pa_tagstruct));
+ t = pa_xmalloc(sizeof(pa_tagstruct));
t->data = (uint8_t*) data;
t->allocated = t->length = data ? length : 0;
t->rindex = 0;
return t;
}
-void pa_tagstruct_free(struct pa_tagstruct*t) {
+void pa_tagstruct_free(pa_tagstruct*t) {
assert(t);
if (t->dynamic)
pa_xfree(t->data);
pa_xfree(t);
}
-uint8_t* pa_tagstruct_free_data(struct pa_tagstruct*t, size_t *l) {
+uint8_t* pa_tagstruct_free_data(pa_tagstruct*t, size_t *l) {
uint8_t *p;
assert(t && t->dynamic && l);
p = t->data;
return p;
}
-static void extend(struct pa_tagstruct*t, size_t l) {
+static void extend(pa_tagstruct*t, size_t l) {
assert(t && t->dynamic);
if (t->length+l <= t->allocated)
t->data = pa_xrealloc(t->data, t->allocated = t->length+l+100);
}
-void pa_tagstruct_puts(struct pa_tagstruct*t, const char *s) {
+void pa_tagstruct_puts(pa_tagstruct*t, const char *s) {
size_t l;
assert(t);
if (s) {
}
}
-void pa_tagstruct_putu32(struct pa_tagstruct*t, uint32_t i) {
+void pa_tagstruct_putu32(pa_tagstruct*t, uint32_t i) {
assert(t);
extend(t, 5);
t->data[t->length] = TAG_U32;
t->length += 5;
}
-void pa_tagstruct_putu8(struct pa_tagstruct*t, uint8_t c) {
+void pa_tagstruct_putu8(pa_tagstruct*t, uint8_t c) {
assert(t);
extend(t, 2);
t->data[t->length] = TAG_U8;
t->length += 2;
}
-void pa_tagstruct_put_sample_spec(struct pa_tagstruct *t, const struct pa_sample_spec *ss) {
+void pa_tagstruct_put_sample_spec(pa_tagstruct *t, const pa_sample_spec *ss) {
uint32_t rate;
assert(t && ss);
extend(t, 7);
t->length += 7;
}
-void pa_tagstruct_put_arbitrary(struct pa_tagstruct *t, const void *p, size_t length) {
+void pa_tagstruct_put_arbitrary(pa_tagstruct *t, const void *p, size_t length) {
uint32_t tmp;
assert(t && p);
t->length += 5+length;
}
-void pa_tagstruct_put_boolean(struct pa_tagstruct*t, int b) {
+void pa_tagstruct_put_boolean(pa_tagstruct*t, int b) {
assert(t);
extend(t, 1);
t->data[t->length] = b ? TAG_BOOLEAN_TRUE : TAG_BOOLEAN_FALSE;
t->length += 1;
}
-void pa_tagstruct_put_timeval(struct pa_tagstruct*t, const struct timeval *tv) {
+void pa_tagstruct_put_timeval(pa_tagstruct*t, const struct timeval *tv) {
uint32_t tmp;
assert(t);
extend(t, 9);
t->length += 9;
}
-void pa_tagstruct_put_usec(struct pa_tagstruct*t, pa_usec_t u) {
+void pa_tagstruct_put_usec(pa_tagstruct*t, pa_usec_t u) {
uint32_t tmp;
assert(t);
extend(t, 9);
t->length += 9;
}
-void pa_tagstruct_putu64(struct pa_tagstruct*t, uint64_t u) {
+void pa_tagstruct_putu64(pa_tagstruct*t, uint64_t u) {
uint32_t tmp;
assert(t);
extend(t, 9);
t->length += 9;
}
-int pa_tagstruct_gets(struct pa_tagstruct*t, const char **s) {
+int pa_tagstruct_gets(pa_tagstruct*t, const char **s) {
int error = 0;
size_t n;
char *c;
return 0;
}
-int pa_tagstruct_getu32(struct pa_tagstruct*t, uint32_t *i) {
+int pa_tagstruct_getu32(pa_tagstruct*t, uint32_t *i) {
assert(t && i);
if (t->rindex+5 > t->length)
return 0;
}
-int pa_tagstruct_getu8(struct pa_tagstruct*t, uint8_t *c) {
+int pa_tagstruct_getu8(pa_tagstruct*t, uint8_t *c) {
assert(t && c);
if (t->rindex+2 > t->length)
return 0;
}
-int pa_tagstruct_get_sample_spec(struct pa_tagstruct *t, struct pa_sample_spec *ss) {
+int pa_tagstruct_get_sample_spec(pa_tagstruct *t, pa_sample_spec *ss) {
assert(t && ss);
if (t->rindex+7 > t->length)
return 0;
}
-int pa_tagstruct_get_arbitrary(struct pa_tagstruct *t, const void **p, size_t length) {
+int pa_tagstruct_get_arbitrary(pa_tagstruct *t, const void **p, size_t length) {
uint32_t len;
assert(t && p);
return 0;
}
-int pa_tagstruct_eof(struct pa_tagstruct*t) {
+int pa_tagstruct_eof(pa_tagstruct*t) {
assert(t);
return t->rindex >= t->length;
}
-const uint8_t* pa_tagstruct_data(struct pa_tagstruct*t, size_t *l) {
+const uint8_t* pa_tagstruct_data(pa_tagstruct*t, size_t *l) {
assert(t && t->dynamic && l);
*l = t->length;
return t->data;
}
-int pa_tagstruct_get_boolean(struct pa_tagstruct*t, int *b) {
+int pa_tagstruct_get_boolean(pa_tagstruct*t, int *b) {
assert(t && b);
if (t->rindex+1 > t->length)
return 0;
}
-int pa_tagstruct_get_timeval(struct pa_tagstruct*t, struct timeval *tv) {
+int pa_tagstruct_get_timeval(pa_tagstruct*t, struct timeval *tv) {
if (t->rindex+9 > t->length)
return -1;
}
-int pa_tagstruct_get_usec(struct pa_tagstruct*t, pa_usec_t *u) {
+int pa_tagstruct_get_usec(pa_tagstruct*t, pa_usec_t *u) {
uint32_t tmp;
assert(t && u);
return 0;
}
-int pa_tagstruct_getu64(struct pa_tagstruct*t, uint64_t *u) {
+int pa_tagstruct_getu64(pa_tagstruct*t, uint64_t *u) {
uint32_t tmp;
assert(t && u);
#include "sample.h"
-struct pa_tagstruct;
-
-struct pa_tagstruct *pa_tagstruct_new(const uint8_t* data, size_t length);
-void pa_tagstruct_free(struct pa_tagstruct*t);
-uint8_t* pa_tagstruct_free_data(struct pa_tagstruct*t, size_t *l);
-
-void pa_tagstruct_puts(struct pa_tagstruct*t, const char *s);
-void pa_tagstruct_putu8(struct pa_tagstruct*t, uint8_t c);
-void pa_tagstruct_putu32(struct pa_tagstruct*t, uint32_t i);
-void pa_tagstruct_putu64(struct pa_tagstruct*t, uint64_t i);
-void pa_tagstruct_put_sample_spec(struct pa_tagstruct *t, const struct pa_sample_spec *ss);
-void pa_tagstruct_put_arbitrary(struct pa_tagstruct*t, const void *p, size_t length);
-void pa_tagstruct_put_boolean(struct pa_tagstruct*t, int b);
-void pa_tagstruct_put_timeval(struct pa_tagstruct*t, const struct timeval *tv);
-void pa_tagstruct_put_usec(struct pa_tagstruct*t, pa_usec_t u);
-
-int pa_tagstruct_gets(struct pa_tagstruct*t, const char **s);
-int pa_tagstruct_getu8(struct pa_tagstruct*t, uint8_t *c);
-int pa_tagstruct_getu32(struct pa_tagstruct*t, uint32_t *i);
-int pa_tagstruct_getu64(struct pa_tagstruct*t, uint64_t *i);
-int pa_tagstruct_get_sample_spec(struct pa_tagstruct *t, struct pa_sample_spec *ss);
-int pa_tagstruct_get_arbitrary(struct pa_tagstruct *t, const void **p, size_t length);
-int pa_tagstruct_get_boolean(struct pa_tagstruct *t, int *b);
-int pa_tagstruct_get_timeval(struct pa_tagstruct*t, struct timeval *tv);
-int pa_tagstruct_get_usec(struct pa_tagstruct*t, pa_usec_t *u);
-
-int pa_tagstruct_eof(struct pa_tagstruct*t);
-const uint8_t* pa_tagstruct_data(struct pa_tagstruct*t, size_t *l);
+typedef struct pa_tagstruct pa_tagstruct;
+
+pa_tagstruct *pa_tagstruct_new(const uint8_t* data, size_t length);
+void pa_tagstruct_free(pa_tagstruct*t);
+uint8_t* pa_tagstruct_free_data(pa_tagstruct*t, size_t *l);
+
+void pa_tagstruct_puts(pa_tagstruct*t, const char *s);
+void pa_tagstruct_putu8(pa_tagstruct*t, uint8_t c);
+void pa_tagstruct_putu32(pa_tagstruct*t, uint32_t i);
+void pa_tagstruct_putu64(pa_tagstruct*t, uint64_t i);
+void pa_tagstruct_put_sample_spec(pa_tagstruct *t, const pa_sample_spec *ss);
+void pa_tagstruct_put_arbitrary(pa_tagstruct*t, const void *p, size_t length);
+void pa_tagstruct_put_boolean(pa_tagstruct*t, int b);
+void pa_tagstruct_put_timeval(pa_tagstruct*t, const struct timeval *tv);
+void pa_tagstruct_put_usec(pa_tagstruct*t, pa_usec_t u);
+
+int pa_tagstruct_gets(pa_tagstruct*t, const char **s);
+int pa_tagstruct_getu8(pa_tagstruct*t, uint8_t *c);
+int pa_tagstruct_getu32(pa_tagstruct*t, uint32_t *i);
+int pa_tagstruct_getu64(pa_tagstruct*t, uint64_t *i);
+int pa_tagstruct_get_sample_spec(pa_tagstruct *t, pa_sample_spec *ss);
+int pa_tagstruct_get_arbitrary(pa_tagstruct *t, const void **p, size_t length);
+int pa_tagstruct_get_boolean(pa_tagstruct *t, int *b);
+int pa_tagstruct_get_timeval(pa_tagstruct*t, struct timeval *tv);
+int pa_tagstruct_get_usec(pa_tagstruct*t, pa_usec_t *u);
+
+int pa_tagstruct_eof(pa_tagstruct*t);
+const uint8_t* pa_tagstruct_data(pa_tagstruct*t, size_t *l);
#endif
#include "tokenizer.h"
#include "dynarray.h"
#include "xmalloc.h"
+#include "gccmacro.h"
struct pa_tokenizer {
- struct pa_dynarray *dynarray;
+ pa_dynarray *dynarray;
};
-static void token_free(void *p, void *userdata) {
+static void token_free(void *p, PA_GCC_UNUSED void *userdata) {
pa_xfree(p);
}
-static void parse(struct pa_dynarray*a, const char *s, unsigned args) {
+static void parse(pa_dynarray*a, const char *s, unsigned args) {
int infty = 0;
const char delimiter[] = " \t\n\r";
const char *p;
}
}
-struct pa_tokenizer* pa_tokenizer_new(const char *s, unsigned args) {
- struct pa_tokenizer *t;
+pa_tokenizer* pa_tokenizer_new(const char *s, unsigned args) {
+ pa_tokenizer *t;
- t = pa_xmalloc(sizeof(struct pa_tokenizer));
+ t = pa_xmalloc(sizeof(pa_tokenizer));
t->dynarray = pa_dynarray_new();
assert(t->dynarray);
return t;
}
-void pa_tokenizer_free(struct pa_tokenizer *t) {
+void pa_tokenizer_free(pa_tokenizer *t) {
assert(t);
pa_dynarray_free(t->dynarray, token_free, NULL);
pa_xfree(t);
}
-const char *pa_tokenizer_get(struct pa_tokenizer *t, unsigned i) {
+const char *pa_tokenizer_get(pa_tokenizer *t, unsigned i) {
assert(t);
return pa_dynarray_get(t->dynarray, i);
}
USA.
***/
-struct pa_tokenizer;
+typedef struct pa_tokenizer pa_tokenizer;
-struct pa_tokenizer* pa_tokenizer_new(const char *s, unsigned args);
-void pa_tokenizer_free(struct pa_tokenizer *t);
+pa_tokenizer* pa_tokenizer_new(const char *s, unsigned args);
+void pa_tokenizer_free(pa_tokenizer *t);
-const char *pa_tokenizer_get(struct pa_tokenizer *t, unsigned i);
+const char *pa_tokenizer_get(pa_tokenizer *t, unsigned i);
#endif
break;
ret += r;
- data = (uint8_t*) data + r;
+ data = (const uint8_t*) data + r;
size -= r;
}
/* Check the current user is member of the specified group */
int pa_uid_in_group(const char *name, gid_t *gid) {
- gid_t *gids, tgid;
- GETGROUPS_T n = sysconf(_SC_NGROUPS_MAX);
+ GETGROUPS_T *gids, tgid;
+ int n = sysconf(_SC_NGROUPS_MAX);
int r = -1, i;
assert(n > 0);
- gids = pa_xmalloc(sizeof(gid_t)*n);
+ gids = pa_xmalloc(sizeof(GETGROUPS_T)*n);
if ((n = getgroups(n, gids)) < 0) {
pa_log(__FILE__": getgroups() failed: %s\n", strerror(errno));
#include <stdarg.h>
#include <stdio.h>
-#include "gcc-printf.h"
+#include "gccmacro.h"
#include "sample.h"
struct timeval;
#include <stdio.h>
#include <polyp/sample.h>
+#include "gccmacro.h"
-int main() {
+int main(PA_GCC_UNUSED int argc, PA_GCC_UNUSED char *argv[]) {
int p;
for (p = 0; p <= 200; p++) {
pa_volume_t v = pa_volume_from_user((double) p/100);
#include "log.h"
#include "props.h"
-struct pa_x11_client;
+typedef struct pa_x11_internal pa_x11_internal;
struct pa_x11_internal {
- PA_LLIST_FIELDS(struct pa_x11_internal);
- struct pa_x11_wrapper *wrapper;
- struct pa_io_event* io_event;
+ PA_LLIST_FIELDS(pa_x11_internal);
+ pa_x11_wrapper *wrapper;
+ pa_io_event* io_event;
int fd;
};
struct pa_x11_wrapper {
- struct pa_core *core;
+ pa_core *core;
int ref;
char *property_name;
Display *display;
- struct pa_defer_event* defer_event;
- struct pa_io_event* io_event;
+ pa_defer_event* defer_event;
+ pa_io_event* io_event;
- PA_LLIST_HEAD(struct pa_x11_client, clients);
- PA_LLIST_HEAD(struct pa_x11_internal, internals);
+ PA_LLIST_HEAD(pa_x11_client, clients);
+ PA_LLIST_HEAD(pa_x11_internal, internals);
};
struct pa_x11_client {
- PA_LLIST_FIELDS(struct pa_x11_client);
- struct pa_x11_wrapper *wrapper;
- int (*callback)(struct pa_x11_wrapper *w, XEvent *e, void *userdata);
+ PA_LLIST_FIELDS(pa_x11_client);
+ pa_x11_wrapper *wrapper;
+ int (*callback)(pa_x11_wrapper *w, XEvent *e, void *userdata);
void *userdata;
};
/* Dispatch all pending X11 events */
-static void work(struct pa_x11_wrapper *w) {
+static void work(pa_x11_wrapper *w) {
assert(w && w->ref >= 1);
while (XPending(w->display)) {
- struct pa_x11_client *c;
+ pa_x11_client *c;
XEvent e;
XNextEvent(w->display, &e);
}
/* IO notification event for the X11 display connection */
-static void display_io_event(struct pa_mainloop_api *m, struct pa_io_event *e, int fd, enum pa_io_event_flags f, void *userdata) {
- struct pa_x11_wrapper *w = userdata;
+static void display_io_event(pa_mainloop_api *m, pa_io_event *e, int fd, PA_GCC_UNUSED pa_io_event_flags f, void *userdata) {
+ pa_x11_wrapper *w = userdata;
assert(m && e && fd >= 0 && w && w->ref >= 1);
work(w);
}
/* Deferred notification event. Called once each main loop iteration */
-static void defer_event(struct pa_mainloop_api *m, struct pa_defer_event *e, void *userdata) {
- struct pa_x11_wrapper *w = userdata;
+static void defer_event(pa_mainloop_api *m, pa_defer_event *e, void *userdata) {
+ pa_x11_wrapper *w = userdata;
assert(m && e && w && w->ref >= 1);
work(w);
}
/* IO notification event for X11 internal connections */
-static void internal_io_event(struct pa_mainloop_api *m, struct pa_io_event *e, int fd, enum pa_io_event_flags f, void *userdata) {
- struct pa_x11_wrapper *w = userdata;
+static void internal_io_event(pa_mainloop_api *m, pa_io_event *e, int fd, PA_GCC_UNUSED pa_io_event_flags f, void *userdata) {
+ pa_x11_wrapper *w = userdata;
assert(m && e && fd >= 0 && w && w->ref >= 1);
XProcessInternalConnection(w->display, fd);
}
/* Add a new IO source for the specified X11 internal connection */
-static struct pa_x11_internal* x11_internal_add(struct pa_x11_wrapper *w, int fd) {
- struct pa_x11_internal *i;
+static pa_x11_internal* x11_internal_add(pa_x11_wrapper *w, int fd) {
+ pa_x11_internal *i;
assert(i && fd >= 0);
- i = pa_xmalloc(sizeof(struct pa_x11_internal));
+ i = pa_xmalloc(sizeof(pa_x11_internal));
i->wrapper = w;
i->io_event = w->core->mainloop->io_new(w->core->mainloop, fd, PA_IO_EVENT_INPUT, internal_io_event, w);
i->fd = fd;
- PA_LLIST_PREPEND(struct pa_x11_internal, w->internals, i);
+ PA_LLIST_PREPEND(pa_x11_internal, w->internals, i);
return i;
}
/* Remove an IO source for an X11 internal connection */
-void x11_internal_remove(struct pa_x11_wrapper *w, struct pa_x11_internal *i) {
+static void x11_internal_remove(pa_x11_wrapper *w, pa_x11_internal *i) {
assert(i);
- PA_LLIST_REMOVE(struct pa_x11_internal, w->internals, i);
+ PA_LLIST_REMOVE(pa_x11_internal, w->internals, i);
w->core->mainloop->io_free(i->io_event);
pa_xfree(i);
}
/* Implementation of XConnectionWatchProc */
static void x11_watch(Display *display, XPointer userdata, int fd, Bool opening, XPointer *watch_data) {
- struct pa_x11_wrapper *w = (struct pa_x11_wrapper*) userdata;
+ pa_x11_wrapper *w = (pa_x11_wrapper*) userdata;
assert(display && w && fd >= 0);
if (opening)
*watch_data = (XPointer) x11_internal_add(w, fd);
else
- x11_internal_remove(w, (struct pa_x11_internal*) *watch_data);
+ x11_internal_remove(w, (pa_x11_internal*) *watch_data);
}
-static struct pa_x11_wrapper* x11_wrapper_new(struct pa_core *c, const char *name, const char *t) {
- struct pa_x11_wrapper*w;
+static pa_x11_wrapper* x11_wrapper_new(pa_core *c, const char *name, const char *t) {
+ pa_x11_wrapper*w;
Display *d;
int r;
return NULL;
}
- w = pa_xmalloc(sizeof(struct pa_x11_wrapper));
+ w = pa_xmalloc(sizeof(pa_x11_wrapper));
w->core = c;
w->ref = 1;
w->property_name = pa_xstrdup(t);
w->display = d;
- PA_LLIST_HEAD_INIT(struct pa_x11_client, w->clients);
- PA_LLIST_HEAD_INIT(struct pa_x11_internal, w->internals);
+ PA_LLIST_HEAD_INIT(pa_x11_client, w->clients);
+ PA_LLIST_HEAD_INIT(pa_x11_internal, w->internals);
w->defer_event = c->mainloop->defer_new(c->mainloop, defer_event, w);
w->io_event = c->mainloop->io_new(c->mainloop, ConnectionNumber(d), PA_IO_EVENT_INPUT, display_io_event, w);
return w;
}
-static void x11_wrapper_free(struct pa_x11_wrapper*w) {
+static void x11_wrapper_free(pa_x11_wrapper*w) {
int r;
assert(w);
pa_xfree(w);
}
-struct pa_x11_wrapper* pa_x11_wrapper_get(struct pa_core *c, const char *name) {
+pa_x11_wrapper* pa_x11_wrapper_get(pa_core *c, const char *name) {
char t[256];
- struct pa_x11_wrapper *w;
+ pa_x11_wrapper *w;
assert(c);
snprintf(t, sizeof(t), "x11-wrapper%s%s", name ? "-" : "", name ? name : "");
return x11_wrapper_new(c, name, t);
}
-struct pa_x11_wrapper* pa_x11_wrapper_ref(struct pa_x11_wrapper *w) {
+pa_x11_wrapper* pa_x11_wrapper_ref(pa_x11_wrapper *w) {
assert(w && w->ref >= 1);
w->ref++;
return w;
}
-void pa_x11_wrapper_unref(struct pa_x11_wrapper* w) {
+void pa_x11_wrapper_unref(pa_x11_wrapper* w) {
assert(w && w->ref >= 1);
if (!(--w->ref))
x11_wrapper_free(w);
}
-Display *pa_x11_wrapper_get_display(struct pa_x11_wrapper *w) {
+Display *pa_x11_wrapper_get_display(pa_x11_wrapper *w) {
assert(w && w->ref >= 1);
return w->display;
}
-struct pa_x11_client* pa_x11_client_new(struct pa_x11_wrapper *w, int (*cb)(struct pa_x11_wrapper *w, XEvent *e, void *userdata), void *userdata) {
- struct pa_x11_client *c;
+pa_x11_client* pa_x11_client_new(pa_x11_wrapper *w, int (*cb)(pa_x11_wrapper *w, XEvent *e, void *userdata), void *userdata) {
+ pa_x11_client *c;
assert(w && w->ref >= 1);
- c = pa_xmalloc(sizeof(struct pa_x11_client));
+ c = pa_xmalloc(sizeof(pa_x11_client));
c->wrapper = w;
c->callback = cb;
c->userdata = userdata;
- PA_LLIST_PREPEND(struct pa_x11_client, w->clients, c);
+ PA_LLIST_PREPEND(pa_x11_client, w->clients, c);
return c;
}
-void pa_x11_client_free(struct pa_x11_client *c) {
+void pa_x11_client_free(pa_x11_client *c) {
assert(c && c->wrapper && c->wrapper->ref >= 1);
- PA_LLIST_REMOVE(struct pa_x11_client, c->wrapper->clients, c);
+ PA_LLIST_REMOVE(pa_x11_client, c->wrapper->clients, c);
pa_xfree(c);
}
#include "core.h"
-struct pa_x11_wrapper;
+typedef struct pa_x11_wrapper pa_x11_wrapper;
/* Return the X11 wrapper for this core. In case no wrapper was
existant before, allocate a new one */
-struct pa_x11_wrapper* pa_x11_wrapper_get(struct pa_core *c, const char *name);
+pa_x11_wrapper* pa_x11_wrapper_get(pa_core *c, const char *name);
/* Increase the wrapper's reference count by one */
-struct pa_x11_wrapper* pa_x11_wrapper_ref(struct pa_x11_wrapper *w);
+pa_x11_wrapper* pa_x11_wrapper_ref(pa_x11_wrapper *w);
/* Decrease the reference counter of an X11 wrapper object */
-void pa_x11_wrapper_unref(struct pa_x11_wrapper* w);
+void pa_x11_wrapper_unref(pa_x11_wrapper* w);
/* Return the X11 display object for this connection */
-Display *pa_x11_wrapper_get_display(struct pa_x11_wrapper *w);
+Display *pa_x11_wrapper_get_display(pa_x11_wrapper *w);
-struct pa_x11_client;
+typedef struct pa_x11_client pa_x11_client;
/* Register an X11 client, that is called for each X11 event */
-struct pa_x11_client* pa_x11_client_new(struct pa_x11_wrapper *w, int (*cb)(struct pa_x11_wrapper *w, XEvent *e, void *userdata), void *userdata);
+pa_x11_client* pa_x11_client_new(pa_x11_wrapper *w, int (*cb)(pa_x11_wrapper *w, XEvent *e, void *userdata), void *userdata);
/* Free an X11 client object */
-void pa_x11_client_free(struct pa_x11_client *c);
+void pa_x11_client_free(pa_x11_client *c);
#endif
#include "memory.h"
#include "util.h"
+#include "xmalloc.h"
+#include "gccmacro.h"
/* Make sure not to allocate more than this much memory. */
#define MAX_ALLOC_SIZE (1024*1024*20) /* 20MB */
/* #undef strndup */
/* #undef strdup */
+static void oom(void) PA_GCC_NORETURN;
+
/** called in case of an OOM situation. Prints an error message and
* exits */
static void oom(void) {
#include <sys/types.h>
#include <stdlib.h>
+#include <limits.h>
+#include <assert.h>
void* pa_xmalloc(size_t l);
void *pa_xmalloc0(size_t l);
void* pa_xmemdup(const void *p, size_t l);
+/** Internal helper for pa_xnew() */
+static inline void* pa_xnew_internal(unsigned n, size_t k) {
+ assert(n < INT_MAX/k);
+ return pa_xmalloc(n*k);
+}
+
+/** Allocate n new structures of the specified type. */
+#define pa_xnew(type, n) ((type*) pa_xnew_internal((n), sizeof(type)))
+
+/** Internal helper for pa_xnew0() */
+static inline void* pa_xnew0_internal(unsigned n, size_t k) {
+ assert(n < INT_MAX/k);
+ return pa_xmalloc0(n*k);
+}
+
+/** Same as pa_xnew() but set the memory to zero */
+#define pa_xnew0(type, n) ((type*) pa_xnew0_internal((n), sizeof(type)))
+
#endif