/* 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);
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"
#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)
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);
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);
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);
}
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)
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";
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);
#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;
}
#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);
git://git.alsa-project.org / alsa-plugins.git / commitdiff