X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~mdw/git/disorder/blobdiff_plain/0ca6d097e900ff5d46ffc4968a468fefecb345af..74b1f70dbce97198dc741ddd61214e55138f826f:/server/speaker.c diff --git a/server/speaker.c b/server/speaker.c index 55dde7e..bcc44cc 100644 --- a/server/speaker.c +++ b/server/speaker.c @@ -1,6 +1,7 @@ /* * This file is part of DisOrder - * Copyright (C) 2005, 2006, 2007 Richard Kettlewell + * Copyright (C) 2005-2008 Richard Kettlewell + * Portions (C) 2007 Mark Wooding * * 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 @@ -34,7 +35,7 @@ * this is arranged by the @c disorder-normalize program (see @ref * server/normalize.c). * - * @b Garbage @b Collection. This program deliberately does not use the +7 * @b Garbage @b Collection. This program deliberately does not use the * garbage collector even though it might be convenient to do so. This is for * two reasons. Firstly some sound APIs use thread threads and we do not want * to have to deal with potential interactions between threading and garbage @@ -68,6 +69,7 @@ #include #include #include +#include #include "configuration.h" #include "syscalls.h" @@ -77,6 +79,8 @@ #include "speaker-protocol.h" #include "user.h" #include "speaker.h" +#include "printf.h" +#include "version.h" /** @brief Linked list of all prepared tracks */ struct track *tracks; @@ -139,13 +143,6 @@ static void help(void) { exit(0); } -/* Display version number and terminate. */ -static void version(void) { - xprintf("disorder-speaker version %s\n", disorder_version_string); - xfclose(stdout); - exit(0); -} - /** @brief Return the number of bytes per frame in @p format */ static size_t bytes_per_frame(const struct stream_header *format) { return format->channels * format->bits / 8; @@ -195,7 +192,7 @@ static void destroy(struct track *t) { * main loop whenever the track's file descriptor is readable, assuming the * buffer has not reached the maximum allowed occupancy. */ -static int fill(struct track *t) { +static int speaker_fill(struct track *t) { size_t where, left; int n; @@ -218,9 +215,12 @@ static int fill(struct track *t) { if(n == 0) { D(("fill %s: eof detected", t->id)); t->eof = 1; + t->playable = 1; return -1; } t->used += n; + if(t->used == sizeof t->buffer) + t->playable = 1; } return 0; } @@ -280,6 +280,17 @@ static void maybe_finished(void) { abandon(); } +/** @brief Return nonzero if we want to play some audio + * + * We want to play audio if there is a current track; and it is not paused; and + * it is playable according to the rules for @ref track::playable. + */ +static int playable(void) { + return playing + && !paused + && playing->playable; +} + /** @brief Play up to @p frames frames of audio * * It is always safe to call this function. @@ -290,15 +301,15 @@ static void maybe_finished(void) { * - If there is not enough audio to play then it play what is available. * * If there are not enough frames to play then whatever is available is played - * instead. It is up to mainloop() to ensure that play() is not called when - * unreasonably only an small amounts of data is available to play. + * instead. It is up to mainloop() to ensure that speaker_play() is not called + * when unreasonably only an small amounts of data is available to play. */ -static void play(size_t frames) { +static void speaker_play(size_t frames) { size_t avail_frames, avail_bytes, written_frames; ssize_t written_bytes; - /* Make sure there's a track to play and it is not pasued */ - if(!playing || paused) + /* Make sure there's a track to play and it is not paused */ + if(!playable()) return; /* Make sure the output device is open */ if(device_state != device_open) { @@ -336,6 +347,11 @@ static void play(size_t frames) { * empty) wrap it back to the start. */ if(!playing->used || playing->start == (sizeof playing->buffer)) playing->start = 0; + /* If the buffer emptied out mark the track as unplayably */ + if(!playing->used && !playing->eof) { + error(0, "track buffer emptied"); + playing->playable = 0; + } frames -= written_frames; return; } @@ -389,18 +405,6 @@ static const struct speaker_backend *backends[] = { 0 }; -/** @brief Return nonzero if we want to play some audio - * - * We want to play audio if there is a current track; and it is not paused; and - * there are at least @ref FRAMES frames of audio to play, or we are in sight - * of the end of the current track. - */ -static int playable(void) { - return playing - && !paused - && (playing->used >= FRAMES || playing->eof); -} - /** @brief Main event loop */ static void mainloop(void) { struct track *t; @@ -460,15 +464,15 @@ static void mainloop(void) { /* We want to play some audio */ if(device_state == device_open) { if(backend->ready()) - play(3 * FRAMES); + speaker_play(3 * FRAMES); } else { /* We must be in _closed or _error, and it should be the latter, but we * cope with either. * - * We most likely timed out, so now is a good time to retry. play() - * knows to re-activate the device if necessary. + * We most likely timed out, so now is a good time to retry. + * speaker_play() knows to re-activate the device if necessary. */ - play(3 * FRAMES); + speaker_play(3 * FRAMES); } } /* Perhaps a connection has arrived */ @@ -495,7 +499,7 @@ static void mainloop(void) { t = findtrack(id, 1/*create*/); write(fd, "", 1); /* write an ack */ if(t->fd != -1) { - error(0, "got a connection for a track that already has one"); + error(0, "%s: already got a connection", id); xclose(fd); } else { nonblock(fd); @@ -522,9 +526,9 @@ static void mainloop(void) { error(0, "cannot play track because no connection arrived"); playing = t; /* We attempt to play straight away rather than going round the loop. - * play() is clever enough to perform any activation that is + * speaker_play() is clever enough to perform any activation that is * required. */ - play(3 * FRAMES); + speaker_play(3 * FRAMES); report(); break; case SM_PAUSE: @@ -538,23 +542,36 @@ static void mainloop(void) { paused = 0; /* As for SM_PLAY we attempt to play straight away. */ if(playing) - play(3 * FRAMES); + speaker_play(3 * FRAMES); } report(); break; case SM_CANCEL: - D(("SM_CANCEL %s", sm.id)); + D(("SM_CANCEL %s", sm.id)); t = removetrack(sm.id); if(t) { if(t == playing) { + /* scratching the playing track */ sm.type = SM_FINISHED; - strcpy(sm.id, playing->id); - speaker_send(1, &sm); playing = 0; + } else { + /* Could be scratching the playing track before it's quite got + * going, or could be just removing a track from the queue. We + * log more because there's been a bug here recently than because + * it's particularly interesting; the log message will be removed + * if no further problems show up. */ + info("SM_CANCEL for nonplaying track %s", sm.id); + sm.type = SM_STILLBORN; } + strcpy(sm.id, t->id); destroy(t); - } else + } else { + /* Probably scratching the playing track well before it's got + * going, but could indicate a bug, so we log this as an error. */ + sm.type = SM_UNKNOWN; error(0, "SM_CANCEL for unknown track %s", sm.id); + } + speaker_send(1, &sm); report(); break; case SM_RELOAD: @@ -571,7 +588,7 @@ static void mainloop(void) { if(t->fd != -1 && t->slot != -1 && (fds[t->slot].revents & (POLLIN | POLLHUP))) - fill(t); + speaker_fill(t); /* Maybe we finished playing a track somewhere in the above */ maybe_finished(); /* If we don't need the sound device for now then close it for the benefit @@ -590,13 +607,14 @@ int main(int argc, char **argv) { static const int one = 1; struct speaker_message sm; const char *d; + char *dir; set_progname(argv); if(!setlocale(LC_CTYPE, "")) fatal(errno, "error calling setlocale"); while((n = getopt_long(argc, argv, "hVc:dDSs", options, 0)) >= 0) { switch(n) { case 'h': help(); - case 'V': version(); + case 'V': version("disorder-speaker"); case 'c': configfile = optarg; break; case 'd': debugging = 1; break; case 'D': debugging = 0; break; @@ -624,18 +642,23 @@ int main(int argc, char **argv) { if(getuid() == 0 || geteuid() == 0) fatal(0, "do not run as root"); /* identify the backend used to play */ for(n = 0; backends[n]; ++n) - if(backends[n]->backend == config->speaker_backend) + if(backends[n]->backend == config->api) break; if(!backends[n]) - fatal(0, "unsupported backend %d", config->speaker_backend); + fatal(0, "unsupported api %d", config->api); backend = backends[n]; /* backend-specific initialization */ backend->init(); + /* create the socket directory */ + byte_xasprintf(&dir, "%s/speaker", config->home); + unlink(dir); /* might be a leftover socket */ + if(mkdir(dir, 0700) < 0 && errno != EEXIST) + fatal(errno, "error creating %s", dir); /* set up the listen socket */ listenfd = xsocket(PF_UNIX, SOCK_STREAM, 0); memset(&addr, 0, sizeof addr); addr.sun_family = AF_UNIX; - snprintf(addr.sun_path, sizeof addr.sun_path, "%s/speaker", + snprintf(addr.sun_path, sizeof addr.sun_path, "%s/speaker/socket", config->home); if(unlink(addr.sun_path) < 0 && errno != ENOENT) error(errno, "removing %s", addr.sun_path);