X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~mdw/git/disorder/blobdiff_plain/84aa9f9339ef6fa104588dd510c433ef20a96fe1..05b75f8d50b83e943af3be4071449304d82dbdcd:/server/speaker.c?ds=sidebyside diff --git a/server/speaker.c b/server/speaker.c index 11916c1..3021652 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 @@ -22,8 +23,9 @@ * * This program is responsible for transmitting a single coherent audio stream * to its destination (over the network, to some sound API, to some - * subprocess). It receives connections from decoders via file descriptor - * passing from the main server and plays them in the right order. + * subprocess). It receives connections from decoders (or rather from the + * process that is about to become disorder-normalize) and plays them in the + * right order. * * @b Encodings. For the ALSA API, * 8- and 16- bit stereo and mono are supported, with any sample rate (within @@ -33,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 @@ -48,25 +50,21 @@ * 2-byte samples. */ -#include -#include "types.h" +#include "common.h" #include -#include -#include #include #include #include #include #include -#include -#include #include #include #include #include #include #include +#include #include "configuration.h" #include "syscalls.h" @@ -76,6 +74,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; @@ -116,6 +116,8 @@ static const struct option options[] = { { "config", required_argument, 0, 'c' }, { "debug", no_argument, 0, 'd' }, { "no-debug", no_argument, 0, 'D' }, + { "syslog", no_argument, 0, 's' }, + { "no-syslog", no_argument, 0, 'S' }, { 0, 0, 0, 0 } }; @@ -128,6 +130,7 @@ static void help(void) { " --version, -V Display version number\n" " --config PATH, -c PATH Set configuration file\n" " --debug, -d Turn on debugging\n" + " --[no-]syslog Force logging\n" "\n" "Speaker process for DisOrder. Not intended to be run\n" "directly.\n"); @@ -135,13 +138,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; @@ -191,7 +187,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; @@ -214,9 +210,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; } @@ -276,6 +275,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. @@ -286,15 +296,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) { @@ -332,6 +342,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; } @@ -371,26 +386,20 @@ int addfd(int fd, int events) { /** @brief Table of speaker backends */ static const struct speaker_backend *backends[] = { -#if API_ALSA +#if HAVE_ALSA_ASOUNDLIB_H &alsa_backend, #endif &command_backend, &network_backend, +#if HAVE_COREAUDIO_AUDIOHARDWARE_H + &coreaudio_backend, +#endif +#if HAVE_SYS_SOUNDCARD_H + &oss_backend, +#endif 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; @@ -425,7 +434,7 @@ static void mainloop(void) { * instead, but the post-poll code will cope even if it's * device_closed. */ if(device_state == device_open) - backend->beforepoll(); + backend->beforepoll(&timeout); } /* If any other tracks don't have a full buffer, try to read sample data * from them. We do this last of all, so that if we run out of slots, @@ -450,15 +459,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 */ @@ -468,7 +477,8 @@ static void mainloop(void) { uint32_t l; char id[24]; - if((fd = accept(listenfd, &addr, &addrlen)) >= 0) { + if((fd = accept(listenfd, (struct sockaddr *)&addr, &addrlen)) >= 0) { + blocking(fd); if(read(fd, &l, sizeof l) < 4) { error(errno, "reading length from inbound connection"); xclose(fd); @@ -484,7 +494,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); @@ -511,9 +521,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: @@ -527,23 +537,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: @@ -560,7 +583,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 @@ -574,25 +597,29 @@ static void mainloop(void) { } int main(int argc, char **argv) { - int n; + int n, logsyslog = !isatty(2); struct sockaddr_un addr; 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:dD", options, 0)) >= 0) { + 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; + case 'S': logsyslog = 0; break; + case 's': logsyslog = 1; break; default: fatal(0, "invalid option"); } } - if(getenv("DISORDER_DEBUG_SPEAKER")) debugging = 1; - /* If stderr is a TTY then log there, otherwise to syslog. */ - if(!isatty(2)) { + if((d = getenv("DISORDER_DEBUG_SPEAKER"))) debugging = atoi(d); + if(logsyslog) { openlog(progname, LOG_PID, LOG_DAEMON); log_default = &log_syslog; } @@ -610,27 +637,35 @@ 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); xsetsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one); - if(bind(listenfd, &addr, sizeof addr) < 0) + if(bind(listenfd, (const struct sockaddr *)&addr, sizeof addr) < 0) fatal(errno, "error binding socket to %s", addr.sun_path); xlisten(listenfd, 128); nonblock(listenfd); info("listening on %s", addr.sun_path); + memset(&sm, 0, sizeof sm); + sm.type = SM_READY; + speaker_send(1, &sm); mainloop(); info("stopped (parent terminated)"); exit(0);