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

   1 /*
   2  * This file is part of DisOrder.
   3  * Copyright (C) 2004-2009 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 3 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,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU 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, see <http://www.gnu.org/licenses/>.
  17  */
  18 /** @file server/server-queue.c
  19  * @brief Server-specific track queue support
  20  */
  21 #include "disorder-server.h"
  22
  23 /* the head of the queue is played next, so normally we add to the tail */
  24 struct queue_entry qhead = {
  25   .next = &qhead,
  26   .prev = &qhead
  27 };
  28
  29 /* the head of the recent list is the oldest thing, the tail the most recently
  30  * played */
  31 struct queue_entry phead = {
  32   .next = &phead,
  33   .prev = &phead
  34 };
  35
  36 long pcount;
  37
  38 void queue_fix_sofar(struct queue_entry *q) {
  39   long sofar;
  40
  41   /* Fake up SOFAR field for currently-playing tracks that don't have it filled
  42    * in by the speaker process.  XXX this horrible bodge should go away when we
  43    * have a more general implementation of pausing as that field will always
  44    * have to be right for the playing track. */
  45   if((q->state == playing_started
  46       || q->state == playing_paused)
  47      && q->type & DISORDER_PLAYER_PAUSES
  48      && (q->type & DISORDER_PLAYER_TYPEMASK) != DISORDER_PLAYER_RAW) {
  49     if(q->lastpaused) {
  50       if(q->uptopause == -1)            /* Don't know how far thru. */
  51         sofar = -1;
  52       else if(q->lastresumed)           /* Has been paused and resumed. */
  53         sofar = q->uptopause + xtime(0) - q->lastresumed;
  54       else                              /* Currently paused. */
  55         sofar = q->uptopause;
  56     } else                              /* Never been paused. */
  57       sofar = xtime(0) - q->played;
  58     q->sofar = sofar;
  59   }
  60 }
  61
  62 static void queue_read_error(const char *msg,
  63                              void *u) {
  64   disorder_fatal(0, "error parsing queue %s: %s", (const char *)u, msg);
  65 }
  66
  67 static void queue_do_read(struct queue_entry *head, const char *path) {
  68   char *buffer;
  69   FILE *fp;
  70   struct queue_entry *q;
  71   int ver = 0;
  72
  73   if(!(fp = fopen(path, "r"))) {
  74     if(errno == ENOENT)
  75       return;                   /* no queue */
  76     disorder_fatal(errno, "error opening %s", path);
  77   }
  78   head->next = head->prev = head;
  79   while(!inputline(path, fp, &buffer, '\n')) {
  80     if(buffer[0] == '#') {
  81       /* Version indicator */
  82       ver = atoi(buffer + 1);
  83       continue;
  84     }
  85     q = xmalloc(sizeof *q);
  86     queue_unmarshall(q, buffer, queue_read_error, (void *)path);
  87     if(ver < 1) {
  88       /* Fix up origin field as best we can; will be wrong in some cases but
  89        * hopefully not too horribly so. */
  90       q->origin = q->submitter ? origin_picked : origin_random;
  91       /* Eliminated obsolete states, since they are assumed elsewhere not to be
  92        * set. */
  93       switch(q->state) {
  94       case playing_isscratch:
  95         q->origin = origin_scratch;
  96         q->state = playing_unplayed;
  97         break;
  98       case playing_random:
  99         q->state = playing_unplayed;
 100         break;
 101       default:
 102         break;
 103       }
 104     }
 105     if(head == &qhead
 106        && (!q->track
 107            || !q->when))
 108       disorder_fatal(0, "incomplete queue entry in %s", path);
 109     queue_insert_entry(head->prev, q);
 110   }
 111   if(ferror(fp))
 112     disorder_fatal(errno, "error reading %s", path);
 113   fclose(fp);
 114 }
 115
 116 void queue_read(void) {
 117   queue_do_read(&qhead, config_get_file("queue"));
 118 }
 119
 120 void recent_read(void) {
 121   struct queue_entry *q;
 122
 123   queue_do_read(&phead, config_get_file("recent"));
 124   /* reset pcount after loading */
 125   pcount = 0;
 126   q = phead.next;
 127   while(q != &phead) {
 128     ++pcount;
 129     q = q->next;
 130   }
 131 }
 132
 133 static void queue_do_write(const struct queue_entry *head, const char *path) {
 134   char *tmp;
 135   FILE *fp;
 136   struct queue_entry *q;
 137
 138   byte_xasprintf(&tmp, "%s.new", path);
 139   if(!(fp = fopen(tmp, "w"))) disorder_fatal(errno, "error opening %s", tmp);
 140   /* Save version indicator */
 141   if(fprintf(fp, "#1\n") < 0)
 142     disorder_fatal(errno, "error writing %s", tmp);
 143   for(q = head->next; q != head; q = q->next)
 144     if(fprintf(fp, "%s\n", queue_marshall(q)) < 0)
 145       disorder_fatal(errno, "error writing %s", tmp);
 146   if(fclose(fp) < 0) disorder_fatal(errno, "error closing %s", tmp);
 147   if(rename(tmp, path) < 0) disorder_fatal(errno, "error replacing %s", path);
 148 }
 149
 150 void queue_write(void) {
 151   queue_do_write(&qhead, config_get_file("queue"));
 152 }
 153
 154 void recent_write(void) {
 155   queue_do_write(&phead, config_get_file("recent"));
 156 }
 157
 158 struct queue_entry *queue_find(const char *key) {
 159   struct queue_entry *q;
 160
 161   for(q = qhead.next;
 162       q != &qhead && strcmp(q->track, key) && strcmp(q->id, key);
 163       q = q->next)
 164     ;
 165   return q != &qhead ? q : 0;
 166 }
 167
 168 /*
 169 Local Variables:
 170 c-basic-offset:2
 171 comment-column:40
 172 fill-column:79
 173 indent-tabs-mode:nil
 174 End:
 175 */