Follow Polypaudio/PulseAudio name change

Polypaudio recently changed its name to PulseAudio which affects the
names of libraries of header files. Update the polyp, now pulse, plug-in
to follow this name change.

Signed-off-by: Pierre Ossman <ossman@cendio.se>

5 files changed, 1801 insertions, 0 deletions

diff --git a/pulse/Makefile.am b/pulse/Makefile.am
new file mode 100644
index 0000000..3da25f0
--- /dev/null
+++ b/pulse/Makefile.am
@@ -0,0 +1,14 @@
+asound_module_pcm_LTLIBRARIES = libasound_module_pcm_pulse.la
+asound_module_ctl_LTLIBRARIES = libasound_module_ctl_pulse.la
+
+asound_module_pcmdir = $(libdir)/alsa-lib
+asound_module_ctldir = $(libdir)/alsa-lib
+
+AM_CFLAGS = -Wall -g @ALSA_CFLAGS@ $(PTHREAD_CFLAGS) $(pulseaudio_CFLAGS) -D_GNU_SOURCE
+AM_LDFLAGS = -module -avoid-version -export-dynamic
+
+libasound_module_pcm_pulse_la_SOURCES = pcm_pulse.c pulse.c pulse.h
+libasound_module_pcm_pulse_la_LIBADD = @ALSA_LIBS@ $(PTHREAD_LIBS) $(pulseaudio_LIBS)
+
+libasound_module_ctl_pulse_la_SOURCES = ctl_pulse.c pulse.c pulse.h
+libasound_module_ctl_pulse_la_LIBADD = @ALSA_LIBS@ $(PTHREAD_LIBS) $(pulseaudio_LIBS)
diff --git a/pulse/ctl_pulse.c b/pulse/ctl_pulse.c
new file mode 100644
index 0000000..06e087f
--- /dev/null
+++ b/pulse/ctl_pulse.c
@@ -0,0 +1,722 @@
+/*
+ * ALSA <-> PulseAudio mixer control plugin
+ *
+ * Copyright (c) 2006 by Pierre Ossman <ossman@cendio.se>
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+#include <sys/poll.h>
+
+#include <alsa/asoundlib.h>
+#include <alsa/control_external.h>
+
+#include "pulse.h"
+
+typedef struct snd_ctl_pulse {
+	snd_ctl_ext_t ext;
+
+    snd_pulse_t *p;
+
+    char *source;
+    char *sink;
+
+    pa_cvolume sink_volume;
+    pa_cvolume source_volume;
+
+    int sink_muted;
+    int source_muted;
+
+    int subscribed;
+    int updated;
+} snd_ctl_pulse_t;
+
+#define SOURCE_VOL_NAME "Capture Volume"
+#define SOURCE_MUTE_NAME "Capture Switch"
+#define SINK_VOL_NAME "Master Playback Volume"
+#define SINK_MUTE_NAME "Master Playback Switch"
+
+#define UPDATE_SINK_VOL     0x01
+#define UPDATE_SINK_MUTE    0x02
+#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)
+{
+    snd_ctl_pulse_t *ctl = (snd_ctl_pulse_t*)userdata;
+    int chan;
+
+    assert(ctl);
+
+    if (is_last) {
+        pa_threaded_mainloop_signal(ctl->p->mainloop, 0);
+        return;
+    }
+
+    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_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;
+
+        ctl->updated |= UPDATE_SINK_VOL;
+        pulse_poll_activate(ctl->p);
+    }
+
+    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)
+{
+    snd_ctl_pulse_t *ctl = (snd_ctl_pulse_t*)userdata;
+    int chan;
+
+    assert(ctl);
+
+    if (is_last) {
+        pa_threaded_mainloop_signal(ctl->p->mainloop, 0);
+        return;
+    }
+
+    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_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;
+
+        ctl->updated |= UPDATE_SOURCE_VOL;
+        pulse_poll_activate(ctl->p);
+    }
+
+    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)
+{
+    snd_ctl_pulse_t *ctl = (snd_ctl_pulse_t*)userdata;
+    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);
+    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)
+{
+    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)
+{
+    snd_ctl_pulse_t *ctl = ext->private_data;
+    int count = 0;
+
+    assert(ctl);
+
+    pa_threaded_mainloop_lock(ctl->p->mainloop);
+
+    if (ctl->source)
+        count += 2;
+    if (ctl->sink)
+        count += 2;
+
+    pa_threaded_mainloop_unlock(ctl->p->mainloop);
+
+    return count;
+}
+
+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;
+
+    assert(ctl);
+
+    snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
+
+    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;
+
+    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);
+
+    return 0;
+}
+
+static snd_ctl_ext_key_t pulse_find_elem(snd_ctl_ext_t *ext,
+    const snd_ctl_elem_id_t *id)
+{
+    const char *name;
+
+    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;
+
+    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)
+{
+    snd_ctl_pulse_t *ctl = ext->private_data;
+    int err = 0;
+
+    if (key > 3)
+        return -EINVAL;
+
+    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;
+
+    if (key & 1)
+        *type = SND_CTL_ELEM_TYPE_BOOLEAN;
+    else
+        *type = SND_CTL_ELEM_TYPE_INTEGER;
+
+    *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;
+
+finish:
+    pa_threaded_mainloop_unlock(ctl->p->mainloop);
+
+    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)
+{
+    *istep = 1;
+    *imin = 0;
+    *imax = PA_VOLUME_NORM;
+
+    return 0;
+}
+
+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;
+}
+
+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;
+}
+
+static void pulse_subscribe_events(snd_ctl_ext_t *ext, int subscribe)
+{
+    snd_ctl_pulse_t *ctl = ext->private_data;
+
+    assert(ctl);
+
+    pa_threaded_mainloop_lock(ctl->p->mainloop);
+
+    ctl->subscribed = !!(subscribe & SND_CTL_EVENT_MASK_VALUE);
+
+    pa_threaded_mainloop_unlock(ctl->p->mainloop);
+}
+
+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;
+
+    if (!ctl->updated)
+        pulse_poll_deactivate(ctl->p);
+
+    err = 1;
+
+finish:
+    pa_threaded_mainloop_unlock(ctl->p->mainloop);
+
+    return err;
+}
+
+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);
+
+    pa_threaded_mainloop_lock(ctl->p->mainloop);
+
+    count = pulse_poll_descriptors_count(ctl->p);
+
+    pa_threaded_mainloop_unlock(ctl->p->mainloop);
+
+    return count;
+}
+
+static int pulse_ctl_poll_descriptors(snd_ctl_ext_t *ext, struct pollfd *pfd, unsigned int space)
+{
+    int num;
+
+	snd_ctl_pulse_t *ctl = ext->private_data;
+
+    assert(ctl);
+    assert(ctl->p);
+
+    pa_threaded_mainloop_lock(ctl->p->mainloop);
+
+    num = pulse_poll_descriptors(ctl->p, pfd, space);
+    if (num < 0)
+        goto finish;
+
+finish:
+    pa_threaded_mainloop_unlock(ctl->p->mainloop);
+
+    return num;
+}
+
+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);
+
+    pa_threaded_mainloop_lock(ctl->p->mainloop);
+
+    err = pulse_poll_revents(ctl->p, pfd, nfds, revents);
+    if (err < 0)
+        goto finish;
+
+    *revents = 0;
+
+    if (ctl->updated)
+        *revents |= POLLIN;
+
+finish:
+    pa_threaded_mainloop_unlock(ctl->p->mainloop);
+
+    return err;
+}
+
+static void pulse_close(snd_ctl_ext_t *ext)
+{
+    snd_ctl_pulse_t *ctl = ext->private_data;
+
+    assert(ctl);
+
+    if (ctl->p)
+        pulse_free(ctl->p);
+
+    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,
+};
+
+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;
+
+    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);
+
+    pa_threaded_mainloop_signal(ctl->p->mainloop, 0);
+}
+
+SND_CTL_PLUGIN_DEFINE_FUNC(pulse)
+{
+	snd_config_iterator_t i, next;
+	const char *server = NULL;
+	const char *device = NULL;
+	const char *source = NULL;
+	const char *sink = NULL;
+	int err;
+	snd_ctl_pulse_t *ctl;
+    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)
+			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;
+        }
+		SNDERR("Unknown field %s", id);
+		return -EINVAL;
+	}
+
+	ctl = calloc(1, sizeof(*ctl));
+
+    ctl->p = pulse_new();
+    if (!ctl->p) {
+        err = -EIO;
+        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 (sink)
+        ctl->sink = strdup(sink);
+    else if (device)
+        ctl->sink = strdup(device);
+
+    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);
+
+        pa_operation_unref(o);
+
+        pa_threaded_mainloop_unlock(ctl->p->mainloop);
+
+        if (err < 0)
+            goto error;
+    }
+
+    pa_threaded_mainloop_lock(ctl->p->mainloop);
+
+    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);
+
+    err = pulse_wait_operation(ctl->p, o);
+
+    pa_operation_unref(o);
+
+    pa_threaded_mainloop_unlock(ctl->p->mainloop);
+
+    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, "Polypaudio plugin", sizeof(ctl->ext.driver) - 1);
+    strncpy(ctl->ext.name, "Polypaudio", sizeof(ctl->ext.name) - 1);
+    strncpy(ctl->ext.longname, "Polypaudio", sizeof(ctl->ext.longname) - 1);
+    strncpy(ctl->ext.mixername, "Polypaudio", 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;
+
+    *handlep = ctl->ext.handle;
+
+    return 0;
+
+error:
+    if (ctl->source)
+        free(ctl->source);
+    if (ctl->sink)
+        free(ctl->sink);
+
+    if (ctl->p)
+        pulse_free(ctl->p);
+
+	free(ctl);
+
+	return err;
+}
+
+SND_CTL_PLUGIN_SYMBOL(pulse);
diff --git a/pulse/pcm_pulse.c b/pulse/pcm_pulse.c
new file mode 100644
index 0000000..3f5247e
--- /dev/null
+++ b/pulse/pcm_pulse.c
@@ -0,0 +1,748 @@
+/*
+ * ALSA <-> PulseAudio PCM I/O plugin
+ *
+ * Copyright (c) 2006 by Pierre Ossman <ossman@cendio.se>
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+#include <stdio.h>
+#include <sys/poll.h>
+
+#include <alsa/asoundlib.h>
+#include <alsa/pcm_external.h>
+
+#include "pulse.h"
+
+typedef struct snd_pcm_pulse {
+	snd_pcm_ioplug_t io;
+
+    snd_pulse_t *p;
+
+    char *device;
+
+    /* Since ALSA expects a ring buffer we must do some voodoo. */
+    size_t last_size;
+    size_t ptr;
+
+    size_t offset;
+
+    pa_stream *stream;
+
+    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)
+{
+    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 (size > pcm->last_size) {
+        pcm->ptr += size - pcm->last_size;
+        pcm->ptr %= pcm->buffer_attr.maxlength;
+    }
+
+    pcm->last_size = size;
+}
+
+static int pulse_start(snd_pcm_ioplug_t *io)
+{
+	snd_pcm_pulse_t *pcm = io->private_data;
+	pa_operation *o;
+	int err = 0;
+
+    assert(pcm);
+    assert(pcm->p);
+
+    pa_threaded_mainloop_lock(pcm->p->mainloop);
+
+    assert(pcm->stream);
+
+    err = pulse_check_connection(pcm->p);
+    if (err < 0)
+        goto finish;
+
+    o = pa_stream_cork(pcm->stream, 0, pulse_stream_success_cb, pcm->p);
+    assert(o);
+
+    err = pulse_wait_operation(pcm->p, o);
+
+    pa_operation_unref(o);
+
+    if (err < 0) {
+        err = -EIO;
+        goto finish;
+    }
+
+finish:
+    pa_threaded_mainloop_unlock(pcm->p->mainloop);
+
+	return err;
+}
+
+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);
+
+    pa_threaded_mainloop_lock(pcm->p->mainloop);
+
+    assert(pcm->stream);
+
+    err = pulse_check_connection(pcm->p);
+    if (err < 0)
+        goto finish;
+
+    o = pa_stream_flush(pcm->stream, pulse_stream_success_cb, pcm->p);
+    assert(o);
+
+    err = pulse_wait_operation(pcm->p, o);
+
+    pa_operation_unref(o);
+
+    if (err < 0) {
+        err = -EIO;
+        goto finish;
+    }
+
+    o = pa_stream_cork(pcm->stream, 1, pulse_stream_success_cb, pcm->p);
+    assert(o);
+
+    err = pulse_wait_operation(pcm->p, o);
+
+    pa_operation_unref(o);
+
+    if (err < 0) {
+        err = -EIO;
+        goto finish;
+    }
+
+finish:
+    pa_threaded_mainloop_unlock(pcm->p->mainloop);
+
+	return err;
+}
+
+int pulse_drain(snd_pcm_ioplug_t *io)
+{
+    snd_pcm_pulse_t *pcm = io->private_data;
+	pa_operation *o;
+	int err = 0;
+
+    assert(pcm);
+    assert(pcm->p);
+
+    pa_threaded_mainloop_lock(pcm->p->mainloop);
+
+    assert(pcm->stream);
+
+    err = pulse_check_connection(pcm->p);
+    if (err < 0)
+        goto finish;
+
+    o = pa_stream_drain(pcm->stream, pulse_stream_success_cb, pcm->p);
+    assert(o);
+
+    err = pulse_wait_operation(pcm->p, o);
+
+    pa_operation_unref(o);
+
+    if (err < 0) {
+        err = -EIO;
+        goto finish;
+    }
+
+finish:
+    pa_threaded_mainloop_unlock(pcm->p->mainloop);
+
+	return err;
+}
+
+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);
+
+    pa_threaded_mainloop_lock(pcm->p->mainloop);
+
+    assert(pcm->stream);
+
+    err = pulse_check_connection(pcm->p);
+    if (err < 0)
+        goto finish;
+
+    update_ptr(pcm);
+
+	err = snd_pcm_bytes_to_frames(io->pcm, pcm->ptr);
+
+finish:
+    pa_threaded_mainloop_unlock(pcm->p->mainloop);
+
+	return err;
+}
+
+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);
+
+    pa_threaded_mainloop_lock(pcm->p->mainloop);
+
+    assert(pcm->stream);
+
+    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));
+
+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)
+{
+	snd_pcm_pulse_t *pcm = io->private_data;
+	const char *buf;
+	int err = 0;
+
+    assert(pcm);
+    assert(pcm->p);
+
+    pa_threaded_mainloop_lock(pcm->p->mainloop);
+
+    assert(pcm->stream);
+
+    err = pulse_check_connection(pcm->p);
+    if (err < 0)
+        goto finish;
+
+    /* Make sure the buffer pointer is in sync */
+    update_ptr(pcm);
+
+    assert(pcm->last_size >= (size * pcm->frame_size));
+
+	buf = (char *)areas->addr + (areas->first + areas->step * offset) / 8;
+
+    pa_stream_write(pcm->stream, buf, size * pcm->frame_size, NULL, 0, 0);
+
+    /* Make sure the buffer pointer is in sync */
+    update_ptr(pcm);
+
+    if (pcm->last_size < pcm->buffer_attr.minreq)
+        pulse_poll_deactivate(pcm->p);
+
+    err = size;
+
+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)
+{
+	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);
+
+    pa_threaded_mainloop_lock(pcm->p->mainloop);
+
+    assert(pcm->stream);
+
+    err = pulse_check_connection(pcm->p);
+    if (err < 0)
+        goto finish;
+
+    /* Make sure the buffer pointer is in sync */
+    update_ptr(pcm);
+
+    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;
+
+        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;
+
+        memcpy(dst_buf, src_buf, frag_length);
+
+        if (pcm->offset == 0)
+            pa_stream_drop(pcm->stream);
+
+        dst_buf = (char*)dst_buf + frag_length;
+        remain_size -= frag_length;
+    }
+
+    /* Make sure the buffer pointer is in sync */
+    update_ptr(pcm);
+
+    if (pcm->last_size < pcm->buffer_attr.minreq)
+        pulse_poll_deactivate(pcm->p);
+
+    err = size - (remain_size / pcm->frame_size);
+
+finish:
+    pa_threaded_mainloop_unlock(pcm->p->mainloop);
+
+	return err;
+}
+
+static void stream_request_cb(pa_stream *p, size_t length, void *userdata)
+{
+    snd_pcm_pulse_t *pcm = userdata;
+
+    assert(pcm);
+    assert(pcm->p);
+
+    pulse_poll_activate(pcm->p);
+}
+
+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);
+
+    pa_threaded_mainloop_lock(pcm->p->mainloop);
+
+    count = pulse_poll_descriptors_count(pcm->p);
+
+    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)
+{
+	snd_pcm_pulse_t *pcm = io->private_data;
+	int err;
+
+    assert(pcm);
+    assert(pcm->p);
+
+    pa_threaded_mainloop_lock(pcm->p->mainloop);
+
+    err = pulse_poll_descriptors(pcm->p, pfd, space);
+
+    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)
+{
+	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;
+
+    *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);
+
+	return err;
+}
+
+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_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, "*** POLYPAUDIO: 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;
+
+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)
+{
+    snd_pcm_pulse_t *pcm = io->private_data;
+	int err = 0;
+
+    assert(pcm);
+    assert(pcm->p);
+
+    pa_threaded_mainloop_lock(pcm->p->mainloop);
+
+    assert(!pcm->stream);
+
+    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, "*** POLYPAUDIO: 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 * pcm->frame_size;
+    pcm->buffer_attr.tlength = io->buffer_size * pcm->frame_size;
+    pcm->buffer_attr.prebuf = 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)
+{
+	snd_pcm_pulse_t *pcm = io->private_data;
+
+    assert(pcm);
+
+    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);
+    }
+
+    pa_threaded_mainloop_unlock(pcm->p->mainloop);
+
+    if (pcm->p)
+        pulse_free(pcm->p);
+
+    if (pcm->device)
+        free(pcm->device);
+
+	free(pcm);
+
+	return 0;
+}
+
+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,
+};
+
+
+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,
+};
+
+
+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_RATE,
+        8000, 48000);
+    if (err < 0)
+        return err;
+
+    err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_PERIOD_BYTES,
+        1, 4294967295U);
+    if (err < 0)
+        return err;
+
+    err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_PERIODS,
+        2, 4294967295U);
+    if (err < 0)
+        return err;
+
+    err = snd_pcm_ioplug_set_param_minmax(io, SND_PCM_IOPLUG_HW_BUFFER_BYTES,
+        1, 4294967295U);
+    if (err < 0)
+        return err;
+
+    return 0;
+}
+
+SND_PCM_PLUGIN_DEFINE_FUNC(pulse)
+{
+	snd_config_iterator_t i, next;
+	const char *server = NULL;
+	const char *device = NULL;
+	int err;
+	snd_pcm_pulse_t *pcm;
+
+	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)
+			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;
+        }
+		SNDERR("Unknown field %s", id);
+		return -EINVAL;
+	}
+
+	pcm = calloc(1, sizeof(*pcm));
+
+    if (device)
+        pcm->device = strdup(device);
+
+    pcm->p = pulse_new();
+    if (!pcm->p) {
+        err = -EIO;
+        goto error;
+    }
+
+    err = pulse_connect(pcm->p, server);
+    if (err < 0)
+        goto error;
+
+	pcm->io.version = SND_PCM_IOPLUG_VERSION;
+	pcm->io.name = "ALSA <-> Polypaudio PCM I/O Plugin";
+	pcm->io.poll_fd = -1;
+	pcm->io.poll_events = 0;
+	pcm->io.mmap_rw = 0;
+	pcm->io.callback = stream == SND_PCM_STREAM_PLAYBACK ?
+		&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) {
+		snd_pcm_ioplug_delete(&pcm->io);
+        goto error;
+    }
+
+	*pcmp = pcm->io.pcm;
+	return 0;
+
+error:
+    if (pcm->p)
+        pulse_free(pcm->p);
+
+	free(pcm);
+
+	return err;
+}
+
+SND_PCM_PLUGIN_SYMBOL(pulse);
diff --git a/pulse/pulse.c b/pulse/pulse.c
new file mode 100644
index 0000000..fd80d9c
--- /dev/null
+++ b/pulse/pulse.c
@@ -0,0 +1,260 @@
+/*
+ * ALSA <-> PulseAudio plugins
+ *
+ * Copyright (c) 2006 by Pierre Ossman <ossman@cendio.se>
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <signal.h>
+#include <sys/poll.h>
+
+#include "pulse.h"
+
+int pulse_check_connection(snd_pulse_t *p)
+{
+    pa_context_state_t state;
+
+    assert(p && p->context && p->mainloop);
+
+    state = pa_context_get_state(p->context);
+
+    if (state != PA_CONTEXT_READY)
+        return -EIO;
+
+    return 0;
+}
+
+void pulse_stream_state_cb(pa_stream *s, void * userdata)
+{
+    snd_pulse_t *p = userdata;
+
+    assert(s);
+    assert(p);
+
+    pa_threaded_mainloop_signal(p->mainloop, 0);
+}
+
+void pulse_stream_success_cb(pa_stream *s, int success, void *userdata)
+{
+    snd_pulse_t *p = userdata;
+
+    assert(s);
+    assert(p);
+
+    pa_threaded_mainloop_signal(p->mainloop, 0);
+}
+
+void pulse_context_success_cb(pa_context *c, int success, void *userdata)
+{
+    snd_pulse_t *p = userdata;
+
+    assert(c);
+    assert(p);
+
+    pa_threaded_mainloop_signal(p->mainloop, 0);
+}
+
+int pulse_wait_operation(snd_pulse_t *p, pa_operation *o)
+{
+    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);
+
+    return 0;
+}
+
+int pulse_wait_stream_state(snd_pulse_t *p, pa_stream *stream, pa_stream_state_t target)
+{
+    pa_stream_state_t state;
+
+    assert(p && stream && (p->state == PULSE_STATE_READY) && p->mainloop);
+
+    while (1) {
+        state = pa_stream_get_state(stream);
+
+        if (state == PA_STREAM_FAILED)
+            return -EIO;
+
+        if (state == target)
+            break;
+
+        pa_threaded_mainloop_wait(p->mainloop);
+    }
+
+    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;
+    }
+}
+
+snd_pulse_t *pulse_new()
+{
+    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->state = PULSE_STATE_INIT;
+
+    if (pipe(fd)) {
+        free(p);
+        return NULL;
+    }
+
+    p->main_fd = fd[0];
+    p->thread_fd = fd[1];
+
+    fcntl(fd[0], F_SETFL, O_NONBLOCK);
+    fcntl(fd[1], F_SETFL, O_NONBLOCK);
+
+    signal(SIGPIPE, SIG_IGN); /* Yes, ugly as hell */
+
+    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_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);
+
+    return p;
+}
+
+void pulse_free(snd_pulse_t *p)
+{
+    pa_threaded_mainloop_stop(p->mainloop);
+
+    pa_context_unref(p->context);
+    pa_threaded_mainloop_free(p->mainloop);
+
+    close(p->thread_fd);
+    close(p->main_fd);
+
+    free(p);
+}
+
+int pulse_connect(snd_pulse_t *p, const char *server)
+{
+    int err;
+
+    assert(p && p->context && p->mainloop && (p->state == PULSE_STATE_INIT));
+
+    pa_threaded_mainloop_lock(p->mainloop);
+
+    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_threaded_mainloop_wait(p->mainloop);
+
+    if (pa_context_get_state(p->context) != PA_CONTEXT_READY)
+        goto error;
+
+    pa_threaded_mainloop_unlock(p->mainloop);
+
+    p->state = PULSE_STATE_READY;
+
+    return 0;
+
+error:
+    fprintf(stderr, "*** PULSEAUDIO: Unable to connect: %s\n",
+        pa_strerror(pa_context_errno(p->context)));
+
+    pa_threaded_mainloop_unlock(p->mainloop);
+
+    return -ECONNREFUSED;
+}
+
+void pulse_poll_activate(snd_pulse_t *p)
+{
+    assert(p);
+
+    write(p->thread_fd, "a", 1);
+}
+
+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);
+}
+
+int pulse_poll_descriptors_count(snd_pulse_t *p)
+{
+    assert(p);
+
+    if (p->main_fd >= 0)
+        return 1;
+    else
+        return 0;
+}
+
+int pulse_poll_descriptors(snd_pulse_t *p, struct pollfd *pfd, unsigned int space)
+{
+    assert(p);
+
+    assert(space >= 1);
+
+    pfd[0].fd = p->main_fd;
+    pfd[0].events = POLLIN;
+    pfd[0].revents = 0;
+
+    return 1;
+}
+
+int pulse_poll_revents(snd_pulse_t *p, struct pollfd *pfd, unsigned int nfds, unsigned short *revents)
+{
+    assert(p);
+
+    return 1;
+}
diff --git a/pulse/pulse.h b/pulse/pulse.h
new file mode 100644
index 0000000..ab53bcb
--- /dev/null
+++ b/pulse/pulse.h
@@ -0,0 +1,57 @@
+/*
+ * ALSA <-> PulseAudio plugins
+ *
+ * Copyright (c) 2006 by Pierre Ossman <ossman@cendio.se>
+ *
+ * This library is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ */
+
+#include <alsa/asoundlib.h>
+
+#include <pulse/pulseaudio.h>
+
+#define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0]))
+
+typedef struct snd_pulse {
+    pa_threaded_mainloop *mainloop;
+    pa_context *context;
+
+    int thread_fd, main_fd;
+
+    enum {
+        PULSE_STATE_INIT,
+        PULSE_STATE_READY,
+    } state;
+} snd_pulse_t;
+
+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);
+
+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);
+
+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);