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

   1 /*
   2  * This file is part of DisOrder.
   3  * Copyright (C) 2004, 2005, 2006 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
  23 #include <sys/types.h>
  24 #include <sys/time.h>
  25 #include <unistd.h>
  26 #include <errno.h>
  27 #include <fnmatch.h>
  28 #include <time.h>
  29 #include <signal.h>
  30 #include <stdlib.h>
  31 #include <assert.h>
  32 #include <sys/socket.h>
  33 #include <string.h>
  34 #include <stdio.h>
  35 #include <pcre.h>
  36 #include <ao/ao.h>
  37
  38 #include "event.h"
  39 #include "log.h"
  40 #include "mem.h"
  41 #include "configuration.h"
  42 #include "queue.h"
  43 #include "trackdb.h"
  44 #include "play.h"
  45 #include "plugin.h"
  46 #include "wstat.h"
  47 #include "eventlog.h"
  48 #include "logfd.h"
  49 #include "syscalls.h"
  50 #include "speaker.h"
  51 #include "disorder.h"
  52 #include "signame.h"
  53 #include "hash.h"
  54
  55 #define SPEAKER "disorder-speaker"
  56
  57 struct queue_entry *playing;
  58 int paused;
  59
  60 static void finished(ev_source *ev);
  61
  62 static int speaker_fd = -1;
  63 static hash *player_pids;
  64 static int shutting_down;
  65
  66 static void store_player_pid(const char *id, pid_t pid) {
  67   if(!player_pids) player_pids = hash_new(sizeof (pid_t));
  68   hash_add(player_pids, id, &pid, HASH_INSERT_OR_REPLACE);
  69 }
  70
  71 static pid_t find_player_pid(const char *id) {
  72   pid_t *pidp;
  73
  74   if(player_pids && (pidp = hash_find(player_pids, id))) return *pidp;
  75   return -1;
  76 }
  77
  78 static void forget_player_pid(const char *id) {
  79   if(player_pids) hash_remove(player_pids, id);
  80 }
  81
  82 /* called when speaker process terminates */
  83 static int speaker_terminated(ev_source attribute((unused)) *ev,
  84                               pid_t attribute((unused)) pid,
  85                               int attribute((unused)) status,
  86                               const struct rusage attribute((unused)) *rusage,
  87                               void attribute((unused)) *u) {
  88   if(status)
  89     error(0, "speaker subprocess terminated with status %s",
  90           wstat(status));
  91   return 0;
  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 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;
 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 write down a pipe (in fact a socket) to
 369        * the speaker process. */
 370       sm.type = smop;
 371       strcpy(sm.id, q->id);
 372       if(socketpair(PF_UNIX, SOCK_STREAM, 0, sp) < 0)
 373         fatal(errno, "error calling socketpair");
 374       xshutdown(sp[0], SHUT_WR);
 375       xshutdown(sp[1], SHUT_RD);
 376       speaker_send(speaker_fd, &sm, sp[0]);
 377       /* Pass the file descriptor to the driver in an environment
 378        * variable. */
 379       snprintf(buffer, sizeof buffer, "DISORDER_RAW_FD=%d", sp[1]);
 380       if(putenv(buffer) < 0)
 381         fatal(errno, "error calling putenv");
 382       xclose(sp[0]);
 383     }
 384     if(waitdevice) {
 385       ao_initialize();
 386       if(*waitdevice) {
 387         n = ao_driver_id(waitdevice);
 388         if(n == -1)
 389           fatal(0, "invalid libao driver: %s", optv[0]);
 390         } else
 391           n = ao_default_driver_id();
 392       /* Make up a format. */
 393       memset(&format, 0, sizeof format);
 394       format.bits = 8;
 395       format.rate = 44100;
 396       format.channels = 1;
 397       format.byte_format = AO_FMT_NATIVE;
 398       retries = 20;
 399       ts.tv_sec = 0;
 400       ts.tv_nsec = 100000000;   /* 0.1s */
 401       while((device = ao_open_live(n, &format, 0)) == 0 && retries-- > 0)
 402           nanosleep(&ts, 0);
 403       if(device)
 404         ao_close(device);
 405     }
 406     play_track(q->pl,
 407                optv, optc,
 408                p,
 409                q->track);
 410     _exit(0);
 411   case -1:                      /* error */
 412     error(errno, "error calling fork");
 413     if(q->type & DISORDER_PLAYER_PREFORK)
 414       play_cleanup(q->pl, q->data);     /* else would leak */
 415     xclose(lfd);
 416     return START_SOFTFAIL;
 417   }
 418   store_player_pid(q->id, pid);
 419   xclose(lfd);
 420   setpgid(pid, pid);
 421   ev_child(ev, pid, 0, player_finished, q);
 422   D(("player subprocess ID %lu", (unsigned long)pid));
 423   return START_OK;
 424 }
 425
 426 int prepare(ev_source *ev,
 427             struct queue_entry *q) {
 428   int n;
 429
 430   /* Find the player plugin */
 431   if(find_player_pid(q->id) > 0) return 0; /* Already going. */
 432   if((n = find_player(q)) < 0) return -1; /* No player */
 433   q->pl = open_plugin(config->player.s[n].s[1], 0); /* No player */
 434   q->type = play_get_type(q->pl);
 435   if((q->type & DISORDER_PLAYER_TYPEMASK) != DISORDER_PLAYER_RAW)
 436     return 0;                           /* Not a raw player */
 437   return start(ev, q, SM_PREPARE);      /* Prepare it */
 438 }
 439
 440 void abandon(ev_source attribute((unused)) *ev,
 441              struct queue_entry *q) {
 442   struct speaker_message sm;
 443   pid_t pid = find_player_pid(q->id);
 444
 445   if(pid < 0) return;                   /* Not prepared. */
 446   if((q->type & DISORDER_PLAYER_TYPEMASK) != DISORDER_PLAYER_RAW)
 447     return;                             /* Not a raw player. */
 448   /* Terminate the player. */
 449   kill(-pid, config->signal);
 450   forget_player_pid(q->id);
 451   /* Cancel the track. */
 452   memset(&sm, 0, sizeof sm);
 453   sm.type = SM_CANCEL;
 454   strcpy(sm.id, q->id);
 455   speaker_send(speaker_fd, &sm, -1);
 456 }
 457
 458 int add_random_track(void) {
 459   struct queue_entry *q;
 460   const char *p;
 461
 462   /* If random play is not enabled then do nothing. */
 463   if(shutting_down || !random_is_enabled())
 464     return 0;
 465   /* If there is already a random track, do nothing. */
 466   for(q = qhead.next; q != &qhead; q = q->next)
 467     if(q->state == playing_random)
 468       return 0;
 469   /* Try to pick a random track */
 470   if(!(p = trackdb_random(16)))
 471     return -1;
 472   /* Add it to the end of the queue. */
 473   q = queue_add(p, 0, WHERE_END);
 474   q->state = playing_random;
 475   /* Commit the queue */
 476   queue_write();
 477   D(("picked %p (%s) at random", (void *)q, q->track));
 478   return 0;
 479 }
 480
 481 /* try to play a track */
 482 void play(ev_source *ev) {
 483   struct queue_entry *q;
 484   int random_enabled = random_is_enabled();
 485
 486   D(("play playing=%p", (void *)playing));
 487   if(shutting_down || playing || !playing_is_enabled()) return;
 488   /* If the queue is empty then add a random track. */
 489   if(qhead.next == &qhead) {
 490     if(!random_enabled)
 491       return;
 492     if(add_random_track()) {
 493       /* On error, try again in 10s. */
 494       retry_play(ev, 10);
 495       return;
 496     }
 497     /* Now there must be at least one track in the queue. */
 498   }
 499   q = qhead.next;
 500   /* If random play is disabled but the track is a random one then don't play
 501    * it.  play() will be called again when random play is re-enabled. */
 502   if(!random_enabled && q->state == playing_random)
 503     return;
 504   D(("taken %p (%s) from queue", (void *)q, q->track));
 505   /* Try to start playing. */
 506   switch(start(ev, q, SM_PLAY)) {
 507   case START_HARDFAIL:
 508     if(q == qhead.next) {
 509       queue_remove(q, 0);               /* Abandon this track. */
 510       queue_played(q);
 511       recent_write();
 512     }
 513     if(qhead.next == &qhead)
 514       /* Queue is empty, wait a bit before trying something else (so we don't
 515        * sit there looping madly in the presence of persistent problem).  Note
 516        * that we might not reliably get a random track lookahead in this case,
 517        * but if we get here then really there are bigger problems. */
 518       retry_play(ev, 1);
 519     else
 520       /* More in queue, try again now. */
 521       play(ev);
 522     break;
 523   case START_SOFTFAIL:
 524     /* Try same track again in a bit. */
 525     retry_play(ev, 10);
 526     break;
 527   case START_OK:
 528     if(q == qhead.next) {
 529       queue_remove(q, 0);
 530       queue_write();
 531     }
 532     playing = q;
 533     time(&playing->played);
 534     playing->state = playing_started;
 535     notify_play(playing->track, playing->submitter);
 536     eventlog("playing", playing->track,
 537              playing->submitter ? playing->submitter : (const char *)0,
 538              (const char *)0);
 539     /* Maybe add a random track. */
 540     add_random_track();
 541     /* If there is another track in the queue prepare it now.  This could
 542      * potentially be a just-added random track. */
 543     if(qhead.next != &qhead)
 544       prepare(ev, qhead.next);
 545     break;
 546   }
 547 }
 548
 549 int playing_is_enabled(void) {
 550   const char *s = trackdb_get_global("playing");
 551
 552   return !s || !strcmp(s, "yes");
 553 }
 554
 555 void enable_playing(const char *who, ev_source *ev) {
 556   trackdb_set_global("playing", "yes", who);
 557   /* Add a random track if necessary. */
 558   add_random_track();
 559   play(ev);
 560 }
 561
 562 void disable_playing(const char *who) {
 563   trackdb_set_global("playing", "no", who);
 564 }
 565
 566 int random_is_enabled(void) {
 567   const char *s = trackdb_get_global("random-play");
 568
 569   return !s || !strcmp(s, "yes");
 570 }
 571
 572 void enable_random(const char *who, ev_source *ev) {
 573   trackdb_set_global("random-play", "yes", who);
 574   add_random_track();
 575   play(ev);
 576 }
 577
 578 void disable_random(const char *who) {
 579   trackdb_set_global("random-play", "no", who);
 580 }
 581
 582 void scratch(const char *who, const char *id) {
 583   struct queue_entry *q;
 584   struct speaker_message sm;
 585   pid_t pid;
 586
 587   D(("scratch playing=%p state=%d id=%s playing->id=%s",
 588      (void *)playing,
 589      playing ? playing->state : 0,
 590      id ? id : "(none)",
 591      playing ? playing->id : "(none)"));
 592   if(playing
 593      && (playing->state == playing_started
 594          || playing->state == playing_paused)
 595      && (!id
 596          || !strcmp(id, playing->id))) {
 597     playing->state = playing_scratched;
 598     playing->scratched = who ? xstrdup(who) : 0;
 599     if((pid = find_player_pid(playing->id)) > 0) {
 600       D(("kill -%d %lu", config->signal, (unsigned long)pid));
 601       kill(-pid, config->signal);
 602       forget_player_pid(playing->id);
 603     } else
 604       error(0, "could not find PID for %s", playing->id);
 605     if((playing->type & DISORDER_PLAYER_TYPEMASK) == DISORDER_PLAYER_RAW) {
 606       memset(&sm, 0, sizeof sm);
 607       sm.type = SM_CANCEL;
 608       strcpy(sm.id, playing->id);
 609       speaker_send(speaker_fd, &sm, -1);
 610       D(("sending SM_CANCEL for %s", playing->id));
 611     }
 612     /* put a scratch track onto the front of the queue (but don't
 613      * bother if playing is disabled) */
 614     if(playing_is_enabled() && config->scratch.n) {
 615       int r = rand() * (double)config->scratch.n / (RAND_MAX + 1.0);
 616       q = queue_add(config->scratch.s[r], who, WHERE_START);
 617       q->state = playing_isscratch;
 618     }
 619     notify_scratch(playing->track, playing->submitter, who,
 620                    time(0) - playing->played);
 621   }
 622 }
 623
 624 void quitting(ev_source *ev) {
 625   struct queue_entry *q;
 626   pid_t pid;
 627
 628   /* Don't start anything new */
 629   shutting_down = 1;
 630   /* Shut down the current player */
 631   if(playing) {
 632     if((pid = find_player_pid(playing->id)) > 0) {
 633       kill(-pid, config->signal);
 634       forget_player_pid(playing->id);
 635     } else
 636       error(0, "could not find PID for %s", playing->id);
 637     playing->state = playing_quitting;
 638     finished(0);
 639   }
 640   /* Zap any other players */
 641   for(q = qhead.next; q != &qhead; q = q->next)
 642     if((pid = find_player_pid(q->id)) > 0) {
 643       D(("kill -%d %lu", config->signal, (unsigned long)pid));
 644       kill(-pid, config->signal);
 645       forget_player_pid(q->id);
 646     } else
 647       error(0, "could not find PID for %s", q->id);
 648   /* Don't need the speaker any more */
 649   ev_fd_cancel(ev, ev_read, speaker_fd);
 650   xclose(speaker_fd);
 651 }
 652
 653 int pause_playing(const char *who) {
 654   struct speaker_message sm;
 655   long played;
 656
 657   /* Can't pause if already paused or if nothing playing. */
 658   if(!playing || paused) return 0;
 659   switch(playing->type & DISORDER_PLAYER_TYPEMASK) {
 660   case DISORDER_PLAYER_STANDALONE:
 661     if(!(playing->type & DISORDER_PLAYER_PAUSES)) {
 662     default:
 663       error(0,  "cannot pause because player is not powerful enough");
 664       return -1;
 665     }
 666     if(play_pause(playing->pl, &played, playing->data)) {
 667       error(0, "player indicates it cannot pause");
 668       return -1;
 669     }
 670     time(&playing->lastpaused);
 671     playing->uptopause = played;
 672     playing->lastresumed = 0;
 673     break;
 674   case DISORDER_PLAYER_RAW:
 675     memset(&sm, 0, sizeof sm);
 676     sm.type = SM_PAUSE;
 677     speaker_send(speaker_fd, &sm, -1);
 678     break;
 679   }
 680   if(who) info("paused by %s", who);
 681   notify_pause(playing->track, who);
 682   paused = 1;
 683   if(playing->state == playing_started)
 684     playing->state = playing_paused;
 685   eventlog("state", "pause", (char *)0);
 686   return 0;
 687 }
 688
 689 void resume_playing(const char *who) {
 690   struct speaker_message sm;
 691
 692   if(!paused) return;
 693   paused = 0;
 694   if(!playing) return;
 695   switch(playing->type & DISORDER_PLAYER_TYPEMASK) {
 696   case DISORDER_PLAYER_STANDALONE:
 697     if(!playing->type & DISORDER_PLAYER_PAUSES) {
 698     default:
 699       /* Shouldn't happen */
 700       return;
 701     }
 702     play_resume(playing->pl, playing->data);
 703     time(&playing->lastresumed);
 704     break;
 705   case DISORDER_PLAYER_RAW:
 706     memset(&sm, 0, sizeof sm);
 707     sm.type = SM_RESUME;
 708     speaker_send(speaker_fd, &sm, -1);
 709     break;
 710   }
 711   if(who) info("resumed by %s", who);
 712   notify_resume(playing->track, who);
 713   if(playing->state == playing_paused)
 714     playing->state = playing_started;
 715   eventlog("state", "resume", (char *)0);
 716 }
 717
 718 /*
 719 Local Variables:
 720 c-basic-offset:2
 721 comment-column:40
 722 fill-column:79
 723 End:
 724 */
 725 /* arch-tag:17f4e83cce4cbaa60a122475379e63f1 */