/*
* 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
*/
/** @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 <config.h>
+#include "common.h"
#if HAVE_ALSA_ASOUNDLIB_H
-#include "types.h"
#include <poll.h>
#include <alsa/asoundlib.h>
-#include <assert.h>
#include <pthread.h>
#include <arpa/inet.h>
#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;
+ const struct packet *p;
-/** @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);
+ 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 */
}
}
~mdw / disorder / blobdiff