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.

5 files changed, 1252 insertions, 1149 deletions

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);