mirrors/pulseaudio
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/pulseaudio/pulseaudio.git synced 2025-10-29 05:40:23 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove pa_bool_t and replace it with bool.

Browse source 
commands used for this (executed from the pulseaudio/src directory):
    find . -regex '\(.*\.[hc]\|.*\.cc\|.*\.m4\)' -not -name 'macro.h' \
        -a -not -name 'reserve.[ch]' -a -not -name 'reserve-monitor.[ch]' \
        -a -not -name 'glib-mainloop.c' -a -not -name 'gkt-test.c' \
        -a -not -name 'glib-mainloop.c' -a -not -name 'gkt-test.c' \
        -a -not -name 'poll-win32.c' -a -not -name 'thread-win32.c' \
        -a -not -name 'dllmain.c' -a -not -name 'gconf-helper.c' \
        -exec sed -i -e 's/\bpa_bool_t\b/bool/g' \
        -e 's/\bTRUE\b/true/g' -e 's/\bFALSE\b/false/g' {} \;

and:
    sed -i -e '181,194!s/\bpa_bool_t\b/bool/' \
        -e '181,194!s/\bTRUE\b/true/' -e \
        '181,194!s/\bFALSE\b/false/' pulsecore/macro.h
This commit is contained in:
poljar (Damir Jelić) 2013-06-27 19:28:09 +02:00 • committed by Tanu Kaskinen
parent e9822bfcb0
commit d806b19714
288 changed files with 3360 additions and 3360 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/daemon/cmdline.c
View file

@ -215,7 +215,7 @@ int pa_cmdline_parse(pa_daemon_conf *conf, int argc, char *const argv [], int *d
case ARG_START:
conf->cmd = PA_CMD_START;
conf->daemonize = TRUE;
conf->daemonize = true;
break;
case ARG_CHECK:
@ -318,7 +318,7 @@ int pa_cmdline_parse(pa_daemon_conf *conf, int argc, char *const argv [], int *d
break;
case 'n':
conf->load_default_script_file = FALSE;
conf->load_default_script_file = false;
break;
case ARG_LOG_TARGET:

6
src/daemon/cpulimit.c
View file

@ -80,7 +80,7 @@ static pa_io_event *io_event = NULL;
static struct sigaction sigaction_prev;
/* Nonzero after pa_cpu_limit_init() */
static pa_bool_t installed = FALSE;
static bool installed = false;
/* The current state of operation */
static enum {
@ -209,7 +209,7 @@ int pa_cpu_limit_init(pa_mainloop_api *m) {
return -1;
}
installed = TRUE;
installed = true;
reset_cpu_time(CPUTIME_INTERVAL_SOFT);
@ -230,7 +230,7 @@ void pa_cpu_limit_done(void) {
if (installed) {
pa_assert_se(sigaction(SIGXCPU, &sigaction_prev, NULL) >= 0);
installed = FALSE;
installed = false;
}
}

76
src/daemon/daemon-conf.c
View file

@ -62,39 +62,39 @@
static const pa_daemon_conf default_conf = {
.cmd = PA_CMD_DAEMON,
.daemonize = FALSE,
.fail = TRUE,
.high_priority = TRUE,
.daemonize = false,
.fail = true,
.high_priority = true,
.nice_level = -11,
.realtime_scheduling = TRUE,
.realtime_scheduling = true,
.realtime_priority = 5, /* Half of JACK's default rtprio */
.disallow_module_loading = FALSE,
.disallow_exit = FALSE,
.flat_volumes = TRUE,
.disallow_module_loading = false,
.disallow_exit = false,
.flat_volumes = true,
.exit_idle_time = 20,
.scache_idle_time = 20,
.script_commands = NULL,
.dl_search_path = NULL,
.load_default_script_file = TRUE,
.load_default_script_file = true,
.default_script_file = NULL,
.log_target = NULL,
.log_level = PA_LOG_NOTICE,
.log_backtrace = 0,
.log_meta = FALSE,
.log_time = FALSE,
.log_meta = false,
.log_time = false,
.resample_method = PA_RESAMPLER_AUTO,
.disable_remixing = FALSE,
.disable_lfe_remixing = TRUE,
.disable_remixing = false,
.disable_lfe_remixing = true,
.config_file = NULL,
.use_pid_file = TRUE,
.system_instance = FALSE,
.use_pid_file = true,
.system_instance = false,
#ifdef HAVE_DBUS
.local_server_type = PA_SERVER_TYPE_UNSET, /* The actual default is _USER, but we have to detect when the user doesn't specify this option. */
#endif
.no_cpu_limit = TRUE,
.disable_shm = FALSE,
.lock_memory = FALSE,
.deferred_volume = TRUE,
.no_cpu_limit = true,
.disable_shm = false,
.lock_memory = false,
.deferred_volume = true,
.default_n_fragments = 4,
.default_fragment_size_msec = 25,
.deferred_volume_safety_margin_usec = 8000,
@ -104,42 +104,42 @@ static const pa_daemon_conf default_conf = {
.default_channel_map = { .channels = 2, .map = { PA_CHANNEL_POSITION_LEFT, PA_CHANNEL_POSITION_RIGHT } },
.shm_size = 0
#ifdef HAVE_SYS_RESOURCE_H
,.rlimit_fsize = { .value = 0, .is_set = FALSE },
.rlimit_data = { .value = 0, .is_set = FALSE },
.rlimit_stack = { .value = 0, .is_set = FALSE },
.rlimit_core = { .value = 0, .is_set = FALSE }
,.rlimit_fsize = { .value = 0, .is_set = false },
.rlimit_data = { .value = 0, .is_set = false },
.rlimit_stack = { .value = 0, .is_set = false },
.rlimit_core = { .value = 0, .is_set = false }
#ifdef RLIMIT_RSS
,.rlimit_rss = { .value = 0, .is_set = FALSE }
,.rlimit_rss = { .value = 0, .is_set = false }
#endif
#ifdef RLIMIT_NPROC
,.rlimit_nproc = { .value = 0, .is_set = FALSE }
,.rlimit_nproc = { .value = 0, .is_set = false }
#endif
#ifdef RLIMIT_NOFILE
,.rlimit_nofile = { .value = 256, .is_set = TRUE }
,.rlimit_nofile = { .value = 256, .is_set = true }
#endif
#ifdef RLIMIT_MEMLOCK
,.rlimit_memlock = { .value = 0, .is_set = FALSE }
,.rlimit_memlock = { .value = 0, .is_set = false }
#endif
#ifdef RLIMIT_AS
,.rlimit_as = { .value = 0, .is_set = FALSE }
,.rlimit_as = { .value = 0, .is_set = false }
#endif
#ifdef RLIMIT_LOCKS
,.rlimit_locks = { .value = 0, .is_set = FALSE }
,.rlimit_locks = { .value = 0, .is_set = false }
#endif
#ifdef RLIMIT_SIGPENDING
,.rlimit_sigpending = { .value = 0, .is_set = FALSE }
,.rlimit_sigpending = { .value = 0, .is_set = false }
#endif
#ifdef RLIMIT_MSGQUEUE
,.rlimit_msgqueue = { .value = 0, .is_set = FALSE }
,.rlimit_msgqueue = { .value = 0, .is_set = false }
#endif
#ifdef RLIMIT_NICE
,.rlimit_nice = { .value = 31, .is_set = TRUE } /* nice level of -11 */
,.rlimit_nice = { .value = 31, .is_set = true } /* nice level of -11 */
#endif
#ifdef RLIMIT_RTPRIO
,.rlimit_rtprio = { .value = 9, .is_set = TRUE } /* One below JACK's default for the server */
,.rlimit_rtprio = { .value = 9, .is_set = true } /* One below JACK's default for the server */
#endif
#ifdef RLIMIT_RTTIME
,.rlimit_rttime = { .value = PA_USEC_PER_SEC, .is_set = TRUE }
,.rlimit_rttime = { .value = PA_USEC_PER_SEC, .is_set = true }
#endif
#endif
};
@ -375,8 +375,8 @@ static int parse_alternate_sample_rate(pa_config_parser_state *state) {
struct channel_conf_info {
pa_daemon_conf *conf;
pa_bool_t default_sample_spec_set;
pa_bool_t default_channel_map_set;
bool default_sample_spec_set;
bool default_channel_map_set;
};
static int parse_sample_channels(pa_config_parser_state *state) {
@ -393,7 +393,7 @@ static int parse_sample_channels(pa_config_parser_state *state) {
}
i->conf->default_sample_spec.channels = (uint8_t) n;
i->default_sample_spec_set = TRUE;
i->default_sample_spec_set = true;
return 0;
}
@ -409,7 +409,7 @@ static int parse_channel_map(pa_config_parser_state *state) {
return -1;
}
i->default_channel_map_set = TRUE;
i->default_channel_map_set = true;
return 0;
}
@ -616,7 +616,7 @@ int pa_daemon_conf_load(pa_daemon_conf *c, const char *filename) {
goto finish;
}
ci.default_channel_map_set = ci.default_sample_spec_set = FALSE;
ci.default_channel_map_set = ci.default_sample_spec_set = false;
ci.conf = c;
r = f ? pa_config_parse(c->config_file, f, table, NULL, NULL) : 0;

4
src/daemon/daemon-conf.h
View file

@ -52,14 +52,14 @@ typedef enum pa_daemon_conf_cmd {
#ifdef HAVE_SYS_RESOURCE_H
typedef struct pa_rlimit {
rlim_t value;
pa_bool_t is_set;
bool is_set;
} pa_rlimit;
#endif
/* A structure containing configuration data for the PulseAudio server . */
typedef struct pa_daemon_conf {
pa_daemon_conf_cmd_t cmd;
pa_bool_t daemonize,
bool daemonize,
fail,
high_priority,
realtime_scheduling,

38
src/daemon/main.c
View file

@ -202,12 +202,12 @@ static int change_user(void) {
if (!pa_streq(pw->pw_dir, PA_SYSTEM_RUNTIME_PATH))
pa_log_warn(_("Home directory of user '%s' is not '%s', ignoring."), PA_SYSTEM_USER, PA_SYSTEM_RUNTIME_PATH);
if (pa_make_secure_dir(PA_SYSTEM_RUNTIME_PATH, 0755, pw->pw_uid, gr->gr_gid, TRUE) < 0) {
if (pa_make_secure_dir(PA_SYSTEM_RUNTIME_PATH, 0755, pw->pw_uid, gr->gr_gid, true) < 0) {
pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_RUNTIME_PATH, pa_cstrerror(errno));
return -1;
}
if (pa_make_secure_dir(PA_SYSTEM_STATE_PATH, 0700, pw->pw_uid, gr->gr_gid, TRUE) < 0) {
if (pa_make_secure_dir(PA_SYSTEM_STATE_PATH, 0700, pw->pw_uid, gr->gr_gid, true) < 0) {
pa_log(_("Failed to create '%s': %s"), PA_SYSTEM_STATE_PATH, pa_cstrerror(errno));
return -1;
}
@ -402,8 +402,8 @@ int main(int argc, char *argv[]) {
char *s;
char *configured_address;
int r = 0, retval = 1, d = 0;
pa_bool_t valid_pid_file = FALSE;
pa_bool_t ltdl_init = FALSE;
bool valid_pid_file = false;
bool ltdl_init = false;
int passed_fd = -1;
const char *e;
#ifdef HAVE_FORK
@ -415,12 +415,12 @@ int main(int argc, char *argv[]) {
struct timeval win32_tv;
#endif
int autospawn_fd = -1;
pa_bool_t autospawn_locked = FALSE;
bool autospawn_locked = false;
#ifdef HAVE_DBUS
pa_dbusobj_server_lookup *server_lookup = NULL; /* /org/pulseaudio/server_lookup */
pa_dbus_connection *lookup_service_bus = NULL; /* Always the user bus. */
pa_dbus_connection *server_bus = NULL; /* The bus where we reserve org.pulseaudio.Server, either the user or the system bus. */
pa_bool_t start_server;
bool start_server;
#endif
pa_log_set_ident("pulseaudio");
@ -522,10 +522,10 @@ int main(int argc, char *argv[]) {
break;
case PA_SERVER_TYPE_USER:
case PA_SERVER_TYPE_NONE:
conf->system_instance = FALSE;
conf->system_instance = false;
break;
case PA_SERVER_TYPE_SYSTEM:
conf->system_instance = TRUE;
conf->system_instance = true;
break;
default:
pa_assert_not_reached();
@ -535,13 +535,13 @@ int main(int argc, char *argv[]) {
if (!start_server && conf->local_server_type == PA_SERVER_TYPE_SYSTEM) {
pa_log_notice(_("System mode refused for non-root user. Only starting the D-Bus server lookup service."));
conf->system_instance = FALSE;
conf->system_instance = false;
}
#endif
LTDL_SET_PRELOADED_SYMBOLS();
pa_ltdl_init();
ltdl_init = TRUE;
ltdl_init = true;
if (conf->dl_search_path)
lt_dlsetsearchpath(conf->dl_search_path);
@ -685,7 +685,7 @@ int main(int argc, char *argv[]) {
* recover (i.e. autospawn) from a crash.
*/
char *ufn;
pa_bool_t start_anyway = FALSE;
bool start_anyway = false;
if ((ufn = pa_runtime_path(PA_NATIVE_DEFAULT_UNIX_SOCKET))) {
char *id;
@ -730,7 +730,7 @@ int main(int argc, char *argv[]) {
if (conf->system_instance && !conf->disable_shm) {
pa_log_notice(_("Running in system mode, forcibly disabling SHM mode!"));
conf->disable_shm = TRUE;
conf->disable_shm = true;
}
if (conf->system_instance && conf->exit_idle_time >= 0) {
@ -748,12 +748,12 @@ int main(int argc, char *argv[]) {
goto finish;
}
if ((pa_autospawn_lock_acquire(TRUE) < 0)) {
if ((pa_autospawn_lock_acquire(true) < 0)) {
pa_log("Failed to acquire autospawn lock");
goto finish;
}
autospawn_locked = TRUE;
autospawn_locked = true;
}
if (conf->daemonize) {
@ -806,9 +806,9 @@ int main(int argc, char *argv[]) {
* to close it in the child */
pa_autospawn_lock_release();
pa_autospawn_lock_done(TRUE);
pa_autospawn_lock_done(true);
autospawn_locked = FALSE;
autospawn_locked = false;
autospawn_fd = -1;
}
@ -992,7 +992,7 @@ int main(int argc, char *argv[]) {
goto finish;
}
valid_pid_file = TRUE;
valid_pid_file = true;
}
pa_disable_sigpipe();
@ -1110,7 +1110,7 @@ int main(int argc, char *argv[]) {
* any modules to be loaded. We haven't loaded any so far, so one might
* think there's no way to contact the server, but receiving certain
* signals could still cause modules to load. */
conf->disallow_module_loading = TRUE;
conf->disallow_module_loading = true;
}
#endif
@ -1161,7 +1161,7 @@ finish:
if (autospawn_locked)
pa_autospawn_lock_release();
pa_autospawn_lock_done(FALSE);
pa_autospawn_lock_done(false);
}
#ifdef OS_IS_WIN32

8
src/daemon/server-lookup.c
View file

@ -42,7 +42,7 @@
struct pa_dbusobj_server_lookup {
pa_core *core;
pa_dbus_connection *conn;
pa_bool_t path_registered;
bool path_registered;
};
static const char introspection[] =
@ -82,7 +82,7 @@ static void unregister_cb(DBusConnection *conn, void *user_data) {
pa_assert(sl);
pa_assert(sl->path_registered);
sl->path_registered = FALSE;
sl->path_registered = false;
}
static DBusHandlerResult handle_introspect(DBusConnection *conn, DBusMessage *msg, pa_dbusobj_server_lookup *sl) {
@ -482,7 +482,7 @@ pa_dbusobj_server_lookup *pa_dbusobj_server_lookup_new(pa_core *c) {
sl = pa_xnew(pa_dbusobj_server_lookup, 1);
sl->core = c;
sl->path_registered = FALSE;
sl->path_registered = false;
if (!(sl->conn = pa_dbus_bus_get(c, DBUS_BUS_SESSION, &error)) || dbus_error_is_set(&error)) {
pa_log_warn("Unable to contact D-Bus: %s: %s", error.name, error.message);
@ -494,7 +494,7 @@ pa_dbusobj_server_lookup *pa_dbusobj_server_lookup_new(pa_core *c) {
goto fail;
}
sl->path_registered = TRUE;
sl->path_registered = true;
return sl;

200
src/modules/alsa/alsa-mixer.c
View file

@ -83,7 +83,7 @@ struct pa_alsa_fdlist {
pa_defer_event *defer;
pa_io_event **ios;
pa_bool_t polled;
bool polled;
void (*cb)(void *userdata);
void *userdata;
@ -105,7 +105,7 @@ static void io_cb(pa_mainloop_api *a, pa_io_event *e, int fd, pa_io_event_flags_
if (fdl->polled)
return;
fdl->polled = TRUE;
fdl->polled = true;
memcpy(fdl->work_fds, fdl->fds, sizeof(struct pollfd) * fdl->num_fds);
@ -189,7 +189,7 @@ static void defer_cb(pa_mainloop_api *a, pa_defer_event *e, void *userdata) {
return;
}
fdl->polled = FALSE;
fdl->polled = false;
if (memcmp(fdl->fds, fdl->work_fds, sizeof(struct pollfd) * num_fds) == 0)
return;
@ -559,7 +559,7 @@ static pa_volume_t from_alsa_volume(long v, long min, long max) {
snd_mixer_selem_id_alloca(&(sid)); \
snd_mixer_selem_id_set_name((sid), (name)); \
snd_mixer_selem_id_set_index((sid), 0); \
} while(FALSE)
} while(false)
static int element_get_volume(pa_alsa_element *e, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v) {
snd_mixer_selem_id_t *sid;
@ -729,7 +729,7 @@ int pa_alsa_path_get_volume(pa_alsa_path *p, snd_mixer_t *m, const pa_channel_ma
return 0;
}
static int element_get_switch(pa_alsa_element *e, snd_mixer_t *m, pa_bool_t *b) {
static int element_get_switch(pa_alsa_element *e, snd_mixer_t *m, bool *b) {
snd_mixer_selem_id_t *sid;
snd_mixer_elem_t *me;
snd_mixer_selem_channel_id_t c;
@ -766,16 +766,16 @@ static int element_get_switch(pa_alsa_element *e, snd_mixer_t *m, pa_bool_t *b)
continue;
if (!value) {
*b = FALSE;
*b = false;
return 0;
}
}
*b = TRUE;
*b = true;
return 0;
}
int pa_alsa_path_get_mute(pa_alsa_path *p, snd_mixer_t *m, pa_bool_t *muted) {
int pa_alsa_path_get_mute(pa_alsa_path *p, snd_mixer_t *m, bool *muted) {
pa_alsa_element *e;
pa_assert(m);
@ -786,7 +786,7 @@ int pa_alsa_path_get_mute(pa_alsa_path *p, snd_mixer_t *m, pa_bool_t *muted) {
return -1;
PA_LLIST_FOREACH(e, p->elements) {
pa_bool_t b;
bool b;
if (e->switch_use != PA_ALSA_SWITCH_MUTE)
continue;
@ -795,12 +795,12 @@ int pa_alsa_path_get_mute(pa_alsa_path *p, snd_mixer_t *m, pa_bool_t *muted) {
return -1;
if (!b) {
*muted = TRUE;
*muted = true;
return 0;
}
}
*muted = FALSE;
*muted = false;
return 0;
}
@ -887,7 +887,7 @@ static int element_get_nearest_alsa_dB(snd_mixer_elem_t *me, snd_mixer_selem_cha
return r;
}
static int element_set_volume(pa_alsa_element *e, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v, pa_bool_t deferred_volume, pa_bool_t write_to_hw) {
static int element_set_volume(pa_alsa_element *e, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v, bool deferred_volume, bool write_to_hw) {
snd_mixer_selem_id_t *sid;
pa_cvolume rv;
@ -913,11 +913,11 @@ static int element_set_volume(pa_alsa_element *e, snd_mixer_t *m, const pa_chann
for (c = 0; c <= SND_MIXER_SCHN_LAST; c++) {
int r;
pa_volume_t f = PA_VOLUME_MUTED;
pa_bool_t found = FALSE;
bool found = false;
for (k = 0; k < cm->channels; k++)
if (e->masks[c][e->n_channels-1] & PA_CHANNEL_POSITION_MASK(cm->map[k])) {
found = TRUE;
found = true;
if (v->values[k] > f)
f = v->values[k];
}
@ -1047,7 +1047,7 @@ static int element_set_volume(pa_alsa_element *e, snd_mixer_t *m, const pa_chann
return 0;
}
int pa_alsa_path_set_volume(pa_alsa_path *p, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v, pa_bool_t deferred_volume, pa_bool_t write_to_hw) {
int pa_alsa_path_set_volume(pa_alsa_path *p, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v, bool deferred_volume, bool write_to_hw) {
pa_alsa_element *e;
pa_cvolume rv;
@ -1088,7 +1088,7 @@ int pa_alsa_path_set_volume(pa_alsa_path *p, snd_mixer_t *m, const pa_channel_ma
return 0;
}
static int element_set_switch(pa_alsa_element *e, snd_mixer_t *m, pa_bool_t b) {
static int element_set_switch(pa_alsa_element *e, snd_mixer_t *m, bool b) {
snd_mixer_elem_t *me;
snd_mixer_selem_id_t *sid;
int r;
@ -1113,7 +1113,7 @@ static int element_set_switch(pa_alsa_element *e, snd_mixer_t *m, pa_bool_t b) {
return r;
}
int pa_alsa_path_set_mute(pa_alsa_path *p, snd_mixer_t *m, pa_bool_t muted) {
int pa_alsa_path_set_mute(pa_alsa_path *p, snd_mixer_t *m, bool muted) {
pa_alsa_element *e;
pa_assert(m);
@ -1142,7 +1142,7 @@ static int element_set_constant_volume(pa_alsa_element *e, snd_mixer_t *m) {
snd_mixer_selem_id_t *sid = NULL;
int r = 0;
long volume = -1;
pa_bool_t volume_set = FALSE;
bool volume_set = false;
pa_assert(m);
pa_assert(e);
@ -1156,7 +1156,7 @@ static int element_set_constant_volume(pa_alsa_element *e, snd_mixer_t *m) {
switch (e->volume_use) {
case PA_ALSA_VOLUME_OFF:
volume = e->min_volume;
volume_set = TRUE;
volume_set = true;
break;
case PA_ALSA_VOLUME_ZERO:
@ -1164,13 +1164,13 @@ static int element_set_constant_volume(pa_alsa_element *e, snd_mixer_t *m) {
long dB = 0;
volume = decibel_fix_get_step(e->db_fix, &dB, (e->direction == PA_ALSA_DIRECTION_OUTPUT ? +1 : -1));
volume_set = TRUE;
volume_set = true;
}
break;
case PA_ALSA_VOLUME_CONSTANT:
volume = e->constant_volume;
volume_set = TRUE;
volume_set = true;
break;
default:
@ -1217,7 +1217,7 @@ int pa_alsa_path_select(pa_alsa_path *p, pa_alsa_setting *s, snd_mixer_t *m, boo
* selecting a path, so we ignore the return value.
* element_set_switch() will print a warning anyway, so this
* won't be a silent failure either. */
(void) element_set_switch(e, m, FALSE);
(void) element_set_switch(e, m, false);
}
}
@ -1225,11 +1225,11 @@ int pa_alsa_path_select(pa_alsa_path *p, pa_alsa_setting *s, snd_mixer_t *m, boo
switch (e->switch_use) {
case PA_ALSA_SWITCH_OFF:
r = element_set_switch(e, m, FALSE);
r = element_set_switch(e, m, false);
break;
case PA_ALSA_SWITCH_ON:
r = element_set_switch(e, m, TRUE);
r = element_set_switch(e, m, true);
break;
case PA_ALSA_SWITCH_MUTE:
@ -1276,9 +1276,9 @@ int pa_alsa_path_select(pa_alsa_path *p, pa_alsa_setting *s, snd_mixer_t *m, boo
}
static int check_required(pa_alsa_element *e, snd_mixer_elem_t *me) {
pa_bool_t has_switch;
pa_bool_t has_enumeration;
pa_bool_t has_volume;
bool has_switch;
bool has_enumeration;
bool has_volume;
pa_assert(e);
pa_assert(me);
@ -1401,7 +1401,7 @@ static int element_probe(pa_alsa_element *e, snd_mixer_t *m) {
}
if (e->switch_use != PA_ALSA_SWITCH_IGNORE)
e->direction_try_other = FALSE;
e->direction_try_other = false;
}
if (e->volume_use != PA_ALSA_VOLUME_IGNORE) {
@ -1429,7 +1429,7 @@ static int element_probe(pa_alsa_element *e, snd_mixer_t *m) {
long min_dB = 0, max_dB = 0;
int r;
e->direction_try_other = FALSE;
e->direction_try_other = false;
if (e->direction == PA_ALSA_DIRECTION_OUTPUT)
r = snd_mixer_selem_get_playback_volume_range(me, &e->min_volume, &e->max_volume);
@ -1452,7 +1452,7 @@ static int element_probe(pa_alsa_element *e, snd_mixer_t *m) {
e->volume_use = PA_ALSA_VOLUME_IGNORE;
} else {
pa_bool_t is_mono;
bool is_mono;
pa_channel_position_t p;
if (e->db_fix &&
@ -1468,7 +1468,7 @@ static int element_probe(pa_alsa_element *e, snd_mixer_t *m) {
}
if (e->db_fix) {
e->has_dB = TRUE;
e->has_dB = true;
e->min_volume = e->db_fix->min_step;
e->max_volume = e->db_fix->max_step;
min_dB = e->db_fix->db_values[0];
@ -1527,7 +1527,7 @@ static int element_probe(pa_alsa_element *e, snd_mixer_t *m) {
if (min_dB >= max_dB) {
pa_assert(!e->db_fix);
pa_log_warn("Your kernel driver is broken: it reports a volume range from %0.2f dB to %0.2f dB which makes no sense.", e->min_dB, e->max_dB);
e->has_dB = FALSE;
e->has_dB = false;
}
}
@ -1553,7 +1553,7 @@ static int element_probe(pa_alsa_element *e, snd_mixer_t *m) {
if (r < 0) {
pa_log_warn("Failed to get dB value of %s: %s", e->alsa_name, pa_alsa_strerror(r));
e->has_dB = FALSE;
e->has_dB = false;
} else
e->max_dB = ((double) max_dB) / 100.0;
}
@ -1617,7 +1617,7 @@ static int element_probe(pa_alsa_element *e, snd_mixer_t *m) {
if (!e->override_map) {
for (p = PA_CHANNEL_POSITION_FRONT_LEFT; p < PA_CHANNEL_POSITION_MAX; p++) {
pa_bool_t has_channel;
bool has_channel;
if (alsa_channel_ids[p] == SND_MIXER_SCHN_UNKNOWN)
continue;
@ -1692,7 +1692,7 @@ static int jack_probe(pa_alsa_jack *j, snd_hctl_t *h) {
if (j->required_absent != PA_ALSA_REQUIRED_IGNORE)
return -1;
if (j->required_any != PA_ALSA_REQUIRED_IGNORE)
j->path->req_any_present = TRUE;
j->path->req_any_present = true;
} else {
if (j->required != PA_ALSA_REQUIRED_IGNORE)
return -1;
@ -1701,7 +1701,7 @@ static int jack_probe(pa_alsa_jack *j, snd_hctl_t *h) {
return 0;
}
static pa_alsa_element* element_get(pa_alsa_path *p, const char *section, pa_bool_t prefixed) {
static pa_alsa_element* element_get(pa_alsa_path *p, const char *section, bool prefixed) {
pa_alsa_element *e;
pa_assert(p);
@ -1790,7 +1790,7 @@ static pa_alsa_option* option_get(pa_alsa_path *p, const char *section) {
return p->last_option;
}
pa_assert_se(e = element_get(p, en, FALSE));
pa_assert_se(e = element_get(p, en, false));
pa_xfree(en);
PA_LLIST_FOREACH(o, e->options)
@ -1820,7 +1820,7 @@ static int element_parse_switch(pa_config_parser_state *state) {
p = state->userdata;
if (!(e = element_get(p, state->section, TRUE))) {
if (!(e = element_get(p, state->section, true))) {
pa_log("[%s:%u] Switch makes no sense in '%s'", state->filename, state->lineno, state->section);
return -1;
}
@ -1851,7 +1851,7 @@ static int element_parse_volume(pa_config_parser_state *state) {
p = state->userdata;
if (!(e = element_get(p, state->section, TRUE))) {
if (!(e = element_get(p, state->section, true))) {
pa_log("[%s:%u] Volume makes no sense in '%s'", state->filename, state->lineno, state->section);
return -1;
}
@ -1887,7 +1887,7 @@ static int element_parse_enumeration(pa_config_parser_state *state) {
p = state->userdata;
if (!(e = element_get(p, state->section, TRUE))) {
if (!(e = element_get(p, state->section, true))) {
pa_log("[%s:%u] Enumeration makes no sense in '%s'", state->filename, state->lineno, state->section);
return -1;
}
@ -1957,7 +1957,7 @@ static int element_parse_required(pa_config_parser_state *state) {
p = state->userdata;
e = element_get(p, state->section, TRUE);
e = element_get(p, state->section, true);
o = option_get(p, state->section);
j = jack_get(p, state->section);
if (!e && !o && !j) {
@ -2023,7 +2023,7 @@ static int element_parse_direction(pa_config_parser_state *state) {
p = state->userdata;
if (!(e = element_get(p, state->section, TRUE))) {
if (!(e = element_get(p, state->section, true))) {
pa_log("[%s:%u] Direction makes no sense in '%s'", state->filename, state->lineno, state->section);
return -1;
}
@ -2049,7 +2049,7 @@ static int element_parse_direction_try_other(pa_config_parser_state *state) {
p = state->userdata;
if (!(e = element_get(p, state->section, TRUE))) {
if (!(e = element_get(p, state->section, true))) {
pa_log("[%s:%u] Direction makes no sense in '%s'", state->filename, state->lineno, state->section);
return -1;
}
@ -2072,7 +2072,7 @@ static int element_parse_volume_limit(pa_config_parser_state *state) {
p = state->userdata;
if (!(e = element_get(p, state->section, TRUE))) {
if (!(e = element_get(p, state->section, true))) {
pa_log("[%s:%u] volume-limit makes no sense in '%s'", state->filename, state->lineno, state->section);
return -1;
}
@ -2130,7 +2130,7 @@ static int element_parse_override_map(pa_config_parser_state *state) {
p = state->userdata;
if (!(e = element_get(p, state->section, TRUE))) {
if (!(e = element_get(p, state->section, true))) {
pa_log("[%s:%u] Override map makes no sense in '%s'", state->filename, state->lineno, state->section);
return -1;
}
@ -2158,7 +2158,7 @@ static int element_parse_override_map(pa_config_parser_state *state) {
pa_xfree(n);
}
e->override_map = TRUE;
e->override_map = true;
return 0;
}
@ -2482,7 +2482,7 @@ pa_alsa_path *pa_alsa_path_synthesize(const char *element, pa_alsa_direction_t d
return p;
}
static pa_bool_t element_drop_unsupported(pa_alsa_element *e) {
static bool element_drop_unsupported(pa_alsa_element *e) {
pa_alsa_option *o, *n;
pa_assert(e);
@ -2558,7 +2558,7 @@ static void path_make_options_unique(pa_alsa_path *p) {
}
}
static pa_bool_t element_create_settings(pa_alsa_element *e, pa_alsa_setting *template) {
static bool element_create_settings(pa_alsa_element *e, pa_alsa_setting *template) {
pa_alsa_option *o;
for (; e; e = e->next)
@ -2567,7 +2567,7 @@ static pa_bool_t element_create_settings(pa_alsa_element *e, pa_alsa_setting *te
break;
if (!e)
return FALSE;
return false;
for (o = e->options; o; o = o->next) {
pa_alsa_setting *s;
@ -2605,7 +2605,7 @@ static pa_bool_t element_create_settings(pa_alsa_element *e, pa_alsa_setting *te
}
}
return TRUE;
return true;
}
static void path_create_settings(pa_alsa_path *p) {
@ -2614,7 +2614,7 @@ static void path_create_settings(pa_alsa_path *p) {
element_create_settings(p->elements, NULL);
}
int pa_alsa_path_probe(pa_alsa_path *p, snd_mixer_t *m, snd_hctl_t *hctl, pa_bool_t ignore_dB) {
int pa_alsa_path_probe(pa_alsa_path *p, snd_mixer_t *m, snd_hctl_t *hctl, bool ignore_dB) {
pa_alsa_element *e;
pa_alsa_jack *j;
double min_dB[PA_CHANNEL_POSITION_MAX], max_dB[PA_CHANNEL_POSITION_MAX];
@ -2626,7 +2626,7 @@ int pa_alsa_path_probe(pa_alsa_path *p, snd_mixer_t *m, snd_hctl_t *hctl, pa_boo
if (p->probed)
return p->supported ? 0 : -1;
p->probed = TRUE;
p->probed = true;
pa_zero(min_dB);
pa_zero(max_dB);
@ -2635,7 +2635,7 @@ int pa_alsa_path_probe(pa_alsa_path *p, snd_mixer_t *m, snd_hctl_t *hctl, pa_boo
PA_LLIST_FOREACH(j, p->jacks) {
if (jack_probe(j, hctl) < 0) {
p->supported = FALSE;
p->supported = false;
pa_log_debug("Probe of jack '%s' failed.", j->alsa_name);
return -1;
}
@ -2644,14 +2644,14 @@ int pa_alsa_path_probe(pa_alsa_path *p, snd_mixer_t *m, snd_hctl_t *hctl, pa_boo
PA_LLIST_FOREACH(e, p->elements) {
if (element_probe(e, m) < 0) {
p->supported = FALSE;
p->supported = false;
pa_log_debug("Probe of element '%s' failed.", e->alsa_name);
return -1;
}
pa_log_debug("Probe of element '%s' succeeded (volume=%d, switch=%d, enumeration=%d).", e->alsa_name, e->volume_use, e->switch_use, e->enumeration_use);
if (ignore_dB)
e->has_dB = FALSE;
e->has_dB = false;
if (e->volume_use == PA_ALSA_VOLUME_MERGE) {
@ -2669,7 +2669,7 @@ int pa_alsa_path_probe(pa_alsa_path *p, snd_mixer_t *m, snd_hctl_t *hctl, pa_boo
path_volume_channels |= PA_CHANNEL_POSITION_MASK(t);
}
p->has_dB = TRUE;
p->has_dB = true;
} else {
if (p->has_dB) {
@ -2692,15 +2692,15 @@ int pa_alsa_path_probe(pa_alsa_path *p, snd_mixer_t *m, snd_hctl_t *hctl, pa_boo
e->volume_use = PA_ALSA_VOLUME_IGNORE;
pa_log_info("Ignoring volume of '%s' on path '%s' (missing dB info)", e->alsa_name, p->name);
}
p->has_volume = TRUE;
p->has_volume = true;
}
if (e->switch_use == PA_ALSA_SWITCH_MUTE)
p->has_mute = TRUE;
p->has_mute = true;
}
if (p->has_req_any && !p->req_any_present) {
p->supported = FALSE;
p->supported = false;
pa_log_debug("Skipping path '%s', none of required-any elements preset.", p->name);
return -1;
}
@ -2709,7 +2709,7 @@ int pa_alsa_path_probe(pa_alsa_path *p, snd_mixer_t *m, snd_hctl_t *hctl, pa_boo
path_make_options_unique(p);
path_create_settings(p);
p->supported = TRUE;
p->supported = true;
p->min_dB = INFINITY;
p->max_dB = -INFINITY;
@ -2904,12 +2904,12 @@ pa_alsa_path_set *pa_alsa_path_set_new(pa_alsa_mapping *m, pa_alsa_direction_t d
for (in = pn; *in; in++) {
pa_alsa_path *p = NULL;
pa_bool_t duplicate = FALSE;
bool duplicate = false;
char **kn;
for (kn = pn; kn < in; kn++)
if (pa_streq(*kn, *in)) {
duplicate = TRUE;
duplicate = true;
break;
}
@ -3018,7 +3018,7 @@ void pa_alsa_path_set_dump(pa_alsa_path_set *ps) {
pa_alsa_path_dump(p);
}
static pa_bool_t options_have_option(pa_alsa_option *options, const char *alsa_name) {
static bool options_have_option(pa_alsa_option *options, const char *alsa_name) {
pa_alsa_option *o;
pa_assert(options);
@ -3026,36 +3026,36 @@ static pa_bool_t options_have_option(pa_alsa_option *options, const char *alsa_n
PA_LLIST_FOREACH(o, options) {
if (pa_streq(o->alsa_name, alsa_name))
return TRUE;
return true;
}
return FALSE;
return false;
}
static pa_bool_t enumeration_is_subset(pa_alsa_option *a_options, pa_alsa_option *b_options) {
static bool enumeration_is_subset(pa_alsa_option *a_options, pa_alsa_option *b_options) {
pa_alsa_option *oa, *ob;
if (!a_options) return TRUE;
if (!b_options) return FALSE;
if (!a_options) return true;
if (!b_options) return false;
/* If there is an option A offers that B does not, then A is not a subset of B. */
PA_LLIST_FOREACH(oa, a_options) {
pa_bool_t found = FALSE;
bool found = false;
PA_LLIST_FOREACH(ob, b_options) {
if (pa_streq(oa->alsa_name, ob->alsa_name)) {
found = TRUE;
found = true;
break;
}
}
if (!found)
return FALSE;
return false;
}
return TRUE;
return true;
}
/**
* Compares two elements to see if a is a subset of b
*/
static pa_bool_t element_is_subset(pa_alsa_element *a, pa_alsa_element *b, snd_mixer_t *m) {
static bool element_is_subset(pa_alsa_element *a, pa_alsa_element *b, snd_mixer_t *m) {
pa_assert(a);
pa_assert(b);
pa_assert(m);
@ -3069,11 +3069,11 @@ static pa_bool_t element_is_subset(pa_alsa_element *a, pa_alsa_element *b, snd_m
/* "Constant" is subset of "Constant" only when their constant values are equal */
if (a->volume_use == PA_ALSA_VOLUME_CONSTANT && b->volume_use == PA_ALSA_VOLUME_CONSTANT && a->constant_volume != b->constant_volume)
return FALSE;
return false;
/* Different volume uses when b is not "Merge" means we are definitely not a subset */
if (a->volume_use != b->volume_use && b->volume_use != PA_ALSA_VOLUME_MERGE)
return FALSE;
return false;
/* "Constant" is a subset of "Merge", if there is not a "volume-limit" in "Merge" below the actual constant.
* "Zero" and "Off" are just special cases of "Constant" when comparing to "Merge"
@ -3096,15 +3096,15 @@ static pa_bool_t element_is_subset(pa_alsa_element *a, pa_alsa_element *b, snd_m
SELEM_INIT(sid, a->alsa_name);
if (!(me = snd_mixer_find_selem(m, sid))) {
pa_log_warn("Element %s seems to have disappeared.", a->alsa_name);
return FALSE;
return false;
}
if (a->direction == PA_ALSA_DIRECTION_OUTPUT) {
if (snd_mixer_selem_ask_playback_dB_vol(me, dB, +1, &a_limit) < 0)
return FALSE;
return false;
} else {
if (snd_mixer_selem_ask_capture_dB_vol(me, dB, -1, &a_limit) < 0)
return FALSE;
return false;
}
}
} else if (a->volume_use == PA_ALSA_VOLUME_OFF)
@ -3113,22 +3113,22 @@ static pa_bool_t element_is_subset(pa_alsa_element *a, pa_alsa_element *b, snd_m
a_limit = a->volume_limit;
else
/* This should never be reached */
pa_assert(FALSE);
pa_assert(false);
if (a_limit > b->volume_limit)
return FALSE;
return false;
}
if (a->volume_use == PA_ALSA_VOLUME_MERGE) {
int s;
/* If override-maps are different, they're not subsets */
if (a->n_channels != b->n_channels)
return FALSE;
return false;
for (s = 0; s <= SND_MIXER_SCHN_LAST; s++)
if (a->masks[s][a->n_channels-1] != b->masks[s][b->n_channels-1]) {
pa_log_debug("Element %s is not a subset - mask a: 0x%" PRIx64 ", mask b: 0x%" PRIx64 ", at channel %d",
a->alsa_name, a->masks[s][a->n_channels-1], b->masks[s][b->n_channels-1], s);
return FALSE;
return false;
}
}
}
@ -3144,31 +3144,31 @@ static pa_bool_t element_is_subset(pa_alsa_element *a, pa_alsa_element *b, snd_m
if (a->switch_use == PA_ALSA_SWITCH_SELECT || a->switch_use == PA_ALSA_SWITCH_MUTE
|| b->switch_use == PA_ALSA_SWITCH_OFF || b->switch_use == PA_ALSA_SWITCH_ON)
return FALSE;
return false;
if (b->switch_use == PA_ALSA_SWITCH_SELECT) {
if (a->switch_use == PA_ALSA_SWITCH_ON) {
if (!options_have_option(b->options, "on"))
return FALSE;
return false;
} else if (a->switch_use == PA_ALSA_SWITCH_OFF) {
if (!options_have_option(b->options, "off"))
return FALSE;
return false;
}
}
} else if (a->switch_use == PA_ALSA_SWITCH_SELECT) {
if (!enumeration_is_subset(a->options, b->options))
return FALSE;
return false;
}
}
if (a->enumeration_use != PA_ALSA_ENUMERATION_IGNORE) {
if (b->enumeration_use == PA_ALSA_ENUMERATION_IGNORE)
return FALSE;
return false;
if (!enumeration_is_subset(a->options, b->options))
return FALSE;
return false;
}
return TRUE;
return true;
}
static void path_set_condense(pa_alsa_path_set *ps, snd_mixer_t *m) {
@ -3966,11 +3966,11 @@ static int profile_verify(pa_alsa_profile *p) {
for (name = p->output_mapping_names; *name; name++) {
pa_alsa_mapping *m;
char **in;
pa_bool_t duplicate = FALSE;
bool duplicate = false;
for (in = name + 1; *in; in++)
if (pa_streq(*name, *in)) {
duplicate = TRUE;
duplicate = true;
break;
}
@ -4002,11 +4002,11 @@ static int profile_verify(pa_alsa_profile *p) {
for (name = p->input_mapping_names; *name; name++) {
pa_alsa_mapping *m;
char **in;
pa_bool_t duplicate = FALSE;
bool duplicate = false;
for (in = name + 1; *in; in++)
if (pa_streq(*name, *in)) {
duplicate = TRUE;
duplicate = true;
break;
}
@ -4277,7 +4277,7 @@ static snd_pcm_t* mapping_open_pcm(pa_alsa_mapping *m,
return pa_alsa_open_by_template(
m->device_strings, dev_id, NULL, &try_ss,
&try_map, mode, &try_period_size,
&try_buffer_size, 0, NULL, NULL, TRUE);
&try_buffer_size, 0, NULL, NULL, true);
}
static void paths_drop_unsupported(pa_hashmap* h) {
@ -4326,13 +4326,13 @@ void pa_alsa_profile_set_probe(
if (!p->supported) {
profile_finalize_probing(last, p);
p->supported = TRUE;
p->supported = true;
if (p->output_mappings) {
PA_IDXSET_FOREACH(m, p->output_mappings, idx) {
if (pa_hashmap_get(broken_outputs, m) == m) {
pa_log_debug("Skipping profile %s - will not be able to open output:%s", p->name, m->name);
p->supported = FALSE;
p->supported = false;
break;
}
}
@ -4342,7 +4342,7 @@ void pa_alsa_profile_set_probe(
PA_IDXSET_FOREACH(m, p->input_mappings, idx) {
if (pa_hashmap_get(broken_inputs, m) == m) {
pa_log_debug("Skipping profile %s - will not be able to open input:%s", p->name, m->name);
p->supported = FALSE;
p->supported = false;
break;
}
}
@ -4363,7 +4363,7 @@ void pa_alsa_profile_set_probe(
SND_PCM_STREAM_PLAYBACK,
default_n_fragments,
default_fragment_size_msec))) {
p->supported = FALSE;
p->supported = false;
if (pa_idxset_size(p->output_mappings) == 1 &&
((!p->input_mappings) || pa_idxset_size(p->input_mappings) == 0)) {
pa_log_debug("Caching failure to open output:%s", m->name);
@ -4384,7 +4384,7 @@ void pa_alsa_profile_set_probe(
SND_PCM_STREAM_CAPTURE,
default_n_fragments,
default_fragment_size_msec))) {
p->supported = FALSE;
p->supported = false;
if (pa_idxset_size(p->input_mappings) == 1 &&
((!p->output_mappings) || pa_idxset_size(p->output_mappings) == 0)) {
pa_log_debug("Caching failure to open input:%s", m->name);
@ -4423,7 +4423,7 @@ void pa_alsa_profile_set_probe(
pa_hashmap_free(broken_inputs, NULL);
pa_hashmap_free(broken_outputs, NULL);
ps->probed = TRUE;
ps->probed = true;
}
void pa_alsa_profile_set_dump(pa_alsa_profile_set *ps) {

40
src/modules/alsa/alsa-mixer.h
View file

@ -138,10 +138,10 @@ struct pa_alsa_element {
long constant_volume;
pa_bool_t override_map:1;
pa_bool_t direction_try_other:1;
bool override_map:1;
bool direction_try_other:1;
pa_bool_t has_dB:1;
bool has_dB:1;
long min_volume, max_volume;
long volume_limit; /* -1 for no configured limit */
double min_dB, max_dB;
@ -162,8 +162,8 @@ struct pa_alsa_jack {
char *name; /* E g "Headphone" */
char *alsa_name; /* E g "Headphone Jack" */
pa_bool_t has_control; /* is the jack itself present? */
pa_bool_t plugged_in; /* is this jack currently plugged in? */
bool has_control; /* is the jack itself present? */
bool plugged_in; /* is this jack currently plugged in? */
snd_hctl_elem_t *hctl_elem; /* Jack detection handle */
pa_available_t state_unplugged, state_plugged;
@ -186,15 +186,15 @@ struct pa_alsa_path {
int eld_device;
pa_proplist *proplist;
pa_bool_t probed:1;
pa_bool_t supported:1;
pa_bool_t has_mute:1;
pa_bool_t has_volume:1;
pa_bool_t has_dB:1;
bool probed:1;
bool supported:1;
bool has_mute:1;
bool has_volume:1;
bool has_dB:1;
bool mute_during_activation:1;
/* These two are used during probing only */
pa_bool_t has_req_any:1;
pa_bool_t req_any_present:1;
bool has_req_any:1;
bool req_any_present:1;
long min_volume, max_volume;
double min_dB, max_dB;
@ -226,12 +226,12 @@ void pa_alsa_element_dump(pa_alsa_element *e);
pa_alsa_path *pa_alsa_path_new(const char *paths_dir, const char *fname, pa_alsa_direction_t direction);
pa_alsa_path *pa_alsa_path_synthesize(const char *element, pa_alsa_direction_t direction);
int pa_alsa_path_probe(pa_alsa_path *p, snd_mixer_t *m, snd_hctl_t *hctl, pa_bool_t ignore_dB);
int pa_alsa_path_probe(pa_alsa_path *p, snd_mixer_t *m, snd_hctl_t *hctl, bool ignore_dB);
void pa_alsa_path_dump(pa_alsa_path *p);
int pa_alsa_path_get_volume(pa_alsa_path *p, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v);
int pa_alsa_path_get_mute(pa_alsa_path *path, snd_mixer_t *m, pa_bool_t *muted);
int pa_alsa_path_set_volume(pa_alsa_path *path, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v, pa_bool_t deferred_volume, pa_bool_t write_to_hw);
int pa_alsa_path_set_mute(pa_alsa_path *path, snd_mixer_t *m, pa_bool_t muted);
int pa_alsa_path_get_mute(pa_alsa_path *path, snd_mixer_t *m, bool *muted);
int pa_alsa_path_set_volume(pa_alsa_path *path, snd_mixer_t *m, const pa_channel_map *cm, pa_cvolume *v, bool deferred_volume, bool write_to_hw);
int pa_alsa_path_set_mute(pa_alsa_path *path, snd_mixer_t *m, bool muted);
int pa_alsa_path_select(pa_alsa_path *p, pa_alsa_setting *s, snd_mixer_t *m, bool device_is_muted);
void pa_alsa_path_set_callback(pa_alsa_path *p, snd_mixer_t *m, snd_mixer_elem_callback_t cb, void *userdata);
void pa_alsa_path_free(pa_alsa_path *p);
@ -282,7 +282,7 @@ struct pa_alsa_profile {
char *description;
unsigned priority;
pa_bool_t supported:1;
bool supported:1;
char **input_mapping_names;
char **output_mapping_names;
@ -314,9 +314,9 @@ struct pa_alsa_profile_set {
pa_hashmap *input_paths;
pa_hashmap *output_paths;
pa_bool_t auto_profiles;
pa_bool_t ignore_dB:1;
pa_bool_t probed:1;
bool auto_profiles;
bool ignore_dB:1;
bool probed:1;
};
void pa_alsa_mapping_dump(pa_alsa_mapping *m);

160
src/modules/alsa/alsa-sink.c
View file

@ -136,9 +136,9 @@ struct userdata {
char *device_name; /* name of the PCM device */
char *control_device; /* name of the control device */
pa_bool_t use_mmap:1, use_tsched:1, deferred_volume:1, fixed_latency_range:1;
bool use_mmap:1, use_tsched:1, deferred_volume:1, fixed_latency_range:1;
pa_bool_t first, after_rewind;
bool first, after_rewind;
pa_rtpoll_item *alsa_rtpoll_item;
@ -162,11 +162,11 @@ struct userdata {
static void userdata_free(struct userdata *u);
/* FIXME: Is there a better way to do this than device names? */
static pa_bool_t is_iec958(struct userdata *u) {
static bool is_iec958(struct userdata *u) {
return (strncmp("iec958", u->device_name, 6) == 0);
}
static pa_bool_t is_hdmi(struct userdata *u) {
static bool is_hdmi(struct userdata *u) {
return (strncmp("hdmi", u->device_name, 4) == 0);
}
@ -176,7 +176,7 @@ static pa_hook_result_t reserve_cb(pa_reserve_wrapper *r, void *forced, struct u
pa_log_debug("Suspending sink %s, because another application requested us to release the device.", u->sink->name);
if (pa_sink_suspend(u->sink, TRUE, PA_SUSPEND_APPLICATION) < 0)
if (pa_sink_suspend(u->sink, true, PA_SUSPEND_APPLICATION) < 0)
return PA_HOOK_CANCEL;
return PA_HOOK_OK;
@ -445,14 +445,14 @@ static int try_recover(struct userdata *u, const char *call, int err) {
return -1;
}
u->first = TRUE;
u->first = true;
u->since_start = 0;
return 0;
}
static size_t check_left_to_play(struct userdata *u, size_t n_bytes, pa_bool_t on_timeout) {
static size_t check_left_to_play(struct userdata *u, size_t n_bytes, bool on_timeout) {
size_t left_to_play;
pa_bool_t underrun = FALSE;
bool underrun = false;
/* We use <= instead of < for this check here because an underrun
* only happens after the last sample was processed, not already when
@ -465,7 +465,7 @@ static size_t check_left_to_play(struct userdata *u, size_t n_bytes, pa_bool_t o
/* We got a dropout. What a mess! */
left_to_play = 0;
underrun = TRUE;
underrun = true;
#if 0
PA_DEBUG_TRAP;
@ -484,13 +484,13 @@ static size_t check_left_to_play(struct userdata *u, size_t n_bytes, pa_bool_t o
#endif
if (u->use_tsched) {
pa_bool_t reset_not_before = TRUE;
bool reset_not_before = true;
if (!u->first && !u->after_rewind) {
if (underrun || left_to_play < u->watermark_inc_threshold)
increase_watermark(u);
else if (left_to_play > u->watermark_dec_threshold) {
reset_not_before = FALSE;
reset_not_before = false;
/* We decrease the watermark only if have actually
* been woken up by a timeout. If something else woke
@ -508,8 +508,8 @@ static size_t check_left_to_play(struct userdata *u, size_t n_bytes, pa_bool_t o
return left_to_play;
}
static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled, pa_bool_t on_timeout) {
pa_bool_t work_done = FALSE;
static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, bool polled, bool on_timeout) {
bool work_done = false;
pa_usec_t max_sleep_usec = 0, process_usec = 0;
size_t left_to_play, input_underrun;
unsigned j = 0;
@ -524,7 +524,7 @@ static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
snd_pcm_sframes_t n;
size_t n_bytes;
int r;
pa_bool_t after_avail = TRUE;
bool after_avail = true;
/* First we determine how many samples are missing to fill the
* buffer up to 100% */
@ -544,7 +544,7 @@ static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
#endif
left_to_play = check_left_to_play(u, n_bytes, on_timeout);
on_timeout = FALSE;
on_timeout = false;
if (u->use_tsched)
@ -589,7 +589,7 @@ static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
}
n_bytes -= u->hwbuf_unused;
polled = FALSE;
polled = false;
#ifdef DEBUG_TIMING
pa_log_debug("Filling up");
@ -626,7 +626,7 @@ static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
break;
pa_assert(frames > 0);
after_avail = FALSE;
after_avail = false;
/* Check these are multiples of 8 bit */
pa_assert((areas[0].first & 7) == 0);
@ -639,7 +639,7 @@ static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
p = (uint8_t*) areas[0].addr + (offset * u->frame_size);
written = frames * u->frame_size;
chunk.memblock = pa_memblock_new_fixed(u->core->mempool, p, written, TRUE);
chunk.memblock = pa_memblock_new_fixed(u->core->mempool, p, written, true);
chunk.length = pa_memblock_get_length(chunk.memblock);
chunk.index = 0;
@ -657,7 +657,7 @@ static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
return r;
}
work_done = TRUE;
work_done = true;
u->write_count += written;
u->since_start += written;
@ -693,8 +693,8 @@ static int mmap_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
return work_done ? 1 : 0;
}
static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled, pa_bool_t on_timeout) {
pa_bool_t work_done = FALSE;
static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, bool polled, bool on_timeout) {
bool work_done = false;
pa_usec_t max_sleep_usec = 0, process_usec = 0;
size_t left_to_play, input_underrun;
unsigned j = 0;
@ -709,7 +709,7 @@ static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
snd_pcm_sframes_t n;
size_t n_bytes;
int r;
pa_bool_t after_avail = TRUE;
bool after_avail = true;
if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->sink->sample_spec)) < 0)) {
@ -726,7 +726,7 @@ static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
#endif
left_to_play = check_left_to_play(u, n_bytes, on_timeout);
on_timeout = FALSE;
on_timeout = false;
if (u->use_tsched)
@ -764,7 +764,7 @@ static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
}
n_bytes -= u->hwbuf_unused;
polled = FALSE;
polled = false;
for (;;) {
snd_pcm_sframes_t frames;
@ -802,7 +802,7 @@ static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
break;
pa_assert(frames > 0);
after_avail = FALSE;
after_avail = false;
written = frames * u->frame_size;
u->memchunk.index += written;
@ -813,7 +813,7 @@ static int unix_write(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polle
pa_memchunk_reset(&u->memchunk);
}
work_done = TRUE;
work_done = true;
u->write_count += written;
u->since_start += written;
@ -862,7 +862,7 @@ static void update_smoother(struct userdata *u) {
/* Let's update the time smoother */
if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, status, &delay, u->hwbuf_size, &u->sink->sample_spec, FALSE)) < 0)) {
if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, status, &delay, u->hwbuf_size, &u->sink->sample_spec, false)) < 0)) {
pa_log_warn("Failed to query DSP status data: %s", pa_alsa_strerror(err));
return;
}
@ -1020,7 +1020,7 @@ static int update_sw_params(struct userdata *u) {
/* Called from IO Context on unsuspend or from main thread when creating sink */
static void reset_watermark(struct userdata *u, size_t tsched_watermark, pa_sample_spec *ss,
pa_bool_t in_thread) {
bool in_thread) {
u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, ss),
&u->sink->sample_spec);
@ -1056,7 +1056,7 @@ static void reset_watermark(struct userdata *u, size_t tsched_watermark, pa_samp
static int unsuspend(struct userdata *u) {
pa_sample_spec ss;
int err;
pa_bool_t b, d;
bool b, d;
snd_pcm_uframes_t period_size, buffer_size;
char *device_name = NULL;
@ -1088,7 +1088,7 @@ static int unsuspend(struct userdata *u) {
b = u->use_mmap;
d = u->use_tsched;
if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &period_size, &buffer_size, 0, &b, &d, TRUE)) < 0) {
if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &period_size, &buffer_size, 0, &b, &d, true)) < 0) {
pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err));
goto fail;
}
@ -1118,16 +1118,16 @@ static int unsuspend(struct userdata *u) {
goto fail;
u->write_count = 0;
pa_smoother_reset(u->smoother, pa_rtclock_now(), TRUE);
pa_smoother_reset(u->smoother, pa_rtclock_now(), true);
u->smoother_interval = SMOOTHER_MIN_INTERVAL;
u->last_smoother_update = 0;
u->first = TRUE;
u->first = true;
u->since_start = 0;
/* reset the watermark to the value defined when sink was created */
if (u->use_tsched)
reset_watermark(u, u->tsched_watermark_ref, &u->sink->sample_spec, TRUE);
reset_watermark(u, u->tsched_watermark_ref, &u->sink->sample_spec, true);
pa_log_info("Resumed successfully...");
@ -1238,13 +1238,13 @@ static int ctl_mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
return 0;
if (u->sink->suspend_cause & PA_SUSPEND_SESSION) {
pa_sink_set_mixer_dirty(u->sink, TRUE);
pa_sink_set_mixer_dirty(u->sink, true);
return 0;
}
if (mask & SND_CTL_EVENT_MASK_VALUE) {
pa_sink_get_volume(u->sink, TRUE);
pa_sink_get_mute(u->sink, TRUE);
pa_sink_get_volume(u->sink, true);
pa_sink_get_mute(u->sink, true);
}
return 0;
@ -1260,7 +1260,7 @@ static int io_mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
return 0;
if (u->sink->suspend_cause & PA_SUSPEND_SESSION) {
pa_sink_set_mixer_dirty(u->sink, TRUE);
pa_sink_set_mixer_dirty(u->sink, true);
return 0;
}
@ -1307,7 +1307,7 @@ static void sink_set_volume_cb(pa_sink *s) {
struct userdata *u = s->userdata;
pa_cvolume r;
char vol_str_pcnt[PA_CVOLUME_SNPRINT_MAX];
pa_bool_t deferred_volume = !!(s->flags & PA_SINK_DEFERRED_VOLUME);
bool deferred_volume = !!(s->flags & PA_SINK_DEFERRED_VOLUME);
pa_assert(u);
pa_assert(u->mixer_path);
@ -1326,7 +1326,7 @@ static void sink_set_volume_cb(pa_sink *s) {
if (u->mixer_path->has_dB) {
pa_cvolume new_soft_volume;
pa_bool_t accurate_enough;
bool accurate_enough;
char vol_str_db[PA_SW_CVOLUME_SNPRINT_DB_MAX];
/* Match exactly what the user requested by software */
@ -1373,11 +1373,11 @@ static void sink_write_volume_cb(pa_sink *s) {
/* Shift up by the base volume */
pa_sw_cvolume_divide_scalar(&hw_vol, &hw_vol, s->base_volume);
if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &hw_vol, TRUE, TRUE) < 0)
if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &hw_vol, true, true) < 0)
pa_log_error("Writing HW volume failed");
else {
pa_cvolume tmp_vol;
pa_bool_t accurate_enough;
bool accurate_enough;
/* Shift down by the base volume, so that 0dB becomes maximum volume */
pa_sw_cvolume_multiply_scalar(&hw_vol, &hw_vol, s->base_volume);
@ -1405,7 +1405,7 @@ static void sink_write_volume_cb(pa_sink *s) {
static void sink_get_mute_cb(pa_sink *s) {
struct userdata *u = s->userdata;
pa_bool_t b;
bool b;
pa_assert(u);
pa_assert(u->mixer_path);
@ -1447,7 +1447,7 @@ static void mixer_volume_init(struct userdata *u) {
pa_sink_set_write_volume_callback(u->sink, NULL);
if (u->mixer_path->has_dB) {
pa_sink_enable_decibel_volume(u->sink, TRUE);
pa_sink_enable_decibel_volume(u->sink, true);
pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB);
u->sink->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
@ -1455,7 +1455,7 @@ static void mixer_volume_init(struct userdata *u) {
pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->sink->base_volume));
} else {
pa_sink_enable_decibel_volume(u->sink, FALSE);
pa_sink_enable_decibel_volume(u->sink, false);
pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume);
u->sink->base_volume = PA_VOLUME_NORM;
@ -1483,7 +1483,7 @@ static int sink_set_port_ucm_cb(pa_sink *s, pa_device_port *p) {
pa_assert(p);
pa_assert(u->ucm_context);
return pa_alsa_ucm_set_port(u->ucm_context, p, TRUE);
return pa_alsa_ucm_set_port(u->ucm_context, p, true);
}
static int sink_set_port_cb(pa_sink *s, pa_device_port *p) {
@ -1555,7 +1555,7 @@ static pa_idxset* sink_get_formats(pa_sink *s) {
return ret;
}
static pa_bool_t sink_set_formats(pa_sink *s, pa_idxset *formats) {
static bool sink_set_formats(pa_sink *s, pa_idxset *formats) {
struct userdata *u = s->userdata;
pa_format_info *f, *g;
uint32_t idx, n;
@ -1566,7 +1566,7 @@ static pa_bool_t sink_set_formats(pa_sink *s, pa_idxset *formats) {
PA_IDXSET_FOREACH(f, formats, idx) {
if (is_iec958(u) && f->encoding == PA_ENCODING_EAC3_IEC61937)
/* EAC3 cannot be sent over over S/PDIF */
return FALSE;
return false;
}
pa_idxset_free(u->formats, (pa_free_cb_t) pa_format_info_free);
@ -1598,35 +1598,35 @@ static pa_bool_t sink_set_formats(pa_sink *s, pa_idxset *formats) {
}
}
return TRUE;
return true;
}
static pa_bool_t sink_update_rate_cb(pa_sink *s, uint32_t rate) {
static bool sink_update_rate_cb(pa_sink *s, uint32_t rate) {
struct userdata *u = s->userdata;
int i;
pa_bool_t supported = FALSE;
bool supported = false;
pa_assert(u);
for (i = 0; u->rates[i]; i++) {
if (u->rates[i] == rate) {
supported = TRUE;
supported = true;
break;
}
}
if (!supported) {
pa_log_info("Sink does not support sample rate of %d Hz", rate);
return FALSE;
return false;
}
if (!PA_SINK_IS_OPENED(s->state)) {
pa_log_info("Updating rate for device %s, new rate is %d",u->device_name, rate);
u->sink->sample_spec.rate = rate;
return TRUE;
return true;
}
return FALSE;
return false;
}
static int process_rewind(struct userdata *u) {
@ -1687,7 +1687,7 @@ static int process_rewind(struct userdata *u) {
pa_log_debug("Rewound %lu bytes.", (unsigned long) rewind_nbytes);
pa_sink_process_rewind(u->sink, rewind_nbytes);
u->after_rewind = TRUE;
u->after_rewind = true;
return 0;
}
} else
@ -1727,7 +1727,7 @@ static void thread_func(void *userdata) {
if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
int work_done;
pa_usec_t sleep_usec = 0;
pa_bool_t on_timeout = pa_rtpoll_timer_elapsed(u->rtpoll);
bool on_timeout = pa_rtpoll_timer_elapsed(u->rtpoll);
if (u->use_mmap)
work_done = mmap_write(u, &sleep_usec, revents & POLLOUT, on_timeout);
@ -1745,9 +1745,9 @@ static void thread_func(void *userdata) {
pa_log_info("Starting playback.");
snd_pcm_start(u->pcm_handle);
pa_smoother_resume(u->smoother, pa_rtclock_now(), TRUE);
pa_smoother_resume(u->smoother, pa_rtclock_now(), true);
u->first = FALSE;
u->first = false;
}
update_smoother(u);
@ -1789,7 +1789,7 @@ static void thread_func(void *userdata) {
rtpoll_sleep = PA_MIN(sleep_usec, cusec);
}
u->after_rewind = FALSE;
u->after_rewind = false;
}
@ -1812,7 +1812,7 @@ static void thread_func(void *userdata) {
pa_rtpoll_set_timer_disabled(u->rtpoll);
/* 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)
goto fail;
if (rtpoll_sleep > 0) {
@ -1851,7 +1851,7 @@ static void thread_func(void *userdata) {
if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
goto fail;
u->first = TRUE;
u->first = true;
u->since_start = 0;
revents = 0;
} else if (revents && u->use_tsched && pa_log_ratelimit(PA_LOG_DEBUG))
@ -1881,15 +1881,15 @@ static void set_sink_name(pa_sink_new_data *data, pa_modargs *ma, const char *de
if ((n = pa_modargs_get_value(ma, "sink_name", NULL))) {
pa_sink_new_data_set_name(data, n);
data->namereg_fail = TRUE;
data->namereg_fail = true;
return;
}
if ((n = pa_modargs_get_value(ma, "name", NULL)))
data->namereg_fail = TRUE;
data->namereg_fail = true;
else {
n = device_id ? device_id : device_name;
data->namereg_fail = FALSE;
data->namereg_fail = false;
}
if (mapping)
@ -1901,7 +1901,7 @@ static void set_sink_name(pa_sink_new_data *data, pa_modargs *ma, const char *de
pa_xfree(t);
}
static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, pa_bool_t ignore_dB) {
static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, bool ignore_dB) {
snd_hctl_t *hctl;
if (!mapping && !element)
@ -1940,8 +1940,8 @@ fail:
}
}
static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
pa_bool_t need_mixer_callback = FALSE;
static int setup_mixer(struct userdata *u, bool ignore_dB) {
bool need_mixer_callback = false;
pa_assert(u);
@ -1982,7 +1982,7 @@ static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
PA_HASHMAP_FOREACH(p, u->mixer_path_set->paths, state) {
if (p->has_volume || p->has_mute)
need_mixer_callback = TRUE;
need_mixer_callback = true;
}
}
else if (u->mixer_path)
@ -2028,7 +2028,7 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
uint32_t nfrags, frag_size, buffer_size, tsched_size, tsched_watermark, rewind_safeguard;
snd_pcm_uframes_t period_frames, buffer_frames, tsched_frames;
size_t frame_size;
pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE, namereg_fail = FALSE, deferred_volume = FALSE, set_formats = FALSE, fixed_latency_range = FALSE;
bool use_mmap = true, b, use_tsched = true, d, ignore_dB = false, namereg_fail = false, deferred_volume = false, set_formats = false, fixed_latency_range = false;
pa_sink_new_data data;
pa_alsa_profile_set *profile_set = NULL;
void *state = NULL;
@ -2113,7 +2113,7 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
u->use_tsched = use_tsched;
u->deferred_volume = deferred_volume;
u->fixed_latency_range = fixed_latency_range;
u->first = TRUE;
u->first = true;
u->rewind_safeguard = rewind_safeguard;
u->rtpoll = pa_rtpoll_new();
pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
@ -2121,11 +2121,11 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
u->smoother = pa_smoother_new(
SMOOTHER_ADJUST_USEC,
SMOOTHER_WINDOW_USEC,
TRUE,
TRUE,
true,
true,
5,
pa_rtclock_now(),
TRUE);
true);
u->smoother_interval = SMOOTHER_MIN_INTERVAL;
/* use ucm */
@ -2192,7 +2192,7 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
&ss, &map,
SND_PCM_STREAM_PLAYBACK,
&period_frames, &buffer_frames, tsched_frames,
&b, &d, FALSE)))
&b, &d, false)))
goto fail;
}
@ -2209,12 +2209,12 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
if (use_mmap && !b) {
pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
u->use_mmap = use_mmap = FALSE;
u->use_mmap = use_mmap = false;
}
if (use_tsched && (!b || !d)) {
pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
u->use_tsched = use_tsched = FALSE;
u->use_tsched = use_tsched = false;
}
if (u->use_mmap)
@ -2228,7 +2228,7 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
}
if (is_iec958(u) || is_hdmi(u))
set_formats = TRUE;
set_formats = true;
u->rates = pa_alsa_get_supported_rates(u->pcm_handle, ss.rate);
if (!u->rates) {
@ -2290,7 +2290,7 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
}
if (u->ucm_context)
pa_alsa_ucm_add_ports(&data.ports, data.proplist, u->ucm_context, TRUE, card);
pa_alsa_ucm_add_ports(&data.ports, data.proplist, u->ucm_context, true, card);
else if (u->mixer_path_set)
pa_alsa_add_ports(&data, u->mixer_path_set, card);
@ -2352,7 +2352,7 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
if (u->use_tsched) {
u->tsched_watermark_ref = tsched_watermark;
reset_watermark(u, u->tsched_watermark_ref, &ss, FALSE);
reset_watermark(u, u->tsched_watermark_ref, &ss, false);
} else
pa_sink_set_fixed_latency(u->sink, pa_bytes_to_usec(u->hwbuf_size, &ss));
@ -2362,7 +2362,7 @@ pa_sink *pa_alsa_sink_new(pa_module *m, pa_modargs *ma, const char*driver, pa_ca
goto fail;
if (u->ucm_context) {
if (u->sink->active_port && pa_alsa_ucm_set_port(u->ucm_context, u->sink->active_port, TRUE) < 0)
if (u->sink->active_port && pa_alsa_ucm_set_port(u->ucm_context, u->sink->active_port, true) < 0)
goto fail;
} else if (setup_mixer(u, ignore_dB) < 0)
goto fail;

144
src/modules/alsa/alsa-source.c
View file

@ -123,9 +123,9 @@ struct userdata {
char *device_name; /* name of the PCM device */
char *control_device; /* name of the control device */
pa_bool_t use_mmap:1, use_tsched:1, deferred_volume:1, fixed_latency_range:1;
bool use_mmap:1, use_tsched:1, deferred_volume:1, fixed_latency_range:1;
pa_bool_t first;
bool first;
pa_rtpoll_item *alsa_rtpoll_item;
@ -151,7 +151,7 @@ static pa_hook_result_t reserve_cb(pa_reserve_wrapper *r, void *forced, struct u
pa_log_debug("Suspending source %s, because another application requested us to release the device.", u->source->name);
if (pa_source_suspend(u->source, TRUE, PA_SUSPEND_APPLICATION) < 0)
if (pa_source_suspend(u->source, true, PA_SUSPEND_APPLICATION) < 0)
return PA_HOOK_CANCEL;
return PA_HOOK_OK;
@ -420,14 +420,14 @@ static int try_recover(struct userdata *u, const char *call, int err) {
return -1;
}
u->first = TRUE;
u->first = true;
return 0;
}
static size_t check_left_to_record(struct userdata *u, size_t n_bytes, pa_bool_t on_timeout) {
static size_t check_left_to_record(struct userdata *u, size_t n_bytes, bool on_timeout) {
size_t left_to_record;
size_t rec_space = u->hwbuf_size - u->hwbuf_unused;
pa_bool_t overrun = FALSE;
bool overrun = false;
/* We use <= instead of < for this check here because an overrun
* only happens after the last sample was processed, not already when
@ -440,7 +440,7 @@ static size_t check_left_to_record(struct userdata *u, size_t n_bytes, pa_bool_t
/* We got a dropout. What a mess! */
left_to_record = 0;
overrun = TRUE;
overrun = true;
#ifdef DEBUG_TIMING
PA_DEBUG_TRAP;
@ -455,12 +455,12 @@ static size_t check_left_to_record(struct userdata *u, size_t n_bytes, pa_bool_t
#endif
if (u->use_tsched) {
pa_bool_t reset_not_before = TRUE;
bool reset_not_before = true;
if (overrun || left_to_record < u->watermark_inc_threshold)
increase_watermark(u);
else if (left_to_record > u->watermark_dec_threshold) {
reset_not_before = FALSE;
reset_not_before = false;
/* We decrease the watermark only if have actually
* been woken up by a timeout. If something else woke
@ -477,8 +477,8 @@ static size_t check_left_to_record(struct userdata *u, size_t n_bytes, pa_bool_t
return left_to_record;
}
static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled, pa_bool_t on_timeout) {
pa_bool_t work_done = FALSE;
static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, bool polled, bool on_timeout) {
bool work_done = false;
pa_usec_t max_sleep_usec = 0, process_usec = 0;
size_t left_to_record;
unsigned j = 0;
@ -493,7 +493,7 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled
snd_pcm_sframes_t n;
size_t n_bytes;
int r;
pa_bool_t after_avail = TRUE;
bool after_avail = true;
if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
@ -510,7 +510,7 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled
#endif
left_to_record = check_left_to_record(u, n_bytes, on_timeout);
on_timeout = FALSE;
on_timeout = false;
if (u->use_tsched)
if (!polled &&
@ -547,7 +547,7 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled
break;
}
polled = FALSE;
polled = false;
#ifdef DEBUG_TIMING
pa_log_debug("Reading");
@ -583,7 +583,7 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled
break;
pa_assert(frames > 0);
after_avail = FALSE;
after_avail = false;
/* Check these are multiples of 8 bit */
pa_assert((areas[0].first & 7) == 0);
@ -595,7 +595,7 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled
p = (uint8_t*) areas[0].addr + (offset * u->frame_size);
chunk.memblock = pa_memblock_new_fixed(u->core->mempool, p, frames * u->frame_size, TRUE);
chunk.memblock = pa_memblock_new_fixed(u->core->mempool, p, frames * u->frame_size, true);
chunk.length = pa_memblock_get_length(chunk.memblock);
chunk.index = 0;
@ -610,7 +610,7 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled
return r;
}
work_done = TRUE;
work_done = true;
u->read_count += frames * u->frame_size;
@ -638,8 +638,8 @@ static int mmap_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled
return work_done ? 1 : 0;
}
static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled, pa_bool_t on_timeout) {
int work_done = FALSE;
static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, bool polled, bool on_timeout) {
int work_done = false;
pa_usec_t max_sleep_usec = 0, process_usec = 0;
size_t left_to_record;
unsigned j = 0;
@ -654,7 +654,7 @@ static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled
snd_pcm_sframes_t n;
size_t n_bytes;
int r;
pa_bool_t after_avail = TRUE;
bool after_avail = true;
if (PA_UNLIKELY((n = pa_alsa_safe_avail(u->pcm_handle, u->hwbuf_size, &u->source->sample_spec)) < 0)) {
@ -666,7 +666,7 @@ static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled
n_bytes = (size_t) n * u->frame_size;
left_to_record = check_left_to_record(u, n_bytes, on_timeout);
on_timeout = FALSE;
on_timeout = false;
if (u->use_tsched)
if (!polled &&
@ -696,7 +696,7 @@ static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled
break;
}
polled = FALSE;
polled = false;
for (;;) {
void *p;
@ -734,7 +734,7 @@ static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled
}
pa_assert(frames > 0);
after_avail = FALSE;
after_avail = false;
chunk.index = 0;
chunk.length = (size_t) frames * u->frame_size;
@ -742,7 +742,7 @@ static int unix_read(struct userdata *u, pa_usec_t *sleep_usec, pa_bool_t polled
pa_source_post(u->source, &chunk);
pa_memblock_unref(chunk.memblock);
work_done = TRUE;
work_done = true;
u->read_count += frames * u->frame_size;
@ -783,7 +783,7 @@ static void update_smoother(struct userdata *u) {
/* Let's update the time smoother */
if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, status, &delay, u->hwbuf_size, &u->source->sample_spec, TRUE)) < 0)) {
if (PA_UNLIKELY((err = pa_alsa_safe_delay(u->pcm_handle, status, &delay, u->hwbuf_size, &u->source->sample_spec, true)) < 0)) {
pa_log_warn("Failed to get delay: %s", pa_alsa_strerror(err));
return;
}
@ -913,7 +913,7 @@ static int update_sw_params(struct userdata *u) {
/* Called from IO Context on unsuspend or from main thread when creating source */
static void reset_watermark(struct userdata *u, size_t tsched_watermark, pa_sample_spec *ss,
pa_bool_t in_thread) {
bool in_thread) {
u->tsched_watermark = pa_usec_to_bytes_round_up(pa_bytes_to_usec_round_up(tsched_watermark, ss),
&u->source->sample_spec);
@ -949,7 +949,7 @@ static void reset_watermark(struct userdata *u, size_t tsched_watermark, pa_samp
static int unsuspend(struct userdata *u) {
pa_sample_spec ss;
int err;
pa_bool_t b, d;
bool b, d;
snd_pcm_uframes_t period_size, buffer_size;
pa_assert(u);
@ -972,7 +972,7 @@ static int unsuspend(struct userdata *u) {
b = u->use_mmap;
d = u->use_tsched;
if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &period_size, &buffer_size, 0, &b, &d, TRUE)) < 0) {
if ((err = pa_alsa_set_hw_params(u->pcm_handle, &ss, &period_size, &buffer_size, 0, &b, &d, true)) < 0) {
pa_log("Failed to set hardware parameters: %s", pa_alsa_strerror(err));
goto fail;
}
@ -1004,15 +1004,15 @@ static int unsuspend(struct userdata *u) {
/* FIXME: We need to reload the volume somehow */
u->read_count = 0;
pa_smoother_reset(u->smoother, pa_rtclock_now(), TRUE);
pa_smoother_reset(u->smoother, pa_rtclock_now(), true);
u->smoother_interval = SMOOTHER_MIN_INTERVAL;
u->last_smoother_update = 0;
u->first = TRUE;
u->first = true;
/* reset the watermark to the value defined when source was created */
if (u->use_tsched)
reset_watermark(u, u->tsched_watermark_ref, &u->source->sample_spec, TRUE);
reset_watermark(u, u->tsched_watermark_ref, &u->source->sample_spec, true);
pa_log_info("Resumed successfully...");
@ -1120,13 +1120,13 @@ static int ctl_mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
return 0;
if (u->source->suspend_cause & PA_SUSPEND_SESSION) {
pa_source_set_mixer_dirty(u->source, TRUE);
pa_source_set_mixer_dirty(u->source, true);
return 0;
}
if (mask & SND_CTL_EVENT_MASK_VALUE) {
pa_source_get_volume(u->source, TRUE);
pa_source_get_mute(u->source, TRUE);
pa_source_get_volume(u->source, true);
pa_source_get_mute(u->source, true);
}
return 0;
@ -1142,7 +1142,7 @@ static int io_mixer_callback(snd_mixer_elem_t *elem, unsigned int mask) {
return 0;
if (u->source->suspend_cause & PA_SUSPEND_SESSION) {
pa_source_set_mixer_dirty(u->source, TRUE);
pa_source_set_mixer_dirty(u->source, true);
return 0;
}
@ -1189,7 +1189,7 @@ static void source_set_volume_cb(pa_source *s) {
struct userdata *u = s->userdata;
pa_cvolume r;
char vol_str_pcnt[PA_CVOLUME_SNPRINT_MAX];
pa_bool_t deferred_volume = !!(s->flags & PA_SOURCE_DEFERRED_VOLUME);
bool deferred_volume = !!(s->flags & PA_SOURCE_DEFERRED_VOLUME);
pa_assert(u);
pa_assert(u->mixer_path);
@ -1208,7 +1208,7 @@ static void source_set_volume_cb(pa_source *s) {
if (u->mixer_path->has_dB) {
pa_cvolume new_soft_volume;
pa_bool_t accurate_enough;
bool accurate_enough;
char vol_str_db[PA_SW_CVOLUME_SNPRINT_DB_MAX];
/* Match exactly what the user requested by software */
@ -1255,11 +1255,11 @@ static void source_write_volume_cb(pa_source *s) {
/* Shift up by the base volume */
pa_sw_cvolume_divide_scalar(&hw_vol, &hw_vol, s->base_volume);
if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &hw_vol, TRUE, TRUE) < 0)
if (pa_alsa_path_set_volume(u->mixer_path, u->mixer_handle, &s->channel_map, &hw_vol, true, true) < 0)
pa_log_error("Writing HW volume failed");
else {
pa_cvolume tmp_vol;
pa_bool_t accurate_enough;
bool accurate_enough;
/* Shift down by the base volume, so that 0dB becomes maximum volume */
pa_sw_cvolume_multiply_scalar(&hw_vol, &hw_vol, s->base_volume);
@ -1287,7 +1287,7 @@ static void source_write_volume_cb(pa_source *s) {
static void source_get_mute_cb(pa_source *s) {
struct userdata *u = s->userdata;
pa_bool_t b;
bool b;
pa_assert(u);
pa_assert(u->mixer_path);
@ -1329,7 +1329,7 @@ static void mixer_volume_init(struct userdata *u) {
pa_source_set_write_volume_callback(u->source, NULL);
if (u->mixer_path->has_dB) {
pa_source_enable_decibel_volume(u->source, TRUE);
pa_source_enable_decibel_volume(u->source, true);
pa_log_info("Hardware volume ranges from %0.2f dB to %0.2f dB.", u->mixer_path->min_dB, u->mixer_path->max_dB);
u->source->base_volume = pa_sw_volume_from_dB(-u->mixer_path->max_dB);
@ -1337,7 +1337,7 @@ static void mixer_volume_init(struct userdata *u) {
pa_log_info("Fixing base volume to %0.2f dB", pa_sw_volume_to_dB(u->source->base_volume));
} else {
pa_source_enable_decibel_volume(u->source, FALSE);
pa_source_enable_decibel_volume(u->source, false);
pa_log_info("Hardware volume ranges from %li to %li.", u->mixer_path->min_volume, u->mixer_path->max_volume);
u->source->base_volume = PA_VOLUME_NORM;
@ -1365,7 +1365,7 @@ static int source_set_port_ucm_cb(pa_source *s, pa_device_port *p) {
pa_assert(p);
pa_assert(u->ucm_context);
return pa_alsa_ucm_set_port(u->ucm_context, p, FALSE);
return pa_alsa_ucm_set_port(u->ucm_context, p, false);
}
static int source_set_port_cb(pa_source *s, pa_device_port *p) {
@ -1409,32 +1409,32 @@ static void source_update_requested_latency_cb(pa_source *s) {
update_sw_params(u);
}
static pa_bool_t source_update_rate_cb(pa_source *s, uint32_t rate) {
static bool source_update_rate_cb(pa_source *s, uint32_t rate) {
struct userdata *u = s->userdata;
int i;
pa_bool_t supported = FALSE;
bool supported = false;
pa_assert(u);
for (i = 0; u->rates[i]; i++) {
if (u->rates[i] == rate) {
supported = TRUE;
supported = true;
break;
}
}
if (!supported) {
pa_log_info("Source does not support sample rate of %d Hz", rate);
return FALSE;
return false;
}
if (!PA_SOURCE_IS_OPENED(s->state)) {
pa_log_info("Updating rate for device %s, new rate is %d", u->device_name, rate);
u->source->sample_spec.rate = rate;
return TRUE;
return true;
}
return FALSE;
return false;
}
static void thread_func(void *userdata) {
@ -1462,15 +1462,15 @@ static void thread_func(void *userdata) {
if (PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
int work_done;
pa_usec_t sleep_usec = 0;
pa_bool_t on_timeout = pa_rtpoll_timer_elapsed(u->rtpoll);
bool on_timeout = pa_rtpoll_timer_elapsed(u->rtpoll);
if (u->first) {
pa_log_info("Starting capture.");
snd_pcm_start(u->pcm_handle);
pa_smoother_resume(u->smoother, pa_rtclock_now(), TRUE);
pa_smoother_resume(u->smoother, pa_rtclock_now(), true);
u->first = FALSE;
u->first = false;
}
if (u->use_mmap)
@ -1524,7 +1524,7 @@ static void thread_func(void *userdata) {
pa_rtpoll_set_timer_disabled(u->rtpoll);
/* 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)
goto fail;
if (rtpoll_sleep > 0) {
@ -1563,7 +1563,7 @@ static void thread_func(void *userdata) {
if (pa_alsa_recover_from_poll(u->pcm_handle, revents) < 0)
goto fail;
u->first = TRUE;
u->first = true;
revents = 0;
} else if (revents && u->use_tsched && pa_log_ratelimit(PA_LOG_DEBUG))
pa_log_debug("Wakeup from ALSA!");
@ -1592,15 +1592,15 @@ static void set_source_name(pa_source_new_data *data, pa_modargs *ma, const char
if ((n = pa_modargs_get_value(ma, "source_name", NULL))) {
pa_source_new_data_set_name(data, n);
data->namereg_fail = TRUE;
data->namereg_fail = true;
return;
}
if ((n = pa_modargs_get_value(ma, "name", NULL)))
data->namereg_fail = TRUE;
data->namereg_fail = true;
else {
n = device_id ? device_id : device_name;
data->namereg_fail = FALSE;
data->namereg_fail = false;
}
if (mapping)
@ -1612,7 +1612,7 @@ static void set_source_name(pa_source_new_data *data, pa_modargs *ma, const char
pa_xfree(t);
}
static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, pa_bool_t ignore_dB) {
static void find_mixer(struct userdata *u, pa_alsa_mapping *mapping, const char *element, bool ignore_dB) {
snd_hctl_t *hctl;
if (!mapping && !element)
@ -1651,8 +1651,8 @@ fail:
}
}
static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
pa_bool_t need_mixer_callback = FALSE;
static int setup_mixer(struct userdata *u, bool ignore_dB) {
bool need_mixer_callback = false;
pa_assert(u);
@ -1692,7 +1692,7 @@ static int setup_mixer(struct userdata *u, pa_bool_t ignore_dB) {
PA_HASHMAP_FOREACH(p, u->mixer_path_set->paths, state) {
if (p->has_volume || p->has_mute)
need_mixer_callback = TRUE;
need_mixer_callback = true;
}
}
else if (u->mixer_path)
@ -1738,7 +1738,7 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
uint32_t nfrags, frag_size, buffer_size, tsched_size, tsched_watermark;
snd_pcm_uframes_t period_frames, buffer_frames, tsched_frames;
size_t frame_size;
pa_bool_t use_mmap = TRUE, b, use_tsched = TRUE, d, ignore_dB = FALSE, namereg_fail = FALSE, deferred_volume = FALSE, fixed_latency_range = FALSE;
bool use_mmap = true, b, use_tsched = true, d, ignore_dB = false, namereg_fail = false, deferred_volume = false, fixed_latency_range = false;
pa_source_new_data data;
pa_alsa_profile_set *profile_set = NULL;
void *state = NULL;
@ -1817,18 +1817,18 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
u->use_tsched = use_tsched;
u->deferred_volume = deferred_volume;
u->fixed_latency_range = fixed_latency_range;
u->first = TRUE;
u->first = true;
u->rtpoll = pa_rtpoll_new();
pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
u->smoother = pa_smoother_new(
SMOOTHER_ADJUST_USEC,
SMOOTHER_WINDOW_USEC,
TRUE,
TRUE,
true,
true,
5,
pa_rtclock_now(),
TRUE);
true);
u->smoother_interval = SMOOTHER_MIN_INTERVAL;
/* use ucm */
@ -1895,7 +1895,7 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
&ss, &map,
SND_PCM_STREAM_CAPTURE,
&period_frames, &buffer_frames, tsched_frames,
&b, &d, FALSE)))
&b, &d, false)))
goto fail;
}
@ -1912,12 +1912,12 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
if (use_mmap && !b) {
pa_log_info("Device doesn't support mmap(), falling back to UNIX read/write mode.");
u->use_mmap = use_mmap = FALSE;
u->use_mmap = use_mmap = false;
}
if (use_tsched && (!b || !d)) {
pa_log_info("Cannot enable timer-based scheduling, falling back to sound IRQ scheduling.");
u->use_tsched = use_tsched = FALSE;
u->use_tsched = use_tsched = false;
}
if (u->use_mmap)
@ -1989,7 +1989,7 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
}
if (u->ucm_context)
pa_alsa_ucm_add_ports(&data.ports, data.proplist, u->ucm_context, FALSE, card);
pa_alsa_ucm_add_ports(&data.ports, data.proplist, u->ucm_context, false, card);
else if (u->mixer_path_set)
pa_alsa_add_ports(&data, u->mixer_path_set, card);
@ -2042,7 +2042,7 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
if (u->use_tsched) {
u->tsched_watermark_ref = tsched_watermark;
reset_watermark(u, u->tsched_watermark_ref, &ss, FALSE);
reset_watermark(u, u->tsched_watermark_ref, &ss, false);
}
else
pa_source_set_fixed_latency(u->source, pa_bytes_to_usec(u->hwbuf_size, &ss));
@ -2053,7 +2053,7 @@ pa_source *pa_alsa_source_new(pa_module *m, pa_modargs *ma, const char*driver, p
goto fail;
if (u->ucm_context) {
if (u->source->active_port && pa_alsa_ucm_set_port(u->ucm_context, u->source->active_port, FALSE) < 0)
if (u->source->active_port && pa_alsa_ucm_set_port(u->ucm_context, u->source->active_port, false) < 0)
goto fail;
} else if (setup_mixer(u, ignore_dB) < 0)
goto fail;

26
src/modules/alsa/alsa-ucm.c
View file

@ -451,10 +451,10 @@ static void add_media_role(const char *name, pa_alsa_ucm_device *list, const cha
static char *modifier_name_to_role(const char *mod_name, bool *is_sink) {
char *sub = NULL, *tmp;
*is_sink = FALSE;
*is_sink = false;
if (pa_startswith(mod_name, "Play")) {
*is_sink = TRUE;
*is_sink = true;
sub = pa_xstrdup(mod_name + 4);
} else if (pa_startswith(mod_name, "Capture"))
sub = pa_xstrdup(mod_name + 7);
@ -476,7 +476,7 @@ static char *modifier_name_to_role(const char *mod_name, bool *is_sink) {
static void ucm_set_media_roles(pa_alsa_ucm_modifier *modifier, pa_alsa_ucm_device *list, const char *mod_name) {
int i;
bool is_sink = FALSE;
bool is_sink = false;
char *sub = NULL;
const char *role_name;
@ -729,7 +729,7 @@ static int ucm_port_contains(const char *port_name, const char *dev_name, bool i
int len;
if (!port_name || !dev_name)
return FALSE;
return false;
port_name += is_sink ? strlen(PA_UCM_PRE_TAG_OUTPUT) : strlen(PA_UCM_PRE_TAG_INPUT);
@ -1203,9 +1203,9 @@ static int ucm_create_mapping(
}
if (sink)
ret = ucm_create_mapping_direction(ucm, ps, p, device, verb_name, device_name, sink, TRUE);
ret = ucm_create_mapping_direction(ucm, ps, p, device, verb_name, device_name, sink, true);
if (ret == 0 && source)
ret = ucm_create_mapping_direction(ucm, ps, p, device, verb_name, device_name, source, FALSE);
ret = ucm_create_mapping_direction(ucm, ps, p, device, verb_name, device_name, source, false);
return ret;
}
@ -1260,7 +1260,7 @@ static int ucm_create_profile(
p->output_mappings = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
p->input_mappings = pa_idxset_new(pa_idxset_trivial_hash_func, pa_idxset_trivial_compare_func);
p->supported = TRUE;
p->supported = true;
pa_hashmap_put(ps->profiles, p->name, p);
/* TODO: get profile priority from ucm info or policy management */
@ -1305,9 +1305,9 @@ static int ucm_create_profile(
source = pa_proplist_gets(mod->proplist, PA_ALSA_PROP_UCM_SOURCE);
if (sink)
ucm_create_mapping_for_modifier(ucm, ps, p, mod, verb_name, name, sink, TRUE);
ucm_create_mapping_for_modifier(ucm, ps, p, mod, verb_name, name, sink, true);
else if (source)
ucm_create_mapping_for_modifier(ucm, ps, p, mod, verb_name, name, source, FALSE);
ucm_create_mapping_for_modifier(ucm, ps, p, mod, verb_name, name, source, false);
}
pa_alsa_profile_dump(p);
@ -1405,7 +1405,7 @@ static void ucm_probe_profile_set(pa_alsa_ucm_config *ucm, pa_alsa_profile_set *
if ((snd_use_case_set(ucm->ucm_mgr, "_verb", p->name)) < 0) {
pa_log("Failed to set verb %s", p->name);
p->supported = FALSE;
p->supported = false;
continue;
}
@ -1418,7 +1418,7 @@ static void ucm_probe_profile_set(pa_alsa_ucm_config *ucm, pa_alsa_profile_set *
m->output_pcm = mapping_open_pcm(ucm, m, SND_PCM_STREAM_PLAYBACK);
if (!m->output_pcm) {
p->supported = FALSE;
p->supported = false;
break;
}
}
@ -1433,7 +1433,7 @@ static void ucm_probe_profile_set(pa_alsa_ucm_config *ucm, pa_alsa_profile_set *
m->input_pcm = mapping_open_pcm(ucm, m, SND_PCM_STREAM_CAPTURE);
if (!m->input_pcm) {
p->supported = FALSE;
p->supported = false;
break;
}
}
@ -1488,7 +1488,7 @@ pa_alsa_profile_set* pa_alsa_ucm_add_profile_set(pa_alsa_ucm_config *ucm, pa_cha
}
ucm_probe_profile_set(ucm, ps);
ps->probed = TRUE;
ps->probed = true;
return ps;
}

80
src/modules/alsa/alsa-util.c
View file

@ -191,17 +191,17 @@ int pa_alsa_set_hw_params(
snd_pcm_uframes_t *period_size,
snd_pcm_uframes_t *buffer_size,
snd_pcm_uframes_t tsched_size,
pa_bool_t *use_mmap,
pa_bool_t *use_tsched,
pa_bool_t require_exact_channel_number) {
bool *use_mmap,
bool *use_tsched,
bool require_exact_channel_number) {
int ret = -1;
snd_pcm_hw_params_t *hwparams, *hwparams_copy;
int dir;
snd_pcm_uframes_t _period_size = period_size ? *period_size : 0;
snd_pcm_uframes_t _buffer_size = buffer_size ? *buffer_size : 0;
pa_bool_t _use_mmap = use_mmap && *use_mmap;
pa_bool_t _use_tsched = use_tsched && *use_tsched;
bool _use_mmap = use_mmap && *use_mmap;
bool _use_tsched = use_tsched && *use_tsched;
pa_sample_spec _ss = *ss;
pa_assert(pcm_handle);
@ -231,7 +231,7 @@ int pa_alsa_set_hw_params(
goto finish;
}
_use_mmap = FALSE;
_use_mmap = false;
}
} else if ((ret = snd_pcm_hw_params_set_access(pcm_handle, hwparams, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
@ -240,10 +240,10 @@ int pa_alsa_set_hw_params(
}
if (!_use_mmap)
_use_tsched = FALSE;
_use_tsched = false;
if (!pa_alsa_pcm_is_hw(pcm_handle))
_use_tsched = FALSE;
_use_tsched = false;
#if (SND_LIB_VERSION >= ((1<<16)|(0<<8)|24)) /* API additions in 1.0.24 */
if (_use_tsched) {
@ -251,7 +251,7 @@ int pa_alsa_set_hw_params(
/* try to disable period wakeups if hardware can do so */
if (snd_pcm_hw_params_can_disable_period_wakeup(hwparams)) {
if ((ret = snd_pcm_hw_params_set_period_wakeup(pcm_handle, hwparams, FALSE)) < 0)
if ((ret = snd_pcm_hw_params_set_period_wakeup(pcm_handle, hwparams, false)) < 0)
/* don't bail, keep going with default mode with period wakeups */
pa_log_debug("snd_pcm_hw_params_set_period_wakeup() failed: %s", pa_alsa_strerror(ret));
else
@ -426,7 +426,7 @@ finish:
return ret;
}
int pa_alsa_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t avail_min, pa_bool_t period_event) {
int pa_alsa_set_sw_params(snd_pcm_t *pcm, snd_pcm_uframes_t avail_min, bool period_event) {
snd_pcm_sw_params_t *swparams;
snd_pcm_uframes_t boundary;
int err;
@ -487,8 +487,8 @@ snd_pcm_t *pa_alsa_open_by_device_id_auto(
snd_pcm_uframes_t *period_size,
snd_pcm_uframes_t *buffer_size,
snd_pcm_uframes_t tsched_size,
pa_bool_t *use_mmap,
pa_bool_t *use_tsched,
bool *use_mmap,
bool *use_tsched,
pa_alsa_profile_set *ps,
pa_alsa_mapping **mapping) {
@ -578,7 +578,7 @@ snd_pcm_t *pa_alsa_open_by_device_id_auto(
tsched_size,
use_mmap,
use_tsched,
FALSE);
false);
pa_xfree(d);
if (pcm_handle && mapping)
@ -596,8 +596,8 @@ snd_pcm_t *pa_alsa_open_by_device_id_mapping(
snd_pcm_uframes_t *period_size,
snd_pcm_uframes_t *buffer_size,
snd_pcm_uframes_t tsched_size,
pa_bool_t *use_mmap,
pa_bool_t *use_tsched,
bool *use_mmap,
bool *use_tsched,
pa_alsa_mapping *m) {
snd_pcm_t *pcm_handle;
@ -648,14 +648,14 @@ snd_pcm_t *pa_alsa_open_by_device_string(
snd_pcm_uframes_t *period_size,
snd_pcm_uframes_t *buffer_size,
snd_pcm_uframes_t tsched_size,
pa_bool_t *use_mmap,
pa_bool_t *use_tsched,
pa_bool_t require_exact_channel_number) {
bool *use_mmap,
bool *use_tsched,
bool require_exact_channel_number) {
int err;
char *d;
snd_pcm_t *pcm_handle;
pa_bool_t reformat = FALSE;
bool reformat = false;
pa_assert(device);
pa_assert(ss);
@ -688,7 +688,7 @@ snd_pcm_t *pa_alsa_open_by_device_string(
require_exact_channel_number)) < 0) {
if (!reformat) {
reformat = TRUE;
reformat = true;
snd_pcm_close(pcm_handle);
continue;
@ -702,7 +702,7 @@ snd_pcm_t *pa_alsa_open_by_device_string(
pa_xfree(d);
d = t;
reformat = FALSE;
reformat = false;
snd_pcm_close(pcm_handle);
continue;
@ -741,9 +741,9 @@ snd_pcm_t *pa_alsa_open_by_template(
snd_pcm_uframes_t *period_size,
snd_pcm_uframes_t *buffer_size,
snd_pcm_uframes_t tsched_size,
pa_bool_t *use_mmap,
pa_bool_t *use_tsched,
pa_bool_t require_exact_channel_number) {
bool *use_mmap,
bool *use_tsched,
bool require_exact_channel_number) {
snd_pcm_t *pcm_handle;
char **i;
@ -862,18 +862,18 @@ void pa_alsa_refcnt_dec(void) {
}
}
pa_bool_t pa_alsa_init_description(pa_proplist *p) {
bool pa_alsa_init_description(pa_proplist *p) {
const char *d, *k;
pa_assert(p);
if (pa_device_init_description(p))
return TRUE;
return true;
if (!(d = pa_proplist_gets(p, "alsa.card_name")))
d = pa_proplist_gets(p, "alsa.name");
if (!d)
return FALSE;
return false;
k = pa_proplist_gets(p, PA_PROP_DEVICE_PROFILE_DESCRIPTION);
@ -882,7 +882,7 @@ pa_bool_t pa_alsa_init_description(pa_proplist *p) {
else if (d)
pa_proplist_sets(p, PA_PROP_DEVICE_DESCRIPTION, d);
return FALSE;
return false;
}
void pa_alsa_init_proplist_card(pa_core *c, pa_proplist *p, int card) {
@ -1142,7 +1142,7 @@ snd_pcm_sframes_t pa_alsa_safe_avail(snd_pcm_t *pcm, size_t hwbuf_size, const pa
}
int pa_alsa_safe_delay(snd_pcm_t *pcm, snd_pcm_status_t *status, snd_pcm_sframes_t *delay, size_t hwbuf_size, const pa_sample_spec *ss,
pa_bool_t capture) {
bool capture) {
ssize_t k;
size_t abs_k;
int err;
@ -1333,7 +1333,7 @@ unsigned int *pa_alsa_get_supported_rates(snd_pcm_t *pcm, unsigned int fallback_
64000, 88200, 96000,
128000, 176400, 192000,
384000 };
pa_bool_t supported[PA_ELEMENTSOF(all_rates)] = { FALSE, };
bool supported[PA_ELEMENTSOF(all_rates)] = { false, };
snd_pcm_hw_params_t *hwparams;
unsigned int i, j, n, *rates = NULL;
int ret;
@ -1347,7 +1347,7 @@ unsigned int *pa_alsa_get_supported_rates(snd_pcm_t *pcm, unsigned int fallback_
for (i = 0, n = 0; i < PA_ELEMENTSOF(all_rates); i++) {
if (snd_pcm_hw_params_test_rate(pcm, hwparams, all_rates[i], 0) == 0) {
supported[i] = TRUE;
supported[i] = true;
n++;
}
}
@ -1377,26 +1377,26 @@ unsigned int *pa_alsa_get_supported_rates(snd_pcm_t *pcm, unsigned int fallback_
return rates;
}
pa_bool_t pa_alsa_pcm_is_hw(snd_pcm_t *pcm) {
bool pa_alsa_pcm_is_hw(snd_pcm_t *pcm) {
snd_pcm_info_t* info;
snd_pcm_info_alloca(&info);
pa_assert(pcm);
if (snd_pcm_info(pcm, info) < 0)
return FALSE;
return false;
return snd_pcm_info_get_card(info) >= 0;
}
pa_bool_t pa_alsa_pcm_is_modem(snd_pcm_t *pcm) {
bool pa_alsa_pcm_is_modem(snd_pcm_t *pcm) {
snd_pcm_info_t* info;
snd_pcm_info_alloca(&info);
pa_assert(pcm);
if (snd_pcm_info(pcm, info) < 0)
return FALSE;
return false;
return snd_pcm_info_get_class(info) == SND_PCM_CLASS_MODEM;
}
@ -1428,26 +1428,26 @@ const char* pa_alsa_strerror(int errnum) {
return translated;
}
pa_bool_t pa_alsa_may_tsched(pa_bool_t want) {
bool pa_alsa_may_tsched(bool want) {
if (!want)
return FALSE;
return false;
if (!pa_rtclock_hrtimer()) {
/* We cannot depend on being woken up in time when the timers
are inaccurate, so let's fallback to classic IO based playback
then. */
pa_log_notice("Disabling timer-based scheduling because high-resolution timers are not available from the kernel.");
return FALSE; }
return false; }
if (pa_running_in_vm()) {
/* We cannot depend on being woken up when we ask for in a VM,
* so let's fallback to classic IO based playback then. */
pa_log_notice("Disabling timer-based scheduling because running inside a VM.");
return FALSE;
return false;
}
return TRUE;
return true;
}
snd_hctl_elem_t* pa_alsa_find_jack(snd_hctl_t *hctl, const char* jack_name) {

38
src/modules/alsa/alsa-util.h
View file

@ -41,14 +41,14 @@ int pa_alsa_set_hw_params(
snd_pcm_uframes_t *period_size, /* modified at return */
snd_pcm_uframes_t *buffer_size, /* modified at return */
snd_pcm_uframes_t tsched_size,
pa_bool_t *use_mmap, /* modified at return */
pa_bool_t *use_tsched, /* modified at return */
pa_bool_t require_exact_channel_number);
bool *use_mmap, /* modified at return */
bool *use_tsched, /* modified at return */
bool require_exact_channel_number);
int pa_alsa_set_sw_params(
snd_pcm_t *pcm,
snd_pcm_uframes_t avail_min,
pa_bool_t period_event);
bool period_event);
/* Picks a working mapping from the profile set based on the specified ss/map */
snd_pcm_t *pa_alsa_open_by_device_id_auto(
@ -60,8 +60,8 @@ snd_pcm_t *pa_alsa_open_by_device_id_auto(
snd_pcm_uframes_t *period_size, /* modified at return */
snd_pcm_uframes_t *buffer_size, /* modified at return */
snd_pcm_uframes_t tsched_size,
pa_bool_t *use_mmap, /* modified at return */
pa_bool_t *use_tsched, /* modified at return */
bool *use_mmap, /* modified at return */
bool *use_tsched, /* modified at return */
pa_alsa_profile_set *ps,
pa_alsa_mapping **mapping); /* modified at return */
@ -75,8 +75,8 @@ snd_pcm_t *pa_alsa_open_by_device_id_mapping(
snd_pcm_uframes_t *period_size, /* modified at return */
snd_pcm_uframes_t *buffer_size, /* modified at return */
snd_pcm_uframes_t tsched_size,
pa_bool_t *use_mmap, /* modified at return */
pa_bool_t *use_tsched, /* modified at return */
bool *use_mmap, /* modified at return */
bool *use_tsched, /* modified at return */
pa_alsa_mapping *mapping);
/* Opens the explicit ALSA device */
@ -89,9 +89,9 @@ snd_pcm_t *pa_alsa_open_by_device_string(
snd_pcm_uframes_t *period_size, /* modified at return */
snd_pcm_uframes_t *buffer_size, /* modified at return */
snd_pcm_uframes_t tsched_size,
pa_bool_t *use_mmap, /* modified at return */
pa_bool_t *use_tsched, /* modified at return */
pa_bool_t require_exact_channel_number);
bool *use_mmap, /* modified at return */
bool *use_tsched, /* modified at return */
bool require_exact_channel_number);
/* Opens the explicit ALSA device with a fallback list */
snd_pcm_t *pa_alsa_open_by_template(
@ -104,9 +104,9 @@ snd_pcm_t *pa_alsa_open_by_template(
snd_pcm_uframes_t *period_size, /* modified at return */
snd_pcm_uframes_t *buffer_size, /* modified at return */
snd_pcm_uframes_t tsched_size,
pa_bool_t *use_mmap, /* modified at return */
pa_bool_t *use_tsched, /* modified at return */
pa_bool_t require_exact_channel_number);
bool *use_mmap, /* modified at return */
bool *use_tsched, /* modified at return */
bool require_exact_channel_number);
void pa_alsa_dump(pa_log_level_t level, snd_pcm_t *pcm);
void pa_alsa_dump_status(snd_pcm_t *pcm);
@ -118,14 +118,14 @@ void pa_alsa_init_proplist_pcm_info(pa_core *c, pa_proplist *p, snd_pcm_info_t *
void pa_alsa_init_proplist_card(pa_core *c, pa_proplist *p, int card);
void pa_alsa_init_proplist_pcm(pa_core *c, pa_proplist *p, snd_pcm_t *pcm);
void pa_alsa_init_proplist_ctl(pa_proplist *p, const char *name);
pa_bool_t pa_alsa_init_description(pa_proplist *p);
bool pa_alsa_init_description(pa_proplist *p);
int pa_alsa_recover_from_poll(snd_pcm_t *pcm, int revents);
pa_rtpoll_item* pa_alsa_build_pollfd(snd_pcm_t *pcm, pa_rtpoll *rtpoll);
snd_pcm_sframes_t pa_alsa_safe_avail(snd_pcm_t *pcm, size_t hwbuf_size, const pa_sample_spec *ss);
int pa_alsa_safe_delay(snd_pcm_t *pcm, snd_pcm_status_t *status, snd_pcm_sframes_t *delay, size_t hwbuf_size, const pa_sample_spec *ss, pa_bool_t capture);
int pa_alsa_safe_delay(snd_pcm_t *pcm, snd_pcm_status_t *status, snd_pcm_sframes_t *delay, size_t hwbuf_size, const pa_sample_spec *ss, bool capture);
int pa_alsa_safe_mmap_begin(snd_pcm_t *pcm, const snd_pcm_channel_area_t **areas, snd_pcm_uframes_t *offset, snd_pcm_uframes_t *frames, size_t hwbuf_size, const pa_sample_spec *ss);
char *pa_alsa_get_driver_name(int card);
@ -135,12 +135,12 @@ char *pa_alsa_get_reserve_name(const char *device);
unsigned int *pa_alsa_get_supported_rates(snd_pcm_t *pcm, unsigned int fallback_rate);
pa_bool_t pa_alsa_pcm_is_hw(snd_pcm_t *pcm);
pa_bool_t pa_alsa_pcm_is_modem(snd_pcm_t *pcm);
bool pa_alsa_pcm_is_hw(snd_pcm_t *pcm);
bool pa_alsa_pcm_is_modem(snd_pcm_t *pcm);
const char* pa_alsa_strerror(int errnum);
pa_bool_t pa_alsa_may_tsched(pa_bool_t want);
bool pa_alsa_may_tsched(bool want);
snd_hctl_elem_t* pa_alsa_find_jack(snd_hctl_t *hctl, const char* jack_name);
snd_hctl_elem_t* pa_alsa_find_eld_ctl(snd_hctl_t *hctl, int device);

30
src/modules/alsa/module-alsa-card.c
View file

@ -45,7 +45,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("ALSA Card");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
PA_MODULE_USAGE(
"name=<name for the card/sink/source, to be prefixed> "
"card_name=<name for the card> "
@ -122,7 +122,7 @@ struct userdata {
pa_alsa_profile_set *profile_set;
/* ucm stuffs */
pa_bool_t use_ucm;
bool use_ucm;
pa_alsa_ucm_config ucm;
/* hooks for modifier action */
@ -158,7 +158,7 @@ static void add_profiles(struct userdata *u, pa_hashmap *h, pa_hashmap *ports) {
PA_IDXSET_FOREACH(m, ap->output_mappings, idx) {
if (u->use_ucm)
pa_alsa_ucm_add_ports_combination(NULL, &m->ucm_context, TRUE, ports, cp, u->core);
pa_alsa_ucm_add_ports_combination(NULL, &m->ucm_context, true, ports, cp, u->core);
else
pa_alsa_path_set_add_ports(m->output_path_set, cp, ports, NULL, u->core);
if (m->channel_map.channels > cp->max_sink_channels)
@ -171,7 +171,7 @@ static void add_profiles(struct userdata *u, pa_hashmap *h, pa_hashmap *ports) {
PA_IDXSET_FOREACH(m, ap->input_mappings, idx) {
if (u->use_ucm)
pa_alsa_ucm_add_ports_combination(NULL, &m->ucm_context, FALSE, ports, cp, u->core);
pa_alsa_ucm_add_ports_combination(NULL, &m->ucm_context, false, ports, cp, u->core);
else
pa_alsa_path_set_add_ports(m->input_path_set, cp, ports, NULL, u->core);
if (m->channel_map.channels > cp->max_source_channels)
@ -256,7 +256,7 @@ static int card_set_profile(pa_card *c, pa_card_profile *new_profile) {
am->sink = pa_alsa_sink_new(c->module, u->modargs, __FILE__, c, am);
if (sink_inputs && am->sink) {
pa_sink_move_all_finish(am->sink, sink_inputs, FALSE);
pa_sink_move_all_finish(am->sink, sink_inputs, false);
sink_inputs = NULL;
}
}
@ -268,7 +268,7 @@ static int card_set_profile(pa_card *c, pa_card_profile *new_profile) {
am->source = pa_alsa_source_new(c->module, u->modargs, __FILE__, c, am);
if (source_outputs && am->source) {
pa_source_move_all_finish(am->source, source_outputs, FALSE);
pa_source_move_all_finish(am->source, source_outputs, false);
source_outputs = NULL;
}
}
@ -349,7 +349,7 @@ static void report_port_state(pa_device_port *p, struct userdata *u) {
static int report_jack_state(snd_hctl_elem_t *elem, unsigned int mask) {
struct userdata *u = snd_hctl_elem_get_callback_private(elem);
snd_ctl_elem_value_t *elem_value;
pa_bool_t plugged_in;
bool plugged_in;
void *state;
pa_alsa_jack *jack;
pa_device_port *port;
@ -502,7 +502,7 @@ static void init_jacks(struct userdata *u) {
jack->hctl_elem = pa_alsa_find_jack(u->hctl_handle, jack->alsa_name);
if (!jack->hctl_elem) {
pa_log_warn("Jack '%s' seems to have disappeared.", jack->alsa_name);
jack->has_control = FALSE;
jack->has_control = false;
continue;
}
snd_hctl_elem_set_callback_private(jack->hctl_elem, u);
@ -525,15 +525,15 @@ static void set_card_name(pa_card_new_data *data, pa_modargs *ma, const char *de
if ((n = pa_modargs_get_value(ma, "card_name", NULL))) {
pa_card_new_data_set_name(data, n);
data->namereg_fail = TRUE;
data->namereg_fail = true;
return;
}
if ((n = pa_modargs_get_value(ma, "name", NULL)))
data->namereg_fail = TRUE;
data->namereg_fail = true;
else {
n = device_id;
data->namereg_fail = FALSE;
data->namereg_fail = false;
}
t = pa_sprintf_malloc("alsa_card.%s", n);
@ -604,13 +604,13 @@ static pa_hook_result_t source_output_unlink_hook_callback(pa_core *c, pa_source
int pa__init(pa_module *m) {
pa_card_new_data data;
pa_modargs *ma;
pa_bool_t ignore_dB = FALSE;
bool ignore_dB = false;
struct userdata *u;
pa_reserve_wrapper *reserve = NULL;
const char *description;
const char *profile = NULL;
char *fn = NULL;
pa_bool_t namereg_fail = FALSE;
bool namereg_fail = false;
pa_alsa_refcnt_inc();
@ -632,7 +632,7 @@ int pa__init(pa_module *m) {
u->device_id = pa_xstrdup(pa_modargs_get_value(ma, "device_id", DEFAULT_DEVICE_ID));
u->modargs = ma;
u->use_ucm = TRUE;
u->use_ucm = true;
u->ucm.core = m->core;
if ((u->alsa_card_index = snd_card_get_index(u->device_id)) < 0) {
@ -673,7 +673,7 @@ int pa__init(pa_module *m) {
(pa_hook_cb_t) source_output_unlink_hook_callback, u);
}
else {
u->use_ucm = FALSE;
u->use_ucm = false;
#ifdef HAVE_UDEV
fn = pa_udev_get_property(u->alsa_card_index, "PULSE_PROFILE_SET");
#endif

2
src/modules/alsa/module-alsa-sink.c
View file

@ -35,7 +35,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("ALSA Sink");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
PA_MODULE_USAGE(
"name=<name of the sink, to be prefixed> "
"sink_name=<name for the sink> "

2
src/modules/alsa/module-alsa-source.c
View file

@ -44,7 +44,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("ALSA Source");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
PA_MODULE_USAGE(
"name=<name for the source, to be prefixed> "
"source_name=<name for the source> "

2
src/modules/dbus/iface-card.c
View file

@ -336,7 +336,7 @@ static void handle_set_active_profile(DBusConnection *conn, DBusMessage *msg, DB
return;
}
if ((r = pa_card_set_profile(c->card, pa_dbusiface_card_profile_get_name(new_active), TRUE)) < 0) {
if ((r = pa_card_set_profile(c->card, pa_dbusiface_card_profile_get_name(new_active), true)) < 0) {
pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED,
"Internal error in PulseAudio: pa_card_set_profile() failed with error code %i.", r);
return;

2
src/modules/dbus/iface-client.c
View file

@ -364,7 +364,7 @@ static void handle_remove_properties(DBusConnection *conn, DBusMessage *msg, voi
pa_dbusiface_client *c = userdata;
char **keys = NULL;
int n_keys = 0;
pa_bool_t changed = FALSE;
bool changed = false;
int i = 0;
pa_assert(conn);

14
src/modules/dbus/iface-core.c
View file

@ -365,7 +365,7 @@ static dbus_bool_t get_is_local(DBusConnection *conn) {
pa_assert(conn);
if (!dbus_connection_get_socket(conn, &conn_fd))
return FALSE;
return false;
return pa_socket_is_local(conn_fd);
}
@ -1407,9 +1407,9 @@ static void handle_upload_sample(DBusConnection *conn, DBusMessage *msg, void *u
sample->volume.channels = n_channels;
for (i = 0; i < n_volume_entries; ++i)
sample->volume.values[i] = default_volume[i];
sample->volume_is_set = TRUE;
sample->volume_is_set = true;
} else {
sample->volume_is_set = FALSE;
sample->volume_is_set = false;
}
dbus_sample = pa_dbusiface_sample_new(c, sample);
@ -1427,17 +1427,17 @@ finish:
pa_memblock_unref(chunk.memblock);
}
static pa_bool_t contains_space(const char *string) {
static bool contains_space(const char *string) {
const char *p;
pa_assert(string);
for (p = string; *p; ++p) {
if (isspace(*p))
return TRUE;
return true;
}
return FALSE;
return false;
}
static void handle_load_module(DBusConnection *conn, DBusMessage *msg, void *userdata) {
@ -1530,7 +1530,7 @@ static void handle_exit(DBusConnection *conn, DBusMessage *msg, void *userdata)
pa_dbus_send_empty_reply(conn, msg);
pa_core_exit(c->core, FALSE, 0);
pa_core_exit(c->core, false, 0);
}
static void handle_listen_for_signal(DBusConnection *conn, DBusMessage *msg, void *userdata) {

64
src/modules/dbus/iface-device.c
View file

@ -440,29 +440,29 @@ static void handle_set_volume(DBusConnection *conn, DBusMessage *msg, DBusMessag
}
if (d->type == PA_DEVICE_TYPE_SINK)
pa_sink_set_volume(d->sink, &new_vol, TRUE, TRUE);
pa_sink_set_volume(d->sink, &new_vol, true, true);
else
pa_source_set_volume(d->source, &new_vol, TRUE, TRUE);
pa_source_set_volume(d->source, &new_vol, true, true);
pa_dbus_send_empty_reply(conn, msg);
}
static void handle_get_has_flat_volume(DBusConnection *conn, DBusMessage *msg, void *userdata) {
pa_dbusiface_device *d = userdata;
dbus_bool_t has_flat_volume = FALSE;
dbus_bool_t has_flat_volume = false;
pa_assert(conn);
pa_assert(msg);
pa_assert(d);
has_flat_volume = (d->type == PA_DEVICE_TYPE_SINK) ? (d->sink->flags & PA_SINK_FLAT_VOLUME) : FALSE;
has_flat_volume = (d->type == PA_DEVICE_TYPE_SINK) ? (d->sink->flags & PA_SINK_FLAT_VOLUME) : false;
pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_BOOLEAN, &has_flat_volume);
}
static void handle_get_has_convertible_to_decibel_volume(DBusConnection *conn, DBusMessage *msg, void *userdata) {
pa_dbusiface_device *d = userdata;
dbus_bool_t has_convertible_to_decibel_volume = FALSE;
dbus_bool_t has_convertible_to_decibel_volume = false;
pa_assert(conn);
pa_assert(msg);
@ -513,7 +513,7 @@ static void handle_get_mute(DBusConnection *conn, DBusMessage *msg, void *userda
static void handle_set_mute(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) {
pa_dbusiface_device *d = userdata;
dbus_bool_t mute = FALSE;
dbus_bool_t mute = false;
pa_assert(conn);
pa_assert(msg);
@ -523,16 +523,16 @@ static void handle_set_mute(DBusConnection *conn, DBusMessage *msg, DBusMessageI
dbus_message_iter_get_basic(iter, &mute);
if (d->type == PA_DEVICE_TYPE_SINK)
pa_sink_set_mute(d->sink, mute, TRUE);
pa_sink_set_mute(d->sink, mute, true);
else
pa_source_set_mute(d->source, mute, TRUE);
pa_source_set_mute(d->source, mute, true);
pa_dbus_send_empty_reply(conn, msg);
}
static void handle_get_has_hardware_volume(DBusConnection *conn, DBusMessage *msg, void *userdata) {
pa_dbusiface_device *d = userdata;
dbus_bool_t has_hardware_volume = FALSE;
dbus_bool_t has_hardware_volume = false;
pa_assert(conn);
pa_assert(msg);
@ -547,7 +547,7 @@ static void handle_get_has_hardware_volume(DBusConnection *conn, DBusMessage *ms
static void handle_get_has_hardware_mute(DBusConnection *conn, DBusMessage *msg, void *userdata) {
pa_dbusiface_device *d = userdata;
dbus_bool_t has_hardware_mute = FALSE;
dbus_bool_t has_hardware_mute = false;
pa_assert(conn);
pa_assert(msg);
@ -577,7 +577,7 @@ static void handle_get_configured_latency(DBusConnection *conn, DBusMessage *msg
static void handle_get_has_dynamic_latency(DBusConnection *conn, DBusMessage *msg, void *userdata) {
pa_dbusiface_device *d = userdata;
dbus_bool_t has_dynamic_latency = FALSE;
dbus_bool_t has_dynamic_latency = false;
pa_assert(conn);
pa_assert(msg);
@ -617,7 +617,7 @@ static void handle_get_latency(DBusConnection *conn, DBusMessage *msg, void *use
static void handle_get_is_hardware_device(DBusConnection *conn, DBusMessage *msg, void *userdata) {
pa_dbusiface_device *d = userdata;
dbus_bool_t is_hardware_device = FALSE;
dbus_bool_t is_hardware_device = false;
pa_assert(conn);
pa_assert(msg);
@ -632,7 +632,7 @@ static void handle_get_is_hardware_device(DBusConnection *conn, DBusMessage *msg
static void handle_get_is_network_device(DBusConnection *conn, DBusMessage *msg, void *userdata) {
pa_dbusiface_device *d = userdata;
dbus_bool_t is_network_device = FALSE;
dbus_bool_t is_network_device = false;
pa_assert(conn);
pa_assert(msg);
@ -753,13 +753,13 @@ static void handle_set_active_port(DBusConnection *conn, DBusMessage *msg, DBusM
}
if (d->type == PA_DEVICE_TYPE_SINK) {
if ((r = pa_sink_set_port(d->sink, pa_dbusiface_device_port_get_name(new_active), TRUE)) < 0) {
if ((r = pa_sink_set_port(d->sink, pa_dbusiface_device_port_get_name(new_active), true)) < 0) {
pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED,
"Internal error in PulseAudio: pa_sink_set_port() failed with error code %i.", r);
return;
}
} else {
if ((r = pa_source_set_port(d->source, pa_dbusiface_device_port_get_name(new_active), TRUE)) < 0) {
if ((r = pa_source_set_port(d->source, pa_dbusiface_device_port_get_name(new_active), true)) < 0) {
pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED,
"Internal error in PulseAudio: pa_source_set_port() failed with error code %i.", r);
return;
@ -796,17 +796,17 @@ static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdat
pa_channel_map *channel_map = NULL;
dbus_uint32_t channels[PA_CHANNELS_MAX];
dbus_uint32_t volume[PA_CHANNELS_MAX];
dbus_bool_t has_flat_volume = FALSE;
dbus_bool_t has_convertible_to_decibel_volume = FALSE;
dbus_bool_t has_flat_volume = false;
dbus_bool_t has_convertible_to_decibel_volume = false;
dbus_uint32_t base_volume = 0;
dbus_uint32_t volume_steps = 0;
dbus_bool_t has_hardware_volume = FALSE;
dbus_bool_t has_hardware_mute = FALSE;
dbus_bool_t has_hardware_volume = false;
dbus_bool_t has_hardware_mute = false;
dbus_uint64_t configured_latency = 0;
dbus_bool_t has_dynamic_latency = FALSE;
dbus_bool_t has_dynamic_latency = false;
dbus_uint64_t latency = 0;
dbus_bool_t is_hardware_device = FALSE;
dbus_bool_t is_network_device = FALSE;
dbus_bool_t is_hardware_device = false;
dbus_bool_t is_network_device = false;
dbus_uint32_t state = 0;
const char **ports = NULL;
unsigned n_ports = 0;
@ -847,7 +847,7 @@ static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdat
sample_format = d->source->sample_spec.format;
sample_rate = d->source->sample_spec.rate;
channel_map = &d->source->channel_map;
has_flat_volume = FALSE;
has_flat_volume = false;
has_convertible_to_decibel_volume = d->source->flags & PA_SOURCE_DECIBEL_VOLUME;
base_volume = d->source->base_volume;
volume_steps = d->source->n_volume_steps;
@ -922,7 +922,7 @@ static void handle_get_all(DBusConnection *conn, DBusMessage *msg, void *userdat
static void handle_suspend(DBusConnection *conn, DBusMessage *msg, void *userdata) {
pa_dbusiface_device *d = userdata;
dbus_bool_t suspend = FALSE;
dbus_bool_t suspend = false;
pa_client *client;
pa_assert(conn);
@ -1074,7 +1074,7 @@ static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t
pa_dbusiface_device *d = userdata;
DBusMessage *signal_msg = NULL;
const pa_cvolume *new_volume = NULL;
pa_bool_t new_mute = FALSE;
bool new_mute = false;
pa_sink_state_t new_sink_state = 0;
pa_source_state_t new_source_state = 0;
pa_device_port *new_active_port = NULL;
@ -1096,8 +1096,8 @@ static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t
&& ((t & PA_SUBSCRIPTION_EVENT_FACILITY_MASK) == PA_SUBSCRIPTION_EVENT_SOURCE)));
new_volume = (d->type == PA_DEVICE_TYPE_SINK)
? pa_sink_get_volume(d->sink, FALSE)
: pa_source_get_volume(d->source, FALSE);
? pa_sink_get_volume(d->sink, false)
: pa_source_get_volume(d->source, false);
if (!pa_cvolume_equal(&d->volume, new_volume)) {
dbus_uint32_t volume[PA_CHANNELS_MAX];
@ -1120,7 +1120,7 @@ static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t
signal_msg = NULL;
}
new_mute = (d->type == PA_DEVICE_TYPE_SINK) ? pa_sink_get_mute(d->sink, FALSE) : pa_source_get_mute(d->source, FALSE);
new_mute = (d->type == PA_DEVICE_TYPE_SINK) ? pa_sink_get_mute(d->sink, false) : pa_source_get_mute(d->source, false);
if (d->mute != new_mute) {
d->mute = new_mute;
@ -1211,8 +1211,8 @@ pa_dbusiface_device *pa_dbusiface_device_new_sink(pa_dbusiface_core *core, pa_si
d->sink = pa_sink_ref(sink);
d->type = PA_DEVICE_TYPE_SINK;
d->path = pa_sprintf_malloc("%s/%s%u", PA_DBUS_CORE_OBJECT_PATH, SINK_OBJECT_NAME, sink->index);
d->volume = *pa_sink_get_volume(sink, FALSE);
d->mute = pa_sink_get_mute(sink, FALSE);
d->volume = *pa_sink_get_volume(sink, false);
d->mute = pa_sink_get_mute(sink, false);
d->sink_state = pa_sink_get_state(sink);
d->ports = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
d->next_port_index = 0;
@ -1245,8 +1245,8 @@ pa_dbusiface_device *pa_dbusiface_device_new_source(pa_dbusiface_core *core, pa_
d->source = pa_source_ref(source);
d->type = PA_DEVICE_TYPE_SOURCE;
d->path = pa_sprintf_malloc("%s/%s%u", PA_DBUS_CORE_OBJECT_PATH, SOURCE_OBJECT_NAME, source->index);
d->volume = *pa_source_get_volume(source, FALSE);
d->mute = pa_source_get_mute(source, FALSE);
d->volume = *pa_source_get_volume(source, false);
d->mute = pa_source_get_mute(source, false);
d->source_state = pa_source_get_state(source);
d->ports = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
d->next_port_index = 0;

2
src/modules/dbus/iface-module.c
View file

@ -261,7 +261,7 @@ static void handle_unload(DBusConnection *conn, DBusMessage *msg, void *userdata
return;
}
pa_module_unload_request(m->module, FALSE);
pa_module_unload_request(m->module, false);
pa_dbus_send_empty_reply(conn, msg);
}

26
src/modules/dbus/iface-stream.c
View file

@ -56,7 +56,7 @@ struct pa_dbusiface_stream {
dbus_bool_t mute;
pa_proplist *proplist;
pa_bool_t has_volume;
bool has_volume;
pa_dbus_protocol *dbus_protocol;
pa_subscription *subscription;
@ -356,7 +356,7 @@ static void handle_get_volume(DBusConnection *conn, DBusMessage *msg, void *user
static void handle_set_volume(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) {
pa_dbusiface_stream *s = userdata;
pa_bool_t volume_writable = TRUE;
bool volume_writable = true;
DBusMessageIter array_iter;
int stream_channels = 0;
dbus_uint32_t *volume = NULL;
@ -369,7 +369,7 @@ static void handle_set_volume(DBusConnection *conn, DBusMessage *msg, DBusMessag
pa_assert(iter);
pa_assert(s);
volume_writable = (s->type == STREAM_TYPE_PLAYBACK) ? s->sink_input->volume_writable : FALSE;
volume_writable = (s->type == STREAM_TYPE_PLAYBACK) ? s->sink_input->volume_writable : false;
if (!s->has_volume || !volume_writable) {
char *str = stream_to_string(s);
@ -405,7 +405,7 @@ static void handle_set_volume(DBusConnection *conn, DBusMessage *msg, DBusMessag
new_vol.values[i] = volume[i];
}
pa_sink_input_set_volume(s->sink_input, &new_vol, TRUE, TRUE);
pa_sink_input_set_volume(s->sink_input, &new_vol, true, true);
pa_dbus_send_empty_reply(conn, msg);
}
@ -427,7 +427,7 @@ static void handle_get_mute(DBusConnection *conn, DBusMessage *msg, void *userda
static void handle_set_mute(DBusConnection *conn, DBusMessage *msg, DBusMessageIter *iter, void *userdata) {
pa_dbusiface_stream *s = userdata;
dbus_bool_t mute = FALSE;
dbus_bool_t mute = false;
pa_assert(conn);
pa_assert(msg);
@ -441,7 +441,7 @@ static void handle_set_mute(DBusConnection *conn, DBusMessage *msg, DBusMessageI
return;
}
pa_sink_input_set_mute(s->sink_input, mute, TRUE);
pa_sink_input_set_mute(s->sink_input, mute, true);
pa_dbus_send_empty_reply(conn, msg);
}
@ -621,7 +621,7 @@ static void handle_move(DBusConnection *conn, DBusMessage *msg, void *userdata)
return;
}
if (pa_sink_input_move_to(s->sink_input, sink, TRUE) < 0) {
if (pa_sink_input_move_to(s->sink_input, sink, true) < 0) {
pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED,
"Moving playback stream %u to sink %s failed.", s->sink_input->index, sink->name);
return;
@ -634,7 +634,7 @@ static void handle_move(DBusConnection *conn, DBusMessage *msg, void *userdata)
return;
}
if (pa_source_output_move_to(s->source_output, source, TRUE) < 0) {
if (pa_source_output_move_to(s->source_output, source, true) < 0) {
pa_dbus_send_error(conn, msg, DBUS_ERROR_FAILED,
"Moving record stream %u to source %s failed.", s->source_output->index, source->name);
return;
@ -736,12 +736,12 @@ static void subscription_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t
}
if (s->type == STREAM_TYPE_PLAYBACK) {
pa_bool_t new_mute = FALSE;
bool new_mute = false;
if (s->has_volume) {
pa_cvolume new_volume;
pa_sink_input_get_volume(s->sink_input, &new_volume, TRUE);
pa_sink_input_get_volume(s->sink_input, &new_volume, true);
if (!pa_cvolume_equal(&s->volume, &new_volume)) {
dbus_uint32_t volume[PA_CHANNELS_MAX];
@ -857,7 +857,7 @@ pa_dbusiface_stream *pa_dbusiface_stream_new_playback(pa_dbusiface_core *core, p
s->has_volume = pa_sink_input_is_volume_readable(sink_input);
if (s->has_volume)
pa_sink_input_get_volume(sink_input, &s->volume, TRUE);
pa_sink_input_get_volume(sink_input, &s->volume, true);
else
pa_cvolume_init(&s->volume);
@ -889,9 +889,9 @@ pa_dbusiface_stream *pa_dbusiface_stream_new_record(pa_dbusiface_core *core, pa_
s->source = pa_source_ref(source_output->source);
s->sample_rate = source_output->sample_spec.rate;
pa_cvolume_init(&s->volume);
s->mute = FALSE;
s->mute = false;
s->proplist = pa_proplist_copy(source_output->proplist);
s->has_volume = FALSE;
s->has_volume = false;
s->dbus_protocol = pa_dbus_protocol_get(source_output->core);
s->subscription = pa_subscription_new(source_output->core, PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT, subscription_cb, s);
s->send_event_slot = pa_hook_connect(&source_output->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_SEND_EVENT],

36
src/modules/dbus/module-dbus-protocol.c
View file

@ -50,7 +50,7 @@ PA_MODULE_USAGE(
"access=local|remote|local,remote "
"tcp_port=<port number> "
"tcp_listen=<hostname>");
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_AUTHOR("Tanu Kaskinen");
PA_MODULE_VERSION(PACKAGE_VERSION);
@ -64,8 +64,8 @@ struct connection;
struct userdata {
pa_module *module;
pa_bool_t local_access;
pa_bool_t remote_access;
bool local_access;
bool remote_access;
uint32_t tcp_port;
char *tcp_listen;
@ -152,7 +152,7 @@ static void client_send_event_cb(pa_client *c, const char *name, pa_proplist *da
static dbus_bool_t user_check_cb(DBusConnection *connection, unsigned long uid, void *data) {
pa_log_debug("Allowing connection by user %lu.", uid);
return TRUE;
return true;
}
static DBusHandlerResult disconnection_filter_cb(DBusConnection *connection, DBusMessage *message, void *user_data) {
@ -198,12 +198,12 @@ static void connection_new_cb(DBusServer *dbus_server, DBusConnection *new_conne
/* FIXME: Here we allow anyone from anywhere to access the server,
* anonymously. Access control should be configurable. */
dbus_connection_set_unix_user_function(new_connection, user_check_cb, NULL, NULL);
dbus_connection_set_allow_anonymous(new_connection, TRUE);
dbus_connection_set_allow_anonymous(new_connection, true);
}
c = pa_xnew(struct connection, 1);
c->server = s;
c->wrap_conn = pa_dbus_wrap_connection_new_from_existing(s->userdata->module->core->mainloop, TRUE, new_connection);
c->wrap_conn = pa_dbus_wrap_connection_new_from_existing(s->userdata->module->core->mainloop, true, new_connection);
c->client = client;
c->client->kill = client_kill_cb;
@ -302,7 +302,7 @@ static dbus_bool_t watch_add_cb(DBusWatch *watch, void *data) {
dbus_watch_set_data(watch, ev, NULL);
return TRUE;
return true;
}
/* Called by D-Bus when a D-Bus fd watch event is removed. */
@ -342,7 +342,7 @@ static dbus_bool_t timeout_add_cb(DBusTimeout *timeout, void *data) {
pa_assert(s);
if (!dbus_timeout_get_enabled(timeout))
return FALSE;
return false;
mainloop = s->userdata->module->core->mainloop;
@ -353,7 +353,7 @@ static dbus_bool_t timeout_add_cb(DBusTimeout *timeout, void *data) {
dbus_timeout_set_data(timeout, ev, NULL);
return TRUE;
return true;
}
/* Called by D-Bus when a D-Bus timer event is removed. */
@ -482,7 +482,7 @@ static struct server *start_tcp_server(struct userdata *u) {
return s;
}
static int get_access_arg(pa_modargs *ma, pa_bool_t *local_access, pa_bool_t *remote_access) {
static int get_access_arg(pa_modargs *ma, bool *local_access, bool *remote_access) {
const char *value = NULL;
pa_assert(ma);
@ -493,14 +493,14 @@ static int get_access_arg(pa_modargs *ma, pa_bool_t *local_access, pa_bool_t *re
return 0;
if (pa_streq(value, "local")) {
*local_access = TRUE;
*remote_access = FALSE;
*local_access = true;
*remote_access = false;
} else if (pa_streq(value, "remote")) {
*local_access = FALSE;
*remote_access = TRUE;
*local_access = false;
*remote_access = true;
} else if (pa_streq(value, "local,remote")) {
*local_access = TRUE;
*remote_access = TRUE;
*local_access = true;
*remote_access = true;
} else
return -1;
@ -536,8 +536,8 @@ int pa__init(pa_module *m) {
m->userdata = u = pa_xnew0(struct userdata, 1);
u->module = m;
u->local_access = TRUE;
u->remote_access = FALSE;
u->local_access = true;
u->remote_access = false;
u->tcp_port = PA_DBUS_DEFAULT_PORT;
if (get_access_arg(ma, &u->local_access, &u->remote_access) < 0) {

6
src/modules/echo-cancel/adrian.c
View file

@ -56,7 +56,7 @@ static void pa_adrian_ec_fixate_spec(pa_sample_spec *rec_ss, pa_channel_map *rec
*rec_map = *out_map;
}
pa_bool_t pa_adrian_ec_init(pa_core *c, pa_echo_canceller *ec,
bool pa_adrian_ec_init(pa_core *c, pa_echo_canceller *ec,
pa_sample_spec *rec_ss, pa_channel_map *rec_map,
pa_sample_spec *play_ss, pa_channel_map *play_map,
pa_sample_spec *out_ss, pa_channel_map *out_map,
@ -93,12 +93,12 @@ pa_bool_t pa_adrian_ec_init(pa_core *c, pa_echo_canceller *ec,
goto fail;
pa_modargs_free(ma);
return TRUE;
return true;
fail:
if (ma)
pa_modargs_free(ma);
return FALSE;
return false;
}
void pa_adrian_ec_run(pa_echo_canceller *ec, const uint8_t *rec, const uint8_t *play, uint8_t *out) {

14
src/modules/echo-cancel/echo-cancel.h
View file

@ -68,7 +68,7 @@ struct pa_echo_canceller_params {
void *apm;
uint32_t blocksize;
pa_sample_spec sample_spec;
pa_bool_t agc;
bool agc;
} webrtc;
#endif
/* each canceller-specific structure goes here */
@ -76,14 +76,14 @@ struct pa_echo_canceller_params {
/* Set this if canceller can do drift compensation. Also see set_drift()
* below */
pa_bool_t drift_compensation;
bool drift_compensation;
};
typedef struct pa_echo_canceller pa_echo_canceller;
struct pa_echo_canceller {
/* Initialise canceller engine. */
pa_bool_t (*init) (pa_core *c,
bool (*init) (pa_core *c,
pa_echo_canceller *ec,
pa_sample_spec *rec_ss,
pa_channel_map *rec_map,
@ -138,7 +138,7 @@ void pa_echo_canceller_set_capture_volume(pa_echo_canceller *ec, pa_cvolume *v);
uint32_t pa_echo_canceller_blocksize_power2(unsigned rate, unsigned ms);
/* Null canceller functions */
pa_bool_t pa_null_ec_init(pa_core *c, pa_echo_canceller *ec,
bool pa_null_ec_init(pa_core *c, pa_echo_canceller *ec,
pa_sample_spec *rec_ss, pa_channel_map *rec_map,
pa_sample_spec *play_ss, pa_channel_map *play_map,
pa_sample_spec *out_ss, pa_channel_map *out_map,
@ -148,7 +148,7 @@ void pa_null_ec_done(pa_echo_canceller *ec);
#ifdef HAVE_SPEEX
/* Speex canceller functions */
pa_bool_t pa_speex_ec_init(pa_core *c, pa_echo_canceller *ec,
bool pa_speex_ec_init(pa_core *c, pa_echo_canceller *ec,
pa_sample_spec *rec_ss, pa_channel_map *rec_map,
pa_sample_spec *play_ss, pa_channel_map *play_map,
pa_sample_spec *out_ss, pa_channel_map *out_map,
@ -159,7 +159,7 @@ void pa_speex_ec_done(pa_echo_canceller *ec);
#ifdef HAVE_ADRIAN_EC
/* Adrian Andre's echo canceller */
pa_bool_t pa_adrian_ec_init(pa_core *c, pa_echo_canceller *ec,
bool pa_adrian_ec_init(pa_core *c, pa_echo_canceller *ec,
pa_sample_spec *rec_ss, pa_channel_map *rec_map,
pa_sample_spec *play_ss, pa_channel_map *play_map,
pa_sample_spec *out_ss, pa_channel_map *out_map,
@ -171,7 +171,7 @@ void pa_adrian_ec_done(pa_echo_canceller *ec);
#ifdef HAVE_WEBRTC
/* WebRTC canceller functions */
PA_C_DECL_BEGIN
pa_bool_t pa_webrtc_ec_init(pa_core *c, pa_echo_canceller *ec,
bool pa_webrtc_ec_init(pa_core *c, pa_echo_canceller *ec,
pa_sample_spec *rec_ss, pa_channel_map *rec_map,
pa_sample_spec *play_ss, pa_channel_map *play_map,
pa_sample_spec *out_ss, pa_channel_map *out_map,

82
src/modules/echo-cancel/module-echo-cancel.c
View file

@ -58,7 +58,7 @@
PA_MODULE_AUTHOR("Wim Taymans");
PA_MODULE_DESCRIPTION("Echo Cancellation");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
PA_MODULE_USAGE(
_("source_name=<name for the source> "
"source_properties=<properties for the source> "
@ -140,8 +140,8 @@ static const pa_echo_canceller ec_table[] = {
#define DEFAULT_CHANNELS 1
#define DEFAULT_ADJUST_TIME_USEC (1*PA_USEC_PER_SEC)
#define DEFAULT_ADJUST_TOLERANCE (5*PA_USEC_PER_MSEC)
#define DEFAULT_SAVE_AEC FALSE
#define DEFAULT_AUTOLOADED FALSE
#define DEFAULT_SAVE_AEC false
#define DEFAULT_AUTOLOADED false
#define MEMBLOCKQ_MAXLENGTH (16*1024*1024)
@ -206,29 +206,29 @@ struct userdata {
pa_core *core;
pa_module *module;
pa_bool_t autoloaded;
pa_bool_t dead;
pa_bool_t save_aec;
bool autoloaded;
bool dead;
bool save_aec;
pa_echo_canceller *ec;
uint32_t source_output_blocksize;
uint32_t source_blocksize;
uint32_t sink_blocksize;
pa_bool_t need_realign;
bool need_realign;
/* to wakeup the source I/O thread */
pa_asyncmsgq *asyncmsgq;
pa_rtpoll_item *rtpoll_item_read, *rtpoll_item_write;
pa_source *source;
pa_bool_t source_auto_desc;
bool source_auto_desc;
pa_source_output *source_output;
pa_memblockq *source_memblockq; /* echo canceler needs fixed sized chunks */
size_t source_skip;
pa_sink *sink;
pa_bool_t sink_auto_desc;
bool sink_auto_desc;
pa_sink_input *sink_input;
pa_memblockq *sink_memblockq;
int64_t send_counter; /* updated in sink IO thread */
@ -250,7 +250,7 @@ struct userdata {
FILE *canceled_file;
FILE *drift_file;
pa_bool_t use_volume_sharing;
bool use_volume_sharing;
struct {
pa_cvolume current_volume;
@ -479,9 +479,9 @@ static int source_set_state_cb(pa_source *s, pa_source_state_t state) {
pa_core_rttime_restart(u->core, u->time_event, pa_rtclock_now() + u->adjust_time);
pa_atomic_store(&u->request_resync, 1);
pa_source_output_cork(u->source_output, FALSE);
pa_source_output_cork(u->source_output, false);
} else if (state == PA_SOURCE_SUSPENDED) {
pa_source_output_cork(u->source_output, TRUE);
pa_source_output_cork(u->source_output, true);
}
return 0;
@ -504,9 +504,9 @@ static int sink_set_state_cb(pa_sink *s, pa_sink_state_t state) {
pa_core_rttime_restart(u->core, u->time_event, pa_rtclock_now() + u->adjust_time);
pa_atomic_store(&u->request_resync, 1);
pa_sink_input_cork(u->sink_input, FALSE);
pa_sink_input_cork(u->sink_input, false);
} else if (state == PA_SINK_SUSPENDED) {
pa_sink_input_cork(u->sink_input, TRUE);
pa_sink_input_cork(u->sink_input, true);
}
return 0;
@ -565,7 +565,7 @@ static void sink_request_rewind_cb(pa_sink *s) {
/* Just hand this one over to the master sink */
pa_sink_input_request_rewind(u->sink_input,
s->thread_info.rewind_nbytes, TRUE, FALSE, FALSE);
s->thread_info.rewind_nbytes, true, false, false);
}
/* Called from main context */
@ -579,7 +579,7 @@ static void source_set_volume_cb(pa_source *s) {
!PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u->source_output)))
return;
pa_source_output_set_volume(u->source_output, &s->real_volume, s->save_volume, TRUE);
pa_source_output_set_volume(u->source_output, &s->real_volume, s->save_volume, true);
}
/* Called from main context */
@ -593,7 +593,7 @@ static void sink_set_volume_cb(pa_sink *s) {
!PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u->sink_input)))
return;
pa_sink_input_set_volume(u->sink_input, &s->real_volume, s->save_volume, TRUE);
pa_sink_input_set_volume(u->sink_input, &s->real_volume, s->save_volume, true);
}
/* Called from main context. */
@ -608,7 +608,7 @@ static void source_get_volume_cb(pa_source *s) {
!PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u->source_output)))
return;
pa_source_output_get_volume(u->source_output, &v, TRUE);
pa_source_output_get_volume(u->source_output, &v, true);
if (pa_cvolume_equal(&s->real_volume, &v))
/* no change */
@ -1003,7 +1003,7 @@ static void source_output_process_rewind_cb(pa_source_output *o, size_t nbytes)
pa_memblockq_rewind(u->sink_memblockq, nbytes);
/* manipulate write index */
pa_memblockq_seek(u->source_memblockq, -nbytes, PA_SEEK_RELATIVE, TRUE);
pa_memblockq_seek(u->source_memblockq, -nbytes, PA_SEEK_RELATIVE, true);
pa_log_debug("Source rewind (%lld) %lld", (long long) nbytes,
(long long) pa_memblockq_get_length (u->source_memblockq));
@ -1058,7 +1058,7 @@ static int source_output_process_msg_cb(pa_msgobject *obj, int code, void *data,
if (u->source_output->source->thread_info.state == PA_SOURCE_RUNNING)
pa_memblockq_push_align(u->sink_memblockq, chunk);
else
pa_memblockq_flush_write(u->sink_memblockq, TRUE);
pa_memblockq_flush_write(u->sink_memblockq, true);
u->recv_counter += (int64_t) chunk->length;
@ -1069,9 +1069,9 @@ static int source_output_process_msg_cb(pa_msgobject *obj, int code, void *data,
/* manipulate write index, never go past what we have */
if (PA_SOURCE_IS_OPENED(u->source_output->source->thread_info.state))
pa_memblockq_seek(u->sink_memblockq, -offset, PA_SEEK_RELATIVE, TRUE);
pa_memblockq_seek(u->sink_memblockq, -offset, PA_SEEK_RELATIVE, true);
else
pa_memblockq_flush_write(u->sink_memblockq, TRUE);
pa_memblockq_flush_write(u->sink_memblockq, true);
pa_log_debug("Sink rewind (%lld)", (long long) offset);
@ -1363,7 +1363,7 @@ static void sink_input_state_change_cb(pa_sink_input *i, pa_sink_input_state_t s
if (PA_SINK_INPUT_IS_LINKED(state) &&
i->thread_info.state == PA_SINK_INPUT_INIT) {
pa_log_debug("Requesting rewind due to state change.");
pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
pa_sink_input_request_rewind(i, 0, false, true, true);
}
}
@ -1375,7 +1375,7 @@ static void source_output_kill_cb(pa_source_output *o) {
pa_assert_ctl_context();
pa_assert_se(u = o->userdata);
u->dead = TRUE;
u->dead = true;
/* The order here matters! We first kill the source output, followed
* by the source. That means the source callbacks must be protected
@ -1391,7 +1391,7 @@ static void source_output_kill_cb(pa_source_output *o) {
pa_log_debug("Source output kill %d", o->index);
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
/* Called from main context */
@ -1401,7 +1401,7 @@ static void sink_input_kill_cb(pa_sink_input *i) {
pa_sink_input_assert_ref(i);
pa_assert_se(u = i->userdata);
u->dead = TRUE;
u->dead = true;
/* The order here matters! We first kill the sink input, followed
* by the sink. That means the sink callbacks must be protected
@ -1417,11 +1417,11 @@ static void sink_input_kill_cb(pa_sink_input *i) {
pa_log_debug("Sink input kill %d", i->index);
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
/* Called from main context. */
static pa_bool_t source_output_may_move_to_cb(pa_source_output *o, pa_source *dest) {
static bool source_output_may_move_to_cb(pa_source_output *o, pa_source *dest) {
struct userdata *u;
pa_source_output_assert_ref(o);
@ -1429,20 +1429,20 @@ static pa_bool_t source_output_may_move_to_cb(pa_source_output *o, pa_source *de
pa_assert_se(u = o->userdata);
if (u->dead || u->autoloaded)
return FALSE;
return false;
return (u->source != dest) && (u->sink != dest->monitor_of);
}
/* Called from main context */
static pa_bool_t sink_input_may_move_to_cb(pa_sink_input *i, pa_sink *dest) {
static bool sink_input_may_move_to_cb(pa_sink_input *i, pa_sink *dest) {
struct userdata *u;
pa_sink_input_assert_ref(i);
pa_assert_se(u = i->userdata);
if (u->dead || u->autoloaded)
return FALSE;
return false;
return u->sink != dest;
}
@ -1539,9 +1539,9 @@ static int canceller_process_msg_cb(pa_msgobject *o, int code, void *userdata, i
pa_cvolume *v = (pa_cvolume *) userdata;
if (u->use_volume_sharing)
pa_source_set_volume(u->source, v, TRUE, FALSE);
pa_source_set_volume(u->source, v, true, false);
else
pa_source_output_set_volume(u->source_output, v, FALSE, TRUE);
pa_source_output_set_volume(u->source_output, v, false, true);
break;
}
@ -1698,9 +1698,9 @@ int pa__init(pa_module*m) {
u->core = m->core;
u->module = m;
m->userdata = u;
u->dead = FALSE;
u->dead = false;
u->use_volume_sharing = TRUE;
u->use_volume_sharing = true;
if (pa_modargs_get_value_boolean(ma, "use_volume_sharing", &u->use_volume_sharing) < 0) {
pa_log("use_volume_sharing= expects a boolean argument");
goto fail;
@ -1744,7 +1744,7 @@ int pa__init(pa_module*m) {
goto fail;
u->asyncmsgq = pa_asyncmsgq_new(0);
u->need_realign = TRUE;
u->need_realign = true;
source_output_ss = source_ss;
source_output_map = source_map;
@ -1815,7 +1815,7 @@ int pa__init(pa_module*m) {
if (!u->use_volume_sharing) {
pa_source_set_get_volume_callback(u->source, source_get_volume_cb);
pa_source_set_set_volume_callback(u->source, source_set_volume_cb);
pa_source_enable_decibel_volume(u->source, TRUE);
pa_source_enable_decibel_volume(u->source, true);
}
u->source->userdata = u;
@ -1865,7 +1865,7 @@ int pa__init(pa_module*m) {
pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
if (!u->use_volume_sharing) {
pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
pa_sink_enable_decibel_volume(u->sink, TRUE);
pa_sink_enable_decibel_volume(u->sink, true);
}
u->sink->userdata = u;
@ -1875,7 +1875,7 @@ int pa__init(pa_module*m) {
pa_source_output_new_data_init(&source_output_data);
source_output_data.driver = __FILE__;
source_output_data.module = m;
pa_source_output_new_data_set_source(&source_output_data, source_master, FALSE);
pa_source_output_new_data_set_source(&source_output_data, source_master, false);
source_output_data.destination_source = u->source;
pa_proplist_sets(source_output_data.proplist, PA_PROP_MEDIA_NAME, "Echo-Cancel Source Stream");
@ -1910,7 +1910,7 @@ int pa__init(pa_module*m) {
pa_sink_input_new_data_init(&sink_input_data);
sink_input_data.driver = __FILE__;
sink_input_data.module = m;
pa_sink_input_new_data_set_sink(&sink_input_data, sink_master, FALSE);
pa_sink_input_new_data_set_sink(&sink_input_data, sink_master, false);
sink_input_data.origin_sink = u->sink;
pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_NAME, "Echo-Cancel Sink Stream");
pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_ROLE, "filter");
@ -2029,7 +2029,7 @@ void pa__done(pa_module*m) {
if (!(u = m->userdata))
return;
u->dead = TRUE;
u->dead = true;
/* See comments in source_output_kill_cb() above regarding
* destruction order! */

4
src/modules/echo-cancel/null.c
View file

@ -25,7 +25,7 @@ PA_C_DECL_BEGIN
#include "echo-cancel.h"
PA_C_DECL_END
pa_bool_t pa_null_ec_init(pa_core *c, pa_echo_canceller *ec,
bool pa_null_ec_init(pa_core *c, pa_echo_canceller *ec,
pa_sample_spec *rec_ss, pa_channel_map *rec_map,
pa_sample_spec *play_ss, pa_channel_map *play_map,
pa_sample_spec *out_ss, pa_channel_map *out_map,
@ -43,7 +43,7 @@ pa_bool_t pa_null_ec_init(pa_core *c, pa_echo_canceller *ec,
pa_sample_spec_snprint(strss_source, sizeof(strss_source), out_ss),
pa_sample_spec_snprint(strss_sink, sizeof(strss_sink), play_ss));
return TRUE;
return true;
}
void pa_null_ec_run(pa_echo_canceller *ec, const uint8_t *rec, const uint8_t *play, uint8_t *out) {

24
src/modules/echo-cancel/speex.c
View file

@ -33,9 +33,9 @@
#define DEFAULT_FRAME_SIZE_MS 20
/* should be between 100-500 ms */
#define DEFAULT_FILTER_SIZE_MS 200
#define DEFAULT_AGC_ENABLED TRUE
#define DEFAULT_DENOISE_ENABLED TRUE
#define DEFAULT_ECHO_SUPPRESS_ENABLED TRUE
#define DEFAULT_AGC_ENABLED true
#define DEFAULT_DENOISE_ENABLED true
#define DEFAULT_ECHO_SUPPRESS_ENABLED true
#define DEFAULT_ECHO_SUPPRESS_ATTENUATION 0
static const char* const valid_modargs[] = {
@ -60,10 +60,10 @@ static void pa_speex_ec_fixate_spec(pa_sample_spec *rec_ss, pa_channel_map *rec_
*rec_map = *out_map;
}
static pa_bool_t pa_speex_ec_preprocessor_init(pa_echo_canceller *ec, pa_sample_spec *out_ss, uint32_t nframes, pa_modargs *ma) {
pa_bool_t agc;
pa_bool_t denoise;
pa_bool_t echo_suppress;
static bool pa_speex_ec_preprocessor_init(pa_echo_canceller *ec, pa_sample_spec *out_ss, uint32_t nframes, pa_modargs *ma) {
bool agc;
bool denoise;
bool echo_suppress;
int32_t echo_suppress_attenuation;
int32_t echo_suppress_attenuation_active;
@ -140,13 +140,13 @@ static pa_bool_t pa_speex_ec_preprocessor_init(pa_echo_canceller *ec, pa_sample_
} else
pa_log_info("All preprocessing options are disabled");
return TRUE;
return true;
fail:
return FALSE;
return false;
}
pa_bool_t pa_speex_ec_init(pa_core *c, pa_echo_canceller *ec,
bool pa_speex_ec_init(pa_core *c, pa_echo_canceller *ec,
pa_sample_spec *rec_ss, pa_channel_map *rec_map,
pa_sample_spec *play_ss, pa_channel_map *play_map,
pa_sample_spec *out_ss, pa_channel_map *out_map,
@ -189,7 +189,7 @@ pa_bool_t pa_speex_ec_init(pa_core *c, pa_echo_canceller *ec,
goto fail;
pa_modargs_free(ma);
return TRUE;
return true;
fail:
if (ma)
@ -202,7 +202,7 @@ fail:
speex_echo_state_destroy(ec->params.priv.speex.state);
ec->params.priv.speex.state = NULL;
}
return FALSE;
return false;
}
void pa_speex_ec_run(pa_echo_canceller *ec, const uint8_t *rec, const uint8_t *play, uint8_t *out) {

30
src/modules/echo-cancel/webrtc.cc
View file

@ -40,14 +40,14 @@ PA_C_DECL_END
#define BLOCK_SIZE_US 10000
#define DEFAULT_HIGH_PASS_FILTER TRUE
#define DEFAULT_NOISE_SUPPRESSION TRUE
#define DEFAULT_ANALOG_GAIN_CONTROL TRUE
#define DEFAULT_DIGITAL_GAIN_CONTROL FALSE
#define DEFAULT_MOBILE FALSE
#define DEFAULT_HIGH_PASS_FILTER true
#define DEFAULT_NOISE_SUPPRESSION true
#define DEFAULT_ANALOG_GAIN_CONTROL true
#define DEFAULT_DIGITAL_GAIN_CONTROL false
#define DEFAULT_MOBILE false
#define DEFAULT_ROUTING_MODE "speakerphone"
#define DEFAULT_COMFORT_NOISE TRUE
#define DEFAULT_DRIFT_COMPENSATION FALSE
#define DEFAULT_COMFORT_NOISE true
#define DEFAULT_DRIFT_COMPENSATION false
static const char* const valid_modargs[] = {
"high_pass_filter",
@ -76,13 +76,13 @@ static int routing_mode_from_string(const char *rmode) {
return -1;
}
pa_bool_t pa_webrtc_ec_init(pa_core *c, pa_echo_canceller *ec,
bool pa_webrtc_ec_init(pa_core *c, pa_echo_canceller *ec,
pa_sample_spec *rec_ss, pa_channel_map *rec_map,
pa_sample_spec *play_ss, pa_channel_map *play_map,
pa_sample_spec *out_ss, pa_channel_map *out_map,
uint32_t *nframes, const char *args) {
webrtc::AudioProcessing *apm = NULL;
pa_bool_t hpf, ns, agc, dgc, mobile, cn;
bool hpf, ns, agc, dgc, mobile, cn;
int rm = -1;
pa_modargs *ma;
@ -109,7 +109,7 @@ pa_bool_t pa_webrtc_ec_init(pa_core *c, pa_echo_canceller *ec,
goto fail;
}
dgc = agc ? FALSE : DEFAULT_DIGITAL_GAIN_CONTROL;
dgc = agc ? false : DEFAULT_DIGITAL_GAIN_CONTROL;
if (pa_modargs_get_value_boolean(ma, "digital_gain_control", &dgc) < 0) {
pa_log("Failed to parse digital_gain_control value");
goto fail;
@ -197,17 +197,17 @@ pa_bool_t pa_webrtc_ec_init(pa_core *c, pa_echo_canceller *ec,
if (mobile && rm <= webrtc::EchoControlMobile::kEarpiece) {
/* Maybe this should be a knob, but we've got a lot of knobs already */
apm->gain_control()->set_mode(webrtc::GainControl::kFixedDigital);
ec->params.priv.webrtc.agc = FALSE;
ec->params.priv.webrtc.agc = false;
} else if (dgc) {
apm->gain_control()->set_mode(webrtc::GainControl::kAdaptiveDigital);
ec->params.priv.webrtc.agc = FALSE;
ec->params.priv.webrtc.agc = false;
} else {
apm->gain_control()->set_mode(webrtc::GainControl::kAdaptiveAnalog);
if (apm->gain_control()->set_analog_level_limits(0, PA_VOLUME_NORM-1) != apm->kNoError) {
pa_log("Failed to initialise AGC");
goto fail;
}
ec->params.priv.webrtc.agc = TRUE;
ec->params.priv.webrtc.agc = true;
}
apm->gain_control()->Enable(true);
@ -221,7 +221,7 @@ pa_bool_t pa_webrtc_ec_init(pa_core *c, pa_echo_canceller *ec,
*nframes = ec->params.priv.webrtc.blocksize / pa_frame_size(out_ss);
pa_modargs_free(ma);
return TRUE;
return true;
fail:
if (ma)
@ -229,7 +229,7 @@ fail:
if (apm)
webrtc::AudioProcessing::Destroy(apm);
return FALSE;
return false;
}
void pa_webrtc_ec_play(pa_echo_canceller *ec, const uint8_t *play) {

8
src/modules/gconf/module-gconf.c
View file

@ -45,7 +45,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("GConf Adapter");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
#define MAX_MODULES 10
#define BUF_MAX 2048
@ -143,7 +143,7 @@ static void unload_one_module(struct module_info *m, unsigned i) {
return;
pa_log_debug("Unloading module #%i", m->items[i].index);
pa_module_unload_by_index(u->core, m->items[i].index, TRUE);
pa_module_unload_by_index(u->core, m->items[i].index, true);
m->items[i].index = PA_INVALID_INDEX;
pa_xfree(m->items[i].name);
pa_xfree(m->items[i].args);
@ -166,7 +166,7 @@ static void load_module(
unsigned i,
const char *name,
const char *args,
pa_bool_t is_new) {
bool is_new) {
struct userdata *u;
pa_module *mod;
@ -324,7 +324,7 @@ static void io_event_cb(
u->io_event = NULL;
}
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
}

12
src/modules/jack/module-jack-sink.c
View file

@ -60,7 +60,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("JACK Sink");
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_USAGE(
"sink_name=<name for the sink> "
@ -94,7 +94,7 @@ struct userdata {
jack_nframes_t frames_in_buffer;
jack_nframes_t saved_frame_time;
pa_bool_t saved_frame_time_valid;
bool saved_frame_time_valid;
};
static const char* const valid_modargs[] = {
@ -154,7 +154,7 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
u->frames_in_buffer = (jack_nframes_t) offset;
u->saved_frame_time = * (jack_nframes_t*) data;
u->saved_frame_time_valid = TRUE;
u->saved_frame_time_valid = true;
return 0;
@ -232,7 +232,7 @@ static void thread_func(void *userdata) {
if (PA_UNLIKELY(u->sink->thread_info.rewind_requested))
pa_sink_process_rewind(u->sink, 0);
if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
if ((ret = pa_rtpoll_run(u->rtpoll, true)) < 0)
goto fail;
if (ret == 0)
@ -293,7 +293,7 @@ int pa__init(pa_module*m) {
jack_status_t status;
const char *server_name, *client_name;
uint32_t channels = 0;
pa_bool_t do_connect = TRUE;
bool do_connect = true;
unsigned i;
const char **ports = NULL, **p;
pa_sink_new_data data;
@ -320,7 +320,7 @@ int pa__init(pa_module*m) {
m->userdata = u = pa_xnew0(struct userdata, 1);
u->core = m->core;
u->module = m;
u->saved_frame_time_valid = FALSE;
u->saved_frame_time_valid = false;
u->rtpoll = pa_rtpoll_new();
pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);

12
src/modules/jack/module-jack-source.c
View file

@ -51,7 +51,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("JACK Source");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE(
"source_name=<name for the source> "
"source_properties=<properties for the source> "
@ -81,7 +81,7 @@ struct userdata {
pa_thread *thread;
jack_nframes_t saved_frame_time;
pa_bool_t saved_frame_time_valid;
bool saved_frame_time_valid;
};
static const char* const valid_modargs[] = {
@ -115,7 +115,7 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
pa_source_post(u->source, chunk);
u->saved_frame_time = (jack_nframes_t) offset;
u->saved_frame_time_valid = TRUE;
u->saved_frame_time_valid = true;
return 0;
@ -198,7 +198,7 @@ static void thread_func(void *userdata) {
for (;;) {
int ret;
if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
if ((ret = pa_rtpoll_run(u->rtpoll, true)) < 0)
goto fail;
if (ret == 0)
@ -247,7 +247,7 @@ int pa__init(pa_module*m) {
jack_status_t status;
const char *server_name, *client_name;
uint32_t channels = 0;
pa_bool_t do_connect = TRUE;
bool do_connect = true;
unsigned i;
const char **ports = NULL, **p;
pa_source_new_data data;
@ -274,7 +274,7 @@ int pa__init(pa_module*m) {
m->userdata = u = pa_xnew0(struct userdata, 1);
u->core = m->core;
u->module = m;
u->saved_frame_time_valid = FALSE;
u->saved_frame_time_valid = false;
u->rtpoll = pa_rtpoll_new();
pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);

16
src/modules/jack/module-jackdbus-detect.c
View file

@ -38,7 +38,7 @@
PA_MODULE_AUTHOR("David Henningsson");
PA_MODULE_DESCRIPTION("Adds JACK sink/source ports when JACK is started");
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_USAGE(
"channels=<number of channels> "
@ -80,9 +80,9 @@ struct userdata {
pa_module *module;
pa_core *core;
pa_dbus_connection *connection;
pa_bool_t filter_added, match_added;
pa_bool_t is_service_started;
pa_bool_t autoconnect_ports;
bool filter_added, match_added;
bool is_service_started;
bool autoconnect_ports;
uint32_t channels;
/* Using index here protects us from module unloading without us knowing */
int jack_module_index[JACK_SS_COUNT];
@ -94,7 +94,7 @@ static void ensure_ports_stopped(struct userdata* u) {
for (i = 0; i < JACK_SS_COUNT; i++)
if (u->jack_module_index[i]) {
pa_module_unload_request_by_index(u->core, u->jack_module_index[i], TRUE);
pa_module_unload_request_by_index(u->core, u->jack_module_index[i], true);
u->jack_module_index[i] = 0;
pa_log_info("Stopped %s.", modnames[i]);
}
@ -125,10 +125,10 @@ static void ensure_ports_started(struct userdata* u) {
}
}
static pa_bool_t check_service_started(struct userdata* u) {
static bool check_service_started(struct userdata* u) {
DBusError error;
DBusMessage *m = NULL, *reply = NULL;
pa_bool_t new_status = FALSE;
bool new_status = false;
dbus_bool_t call_result;
pa_assert(u);
@ -230,7 +230,7 @@ int pa__init(pa_module *m) {
m->userdata = u = pa_xnew0(struct userdata, 1);
u->core = m->core;
u->module = m;
u->autoconnect_ports = TRUE;
u->autoconnect_ports = true;
u->channels = 0;
if (pa_modargs_get_value_boolean(ma, "connect", &u->autoconnect_ports) < 0) {

4
src/modules/macosx/module-bonjour-publish.c
View file

@ -50,7 +50,7 @@
PA_MODULE_AUTHOR("Daniel Mack");
PA_MODULE_DESCRIPTION("Mac OS X Bonjour Service Publisher");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
#define SERVICE_TYPE_SINK "_pulse-sink._tcp"
#define SERVICE_TYPE_SOURCE "_pulse-source._tcp"
@ -330,7 +330,7 @@ static void service_free(struct service *s) {
pa_xfree(s);
}
static pa_bool_t shall_ignore(pa_object *o) {
static bool shall_ignore(pa_object *o) {
pa_object_assert_ref(o);
if (pa_sink_isinstance(o))

14
src/modules/macosx/module-coreaudio-detect.c
View file

@ -40,7 +40,7 @@
PA_MODULE_AUTHOR("Daniel Mack");
PA_MODULE_DESCRIPTION("CoreAudio device detection");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE("ioproc_frames=<passed on to module-coreaudio-device> ");
static const char* const valid_modargs[] = {
@ -146,11 +146,11 @@ static int ca_update_device_list(struct pa_module *m) {
/* scan for devices which are reported but not in our cached list */
for (i = 0; i < num_devices; i++) {
bool found = FALSE;
bool found = false;
PA_LLIST_FOREACH(dev, u->devices)
if (dev->id == device_id[i]) {
found = TRUE;
found = true;
break;
}
@ -162,17 +162,17 @@ static int ca_update_device_list(struct pa_module *m) {
scan_removed:
PA_LLIST_FOREACH(dev, u->devices) {
bool found = FALSE;
bool found = false;
for (i = 0; i < num_devices; i++)
if (dev->id == device_id[i]) {
found = TRUE;
found = true;
break;
}
if (!found) {
pa_log_debug("object id %d has been removed (module index %d) %p", (unsigned int) dev->id, dev->module_index, dev);
pa_module_unload_request_by_index(m->core, dev->module_index, TRUE);
pa_module_unload_request_by_index(m->core, dev->module_index, true);
PA_LLIST_REMOVE(ca_device, u->devices, dev);
pa_xfree(dev);
/* the current list item pointer is not valid anymore, so start over. */
@ -265,7 +265,7 @@ void pa__done(pa_module *m) {
while (dev) {
struct ca_device *next = dev->next;
pa_module_unload_request_by_index(m->core, dev->module_index, TRUE);
pa_module_unload_request_by_index(m->core, dev->module_index, true);
pa_xfree(dev);
dev = next;

40
src/modules/macosx/module-coreaudio-device.c
View file

@ -57,7 +57,7 @@
PA_MODULE_AUTHOR("Daniel Mack");
PA_MODULE_DESCRIPTION("CoreAudio device");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
PA_MODULE_USAGE("object_id=<the CoreAudio device id> "
"ioproc_frames=<audio frames per IOProc call> ");
@ -86,7 +86,7 @@ struct userdata {
pa_module *module;
pa_card *card;
pa_bool_t running;
bool running;
char *device_name, *vendor_name;
@ -105,7 +105,7 @@ struct coreaudio_sink {
char *name;
unsigned int channel_idx;
pa_bool_t active;
bool active;
pa_channel_map map;
pa_sample_spec ss;
@ -119,7 +119,7 @@ struct coreaudio_source {
char *name;
unsigned int channel_idx;
pa_bool_t active;
bool active;
pa_channel_map map;
pa_sample_spec ss;
@ -191,13 +191,13 @@ static pa_usec_t get_latency_us(pa_object *o) {
u = sink->userdata;
ss = &sink->ss;
is_source = FALSE;
is_source = false;
} else if (pa_source_isinstance(o)) {
coreaudio_source *source = PA_SOURCE(o)->userdata;
u = source->userdata;
ss = &source->ss;
is_source = TRUE;
is_source = true;
} else
pa_assert_not_reached();
@ -256,17 +256,17 @@ static pa_usec_t get_latency_us(pa_object *o) {
static void ca_device_check_device_state(struct userdata *u) {
coreaudio_sink *ca_sink;
coreaudio_source *ca_source;
pa_bool_t active = FALSE;
bool active = false;
pa_assert(u);
for (ca_sink = u->sinks; ca_sink; ca_sink = ca_sink->next)
if (ca_sink->active)
active = TRUE;
active = true;
for (ca_source = u->sources; ca_source; ca_source = ca_source->next)
if (ca_source->active)
active = TRUE;
active = true;
if (active && !u->running)
AudioDeviceStart(u->object_id, u->proc_id);
@ -291,7 +291,7 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
pa_assert(sink);
if (PA_SINK_IS_OPENED(sink->pa_sink->thread_info.state)) {
audio_chunk.memblock = pa_memblock_new_fixed(u->module->core->mempool, buf->mData, buf->mDataByteSize, FALSE);
audio_chunk.memblock = pa_memblock_new_fixed(u->module->core->mempool, buf->mData, buf->mDataByteSize, false);
audio_chunk.length = buf->mDataByteSize;
audio_chunk.index = 0;
@ -329,7 +329,7 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
pa_assert(source);
if (PA_SOURCE_IS_OPENED(source->pa_source->thread_info.state)) {
audio_chunk.memblock = pa_memblock_new_fixed(u->module->core->mempool, buf->mData, buf->mDataByteSize, TRUE);
audio_chunk.memblock = pa_memblock_new_fixed(u->module->core->mempool, buf->mData, buf->mDataByteSize, true);
audio_chunk.length = buf->mDataByteSize;
audio_chunk.index = 0;
@ -358,11 +358,11 @@ static int ca_sink_set_state(pa_sink *s, pa_sink_state_t state) {
switch (state) {
case PA_SINK_SUSPENDED:
case PA_SINK_IDLE:
sink->active = FALSE;
sink->active = false;
break;
case PA_SINK_RUNNING:
sink->active = TRUE;
sink->active = true;
break;
case PA_SINK_UNLINKED:
@ -432,7 +432,7 @@ static int ca_device_create_sink(pa_module *m, AudioBuffer *buf, int channel_idx
new_data.card = u->card;
new_data.driver = __FILE__;
new_data.module = u->module;
new_data.namereg_fail = FALSE;
new_data.namereg_fail = false;
pa_sink_new_data_set_name(&new_data, ca_sink->name);
pa_sink_new_data_set_channel_map(&new_data, &ca_sink->map);
pa_sink_new_data_set_sample_spec(&new_data, &ca_sink->ss);
@ -476,11 +476,11 @@ static int ca_source_set_state(pa_source *s, pa_source_state_t state) {
switch (state) {
case PA_SOURCE_SUSPENDED:
case PA_SOURCE_IDLE:
source->active = FALSE;
source->active = false;
break;
case PA_SOURCE_RUNNING:
source->active = TRUE;
source->active = true;
break;
case PA_SOURCE_UNLINKED:
@ -550,7 +550,7 @@ static int ca_device_create_source(pa_module *m, AudioBuffer *buf, int channel_i
new_data.card = u->card;
new_data.driver = __FILE__;
new_data.module = u->module;
new_data.namereg_fail = FALSE;
new_data.namereg_fail = false;
pa_source_new_data_set_name(&new_data, ca_source->name);
pa_source_new_data_set_channel_map(&new_data, &ca_source->map);
pa_source_new_data_set_sample_spec(&new_data, &ca_source->ss);
@ -678,7 +678,7 @@ static void thread_func(void *userdata) {
pa_sink_process_rewind(ca_sink->pa_sink, 0);
}
ret = pa_rtpoll_run(u->rtpoll, TRUE);
ret = pa_rtpoll_run(u->rtpoll, true);
if (ret < 0)
goto fail;
@ -775,10 +775,10 @@ int pa__init(pa_module *m) {
PA_LLIST_HEAD_INIT(coreaudio_sink, u->sinks);
/* create sinks */
ca_device_create_streams(m, FALSE);
ca_device_create_streams(m, false);
/* create sources */
ca_device_create_streams(m, TRUE);
ca_device_create_streams(m, true);
/* create the message thread */
if (!(u->thread = pa_thread_new(u->device_name, thread_func, u))) {

14
src/modules/module-always-sink.c
View file

@ -37,7 +37,7 @@
PA_MODULE_AUTHOR("Colin Guthrie");
PA_MODULE_DESCRIPTION(_("Always keeps at least one sink loaded even if it's a null one"));
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE(
"sink_name=<name of sink>");
@ -51,7 +51,7 @@ static const char* const valid_modargs[] = {
struct userdata {
pa_hook_slot *put_slot, *unlink_slot;
uint32_t null_module;
pa_bool_t ignore;
bool ignore;
char *sink_name;
};
@ -76,7 +76,7 @@ static void load_null_sink_if_needed(pa_core *c, pa_sink *sink, struct userdata*
pa_log_debug("Autoloading null-sink as no other sinks detected.");
u->ignore = TRUE;
u->ignore = true;
t = pa_sprintf_malloc("sink_name=%s sink_properties='device.description=\"%s\"'", u->sink_name,
_("Dummy Output"));
@ -84,7 +84,7 @@ static void load_null_sink_if_needed(pa_core *c, pa_sink *sink, struct userdata*
u->null_module = m ? m->index : PA_INVALID_INDEX;
pa_xfree(t);
u->ignore = FALSE;
u->ignore = false;
if (!m)
pa_log_warn("Unable to load module-null-sink");
@ -115,7 +115,7 @@ static pa_hook_result_t put_hook_callback(pa_core *c, pa_sink *sink, void* userd
pa_log_info("A new sink has been discovered. Unloading null-sink.");
pa_module_unload_request_by_index(c, u->null_module, TRUE);
pa_module_unload_request_by_index(c, u->null_module, true);
u->null_module = PA_INVALID_INDEX;
return PA_HOOK_OK;
@ -160,7 +160,7 @@ int pa__init(pa_module*m) {
u->put_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_PUT], PA_HOOK_LATE, (pa_hook_cb_t) put_hook_callback, u);
u->unlink_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_UNLINK], PA_HOOK_EARLY, (pa_hook_cb_t) unlink_hook_callback, u);
u->null_module = PA_INVALID_INDEX;
u->ignore = FALSE;
u->ignore = false;
pa_modargs_free(ma);
@ -182,7 +182,7 @@ void pa__done(pa_module*m) {
if (u->unlink_slot)
pa_hook_slot_free(u->unlink_slot);
if (u->null_module != PA_INVALID_INDEX && m->core->state != PA_CORE_SHUTDOWN)
pa_module_unload_request_by_index(m->core, u->null_module, TRUE);
pa_module_unload_request_by_index(m->core, u->null_module, true);
pa_xfree(u->sink_name);
pa_xfree(u);

14
src/modules/module-augment-properties.c
View file

@ -41,7 +41,7 @@
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);
#define STAT_INTERVAL 30
#define MAX_CACHE_SIZE 50
@ -52,7 +52,7 @@ static const char* const valid_modargs[] = {
struct rule {
time_t timestamp;
pa_bool_t good;
bool good;
time_t mtime;
char *process_name;
char *application_name;
@ -145,13 +145,13 @@ static void update_rule(struct rule *r) {
{ NULL, catch_all, NULL, NULL },
{ NULL, NULL, NULL, NULL },
};
pa_bool_t found = FALSE;
bool found = false;
pa_assert(r);
fn = pa_sprintf_malloc(DESKTOPFILEDIR PA_PATH_SEP "%s.desktop", r->process_name);
if (stat(fn, &st) == 0)
found = TRUE;
found = true;
else {
#ifdef DT_DIR
DIR *desktopfiles_dir;
@ -169,7 +169,7 @@ static void update_rule(struct rule *r) {
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;
}
}
@ -178,7 +178,7 @@ static void update_rule(struct rule *r) {
#endif
}
if (!found) {
r->good = FALSE;
r->good = false;
pa_xfree(fn);
return;
}
@ -194,7 +194,7 @@ static void update_rule(struct rule *r) {
} else
pa_log_debug("Found %s.", fn);
r->good = TRUE;
r->good = true;
r->mtime = st.st_mtime;
pa_xfree(r->application_name);
pa_xfree(r->icon_name);

14
src/modules/module-card-restore.c
View file

@ -51,7 +51,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Automatically restore profile of cards");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
#define SAVE_INTERVAL (10 * PA_USEC_PER_SEC)
@ -184,10 +184,10 @@ static bool entrys_equal(struct entry *a, struct entry *b) {
return true;
}
static pa_bool_t entry_write(struct userdata *u, const char *name, const struct entry *e) {
static bool entry_write(struct userdata *u, const char *name, const struct entry *e) {
pa_tagstruct *t;
pa_datum key, data;
pa_bool_t r;
bool r;
void *state;
struct port_info *p_info;
@ -210,7 +210,7 @@ static pa_bool_t entry_write(struct userdata *u, const char *name, const struct
data.data = (void*)pa_tagstruct_data(t, &data.size);
r = (pa_database_set(u->database, &key, &data, TRUE) == 0);
r = (pa_database_set(u->database, &key, &data, true) == 0);
pa_tagstruct_free(t);
@ -449,7 +449,7 @@ static pa_hook_result_t card_new_hook_callback(pa_core *c, pa_card_new_data *new
if (!new_data->active_profile) {
pa_card_new_data_set_profile(new_data, e->profile);
pa_log_info("Restored profile '%s' for card %s.", new_data->active_profile, new_data->name);
new_data->save_profile = TRUE;
new_data->save_profile = true;
} else
pa_log_debug("Not restoring profile for card %s, because already set.", new_data->name);
@ -491,10 +491,10 @@ int pa__init(pa_module*m) {
u->port_offset_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_PORT_LATENCY_OFFSET_CHANGED], PA_HOOK_NORMAL, (pa_hook_cb_t) port_offset_change_callback, u);
u->hooks_connected = true;
if (!(fname = pa_state_path("card-database", TRUE)))
if (!(fname = pa_state_path("card-database", true)))
goto fail;
if (!(u->database = pa_database_open(fname, TRUE))) {
if (!(u->database = pa_database_open(fname, true))) {
pa_log("Failed to open volume database '%s': %s", fname, pa_cstrerror(errno));
pa_xfree(fname);
goto fail;

10
src/modules/module-cli.c
View file

@ -42,7 +42,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Command line interface");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE("exit_on_eof=<exit daemon after EOF?>");
static const char* const valid_modargs[] = {
@ -56,7 +56,7 @@ static void eof_and_unload_cb(pa_cli*c, void *userdata) {
pa_assert(c);
pa_assert(m);
pa_module_unload_request(m, TRUE);
pa_module_unload_request(m, true);
}
static void eof_and_exit_cb(pa_cli*c, void *userdata) {
@ -65,13 +65,13 @@ static void eof_and_exit_cb(pa_cli*c, void *userdata) {
pa_assert(c);
pa_assert(m);
pa_core_exit(m->core, FALSE, 0);
pa_core_exit(m->core, false, 0);
}
int pa__init(pa_module*m) {
pa_iochannel *io;
pa_modargs *ma;
pa_bool_t exit_on_eof = FALSE;
bool exit_on_eof = false;
#ifndef OS_IS_WIN32
int fd;
#endif
@ -115,7 +115,7 @@ int pa__init(pa_module*m) {
#endif
{
io = pa_iochannel_new(m->core->mainloop, STDIN_FILENO, STDOUT_FILENO);
pa_iochannel_set_noclose(io, TRUE);
pa_iochannel_set_noclose(io, true);
pa_log_debug("Failed to open /dev/tty, using stdin/stdout fds instead.");
}

72
src/modules/module-combine-sink.c
View file

@ -52,7 +52,7 @@
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> "
@ -90,7 +90,7 @@ struct output {
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 */
@ -121,8 +121,8 @@ struct userdata {
pa_time_event *time_event;
pa_usec_t adjust_time;
pa_bool_t automatic;
pa_bool_t auto_desc;
bool automatic;
bool auto_desc;
pa_strlist *unlinked_slaves;
@ -138,7 +138,7 @@ struct userdata {
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;
@ -304,7 +304,7 @@ static void thread_func(void *userdata) {
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;
@ -322,14 +322,14 @@ static void thread_func(void *userdata) {
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;
}
@ -513,7 +513,7 @@ static void sink_input_attach_cb(pa_sink_input *i) {
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));
@ -549,7 +549,7 @@ static void sink_input_kill_cb(pa_sink_input *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);
pa_idxset_remove_by_data(o->userdata->outputs, o, NULL);
output_free(o);
}
@ -575,7 +575,7 @@ static int sink_input_process_msg(pa_msgobject *obj, int code, void *data, int64
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;
}
@ -740,12 +740,12 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
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());
@ -812,7 +812,7 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
}
static void update_description(struct userdata *u) {
pa_bool_t first = TRUE;
bool first = true;
char *t;
struct output *o;
uint32_t idx;
@ -834,7 +834,7 @@ static void update_description(struct userdata *u) {
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)));
@ -855,7 +855,7 @@ static int output_create_sink_input(struct output *o) {
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");
@ -958,7 +958,7 @@ static void output_enable(struct output *o) {
* 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) {
@ -977,7 +977,7 @@ static void output_enable(struct output *o) {
output_add_within_thread(o);
}
o->ignore_state_change = FALSE;
o->ignore_state_change = false;
}
/* Called from main context */
@ -1000,9 +1000,9 @@ static void output_disable(struct output *o) {
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 */
@ -1016,25 +1016,25 @@ static void output_verify(struct output *o) {
}
/* 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 */
@ -1166,11 +1166,11 @@ int pa__init(pa_module*m) {
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);
adjust_time_sec = DEFAULT_ADJUST_TIME_USEC / PA_USEC_PER_SEC;
if (pa_modargs_get_value_u32(ma, "adjust_time", &adjust_time_sec) < 0) {
@ -1195,7 +1195,7 @@ int pa__init(pa_module*m) {
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);
@ -1213,7 +1213,7 @@ int pa__init(pa_module*m) {
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;
@ -1245,7 +1245,7 @@ int pa__init(pa_module*m) {
}
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));
@ -1263,9 +1263,9 @@ int pa__init(pa_module*m) {
}
/* 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");
}

4
src/modules/module-combine.c
View file

@ -34,7 +34,7 @@
PA_MODULE_AUTHOR("Colin Guthrie");
PA_MODULE_DESCRIPTION("Compatibility module (module-combine rename)");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
PA_MODULE_DEPRECATED("Please use module-combine-sink instead of module-combine!");
struct userdata {
@ -65,7 +65,7 @@ void pa__done(pa_module*m) {
u = m->userdata;
if (u && PA_INVALID_INDEX != u->module_index)
pa_module_unload_by_index(m->core, u->module_index, TRUE);
pa_module_unload_by_index(m->core, u->module_index, true);
pa_xfree(u);
}

6
src/modules/module-console-kit.c
View file

@ -44,7 +44,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Create a client for each ConsoleKit session of this user");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
static const char* const valid_modargs[] = {
NULL
@ -60,7 +60,7 @@ struct userdata {
pa_core *core;
pa_dbus_connection *connection;
pa_hashmap *sessions;
pa_bool_t filter_added;
bool filter_added;
};
static void add_session(struct userdata *u, const char *id) {
@ -310,7 +310,7 @@ int pa__init(pa_module*m) {
goto fail;
}
u->filter_added = TRUE;
u->filter_added = true;
if (pa_dbus_add_matches(
pa_dbus_connection_get(connection), &error,

12
src/modules/module-default-device-restore.c
View file

@ -41,7 +41,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Automatically restore the default sink and source");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
#define SAVE_INTERVAL (5 * PA_USEC_PER_SEC)
@ -50,7 +50,7 @@ struct userdata {
pa_subscription *subscription;
pa_time_event *time_event;
char *sink_filename, *source_filename;
pa_bool_t modified;
bool modified;
};
static void load(struct userdata *u) {
@ -125,7 +125,7 @@ static void save(struct userdata *u) {
pa_log("Failed to save default source: %s", pa_cstrerror(errno));
}
u->modified = FALSE;
u->modified = false;
}
static void time_cb(pa_mainloop_api *a, pa_time_event *e, const struct timeval *t, void *userdata) {
@ -145,7 +145,7 @@ static void subscribe_cb(pa_core *c, pa_subscription_event_type_t t, uint32_t id
pa_assert(u);
u->modified = TRUE;
u->modified = true;
if (!u->time_event)
u->time_event = pa_core_rttime_new(u->core, pa_rtclock_now() + SAVE_INTERVAL, time_cb, u);
@ -159,10 +159,10 @@ int pa__init(pa_module *m) {
m->userdata = u = pa_xnew0(struct userdata, 1);
u->core = m->core;
if (!(u->sink_filename = pa_state_path("default-sink", TRUE)))
if (!(u->sink_filename = pa_state_path("default-sink", true)))
goto fail;
if (!(u->source_filename = pa_state_path("default-source", TRUE)))
if (!(u->source_filename = pa_state_path("default-source", true)))
goto fail;
load(u);

2
src/modules/module-defs.h.m4
View file

@ -30,6 +30,6 @@ const char* pa__get_description(void);
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

6
src/modules/module-detect.c
View file

@ -46,7 +46,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Detect available audio hardware and load matching drivers");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE("just-one=<boolean>");
PA_MODULE_DEPRECATED("Please use module-udev-detect instead of module-detect!");
@ -219,7 +219,7 @@ static int detect_waveout(pa_core *c, int just_one) {
#endif
int pa__init(pa_module*m) {
pa_bool_t just_one = FALSE;
bool just_one = false;
int n = 0;
pa_modargs *ma;
@ -255,7 +255,7 @@ int pa__init(pa_module*m) {
pa_log_info("loaded %i modules.", n);
/* We were successful and can unload ourselves now. */
pa_module_unload_request(m, TRUE);
pa_module_unload_request(m, true);
pa_modargs_free(ma);

80
src/modules/module-device-manager.c
View file

@ -56,7 +56,7 @@
PA_MODULE_AUTHOR("Colin Guthrie");
PA_MODULE_DESCRIPTION("Keep track of devices (and their descriptions) both past and present and prioritise by role");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE(
"do_routing=<Automatically route streams based on a priority list (unique per-role)?> "
"on_hotplug=<When new device becomes available, recheck streams?> "
@ -120,9 +120,9 @@ struct userdata {
pa_native_protocol *protocol;
pa_idxset *subscribed;
pa_bool_t on_hotplug;
pa_bool_t on_rescue;
pa_bool_t do_routing;
bool on_hotplug;
bool on_rescue;
bool do_routing;
role_indexes_t preferred_sinks;
role_indexes_t preferred_sources;
@ -133,7 +133,7 @@ struct userdata {
struct entry {
uint8_t version;
char *description;
pa_bool_t user_set_description;
bool user_set_description;
char *icon;
role_indexes_t priority;
};
@ -200,10 +200,10 @@ static void entry_free(struct entry* e) {
pa_xfree(e);
}
static pa_bool_t entry_write(struct userdata *u, const char *name, const struct entry *e) {
static bool entry_write(struct userdata *u, const char *name, const struct entry *e) {
pa_tagstruct *t;
pa_datum key, data;
pa_bool_t r;
bool r;
pa_assert(u);
pa_assert(name);
@ -222,7 +222,7 @@ static pa_bool_t entry_write(struct userdata *u, const char *name, const struct
data.data = (void*)pa_tagstruct_data(t, &data.size);
r = (pa_database_set(u->database, &key, &data, TRUE) == 0);
r = (pa_database_set(u->database, &key, &data, true) == 0);
pa_tagstruct_free(t);
@ -236,7 +236,7 @@ static struct entry* legacy_entry_read(struct userdata *u, pa_datum *data) {
struct legacy_entry {
uint8_t version;
char description[PA_NAME_MAX];
pa_bool_t user_set_description;
bool user_set_description;
char icon[PA_NAME_MAX];
role_indexes_t priority;
} PA_GCC_PACKED;
@ -360,7 +360,7 @@ fail:
}
#ifdef DUMP_DATABASE
static void dump_database_helper(struct userdata *u, uint32_t role_index, const char* human, pa_bool_t sink_mode) {
static void dump_database_helper(struct userdata *u, uint32_t role_index, const char* human, bool sink_mode) {
pa_assert(u);
pa_assert(human);
@ -381,7 +381,7 @@ static void dump_database_helper(struct userdata *u, uint32_t role_index, const
static void dump_database(struct userdata *u) {
pa_datum key;
pa_bool_t done;
bool done;
pa_assert(u);
@ -423,7 +423,7 @@ static void dump_database(struct userdata *u) {
strncpy(name, role_names[role], len);
for (int i = len+1; i < 12; ++i) name[i] = ' ';
name[len] = ':'; name[0] -= 32; name[12] = '\0';
dump_database_helper(u, role, name, TRUE);
dump_database_helper(u, role, name, true);
}
pa_log_debug(" Sources:");
@ -433,7 +433,7 @@ static void dump_database(struct userdata *u) {
strncpy(name, role_names[role], len);
for (int i = len+1; i < 12; ++i) name[i] = ' ';
name[len] = ':'; name[0] -= 32; name[12] = '\0';
dump_database_helper(u, role, name, FALSE);
dump_database_helper(u, role, name, false);
}
}
@ -462,7 +462,7 @@ static void notify_subscribers(struct userdata *u) {
}
}
static pa_bool_t entries_equal(const struct entry *a, const struct entry *b) {
static bool entries_equal(const struct entry *a, const struct entry *b) {
pa_assert(a);
pa_assert(b);
@ -470,13 +470,13 @@ static pa_bool_t entries_equal(const struct entry *a, const struct entry *b) {
if (!pa_streq(a->description, b->description)
|| a->user_set_description != b->user_set_description
|| !pa_streq(a->icon, b->icon))
return FALSE;
return false;
for (int i=0; i < NUM_ROLES; ++i)
if (a->priority[i] != b->priority[i])
return FALSE;
return false;
return TRUE;
return true;
}
static char *get_name(const char *key, const char *prefix) {
@ -505,7 +505,7 @@ static inline struct entry *load_or_initialize_entry(struct userdata *u, struct
/* This is a new device, so make sure we write it's priority list correctly */
role_indexes_t max_priority;
pa_datum key;
pa_bool_t done;
bool done;
pa_zero(max_priority);
done = !pa_database_first(u->database, &key, NULL);
@ -540,7 +540,7 @@ static inline struct entry *load_or_initialize_entry(struct userdata *u, struct
for (uint32_t i = 0; i < NUM_ROLES; ++i) {
entry->priority[i] = max_priority[i] + 1;
}
entry->user_set_description = FALSE;
entry->user_set_description = false;
}
return old;
@ -559,7 +559,7 @@ static uint32_t get_role_index(const char* role) {
static void update_highest_priority_device_indexes(struct userdata *u, const char *prefix, void *ignore_device) {
role_indexes_t *indexes, highest_priority_available;
pa_datum key;
pa_bool_t done, sink_mode;
bool done, sink_mode;
pa_assert(u);
pa_assert(prefix);
@ -597,7 +597,7 @@ static void update_highest_priority_device_indexes(struct userdata *u, const cha
/* We've found a device with a higher priority than that we've currently got,
so see if it is currently available or not and update our list */
uint32_t idx;
pa_bool_t found = FALSE;
bool found = false;
if (sink_mode) {
pa_sink *sink;
@ -606,7 +606,7 @@ static void update_highest_priority_device_indexes(struct userdata *u, const cha
if ((pa_sink*) ignore_device == sink)
continue;
if (pa_streq(sink->name, device_name)) {
found = TRUE;
found = true;
idx = sink->index; /* Is this needed? */
break;
}
@ -618,7 +618,7 @@ static void update_highest_priority_device_indexes(struct userdata *u, const cha
if ((pa_source*) ignore_device == source)
continue;
if (pa_streq(source->name, device_name)) {
found = TRUE;
found = true;
idx = source->index; /* Is this needed? */
break;
}
@ -681,7 +681,7 @@ static void route_sink_input(struct userdata *u, pa_sink_input *si) {
return;
if (si->sink != sink)
pa_sink_input_move_to(si, sink, FALSE);
pa_sink_input_move_to(si, sink, false);
}
static pa_hook_result_t route_sink_inputs(struct userdata *u, pa_sink *ignore_sink) {
@ -742,7 +742,7 @@ static void route_source_output(struct userdata *u, pa_source_output *so) {
return;
if (so->source != source)
pa_source_output_move_to(so, source, FALSE);
pa_source_output_move_to(so, source, false);
}
static pa_hook_result_t route_source_outputs(struct userdata *u, pa_source* ignore_source) {
@ -966,7 +966,7 @@ static pa_hook_result_t sink_input_new_hook_callback(pa_core *c, pa_sink_input_n
pa_sink *sink;
if ((sink = pa_idxset_get_by_index(u->core->sinks, device_index))) {
if (!pa_sink_input_new_data_set_sink(new_data, sink, FALSE))
if (!pa_sink_input_new_data_set_sink(new_data, sink, false))
pa_log_debug("Not restoring device for stream because no supported format was found");
}
}
@ -1006,7 +1006,7 @@ static pa_hook_result_t source_output_new_hook_callback(pa_core *c, pa_source_ou
pa_source *source;
if ((source = pa_idxset_get_by_index(u->core->sources, device_index)))
if (!pa_source_output_new_data_set_source(new_data, source, FALSE))
if (!pa_source_output_new_data_set_source(new_data, source, false))
pa_log_debug("Not restoring device for stream because no supported format was found");
}
}
@ -1143,7 +1143,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
case SUBCOMMAND_READ: {
pa_datum key;
pa_bool_t done;
bool done;
if (!pa_tagstruct_eof(t))
goto fail;
@ -1222,7 +1222,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
if ((e = entry_read(u, device))) {
pa_xfree(e->description);
e->description = pa_xstrdup(description);
e->user_set_description = TRUE;
e->user_set_description = true;
if (entry_write(u, (char *)device, e)) {
apply_entry(u, device, e);
@ -1262,7 +1262,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
case SUBCOMMAND_ROLE_DEVICE_PRIORITY_ROUTING: {
pa_bool_t enable;
bool enable;
if (pa_tagstruct_get_boolean(t, &enable) < 0)
goto fail;
@ -1282,14 +1282,14 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
struct entry *e;
uint32_t role_index, n_devices;
pa_datum key;
pa_bool_t done, sink_mode = TRUE;
bool done, sink_mode = true;
struct device_t { uint32_t prio; char *device; };
struct device_t *device;
struct device_t **devices;
uint32_t i, idx, offset;
pa_hashmap *h;
/*void *state;*/
pa_bool_t first;
bool first;
if (pa_tagstruct_gets(t, &role) < 0 ||
pa_tagstruct_getu32(t, &n_devices) < 0 ||
@ -1301,7 +1301,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
/* Cycle through the devices given and make sure they exist */
h = pa_hashmap_new(pa_idxset_string_hash_func, pa_idxset_string_compare_func);
first = TRUE;
first = true;
idx = 0;
for (i = 0; i < n_devices; ++i) {
const char *s;
@ -1330,7 +1330,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
entry_free(e);
if (first) {
first = FALSE;
first = false;
sink_mode = (0 == strncmp("sink:", s, 5));
} else if ((sink_mode && 0 != strncmp("sink:", s, 5)) || (!sink_mode && 0 != strncmp("source:", s, 7))) {
while ((device = pa_hashmap_steal_first(h))) {
@ -1432,7 +1432,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
/* Go through in order and write the new entry and cleanup our own list */
idx = 1;
first = TRUE;
first = true;
for (i = 0; i < n_devices; ++i) {
if ((e = entry_read(u, devices[i]->device))) {
if (e->priority[role_index] == idx)
@ -1441,7 +1441,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
e->priority[role_index] = idx;
if (entry_write(u, (char *) devices[i]->device, e)) {
first = FALSE;
first = false;
idx++;
}
}
@ -1468,7 +1468,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
case SUBCOMMAND_SUBSCRIBE: {
pa_bool_t enabled;
bool enabled;
if (pa_tagstruct_get_boolean(t, &enabled) < 0 ||
!pa_tagstruct_eof(t))
@ -1518,7 +1518,7 @@ int pa__init(pa_module*m) {
pa_sink *sink;
pa_source *source;
uint32_t idx;
pa_bool_t do_routing = FALSE, on_hotplug = TRUE, on_rescue = TRUE;
bool do_routing = false, on_hotplug = true, on_rescue = true;
uint32_t total_devices;
pa_assert(m);
@ -1571,10 +1571,10 @@ int pa__init(pa_module*m) {
u->source_unlink_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_UNLINK], PA_HOOK_LATE+5, (pa_hook_cb_t) source_unlink_hook_callback, u);
}
if (!(fname = pa_state_path("device-manager", TRUE)))
if (!(fname = pa_state_path("device-manager", true)))
goto fail;
if (!(u->database = pa_database_open(fname, TRUE))) {
if (!(u->database = pa_database_open(fname, true))) {
pa_log("Failed to open volume database '%s': %s", fname, pa_cstrerror(errno));
pa_xfree(fname);
goto fail;

140
src/modules/module-device-restore.c
View file

@ -59,7 +59,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Automatically restore the volume/mute state of devices");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE(
"restore_port=<Save/restore port?> "
"restore_volume=<Save/restore volumes?> "
@ -95,10 +95,10 @@ struct userdata {
pa_native_protocol *protocol;
pa_idxset *subscribed;
pa_bool_t restore_volume:1;
pa_bool_t restore_muted:1;
pa_bool_t restore_port:1;
pa_bool_t restore_formats:1;
bool restore_volume:1;
bool restore_muted:1;
bool restore_port:1;
bool restore_formats:1;
};
/* Protocol extension commands */
@ -115,7 +115,7 @@ enum {
struct entry {
uint8_t version;
pa_bool_t port_valid;
bool port_valid;
char *port;
};
@ -123,8 +123,8 @@ struct entry {
struct perportentry {
uint8_t version;
pa_bool_t muted_valid, volume_valid;
pa_bool_t muted;
bool muted_valid, volume_valid;
bool muted;
pa_channel_map channel_map;
pa_cvolume volume;
pa_idxset *formats;
@ -174,9 +174,9 @@ static void trigger_save(struct userdata *u, pa_device_type_t type, uint32_t sin
#ifdef ENABLE_LEGACY_DATABASE_ENTRY_FORMAT
/* Some forward declarations */
static pa_bool_t legacy_entry_read(struct userdata *u, pa_datum *data, struct entry **entry, struct perportentry **perportentry);
static bool legacy_entry_read(struct userdata *u, pa_datum *data, struct entry **entry, struct perportentry **perportentry);
static struct perportentry* perportentry_read(struct userdata *u, const char *basekeyname, const char *port);
static pa_bool_t perportentry_write(struct userdata *u, const char *basekeyname, const char *port, const struct perportentry *e);
static bool perportentry_write(struct userdata *u, const char *basekeyname, const char *port, const struct perportentry *e);
static void perportentry_free(struct perportentry* e);
#endif
@ -193,10 +193,10 @@ static void entry_free(struct entry* e) {
pa_xfree(e);
}
static pa_bool_t entry_write(struct userdata *u, const char *name, const struct entry *e) {
static bool entry_write(struct userdata *u, const char *name, const struct entry *e) {
pa_tagstruct *t;
pa_datum key, data;
pa_bool_t r;
bool r;
pa_assert(u);
pa_assert(name);
@ -212,7 +212,7 @@ static pa_bool_t entry_write(struct userdata *u, const char *name, const struct
data.data = (void*)pa_tagstruct_data(t, &data.size);
r = (pa_database_set(u->database, &key, &data, TRUE) == 0);
r = (pa_database_set(u->database, &key, &data, true) == 0);
pa_tagstruct_free(t);
@ -271,7 +271,7 @@ fail:
struct perportentry *ppe;
pa_log_debug("Attempting to load legacy (pre-v1.0) data for key: %s", name);
if (legacy_entry_read(u, &data, &e, &ppe)) {
pa_bool_t written = FALSE;
bool written = false;
pa_log_debug("Success. Saving new format for key: %s", name);
written = entry_write(u, name, e);
@ -323,18 +323,18 @@ static struct entry* entry_copy(const struct entry *e) {
return r;
}
static pa_bool_t entries_equal(const struct entry *a, const struct entry *b) {
static bool entries_equal(const struct entry *a, const struct entry *b) {
pa_assert(a && b);
if (a->port_valid != b->port_valid ||
(a->port_valid && !pa_streq(a->port, b->port)))
return FALSE;
return false;
return TRUE;
return true;
}
static struct perportentry* perportentry_new(pa_bool_t add_pcm_format) {
static struct perportentry* perportentry_new(bool add_pcm_format) {
struct perportentry *r = pa_xnew0(struct perportentry, 1);
r->version = PERPORTENTRY_VERSION;
r->formats = pa_idxset_new(NULL, NULL);
@ -353,10 +353,10 @@ static void perportentry_free(struct perportentry* e) {
pa_xfree(e);
}
static pa_bool_t perportentry_write(struct userdata *u, const char *basekeyname, const char *port, const struct perportentry *e) {
static bool perportentry_write(struct userdata *u, const char *basekeyname, const char *port, const struct perportentry *e) {
pa_tagstruct *t;
pa_datum key, data;
pa_bool_t r;
bool r;
uint32_t i;
pa_format_info *f;
uint8_t n_formats;
@ -389,7 +389,7 @@ static pa_bool_t perportentry_write(struct userdata *u, const char *basekeyname,
data.data = (void*)pa_tagstruct_data(t, &data.size);
r = (pa_database_set(u->database, &key, &data, TRUE) == 0);
r = (pa_database_set(u->database, &key, &data, true) == 0);
pa_tagstruct_free(t);
pa_xfree(name);
@ -418,7 +418,7 @@ static struct perportentry* perportentry_read(struct userdata *u, const char *ba
goto fail;
t = pa_tagstruct_new(data.data, data.size);
e = perportentry_new(FALSE);
e = perportentry_new(false);
if (pa_tagstruct_getu8(t, &e->version) < 0 ||
e->version > PERPORTENTRY_VERSION ||
@ -490,7 +490,7 @@ static struct perportentry* perportentry_copy(const struct perportentry *e) {
pa_format_info *f;
pa_assert(e);
r = perportentry_new(FALSE);
r = perportentry_new(false);
r->version = e->version;
r->muted_valid = e->muted_valid;
r->volume_valid = e->volume_valid;
@ -504,36 +504,36 @@ static struct perportentry* perportentry_copy(const struct perportentry *e) {
return r;
}
static pa_bool_t perportentries_equal(const struct perportentry *a, const struct perportentry *b) {
static bool perportentries_equal(const struct perportentry *a, const struct perportentry *b) {
pa_cvolume t;
pa_assert(a && b);
if (a->muted_valid != b->muted_valid ||
(a->muted_valid && (a->muted != b->muted)))
return FALSE;
return false;
t = b->volume;
if (a->volume_valid != b->volume_valid ||
(a->volume_valid && !pa_cvolume_equal(pa_cvolume_remap(&t, &b->channel_map, &a->channel_map), &a->volume)))
return FALSE;
return false;
if (pa_idxset_size(a->formats) != pa_idxset_size(b->formats))
return FALSE;
return false;
/** TODO: Compare a bit better */
return TRUE;
return true;
}
#ifdef ENABLE_LEGACY_DATABASE_ENTRY_FORMAT
#define LEGACY_ENTRY_VERSION 2
static pa_bool_t legacy_entry_read(struct userdata *u, pa_datum *data, struct entry **entry, struct perportentry **perportentry) {
static bool legacy_entry_read(struct userdata *u, pa_datum *data, struct entry **entry, struct perportentry **perportentry) {
struct legacy_entry {
uint8_t version;
pa_bool_t muted_valid:1, volume_valid:1, port_valid:1;
pa_bool_t muted:1;
bool muted_valid:1, volume_valid:1, port_valid:1;
bool muted:1;
pa_channel_map channel_map;
pa_cvolume volume;
char port[PA_NAME_MAX];
@ -547,43 +547,43 @@ static pa_bool_t legacy_entry_read(struct userdata *u, pa_datum *data, struct en
if (data->size != sizeof(struct legacy_entry)) {
pa_log_debug("Size does not match.");
return FALSE;
return false;
}
le = (struct legacy_entry*)data->data;
if (le->version != LEGACY_ENTRY_VERSION) {
pa_log_debug("Version mismatch.");
return FALSE;
return false;
}
if (!memchr(le->port, 0, sizeof(le->port))) {
pa_log_warn("Port has missing NUL byte.");
return FALSE;
return false;
}
if (le->volume_valid && !pa_channel_map_valid(&le->channel_map)) {
pa_log_warn("Invalid channel map.");
return FALSE;
return false;
}
if (le->volume_valid && (!pa_cvolume_valid(&le->volume) || !pa_cvolume_compatible_with_channel_map(&le->volume, &le->channel_map))) {
pa_log_warn("Volume and channel map don't match.");
return FALSE;
return false;
}
*entry = entry_new();
(*entry)->port_valid = le->port_valid;
(*entry)->port = pa_xstrdup(le->port);
*perportentry = perportentry_new(TRUE);
*perportentry = perportentry_new(true);
(*perportentry)->muted_valid = le->muted_valid;
(*perportentry)->volume_valid = le->volume_valid;
(*perportentry)->muted = le->muted;
(*perportentry)->channel_map = le->channel_map;
(*perportentry)->volume = le->volume;
return TRUE;
return true;
}
#endif
@ -594,7 +594,7 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3
char *name;
const char *port = NULL;
pa_device_type_t type;
pa_bool_t written = FALSE;
bool written = false;
pa_assert(c);
pa_assert(u);
@ -624,23 +624,23 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3
if (sink->save_port) {
pa_xfree(e->port);
e->port = pa_xstrdup(port ? port : "");
e->port_valid = TRUE;
e->port_valid = true;
}
if ((oldppe = perportentry_read(u, name, port)))
ppe = perportentry_copy(oldppe);
else
ppe = perportentry_new(TRUE);
ppe = perportentry_new(true);
if (sink->save_volume) {
ppe->channel_map = sink->channel_map;
ppe->volume = *pa_sink_get_volume(sink, FALSE);
ppe->volume_valid = TRUE;
ppe->volume = *pa_sink_get_volume(sink, false);
ppe->volume_valid = true;
}
if (sink->save_muted) {
ppe->muted = pa_sink_get_mute(sink, FALSE);
ppe->muted_valid = TRUE;
ppe->muted = pa_sink_get_mute(sink, false);
ppe->muted_valid = true;
}
} else {
pa_source *source;
@ -663,23 +663,23 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3
if (source->save_port) {
pa_xfree(e->port);
e->port = pa_xstrdup(port ? port : "");
e->port_valid = TRUE;
e->port_valid = true;
}
if ((oldppe = perportentry_read(u, name, port)))
ppe = perportentry_copy(oldppe);
else
ppe = perportentry_new(TRUE);
ppe = perportentry_new(true);
if (source->save_volume) {
ppe->channel_map = source->channel_map;
ppe->volume = *pa_source_get_volume(source, FALSE);
ppe->volume_valid = TRUE;
ppe->volume = *pa_source_get_volume(source, false);
ppe->volume_valid = true;
}
if (source->save_muted) {
ppe->muted = pa_source_get_mute(source, FALSE);
ppe->muted_valid = TRUE;
ppe->muted = pa_source_get_mute(source, false);
ppe->muted_valid = true;
}
}
@ -745,7 +745,7 @@ static pa_hook_result_t sink_new_hook_callback(pa_core *c, pa_sink_new_data *new
if (!new_data->active_port) {
pa_log_info("Restoring port for sink %s.", name);
pa_sink_new_data_set_port(new_data, e->port);
new_data->save_port = TRUE;
new_data->save_port = true;
} else
pa_log_debug("Not restoring port for sink %s, because already set.", name);
}
@ -783,7 +783,7 @@ static pa_hook_result_t sink_fixate_hook_callback(pa_core *c, pa_sink_new_data *
pa_sink_new_data_set_volume(new_data, &v);
pa_log_info("Restored volume: %s", pa_cvolume_snprint(buf, PA_CVOLUME_SNPRINT_MAX, &new_data->volume));
new_data->save_volume = TRUE;
new_data->save_volume = true;
} else
pa_log_debug("Not restoring volume for sink %s, because already set.", new_data->name);
}
@ -793,7 +793,7 @@ static pa_hook_result_t sink_fixate_hook_callback(pa_core *c, pa_sink_new_data *
if (!new_data->muted_is_set) {
pa_log_info("Restoring mute state for sink %s.", new_data->name);
pa_sink_new_data_set_muted(new_data, e->muted);
new_data->save_muted = TRUE;
new_data->save_muted = true;
} else
pa_log_debug("Not restoring mute state for sink %s, because already set.", new_data->name);
}
@ -826,17 +826,17 @@ static pa_hook_result_t sink_port_hook_callback(pa_core *c, pa_sink *sink, struc
pa_log_info("Restoring volume for sink %s.", sink->name);
v = e->volume;
pa_cvolume_remap(&v, &e->channel_map, &sink->channel_map);
pa_sink_set_volume(sink, &v, TRUE, FALSE);
pa_sink_set_volume(sink, &v, true, false);
pa_log_info("Restored volume: %s", pa_cvolume_snprint(buf, PA_CVOLUME_SNPRINT_MAX, &sink->reference_volume));
sink->save_volume = TRUE;
sink->save_volume = true;
}
if (u->restore_muted && e->muted_valid) {
pa_log_info("Restoring mute state for sink %s.", sink->name);
pa_sink_set_mute(sink, e->muted, FALSE);
sink->save_muted = TRUE;
pa_sink_set_mute(sink, e->muted, false);
sink->save_muted = true;
}
perportentry_free(e);
@ -888,7 +888,7 @@ static pa_hook_result_t source_new_hook_callback(pa_core *c, pa_source_new_data
if (!new_data->active_port) {
pa_log_info("Restoring port for source %s.", name);
pa_source_new_data_set_port(new_data, e->port);
new_data->save_port = TRUE;
new_data->save_port = true;
} else
pa_log_debug("Not restoring port for source %s, because already set.", name);
}
@ -926,7 +926,7 @@ static pa_hook_result_t source_fixate_hook_callback(pa_core *c, pa_source_new_da
pa_source_new_data_set_volume(new_data, &v);
pa_log_info("Restored volume: %s", pa_cvolume_snprint(buf, PA_CVOLUME_SNPRINT_MAX, &new_data->volume));
new_data->save_volume = TRUE;
new_data->save_volume = true;
} else
pa_log_debug("Not restoring volume for source %s, because already set.", new_data->name);
}
@ -936,7 +936,7 @@ static pa_hook_result_t source_fixate_hook_callback(pa_core *c, pa_source_new_da
if (!new_data->muted_is_set) {
pa_log_info("Restoring mute state for source %s.", new_data->name);
pa_source_new_data_set_muted(new_data, e->muted);
new_data->save_muted = TRUE;
new_data->save_muted = true;
} else
pa_log_debug("Not restoring mute state for source %s, because already set.", new_data->name);
}
@ -969,17 +969,17 @@ static pa_hook_result_t source_port_hook_callback(pa_core *c, pa_source *source,
pa_log_info("Restoring volume for source %s.", source->name);
v = e->volume;
pa_cvolume_remap(&v, &e->channel_map, &source->channel_map);
pa_source_set_volume(source, &v, TRUE, FALSE);
pa_source_set_volume(source, &v, true, false);
pa_log_info("Restored volume: %s", pa_cvolume_snprint(buf, PA_CVOLUME_SNPRINT_MAX, &source->reference_volume));
source->save_volume = TRUE;
source->save_volume = true;
}
if (u->restore_muted && e->muted_valid) {
pa_log_info("Restoring mute state for source %s.", source->name);
pa_source_set_mute(source, e->muted, FALSE);
source->save_muted = TRUE;
pa_source_set_mute(source, e->muted, false);
source->save_muted = true;
}
perportentry_free(e);
@ -1057,7 +1057,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
case SUBCOMMAND_SUBSCRIBE: {
pa_bool_t enabled;
bool enabled;
if (pa_tagstruct_get_boolean(t, &enabled) < 0 ||
!pa_tagstruct_eof(t))
@ -1144,7 +1144,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
/* Read or create an entry */
name = pa_sprintf_malloc("sink:%s", sink->name);
if (!(e = perportentry_read(u, name, (sink->active_port ? sink->active_port->name : NULL))))
e = perportentry_new(FALSE);
e = perportentry_new(false);
else {
/* Clean out any saved formats */
pa_idxset_free(e->formats, (pa_free_cb_t) pa_format_info_free);
@ -1210,7 +1210,7 @@ int pa__init(pa_module*m) {
pa_sink *sink;
pa_source *source;
uint32_t idx;
pa_bool_t restore_volume = TRUE, restore_muted = TRUE, restore_port = TRUE, restore_formats = TRUE;
bool restore_volume = true, restore_muted = true, restore_port = true, restore_formats = true;
pa_assert(m);
@ -1263,10 +1263,10 @@ int pa__init(pa_module*m) {
if (restore_formats)
u->sink_put_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_PUT], PA_HOOK_EARLY, (pa_hook_cb_t) sink_put_hook_callback, u);
if (!(fname = pa_state_path("device-volumes", TRUE)))
if (!(fname = pa_state_path("device-volumes", true)))
goto fail;
if (!(u->database = pa_database_open(fname, TRUE))) {
if (!(u->database = pa_database_open(fname, true))) {
pa_log("Failed to open volume database '%s': %s", fname, pa_cstrerror(errno));
pa_xfree(fname);
goto fail;

68
src/modules/module-equalizer-sink.c
View file

@ -71,7 +71,7 @@
PA_MODULE_AUTHOR("Jason Newton");
PA_MODULE_DESCRIPTION(_("General Purpose Equalizer"));
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
PA_MODULE_USAGE(
_("sink_name=<name of the sink> "
"sink_properties=<properties for the sink> "
@ -85,13 +85,13 @@ PA_MODULE_USAGE(
));
#define MEMBLOCKQ_MAXLENGTH (16*1024*1024)
#define DEFAULT_AUTOLOADED FALSE
#define DEFAULT_AUTOLOADED false
struct userdata {
pa_module *module;
pa_sink *sink;
pa_sink_input *sink_input;
pa_bool_t autoloaded;
bool autoloaded;
size_t channels;
size_t fft_size;//length (res) of fft
@ -122,7 +122,7 @@ struct userdata {
size_t output_buffer_length;
size_t output_buffer_max_length;
pa_memblockq *output_q;
pa_bool_t first_iteration;
bool first_iteration;
pa_dbus_protocol *dbus_protocol;
char *dbus_path;
@ -197,17 +197,17 @@ static void interpolate(float *samples, size_t length, uint32_t *xs, float *ys,
samples[length-1] = ys[n_points-1];
}
static pa_bool_t is_monotonic(const uint32_t *xs, size_t length) {
static bool is_monotonic(const uint32_t *xs, size_t length) {
pa_assert(xs);
if (length < 2)
return TRUE;
return true;
for(size_t i = 1; i < length; ++i)
if (xs[i] <= xs[i-1])
return FALSE;
return false;
return TRUE;
return true;
}
/* ensures memory allocated is a multiple of v_size and aligned */
@ -301,7 +301,7 @@ static void sink_request_rewind_cb(pa_sink *s) {
return;
/* Just hand this one over to the master sink */
pa_sink_input_request_rewind(u->sink_input, s->thread_info.rewind_nbytes+pa_memblockq_get_length(u->input_q), TRUE, FALSE, FALSE);
pa_sink_input_request_rewind(u->sink_input, s->thread_info.rewind_nbytes+pa_memblockq_get_length(u->input_q), true, false, false);
}
/* Called from I/O thread context */
@ -332,7 +332,7 @@ static void sink_set_volume_cb(pa_sink *s) {
!PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u->sink_input)))
return;
pa_sink_input_set_volume(u->sink_input, &s->real_volume, s->save_volume, TRUE);
pa_sink_input_set_volume(u->sink_input, &s->real_volume, s->save_volume, true);
}
/* Called from main context */
@ -564,7 +564,7 @@ static void process_samples(struct userdata *u) {
pa_sample_clamp(PA_SAMPLE_FLOAT32NE, (uint8_t *) (((float *)u->output_buffer) + c) + offset, fs, u->work_buffer, sizeof(float), u->R);
}
if (u->first_iteration) {
u->first_iteration = FALSE;
u->first_iteration = false;
}
u->samples_gathered -= u->R;
}
@ -711,7 +711,7 @@ static void reset_filter(struct userdata *u) {
for(size_t i = 0; i < u->channels; ++i)
pa_memzero(u->overlap_accum[i], u->overlap_size * sizeof(float));
u->first_iteration = TRUE;
u->first_iteration = true;
//set buffer size to max request, no overlap copy
max_request = PA_ROUND_UP(pa_sink_input_get_max_request(u->sink_input) / fs , u->R);
max_request = PA_MAX(max_request, u->window_size);
@ -739,7 +739,7 @@ static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
if (amount > 0) {
//invalidate the output q
pa_memblockq_seek(u->input_q, - (int64_t) amount, PA_SEEK_RELATIVE, TRUE);
pa_memblockq_seek(u->input_q, - (int64_t) amount, PA_SEEK_RELATIVE, true);
pa_log("Resetting filter");
//reset_filter(u); //this is the "proper" thing to do...
}
@ -851,7 +851,7 @@ static void sink_input_kill_cb(pa_sink_input *i) {
/* Leave u->sink alone for now, it will be cleaned up on module
* unload (and it is needed during unload as well). */
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
/* Called from IO thread context */
@ -866,7 +866,7 @@ static void sink_input_state_change_cb(pa_sink_input *i, pa_sink_input_state_t s
if (PA_SINK_INPUT_IS_LINKED(state) &&
i->thread_info.state == PA_SINK_INPUT_INIT) {
pa_log_debug("Requesting rewind due to state change.");
pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
pa_sink_input_request_rewind(i, 0, false, true, true);
}
}
@ -924,7 +924,7 @@ static void save_profile(struct userdata *u, size_t channel, char *name) {
key.size = strlen(key.data);
data.data = profile;
data.size = profile_size;
pa_database_set(u->database, &key, &data, TRUE);
pa_database_set(u->database, &key, &data, true);
pa_database_sync(u->database);
if (u->base_profiles[channel]) {
pa_xfree(u->base_profiles[channel]);
@ -962,11 +962,11 @@ static void save_state(struct userdata *u) {
data.data = state;
data.size = filter_state_size + packed_length;
//thread safety for 0.9.17?
pa_assert_se(dbname = pa_state_path(EQ_STATE_DB, FALSE));
pa_assert_se(database = pa_database_open(dbname, TRUE));
pa_assert_se(dbname = pa_state_path(EQ_STATE_DB, false));
pa_assert_se(database = pa_database_open(dbname, true));
pa_xfree(dbname);
pa_database_set(database, &key, &data, TRUE);
pa_database_set(database, &key, &data, true);
pa_database_sync(database);
pa_database_close(database);
pa_xfree(state);
@ -1014,8 +1014,8 @@ static void load_state(struct userdata *u) {
pa_datum key, value;
pa_database *database;
char *dbname;
pa_assert_se(dbname = pa_state_path(EQ_STATE_DB, FALSE));
database = pa_database_open(dbname, FALSE);
pa_assert_se(dbname = pa_state_path(EQ_STATE_DB, false));
database = pa_database_open(dbname, false);
pa_xfree(dbname);
if (!database) {
pa_log("No resume state");
@ -1053,14 +1053,14 @@ static void load_state(struct userdata *u) {
}
/* Called from main context */
static pa_bool_t sink_input_may_move_to_cb(pa_sink_input *i, pa_sink *dest) {
static bool sink_input_may_move_to_cb(pa_sink_input *i, pa_sink *dest) {
struct userdata *u;
pa_sink_input_assert_ref(i);
pa_assert_se(u = i->userdata);
if (u->autoloaded)
return FALSE;
return false;
return u->sink != dest;
}
@ -1092,7 +1092,7 @@ int pa__init(pa_module*m) {
unsigned c;
float *H;
unsigned a_i;
pa_bool_t use_volume_sharing = TRUE;
bool use_volume_sharing = true;
pa_assert(m);
@ -1161,7 +1161,7 @@ int pa__init(pa_module*m) {
u->inverse_plan = fftwf_plan_dft_c2r_1d(u->fft_size, u->output_window, u->work_buffer, FFTW_ESTIMATE);
hanning_window(u->W, u->window_size);
u->first_iteration = TRUE;
u->first_iteration = true;
u->base_profiles = pa_xnew0(char *, u->channels);
for (c = 0; c < u->channels; ++c)
@ -1210,7 +1210,7 @@ int pa__init(pa_module*m) {
pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
if (!use_volume_sharing) {
pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
pa_sink_enable_decibel_volume(u->sink, TRUE);
pa_sink_enable_decibel_volume(u->sink, true);
}
u->sink->userdata = u;
@ -1227,7 +1227,7 @@ int pa__init(pa_module*m) {
pa_sink_input_new_data_init(&sink_input_data);
sink_input_data.driver = __FILE__;
sink_input_data.module = m;
pa_sink_input_new_data_set_sink(&sink_input_data, master, FALSE);
pa_sink_input_new_data_set_sink(&sink_input_data, master, false);
sink_input_data.origin_sink = u->sink;
pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_NAME, "Equalized Stream");
pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_ROLE, "filter");
@ -1592,8 +1592,8 @@ void dbus_init(struct userdata *u) {
char *dbname;
sink_list=pa_idxset_new(&pa_idxset_trivial_hash_func, &pa_idxset_trivial_compare_func);
pa_shared_set(u->sink->core, SINKLIST, sink_list);
pa_assert_se(dbname = pa_state_path("equalizer-presets", FALSE));
pa_assert_se(u->database = pa_database_open(dbname, TRUE));
pa_assert_se(dbname = pa_state_path("equalizer-presets", false));
pa_assert_se(u->database = pa_database_open(dbname, true));
pa_xfree(dbname);
pa_shared_set(u->sink->core, EQDB, u->database);
pa_dbus_protocol_add_interface(u->dbus_protocol, MANAGER_PATH, &manager_info, u->sink->core);
@ -1702,7 +1702,7 @@ static void get_profiles(pa_core *c, char ***names, unsigned *n) {
pa_database *database;
pa_datum key, next_key;
pa_strlist *head=NULL, *iter;
pa_bool_t done;
bool done;
pa_assert_se(database = pa_shared_get(c, EQDB));
pa_assert(c);
@ -1790,7 +1790,7 @@ void equalizer_handle_seed_filter(DBusConnection *conn, DBusMessage *msg, void *
double *_ys, preamp;
unsigned x_npoints, y_npoints, a_i;
float *H;
pa_bool_t points_good = TRUE;
bool points_good = true;
pa_assert(conn);
pa_assert(msg);
@ -1815,7 +1815,7 @@ void equalizer_handle_seed_filter(DBusConnection *conn, DBusMessage *msg, void *
}
for(size_t i = 0; i < x_npoints; ++i) {
if (xs[i] >= FILTER_SIZE(u)) {
points_good = FALSE;
points_good = false;
break;
}
}
@ -1868,7 +1868,7 @@ void equalizer_handle_get_filter_points(DBusConnection *conn, DBusMessage *msg,
double *ys, preamp;
unsigned x_npoints, a_i;
float *H;
pa_bool_t points_good=TRUE;
bool points_good=true;
DBusMessage *reply = NULL;
DBusMessageIter msg_iter;
DBusError error;
@ -1894,7 +1894,7 @@ void equalizer_handle_get_filter_points(DBusConnection *conn, DBusMessage *msg,
for(size_t i = 0; i < x_npoints; ++i) {
if (xs[i] >= FILTER_SIZE(u)) {
points_good=FALSE;
points_good=false;
break;
}
}

4
src/modules/module-esound-compat-spawnfd.c
View file

@ -36,7 +36,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("ESOUND compatibility module: -spawnfd emulation");
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_USAGE("fd=<file descriptor>");
@ -66,7 +66,7 @@ int pa__init(pa_module*m) {
pa_assert_se(pa_close(fd) == 0);
pa_module_unload_request(m, TRUE);
pa_module_unload_request(m, true);
ret = 0;

4
src/modules/module-esound-compat-spawnpid.c
View file

@ -38,7 +38,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("ESOUND compatibility module: -spawnpid emulation");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE("pid=<process id>");
static const char* const valid_modargs[] = {
@ -63,7 +63,7 @@ int pa__init(pa_module*m) {
if (kill((pid_t) pid, SIGUSR1) < 0)
pa_log_warn("kill(%u) failed: %s", pid, pa_cstrerror(errno));
pa_module_unload_request(m, TRUE);
pa_module_unload_request(m, true);
ret = 0;

22
src/modules/module-esound-sink.c
View file

@ -72,7 +72,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("ESOUND Sink");
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> "
@ -159,7 +159,7 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
case PA_SINK_RUNNING:
if (u->sink->thread_info.state == PA_SINK_SUSPENDED)
pa_smoother_resume(u->smoother, pa_rtclock_now(), TRUE);
pa_smoother_resume(u->smoother, pa_rtclock_now(), true);
break;
@ -307,7 +307,7 @@ static void thread_func(void *userdata) {
pollfd->events = (short) (PA_SINK_IS_OPENED(u->sink->thread_info.state) ? POLLOUT : 0);
}
if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
if ((ret = pa_rtpoll_run(u->rtpoll, true)) < 0)
goto fail;
if (ret == 0)
@ -370,7 +370,7 @@ static int do_write(struct userdata *u) {
pa_assert(u->fd < 0);
u->fd = pa_iochannel_get_send_fd(u->io);
pa_iochannel_set_noclose(u->io, TRUE);
pa_iochannel_set_noclose(u->io, true);
pa_iochannel_free(u->io);
u->io = NULL;
@ -497,7 +497,7 @@ static void io_callback(pa_iochannel *io, void*userdata) {
u->io = NULL;
}
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
}
@ -509,7 +509,7 @@ static void on_connection(pa_socket_client *c, pa_iochannel*io, void *userdata)
if (!io) {
pa_log("Connection failed: %s", pa_cstrerror(errno));
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
return;
}
@ -555,11 +555,11 @@ int pa__init(pa_module*m) {
u->smoother = pa_smoother_new(
PA_USEC_PER_SEC,
PA_USEC_PER_SEC*2,
TRUE,
TRUE,
true,
true,
10,
0,
FALSE);
false);
pa_memchunk_reset(&u->memchunk);
u->offset = 0;
@ -613,7 +613,7 @@ int pa__init(pa_module*m) {
pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
pa_sink_set_rtpoll(u->sink, u->rtpoll);
if (!(u->client = pa_socket_client_new_string(u->core->mainloop, TRUE, espeaker, ESD_DEFAULT_PORT))) {
if (!(u->client = pa_socket_client_new_string(u->core->mainloop, true, espeaker, ESD_DEFAULT_PORT))) {
pa_log("Failed to connect to server.");
goto fail;
}
@ -622,7 +622,7 @@ int pa__init(pa_module*m) {
/* Prepare the initial request */
u->write_data = pa_xmalloc(u->write_length = ESD_KEY_LEN + sizeof(int32_t));
if (pa_authkey_load_auto(pa_modargs_get_value(ma, "cookie", ".esd_auth"), TRUE, u->write_data, ESD_KEY_LEN) < 0) {
if (pa_authkey_load_auto(pa_modargs_get_value(ma, "cookie", ".esd_auth"), true, u->write_data, ESD_KEY_LEN) < 0) {
pa_log("Failed to load cookie");
goto fail;
}

88
src/modules/module-filter-apply.c
View file

@ -44,7 +44,7 @@
PA_MODULE_AUTHOR("Colin Guthrie");
PA_MODULE_DESCRIPTION("Load filter sinks automatically when needed");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE(_("autoclean=<automatically unload unused filters?>"));
static const char* const valid_modargs[] = {
@ -52,7 +52,7 @@ static const char* const valid_modargs[] = {
NULL
};
#define DEFAULT_AUTOCLEAN TRUE
#define DEFAULT_AUTOCLEAN true
#define HOUSEKEEPING_INTERVAL (10 * PA_USEC_PER_SEC)
struct filter {
@ -78,7 +78,7 @@ struct userdata {
*source_output_proplist_slot,
*source_output_unlink_slot,
*source_unlink_slot;
pa_bool_t autoclean;
bool autoclean;
pa_time_event *housekeeping_time_event;
};
@ -128,7 +128,7 @@ static void filter_free(struct filter *f) {
pa_xfree(f);
}
static const char* should_filter(pa_object *o, pa_bool_t is_sink_input) {
static const char* should_filter(pa_object *o, bool is_sink_input) {
const char *apply;
pa_proplist *pl;
@ -148,11 +148,11 @@ static const char* should_filter(pa_object *o, pa_bool_t is_sink_input) {
return NULL;
}
static pa_bool_t should_group_filter(struct filter *filter) {
static bool should_group_filter(struct filter *filter) {
return pa_streq(filter->name, "echo-cancel");
}
static char* get_group(pa_object *o, pa_bool_t is_sink_input) {
static char* get_group(pa_object *o, bool is_sink_input) {
pa_proplist *pl;
if (is_sink_input)
@ -170,7 +170,7 @@ static char* get_group(pa_object *o, pa_bool_t is_sink_input) {
* looking up streams that belong to the same stream group as the original
* object. The idea is that streams from the sam group are always routed
* together. */
static pa_bool_t find_paired_master(struct userdata *u, struct filter *filter, pa_object *o, pa_bool_t is_sink_input) {
static bool find_paired_master(struct userdata *u, struct filter *filter, pa_object *o, bool is_sink_input) {
char *group;
if ((group = get_group(o, is_sink_input))) {
@ -182,7 +182,7 @@ static pa_bool_t find_paired_master(struct userdata *u, struct filter *filter, p
pa_source_output *so;
PA_IDXSET_FOREACH(so, u->core->source_outputs, idx) {
g = get_group(PA_OBJECT(so), FALSE);
g = get_group(PA_OBJECT(so), false);
if (pa_streq(g, group)) {
if (pa_streq(module_name, so->source->module->name)) {
@ -203,7 +203,7 @@ static pa_bool_t find_paired_master(struct userdata *u, struct filter *filter, p
pa_sink_input *si;
PA_IDXSET_FOREACH(si, u->core->sink_inputs, idx) {
g = get_group(PA_OBJECT(si), TRUE);
g = get_group(PA_OBJECT(si), true);
if (pa_streq(g, group)) {
if (pa_streq(module_name, si->sink->module->name)) {
@ -226,14 +226,14 @@ static pa_bool_t find_paired_master(struct userdata *u, struct filter *filter, p
pa_xfree(module_name);
if (!filter->sink_master || !filter->source_master)
return FALSE;
return false;
}
return TRUE;
return true;
}
static pa_bool_t nothing_attached(struct filter *f) {
pa_bool_t no_si = TRUE, no_so = TRUE;
static bool nothing_attached(struct filter *f) {
bool no_si = true, no_so = true;
if (f->sink)
no_si = pa_idxset_isempty(f->sink->inputs);
@ -264,7 +264,7 @@ static void housekeeping_time_callback(pa_mainloop_api*a, pa_time_event* e, cons
idx = filter->module_index;
pa_hashmap_remove(u->filters, filter);
filter_free(filter);
pa_module_unload_request_by_index(u->core, idx, TRUE);
pa_module_unload_request_by_index(u->core, idx, true);
}
}
@ -283,14 +283,14 @@ static void trigger_housekeeping(struct userdata *u) {
u->housekeeping_time_event = pa_core_rttime_new(u->core, pa_rtclock_now() + HOUSEKEEPING_INTERVAL, housekeeping_time_callback, u);
}
static int do_move(pa_object *obj, pa_object *parent, pa_bool_t restore, pa_bool_t is_input) {
static int do_move(pa_object *obj, pa_object *parent, bool restore, bool is_input) {
if (is_input)
return pa_sink_input_move_to(PA_SINK_INPUT(obj), PA_SINK(parent), restore);
else
return pa_source_output_move_to(PA_SOURCE_OUTPUT(obj), PA_SOURCE(parent), restore);
}
static void move_object_for_filter(pa_object *o, struct filter* filter, pa_bool_t restore, pa_bool_t is_sink_input) {
static void move_object_for_filter(pa_object *o, struct filter* filter, bool restore, bool is_sink_input) {
pa_object *parent;
pa_proplist *pl;
const char *name;
@ -314,7 +314,7 @@ static void move_object_for_filter(pa_object *o, struct filter* filter, pa_bool_
pa_proplist_sets(pl, PA_PROP_FILTER_APPLY_MOVING, "1");
if (do_move(o, parent, FALSE, is_sink_input) < 0)
if (do_move(o, parent, false, is_sink_input) < 0)
pa_log_info("Failed to move %s for \"%s\" to <%s>.", is_sink_input ? "sink-input" : "source-output",
pa_strnull(pa_proplist_gets(pl, PA_PROP_APPLICATION_NAME)), name);
else
@ -324,8 +324,8 @@ static void move_object_for_filter(pa_object *o, struct filter* filter, pa_bool_
pa_proplist_unset(pl, PA_PROP_FILTER_APPLY_MOVING);
}
static void move_objects_for_filter(struct userdata *u, pa_object *o, struct filter* filter, pa_bool_t restore,
pa_bool_t is_sink_input) {
static void move_objects_for_filter(struct userdata *u, pa_object *o, struct filter* filter, bool restore,
bool is_sink_input) {
if (!should_group_filter(filter))
move_object_for_filter(o, filter, restore, is_sink_input);
@ -338,19 +338,19 @@ static void move_objects_for_filter(struct userdata *u, pa_object *o, struct fil
group = get_group(o, is_sink_input);
PA_IDXSET_FOREACH(so, u->core->source_outputs, idx) {
g = get_group(PA_OBJECT(so), FALSE);
g = get_group(PA_OBJECT(so), false);
if (pa_streq(g, group))
move_object_for_filter(PA_OBJECT(so), filter, restore, FALSE);
move_object_for_filter(PA_OBJECT(so), filter, restore, false);
pa_xfree(g);
}
PA_IDXSET_FOREACH(si, u->core->sink_inputs, idx) {
g = get_group(PA_OBJECT(si), TRUE);
g = get_group(PA_OBJECT(si), true);
if (pa_streq(g, group))
move_object_for_filter(PA_OBJECT(si), filter, restore, TRUE);
move_object_for_filter(PA_OBJECT(si), filter, restore, true);
pa_xfree(g);
}
@ -399,22 +399,22 @@ static void find_filters_for_module(struct userdata *u, pa_module *m, const char
pa_hashmap_put(u->filters, fltr, fltr);
}
static pa_bool_t can_unload_module(struct userdata *u, uint32_t idx) {
static bool can_unload_module(struct userdata *u, uint32_t idx) {
void *state;
struct filter *filter;
/* Check if any other struct filters point to the same module */
PA_HASHMAP_FOREACH(filter, u->filters, state) {
if (filter->module_index == idx && !nothing_attached(filter))
return FALSE;
return false;
}
return TRUE;
return true;
}
static pa_hook_result_t process(struct userdata *u, pa_object *o, pa_bool_t is_sink_input) {
static pa_hook_result_t process(struct userdata *u, pa_object *o, bool is_sink_input) {
const char *want;
pa_bool_t done_something = FALSE;
bool done_something = false;
pa_sink *sink = NULL;
pa_source *source = NULL;
pa_module *module = NULL;
@ -475,7 +475,7 @@ static pa_hook_result_t process(struct userdata *u, pa_object *o, pa_bool_t is_s
if ((m = pa_module_load(u->core, module_name, args))) {
find_filters_for_module(u, m, want);
filter = pa_hashmap_get(u->filters, fltr);
done_something = TRUE;
done_something = true;
}
pa_xfree(args);
}
@ -492,8 +492,8 @@ static pa_hook_result_t process(struct userdata *u, pa_object *o, pa_bool_t is_s
/* We can move the stream now as we know the destination. If this
* isn't true, we will do it later when the sink appears. */
if ((is_sink_input && filter->sink) || (!is_sink_input && filter->source)) {
move_objects_for_filter(u, o, filter, FALSE, is_sink_input);
done_something = TRUE;
move_objects_for_filter(u, o, filter, false, is_sink_input);
done_something = true;
}
} else {
void *state;
@ -503,8 +503,8 @@ static pa_hook_result_t process(struct userdata *u, pa_object *o, pa_bool_t is_s
* This can happen if an input's proplist changes */
PA_HASHMAP_FOREACH(filter, u->filters, state) {
if ((is_sink_input && sink == filter->sink) || (!is_sink_input && source == filter->source)) {
move_objects_for_filter(u, o, filter, TRUE, is_sink_input);
done_something = TRUE;
move_objects_for_filter(u, o, filter, true, is_sink_input);
done_something = true;
break;
}
}
@ -520,7 +520,7 @@ static pa_hook_result_t sink_input_put_cb(pa_core *core, pa_sink_input *i, struc
pa_core_assert_ref(core);
pa_sink_input_assert_ref(i);
return process(u, PA_OBJECT(i), TRUE);
return process(u, PA_OBJECT(i), true);
}
static pa_hook_result_t sink_input_move_finish_cb(pa_core *core, pa_sink_input *i, struct userdata *u) {
@ -530,14 +530,14 @@ static pa_hook_result_t sink_input_move_finish_cb(pa_core *core, pa_sink_input *
if (pa_proplist_gets(i->proplist, PA_PROP_FILTER_APPLY_MOVING))
return PA_HOOK_OK;
return process(u, PA_OBJECT(i), TRUE);
return process(u, PA_OBJECT(i), true);
}
static pa_hook_result_t sink_input_proplist_cb(pa_core *core, pa_sink_input *i, struct userdata *u) {
pa_core_assert_ref(core);
pa_sink_input_assert_ref(i);
return process(u, PA_OBJECT(i), TRUE);
return process(u, PA_OBJECT(i), true);
}
static pa_hook_result_t sink_input_unlink_cb(pa_core *core, pa_sink_input *i, struct userdata *u) {
@ -573,7 +573,7 @@ static pa_hook_result_t sink_unlink_cb(pa_core *core, pa_sink *sink, struct user
pa_sink_input *i;
PA_IDXSET_FOREACH(i, sink->inputs, idx)
move_objects_for_filter(u, PA_OBJECT(i), filter, TRUE, TRUE);
move_objects_for_filter(u, PA_OBJECT(i), filter, true, true);
}
idx = filter->module_index;
@ -581,7 +581,7 @@ static pa_hook_result_t sink_unlink_cb(pa_core *core, pa_sink *sink, struct user
filter_free(filter);
if (can_unload_module(u, idx))
pa_module_unload_request_by_index(u->core, idx, TRUE);
pa_module_unload_request_by_index(u->core, idx, true);
}
}
@ -592,7 +592,7 @@ static pa_hook_result_t source_output_put_cb(pa_core *core, pa_source_output *o,
pa_core_assert_ref(core);
pa_source_output_assert_ref(o);
return process(u, PA_OBJECT(o), FALSE);
return process(u, PA_OBJECT(o), false);
}
static pa_hook_result_t source_output_move_finish_cb(pa_core *core, pa_source_output *o, struct userdata *u) {
@ -602,14 +602,14 @@ static pa_hook_result_t source_output_move_finish_cb(pa_core *core, pa_source_ou
if (pa_proplist_gets(o->proplist, PA_PROP_FILTER_APPLY_MOVING))
return PA_HOOK_OK;
return process(u, PA_OBJECT(o), FALSE);
return process(u, PA_OBJECT(o), false);
}
static pa_hook_result_t source_output_proplist_cb(pa_core *core, pa_source_output *o, struct userdata *u) {
pa_core_assert_ref(core);
pa_source_output_assert_ref(o);
return process(u, PA_OBJECT(o), FALSE);
return process(u, PA_OBJECT(o), false);
}
static pa_hook_result_t source_output_unlink_cb(pa_core *core, pa_source_output *o, struct userdata *u) {
@ -645,7 +645,7 @@ static pa_hook_result_t source_unlink_cb(pa_core *core, pa_source *source, struc
pa_source_output *o;
PA_IDXSET_FOREACH(o, source->outputs, idx)
move_objects_for_filter(u, PA_OBJECT(o), filter, TRUE, FALSE);
move_objects_for_filter(u, PA_OBJECT(o), filter, true, false);
}
idx = filter->module_index;
@ -653,7 +653,7 @@ static pa_hook_result_t source_unlink_cb(pa_core *core, pa_source *source, struc
filter_free(filter);
if (can_unload_module(u, idx))
pa_module_unload_request_by_index(u->core, idx, TRUE);
pa_module_unload_request_by_index(u->core, idx, true);
}
}
@ -743,7 +743,7 @@ void pa__done(pa_module *m) {
struct filter *f;
while ((f = pa_hashmap_steal_first(u->filters))) {
pa_module_unload_request_by_index(u->core, f->module_index, TRUE);
pa_module_unload_request_by_index(u->core, f->module_index, true);
filter_free(f);
}

12
src/modules/module-filter-heuristics.c
View file

@ -40,7 +40,7 @@
PA_MODULE_AUTHOR("Colin Guthrie");
PA_MODULE_DESCRIPTION("Detect when various filters are desirable");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
static const char* const valid_modargs[] = {
NULL
@ -55,7 +55,7 @@ struct userdata {
*source_output_move_finish_slot;
};
static pa_hook_result_t process(struct userdata *u, pa_object *o, pa_bool_t is_sink_input) {
static pa_hook_result_t process(struct userdata *u, pa_object *o, bool is_sink_input) {
const char *want;
pa_proplist *pl, *parent_pl;
@ -99,7 +99,7 @@ static pa_hook_result_t sink_input_put_cb(pa_core *core, pa_sink_input *i, struc
pa_sink_input_assert_ref(i);
pa_assert(u);
return process(u, PA_OBJECT(i), TRUE);
return process(u, PA_OBJECT(i), true);
}
static pa_hook_result_t sink_input_move_finish_cb(pa_core *core, pa_sink_input *i, struct userdata *u) {
@ -111,7 +111,7 @@ static pa_hook_result_t sink_input_move_finish_cb(pa_core *core, pa_sink_input *
if (pa_proplist_gets(i->proplist, PA_PROP_FILTER_APPLY_MOVING))
return PA_HOOK_OK;
return process(u, PA_OBJECT(i), TRUE);
return process(u, PA_OBJECT(i), true);
}
static pa_hook_result_t source_output_put_cb(pa_core *core, pa_source_output *i, struct userdata *u) {
@ -119,7 +119,7 @@ static pa_hook_result_t source_output_put_cb(pa_core *core, pa_source_output *i,
pa_source_output_assert_ref(i);
pa_assert(u);
return process(u, PA_OBJECT(i), FALSE);
return process(u, PA_OBJECT(i), false);
}
static pa_hook_result_t source_output_move_finish_cb(pa_core *core, pa_source_output *i, struct userdata *u) {
@ -131,7 +131,7 @@ static pa_hook_result_t source_output_move_finish_cb(pa_core *core, pa_source_ou
if (pa_proplist_gets(i->proplist, PA_PROP_FILTER_APPLY_MOVING))
return PA_HOOK_OK;
return process(u, PA_OBJECT(i), FALSE);
return process(u, PA_OBJECT(i), false);
}
int pa__init(pa_module *m) {

6
src/modules/module-hal-detect-compat.c
View file

@ -35,7 +35,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Compatibility module");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_DEPRECATED("Please use module-udev-detect instead of module-hal-detect!");
static const char* const valid_modargs[] = {
@ -47,7 +47,7 @@ static const char* const valid_modargs[] = {
int pa__init(pa_module*m) {
pa_modargs *ma = NULL;
pa_bool_t tsched = TRUE;
bool tsched = true;
pa_module *n;
char *t;
@ -70,7 +70,7 @@ int pa__init(pa_module*m) {
pa_xfree(t);
if (n)
pa_module_unload_request(m, TRUE);
pa_module_unload_request(m, true);
pa_modargs_free(ma);

30
src/modules/module-intended-roles.c
View file

@ -38,7 +38,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Automatically set device of streams based on intended roles of devices");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE(
"on_hotplug=<When new device becomes available, recheck streams?> "
"on_rescue=<When device becomes unavailable, recheck streams?>");
@ -61,11 +61,11 @@ struct userdata {
*sink_unlink_hook_slot,
*source_unlink_hook_slot;
pa_bool_t on_hotplug:1;
pa_bool_t on_rescue:1;
bool on_hotplug:1;
bool on_rescue:1;
};
static pa_bool_t role_match(pa_proplist *proplist, const char *role) {
static bool role_match(pa_proplist *proplist, const char *role) {
return pa_str_in_list_spaces(pa_proplist_gets(proplist, PA_PROP_DEVICE_INTENDED_ROLES), role);
}
@ -95,7 +95,7 @@ static pa_hook_result_t sink_input_new_hook_callback(pa_core *c, pa_sink_input_n
/* Prefer the default sink over any other sink, just in case... */
if ((def = pa_namereg_get_default_sink(c)))
if (role_match(def->proplist, role) && pa_sink_input_new_data_set_sink(new_data, def, FALSE))
if (role_match(def->proplist, role) && pa_sink_input_new_data_set_sink(new_data, def, false))
return PA_HOOK_OK;
/* @todo: favour the highest priority device, not the first one we find? */
@ -106,7 +106,7 @@ static pa_hook_result_t sink_input_new_hook_callback(pa_core *c, pa_sink_input_n
if (!PA_SINK_IS_LINKED(pa_sink_get_state(s)))
continue;
if (role_match(s->proplist, role) && pa_sink_input_new_data_set_sink(new_data, s, FALSE))
if (role_match(s->proplist, role) && pa_sink_input_new_data_set_sink(new_data, s, false))
return PA_HOOK_OK;
}
@ -140,7 +140,7 @@ static pa_hook_result_t source_output_new_hook_callback(pa_core *c, pa_source_ou
/* Prefer the default source over any other source, just in case... */
if ((def = pa_namereg_get_default_source(c)))
if (role_match(def->proplist, role)) {
pa_source_output_new_data_set_source(new_data, def, FALSE);
pa_source_output_new_data_set_source(new_data, def, false);
return PA_HOOK_OK;
}
@ -156,7 +156,7 @@ static pa_hook_result_t source_output_new_hook_callback(pa_core *c, pa_source_ou
/* @todo: favour the highest priority device, not the first one we find? */
if (role_match(s->proplist, role)) {
pa_source_output_new_data_set_source(new_data, s, FALSE);
pa_source_output_new_data_set_source(new_data, s, false);
return PA_HOOK_OK;
}
}
@ -202,7 +202,7 @@ static pa_hook_result_t sink_put_hook_callback(pa_core *c, pa_sink *sink, struct
if (!role_match(sink->proplist, role))
continue;
pa_sink_input_move_to(si, sink, FALSE);
pa_sink_input_move_to(si, sink, false);
}
return PA_HOOK_OK;
@ -252,7 +252,7 @@ static pa_hook_result_t source_put_hook_callback(pa_core *c, pa_source *source,
if (!role_match(source->proplist, role))
continue;
pa_source_output_move_to(so, source, FALSE);
pa_source_output_move_to(so, source, false);
}
return PA_HOOK_OK;
@ -289,7 +289,7 @@ static pa_hook_result_t sink_unlink_hook_callback(pa_core *c, pa_sink *sink, str
/* Would the default sink fit? If so, let's use it */
if (def != sink && role_match(def->proplist, role))
if (pa_sink_input_move_to(si, def, FALSE) >= 0)
if (pa_sink_input_move_to(si, def, false) >= 0)
continue;
/* Try to find some other fitting sink */
@ -302,7 +302,7 @@ static pa_hook_result_t sink_unlink_hook_callback(pa_core *c, pa_sink *sink, str
continue;
if (role_match(d->proplist, role))
if (pa_sink_input_move_to(si, d, FALSE) >= 0)
if (pa_sink_input_move_to(si, d, false) >= 0)
break;
}
}
@ -344,7 +344,7 @@ static pa_hook_result_t source_unlink_hook_callback(pa_core *c, pa_source *sourc
/* Would the default source fit? If so, let's use it */
if (def != source && role_match(def->proplist, role) && !source->monitor_of == !def->monitor_of) {
pa_source_output_move_to(so, def, FALSE);
pa_source_output_move_to(so, def, false);
continue;
}
@ -359,7 +359,7 @@ static pa_hook_result_t source_unlink_hook_callback(pa_core *c, pa_source *sourc
/* If moving from a monitor, move to another monitor */
if (!source->monitor_of == !d->monitor_of && role_match(d->proplist, role)) {
pa_source_output_move_to(so, d, FALSE);
pa_source_output_move_to(so, d, false);
break;
}
}
@ -371,7 +371,7 @@ static pa_hook_result_t source_unlink_hook_callback(pa_core *c, pa_source *sourc
int pa__init(pa_module*m) {
pa_modargs *ma = NULL;
struct userdata *u;
pa_bool_t on_hotplug = TRUE, on_rescue = TRUE;
bool on_hotplug = true, on_rescue = true;
pa_assert(m);

40
src/modules/module-ladspa-sink.c
View file

@ -52,7 +52,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION(_("Virtual LADSPA sink"));
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> "
@ -92,7 +92,7 @@ struct userdata {
pa_memblockq *memblockq;
pa_bool_t *use_default;
bool *use_default;
pa_sample_spec ss;
#ifdef HAVE_DBUS
@ -100,7 +100,7 @@ struct userdata {
char *dbus_path;
#endif
pa_bool_t auto_desc;
bool auto_desc;
};
static const char* const valid_modargs[] = {
@ -124,7 +124,7 @@ enum {
LADSPA_SINK_MESSAGE_UPDATE_PARAMETERS = PA_SINK_MESSAGE_MAX
};
static int write_control_parameters(struct userdata *u, double *control_values, pa_bool_t *use_default);
static int write_control_parameters(struct userdata *u, double *control_values, bool *use_default);
static void connect_control_ports(struct userdata *u);
#ifdef HAVE_DBUS
@ -184,7 +184,7 @@ static void set_algorithm_parameters(DBusConnection *conn, DBusMessage *msg, DBu
unsigned n_dbus_control, n_dbus_use_default;
double *read_values = NULL;
dbus_bool_t *read_defaults = NULL;
pa_bool_t *use_defaults = NULL;
bool *use_defaults = NULL;
unsigned long i;
pa_assert(conn);
@ -216,7 +216,7 @@ static void set_algorithm_parameters(DBusConnection *conn, DBusMessage *msg, DBu
return;
}
use_defaults = pa_xnew(pa_bool_t, n_control);
use_defaults = pa_xnew(bool, n_control);
for (i = 0; i < u->n_control; i++)
use_defaults[i] = read_defaults[i];
@ -403,7 +403,7 @@ static void sink_request_rewind_cb(pa_sink *s) {
/* Just hand this one over to the master sink */
pa_sink_input_request_rewind(u->sink_input,
s->thread_info.rewind_nbytes +
pa_memblockq_get_length(u->memblockq), TRUE, FALSE, FALSE);
pa_memblockq_get_length(u->memblockq), true, false, false);
}
/* Called from I/O thread context */
@ -511,7 +511,7 @@ static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
if (amount > 0) {
unsigned c;
pa_memblockq_seek(u->memblockq, - (int64_t) amount, PA_SEEK_RELATIVE, TRUE);
pa_memblockq_seek(u->memblockq, - (int64_t) amount, PA_SEEK_RELATIVE, true);
pa_log_debug("Resetting plugin");
@ -622,7 +622,7 @@ static void sink_input_kill_cb(pa_sink_input *i) {
pa_sink_unref(u->sink);
u->sink = NULL;
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
/* Called from IO thread context */
@ -637,7 +637,7 @@ static void sink_input_state_change_cb(pa_sink_input *i, pa_sink_input_state_t s
if (PA_SINK_INPUT_IS_LINKED(state) &&
i->thread_info.state == PA_SINK_INPUT_INIT) {
pa_log_debug("Requesting rewind due to state change.");
pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
pa_sink_input_request_rewind(i, 0, false, true, true);
}
}
@ -678,7 +678,7 @@ static void sink_input_mute_changed_cb(pa_sink_input *i) {
pa_sink_mute_changed(u->sink, i->muted);
}
static int parse_control_parameters(struct userdata *u, const char *cdata, double *read_values, pa_bool_t *use_default) {
static int parse_control_parameters(struct userdata *u, const char *cdata, double *read_values, bool *use_default) {
unsigned long p = 0;
const char *state = NULL;
char *k;
@ -699,7 +699,7 @@ static int parse_control_parameters(struct userdata *u, const char *cdata, doubl
if (*k == 0) {
pa_log_debug("Read empty config value (p=%lu)", p);
use_default[p++] = TRUE;
use_default[p++] = true;
pa_xfree(k);
continue;
}
@ -714,7 +714,7 @@ static int parse_control_parameters(struct userdata *u, const char *cdata, doubl
pa_log_debug("Read config value %f (p=%lu)", f, p);
use_default[p] = FALSE;
use_default[p] = false;
read_values[p++] = f;
}
@ -722,7 +722,7 @@ static int parse_control_parameters(struct userdata *u, const char *cdata, doubl
if it is left empty, so we do it here. */
if (*cdata == 0 || cdata[strlen(cdata) - 1] == ',') {
if (p < u->n_control)
use_default[p] = TRUE;
use_default[p] = true;
p++;
}
@ -771,7 +771,7 @@ static void connect_control_ports(struct userdata *u) {
}
}
static int validate_control_parameters(struct userdata *u, double *control_values, pa_bool_t *use_default) {
static int validate_control_parameters(struct userdata *u, double *control_values, bool *use_default) {
unsigned long p = 0, h = 0;
const LADSPA_Descriptor *d;
pa_sample_spec ss;
@ -834,7 +834,7 @@ static int validate_control_parameters(struct userdata *u, double *control_value
return 0;
}
static int write_control_parameters(struct userdata *u, double *control_values, pa_bool_t *use_default) {
static int write_control_parameters(struct userdata *u, double *control_values, bool *use_default) {
unsigned long p = 0, h = 0, c;
const LADSPA_Descriptor *d;
pa_sample_spec ss;
@ -1177,15 +1177,15 @@ int pa__init(pa_module*m) {
if (u->n_control > 0) {
double *control_values;
pa_bool_t *use_default;
bool *use_default;
/* temporary storage for parser */
control_values = pa_xnew(double, (unsigned) u->n_control);
use_default = pa_xnew(pa_bool_t, (unsigned) u->n_control);
use_default = pa_xnew(bool, (unsigned) u->n_control);
/* real storage */
u->control = pa_xnew(LADSPA_Data, (unsigned) u->n_control);
u->use_default = pa_xnew(pa_bool_t, (unsigned) u->n_control);
u->use_default = pa_xnew(bool, (unsigned) u->n_control);
if ((parse_control_parameters(u, cdata, control_values, use_default) < 0) ||
(write_control_parameters(u, control_values, use_default) < 0)) {
@ -1257,7 +1257,7 @@ int pa__init(pa_module*m) {
pa_sink_input_new_data_init(&sink_input_data);
sink_input_data.driver = __FILE__;
sink_input_data.module = m;
pa_sink_input_new_data_set_sink(&sink_input_data, master, FALSE);
pa_sink_input_new_data_set_sink(&sink_input_data, master, false);
sink_input_data.origin_sink = u->sink;
pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_NAME, "LADSPA Stream");
pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_ROLE, "filter");

16
src/modules/module-lirc.c
View file

@ -44,7 +44,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("LIRC volume control");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE("config=<config file> sink=<sink name> appname=<lirc application name> volume_limit=<volume limit> volume_step=<volume change step>");
static const char* const valid_modargs[] = {
@ -123,29 +123,29 @@ static void io_callback(pa_mainloop_api *io, pa_io_event *e, int fd, pa_io_event
if (!(s = pa_namereg_get(u->module->core, u->sink_name, PA_NAMEREG_SINK)))
pa_log("Failed to get sink '%s'", u->sink_name);
else {
pa_cvolume cv = *pa_sink_get_volume(s, FALSE);
pa_cvolume cv = *pa_sink_get_volume(s, false);
switch (volchange) {
case UP:
pa_cvolume_inc_clamp(&cv, u->volume_step, u->volume_limit);
pa_sink_set_volume(s, &cv, TRUE, TRUE);
pa_sink_set_volume(s, &cv, true, true);
break;
case DOWN:
pa_cvolume_dec(&cv, u->volume_step);
pa_sink_set_volume(s, &cv, TRUE, TRUE);
pa_sink_set_volume(s, &cv, true, true);
break;
case MUTE:
pa_sink_set_mute(s, TRUE, TRUE);
pa_sink_set_mute(s, true, true);
break;
case RESET:
pa_sink_set_mute(s, FALSE, TRUE);
pa_sink_set_mute(s, false, true);
break;
case MUTE_TOGGLE:
pa_sink_set_mute(s, !pa_sink_get_mute(s, FALSE), TRUE);
pa_sink_set_mute(s, !pa_sink_get_mute(s, false), true);
break;
case INVALID:
@ -164,7 +164,7 @@ fail:
u->module->core->mainloop->io_free(u->io);
u->io = NULL;
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
pa_xfree(code);
}

42
src/modules/module-loopback.c
View file

@ -43,7 +43,7 @@
PA_MODULE_AUTHOR("Pierre-Louis Bossart");
PA_MODULE_DESCRIPTION("Loopback from source to sink");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
PA_MODULE_USAGE(
"source=<source to connect to> "
"sink=<sink to connect to> "
@ -86,7 +86,7 @@ struct userdata {
size_t skip;
pa_usec_t latency;
pa_bool_t in_pop;
bool in_pop;
size_t min_memblockq_length;
struct {
@ -381,7 +381,7 @@ static void source_output_kill_cb(pa_source_output *o) {
pa_assert_se(u = o->userdata);
teardown(u);
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
/* Called from main thread */
@ -422,7 +422,7 @@ static void source_output_moving_cb(pa_source_output *o, pa_source *dest) {
}
/* Called from main thread */
static void source_output_suspend_cb(pa_source_output *o, pa_bool_t suspended) {
static void source_output_suspend_cb(pa_source_output *o, bool suspended) {
struct userdata *u;
pa_source_output_assert_ref(o);
@ -457,10 +457,10 @@ static int sink_input_pop_cb(pa_sink_input *i, size_t nbytes, pa_memchunk *chunk
pa_assert_se(u = i->userdata);
pa_assert(chunk);
u->in_pop = TRUE;
u->in_pop = true;
while (pa_asyncmsgq_process_one(u->asyncmsgq) > 0)
;
u->in_pop = FALSE;
u->in_pop = false;
if (pa_memblockq_peek(u->memblockq, chunk) < 0) {
pa_log_info("Could not peek into queue");
@ -511,7 +511,7 @@ static int sink_input_process_msg_cb(pa_msgobject *obj, int code, void *data, in
if (PA_SINK_IS_OPENED(u->sink_input->sink->thread_info.state))
pa_memblockq_push_align(u->memblockq, chunk);
else
pa_memblockq_flush_write(u->memblockq, TRUE);
pa_memblockq_flush_write(u->memblockq, true);
update_min_memblockq_length(u);
@ -524,7 +524,7 @@ static int sink_input_process_msg_cb(pa_msgobject *obj, int code, void *data, in
pa_log_debug("Requesting rewind due to end of underrun.");
pa_sink_input_request_rewind(u->sink_input,
(size_t) (u->sink_input->thread_info.underrun_for == (size_t) -1 ? 0 : u->sink_input->thread_info.underrun_for),
FALSE, TRUE, FALSE);
false, true, false);
}
u->recv_counter += (int64_t) chunk->length;
@ -536,9 +536,9 @@ static int sink_input_process_msg_cb(pa_msgobject *obj, int code, void *data, in
pa_sink_input_assert_io_context(u->sink_input);
if (PA_SINK_IS_OPENED(u->sink_input->sink->thread_info.state))
pa_memblockq_seek(u->memblockq, -offset, PA_SEEK_RELATIVE, TRUE);
pa_memblockq_seek(u->memblockq, -offset, PA_SEEK_RELATIVE, true);
else
pa_memblockq_flush_write(u->memblockq, TRUE);
pa_memblockq_flush_write(u->memblockq, true);
u->recv_counter -= offset;
@ -649,7 +649,7 @@ static void sink_input_kill_cb(pa_sink_input *i) {
pa_assert_se(u = i->userdata);
teardown(u);
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
/* Called from the output thread context */
@ -701,7 +701,7 @@ static bool sink_input_may_move_to_cb(pa_sink_input *i, pa_sink *dest) {
}
/* Called from main thread */
static void sink_input_suspend_cb(pa_sink_input *i, pa_bool_t suspended) {
static void sink_input_suspend_cb(pa_sink_input *i, bool suspended) {
struct userdata *u;
pa_sink_input_assert_ref(i);
@ -718,10 +718,10 @@ int pa__init(pa_module *m) {
struct userdata *u;
pa_sink *sink = NULL;
pa_sink_input_new_data sink_input_data;
pa_bool_t sink_dont_move;
bool sink_dont_move;
pa_source *source = NULL;
pa_source_output_new_data source_output_data;
pa_bool_t source_dont_move;
bool source_dont_move;
uint32_t latency_msec;
pa_sample_spec ss;
pa_channel_map map;
@ -731,7 +731,7 @@ int pa__init(pa_module *m) {
pa_memchunk silence;
uint32_t adjust_time_sec;
const char *n;
pa_bool_t remix = TRUE;
bool remix = true;
pa_assert(m);
@ -823,7 +823,7 @@ int pa__init(pa_module *m) {
sink_input_data.module = m;
if (sink)
pa_sink_input_new_data_set_sink(&sink_input_data, sink, FALSE);
pa_sink_input_new_data_set_sink(&sink_input_data, sink, false);
if (pa_modargs_get_proplist(ma, "sink_input_properties", sink_input_data.proplist, PA_UPDATE_REPLACE) < 0) {
pa_log("Failed to parse the sink_input_properties value.");
@ -850,7 +850,7 @@ int pa__init(pa_module *m) {
if (!channels_set)
sink_input_data.flags |= PA_SINK_INPUT_FIX_CHANNELS;
sink_dont_move = FALSE;
sink_dont_move = false;
if (pa_modargs_get_value_boolean(ma, "sink_dont_move", &sink_dont_move) < 0) {
pa_log("sink_dont_move= expects a boolean argument.");
goto fail;
@ -890,7 +890,7 @@ int pa__init(pa_module *m) {
source_output_data.driver = __FILE__;
source_output_data.module = m;
if (source)
pa_source_output_new_data_set_source(&source_output_data, source, FALSE);
pa_source_output_new_data_set_source(&source_output_data, source, false);
if (pa_modargs_get_proplist(ma, "source_output_properties", source_output_data.proplist, PA_UPDATE_REPLACE) < 0) {
pa_log("Failed to parse the source_output_properties value.");
@ -908,7 +908,7 @@ int pa__init(pa_module *m) {
if (!remix)
source_output_data.flags |= PA_SOURCE_OUTPUT_NO_REMIX;
source_dont_move = FALSE;
source_dont_move = false;
if (pa_modargs_get_value_boolean(ma, "source_dont_move", &source_dont_move) < 0) {
pa_log("source_dont_move= expects a boolean argument.");
goto fail;
@ -972,10 +972,10 @@ int pa__init(pa_module *m) {
pa_source_output_put(u->source_output);
if (pa_source_get_state(u->source_output->source) != PA_SOURCE_SUSPENDED)
pa_sink_input_cork(u->sink_input, FALSE);
pa_sink_input_cork(u->sink_input, false);
if (pa_sink_get_state(u->sink_input->sink) != PA_SINK_SUSPENDED)
pa_source_output_cork(u->source_output, FALSE);
pa_source_output_cork(u->source_output, false);
update_adjust_timer(u);

2
src/modules/module-match.c
View file

@ -51,7 +51,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Playback stream expression matching module");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE("table=<filename> "
"key=<property_key>");

12
src/modules/module-mmkbd-evdev.c
View file

@ -47,7 +47,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Multimedia keyboard support via Linux evdev");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
PA_MODULE_USAGE("device=<evdev device> sink=<sink name> volume_limit=<volume limit> volume_step=<volume change step>");
#define DEFAULT_DEVICE "/dev/input/event0"
@ -118,21 +118,21 @@ static void io_callback(pa_mainloop_api *io, pa_io_event *e, int fd, pa_io_event
if (!(s = pa_namereg_get(u->module->core, u->sink_name, PA_NAMEREG_SINK)))
pa_log("Failed to get sink '%s'", u->sink_name);
else {
pa_cvolume cv = *pa_sink_get_volume(s, FALSE);
pa_cvolume cv = *pa_sink_get_volume(s, false);
switch (volchange) {
case UP:
pa_cvolume_inc_clamp(&cv, u->volume_step, u->volume_limit);
pa_sink_set_volume(s, &cv, TRUE, TRUE);
pa_sink_set_volume(s, &cv, true, true);
break;
case DOWN:
pa_cvolume_dec(&cv, u->volume_step);
pa_sink_set_volume(s, &cv, TRUE, TRUE);
pa_sink_set_volume(s, &cv, true, true);
break;
case MUTE_TOGGLE:
pa_sink_set_mute(s, !pa_sink_get_mute(s, FALSE), TRUE);
pa_sink_set_mute(s, !pa_sink_get_mute(s, false), true);
break;
case INVALID:
@ -149,7 +149,7 @@ fail:
u->module->core->mainloop->io_free(u->io);
u->io = NULL;
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
#define test_bit(bit, array) (array[bit/8] & (1<<(bit%8)))

4
src/modules/module-native-protocol-fd.c
View file

@ -38,7 +38,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Native protocol autospawn helper");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
static const char* const valid_modargs[] = {
"fd",
@ -70,7 +70,7 @@ int pa__init(pa_module*m) {
options = pa_native_options_new();
options->module = m;
options->auth_anonymous = TRUE;
options->auth_anonymous = true;
pa_native_protocol_connect(m->userdata, io, options);

4
src/modules/module-null-sink.c
View file

@ -48,7 +48,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION(_("Clocked NULL sink"));
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
PA_MODULE_USAGE(
"sink_name=<name of sink> "
"sink_properties=<properties for the sink> "
@ -226,7 +226,7 @@ static void thread_func(void *userdata) {
pa_rtpoll_set_timer_disabled(u->rtpoll);
/* 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)
goto fail;
if (ret == 0)

4
src/modules/module-null-source.c
View file

@ -48,7 +48,7 @@
PA_MODULE_AUTHOR("Lennart Poettering & Marc-Andre Lureau");
PA_MODULE_DESCRIPTION("Clocked NULL source");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
PA_MODULE_USAGE(
"format=<sample format> "
"channels=<number of channels> "
@ -159,7 +159,7 @@ static void thread_func(void *userdata) {
pa_rtpoll_set_timer_disabled(u->rtpoll);
/* 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)
goto fail;
if (ret == 0)

4
src/modules/module-pipe-sink.c
View file

@ -53,7 +53,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("UNIX pipe sink");
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> "
@ -196,7 +196,7 @@ static void thread_func(void *userdata) {
/* Hmm, nothing to do. Let's sleep */
pollfd->events = (short) (u->sink->thread_info.state == PA_SINK_RUNNING ? POLLOUT : 0);
if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
if ((ret = pa_rtpoll_run(u->rtpoll, true)) < 0)
goto fail;
if (ret == 0)

4
src/modules/module-pipe-source.c
View file

@ -53,7 +53,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("UNIX pipe source");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
PA_MODULE_USAGE(
"source_name=<name for the source> "
"source_properties=<properties for the source> "
@ -184,7 +184,7 @@ static void thread_func(void *userdata) {
/* Hmm, nothing to do. Let's sleep */
pollfd->events = (short) (u->source->thread_info.state == PA_SOURCE_RUNNING ? POLLIN : 0);
if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
if ((ret = pa_rtpoll_run(u->rtpoll, true)) < 0)
goto fail;
if (ret == 0)

2
src/modules/module-position-event-sounds.c
View file

@ -44,7 +44,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Position event sounds between L and R depending on the position on screen of the widget triggering them.");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
static const char* const valid_modargs[] = {
NULL

8
src/modules/module-protocol-stub.c
View file

@ -169,7 +169,7 @@
# error "Broken build system"
#endif
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_VERSION(PACKAGE_VERSION);
@ -239,7 +239,7 @@ int pa__init(pa_module*m) {
#if defined(USE_TCP_SOCKETS)
uint32_t port = IPV4_PORT;
pa_bool_t port_fallback = TRUE;
bool port_fallback = true;
const char *listen_on;
#else
int r;
@ -289,7 +289,7 @@ int pa__init(pa_module*m) {
#if defined(USE_TCP_SOCKETS)
if (pa_in_system_mode() || pa_modargs_get_value(ma, "port", NULL))
port_fallback = FALSE;
port_fallback = false;
if (pa_modargs_get_value_u32(ma, "port", &port) < 0 || port < 1 || port > 0xFFFF) {
pa_log("port= expects a numerical argument between 1 and 65535.");
@ -337,7 +337,7 @@ int pa__init(pa_module*m) {
/* This socket doesn't reside in our own runtime dir but in
* /tmp/.esd/, hence we have to create the dir first */
if (pa_make_secure_parent_dir(u->socket_path, pa_in_system_mode() ? 0755U : 0700U, (uid_t)-1, (gid_t)-1, FALSE) < 0) {
if (pa_make_secure_parent_dir(u->socket_path, pa_in_system_mode() ? 0755U : 0700U, (uid_t)-1, (gid_t)-1, false) < 0) {
pa_log("Failed to create socket directory '%s': %s\n", u->socket_path, pa_cstrerror(errno));
goto fail;
}

14
src/modules/module-remap-sink.c
View file

@ -38,7 +38,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Virtual channel remapping sink");
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> "
@ -56,7 +56,7 @@ struct userdata {
pa_sink *sink;
pa_sink_input *sink_input;
pa_bool_t auto_desc;
bool auto_desc;
};
static const char* const valid_modargs[] = {
@ -127,7 +127,7 @@ static void sink_request_rewind(pa_sink *s) {
!PA_SINK_INPUT_IS_LINKED(u->sink_input->thread_info.state))
return;
pa_sink_input_request_rewind(u->sink_input, s->thread_info.rewind_nbytes, TRUE, FALSE, FALSE);
pa_sink_input_request_rewind(u->sink_input, s->thread_info.rewind_nbytes, true, false, false);
}
/* Called from I/O thread context */
@ -270,7 +270,7 @@ static void sink_input_kill_cb(pa_sink_input *i) {
pa_sink_unref(u->sink);
u->sink = NULL;
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
/* Called from IO thread context */
@ -285,7 +285,7 @@ static void sink_input_state_change_cb(pa_sink_input *i, pa_sink_input_state_t s
if (PA_SINK_INPUT_IS_LINKED(state) &&
i->thread_info.state == PA_SINK_INPUT_INIT) {
pa_log_debug("Requesting rewind due to state change.");
pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
pa_sink_input_request_rewind(i, 0, false, true, true);
}
}
@ -323,7 +323,7 @@ int pa__init(pa_module*m) {
pa_sink *master;
pa_sink_input_new_data sink_input_data;
pa_sink_new_data sink_data;
pa_bool_t remix = TRUE;
bool remix = true;
pa_assert(m);
@ -411,7 +411,7 @@ int pa__init(pa_module*m) {
pa_sink_input_new_data_init(&sink_input_data);
sink_input_data.driver = __FILE__;
sink_input_data.module = m;
pa_sink_input_new_data_set_sink(&sink_input_data, master, FALSE);
pa_sink_input_new_data_set_sink(&sink_input_data, master, false);
sink_input_data.origin_sink = u->sink;
pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_NAME, "Remapped Stream");
pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_ROLE, "filter");

10
src/modules/module-rescue-streams.c
View file

@ -38,7 +38,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("When a sink/source is removed, try to move its streams to the default sink/source");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
static const char* const valid_modargs[] = {
NULL,
@ -104,7 +104,7 @@ static pa_hook_result_t sink_unlink_hook_callback(pa_core *c, pa_sink *sink, voi
if (!(target = find_evacuation_sink(c, i, sink)))
continue;
if (pa_sink_input_move_to(i, target, FALSE) < 0)
if (pa_sink_input_move_to(i, target, false) < 0)
pa_log_info("Failed to move sink input %u \"%s\" to %s.", i->index,
pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_APPLICATION_NAME)), target->name);
else
@ -128,7 +128,7 @@ static pa_hook_result_t sink_input_move_fail_hook_callback(pa_core *c, pa_sink_i
if (!(target = find_evacuation_sink(c, i, NULL)))
return PA_HOOK_OK;
if (pa_sink_input_finish_move(i, target, FALSE) < 0) {
if (pa_sink_input_finish_move(i, target, false) < 0) {
pa_log_info("Failed to move sink input %u \"%s\" to %s.", i->index,
pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_APPLICATION_NAME)), target->name);
return PA_HOOK_OK;
@ -195,7 +195,7 @@ static pa_hook_result_t source_unlink_hook_callback(pa_core *c, pa_source *sourc
if (!(target = find_evacuation_source(c, o, source)))
continue;
if (pa_source_output_move_to(o, target, FALSE) < 0)
if (pa_source_output_move_to(o, target, false) < 0)
pa_log_info("Failed to move source output %u \"%s\" to %s.", o->index,
pa_strnull(pa_proplist_gets(o->proplist, PA_PROP_APPLICATION_NAME)), target->name);
else
@ -219,7 +219,7 @@ static pa_hook_result_t source_output_move_fail_hook_callback(pa_core *c, pa_sou
if (!(target = find_evacuation_source(c, i, NULL)))
return PA_HOOK_OK;
if (pa_source_output_finish_move(i, target, FALSE) < 0) {
if (pa_source_output_finish_move(i, target, false) < 0) {
pa_log_info("Failed to move source input %u \"%s\" to %s.", i->index,
pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_APPLICATION_NAME)), target->name);
return PA_HOOK_OK;

36
src/modules/module-role-cork.c
View file

@ -38,7 +38,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Mute & cork streams with certain roles while others exist");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE(
"trigger_roles=<Comma separated list of roles which will trigger a cork> "
"cork_roles=<Comma separated list of roles which will be corked> "
@ -56,7 +56,7 @@ struct userdata {
pa_hashmap *cork_state;
pa_idxset *trigger_roles;
pa_idxset *cork_roles;
pa_bool_t global:1;
bool global:1;
pa_hook_slot
*sink_input_put_slot,
*sink_input_unlink_slot,
@ -64,7 +64,7 @@ struct userdata {
*sink_input_move_finish_slot;
};
static pa_bool_t shall_cork(struct userdata *u, pa_sink *s, pa_sink_input *ignore) {
static bool shall_cork(struct userdata *u, pa_sink *s, pa_sink_input *ignore) {
pa_sink_input *j;
uint32_t idx, role_idx;
const char *trigger_role;
@ -84,25 +84,25 @@ static pa_bool_t shall_cork(struct userdata *u, pa_sink *s, pa_sink_input *ignor
PA_IDXSET_FOREACH(trigger_role, u->trigger_roles, role_idx) {
if (pa_streq(role, trigger_role)) {
pa_log_debug("Found a '%s' stream that will trigger the auto-cork.", trigger_role);
return TRUE;
return true;
}
}
}
return FALSE;
return false;
}
static inline void apply_cork_to_sink(struct userdata *u, pa_sink *s, pa_sink_input *ignore, pa_bool_t cork) {
static inline void apply_cork_to_sink(struct userdata *u, pa_sink *s, pa_sink_input *ignore, bool cork) {
pa_sink_input *j;
uint32_t idx, role_idx;
const char *cork_role;
pa_bool_t trigger = FALSE;
bool trigger = false;
pa_assert(u);
pa_sink_assert_ref(s);
for (j = PA_SINK_INPUT(pa_idxset_first(s->inputs, &idx)); j; j = PA_SINK_INPUT(pa_idxset_next(s->inputs, &idx))) {
pa_bool_t corked, muted, corked_here;
bool corked, muted, corked_here;
const char *role;
if (j == ignore)
@ -126,7 +126,7 @@ static inline void apply_cork_to_sink(struct userdata *u, pa_sink *s, pa_sink_in
pa_log_debug("Found a '%s' stream that should be corked/muted.", cork_role);
if (!corked_here)
pa_hashmap_put(u->cork_state, j, PA_INT_TO_PTR(1));
pa_sink_input_set_mute(j, TRUE, FALSE);
pa_sink_input_set_mute(j, true, false);
pa_sink_input_send_event(j, PA_STREAM_EVENT_REQUEST_CORK, NULL);
} else if (!cork) {
pa_hashmap_remove(u->cork_state, j);
@ -134,7 +134,7 @@ static inline void apply_cork_to_sink(struct userdata *u, pa_sink *s, pa_sink_in
if (corked_here && (corked || muted)) {
pa_log_debug("Found a '%s' stream that should be uncorked/unmuted.", cork_role);
if (muted)
pa_sink_input_set_mute(j, FALSE, FALSE);
pa_sink_input_set_mute(j, false, false);
if (corked)
pa_sink_input_send_event(j, PA_STREAM_EVENT_REQUEST_UNCORK, NULL);
}
@ -142,7 +142,7 @@ static inline void apply_cork_to_sink(struct userdata *u, pa_sink *s, pa_sink_in
}
}
static void apply_cork(struct userdata *u, pa_sink *s, pa_sink_input *ignore, pa_bool_t cork) {
static void apply_cork(struct userdata *u, pa_sink *s, pa_sink_input *ignore, bool cork) {
pa_assert(u);
if (u->global) {
@ -153,8 +153,8 @@ static void apply_cork(struct userdata *u, pa_sink *s, pa_sink_input *ignore, pa
apply_cork_to_sink(u, s, ignore, cork);
}
static pa_hook_result_t process(struct userdata *u, pa_sink_input *i, pa_bool_t create) {
pa_bool_t cork = FALSE;
static pa_hook_result_t process(struct userdata *u, pa_sink_input *i, bool create) {
bool cork = false;
const char *role;
pa_assert(u);
@ -179,34 +179,34 @@ static pa_hook_result_t sink_input_put_cb(pa_core *core, pa_sink_input *i, struc
pa_core_assert_ref(core);
pa_sink_input_assert_ref(i);
return process(u, i, TRUE);
return process(u, i, true);
}
static pa_hook_result_t sink_input_unlink_cb(pa_core *core, pa_sink_input *i, struct userdata *u) {
pa_sink_input_assert_ref(i);
return process(u, i, FALSE);
return process(u, i, false);
}
static pa_hook_result_t sink_input_move_start_cb(pa_core *core, pa_sink_input *i, struct userdata *u) {
pa_core_assert_ref(core);
pa_sink_input_assert_ref(i);
return process(u, i, FALSE);
return process(u, i, false);
}
static pa_hook_result_t sink_input_move_finish_cb(pa_core *core, pa_sink_input *i, struct userdata *u) {
pa_core_assert_ref(core);
pa_sink_input_assert_ref(i);
return process(u, i, TRUE);
return process(u, i, true);
}
int pa__init(pa_module *m) {
pa_modargs *ma = NULL;
struct userdata *u;
const char *roles;
pa_bool_t global = FALSE;
bool global = false;
pa_assert(m);

36
src/modules/module-rygel-media-server.c
View file

@ -51,7 +51,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("UPnP MediaServer Plugin for Rygel");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE("display_name=<UPnP Media Server name>");
/* This implements http://live.gnome.org/Rygel/MediaServer2Spec */
@ -170,7 +170,7 @@ struct userdata {
pa_module *module;
pa_dbus_connection *bus;
pa_bool_t got_name:1;
bool got_name:1;
char *display_name;
@ -211,7 +211,7 @@ static pa_hook_result_t source_new_or_unlink_cb(pa_core *c, pa_source *s, struct
return PA_HOOK_OK;
}
static pa_bool_t message_is_property_get(DBusMessage *m, const char *interface, const char *property) {
static bool message_is_property_get(DBusMessage *m, const char *interface, const char *property) {
const char *i, *p;
DBusError error;
@ -220,17 +220,17 @@ static pa_bool_t message_is_property_get(DBusMessage *m, const char *interface,
pa_assert(m);
if (!dbus_message_is_method_call(m, "org.freedesktop.DBus.Properties", "Get"))
return FALSE;
return false;
if (!dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &i, DBUS_TYPE_STRING, &p, DBUS_TYPE_INVALID) || dbus_error_is_set(&error)) {
dbus_error_free(&error);
return FALSE;
return false;
}
return pa_streq(i, interface) && pa_streq(p, property);
}
static pa_bool_t message_is_property_get_all(DBusMessage *m, const char *interface) {
static bool message_is_property_get_all(DBusMessage *m, const char *interface) {
const char *i;
DBusError error;
@ -239,11 +239,11 @@ static pa_bool_t message_is_property_get_all(DBusMessage *m, const char *interfa
pa_assert(m);
if (!dbus_message_is_method_call(m, "org.freedesktop.DBus.Properties", "GetAll"))
return FALSE;
return false;
if (!dbus_message_get_args(m, &error, DBUS_TYPE_STRING, &i, DBUS_TYPE_INVALID) || dbus_error_is_set(&error)) {
dbus_error_free(&error);
return FALSE;
return false;
}
return pa_streq(i, interface);
@ -473,7 +473,7 @@ static void append_property_dict_entry_item_display_name(DBusMessage *m, DBusMes
pa_assert_se(dbus_message_iter_close_container(iter, &sub));
}
static pa_bool_t get_mediacontainer2_list_args(DBusMessage *m, unsigned *offset, unsigned *max_entries, char ***filter, int *filter_len) {
static bool get_mediacontainer2_list_args(DBusMessage *m, unsigned *offset, unsigned *max_entries, char ***filter, int *filter_len) {
DBusError error;
dbus_error_init(&error);
@ -485,10 +485,10 @@ static pa_bool_t get_mediacontainer2_list_args(DBusMessage *m, unsigned *offset,
if (!dbus_message_get_args(m, &error, DBUS_TYPE_UINT32, offset, DBUS_TYPE_UINT32, max_entries, DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, filter, filter_len, DBUS_TYPE_INVALID) || dbus_error_is_set(&error)) {
dbus_error_free(&error);
return FALSE;
return false;
}
return TRUE;
return true;
}
static unsigned get_sinks_or_sources_count(const char *path, const struct userdata *u) {
@ -528,7 +528,7 @@ static void append_sink_or_source_container_properties(
if (filter_len == 1 && (*filter)[0] == '*' && (*filter)[1] == '\0') {
append_sink_or_source_container_mediaobject2_properties(r, &sub, path);
append_property_dict_entry_unsigned(r, &sub, "ChildCount", get_sinks_or_sources_count(path, user_data));
append_property_dict_entry_boolean(r, &sub, "Searchable", FALSE);
append_property_dict_entry_boolean(r, &sub, "Searchable", false);
}
else {
for (int i = 0; i < filter_len; ++i) {
@ -552,7 +552,7 @@ static void append_sink_or_source_container_properties(
append_property_dict_entry_unsigned(r, &sub, "ChildCount", get_sinks_or_sources_count(path, user_data));
}
else if (pa_streq(property_name, "Searchable")) {
append_property_dict_entry_boolean(r, &sub, "Searchable", FALSE);
append_property_dict_entry_boolean(r, &sub, "Searchable", false);
}
}
}
@ -642,7 +642,7 @@ static DBusHandlerResult root_handler(DBusConnection *c, DBusMessage *m, void *u
} else if (message_is_property_get(m, "org.gnome.UPnP.MediaContainer2", "Searchable")) {
pa_assert_se(r = dbus_message_new_method_return(m));
append_variant_boolean(r, NULL, FALSE);
append_variant_boolean(r, NULL, false);
} else if (message_is_property_get_all(m, "org.gnome.UPnP.MediaContainer2")) {
DBusMessageIter iter, sub;
@ -654,7 +654,7 @@ static DBusHandlerResult root_handler(DBusConnection *c, DBusMessage *m, void *u
append_property_dict_entry_unsigned(r, &sub, "ChildCount", PA_ELEMENTSOF(array_root_containers));
append_property_dict_entry_unsigned(r, &sub, "ItemCount", PA_ELEMENTSOF(array_no_children));
append_property_dict_entry_unsigned(r, &sub, "ContainerCount", PA_ELEMENTSOF(array_root_containers));
append_property_dict_entry_boolean(r, &sub, "Searchable", FALSE);
append_property_dict_entry_boolean(r, &sub, "Searchable", false);
pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
} else if (dbus_message_is_method_call(m, "org.gnome.UPnP.MediaContainer2", "ListChildren")
@ -803,7 +803,7 @@ static DBusHandlerResult sinks_and_sources_handler(DBusConnection *c, DBusMessag
} else if (message_is_property_get(m, "org.gnome.UPnP.MediaContainer2", "Searchable")) {
pa_assert_se(r = dbus_message_new_method_return(m));
append_variant_boolean(r, NULL, FALSE);
append_variant_boolean(r, NULL, false);
} else if (message_is_property_get_all(m, "org.gnome.UPnP.MediaContainer2")) {
DBusMessageIter iter, sub;
@ -819,7 +819,7 @@ static DBusHandlerResult sinks_and_sources_handler(DBusConnection *c, DBusMessag
append_property_dict_entry_unsigned(r, &sub, "ChildCount", item_count);
append_property_dict_entry_unsigned(r, &sub, "ItemCount", item_count);
append_property_dict_entry_unsigned(r, &sub, "ContainerCount", 0);
append_property_dict_entry_boolean(r, &sub, "Searchable", FALSE);
append_property_dict_entry_boolean(r, &sub, "Searchable", false);
pa_assert_se(dbus_message_iter_close_container(&iter, &sub));
@ -1081,7 +1081,7 @@ int pa__init(pa_module *m) {
goto fail;
}
u->got_name = TRUE;
u->got_name = true;
pa_modargs_free(ma);

4
src/modules/module-sine-source.c
View file

@ -46,7 +46,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Sine wave generator source");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
PA_MODULE_USAGE(
"source_name=<name for the source> "
"source_properties=<properties for the source> "
@ -178,7 +178,7 @@ static void thread_func(void *userdata) {
pa_rtpoll_set_timer_disabled(u->rtpoll);
/* 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)
goto fail;
if (ret == 0)

8
src/modules/module-sine.c
View file

@ -38,7 +38,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Sine wave generator");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
PA_MODULE_USAGE(
"sink=<sink to connect to> "
"frequency=<frequency in Hz>");
@ -99,7 +99,7 @@ static void sink_input_kill_cb(pa_sink_input *i) {
pa_sink_input_unref(u->sink_input);
u->sink_input = NULL;
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
/* Called from IO thread context */
@ -113,7 +113,7 @@ static void sink_input_state_change_cb(pa_sink_input *i, pa_sink_input_state_t s
* we are heard right-away. */
if (PA_SINK_INPUT_IS_LINKED(state) &&
i->thread_info.state == PA_SINK_INPUT_INIT)
pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
pa_sink_input_request_rewind(i, 0, false, true, true);
}
int pa__init(pa_module*m) {
@ -155,7 +155,7 @@ int pa__init(pa_module*m) {
pa_sink_input_new_data_init(&data);
data.driver = __FILE__;
data.module = m;
pa_sink_input_new_data_set_sink(&data, sink, FALSE);
pa_sink_input_new_data_set_sink(&data, sink, false);
pa_proplist_setf(data.proplist, PA_PROP_MEDIA_NAME, "%u Hz Sine", frequency);
pa_proplist_sets(data.proplist, PA_PROP_MEDIA_ROLE, "abstract");
pa_proplist_setf(data.proplist, "sine.hz", "%u", frequency);

42
src/modules/module-solaris.c
View file

@ -75,7 +75,7 @@ PA_MODULE_USAGE(
"rate=<sample rate> "
"buffer_length=<milliseconds> "
"channel_map=<channel map>");
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
struct userdata {
pa_core *core;
@ -100,7 +100,7 @@ struct userdata {
pa_rtpoll_item *rtpoll_item;
pa_module *module;
pa_bool_t sink_suspended, source_suspended;
bool sink_suspended, source_suspended;
uint32_t play_samples_msw, record_samples_msw;
uint32_t prev_playback_samples, prev_record_samples;
@ -404,14 +404,14 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
if (suspend(u) < 0)
return -1;
}
u->sink_suspended = TRUE;
u->sink_suspended = true;
break;
case PA_SINK_IDLE:
case PA_SINK_RUNNING:
if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
pa_smoother_resume(u->smoother, pa_rtclock_now(), TRUE);
pa_smoother_resume(u->smoother, pa_rtclock_now(), true);
if (!u->source || u->source_suspended) {
if (unsuspend(u) < 0)
@ -419,7 +419,7 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
u->sink->get_volume(u->sink);
u->sink->get_mute(u->sink);
}
u->sink_suspended = FALSE;
u->sink_suspended = false;
}
break;
@ -456,7 +456,7 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
if (suspend(u) < 0)
return -1;
}
u->source_suspended = TRUE;
u->source_suspended = true;
break;
case PA_SOURCE_IDLE:
@ -468,7 +468,7 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
return -1;
u->source->get_volume(u->source);
}
u->source_suspended = FALSE;
u->source_suspended = false;
}
break;
@ -652,7 +652,7 @@ static void thread_func(void *userdata) {
if (ioctl(u->fd, AUDIO_SETINFO, &info) < 0)
pa_log("AUDIO_SETINFO: %s", pa_cstrerror(errno));
pa_smoother_reset(u->smoother, pa_rtclock_now(), TRUE);
pa_smoother_reset(u->smoother, pa_rtclock_now(), true);
}
for (;;) {
@ -778,7 +778,7 @@ static void thread_func(void *userdata) {
}
/* 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)
goto fail;
if (ret == 0)
@ -817,17 +817,17 @@ static void sig_callback(pa_mainloop_api *api, pa_signal_event*e, int sig, void
pa_log_debug("caught signal");
if (u->sink) {
pa_sink_get_volume(u->sink, TRUE);
pa_sink_get_mute(u->sink, TRUE);
pa_sink_get_volume(u->sink, true);
pa_sink_get_mute(u->sink, true);
}
if (u->source)
pa_source_get_volume(u->source, TRUE);
pa_source_get_volume(u->source, true);
}
int pa__init(pa_module *m) {
struct userdata *u = NULL;
pa_bool_t record = TRUE, playback = TRUE;
bool record = true, playback = true;
pa_sample_spec ss;
pa_channel_map map;
pa_modargs *ma = NULL;
@ -837,7 +837,7 @@ int pa__init(pa_module *m) {
pa_source_new_data source_new_data;
char const *name;
char *name_buf;
pa_bool_t namereg_fail;
bool namereg_fail;
pa_assert(m);
@ -858,7 +858,7 @@ int pa__init(pa_module *m) {
u = pa_xnew0(struct userdata, 1);
if (!(u->smoother = pa_smoother_new(PA_USEC_PER_SEC, PA_USEC_PER_SEC * 2, TRUE, TRUE, 10, pa_rtclock_now(), TRUE)))
if (!(u->smoother = pa_smoother_new(PA_USEC_PER_SEC, PA_USEC_PER_SEC * 2, true, true, 10, pa_rtclock_now(), true)))
goto fail;
/*
@ -913,11 +913,11 @@ int pa__init(pa_module *m) {
if (u->mode != O_WRONLY) {
name_buf = NULL;
namereg_fail = TRUE;
namereg_fail = true;
if (!(name = pa_modargs_get_value(ma, "source_name", NULL))) {
name = name_buf = pa_sprintf_malloc("solaris_input.%s", pa_path_get_filename(u->device_name));
namereg_fail = FALSE;
namereg_fail = false;
}
pa_source_new_data_init(&source_new_data);
@ -957,16 +957,16 @@ int pa__init(pa_module *m) {
pa_source_set_get_volume_callback(u->source, source_get_volume);
pa_source_set_set_volume_callback(u->source, source_set_volume);
u->source->refresh_volume = TRUE;
u->source->refresh_volume = true;
} else
u->source = NULL;
if (u->mode != O_RDONLY) {
name_buf = NULL;
namereg_fail = TRUE;
namereg_fail = true;
if (!(name = pa_modargs_get_value(ma, "sink_name", NULL))) {
name = name_buf = pa_sprintf_malloc("solaris_output.%s", pa_path_get_filename(u->device_name));
namereg_fail = FALSE;
namereg_fail = false;
}
pa_sink_new_data_init(&sink_new_data);
@ -1004,7 +1004,7 @@ int pa__init(pa_module *m) {
pa_sink_set_set_volume_callback(u->sink, sink_set_volume);
pa_sink_set_get_mute_callback(u->sink, sink_get_mute);
pa_sink_set_set_mute_callback(u->sink, sink_set_mute);
u->sink->refresh_volume = u->sink->refresh_muted = TRUE;
u->sink->refresh_volume = u->sink->refresh_muted = true;
} else
u->sink = NULL;

176
src/modules/module-stream-restore.c
View file

@ -63,7 +63,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Automatically restore the volume/mute/device state of streams");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE(
"restore_device=<Save/restore sinks/sources?> "
"restore_volume=<Save/restore volumes?> "
@ -107,11 +107,11 @@ struct userdata {
pa_time_event *save_time_event;
pa_database* database;
pa_bool_t restore_device:1;
pa_bool_t restore_volume:1;
pa_bool_t restore_muted:1;
pa_bool_t on_hotplug:1;
pa_bool_t on_rescue:1;
bool restore_device:1;
bool restore_volume:1;
bool restore_muted:1;
bool on_hotplug:1;
bool on_rescue:1;
pa_native_protocol *protocol;
pa_idxset *subscribed;
@ -127,8 +127,8 @@ struct userdata {
struct entry {
uint8_t version;
pa_bool_t muted_valid, volume_valid, device_valid, card_valid;
pa_bool_t muted;
bool muted_valid, volume_valid, device_valid, card_valid;
bool muted;
pa_channel_map channel_map;
pa_cvolume volume;
char* device;
@ -147,7 +147,7 @@ enum {
static struct entry* entry_new(void);
static void entry_free(struct entry *e);
static struct entry *entry_read(struct userdata *u, const char *name);
static pa_bool_t entry_write(struct userdata *u, const char *name, const struct entry *e, pa_bool_t replace);
static bool entry_write(struct userdata *u, const char *name, const struct entry *e, bool replace);
static struct entry* entry_copy(const struct entry *e);
static void entry_apply(struct userdata *u, const char *name, struct entry *e);
static void trigger_save(struct userdata *u);
@ -603,8 +603,8 @@ static void handle_add_entry(DBusConnection *conn, DBusMessage *msg, void *userd
const char *device = NULL;
pa_channel_map map;
pa_cvolume vol;
dbus_bool_t muted = FALSE;
dbus_bool_t apply_immediately = FALSE;
dbus_bool_t muted = false;
dbus_bool_t apply_immediately = false;
struct dbus_entry *dbus_entry = NULL;
struct entry *e = NULL;
@ -633,14 +633,14 @@ static void handle_add_entry(DBusConnection *conn, DBusMessage *msg, void *userd
}
if ((dbus_entry = pa_hashmap_get(u->dbus_entries, name))) {
pa_bool_t mute_updated = FALSE;
pa_bool_t volume_updated = FALSE;
pa_bool_t device_updated = FALSE;
bool mute_updated = false;
bool volume_updated = false;
bool device_updated = false;
pa_assert_se(e = entry_read(u, name));
mute_updated = e->muted != muted;
e->muted = muted;
e->muted_valid = TRUE;
e->muted_valid = true;
volume_updated = (e->volume_valid != !!map.channels) || !pa_cvolume_equal(&e->volume, &vol);
e->volume = vol;
@ -664,7 +664,7 @@ static void handle_add_entry(DBusConnection *conn, DBusMessage *msg, void *userd
pa_assert_se(pa_hashmap_put(u->dbus_entries, dbus_entry->entry_name, dbus_entry) == 0);
e = entry_new();
e->muted_valid = TRUE;
e->muted_valid = true;
e->volume_valid = !!map.channels;
e->device_valid = !!device[0];
e->muted = muted;
@ -675,7 +675,7 @@ static void handle_add_entry(DBusConnection *conn, DBusMessage *msg, void *userd
send_new_entry_signal(dbus_entry);
}
pa_assert_se(entry_write(u, name, e, TRUE));
pa_assert_se(entry_write(u, name, e, true));
if (apply_immediately)
entry_apply(u, name, e);
@ -748,7 +748,7 @@ static void handle_entry_set_device(DBusConnection *conn, DBusMessage *msg, DBus
struct dbus_entry *de = userdata;
const char *device;
struct entry *e;
pa_bool_t updated;
bool updated;
pa_assert(conn);
pa_assert(msg);
@ -766,7 +766,7 @@ static void handle_entry_set_device(DBusConnection *conn, DBusMessage *msg, DBus
e->device = pa_xstrdup(device);
e->device_valid = !!device[0];
pa_assert_se(entry_write(de->userdata, de->entry_name, e, TRUE));
pa_assert_se(entry_write(de->userdata, de->entry_name, e, true));
entry_apply(de->userdata, de->entry_name, e);
send_device_updated_signal(de, e);
@ -805,7 +805,7 @@ static void handle_entry_set_volume(DBusConnection *conn, DBusMessage *msg, DBus
pa_channel_map map;
pa_cvolume vol;
struct entry *e = NULL;
pa_bool_t updated = FALSE;
bool updated = false;
pa_assert(conn);
pa_assert(msg);
@ -824,7 +824,7 @@ static void handle_entry_set_volume(DBusConnection *conn, DBusMessage *msg, DBus
e->channel_map = map;
e->volume_valid = !!map.channels;
pa_assert_se(entry_write(de->userdata, de->entry_name, e, TRUE));
pa_assert_se(entry_write(de->userdata, de->entry_name, e, true));
entry_apply(de->userdata, de->entry_name, e);
send_volume_updated_signal(de, e);
@ -847,7 +847,7 @@ static void handle_entry_get_mute(DBusConnection *conn, DBusMessage *msg, void *
pa_assert_se(e = entry_read(de->userdata, de->entry_name));
mute = e->muted_valid ? e->muted : FALSE;
mute = e->muted_valid ? e->muted : false;
pa_dbus_send_basic_variant_reply(conn, msg, DBUS_TYPE_BOOLEAN, &mute);
@ -858,7 +858,7 @@ static void handle_entry_set_mute(DBusConnection *conn, DBusMessage *msg, DBusMe
struct dbus_entry *de = userdata;
dbus_bool_t mute;
struct entry *e;
pa_bool_t updated;
bool updated;
pa_assert(conn);
pa_assert(msg);
@ -873,9 +873,9 @@ static void handle_entry_set_mute(DBusConnection *conn, DBusMessage *msg, DBusMe
if (updated) {
e->muted = mute;
e->muted_valid = TRUE;
e->muted_valid = true;
pa_assert_se(entry_write(de->userdata, de->entry_name, e, TRUE));
pa_assert_se(entry_write(de->userdata, de->entry_name, e, true));
entry_apply(de->userdata, de->entry_name, e);
send_mute_updated_signal(de, e);
@ -904,7 +904,7 @@ static void handle_entry_get_all(DBusConnection *conn, DBusMessage *msg, void *u
pa_assert_se(e = entry_read(de->userdata, de->entry_name));
device = e->device_valid ? e->device : "";
mute = e->muted_valid ? e->muted : FALSE;
mute = e->muted_valid ? e->muted : false;
pa_assert_se((reply = dbus_message_new_method_return(msg)));
@ -986,10 +986,10 @@ static void entry_free(struct entry* e) {
pa_xfree(e);
}
static pa_bool_t entry_write(struct userdata *u, const char *name, const struct entry *e, pa_bool_t replace) {
static bool entry_write(struct userdata *u, const char *name, const struct entry *e, bool replace) {
pa_tagstruct *t;
pa_datum key, data;
pa_bool_t r;
bool r;
pa_assert(u);
pa_assert(name);
@ -1025,8 +1025,8 @@ static pa_bool_t entry_write(struct userdata *u, const char *name, const struct
static struct entry *legacy_entry_read(struct userdata *u, const char *name) {
struct legacy_entry {
uint8_t version;
pa_bool_t muted_valid:1, volume_valid:1, device_valid:1, card_valid:1;
pa_bool_t muted:1;
bool muted_valid:1, volume_valid:1, device_valid:1, card_valid:1;
bool muted:1;
pa_channel_map channel_map;
pa_cvolume volume;
char device[PA_NAME_MAX];
@ -1220,7 +1220,7 @@ static void trigger_save(struct userdata *u) {
u->save_time_event = pa_core_rttime_new(u->core, pa_rtclock_now() + SAVE_INTERVAL, save_time_callback, u);
}
static pa_bool_t entries_equal(const struct entry *a, const struct entry *b) {
static bool entries_equal(const struct entry *a, const struct entry *b) {
pa_cvolume t;
pa_assert(a);
@ -1228,22 +1228,22 @@ static pa_bool_t entries_equal(const struct entry *a, const struct entry *b) {
if (a->device_valid != b->device_valid ||
(a->device_valid && !pa_streq(a->device, b->device)))
return FALSE;
return false;
if (a->card_valid != b->card_valid ||
(a->card_valid && !pa_streq(a->card, b->card)))
return FALSE;
return false;
if (a->muted_valid != b->muted_valid ||
(a->muted_valid && (a->muted != b->muted)))
return FALSE;
return false;
t = b->volume;
if (a->volume_valid != b->volume_valid ||
(a->volume_valid && !pa_cvolume_equal(pa_cvolume_remap(&t, &b->channel_map, &a->channel_map), &a->volume)))
return FALSE;
return false;
return TRUE;
return true;
}
static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint32_t idx, void *userdata) {
@ -1253,10 +1253,10 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3
/* These are only used when D-Bus is enabled, but in order to reduce ifdef
* clutter these are defined here unconditionally. */
pa_bool_t created_new_entry = TRUE;
pa_bool_t device_updated = FALSE;
pa_bool_t volume_updated = FALSE;
pa_bool_t mute_updated = FALSE;
bool created_new_entry = true;
bool device_updated = false;
bool volume_updated = false;
bool mute_updated = false;
#ifdef HAVE_DBUS
struct dbus_entry *de = NULL;
@ -1282,7 +1282,7 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3
if ((old = entry_read(u, name))) {
entry = entry_copy(old);
created_new_entry = FALSE;
created_new_entry = false;
} else
entry = entry_new();
@ -1290,8 +1290,8 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3
pa_assert(sink_input->volume_writable);
entry->channel_map = sink_input->channel_map;
pa_sink_input_get_volume(sink_input, &entry->volume, FALSE);
entry->volume_valid = TRUE;
pa_sink_input_get_volume(sink_input, &entry->volume, false);
entry->volume_valid = true;
volume_updated = !created_new_entry
&& (!old->volume_valid
@ -1301,7 +1301,7 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3
if (sink_input->save_muted) {
entry->muted = pa_sink_input_get_mute(sink_input);
entry->muted_valid = TRUE;
entry->muted_valid = true;
mute_updated = !created_new_entry && (!old->muted_valid || entry->muted != old->muted);
}
@ -1309,13 +1309,13 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3
if (sink_input->save_sink) {
pa_xfree(entry->device);
entry->device = pa_xstrdup(sink_input->sink->name);
entry->device_valid = TRUE;
entry->device_valid = true;
device_updated = !created_new_entry && (!old->device_valid || !pa_streq(entry->device, old->device));
if (sink_input->sink->card) {
pa_xfree(entry->card);
entry->card = pa_xstrdup(sink_input->sink->card->name);
entry->card_valid = TRUE;
entry->card_valid = true;
}
}
@ -1332,7 +1332,7 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3
if ((old = entry_read(u, name))) {
entry = entry_copy(old);
created_new_entry = FALSE;
created_new_entry = false;
} else
entry = entry_new();
@ -1340,8 +1340,8 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3
pa_assert(source_output->volume_writable);
entry->channel_map = source_output->channel_map;
pa_source_output_get_volume(source_output, &entry->volume, FALSE);
entry->volume_valid = TRUE;
pa_source_output_get_volume(source_output, &entry->volume, false);
entry->volume_valid = true;
volume_updated = !created_new_entry
&& (!old->volume_valid
@ -1351,7 +1351,7 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3
if (source_output->save_muted) {
entry->muted = pa_source_output_get_mute(source_output);
entry->muted_valid = TRUE;
entry->muted_valid = true;
mute_updated = !created_new_entry && (!old->muted_valid || entry->muted != old->muted);
}
@ -1359,14 +1359,14 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3
if (source_output->save_source) {
pa_xfree(entry->device);
entry->device = pa_xstrdup(source_output->source->name);
entry->device_valid = TRUE;
entry->device_valid = true;
device_updated = !created_new_entry && (!old->device_valid || !pa_streq(entry->device, old->device));
if (source_output->source->card) {
pa_xfree(entry->card);
entry->card = pa_xstrdup(source_output->source->card->name);
entry->card_valid = TRUE;
entry->card_valid = true;
}
}
}
@ -1387,7 +1387,7 @@ static void subscribe_callback(pa_core *c, pa_subscription_event_type_t t, uint3
pa_log_info("Storing volume/mute/device for stream %s.", name);
if (entry_write(u, name, entry, TRUE))
if (entry_write(u, name, entry, true))
trigger_save(u);
#ifdef HAVE_DBUS
@ -1442,7 +1442,7 @@ static pa_hook_result_t sink_input_new_hook_callback(pa_core *c, pa_sink_input_n
same time, in which case we want to make sure we don't
interfere with that */
if (s && PA_SINK_IS_LINKED(pa_sink_get_state(s)))
if (pa_sink_input_new_data_set_sink(new_data, s, TRUE))
if (pa_sink_input_new_data_set_sink(new_data, s, true))
pa_log_info("Restoring device for stream %s.", name);
entry_free(e);
@ -1481,8 +1481,8 @@ static pa_hook_result_t sink_input_fixate_hook_callback(pa_core *c, pa_sink_inpu
pa_cvolume_remap(&v, &e->channel_map, &new_data->channel_map);
pa_sink_input_new_data_set_volume(new_data, &v);
new_data->volume_is_absolute = FALSE;
new_data->save_volume = TRUE;
new_data->volume_is_absolute = false;
new_data->save_volume = true;
}
}
@ -1491,7 +1491,7 @@ static pa_hook_result_t sink_input_fixate_hook_callback(pa_core *c, pa_sink_inpu
if (!new_data->muted_is_set) {
pa_log_info("Restoring mute state for sink input %s.", name);
pa_sink_input_new_data_set_muted(new_data, e->muted);
new_data->save_muted = TRUE;
new_data->save_muted = true;
} else
pa_log_debug("Not restoring mute state for sink input %s, because already set.", name);
}
@ -1539,7 +1539,7 @@ static pa_hook_result_t source_output_new_hook_callback(pa_core *c, pa_source_ou
interfere with that */
if (s && PA_SOURCE_IS_LINKED(pa_source_get_state(s))) {
pa_log_info("Restoring device for stream %s.", name);
pa_source_output_new_data_set_source(new_data, s, TRUE);
pa_source_output_new_data_set_source(new_data, s, true);
}
entry_free(e);
@ -1578,8 +1578,8 @@ static pa_hook_result_t source_output_fixate_hook_callback(pa_core *c, pa_source
pa_cvolume_remap(&v, &e->channel_map, &new_data->channel_map);
pa_source_output_new_data_set_volume(new_data, &v);
new_data->volume_is_absolute = FALSE;
new_data->save_volume = TRUE;
new_data->volume_is_absolute = false;
new_data->save_volume = true;
}
}
@ -1588,7 +1588,7 @@ static pa_hook_result_t source_output_fixate_hook_callback(pa_core *c, pa_source
if (!new_data->muted_is_set) {
pa_log_info("Restoring mute state for source output %s.", name);
pa_source_output_new_data_set_muted(new_data, e->muted);
new_data->save_muted = TRUE;
new_data->save_muted = true;
} else
pa_log_debug("Not restoring mute state for source output %s, because already set.", name);
}
@ -1636,7 +1636,7 @@ static pa_hook_result_t sink_put_hook_callback(pa_core *c, pa_sink *sink, struct
if ((e = entry_read(u, name))) {
if (e->device_valid && pa_streq(e->device, sink->name))
pa_sink_input_move_to(si, sink, TRUE);
pa_sink_input_move_to(si, sink, true);
entry_free(e);
}
@ -1684,7 +1684,7 @@ static pa_hook_result_t source_put_hook_callback(pa_core *c, pa_source *source,
if ((e = entry_read(u, name))) {
if (e->device_valid && pa_streq(e->device, source->name))
pa_source_output_move_to(so, source, TRUE);
pa_source_output_move_to(so, source, true);
entry_free(e);
}
@ -1726,7 +1726,7 @@ static pa_hook_result_t sink_unlink_hook_callback(pa_core *c, pa_sink *sink, str
if ((d = pa_namereg_get(c, e->device, PA_NAMEREG_SINK)) &&
d != sink &&
PA_SINK_IS_LINKED(pa_sink_get_state(d)))
pa_sink_input_move_to(si, d, TRUE);
pa_sink_input_move_to(si, d, true);
}
entry_free(e);
@ -1772,7 +1772,7 @@ static pa_hook_result_t source_unlink_hook_callback(pa_core *c, pa_source *sourc
if ((d = pa_namereg_get(c, e->device, PA_NAMEREG_SOURCE)) &&
d != source &&
PA_SOURCE_IS_LINKED(pa_source_get_state(d)))
pa_source_output_move_to(so, d, TRUE);
pa_source_output_move_to(so, d, true);
}
entry_free(e);
@ -1837,7 +1837,7 @@ static int fill_db(struct userdata *u, const char *filename) {
pa_zero(e);
e.version = ENTRY_VERSION;
e.volume_valid = TRUE;
e.volume_valid = true;
pa_cvolume_set(&e.volume, 1, pa_sw_volume_from_dB(db));
pa_channel_map_init_mono(&e.channel_map);
@ -1847,7 +1847,7 @@ static int fill_db(struct userdata *u, const char *filename) {
data.data = (void *) &e;
data.size = sizeof(e);
if (pa_database_set(u->database, &key, &data, FALSE) == 0)
if (pa_database_set(u->database, &key, &data, false) == 0)
pa_log_debug("Setting %s to %0.2f dB.", ln, db);
} else
pa_log_warn("[%s:%u] Positive dB values are not allowed, not setting entry %s.", fn, n, ln);
@ -1895,12 +1895,12 @@ static void entry_apply(struct userdata *u, const char *name, struct entry *e) {
v = e->volume;
pa_log_info("Restoring volume for sink input %s.", name);
pa_cvolume_remap(&v, &e->channel_map, &si->channel_map);
pa_sink_input_set_volume(si, &v, TRUE, FALSE);
pa_sink_input_set_volume(si, &v, true, false);
}
if (u->restore_muted && e->muted_valid) {
pa_log_info("Restoring mute state for sink input %s.", name);
pa_sink_input_set_mute(si, e->muted, TRUE);
pa_sink_input_set_mute(si, e->muted, true);
}
if (u->restore_device) {
@ -1910,7 +1910,7 @@ static void entry_apply(struct userdata *u, const char *name, struct entry *e) {
/* If the device is not valid we should make sure the
save flag is cleared as the user may have specifically
removed the sink element from the rule. */
si->save_sink = FALSE;
si->save_sink = false;
/* This is cheating a bit. The sink input itself has not changed
but the rules governing it's routing have, so we fire this event
such that other routing modules (e.g. module-device-manager)
@ -1919,7 +1919,7 @@ static void entry_apply(struct userdata *u, const char *name, struct entry *e) {
}
} else if ((s = pa_namereg_get(u->core, e->device, PA_NAMEREG_SINK))) {
pa_log_info("Restoring device for stream %s.", name);
pa_sink_input_move_to(si, s, TRUE);
pa_sink_input_move_to(si, s, true);
}
}
}
@ -1943,12 +1943,12 @@ static void entry_apply(struct userdata *u, const char *name, struct entry *e) {
v = e->volume;
pa_log_info("Restoring volume for source output %s.", name);
pa_cvolume_remap(&v, &e->channel_map, &so->channel_map);
pa_source_output_set_volume(so, &v, TRUE, FALSE);
pa_source_output_set_volume(so, &v, true, false);
}
if (u->restore_muted && e->muted_valid) {
pa_log_info("Restoring mute state for source output %s.", name);
pa_source_output_set_mute(so, e->muted, TRUE);
pa_source_output_set_mute(so, e->muted, true);
}
if (u->restore_device) {
@ -1958,7 +1958,7 @@ static void entry_apply(struct userdata *u, const char *name, struct entry *e) {
/* If the device is not valid we should make sure the
save flag is cleared as the user may have specifically
removed the source element from the rule. */
so->save_source = FALSE;
so->save_source = false;
/* This is cheating a bit. The source output itself has not changed
but the rules governing it's routing have, so we fire this event
such that other routing modules (e.g. module-device-manager)
@ -1967,7 +1967,7 @@ static void entry_apply(struct userdata *u, const char *name, struct entry *e) {
}
} else if ((s = pa_namereg_get(u->core, e->device, PA_NAMEREG_SOURCE))) {
pa_log_info("Restoring device for stream %s.", name);
pa_source_output_move_to(so, s, TRUE);
pa_source_output_move_to(so, s, true);
}
}
}
@ -1976,7 +1976,7 @@ static void entry_apply(struct userdata *u, const char *name, struct entry *e) {
#ifdef DEBUG_VOLUME
PA_GCC_UNUSED static void stream_restore_dump_database(struct userdata *u) {
pa_datum key;
pa_bool_t done;
bool done;
done = !pa_database_first(u->database, &key, NULL);
@ -2039,7 +2039,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
case SUBCOMMAND_READ: {
pa_datum key;
pa_bool_t done;
bool done;
if (!pa_tagstruct_eof(t))
goto fail;
@ -2064,7 +2064,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
pa_tagstruct_put_channel_map(reply, e->volume_valid ? &e->channel_map : pa_channel_map_init(&cm));
pa_tagstruct_put_cvolume(reply, e->volume_valid ? &e->volume : pa_cvolume_init(&r));
pa_tagstruct_puts(reply, e->device_valid ? e->device : NULL);
pa_tagstruct_put_boolean(reply, e->muted_valid ? e->muted : FALSE);
pa_tagstruct_put_boolean(reply, e->muted_valid ? e->muted : false);
entry_free(e);
}
@ -2079,7 +2079,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
case SUBCOMMAND_WRITE: {
uint32_t mode;
pa_bool_t apply_immediately = FALSE;
bool apply_immediately = false;
if (pa_tagstruct_getu32(t, &mode) < 0 ||
pa_tagstruct_get_boolean(t, &apply_immediately) < 0)
@ -2105,7 +2105,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
while (!pa_tagstruct_eof(t)) {
const char *name, *device;
pa_bool_t muted;
bool muted;
struct entry *entry;
#ifdef HAVE_DBUS
struct entry *old;
@ -2134,7 +2134,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
}
entry->muted = muted;
entry->muted_valid = TRUE;
entry->muted_valid = true;
entry->device = pa_xstrdup(device);
entry->device_valid = device && !!entry->device[0];
@ -2225,7 +2225,7 @@ static int extension_cb(pa_native_protocol *p, pa_module *m, pa_native_connectio
case SUBCOMMAND_SUBSCRIBE: {
pa_bool_t enabled;
bool enabled;
if (pa_tagstruct_get_boolean(t, &enabled) < 0 ||
!pa_tagstruct_eof(t))
@ -2274,7 +2274,7 @@ static void clean_up_db(struct userdata *u) {
#ifdef ENABLE_LEGACY_DATABASE_ENTRY_FORMAT
PA_LLIST_HEAD(struct clean_up_item, to_be_converted);
#endif
pa_bool_t done = FALSE;
bool done = false;
pa_datum key;
struct clean_up_item *item = NULL;
struct clean_up_item *next = NULL;
@ -2347,7 +2347,7 @@ static void clean_up_db(struct userdata *u) {
PA_LLIST_FOREACH_SAFE(item, next, to_be_converted) {
pa_log_debug("Upgrading a legacy entry to the current format: %s", item->entry_name);
pa_assert_se(entry_write(u, item->entry_name, item->entry, TRUE) >= 0);
pa_assert_se(entry_write(u, item->entry_name, item->entry, true) >= 0);
trigger_save(u);
PA_LLIST_REMOVE(struct clean_up_item, to_be_converted, item);
@ -2365,10 +2365,10 @@ int pa__init(pa_module*m) {
pa_sink_input *si;
pa_source_output *so;
uint32_t idx;
pa_bool_t restore_device = TRUE, restore_volume = TRUE, restore_muted = TRUE, on_hotplug = TRUE, on_rescue = TRUE;
bool restore_device = true, restore_volume = true, restore_muted = true, on_hotplug = true, on_rescue = true;
#ifdef HAVE_DBUS
pa_datum key;
pa_bool_t done;
bool done;
#endif
pa_assert(m);
@ -2430,10 +2430,10 @@ int pa__init(pa_module*m) {
u->source_output_fixate_hook_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_OUTPUT_FIXATE], PA_HOOK_EARLY, (pa_hook_cb_t) source_output_fixate_hook_callback, u);
}
if (!(fname = pa_state_path("stream-volumes", TRUE)))
if (!(fname = pa_state_path("stream-volumes", true)))
goto fail;
if (!(u->database = pa_database_open(fname, TRUE))) {
if (!(u->database = pa_database_open(fname, true))) {
pa_log("Failed to open volume database '%s': %s", fname, pa_cstrerror(errno));
pa_xfree(fname);
goto fail;

10
src/modules/module-suspend-on-idle.c
View file

@ -39,7 +39,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("When a sink/source is idle for too long, suspend it");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE("timeout=<timeout>");
static const char* const valid_modargs[] = {
@ -89,13 +89,13 @@ static void timeout_cb(pa_mainloop_api*a, pa_time_event* e, const struct timeval
if (d->sink && pa_sink_check_suspend(d->sink) <= 0 && !(d->sink->suspend_cause & PA_SUSPEND_IDLE)) {
pa_log_info("Sink %s idle for too long, suspending ...", d->sink->name);
pa_sink_suspend(d->sink, TRUE, PA_SUSPEND_IDLE);
pa_sink_suspend(d->sink, true, PA_SUSPEND_IDLE);
pa_core_maybe_vacuum(d->userdata->core);
}
if (d->source && pa_source_check_suspend(d->source) <= 0 && !(d->source->suspend_cause & PA_SUSPEND_IDLE)) {
pa_log_info("Source %s idle for too long, suspending ...", d->source->name);
pa_source_suspend(d->source, TRUE, PA_SUSPEND_IDLE);
pa_source_suspend(d->source, true, PA_SUSPEND_IDLE);
pa_core_maybe_vacuum(d->userdata->core);
}
}
@ -129,12 +129,12 @@ static void resume(struct device_info *d) {
if (d->sink) {
pa_log_debug("Sink %s becomes busy, resuming.", d->sink->name);
pa_sink_suspend(d->sink, FALSE, PA_SUSPEND_IDLE);
pa_sink_suspend(d->sink, false, PA_SUSPEND_IDLE);
}
if (d->source) {
pa_log_debug("Source %s becomes busy, resuming.", d->source->name);
pa_source_suspend(d->source, FALSE, PA_SUSPEND_IDLE);
pa_source_suspend(d->source, false, PA_SUSPEND_IDLE);
}
}

6
src/modules/module-switch-on-connect.c
View file

@ -40,7 +40,7 @@
PA_MODULE_AUTHOR("Michael Terry");
PA_MODULE_DESCRIPTION("When a sink/source is added, switch to it");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
static const char* const valid_modargs[] = {
NULL,
@ -90,7 +90,7 @@ static pa_hook_result_t sink_put_hook_callback(pa_core *c, pa_sink *sink, void*
if (i->save_sink || !PA_SINK_INPUT_IS_LINKED(i->state))
continue;
if (pa_sink_input_move_to(i, sink, FALSE) < 0)
if (pa_sink_input_move_to(i, sink, false) < 0)
pa_log_info("Failed to move sink input %u \"%s\" to %s.", i->index,
pa_strnull(pa_proplist_gets(i->proplist, PA_PROP_APPLICATION_NAME)), sink->name);
else
@ -143,7 +143,7 @@ static pa_hook_result_t source_put_hook_callback(pa_core *c, pa_source *source,
if (o->save_source || !PA_SOURCE_OUTPUT_IS_LINKED(o->state))
continue;
if (pa_source_output_move_to(o, source, FALSE) < 0)
if (pa_source_output_move_to(o, source, false) < 0)
pa_log_info("Failed to move source output %u \"%s\" to %s.", o->index,
pa_strnull(pa_proplist_gets(o->proplist, PA_PROP_APPLICATION_NAME)), source->name);
else

12
src/modules/module-switch-on-port-available.c
View file

@ -121,7 +121,7 @@ static int try_to_switch_profile(pa_device_port *port) {
return -1;
}
if (pa_card_set_profile(port->card, best_profile->name, FALSE) != 0) {
if (pa_card_set_profile(port->card, best_profile->name, false) != 0) {
pa_log_debug("Could not set profile %s", best_profile->name);
return -1;
}
@ -157,7 +157,7 @@ static pa_hook_result_t port_available_hook_callback(pa_core *c, pa_device_port
pa_card* card;
pa_sink *sink;
pa_source *source;
pa_bool_t is_active_profile, is_active_port;
bool is_active_profile, is_active_port;
if (port->available == PA_AVAILABLE_UNKNOWN)
return PA_HOOK_OK;
@ -196,9 +196,9 @@ static pa_hook_result_t port_available_hook_callback(pa_core *c, pa_device_port
}
if (source)
pa_source_set_port(source, port->name, FALSE);
pa_source_set_port(source, port->name, false);
if (sink)
pa_sink_set_port(sink, port->name, FALSE);
pa_sink_set_port(sink, port->name, false);
}
if (port->available == PA_AVAILABLE_NO) {
@ -206,7 +206,7 @@ static pa_hook_result_t port_available_hook_callback(pa_core *c, pa_device_port
pa_device_port *p2 = find_best_port(sink->ports);
if (p2 && p2->available != PA_AVAILABLE_NO)
pa_sink_set_port(sink, p2->name, FALSE);
pa_sink_set_port(sink, p2->name, false);
else {
/* Maybe try to switch to another profile? */
}
@ -216,7 +216,7 @@ static pa_hook_result_t port_available_hook_callback(pa_core *c, pa_device_port
pa_device_port *p2 = find_best_port(source->ports);
if (p2 && p2->available != PA_AVAILABLE_NO)
pa_source_set_port(source, p2->name, FALSE);
pa_source_set_port(source, p2->name, false);
else {
/* Maybe try to switch to another profile? */
}

2
src/modules/module-systemd-login.c
View file

@ -45,7 +45,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Create a client for each login session of this user");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
static const char* const valid_modargs[] = {
NULL

146
src/modules/module-tunnel.c
View file

@ -89,7 +89,7 @@ PA_MODULE_USAGE(
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
static const char* const valid_modargs[] = {
"server",
@ -205,8 +205,8 @@ struct userdata {
int64_t counter, counter_delta;
pa_bool_t remote_corked:1;
pa_bool_t remote_suspended:1;
bool remote_corked:1;
bool remote_suspended:1;
pa_usec_t transport_usec; /* maintained in the main thread */
pa_usec_t thread_transport_usec; /* maintained in the IO thread */
@ -248,7 +248,7 @@ static void command_stream_killed(pa_pdispatch *pd, uint32_t command, uint32_t
pa_assert(u->pdispatch == pd);
pa_log_warn("Stream killed");
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
/* Called from main context */
@ -268,7 +268,7 @@ static void command_overflow_or_underflow(pa_pdispatch *pd, uint32_t command,
static void command_suspended(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct userdata *u = userdata;
uint32_t channel;
pa_bool_t suspended;
bool suspended;
pa_assert(pd);
pa_assert(t);
@ -280,7 +280,7 @@ static void command_suspended(pa_pdispatch *pd, uint32_t command, uint32_t tag
!pa_tagstruct_eof(t)) {
pa_log("Invalid packet.");
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
return;
}
@ -300,7 +300,7 @@ static void command_moved(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa
struct userdata *u = userdata;
uint32_t channel, di;
const char *dn;
pa_bool_t suspended;
bool suspended;
pa_assert(pd);
pa_assert(t);
@ -313,7 +313,7 @@ static void command_moved(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa
pa_tagstruct_get_boolean(t, &suspended) < 0) {
pa_log_error("Invalid packet.");
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
return;
}
@ -342,7 +342,7 @@ static void command_stream_buffer_attr_changed(pa_pdispatch *pd, uint32_t comman
pa_tagstruct_getu32(t, &maxlength) < 0) {
pa_log_error("Invalid packet.");
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
return;
}
@ -351,7 +351,7 @@ static void command_stream_buffer_attr_changed(pa_pdispatch *pd, uint32_t comman
pa_tagstruct_get_usec(t, &usec) < 0) {
pa_log_error("Invalid packet.");
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
return;
}
} else {
@ -361,7 +361,7 @@ static void command_stream_buffer_attr_changed(pa_pdispatch *pd, uint32_t comman
pa_tagstruct_get_usec(t, &usec) < 0) {
pa_log_error("Invalid packet.");
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
return;
}
}
@ -391,7 +391,7 @@ static void command_started(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa
#endif
/* Called from IO thread context */
static void check_smoother_status(struct userdata *u, pa_bool_t past) {
static void check_smoother_status(struct userdata *u, bool past) {
pa_usec_t x;
pa_assert(u);
@ -410,22 +410,22 @@ static void check_smoother_status(struct userdata *u, pa_bool_t past) {
if (u->remote_suspended || u->remote_corked)
pa_smoother_pause(u->smoother, x);
else
pa_smoother_resume(u->smoother, x, TRUE);
pa_smoother_resume(u->smoother, x, true);
}
/* Called from IO thread context */
static void stream_cork_within_thread(struct userdata *u, pa_bool_t cork) {
static void stream_cork_within_thread(struct userdata *u, bool cork) {
pa_assert(u);
if (u->remote_corked == cork)
return;
u->remote_corked = cork;
check_smoother_status(u, FALSE);
check_smoother_status(u, false);
}
/* Called from main context */
static void stream_cork(struct userdata *u, pa_bool_t cork) {
static void stream_cork(struct userdata *u, bool cork) {
pa_tagstruct *t;
pa_assert(u);
@ -447,14 +447,14 @@ static void stream_cork(struct userdata *u, pa_bool_t cork) {
}
/* Called from IO thread context */
static void stream_suspend_within_thread(struct userdata *u, pa_bool_t suspend) {
static void stream_suspend_within_thread(struct userdata *u, bool suspend) {
pa_assert(u);
if (u->remote_suspended == suspend)
return;
u->remote_suspended = suspend;
check_smoother_status(u, TRUE);
check_smoother_status(u, true);
}
#ifdef TUNNEL_SINK
@ -567,13 +567,13 @@ static int sink_set_state(pa_sink *s, pa_sink_state_t state) {
case PA_SINK_SUSPENDED:
pa_assert(PA_SINK_IS_OPENED(s->state));
stream_cork(u, TRUE);
stream_cork(u, true);
break;
case PA_SINK_IDLE:
case PA_SINK_RUNNING:
if (s->state == PA_SINK_SUSPENDED)
stream_cork(u, FALSE);
stream_cork(u, false);
break;
case PA_SINK_UNLINKED:
@ -663,13 +663,13 @@ static int source_set_state(pa_source *s, pa_source_state_t state) {
case PA_SOURCE_SUSPENDED:
pa_assert(PA_SOURCE_IS_OPENED(s->state));
stream_cork(u, TRUE);
stream_cork(u, true);
break;
case PA_SOURCE_IDLE:
case PA_SOURCE_RUNNING:
if (s->state == PA_SOURCE_SUSPENDED)
stream_cork(u, FALSE);
stream_cork(u, false);
break;
case PA_SOURCE_UNLINKED:
@ -700,7 +700,7 @@ static void thread_func(void *userdata) {
pa_sink_process_rewind(u->sink, 0);
#endif
if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
if ((ret = pa_rtpoll_run(u->rtpoll, true)) < 0)
goto fail;
if (ret == 0)
@ -744,7 +744,7 @@ static void command_request(pa_pdispatch *pd, uint32_t command, uint32_t tag, p
return;
fail:
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
#endif
@ -753,7 +753,7 @@ fail:
static void stream_get_latency_callback(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_tagstruct *t, void *userdata) {
struct userdata *u = userdata;
pa_usec_t sink_usec, source_usec;
pa_bool_t playing;
bool playing;
int64_t write_index, read_index;
struct timeval local, remote, now;
pa_sample_spec *ss;
@ -855,7 +855,7 @@ static void stream_get_latency_callback(pa_pdispatch *pd, uint32_t command, uint
fail:
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
/* Called from main context */
@ -990,7 +990,7 @@ static void server_info_cb(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa
return;
fail:
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
static int read_ports(struct userdata *u, pa_tagstruct *t) {
@ -1058,7 +1058,7 @@ static void sink_info_cb(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_t
pa_sample_spec ss;
pa_channel_map cm;
pa_cvolume volume;
pa_bool_t mute;
bool mute;
pa_usec_t latency;
pa_assert(pd);
@ -1137,7 +1137,7 @@ static void sink_info_cb(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa_t
return;
fail:
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
/* Called from main context */
@ -1146,11 +1146,11 @@ static void sink_input_info_cb(pa_pdispatch *pd, uint32_t command, uint32_t tag
uint32_t idx, owner_module, client, sink;
pa_usec_t buffer_usec, sink_usec;
const char *name, *driver, *resample_method;
pa_bool_t mute = FALSE;
bool mute = false;
pa_sample_spec sample_spec;
pa_channel_map channel_map;
pa_cvolume volume;
pa_bool_t b;
bool b;
pa_assert(pd);
pa_assert(u);
@ -1246,7 +1246,7 @@ static void sink_input_info_cb(pa_pdispatch *pd, uint32_t command, uint32_t tag
return;
fail:
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
#else
@ -1259,7 +1259,7 @@ static void source_info_cb(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa
pa_sample_spec ss;
pa_channel_map cm;
pa_cvolume volume;
pa_bool_t mute;
bool mute;
pa_usec_t latency, configured_latency;
pa_assert(pd);
@ -1336,7 +1336,7 @@ static void source_info_cb(pa_pdispatch *pd, uint32_t command, uint32_t tag, pa
return;
fail:
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
#endif
@ -1397,7 +1397,7 @@ static void command_subscribe_event(pa_pdispatch *pd, uint32_t command, uint32
if (pa_tagstruct_getu32(t, &e) < 0 ||
pa_tagstruct_getu32(t, &idx) < 0) {
pa_log("Invalid protocol reply");
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
return;
}
@ -1479,7 +1479,7 @@ static void create_stream_callback(pa_pdispatch *pd, uint32_t command, uint32_t
pa_channel_map cm;
uint32_t device_index;
const char *dn;
pa_bool_t suspended;
bool suspended;
if (pa_tagstruct_get_sample_spec(t, &ss) < 0 ||
pa_tagstruct_get_channel_map(t, &cm) < 0 ||
@ -1544,7 +1544,7 @@ parse_error:
pa_log("Invalid reply. (Create stream)");
fail:
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
@ -1672,20 +1672,20 @@ static void setup_complete_callback(pa_pdispatch *pd, uint32_t command, uint32_t
#endif
if (u->version >= 12) {
pa_tagstruct_put_boolean(reply, FALSE); /* no_remap */
pa_tagstruct_put_boolean(reply, FALSE); /* no_remix */
pa_tagstruct_put_boolean(reply, FALSE); /* fix_format */
pa_tagstruct_put_boolean(reply, FALSE); /* fix_rate */
pa_tagstruct_put_boolean(reply, FALSE); /* fix_channels */
pa_tagstruct_put_boolean(reply, TRUE); /* no_move */
pa_tagstruct_put_boolean(reply, FALSE); /* variable_rate */
pa_tagstruct_put_boolean(reply, false); /* no_remap */
pa_tagstruct_put_boolean(reply, false); /* no_remix */
pa_tagstruct_put_boolean(reply, false); /* fix_format */
pa_tagstruct_put_boolean(reply, false); /* fix_rate */
pa_tagstruct_put_boolean(reply, false); /* fix_channels */
pa_tagstruct_put_boolean(reply, true); /* no_move */
pa_tagstruct_put_boolean(reply, false); /* variable_rate */
}
if (u->version >= 13) {
pa_proplist *pl;
pa_tagstruct_put_boolean(reply, FALSE); /* start muted/peak detect*/
pa_tagstruct_put_boolean(reply, TRUE); /* adjust_latency */
pa_tagstruct_put_boolean(reply, false); /* start muted/peak detect*/
pa_tagstruct_put_boolean(reply, true); /* adjust_latency */
pl = pa_proplist_new();
pa_proplist_sets(pl, PA_PROP_MEDIA_NAME, name);
@ -1700,25 +1700,25 @@ static void setup_complete_callback(pa_pdispatch *pd, uint32_t command, uint32_t
if (u->version >= 14) {
#ifdef TUNNEL_SINK
pa_tagstruct_put_boolean(reply, FALSE); /* volume_set */
pa_tagstruct_put_boolean(reply, false); /* volume_set */
#endif
pa_tagstruct_put_boolean(reply, TRUE); /* early rquests */
pa_tagstruct_put_boolean(reply, true); /* early rquests */
}
if (u->version >= 15) {
#ifdef TUNNEL_SINK
pa_tagstruct_put_boolean(reply, FALSE); /* muted_set */
pa_tagstruct_put_boolean(reply, false); /* muted_set */
#endif
pa_tagstruct_put_boolean(reply, FALSE); /* don't inhibit auto suspend */
pa_tagstruct_put_boolean(reply, FALSE); /* fail on suspend */
pa_tagstruct_put_boolean(reply, false); /* don't inhibit auto suspend */
pa_tagstruct_put_boolean(reply, false); /* fail on suspend */
}
#ifdef TUNNEL_SINK
if (u->version >= 17)
pa_tagstruct_put_boolean(reply, FALSE); /* relative volume */
pa_tagstruct_put_boolean(reply, false); /* relative volume */
if (u->version >= 18)
pa_tagstruct_put_boolean(reply, FALSE); /* passthrough stream */
pa_tagstruct_put_boolean(reply, false); /* passthrough stream */
#endif
#ifdef TUNNEL_SINK
@ -1732,11 +1732,11 @@ static void setup_complete_callback(pa_pdispatch *pd, uint32_t command, uint32_t
pa_tagstruct_putu8(reply, 0);
pa_cvolume_reset(&volume, u->source->sample_spec.channels);
pa_tagstruct_put_cvolume(reply, &volume);
pa_tagstruct_put_boolean(reply, FALSE); /* muted */
pa_tagstruct_put_boolean(reply, FALSE); /* volume_set */
pa_tagstruct_put_boolean(reply, FALSE); /* muted_set */
pa_tagstruct_put_boolean(reply, FALSE); /* relative volume */
pa_tagstruct_put_boolean(reply, FALSE); /* passthrough stream */
pa_tagstruct_put_boolean(reply, false); /* muted */
pa_tagstruct_put_boolean(reply, false); /* volume_set */
pa_tagstruct_put_boolean(reply, false); /* muted_set */
pa_tagstruct_put_boolean(reply, false); /* relative volume */
pa_tagstruct_put_boolean(reply, false); /* passthrough stream */
}
#endif
@ -1748,7 +1748,7 @@ static void setup_complete_callback(pa_pdispatch *pd, uint32_t command, uint32_t
return;
fail:
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
/* Called from main context */
@ -1759,7 +1759,7 @@ static void pstream_die_callback(pa_pstream *p, void *userdata) {
pa_assert(u);
pa_log_warn("Stream died.");
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
/* Called from main context */
@ -1772,7 +1772,7 @@ static void pstream_packet_callback(pa_pstream *p, pa_packet *packet, const pa_c
if (pa_pdispatch_run(u->pdispatch, packet, creds, u) < 0) {
pa_log("Invalid packet");
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
return;
}
}
@ -1788,7 +1788,7 @@ static void pstream_memblock_callback(pa_pstream *p, uint32_t channel, int64_t o
if (channel != u->channel) {
pa_log("Received memory block on bad channel.");
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
return;
}
@ -1813,12 +1813,12 @@ static void on_connection(pa_socket_client *sc, pa_iochannel *io, void *userdata
if (!io) {
pa_log("Connection failed: %s", pa_cstrerror(errno));
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
return;
}
u->pstream = pa_pstream_new(u->core->mainloop, io, u->core->mempool);
u->pdispatch = pa_pdispatch_new(u->core->mainloop, TRUE, command_table, PA_COMMAND_MAX);
u->pdispatch = pa_pdispatch_new(u->core->mainloop, true, command_table, PA_COMMAND_MAX);
pa_pstream_set_die_callback(u->pstream, pstream_die_callback, u);
pa_pstream_set_receive_packet_callback(u->pstream, pstream_packet_callback, u);
@ -1932,23 +1932,23 @@ int pa__init(pa_module*m) {
u->smoother = pa_smoother_new(
PA_USEC_PER_SEC,
PA_USEC_PER_SEC*2,
TRUE,
TRUE,
true,
true,
10,
pa_rtclock_now(),
FALSE);
false);
u->ctag = 1;
u->device_index = u->channel = PA_INVALID_INDEX;
u->time_event = NULL;
u->ignore_latency_before = 0;
u->transport_usec = u->thread_transport_usec = 0;
u->remote_suspended = u->remote_corked = FALSE;
u->remote_suspended = u->remote_corked = false;
u->counter = u->counter_delta = 0;
u->rtpoll = pa_rtpoll_new();
pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
if (!(u->auth_cookie = pa_auth_cookie_get(u->core, pa_modargs_get_value(ma, "cookie", PA_NATIVE_COOKIE_FILE), TRUE, PA_NATIVE_COOKIE_LENGTH)))
if (!(u->auth_cookie = pa_auth_cookie_get(u->core, pa_modargs_get_value(ma, "cookie", PA_NATIVE_COOKIE_FILE), true, PA_NATIVE_COOKIE_LENGTH)))
goto fail;
if (!(u->server_name = pa_xstrdup(pa_modargs_get_value(ma, "server", NULL)))) {
@ -1963,7 +1963,7 @@ int pa__init(pa_module*m) {
goto fail;
}
if (!(u->client = pa_socket_client_new_string(m->core->mainloop, TRUE, u->server_name, PA_NATIVE_DEFAULT_PORT))) {
if (!(u->client = pa_socket_client_new_string(m->core->mainloop, true, u->server_name, PA_NATIVE_DEFAULT_PORT))) {
pa_log("Failed to connect to server '%s'", u->server_name);
goto fail;
}
@ -1978,7 +1978,7 @@ int pa__init(pa_module*m) {
pa_sink_new_data_init(&data);
data.driver = __FILE__;
data.module = m;
data.namereg_fail = TRUE;
data.namereg_fail = true;
pa_sink_new_data_set_name(&data, dn);
pa_sink_new_data_set_sample_spec(&data, &ss);
pa_sink_new_data_set_channel_map(&data, &map);
@ -2007,7 +2007,7 @@ int pa__init(pa_module*m) {
pa_sink_set_set_volume_callback(u->sink, sink_set_volume);
pa_sink_set_set_mute_callback(u->sink, sink_set_mute);
u->sink->refresh_volume = u->sink->refresh_muted = FALSE;
u->sink->refresh_volume = u->sink->refresh_muted = false;
/* pa_sink_set_latency_range(u->sink, MIN_NETWORK_LATENCY_USEC, 0); */
@ -2022,7 +2022,7 @@ int pa__init(pa_module*m) {
pa_source_new_data_init(&data);
data.driver = __FILE__;
data.module = m;
data.namereg_fail = TRUE;
data.namereg_fail = true;
pa_source_new_data_set_name(&data, dn);
pa_source_new_data_set_sample_spec(&data, &ss);
pa_source_new_data_set_channel_map(&data, &map);

48
src/modules/module-udev-detect.c
View file

@ -43,7 +43,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Detect available audio hardware and load matching drivers");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_USAGE(
"tsched=<enable system timer based scheduling mode?> "
"tsched_buffer_size=<buffer size when using timer based scheduling> "
@ -54,7 +54,7 @@ PA_MODULE_USAGE(
struct device {
char *path;
pa_bool_t need_verify;
bool need_verify;
char *card_name;
char *args;
uint32_t module;
@ -65,11 +65,11 @@ struct userdata {
pa_core *core;
pa_hashmap *devices;
pa_bool_t use_tsched:1;
bool use_tsched:1;
bool tsched_buffer_size_valid:1;
pa_bool_t fixed_latency_range:1;
pa_bool_t ignore_dB:1;
pa_bool_t deferred_volume:1;
bool fixed_latency_range:1;
bool ignore_dB:1;
bool deferred_volume:1;
bool use_ucm:1;
uint32_t tsched_buffer_size;
@ -155,9 +155,9 @@ finish:
return r;
}
static pa_bool_t pcm_is_modem(const char *card_idx, const char *pcm) {
static bool pcm_is_modem(const char *card_idx, const char *pcm) {
char *sysfs_path, *pcm_class;
pa_bool_t is_modem;
bool is_modem;
pa_assert(card_idx);
pa_assert(pcm);
@ -175,13 +175,13 @@ static pa_bool_t pcm_is_modem(const char *card_idx, const char *pcm) {
return is_modem;
}
static pa_bool_t is_card_busy(const char *id) {
static bool is_card_busy(const char *id) {
char *card_path = NULL, *pcm_path = NULL, *sub_status = NULL;
DIR *card_dir = NULL, *pcm_dir = NULL;
FILE *status_file = NULL;
size_t len;
struct dirent *space = NULL, *de;
pa_bool_t busy = FALSE;
bool busy = false;
int r;
pa_assert(id);
@ -258,7 +258,7 @@ static pa_bool_t is_card_busy(const char *id) {
}
if (!pa_streq(line, "closed\n")) {
busy = TRUE;
busy = true;
break;
}
}
@ -286,7 +286,7 @@ fail:
static void verify_access(struct userdata *u, struct device *d) {
char *cd;
pa_card *card;
pa_bool_t accessible;
bool accessible;
pa_assert(u);
pa_assert(d);
@ -303,7 +303,7 @@ static void verify_access(struct userdata *u, struct device *d) {
if (accessible) {
pa_module *m;
pa_bool_t busy;
bool busy;
/* Check if any of the PCM devices that belong to this
* card are currently busy. If they are, don't try to load
@ -442,7 +442,7 @@ static void remove_card(struct userdata *u, struct udev_device *dev) {
pa_log_info("Card %s removed.", d->path);
if (d->module != PA_INVALID_INDEX)
pa_module_unload_request_by_index(u->core, d->module, TRUE);
pa_module_unload_request_by_index(u->core, d->module, true);
device_free(d);
}
@ -521,12 +521,12 @@ fail:
u->udev_io = NULL;
}
static pa_bool_t pcm_node_belongs_to_device(
static bool pcm_node_belongs_to_device(
struct device *d,
const char *node) {
char *cd;
pa_bool_t b;
bool b;
cd = pa_sprintf_malloc("pcmC%sD", path_get_card_id(d->path));
b = pa_startswith(node, cd);
@ -535,12 +535,12 @@ static pa_bool_t pcm_node_belongs_to_device(
return b;
}
static pa_bool_t control_node_belongs_to_device(
static bool control_node_belongs_to_device(
struct device *d,
const char *node) {
char *cd;
pa_bool_t b;
bool b;
cd = pa_sprintf_malloc("controlC%s", path_get_card_id(d->path));
b = pa_streq(node, cd);
@ -562,7 +562,7 @@ static void inotify_cb(
} buf;
struct userdata *u = userdata;
static int type = 0;
pa_bool_t deleted = FALSE;
bool deleted = false;
struct device *d;
void *state;
@ -602,18 +602,18 @@ static void inotify_cb(
if (((event->mask & IN_ATTRIB) && pa_startswith(event->name, "controlC")))
PA_HASHMAP_FOREACH(d, u->devices, state)
if (control_node_belongs_to_device(d, event->name))
d->need_verify = TRUE;
d->need_verify = true;
/* ALSA doesn't really give us any guarantee on the closing
* order, so let's simply hope */
if (((event->mask & IN_CLOSE_WRITE) && pa_startswith(event->name, "pcmC")))
PA_HASHMAP_FOREACH(d, u->devices, state)
if (pcm_node_belongs_to_device(d, event->name))
d->need_verify = TRUE;
d->need_verify = true;
/* /dev/snd/ might have been removed */
if ((event->mask & (IN_DELETE_SELF|IN_MOVE_SELF)))
deleted = TRUE;
deleted = true;
event = (struct inotify_event*) ((uint8_t*) event + len);
r -= len;
@ -622,7 +622,7 @@ static void inotify_cb(
PA_HASHMAP_FOREACH(d, u->devices, state)
if (d->need_verify) {
d->need_verify = FALSE;
d->need_verify = false;
verify_access(u, d);
}
@ -688,7 +688,7 @@ int pa__init(pa_module *m) {
struct udev_enumerate *enumerate = NULL;
struct udev_list_entry *item = NULL, *first = NULL;
int fd;
pa_bool_t use_tsched = TRUE, fixed_latency_range = FALSE, ignore_dB = FALSE, deferred_volume = m->core->deferred_volume;
bool use_tsched = true, fixed_latency_range = false, ignore_dB = false, deferred_volume = m->core->deferred_volume;
bool use_ucm = true;
pa_assert(m);

24
src/modules/module-virtual-sink.c
View file

@ -43,7 +43,7 @@
PA_MODULE_AUTHOR("Pierre-Louis Bossart");
PA_MODULE_DESCRIPTION(_("Virtual sink"));
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> "
@ -61,14 +61,14 @@ struct userdata {
pa_module *module;
/* FIXME: Uncomment this and take "autoloaded" as a modarg if this is a filter */
/* pa_bool_t autoloaded; */
/* bool autoloaded; */
pa_sink *sink;
pa_sink_input *sink_input;
pa_memblockq *memblockq;
pa_bool_t auto_desc;
bool auto_desc;
unsigned channels;
};
@ -144,7 +144,7 @@ static void sink_request_rewind_cb(pa_sink *s) {
/* Just hand this one over to the master sink */
pa_sink_input_request_rewind(u->sink_input,
s->thread_info.rewind_nbytes +
pa_memblockq_get_length(u->memblockq), TRUE, FALSE, FALSE);
pa_memblockq_get_length(u->memblockq), true, false, false);
}
/* Called from I/O thread context */
@ -175,7 +175,7 @@ static void sink_set_volume_cb(pa_sink *s) {
!PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u->sink_input)))
return;
pa_sink_input_set_volume(u->sink_input, &s->real_volume, s->save_volume, TRUE);
pa_sink_input_set_volume(u->sink_input, &s->real_volume, s->save_volume, true);
}
/* Called from main context */
@ -281,7 +281,7 @@ static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
u->sink->thread_info.rewind_nbytes = 0;
if (amount > 0) {
pa_memblockq_seek(u->memblockq, - (int64_t) amount, PA_SEEK_RELATIVE, TRUE);
pa_memblockq_seek(u->memblockq, - (int64_t) amount, PA_SEEK_RELATIVE, true);
/* (5) PUT YOUR CODE HERE TO RESET YOUR FILTER */
}
@ -398,7 +398,7 @@ static void sink_input_kill_cb(pa_sink_input *i) {
pa_sink_unref(u->sink);
u->sink = NULL;
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
/* Called from IO thread context */
@ -413,7 +413,7 @@ static void sink_input_state_change_cb(pa_sink_input *i, pa_sink_input_state_t s
if (PA_SINK_INPUT_IS_LINKED(state) &&
i->thread_info.state == PA_SINK_INPUT_INIT) {
pa_log_debug("Requesting rewind due to state change.");
pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
pa_sink_input_request_rewind(i, 0, false, true, true);
}
}
@ -472,8 +472,8 @@ int pa__init(pa_module*m) {
pa_sink *master=NULL;
pa_sink_input_new_data sink_input_data;
pa_sink_new_data sink_data;
pa_bool_t use_volume_sharing = TRUE;
pa_bool_t force_flat_volume = FALSE;
bool use_volume_sharing = true;
bool force_flat_volume = false;
pa_memchunk silence;
pa_assert(m);
@ -559,7 +559,7 @@ int pa__init(pa_module*m) {
pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
if (!use_volume_sharing) {
pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
pa_sink_enable_decibel_volume(u->sink, TRUE);
pa_sink_enable_decibel_volume(u->sink, true);
}
/* Normally this flag would be enabled automatically be we can force it. */
if (force_flat_volume)
@ -572,7 +572,7 @@ int pa__init(pa_module*m) {
pa_sink_input_new_data_init(&sink_input_data);
sink_input_data.driver = __FILE__;
sink_input_data.module = m;
pa_sink_input_new_data_set_sink(&sink_input_data, master, FALSE);
pa_sink_input_new_data_set_sink(&sink_input_data, master, false);
sink_input_data.origin_sink = u->sink;
pa_proplist_setf(sink_input_data.proplist, PA_PROP_MEDIA_NAME, "Virtual Sink Stream from %s", pa_proplist_gets(u->sink->proplist, PA_PROP_DEVICE_DESCRIPTION));
pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_ROLE, "filter");

22
src/modules/module-virtual-source.c
View file

@ -46,7 +46,7 @@
PA_MODULE_AUTHOR("Pierre-Louis Bossart");
PA_MODULE_DESCRIPTION("Virtual source");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
PA_MODULE_USAGE(
_("source_name=<name for the source> "
"source_properties=<properties for the source> "
@ -67,14 +67,14 @@ struct userdata {
pa_module *module;
/* FIXME: Uncomment this and take "autoloaded" as a modarg if this is a filter */
/* pa_bool_t autoloaded; */
/* bool autoloaded; */
pa_source *source;
pa_source_output *source_output;
pa_memblockq *memblockq;
pa_bool_t auto_desc;
bool auto_desc;
unsigned channels;
/* optional fields for uplink sink */
@ -128,7 +128,7 @@ static int sink_set_state_cb(pa_sink *s, pa_sink_state_t state) {
if (state == PA_SINK_RUNNING) {
/* need to wake-up source if it was suspended */
pa_log_debug("Resuming source %s, because its uplink sink became active.", u->source->name);
pa_source_suspend(u->source, FALSE, PA_SUSPEND_ALL);
pa_source_suspend(u->source, false, PA_SUSPEND_ALL);
/* FIXME: if there's no client connected, the source will suspend
and playback will be stuck. You'd want to prevent the source from
@ -240,7 +240,7 @@ static void source_set_volume_cb(pa_source *s) {
!PA_SOURCE_OUTPUT_IS_LINKED(pa_source_output_get_state(u->source_output)))
return;
pa_source_output_set_volume(u->source_output, &s->real_volume, s->save_volume, TRUE);
pa_source_output_set_volume(u->source_output, &s->real_volume, s->save_volume, true);
}
/* Called from main context */
@ -333,7 +333,7 @@ static void source_output_push_cb(pa_source_output *o, const pa_memchunk *chunk)
chunk->length, /* same length as input */
(const pa_sample_spec *)&o->sample_spec, /* same sample spec for input and output */
NULL, /* no volume information */
FALSE); /* no mute */
false); /* no mute */
pa_memblock_release(target_chunk.memblock);
pa_memblock_unref(tchunk.memblock); /* clean-up */
@ -434,7 +434,7 @@ static void source_output_kill_cb(pa_source_output *o) {
pa_source_unref(u->source);
u->source = NULL;
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
/* Called from main thread */
@ -473,8 +473,8 @@ int pa__init(pa_module*m) {
pa_source *master=NULL;
pa_source_output_new_data source_output_data;
pa_source_new_data source_data;
pa_bool_t use_volume_sharing = TRUE;
pa_bool_t force_flat_volume = FALSE;
bool use_volume_sharing = true;
bool force_flat_volume = false;
/* optional for uplink_sink */
pa_sink_new_data sink_data;
@ -568,7 +568,7 @@ int pa__init(pa_module*m) {
pa_source_set_set_mute_callback(u->source, source_set_mute_cb);
if (!use_volume_sharing) {
pa_source_set_set_volume_callback(u->source, source_set_volume_cb);
pa_source_enable_decibel_volume(u->source, TRUE);
pa_source_enable_decibel_volume(u->source, true);
}
/* Normally this flag would be enabled automatically be we can force it. */
if (force_flat_volume)
@ -581,7 +581,7 @@ int pa__init(pa_module*m) {
pa_source_output_new_data_init(&source_output_data);
source_output_data.driver = __FILE__;
source_output_data.module = m;
pa_source_output_new_data_set_source(&source_output_data, master, FALSE);
pa_source_output_new_data_set_source(&source_output_data, master, false);
source_output_data.destination_source = u->source;
pa_proplist_setf(source_output_data.proplist, PA_PROP_MEDIA_NAME, "Virtual Source Stream of %s", pa_proplist_gets(u->source->proplist, PA_PROP_DEVICE_DESCRIPTION));

24
src/modules/module-virtual-surround-sink.c
View file

@ -48,7 +48,7 @@
PA_MODULE_AUTHOR("Niels Ole Salscheider");
PA_MODULE_DESCRIPTION(_("Virtual surround sink"));
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> "
@ -68,14 +68,14 @@ struct userdata {
pa_module *module;
/* FIXME: Uncomment this and take "autoloaded" as a modarg if this is a filter */
/* pa_bool_t autoloaded; */
/* bool autoloaded; */
pa_sink *sink;
pa_sink_input *sink_input;
pa_memblockq *memblockq;
pa_bool_t auto_desc;
bool auto_desc;
unsigned channels;
unsigned hrir_channels;
@ -165,7 +165,7 @@ static void sink_request_rewind_cb(pa_sink *s) {
/* Just hand this one over to the master sink */
pa_sink_input_request_rewind(u->sink_input,
s->thread_info.rewind_nbytes +
pa_memblockq_get_length(u->memblockq), TRUE, FALSE, FALSE);
pa_memblockq_get_length(u->memblockq), true, false, false);
}
/* Called from I/O thread context */
@ -196,7 +196,7 @@ static void sink_set_volume_cb(pa_sink *s) {
!PA_SINK_INPUT_IS_LINKED(pa_sink_input_get_state(u->sink_input)))
return;
pa_sink_input_set_volume(u->sink_input, &s->real_volume, s->save_volume, TRUE);
pa_sink_input_set_volume(u->sink_input, &s->real_volume, s->save_volume, true);
}
/* Called from main context */
@ -303,7 +303,7 @@ static void sink_input_process_rewind_cb(pa_sink_input *i, size_t nbytes) {
u->sink->thread_info.rewind_nbytes = 0;
if (amount > 0) {
pa_memblockq_seek(u->memblockq, - (int64_t) amount, PA_SEEK_RELATIVE, TRUE);
pa_memblockq_seek(u->memblockq, - (int64_t) amount, PA_SEEK_RELATIVE, true);
/* Reset the input buffer */
memset(u->input_buffer, 0, u->hrir_samples * u->sink_fs);
@ -410,7 +410,7 @@ static void sink_input_kill_cb(pa_sink_input *i) {
pa_sink_unref(u->sink);
u->sink = NULL;
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
/* Called from IO thread context */
@ -425,7 +425,7 @@ static void sink_input_state_change_cb(pa_sink_input *i, pa_sink_input_state_t s
if (PA_SINK_INPUT_IS_LINKED(state) &&
i->thread_info.state == PA_SINK_INPUT_INIT) {
pa_log_debug("Requesting rewind due to state change.");
pa_sink_input_request_rewind(i, 0, FALSE, TRUE, TRUE);
pa_sink_input_request_rewind(i, 0, false, true, true);
}
}
@ -527,8 +527,8 @@ int pa__init(pa_module*m) {
pa_sink *master=NULL;
pa_sink_input_new_data sink_input_data;
pa_sink_new_data sink_data;
pa_bool_t use_volume_sharing = TRUE;
pa_bool_t force_flat_volume = FALSE;
bool use_volume_sharing = true;
bool force_flat_volume = false;
pa_memchunk silence;
const char *hrir_file;
@ -661,7 +661,7 @@ int pa__init(pa_module*m) {
pa_sink_set_set_mute_callback(u->sink, sink_set_mute_cb);
if (!use_volume_sharing) {
pa_sink_set_set_volume_callback(u->sink, sink_set_volume_cb);
pa_sink_enable_decibel_volume(u->sink, TRUE);
pa_sink_enable_decibel_volume(u->sink, true);
}
/* Normally this flag would be enabled automatically be we can force it. */
if (force_flat_volume)
@ -674,7 +674,7 @@ int pa__init(pa_module*m) {
pa_sink_input_new_data_init(&sink_input_data);
sink_input_data.driver = __FILE__;
sink_input_data.module = m;
pa_sink_input_new_data_set_sink(&sink_input_data, master, FALSE);
pa_sink_input_new_data_set_sink(&sink_input_data, master, false);
sink_input_data.origin_sink = u->sink;
pa_proplist_setf(sink_input_data.proplist, PA_PROP_MEDIA_NAME, "Virtual Surround Sink Stream from %s", pa_proplist_gets(u->sink->proplist, PA_PROP_DEVICE_DESCRIPTION));
pa_proplist_sets(sink_input_data.proplist, PA_PROP_MEDIA_ROLE, "filter");

6
src/modules/module-volume-restore.c
View file

@ -35,7 +35,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Compatibility module");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
PA_MODULE_DEPRECATED("Please use module-stream-restore instead of module-volume-restore!");
static const char* const valid_modargs[] = {
@ -47,7 +47,7 @@ static const char* const valid_modargs[] = {
int pa__init(pa_module*m) {
pa_modargs *ma = NULL;
pa_bool_t restore_device = TRUE, restore_volume = TRUE;
bool restore_device = true, restore_volume = true;
pa_module *n;
char *t;
@ -71,7 +71,7 @@ int pa__init(pa_module*m) {
pa_xfree(t);
if (n)
pa_module_unload_request(m, TRUE);
pa_module_unload_request(m, true);
pa_modargs_free(ma);

10
src/modules/module-waveout.c
View file

@ -253,7 +253,7 @@ static void thread_func(void *userdata) {
for (;;) {
int ret;
pa_bool_t need_timer = FALSE;
bool need_timer = false;
if (u->sink) {
if (PA_UNLIKELY(u->sink->thread_info.rewind_requested))
@ -261,13 +261,13 @@ static void thread_func(void *userdata) {
if (PA_SINK_IS_OPENED(u->sink->thread_info.state)) {
do_write(u);
need_timer = TRUE;
need_timer = true;
}
}
if (u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state)) {
do_read(u);
need_timer = TRUE;
need_timer = true;
}
if (need_timer)
@ -276,7 +276,7 @@ static void thread_func(void *userdata) {
pa_rtpoll_set_timer_disabled(u->rtpoll);
/* 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)
goto fail;
if (ret == 0)
@ -499,7 +499,7 @@ int pa__init(pa_module *m) {
WAVEOUTCAPS pwoc;
MMRESULT result;
int nfrags, frag_size;
pa_bool_t record = TRUE, playback = TRUE;
bool record = true, playback = true;
unsigned int device;
pa_sample_spec ss;
pa_channel_map map;

16
src/modules/module-zeroconf-discover.c
View file

@ -49,7 +49,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("mDNS/DNS-SD Service Discovery");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
#define SERVICE_TYPE_SINK "_pulse-sink._tcp"
#define SERVICE_TYPE_SOURCE "_non-monitor._sub._pulse-source._tcp"
@ -153,7 +153,7 @@ static void resolver_cb(
pa_sample_spec ss;
pa_channel_map cm;
AvahiStringList *l;
pa_bool_t channel_map_set = FALSE;
bool channel_map_set = false;
pa_module *m;
ss = u->core->default_sample_spec;
@ -175,7 +175,7 @@ static void resolver_cb(
ss.format = pa_parse_sample_format(value);
else if (pa_streq(key, "channel_map")) {
pa_channel_map_parse(&cm, value);
channel_map_set = TRUE;
channel_map_set = true;
}
avahi_free(key);
@ -281,7 +281,7 @@ static void browser_cb(
struct tunnel *t2;
if ((t2 = pa_hashmap_get(u->tunnels, t))) {
pa_module_unload_request_by_index(u->core, t2->module_index, TRUE);
pa_module_unload_request_by_index(u->core, t2->module_index, true);
pa_hashmap_remove(u->tunnels, t2);
tunnel_free(t2);
}
@ -314,7 +314,7 @@ static void client_callback(AvahiClient *c, AvahiClientState state, void *userda
browser_cb, u))) {
pa_log("avahi_service_browser_new() failed: %s", avahi_strerror(avahi_client_errno(c)));
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
}
@ -329,7 +329,7 @@ static void client_callback(AvahiClient *c, AvahiClientState state, void *userda
browser_cb, u))) {
pa_log("avahi_service_browser_new() failed: %s", avahi_strerror(avahi_client_errno(c)));
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
}
@ -343,7 +343,7 @@ static void client_callback(AvahiClient *c, AvahiClientState state, void *userda
if (!(u->client = avahi_client_new(u->avahi_poll, AVAHI_CLIENT_NO_FAIL, client_callback, u, &error))) {
pa_log("avahi_client_new() failed: %s", avahi_strerror(error));
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
}
@ -422,7 +422,7 @@ void pa__done(pa_module*m) {
struct tunnel *t;
while ((t = pa_hashmap_steal_first(u->tunnels))) {
pa_module_unload_request_by_index(u->core, t->module_index, TRUE);
pa_module_unload_request_by_index(u->core, t->module_index, true);
tunnel_free(t);
}

16
src/modules/module-zeroconf-publish.c
View file

@ -53,7 +53,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("mDNS/DNS-SD Service Publisher");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
#define SERVICE_TYPE_SINK "_pulse-sink._tcp"
#define SERVICE_TYPE_SOURCE "_pulse-source._tcp"
@ -150,7 +150,7 @@ static void get_service_data(struct service *s, pa_object *device) {
if (pa_sink_isinstance(device)) {
pa_sink *sink = PA_SINK(device);
s->is_sink = TRUE;
s->is_sink = true;
s->service_type = SERVICE_TYPE_SINK;
s->ss = sink->sample_spec;
s->cm = sink->channel_map;
@ -161,7 +161,7 @@ static void get_service_data(struct service *s, pa_object *device) {
} else if (pa_source_isinstance(device)) {
pa_source *source = PA_SOURCE(device);
s->is_sink = FALSE;
s->is_sink = false;
s->service_type = SERVICE_TYPE_SOURCE;
s->ss = source->sample_spec;
s->cm = source->channel_map;
@ -439,7 +439,7 @@ static void service_free(struct service *s) {
}
/* Runs in PA mainloop context */
static pa_bool_t shall_ignore(pa_object *o) {
static bool shall_ignore(pa_object *o) {
pa_object_assert_ref(o);
if (pa_sink_isinstance(o))
@ -601,7 +601,7 @@ fail:
}
/* Runs in Avahi mainloop context */
static void unpublish_all_services(struct userdata *u, pa_bool_t rem) {
static void unpublish_all_services(struct userdata *u, bool rem) {
void *state = NULL;
struct service *s;
@ -675,7 +675,7 @@ static void client_callback(AvahiClient *c, AvahiClientState state, void *userda
case AVAHI_CLIENT_S_COLLISION:
pa_log_debug("Host name collision");
unpublish_all_services(u, FALSE);
unpublish_all_services(u, false);
break;
case AVAHI_CLIENT_FAILURE:
@ -684,12 +684,12 @@ static void client_callback(AvahiClient *c, AvahiClientState state, void *userda
pa_log_debug("Avahi daemon disconnected.");
unpublish_all_services(u, TRUE);
unpublish_all_services(u, true);
avahi_client_free(u->client);
if (!(u->client = avahi_client_new(u->avahi_poll, AVAHI_CLIENT_NO_FAIL, client_callback, u, &error))) {
pa_log("avahi_client_new() failed: %s", avahi_strerror(error));
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
}

100
src/modules/oss/module-oss.c
View file

@ -78,7 +78,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("OSS Sink/Source");
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> "
@ -116,10 +116,10 @@ struct userdata {
size_t frame_size;
uint32_t in_fragment_size, out_fragment_size, in_nfrags, out_nfrags, in_hwbuf_size, out_hwbuf_size;
pa_bool_t use_getospace, use_getispace;
pa_bool_t use_getodelay;
bool use_getospace, use_getispace;
bool use_getodelay;
pa_bool_t sink_suspended, source_suspended;
bool sink_suspended, source_suspended;
int fd;
int mode;
@ -129,7 +129,7 @@ struct userdata {
int nfrags, frag_size, orig_frag_size;
pa_bool_t use_mmap;
bool use_mmap;
unsigned out_mmap_current, in_mmap_current;
void *in_mmap, *out_mmap;
pa_memblock **in_mmap_memblocks, **out_mmap_memblocks;
@ -157,7 +157,7 @@ static const char* const valid_modargs[] = {
NULL
};
static int trigger(struct userdata *u, pa_bool_t quick) {
static int trigger(struct userdata *u, bool quick) {
int enable_bits = 0, zero = 0;
pa_assert(u);
@ -647,7 +647,7 @@ fail:
static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
struct userdata *u = PA_SINK(o)->userdata;
int ret;
pa_bool_t do_trigger = FALSE, quick = TRUE;
bool do_trigger = false, quick = true;
switch (code) {
@ -678,16 +678,16 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
return -1;
}
do_trigger = TRUE;
do_trigger = true;
u->sink_suspended = TRUE;
u->sink_suspended = true;
break;
case PA_SINK_IDLE:
case PA_SINK_RUNNING:
if (u->sink->thread_info.state == PA_SINK_INIT) {
do_trigger = TRUE;
do_trigger = true;
quick = u->source && PA_SOURCE_IS_OPENED(u->source->thread_info.state);
}
@ -696,15 +696,15 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
if (!u->source || u->source_suspended) {
if (unsuspend(u) < 0)
return -1;
quick = FALSE;
quick = false;
}
do_trigger = TRUE;
do_trigger = true;
u->out_mmap_current = 0;
u->out_mmap_saved_nfrags = 0;
u->sink_suspended = FALSE;
u->sink_suspended = false;
}
break;
@ -732,7 +732,7 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t offset, pa_memchunk *chunk) {
struct userdata *u = PA_SOURCE(o)->userdata;
int ret;
int do_trigger = FALSE, quick = TRUE;
int do_trigger = false, quick = true;
switch (code) {
@ -761,16 +761,16 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
return -1;
}
do_trigger = TRUE;
do_trigger = true;
u->source_suspended = TRUE;
u->source_suspended = true;
break;
case PA_SOURCE_IDLE:
case PA_SOURCE_RUNNING:
if (u->source->thread_info.state == PA_SOURCE_INIT) {
do_trigger = TRUE;
do_trigger = true;
quick = u->sink && PA_SINK_IS_OPENED(u->sink->thread_info.state);
}
@ -779,15 +779,15 @@ static int source_process_msg(pa_msgobject *o, int code, void *data, int64_t off
if (!u->sink || u->sink_suspended) {
if (unsuspend(u) < 0)
return -1;
quick = FALSE;
quick = false;
}
do_trigger = TRUE;
do_trigger = true;
u->in_mmap_current = 0;
u->in_mmap_saved_nfrags = 0;
u->source_suspended = FALSE;
u->source_suspended = false;
}
break;
@ -921,7 +921,7 @@ static void thread_func(void *userdata) {
} else {
ssize_t l;
pa_bool_t loop = FALSE, work_done = FALSE;
bool loop = false, work_done = false;
l = (ssize_t) u->out_fragment_size;
@ -930,14 +930,14 @@ static void thread_func(void *userdata) {
if (ioctl(u->fd, SNDCTL_DSP_GETOSPACE, &info) < 0) {
pa_log_info("Device doesn't support SNDCTL_DSP_GETOSPACE: %s", pa_cstrerror(errno));
u->use_getospace = FALSE;
u->use_getospace = false;
} else {
l = info.bytes;
/* We loop only if GETOSPACE worked and we
* actually *know* that we can write more than
* one fragment at a time */
loop = TRUE;
loop = true;
}
}
@ -952,7 +952,7 @@ static void thread_func(void *userdata) {
* avoid spinning forever. */
if (l <= 0 && (revents & POLLOUT)) {
l = (ssize_t) u->out_fragment_size;
loop = FALSE;
loop = false;
}
while (l > 0) {
@ -1001,7 +1001,7 @@ static void thread_func(void *userdata) {
l -= t;
revents &= ~POLLOUT;
work_done = TRUE;
work_done = true;
}
if (!loop)
@ -1032,7 +1032,7 @@ static void thread_func(void *userdata) {
void *p;
ssize_t l;
pa_memchunk memchunk;
pa_bool_t loop = FALSE, work_done = FALSE;
bool loop = false, work_done = false;
l = (ssize_t) u->in_fragment_size;
@ -1041,10 +1041,10 @@ static void thread_func(void *userdata) {
if (ioctl(u->fd, SNDCTL_DSP_GETISPACE, &info) < 0) {
pa_log_info("Device doesn't support SNDCTL_DSP_GETISPACE: %s", pa_cstrerror(errno));
u->use_getispace = FALSE;
u->use_getispace = false;
} else {
l = info.bytes;
loop = TRUE;
loop = true;
}
}
@ -1052,7 +1052,7 @@ static void thread_func(void *userdata) {
if (l <= 0 && (revents & POLLIN)) {
l = (ssize_t) u->in_fragment_size;
loop = FALSE;
loop = false;
}
while (l > 0) {
@ -1105,7 +1105,7 @@ static void thread_func(void *userdata) {
l -= t;
revents &= ~POLLIN;
work_done = TRUE;
work_done = true;
}
if (!loop)
@ -1131,7 +1131,7 @@ static void thread_func(void *userdata) {
}
/* 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)
goto fail;
if (ret == 0)
@ -1170,13 +1170,13 @@ int pa__init(pa_module*m) {
int fd = -1;
int nfrags, orig_frag_size, frag_size;
int mode, caps;
pa_bool_t record = TRUE, playback = TRUE, use_mmap = TRUE;
bool record = true, playback = true, use_mmap = true;
pa_sample_spec ss;
pa_channel_map map;
pa_modargs *ma = NULL;
char hwdesc[64];
const char *name;
pa_bool_t namereg_fail;
bool namereg_fail;
pa_sink_new_data sink_new_data;
pa_source_new_data source_new_data;
@ -1226,12 +1226,12 @@ int pa__init(pa_module*m) {
if (use_mmap && (!(caps & DSP_CAP_MMAP) || !(caps & DSP_CAP_TRIGGER))) {
pa_log_info("OSS device not mmap capable, falling back to UNIX read/write mode.");
use_mmap = FALSE;
use_mmap = false;
}
if (use_mmap && mode == O_WRONLY) {
pa_log_info("Device opened for playback only, cannot do memory mapping, falling back to UNIX write() mode.");
use_mmap = FALSE;
use_mmap = false;
}
if (pa_oss_get_hw_description(dev, hwdesc, sizeof(hwdesc)) >= 0)
@ -1262,8 +1262,8 @@ int pa__init(pa_module*m) {
u->fd = fd;
u->mixer_fd = -1;
u->mixer_devmask = 0;
u->use_getospace = u->use_getispace = TRUE;
u->use_getodelay = TRUE;
u->use_getospace = u->use_getispace = true;
u->use_getodelay = true;
u->mode = mode;
u->frame_size = pa_frame_size(&ss);
u->device_name = pa_xstrdup(dev);
@ -1280,14 +1280,14 @@ int pa__init(pa_module*m) {
pa_log_info("Input -- %u fragments of size %u.", info.fragstotal, info.fragsize);
u->in_fragment_size = (uint32_t) info.fragsize;
u->in_nfrags = (uint32_t) info.fragstotal;
u->use_getispace = TRUE;
u->use_getispace = true;
}
if (ioctl(fd, SNDCTL_DSP_GETOSPACE, &info) >= 0) {
pa_log_info("Output -- %u fragments of size %u.", info.fragstotal, info.fragsize);
u->out_fragment_size = (uint32_t) info.fragsize;
u->out_nfrags = (uint32_t) info.fragstotal;
u->use_getospace = TRUE;
u->use_getospace = true;
}
u->in_hwbuf_size = u->in_nfrags * u->in_fragment_size;
@ -1299,17 +1299,17 @@ int pa__init(pa_module*m) {
if (use_mmap) {
if ((u->in_mmap = mmap(NULL, u->in_hwbuf_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
pa_log_warn("mmap(PROT_READ) failed, reverting to non-mmap mode: %s", pa_cstrerror(errno));
use_mmap = u->use_mmap = FALSE;
use_mmap = u->use_mmap = false;
u->in_mmap = NULL;
} else
pa_log_debug("Successfully mmap()ed input buffer.");
}
if ((name = pa_modargs_get_value(ma, "source_name", NULL)))
namereg_fail = TRUE;
namereg_fail = true;
else {
name = name_buf = pa_sprintf_malloc("oss_input.%s", pa_path_get_filename(dev));
namereg_fail = FALSE;
namereg_fail = false;
}
pa_source_new_data_init(&source_new_data);
@ -1347,7 +1347,7 @@ int pa__init(pa_module*m) {
pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
pa_source_set_rtpoll(u->source, u->rtpoll);
pa_source_set_fixed_latency(u->source, pa_bytes_to_usec(u->in_hwbuf_size, &u->source->sample_spec));
u->source->refresh_volume = TRUE;
u->source->refresh_volume = true;
if (use_mmap)
u->in_mmap_memblocks = pa_xnew0(pa_memblock*, u->in_nfrags);
@ -1364,7 +1364,7 @@ int pa__init(pa_module*m) {
goto go_on;
} else {
pa_log_warn("mmap(PROT_WRITE) failed, reverting to non-mmap mode: %s", pa_cstrerror(errno));
u->use_mmap = use_mmap = FALSE;
u->use_mmap = use_mmap = false;
u->out_mmap = NULL;
}
} else {
@ -1374,10 +1374,10 @@ int pa__init(pa_module*m) {
}
if ((name = pa_modargs_get_value(ma, "sink_name", NULL)))
namereg_fail = TRUE;
namereg_fail = true;
else {
name = name_buf = pa_sprintf_malloc("oss_output.%s", pa_path_get_filename(dev));
namereg_fail = FALSE;
namereg_fail = false;
}
pa_sink_new_data_init(&sink_new_data);
@ -1415,7 +1415,7 @@ int pa__init(pa_module*m) {
pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
pa_sink_set_rtpoll(u->sink, u->rtpoll);
pa_sink_set_fixed_latency(u->sink, pa_bytes_to_usec(u->out_hwbuf_size, &u->sink->sample_spec));
u->sink->refresh_volume = TRUE;
u->sink->refresh_volume = true;
pa_sink_set_max_request(u->sink, u->out_hwbuf_size);
@ -1424,7 +1424,7 @@ int pa__init(pa_module*m) {
}
if ((u->mixer_fd = pa_oss_open_mixer_for_device(u->device_name)) >= 0) {
pa_bool_t do_close = TRUE;
bool do_close = true;
if (ioctl(fd, SOUND_MIXER_READ_DEVMASK, &u->mixer_devmask) < 0)
pa_log_warn("SOUND_MIXER_READ_DEVMASK failed: %s", pa_cstrerror(errno));
@ -1434,7 +1434,7 @@ int pa__init(pa_module*m) {
pa_sink_set_get_volume_callback(u->sink, sink_get_volume);
pa_sink_set_set_volume_callback(u->sink, sink_set_volume);
u->sink->n_volume_steps = 101;
do_close = FALSE;
do_close = false;
}
if (u->source && (u->mixer_devmask & (SOUND_MASK_RECLEV|SOUND_MASK_IGAIN))) {
@ -1442,7 +1442,7 @@ int pa__init(pa_module*m) {
pa_source_set_get_volume_callback(u->source, source_get_volume);
pa_source_set_set_volume_callback(u->source, source_set_volume);
u->source->n_volume_steps = 101;
do_close = FALSE;
do_close = false;
}
}

10
src/modules/raop/module-raop-discover.c
View file

@ -50,7 +50,7 @@
PA_MODULE_AUTHOR("Colin Guthrie");
PA_MODULE_DESCRIPTION("mDNS/DNS-SD Service Discovery of RAOP devices");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(TRUE);
PA_MODULE_LOAD_ONCE(true);
#define SERVICE_TYPE_SINK "_raop._tcp"
@ -256,7 +256,7 @@ static void browser_cb(
struct tunnel *t2;
if ((t2 = pa_hashmap_get(u->tunnels, t))) {
pa_module_unload_request_by_index(u->core, t2->module_index, TRUE);
pa_module_unload_request_by_index(u->core, t2->module_index, true);
pa_hashmap_remove(u->tunnels, t2);
tunnel_free(t2);
}
@ -289,7 +289,7 @@ static void client_callback(AvahiClient *c, AvahiClientState state, void *userda
browser_cb, u))) {
pa_log("avahi_service_browser_new() failed: %s", avahi_strerror(avahi_client_errno(c)));
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
}
@ -303,7 +303,7 @@ static void client_callback(AvahiClient *c, AvahiClientState state, void *userda
if (!(u->client = avahi_client_new(u->avahi_poll, AVAHI_CLIENT_NO_FAIL, client_callback, u, &error))) {
pa_log("avahi_client_new() failed: %s", avahi_strerror(error));
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
}
@ -377,7 +377,7 @@ void pa__done(pa_module*m) {
struct tunnel *t;
while ((t = pa_hashmap_steal_first(u->tunnels))) {
pa_module_unload_request_by_index(u->core, t->module_index, TRUE);
pa_module_unload_request_by_index(u->core, t->module_index, true);
tunnel_free(t);
}

14
src/modules/raop/module-raop-sink.c
View file

@ -63,7 +63,7 @@
PA_MODULE_AUTHOR("Colin Guthrie");
PA_MODULE_DESCRIPTION("RAOP Sink");
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> "
@ -186,7 +186,7 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
case PA_SINK_RUNNING:
if (u->sink->thread_info.state == PA_SINK_SUSPENDED) {
pa_smoother_resume(u->smoother, pa_rtclock_now(), TRUE);
pa_smoother_resume(u->smoother, pa_rtclock_now(), true);
/* The connection can be closed when idle, so check to
see if we need to reestablish it */
@ -253,7 +253,7 @@ static int sink_process_msg(pa_msgobject *o, int code, void *data, int64_t offse
/* Question: is this valid here: or should we do some sort of:
return pa_sink_process_msg(PA_MSGOBJECT(u->core), PA_CORE_MESSAGE_UNLOAD_MODULE, u->module, 0, NULL);
?? */
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
}
return 0;
}
@ -465,7 +465,7 @@ static void thread_func(void *userdata) {
pollfd->events = POLLOUT; /*PA_SINK_IS_OPENED(u->sink->thread_info.state) ? POLLOUT : 0;*/
}
if ((ret = pa_rtpoll_run(u->rtpoll, TRUE)) < 0)
if ((ret = pa_rtpoll_run(u->rtpoll, true)) < 0)
goto fail;
if (ret == 0)
@ -537,11 +537,11 @@ int pa__init(pa_module*m) {
u->smoother = pa_smoother_new(
PA_USEC_PER_SEC,
PA_USEC_PER_SEC*2,
TRUE,
TRUE,
true,
true,
10,
0,
FALSE);
false);
pa_memchunk_reset(&u->raw_memchunk);
pa_memchunk_reset(&u->encoded_memchunk);
u->offset = 0;

4
src/modules/raop/raop_client.c
View file

@ -221,7 +221,7 @@ static void on_connection(pa_socket_client *sc, pa_iochannel *io, void *userdata
c->fd = pa_iochannel_get_send_fd(io);
pa_iochannel_set_noclose(io, TRUE);
pa_iochannel_set_noclose(io, true);
pa_iochannel_free(io);
pa_make_tcp_socket_low_delay(c->fd);
@ -323,7 +323,7 @@ static void rtsp_cb(pa_rtsp_client *rtsp, pa_rtsp_state state, pa_headerlist* he
uint32_t port = pa_rtsp_serverport(c->rtsp);
pa_log_debug("RAOP: RECORDED");
if (!(c->sc = pa_socket_client_new_string(c->core->mainloop, TRUE, c->host, port))) {
if (!(c->sc = pa_socket_client_new_string(c->core->mainloop, true, c->host, port))) {
pa_log("failed to connect to server '%s:%d'", c->host, port);
return;
}

4
src/modules/reserve-wrap.c
View file

@ -331,7 +331,7 @@ pa_hook* pa_reserve_monitor_wrapper_hook(pa_reserve_monitor_wrapper *w) {
return &w->hook;
}
pa_bool_t pa_reserve_monitor_wrapper_busy(pa_reserve_monitor_wrapper *w) {
bool pa_reserve_monitor_wrapper_busy(pa_reserve_monitor_wrapper *w) {
pa_assert(w);
pa_assert(PA_REFCNT_VALUE(w) >= 1);
@ -339,6 +339,6 @@ pa_bool_t pa_reserve_monitor_wrapper_busy(pa_reserve_monitor_wrapper *w) {
#ifdef HAVE_DBUS
return rm_busy(w->monitor) > 0;
#else
return FALSE;
return false;
#endif
}

2
src/modules/reserve-wrap.h
View file

@ -40,6 +40,6 @@ pa_reserve_monitor_wrapper* pa_reserve_monitor_wrapper_get(pa_core *c, const cha
void pa_reserve_monitor_wrapper_unref(pa_reserve_monitor_wrapper *m);
pa_hook* pa_reserve_monitor_wrapper_hook(pa_reserve_monitor_wrapper *m);
pa_bool_t pa_reserve_monitor_wrapper_busy(pa_reserve_monitor_wrapper *m);
bool pa_reserve_monitor_wrapper_busy(pa_reserve_monitor_wrapper *m);
#endif

8
src/modules/rtp/headerlist.c
View file

@ -61,7 +61,7 @@ void pa_headerlist_free(pa_headerlist* p) {
int pa_headerlist_puts(pa_headerlist *p, const char *key, const char *value) {
struct header *hdr;
pa_bool_t add = FALSE;
bool add = false;
pa_assert(p);
pa_assert(key);
@ -69,7 +69,7 @@ int pa_headerlist_puts(pa_headerlist *p, const char *key, const char *value) {
if (!(hdr = pa_hashmap_get(MAKE_HASHMAP(p), key))) {
hdr = pa_xnew(struct header, 1);
hdr->key = pa_xstrdup(key);
add = TRUE;
add = true;
} else
pa_xfree(hdr->value);
@ -84,7 +84,7 @@ int pa_headerlist_puts(pa_headerlist *p, const char *key, const char *value) {
int pa_headerlist_putsappend(pa_headerlist *p, const char *key, const char *value) {
struct header *hdr;
pa_bool_t add = FALSE;
bool add = false;
pa_assert(p);
pa_assert(key);
@ -93,7 +93,7 @@ int pa_headerlist_putsappend(pa_headerlist *p, const char *key, const char *valu
hdr = pa_xnew(struct header, 1);
hdr->key = pa_xstrdup(key);
hdr->value = pa_xstrdup(value);
add = TRUE;
add = true;
} else {
void *newval = pa_sprintf_malloc("%s%s", (char*)hdr->value, value);
pa_xfree(hdr->value);

22
src/modules/rtp/module-rtp-recv.c
View file

@ -64,7 +64,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Receive data from a network via RTP/SAP/SDP");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
PA_MODULE_USAGE(
"sink=<name of the sink> "
"sap_address=<multicast address to listen on> "
@ -91,7 +91,7 @@ struct session {
pa_sink_input *sink_input;
pa_memblockq *memblockq;
pa_bool_t first_packet;
bool first_packet;
uint32_t ssrc;
uint32_t offset;
@ -191,7 +191,7 @@ static void sink_input_kill(pa_sink_input* i) {
}
/* Called from IO context */
static void sink_input_suspend_within_thread(pa_sink_input* i, pa_bool_t b) {
static void sink_input_suspend_within_thread(pa_sink_input* i, bool b) {
struct session *s;
pa_sink_input_assert_ref(i);
pa_assert_se(s = i->userdata);
@ -199,7 +199,7 @@ static void sink_input_suspend_within_thread(pa_sink_input* i, pa_bool_t b) {
if (b)
pa_memblockq_flush_read(s->memblockq);
else
s->first_packet = FALSE;
s->first_packet = false;
}
/* Called from I/O thread context */
@ -234,7 +234,7 @@ static int rtpoll_work_cb(pa_rtpoll_item *i) {
}
if (!s->first_packet) {
s->first_packet = TRUE;
s->first_packet = true;
s->ssrc = s->rtp_context.ssrc;
s->offset = s->rtp_context.timestamp;
@ -257,7 +257,7 @@ static int rtpoll_work_cb(pa_rtpoll_item *i) {
else
delta = j;
pa_memblockq_seek(s->memblockq, delta * (int64_t) s->rtp_context.frame_size, PA_SEEK_RELATIVE, TRUE);
pa_memblockq_seek(s->memblockq, delta * (int64_t) s->rtp_context.frame_size, PA_SEEK_RELATIVE, true);
if (now.tv_sec == 0) {
PA_ONCE_BEGIN {
@ -269,7 +269,7 @@ static int rtpoll_work_cb(pa_rtpoll_item *i) {
if (pa_memblockq_push(s->memblockq, &chunk) < 0) {
pa_log_warn("Queue overrun");
pa_memblockq_seek(s->memblockq, (int64_t) chunk.length, PA_SEEK_RELATIVE, TRUE);
pa_memblockq_seek(s->memblockq, (int64_t) chunk.length, PA_SEEK_RELATIVE, true);
}
/* pa_log("blocks in q: %u", pa_memblockq_get_nblocks(s->memblockq)); */
@ -378,7 +378,7 @@ static int rtpoll_work_cb(pa_rtpoll_item *i) {
pa_log_debug("Requesting rewind due to end of underrun");
pa_sink_input_request_rewind(s->sink_input,
(size_t) (s->sink_input->thread_info.underrun_for == (uint64_t) -1 ? 0 : s->sink_input->thread_info.underrun_for),
FALSE, TRUE, FALSE);
false, true, false);
}
return 1;
@ -505,7 +505,7 @@ static struct session *session_new(struct userdata *u, const pa_sdp_info *sdp_in
s = pa_xnew0(struct session, 1);
s->userdata = u;
s->first_packet = FALSE;
s->first_packet = false;
s->sdp_info = *sdp_info;
s->rtpoll_item = NULL;
s->intended_latency = LATENCY_USEC;
@ -519,7 +519,7 @@ static struct session *session_new(struct userdata *u, const pa_sdp_info *sdp_in
goto fail;
pa_sink_input_new_data_init(&data);
pa_sink_input_new_data_set_sink(&data, sink, FALSE);
pa_sink_input_new_data_set_sink(&data, sink, false);
data.driver = __FILE__;
pa_proplist_sets(data.proplist, PA_PROP_MEDIA_ROLE, "stream");
pa_proplist_setf(data.proplist, PA_PROP_MEDIA_NAME,
@ -617,7 +617,7 @@ static void session_free(struct session *s) {
static void sap_event_cb(pa_mainloop_api *m, pa_io_event *e, int fd, pa_io_event_flags_t flags, void *userdata) {
struct userdata *u = userdata;
pa_bool_t goodbye = FALSE;
bool goodbye = false;
pa_sdp_info info;
struct session *s;

8
src/modules/rtp/module-rtp-send.c
View file

@ -57,7 +57,7 @@
PA_MODULE_AUTHOR("Lennart Poettering");
PA_MODULE_DESCRIPTION("Read data from source and send it to the network via RTP/SAP/SDP");
PA_MODULE_VERSION(PACKAGE_VERSION);
PA_MODULE_LOAD_ONCE(FALSE);
PA_MODULE_LOAD_ONCE(false);
PA_MODULE_USAGE(
"source=<name of the source> "
"format=<sample format> "
@ -145,7 +145,7 @@ static void source_output_kill(pa_source_output* o) {
pa_source_output_assert_ref(o);
pa_assert_se(u = o->userdata);
pa_module_unload_request(u->module, TRUE);
pa_module_unload_request(u->module, true);
pa_source_output_unlink(u->source_output);
pa_source_output_unref(u->source_output);
@ -187,7 +187,7 @@ int pa__init(pa_module*m) {
int r, j;
socklen_t k;
char hn[128], *n;
pa_bool_t loop = FALSE;
bool loop = false;
pa_source_output_new_data data;
pa_assert(m);
@ -368,7 +368,7 @@ int pa__init(pa_module*m) {
pa_proplist_setf(data.proplist, "rtp.ttl", "%lu", (unsigned long) ttl);
data.driver = __FILE__;
data.module = m;
pa_source_output_new_data_set_source(&data, s, FALSE);
pa_source_output_new_data_set_source(&data, s, false);
pa_source_output_new_data_set_sample_spec(&data, &ss);
pa_source_output_new_data_set_channel_map(&data, &cm);
data.flags = PA_SOURCE_OUTPUT_DONT_INHIBIT_AUTO_SUSPEND;

4
src/modules/rtp/rtp.c
View file

@ -170,7 +170,7 @@ int pa_rtp_recv(pa_rtp_context *c, pa_memchunk *chunk, pa_mempool *pool, struct
unsigned cc;
ssize_t r;
uint8_t aux[1024];
pa_bool_t found_tstamp = FALSE;
bool found_tstamp = false;
pa_assert(c);
pa_assert(chunk);
@ -280,7 +280,7 @@ int pa_rtp_recv(pa_rtp_context *c, pa_memchunk *chunk, pa_mempool *pool, struct
for (cm = CMSG_FIRSTHDR(&m); cm; cm = CMSG_NXTHDR(&m, cm))
if (cm->cmsg_level == SOL_SOCKET && cm->cmsg_type == SCM_TIMESTAMP) {
memcpy(tstamp, CMSG_DATA(cm), sizeof(struct timeval));
found_tstamp = TRUE;
found_tstamp = true;
break;
}

2
src/modules/rtp/rtsp_client.c
View file

@ -329,7 +329,7 @@ int pa_rtsp_connect(pa_rtsp_client *c) {
c->session = NULL;
pa_log_debug("Attempting to connect to server '%s:%d'", c->hostname, c->port);
if (!(c->sc = pa_socket_client_new_string(c->mainloop, TRUE, c->hostname, c->port))) {
if (!(c->sc = pa_socket_client_new_string(c->mainloop, true, c->hostname, c->port))) {
pa_log("failed to connect to server '%s:%d'", c->hostname, c->port);
return -1;
}

Some files were not shown because too many files have changed in this diff Show more