diff options
Diffstat (limited to 'polyp/pcm_polyp.c')
-rw-r--r-- | polyp/pcm_polyp.c | 626 |
1 files changed, 626 insertions, 0 deletions
diff --git a/polyp/pcm_polyp.c b/polyp/pcm_polyp.c new file mode 100644 index 0000000..e3ea506 --- /dev/null +++ b/polyp/pcm_polyp.c @@ -0,0 +1,626 @@ +/* + * ALSA <-> Polypaudio 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 "polyp.h" + +typedef struct snd_pcm_polyp { + snd_pcm_ioplug_t io; + + snd_polyp_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_polyp_t; + +static void update_ptr(snd_pcm_polyp_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 polyp_start(snd_pcm_ioplug_t *io) +{ + snd_pcm_polyp_t *pcm = io->private_data; + pa_operation *o; + int err; + + assert(pcm && pcm->p && pcm->stream); + + err = polyp_finish_poll(pcm->p); + if (err < 0) + return err; + + err = polyp_check_connection(pcm->p); + if (err < 0) + return err; + + o = pa_stream_cork(pcm->stream, 0, NULL, NULL); + assert(o); + + err = polyp_wait_operation(pcm->p, o); + + pa_operation_unref(o); + + if (err < 0) + return -EIO; + + return 0; +} + +static int polyp_stop(snd_pcm_ioplug_t *io) +{ + snd_pcm_polyp_t *pcm = io->private_data; + pa_operation *o; + int err; + + assert(pcm && pcm->p && pcm->stream); + + err = polyp_finish_poll(pcm->p); + if (err < 0) + return err; + + err = polyp_check_connection(pcm->p); + if (err < 0) + return err; + + o = pa_stream_flush(pcm->stream, NULL, NULL); + assert(o); + + err = polyp_wait_operation(pcm->p, o); + + pa_operation_unref(o); + + if (err < 0) + return -EIO; + + o = pa_stream_cork(pcm->stream, 1, NULL, NULL); + assert(o); + + err = polyp_wait_operation(pcm->p, o); + + pa_operation_unref(o); + + if (err < 0) + return -EIO; + + return 0; +} + +int polyp_drain(snd_pcm_ioplug_t *io) +{ + snd_pcm_polyp_t *pcm = io->private_data; + pa_operation *o; + int err; + + assert(pcm && pcm->p && pcm->stream); + + err = polyp_finish_poll(pcm->p); + if (err < 0) + return err; + + err = polyp_check_connection(pcm->p); + if (err < 0) + return err; + + o = pa_stream_drain(pcm->stream, NULL, NULL); + assert(o); + + err = polyp_wait_operation(pcm->p, o); + + pa_operation_unref(o); + + if (err < 0) + return -EIO; + + return 0; +} + +static snd_pcm_sframes_t polyp_pointer(snd_pcm_ioplug_t *io) +{ + snd_pcm_polyp_t *pcm = io->private_data; + int err; + + assert(pcm && pcm->p && pcm->stream); + + err = polyp_finish_poll(pcm->p); + if (err < 0) + return err; + + err = polyp_check_connection(pcm->p); + if (err < 0) + return err; + + update_ptr(pcm); + + err = polyp_start_poll(pcm->p); + if (err < 0) + return err; + + return snd_pcm_bytes_to_frames(io->pcm, pcm->ptr); +} + +static snd_pcm_sframes_t polyp_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; + const char *buf; + int err; + + assert(pcm && pcm->p && pcm->stream); + + err = polyp_finish_poll(pcm->p); + if (err < 0) + return err; + + err = polyp_check_connection(pcm->p); + if (err < 0) + return err; + + /* 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); + + /* Make sure the buffer pointer is in sync */ + update_ptr(pcm); + + return size; +} + +static snd_pcm_sframes_t polyp_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; + void *dst_buf, *src_buf; + size_t remain_size, frag_length; + int err; + + assert(pcm && pcm->p && pcm->stream); + + err = polyp_finish_poll(pcm->p); + if (err < 0) + return err; + + err = polyp_check_connection(pcm->p); + if (err < 0) + return err; + + /* 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, (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); + + return size - (remain_size / pcm->frame_size); +} + +static int polyp_pcm_poll_descriptors_count(snd_pcm_ioplug_t *io) +{ + snd_pcm_polyp_t *pcm = io->private_data; + + assert(pcm && pcm->p); + + return polyp_poll_descriptors_count(pcm->p); +} + +static int polyp_pcm_poll_descriptors(snd_pcm_ioplug_t *io, struct pollfd *pfd, unsigned int space) +{ + snd_pcm_polyp_t *pcm = io->private_data; + + assert(pcm && pcm->p); + + return polyp_poll_descriptors(pcm->p, pfd, space); +} + +static int polyp_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; + int err; + + assert(pcm && pcm->p); + + err = polyp_poll_revents(pcm->p, pfd, nfds, revents); + if (err < 0) + return err; + + *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 |= POLLIN; + else + *revents |= POLLOUT; + } + + return 0; +} + +static int polyp_prepare(snd_pcm_ioplug_t *io) +{ + snd_pcm_polyp_t *pcm = io->private_data; + int err; + pa_stream_state_t state; + + assert(pcm && pcm->p); + + err = polyp_finish_poll(pcm->p); + if (err < 0) + return err; + + if (pcm->stream) { + pa_stream_unref(pcm->stream); + pcm->stream = NULL; + } + + err = polyp_check_connection(pcm->p); + if (err < 0) + return err; + + assert(pcm->stream == NULL); + + if (io->stream == SND_PCM_STREAM_PLAYBACK) + pcm->stream = pa_stream_new(pcm->p->context, "ALSA Playback", &pcm->ss, NULL); + else + pcm->stream = pa_stream_new(pcm->p->context, "ALSA Capture", &pcm->ss, NULL); + assert(pcm->stream); + + if (io->stream == SND_PCM_STREAM_PLAYBACK) + pa_stream_connect_playback(pcm->stream, pcm->device, &pcm->buffer_attr, 0, NULL); + else + pa_stream_connect_record(pcm->stream, pcm->device, &pcm->buffer_attr, 0); + + while (1) { + state = pa_stream_get_state(pcm->stream); + + if (state == PA_STREAM_FAILED) + goto error; + + if (state == PA_STREAM_READY) + break; + + err = pa_mainloop_iterate(pcm->p->mainloop, 1, NULL); + if (err < 0) + return -EIO; + } + + pcm->last_size = 0; + pcm->ptr = 0; + pcm->offset = 0; + + return 0; + +error: + fprintf(stderr, "*** POLYPAUDIO: Unable to create stream.\n"); + pa_stream_unref(pcm->stream); + pcm->stream = NULL; + return -EIO; +} + +static int polyp_hw_params(snd_pcm_ioplug_t *io, snd_pcm_hw_params_t *params) +{ + snd_pcm_polyp_t *pcm = io->private_data; + + assert(pcm && pcm->p && !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)); + return -EINVAL; + } + + 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; + + return 0; +} + +static int polyp_close(snd_pcm_ioplug_t *io) +{ + snd_pcm_polyp_t *pcm = io->private_data; + + assert(pcm); + + if (pcm->stream) + pa_stream_unref(pcm->stream); + + if (pcm->p) + polyp_free(pcm->p); + + if (pcm->device) + free(pcm->device); + + free(pcm); + + 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, + .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 polyp_capture_callback = { + .start = polyp_start, + .stop = polyp_stop, + .pointer = polyp_pointer, + .transfer = polyp_read, + .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 int polyp_hw_constraint(snd_pcm_polyp_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(polyp) +{ + snd_config_iterator_t i, next; + const char *server = NULL; + const char *device = NULL; + int err; + snd_pcm_polyp_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 = polyp_new(); + assert(pcm->p); + + err = polyp_connect(pcm->p, server); + if (err < 0) + goto error; + + err = polyp_start_thread(pcm->p); + 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 ? + &polyp_playback_callback : &polyp_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); + if (err < 0) { + snd_pcm_ioplug_delete(&pcm->io); + goto error; + } + + *pcmp = pcm->io.pcm; + return 0; + +error: + if (pcm->p) + polyp_free(pcm->p); + + free(pcm); + + return err; +} + +SND_PCM_PLUGIN_SYMBOL(polyp); |