static time_t last_report; /* when we last reported */
static int paused; /* pause status */
-static ao_sample_format pcm_format; /* current format if aodev != 0 */
static size_t bpf; /* bytes per frame */
static struct pollfd fds[NFDS]; /* if we need more than that */
static int fdno; /* fd number */
static size_t bufsize; /* buffer size */
#if API_ALSA
-static snd_pcm_t *pcm; /* current pcm handle */
+/** @brief The current PCM handle */
+static snd_pcm_t *pcm;
static snd_pcm_uframes_t last_pcm_bufsize; /* last seen buffer size */
+static ao_sample_format pcm_format; /* current format if aodev != 0 */
#endif
-static int ready; /* ready to send audio */
+
+/** @brief Ready to send audio
+ *
+ * This is set when the destination is ready to receive audio. Generally
+ * this implies that the sound device is open. In the ALSA backend it
+ * does @b not necessarily imply that is has the right sample format.
+ */
+static int ready;
+
static int forceplay; /* frames to force play */
static int cmdfd = -1; /* child process input */
static int bfd = -1; /* broadcast FD */
* @c -1 terminates the list.
*/
int backend;
+
+ /** @brief Flags
+ *
+ * Possible values
+ * - @ref FIXED_FORMAT
+ */
+ unsigned flags;
+/** @brief Lock to configured sample format */
+#define FIXED_FORMAT 0x0001
/** @brief Initialization
*
- * Called once at startup.
+ * Called once at startup. This is responsible for one-time setup
+ * operations, for instance opening a network socket to transmit to.
+ *
+ * When writing to a native sound API this might @b not imply opening the
+ * native sound device - that might be done by @c activate below.
*/
void (*init)(void);
* @return 0 on success, non-0 on error
*
* Called to activate the output device.
+ *
+ * After this function succeeds, @ref ready should be non-0. As well as
+ * opening the audio device, this function is responsible for reconfiguring
+ * if it necessary to cope with different samples formats (for backends that
+ * don't demand a single fixed sample format for the lifetime of the server).
*/
int (*activate)(void);
+
+ /** @brief Play sound
+ * @param frames Number of frames to play
+ * @return Number of frames actually played
+ */
+ size_t (*play)(size_t frames);
+
+ /** @brief Deactivation
+ *
+ * Called to deactivate the sound device. This is the inverse of
+ * @c activate above.
+ */
+ void (*deactivate)(void);
};
/** @brief Selected backend */
* to a sox invocation, which performs the required translation.
*/
static void enable_translation(struct track *t) {
- switch(config->speaker_backend) {
- case BACKEND_COMMAND:
- case BACKEND_NETWORK:
- /* These backends need a specific sample format */
- break;
- case BACKEND_ALSA:
- /* ALSA can cope */
- return;
- }
- if(!formats_equal(&t->format, &config->sample_format)) {
+ if((backend->flags & FIXED_FORMAT)
+ && !formats_equal(&t->format, &config->sample_format)) {
char argbuf[1024], *q = argbuf;
const char *av[18], **pp = av;
int soxpipe[2];
/** @brief Close the sound device */
static void idle(void) {
D(("idle"));
-#if API_ALSA
- if(config->speaker_backend == BACKEND_ALSA && pcm) {
- int err;
-
- if((err = snd_pcm_nonblock(pcm, 0)) < 0)
- fatal(0, "error calling snd_pcm_nonblock: %d", err);
- D(("draining pcm"));
- snd_pcm_drain(pcm);
- D(("closing pcm"));
- snd_pcm_close(pcm);
- pcm = 0;
- forceplay = 0;
- D(("released audio device"));
- }
-#endif
+ if(backend->deactivate)
+ backend->deactivate();
idled = 1;
ready = 0;
}
}
static void play(size_t frames) {
- size_t avail_bytes, write_bytes, written_frames;
+ size_t avail_frames, avail_bytes, write_bytes, written_frames;
ssize_t written_bytes;
struct rtp_header header;
struct iovec vec[2];
+ /* Make sure the output device is activated */
if(activate()) {
if(playing)
forceplay = frames;
forceplay = 0;
/* Figure out how many frames there are available to write */
if(playing->start + playing->used > playing->size)
+ /* The ring buffer is currently wrapped, only play up to the wrap point */
avail_bytes = playing->size - playing->start;
else
+ /* The ring buffer is not wrapped, can play the lot */
avail_bytes = playing->used;
+ avail_frames = avail_bytes / bpf;
+ /* Only play up to the requested amount */
+ if(avail_frames > frames)
+ avail_frames = frames;
+ if(!avail_frames)
+ return;
switch(config->speaker_backend) {
#if API_ALSA
case BACKEND_ALSA: {
- snd_pcm_sframes_t pcm_written_frames;
- size_t avail_frames;
- int err;
-
- avail_frames = avail_bytes / bpf;
- if(avail_frames > frames)
- avail_frames = frames;
- if(!avail_frames)
- return;
- pcm_written_frames = snd_pcm_writei(pcm,
- playing->buffer + playing->start,
- avail_frames);
- D(("actually play %zu frames, wrote %d",
- avail_frames, (int)pcm_written_frames));
- if(pcm_written_frames < 0) {
- switch(pcm_written_frames) {
- case -EPIPE: /* underrun */
- error(0, "snd_pcm_writei reports underrun");
- if((err = snd_pcm_prepare(pcm)) < 0)
- fatal(0, "error calling snd_pcm_prepare: %d", err);
- return;
- case -EAGAIN:
- return;
- default:
- fatal(0, "error calling snd_pcm_writei: %d",
- (int)pcm_written_frames);
- }
- }
- written_frames = pcm_written_frames;
- written_bytes = written_frames * bpf;
+ written_frames = backend->play(avail_frames);
break;
}
#endif
default:
assert(!"reached");
}
+ written_bytes = written_frames * bpf;
/* written_bytes and written_frames had better both be set and correct by
* this point */
playing->start += written_bytes;
}
return -1;
}
+
+/** @brief Play via ALSA */
+static size_t alsa_play(size_t frames) {
+ snd_pcm_sframes_t pcm_written_frames;
+ int err;
+
+ pcm_written_frames = snd_pcm_writei(pcm,
+ playing->buffer + playing->start,
+ frames);
+ D(("actually play %zu frames, wrote %d",
+ frames, (int)pcm_written_frames));
+ if(pcm_written_frames < 0) {
+ switch(pcm_written_frames) {
+ case -EPIPE: /* underrun */
+ error(0, "snd_pcm_writei reports underrun");
+ if((err = snd_pcm_prepare(pcm)) < 0)
+ fatal(0, "error calling snd_pcm_prepare: %d", err);
+ return 0;
+ case -EAGAIN:
+ return 0;
+ default:
+ fatal(0, "error calling snd_pcm_writei: %d",
+ (int)pcm_written_frames);
+ }
+ } else
+ return pcm_written_frames;
+}
+
+/** @brief ALSA deactivation */
+static void alsa_deactivate(void) {
+ if(pcm) {
+ int err;
+
+ if((err = snd_pcm_nonblock(pcm, 0)) < 0)
+ fatal(0, "error calling snd_pcm_nonblock: %d", err);
+ D(("draining pcm"));
+ snd_pcm_drain(pcm);
+ D(("closing pcm"));
+ snd_pcm_close(pcm);
+ pcm = 0;
+ forceplay = 0;
+ D(("released audio device"));
+ }
+}
#endif
/** @brief Command backend initialization */
fork_cmd();
}
-/** @brief Command backend activation */
-static int command_activate(void) {
+/** @brief Play to a subprocess */
+static size_t command_play(size_t frames) {
+ return frames;
+}
+
+/** @brief Command/network backend activation */
+static int generic_activate(void) {
if(!ready) {
- pcm_format = config->sample_format;
bufsize = 3 * FRAMES;
bpf = bytes_per_frame(&config->sample_format);
D(("acquired audio device"));
}
}
-/** @brief Network backend activation */
-static int network_activate(void) {
- if(!ready) {
- pcm_format = config->sample_format;
- bufsize = 3 * FRAMES;
- bpf = bytes_per_frame(&config->sample_format);
- D(("acquired audio device"));
- ready = 1;
- }
- return 0;
+/** @brief Play over the network */
+static size_t network_play(size_t frames) {
+ return frames;
}
/** @brief Table of speaker backends */
#if API_ALSA
{
BACKEND_ALSA,
+ 0,
alsa_init,
- alsa_activate
+ alsa_activate,
+ alsa_play,
+ alsa_deactivate
},
#endif
{
BACKEND_COMMAND,
+ FIXED_FORMAT,
command_init,
- command_activate
+ generic_activate,
+ command_play,
+ 0 /* deactivate */
},
{
BACKEND_NETWORK,
+ FIXED_FORMAT,
network_init,
- network_activate
+ generic_activate,
+ network_play,
+ 0 /* deactivate */
},
- { -1, 0, 0 }
+ { -1, 0, 0, 0, 0, 0 }
};
int main(int argc, char **argv) {