chiark - git - mdw - disorder/blob - server/play.c

   1 /*
   2  * This file is part of DisOrder.
   3  * Copyright (C) 2004, 2005, 2006, 2007 Richard Kettlewell
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  18  * USA
  19  */
  20
  21 #include <config.h>
  22 #include "types.h"
  23
  24 #include <sys/types.h>
  25 #include <sys/time.h>
  26 #include <unistd.h>
  27 #include <errno.h>
  28 #include <fnmatch.h>
  29 #include <time.h>
  30 #include <signal.h>
  31 #include <stdlib.h>
  32 #include <assert.h>
  33 #include <sys/socket.h>
  34 #include <string.h>
  35 #include <stdio.h>
  36 #include <pcre.h>
  37 #include <ao/ao.h>
  38 #include <sys/wait.h>
  39
  40 #include "event.h"
  41 #include "log.h"
  42 #include "mem.h"
  43 #include "configuration.h"
  44 #include "queue.h"
  45 #include "trackdb.h"
  46 #include "play.h"
  47 #include "plugin.h"
  48 #include "wstat.h"
  49 #include "eventlog.h"
  50 #include "logfd.h"
  51 #include "syscalls.h"
  52 #include "speaker-protocol.h"
  53 #include "disorder.h"
  54 #include "signame.h"
  55 #include "hash.h"
  56
  57 #define SPEAKER "disorder-speaker"
  58
  59 struct queue_entry *playing;
  60 int paused;
  61
  62 static void finished(ev_source *ev);
  63
  64 static int speaker_fd = -1;
  65 static hash *player_pids;
  66 static int shutting_down;
  67
  68 static void store_player_pid(const char *id, pid_t pid) {
  69   if(!player_pids) player_pids = hash_new(sizeof (pid_t));
  70   hash_add(player_pids, id, &pid, HASH_INSERT_OR_REPLACE);
  71 }
  72
  73 static pid_t find_player_pid(const char *id) {
  74   pid_t *pidp;
  75
  76   if(player_pids && (pidp = hash_find(player_pids, id))) return *pidp;
  77   return -1;
  78 }
  79
  80 static void forget_player_pid(const char *id) {
  81   if(player_pids) hash_remove(player_pids, id);
  82 }
  83
  84 /* called when speaker process terminates */
  85 static int speaker_terminated(ev_source attribute((unused)) *ev,
  86                               pid_t attribute((unused)) pid,
  87                               int attribute((unused)) status,
  88                               const struct rusage attribute((unused)) *rusage,
  89                               void attribute((unused)) *u) {
  90   fatal(0, "speaker subprocess %s",
  91         wstat(status));
  92 }
  93
  94 /* called when speaker process has something to say */
  95 static int speaker_readable(ev_source *ev, int fd,
  96                             void attribute((unused)) *u) {
  97   struct speaker_message sm;
  98   int ret = speaker_recv(fd, &sm, 0);
  99
 100   if(ret < 0) return 0;                 /* EAGAIN */
 101   if(!ret) {                            /* EOF */
 102     ev_fd_cancel(ev, ev_read, fd);
 103     return 0;
 104   }
 105   switch(sm.type) {
 106   case SM_PAUSED:
 107     /* track ID is paused, DATA seconds played */
 108     D(("SM_PAUSED %s %ld", sm.id, sm.data));
 109     playing->sofar = sm.data;
 110     break;
 111   case SM_FINISHED:
 112     /* the playing track finished */
 113     D(("SM_FINISHED %s", sm.id));
 114     finished(ev);
 115     break;
 116   case SM_PLAYING:
 117     /* track ID is playing, DATA seconds played */
 118     D(("SM_PLAYING %s %ld", sm.id, sm.data));
 119     playing->sofar = sm.data;
 120     break;
 121   default:
 122     error(0, "unknown message type %d", sm.type);
 123   }
 124   return 0;
 125 }
 126
 127 void speaker_setup(ev_source *ev) {
 128   int sp[2], lfd;
 129   pid_t pid;
 130
 131   if(socketpair(PF_UNIX, SOCK_DGRAM, 0, sp) < 0)
 132     fatal(errno, "error calling socketpair");
 133   if(!isatty(2))
 134     lfd = logfd(ev, SPEAKER);
 135   else
 136     lfd = -1;
 137   if(!(pid = xfork())) {
 138     exitfn = _exit;
 139     ev_signal_atfork(ev);
 140     xdup2(sp[0], 0);
 141     xdup2(sp[0], 1);
 142     xclose(sp[0]);
 143     xclose(sp[1]);
 144     if(lfd != -1) {
 145       xdup2(lfd, 2);
 146       xclose(lfd);
 147     }
 148     signal(SIGPIPE, SIG_DFL);
 149 #if 0
 150     execlp("valgrind", "valgrind", SPEAKER, "--config", configfile,
 151            debugging ? "--debug" : "--no-debug", (char *)0);
 152 #else
 153     execlp(SPEAKER, SPEAKER, "--config", configfile,
 154            debugging ? "--debug" : "--no-debug", (char *)0);
 155 #endif
 156     fatal(errno, "error invoking %s", SPEAKER);
 157   }
 158   ev_child(ev, pid, 0, speaker_terminated, 0);
 159   speaker_fd = sp[1];
 160   xclose(sp[0]);
 161   cloexec(speaker_fd);
 162   /* Don't need to make speaker_fd nonblocking because speaker_recv() uses
 163    * MSG_DONTWAIT. */
 164   ev_fd(ev, ev_read, speaker_fd, speaker_readable, 0);
 165 }
 166
 167 void speaker_reload(void) {
 168   struct speaker_message sm;
 169
 170   memset(&sm, 0, sizeof sm);
 171   sm.type = SM_RELOAD;
 172   speaker_send(speaker_fd, &sm, -1);
 173 }
 174
 175 /* timeout for play retry */
 176 static int play_again(ev_source *ev,
 177                       const struct timeval attribute((unused)) *now,
 178                       void attribute((unused)) *u) {
 179   D(("play_again"));
 180   play(ev);
 181   return 0;
 182 }
 183
 184 /* try calling play() again after @offset@ seconds */
 185 static void retry_play(ev_source *ev, int offset) {
 186   struct timeval w;
 187
 188   D(("retry_play(%d)", offset));
 189   gettimeofday(&w, 0);
 190   w.tv_sec += offset;
 191   ev_timeout(ev, 0, &w, play_again, 0);
 192 }
 193
 194 /* Called when the currently playing track finishes playing.  This
 195  * might be because the player finished or because the speaker process
 196  * told us so. */
 197 static void finished(ev_source *ev) {
 198   D(("finished playing=%p", (void *)playing));
 199   if(!playing)
 200     return;
 201   if(playing->state != playing_scratched)
 202     notify_not_scratched(playing->track, playing->submitter);
 203   switch(playing->state) {
 204   case playing_ok:
 205     eventlog("completed", playing->track, (char *)0);
 206     break;
 207   case playing_scratched:
 208     eventlog("scratched", playing->track, playing->scratched, (char *)0);
 209     break;
 210   case playing_failed:
 211     eventlog("failed", playing->track, wstat(playing->wstat), (char *)0);
 212     break;
 213   default:
 214     break;
 215   }
 216   queue_played(playing);
 217   recent_write();
 218   forget_player_pid(playing->id);
 219   playing = 0;
 220   if(ev) retry_play(ev, config->gap);
 221 }
 222
 223 /* Called when a player terminates. */
 224 static int player_finished(ev_source *ev,
 225                            pid_t pid,
 226                            int status,
 227                            const struct rusage attribute((unused)) *rusage,
 228                            void *u) {
 229   struct queue_entry *q = u;
 230
 231   D(("player_finished pid=%lu status=%#x",
 232      (unsigned long)pid, (unsigned)status));
 233   /* Record that this PID is dead.  If we killed the track we might know this
 234    * already, but also it might have exited or crashed.  Either way we don't
 235    * want to end up signalling it. */
 236   if(pid == find_player_pid(q->id))
 237     forget_player_pid(q->id);
 238   switch(q->state) {
 239   case playing_unplayed:
 240   case playing_random:
 241     /* If this was an SM_PREPARE track then either it failed or we deliberately
 242      * stopped it because it was removed from the queue or moved down it.  So
 243      * leave it state alone for future use. */
 244     break;
 245   default:
 246     /* We actually started playing this track. */
 247     if(status) {
 248       if(q->state != playing_scratched)
 249         q->state = playing_failed;
 250     } else
 251       q->state = playing_ok;
 252     break;
 253   }
 254   /* Regardless we always report and record the status and do cleanup for
 255    * prefork calls. */
 256   if(status)
 257     error(0, "player for %s %s", q->track, wstat(status));
 258   if(q->type & DISORDER_PLAYER_PREFORK)
 259     play_cleanup(q->pl, q->data);
 260   q->wstat = status;
 261   /* If this actually was the current track, and does not use the speaker
 262    * process, then it must have finished.  For raw-output players we will get a
 263    * separate notification from the speaker process. */
 264   if(q == playing
 265      && (q->type & DISORDER_PLAYER_TYPEMASK) != DISORDER_PLAYER_RAW)
 266     finished(ev);
 267   return 0;
 268 }
 269
 270 /* Find the player for Q */
 271 static int find_player(const struct queue_entry *q) {
 272   int n;
 273
 274   for(n = 0; n < config->player.n; ++n)
 275     if(fnmatch(config->player.s[n].s[0], q->track, 0) == 0)
 276       break;
 277   if(n >= config->player.n)
 278     return -1;
 279   else
 280     return n;
 281 }
 282
 283 /* Return values from start() */
 284 #define START_OK 0                      /* Succeeded. */
 285 #define START_HARDFAIL 1                /* Track is broken. */
 286 #define START_SOFTFAIL 2           /* Track OK, system (temporarily?) broken */
 287
 288 /* Play or prepare Q */
 289 static int start(ev_source *ev,
 290                  struct queue_entry *q,
 291                  int smop) {
 292   int n, lfd;
 293   const char *p;
 294   int np[2], sp[2];
 295   struct speaker_message sm;
 296   char buffer[64];
 297   int optc;
 298   ao_sample_format format;
 299   ao_device *device;
 300   int retries;
 301   struct timespec ts;
 302   const char *waitdevice = 0;
 303   const char *const *optv;
 304   pid_t pid, npid;
 305
 306   memset(&sm, 0, sizeof sm);
 307   if(find_player_pid(q->id) > 0) {
 308     if(smop == SM_PREPARE) return START_OK;
 309     /* We have already sent an SM_PREPARE for this track so we just need to
 310      * tell the speaker process to start actually playing the queued up audio
 311      * data */
 312     strcpy(sm.id, q->id);
 313     sm.type = SM_PLAY;
 314     speaker_send(speaker_fd, &sm, -1);
 315     return START_OK;
 316   }
 317   /* Find the player plugin. */
 318   if((n = find_player(q)) < 0) return START_HARDFAIL;
 319   if(!(q->pl = open_plugin(config->player.s[n].s[1], 0)))
 320     return START_HARDFAIL;
 321   q->type = play_get_type(q->pl);
 322   /* Can't prepare non-raw tracks. */
 323   if(smop == SM_PREPARE
 324      && (q->type & DISORDER_PLAYER_TYPEMASK) != DISORDER_PLAYER_RAW)
 325     return START_OK;
 326   /* Call the prefork function. */
 327   p = trackdb_rawpath(q->track);
 328   if(q->type & DISORDER_PLAYER_PREFORK)
 329     if(!(q->data = play_prefork(q->pl, p))) {
 330       error(0, "prefork function for %s failed", q->track);
 331       return START_HARDFAIL;
 332     }
 333   /* Use the second arg as the tag if available (it's probably a command name),
 334    * otherwise the module name. */
 335   lfd = logfd(ev, (config->player.s[n].s[2]
 336                    ? config->player.s[n].s[2] : config->player.s[n].s[1]));
 337   optc = config->player.s[n].n - 2;
 338   optv = (void *)&config->player.s[n].s[2];
 339   while(optc > 0 && optv[0][0] == '-') {
 340     if(!strcmp(optv[0], "--")) {
 341       ++optv;
 342       --optc;
 343       break;
 344     }
 345     if(!strcmp(optv[0], "--wait-for-device")
 346        || !strncmp(optv[0], "--wait-for-device=", 18)) {
 347       if((waitdevice = strchr(optv[0], '='))) {
 348         ++waitdevice;
 349       } else
 350         waitdevice = "";                /* use default */
 351       ++optv;
 352       --optc;
 353     } else {
 354       error(0, "unknown option %s", optv[0]);
 355       return START_HARDFAIL;
 356     }
 357   }
 358   switch(pid = fork()) {
 359   case 0:                       /* child */
 360     exitfn = _exit;
 361     ev_signal_atfork(ev);
 362     signal(SIGPIPE, SIG_DFL);
 363     xdup2(lfd, 1);
 364     xdup2(lfd, 2);
 365     xclose(lfd);                        /* tidy up */
 366     setpgid(0, 0);
 367     if((q->type & DISORDER_PLAYER_TYPEMASK) == DISORDER_PLAYER_RAW) {
 368       /* "Raw" format players need special treatment:
 369        * 1) their output needs to go via the disorder-normalize process
 370        * 2) the output of that needs to be passed to the disorder-speaker
 371        *    process.
 372        */
 373       /* np will be the pipe to disorder-normalize */
 374       if(socketpair(PF_UNIX, SOCK_STREAM, 0, np) < 0)
 375         fatal(errno, "error calling socketpair");
 376       xshutdown(np[0], SHUT_WR);        /* normalize reads from np[0] */
 377       xshutdown(np[1], SHUT_RD);        /* decoder writes to np[1] */
 378       /* sp will be the pipe to disorder-speaker */
 379       sm.type = smop;
 380       if(socketpair(PF_UNIX, SOCK_STREAM, 0, sp) < 0)
 381         fatal(errno, "error calling socketpair");
 382       xshutdown(sp[0], SHUT_WR);        /* speaker reads from sp[0] */
 383       xshutdown(sp[1], SHUT_RD);        /* normalize writes to sp[1] */
 384       /* Start disorder-normalize */
 385       if(!(npid = xfork())) {
 386         if(!xfork()) {
 387           xdup2(np[0], 0);
 388           xdup2(sp[1], 1);
 389           xclose(np[0]);
 390           xclose(np[1]);
 391           xclose(sp[0]);
 392           xclose(sp[1]);
 393           execlp("disorder-normalize", "disorder-normalize", (char *)0);
 394           fatal(errno, "executing disorder-normalize");
 395         }
 396         _exit(0);
 397       } else {
 398         int w;
 399
 400         while(waitpid(npid, &w, 0) < 0 && errno == EINTR)
 401           ;
 402       }
 403       /* Send the speaker process the file descriptor to read from */
 404       strcpy(sm.id, q->id);
 405       speaker_send(speaker_fd, &sm, sp[0]);
 406       /* Pass the file descriptor to the driver in an environment
 407        * variable. */
 408       snprintf(buffer, sizeof buffer, "DISORDER_RAW_FD=%d", np[1]);
 409       if(putenv(buffer) < 0)
 410         fatal(errno, "error calling putenv");
 411       /* Close all the FDs we don't need */
 412       xclose(sp[0]);
 413       xclose(sp[1]);
 414       xclose(np[0]);
 415     }
 416     if(waitdevice) {
 417       ao_initialize();
 418       if(*waitdevice) {
 419         n = ao_driver_id(waitdevice);
 420         if(n == -1)
 421           fatal(0, "invalid libao driver: %s", optv[0]);
 422         } else
 423           n = ao_default_driver_id();
 424       /* Make up a format. */
 425       memset(&format, 0, sizeof format);
 426       format.bits = 8;
 427       format.rate = 44100;
 428       format.channels = 1;
 429       format.byte_format = AO_FMT_NATIVE;
 430       retries = 20;
 431       ts.tv_sec = 0;
 432       ts.tv_nsec = 100000000;   /* 0.1s */
 433       while((device = ao_open_live(n, &format, 0)) == 0 && retries-- > 0)
 434           nanosleep(&ts, 0);
 435       if(device)
 436         ao_close(device);
 437     }
 438     play_track(q->pl,
 439                optv, optc,
 440                p,
 441                q->track);
 442     _exit(0);
 443   case -1:                      /* error */
 444     error(errno, "error calling fork");
 445     if(q->type & DISORDER_PLAYER_PREFORK)
 446       play_cleanup(q->pl, q->data);     /* else would leak */
 447     xclose(lfd);
 448     return START_SOFTFAIL;
 449   }
 450   store_player_pid(q->id, pid);
 451   xclose(lfd);
 452   setpgid(pid, pid);
 453   ev_child(ev, pid, 0, player_finished, q);
 454   D(("player subprocess ID %lu", (unsigned long)pid));
 455   return START_OK;
 456 }
 457
 458 int prepare(ev_source *ev,
 459             struct queue_entry *q) {
 460   int n;
 461
 462   /* Find the player plugin */
 463   if(find_player_pid(q->id) > 0) return 0; /* Already going. */
 464   if((n = find_player(q)) < 0) return -1; /* No player */
 465   q->pl = open_plugin(config->player.s[n].s[1], 0); /* No player */
 466   q->type = play_get_type(q->pl);
 467   if((q->type & DISORDER_PLAYER_TYPEMASK) != DISORDER_PLAYER_RAW)
 468     return 0;                           /* Not a raw player */
 469   return start(ev, q, SM_PREPARE);      /* Prepare it */
 470 }
 471
 472 void abandon(ev_source attribute((unused)) *ev,
 473              struct queue_entry *q) {
 474   struct speaker_message sm;
 475   pid_t pid = find_player_pid(q->id);
 476
 477   if(pid < 0) return;                   /* Not prepared. */
 478   if((q->type & DISORDER_PLAYER_TYPEMASK) != DISORDER_PLAYER_RAW)
 479     return;                             /* Not a raw player. */
 480   /* Terminate the player. */
 481   kill(-pid, config->signal);
 482   forget_player_pid(q->id);
 483   /* Cancel the track. */
 484   memset(&sm, 0, sizeof sm);
 485   sm.type = SM_CANCEL;
 486   strcpy(sm.id, q->id);
 487   speaker_send(speaker_fd, &sm, -1);
 488 }
 489
 490 int add_random_track(void) {
 491   struct queue_entry *q;
 492   const char *p;
 493   long qlen = 0;
 494   int rc = 0;
 495
 496   /* If random play is not enabled then do nothing. */
 497   if(shutting_down || !random_is_enabled())
 498     return 0;
 499   /* Count how big the queue is */
 500   for(q = qhead.next; q != &qhead; q = q->next)
 501     ++qlen;
 502   /* Add random tracks until the queue is at the right size */
 503   while(qlen < config->queue_pad) {
 504     /* Try to pick a random track */
 505     if(!(p = trackdb_random(16))) {
 506       rc = -1;
 507       break;
 508     }
 509     /* Add it to the end of the queue. */
 510     q = queue_add(p, 0, WHERE_END);
 511     q->state = playing_random;
 512     D(("picked %p (%s) at random", (void *)q, q->track));
 513     ++qlen;
 514   }
 515   /* Commit the queue */
 516   queue_write();
 517   return rc;
 518 }
 519
 520 /* try to play a track */
 521 void play(ev_source *ev) {
 522   struct queue_entry *q;
 523   int random_enabled = random_is_enabled();
 524
 525   D(("play playing=%p", (void *)playing));
 526   if(shutting_down || playing || !playing_is_enabled()) return;
 527   /* If the queue is empty then add a random track. */
 528   if(qhead.next == &qhead) {
 529     if(!random_enabled)
 530       return;
 531     if(add_random_track()) {
 532       /* On error, try again in 10s. */
 533       retry_play(ev, 10);
 534       return;
 535     }
 536     /* Now there must be at least one track in the queue. */
 537   }
 538   q = qhead.next;
 539   /* If random play is disabled but the track is a random one then don't play
 540    * it.  play() will be called again when random play is re-enabled. */
 541   if(!random_enabled && q->state == playing_random)
 542     return;
 543   D(("taken %p (%s) from queue", (void *)q, q->track));
 544   /* Try to start playing. */
 545   switch(start(ev, q, SM_PLAY)) {
 546   case START_HARDFAIL:
 547     if(q == qhead.next) {
 548       queue_remove(q, 0);               /* Abandon this track. */
 549       queue_played(q);
 550       recent_write();
 551     }
 552     if(qhead.next == &qhead)
 553       /* Queue is empty, wait a bit before trying something else (so we don't
 554        * sit there looping madly in the presence of persistent problem).  Note
 555        * that we might not reliably get a random track lookahead in this case,
 556        * but if we get here then really there are bigger problems. */
 557       retry_play(ev, 1);
 558     else
 559       /* More in queue, try again now. */
 560       play(ev);
 561     break;
 562   case START_SOFTFAIL:
 563     /* Try same track again in a bit. */
 564     retry_play(ev, 10);
 565     break;
 566   case START_OK:
 567     if(q == qhead.next) {
 568       queue_remove(q, 0);
 569       queue_write();
 570     }
 571     playing = q;
 572     time(&playing->played);
 573     playing->state = playing_started;
 574     notify_play(playing->track, playing->submitter);
 575     eventlog("playing", playing->track,
 576              playing->submitter ? playing->submitter : (const char *)0,
 577              (const char *)0);
 578     /* Maybe add a random track. */
 579     add_random_track();
 580     /* If there is another track in the queue prepare it now.  This could
 581      * potentially be a just-added random track. */
 582     if(qhead.next != &qhead)
 583       prepare(ev, qhead.next);
 584     break;
 585   }
 586 }
 587
 588 int playing_is_enabled(void) {
 589   const char *s = trackdb_get_global("playing");
 590
 591   return !s || !strcmp(s, "yes");
 592 }
 593
 594 void enable_playing(const char *who, ev_source *ev) {
 595   trackdb_set_global("playing", "yes", who);
 596   /* Add a random track if necessary. */
 597   add_random_track();
 598   play(ev);
 599 }
 600
 601 void disable_playing(const char *who) {
 602   trackdb_set_global("playing", "no", who);
 603 }
 604
 605 int random_is_enabled(void) {
 606   const char *s = trackdb_get_global("random-play");
 607
 608   return !s || !strcmp(s, "yes");
 609 }
 610
 611 void enable_random(const char *who, ev_source *ev) {
 612   trackdb_set_global("random-play", "yes", who);
 613   add_random_track();
 614   play(ev);
 615 }
 616
 617 void disable_random(const char *who) {
 618   trackdb_set_global("random-play", "no", who);
 619 }
 620
 621 void scratch(const char *who, const char *id) {
 622   struct queue_entry *q;
 623   struct speaker_message sm;
 624   pid_t pid;
 625
 626   D(("scratch playing=%p state=%d id=%s playing->id=%s",
 627      (void *)playing,
 628      playing ? playing->state : 0,
 629      id ? id : "(none)",
 630      playing ? playing->id : "(none)"));
 631   if(playing
 632      && (playing->state == playing_started
 633          || playing->state == playing_paused)
 634      && (!id
 635          || !strcmp(id, playing->id))) {
 636     playing->state = playing_scratched;
 637     playing->scratched = who ? xstrdup(who) : 0;
 638     if((pid = find_player_pid(playing->id)) > 0) {
 639       D(("kill -%d %lu", config->signal, (unsigned long)pid));
 640       kill(-pid, config->signal);
 641       forget_player_pid(playing->id);
 642     } else
 643       error(0, "could not find PID for %s", playing->id);
 644     if((playing->type & DISORDER_PLAYER_TYPEMASK) == DISORDER_PLAYER_RAW) {
 645       memset(&sm, 0, sizeof sm);
 646       sm.type = SM_CANCEL;
 647       strcpy(sm.id, playing->id);
 648       speaker_send(speaker_fd, &sm, -1);
 649       D(("sending SM_CANCEL for %s", playing->id));
 650     }
 651     /* put a scratch track onto the front of the queue (but don't
 652      * bother if playing is disabled) */
 653     if(playing_is_enabled() && config->scratch.n) {
 654       int r = rand() * (double)config->scratch.n / (RAND_MAX + 1.0);
 655       q = queue_add(config->scratch.s[r], who, WHERE_START);
 656       q->state = playing_isscratch;
 657     }
 658     notify_scratch(playing->track, playing->submitter, who,
 659                    time(0) - playing->played);
 660   }
 661 }
 662
 663 void quitting(ev_source *ev) {
 664   struct queue_entry *q;
 665   pid_t pid;
 666
 667   /* Don't start anything new */
 668   shutting_down = 1;
 669   /* Shut down the current player */
 670   if(playing) {
 671     if((pid = find_player_pid(playing->id)) > 0) {
 672       kill(-pid, config->signal);
 673       forget_player_pid(playing->id);
 674     } else
 675       error(0, "could not find PID for %s", playing->id);
 676     playing->state = playing_quitting;
 677     finished(0);
 678   }
 679   /* Zap any other players */
 680   for(q = qhead.next; q != &qhead; q = q->next)
 681     if((pid = find_player_pid(q->id)) > 0) {
 682       D(("kill -%d %lu", config->signal, (unsigned long)pid));
 683       kill(-pid, config->signal);
 684       forget_player_pid(q->id);
 685     } else
 686       error(0, "could not find PID for %s", q->id);
 687   /* Don't need the speaker any more */
 688   ev_fd_cancel(ev, ev_read, speaker_fd);
 689   xclose(speaker_fd);
 690 }
 691
 692 int pause_playing(const char *who) {
 693   struct speaker_message sm;
 694   long played;
 695
 696   /* Can't pause if already paused or if nothing playing. */
 697   if(!playing || paused) return 0;
 698   switch(playing->type & DISORDER_PLAYER_TYPEMASK) {
 699   case DISORDER_PLAYER_STANDALONE:
 700     if(!(playing->type & DISORDER_PLAYER_PAUSES)) {
 701     default:
 702       error(0,  "cannot pause because player is not powerful enough");
 703       return -1;
 704     }
 705     if(play_pause(playing->pl, &played, playing->data)) {
 706       error(0, "player indicates it cannot pause");
 707       return -1;
 708     }
 709     time(&playing->lastpaused);
 710     playing->uptopause = played;
 711     playing->lastresumed = 0;
 712     break;
 713   case DISORDER_PLAYER_RAW:
 714     memset(&sm, 0, sizeof sm);
 715     sm.type = SM_PAUSE;
 716     speaker_send(speaker_fd, &sm, -1);
 717     break;
 718   }
 719   if(who) info("paused by %s", who);
 720   notify_pause(playing->track, who);
 721   paused = 1;
 722   if(playing->state == playing_started)
 723     playing->state = playing_paused;
 724   eventlog("state", "pause", (char *)0);
 725   return 0;
 726 }
 727
 728 void resume_playing(const char *who) {
 729   struct speaker_message sm;
 730
 731   if(!paused) return;
 732   paused = 0;
 733   if(!playing) return;
 734   switch(playing->type & DISORDER_PLAYER_TYPEMASK) {
 735   case DISORDER_PLAYER_STANDALONE:
 736     if(!playing->type & DISORDER_PLAYER_PAUSES) {
 737     default:
 738       /* Shouldn't happen */
 739       return;
 740     }
 741     play_resume(playing->pl, playing->data);
 742     time(&playing->lastresumed);
 743     break;
 744   case DISORDER_PLAYER_RAW:
 745     memset(&sm, 0, sizeof sm);
 746     sm.type = SM_RESUME;
 747     speaker_send(speaker_fd, &sm, -1);
 748     break;
 749   }
 750   if(who) info("resumed by %s", who);
 751   notify_resume(playing->track, who);
 752   if(playing->state == playing_paused)
 753     playing->state = playing_started;
 754   eventlog("state", "resume", (char *)0);
 755 }
 756
 757 /*
 758 Local Variables:
 759 c-basic-offset:2
 760 comment-column:40
 761 fill-column:79
 762 End:
 763 */