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>

10 files changed, 261 insertions, 261 deletions

diff --git a/Makefile.am b/Makefile.am
index 8cef8bd..faa3c8e 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,8 +1,8 @@
 if HAVE_JACK
 JACKDIR = jack
 endif
-if HAVE_POLYP
-POLYPDIR = polyp
+if HAVE_PULSE
+PULSEDIR = pulse
 endif
 if HAVE_SAMPLERATE
 SAMPLERATEDIR = rate
@@ -11,7 +11,7 @@ if HAVE_AVCODEC
 A52DIR = a52
 endif
 
-SUBDIRS = oss mix $(JACKDIR) $(POLYPDIR) $(SAMPLERATEDIR) $(A52DIR) doc
+SUBDIRS = oss mix $(JACKDIR) $(PULSEDIR) $(SAMPLERATEDIR) $(A52DIR) doc
 EXTRA_DIST = hgcompile version COPYING.GPL
 AUTOMAKE_OPTIONS = foreign
 
diff --git a/configure.in b/configure.in
index 831423d..3f3142e 100644
--- a/configure.in
+++ b/configure.in
@@ -16,8 +16,8 @@ AC_CHECK_LIB(asound, snd_pcm_ioplug_create,,
 PKG_CHECK_MODULES(JACK, jack >= 0.98, [HAVE_JACK=yes], [HAVE_JACK=no])
 AM_CONDITIONAL(HAVE_JACK, test x$HAVE_JACK = xyes)
 
-PKG_CHECK_MODULES(polypaudio, [polyplib >= 0.9.0], [HAVE_POLYP=yes], [HAVE_POLYP=no])
-AM_CONDITIONAL(HAVE_POLYP, test x$HAVE_POLYP = xyes)
+PKG_CHECK_MODULES(PulseAudio, [libpulse >= 0.9.2], [HAVE_PULSE=yes], [HAVE_PULSE=no])
+AM_CONDITIONAL(HAVE_PULSE, test x$HAVE_PULSE = xyes)
 
 PKG_CHECK_MODULES(samplerate, [samplerate], [HAVE_SAMPLERATE=yes], [HAVE_SAMPLERATE=no])
 AM_CONDITIONAL(HAVE_SAMPLERATE, test x$HAVE_SAMPLERATE = xyes)
@@ -49,7 +49,7 @@ AC_OUTPUT([
 	Makefile
 	oss/Makefile
 	jack/Makefile
-	polyp/Makefile
+	pulse/Makefile
 	mix/Makefile
 	rate/Makefile
 	a52/Makefile
diff --git a/doc/Makefile.am b/doc/Makefile.am
index df66ab8..efcac16 100644
--- a/doc/Makefile.am
+++ b/doc/Makefile.am
@@ -1,2 +1,2 @@
-EXTRA_DIST = README-pcm-oss README-jack README-polyp \
+EXTRA_DIST = README-pcm-oss README-jack README-pulse \
 	upmix.txt vdownmix.txt samplerate.txt a52.txt
diff --git a/doc/README-polyp b/doc/README-pulse
index de46c3d..d5431b4 100644
--- a/doc/README-polyp
+++ b/doc/README-pulse
@@ -1,35 +1,35 @@
-Polypaudio <--> ALSA plugins
+PulseAudio <--> ALSA plugins
 ============================
 
-This plugin allows any program that uses the ALSA API to access a Polypaudio
+This plugin allows any program that uses the ALSA API to access a PulseAudio
 sound daemon. In other words, native ALSA applications can play and record
 sound across a network.
 
 There are two plugins in the suite, one for PCM and one for mixer control. A
 typical configuration will look like:
 
-    pcm.polyp {
-        type polyp
+    pcm.pulse {
+        type pulse
     }
 
-    ctl.polyp {
-        type polyp
+    ctl.pulse {
+        type pulse
     }
 
-Put the above in ~/.asoundrc, or /etc/asound.conf, and use "polyp" as device
+Put the above in ~/.asoundrc, or /etc/asound.conf, and use "pulse" as device
 in your ALSA applications. For example:
 
-    % aplay -Dpolyp foo.wav
-    % amixer -Dpolyp
+    % aplay -Dpulse foo.wav
+    % amixer -Dpulse
 
-Polypaudio will accept more or less any format you throw at it. So a plug
+PulseAudio will accept more or less any format you throw at it. So a plug
 wrapper is unnecessary. Mixing is also handled so dmix will only cause a
 performance hit without any gain.
 
-The plugins will respect your Polypaudio environment variables (like
-POLYP_SERVER), but you can override these in ALSA's configuration files.
+The plugins will respect your PulseAudio environment variables (like
+PULSE_SERVER), but you can override these in ALSA's configuration files.
 
-Both plugins accept the "server" parameter, specifying which Polypaudio server
+Both plugins accept the "server" parameter, specifying which PulseAudio server
 to contact. Both also accept the "device" parameter, which indicate which
 source and sink to use.
 
diff --git a/polyp/Makefile.am b/polyp/Makefile.am
deleted file mode 100644
index 858de93..0000000
--- a/polyp/Makefile.am
+++ /dev/null
@@ -1,14 +0,0 @@
-asound_module_pcm_LTLIBRARIES = libasound_module_pcm_polyp.la
-asound_module_ctl_LTLIBRARIES = libasound_module_ctl_polyp.la
-
-asound_module_pcmdir = $(libdir)/alsa-lib
-asound_module_ctldir = $(libdir)/alsa-lib
-
-AM_CFLAGS = -Wall -g @ALSA_CFLAGS@ $(PTHREAD_CFLAGS) $(polypaudio_CFLAGS) -D_GNU_SOURCE
-AM_LDFLAGS = -module -avoid-version -export-dynamic
-
-libasound_module_pcm_polyp_la_SOURCES = pcm_polyp.c polyp.c polyp.h
-libasound_module_pcm_polyp_la_LIBADD = @ALSA_LIBS@ $(PTHREAD_LIBS) $(polypaudio_LIBS)
-
-libasound_module_ctl_polyp_la_SOURCES = ctl_polyp.c polyp.c polyp.h
-libasound_module_ctl_polyp_la_LIBADD = @ALSA_LIBS@ $(PTHREAD_LIBS) $(polypaudio_LIBS)
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/polyp/ctl_polyp.c b/pulse/ctl_pulse.c
index dea3fb8..06e087f 100644
--- a/polyp/ctl_polyp.c
+++ b/pulse/ctl_pulse.c
@@ -1,5 +1,5 @@
 /*
- * ALSA <-> Polypaudio mixer control plugin
+ * ALSA <-> PulseAudio mixer control plugin
  *
  * Copyright (c) 2006 by Pierre Ossman <ossman@cendio.se>
  *
@@ -23,12 +23,12 @@
 #include <alsa/asoundlib.h>
 #include <alsa/control_external.h>
 
-#include "polyp.h"
+#include "pulse.h"
 
-typedef struct snd_ctl_polyp {
+typedef struct snd_ctl_pulse {
 	snd_ctl_ext_t ext;
 
-    snd_polyp_t *p;
+    snd_pulse_t *p;
 
     char *source;
     char *sink;
@@ -41,7 +41,7 @@ typedef struct snd_ctl_polyp {
 
     int subscribed;
     int updated;
-} snd_ctl_polyp_t;
+} snd_ctl_pulse_t;
 
 #define SOURCE_VOL_NAME "Capture Volume"
 #define SOURCE_MUTE_NAME "Capture Switch"
@@ -55,7 +55,7 @@ typedef struct snd_ctl_polyp {
 
 static void sink_info_cb(pa_context *c, const pa_sink_info *i, int is_last, void *userdata)
 {
-    snd_ctl_polyp_t *ctl = (snd_ctl_polyp_t*)userdata;
+    snd_ctl_pulse_t *ctl = (snd_ctl_pulse_t*)userdata;
     int chan;
 
     assert(ctl);
@@ -70,7 +70,7 @@ static void sink_info_cb(pa_context *c, const pa_sink_info *i, int is_last, void
     if (!!ctl->sink_muted != !!i->mute) {
         ctl->sink_muted = i->mute;
         ctl->updated |= UPDATE_SINK_MUTE;
-        polyp_poll_activate(ctl->p);
+        pulse_poll_activate(ctl->p);
     }
 
     if (ctl->sink_volume.channels == i->volume.channels) {
@@ -82,7 +82,7 @@ static void sink_info_cb(pa_context *c, const pa_sink_info *i, int is_last, void
             return;
 
         ctl->updated |= UPDATE_SINK_VOL;
-        polyp_poll_activate(ctl->p);
+        pulse_poll_activate(ctl->p);
     }
 
     memcpy(&ctl->sink_volume, &i->volume, sizeof(pa_cvolume));
@@ -90,7 +90,7 @@ static void sink_info_cb(pa_context *c, const pa_sink_info *i, int is_last, void
 
 static void source_info_cb(pa_context *c, const pa_source_info *i, int is_last, void *userdata)
 {
-    snd_ctl_polyp_t *ctl = (snd_ctl_polyp_t*)userdata;
+    snd_ctl_pulse_t *ctl = (snd_ctl_pulse_t*)userdata;
     int chan;
 
     assert(ctl);
@@ -105,7 +105,7 @@ static void source_info_cb(pa_context *c, const pa_source_info *i, int is_last,
     if (!!ctl->source_muted != !!i->mute) {
         ctl->source_muted = i->mute;
         ctl->updated |= UPDATE_SOURCE_MUTE;
-        polyp_poll_activate(ctl->p);
+        pulse_poll_activate(ctl->p);
     }
 
     if (ctl->source_volume.channels == i->volume.channels) {
@@ -117,7 +117,7 @@ static void source_info_cb(pa_context *c, const pa_source_info *i, int is_last,
             return;
 
         ctl->updated |= UPDATE_SOURCE_VOL;
-        polyp_poll_activate(ctl->p);
+        pulse_poll_activate(ctl->p);
     }
 
     memcpy(&ctl->source_volume, &i->volume, sizeof(pa_cvolume));
@@ -126,7 +126,7 @@ static void source_info_cb(pa_context *c, const pa_source_info *i, int is_last,
 static void event_cb(pa_context *c, pa_subscription_event_type_t t,
     uint32_t index, void *userdata)
 {
-    snd_ctl_polyp_t *ctl = (snd_ctl_polyp_t*)userdata;
+    snd_ctl_pulse_t *ctl = (snd_ctl_pulse_t*)userdata;
     pa_operation *o;
 
     assert(ctl && ctl->p && ctl->p->context);
@@ -140,7 +140,7 @@ static void event_cb(pa_context *c, pa_subscription_event_type_t t,
     pa_operation_unref(o);
 }
 
-static int polyp_update_volume(snd_ctl_polyp_t *ctl)
+static int pulse_update_volume(snd_ctl_pulse_t *ctl)
 {
     int err;
     pa_operation *o;
@@ -149,14 +149,14 @@ static int polyp_update_volume(snd_ctl_polyp_t *ctl)
 
     o = pa_context_get_sink_info_by_name(ctl->p->context, ctl->sink,
         sink_info_cb, ctl);
-    err = polyp_wait_operation(ctl->p, o);
+    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 = polyp_wait_operation(ctl->p, o);
+    err = pulse_wait_operation(ctl->p, o);
     pa_operation_unref(o);
     if (err < 0)
         return err;
@@ -164,9 +164,9 @@ static int polyp_update_volume(snd_ctl_polyp_t *ctl)
     return 0;
 }
 
-static int polyp_elem_count(snd_ctl_ext_t *ext)
+static int pulse_elem_count(snd_ctl_ext_t *ext)
 {
-    snd_ctl_polyp_t *ctl = ext->private_data;
+    snd_ctl_pulse_t *ctl = ext->private_data;
     int count = 0;
 
     assert(ctl);
@@ -183,10 +183,10 @@ static int polyp_elem_count(snd_ctl_ext_t *ext)
     return count;
 }
 
-static int polyp_elem_list(snd_ctl_ext_t *ext, unsigned int offset,
+static int pulse_elem_list(snd_ctl_ext_t *ext, unsigned int offset,
     snd_ctl_elem_id_t *id)
 {
-    snd_ctl_polyp_t *ctl = ext->private_data;
+    snd_ctl_pulse_t *ctl = ext->private_data;
 
     assert(ctl);
 
@@ -212,7 +212,7 @@ static int polyp_elem_list(snd_ctl_ext_t *ext, unsigned int offset,
     return 0;
 }
 
-static snd_ctl_ext_key_t polyp_find_elem(snd_ctl_ext_t *ext,
+static snd_ctl_ext_key_t pulse_find_elem(snd_ctl_ext_t *ext,
     const snd_ctl_elem_id_t *id)
 {
     const char *name;
@@ -231,10 +231,10 @@ static snd_ctl_ext_key_t polyp_find_elem(snd_ctl_ext_t *ext,
     return SND_CTL_EXT_KEY_NOT_FOUND;
 }
 
-static int polyp_get_attribute(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
+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_polyp_t *ctl = ext->private_data;
+    snd_ctl_pulse_t *ctl = ext->private_data;
     int err = 0;
 
     if (key > 3)
@@ -245,11 +245,11 @@ static int polyp_get_attribute(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
 
     pa_threaded_mainloop_lock(ctl->p->mainloop);
 
-    err = polyp_check_connection(ctl->p);
+    err = pulse_check_connection(ctl->p);
     if (err < 0)
         goto finish;
 
-    err = polyp_update_volume(ctl);
+    err = pulse_update_volume(ctl);
     if (err < 0)
         goto finish;
 
@@ -273,7 +273,7 @@ finish:
     return err;
 }
 
-static int polyp_get_integer_info(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
+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;
@@ -283,10 +283,10 @@ static int polyp_get_integer_info(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
     return 0;
 }
 
-static int polyp_read_integer(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
+static int pulse_read_integer(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
     long *value)
 {
-    snd_ctl_polyp_t *ctl = ext->private_data;
+    snd_ctl_pulse_t *ctl = ext->private_data;
     int err = 0, i;
     pa_cvolume *vol = NULL;
 
@@ -295,11 +295,11 @@ static int polyp_read_integer(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
 
     pa_threaded_mainloop_lock(ctl->p->mainloop);
 
-    err = polyp_check_connection(ctl->p);
+    err = pulse_check_connection(ctl->p);
     if (err < 0)
         goto finish;
 
-    err = polyp_update_volume(ctl);
+    err = pulse_update_volume(ctl);
     if (err < 0)
         goto finish;
 
@@ -332,10 +332,10 @@ finish:
     return err;
 }
 
-static int polyp_write_integer(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
+static int pulse_write_integer(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
     long *value)
 {
-    snd_ctl_polyp_t *ctl = ext->private_data;
+    snd_ctl_pulse_t *ctl = ext->private_data;
     int err = 0, i;
     pa_operation *o;
     pa_cvolume *vol = NULL;
@@ -345,11 +345,11 @@ static int polyp_write_integer(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
 
     pa_threaded_mainloop_lock(ctl->p->mainloop);
 
-    err = polyp_check_connection(ctl->p);
+    err = pulse_check_connection(ctl->p);
     if (err < 0)
         goto finish;
 
-    err = polyp_update_volume(ctl);
+    err = pulse_update_volume(ctl);
     if (err < 0)
         goto finish;
 
@@ -388,20 +388,20 @@ static int polyp_write_integer(snd_ctl_ext_t *ext, snd_ctl_ext_key_t key,
 
         if (key == 0)
             o = pa_context_set_source_volume_by_name(ctl->p->context,
-                ctl->source, vol, polyp_context_success_cb, ctl->p);
+                ctl->source, vol, pulse_context_success_cb, ctl->p);
         else
             o = pa_context_set_sink_volume_by_name(ctl->p->context,
-                ctl->sink, vol, polyp_context_success_cb, ctl->p);
+                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, polyp_context_success_cb, ctl->p);
+                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, polyp_context_success_cb, ctl->p);
+                ctl->sink, ctl->sink_muted, pulse_context_success_cb, ctl->p);
     }
 
-    err = polyp_wait_operation(ctl->p, o);
+    err = pulse_wait_operation(ctl->p, o);
     pa_operation_unref(o);
     if (err < 0)
         goto finish;
@@ -414,9 +414,9 @@ finish:
     return err;
 }
 
-static void polyp_subscribe_events(snd_ctl_ext_t *ext, int subscribe)
+static void pulse_subscribe_events(snd_ctl_ext_t *ext, int subscribe)
 {
-    snd_ctl_polyp_t *ctl = ext->private_data;
+    snd_ctl_pulse_t *ctl = ext->private_data;
 
     assert(ctl);
 
@@ -427,10 +427,10 @@ static void polyp_subscribe_events(snd_ctl_ext_t *ext, int subscribe)
     pa_threaded_mainloop_unlock(ctl->p->mainloop);
 }
 
-static int polyp_read_event(snd_ctl_ext_t *ext, snd_ctl_elem_id_t *id,
+static int pulse_read_event(snd_ctl_ext_t *ext, snd_ctl_elem_id_t *id,
     unsigned int *event_mask)
 {
-    snd_ctl_polyp_t *ctl = ext->private_data;
+    snd_ctl_pulse_t *ctl = ext->private_data;
     int offset;
     int err = -EAGAIN;
 
@@ -447,23 +447,23 @@ static int polyp_read_event(snd_ctl_ext_t *ext, snd_ctl_elem_id_t *id,
         offset = 0;
 
     if (ctl->updated & UPDATE_SOURCE_VOL) {
-        polyp_elem_list(ext, 0, id);
+        pulse_elem_list(ext, 0, id);
         ctl->updated &= ~UPDATE_SOURCE_VOL;
     } else if (ctl->updated & UPDATE_SOURCE_MUTE) {
-        polyp_elem_list(ext, 1, id);
+        pulse_elem_list(ext, 1, id);
         ctl->updated &= ~UPDATE_SOURCE_MUTE;
     } else if (ctl->updated & UPDATE_SINK_VOL) {
-        polyp_elem_list(ext, offset + 0, id);
+        pulse_elem_list(ext, offset + 0, id);
         ctl->updated &= ~UPDATE_SINK_VOL;
     } else if (ctl->updated & UPDATE_SINK_MUTE) {
-        polyp_elem_list(ext, offset + 1, id);
+        pulse_elem_list(ext, offset + 1, id);
         ctl->updated &= ~UPDATE_SINK_MUTE;
     }
 
     *event_mask = SND_CTL_EVENT_MASK_VALUE;
 
     if (!ctl->updated)
-        polyp_poll_deactivate(ctl->p);
+        pulse_poll_deactivate(ctl->p);
 
     err = 1;
 
@@ -473,9 +473,9 @@ finish:
     return err;
 }
 
-static int polyp_ctl_poll_descriptors_count(snd_ctl_ext_t *ext)
+static int pulse_ctl_poll_descriptors_count(snd_ctl_ext_t *ext)
 {
-	snd_ctl_polyp_t *ctl = ext->private_data;
+	snd_ctl_pulse_t *ctl = ext->private_data;
 	int count;
 
     assert(ctl);
@@ -483,25 +483,25 @@ static int polyp_ctl_poll_descriptors_count(snd_ctl_ext_t *ext)
 
     pa_threaded_mainloop_lock(ctl->p->mainloop);
 
-    count = polyp_poll_descriptors_count(ctl->p);
+    count = pulse_poll_descriptors_count(ctl->p);
 
     pa_threaded_mainloop_unlock(ctl->p->mainloop);
 
     return count;
 }
 
-static int polyp_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;
 
-	snd_ctl_polyp_t *ctl = ext->private_data;
+	snd_ctl_pulse_t *ctl = ext->private_data;
 
     assert(ctl);
     assert(ctl->p);
 
     pa_threaded_mainloop_lock(ctl->p->mainloop);
 
-    num = polyp_poll_descriptors(ctl->p, pfd, space);
+    num = pulse_poll_descriptors(ctl->p, pfd, space);
     if (num < 0)
         goto finish;
 
@@ -511,9 +511,9 @@ finish:
     return num;
 }
 
-static int polyp_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_polyp_t *ctl = ext->private_data;
+	snd_ctl_pulse_t *ctl = ext->private_data;
 	int err = 0;
 
     assert(ctl);
@@ -521,7 +521,7 @@ static int polyp_ctl_poll_revents(snd_ctl_ext_t *ext, struct pollfd *pfd, unsign
 
     pa_threaded_mainloop_lock(ctl->p->mainloop);
 
-    err = polyp_poll_revents(ctl->p, pfd, nfds, revents);
+    err = pulse_poll_revents(ctl->p, pfd, nfds, revents);
     if (err < 0)
         goto finish;
 
@@ -536,14 +536,14 @@ finish:
     return err;
 }
 
-static void polyp_close(snd_ctl_ext_t *ext)
+static void pulse_close(snd_ctl_ext_t *ext)
 {
-    snd_ctl_polyp_t *ctl = ext->private_data;
+    snd_ctl_pulse_t *ctl = ext->private_data;
 
     assert(ctl);
 
     if (ctl->p)
-        polyp_free(ctl->p);
+        pulse_free(ctl->p);
 
     if (ctl->source)
         free(ctl->source);
@@ -553,25 +553,25 @@ static void polyp_close(snd_ctl_ext_t *ext)
 	free(ctl);
 }
 
-static snd_ctl_ext_callback_t polyp_ext_callback = {
-    .elem_count = polyp_elem_count,
-    .elem_list = polyp_elem_list,
-    .find_elem = polyp_find_elem,
-    .get_attribute = polyp_get_attribute,
-    .get_integer_info = polyp_get_integer_info,
-    .read_integer = polyp_read_integer,
-    .write_integer = polyp_write_integer,
-    .subscribe_events = polyp_subscribe_events,
-    .read_event = polyp_read_event,
-    .poll_descriptors_count = polyp_ctl_poll_descriptors_count,
-    .poll_descriptors = polyp_ctl_poll_descriptors,
-    .poll_revents = polyp_ctl_poll_revents,
-    .close = polyp_close,
+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_polyp_t *ctl = (snd_ctl_polyp_t*)userdata;
+    snd_ctl_pulse_t *ctl = (snd_ctl_pulse_t*)userdata;
 
     assert(ctl && i);
 
@@ -583,7 +583,7 @@ static void server_info_cb(pa_context *c, const pa_server_info*i, void *userdata
     pa_threaded_mainloop_signal(ctl->p->mainloop, 0);
 }
 
-SND_CTL_PLUGIN_DEFINE_FUNC(polyp)
+SND_CTL_PLUGIN_DEFINE_FUNC(pulse)
 {
 	snd_config_iterator_t i, next;
 	const char *server = NULL;
@@ -591,7 +591,7 @@ SND_CTL_PLUGIN_DEFINE_FUNC(polyp)
 	const char *source = NULL;
 	const char *sink = NULL;
 	int err;
-	snd_ctl_polyp_t *ctl;
+	snd_ctl_pulse_t *ctl;
     pa_operation *o;
 
 	snd_config_for_each(i, next, conf) {
@@ -635,13 +635,13 @@ SND_CTL_PLUGIN_DEFINE_FUNC(polyp)
 
 	ctl = calloc(1, sizeof(*ctl));
 
-    ctl->p = polyp_new();
+    ctl->p = pulse_new();
     if (!ctl->p) {
         err = -EIO;
         goto error;
     }
 
-    err = polyp_connect(ctl->p, server);
+    err = pulse_connect(ctl->p, server);
     if (err < 0)
         goto error;
 
@@ -659,7 +659,7 @@ SND_CTL_PLUGIN_DEFINE_FUNC(polyp)
         pa_threaded_mainloop_lock(ctl->p->mainloop);
 
         o = pa_context_get_server_info(ctl->p->context, server_info_cb, ctl);
-        err = polyp_wait_operation(ctl->p, o);
+        err = pulse_wait_operation(ctl->p, o);
 
         pa_operation_unref(o);
 
@@ -675,9 +675,9 @@ SND_CTL_PLUGIN_DEFINE_FUNC(polyp)
 
     o = pa_context_subscribe(ctl->p->context,
         PA_SUBSCRIPTION_MASK_SINK | PA_SUBSCRIPTION_MASK_SOURCE,
-        polyp_context_success_cb, ctl->p);
+        pulse_context_success_cb, ctl->p);
 
-    err = polyp_wait_operation(ctl->p, o);
+    err = pulse_wait_operation(ctl->p, o);
 
     pa_operation_unref(o);
 
@@ -688,13 +688,13 @@ SND_CTL_PLUGIN_DEFINE_FUNC(polyp)
 
     ctl->ext.version = SND_CTL_EXT_VERSION;
     ctl->ext.card_idx = 0;
-    strncpy(ctl->ext.id, "polyp", sizeof(ctl->ext.id) - 1);
+    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 = &polyp_ext_callback;
+    ctl->ext.callback = &pulse_ext_callback;
     ctl->ext.private_data = ctl;
 
     err = snd_ctl_ext_create(&ctl->ext, name, mode);
@@ -712,11 +712,11 @@ error:
         free(ctl->sink);
 
     if (ctl->p)
-        polyp_free(ctl->p);
+        pulse_free(ctl->p);
 
 	free(ctl);
 
 	return err;
 }
 
-SND_CTL_PLUGIN_SYMBOL(polyp);
+SND_CTL_PLUGIN_SYMBOL(pulse);
diff --git a/polyp/pcm_polyp.c b/pulse/pcm_pulse.c
index 44ae35e..3f5247e 100644
--- a/polyp/pcm_polyp.c
+++ b/pulse/pcm_pulse.c
@@ -1,5 +1,5 @@
 /*
- * ALSA <-> Polypaudio PCM I/O plugin
+ * ALSA <-> PulseAudio PCM I/O plugin
  *
  * Copyright (c) 2006 by Pierre Ossman <ossman@cendio.se>
  *
@@ -24,12 +24,12 @@
 #include <alsa/asoundlib.h>
 #include <alsa/pcm_external.h>
 
-#include "polyp.h"
+#include "pulse.h"
 
-typedef struct snd_pcm_polyp {
+typedef struct snd_pcm_pulse {
 	snd_pcm_ioplug_t io;
 
-    snd_polyp_t *p;
+    snd_pulse_t *p;
 
     char *device;
 
@@ -44,9 +44,9 @@ typedef struct snd_pcm_polyp {
     pa_sample_spec ss;
     unsigned int frame_size;
     pa_buffer_attr buffer_attr;
-} snd_pcm_polyp_t;
+} snd_pcm_pulse_t;
 
-static void update_ptr(snd_pcm_polyp_t *pcm)
+static void update_ptr(snd_pcm_pulse_t *pcm)
 {
     size_t size;
 
@@ -63,9 +63,9 @@ static void update_ptr(snd_pcm_polyp_t *pcm)
     pcm->last_size = size;
 }
 
-static int polyp_start(snd_pcm_ioplug_t *io)
+static int pulse_start(snd_pcm_ioplug_t *io)
 {
-	snd_pcm_polyp_t *pcm = io->private_data;
+	snd_pcm_pulse_t *pcm = io->private_data;
 	pa_operation *o;
 	int err = 0;
 
@@ -76,14 +76,14 @@ static int polyp_start(snd_pcm_ioplug_t *io)
 
     assert(pcm->stream);
 
-    err = polyp_check_connection(pcm->p);
+    err = pulse_check_connection(pcm->p);
     if (err < 0)
         goto finish;
 
-    o = pa_stream_cork(pcm->stream, 0, polyp_stream_success_cb, pcm->p);
+    o = pa_stream_cork(pcm->stream, 0, pulse_stream_success_cb, pcm->p);
     assert(o);
 
-    err = polyp_wait_operation(pcm->p, o);
+    err = pulse_wait_operation(pcm->p, o);
 
     pa_operation_unref(o);
 
@@ -98,9 +98,9 @@ finish:
 	return err;
 }
 
-static int polyp_stop(snd_pcm_ioplug_t *io)
+static int pulse_stop(snd_pcm_ioplug_t *io)
 {
-	snd_pcm_polyp_t *pcm = io->private_data;
+	snd_pcm_pulse_t *pcm = io->private_data;
 	pa_operation *o;
 	int err = 0;
 
@@ -111,14 +111,14 @@ static int polyp_stop(snd_pcm_ioplug_t *io)
 
     assert(pcm->stream);
 
-    err = polyp_check_connection(pcm->p);
+    err = pulse_check_connection(pcm->p);
     if (err < 0)
         goto finish;
 
-    o = pa_stream_flush(pcm->stream, polyp_stream_success_cb, pcm->p);
+    o = pa_stream_flush(pcm->stream, pulse_stream_success_cb, pcm->p);
     assert(o);
 
-    err = polyp_wait_operation(pcm->p, o);
+    err = pulse_wait_operation(pcm->p, o);
 
     pa_operation_unref(o);
 
@@ -127,10 +127,10 @@ static int polyp_stop(snd_pcm_ioplug_t *io)
         goto finish;
     }
 
-    o = pa_stream_cork(pcm->stream, 1, polyp_stream_success_cb, pcm->p);
+    o = pa_stream_cork(pcm->stream, 1, pulse_stream_success_cb, pcm->p);
     assert(o);
 
-    err = polyp_wait_operation(pcm->p, o);
+    err = pulse_wait_operation(pcm->p, o);
 
     pa_operation_unref(o);
 
@@ -145,9 +145,9 @@ finish:
 	return err;
 }
 
-int polyp_drain(snd_pcm_ioplug_t *io)
+int pulse_drain(snd_pcm_ioplug_t *io)
 {
-    snd_pcm_polyp_t *pcm = io->private_data;
+    snd_pcm_pulse_t *pcm = io->private_data;
 	pa_operation *o;
 	int err = 0;
 
@@ -158,14 +158,14 @@ int polyp_drain(snd_pcm_ioplug_t *io)
 
     assert(pcm->stream);
 
-    err = polyp_check_connection(pcm->p);
+    err = pulse_check_connection(pcm->p);
     if (err < 0)
         goto finish;
 
-    o = pa_stream_drain(pcm->stream, polyp_stream_success_cb, pcm->p);
+    o = pa_stream_drain(pcm->stream, pulse_stream_success_cb, pcm->p);
     assert(o);
 
-    err = polyp_wait_operation(pcm->p, o);
+    err = pulse_wait_operation(pcm->p, o);
 
     pa_operation_unref(o);
 
@@ -180,9 +180,9 @@ finish:
 	return err;
 }
 
-static snd_pcm_sframes_t polyp_pointer(snd_pcm_ioplug_t *io)
+static snd_pcm_sframes_t pulse_pointer(snd_pcm_ioplug_t *io)
 {
-	snd_pcm_polyp_t *pcm = io->private_data;
+	snd_pcm_pulse_t *pcm = io->private_data;
 	int err = 0;
 
     assert(pcm);
@@ -192,7 +192,7 @@ static snd_pcm_sframes_t polyp_pointer(snd_pcm_ioplug_t *io)
 
     assert(pcm->stream);
 
-    err = polyp_check_connection(pcm->p);
+    err = pulse_check_connection(pcm->p);
     if (err < 0)
         goto finish;
 
@@ -206,10 +206,10 @@ finish:
 	return err;
 }
 
-static int polyp_delay(snd_pcm_ioplug_t *io,
+static int pulse_delay(snd_pcm_ioplug_t *io,
                        snd_pcm_sframes_t *delayp)
 {
-	snd_pcm_polyp_t *pcm = io->private_data;
+	snd_pcm_pulse_t *pcm = io->private_data;
 	int err = 0;
 	pa_usec_t lat;
 
@@ -220,7 +220,7 @@ static int polyp_delay(snd_pcm_ioplug_t *io,
 
     assert(pcm->stream);
 
-    err = polyp_check_connection(pcm->p);
+    err = pulse_check_connection(pcm->p);
     if (err < 0)
         goto finish;
 
@@ -237,12 +237,12 @@ finish:
 	return err;
 }
 
-static snd_pcm_sframes_t polyp_write(snd_pcm_ioplug_t *io,
+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_polyp_t *pcm = io->private_data;
+	snd_pcm_pulse_t *pcm = io->private_data;
 	const char *buf;
 	int err = 0;
 
@@ -253,7 +253,7 @@ static snd_pcm_sframes_t polyp_write(snd_pcm_ioplug_t *io,
 
     assert(pcm->stream);
 
-    err = polyp_check_connection(pcm->p);
+    err = pulse_check_connection(pcm->p);
     if (err < 0)
         goto finish;
 
@@ -270,7 +270,7 @@ static snd_pcm_sframes_t polyp_write(snd_pcm_ioplug_t *io,
     update_ptr(pcm);
 
     if (pcm->last_size < pcm->buffer_attr.minreq)
-        polyp_poll_deactivate(pcm->p);
+        pulse_poll_deactivate(pcm->p);
 
     err = size;
 
@@ -280,12 +280,12 @@ finish:
 	return err;
 }
 
-static snd_pcm_sframes_t polyp_read(snd_pcm_ioplug_t *io,
+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_polyp_t *pcm = io->private_data;
+	snd_pcm_pulse_t *pcm = io->private_data;
 	void *dst_buf, *src_buf;
 	size_t remain_size, frag_length;
 	int err = 0;
@@ -297,7 +297,7 @@ static snd_pcm_sframes_t polyp_read(snd_pcm_ioplug_t *io,
 
     assert(pcm->stream);
 
-    err = polyp_check_connection(pcm->p);
+    err = pulse_check_connection(pcm->p);
     if (err < 0)
         goto finish;
 
@@ -334,7 +334,7 @@ static snd_pcm_sframes_t polyp_read(snd_pcm_ioplug_t *io,
     update_ptr(pcm);
 
     if (pcm->last_size < pcm->buffer_attr.minreq)
-        polyp_poll_deactivate(pcm->p);
+        pulse_poll_deactivate(pcm->p);
 
     err = size - (remain_size / pcm->frame_size);
 
@@ -346,17 +346,17 @@ finish:
 
 static void stream_request_cb(pa_stream *p, size_t length, void *userdata)
 {
-    snd_pcm_polyp_t *pcm = userdata;
+    snd_pcm_pulse_t *pcm = userdata;
 
     assert(pcm);
     assert(pcm->p);
 
-    polyp_poll_activate(pcm->p);
+    pulse_poll_activate(pcm->p);
 }
 
-static int polyp_pcm_poll_descriptors_count(snd_pcm_ioplug_t *io)
+static int pulse_pcm_poll_descriptors_count(snd_pcm_ioplug_t *io)
 {
-	snd_pcm_polyp_t *pcm = io->private_data;
+	snd_pcm_pulse_t *pcm = io->private_data;
 	int count;
 
     assert(pcm);
@@ -364,16 +364,16 @@ static int polyp_pcm_poll_descriptors_count(snd_pcm_ioplug_t *io)
 
     pa_threaded_mainloop_lock(pcm->p->mainloop);
 
-    count = polyp_poll_descriptors_count(pcm->p);
+    count = pulse_poll_descriptors_count(pcm->p);
 
     pa_threaded_mainloop_unlock(pcm->p->mainloop);
 
 	return count;
 }
 
-static int polyp_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_polyp_t *pcm = io->private_data;
+	snd_pcm_pulse_t *pcm = io->private_data;
 	int err;
 
     assert(pcm);
@@ -381,16 +381,16 @@ static int polyp_pcm_poll_descriptors(snd_pcm_ioplug_t *io, struct pollfd *pfd,
 
     pa_threaded_mainloop_lock(pcm->p->mainloop);
 
-    err = polyp_poll_descriptors(pcm->p, pfd, space);
+    err = pulse_poll_descriptors(pcm->p, pfd, space);
 
     pa_threaded_mainloop_unlock(pcm->p->mainloop);
 
 	return err;
 }
 
-static int polyp_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_polyp_t *pcm = io->private_data;
+	snd_pcm_pulse_t *pcm = io->private_data;
 	int err = 0;
 
     assert(pcm);
@@ -398,7 +398,7 @@ static int polyp_pcm_poll_revents(snd_pcm_ioplug_t *io, struct pollfd *pfd, unsi
 
     pa_threaded_mainloop_lock(pcm->p->mainloop);
 
-    err = polyp_poll_revents(pcm->p, pfd, nfds, revents);
+    err = pulse_poll_revents(pcm->p, pfd, nfds, revents);
     if (err < 0)
         goto finish;
 
@@ -425,10 +425,10 @@ finish:
 	return err;
 }
 
-static int polyp_prepare(snd_pcm_ioplug_t *io)
+static int pulse_prepare(snd_pcm_ioplug_t *io)
 {
     pa_channel_map map;
-    snd_pcm_polyp_t *pcm = io->private_data;
+    snd_pcm_pulse_t *pcm = io->private_data;
     int err = 0;
 
     assert(pcm);
@@ -438,12 +438,12 @@ static int polyp_prepare(snd_pcm_ioplug_t *io)
 
     if (pcm->stream) {
         pa_stream_disconnect(pcm->stream);
-        polyp_wait_stream_state(pcm->p, pcm->stream, PA_STREAM_TERMINATED);
+        pulse_wait_stream_state(pcm->p, pcm->stream, PA_STREAM_TERMINATED);
         pa_stream_unref(pcm->stream);
         pcm->stream = NULL;
     }
 
-    err = polyp_check_connection(pcm->p);
+    err = pulse_check_connection(pcm->p);
     if (err < 0)
         goto finish;
 
@@ -457,7 +457,7 @@ static int polyp_prepare(snd_pcm_ioplug_t *io)
             pa_channel_map_init_auto(&map, pcm->ss.channels, PA_CHANNEL_MAP_ALSA));
     assert(pcm->stream);
 
-    pa_stream_set_state_callback(pcm->stream, polyp_stream_state_cb, pcm->p);
+    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);
@@ -469,7 +469,7 @@ static int polyp_prepare(snd_pcm_ioplug_t *io)
 	        PA_STREAM_AUTO_TIMING_UPDATE | PA_STREAM_INTERPOLATE_TIMING);
     }
 
-    err = polyp_wait_stream_state(pcm->p, pcm->stream, PA_STREAM_READY);
+    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);
@@ -487,9 +487,9 @@ finish:
 	return err;
 }
 
-static int polyp_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_polyp_t *pcm = io->private_data;
+    snd_pcm_pulse_t *pcm = io->private_data;
 	int err = 0;
 
     assert(pcm);
@@ -545,9 +545,9 @@ finish:
 	return err;
 }
 
-static int polyp_close(snd_pcm_ioplug_t *io)
+static int pulse_close(snd_pcm_ioplug_t *io)
 {
-	snd_pcm_polyp_t *pcm = io->private_data;
+	snd_pcm_pulse_t *pcm = io->private_data;
 
     assert(pcm);
 
@@ -555,14 +555,14 @@ static int polyp_close(snd_pcm_ioplug_t *io)
 
     if (pcm->stream) {
         pa_stream_disconnect(pcm->stream);
-        polyp_wait_stream_state(pcm->p, pcm->stream, PA_STREAM_TERMINATED);
+        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)
-        polyp_free(pcm->p);
+        pulse_free(pcm->p);
 
     if (pcm->device)
         free(pcm->device);
@@ -572,38 +572,38 @@ static int polyp_close(snd_pcm_ioplug_t *io)
 	return 0;
 }
 
-static snd_pcm_ioplug_callback_t polyp_playback_callback = {
-    .start = polyp_start,
-    .stop = polyp_stop,
-    .drain = polyp_drain,
-    .pointer = polyp_pointer,
-    .transfer = polyp_write,
-    .delay = polyp_delay,
-    .poll_descriptors_count = polyp_pcm_poll_descriptors_count,
-    .poll_descriptors = polyp_pcm_poll_descriptors,
-    .poll_revents = polyp_pcm_poll_revents,
-    .prepare = polyp_prepare,
-    .hw_params = polyp_hw_params,
-    .close = polyp_close,
+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 polyp_capture_callback = {
-    .start = polyp_start,
-    .stop = polyp_stop,
-    .pointer = polyp_pointer,
-    .transfer = polyp_read,
-    .delay = polyp_delay,
-    .poll_descriptors_count = polyp_pcm_poll_descriptors_count,
-    .poll_descriptors = polyp_pcm_poll_descriptors,
-    .poll_revents = polyp_pcm_poll_revents,
-    .prepare = polyp_prepare,
-    .hw_params = polyp_hw_params,
-    .close = polyp_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 polyp_hw_constraint(snd_pcm_polyp_t *pcm)
+static int pulse_hw_constraint(snd_pcm_pulse_t *pcm)
 {
     snd_pcm_ioplug_t *io = &pcm->io;
 
@@ -666,13 +666,13 @@ static int polyp_hw_constraint(snd_pcm_polyp_t *pcm)
     return 0;
 }
 
-SND_PCM_PLUGIN_DEFINE_FUNC(polyp)
+SND_PCM_PLUGIN_DEFINE_FUNC(pulse)
 {
 	snd_config_iterator_t i, next;
 	const char *server = NULL;
 	const char *device = NULL;
 	int err;
-	snd_pcm_polyp_t *pcm;
+	snd_pcm_pulse_t *pcm;
 
 	snd_config_for_each(i, next, conf) {
 		snd_config_t *n = snd_config_iterator_entry(i);
@@ -704,13 +704,13 @@ SND_PCM_PLUGIN_DEFINE_FUNC(polyp)
     if (device)
         pcm->device = strdup(device);
 
-    pcm->p = polyp_new();
+    pcm->p = pulse_new();
     if (!pcm->p) {
         err = -EIO;
         goto error;
     }
 
-    err = polyp_connect(pcm->p, server);
+    err = pulse_connect(pcm->p, server);
     if (err < 0)
         goto error;
 
@@ -720,14 +720,14 @@ SND_PCM_PLUGIN_DEFINE_FUNC(polyp)
 	pcm->io.poll_events = 0;
 	pcm->io.mmap_rw = 0;
 	pcm->io.callback = stream == SND_PCM_STREAM_PLAYBACK ?
-		&polyp_playback_callback : &polyp_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 = polyp_hw_constraint(pcm);
+    err = pulse_hw_constraint(pcm);
     if (err < 0) {
 		snd_pcm_ioplug_delete(&pcm->io);
         goto error;
@@ -738,11 +738,11 @@ SND_PCM_PLUGIN_DEFINE_FUNC(polyp)
 
 error:
     if (pcm->p)
-        polyp_free(pcm->p);
+        pulse_free(pcm->p);
 
 	free(pcm);
 
 	return err;
 }
 
-SND_PCM_PLUGIN_SYMBOL(polyp);
+SND_PCM_PLUGIN_SYMBOL(pulse);
diff --git a/polyp/polyp.c b/pulse/pulse.c
index f5e5cac..fd80d9c 100644
--- a/polyp/polyp.c
+++ b/pulse/pulse.c
@@ -1,5 +1,5 @@
 /*
- * ALSA <-> Polypaudio plugins
+ * ALSA <-> PulseAudio plugins
  *
  * Copyright (c) 2006 by Pierre Ossman <ossman@cendio.se>
  *
@@ -23,9 +23,9 @@
 #include <signal.h>
 #include <sys/poll.h>
 
-#include "polyp.h"
+#include "pulse.h"
 
-int polyp_check_connection(snd_polyp_t *p)
+int pulse_check_connection(snd_pulse_t *p)
 {
     pa_context_state_t state;
 
@@ -39,9 +39,9 @@ int polyp_check_connection(snd_polyp_t *p)
     return 0;
 }
 
-void polyp_stream_state_cb(pa_stream *s, void * userdata)
+void pulse_stream_state_cb(pa_stream *s, void * userdata)
 {
-    snd_polyp_t *p = userdata;
+    snd_pulse_t *p = userdata;
 
     assert(s);
     assert(p);
@@ -49,9 +49,9 @@ void polyp_stream_state_cb(pa_stream *s, void * userdata)
     pa_threaded_mainloop_signal(p->mainloop, 0);
 }
 
-void polyp_stream_success_cb(pa_stream *s, int success, void *userdata)
+void pulse_stream_success_cb(pa_stream *s, int success, void *userdata)
 {
-    snd_polyp_t *p = userdata;
+    snd_pulse_t *p = userdata;
 
     assert(s);
     assert(p);
@@ -59,9 +59,9 @@ void polyp_stream_success_cb(pa_stream *s, int success, void *userdata)
     pa_threaded_mainloop_signal(p->mainloop, 0);
 }
 
-void polyp_context_success_cb(pa_context *c, int success, void *userdata)
+void pulse_context_success_cb(pa_context *c, int success, void *userdata)
 {
-    snd_polyp_t *p = userdata;
+    snd_pulse_t *p = userdata;
 
     assert(c);
     assert(p);
@@ -69,9 +69,9 @@ void polyp_context_success_cb(pa_context *c, int success, void *userdata)
     pa_threaded_mainloop_signal(p->mainloop, 0);
 }
 
-int polyp_wait_operation(snd_polyp_t *p, pa_operation *o)
+int pulse_wait_operation(snd_pulse_t *p, pa_operation *o)
 {
-    assert(p && o && (p->state == POLYP_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);
@@ -79,11 +79,11 @@ int polyp_wait_operation(snd_polyp_t *p, pa_operation *o)
     return 0;
 }
 
-int polyp_wait_stream_state(snd_polyp_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;
 
-    assert(p && stream && (p->state == POLYP_STATE_READY) && p->mainloop);
+    assert(p && stream && (p->state == PULSE_STATE_READY) && p->mainloop);
 
     while (1) {
         state = pa_stream_get_state(stream);
@@ -101,7 +101,7 @@ int polyp_wait_stream_state(snd_polyp_t *p, pa_stream *stream, pa_stream_state_t
 }
 
 static void context_state_cb(pa_context *c, void *userdata) {
-    snd_polyp_t *p = userdata;
+    snd_pulse_t *p = userdata;
     assert(c);
 
     switch (pa_context_get_state(c)) {
@@ -119,16 +119,16 @@ static void context_state_cb(pa_context *c, void *userdata) {
     }
 }
 
-snd_polyp_t *polyp_new()
+snd_pulse_t *pulse_new()
 {
-    snd_polyp_t *p;
+    snd_pulse_t *p;
 	int fd[2] = { -1, -1 };
 	char proc[PATH_MAX], buf[PATH_MAX + 20];
 
-    p = calloc(1, sizeof(snd_polyp_t));
+    p = calloc(1, sizeof(snd_pulse_t));
     assert(p);
 
-    p->state = POLYP_STATE_INIT;
+    p->state = PULSE_STATE_INIT;
 
     if (pipe(fd)) {
         free(p);
@@ -165,7 +165,7 @@ snd_polyp_t *polyp_new()
     return p;
 }
 
-void polyp_free(snd_polyp_t *p)
+void pulse_free(snd_pulse_t *p)
 {
     pa_threaded_mainloop_stop(p->mainloop);
 
@@ -178,11 +178,11 @@ void polyp_free(snd_polyp_t *p)
     free(p);
 }
 
-int polyp_connect(snd_polyp_t *p, const char *server)
+int pulse_connect(snd_pulse_t *p, const char *server)
 {
     int err;
 
-    assert(p && p->context && p->mainloop && (p->state == POLYP_STATE_INIT));
+    assert(p && p->context && p->mainloop && (p->state == PULSE_STATE_INIT));
 
     pa_threaded_mainloop_lock(p->mainloop);
 
@@ -199,12 +199,12 @@ int polyp_connect(snd_polyp_t *p, const char *server)
 
     pa_threaded_mainloop_unlock(p->mainloop);
 
-    p->state = POLYP_STATE_READY;
+    p->state = PULSE_STATE_READY;
 
     return 0;
 
 error:
-    fprintf(stderr, "*** POLYPAUDIO: Unable to connect: %s\n",
+    fprintf(stderr, "*** PULSEAUDIO: Unable to connect: %s\n",
         pa_strerror(pa_context_errno(p->context)));
 
     pa_threaded_mainloop_unlock(p->mainloop);
@@ -212,14 +212,14 @@ error:
     return -ECONNREFUSED;
 }
 
-void polyp_poll_activate(snd_polyp_t *p)
+void pulse_poll_activate(snd_pulse_t *p)
 {
     assert(p);
 
     write(p->thread_fd, "a", 1);
 }
 
-void polyp_poll_deactivate(snd_polyp_t *p)
+void pulse_poll_deactivate(snd_pulse_t *p)
 {
 	char buf[10];
 
@@ -229,7 +229,7 @@ void polyp_poll_deactivate(snd_polyp_t *p)
     while (read(p->main_fd, buf, sizeof(buf)) > 0);
 }
 
-int polyp_poll_descriptors_count(snd_polyp_t *p)
+int pulse_poll_descriptors_count(snd_pulse_t *p)
 {
     assert(p);
 
@@ -239,7 +239,7 @@ int polyp_poll_descriptors_count(snd_polyp_t *p)
         return 0;
 }
 
-int polyp_poll_descriptors(snd_polyp_t *p, struct pollfd *pfd, unsigned int space)
+int pulse_poll_descriptors(snd_pulse_t *p, struct pollfd *pfd, unsigned int space)
 {
     assert(p);
 
@@ -252,7 +252,7 @@ int polyp_poll_descriptors(snd_polyp_t *p, struct pollfd *pfd, unsigned int spac
     return 1;
 }
 
-int polyp_poll_revents(snd_polyp_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);
 
diff --git a/polyp/polyp.h b/pulse/pulse.h
index f210e18..ab53bcb 100644
--- a/polyp/polyp.h
+++ b/pulse/pulse.h
@@ -1,5 +1,5 @@
 /*
- * ALSA <-> Polypaudio plugins
+ * ALSA <-> PulseAudio plugins
  *
  * Copyright (c) 2006 by Pierre Ossman <ossman@cendio.se>
  *
@@ -20,38 +20,38 @@
 
 #include <alsa/asoundlib.h>
 
-#include <polyp/polypaudio.h>
+#include <pulse/pulseaudio.h>
 
 #define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0]))
 
-typedef struct snd_polyp {
+typedef struct snd_pulse {
     pa_threaded_mainloop *mainloop;
     pa_context *context;
 
     int thread_fd, main_fd;
 
     enum {
-        POLYP_STATE_INIT,
-        POLYP_STATE_READY,
+        PULSE_STATE_INIT,
+        PULSE_STATE_READY,
     } state;
-} snd_polyp_t;
+} snd_pulse_t;
 
-int polyp_check_connection(snd_polyp_t *p);
+int pulse_check_connection(snd_pulse_t *p);
 
-void polyp_stream_state_cb(pa_stream *s, void * userdata);
-void polyp_stream_success_cb(pa_stream *s, int success, void *userdata);
-void polyp_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 polyp_wait_operation(snd_polyp_t *p, pa_operation *o);
-int polyp_wait_stream_state(snd_polyp_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_polyp_t *polyp_new();
-void polyp_free(snd_polyp_t *p);
+snd_pulse_t *pulse_new();
+void pulse_free(snd_pulse_t *p);
 
-int polyp_connect(snd_polyp_t *p, const char *server);
+int pulse_connect(snd_pulse_t *p, const char *server);
 
-void polyp_poll_activate(snd_polyp_t *p);
-void polyp_poll_deactivate(snd_polyp_t *p);
-int polyp_poll_descriptors_count(snd_polyp_t *p);
-int polyp_poll_descriptors(snd_polyp_t *p, struct pollfd *pfd, unsigned int space);
-int polyp_poll_revents(snd_polyp_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);