source/playlist.c

   1 /*
   2         Copyright (C) 2006 by Jonas Kramer
   3         Published under the terms of the GNU General Public License (GPL).
   4 */
   5
   6 #define _GNU_SOURCE
   7
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <assert.h>
  13 #include <unistd.h>
  14 #include <sys/types.h>
  15
  16
  17 #include "hash.h"
  18 #include "http.h"
  19 #include "settings.h"
  20 #include "service.h"
  21 #include "strary.h"
  22 #include "util.h"
  23
  24 #include "playlist.h"
  25 #include "globals.h"
  26
  27 #include "interface.h"
  28 #include "json.h"
  29 #include "rest.h"
  30
  31
  32 int expand(struct playlist * list) {
  33         struct hash p = { 0, NULL };
  34         char * response;
  35
  36         assert(list != NULL);
  37
  38         set(& p, "discovery", (!!enabled(DISCOVERY)) ? "true" : "false");
  39         response = rest("radio.getPlaylist", & p);
  40
  41         if(response != NULL) {
  42                 int result = parse_playlist(list, response);
  43                 free(response);
  44                 return result;
  45         }
  46         else {
  47                 return 0;
  48         }
  49 }
  50
  51 void trim(char * string){
  52         int offset = 0;
  53         while(string[offset] == ' ')
  54                 offset++;
  55
  56         if(offset)
  57                 memmove(string, string + offset, strlen(string + offset) + 1);
  58 }
  59
  60
  61 int parse_playlist(struct playlist * list, char * plain_json) {
  62         json_value * playlist, * track_array, * track, * extension;
  63         unsigned n;
  64
  65         assert(list != NULL);
  66         assert(plain_json != NULL);
  67
  68         playlist = json_parse(plain_json);
  69
  70         assert(playlist != NULL);
  71
  72         track_array = json_query(playlist, "playlist", "trackList", "track", NULL);
  73
  74         assert(track_array != NULL);
  75
  76         for(n = 0; n < track_array->u.array.length; ++n) {
  77                 struct tracknode * node = NULL;
  78                 char * duration;
  79
  80                 node = malloc(sizeof(struct tracknode));
  81                 assert(node != NULL);
  82
  83                 memset(node, 0, sizeof(struct tracknode));
  84
  85
  86                 track = track_array->u.array.values[n];
  87                 extension = json_query(track, "extension", NULL);
  88
  89                 json_hash(track, & node->track, NULL);
  90                 json_hash(extension, & node->track, NULL);
  91
  92                 if((duration = strdup(value(& node->track, "duration"))) != NULL) {
  93                         duration[strlen(duration) - 3] = 0;
  94                         set(& node->track, "duration", duration);
  95                         free(duration);
  96                 }
  97
  98                 if(list->title) {
  99                         trim(list->title);
 100
 101                         set(& node->track, "station", list->title);
 102                 }
 103                 else {
 104                         set(& node->track, "station", "Unknown Station");
 105                 }
 106
 107                 push(list, node);
 108
 109                 debug("track location: %s\n", value(& node->track, "location"));
 110         }
 111
 112         json_value_free(playlist);
 113
 114         return 1;
 115 }
 116
 117
 118 void freelist(struct playlist * list) {
 119         if(list->title != NULL)
 120                 free(list->title);
 121
 122         while(list->track)
 123                 shift(list);
 124
 125         memset(list, 0, sizeof(struct playlist));
 126 }
 127
 128
 129 void push(struct playlist * list, struct tracknode * node) {
 130         if(!list->track)
 131                 list->track = node;
 132         else {
 133                 struct tracknode * last = list->track;
 134                 while(last->next != NULL)
 135                         last = last->next;
 136                 last->next = node;
 137         }
 138
 139         ++list->left;
 140 }
 141
 142
 143 void shift(struct playlist * list) {
 144         if(list->track) {
 145                 struct tracknode * node = list->track;
 146                 list->track = node->next;
 147                 empty(& node->track);
 148                 free(node);
 149                 --(list->left);
 150         }
 151 }
 152
 153 void preview(struct playlist list) {
 154         struct tracknode * node;
 155         unsigned n = 0;
 156
 157         if (list.track != NULL)
 158                 node = list.track->next;
 159         else
 160         {
 161                 puts("No tracks in queue.");
 162                 return;
 163         }
 164
 165         if(node == NULL) {
 166                 puts("No tracks in queue.");
 167         }
 168         else {
 169                 puts("Upcoming tracks:");
 170                 while(node != NULL) {
 171                         const char * format;
 172
 173                         format = haskey(& rc, "preview-format")
 174                                 ? value(& rc, "preview-format")
 175                                 : "%a - %t";
 176
 177                         printf("%2d %s\n", n++, meta(format, M_COLORED, & node->track));
 178
 179                         node = node->next;
 180                 }
 181         }
 182 }