if HAVE_JACK
JACKDIR = jack
endif
-if HAVE_POLYP
-POLYPDIR = polyp
+if HAVE_PULSE
+PULSEDIR = pulse
endif
if HAVE_SAMPLERATE
SAMPLERATEDIR = rate
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
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)
Makefile
oss/Makefile
jack/Makefile
- polyp/Makefile
+ pulse/Makefile
mix/Makefile
rate/Makefile
a52/Makefile
-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
-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.
+++ /dev/null
-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)
--- /dev/null
+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)
/*
- * ALSA <-> Polypaudio mixer control plugin
+ * ALSA <-> PulseAudio mixer control plugin
*
* Copyright (c) 2006 by Pierre Ossman <ossman@cendio.se>
*
#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;
int subscribed;
int updated;
-} snd_ctl_polyp_t;
+} snd_ctl_pulse_t;
#define SOURCE_VOL_NAME "Capture Volume"
#define SOURCE_MUTE_NAME "Capture Switch"
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);
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) {
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));
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);
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) {
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));
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);
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;
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;
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);
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);
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;
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)
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;
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;
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;
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;
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;
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;
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;
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);
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;
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;
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);
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;
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);
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;
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);
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);
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;
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) {
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;
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);
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);
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);
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);
/*
- * ALSA <-> Polypaudio PCM I/O plugin
+ * ALSA <-> PulseAudio PCM I/O plugin
*
* Copyright (c) 2006 by Pierre Ossman <ossman@cendio.se>
*
#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;
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;
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;
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);
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;
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);
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);
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;
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);
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);
assert(pcm->stream);
- err = polyp_check_connection(pcm->p);
+ err = pulse_check_connection(pcm->p);
if (err < 0)
goto 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;
assert(pcm->stream);
- err = polyp_check_connection(pcm->p);
+ err = pulse_check_connection(pcm->p);
if (err < 0)
goto 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;
assert(pcm->stream);
- err = polyp_check_connection(pcm->p);
+ err = pulse_check_connection(pcm->p);
if (err < 0)
goto finish;
update_ptr(pcm);
if (pcm->last_size < pcm->buffer_attr.minreq)
- polyp_poll_deactivate(pcm->p);
+ pulse_poll_deactivate(pcm->p);
err = size;
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;
assert(pcm->stream);
- err = polyp_check_connection(pcm->p);
+ err = pulse_check_connection(pcm->p);
if (err < 0)
goto finish;
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);
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);
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);
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);
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;
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);
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;
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);
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);
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);
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);
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);
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;
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);
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;
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;
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);
/*
- * ALSA <-> Polypaudio plugins
+ * ALSA <-> PulseAudio plugins
*
* Copyright (c) 2006 by Pierre Ossman <ossman@cendio.se>
*
#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;
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);
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);
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);
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);
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);
}
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)) {
}
}
-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);
return p;
}
-void polyp_free(snd_polyp_t *p)
+void pulse_free(snd_pulse_t *p)
{
pa_threaded_mainloop_stop(p->mainloop);
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);
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);
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];
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);
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);
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);
/*
- * ALSA <-> Polypaudio plugins
+ * ALSA <-> PulseAudio plugins
*
* Copyright (c) 2006 by Pierre Ossman <ossman@cendio.se>
*
#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);
git://git.alsa-project.org / alsa-plugins.git / commitdiff