From d612c4e404dbd474f115ea9e2c986cb94145987a Mon Sep 17 00:00:00 2001 From: Lennart Poettering Date: Thu, 21 Aug 2008 23:16:08 +0200 Subject: Reindent to Linux kernel style The PulseAudio plugin was horrible mix-up of different indenting styles even in the same files. Indenting by 4, by 2, by 8 characters, sometimes with tabs, sometimes with spaces. To fix this chaos I ran all files through "indent -kr -i8". Hopefully future patches will follow kernel style indenting too. --- pulse/conf_pulse.c | 86 ++--- pulse/ctl_pulse.c | 1000 +++++++++++++++++++++++++++------------------------- pulse/pcm_pulse.c | 998 ++++++++++++++++++++++++++------------------------- pulse/pulse.c | 274 +++++++------- pulse/pulse.h | 43 +-- 5 files changed, 1252 insertions(+), 1149 deletions(-) (limited to 'pulse') diff --git a/pulse/conf_pulse.c b/pulse/conf_pulse.c index 6627b31..aa9a51a 100644 --- a/pulse/conf_pulse.c +++ b/pulse/conf_pulse.c @@ -28,64 +28,66 @@ /* Not actually part of the alsa api.... */ extern int -snd_config_hook_load (snd_config_t *root, snd_config_t *config, - snd_config_t **dst, snd_config_t *private_data); +snd_config_hook_load(snd_config_t * root, snd_config_t * config, + snd_config_t ** dst, snd_config_t * private_data); int -conf_pulse_hook_load_if_running (snd_config_t *root, snd_config_t *config, - snd_config_t **dst, snd_config_t *private_data) { - pa_mainloop *loop = NULL; - pa_context *context = NULL; - int ret = 0, err, state; +conf_pulse_hook_load_if_running(snd_config_t * root, snd_config_t * config, + snd_config_t ** dst, + snd_config_t * private_data) +{ + pa_mainloop *loop = NULL; + pa_context *context = NULL; + int ret = 0, err, state; - *dst = NULL; + *dst = NULL; - /* Defined if we're called inside the pulsedaemon itself */ - if (getenv("PULSE_INTERNAL") != NULL) - goto out; + /* Defined if we're called inside the pulsedaemon itself */ + if (getenv("PULSE_INTERNAL") != NULL) + goto out; - loop = pa_mainloop_new(); - if (loop == NULL) - goto out; + loop = pa_mainloop_new(); + if (loop == NULL) + goto out; - context = pa_context_new(pa_mainloop_get_api(loop), "Alsa hook"); - if (context == NULL) - goto out; + context = pa_context_new(pa_mainloop_get_api(loop), "Alsa hook"); + if (context == NULL) + goto out; - err = pa_context_connect (context, NULL, 0, NULL); - if (err < 0) - goto out; + err = pa_context_connect(context, NULL, 0, NULL); + if (err < 0) + goto out; - do { - err = pa_mainloop_prepare (loop, -1); - if (err < 0) - goto out; + do { + err = pa_mainloop_prepare(loop, -1); + if (err < 0) + goto out; - err = pa_mainloop_poll (loop); - if (err < 0) - goto out; + err = pa_mainloop_poll(loop); + if (err < 0) + goto out; - err = pa_mainloop_dispatch (loop); - if (err < 0) - goto out; + err = pa_mainloop_dispatch(loop); + if (err < 0) + goto out; - state = pa_context_get_state(context); - } while (state < PA_CONTEXT_AUTHORIZING); + state = pa_context_get_state(context); + } while (state < PA_CONTEXT_AUTHORIZING); - if (state > PA_CONTEXT_READY) - goto out; + if (state > PA_CONTEXT_READY) + goto out; - ret = snd_config_hook_load(root, config, dst, private_data); + ret = snd_config_hook_load(root, config, dst, private_data); -out: - if (context != NULL) - pa_context_unref(context); + out: + if (context != NULL) + pa_context_unref(context); - if (loop != NULL) - pa_mainloop_free(loop); + if (loop != NULL) + pa_mainloop_free(loop); - return ret; + return ret; } SND_DLSYM_BUILD_VERSION(conf_pulse_hook_load_if_running, - SND_CONFIG_DLSYM_VERSION_HOOK); + SND_CONFIG_DLSYM_VERSION_HOOK); diff --git a/pulse/ctl_pulse.c b/pulse/ctl_pulse.c index dcf2769..6fa6546 100644 --- a/pulse/ctl_pulse.c +++ b/pulse/ctl_pulse.c @@ -28,19 +28,19 @@ typedef struct snd_ctl_pulse { snd_ctl_ext_t ext; - snd_pulse_t *p; + snd_pulse_t *p; - char *source; - char *sink; + char *source; + char *sink; - pa_cvolume sink_volume; - pa_cvolume source_volume; + pa_cvolume sink_volume; + pa_cvolume source_volume; - int sink_muted; - int source_muted; + int sink_muted; + int source_muted; - int subscribed; - int updated; + int subscribed; + int updated; } snd_ctl_pulse_t; #define SOURCE_VOL_NAME "Capture Volume" @@ -53,534 +53,566 @@ typedef struct snd_ctl_pulse { #define UPDATE_SOURCE_VOL 0x04 #define UPDATE_SOURCE_MUTE 0x08 -static void sink_info_cb(pa_context *c, const pa_sink_info *i, int is_last, void *userdata) +static void sink_info_cb(pa_context * c, const pa_sink_info * i, + int is_last, void *userdata) { - snd_ctl_pulse_t *ctl = (snd_ctl_pulse_t*)userdata; - int chan; + snd_ctl_pulse_t *ctl = (snd_ctl_pulse_t *) userdata; + int chan; - assert(ctl); + assert(ctl); - if (is_last) { - pa_threaded_mainloop_signal(ctl->p->mainloop, 0); - return; - } + if (is_last) { + pa_threaded_mainloop_signal(ctl->p->mainloop, 0); + return; + } - assert(i); + assert(i); - if (!!ctl->sink_muted != !!i->mute) { - ctl->sink_muted = i->mute; - ctl->updated |= UPDATE_SINK_MUTE; - pulse_poll_activate(ctl->p); - } + if (!!ctl->sink_muted != !!i->mute) { + ctl->sink_muted = i->mute; + ctl->updated |= UPDATE_SINK_MUTE; + pulse_poll_activate(ctl->p); + } - if (ctl->sink_volume.channels == i->volume.channels) { - for (chan = 0;chan < ctl->sink_volume.channels;chan++) - if (i->volume.values[chan] != ctl->sink_volume.values[chan]) - break; + if (ctl->sink_volume.channels == i->volume.channels) { + for (chan = 0; chan < ctl->sink_volume.channels; chan++) + if (i->volume.values[chan] != + ctl->sink_volume.values[chan]) + break; - if (chan == ctl->sink_volume.channels) - return; + if (chan == ctl->sink_volume.channels) + return; - ctl->updated |= UPDATE_SINK_VOL; - pulse_poll_activate(ctl->p); - } + ctl->updated |= UPDATE_SINK_VOL; + pulse_poll_activate(ctl->p); + } - memcpy(&ctl->sink_volume, &i->volume, sizeof(pa_cvolume)); + memcpy(&ctl->sink_volume, &i->volume, sizeof(pa_cvolume)); } -static void source_info_cb(pa_context *c, const pa_source_info *i, int is_last, void *userdata) +static void source_info_cb(pa_context * c, const pa_source_info * i, + int is_last, void *userdata) { - snd_ctl_pulse_t *ctl = (snd_ctl_pulse_t*)userdata; - int chan; + snd_ctl_pulse_t *ctl = (snd_ctl_pulse_t *) userdata; + int chan; - assert(ctl); + assert(ctl); - if (is_last) { - pa_threaded_mainloop_signal(ctl->p->mainloop, 0); - return; - } + if (is_last) { + pa_threaded_mainloop_signal(ctl->p->mainloop, 0); + return; + } - assert(i); + assert(i); - if (!!ctl->source_muted != !!i->mute) { - ctl->source_muted = i->mute; - ctl->updated |= UPDATE_SOURCE_MUTE; - pulse_poll_activate(ctl->p); - } + if (!!ctl->source_muted != !!i->mute) { + ctl->source_muted = i->mute; + ctl->updated |= UPDATE_SOURCE_MUTE; + pulse_poll_activate(ctl->p); + } - if (ctl->source_volume.channels == i->volume.channels) { - for (chan = 0;chan < ctl->source_volume.channels;chan++) - if (i->volume.values[chan] != ctl->source_volume.values[chan]) - break; + if (ctl->source_volume.channels == i->volume.channels) { + for (chan = 0; chan < ctl->source_volume.channels; chan++) + if (i->volume.values[chan] != + ctl->source_volume.values[chan]) + break; - if (chan == ctl->source_volume.channels) - return; + if (chan == ctl->source_volume.channels) + return; - ctl->updated |= UPDATE_SOURCE_VOL; - pulse_poll_activate(ctl->p); - } + ctl->updated |= UPDATE_SOURCE_VOL; + pulse_poll_activate(ctl->p); + } - memcpy(&ctl->source_volume, &i->volume, sizeof(pa_cvolume)); + memcpy(&ctl->source_volume, &i->volume, sizeof(pa_cvolume)); } -static void event_cb(pa_context *c, pa_subscription_event_type_t t, - uint32_t index, void *userdata) +static void event_cb(pa_context * c, pa_subscription_event_type_t t, + uint32_t index, void *userdata) { - snd_ctl_pulse_t *ctl = (snd_ctl_pulse_t*)userdata; - pa_operation *o; + snd_ctl_pulse_t *ctl = (snd_ctl_pulse_t *) userdata; + pa_operation *o; - assert(ctl && ctl->p && ctl->p->context); + assert(ctl && ctl->p && ctl->p->context); - o = pa_context_get_sink_info_by_name(ctl->p->context, ctl->sink, - sink_info_cb, ctl); - pa_operation_unref(o); + o = pa_context_get_sink_info_by_name(ctl->p->context, ctl->sink, + sink_info_cb, ctl); + pa_operation_unref(o); - o = pa_context_get_source_info_by_name(ctl->p->context, ctl->source, - source_info_cb, ctl); - pa_operation_unref(o); + o = pa_context_get_source_info_by_name(ctl->p->context, + ctl->source, source_info_cb, + ctl); + pa_operation_unref(o); } -static int pulse_update_volume(snd_ctl_pulse_t *ctl) +static int pulse_update_volume(snd_ctl_pulse_t * ctl) { - int err; - pa_operation *o; - - assert(ctl && ctl->p && ctl->p->context); - - o = pa_context_get_sink_info_by_name(ctl->p->context, ctl->sink, - sink_info_cb, ctl); - err = pulse_wait_operation(ctl->p, o); - pa_operation_unref(o); - if (err < 0) - return err; - - o = pa_context_get_source_info_by_name(ctl->p->context, ctl->source, - source_info_cb, ctl); - err = pulse_wait_operation(ctl->p, o); - pa_operation_unref(o); - if (err < 0) - return err; - - return 0; + int err; + pa_operation *o; + + assert(ctl && ctl->p && ctl->p->context); + + o = pa_context_get_sink_info_by_name(ctl->p->context, ctl->sink, + sink_info_cb, ctl); + err = pulse_wait_operation(ctl->p, o); + pa_operation_unref(o); + if (err < 0) + return err; + + o = pa_context_get_source_info_by_name(ctl->p->context, + ctl->source, source_info_cb, + ctl); + err = pulse_wait_operation(ctl->p, o); + pa_operation_unref(o); + if (err < 0) + return err; + + return 0; } -static int pulse_elem_count(snd_ctl_ext_t *ext) +static int pulse_elem_count(snd_ctl_ext_t * ext) { - snd_ctl_pulse_t *ctl = ext->private_data; - int count = 0; + snd_ctl_pulse_t *ctl = ext->private_data; + int count = 0; - assert(ctl); + assert(ctl); - pa_threaded_mainloop_lock(ctl->p->mainloop); + pa_threaded_mainloop_lock(ctl->p->mainloop); - if (ctl->source) - count += 2; - if (ctl->sink) - count += 2; + if (ctl->source) + count += 2; + if (ctl->sink) + count += 2; - pa_threaded_mainloop_unlock(ctl->p->mainloop); + pa_threaded_mainloop_unlock(ctl->p->mainloop); - return count; + return count; } -static int pulse_elem_list(snd_ctl_ext_t *ext, unsigned int offset, - snd_ctl_elem_id_t *id) +static int pulse_elem_list(snd_ctl_ext_t * ext, unsigned int offset, + snd_ctl_elem_id_t * id) { - snd_ctl_pulse_t *ctl = ext->private_data; + snd_ctl_pulse_t *ctl = ext->private_data; - assert(ctl); + assert(ctl); - snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER); + snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER); - pa_threaded_mainloop_lock(ctl->p->mainloop); + pa_threaded_mainloop_lock(ctl->p->mainloop); - if (ctl->source) { - if (offset == 0) - snd_ctl_elem_id_set_name(id, SOURCE_VOL_NAME); - else if (offset == 1) - snd_ctl_elem_id_set_name(id, SOURCE_MUTE_NAME); - } else - offset += 2; + if (ctl->source) { + if (offset == 0) + snd_ctl_elem_id_set_name(id, SOURCE_VOL_NAME); + else if (offset == 1) + snd_ctl_elem_id_set_name(id, SOURCE_MUTE_NAME); + } else + offset += 2; - pa_threaded_mainloop_unlock(ctl->p->mainloop); + pa_threaded_mainloop_unlock(ctl->p->mainloop); - if (offset == 2) - snd_ctl_elem_id_set_name(id, SINK_VOL_NAME); - else if (offset == 3) - snd_ctl_elem_id_set_name(id, SINK_MUTE_NAME); + if (offset == 2) + snd_ctl_elem_id_set_name(id, SINK_VOL_NAME); + else if (offset == 3) + snd_ctl_elem_id_set_name(id, SINK_MUTE_NAME); - return 0; + return 0; } -static snd_ctl_ext_key_t pulse_find_elem(snd_ctl_ext_t *ext, - const snd_ctl_elem_id_t *id) +static snd_ctl_ext_key_t pulse_find_elem(snd_ctl_ext_t * ext, + const snd_ctl_elem_id_t * id) { - const char *name; + const char *name; - name = snd_ctl_elem_id_get_name(id); + name = snd_ctl_elem_id_get_name(id); - if (strcmp(name, SOURCE_VOL_NAME) == 0) - return 0; - if (strcmp(name, SOURCE_MUTE_NAME) == 0) - return 1; - if (strcmp(name, SINK_VOL_NAME) == 0) - return 2; - if (strcmp(name, SINK_MUTE_NAME) == 0) - return 3; + if (strcmp(name, SOURCE_VOL_NAME) == 0) + return 0; + if (strcmp(name, SOURCE_MUTE_NAME) == 0) + return 1; + if (strcmp(name, SINK_VOL_NAME) == 0) + return 2; + if (strcmp(name, SINK_MUTE_NAME) == 0) + return 3; - return SND_CTL_EXT_KEY_NOT_FOUND; + return SND_CTL_EXT_KEY_NOT_FOUND; } -static int pulse_get_attribute(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key, - int *type, unsigned int *acc, unsigned int *count) +static int pulse_get_attribute(snd_ctl_ext_t * ext, snd_ctl_ext_key_t key, + int *type, unsigned int *acc, + unsigned int *count) { - snd_ctl_pulse_t *ctl = ext->private_data; - int err = 0; + snd_ctl_pulse_t *ctl = ext->private_data; + int err = 0; - if (key > 3) - return -EINVAL; + if (key > 3) + return -EINVAL; - assert(ctl); - assert(ctl->p); + assert(ctl); + assert(ctl->p); - pa_threaded_mainloop_lock(ctl->p->mainloop); + pa_threaded_mainloop_lock(ctl->p->mainloop); - err = pulse_check_connection(ctl->p); - if (err < 0) - goto finish; + err = pulse_check_connection(ctl->p); + if (err < 0) + goto finish; - err = pulse_update_volume(ctl); - if (err < 0) - goto finish; + err = pulse_update_volume(ctl); + if (err < 0) + goto finish; - if (key & 1) - *type = SND_CTL_ELEM_TYPE_BOOLEAN; - else - *type = SND_CTL_ELEM_TYPE_INTEGER; + if (key & 1) + *type = SND_CTL_ELEM_TYPE_BOOLEAN; + else + *type = SND_CTL_ELEM_TYPE_INTEGER; - *acc = SND_CTL_EXT_ACCESS_READWRITE; + *acc = SND_CTL_EXT_ACCESS_READWRITE; - if (key == 0) - *count = ctl->source_volume.channels; - else if (key == 2) - *count = ctl->sink_volume.channels; - else - *count = 1; + if (key == 0) + *count = ctl->source_volume.channels; + else if (key == 2) + *count = ctl->sink_volume.channels; + else + *count = 1; -finish: - pa_threaded_mainloop_unlock(ctl->p->mainloop); + finish: + pa_threaded_mainloop_unlock(ctl->p->mainloop); - return err; + return err; } -static int pulse_get_integer_info(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key, - long *imin, long *imax, long *istep) +static int pulse_get_integer_info(snd_ctl_ext_t * ext, + snd_ctl_ext_key_t key, long *imin, + long *imax, long *istep) { - *istep = 1; - *imin = 0; - *imax = PA_VOLUME_NORM; + *istep = 1; + *imin = 0; + *imax = PA_VOLUME_NORM; - return 0; + return 0; } -static int pulse_read_integer(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key, - long *value) +static int pulse_read_integer(snd_ctl_ext_t * ext, snd_ctl_ext_key_t key, + long *value) { - snd_ctl_pulse_t *ctl = ext->private_data; - int err = 0, i; - pa_cvolume *vol = NULL; - - assert(ctl); - assert(ctl->p); - - pa_threaded_mainloop_lock(ctl->p->mainloop); - - err = pulse_check_connection(ctl->p); - if (err < 0) - goto finish; - - err = pulse_update_volume(ctl); - if (err < 0) - goto finish; - - switch (key) { - case 0: - vol = &ctl->source_volume; - break; - case 1: - *value = !ctl->source_muted; - break; - case 2: - vol = &ctl->sink_volume; - break; - case 3: - *value = !ctl->sink_muted; - break; - default: - err = -EINVAL; - goto finish; - } - - if (vol) { - for (i = 0;i < vol->channels;i++) - value[i] = vol->values[i]; - } - -finish: - pa_threaded_mainloop_unlock(ctl->p->mainloop); - - return err; -} + snd_ctl_pulse_t *ctl = ext->private_data; + int err = 0, i; + pa_cvolume *vol = NULL; + + assert(ctl); + assert(ctl->p); + + pa_threaded_mainloop_lock(ctl->p->mainloop); + + err = pulse_check_connection(ctl->p); + if (err < 0) + goto finish; + + err = pulse_update_volume(ctl); + if (err < 0) + goto finish; + + switch (key) { + case 0: + vol = &ctl->source_volume; + break; + case 1: + *value = !ctl->source_muted; + break; + case 2: + vol = &ctl->sink_volume; + break; + case 3: + *value = !ctl->sink_muted; + break; + default: + err = -EINVAL; + goto finish; + } -static int pulse_write_integer(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key, - long *value) -{ - snd_ctl_pulse_t *ctl = ext->private_data; - int err = 0, i; - pa_operation *o; - pa_cvolume *vol = NULL; - - assert(ctl); - assert(ctl->p && ctl->p->context); - - pa_threaded_mainloop_lock(ctl->p->mainloop); - - err = pulse_check_connection(ctl->p); - if (err < 0) - goto finish; - - err = pulse_update_volume(ctl); - if (err < 0) - goto finish; - - switch (key) { - case 0: - vol = &ctl->source_volume; - break; - case 1: - if (!!ctl->source_muted == !*value) - goto finish; - ctl->source_muted = !*value; - break; - case 2: - vol = &ctl->sink_volume; - break; - case 3: - if (!!ctl->sink_muted == !*value) - goto finish; - ctl->sink_muted = !*value; - break; - default: - err = -EINVAL; - goto finish; - } - - if (vol) { - for (i = 0;i < vol->channels;i++) - if (value[i] != vol->values[i]) - break; - - if (i == vol->channels) - goto finish; - - for (i = 0;i < vol->channels;i++) - vol->values[i] = value[i]; - - if (key == 0) - o = pa_context_set_source_volume_by_name(ctl->p->context, - ctl->source, vol, pulse_context_success_cb, ctl->p); - else - o = pa_context_set_sink_volume_by_name(ctl->p->context, - ctl->sink, vol, pulse_context_success_cb, ctl->p); - } else { - if (key == 1) - o = pa_context_set_source_mute_by_name(ctl->p->context, - ctl->source, ctl->source_muted, pulse_context_success_cb, ctl->p); - else - o = pa_context_set_sink_mute_by_name(ctl->p->context, - ctl->sink, ctl->sink_muted, pulse_context_success_cb, ctl->p); - } - - err = pulse_wait_operation(ctl->p, o); - pa_operation_unref(o); - if (err < 0) - goto finish; - - err = 1; - -finish: - pa_threaded_mainloop_unlock(ctl->p->mainloop); - - return err; + if (vol) { + for (i = 0; i < vol->channels; i++) + value[i] = vol->values[i]; + } + + finish: + pa_threaded_mainloop_unlock(ctl->p->mainloop); + + return err; } -static void pulse_subscribe_events(snd_ctl_ext_t *ext, int subscribe) +static int pulse_write_integer(snd_ctl_ext_t * ext, snd_ctl_ext_key_t key, + long *value) { - snd_ctl_pulse_t *ctl = ext->private_data; + snd_ctl_pulse_t *ctl = ext->private_data; + int err = 0, i; + pa_operation *o; + pa_cvolume *vol = NULL; + + assert(ctl); + assert(ctl->p && ctl->p->context); + + pa_threaded_mainloop_lock(ctl->p->mainloop); + + err = pulse_check_connection(ctl->p); + if (err < 0) + goto finish; + + err = pulse_update_volume(ctl); + if (err < 0) + goto finish; + + switch (key) { + case 0: + vol = &ctl->source_volume; + break; + case 1: + if (!!ctl->source_muted == !*value) + goto finish; + ctl->source_muted = !*value; + break; + case 2: + vol = &ctl->sink_volume; + break; + case 3: + if (!!ctl->sink_muted == !*value) + goto finish; + ctl->sink_muted = !*value; + break; + default: + err = -EINVAL; + goto finish; + } + + if (vol) { + for (i = 0; i < vol->channels; i++) + if (value[i] != vol->values[i]) + break; + + if (i == vol->channels) + goto finish; + + for (i = 0; i < vol->channels; i++) + vol->values[i] = value[i]; + + if (key == 0) + o = pa_context_set_source_volume_by_name(ctl->p-> + context, + ctl-> + source, + vol, + pulse_context_success_cb, + ctl->p); + else + o = pa_context_set_sink_volume_by_name(ctl->p-> + context, + ctl->sink, + vol, + pulse_context_success_cb, + ctl->p); + } else { + if (key == 1) + o = pa_context_set_source_mute_by_name(ctl->p-> + context, + ctl->source, + ctl-> + source_muted, + pulse_context_success_cb, + ctl->p); + else + o = pa_context_set_sink_mute_by_name(ctl->p-> + context, + ctl->sink, + ctl-> + sink_muted, + pulse_context_success_cb, + ctl->p); + } - assert(ctl); + err = pulse_wait_operation(ctl->p, o); + pa_operation_unref(o); + if (err < 0) + goto finish; - pa_threaded_mainloop_lock(ctl->p->mainloop); + err = 1; - ctl->subscribed = !!(subscribe & SND_CTL_EVENT_MASK_VALUE); + finish: + pa_threaded_mainloop_unlock(ctl->p->mainloop); - pa_threaded_mainloop_unlock(ctl->p->mainloop); + return err; } -static int pulse_read_event(snd_ctl_ext_t *ext, snd_ctl_elem_id_t *id, - unsigned int *event_mask) +static void pulse_subscribe_events(snd_ctl_ext_t * ext, int subscribe) { - snd_ctl_pulse_t *ctl = ext->private_data; - int offset; - int err = -EAGAIN; + snd_ctl_pulse_t *ctl = ext->private_data; - assert(ctl); + assert(ctl); - pa_threaded_mainloop_lock(ctl->p->mainloop); + pa_threaded_mainloop_lock(ctl->p->mainloop); - if (!ctl->updated || !ctl->subscribed) - goto finish; + ctl->subscribed = !!(subscribe & SND_CTL_EVENT_MASK_VALUE); - if (ctl->source) - offset = 2; - else - offset = 0; + pa_threaded_mainloop_unlock(ctl->p->mainloop); +} - if (ctl->updated & UPDATE_SOURCE_VOL) { - pulse_elem_list(ext, 0, id); - ctl->updated &= ~UPDATE_SOURCE_VOL; - } else if (ctl->updated & UPDATE_SOURCE_MUTE) { - pulse_elem_list(ext, 1, id); - ctl->updated &= ~UPDATE_SOURCE_MUTE; - } else if (ctl->updated & UPDATE_SINK_VOL) { - pulse_elem_list(ext, offset + 0, id); - ctl->updated &= ~UPDATE_SINK_VOL; - } else if (ctl->updated & UPDATE_SINK_MUTE) { - pulse_elem_list(ext, offset + 1, id); - ctl->updated &= ~UPDATE_SINK_MUTE; - } +static int pulse_read_event(snd_ctl_ext_t * ext, snd_ctl_elem_id_t * id, + unsigned int *event_mask) +{ + snd_ctl_pulse_t *ctl = ext->private_data; + int offset; + int err = -EAGAIN; + + assert(ctl); + + pa_threaded_mainloop_lock(ctl->p->mainloop); + + if (!ctl->updated || !ctl->subscribed) + goto finish; + + if (ctl->source) + offset = 2; + else + offset = 0; + + if (ctl->updated & UPDATE_SOURCE_VOL) { + pulse_elem_list(ext, 0, id); + ctl->updated &= ~UPDATE_SOURCE_VOL; + } else if (ctl->updated & UPDATE_SOURCE_MUTE) { + pulse_elem_list(ext, 1, id); + ctl->updated &= ~UPDATE_SOURCE_MUTE; + } else if (ctl->updated & UPDATE_SINK_VOL) { + pulse_elem_list(ext, offset + 0, id); + ctl->updated &= ~UPDATE_SINK_VOL; + } else if (ctl->updated & UPDATE_SINK_MUTE) { + pulse_elem_list(ext, offset + 1, id); + ctl->updated &= ~UPDATE_SINK_MUTE; + } - *event_mask = SND_CTL_EVENT_MASK_VALUE; + *event_mask = SND_CTL_EVENT_MASK_VALUE; - if (!ctl->updated) - pulse_poll_deactivate(ctl->p); + if (!ctl->updated) + pulse_poll_deactivate(ctl->p); - err = 1; + err = 1; -finish: - pa_threaded_mainloop_unlock(ctl->p->mainloop); + finish: + pa_threaded_mainloop_unlock(ctl->p->mainloop); - return err; + return err; } -static int pulse_ctl_poll_descriptors_count(snd_ctl_ext_t *ext) +static int pulse_ctl_poll_descriptors_count(snd_ctl_ext_t * ext) { snd_ctl_pulse_t *ctl = ext->private_data; int count; - assert(ctl); - assert(ctl->p); + assert(ctl); + assert(ctl->p); - pa_threaded_mainloop_lock(ctl->p->mainloop); + pa_threaded_mainloop_lock(ctl->p->mainloop); - count = pulse_poll_descriptors_count(ctl->p); + count = pulse_poll_descriptors_count(ctl->p); - pa_threaded_mainloop_unlock(ctl->p->mainloop); + pa_threaded_mainloop_unlock(ctl->p->mainloop); - return count; + return count; } -static int pulse_ctl_poll_descriptors(snd_ctl_ext_t *ext, struct pollfd *pfd, unsigned int space) +static int pulse_ctl_poll_descriptors(snd_ctl_ext_t * ext, + struct pollfd *pfd, + unsigned int space) { - int num; + int num; snd_ctl_pulse_t *ctl = ext->private_data; - assert(ctl); - assert(ctl->p); + assert(ctl); + assert(ctl->p); - pa_threaded_mainloop_lock(ctl->p->mainloop); + pa_threaded_mainloop_lock(ctl->p->mainloop); - num = pulse_poll_descriptors(ctl->p, pfd, space); - if (num < 0) - goto finish; + num = pulse_poll_descriptors(ctl->p, pfd, space); + if (num < 0) + goto finish; -finish: - pa_threaded_mainloop_unlock(ctl->p->mainloop); + finish: + pa_threaded_mainloop_unlock(ctl->p->mainloop); - return num; + return num; } -static int pulse_ctl_poll_revents(snd_ctl_ext_t *ext, struct pollfd *pfd, unsigned int nfds, unsigned short *revents) +static int pulse_ctl_poll_revents(snd_ctl_ext_t * ext, struct pollfd *pfd, + unsigned int nfds, + unsigned short *revents) { snd_ctl_pulse_t *ctl = ext->private_data; int err = 0; - assert(ctl); - assert(ctl->p); + assert(ctl); + assert(ctl->p); - pa_threaded_mainloop_lock(ctl->p->mainloop); + pa_threaded_mainloop_lock(ctl->p->mainloop); - err = pulse_poll_revents(ctl->p, pfd, nfds, revents); - if (err < 0) - goto finish; + err = pulse_poll_revents(ctl->p, pfd, nfds, revents); + if (err < 0) + goto finish; - *revents = 0; + *revents = 0; - if (ctl->updated) - *revents |= POLLIN; + if (ctl->updated) + *revents |= POLLIN; -finish: - pa_threaded_mainloop_unlock(ctl->p->mainloop); + finish: + pa_threaded_mainloop_unlock(ctl->p->mainloop); - return err; + return err; } -static void pulse_close(snd_ctl_ext_t *ext) +static void pulse_close(snd_ctl_ext_t * ext) { - snd_ctl_pulse_t *ctl = ext->private_data; + snd_ctl_pulse_t *ctl = ext->private_data; - assert(ctl); + assert(ctl); - if (ctl->p) - pulse_free(ctl->p); + if (ctl->p) + pulse_free(ctl->p); - if (ctl->source) - free(ctl->source); - if (ctl->sink) - free(ctl->sink); + if (ctl->source) + free(ctl->source); + if (ctl->sink) + free(ctl->sink); free(ctl); } static snd_ctl_ext_callback_t pulse_ext_callback = { - .elem_count = pulse_elem_count, - .elem_list = pulse_elem_list, - .find_elem = pulse_find_elem, - .get_attribute = pulse_get_attribute, - .get_integer_info = pulse_get_integer_info, - .read_integer = pulse_read_integer, - .write_integer = pulse_write_integer, - .subscribe_events = pulse_subscribe_events, - .read_event = pulse_read_event, - .poll_descriptors_count = pulse_ctl_poll_descriptors_count, - .poll_descriptors = pulse_ctl_poll_descriptors, - .poll_revents = pulse_ctl_poll_revents, - .close = pulse_close, + .elem_count = pulse_elem_count, + .elem_list = pulse_elem_list, + .find_elem = pulse_find_elem, + .get_attribute = pulse_get_attribute, + .get_integer_info = pulse_get_integer_info, + .read_integer = pulse_read_integer, + .write_integer = pulse_write_integer, + .subscribe_events = pulse_subscribe_events, + .read_event = pulse_read_event, + .poll_descriptors_count = pulse_ctl_poll_descriptors_count, + .poll_descriptors = pulse_ctl_poll_descriptors, + .poll_revents = pulse_ctl_poll_revents, + .close = pulse_close, }; -static void server_info_cb(pa_context *c, const pa_server_info*i, void *userdata) +static void server_info_cb(pa_context * c, const pa_server_info * i, + void *userdata) { - snd_ctl_pulse_t *ctl = (snd_ctl_pulse_t*)userdata; + snd_ctl_pulse_t *ctl = (snd_ctl_pulse_t *) userdata; - assert(ctl && i); + assert(ctl && i); - if (i->default_source_name && !ctl->source) - ctl->source = strdup(i->default_source_name); - if (i->default_sink_name && !ctl->sink) - ctl->sink = strdup(i->default_sink_name); + if (i->default_source_name && !ctl->source) + ctl->source = strdup(i->default_source_name); + if (i->default_sink_name && !ctl->sink) + ctl->sink = strdup(i->default_sink_name); - pa_threaded_mainloop_signal(ctl->p->mainloop, 0); + pa_threaded_mainloop_signal(ctl->p->mainloop, 0); } SND_CTL_PLUGIN_DEFINE_FUNC(pulse) @@ -592,127 +624,133 @@ SND_CTL_PLUGIN_DEFINE_FUNC(pulse) const char *sink = NULL; int err; snd_ctl_pulse_t *ctl; - pa_operation *o; + pa_operation *o; snd_config_for_each(i, next, conf) { snd_config_t *n = snd_config_iterator_entry(i); const char *id; if (snd_config_get_id(n, &id) < 0) continue; - if (strcmp(id, "comment") == 0 || strcmp(id, "type") == 0 || strcmp(id, "hint") == 0) + if (strcmp(id, "comment") == 0 || strcmp(id, "type") == 0 + || strcmp(id, "hint") == 0) + continue; + if (strcmp(id, "server") == 0) { + if (snd_config_get_string(n, &server) < 0) { + SNDERR("Invalid type for %s", id); + return -EINVAL; + } continue; - if (strcmp(id, "server") == 0) { - if (snd_config_get_string(n, &server) < 0) { - SNDERR("Invalid type for %s", id); - return -EINVAL; - } - continue; - } - if (strcmp(id, "device") == 0) { - if (snd_config_get_string(n, &device) < 0) { - SNDERR("Invalid type for %s", id); - return -EINVAL; - } - continue; - } - if (strcmp(id, "source") == 0) { - if (snd_config_get_string(n, &source) < 0) { - SNDERR("Invalid type for %s", id); - return -EINVAL; - } - continue; - } - if (strcmp(id, "sink") == 0) { - if (snd_config_get_string(n, &sink) < 0) { - SNDERR("Invalid type for %s", id); - return -EINVAL; - } - continue; - } + } + if (strcmp(id, "device") == 0) { + if (snd_config_get_string(n, &device) < 0) { + SNDERR("Invalid type for %s", id); + return -EINVAL; + } + continue; + } + if (strcmp(id, "source") == 0) { + if (snd_config_get_string(n, &source) < 0) { + SNDERR("Invalid type for %s", id); + return -EINVAL; + } + continue; + } + if (strcmp(id, "sink") == 0) { + if (snd_config_get_string(n, &sink) < 0) { + SNDERR("Invalid type for %s", id); + return -EINVAL; + } + continue; + } SNDERR("Unknown field %s", id); return -EINVAL; } ctl = calloc(1, sizeof(*ctl)); - ctl->p = pulse_new(); - if (!ctl->p) { - err = -EIO; - goto error; - } + ctl->p = pulse_new(); + if (!ctl->p) { + err = -EIO; + goto error; + } - err = pulse_connect(ctl->p, server); - if (err < 0) - goto error; + err = pulse_connect(ctl->p, server); + if (err < 0) + goto error; - if (source) - ctl->source = strdup(source); - else if (device) - ctl->source = strdup(device); + if (source) + ctl->source = strdup(source); + else if (device) + ctl->source = strdup(device); - if (sink) - ctl->sink = strdup(sink); - else if (device) - ctl->sink = strdup(device); + if (sink) + ctl->sink = strdup(sink); + else if (device) + ctl->sink = strdup(device); - if (!ctl->source || !ctl->sink) { - pa_threaded_mainloop_lock(ctl->p->mainloop); + if (!ctl->source || !ctl->sink) { + pa_threaded_mainloop_lock(ctl->p->mainloop); - o = pa_context_get_server_info(ctl->p->context, server_info_cb, ctl); - err = pulse_wait_operation(ctl->p, o); + o = pa_context_get_server_info(ctl->p->context, + server_info_cb, ctl); + err = pulse_wait_operation(ctl->p, o); - pa_operation_unref(o); + pa_operation_unref(o); - pa_threaded_mainloop_unlock(ctl->p->mainloop); + pa_threaded_mainloop_unlock(ctl->p->mainloop); - if (err < 0) - goto error; - } + if (err < 0) + goto error; + } - pa_threaded_mainloop_lock(ctl->p->mainloop); + pa_threaded_mainloop_lock(ctl->p->mainloop); - pa_context_set_subscribe_callback(ctl->p->context, event_cb, ctl); + pa_context_set_subscribe_callback(ctl->p->context, event_cb, ctl); - o = pa_context_subscribe(ctl->p->context, - PA_SUBSCRIPTION_MASK_SINK | PA_SUBSCRIPTION_MASK_SOURCE, - pulse_context_success_cb, ctl->p); + o = pa_context_subscribe(ctl->p->context, + PA_SUBSCRIPTION_MASK_SINK | + PA_SUBSCRIPTION_MASK_SOURCE, + pulse_context_success_cb, ctl->p); - err = pulse_wait_operation(ctl->p, o); + err = pulse_wait_operation(ctl->p, o); - pa_operation_unref(o); + pa_operation_unref(o); - pa_threaded_mainloop_unlock(ctl->p->mainloop); + pa_threaded_mainloop_unlock(ctl->p->mainloop); - if (err < 0) - goto error; + if (err < 0) + goto error; - ctl->ext.version = SND_CTL_EXT_VERSION; - ctl->ext.card_idx = 0; - strncpy(ctl->ext.id, "pulse", sizeof(ctl->ext.id) - 1); - strncpy(ctl->ext.driver, "PulseAudio plugin", sizeof(ctl->ext.driver) - 1); - strncpy(ctl->ext.name, "PulseAudio", sizeof(ctl->ext.name) - 1); - strncpy(ctl->ext.longname, "PulseAudio", sizeof(ctl->ext.longname) - 1); - strncpy(ctl->ext.mixername, "PulseAudio", sizeof(ctl->ext.mixername) - 1); - ctl->ext.poll_fd = -1; - ctl->ext.callback = &pulse_ext_callback; - ctl->ext.private_data = ctl; + ctl->ext.version = SND_CTL_EXT_VERSION; + ctl->ext.card_idx = 0; + strncpy(ctl->ext.id, "pulse", sizeof(ctl->ext.id) - 1); + strncpy(ctl->ext.driver, "PulseAudio plugin", + sizeof(ctl->ext.driver) - 1); + strncpy(ctl->ext.name, "PulseAudio", sizeof(ctl->ext.name) - 1); + strncpy(ctl->ext.longname, "PulseAudio", + sizeof(ctl->ext.longname) - 1); + strncpy(ctl->ext.mixername, "PulseAudio", + sizeof(ctl->ext.mixername) - 1); + ctl->ext.poll_fd = -1; + ctl->ext.callback = &pulse_ext_callback; + ctl->ext.private_data = ctl; - err = snd_ctl_ext_create(&ctl->ext, name, mode); - if (err < 0) - goto error; + err = snd_ctl_ext_create(&ctl->ext, name, mode); + if (err < 0) + goto error; - *handlep = ctl->ext.handle; + *handlep = ctl->ext.handle; - return 0; + return 0; -error: - if (ctl->source) - free(ctl->source); - if (ctl->sink) - free(ctl->sink); + error: + if (ctl->source) + free(ctl->source); + if (ctl->sink) + free(ctl->sink); - if (ctl->p) - pulse_free(ctl->p); + if (ctl->p) + pulse_free(ctl->p); free(ctl); diff --git a/pulse/pcm_pulse.c b/pulse/pcm_pulse.c index 7edd157..8743a02 100644 --- a/pulse/pcm_pulse.c +++ b/pulse/pcm_pulse.c @@ -29,366 +29,377 @@ typedef struct snd_pcm_pulse { snd_pcm_ioplug_t io; - snd_pulse_t *p; + snd_pulse_t *p; - char *device; + char *device; - /* Since ALSA expects a ring buffer we must do some voodoo. */ - size_t last_size; - size_t ptr; - int underrun; + /* Since ALSA expects a ring buffer we must do some voodoo. */ + size_t last_size; + size_t ptr; + int underrun; - size_t offset; + size_t offset; - pa_stream *stream; + pa_stream *stream; - pa_sample_spec ss; - unsigned int frame_size; - pa_buffer_attr buffer_attr; + pa_sample_spec ss; + unsigned int frame_size; + pa_buffer_attr buffer_attr; } snd_pcm_pulse_t; -static void update_ptr(snd_pcm_pulse_t *pcm) +static void update_ptr(snd_pcm_pulse_t * pcm) { - size_t size; + size_t size; - if (pcm->io.stream == SND_PCM_STREAM_PLAYBACK) - size = pa_stream_writable_size(pcm->stream); - else - size = pa_stream_readable_size(pcm->stream) - pcm->offset; + if (pcm->io.stream == SND_PCM_STREAM_PLAYBACK) + size = pa_stream_writable_size(pcm->stream); + else + size = pa_stream_readable_size(pcm->stream) - pcm->offset; - if (size > pcm->last_size) { - pcm->ptr += size - pcm->last_size; - pcm->ptr %= pcm->buffer_attr.tlength; - } + if (size > pcm->last_size) { + pcm->ptr += size - pcm->last_size; + pcm->ptr %= pcm->buffer_attr.tlength; + } - pcm->last_size = size; + pcm->last_size = size; } -static int pulse_start(snd_pcm_ioplug_t *io) +static int pulse_start(snd_pcm_ioplug_t * io) { snd_pcm_pulse_t *pcm = io->private_data; pa_operation *o, *u; int err = 0, err_o = 0, err_u = 0; - assert(pcm); - assert(pcm->p); + assert(pcm); + assert(pcm->p); - if (pcm->stream == NULL) - return 0; + if (pcm->stream == NULL) + return 0; - pa_threaded_mainloop_lock(pcm->p->mainloop); + pa_threaded_mainloop_lock(pcm->p->mainloop); - err = pulse_check_connection(pcm->p); - if (err < 0) - goto finish; + err = pulse_check_connection(pcm->p); + if (err < 0) + goto finish; - o = pa_stream_cork(pcm->stream, 0, pulse_stream_success_cb, pcm->p); - if (!o) { - err = -EIO; - goto finish; - } + o = pa_stream_cork(pcm->stream, 0, pulse_stream_success_cb, + pcm->p); + if (!o) { + err = -EIO; + goto finish; + } - u = pa_stream_trigger(pcm->stream, pulse_stream_success_cb, pcm->p); - if (!u) { - pa_operation_unref(o); - err = -EIO; - goto finish; - } + u = pa_stream_trigger(pcm->stream, pulse_stream_success_cb, + pcm->p); + if (!u) { + pa_operation_unref(o); + err = -EIO; + goto finish; + } - err_o = pulse_wait_operation(pcm->p, o); - err_u = pulse_wait_operation(pcm->p, u); + err_o = pulse_wait_operation(pcm->p, o); + err_u = pulse_wait_operation(pcm->p, u); - pa_operation_unref(o); - pa_operation_unref(u); + pa_operation_unref(o); + pa_operation_unref(u); - if (err_o < 0 || err_u < 0) { - err = -EIO; - goto finish; - } else - pcm->underrun = 0; + if (err_o < 0 || err_u < 0) { + err = -EIO; + goto finish; + } else + pcm->underrun = 0; -finish: - pa_threaded_mainloop_unlock(pcm->p->mainloop); + finish: + pa_threaded_mainloop_unlock(pcm->p->mainloop); return err; } -static int pulse_stop(snd_pcm_ioplug_t *io) +static int pulse_stop(snd_pcm_ioplug_t * io) { snd_pcm_pulse_t *pcm = io->private_data; pa_operation *o; int err = 0; - assert(pcm); - assert(pcm->p); + assert(pcm); + assert(pcm->p); - pa_threaded_mainloop_lock(pcm->p->mainloop); + pa_threaded_mainloop_lock(pcm->p->mainloop); - err = pulse_check_connection(pcm->p); - if (err < 0) - goto finish; + err = pulse_check_connection(pcm->p); + if (err < 0) + goto finish; - /* If stream connection fails, this gets called anyway */ - if (pcm->stream == NULL) - goto finish; + /* If stream connection fails, this gets called anyway */ + if (pcm->stream == NULL) + goto finish; - o = pa_stream_flush(pcm->stream, pulse_stream_success_cb, pcm->p); - if (!o) { - err = -EIO; - goto finish; - } + o = pa_stream_flush(pcm->stream, pulse_stream_success_cb, pcm->p); + if (!o) { + err = -EIO; + goto finish; + } - err = pulse_wait_operation(pcm->p, o); + err = pulse_wait_operation(pcm->p, o); - pa_operation_unref(o); + pa_operation_unref(o); - if (err < 0) { - err = -EIO; - goto finish; - } + if (err < 0) { + err = -EIO; + goto finish; + } - o = pa_stream_cork(pcm->stream, 1, pulse_stream_success_cb, pcm->p); - if (!o) { - err = -EIO; - goto finish; - } + o = pa_stream_cork(pcm->stream, 1, pulse_stream_success_cb, + pcm->p); + if (!o) { + err = -EIO; + goto finish; + } - err = pulse_wait_operation(pcm->p, o); + err = pulse_wait_operation(pcm->p, o); - pa_operation_unref(o); + pa_operation_unref(o); - if (err < 0) { - err = -EIO; - goto finish; - } + if (err < 0) { + err = -EIO; + goto finish; + } -finish: - pa_threaded_mainloop_unlock(pcm->p->mainloop); + finish: + pa_threaded_mainloop_unlock(pcm->p->mainloop); return err; } -int pulse_drain(snd_pcm_ioplug_t *io) +int pulse_drain(snd_pcm_ioplug_t * io) { - snd_pcm_pulse_t *pcm = io->private_data; + snd_pcm_pulse_t *pcm = io->private_data; pa_operation *o; int err = 0; - assert(pcm); - assert(pcm->p); + assert(pcm); + assert(pcm->p); - pa_threaded_mainloop_lock(pcm->p->mainloop); + pa_threaded_mainloop_lock(pcm->p->mainloop); - assert(pcm->stream); + assert(pcm->stream); - err = pulse_check_connection(pcm->p); - if (err < 0) - goto finish; + err = pulse_check_connection(pcm->p); + if (err < 0) + goto finish; - o = pa_stream_drain(pcm->stream, pulse_stream_success_cb, pcm->p); - if (!o) { - err = -EIO; - goto finish; - } + o = pa_stream_drain(pcm->stream, pulse_stream_success_cb, pcm->p); + if (!o) { + err = -EIO; + goto finish; + } - err = pulse_wait_operation(pcm->p, o); + err = pulse_wait_operation(pcm->p, o); - pa_operation_unref(o); + pa_operation_unref(o); - if (err < 0) { - err = -EIO; - goto finish; - } + if (err < 0) { + err = -EIO; + goto finish; + } -finish: - pa_threaded_mainloop_unlock(pcm->p->mainloop); + finish: + pa_threaded_mainloop_unlock(pcm->p->mainloop); return err; } -static snd_pcm_sframes_t pulse_pointer(snd_pcm_ioplug_t *io) +static snd_pcm_sframes_t pulse_pointer(snd_pcm_ioplug_t * io) { snd_pcm_pulse_t *pcm = io->private_data; int err = 0; - assert(pcm); - assert(pcm->p); + assert(pcm); + assert(pcm->p); - pa_threaded_mainloop_lock(pcm->p->mainloop); + pa_threaded_mainloop_lock(pcm->p->mainloop); - assert(pcm->stream); + assert(pcm->stream); - err = pulse_check_connection(pcm->p); - if (err < 0) - goto finish; + err = pulse_check_connection(pcm->p); + if (err < 0) + goto finish; - update_ptr(pcm); + update_ptr(pcm); err = snd_pcm_bytes_to_frames(io->pcm, pcm->ptr); if (pcm->underrun) err = -EPIPE; -finish: - pa_threaded_mainloop_unlock(pcm->p->mainloop); + finish: + pa_threaded_mainloop_unlock(pcm->p->mainloop); return err; } -static int pulse_delay(snd_pcm_ioplug_t *io, - snd_pcm_sframes_t *delayp) +static int pulse_delay(snd_pcm_ioplug_t * io, snd_pcm_sframes_t * delayp) { snd_pcm_pulse_t *pcm = io->private_data; int err = 0; pa_usec_t lat; - assert(pcm); - assert(pcm->p); + assert(pcm); + assert(pcm->p); - pa_threaded_mainloop_lock(pcm->p->mainloop); + pa_threaded_mainloop_lock(pcm->p->mainloop); - assert(pcm->stream); + assert(pcm->stream); - err = pulse_check_connection(pcm->p); - if (err < 0) - goto finish; + err = pulse_check_connection(pcm->p); + if (err < 0) + goto finish; if (pa_stream_get_latency(pcm->stream, &lat, NULL)) { err = -EIO; goto finish; } - *delayp = snd_pcm_bytes_to_frames(io->pcm, pa_usec_to_bytes(lat, &pcm->ss)); + *delayp = + snd_pcm_bytes_to_frames(io->pcm, + pa_usec_to_bytes(lat, &pcm->ss)); - if (pcm->underrun && pcm->io.state == SND_PCM_STATE_RUNNING) + if (pcm->underrun && pcm->io.state == SND_PCM_STATE_RUNNING) snd_pcm_ioplug_set_state(io, SND_PCM_STATE_XRUN); -finish: - pa_threaded_mainloop_unlock(pcm->p->mainloop); + finish: + pa_threaded_mainloop_unlock(pcm->p->mainloop); return err; } -static snd_pcm_sframes_t pulse_write(snd_pcm_ioplug_t *io, - const snd_pcm_channel_area_t *areas, - snd_pcm_uframes_t offset, - snd_pcm_uframes_t size) +static snd_pcm_sframes_t pulse_write(snd_pcm_ioplug_t * io, + const snd_pcm_channel_area_t * areas, + snd_pcm_uframes_t offset, + snd_pcm_uframes_t size) { snd_pcm_pulse_t *pcm = io->private_data; const char *buf; int err = 0; - assert(pcm); - assert(pcm->p); + assert(pcm); + assert(pcm->p); - pa_threaded_mainloop_lock(pcm->p->mainloop); + pa_threaded_mainloop_lock(pcm->p->mainloop); - assert(pcm->stream); + assert(pcm->stream); - err = pulse_check_connection(pcm->p); - if (err < 0) - goto finish; + err = pulse_check_connection(pcm->p); + if (err < 0) + goto finish; - /* Make sure the buffer pointer is in sync */ - update_ptr(pcm); + /* Make sure the buffer pointer is in sync */ + update_ptr(pcm); - assert(pcm->last_size >= (size * pcm->frame_size)); + assert(pcm->last_size >= (size * pcm->frame_size)); - buf = (char *)areas->addr + (areas->first + areas->step * offset) / 8; + buf = + (char *) areas->addr + (areas->first + + areas->step * offset) / 8; - pa_stream_write(pcm->stream, buf, size * pcm->frame_size, NULL, 0, 0); + pa_stream_write(pcm->stream, buf, size * pcm->frame_size, NULL, 0, + 0); - /* Make sure the buffer pointer is in sync */ - update_ptr(pcm); + /* Make sure the buffer pointer is in sync */ + update_ptr(pcm); - if (pcm->last_size < pcm->buffer_attr.minreq) - pulse_poll_deactivate(pcm->p); + if (pcm->last_size < pcm->buffer_attr.minreq) + pulse_poll_deactivate(pcm->p); - err = size; - pcm->underrun = 0; + err = size; + pcm->underrun = 0; -finish: - pa_threaded_mainloop_unlock(pcm->p->mainloop); + finish: + pa_threaded_mainloop_unlock(pcm->p->mainloop); return err; } -static snd_pcm_sframes_t pulse_read(snd_pcm_ioplug_t *io, - const snd_pcm_channel_area_t *areas, - snd_pcm_uframes_t offset, - snd_pcm_uframes_t size) +static snd_pcm_sframes_t pulse_read(snd_pcm_ioplug_t * io, + const snd_pcm_channel_area_t * areas, + snd_pcm_uframes_t offset, + snd_pcm_uframes_t size) { snd_pcm_pulse_t *pcm = io->private_data; void *dst_buf, *src_buf; size_t remain_size, frag_length; int err = 0; - assert(pcm); - assert(pcm->p); + assert(pcm); + assert(pcm->p); - pa_threaded_mainloop_lock(pcm->p->mainloop); + pa_threaded_mainloop_lock(pcm->p->mainloop); - assert(pcm->stream); + assert(pcm->stream); - err = pulse_check_connection(pcm->p); - if (err < 0) - goto finish; + err = pulse_check_connection(pcm->p); + if (err < 0) + goto finish; - /* Make sure the buffer pointer is in sync */ - update_ptr(pcm); + /* Make sure the buffer pointer is in sync */ + update_ptr(pcm); - remain_size = size * pcm->frame_size; + remain_size = size * pcm->frame_size; - dst_buf = (char *)areas->addr + (areas->first + areas->step * offset) / 8; - while (remain_size > 0) { - pa_stream_peek(pcm->stream, (const void**)&src_buf, &frag_length); - if (frag_length == 0) - break; + dst_buf = + (char *) areas->addr + (areas->first + + areas->step * offset) / 8; + while (remain_size > 0) { + pa_stream_peek(pcm->stream, (const void **) &src_buf, + &frag_length); + if (frag_length == 0) + break; - src_buf = (char*)src_buf + pcm->offset; - frag_length -= pcm->offset; + src_buf = (char *) src_buf + pcm->offset; + frag_length -= pcm->offset; - if (frag_length > remain_size) { - pcm->offset += remain_size; - frag_length = remain_size; - } else - pcm->offset = 0; + if (frag_length > remain_size) { + pcm->offset += remain_size; + frag_length = remain_size; + } else + pcm->offset = 0; - memcpy(dst_buf, src_buf, frag_length); + memcpy(dst_buf, src_buf, frag_length); - if (pcm->offset == 0) - pa_stream_drop(pcm->stream); + if (pcm->offset == 0) + pa_stream_drop(pcm->stream); - dst_buf = (char*)dst_buf + frag_length; - remain_size -= frag_length; - } + dst_buf = (char *) dst_buf + frag_length; + remain_size -= frag_length; + } - /* Make sure the buffer pointer is in sync */ - update_ptr(pcm); + /* Make sure the buffer pointer is in sync */ + update_ptr(pcm); - if (pcm->last_size < pcm->buffer_attr.minreq) - pulse_poll_deactivate(pcm->p); + if (pcm->last_size < pcm->buffer_attr.minreq) + pulse_poll_deactivate(pcm->p); - err = size - (remain_size / pcm->frame_size); + err = size - (remain_size / pcm->frame_size); -finish: - pa_threaded_mainloop_unlock(pcm->p->mainloop); + finish: + pa_threaded_mainloop_unlock(pcm->p->mainloop); return err; } -static void stream_request_cb(pa_stream *p, size_t length, void *userdata) +static void stream_request_cb(pa_stream * p, size_t length, void *userdata) { - snd_pcm_pulse_t *pcm = userdata; + snd_pcm_pulse_t *pcm = userdata; - assert(pcm); - assert(pcm->p); + assert(pcm); + assert(pcm->p); - pulse_poll_activate(pcm->p); + pulse_poll_activate(pcm->p); } -static void stream_underrun_cb(pa_stream *p, void *userdata) { +static void stream_underrun_cb(pa_stream * p, void *userdata) +{ snd_pcm_pulse_t *pcm = userdata; assert(pcm); @@ -397,231 +408,262 @@ static void stream_underrun_cb(pa_stream *p, void *userdata) { pcm->underrun = 1; } -static int pulse_pcm_poll_descriptors_count(snd_pcm_ioplug_t *io) +static int pulse_pcm_poll_descriptors_count(snd_pcm_ioplug_t * io) { snd_pcm_pulse_t *pcm = io->private_data; int count; - assert(pcm); - assert(pcm->p); + assert(pcm); + assert(pcm->p); - pa_threaded_mainloop_lock(pcm->p->mainloop); + pa_threaded_mainloop_lock(pcm->p->mainloop); - count = pulse_poll_descriptors_count(pcm->p); + count = pulse_poll_descriptors_count(pcm->p); - pa_threaded_mainloop_unlock(pcm->p->mainloop); + pa_threaded_mainloop_unlock(pcm->p->mainloop); return count; } -static int pulse_pcm_poll_descriptors(snd_pcm_ioplug_t *io, struct pollfd *pfd, unsigned int space) +static int pulse_pcm_poll_descriptors(snd_pcm_ioplug_t * io, + struct pollfd *pfd, + unsigned int space) { snd_pcm_pulse_t *pcm = io->private_data; int err; - assert(pcm); - assert(pcm->p); + assert(pcm); + assert(pcm->p); - pa_threaded_mainloop_lock(pcm->p->mainloop); + pa_threaded_mainloop_lock(pcm->p->mainloop); - err = pulse_poll_descriptors(pcm->p, pfd, space); + err = pulse_poll_descriptors(pcm->p, pfd, space); - pa_threaded_mainloop_unlock(pcm->p->mainloop); + pa_threaded_mainloop_unlock(pcm->p->mainloop); return err; } -static int pulse_pcm_poll_revents(snd_pcm_ioplug_t *io, struct pollfd *pfd, unsigned int nfds, unsigned short *revents) +static int pulse_pcm_poll_revents(snd_pcm_ioplug_t * io, + struct pollfd *pfd, unsigned int nfds, + unsigned short *revents) { snd_pcm_pulse_t *pcm = io->private_data; int err = 0; - assert(pcm); - assert(pcm->p); - - pa_threaded_mainloop_lock(pcm->p->mainloop); - - err = pulse_poll_revents(pcm->p, pfd, nfds, revents); - if (err < 0) - goto finish; + assert(pcm); + assert(pcm->p); - *revents = 0; + pa_threaded_mainloop_lock(pcm->p->mainloop); - /* - * Make sure we have an up-to-date value. - */ - update_ptr(pcm); + err = pulse_poll_revents(pcm->p, pfd, nfds, revents); + if (err < 0) + goto finish; - /* - * ALSA thinks in periods, not bytes, samples or frames. - */ - if (pcm->last_size >= pcm->buffer_attr.minreq) { - if (io->stream == SND_PCM_STREAM_PLAYBACK) - *revents |= POLLOUT; - else - *revents |= POLLIN; - } + *revents = 0; + + /* + * Make sure we have an up-to-date value. + */ + update_ptr(pcm); + + /* + * ALSA thinks in periods, not bytes, samples or frames. + */ + if (pcm->last_size >= pcm->buffer_attr.minreq) { + if (io->stream == SND_PCM_STREAM_PLAYBACK) + *revents |= POLLOUT; + else + *revents |= POLLIN; + } -finish: - pa_threaded_mainloop_unlock(pcm->p->mainloop); + finish: + pa_threaded_mainloop_unlock(pcm->p->mainloop); return err; } -static int pulse_prepare(snd_pcm_ioplug_t *io) +static int pulse_prepare(snd_pcm_ioplug_t * io) { - pa_channel_map map; - snd_pcm_pulse_t *pcm = io->private_data; - int err = 0; - - assert(pcm); - assert(pcm->p); - - pa_threaded_mainloop_lock(pcm->p->mainloop); - - if (pcm->stream) { - pa_stream_disconnect(pcm->stream); - pulse_wait_stream_state(pcm->p, pcm->stream, PA_STREAM_TERMINATED); - pa_stream_unref(pcm->stream); - pcm->stream = NULL; - } - - err = pulse_check_connection(pcm->p); - if (err < 0) - goto finish; - - assert(pcm->stream == NULL); - - if (io->stream == SND_PCM_STREAM_PLAYBACK) - pcm->stream = pa_stream_new(pcm->p->context, "ALSA Playback", &pcm->ss, - pa_channel_map_init_auto(&map, pcm->ss.channels, PA_CHANNEL_MAP_ALSA)); - else - pcm->stream = pa_stream_new(pcm->p->context, "ALSA Capture", &pcm->ss, - pa_channel_map_init_auto(&map, pcm->ss.channels, PA_CHANNEL_MAP_ALSA)); - assert(pcm->stream); - - pa_stream_set_state_callback(pcm->stream, pulse_stream_state_cb, pcm->p); - - if (io->stream == SND_PCM_STREAM_PLAYBACK) { - pa_stream_set_write_callback(pcm->stream, stream_request_cb, pcm); - pa_stream_set_underflow_callback(pcm->stream, stream_underrun_cb, pcm); - pa_stream_connect_playback(pcm->stream, pcm->device, &pcm->buffer_attr, - PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_INTERPOLATE_TIMING, NULL, NULL); - } else { - pa_stream_set_read_callback(pcm->stream, stream_request_cb, pcm); - pa_stream_connect_record(pcm->stream, pcm->device, &pcm->buffer_attr, - PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_INTERPOLATE_TIMING); - } - - err = pulse_wait_stream_state(pcm->p, pcm->stream, PA_STREAM_READY); - if (err < 0) { - fprintf(stderr, "*** PULSEAUDIO: Unable to create stream.\n"); - pa_stream_unref(pcm->stream); - pcm->stream = NULL; - goto finish; - } - - pcm->last_size = 0; - pcm->ptr = 0; - pcm->offset = 0; - pcm->underrun = 0; - -finish: - pa_threaded_mainloop_unlock(pcm->p->mainloop); + pa_channel_map map; + snd_pcm_pulse_t *pcm = io->private_data; + int err = 0; + + assert(pcm); + assert(pcm->p); + + pa_threaded_mainloop_lock(pcm->p->mainloop); + + if (pcm->stream) { + pa_stream_disconnect(pcm->stream); + pulse_wait_stream_state(pcm->p, pcm->stream, + PA_STREAM_TERMINATED); + pa_stream_unref(pcm->stream); + pcm->stream = NULL; + } + + err = pulse_check_connection(pcm->p); + if (err < 0) + goto finish; + + assert(pcm->stream == NULL); + + if (io->stream == SND_PCM_STREAM_PLAYBACK) + pcm->stream = + pa_stream_new(pcm->p->context, "ALSA Playback", + &pcm->ss, pa_channel_map_init_auto(&map, + pcm-> + ss. + channels, + PA_CHANNEL_MAP_ALSA)); + else + pcm->stream = + pa_stream_new(pcm->p->context, "ALSA Capture", + &pcm->ss, pa_channel_map_init_auto(&map, + pcm-> + ss. + channels, + PA_CHANNEL_MAP_ALSA)); + assert(pcm->stream); + + pa_stream_set_state_callback(pcm->stream, pulse_stream_state_cb, + pcm->p); + + if (io->stream == SND_PCM_STREAM_PLAYBACK) { + pa_stream_set_write_callback(pcm->stream, + stream_request_cb, pcm); + pa_stream_set_underflow_callback(pcm->stream, + stream_underrun_cb, pcm); + pa_stream_connect_playback(pcm->stream, pcm->device, + &pcm->buffer_attr, + PA_STREAM_AUTO_TIMING_UPDATE | + PA_STREAM_INTERPOLATE_TIMING, + NULL, NULL); + } else { + pa_stream_set_read_callback(pcm->stream, stream_request_cb, + pcm); + pa_stream_connect_record(pcm->stream, pcm->device, + &pcm->buffer_attr, + PA_STREAM_AUTO_TIMING_UPDATE | + PA_STREAM_INTERPOLATE_TIMING); + } + + err = + pulse_wait_stream_state(pcm->p, pcm->stream, PA_STREAM_READY); + if (err < 0) { + fprintf(stderr, + "*** PULSEAUDIO: Unable to create stream.\n"); + pa_stream_unref(pcm->stream); + pcm->stream = NULL; + goto finish; + } + + pcm->last_size = 0; + pcm->ptr = 0; + pcm->offset = 0; + pcm->underrun = 0; + + finish: + pa_threaded_mainloop_unlock(pcm->p->mainloop); return err; } -static int pulse_hw_params(snd_pcm_ioplug_t *io, snd_pcm_hw_params_t *params) +static int pulse_hw_params(snd_pcm_ioplug_t * io, + snd_pcm_hw_params_t * params) { - snd_pcm_pulse_t *pcm = io->private_data; - snd_pcm_t *base = io->pcm; + snd_pcm_pulse_t *pcm = io->private_data; + snd_pcm_t *base = io->pcm; int err = 0; - assert(pcm); - assert(pcm->p); + assert(pcm); + assert(pcm->p); + + //Resolving bugtrack ID 0003470 + if (!base) { + switch (snd_pcm_state(base)) { + case SND_PCM_STATE_SETUP: + case SND_PCM_STATE_PREPARED: + break; + default: + assert(!pcm->stream); + break; + } + } - //Resolving bugtrack ID 0003470 - if (!base) { - switch (snd_pcm_state(base)) { - case SND_PCM_STATE_SETUP: - case SND_PCM_STATE_PREPARED: - break; + pa_threaded_mainloop_lock(pcm->p->mainloop); + + pcm->frame_size = + (snd_pcm_format_physical_width(io->format) * io->channels) / 8; + + switch (io->format) { + case SND_PCM_FORMAT_U8: + pcm->ss.format = PA_SAMPLE_U8; + break; + case SND_PCM_FORMAT_A_LAW: + pcm->ss.format = PA_SAMPLE_ALAW; + break; + case SND_PCM_FORMAT_MU_LAW: + pcm->ss.format = PA_SAMPLE_ULAW; + break; + case SND_PCM_FORMAT_S16_LE: + pcm->ss.format = PA_SAMPLE_S16LE; + break; + case SND_PCM_FORMAT_S16_BE: + pcm->ss.format = PA_SAMPLE_S16BE; + break; + case SND_PCM_FORMAT_FLOAT_LE: + pcm->ss.format = PA_SAMPLE_FLOAT32LE; + break; + case SND_PCM_FORMAT_FLOAT_BE: + pcm->ss.format = PA_SAMPLE_FLOAT32BE; + break; default: - assert(!pcm->stream); - break; + fprintf(stderr, "*** PULSEAUDIO: unsupported format %s\n", + snd_pcm_format_name(io->format)); + err = -EINVAL; + goto finish; } - } - - pa_threaded_mainloop_lock(pcm->p->mainloop); - - pcm->frame_size = (snd_pcm_format_physical_width(io->format) * io->channels) / 8; - - switch (io->format) { - case SND_PCM_FORMAT_U8: - pcm->ss.format = PA_SAMPLE_U8; - break; - case SND_PCM_FORMAT_A_LAW: - pcm->ss.format = PA_SAMPLE_ALAW; - break; - case SND_PCM_FORMAT_MU_LAW: - pcm->ss.format = PA_SAMPLE_ULAW; - break; - case SND_PCM_FORMAT_S16_LE: - pcm->ss.format = PA_SAMPLE_S16LE; - break; - case SND_PCM_FORMAT_S16_BE: - pcm->ss.format = PA_SAMPLE_S16BE; - break; - case SND_PCM_FORMAT_FLOAT_LE: - pcm->ss.format = PA_SAMPLE_FLOAT32LE; - break; - case SND_PCM_FORMAT_FLOAT_BE: - pcm->ss.format = PA_SAMPLE_FLOAT32BE; - break; - default: - fprintf(stderr, "*** PULSEAUDIO: unsupported format %s\n", - snd_pcm_format_name(io->format)); - err = -EINVAL; - goto finish; - } - - pcm->ss.rate = io->rate; - pcm->ss.channels = io->channels; - - pcm->buffer_attr.maxlength = (io->buffer_size*3)/2 * pcm->frame_size; - pcm->buffer_attr.tlength = io->buffer_size * pcm->frame_size; - pcm->buffer_attr.prebuf = (io->buffer_size - io->period_size) * pcm->frame_size; - pcm->buffer_attr.minreq = io->period_size * pcm->frame_size; - pcm->buffer_attr.fragsize = io->period_size * pcm->frame_size; - -finish: - pa_threaded_mainloop_unlock(pcm->p->mainloop); + + pcm->ss.rate = io->rate; + pcm->ss.channels = io->channels; + + pcm->buffer_attr.maxlength = + (io->buffer_size * 3) / 2 * pcm->frame_size; + pcm->buffer_attr.tlength = io->buffer_size * pcm->frame_size; + pcm->buffer_attr.prebuf = + (io->buffer_size - io->period_size) * pcm->frame_size; + pcm->buffer_attr.minreq = io->period_size * pcm->frame_size; + pcm->buffer_attr.fragsize = io->period_size * pcm->frame_size; + + finish: + pa_threaded_mainloop_unlock(pcm->p->mainloop); return err; } -static int pulse_close(snd_pcm_ioplug_t *io) +static int pulse_close(snd_pcm_ioplug_t * io) { snd_pcm_pulse_t *pcm = io->private_data; - assert(pcm); + assert(pcm); - pa_threaded_mainloop_lock(pcm->p->mainloop); + pa_threaded_mainloop_lock(pcm->p->mainloop); - if (pcm->stream) { - pa_stream_disconnect(pcm->stream); - pulse_wait_stream_state(pcm->p, pcm->stream, PA_STREAM_TERMINATED); - pa_stream_unref(pcm->stream); - } + if (pcm->stream) { + pa_stream_disconnect(pcm->stream); + pulse_wait_stream_state(pcm->p, pcm->stream, + PA_STREAM_TERMINATED); + pa_stream_unref(pcm->stream); + } - pa_threaded_mainloop_unlock(pcm->p->mainloop); + pa_threaded_mainloop_unlock(pcm->p->mainloop); - if (pcm->p) - pulse_free(pcm->p); + if (pcm->p) + pulse_free(pcm->p); - if (pcm->device) - free(pcm->device); + if (pcm->device) + free(pcm->device); free(pcm); @@ -629,89 +671,98 @@ static int pulse_close(snd_pcm_ioplug_t *io) } static snd_pcm_ioplug_callback_t pulse_playback_callback = { - .start = pulse_start, - .stop = pulse_stop, - .drain = pulse_drain, - .pointer = pulse_pointer, - .transfer = pulse_write, - .delay = pulse_delay, - .poll_descriptors_count = pulse_pcm_poll_descriptors_count, - .poll_descriptors = pulse_pcm_poll_descriptors, - .poll_revents = pulse_pcm_poll_revents, - .prepare = pulse_prepare, - .hw_params = pulse_hw_params, - .close = pulse_close, + .start = pulse_start, + .stop = pulse_stop, + .drain = pulse_drain, + .pointer = pulse_pointer, + .transfer = pulse_write, + .delay = pulse_delay, + .poll_descriptors_count = pulse_pcm_poll_descriptors_count, + .poll_descriptors = pulse_pcm_poll_descriptors, + .poll_revents = pulse_pcm_poll_revents, + .prepare = pulse_prepare, + .hw_params = pulse_hw_params, + .close = pulse_close, }; static snd_pcm_ioplug_callback_t pulse_capture_callback = { - .start = pulse_start, - .stop = pulse_stop, - .pointer = pulse_pointer, - .transfer = pulse_read, - .delay = pulse_delay, - .poll_descriptors_count = pulse_pcm_poll_descriptors_count, - .poll_descriptors = pulse_pcm_poll_descriptors, - .poll_revents = pulse_pcm_poll_revents, - .prepare = pulse_prepare, - .hw_params = pulse_hw_params, - .close = pulse_close, + .start = pulse_start, + .stop = pulse_stop, + .pointer = pulse_pointer, + .transfer = pulse_read, + .delay = pulse_delay, + .poll_descriptors_count = pulse_pcm_poll_descriptors_count, + .poll_descriptors = pulse_pcm_poll_descriptors, + .poll_revents = pulse_pcm_poll_revents, + .prepare = pulse_prepare, + .hw_params = pulse_hw_params, + .close = pulse_close, }; -static int pulse_hw_constraint(snd_pcm_pulse_t *pcm) +static int pulse_hw_constraint(snd_pcm_pulse_t * pcm) { - snd_pcm_ioplug_t *io = &pcm->io; - - static const snd_pcm_access_t access_list[] = { - SND_PCM_ACCESS_RW_INTERLEAVED - }; - static const unsigned int formats[] = { - SND_PCM_FORMAT_U8, - SND_PCM_FORMAT_A_LAW, - SND_PCM_FORMAT_MU_LAW, - SND_PCM_FORMAT_S16_LE, - SND_PCM_FORMAT_S16_BE, - SND_PCM_FORMAT_FLOAT_LE, - SND_PCM_FORMAT_FLOAT_BE - }; - - int err; - - err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_ACCESS, - ARRAY_SIZE(access_list), access_list); - if (err < 0) - return err; - - err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_FORMAT, - ARRAY_SIZE(formats), formats); - if (err < 0) - return err; - - err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_CHANNELS, - 1, PA_CHANNELS_MAX); - if (err < 0) - return err; - - /* FIXME: Investigate actual min and max */ - err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_RATE, - 8000, 48000); - if (err < 0) - return err; - - err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_BUFFER_BYTES, - 1, 4 * 1024 * 1024); - if (err < 0) - return err; - - err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_PERIOD_BYTES, 256, 1024 * 1024); + snd_pcm_ioplug_t *io = &pcm->io; + + static const snd_pcm_access_t access_list[] = { + SND_PCM_ACCESS_RW_INTERLEAVED + }; + static const unsigned int formats[] = { + SND_PCM_FORMAT_U8, + SND_PCM_FORMAT_A_LAW, + SND_PCM_FORMAT_MU_LAW, + SND_PCM_FORMAT_S16_LE, + SND_PCM_FORMAT_S16_BE, + SND_PCM_FORMAT_FLOAT_LE, + SND_PCM_FORMAT_FLOAT_BE + }; + + int err; + + err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_ACCESS, + ARRAY_SIZE(access_list), + access_list); + if (err < 0) + return err; + + err = snd_pcm_ioplug_set_param_list(io, SND_PCM_IOPLUG_HW_FORMAT, + ARRAY_SIZE(formats), formats); + if (err < 0) + return err; + + err = + snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_CHANNELS, + 1, PA_CHANNELS_MAX); + if (err < 0) + return err; + + /* FIXME: Investigate actual min and max */ + err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_RATE, + 8000, 48000); if (err < 0) return err; - err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_PERIODS, 2, 1024); + err = + snd_pcm_ioplug_set_param_minmax(io, + SND_PCM_IOPLUG_HW_BUFFER_BYTES, + 1, 4 * 1024 * 1024); if (err < 0) return err; - return 0; + + err = + snd_pcm_ioplug_set_param_minmax(io, + SND_PCM_IOPLUG_HW_PERIOD_BYTES, + 256, 1024 * 1024); + if (err < 0) + return err; + + err = + snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_PERIODS, + 2, 1024); + if (err < 0) + return err; + return 0; } SND_PCM_PLUGIN_DEFINE_FUNC(pulse) @@ -727,40 +778,41 @@ SND_PCM_PLUGIN_DEFINE_FUNC(pulse) const char *id; if (snd_config_get_id(n, &id) < 0) continue; - if (strcmp(id, "comment") == 0 || strcmp(id, "type") == 0 || strcmp(id, "hint") == 0) + if (strcmp(id, "comment") == 0 || strcmp(id, "type") == 0 + || strcmp(id, "hint") == 0) + continue; + if (strcmp(id, "server") == 0) { + if (snd_config_get_string(n, &server) < 0) { + SNDERR("Invalid type for %s", id); + return -EINVAL; + } continue; - if (strcmp(id, "server") == 0) { - if (snd_config_get_string(n, &server) < 0) { - SNDERR("Invalid type for %s", id); - return -EINVAL; - } - continue; - } - if (strcmp(id, "device") == 0) { - if (snd_config_get_string(n, &device) < 0) { - SNDERR("Invalid type for %s", id); - return -EINVAL; - } - continue; - } + } + if (strcmp(id, "device") == 0) { + if (snd_config_get_string(n, &device) < 0) { + SNDERR("Invalid type for %s", id); + return -EINVAL; + } + continue; + } SNDERR("Unknown field %s", id); return -EINVAL; } pcm = calloc(1, sizeof(*pcm)); - if (device) - pcm->device = strdup(device); + if (device) + pcm->device = strdup(device); - pcm->p = pulse_new(); - if (!pcm->p) { - err = -EIO; - goto error; - } + pcm->p = pulse_new(); + if (!pcm->p) { + err = -EIO; + goto error; + } - err = pulse_connect(pcm->p, server); - if (err < 0) - goto error; + err = pulse_connect(pcm->p, server); + if (err < 0) + goto error; pcm->io.version = SND_PCM_IOPLUG_VERSION; pcm->io.name = "ALSA <-> PulseAudio PCM I/O Plugin"; @@ -768,25 +820,25 @@ SND_PCM_PLUGIN_DEFINE_FUNC(pulse) pcm->io.poll_events = 0; pcm->io.mmap_rw = 0; pcm->io.callback = stream == SND_PCM_STREAM_PLAYBACK ? - &pulse_playback_callback : &pulse_capture_callback; + &pulse_playback_callback : &pulse_capture_callback; pcm->io.private_data = pcm; err = snd_pcm_ioplug_create(&pcm->io, name, stream, mode); if (err < 0) goto error; - err = pulse_hw_constraint(pcm); - if (err < 0) { + err = pulse_hw_constraint(pcm); + if (err < 0) { snd_pcm_ioplug_delete(&pcm->io); - goto error; - } + goto error; + } *pcmp = pcm->io.pcm; return 0; -error: - if (pcm->p) - pulse_free(pcm->p); + error: + if (pcm->p) + pulse_free(pcm->p); free(pcm); diff --git a/pulse/pulse.c b/pulse/pulse.c index fd80d9c..4fae317 100644 --- a/pulse/pulse.c +++ b/pulse/pulse.c @@ -25,236 +25,244 @@ #include "pulse.h" -int pulse_check_connection(snd_pulse_t *p) +int pulse_check_connection(snd_pulse_t * p) { - pa_context_state_t state; + pa_context_state_t state; - assert(p && p->context && p->mainloop); + assert(p && p->context && p->mainloop); - state = pa_context_get_state(p->context); + state = pa_context_get_state(p->context); - if (state != PA_CONTEXT_READY) - return -EIO; + if (state != PA_CONTEXT_READY) + return -EIO; - return 0; + return 0; } -void pulse_stream_state_cb(pa_stream *s, void * userdata) +void pulse_stream_state_cb(pa_stream * s, void *userdata) { - snd_pulse_t *p = userdata; + snd_pulse_t *p = userdata; - assert(s); - assert(p); + assert(s); + assert(p); - pa_threaded_mainloop_signal(p->mainloop, 0); + pa_threaded_mainloop_signal(p->mainloop, 0); } -void pulse_stream_success_cb(pa_stream *s, int success, void *userdata) +void pulse_stream_success_cb(pa_stream * s, int success, void *userdata) { - snd_pulse_t *p = userdata; + snd_pulse_t *p = userdata; - assert(s); - assert(p); + assert(s); + assert(p); - pa_threaded_mainloop_signal(p->mainloop, 0); + pa_threaded_mainloop_signal(p->mainloop, 0); } -void pulse_context_success_cb(pa_context *c, int success, void *userdata) +void pulse_context_success_cb(pa_context * c, int success, void *userdata) { - snd_pulse_t *p = userdata; + snd_pulse_t *p = userdata; - assert(c); - assert(p); + assert(c); + assert(p); - pa_threaded_mainloop_signal(p->mainloop, 0); + pa_threaded_mainloop_signal(p->mainloop, 0); } -int pulse_wait_operation(snd_pulse_t *p, pa_operation *o) +int pulse_wait_operation(snd_pulse_t * p, pa_operation * o) { - assert(p && o && (p->state == PULSE_STATE_READY) && p->mainloop); + assert(p && o && (p->state == PULSE_STATE_READY) && p->mainloop); - while (pa_operation_get_state(o) == PA_OPERATION_RUNNING) - pa_threaded_mainloop_wait(p->mainloop); + while (pa_operation_get_state(o) == PA_OPERATION_RUNNING) + pa_threaded_mainloop_wait(p->mainloop); - return 0; + return 0; } -int pulse_wait_stream_state(snd_pulse_t *p, pa_stream *stream, pa_stream_state_t target) +int pulse_wait_stream_state(snd_pulse_t * p, pa_stream * stream, + pa_stream_state_t target) { - pa_stream_state_t state; + pa_stream_state_t state; - assert(p && stream && (p->state == PULSE_STATE_READY) && p->mainloop); + assert(p && stream && (p->state == PULSE_STATE_READY) + && p->mainloop); - while (1) { - state = pa_stream_get_state(stream); + while (1) { + state = pa_stream_get_state(stream); - if (state == PA_STREAM_FAILED) - return -EIO; + if (state == PA_STREAM_FAILED) + return -EIO; - if (state == target) - break; + if (state == target) + break; - pa_threaded_mainloop_wait(p->mainloop); - } + pa_threaded_mainloop_wait(p->mainloop); + } - return 0; + return 0; } -static void context_state_cb(pa_context *c, void *userdata) { - snd_pulse_t *p = userdata; - assert(c); - - switch (pa_context_get_state(c)) { - case PA_CONTEXT_READY: - case PA_CONTEXT_TERMINATED: - case PA_CONTEXT_FAILED: - pa_threaded_mainloop_signal(p->mainloop, 0); - break; - - case PA_CONTEXT_UNCONNECTED: - case PA_CONTEXT_CONNECTING: - case PA_CONTEXT_AUTHORIZING: - case PA_CONTEXT_SETTING_NAME: - break; - } +static void context_state_cb(pa_context * c, void *userdata) +{ + snd_pulse_t *p = userdata; + assert(c); + + switch (pa_context_get_state(c)) { + case PA_CONTEXT_READY: + case PA_CONTEXT_TERMINATED: + case PA_CONTEXT_FAILED: + pa_threaded_mainloop_signal(p->mainloop, 0); + break; + + case PA_CONTEXT_UNCONNECTED: + case PA_CONTEXT_CONNECTING: + case PA_CONTEXT_AUTHORIZING: + case PA_CONTEXT_SETTING_NAME: + break; + } } snd_pulse_t *pulse_new() { - snd_pulse_t *p; + snd_pulse_t *p; int fd[2] = { -1, -1 }; char proc[PATH_MAX], buf[PATH_MAX + 20]; - p = calloc(1, sizeof(snd_pulse_t)); - assert(p); + p = calloc(1, sizeof(snd_pulse_t)); + assert(p); - p->state = PULSE_STATE_INIT; + p->state = PULSE_STATE_INIT; - if (pipe(fd)) { - free(p); - return NULL; - } + if (pipe(fd)) { + free(p); + return NULL; + } - p->main_fd = fd[0]; - p->thread_fd = fd[1]; + p->main_fd = fd[0]; + p->thread_fd = fd[1]; - fcntl(fd[0], F_SETFL, O_NONBLOCK); - fcntl(fd[1], F_SETFL, O_NONBLOCK); + fcntl(fd[0], F_SETFL, O_NONBLOCK); + fcntl(fd[1], F_SETFL, O_NONBLOCK); - signal(SIGPIPE, SIG_IGN); /* Yes, ugly as hell */ + signal(SIGPIPE, SIG_IGN); /* Yes, ugly as hell */ - p->mainloop = pa_threaded_mainloop_new(); - assert(p->mainloop); + p->mainloop = pa_threaded_mainloop_new(); + assert(p->mainloop); - if (pa_threaded_mainloop_start(p->mainloop) < 0) { - pa_threaded_mainloop_free(p->mainloop); - close(fd[0]); - close(fd[1]); - free(p); - return NULL; - } + if (pa_threaded_mainloop_start(p->mainloop) < 0) { + pa_threaded_mainloop_free(p->mainloop); + close(fd[0]); + close(fd[1]); + free(p); + return NULL; + } - if (pa_get_binary_name(proc, sizeof(proc))) - snprintf(buf, sizeof(buf), "ALSA plug-in [%s]", pa_path_get_filename(proc)); - else - snprintf(buf, sizeof(buf), "ALSA plug-in"); + if (pa_get_binary_name(proc, sizeof(proc))) + snprintf(buf, sizeof(buf), "ALSA plug-in [%s]", + pa_path_get_filename(proc)); + else + snprintf(buf, sizeof(buf), "ALSA plug-in"); - p->context = pa_context_new(pa_threaded_mainloop_get_api(p->mainloop), buf); - assert(p->context); + p->context = + pa_context_new(pa_threaded_mainloop_get_api(p->mainloop), buf); + assert(p->context); - return p; + return p; } -void pulse_free(snd_pulse_t *p) +void pulse_free(snd_pulse_t * p) { - pa_threaded_mainloop_stop(p->mainloop); + pa_threaded_mainloop_stop(p->mainloop); - pa_context_unref(p->context); - pa_threaded_mainloop_free(p->mainloop); + pa_context_unref(p->context); + pa_threaded_mainloop_free(p->mainloop); - close(p->thread_fd); - close(p->main_fd); + close(p->thread_fd); + close(p->main_fd); - free(p); + free(p); } -int pulse_connect(snd_pulse_t *p, const char *server) +int pulse_connect(snd_pulse_t * p, const char *server) { - int err; + int err; - assert(p && p->context && p->mainloop && (p->state == PULSE_STATE_INIT)); + assert(p && p->context && p->mainloop + && (p->state == PULSE_STATE_INIT)); - pa_threaded_mainloop_lock(p->mainloop); + pa_threaded_mainloop_lock(p->mainloop); - err = pa_context_connect(p->context, server, 0, NULL); - if (err < 0) - goto error; + err = pa_context_connect(p->context, server, 0, NULL); + if (err < 0) + goto error; - pa_context_set_state_callback(p->context, context_state_cb, p); + pa_context_set_state_callback(p->context, context_state_cb, p); - pa_threaded_mainloop_wait(p->mainloop); + pa_threaded_mainloop_wait(p->mainloop); - if (pa_context_get_state(p->context) != PA_CONTEXT_READY) - goto error; + if (pa_context_get_state(p->context) != PA_CONTEXT_READY) + goto error; - pa_threaded_mainloop_unlock(p->mainloop); + pa_threaded_mainloop_unlock(p->mainloop); - p->state = PULSE_STATE_READY; + p->state = PULSE_STATE_READY; - return 0; + return 0; -error: - fprintf(stderr, "*** PULSEAUDIO: Unable to connect: %s\n", - pa_strerror(pa_context_errno(p->context))); + error: + fprintf(stderr, "*** PULSEAUDIO: Unable to connect: %s\n", + pa_strerror(pa_context_errno(p->context))); - pa_threaded_mainloop_unlock(p->mainloop); + pa_threaded_mainloop_unlock(p->mainloop); - return -ECONNREFUSED; + return -ECONNREFUSED; } -void pulse_poll_activate(snd_pulse_t *p) +void pulse_poll_activate(snd_pulse_t * p) { - assert(p); + assert(p); - write(p->thread_fd, "a", 1); + write(p->thread_fd, "a", 1); } -void pulse_poll_deactivate(snd_pulse_t *p) +void pulse_poll_deactivate(snd_pulse_t * p) { char buf[10]; assert(p); - /* Drain the pipe */ - while (read(p->main_fd, buf, sizeof(buf)) > 0); + /* Drain the pipe */ + while (read(p->main_fd, buf, sizeof(buf)) > 0); } -int pulse_poll_descriptors_count(snd_pulse_t *p) +int pulse_poll_descriptors_count(snd_pulse_t * p) { - assert(p); + assert(p); - if (p->main_fd >= 0) - return 1; - else - return 0; + if (p->main_fd >= 0) + return 1; + else + return 0; } -int pulse_poll_descriptors(snd_pulse_t *p, struct pollfd *pfd, unsigned int space) +int pulse_poll_descriptors(snd_pulse_t * p, struct pollfd *pfd, + unsigned int space) { - assert(p); + assert(p); - assert(space >= 1); + assert(space >= 1); - pfd[0].fd = p->main_fd; - pfd[0].events = POLLIN; - pfd[0].revents = 0; + pfd[0].fd = p->main_fd; + pfd[0].events = POLLIN; + pfd[0].revents = 0; - return 1; + return 1; } -int pulse_poll_revents(snd_pulse_t *p, struct pollfd *pfd, unsigned int nfds, unsigned short *revents) +int pulse_poll_revents(snd_pulse_t * p, struct pollfd *pfd, + unsigned int nfds, unsigned short *revents) { - assert(p); + assert(p); - return 1; + return 1; } diff --git a/pulse/pulse.h b/pulse/pulse.h index ab53bcb..bd085b4 100644 --- a/pulse/pulse.h +++ b/pulse/pulse.h @@ -25,33 +25,36 @@ #define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0])) typedef struct snd_pulse { - pa_threaded_mainloop *mainloop; - pa_context *context; + pa_threaded_mainloop *mainloop; + pa_context *context; - int thread_fd, main_fd; + int thread_fd, main_fd; - enum { - PULSE_STATE_INIT, - PULSE_STATE_READY, - } state; + enum { + PULSE_STATE_INIT, + PULSE_STATE_READY, + } state; } snd_pulse_t; -int pulse_check_connection(snd_pulse_t *p); +int pulse_check_connection(snd_pulse_t * p); -void pulse_stream_state_cb(pa_stream *s, void * userdata); -void pulse_stream_success_cb(pa_stream *s, int success, void *userdata); -void pulse_context_success_cb(pa_context *c, int success, void *userdata); +void pulse_stream_state_cb(pa_stream * s, void *userdata); +void pulse_stream_success_cb(pa_stream * s, int success, void *userdata); +void pulse_context_success_cb(pa_context * c, int success, void *userdata); -int pulse_wait_operation(snd_pulse_t *p, pa_operation *o); -int pulse_wait_stream_state(snd_pulse_t *p, pa_stream *stream, pa_stream_state_t target); +int pulse_wait_operation(snd_pulse_t * p, pa_operation * o); +int pulse_wait_stream_state(snd_pulse_t * p, pa_stream * stream, + pa_stream_state_t target); snd_pulse_t *pulse_new(); -void pulse_free(snd_pulse_t *p); +void pulse_free(snd_pulse_t * p); -int pulse_connect(snd_pulse_t *p, const char *server); +int pulse_connect(snd_pulse_t * p, const char *server); -void pulse_poll_activate(snd_pulse_t *p); -void pulse_poll_deactivate(snd_pulse_t *p); -int pulse_poll_descriptors_count(snd_pulse_t *p); -int pulse_poll_descriptors(snd_pulse_t *p, struct pollfd *pfd, unsigned int space); -int pulse_poll_revents(snd_pulse_t *p, struct pollfd *pfd, unsigned int nfds, unsigned short *revents); +void pulse_poll_activate(snd_pulse_t * p); +void pulse_poll_deactivate(snd_pulse_t * p); +int pulse_poll_descriptors_count(snd_pulse_t * p); +int pulse_poll_descriptors(snd_pulse_t * p, struct pollfd *pfd, + unsigned int space); +int pulse_poll_revents(snd_pulse_t * p, struct pollfd *pfd, + unsigned int nfds, unsigned short *revents); -- cgit