X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~mdw/git/disorder/blobdiff_plain/b28bddbb2d2b2f07364153df3b980605d9caa9d9..90ad6c6efcbcdb2d12ffe9abf232da980b9ea446:/clients/playrtp-alsa.c diff --git a/clients/playrtp-alsa.c b/clients/playrtp-alsa.c index 142f1ee..ac8ef7e 100644 --- a/clients/playrtp-alsa.c +++ b/clients/playrtp-alsa.c @@ -1,6 +1,6 @@ /* * This file is part of DisOrder. - * Copyright (C) 2007 Richard Kettlewell + * Copyright (C) 2008 Richard Kettlewell * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -19,6 +19,10 @@ */ /** @file clients/playrtp-alsa.c * @brief RTP player - ALSA support + * + * This has been rewritten to use the @ref alsabg.h interface and is therefore + * now closely modelled on @ref playrtp-coreaudio.c. Given a similar interface + * wrapping OSS the whole of playrtp could probably be greatly simplified. */ #include @@ -37,208 +41,63 @@ #include "vector.h" #include "heap.h" #include "playrtp.h" +#include "alsabg.h" -/** @brief PCM handle */ -static snd_pcm_t *pcm; - -/** @brief True when @ref pcm is up and running */ -static int playrtp_alsa_prepared = 1; - -static void playrtp_alsa_init(void) { - snd_pcm_hw_params_t *hwparams; - snd_pcm_sw_params_t *swparams; - /* Only support one format for now */ - const int sample_format = SND_PCM_FORMAT_S16_BE; - unsigned rate = 44100; - const int channels = 2; - const int samplesize = channels * sizeof(uint16_t); - snd_pcm_uframes_t pcm_bufsize = MAXSAMPLES * samplesize * 3; - /* If we can write more than this many samples we'll get a wakeup */ - const int avail_min = 256; - int err; - - /* Open ALSA */ - if((err = snd_pcm_open(&pcm, - device ? device : "default", - SND_PCM_STREAM_PLAYBACK, - SND_PCM_NONBLOCK))) - fatal(0, "error from snd_pcm_open: %d", err); - /* Set up 'hardware' parameters */ - snd_pcm_hw_params_alloca(&hwparams); - if((err = snd_pcm_hw_params_any(pcm, hwparams)) < 0) - fatal(0, "error from snd_pcm_hw_params_any: %d", err); - if((err = snd_pcm_hw_params_set_access(pcm, hwparams, - SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) - fatal(0, "error from snd_pcm_hw_params_set_access: %d", err); - if((err = snd_pcm_hw_params_set_format(pcm, hwparams, - sample_format)) < 0) - - fatal(0, "error from snd_pcm_hw_params_set_format (%d): %d", - sample_format, err); - if((err = snd_pcm_hw_params_set_rate_near(pcm, hwparams, &rate, 0)) < 0) - fatal(0, "error from snd_pcm_hw_params_set_rate (%d): %d", - rate, err); - if((err = snd_pcm_hw_params_set_channels(pcm, hwparams, - channels)) < 0) - fatal(0, "error from snd_pcm_hw_params_set_channels (%d): %d", - channels, err); - if((err = snd_pcm_hw_params_set_buffer_size_near(pcm, hwparams, - &pcm_bufsize)) < 0) - fatal(0, "error from snd_pcm_hw_params_set_buffer_size (%d): %d", - MAXSAMPLES * samplesize * 3, err); - if((err = snd_pcm_hw_params(pcm, hwparams)) < 0) - fatal(0, "error calling snd_pcm_hw_params: %d", err); - /* Set up 'software' parameters */ - snd_pcm_sw_params_alloca(&swparams); - if((err = snd_pcm_sw_params_current(pcm, swparams)) < 0) - fatal(0, "error calling snd_pcm_sw_params_current: %d", err); - if((err = snd_pcm_sw_params_set_avail_min(pcm, swparams, avail_min)) < 0) - fatal(0, "error calling snd_pcm_sw_params_set_avail_min %d: %d", - avail_min, err); - if((err = snd_pcm_sw_params(pcm, swparams)) < 0) - fatal(0, "error calling snd_pcm_sw_params: %d", err); -} - -/** @brief Wait until ALSA wants some audio */ -static void wait_alsa(void) { - struct pollfd fds[64]; - int nfds, err; - unsigned short events; - - for(;;) { - do { - if((nfds = snd_pcm_poll_descriptors(pcm, - fds, sizeof fds / sizeof *fds)) < 0) - fatal(0, "error calling snd_pcm_poll_descriptors: %d", nfds); - } while(poll(fds, nfds, -1) < 0 && errno == EINTR); - if((err = snd_pcm_poll_descriptors_revents(pcm, fds, nfds, &events))) - fatal(0, "error calling snd_pcm_poll_descriptors_revents: %d", err); - if(events & POLLOUT) - return; - } -} +/** @brief Callback from alsa_bg_collect() */ +static int playrtp_alsa_supply(void *dst, + unsigned supply_nsamples) { + unsigned samples_available; -/** @brief Play some sound via ALSA - * @param s Pointer to sample data - * @param n Number of samples - * @return 0 on success, -1 on non-fatal error - */ -static int playrtp_alsa_writei(const void *s, size_t n) { - /* Do the write */ - const snd_pcm_sframes_t frames_written = snd_pcm_writei(pcm, s, n / 2); - if(frames_written < 0) { - /* Something went wrong */ - switch(frames_written) { - case -EAGAIN: - return 0; - case -EPIPE: - error(0, "error calling snd_pcm_writei: %ld", - (long)frames_written); - return -1; - default: - fatal(0, "error calling snd_pcm_writei: %ld", - (long)frames_written); - } + pthread_mutex_lock(&lock); + const struct packet *p = playrtp_next_packet(); + if(p && contains(p, next_timestamp)) { + /* This packet is ready to play */ + const uint32_t packet_end = p->timestamp + p->nsamples; + const uint32_t offset = next_timestamp - p->timestamp; + const uint16_t *src = (void *)(p->samples_raw + offset); + samples_available = packet_end - next_timestamp; + if(samples_available > supply_nsamples) + samples_available = supply_nsamples; + next_timestamp += samples_available; + memcpy(dst, src, samples_available * sizeof (int16_t)); + /* We don't bother junking the packet - that'll be dealt with next time + * round */ } else { - /* Success */ - next_timestamp += frames_written * 2; - if(dump_buffer) { - snd_pcm_sframes_t count; - const int16_t *sp = s; - - for(count = 0; count < frames_written * 2; ++count) { - dump_buffer[dump_index++] = (int16_t)ntohs(*sp++); - dump_index %= dump_size; - } - } - return 0; - } -} - -/** @brief Play the relevant part of a packet - * @param p Packet to play - * @return 0 on success, -1 on non-fatal error - */ -static int playrtp_alsa_play(const struct packet *p) { - return playrtp_alsa_writei(p->samples_raw + next_timestamp - p->timestamp, - (p->timestamp + p->nsamples) - next_timestamp); -} - -/** @brief Play some silence - * @param p Next packet or NULL - * @return 0 on success, -1 on non-fatal error - */ -static int playrtp_alsa_infill(const struct packet *p) { - static const uint16_t zeros[INFILL_SAMPLES]; - size_t samples_available = INFILL_SAMPLES; - - if(p && samples_available > p->timestamp - next_timestamp) - samples_available = p->timestamp - next_timestamp; - return playrtp_alsa_writei(zeros, samples_available); -} - -static void playrtp_alsa_enable(void){ - int err; - - if(!playrtp_alsa_prepared) { - if((err = snd_pcm_prepare(pcm))) - fatal(0, "error calling snd_pcm_prepare: %d", err); - playrtp_alsa_prepared = 1; + /* No packet is ready to play (and there might be no packet at all) */ + samples_available = p ? p->timestamp - next_timestamp : supply_nsamples; + if(samples_available > supply_nsamples) + samples_available = supply_nsamples; + /*info("infill %d", samples_available);*/ + next_timestamp += samples_available; + /* Unlike Core Audio the buffer is not guaranteed to be 0-filled */ + memset(dst, 0, samples_available * sizeof (int16_t)); } -} - -/** @brief Reset ALSA state after we lost synchronization */ -static void playrtp_alsa_disable(int hard_reset) { - int err; - - if((err = snd_pcm_nonblock(pcm, 0))) - fatal(0, "error calling snd_pcm_nonblock: %d", err); - if(hard_reset) { - if((err = snd_pcm_drop(pcm))) - fatal(0, "error calling snd_pcm_drop: %d", err); - } else - if((err = snd_pcm_drain(pcm))) - fatal(0, "error calling snd_pcm_drain: %d", err); - if((err = snd_pcm_nonblock(pcm, 1))) - fatal(0, "error calling snd_pcm_nonblock: %d", err); - playrtp_alsa_prepared = 0; + pthread_mutex_unlock(&lock); + return samples_available; } void playrtp_alsa(void) { - int escape; - const struct packet *p; - - playrtp_alsa_init(); + alsa_bg_init(device ? device : "default", + playrtp_alsa_supply); pthread_mutex_lock(&lock); for(;;) { /* Wait for the buffer to fill up a bit */ playrtp_fill_buffer(); - playrtp_alsa_enable(); - escape = 0; + /* Start playing now */ info("Playing..."); - /* Keep playing until the buffer empties out, or ALSA tells us to get - * lost */ - while((nsamples >= minbuffer - || (nsamples > 0 - && contains(pheap_first(&packets), next_timestamp))) - && !escape) { - /* Wait for ALSA to ask us for more data */ - pthread_mutex_unlock(&lock); - wait_alsa(); - pthread_mutex_lock(&lock); - /* ALSA is ready for more data, find something to play */ - p = playrtp_next_packet(); - /* Play it or play some silence */ - if(contains(p, next_timestamp)) - escape = playrtp_alsa_play(p); - else - escape = playrtp_alsa_infill(p); + next_timestamp = pheap_first(&packets)->timestamp; + active = 1; + alsa_bg_enable(); + /* Wait until the buffer empties out */ + while(nsamples >= minbuffer + || (nsamples > 0 + && contains(pheap_first(&packets), next_timestamp))) { + pthread_cond_wait(&cond, &lock); } + /* Stop playing for a bit until the buffer re-fills */ + alsa_bg_disable(); active = 0; - /* We stop playing for a bit until the buffer re-fills */ - pthread_mutex_unlock(&lock); - playrtp_alsa_disable(escape); - pthread_mutex_lock(&lock); + /* Go back round */ } }