const char* pa__get_usage(void);
const char* pa__get_version(void);
const char* pa__get_deprecated(void);
-pa_bool_t pa__load_once(void);
+bool pa__load_once(void);
#endif
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Augment the property sets of streams with additional static information");
PA_MODULE_VERSION(PACKAGE_VERSION);
-PA_MODULE_LOAD_ONCE(TRUE);
+PA_MODULE_LOAD_ONCE(true);
#ifndef CONFIG_FILE_DIR
#define CONFIG_FILE_DIR "/etc/pulse/augment_property_client_rules"
struct rule {
time_t timestamp;
- pa_bool_t good;
+ bool good;
time_t desktop_mtime;
time_t conf_mtime;
char *process_name;
struct sink_input_rule_section {
char *stream_key;
- pa_bool_t comp;
+ bool comp;
regex_t stream_value;
char *section_name; /* for hashmap memory management */
};
}
static void sink_input_rule_file_free(struct sink_input_rule_file *rf, struct userdata *u) {
+ void *state;
+ struct sink_input_rule_section *section;
+
pa_assert(rf);
- pa_hashmap_free(rf->rules, (pa_free_cb_t) sink_input_rule_free);
+ PA_HASHMAP_FOREACH(section, rf->rules, state) {
+ pa_xfree(section->stream_key);
+ if (section->comp)
+ regfree(§ion->stream_value);
+ pa_xfree(section->section_name);
+ }
+
+ pa_hashmap_free(rf->rules);
+
pa_xfree(rf->client_name);
pa_xfree(rf->target_key);
pa_xfree(rf->target_value);
pa_xfree(rf);
}
-static int parse_properties(
- const char *filename,
- unsigned line,
- const char *section,
- const char *lvalue,
- const char *rvalue,
- void *data,
- void *userdata) {
+static int parse_properties(pa_config_parser_state *state) {
- struct rule *r = userdata;
+ pa_assert(state);
+
+ struct rule *r = state->userdata;
pa_proplist *n;
- if (!(n = pa_proplist_from_string(rvalue)))
+ if (!(n = pa_proplist_from_string(state->rvalue)))
return -1;
if (r->proplist) {
return 0;
}
-static int parse_categories(
- const char *filename,
- unsigned line,
- const char *section,
- const char *lvalue,
- const char *rvalue,
- void *data,
- void *userdata) {
-
- struct rule *r = userdata;
- const char *state = NULL;
+static int parse_categories(pa_config_parser_state *state) {
+ pa_assert(state);
+
+ struct rule *r = state->userdata;
+ const char *s = NULL;
char *c;
- while ((c = pa_split(rvalue, ";", &state))) {
+ while ((c = pa_split(state->rvalue, ";", &s))) {
if (pa_streq(c, "Game")) {
pa_xfree(r->role);
return 0;
}
-static int check_type(
- const char *filename,
- unsigned line,
- const char *section,
- const char *lvalue,
- const char *rvalue,
- void *data,
- void *userdata) {
+static int check_type(pa_config_parser_state *state) {
+ pa_assert(state);
- return pa_streq(rvalue, "Application") ? 0 : -1;
+ return pa_streq(state->rvalue, "Application") ? 0 : -1;
}
-static int catch_all(
- const char *filename,
- unsigned line,
- const char *section,
- const char *lvalue,
- const char *rvalue,
- void *data,
- void *userdata) {
+static int catch_all(pa_config_parser_state *state) {
return 0;
}
-static void parse_file(struct rule *r, const char *fn, pa_config_item *table, pa_bool_t first) {
+static void parse_file(struct rule *r, const char *fn, pa_config_item *table, bool first) {
char *application_name = NULL;
char *icon_name = NULL;
char *role = NULL;
{ NULL, catch_all, NULL, NULL },
{ NULL, NULL, NULL, NULL },
};
- pa_bool_t found = FALSE;
+ bool found = false;
pa_assert(r);
pa_log_debug("Looking for file %s", fn);
if (stat(fn, &st) == 0)
- found = TRUE;
+ found = true;
if (!found)
- r->good = FALSE;
+ r->good = false;
if (found && !(r->good && st.st_mtime == r->conf_mtime)) {
/* Theoretically the filename could have changed, but if so
else
pa_log_debug("Found %s.", fn);
- parse_file(r, fn, table, TRUE);
+ parse_file(r, fn, table, true);
r->conf_mtime = st.st_mtime;
- r->good = TRUE;
+ r->good = true;
}
pa_xfree(fn);
- found = FALSE;
+ found = false;
fn = pa_sprintf_malloc(DESKTOPFILEDIR PA_PATH_SEP "%s.desktop", r->process_name);
pa_log_debug("Looking for file %s", fn);
if (stat(fn, &st) == 0)
- found = TRUE;
+ found = true;
else {
#ifdef DT_DIR
DIR *desktopfiles_dir;
fn = pa_sprintf_malloc(DESKTOPFILEDIR PA_PATH_SEP "%s" PA_PATH_SEP "%s.desktop", dir->d_name, r->process_name);
if (stat(fn, &st) == 0) {
- found = TRUE;
+ found = true;
break;
}
}
#endif
}
if (!found) {
- r->good = FALSE;
+ r->good = false;
pa_xfree(fn);
return;
}
} else
pa_log_debug("Found %s.", fn);
- parse_file(r, fn, table, FALSE);
+ parse_file(r, fn, table, false);
r->desktop_mtime = st.st_mtime;
- r->good = TRUE;
+ r->good = true;
pa_xfree(fn);
r = pa_xnew0(struct rule, 1);
r->process_name = pa_xstrdup(pn);
r->timestamp = now;
- pa_hashmap_put(u->cache, r->process_name, r);
+ pa_hashmap_put(u->cache, (void *)r->process_name, r);
update_rule(r);
}
/* init the map */
while (*iter) {
- pa_hashmap_put(valid, (const void *) *iter, (void *) RULE_UNDEFINED);
+ pa_hashmap_put(valid, (void *) *iter, (void *) RULE_UNDEFINED);
iter++;
}
if (status == RULE_UNDEFINED) {
pa_hashmap_remove(valid, *iter);
- pa_hashmap_put(valid, (const void *) *iter, (void *) RULE_HIT);
+ pa_hashmap_put(valid, (void *) *iter, (void *) RULE_HIT);
}
}
else {
/* miss, no more processing for this rule file*/
pa_hashmap_remove(valid, *iter);
- pa_hashmap_put(valid, (const void *) *iter, (void *) RULE_MISS);
+ pa_hashmap_put(valid, (void *) *iter, (void *) RULE_MISS);
pa_log_debug("miss %s", *iter);
}
}
}
}
- pa_hashmap_free(valid, NULL);
+ pa_hashmap_free(valid);
iter = possible;
while (*iter) {
return process_sink_input(u, new_data->proplist, new_data->client);
}
-static int parse_rule_sections(
- const char *filename,
- unsigned line,
- const char *section,
- const char *lvalue,
- const char *rvalue,
- void *data,
- void *userdata) {
+static int parse_rule_sections(pa_config_parser_state *state) {
- struct sink_input_rule_file **rfp = data;
- struct sink_input_rule_file *rf = *rfp;
+ struct sink_input_rule_file **rfp;
+ struct sink_input_rule_file *rf;
+ struct sink_input_rule_section *s;
- struct sink_input_rule_section *s = pa_hashmap_get(rf->rules, section);
+ pa_assert(state);
+
+ rfp = state->data;
+ rf = *rfp;
+ s = pa_hashmap_get(rf->rules, state->section);
if (!s) {
s = pa_xnew0(struct sink_input_rule_section, 1);
- s->comp = FALSE;
+ s->comp = false;
/* add key to the struct for later freeing */
- s->section_name = pa_xstrdup(section);
- pa_hashmap_put(rf->rules, s->section_name, s);
+ s->section_name = pa_xstrdup(state->section);
+ pa_hashmap_put(rf->rules, (void *)s->section_name, s);
}
- if (strcmp(lvalue, "prop_key") == 0) {
+ if (strcmp(state->lvalue, "prop_key") == 0) {
if (s->stream_key)
pa_xfree(s->stream_key);
- s->stream_key = pa_xstrdup(rvalue);
+ s->stream_key = pa_xstrdup(state->rvalue);
}
- else if (strcmp(lvalue, "prop_value") == 0) {
+ else if (strcmp(state->lvalue, "prop_value") == 0) {
int ret;
if (s->comp)
regfree(&s->stream_value);
- ret = regcomp(&s->stream_value, rvalue, REG_EXTENDED|REG_NOSUB);
- s->comp = TRUE;
+ ret = regcomp(&s->stream_value, state->rvalue, REG_EXTENDED|REG_NOSUB);
+ s->comp = true;
if (ret != 0) {
char errbuf[256];
return 0;
}
-static pa_bool_t validate_sink_input_rule(struct sink_input_rule_file *rf) {
+static bool validate_sink_input_rule(struct sink_input_rule_file *rf) {
void *state;
struct sink_input_rule_section *s;
if (!rf->target_key || !rf->target_value) {
pa_log_error("No result condition listed for rule file");
/* no result condition listed, so no point in using this rule file */
- return FALSE;
+ return false;
}
PA_HASHMAP_FOREACH(s, rf->rules, state) {
- if (!s->stream_key || s->comp == FALSE) {
+ if (!s->stream_key || s->comp == false) {
pa_log_error("Incomplete rule section [%s] in rule file", s->section_name);
- return FALSE;
+ return false;
}
}
- return TRUE;
+ return true;
}
static pa_hashmap *update_sink_input_rules() {
}
else {
pa_log_info("adding filename %s to %p", rf->fn, rf);
- pa_hashmap_put(rules, rf->fn, rf);
+ pa_hashmap_put(rules, (void *)rf->fn, rf);
}
}
}
closedir(sinkinputrulefiles_dir);
if (pa_hashmap_isempty(rules)) {
- pa_hashmap_free(rules, NULL);
+ pa_hashmap_free(rules);
return NULL;
}
void pa__done(pa_module *m) {
struct userdata* u;
+ struct sink_input_rule_file *rf;
+ void *state;
pa_assert(m);
while ((r = pa_hashmap_steal_first(u->cache)))
rule_free(r);
- pa_hashmap_free(u->cache, NULL);
+ pa_hashmap_free(u->cache);
}
- if (u->sink_input_rules)
- pa_hashmap_free(u->sink_input_rules, (pa_free_cb_t) sink_input_rule_file_free);
+ if (u->sink_input_rules) {
+
+ PA_HASHMAP_FOREACH(rf, u->sink_input_rules, state) {
+ sink_input_rule_file_free(rf, NULL);
+ }
+
+ pa_hashmap_free(u->sink_input_rules);
+ }
if (u->directory_watch_client)
pa_client_free(u->directory_watch_client);
const char* pa__get_usage(void);
const char* pa__get_version(void);
const char* pa__get_deprecated(void);
-pa_bool_t pa__load_once(void);
+bool pa__load_once(void);
#endif
PA_MODULE_AUTHOR("Ismo Puustinen");
PA_MODULE_DESCRIPTION("Directory watch module");
PA_MODULE_VERSION(PACKAGE_VERSION);
-PA_MODULE_LOAD_ONCE(TRUE);
+PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE("");
struct userdata {
pa_log_debug("> inotify_cb");
- while (TRUE) {
+ while (true) {
r = pa_read(fd, &eventbuf, sizeof(eventbuf), &type);
PA_LLIST_PREPEND(struct client_id, cd->ids, id);
- pa_hashmap_put(u->paths_to_clients, (const void *)0 + wd, (void *) cd);
+ pa_hashmap_put(u->paths_to_clients, (void *)0 + wd, (void *) cd);
}
#endif
return 0;
void *state;
struct client_data *cd;
struct client_id *id;
- pa_bool_t found = FALSE;
+ bool found = false;
PA_HASHMAP_FOREACH(cd, u->paths_to_clients, state) {
PA_LLIST_FOREACH(id, cd->ids) {
if (id->id == c->index) {
PA_LLIST_REMOVE(struct client_id, cd->ids, id);
pa_xfree(id);
- found = TRUE;
+ found = true;
break;
}
}
void pa__done(pa_module *m) {
struct userdata *u;
+#ifdef HAVE_INOTIFY
+ void *state;
+ struct client_data *cd;
+#endif
pa_assert(m);
pa_assert(m->userdata);
pa_close(u->inotify_fd);
- if (u->paths_to_clients)
- pa_hashmap_free(u->paths_to_clients, (pa_free_cb_t) client_data_free);
+ if (u->paths_to_clients) {
+
+ PA_HASHMAP_FOREACH(cd, u->paths_to_clients, state) {
+ pa_xfree(cd->directory);
+ while(cd->ids) {
+ struct client_id *id = cd->ids;
+ PA_LLIST_REMOVE(struct client_id, cd->ids, id);
+ pa_xfree(id);
+ }
+ }
+
+ pa_hashmap_free(u->paths_to_clients);
+ }
#endif
pa_xfree(u);
const char* pa__get_usage(void);
const char* pa__get_version(void);
const char* pa__get_deprecated(void);
-pa_bool_t pa__load_once(void);
+bool pa__load_once(void);
#endif
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Combine multiple sinks to one");
PA_MODULE_VERSION(PACKAGE_VERSION);
-PA_MODULE_LOAD_ONCE(FALSE);
+PA_MODULE_LOAD_ONCE(false);
PA_MODULE_USAGE(
"sink_name=<name for the sink> "
"sink_properties=<properties for the sink> "
NULL
};
-
-
-
#include "userdata.h"
-
enum {
SINK_MESSAGE_ADD_OUTPUT = PA_SINK_MESSAGE_MAX,
SINK_MESSAGE_REMOVE_OUTPUT,
pa_thread_mq_install(&u->thread_mq);
u->thread_info.timestamp = pa_rtclock_now();
- u->thread_info.in_null_mode = FALSE;
+ u->thread_info.in_null_mode = false;
for (;;) {
int ret;
process_render_null(u, now);
pa_rtpoll_set_timer_absolute(u->rtpoll, u->thread_info.timestamp);
- u->thread_info.in_null_mode = TRUE;
+ u->thread_info.in_null_mode = true;
} else {
pa_rtpoll_set_timer_disabled(u->rtpoll);
- u->thread_info.in_null_mode = FALSE;
+ u->thread_info.in_null_mode = false;
}
/* Hmm, nothing to do. Let's sleep */
- if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0) {
+ if ((ret = pa_rtpoll_run(u->rtpoll, true)) < 0) {
pa_log_info("pa_rtpoll_run() = %i", ret);
goto fail;
}
PA_RTPOLL_EARLY,
o->outq);
- pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
+ pa_sink_input_request_rewind(i, 0, false, true, true);
pa_atomic_store(&o->max_request, (int) pa_sink_input_get_max_request(i));
pa_sink_input_assert_ref(i);
pa_assert_se(o = i->userdata);
- pa_module_unload_request(o->userdata->module, TRUE);
+ pa_module_unload_request(o->userdata->module, true);
output_free(o);
}
if (PA_SINK_IS_OPENED(o->sink_input->sink->thread_info.state))
pa_memblockq_push_align(o->memblockq, chunk);
else
- pa_memblockq_flush_write(o->memblockq, TRUE);
+ pa_memblockq_flush_write(o->memblockq, true);
return 0;
}
switch (code) {
case PA_SINK_MESSAGE_SET_STATE: {
- pa_bool_t running = (PA_PTR_TO_UINT(data) == PA_SINK_RUNNING);
+ bool running = (PA_PTR_TO_UINT(data) == PA_SINK_RUNNING);
pa_atomic_store(&u->thread_info.running, running);
if (running)
- pa_smoother_resume(u->thread_info.smoother, pa_rtclock_now(), TRUE);
+ pa_smoother_resume(u->thread_info.smoother, pa_rtclock_now(), true);
else
pa_smoother_pause(u->thread_info.smoother, pa_rtclock_now());
}
static void update_description(struct userdata *u) {
- pa_bool_t first = TRUE;
+ bool first = true;
char *t;
struct output *o;
uint32_t idx;
if (first) {
e = pa_sprintf_malloc("%s %s", t, pa_strnull(pa_proplist_gets(o->sink->proplist, PA_PROP_DEVICE_DESCRIPTION)));
- first = FALSE;
+ first = false;
} else
e = pa_sprintf_malloc("%s, %s", t, pa_strnull(pa_proplist_gets(o->sink->proplist, PA_PROP_DEVICE_DESCRIPTION)));
return 0;
pa_sink_input_new_data_init(&data);
- pa_sink_input_new_data_set_sink(&data, o->sink, FALSE);
+ pa_sink_input_new_data_set_sink(&data, o->sink, false);
data.driver = __FILE__;
pa_proplist_setf(data.proplist, PA_PROP_MEDIA_NAME, "Simultaneous output on %s", pa_strnull(pa_proplist_gets(o->sink->proplist, PA_PROP_DEVICE_DESCRIPTION)));
pa_proplist_sets(data.proplist, PA_PROP_MEDIA_ROLE, "filter");
* of the sink might hence be called from here, which might then
* cause us to be called in a loop. Make sure that state changes
* for this output don't cause this loop by setting a flag here */
- o->ignore_state_change = TRUE;
+ o->ignore_state_change = true;
if (output_create_sink_input(o) >= 0) {
output_add_within_thread(o);
}
- o->ignore_state_change = FALSE;
+ o->ignore_state_change = false;
}
/* Called from main context */
o->sink_input = NULL;
/* Finally, drop all queued data */
- pa_memblockq_flush_write(o->memblockq, TRUE);
- pa_asyncmsgq_flush(o->inq, FALSE);
- pa_asyncmsgq_flush(o->outq, FALSE);
+ pa_memblockq_flush_write(o->memblockq, true);
+ pa_asyncmsgq_flush(o->inq, false);
+ pa_asyncmsgq_flush(o->outq, false);
}
/* Called from main context */
}
/* Called from main context */
-static pa_bool_t is_suitable_sink(struct userdata *u, pa_sink *s) {
+static bool is_suitable_sink(struct userdata *u, pa_sink *s) {
const char *t;
pa_sink_assert_ref(s);
if (s == u->sink)
- return FALSE;
+ return false;
if (!(s->flags & PA_SINK_HARDWARE))
- return FALSE;
+ return false;
if (!(s->flags & PA_SINK_LATENCY))
- return FALSE;
+ return false;
if ((t = pa_proplist_gets(s->proplist, PA_PROP_DEVICE_CLASS)))
if (!pa_streq(t, "sound"))
- return FALSE;
+ return false;
- return TRUE;
+ return true;
}
/* Called from main context */
u->thread_info.smoother = pa_smoother_new(
PA_USEC_PER_SEC,
PA_USEC_PER_SEC*2,
- TRUE,
- TRUE,
+ true,
+ true,
10,
pa_rtclock_now(),
- TRUE);
+ true);
u->add_slave = add_slave;
u->remove_slave = remove_slave;
char *n = NULL;
pa_sample_spec slaves_spec;
pa_channel_map slaves_map;
- pa_bool_t is_first_slave = TRUE;
+ bool is_first_slave = true;
pa_sample_spec_init(&slaves_spec);
if (is_first_slave) {
slaves_spec = slave_sink->sample_spec;
slaves_map = slave_sink->channel_map;
- is_first_slave = FALSE;
+ is_first_slave = false;
} else {
if (slaves_spec.format != slave_sink->sample_spec.format)
slaves_spec.format = PA_SAMPLE_INVALID;
}
pa_sink_new_data_init(&data);
- data.namereg_fail = FALSE;
+ data.namereg_fail = false;
data.driver = __FILE__;
data.module = m;
pa_sink_new_data_set_name(&data, pa_modargs_get_value(ma, "sink_name", DEFAULT_SINK_NAME));
}
/* Check proplist for a description & fill in a default value if not */
- u->auto_desc = FALSE;
+ u->auto_desc = false;
if (NULL == pa_proplist_gets(data.proplist, PA_PROP_DEVICE_DESCRIPTION)) {
- u->auto_desc = TRUE;
+ u->auto_desc = true;
pa_proplist_sets(data.proplist, PA_PROP_DEVICE_DESCRIPTION, "Simultaneous Output");
}
i->flags &= ~(pa_sink_input_flags_t)PA_SINK_INPUT_DONT_MOVE;
- sts = pa_sink_input_move_to(i, s, FALSE);
+ sts = pa_sink_input_move_to(i, s, false);
i->flags |= (pa_sink_input_flags_t)PA_SINK_INPUT_DONT_MOVE;
#ifndef foocombinesinkuserdatafoo
#define foocombinesinkuserdatafoo
-
-
struct output {
struct userdata *userdata;
pa_sink *sink;
pa_sink_input *sink_input;
- pa_bool_t ignore_state_change;
+ bool ignore_state_change;
pa_asyncmsgq *inq, /* Message queue from the sink thread to this sink input */
*outq; /* Message queue from this sink input to the sink thread */
pa_time_event *time_event;
pa_usec_t adjust_time;
- pa_bool_t automatic;
- pa_bool_t auto_desc;
- pa_bool_t no_reattach;
+ bool automatic;
+ bool auto_desc;
+ bool no_reattach;
pa_strlist *unlinked_slaves;
PA_LLIST_HEAD(struct output, active_outputs); /* managed in IO thread context */
pa_atomic_t running; /* we cache that value here, so that every thread can query it cheaply */
pa_usec_t timestamp;
- pa_bool_t in_null_mode;
+ bool in_null_mode;
pa_smoother *smoother;
uint64_t counter;
} thread_info;
if (u->routerif && am->domain.id != AM_ID_INVALID)
pa_routerif_unregister_domain(u, am->domain.id);
- pa_hashmap_free(am->nodes, NULL);
- pa_hashmap_free(am->conns, NULL);
+ pa_hashmap_free(am->nodes);
+ pa_hashmap_free(am->conns);
pa_xfree((void *)am->domain.name);
pa_xfree(am);
u->audiomgr = NULL;
dr->name = AUDIOMGR_DOMAIN; /* AM domain name */
dr->bus_name = AUDIOMGR_NODE; /* AM internal bus name. */
dr->node_name = AUDIOMGR_NODE; /* node name on AM's internal bus */
- dr->early = FALSE;
- dr->complete = FALSE;
+ dr->early = false;
+ dr->complete = false;
dr->state = 1;
pa_routerif_register_domain(u, dr);
}
-void pa_audiomgr_unregister_domain(struct userdata *u, pa_bool_t send_state)
+void pa_audiomgr_unregister_domain(struct userdata *u, bool send_state)
{
pa_audiomgr *am;
mir_node *node;
pa_audiomgr *am;
am_nodereg_data *rd;
am_method method;
- pa_bool_t success;
+ bool success;
pa_assert(u);
pa_assert_se((am = u->audiomgr));
am_nodeunreg_data *ud;
am_method method;
mir_node *removed;
- pa_bool_t success;
+ bool success;
void *key;
pa_assert(u);
void pa_audiomgr_domain_registered(struct userdata *, uint16_t, uint16_t,
am_domainreg_data *);
-void pa_audiomgr_unregister_domain(struct userdata *, pa_bool_t);
+void pa_audiomgr_unregister_domain(struct userdata *, bool);
void pa_audiomgr_register_node(struct userdata *, mir_node *);
}
}
-pa_bool_t pa_classify_node_by_property(mir_node *node, pa_proplist *pl)
+bool pa_classify_node_by_property(mir_node *node, pa_proplist *pl)
{
typedef struct {
const char *name;
for (i = 0; map[i].name; i++) {
if (pa_streq(type, map[i].name)) {
node->type = map[i].value;
- return TRUE;
+ return true;
}
}
}
- return FALSE;
+ return false;
}
/* data->direction must be set */
}
-pa_bool_t pa_classify_multiplex_stream(mir_node *node)
+bool pa_classify_multiplex_stream(mir_node *node)
{
- static pa_bool_t multiplex[mir_application_class_end] = {
- [ mir_player ] = TRUE,
- [ mir_game ] = TRUE,
+ static bool multiplex[mir_application_class_end] = {
+ [ mir_player ] = true,
+ [ mir_game ] = true,
};
mir_node_type class;
}
}
- return FALSE;
+ return false;
}
const char *pa_classify_loopback_stream(mir_node *node)
void pa_classify_node_by_card(mir_node *, pa_card *, pa_card_profile *,
pa_device_port *);
-pa_bool_t pa_classify_node_by_property(mir_node *, pa_proplist *);
+bool pa_classify_node_by_property(mir_node *, pa_proplist *);
void pa_classify_guess_device_node_type_and_name(mir_node*, const char *,
const char *);
mir_node_type pa_classify_guess_stream_node_type(struct userdata *,
pa_nodeset_resdef **);
mir_node_type pa_classify_guess_application_class(mir_node *);
-pa_bool_t pa_classify_multiplex_stream(mir_node *);
+bool pa_classify_multiplex_stream(mir_node *);
const char *pa_classify_loopback_stream(mir_node *);
cstrdef_destroy(u, cd);
}
- pa_hashmap_free(constrain->defs, NULL);
+ pa_hashmap_free(constrain->defs);
pa_xfree(constrain);
mir_node *n;
mir_rtentry *rte;
mir_rtgroup *rtg;
- pa_bool_t blocked;
+ bool blocked;
pa_assert(u);
pa_assert(node);
return p - buf;
}
-pa_bool_t mir_constrain_port(struct userdata *u,
+bool mir_constrain_port(struct userdata *u,
mir_constr_def *cd,
mir_node *active,
mir_node *node)
{
char *active_port;
char *node_port;
- pa_bool_t block;
+ bool block;
pa_assert(u);
pa_assert(cd);
return block;
}
-pa_bool_t mir_constrain_profile(struct userdata *u,
+bool mir_constrain_profile(struct userdata *u,
mir_constr_def *cd,
mir_node *active,
mir_node *node)
{
char *active_profile;
char *node_profile;
- pa_bool_t block;
+ bool block;
pa_assert(u);
pa_assert(cd);
#include "userdata.h"
#include "list.h"
-typedef pa_bool_t (*mir_constrain_func_t)(struct userdata *, mir_constr_def *,
+typedef bool (*mir_constrain_func_t)(struct userdata *, mir_constr_def *,
mir_node *, mir_node *);
struct pa_constrain {
int mir_constrain_print(mir_node *, char *, int);
-pa_bool_t mir_constrain_port(struct userdata *, mir_constr_def *,
+bool mir_constrain_port(struct userdata *, mir_constr_def *,
mir_node *, mir_node *);
-pa_bool_t mir_constrain_profile(struct userdata *, mir_constr_def *,
+bool mir_constrain_profile(struct userdata *, mir_constr_def *,
mir_node *, mir_node *);
typedef void (*pending_cb_t)(struct userdata *, const char *,
DBusMessage *, void *);
-typedef pa_bool_t (*method_t)(struct userdata *, DBusMessage *);
+typedef bool (*method_t)(struct userdata *, DBusMessage *);
struct pending {
static void free_routerif(pa_routerif *,struct userdata *);
-static pa_bool_t send_message_with_reply(struct userdata *,
+static bool send_message_with_reply(struct userdata *,
DBusConnection *, DBusMessage *,
pending_cb_t, void *);
static void murphy_registration_cb(struct userdata *, const char *,
DBusMessage *, void *);
-static pa_bool_t register_to_murphy(struct userdata *);
+static bool register_to_murphy(struct userdata *);
#if 0
static int signal_status(struct userdata *, uint32_t, uint32_t);
#endif
DBusMessage *, void *);
static void audiomgr_register_domain_cb(struct userdata *, const char *,
DBusMessage *, void *);
-static pa_bool_t register_to_audiomgr(struct userdata *);
-static pa_bool_t unregister_from_audiomgr(struct userdata *);
+static bool register_to_audiomgr(struct userdata *);
+static bool unregister_from_audiomgr(struct userdata *);
static void audiomgr_register_node_cb(struct userdata *, const char *,
DBusMessage *, void *);
static void audiomgr_unregister_node_cb(struct userdata *, const char *,
DBusMessage *, void *);
-static pa_bool_t build_sound_properties(DBusMessageIter *,
+static bool build_sound_properties(DBusMessageIter *,
struct am_nodereg_data *);
-static pa_bool_t build_connection_formats(DBusMessageIter *,
+static bool build_connection_formats(DBusMessageIter *,
struct am_nodereg_data *);
-static pa_bool_t routerif_connect(struct userdata *, DBusMessage *);
-static pa_bool_t routerif_disconnect(struct userdata *, DBusMessage *);
+static bool routerif_connect(struct userdata *, DBusMessage *);
+static bool routerif_disconnect(struct userdata *, DBusMessage *);
static const char *method_str(am_method);
pa_xfree((void *)pdata);
}
-static pa_bool_t send_message_with_reply(struct userdata *u,
+static bool send_message_with_reply(struct userdata *u,
DBusConnection *conn,
DBusMessage *msg,
pending_cb_t cb,
}
- return TRUE;
+ return true;
failed:
if (pdata) {
pa_xfree((void *)pdata->method);
pa_xfree((void *)pdata);
}
- return FALSE;
+ return false;
}
DBusMessageIter arrit;
DBusMessageIter entit;
DBusMessageIter actit;
- int success = TRUE;
+ int success = true;
pa_log_debug("got policy actions");
if (!dbus_message_iter_next(&msgit) ||
dbus_message_iter_get_arg_type(&msgit) != DBUS_TYPE_ARRAY) {
- success = FALSE;
+ success = false;
goto send_signal;
}
do {
if (dbus_message_iter_get_arg_type(&arrit) != DBUS_TYPE_DICT_ENTRY) {
- success = FALSE;
+ success = false;
continue;
}
do {
if (dbus_message_iter_get_arg_type(&entit) != DBUS_TYPE_STRING) {
- success = FALSE;
+ success = false;
continue;
}
if (!dbus_message_iter_next(&entit) ||
dbus_message_iter_get_arg_type(&entit) != DBUS_TYPE_ARRAY) {
- success = FALSE;
+ success = false;
continue;
}
dbus_message_iter_recurse(&entit, &actit);
if (dbus_message_iter_get_arg_type(&actit) != DBUS_TYPE_ARRAY) {
- success = FALSE;
+ success = false;
continue;
}
}
}
-static pa_bool_t register_to_murphy(struct userdata *u)
+static bool register_to_murphy(struct userdata *u)
{
static const char *name = "pulseaudio";
if (msg == NULL) {
pa_log("%s: Failed to create D-Bus message to register", __FILE__);
- success = FALSE;
+ success = false;
goto getout;
}
//uint32_t serial;
dbus_int16_t errcod;
DBusMessage *reply;
- pa_bool_t success;
+ bool success;
pa_assert(conn);
pa_assert(msg);
}
-static pa_bool_t register_to_audiomgr(struct userdata *u)
+static bool register_to_audiomgr(struct userdata *u)
{
pa_audiomgr_register_domain(u);
- return TRUE;
+ return true;
}
-static pa_bool_t unregister_from_audiomgr(struct userdata *u)
+static bool unregister_from_audiomgr(struct userdata *u)
{
- pa_audiomgr_unregister_domain(u, FALSE);
- return TRUE;
+ pa_audiomgr_unregister_domain(u, false);
+ return true;
}
static void audiomgr_register_domain_cb(struct userdata *u,
-pa_bool_t pa_routerif_register_domain(struct userdata *u,
+bool pa_routerif_register_domain(struct userdata *u,
am_domainreg_data *dr)
{
pa_routerif *routerif;
if (msg == NULL) {
pa_log("%s: Failed to create D-Bus message to '%s'",
__FILE__, AUDIOMGR_REGISTER_DOMAIN);
- success = FALSE;
+ success = false;
goto getout;
}
return success;
}
-pa_bool_t pa_routerif_domain_complete(struct userdata *u, uint16_t domain)
+bool pa_routerif_domain_complete(struct userdata *u, uint16_t domain)
{
dbus_int32_t id32 = domain;
pa_routerif *routerif;
DBusConnection *conn;
DBusMessage *msg;
- pa_bool_t success;
+ bool success;
pa_assert(u);
pa_assert_se((routerif = u->routerif));
if (msg == NULL) {
pa_log("%s: Failed to create D-Bus message for '%s'",
__FILE__, AUDIOMGR_DOMAIN_COMPLETE);
- success = FALSE;
+ success = false;
goto getout;
}
return success;
}
-pa_bool_t pa_routerif_unregister_domain(struct userdata *u, uint16_t domain)
+bool pa_routerif_unregister_domain(struct userdata *u, uint16_t domain)
{
pa_routerif *routerif;
DBusConnection *conn;
DBusMessage *msg;
- pa_bool_t success;
+ bool success;
pa_assert(u);
pa_assert_se((routerif = u->routerif));
if (msg == NULL) {
pa_log("%s: Failed to create D-Bus message for '%s'",
__FILE__, AUDIOMGR_DEREGISTER_DOMAIN);
- success = FALSE;
+ success = false;
goto getout;
}
- dbus_message_set_no_reply(msg, TRUE);
+ dbus_message_set_no_reply(msg, true);
success = dbus_message_append_args(msg,
DBUS_TYPE_UINT16, &domain,
}
}
-static pa_bool_t build_sound_properties(DBusMessageIter *mit,
+static bool build_sound_properties(DBusMessageIter *mit,
struct am_nodereg_data *rd)
{
static int16_t zero;
#define CONT_CLOSE(p,c) dbus_message_iter_close_container(p, c)
if (!CONT_OPEN(mit, DBUS_TYPE_ARRAY, "(nn)", &ait))
- return FALSE;
+ return false;
for (i = 1; i < 3; i++) {
if (! CONT_OPEN (&ait, DBUS_TYPE_STRUCT, NULL, &sit) ||
! CONT_APPEND (&sit, DBUS_TYPE_INT16, &zero ) ||
! CONT_CLOSE (&ait, &sit) )
{
- return FALSE;
+ return false;
}
}
if (!CONT_CLOSE(mit, &ait))
- return FALSE;
+ return false;
#undef CONT_CLOSE
#undef CONT_APPEND
#undef CONT_OPEN
- return TRUE;
+ return true;
}
-static pa_bool_t build_connection_formats(DBusMessageIter *mit,
+static bool build_connection_formats(DBusMessageIter *mit,
struct am_nodereg_data *rd)
{
DBusMessageIter ait;
#define CONT_CLOSE dbus_message_iter_close_container(mit, &ait)
if (!CONT_OPEN(DBUS_TYPE_ARRAY, "n"))
- return FALSE;
+ return false;
for (i = 1; i < 2; i++) {
if (!CONT_APPEND(DBUS_TYPE_INT16, &i))
- return FALSE;
+ return false;
}
if (!CONT_CLOSE)
- return FALSE;
+ return false;
#undef CONT_CLOSE
#undef CONT_APPEND
#undef CONT_OPEN
- return TRUE;
+ return true;
}
-pa_bool_t pa_routerif_register_node(struct userdata *u,
+bool pa_routerif_register_node(struct userdata *u,
am_method m,
am_nodereg_data *rd)
{
DBusMessage *msg;
DBusMessageIter mit;
DBusMessageIter cit;
- pa_bool_t success = FALSE;
+ bool success = false;
pa_assert(u);
pa_assert(rd);
}
}
-pa_bool_t pa_routerif_unregister_node(struct userdata *u,
+bool pa_routerif_unregister_node(struct userdata *u,
am_method m,
am_nodeunreg_data *ud)
{
pa_routerif *routerif;
DBusConnection *conn;
DBusMessage *msg;
- pa_bool_t success = FALSE;
+ bool success = false;
pa_assert(u);
pa_assert(ud);
return success;
}
-static pa_bool_t routerif_connect(struct userdata *u, DBusMessage *msg)
+static bool routerif_connect(struct userdata *u, DBusMessage *msg)
{
struct am_connect_data ac;
int success;
if (!success) {
pa_log("%s: got broken connect message from AudioManager. "
"Ignoring it", __FILE__);
- return FALSE;
+ return false;
}
pa_log_debug("AudioManager connect(%u|%u|%u|%u|%d)",
pa_audiomgr_connect(u, &ac);
- return TRUE;
+ return true;
}
-static pa_bool_t routerif_disconnect(struct userdata *u, DBusMessage *msg)
+static bool routerif_disconnect(struct userdata *u, DBusMessage *msg)
{
struct am_connect_data ac;
int success;
if (!success) {
pa_log("%s: got broken disconnect message from AudioManager. "
"Ignoring it", __FILE__);
- return FALSE;
+ return false;
}
pa_log_debug("AudioManager disconnect(%u|%u)", ac.handle, ac.connection);
pa_audiomgr_disconnect(u, &ac);
- return TRUE;
+ return true;
}
-pa_bool_t pa_routerif_acknowledge(struct userdata *u, am_method m,
+bool pa_routerif_acknowledge(struct userdata *u, am_method m,
struct am_ack_data *ad)
{
const char *method = method_str(m);
pa_routerif *routerif;
DBusConnection *conn;
DBusMessage *msg;
- pa_bool_t success;
+ bool success;
pa_assert(u);
pa_assert(method);
if (msg == NULL) {
pa_log("%s: Failed to create D-Bus message for '%s'",
__FILE__, method);
- success = FALSE;
+ success = false;
goto getout;
}
static void handle_alsa_card(struct userdata *, pa_card *);
static void handle_bluetooth_card(struct userdata *, pa_card *);
-static pa_bool_t get_bluetooth_port_availability(mir_node *, pa_device_port *);
+static bool get_bluetooth_port_availability(mir_node *, pa_device_port *);
static void handle_udev_loaded_card(struct userdata *, pa_card *,
mir_node *, char *);
static void handle_card_ports(struct userdata *, mir_node *,
pa_card *, pa_card_profile *);
-static mir_node *create_node(struct userdata *, mir_node *, pa_bool_t *);
+static mir_node *create_node(struct userdata *, mir_node *, bool *);
static void destroy_node(struct userdata *, mir_node *);
-static pa_bool_t update_node_availability(struct userdata *, mir_node *,
- pa_bool_t);
-static pa_bool_t update_node_availability_by_device(struct userdata *,
+static bool update_node_availability(struct userdata *, mir_node *,
+ bool);
+static bool update_node_availability_by_device(struct userdata *,
mir_direction,
void *, pa_device_port *,
- pa_bool_t);
+ bool);
static void parse_profile_name(pa_card_profile *,
char **, char **, char *, int);
discover->chmin = 1;
discover->chmax = 2;
- discover->selected = TRUE;
+ discover->selected = true;
discover->nodes.byname = pa_hashmap_new(pa_idxset_string_hash_func,
pa_idxset_string_compare_func);
PA_HASHMAP_FOREACH(node, discover->nodes.byname, state) {
mir_node_destroy(u, node);
}
- pa_hashmap_free(discover->nodes.byname, NULL);
- pa_hashmap_free(discover->nodes.byptr, NULL);
+ pa_hashmap_free(discover->nodes.byname);
+ pa_hashmap_free(discover->nodes.byptr);
pa_xfree(discover);
u->discover = NULL;
}
pa_source *source;
pa_discover *discover;
const char *bus;
- pa_bool_t pci;
- pa_bool_t usb;
- pa_bool_t bluetooth;
+ bool pci;
+ bool usb;
+ bool bluetooth;
uint32_t stamp;
mir_node *node;
void *state;
uint32_t index;
- pa_bool_t need_routing;
+ bool need_routing;
pa_assert(u);
pa_assert(card);
if ((index = u->state.sink) != PA_IDXSET_INVALID) {
if ((sink = pa_idxset_get_by_index(core->sinks, index)))
- pa_discover_add_sink(u, sink, TRUE);
+ pa_discover_add_sink(u, sink, true);
else
pa_log_debug("sink.%u is gone", index);
u->state.sink = PA_IDXSET_INVALID;
if (!prof->n_sinks && !prof->n_sources) {
/* switched off but not unloaded yet */
- need_routing = FALSE;
+ need_routing = false;
PA_HASHMAP_FOREACH(node, discover->nodes.byname, state) {
if (node->implement == mir_device &&
node->type != mir_bluetooth_sco)
{
if (node->available) {
- node->available = FALSE;
- need_routing = TRUE;
+ node->available = false;
+ need_routing = true;
}
}
}
pa_source *source;
mir_node *node;
uint32_t idx;
- pa_bool_t available;
+ bool available;
const char *state;
- pa_bool_t btport;
- pa_bool_t route;
+ bool btport;
+ bool route;
pa_direction_t direction;
void *iter;
pa_log_debug("port '%s' availabilty changed to %s. Updating",
port->name, state);
- btport = FALSE;
- route = FALSE;
+ btport = false;
+ route = false;
direction = 0;
iter = NULL;
while ((node = pa_utils_get_node_from_port(u, port, &iter))) {
- btport = TRUE;
+ btport = true;
available = get_bluetooth_port_availability(node, port);
route |= update_node_availability(u, node, available);
direction |= (node->direction == mir_input) ? PA_DIRECTION_INPUT : PA_DIRECTION_OUTPUT;
set_bluetooth_profile(u, port->card, direction);
else {
switch (port->available) {
- case PA_PORT_AVAILABLE_NO: available = FALSE; break;
- case PA_PORT_AVAILABLE_YES: available = TRUE; break;
+ case PA_PORT_AVAILABLE_NO: available = false; break;
+ case PA_PORT_AVAILABLE_YES: available = true; break;
default: /* do nothing */ return;
}
mir_router_make_routing(u);
}
-void pa_discover_add_sink(struct userdata *u, pa_sink *sink, pa_bool_t route)
+void pa_discover_add_sink(struct userdata *u, pa_sink *sink, bool route)
{
static pa_nodeset_resdef def_resdef = {0, {0, 0}};
const char *loopback_role;
pa_nodeset_map *map;
pa_nodeset_resdef *resdef;
- pa_bool_t make_rset;
+ bool make_rset;
pa_nodeset_resdef rdbuf;
pa_source *ns;
mir_node data;
pa_log_debug("node for '%s' found (key %s). Updating with sink data",
node->paname, node->key);
node->paidx = sink->index;
- node->available = TRUE;
+ node->available = true;
pa_discover_add_node_to_ptr_hash(u, sink, node);
if ((loopback_role = pa_classify_loopback_stream(node))) {
data.direction = mir_output;
data.implement = mir_device;
data.channels = sink->channel_map.channels;
- data.available = TRUE;
+ data.available = true;
data.paidx = sink->index;
if (sink == pa_utils_get_null_sink(u)) {
- data.visible = FALSE;
+ data.visible = false;
data.type = mir_null;
data.amname = pa_xstrdup("Silent");
data.amid = AM_ID_INVALID;
}
else if (pa_classify_node_by_property(&data, sink->proplist)) {
data.privacy = mir_public;
- data.visible = TRUE;
+ data.visible = true;
data.amname = pa_xstrdup(mir_node_type_str(data.type));
data.amid = AM_ID_INVALID;
data.paname = pa_xstrdup(sink->name);
if (sink->card) {
if (type != mir_bluetooth_a2dp && type != mir_bluetooth_sco)
- node->available = FALSE;
+ node->available = false;
else {
if (!u->state.profile)
schedule_deferred_routing(u);
const char *loopback_role;
pa_nodeset_map *map;
pa_nodeset_resdef *resdef;
- pa_bool_t make_rset;
+ bool make_rset;
uint32_t sink_index;
pa_sink *ns;
mir_node data;
pa_log_debug("node for '%s' found. Updating with source data",
node->amname);
node->paidx = source->index;
- node->available = TRUE;
+ node->available = true;
pa_discover_add_node_to_ptr_hash(u, source, node);
if ((loopback_role = pa_classify_loopback_stream(node))) {
if (!(ns = pa_utils_get_null_sink(u))) {
data.direction = mir_input;
data.implement = mir_device;
data.channels = source->channel_map.channels;
- data.available = TRUE;
+ data.available = true;
if (source == pa_utils_get_null_source(u)) {
- data.visible = FALSE;
+ data.visible = false;
data.type = mir_null;
data.amname = pa_xstrdup("Silent");
data.amid = AM_ID_INVALID;
data.paidx = source->index;
}
else if (pa_classify_node_by_property(&data, source->proplist)) {
- data.visible = TRUE;
+ data.visible = true;
data.amname = pa_xstrdup(mir_node_type_str(data.type));
data.amid = AM_ID_INVALID;
data.paname = pa_xstrdup(source->name);
if (source->card) {
if (type != mir_bluetooth_sco)
- node->available = FALSE;
+ node->available = false;
else {
if (!u->state.profile)
schedule_deferred_routing(u);
data.channels = sinp->channel_map.channels;
data.type = type;
data.zone = pa_utils_get_zone(sinp->proplist);
- data.visible = TRUE;
- data.available = TRUE;
+ data.visible = true;
+ data.available = true;
data.amname = name;
data.amdescr = (char *)pa_proplist_gets(pl, PA_PROP_MEDIA_NAME);
data.amid = AM_ID_INVALID;
if (sink && target) {
pa_log_debug("move stream to sink %u (%s)", sink->index, sink->name);
- if (pa_sink_input_move_to(sinp, sink, FALSE) < 0)
+ if (pa_sink_input_move_to(sinp, sink, false) < 0)
pa_log("failed to route '%s' => '%s'",node->amname,target->amname);
else {
pa_log_debug("register route '%s' => '%s'",
}
}
-pa_bool_t pa_discover_preroute_sink_input(struct userdata *u,
- pa_sink_input_new_data *data)
+bool pa_discover_preroute_sink_input(struct userdata *u,
+ pa_sink_input_new_data *data)
{
pa_core *core;
pa_module *m;
fake.channels = data->channel_map.channels;
fake.type = type;
fake.zone = pa_utils_get_zone(data->proplist);
- fake.visible = TRUE;
- fake.available = TRUE;
+ fake.visible = true;
+ fake.available = true;
fake.amname = "<preroute sink-input>";
role = pa_proplist_gets(data->proplist, PA_PROP_MEDIA_ROLE);
schedule_stream_uncorking(u, sink);
}
#endif
- if (pa_sink_input_new_data_set_sink(data, sink, FALSE))
+
+ if (pa_sink_input_new_data_set_sink(data, sink, false))
pa_log_debug("set sink %u for new sink-input", sink->index);
else {
pa_log("can't set sink %u for new sink-input", sink->index);
const char *media;
mir_node_type type;
char key[256];
- pa_bool_t created;
+ bool created;
pa_muxnode *mux;
pa_nodeset_resdef *resdef;
pa_nodeset_resdef rdbuf;
data.channels = sinp->channel_map.channels;
data.type = type;
data.zone = pa_utils_get_zone(pl);
- data.visible = TRUE;
- data.available = TRUE;
+ data.visible = true;
+ data.available = true;
data.amname = name;
data.amdescr = (char *)pa_proplist_gets(pl, PA_PROP_MEDIA_NAME);
data.amid = AM_ID_INVALID;
mir_node *node;
mir_node *sinknod;
char *name;
- pa_bool_t had_properties;
+ bool had_properties;
pa_assert(u);
pa_assert(sinp);
data.channels = sout->channel_map.channels;
data.type = type;
data.zone = pa_utils_get_zone(sout->proplist);
- data.visible = TRUE;
- data.available = TRUE;
+ data.visible = true;
+ data.available = true;
data.amname = name;
data.amdescr = (char *)pa_proplist_gets(pl, PA_PROP_MEDIA_NAME);
data.amid = AM_ID_INVALID;
pa_log_debug("move stream to source %u (%s)",
source->index, source->name);
- if (pa_source_output_move_to(sout, source, FALSE) < 0)
+ if (pa_source_output_move_to(sout, source, false) < 0)
pa_log("failed to route '%s' => '%s'",node->amname,target->amname);
else {
pa_log_debug("register route '%s' => '%s'",
}
}
-pa_bool_t pa_discover_preroute_source_output(struct userdata *u,
- pa_source_output_new_data *data)
+bool pa_discover_preroute_source_output(struct userdata *u,
+ pa_source_output_new_data *data)
{
pa_core *core;
pa_module *m;
fake.channels = data->channel_map.channels;
fake.type = type;
fake.zone = pa_utils_get_zone(data->proplist);
- fake.visible = TRUE;
- fake.available = TRUE;
+ fake.visible = true;
+ fake.available = true;
fake.amname = "<preroute source-output>";
role = pa_proplist_gets(data->proplist, PA_PROP_MEDIA_ROLE);
source = make_input_prerouting(u, &fake, role, NULL);
if (source) {
- if (pa_source_output_new_data_set_source(data, source, FALSE)) {
+ if (pa_source_output_new_data_set_source(data, source, false)) {
pa_log_debug("set source %u for new source-output",
source->index);
}
const char *media;
mir_node_type type;
char key[256];
- pa_bool_t created;
+ bool created;
pa_nodeset_resdef *resdef;
pa_nodeset_resdef rdbuf;
data.channels = sout->channel_map.channels;
data.type = type;
data.zone = pa_utils_get_zone(pl);
- data.visible = TRUE;
- data.available = TRUE;
+ data.visible = true;
+ data.available = true;
data.amname = name;
data.amdescr = (char *)pa_proplist_gets(pl, PA_PROP_MEDIA_NAME);
data.amid = AM_ID_INVALID;
memset(&data, 0, sizeof(data));
data.zone = pa_utils_get_zone(card->proplist);
- data.visible = TRUE;
+ data.visible = true;
data.amid = AM_ID_INVALID;
data.implement = mir_device;
data.paidx = PA_IDXSET_INVALID;
memset(&data, 0, sizeof(data));
data.key = key;
- data.visible = TRUE;
+ data.visible = true;
data.amid = AM_ID_INVALID;
data.implement = mir_device;
data.paidx = PA_IDXSET_INVALID;
cd = mir_constrain_create(u, "profile", mir_constrain_profile, cnam);
PA_HASHMAP_FOREACH(prof, card->profiles, cstate) {
- data.available = FALSE;
+ data.available = false;
data.pacard.profile = prof->name;
if (prof->n_sinks > 0) {
char amname[MAX_NAME_LENGTH+1];
char key[MAX_NAME_LENGTH+1];
int len;
- pa_bool_t input;
- pa_bool_t output;
+ bool input;
+ bool output;
pa_assert_se((discover = u->discover));
memset(&data, 0, sizeof(data));
data.key = key;
data.zone = pa_utils_get_zone(card->proplist);
- data.visible = TRUE;
+ data.visible = true;
data.amid = AM_ID_INVALID;
data.implement = mir_device;
data.paidx = PA_IDXSET_INVALID;
pa_assert(port->profiles);
- input = output = TRUE;
+ input = output = true;
len = strlen(port->name);
if (len >= 6 && !strcmp("-input", port->name + (len-6)))
- output = FALSE;
+ output = false;
else if (len >= 7 && !strcmp("-output", port->name + (len-7)))
- input = FALSE;
+ input = false;
PA_HASHMAP_FOREACH(prof, port->profiles, state1) {
}
}
-static pa_bool_t get_bluetooth_port_availability(mir_node *node,
+static bool get_bluetooth_port_availability(mir_node *node,
pa_device_port *port)
{
- pa_bool_t available = FALSE;
+ bool available = false;
const char *prof;
pa_assert(node);
!strcmp(prof, "a2dp_sink"))
available = (port->available != PA_PORT_AVAILABLE_NO);
else
- available = TRUE;
+ available = true;
}
return available;
pa_card *card, pa_card_profile *prof)
{
mir_node *node = NULL;
- pa_bool_t have_ports = FALSE;
+ bool have_ports = false;
mir_constr_def *cd = NULL;
char *amname = data->amname;
pa_device_port *port;
void *state;
- pa_bool_t created;
+ bool created;
char key[MAX_NAME_LENGTH+1];
pa_assert(u);
((port->direction == PA_DIRECTION_INPUT && data->direction == mir_input)||
(port->direction == PA_DIRECTION_OUTPUT && data->direction == mir_output)))
{
- have_ports = TRUE;
+ have_ports = true;
amname[0] = '\0';
snprintf(key, sizeof(key), "%s@%s", data->paname, port->name);
if (!have_ports) {
data->key = data->paname;
- data->available = TRUE;
+ data->available = true;
pa_classify_node_by_card(data, card, prof, NULL);
static mir_node *create_node(struct userdata *u, mir_node *data,
- pa_bool_t *created_ret)
+ bool *created_ret)
{
pa_discover *discover;
mir_node *node;
- pa_bool_t created;
+ bool created;
char buf[2048];
pa_assert(u);
pa_assert_se((discover = u->discover));
if ((node = pa_hashmap_get(discover->nodes.byname, data->key)))
- created = FALSE;
+ created = false;
else {
- created = TRUE;
+ created = true;
node = mir_node_create(u, data);
pa_hashmap_put(discover->nodes.byname, node->key, node);
}
}
-static pa_bool_t update_node_availability(struct userdata *u,
+static bool update_node_availability(struct userdata *u,
mir_node *node,
- pa_bool_t available)
+ bool available)
{
pa_assert(u);
pa_assert(node);
extapi_signal_node_change(u);
- return TRUE; /* routing needed */
+ return true; /* routing needed */
}
- return FALSE;
+ return false;
}
-static pa_bool_t update_node_availability_by_device(struct userdata *u,
+static bool update_node_availability_by_device(struct userdata *u,
mir_direction direction,
void *data,
pa_device_port *port,
- pa_bool_t available)
+ bool available)
{
mir_node *node;
char *key;
}
}
- return FALSE; /* no routing needed */
+ return false; /* no routing needed */
}
static char *get_name(char **string_ptr, int offs)
pa_card *card;
pa_card_profile *profile;
const char *bus;
- pa_bool_t pci;
- pa_bool_t usb;
- pa_bool_t bluetooth;
+ bool pci;
+ bool usb;
+ bool bluetooth;
char *type;
char *name;
const char *profile_name;
pa_device_port *port;
pa_card_profile *prof, *make_active;
void *state0, *state1;
- pa_bool_t port_available;
- pa_bool_t switch_off;
+ bool port_available;
+ bool switch_off;
int nport;
pa_assert(u);
pa_assert_se((core = u->core));
make_active = NULL;
- switch_off = FALSE;
+ switch_off = false;
nport = 0;
pa_log_debug("which profile to make active:");
if (!make_active) {
pa_log_debug(" considering %s", prof->name);
make_active = prof;
- switch_off = TRUE;
+ switch_off = true;
}
}
else {
- port_available = FALSE;
+ port_available = false;
PA_HASHMAP_FOREACH(port, card->ports, state1) {
if ((direction & port->direction) &&
else {
pa_log_debug("Set profile %s", make_active->name);
- if (pa_card_set_profile(card, make_active->name, FALSE) < 0) {
+ if (pa_card_set_profile(card, make_active->name, false) < 0) {
pa_log_debug("Failed to change profile to %s",
make_active->name);
}
goto out;
}
- pa_sink_input_cork(sinp, FALSE);
+ pa_sink_input_cork(sinp, false);
pa_log_debug("stream.%u uncorked", sinp->index);
*/
unsigned chmin; /**< minimum of max channels */
unsigned chmax; /**< maximum of max channels */
- pa_bool_t selected; /**< for alsa cards: whether to consider the
+ bool selected; /**< for alsa cards: whether to consider the
selected profile alone.
for bluetooth cards: no effect */
struct {
void pa_discover_port_available_changed(struct userdata *, pa_device_port *);
-void pa_discover_add_sink(struct userdata *, pa_sink *, pa_bool_t);
+void pa_discover_add_sink(struct userdata *, pa_sink *, bool);
void pa_discover_remove_sink(struct userdata *, pa_sink *);
void pa_discover_add_source(struct userdata *, pa_source *);
void pa_discover_remove_source(struct userdata *, pa_source *);
void pa_discover_register_sink_input(struct userdata *, pa_sink_input *);
-pa_bool_t pa_discover_preroute_sink_input(struct userdata *,
+bool pa_discover_preroute_sink_input(struct userdata *,
pa_sink_input_new_data *);
void pa_discover_add_sink_input(struct userdata *, pa_sink_input *);
void pa_discover_remove_sink_input(struct userdata *, pa_sink_input *);
void pa_discover_register_source_output(struct userdata *, pa_source_output *);
-pa_bool_t pa_discover_preroute_source_output(struct userdata *,
+bool pa_discover_preroute_source_output(struct userdata *,
pa_source_output_new_data *);
void pa_discover_add_source_output(struct userdata *, pa_source_output *);
void pa_discover_remove_source_output(struct userdata *, pa_source_output *);
if (u && (ap = u->extapi)) {
if (ap->conns)
- pa_hashmap_free(ap->conns, NULL);
+ pa_hashmap_free(ap->conns);
if (ap->subscribed)
pa_idxset_free(ap->subscribed, NULL);
pa_xfree(ap);
case SUBCOMMAND_SUBSCRIBE: {
- pa_bool_t enabled;
+ bool enabled;
pa_log_debug("subscribe called in module-murphy-ivi");
uint32_t time;
uint32_t i,j;
int class;
- pa_bool_t rampit;
+ bool rampit;
pa_assert(u);
pa_assert_se(u->fader);
pa_volume_t newvol)
{
transition_time *transit;
- pa_bool_t rampit;
+ bool rampit;
pa_volume_t oldvol;
pa_cvolume_ramp_int *ramp;
uint32_t time;
pa_cvolume_set(&sinp->volume_factor, sinp->volume.channels, vol);
if (pa_sink_flat_volume_enabled(sink)) {
- pa_sink_set_volume(sink, NULL, TRUE, FALSE);
+ pa_sink_set_volume(sink, NULL, true, false);
}
else {
pa_sw_cvolume_multiply(&sinp->soft_volume, &sinp->real_ratio,
ramp_time,
vol);
- pa_sink_input_set_volume_ramp(sinp, &rampvol, TRUE, FALSE);
+ pa_sink_input_set_volume_ramp(sinp, &rampvol, true, false);
}
}
pa_loopnode *loop, *n;
PA_LLIST_FOREACH_SAFE(loop,n, loopback->loopnodes) {
- pa_module_unload_by_index(core, loop->module_index, FALSE);
+ pa_module_unload_by_index(core, loop->module_index, false);
}
}
pa_log("can't find input stream of loopback module (index %u)",
module->index);
}
- pa_module_unload(core, module, FALSE);
+ pa_module_unload(core, module, false);
return NULL;
}
if (loop) {
PA_LLIST_REMOVE(pa_loopnode, loopback->loopnodes, loop);
- pa_module_unload_by_index(core, loop->module_index, FALSE);
+ pa_module_unload_by_index(core, loop->module_index, false);
pa_xfree(loop);
}
}
const char* pa__get_description(void);
const char* pa__get_usage(void);
const char* pa__get_version(void);
-pa_bool_t pa__load_once(void);
+bool pa__load_once(void);
#endif
PA_MODULE_AUTHOR("Janos Kovacs");
PA_MODULE_DESCRIPTION("Murphy and GenIVI compliant audio policy module");
PA_MODULE_VERSION(PACKAGE_VERSION);
-PA_MODULE_LOAD_ONCE(TRUE);
+PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE(
"config_dir=<configuration directory>"
"config_file=<policy configuration file> "
pa_muxnode *mux, *n;
PA_LLIST_FOREACH_SAFE(mux,n, multiplex->muxnodes) {
- pa_module_unload_by_index(core, mux->module_index, FALSE);
+ pa_module_unload_by_index(core, mux->module_index, false);
}
}
pa_assert_se((u = module->userdata));
pa_assert(u->sink);
- u->no_reattach = TRUE;
+ u->no_reattach = true;
mux = pa_xnew0(pa_muxnode, 1);
mux->module_index = module->index;
pa_assert(core);
if (mux) {
- pa_module_unload_by_index(core, mux->module_index, FALSE);
+ pa_module_unload_by_index(core, mux->module_index, false);
PA_LLIST_REMOVE(pa_muxnode, multiplex->muxnodes, mux);
pa_xfree(mux);
}
return NULL;
}
-pa_bool_t pa_multiplex_sink_input_remove(pa_multiplex *multiplex,
+bool pa_multiplex_sink_input_remove(pa_multiplex *multiplex,
pa_sink_input *sinp)
{
pa_muxnode *mux;
mux->module_index);
}
- return TRUE;
+ return true;
}
- return FALSE;
+ return false;
}
-pa_bool_t pa_multiplex_add_default_route(pa_core *core,
+bool pa_multiplex_add_default_route(pa_core *core,
pa_muxnode *mux,
pa_sink *sink,
int type)
if (!(sinp = u->add_slave(u, sink))) {
pa_log("failed to add new slave to mux %u", mux->module_index);
- return FALSE;
+ return false;
}
copy_media_role_property(u->sink, sinp);
pa_utils_set_stream_routing_properties(sinp->proplist, type, NULL);
mux->defstream_index = sinp->index;
- return TRUE;
+ return true;
}
}
- return FALSE;
+ return false;
}
-pa_bool_t pa_multiplex_remove_default_route(pa_core *core,
+bool pa_multiplex_remove_default_route(pa_core *core,
pa_muxnode *mux,
- pa_bool_t transfer_to_explicit)
+ bool transfer_to_explicit)
{
pa_module *module;
pa_sink_input *sinp;
if (transfer_to_explicit) {
pa_log_debug("converting default route sink-input.%u -> sink.%u "
"to explicit", sinp->index, sinp->sink->index);
- pa_utils_set_stream_routing_method_property(sinp->proplist, TRUE);
- return TRUE;
+ pa_utils_set_stream_routing_method_property(sinp->proplist, true);
+ return true;
}
else {
u->remove_slave(u, sinp, NULL);
}
}
- return FALSE;
+ return false;
}
-pa_bool_t pa_multiplex_change_default_route(pa_core *core,
+bool pa_multiplex_change_default_route(pa_core *core,
pa_muxnode *mux,
pa_sink *sink)
{
else {
pa_log_debug("default stream was successfully moved on mux %u",
mux->module_index);
- return TRUE;
+ return true;
}
}
- return FALSE;
+ return false;
}
-pa_bool_t pa_multiplex_add_explicit_route(pa_core *core,
+bool pa_multiplex_add_explicit_route(pa_core *core,
pa_muxnode *mux,
pa_sink *sink,
int type)
if (!(sinp = u->add_slave(u, sink))) {
pa_log("failed to add new slave to mux %u", mux->module_index);
- return FALSE;
+ return false;
}
copy_media_role_property(u->sink, sinp);
pa_utils_set_stream_routing_properties(sinp->proplist, type, sink);
- return TRUE;
+ return true;
}
}
- return FALSE;
+ return false;
}
-pa_bool_t pa_multiplex_remove_explicit_route(pa_core *core,
+bool pa_multiplex_remove_explicit_route(pa_core *core,
pa_muxnode *mux,
pa_sink *sink)
{
pa_log_debug("link to sink.%u removed", sink->index);
- return TRUE;
+ return true;
}
- return FALSE;
+ return false;
}
-pa_bool_t pa_multiplex_duplicate_route(pa_core *core,
+bool pa_multiplex_duplicate_route(pa_core *core,
pa_muxnode *mux,
pa_sink_input *sinp,
pa_sink *sink)
if (i->sink == sink) {
pa_log_debug("route sink-input.%u -> sink.%u is a duplicate",
i->index, sink->index);
- return TRUE;
+ return true;
}
}
}
}
- return FALSE;
+ return false;
}
int pa_multiplex_no_of_routes(pa_core *core, pa_muxnode *mux)
pa_muxnode *pa_multiplex_find_by_sink(pa_multiplex *, uint32_t);
pa_muxnode *pa_multiplex_find_by_module(pa_multiplex *, pa_module *);
-pa_bool_t pa_multiplex_sink_input_remove(pa_multiplex *, pa_sink_input *);
+bool pa_multiplex_sink_input_remove(pa_multiplex *, pa_sink_input *);
-pa_bool_t pa_multiplex_add_default_route(pa_core *, pa_muxnode *,pa_sink *,int);
-pa_bool_t pa_multiplex_remove_default_route(pa_core *,pa_muxnode *,pa_bool_t);
-pa_bool_t pa_multiplex_change_default_route(pa_core *,pa_muxnode *,pa_sink *);
+bool pa_multiplex_add_default_route(pa_core *, pa_muxnode *,pa_sink *,int);
+bool pa_multiplex_remove_default_route(pa_core *,pa_muxnode *,bool);
+bool pa_multiplex_change_default_route(pa_core *,pa_muxnode *,pa_sink *);
-pa_bool_t pa_multiplex_add_explicit_route(pa_core*, pa_muxnode*, pa_sink*,int);
-pa_bool_t pa_multiplex_remove_explicit_route(pa_core *, pa_muxnode *, pa_sink *);
+bool pa_multiplex_add_explicit_route(pa_core*, pa_muxnode*, pa_sink*,int);
+bool pa_multiplex_remove_explicit_route(pa_core *, pa_muxnode *, pa_sink *);
-pa_bool_t pa_multiplex_duplicate_route(pa_core *, pa_muxnode *,
+bool pa_multiplex_duplicate_route(pa_core *, pa_muxnode *,
pa_sink_input *, pa_sink *);
int pa_multiplex_no_of_routes(pa_core *, pa_muxnode *);
};
-static pa_bool_t use_default_configuration(struct userdata *);
+static bool use_default_configuration(struct userdata *);
#if 0
-static pa_bool_t parse_config_file(struct userdata *, FILE *);
+static bool parse_config_file(struct userdata *, FILE *);
#endif
pa_mir_config *pa_mir_config_init(struct userdata *u)
}
-pa_bool_t pa_mir_config_parse_file(struct userdata *u, const char *path)
+bool pa_mir_config_parse_file(struct userdata *u, const char *path)
{
pa_module *module;
pa_mir_config *config;
pa_assert_se((config = u->config));
if (!path)
- success = FALSE;
+ success = false;
else {
pa_log_info("%s: configuration file is '%s'", module->name, path);
success = pa_scripting_dofile(u, path);
return success;
}
-static pa_bool_t use_default_configuration(struct userdata *u)
+static bool use_default_configuration(struct userdata *u)
{
zone_def *z;
rtgroup_def *r;
mir_volume_add_class_limit(u, mir_navigator,mir_volume_suppress,&suppress);
- return TRUE;
+ return true;
}
/*
struct pa_mir_config *pa_mir_config_init(struct userdata *);
void pa_mir_config_done(struct userdata *);
-pa_bool_t pa_mir_config_parse_file(struct userdata *, const char *);
+bool pa_mir_config_parse_file(struct userdata *, const char *);
#endif /* foomurphyconfigfoo */
mrp_sockaddr_t saddr;
socklen_t alen;
const char *atype;
- pa_bool_t connected;
+ bool connected;
struct {
pa_time_event *evt;
pa_usec_t period;
#ifdef WITH_RESOURCES
typedef struct {
const char *id;
- pa_bool_t autorel;
+ bool autorel;
int state;
- pa_bool_t grant;
+ bool grant;
const char *policy;
} rset_data;
static void resource_xport_closed_evt(mrp_transport_t *, int, void *);
static mrp_msg_t *resource_create_request(uint32_t, mrp_resproto_request_t);
-static pa_bool_t resource_send_message(resource_interface *, mrp_msg_t *,
+static bool resource_send_message(resource_interface *, mrp_msg_t *,
uint32_t, uint16_t, uint32_t);
-static pa_bool_t resource_set_create_node(struct userdata *, mir_node *,
- pa_nodeset_resdef *, pa_bool_t);
-static pa_bool_t resource_set_create_all(struct userdata *);
-static pa_bool_t resource_set_destroy_node(struct userdata *, uint32_t);
-static pa_bool_t resource_set_destroy_all(struct userdata *);
+static bool resource_set_create_node(struct userdata *, mir_node *,
+ pa_nodeset_resdef *, bool);
+static bool resource_set_create_all(struct userdata *);
+static bool resource_set_destroy_node(struct userdata *, uint32_t);
+static bool resource_set_destroy_all(struct userdata *);
static void resource_set_notification(struct userdata *, const char *,
int, mrp_domctl_value_t **);
-static pa_bool_t resource_push_attributes(mrp_msg_t *, resource_interface *,
+static bool resource_push_attributes(mrp_msg_t *, resource_interface *,
pa_proplist *);
static void resource_recv_msg(mrp_transport_t *, mrp_msg_t *, void *);
static void resource_set_create_response_abort(struct userdata *,
mrp_msg_t *, void **);
-static pa_bool_t resource_fetch_seqno(mrp_msg_t *, void **, uint32_t *);
-static pa_bool_t resource_fetch_request(mrp_msg_t *, void **, uint16_t *);
-static pa_bool_t resource_fetch_status(mrp_msg_t *, void **, int *);
-static pa_bool_t resource_fetch_rset_id(mrp_msg_t *, void **, uint32_t*);
-static pa_bool_t resource_fetch_rset_state(mrp_msg_t *, void **,
+static bool resource_fetch_seqno(mrp_msg_t *, void **, uint32_t *);
+static bool resource_fetch_request(mrp_msg_t *, void **, uint16_t *);
+static bool resource_fetch_status(mrp_msg_t *, void **, int *);
+static bool resource_fetch_rset_id(mrp_msg_t *, void **, uint32_t*);
+static bool resource_fetch_rset_state(mrp_msg_t *, void **,
mrp_resproto_state_t *);
-static pa_bool_t resource_fetch_rset_mask(mrp_msg_t *, void **,
+static bool resource_fetch_rset_mask(mrp_msg_t *, void **,
mrp_resproto_state_t *);
-static pa_bool_t resource_transport_create(struct userdata *, pa_murphyif *);
+static bool resource_transport_create(struct userdata *, pa_murphyif *);
static void resource_transport_destroy(pa_murphyif *);
static void connect_attempt(pa_mainloop_api *, pa_time_event *,
}
}
- pa_hashmap_free(rif->nodes.rsetid, NULL);
- pa_hashmap_free(rif->nodes.pid, NULL);
+ pa_hashmap_free(rif->nodes.rsetid);
+ pa_hashmap_free(rif->nodes.pid);
PA_LLIST_FOREACH_SAFE(attr, a, rif->attrs)
resource_attribute_destroy(rif, attr);
break;
case CONNECTED:
- node->localrset = resource_set_create_node(u, node, resdef, TRUE);
+ node->localrset = resource_set_create_node(u, node, resdef, true);
break;
case DISCONNECTED:
pa_xfree(node->rsetid);
- node->localrset = FALSE;
+ node->localrset = false;
node->rsetid = NULL;
}
}
status = DISCONNECTED;
else {
pa_log_info("resource transport connected to '%s'", rif->addr);
- rif->connected = TRUE;
+ rif->connected = true;
status = CONNECTING;
}
}
return msg;
}
-static pa_bool_t resource_send_message(resource_interface *rif,
+static bool resource_send_message(resource_interface *rif,
mrp_msg_t *msg,
uint32_t nodidx,
uint16_t reqid,
uint32_t seqno)
{
resource_request *req;
- pa_bool_t success = TRUE;
+ bool success = true;
if (!mrp_transport_send(rif->transp, msg)) {
pa_log("failed to send resource message");
- success = FALSE;
+ success = false;
}
else {
req = pa_xnew0(resource_request, 1);
return success;
}
-static pa_bool_t resource_set_create_node(struct userdata *u,
+static bool resource_set_create_node(struct userdata *u,
mir_node *node,
pa_nodeset_resdef *resdef,
- pa_bool_t acquire)
+ bool acquire)
{
pa_core *core;
pa_murphyif *murphyif;
uint32_t audio_flags = 0;
uint32_t priority;
pa_proplist *proplist = NULL;
- pa_bool_t success = TRUE;
+ bool success = true;
pa_assert(u);
pa_assert(node);
success = resource_send_message(rif, msg, node->index, reqid, seqno);
}
else {
- success = FALSE;
+ success = false;
mrp_msg_unref(msg);
}
return success;
}
-static pa_bool_t resource_set_create_all(struct userdata *u)
+static bool resource_set_create_all(struct userdata *u)
{
uint32_t idx;
mir_node *node;
- pa_bool_t success;
+ bool success;
pa_assert(u);
- success = TRUE;
+ success = true;
idx = PA_IDXSET_INVALID;
(node->implement == mir_device && node->loop) )
{
if (!node->rsetid) {
- node->localrset = resource_set_create_node(u, node, NULL, FALSE);
+ node->localrset = resource_set_create_node(u, node, NULL, false);
success &= node->localrset;
}
}
return success;
}
-static pa_bool_t resource_set_destroy_node(struct userdata *u, uint32_t rsetid)
+static bool resource_set_destroy_node(struct userdata *u, uint32_t rsetid)
{
pa_murphyif *murphyif;
resource_interface *rif;
uint16_t reqid;
uint32_t seqno;
uint32_t nodidx;
- pa_bool_t success;
+ bool success;
pa_assert(u);
if (PUSH_VALUE(msg, RESOURCE_SET_ID, UINT32, rsetid))
success = resource_send_message(rif, msg, nodidx, reqid, seqno);
else {
- success = FALSE;
+ success = false;
mrp_msg_unref(msg);
}
return success;
}
-static pa_bool_t resource_set_destroy_all(struct userdata *u)
+static bool resource_set_destroy_all(struct userdata *u)
{
pa_murphyif *murphyif;
resource_interface *rif;
mir_node *node;
uint32_t rsetid;
char *e;
- pa_bool_t success;
+ bool success;
pa_assert(u);
pa_assert_se((murphyif = u->murphyif));
rif = &murphyif->resource;
- success = TRUE;
+ success = true;
idx = PA_IDXSET_INVALID;
rsetid = strtoul(node->rsetid, &e, 10);
if (e == node->rsetid || *e)
- success = FALSE;
+ success = false;
else {
rset_hashmap_remove(u, node->rsetid, node);
success &= resource_set_destroy_node(u, rsetid);
pa_xfree(node->rsetid);
- node->localrset = FALSE;
+ node->localrset = false;
node->rsetid = NULL;
}
}
}
-static pa_bool_t resource_push_attributes(mrp_msg_t *msg,
+static bool resource_push_attributes(mrp_msg_t *msg,
resource_interface *rif,
pa_proplist *proplist)
{
PA_LLIST_FOREACH(attr, rif->attrs) {
if (!PUSH_VALUE(msg, ATTRIBUTE_NAME, STRING, attr->def.name))
- return FALSE;
+ return false;
if (proplist)
sts = pa_proplist_get(proplist, attr->prop, &v.ptr, &size);
v.str = attr->def.value.string;
else if (v.str[size-1] != '\0' || strlen(v.str) != (size-1) ||
!pa_utf8_valid(v.str))
- return FALSE;
+ return false;
if (!PUSH_VALUE(msg, ATTRIBUTE_VALUE, STRING, v.str))
- return FALSE;
+ return false;
break;
case mqi_integer:
if (sts < 0)
v.i32 = &attr->def.value.integer;
else if (size != sizeof(*v.i32))
- return FALSE;
+ return false;
if (!PUSH_VALUE(msg, ATTRIBUTE_VALUE, SINT8, *v.i32))
- return FALSE;
+ return false;
break;
case mqi_unsignd:
if (sts < 0)
v.u32 = &attr->def.value.unsignd;
else if (size != sizeof(*v.u32))
- return FALSE;
+ return false;
if (!PUSH_VALUE(msg, ATTRIBUTE_VALUE, SINT8, *v.u32))
- return FALSE;
+ return false;
break;
case mqi_floating:
if (sts < 0)
v.dbl = &attr->def.value.floating;
else if (size != sizeof(*v.dbl))
- return FALSE;
+ return false;
if (!PUSH_VALUE(msg, ATTRIBUTE_VALUE, SINT8, *v.dbl))
- return FALSE;
+ return false;
break;
default: /* we should never get here */
- return FALSE;
+ return false;
}
}
- return TRUE;
+ return true;
}
}
-static pa_bool_t resource_fetch_seqno(mrp_msg_t *msg,
+static bool resource_fetch_seqno(mrp_msg_t *msg,
void **pcursor,
uint32_t *pseqno)
{
}
-static pa_bool_t resource_fetch_request(mrp_msg_t *msg,
+static bool resource_fetch_request(mrp_msg_t *msg,
void **pcursor,
uint16_t *preqtype)
{
return true;
}
-static pa_bool_t resource_fetch_status(mrp_msg_t *msg,
+static bool resource_fetch_status(mrp_msg_t *msg,
void **pcursor,
int *pstatus)
{
tag != RESPROTO_REQUEST_STATUS || type != MRP_MSG_FIELD_SINT16)
{
*pstatus = EINVAL;
- return FALSE;
+ return false;
}
*pstatus = value.s16;
- return TRUE;
+ return true;
}
-static pa_bool_t resource_fetch_rset_id(mrp_msg_t *msg,
+static bool resource_fetch_rset_id(mrp_msg_t *msg,
void **pcursor,
uint32_t *pid)
{
tag != RESPROTO_RESOURCE_SET_ID || type != MRP_MSG_FIELD_UINT32)
{
*pid = INVALID_ID;
- return FALSE;
+ return false;
}
*pid = value.u32;
- return TRUE;
+ return true;
}
-static pa_bool_t resource_fetch_rset_state(mrp_msg_t *msg,
+static bool resource_fetch_rset_state(mrp_msg_t *msg,
void **pcursor,
mrp_resproto_state_t *pstate)
{
tag != RESPROTO_RESOURCE_STATE || type != MRP_MSG_FIELD_UINT16)
{
*pstate = 0;
- return FALSE;
+ return false;
}
*pstate = value.u16;
- return TRUE;
+ return true;
}
-static pa_bool_t resource_fetch_rset_mask(mrp_msg_t *msg,
+static bool resource_fetch_rset_mask(mrp_msg_t *msg,
void **pcursor,
mrp_resproto_state_t *pmask)
{
tag != RESPROTO_RESOURCE_GRANT || type != MRP_MSG_FIELD_UINT32)
{
*pmask = 0;
- return FALSE;
+ return false;
}
*pmask = value.u32;
- return TRUE;
+ return true;
}
-static pa_bool_t resource_transport_create(struct userdata *u,
+static bool resource_transport_create(struct userdata *u,
pa_murphyif *murphyif)
{
static mrp_transport_evt_t ev = {
if (!rif->transp)
rif->transp = mrp_transport_create(murphyif->ml, rif->atype, &ev, u,0);
- return rif->transp ? TRUE : FALSE;
+ return rif->transp ? true : false;
}
static void resource_transport_destroy(pa_murphyif *murphyif)
mrp_transport_destroy(rif->transp);
rif->transp = NULL;
- rif->connected = FALSE;
+ rif->connected = false;
}
static void connect_attempt(pa_mainloop_api *a,
ph->node = node;
ph->rset = rset;
- if (pa_hashmap_put(rif->nodes.pid, ph->pid, ph) == 0)
+ if (pa_hashmap_put(rif->nodes.pid, (void *)ph->pid, ph) == 0)
return 0;
else
pid_hashmap_free(ph, NULL);
if (!(ph = pa_hashmap_remove(rif->nodes.pid, pid)))
node = NULL;
else if (!(node = ph->node))
- pa_hashmap_put(rif->nodes.pid, ph->pid, ph);
+ pa_hashmap_put(rif->nodes.pid, (void *)ph->pid, ph);
else
pid_hashmap_free(ph, NULL);
if (!(ph = pa_hashmap_remove(rif->nodes.pid, pid)))
rset = NULL;
else if (!(rset = ph->rset))
- pa_hashmap_put(rif->nodes.pid, ph->pid, ph);
+ pa_hashmap_put(rif->nodes.pid, (void *)ph->pid, ph);
else {
ph->rset = NULL;
pid_hashmap_free(ph, NULL);
rh->nodes = pa_xnew0(mir_node *, 2);
rh->rset = rset;
- pa_hashmap_put(rif->nodes.rsetid, rh->rset->id, rh);
+ pa_hashmap_put(rif->nodes.rsetid, (void *)rh->rset->id, rh);
i = 0;
}
void pa_nodeset_done(struct userdata *u)
{
pa_nodeset *ns;
+ pa_nodeset_map *role, *binary;
+ void *state;
int i;
if (u && (ns = u->nodeset)) {
pa_idxset_free(ns->nodes, NULL);
- pa_hashmap_free(ns->roles, free_map_cb);
- pa_hashmap_free(ns->binaries, free_map_cb);
+
+ PA_HASHMAP_FOREACH(role, ns->roles, state) {
+ pa_xfree((void *)role->name);
+ pa_xfree((void *)role->resdef);
+ }
+
+ pa_hashmap_free(ns->roles);
+
+ PA_HASHMAP_FOREACH(binary, ns->binaries, state) {
+ pa_xfree((void *)binary->name);
+ pa_xfree((void *)binary->resdef);
+ }
+
+ pa_hashmap_free(ns->binaries);
for (i = 0; i < APCLASS_DIM; i++)
pa_xfree((void *)ns->class_name[i]);
}
}
+
+
int pa_nodeset_add_class(struct userdata *u, mir_node_type t,const char *clnam)
{
pa_nodeset *ns;
memcpy(map->resdef, resdef, sizeof(pa_nodeset_resdef));
}
- return pa_hashmap_put(ns->roles, map->name, map);
+ return pa_hashmap_put(ns->roles, (void *)map->name, map);
}
void pa_nodeset_delete_role(struct userdata *u, const char *role)
memcpy(map->resdef, resdef, sizeof(pa_nodeset_resdef));
}
- return pa_hashmap_put(ns->binaries, map->name, map);
+ return pa_hashmap_put(ns->binaries, (void *)map->name, map);
}
void pa_nodeset_delete_binary(struct userdata *u, const char *bin)
mir_privacy privacy; /**< mir_public | mir_private */
mir_node_type type; /**< mir_speakers | mir_headset | ... */
char *zone; /**< zone where the node belong */
- pa_bool_t visible; /**< internal or can appear on UI */
- pa_bool_t available; /**< eg. is the headset connected? */
- pa_bool_t ignore; /**< do not consider it while routing */
- pa_bool_t localrset; /**< locally generated resource set */
+ bool visible; /**< internal or can appear on UI */
+ bool available; /**< eg. is the headset connected? */
+ bool ignore; /**< do not consider it while routing */
+ bool localrset; /**< locally generated resource set */
char *amname; /**< audiomanager name */
char *amdescr; /**< UI description */
uint16_t amid; /**< handle to audiomanager, if any */
rtgroup_destroy(u, rtg);
}
- pa_hashmap_free(router->rtgroups.input, NULL);
- pa_hashmap_free(router->rtgroups.output, NULL);
+ pa_hashmap_free(router->rtgroups.input);
+ pa_hashmap_free(router->rtgroups.output);
for (i = 0; i < MRP_ZONE_MAX; i++) {
if ((map = router->classmap.input[i]))
}
-pa_bool_t mir_router_assign_class_to_rtgroup(struct userdata *u,
+bool mir_router_assign_class_to_rtgroup(struct userdata *u,
mir_node_type class,
uint32_t zone,
mir_direction type,
pa_log_debug("can't assign class (%d) to routing group '%s': "
"class id is out of range (0 - %d)",
class, rtgrpnam, router->maplen);
- return FALSE;
+ return false;
}
clnam = mir_node_type_str(class);
clnam, zone, direction, rtgrpnam);
}
- return TRUE;
+ return true;
}
mir_node *start;
mir_node *end;
int priority;
- pa_bool_t done;
+ bool done;
mir_node *target;
uint32_t stamp;
pa_assert_se((data->implement == mir_stream));
priority = node_priority(u, data);
- done = FALSE;
+ done = false;
target = NULL;
stamp = pa_utils_new_stamp();
if (priority >= node_priority(u, start)) {
if ((target = find_default_route(u, data, stamp)))
implement_preroute(u, data, target, stamp);
- done = TRUE;
+ done = true;
}
if (start->stamp >= stamp)
void mir_router_make_routing(struct userdata *u)
{
- static pa_bool_t ongoing_routing;
+ static bool ongoing_routing;
pa_router *router;
mir_node *start;
if (ongoing_routing)
return;
- ongoing_routing = TRUE;
+ ongoing_routing = true;
stamp = pa_utils_new_stamp();
make_explicit_routes(u, stamp);
pa_fader_apply_volume_limits(u, stamp);
- ongoing_routing = FALSE;
+ ongoing_routing = false;
}
-pa_bool_t mir_router_default_accept(struct userdata *u, mir_rtgroup *rtg,
+bool mir_router_default_accept(struct userdata *u, mir_rtgroup *rtg,
mir_node *node)
{
pa_core *core;
pa_source *source;
pa_proplist *pl;
mir_node_type class;
- pa_bool_t accept;
+ bool accept;
const char *role, *excluded_role;
pa_assert(u);
class = node->type;
if (class == mir_bluetooth_carkit)
- accept = FALSE;
+ accept = false;
else if (class == mir_jack || class == mir_hdmi) {
pa_assert_se((core = u->core));
excluded_role = "hfp_downlink";
}
role = pl ? pa_proplist_gets(pl, PA_PROP_NODE_ROLE) : NULL;
- accept = role ? strcmp(role, excluded_role) : TRUE;
+ accept = role ? strcmp(role, excluded_role) : true;
}
else {
accept = (class >= mir_device_class_begin &&
}
-pa_bool_t mir_router_phone_accept(struct userdata *u, mir_rtgroup *rtg,
+bool mir_router_phone_accept(struct userdata *u, mir_rtgroup *rtg,
mir_node *node)
{
pa_core *core;
}
}
- return FALSE;
+ return false;
}
continue;
}
- if (!mir_switch_setup_link(u, from, to, TRUE))
+ if (!mir_switch_setup_link(u, from, to, true))
continue;
if (from->implement == mir_stream)
uint32_t stamp)
{
if (data->direction == mir_output)
- mir_switch_setup_link(u, target, NULL, FALSE);
+ mir_switch_setup_link(u, target, NULL, false);
else {
- mir_switch_setup_link(u, NULL, target, FALSE);
+ mir_switch_setup_link(u, NULL, target, false);
mir_volume_add_limiting_class(u, target, data->type, stamp);
}
}
uint32_t stamp)
{
if (start->direction == mir_output)
- mir_switch_setup_link(u, end, start, FALSE);
+ mir_switch_setup_link(u, end, start, false);
else {
- mir_switch_setup_link(u, start, end, FALSE);
+ mir_switch_setup_link(u, start, end, false);
mir_volume_add_limiting_class(u, end, volume_class(start), stamp);
}
}
#include "userdata.h"
#include "list.h"
-typedef pa_bool_t (*mir_rtgroup_accept_t)(struct userdata *, mir_rtgroup *,
+typedef bool (*mir_rtgroup_accept_t)(struct userdata *, mir_rtgroup *,
mir_node *);
typedef int (*mir_rtgroup_compare_t)(struct userdata *, mir_rtgroup *,
mir_node *, mir_node *);
struct mir_connection {
mir_dlist link; /**< list of connections */
- pa_bool_t blocked; /**< true if this conflicts with another route */
+ bool blocked; /**< true if this conflicts with another route */
uint16_t amid; /**< audio manager connection id */
uint32_t from; /**< source node index */
uint32_t to; /**< destination node index */
mir_rtgroup_compare_t);
void mir_router_destroy_rtgroup(struct userdata *, mir_direction,
const char *);
-pa_bool_t mir_router_assign_class_to_rtgroup(struct userdata *, mir_node_type,
+bool mir_router_assign_class_to_rtgroup(struct userdata *, mir_node_type,
uint32_t, mir_direction,
const char *);
int mir_router_print_rtgroups(struct userdata *, char *, int);
-pa_bool_t mir_router_default_accept(struct userdata *, mir_rtgroup *,
+bool mir_router_default_accept(struct userdata *, mir_rtgroup *,
mir_node *);
-pa_bool_t mir_router_phone_accept(struct userdata *, mir_rtgroup *,
+bool mir_router_phone_accept(struct userdata *, mir_rtgroup *,
mir_node *);
int mir_router_default_compare(struct userdata *, mir_rtgroup *,
void pa_routerif_done(struct userdata *);
-pa_bool_t pa_routerif_register_domain(struct userdata *,
+bool pa_routerif_register_domain(struct userdata *,
am_domainreg_data *);
-pa_bool_t pa_routerif_domain_complete(struct userdata *, uint16_t);
-pa_bool_t pa_routerif_unregister_domain(struct userdata *, uint16_t);
+bool pa_routerif_domain_complete(struct userdata *, uint16_t);
+bool pa_routerif_unregister_domain(struct userdata *, uint16_t);
-pa_bool_t pa_routerif_register_node(struct userdata *, am_method,
+bool pa_routerif_register_node(struct userdata *, am_method,
am_nodereg_data *);
-pa_bool_t pa_routerif_unregister_node(struct userdata *, am_method,
+bool pa_routerif_unregister_node(struct userdata *, am_method,
am_nodeunreg_data *);
-pa_bool_t pa_routerif_acknowledge(struct userdata *, am_method, am_ack_data *);
+bool pa_routerif_acknowledge(struct userdata *, am_method, am_ack_data *);
#endif /* foorouteriffoo */
struct pa_scripting {
lua_State *L;
- pa_bool_t configured;
+ bool configured;
};
struct scripting_import {
typedef struct {
const char *name;
- pa_bool_t needres;
+ bool needres;
const char *role;
pa_nodeset_resdef resource;
} map_t;
map_t *roles;
map_t *binaries;
struct {
- pa_bool_t resource;
+ bool resource;
} needs;
};
} intarray_t;
typedef struct {
- pa_bool_t mallocd;
+ bool mallocd;
double *value;
} limit_data_t;
static int rtgroup_tostring(lua_State *);
static void rtgroup_destroy(void *);
-static pa_bool_t rtgroup_accept(struct userdata *, mir_rtgroup *, mir_node *);
+static bool rtgroup_accept(struct userdata *, mir_rtgroup *, mir_node *);
static int rtgroup_compare(struct userdata *, mir_rtgroup *,
mir_node *, mir_node *);
lua_setglobal(L, USERDATA);
scripting->L = L;
- scripting->configured = FALSE;
+ scripting->configured = false;
}
return scripting;
}
}
-pa_bool_t pa_scripting_dofile(struct userdata *u, const char *file)
+bool pa_scripting_dofile(struct userdata *u, const char *file)
{
pa_scripting *scripting;
lua_State *L;
- pa_bool_t success;
+ bool success;
pa_assert(u);
pa_assert(file);
pa_assert_se((L = scripting->L));
if (luaL_loadfile(L, file) || lua_pcall(L, 0, 0, 0)) {
- success = FALSE;
+ success = false;
pa_log("%s", lua_tostring(L, -1));
lua_pop(L, 1);
}
else {
- success =TRUE;
- scripting->configured = TRUE;
+ success =true;
+ scripting->configured = true;
setup_murphy_interface(u);
pa_zoneset_update_module_property(u);
}
}
-static pa_bool_t rtgroup_accept(struct userdata *u,
+static bool rtgroup_accept(struct userdata *u,
mir_rtgroup *rtg,
mir_node *node)
{
mrp_funcbridge_value_t args[2];
char rt;
mrp_funcbridge_value_t rv;
- pa_bool_t accept;
+ bool accept;
pa_assert(u);
pa_assert_se((scripting = u->scripting));
route_t *route = NULL;
map_t *roles = NULL;
map_t *binaries = NULL;
- pa_bool_t needs_resource = FALSE;
+ bool needs_resource = false;
pa_nodeset_resdef *resdef;
map_t *r, *b;
size_t i;
const char *n;
- pa_bool_t ir, or;
+ bool ir, or;
MRP_LUA_ENTER;
mir_router_assign_class_priority(u, type, priority);
- ir = or = TRUE;
+ ir = or = true;
if (route->input) {
for (i = 0; i < MRP_ZONE_MAX; i++) {
limit_data_t *limit = NULL;
mrp_funcbridge_t *calculate = NULL;
intarray_t *classes = NULL;
- pa_bool_t suppress = FALSE;
- pa_bool_t correct = FALSE;
+ bool suppress = false;
+ bool correct = false;
size_t arglgh = 0;
size_t i;
int class;
if (calculate->c.data == mir_volume_suppress) {
if (type != vollim_class)
luaL_error(L, "attempt to make generic volume supression");
- suppress = TRUE;
+ suppress = true;
arglgh = sizeof(mir_volume_suppress_arg);
}
else if (calculate->c.data == mir_volume_correction) {
if (type != vollim_generic)
luaL_error(L, "attempt to make class based volume correction");
- correct = TRUE;
+ correct = true;
arglgh = sizeof(double *);
}
else {
luaL_error(L, "volume limit is in dB and can't be positive");
else {
ld = pa_xnew0(limit_data_t, 1);
- ld->mallocd = TRUE;
+ ld->mallocd = true;
ld->value = pa_xnew0(double, 1);
*ld->value = value;
}
luaL_error(L, "broken link for volume limit value");
else {
ld = pa_xnew0(limit_data_t, 1);
- ld->mallocd = FALSE;
+ ld->mallocd = false;
ld->value = &v->floating;
}
break;
default:
- ld->mallocd = FALSE;
+ ld->mallocd = false;
ld->value = &nolimit;
break;
}
switch (lua_type(L, -1)) {
case LUA_TNUMBER:
- m->needres = FALSE;
+ m->needres = false;
break;
case LUA_TSTRING:
break;
case LUA_TTABLE:
- m->needres = TRUE;
+ m->needres = true;
if ((len = luaL_getn(L, def)) < 1)
luaL_error(L, "invalid resource definition '%s'", name);
const char *key;
lua_State *L;
int class;
- pa_bool_t need_domainctl;
+ bool need_domainctl;
char buf[8192];
const char *columns;
int top;
(IMPORT_CLASS)->constructor);
}
- need_domainctl = FALSE;
+ need_domainctl = false;
lua_pushnil(L);
while (lua_next(L, class)) {
pa_log_debug("adding import '%s'", imp->table);
- need_domainctl = TRUE;
+ need_domainctl = true;
columns = comma_separated_list(imp->columns, buf,sizeof(buf));
pa_murphyif_add_watch(u, imp->table, columns, imp->condition,
pa_scripting *pa_scripting_init(struct userdata *);
void pa_scripting_done(struct userdata *);
-pa_bool_t pa_scripting_dofile(struct userdata *, const char *);
+bool pa_scripting_dofile(struct userdata *, const char *);
scripting_node *pa_scripting_node_create(struct userdata *, mir_node *);
void pa_scripting_node_destroy(struct userdata *, mir_node *);
}
-pa_bool_t pa_routerif_register_domain(struct userdata *u,
+bool pa_routerif_register_domain(struct userdata *u,
am_domainreg_data *dr)
{
pa_routerif *routerif;
- int success = TRUE;
+ int success = true;
pa_assert(u);
pa_assert(dr);
return success;
}
-pa_bool_t pa_routerif_domain_complete(struct userdata *u, uint16_t domain)
+bool pa_routerif_domain_complete(struct userdata *u, uint16_t domain)
{
pa_routerif *routerif;
- pa_bool_t success = TRUE;
+ bool success = true;
pa_assert(u);
pa_assert_se((routerif = u->routerif));
return success;
}
-pa_bool_t pa_routerif_unregister_domain(struct userdata *u, uint16_t domain)
+bool pa_routerif_unregister_domain(struct userdata *u, uint16_t domain)
{
pa_routerif *routerif;
- pa_bool_t success = TRUE;
+ bool success = true;
pa_assert(u);
pa_assert_se((routerif = u->routerif));
}
-pa_bool_t pa_routerif_register_node(struct userdata *u,
+bool pa_routerif_register_node(struct userdata *u,
am_method m,
am_nodereg_data *rd)
{
const char *method = method_str(m);
pa_routerif *routerif;
- pa_bool_t success = TRUE;
+ bool success = true;
pa_assert(u);
pa_assert(rd);
}
-pa_bool_t pa_routerif_unregister_node(struct userdata *u,
+bool pa_routerif_unregister_node(struct userdata *u,
am_method m,
am_nodeunreg_data *ud)
{
const char *method = method_str(m);
pa_routerif *routerif;
- pa_bool_t success = TRUE;
+ bool success = true;
pa_assert(u);
pa_assert(ud);
}
-pa_bool_t pa_routerif_acknowledge(struct userdata *u, am_method m,
+bool pa_routerif_acknowledge(struct userdata *u, am_method m,
struct am_ack_data *ad)
{
const char *method = method_str(m);
pa_routerif *routerif;
- pa_bool_t success = TRUE;
+ bool success = true;
pa_assert(u);
pa_assert(method);
static pa_sink_input_flags_t flag_mask = PA_SINK_INPUT_NO_CREATE_ON_SUSPEND |
PA_SINK_INPUT_KILL_ON_SUSPEND;
+static void sink_input_block(struct userdata *, pa_sink_input *, bool);
-static void sink_input_block(struct userdata *, pa_sink_input *, pa_bool_t);
-
-pa_bool_t pa_stream_state_start_corked(struct userdata *u,
+bool pa_stream_state_start_corked(struct userdata *u,
pa_sink_input_new_data *data,
pa_nodeset_resdef *resdef)
{
data->flags &= ~flag_mask;
data->flags |= PA_SINK_INPUT_START_CORKED;
- return TRUE;
+ return true;
}
- return FALSE;
+ return false;
}
void pa_stream_state_change(struct userdata *u, mir_node *node, int req)
case PA_STREAM_KILL:
case PA_STREAM_BLOCK:
pa_log_debug("mute '%s'", node->amname);
- pa_sink_input_set_mute(sinp, TRUE, FALSE);
+ pa_sink_input_set_mute(sinp, true, false);
break;
case PA_STREAM_RUN:
pa_log_debug("unmute '%s'", node->amname);
- pa_sink_input_set_mute(sinp, FALSE, FALSE);
+ pa_sink_input_set_mute(sinp, false, false);
break;
default:
case PA_STREAM_BLOCK:
pa_log_debug("blocking '%s'", node->amname);
- sink_input_block(u, sinp, TRUE);
+ sink_input_block(u, sinp, true);
break;
case PA_STREAM_RUN:
pa_log_debug("unblock '%s'", node->amname);
- sink_input_block(u, sinp, FALSE);
+ sink_input_block(u, sinp, false);
break;
default:
static void sink_input_block(struct userdata *u,
pa_sink_input *sinp,
- pa_bool_t block)
+ bool block)
{
const char *event;
pa_proplist *pl;
#define PA_STREAM_KILL -1
-pa_bool_t pa_stream_state_start_corked(struct userdata *,
+bool pa_stream_state_start_corked(struct userdata *,
pa_sink_input_new_data *,
pa_nodeset_resdef *);
void pa_stream_state_change(struct userdata *u, mir_node *, int);
#include "utils.h"
#include "classify.h"
-static pa_bool_t setup_explicit_stream2dev_link(struct userdata *,
+static bool setup_explicit_stream2dev_link(struct userdata *,
mir_node *,
mir_node *);
-static pa_bool_t teardown_explicit_stream2dev_link(struct userdata*, mir_node*,
+static bool teardown_explicit_stream2dev_link(struct userdata*, mir_node*,
mir_node *);
-static pa_bool_t setup_default_dev2stream_link(struct userdata *, mir_node *,
+static bool setup_default_dev2stream_link(struct userdata *, mir_node *,
mir_node *);
-static pa_bool_t setup_default_stream2dev_link(struct userdata *, mir_node *,
+static bool setup_default_stream2dev_link(struct userdata *, mir_node *,
mir_node *);
-static pa_bool_t setup_default_dev2dev_link(struct userdata *,
+static bool setup_default_dev2dev_link(struct userdata *,
mir_node *,
mir_node *);
static pa_source *setup_device_input(struct userdata *, mir_node *);
static pa_sink *setup_device_output(struct userdata *, mir_node *);
-static pa_bool_t set_profile(struct userdata *, mir_node *);
-static pa_bool_t set_port(struct userdata *, mir_node *);
+static bool set_profile(struct userdata *, mir_node *);
+static bool set_port(struct userdata *, mir_node *);
-pa_bool_t mir_switch_setup_link(struct userdata *u,
+bool mir_switch_setup_link(struct userdata *u,
mir_node *from,
mir_node *to,
- pa_bool_t explicit)
+ bool explicit)
{
pa_core *core;
case mir_device:
if (!setup_explicit_stream2dev_link(u, from, to))
- return FALSE;
+ return false;
break;
default:
pa_log("%s: can't setup link: invalid sink node "
"implement", __FILE__);
- return FALSE;
+ return false;
}
break;
default:
pa_log("%s: can't setup link: invalid source node "
"implement", __FILE__);
- return FALSE;
+ return false;
}
}
else {
case mir_device:
if (!setup_default_dev2stream_link(u, from, to))
- return FALSE;
+ return false;
break;
default:
pa_log("%s: can't setup link: invalid source node "
"implement", __FILE__);
- return FALSE;
+ return false;
}
break;
case mir_stream:
if (!setup_default_stream2dev_link(u, from, to))
- return FALSE;
+ return false;
break;
case mir_device:
if (!setup_default_dev2dev_link(u, from, to))
- return FALSE;
+ return false;
break;
default:
pa_log("%s: can't setup link: invalid source node "
"implement", __FILE__);
- return FALSE;
+ return false;
}
}
break;
default:
pa_log("%s: can't setup link: invalid sink node "
"implement", __FILE__);
- return FALSE;
+ return false;
}
}
else {
pa_log_debug("link %s => %s is established", from->amname, to->amname);
- return TRUE;
+ return true;
}
-pa_bool_t mir_switch_teardown_link(struct userdata *u,
+bool mir_switch_teardown_link(struct userdata *u,
mir_node *from,
mir_node *to)
{
case mir_device: /* stream -> device */
if (!teardown_explicit_stream2dev_link(u, from, to))
- return FALSE;
+ return false;
break;
default:
pa_log("%s: can't teardown link: invalid sink node "
"implement", __FILE__);
- return FALSE;
+ return false;
}
break;
default:
pa_log("%s: can't teardown link: invalid source node "
"implement", __FILE__);
- return FALSE;
+ return false;
}
pa_log_debug("link %s => %s is torn down", from->amname, to->amname);
- return TRUE;
+ return true;
}
-static pa_bool_t setup_explicit_stream2dev_link(struct userdata *u,
+static bool setup_explicit_stream2dev_link(struct userdata *u,
mir_node *from,
mir_node *to)
{
pa_assert((core = u->core));
if (!(sink = setup_device_output(u, to)))
- return FALSE;
+ return false;
if (!set_profile(u, from) || !set_port(u, from)) {
pa_log("can't route from '%s'", from->amname);
- return FALSE;
+ return false;
}
if ((mux = from->mux)) {
sinp = pa_idxset_get_by_index(core->sink_inputs, mux->defstream_index);
if (sinp && sinp->sink == sink) {
- if (!pa_multiplex_remove_default_route(core, mux, TRUE))
- return FALSE;
+ if (!pa_multiplex_remove_default_route(core, mux, true))
+ return false;
}
else if (pa_multiplex_duplicate_route(core, mux, NULL, sink)) {
pa_log_debug("multiplex route %s => %s already exists",
from->amname, to->amname);
- return TRUE;
+ return true;
}
else {
if (!pa_multiplex_add_explicit_route(core, mux, sink, from->type))
- return FALSE;
+ return false;
}
}
else {
pa_log_debug("direct route: sink-input.%u -> sink.%u",
sinp->index, sink->index);
- if (pa_sink_input_move_to(sinp, sink, FALSE) < 0)
- return FALSE;
+ if (pa_sink_input_move_to(sinp, sink, false) < 0)
+ return false;
}
}
}
pa_log_debug("link %s => %s is established", from->amname, to->amname);
- return TRUE;
+ return true;
}
-static pa_bool_t teardown_explicit_stream2dev_link(struct userdata *u,
+static bool teardown_explicit_stream2dev_link(struct userdata *u,
mir_node *from,
mir_node *to)
{
if ((mux = from->mux)) {
if (!(sink = pa_idxset_get_by_index(core->sinks, to->paidx))) {
pa_log_debug("can't find sink.%u", to->paidx);
- return FALSE;
+ return false;
}
if (!pa_multiplex_remove_explicit_route(core, mux, sink)) {
pa_log_debug("can't remove multiplex route on mux %u", mux->module_index);
- return FALSE;
+ return false;
}
}
else {
if (!(sinp = pa_idxset_get_by_index(core->sink_inputs, from->paidx))) {
pa_log_debug("can't find source.%u", from->paidx);
- return FALSE;
+ return false;
}
if (!(sink = pa_utils_get_null_sink(u))) {
pa_log_debug("can't remove direct route: no null sink");
- return FALSE;
+ return false;
}
- if (pa_sink_input_move_to(sinp, sink, FALSE) < 0)
- return FALSE;
+ if (pa_sink_input_move_to(sinp, sink, false) < 0)
+ return false;
}
pa_log_debug("link %s => %s is torn down", from->amname, to->amname);
- return TRUE;
+ return true;
}
-static pa_bool_t setup_default_dev2stream_link(struct userdata *u,
+static bool setup_default_dev2stream_link(struct userdata *u,
mir_node *from,
mir_node *to)
{
if (!(source = setup_device_input(u, from))) {
pa_log_debug("can't route '%s': no source", from->amname);
- return FALSE;
+ return false;
}
if (to->paidx == PA_IDXSET_INVALID) {
pa_log_debug("can't route '%s': no source-output", to->amname);
- return FALSE;
+ return false;
}
if (!(sout = pa_idxset_get_by_index(core->source_outputs, to->paidx))) {
pa_log_debug("can't find sink input for '%s'", to->amname);
- return FALSE;
+ return false;
}
pa_log_debug("direct route: source.%d -> source->output.%d",
source->index, sout->index);
- if (pa_source_output_move_to(sout, source, FALSE) < 0)
- return FALSE;
+ if (pa_source_output_move_to(sout, source, false) < 0)
+ return false;
- return TRUE;
+ return true;
}
-static pa_bool_t setup_default_stream2dev_link(struct userdata *u,
+static bool setup_default_stream2dev_link(struct userdata *u,
mir_node *from,
mir_node *to)
{
pa_assert((core = u->core));
if (!(sink = setup_device_output(u, to)))
- return FALSE;
+ return false;
if (!set_profile(u, from) || !set_port(u, from)) {
pa_log("can't route from '%s'", from->amname);
- return FALSE;
+ return false;
}
if ((mux = from->mux)) {
if (mux->defstream_index == PA_IDXSET_INVALID) {
if ((n = pa_multiplex_no_of_routes(core, mux)) < 0)
- return FALSE;
+ return false;
else if (n > 0) {
pa_log_debug("currently mux %u has no default route",
mux->module_index);
- return TRUE;
+ return true;
}
sinp = NULL;
}
"duplicate to an explicit route. "
"Removing it ...", mux->module_index);
mux->defstream_index = PA_IDXSET_INVALID;
- return TRUE; /* the routing is a success */
+ return true; /* the routing is a success */
}
if (!pa_multiplex_add_default_route(core, mux,sink, from->type)) {
pa_log_debug("failed to add default route on mux %d",
mux->module_index);
mux->defstream_index = PA_IDXSET_INVALID;
- return FALSE;
+ return false;
}
}
else if (pa_multiplex_duplicate_route(core, mux, sinp, sink)) {
pa_log_debug("the default stream on mux %u would be a duplicate "
"to an explicit route. Removing it ...",
mux->module_index);
- return TRUE; /* the routing is a success */
+ return true; /* the routing is a success */
}
if (sinp) {
}
if (!pa_multiplex_change_default_route(core, mux, sink))
- return FALSE;
+ return false;
}
else {
if (from->paidx == PA_IDXSET_INVALID) {
pa_log_debug("can't route '%s': no sink-input", to->amname);
- return FALSE;
+ return false;
}
if (!(sinp = pa_idxset_get_by_index(core->sink_inputs, from->paidx))) {
pa_log_debug("can't find sink input for '%s'", from->amname);
- return FALSE;
+ return false;
}
pa_log_debug("direct route: sink-input.%d -> sink.%d",
sinp->index, sink->index);
- if (pa_sink_input_move_to(sinp, sink, FALSE) < 0)
- return FALSE;
+ if (pa_sink_input_move_to(sinp, sink, false) < 0)
+ return false;
}
- return TRUE;
+ return true;
}
-static pa_bool_t setup_default_dev2dev_link(struct userdata *u,
+static bool setup_default_dev2dev_link(struct userdata *u,
mir_node *from,
mir_node *to)
{
if (!(loop = from->loop)) {
pa_log_debug("source is not looped back");
- return FALSE;
+ return false;
}
if (!(sink = setup_device_output(u, to)))
- return FALSE;
+ return false;
if ((mux = from->mux)) {
if (mux->defstream_index == PA_IDXSET_INVALID) {
if ((n = pa_multiplex_no_of_routes(core, mux)) < 0)
- return FALSE;
+ return false;
else if (n > 0) {
pa_log_debug("currently mux %u has no default route",
mux->module_index);
- return TRUE;
+ return true;
}
sinp = NULL;
}
"duplicate to an explicit route. "
"Removing it ...", mux->module_index);
mux->defstream_index = PA_IDXSET_INVALID;
- return TRUE; /* the routing is a success */
+ return true; /* the routing is a success */
}
type = pa_classify_guess_application_class(from);
pa_log_debug("failed to add default route on mux %d",
mux->module_index);
mux->defstream_index = PA_IDXSET_INVALID;
- return FALSE;
+ return false;
}
}
else if (pa_multiplex_duplicate_route(core, mux, sinp, sink)) {
pa_log_debug("the default stream on mux %u would be a duplicate "
"to an explicit route. Removing it ...",
mux->module_index);
- return TRUE; /* the routing is a success */
+ return true; /* the routing is a success */
}
if (sinp) {
}
if (!pa_multiplex_change_default_route(core, mux, sink))
- return FALSE;
+ return false;
}
else {
sinp = pa_idxset_get_by_index(core->sink_inputs,
if (!sinp) {
pa_log_debug("can't find looped back sink input for '%s'",
from->amname);
- return FALSE;
+ return false;
}
pa_log_debug("loopback route: source.%d -> (source-output - "
"sink-input.%d) -> sink.%d",
from->paidx, sinp->index, sink->index);
- if (pa_sink_input_move_to(sinp, sink, FALSE) < 0)
- return FALSE;
+ if (pa_sink_input_move_to(sinp, sink, false) < 0)
+ return false;
}
- return TRUE;
+ return true;
}
static pa_source *setup_device_input(struct userdata *u, mir_node *node)
}
-static pa_bool_t set_profile(struct userdata *u, mir_node *node)
+static bool set_profile(struct userdata *u, mir_node *node)
{
pa_core *core;
pa_card *card;
pa_assert_se((core = u->core));
if (node->implement != mir_device)
- return TRUE;
+ return true;
if (node->type == mir_bluetooth_a2dp ||
node->type == mir_bluetooth_sco)
if (!card) {
pa_log("can't find card for '%s'", node->amname);
- return FALSE;
+ return false;
}
pa_assert_se(prof = card->active_profile);
if (u->state.profile) {
pa_log("nested profile setting is not allowed. won't change "
"'%s' => '%s'", prof->name, node->pacard.profile);
- return FALSE;
+ return false;
}
u->state.profile = node->pacard.profile;
- pa_card_set_profile(card, node->pacard.profile, FALSE);
+ pa_card_set_profile(card, node->pacard.profile, false);
u->state.profile = NULL;
}
}
- return TRUE;
+ return true;
}
-static pa_bool_t set_port(struct userdata *u, mir_node *node)
+static bool set_port(struct userdata *u, mir_node *node)
{
pa_core *core;
pa_sink *sink;
pa_assert_se((core = u->core));
if (node->direction != mir_input && node->direction != mir_output)
- return FALSE;
+ return false;
if (node->implement != mir_device)
- return TRUE;
+ return true;
if (!node->paport)
- return TRUE;
+ return true;
if (node->direction == mir_input) {
source = pa_namereg_get(core, node->paname, PA_NAMEREG_SOURCE);
if (!(data = source)) {
pa_log("can't set port for '%s': source not found",
node->paname);
- return FALSE;
+ return false;
}
if ((port = source->active_port) && pa_streq(node->paport, port->name))
- return TRUE;
+ return true;
- if (pa_source_set_port(source, node->paport, FALSE) < 0)
- return FALSE;
+ if (pa_source_set_port(source, node->paport, false) < 0)
+ return false;
paidx = source->index;
}
if (!(data = sink)) {
pa_log("can't set port for '%s': sink not found",
node->paname);
- return FALSE;
+ return false;
}
if ((port = sink->active_port) && pa_streq(node->paport, port->name))
- return TRUE;
+ return true;
- if (pa_sink_set_port(sink, node->paport, FALSE) < 0)
- return FALSE;
+ if (pa_sink_set_port(sink, node->paport, false) < 0)
+ return false;
paidx = sink->index;
}
pa_discover_add_node_to_ptr_hash(u, data, node);
- return TRUE;
+ return true;
}
#include "userdata.h"
-pa_bool_t mir_switch_setup_link(struct userdata *, mir_node *, mir_node *,
- pa_bool_t);
-pa_bool_t mir_switch_teardown_link(struct userdata *, mir_node *, mir_node *);
+bool mir_switch_setup_link(struct userdata *, mir_node *, mir_node *,
+ bool);
+bool mir_switch_teardown_link(struct userdata *, mir_node *, mir_node *);
#endif /* foomirswitchfoo */
}
PA_IDXSET_FOREACH(sink, core->sinks, index) {
- pa_discover_add_sink(u, sink, FALSE);
+ pa_discover_add_sink(u, sink, false);
}
PA_IDXSET_FOREACH(source, core->sources, index) {
pa_assert(u);
pa_assert(sink);
- pa_discover_add_sink(u, sink, TRUE);
+ pa_discover_add_sink(u, sink, true);
return PA_HOOK_OK;
}
{
pa_sink_input_new_data *data = (pa_sink_input_new_data *)call_data;
struct userdata *u = (struct userdata *)slot_data;
- pa_bool_t success;
+ bool success;
pa_assert(u);
pa_assert(data);
{
pa_source_output_new_data *data = (pa_source_output_new_data *)call_data;
struct userdata *u = (struct userdata *)slot_data;
- pa_bool_t success;
+ bool success;
pa_assert(u);
pa_assert(data);
static uint32_t stamp;
static char *stream_name(pa_proplist *);
-static pa_bool_t get_unsigned_property(pa_proplist *, const char *,uint32_t *);
+static bool get_unsigned_property(pa_proplist *, const char *,uint32_t *);
pa_null_sink *pa_utils_create_null_sink(struct userdata *u, const char *name)
if (u && (ns = u->nullsink) && (core = u->core)) {
if ((module = pa_idxset_get_by_index(core->modules,ns->module_index))){
pa_log_info("unloading null sink '%s'", ns->name);
- pa_module_unload(core, module, FALSE);
+ pa_module_unload(core, module, false);
}
pa_xfree(ns->name);
return (char *)zone;
}
-pa_bool_t pa_utils_set_stream_routing_properties(pa_proplist *pl,
+bool pa_utils_set_stream_routing_properties(pa_proplist *pl,
int styp,
void *target)
{
pa_proplist_sets(pl, PA_PROP_ROUTING_METHOD , method) < 0 )
{
pa_log("failed to set some stream property");
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
-pa_bool_t pa_utils_unset_stream_routing_properties(pa_proplist *pl)
+bool pa_utils_unset_stream_routing_properties(pa_proplist *pl)
{
pa_assert(pl);
pa_proplist_unset(pl, PA_PROP_ROUTING_METHOD ) < 0 )
{
pa_log("failed to unset some stream property");
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
void pa_utils_set_stream_routing_method_property(pa_proplist *pl,
- pa_bool_t explicit)
+ bool explicit)
{
const char *method = explicit ? PA_ROUTING_EXPLICIT : PA_ROUTING_DEFAULT;
}
}
-pa_bool_t pa_utils_stream_has_default_route(pa_proplist *pl)
+bool pa_utils_stream_has_default_route(pa_proplist *pl)
{
const char *method;
method = pa_proplist_gets(pl, PA_PROP_ROUTING_METHOD);
if (method && pa_streq(method, PA_ROUTING_DEFAULT))
- return TRUE;
+ return true;
- return FALSE;
+ return false;
}
int pa_utils_get_stream_class(pa_proplist *pl)
}
-pa_bool_t pa_utils_set_resource_properties(pa_proplist *pl,
+bool pa_utils_set_resource_properties(pa_proplist *pl,
pa_nodeset_resdef *resdef)
{
char priority[32];
pa_assert(pl);
if (!resdef)
- return FALSE;
+ return false;
snprintf(priority , sizeof(priority) , "%d", resdef->priority );
snprintf(rsetflags , sizeof(rsetflags) , "%d", resdef->flags.rset );
pa_proplist_sets(pl, PA_PROP_RESOURCE_AUDIO_FLAGS, audioflags) < 0 )
{
pa_log("failed to set some resource property");
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
-pa_bool_t pa_utils_unset_resource_properties(pa_proplist *pl)
+bool pa_utils_unset_resource_properties(pa_proplist *pl)
{
pa_assert(pl);
pa_proplist_unset(pl, PA_PROP_RESOURCE_AUDIO_FLAGS) < 0 )
{
pa_log("failed to unset some resource property");
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
pa_nodeset_resdef *pa_utils_get_resource_properties(pa_proplist *pl,
}
-static pa_bool_t get_unsigned_property(pa_proplist *pl,
+static bool get_unsigned_property(pa_proplist *pl,
const char *name,
uint32_t *value)
{
if (!(str = pa_proplist_gets(pl, name))) {
*value = 0;
- return FALSE;
+ return false;
}
*value = strtoul(str, &e, 10);
if (e == str || *e) {
*value = 0;
- return FALSE;
+ return false;
}
- return TRUE;
+ return true;
}
char *pa_utils_get_zone(pa_proplist *);
-pa_bool_t pa_utils_set_stream_routing_properties(pa_proplist *, int, void *);
-pa_bool_t pa_utils_unset_stream_routing_properties(pa_proplist *);
-void pa_utils_set_stream_routing_method_property(pa_proplist *,pa_bool_t);
-pa_bool_t pa_utils_stream_has_default_route(pa_proplist *);
+bool pa_utils_set_stream_routing_properties(pa_proplist *, int, void *);
+bool pa_utils_unset_stream_routing_properties(pa_proplist *);
+void pa_utils_set_stream_routing_method_property(pa_proplist *,bool);
+bool pa_utils_stream_has_default_route(pa_proplist *);
int pa_utils_get_stream_class(pa_proplist *);
#ifdef foomurphyuserdatafoo /* argh ... */
-pa_bool_t pa_utils_set_resource_properties(pa_proplist *, pa_nodeset_resdef *);
-pa_bool_t pa_utils_unset_resource_properties(pa_proplist *);
+bool pa_utils_set_resource_properties(pa_proplist *, pa_nodeset_resdef *);
+bool pa_utils_unset_resource_properties(pa_proplist *);
pa_nodeset_resdef *pa_utils_get_resource_properties(pa_proplist *,
pa_nodeset_resdef *);
return zs;
}
-
void pa_zoneset_done(struct userdata *u)
{
pa_zoneset *zs;
- int i;
+ void *state;
+ mir_zone *zone;
if (u && (zs = u->zoneset)) {
- pa_hashmap_free(zs->zones.hash, free_zone_cb);
+
+ PA_HASHMAP_FOREACH(zone, zs->zones.hash, state) {
+ pa_xfree((void *)zone->name);
+ }
+
+ pa_hashmap_free(zs->zones.hash);
free(zs);
}
zone->name = pa_xstrdup(name);
zone->index = index;
- if (pa_hashmap_put(zs->zones.hash, zone->name, zone))
+ if (pa_hashmap_put(zs->zones.hash, (void *)zone->name, zone))
return -1;
zs->zones.index[index] = zone;
projects / profile / ivi / pulseaudio-module-murphy-ivi.git / commitdiff