docs note that sox is required for speaker_command

[disorder] / server / speaker.c

diff --git a/server/speaker.c b/server/speaker.c
index 1593b781e3a0f23a160ccf3c32c664b3335d241c..2d4c6eaa487b0aa4ad57964aaa734eb9e8d8f454 100644 (file)
--- a/server/speaker.c
+++ b/server/speaker.c
@@ -40,7 +40,10 @@
 #include <string.h>
 #include <assert.h>
 #include <sys/select.h>
 #include <string.h>
 #include <assert.h>
 #include <sys/select.h>

+#include <sys/wait.h>

 #include <time.h>
 #include <time.h>

+#include <fcntl.h>
+#include <poll.h>

 
 #include "configuration.h"
 #include "syscalls.h"
 
 #include "configuration.h"
 #include "syscalls.h"


@@ -50,8 +53,9 @@
 #include "speaker.h"
 #include "user.h"
 
 #include "speaker.h"
 #include "user.h"
 

-#if BUILD_SPEAKER
+#if API_ALSA

 #include <alsa/asoundlib.h>
 #include <alsa/asoundlib.h>

+#endif

 
 #define BUFFER_SECONDS 5                /* How many seconds of input to
                                          * buffer. */
 
 #define BUFFER_SECONDS 5                /* How many seconds of input to
                                          * buffer. */


@@ -78,13 +82,18 @@ static struct track {
 
 static time_t last_report;              /* when we last reported */
 static int paused;                      /* pause status */
 
 static time_t last_report;              /* when we last reported */
 static int paused;                      /* pause status */

-static snd_pcm_t *pcm;                  /* current pcm handle */

 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 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 snd_pcm_uframes_t pcm_bufsize;   /* buffer size */
+static size_t bufsize;                  /* buffer size */
+#if API_ALSA
+static snd_pcm_t *pcm;                  /* current pcm handle */
+static snd_pcm_uframes_t last_pcm_bufsize; /* last seen buffer size */
+#endif
+static int ready;                       /* ready to send audio */

 static int forceplay;                   /* frames to force play */
 static int forceplay;                   /* frames to force play */

+static int kidfd = -1;                  /* child process input */

 
 static const struct option options[] = {
   { "help", no_argument, 0, 'h' },
 
 static const struct option options[] = {
   { "help", no_argument, 0, 'h' },


@@ -230,10 +239,11 @@ static int formats_equal(const ao_sample_format *a,
 
 /* Close the sound device. */
 static void idle(void) {
 
 /* Close the sound device. */
 static void idle(void) {

-  int  err;
-

   D(("idle"));
   D(("idle"));

+#if API_ALSA

   if(pcm) {
   if(pcm) {

+    int  err;
+

     if((err = snd_pcm_nonblock(pcm, 0)) < 0)
       fatal(0, "error calling snd_pcm_nonblock: %d", err);
     D(("draining pcm"));
     if((err = snd_pcm_nonblock(pcm, 0)) < 0)
       fatal(0, "error calling snd_pcm_nonblock: %d", err);
     D(("draining pcm"));


@@ -244,6 +254,8 @@ static void idle(void) {
     forceplay = 0;
     D(("released audio device"));
   }
     forceplay = 0;
     D(("released audio device"));
   }

+#endif
+  ready = 0;

 }
 
 /* Abandon the current track */
 }
 
 /* Abandon the current track */


@@ -261,24 +273,114 @@ static void abandon(void) {
   forceplay = 0;
 }
 
   forceplay = 0;
 }
 

+#if API_ALSA
+static void log_params(snd_pcm_hw_params_t *hwparams,
+                       snd_pcm_sw_params_t *swparams) {
+  snd_pcm_uframes_t f;
+  unsigned u;
+
+  return;                               /* too verbose */
+  if(hwparams) {
+    /* TODO */
+  }
+  if(swparams) {
+    snd_pcm_sw_params_get_silence_size(swparams, &f);
+    info("sw silence_size=%lu", (unsigned long)f);
+    snd_pcm_sw_params_get_silence_threshold(swparams, &f);
+    info("sw silence_threshold=%lu", (unsigned long)f);
+    snd_pcm_sw_params_get_sleep_min(swparams, &u);
+    info("sw sleep_min=%lu", (unsigned long)u);
+    snd_pcm_sw_params_get_start_threshold(swparams, &f);
+    info("sw start_threshold=%lu", (unsigned long)f);
+    snd_pcm_sw_params_get_stop_threshold(swparams, &f);
+    info("sw stop_threshold=%lu", (unsigned long)f);
+    snd_pcm_sw_params_get_xfer_align(swparams, &f);
+    info("sw xfer_align=%lu", (unsigned long)f);
+  }
+}
+#endif
+
+static void soxargs(const char ***pp, char **qq, ao_sample_format *ao)
+{
+  int n;
+
+  *(*pp)++ = "-t.raw";
+  *(*pp)++ = "-s";
+  *(*pp)++ = *qq; n = sprintf(*qq, "-r%d", ao->rate); *qq += n + 1;
+  switch(ao->byte_format) {
+    case AO_FMT_NATIVE: break;
+    case AO_FMT_BIG: *(*pp)++ = "-B"; break;
+    case AO_FMT_LITTLE: *(*pp)++ = "-L"; break;
+  }
+  *(*pp)++ = *qq; n = sprintf(*qq, "-%d", ao->bits/8); *qq += n + 1;
+  *(*pp)++ = *qq; n = sprintf(*qq, "-c%d", ao->channels); *qq += n + 1;
+}
+

 /* Make sure the sound device is open and has the right sample format.  Return
  * 0 on success and -1 on error. */
 static int activate(void) {
 /* Make sure the sound device is open and has the right sample format.  Return
  * 0 on success and -1 on error. */
 static int activate(void) {

-  int err;
-  snd_pcm_hw_params_t *hwparams;
-  snd_pcm_sw_params_t *swparams;
-  int sample_format = 0;
-  unsigned rate;
-

   /* If we don't know the format yet we cannot start. */
   if(!playing->got_format) {
     D((" - not got format for %s", playing->id));
     return -1;
   }
   /* If we don't know the format yet we cannot start. */
   if(!playing->got_format) {
     D((" - not got format for %s", playing->id));
     return -1;
   }

+  if(kidfd >= 0) {
+    if(!formats_equal(&playing->format, &config->sample_format)) {
+      char argbuf[1024], *q = argbuf;
+      const char *av[18], **pp = av;
+      int soxpipe[2];
+      pid_t soxkid;
+      *pp++ = "sox";
+      soxargs(&pp, &q, &playing->format);
+      *pp++ = "-";
+      soxargs(&pp, &q, &config->sample_format);
+      *pp++ = "-";
+      *pp++ = 0;
+      if(debugging) {
+        for(pp = av; *pp; pp++)
+          D(("sox arg[%d] = %s", pp - av, *pp));
+        D(("end args"));
+      }
+      xpipe(soxpipe);
+      soxkid = xfork();
+      if(soxkid == 0) {
+        xdup2(playing->fd, 0);
+        xdup2(soxpipe[1], 1);
+        fcntl(0, F_SETFL, fcntl(0, F_GETFL) & ~O_NONBLOCK);
+        close(soxpipe[0]);
+        close(soxpipe[1]);
+        close(playing->fd);
+        execvp("sox", (char **)av);
+        _exit(1);
+      }
+      D(("forking sox for format conversion (kid = %d)", soxkid));
+      close(playing->fd);
+      close(soxpipe[1]);
+      playing->fd = soxpipe[0];
+      playing->format = config->sample_format;
+      ready = 0;
+    }
+    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;
+  }
+#if API_ALSA

   /* If we need to change format then close the current device. */
   if(pcm && !formats_equal(&playing->format, &pcm_format))
      idle();
   if(!pcm) {
   /* If we need to change format then close the current device. */
   if(pcm && !formats_equal(&playing->format, &pcm_format))
      idle();
   if(!pcm) {

+    snd_pcm_hw_params_t *hwparams;
+    snd_pcm_sw_params_t *swparams;
+    snd_pcm_uframes_t pcm_bufsize;
+    int err;
+    int sample_format = 0;
+    unsigned rate;
+

     D(("snd_pcm_open"));
     if((err = snd_pcm_open(&pcm,
                            config->device,
     D(("snd_pcm_open"));
     if((err = snd_pcm_open(&pcm,
                            config->device,


@@ -331,14 +433,16 @@ static int activate(void) {
             playing->format.channels, err);
       goto fatal;
     }
             playing->format.channels, err);
       goto fatal;
     }

-    pcm_bufsize = 3 * FRAMES;
+    bufsize = 3 * FRAMES;
+    pcm_bufsize = bufsize;

     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",
             3 * FRAMES, 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",
             3 * FRAMES, err);

-    if(pcm_bufsize != 3 * FRAMES)
+    if(pcm_bufsize != 3 * FRAMES && pcm_bufsize != last_pcm_bufsize)

       info("asked for PCM buffer of %d frames, got %d",
            3 * FRAMES, (int)pcm_bufsize);
       info("asked for PCM buffer of %d frames, got %d",
            3 * FRAMES, (int)pcm_bufsize);

+    last_pcm_bufsize = pcm_bufsize;

     if((err = snd_pcm_hw_params(pcm, hwparams)) < 0)
       fatal(0, "error calling snd_pcm_hw_params: %d", err);
     D(("set up sw params"));
     if((err = snd_pcm_hw_params(pcm, hwparams)) < 0)
       fatal(0, "error calling snd_pcm_hw_params: %d", err);
     D(("set up sw params"));


@@ -353,6 +457,8 @@ static int activate(void) {
     pcm_format = playing->format;
     bpf = bytes_per_frame(&pcm_format);
     D(("acquired audio device"));
     pcm_format = playing->format;
     bpf = bytes_per_frame(&pcm_format);
     D(("acquired audio device"));

+    log_params(hwparams, swparams);
+    ready = 1;

   }
   return 0;
 fatal:
   }
   return 0;
 fatal:


@@ -363,6 +469,7 @@ error:
     snd_pcm_close(pcm);
     pcm = 0;
   }
     snd_pcm_close(pcm);
     pcm = 0;
   }

+#endif

   return -1;
 }
 
   return -1;
 }
 


@@ -375,10 +482,27 @@ static void maybe_finished(void) {
     abandon();
 }
 
     abandon();
 }
 

+static void fork_kid(void) {
+  pid_t kid;
+  int pfd[2];
+  if(kidfd != -1) close(kidfd);
+  xpipe(pfd);
+  kid = xfork();
+  if(!kid) {
+    xdup2(pfd[0], 0);
+    close(pfd[0]);
+    close(pfd[1]);
+    execl("/bin/sh", "sh", "-c", config->speaker_command, (char *)0);
+    fatal(errno, "error execing /bin/sh");
+  }
+  close(pfd[0]);
+  kidfd = pfd[1];
+  D(("forked kid %d, fd = %d", kid, kidfd));
+}
+

 static void play(size_t frames) {
 static void play(size_t frames) {

-  snd_pcm_sframes_t written_frames;
-  size_t avail_bytes, avail_frames, written_bytes;
-  int err;
+  size_t avail_bytes, written_frames;
+  ssize_t written_bytes;

 
   if(activate()) {
     if(playing)
 
   if(activate()) {
     if(playing)


@@ -405,30 +529,61 @@ static void play(size_t frames) {
     avail_bytes = playing->size - playing->start;
   else
     avail_bytes = playing->used;
     avail_bytes = playing->size - playing->start;
   else
     avail_bytes = playing->used;

-  avail_frames = avail_bytes / bpf;
-  if(avail_frames > frames)
-    avail_frames = frames;
-  if(!avail_frames)
-    return;
-  written_frames = snd_pcm_writei(pcm,
-                                  playing->buffer + playing->start,
-                                  avail_frames);
-  D(("actually play %zu frames, wrote %d",
-     avail_frames, (int)written_frames));
-  if(written_frames < 0) {
-    switch(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:
+
+  if(kidfd == -1) {
+#if API_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;
       return;

-    default:
-      fatal(0, "error calling snd_pcm_writei: %d", (int)written_frames);
+    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;
+#else
+    assert(!"reached");
+#endif
+  } else {
+    if(avail_bytes > frames * bpf)
+      avail_bytes = frames * bpf;
+    written_bytes = write(kidfd, playing->buffer + playing->start,
+                          avail_bytes);
+    D(("actually play %zu bytes, wrote %d",
+       avail_bytes, (int)written_bytes));
+    if(written_bytes < 0) {
+      switch(errno) {
+        case EPIPE:
+          error(0, "hmm, kid died; trying another");
+          fork_kid();
+          return;
+        case EAGAIN:
+          return;
+      }
+    }
+    written_frames = written_bytes / bpf; /* good enough */

   }
   }

-  written_bytes = written_frames * bpf;

   playing->start += written_bytes;
   playing->used -= written_bytes;
   playing->played += written_frames;
   playing->start += written_bytes;
   playing->used -= written_bytes;
   playing->played += written_frames;


@@ -453,6 +608,16 @@ static void report(void) {
   time(&last_report);
 }
 
   time(&last_report);
 }
 

+static void reap(int __attribute__((unused)) sig) {
+  pid_t kid;
+  int st;
+
+  do
+    kid = waitpid(-1, &st, WNOHANG);
+  while(kid > 0);
+  signal(SIGCHLD, reap);
+}
+

 static int addfd(int fd, int events) {
   if(fdno < NFDS) {
     fds[fdno].fd = fd;
 static int addfd(int fd, int events) {
   if(fdno < NFDS) {
     fds[fdno].fd = fd;


@@ -463,10 +628,12 @@ static int addfd(int fd, int events) {
 }
 
 int main(int argc, char **argv) {
 }
 
 int main(int argc, char **argv) {

-  int n, fd, stdin_slot, alsa_slots, alsa_nslots = -1, err;
-  unsigned short alsa_revents;
+  int n, fd, stdin_slot, alsa_slots, kid_slot;

   struct track *t;
   struct speaker_message sm;
   struct track *t;
   struct speaker_message sm;

+#if API_ALSA
+  int alsa_nslots = -1, err;
+#endif

 
   set_progname(argv);
   mem_init(0);
 
   set_progname(argv);
   mem_init(0);


@@ -490,6 +657,8 @@ int main(int argc, char **argv) {
   if(config_read()) fatal(0, "cannot read configuration");
   /* ignore SIGPIPE */
   signal(SIGPIPE, SIG_IGN);
   if(config_read()) fatal(0, "cannot read configuration");
   /* ignore SIGPIPE */
   signal(SIGPIPE, SIG_IGN);

+  /* reap kids */
+  signal(SIGCHLD, reap);

   /* set nice value */
   xnice(config->nice_speaker);
   /* change user */
   /* set nice value */
   xnice(config->nice_speaker);
   /* change user */


@@ -497,6 +666,15 @@ int main(int argc, char **argv) {
   /* make sure we're not root, whatever the config says */
   if(getuid() == 0 || geteuid() == 0) fatal(0, "do not run as root");
   info("started");
   /* make sure we're not root, whatever the config says */
   if(getuid() == 0 || geteuid() == 0) fatal(0, "do not run as root");
   info("started");

+  if(config->speaker_command)
+    fork_kid();
+  else {
+#if API_ALSA
+    /* ok */
+#else
+    fatal(0, "invoked speaker but no speaker_command and no known sound API");
+ #endif
+  }

   while(getppid() != 1) {
     fdno = 0;
     /* Always ready for commands from the main server. */
   while(getppid() != 1) {
     fdno = 0;
     /* Always ready for commands from the main server. */


@@ -509,18 +687,39 @@ int main(int argc, char **argv) {
       playing->slot = -1;
     /* If forceplay is set then wait until it succeeds before waiting on the
      * sound device. */
       playing->slot = -1;
     /* If forceplay is set then wait until it succeeds before waiting on the
      * sound device. */

-    if(pcm && !forceplay) {
-      alsa_slots = fdno;
-      alsa_nslots = snd_pcm_poll_descriptors(pcm, &fds[fdno], NFDS - fdno);
-      fdno += alsa_nslots;
-    } else
-      alsa_slots = -1;
+    alsa_slots = -1;
+    kid_slot = -1;
+    if(ready && !forceplay) {
+      if(kidfd >= 0)
+        kid_slot = addfd(kidfd, POLLOUT);
+      else {
+#if API_ALSA
+        int retry = 3;
+        
+        alsa_slots = fdno;
+        do {
+          retry = 0;
+          alsa_nslots = snd_pcm_poll_descriptors(pcm, &fds[fdno], NFDS - fdno);
+          if((alsa_nslots <= 0
+              || !(fds[alsa_slots].events & POLLOUT))
+             && snd_pcm_state(pcm) == SND_PCM_STATE_XRUN) {
+            error(0, "underrun detected after call to snd_pcm_poll_descriptors()");
+            if((err = snd_pcm_prepare(pcm)))
+              fatal(0, "error calling snd_pcm_prepare: %d", err);
+          } else
+            break;
+        } while(retry-- > 0);
+        if(alsa_nslots >= 0)
+          fdno += alsa_nslots;
+#endif
+      }
+    }

     /* If any other tracks don't have a full buffer, try to read sample data
      * from them. */
     for(t = tracks; t; t = t->next)
       if(t != playing) {
         if(!t->eof && t->used < t->size) {
     /* If any other tracks don't have a full buffer, try to read sample data
      * from them. */
     for(t = tracks; t; t = t->next)
       if(t != playing) {
         if(!t->eof && t->used < t->size) {

-          t->slot = addfd(t->fd,  POLLIN);
+          t->slot = addfd(t->fd,  POLLIN | POLLHUP);

         } else
           t->slot = -1;
       }
         } else
           t->slot = -1;
       }


@@ -532,12 +731,19 @@ int main(int argc, char **argv) {
     }
     /* Play some sound before doing anything else */
     if(alsa_slots != -1) {
     }
     /* Play some sound before doing anything else */
     if(alsa_slots != -1) {

+#if API_ALSA
+      unsigned short alsa_revents;
+      

       if((err = snd_pcm_poll_descriptors_revents(pcm,
                                                  &fds[alsa_slots],
                                                  alsa_nslots,
                                                  &alsa_revents)) < 0)
         fatal(0, "error calling snd_pcm_poll_descriptors_revents: %d", err);
       if((err = snd_pcm_poll_descriptors_revents(pcm,
                                                  &fds[alsa_slots],
                                                  alsa_nslots,
                                                  &alsa_revents)) < 0)
         fatal(0, "error calling snd_pcm_poll_descriptors_revents: %d", err);

-      if(alsa_revents & POLLOUT)
+      if(alsa_revents & (POLLOUT | POLLERR))
+        play(3 * FRAMES);
+#endif
+    } else if(kid_slot != -1) {
+      if(fds[kid_slot].revents & (POLLOUT | POLLERR))

         play(3 * FRAMES);
     } else {
       /* Some attempt to play must have failed */
         play(3 * FRAMES);
     } else {
       /* Some attempt to play must have failed */


@@ -563,7 +769,7 @@ int main(int argc, char **argv) {
          t = findtrack(sm.id, 1);
           if(fd != -1) acquire(t, fd);
           playing = t;
          t = findtrack(sm.id, 1);
           if(fd != -1) acquire(t, fd);
           playing = t;

-          play(pcm_bufsize);
+          play(bufsize);

           report();
          break;
        case SM_PAUSE:
           report();
          break;
        case SM_PAUSE:


@@ -576,7 +782,7 @@ int main(int argc, char **argv) {
           if(paused) {
             paused = 0;
             if(playing)
           if(paused) {
             paused = 0;
             if(playing)

-              play(pcm_bufsize);
+              play(bufsize);

           }
           report();
          break;
           }
           report();
          break;


@@ -606,16 +812,16 @@ int main(int argc, char **argv) {
     }
     /* Read in any buffered data */
     for(t = tracks; t; t = t->next)
     }
     /* Read in any buffered data */
     for(t = tracks; t; t = t->next)

-      if(t->slot != -1 && (fds[t->slot].revents & POLLIN))
+      if(t->slot != -1 && (fds[t->slot].revents & (POLLIN | POLLHUP)))

          fill(t);
     /* We might be able to play now */
          fill(t);
     /* We might be able to play now */

-    if(pcm && forceplay && playing && !paused)
+    if(ready && forceplay && playing && !paused)

       play(forceplay);
     /* 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
      * of anyone else who wants it. */
       play(forceplay);
     /* 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
      * of anyone else who wants it. */

-    if((!playing || paused) && pcm)
+    if((!playing || paused) && ready)

       idle();
     /* If we've not reported out state for a second do so now. */
     if(time(0) > last_report)
       idle();
     /* If we've not reported out state for a second do so now. */
     if(time(0) > last_report)


@@ -624,13 +830,6 @@ int main(int argc, char **argv) {
   info("stopped (parent terminated)");
   exit(0);
 }
   info("stopped (parent terminated)");
   exit(0);
 }

-#else
-int main(int attribute((unused)) argc, char **argv) {
-  set_progname(argv);
-  mem_init(0);
-  fatal(0, "disorder-speaker not supported on this platform");
-}
-#endif

 
 /*
 Local Variables:
 
 /*
 Local Variables: