X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~mdw/git/disorder/blobdiff_plain/67895023d60fc492720d2f575045ed0173948947..a9ace56da67aedfd82c9f70b6cc11f1fa290fd69:/server/speaker.c

diff --git a/server/speaker.c b/server/speaker.c
index 9b16cc8..de5692b 100644
--- a/server/speaker.c
+++ b/server/speaker.c
@@ -41,6 +41,11 @@
  * obvious way.  If the callback finds itself required to play when there is no
  * playing track it returns dead air.
  *
+ * To implement gapless playback, the server is notified that a track has
+ * finished slightly early.  @ref SM_PLAY is therefore allowed to arrive while
+ * the previous track is still playing provided an early @ref SM_FINISHED has
+ * been sent for it.
+ *
  * @b Encodings.  The encodings supported depend entirely on the uaudio backend
  * chosen.  See @ref uaudio.h, etc.
  *
@@ -79,6 +84,8 @@
 #include <sys/un.h>
 #include <sys/stat.h>
 #include <pthread.h>
+#include <sys/resource.h>
+#include <gcrypt.h>
 
 #include "configuration.h"
 #include "syscalls.h"
@@ -94,6 +101,12 @@
 /** @brief Maximum number of FDs to poll for */
 #define NFDS 1024
 
+/** @brief Number of bytes before end of track to send SM_FINISHED
+ *
+ * Generally set to 1 second.
+ */
+static size_t early_finish;
+
 /** @brief Track structure
  *
  * Known tracks are kept in a linked list.  Usually there will be at most two
@@ -131,6 +144,14 @@ struct track {
    * out life not playable.
    */
   int playable;
+
+  /** @brief Set when finished
+   *
+   * This is set when we've notified the server that the track is finished.
+   * Once this has happened (typically very late in the track's lifetime) the
+   * track cannot be paused or cancelled.
+   */
+  int finished;
   
   /** @brief Input buffer
    *
@@ -142,9 +163,13 @@ struct track {
 /** @brief Lock protecting data structures
  *
  * This lock protects values shared between the main thread and the callback.
- * It is needed e.g. if changing @ref playing or if modifying buffer pointers.
- * It is not needed to add a new track, to read values only modified in the
- * same thread, etc.
+ *
+ * It is held 'all' the time by the main thread, the exceptions being when
+ * called activate/deactivate callbacks and when calling (potentially) slow
+ * system calls (in particular poll(), where in fact the main thread will spend
+ * most of its time blocked).
+ *
+ * The callback holds it when it's running.
  */
 static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 
@@ -153,11 +178,17 @@ static struct track *tracks;
 
 /** @brief Playing track, or NULL
  *
- * This means the DESIRED playing track.  It does not reflect any other state
- * (e.g. activation of uaudio backend).
+ * This means the track the speaker process intends to play.  It does not
+ * reflect any other state (e.g. activation of uaudio backend).
  */
 static struct track *playing;
 
+/** @brief Pending playing track, or NULL
+ *
+ * This means the track the server wants the speaker to play.
+ */
+static struct track *pending_playing;
+
 /** @brief Array of file descriptors for poll() */
 static struct pollfd fds[NFDS];
 
@@ -272,7 +303,6 @@ static int speaker_fill(struct track *t) {
      t->id, t->eof, t->used));
   if(t->eof)
     return -1;
-  pthread_mutex_lock(&lock);
   if(t->used < sizeof t->buffer) {
     /* there is room left in the buffer */
     where = (t->start + t->used) % sizeof t->buffer;
@@ -288,7 +318,7 @@ static int speaker_fill(struct track *t) {
     pthread_mutex_lock(&lock);
     if(n < 0) {
       if(errno != EAGAIN)
-        fatal(errno, "error reading sample stream");
+        disorder_fatal(errno, "error reading sample stream");
       rc = 0;
     } else if(n == 0) {
       D(("fill %s: eof detected", t->id));
@@ -307,7 +337,6 @@ static int speaker_fill(struct track *t) {
       rc = 0;
     }
   }
-  pthread_mutex_unlock(&lock);
   return rc;
 }
 
@@ -315,10 +344,15 @@ static int speaker_fill(struct track *t) {
  *
  * 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.
+ *
+ * We don't allow tracks to be paused if we've already told the server we've
+ * finished them; that would cause such tracks to survive much longer than the
+ * few samples they're supposed to, with report() remaining silent for the
+ * duration.
  */
 static int playable(void) {
   return playing
-         && !paused
+         && (!paused || playing->finished)
          && playing->playable;
 }
 
@@ -327,15 +361,17 @@ static void report(void) {
   struct speaker_message sm;
 
   if(playing) {
+    /* Had better not send a report for a track that the server thinks has
+     * finished, that would be confusing. */
+    if(playing->finished)
+      return;
     memset(&sm, 0, sizeof sm);
     sm.type = paused ? SM_PAUSED : SM_PLAYING;
     strcpy(sm.id, playing->id);
-    pthread_mutex_lock(&lock);
     sm.data = playing->played / (uaudio_rate * uaudio_channels);
-    pthread_mutex_unlock(&lock);
     speaker_send(1, &sm);
+    xtime(&last_report);
   }
-  time(&last_report);
 }
 
 /** @brief Add a file descriptor to the set to poll() for
@@ -390,8 +426,10 @@ static size_t speaker_callback(void *buffer,
       if(playing->start == sizeof playing->buffer)
         playing->start = 0;
       /* See if we've reached the end of the track */
-      if(playing->used == 0 && playing->eof)
-        write(sigpipe[1], "", 1);
+      if(playing->used == 0 && playing->eof) {
+        int ignored = write(sigpipe[1], "", 1);
+        (void) ignored;
+      }
       provided_samples = bytes / uaudio_sample_size;
       playing->played += provided_samples;
     }
@@ -401,6 +439,11 @@ static size_t speaker_callback(void *buffer,
   if(!provided_samples) {
     memset(buffer, 0, max_bytes);
     provided_samples = max_samples;
+    if(playing)
+      disorder_info("%zu samples silence, playing->used=%zu",
+                    provided_samples, playing->used);
+    else
+      disorder_info("%zu samples silence, playing=NULL", provided_samples);
   }
   pthread_mutex_unlock(&lock);
   return provided_samples;
@@ -413,13 +456,14 @@ static void mainloop(void) {
   int n, fd, stdin_slot, timeout, listen_slot, sigpipe_slot;
 
   /* Keep going while our parent process is alive */
+  pthread_mutex_lock(&lock);
   while(getppid() != 1) {
     int force_report = 0;
 
     fdno = 0;
-    /* By default we will wait up to a second before thinking about current
-     * state. */
-    timeout = 1000;
+    /* By default we will wait up to half a second before thinking about
+     * current state. */
+    timeout = 500;
     /* Always ready for commands from the main server. */
     stdin_slot = addfd(0, POLLIN);
     /* Also always ready for inbound connections */
@@ -445,12 +489,14 @@ static void mainloop(void) {
         } else
           t->slot = -1;
       }
-    sigpipe_slot = addfd(sigpipe[1], POLLIN);
+    sigpipe_slot = addfd(sigpipe[0], POLLIN);
     /* Wait for something interesting to happen */
+    pthread_mutex_unlock(&lock);
     n = poll(fds, fdno, timeout);
+    pthread_mutex_lock(&lock);
     if(n < 0) {
       if(errno == EINTR) continue;
-      fatal(errno, "error calling poll");
+      disorder_fatal(errno, "error calling poll");
     }
     /* Perhaps a connection has arrived */
     if(fds[listen_slot].revents & POLLIN) {
@@ -462,22 +508,22 @@ static void mainloop(void) {
       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");
+          disorder_error(errno, "reading length from inbound connection");
           xclose(fd);
         } else if(l >= sizeof id) {
-          error(0, "id length too long");
+          disorder_error(0, "id length too long");
           xclose(fd);
         } else if(read(fd, id, l) < (ssize_t)l) {
-          error(errno, "reading id from inbound connection");
+          disorder_error(errno, "reading id from inbound connection");
           xclose(fd);
         } else {
           id[l] = 0;
           D(("id %s fd %d", id, fd));
           t = findtrack(id, 1/*create*/);
           if (write(fd, "", 1) < 0)             /* write an ack */
-			error(errno, "writing ack to inbound connection");
+            disorder_error(errno, "writing ack to inbound connection");
           if(t->fd != -1) {
-            error(0, "%s: already got a connection", id);
+            disorder_error(0, "%s: already got a connection", id);
             xclose(fd);
           } else {
             nonblock(fd);
@@ -485,7 +531,7 @@ static void mainloop(void) {
           }
         }
       } else
-        error(errno, "accept");
+        disorder_error(errno, "accept");
     }
     /* Perhaps we have a command to process */
     if(fds[stdin_slot].revents & POLLIN) {
@@ -493,18 +539,41 @@ static void mainloop(void) {
        * this won't be the case, so we don't bother looping around to pick them
        * all up. */ 
       n = speaker_recv(0, &sm);
-      /* TODO */
       if(n > 0)
+        /* As a rule we don't send success replies to most commands - we just
+         * force the regular status update to be sent immediately rather than
+         * on schedule. */
 	switch(sm.type) {
 	case SM_PLAY:
-          if(playing)
-            fatal(0, "got SM_PLAY but already playing something");
+          /* SM_PLAY is only allowed if the server reasonably believes that
+           * nothing is playing */
+          if(playing) {
+            /* If finished isn't set then the server can't believe that this
+             * track has finished */
+            if(!playing->finished)
+              disorder_fatal(0, "got SM_PLAY but already playing something");
+            /* If pending_playing is set then the server must believe that that
+             * is playing */
+            if(pending_playing)
+              disorder_fatal(0, "got SM_PLAY but have a pending playing track");
+          }
 	  t = findtrack(sm.id, 1);
           D(("SM_PLAY %s fd %d", t->id, t->fd));
           if(t->fd == -1)
-            error(0, "cannot play track because no connection arrived");
-          playing = t;
-          force_report = 1;
+            disorder_error(0,
+                           "cannot play track because no connection arrived");
+          /* TODO as things stand we often report this error message but then
+           * appear to proceed successfully.  Understanding why requires a look
+           * at play.c: we call prepare() which makes the connection in a child
+           * process, and then sends the SM_PLAY in the parent process.  The
+           * latter may well be faster.  As it happens this is harmless; we'll
+           * just sit around sending silence until the decoder connects and
+           * starts sending some sample data.  But is is annoying and ought to
+           * be fixed. */
+          pending_playing = t;
+          /* If nothing is currently playing then we'll switch to the pending
+           * track below so there's no point distinguishing the situations
+           * here. */
 	  break;
 	case SM_PAUSE:
           D(("SM_PAUSE"));
@@ -520,40 +589,43 @@ static void mainloop(void) {
           D(("SM_CANCEL %s", sm.id));
 	  t = removetrack(sm.id);
 	  if(t) {
-            pthread_mutex_lock(&lock);
-	    if(t == playing) {
-              /* scratching the playing track */
+	    if(t == playing || t == pending_playing) {
+              /* Scratching the track that the server believes is playing,
+               * which might either be the actual playing track or a pending
+               * playing track */
               sm.type = SM_FINISHED;
-	      playing = 0;
+              if(t == playing)
+                playing = 0;
+              else
+                pending_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);
+              disorder_info("SM_CANCEL for nonplaying track %s", sm.id);
               sm.type = SM_STILLBORN;
             }
             strcpy(sm.id, t->id);
 	    destroy(t);
-            pthread_mutex_unlock(&lock);
 	  } 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);
+	    disorder_error(0, "SM_CANCEL for unknown track %s", sm.id);
           }
           speaker_send(1, &sm);
           force_report = 1;
 	  break;
 	case SM_RELOAD:
           D(("SM_RELOAD"));
-	  if(config_read(1))
-            error(0, "cannot read configuration");
-          info("reloaded configuration");
+	  if(config_read(1, NULL))
+            disorder_error(0, "cannot read configuration");
+          disorder_info("reloaded configuration");
 	  break;
 	default:
-	  error(0, "unknown message type %d", sm.type);
+	  disorder_error(0, "unknown message type %d", sm.type);
         }
     }
     /* Read in any buffered data */
@@ -566,36 +638,55 @@ static void mainloop(void) {
      * interrupted poll(). */
     if(fds[sigpipe_slot].revents & POLLIN) {
       char buffer[64];
+      int ignored; (void)ignored;
 
-      read(sigpipe[0], buffer, sizeof buffer);
+      ignored = read(sigpipe[0], buffer, sizeof buffer);
     }
-    if(playing && playing->used == 0 && playing->eof) {
-      /* The playing track is done.  Tell the server, and destroy it. */
+    /* Send SM_FINISHED when we're near the end of the track.
+     *
+     * This is how we implement gapless play; we hope that the SM_PLAY from the
+     * server arrives before the remaining bytes of the track play out.
+     */
+    if(playing
+       && playing->eof
+       && !playing->finished
+       && playing->used <= early_finish) {
       memset(&sm, 0, sizeof sm);
       sm.type = SM_FINISHED;
       strcpy(sm.id, playing->id);
       speaker_send(1, &sm);
+      playing->finished = 1;
+    }
+    /* When the track is actually finished, deconfigure it */
+    if(playing && playing->eof && !playing->used) {
       removetrack(playing->id);
-      pthread_mutex_lock(&lock);
       destroy(playing);
       playing = 0;
-      pthread_mutex_unlock(&lock);
-      /* The server will presumalby send as an SM_PLAY by return */
+    }
+    /* Act on the pending SM_PLAY */
+    if(!playing && pending_playing) {
+      playing = pending_playing;
+      pending_playing = 0;
+      force_report = 1;
     }
     /* Impose any state change required by the above */
     if(playable()) {
       if(!activated) {
         activated = 1;
+        pthread_mutex_unlock(&lock);
         backend->activate();
+        pthread_mutex_lock(&lock);
       }
     } else {
       if(activated) {
         activated = 0;
+        pthread_mutex_unlock(&lock);
         backend->deactivate();
+        pthread_mutex_lock(&lock);
       }
     }
     /* If we've not reported our state for a second do so now. */
-    if(force_report || time(0) > last_report)
+    if(force_report || xtime(0) > last_report)
       report();
   }
 }
@@ -610,7 +701,7 @@ int main(int argc, char **argv) {
   struct rlimit rl[1];
 
   set_progname(argv);
-  if(!setlocale(LC_CTYPE, "")) fatal(errno, "error calling setlocale");
+  if(!setlocale(LC_CTYPE, "")) disorder_fatal(errno, "error calling setlocale");
   while((n = getopt_long(argc, argv, "hVc:dDSs", options, 0)) >= 0) {
     switch(n) {
     case 'h': help();
@@ -620,7 +711,7 @@ int main(int argc, char **argv) {
     case 'D': debugging = 0; break;
     case 'S': logsyslog = 0; break;
     case 's': logsyslog = 1; break;
-    default: fatal(0, "invalid option");
+    default: disorder_fatal(0, "invalid option");
     }
   }
   if((d = getenv("DISORDER_DEBUG_SPEAKER"))) debugging = atoi(d);
@@ -629,7 +720,7 @@ int main(int argc, char **argv) {
     log_default = &log_syslog;
   }
   config_uaudio_apis = uaudio_apis;
-  if(config_read(1)) fatal(0, "cannot read configuration");
+  if(config_read(1, NULL)) disorder_fatal(0, "cannot read configuration");
   /* ignore SIGPIPE */
   signal(SIGPIPE, SIG_IGN);
   /* set nice value */
@@ -638,19 +729,24 @@ int main(int argc, char **argv) {
   become_mortal();
   /* make sure we're not root, whatever the config says */
   if(getuid() == 0 || geteuid() == 0)
-    fatal(0, "do not run as root");
+    disorder_fatal(0, "do not run as root");
   /* Make sure we can't have more than NFDS files open (it would bust our
    * poll() array) */
   if(getrlimit(RLIMIT_NOFILE, rl) < 0)
-    fatal(errno, "getrlimit RLIMIT_NOFILE");
+    disorder_fatal(errno, "getrlimit RLIMIT_NOFILE");
   if(rl->rlim_cur > NFDS) {
     rl->rlim_cur = NFDS;
     if(setrlimit(RLIMIT_NOFILE, rl) < 0)
-      fatal(errno, "setrlimit to reduce RLIMIT_NOFILE to %lu",
+      disorder_fatal(errno, "setrlimit to reduce RLIMIT_NOFILE to %lu",
             (unsigned long)rl->rlim_cur);
-    info("set RLIM_NOFILE to %lu", (unsigned long)rl->rlim_cur);
+    disorder_info("set RLIM_NOFILE to %lu", (unsigned long)rl->rlim_cur);
   } else
-    info("RLIM_NOFILE is %lu", (unsigned long)rl->rlim_cur);
+    disorder_info("RLIM_NOFILE is %lu", (unsigned long)rl->rlim_cur);
+  /* gcrypt initialization */
+  if(!gcry_check_version(NULL))
+    disorder_fatal(0, "gcry_check_version failed");
+  gcry_control(GCRYCTL_INIT_SECMEM, 0);
+  gcry_control (GCRYCTL_INITIALIZATION_FINISHED, 0);
   /* create a pipe between the backend callback and the poll() loop */
   xpipe(sigpipe);
   nonblock(sigpipe[0]);
@@ -659,6 +755,7 @@ int main(int argc, char **argv) {
                     config->sample_format.channels,
                     config->sample_format.bits,
                     config->sample_format.bits != 8);
+  early_finish = uaudio_sample_size * uaudio_channels * uaudio_rate;
   /* TODO other parameters! */
   backend = uaudio_find(config->api);
   /* backend-specific initialization */
@@ -669,7 +766,7 @@ int main(int argc, char **argv) {
   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);
+    disorder_fatal(errno, "error creating %s", dir);
   /* set up the listen socket */
   listenfd = xsocket(PF_UNIX, SOCK_STREAM, 0);
   memset(&addr, 0, sizeof addr);
@@ -677,18 +774,18 @@ int main(int argc, char **argv) {
   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);
+    disorder_error(errno, "removing %s", addr.sun_path);
   xsetsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof one);
   if(bind(listenfd, (const struct sockaddr *)&addr, sizeof addr) < 0)
-    fatal(errno, "error binding socket to %s", addr.sun_path);
+    disorder_fatal(errno, "error binding socket to %s", addr.sun_path);
   xlisten(listenfd, 128);
   nonblock(listenfd);
-  info("listening on %s", addr.sun_path);
+  disorder_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)");
+  disorder_info("stopped (parent terminated)");
   exit(0);
 }