playlist.c

   1 /*
   2  * Copyright (C) 2007 Andre Noll <maan@tuebingen.mpg.de>
   3  *
   4  * Licensed under the GPL v2. For licencing details see COPYING.
   5  */
   6
   7 #include <regex.h>
   8 #include <osl.h>
   9 #include <lopsub.h>
  10
  11 #include "para.h"
  12 #include "error.h"
  13 #include "string.h"
  14 #include "afh.h"
  15 #include "afs.h"
  16 #include "ipc.h"
  17 #include "sideband.h"
  18
  19 /** \file playlist.c Functions for loading and saving playlists. */
  20
  21 /** Structure used for adding entries to a playlist. */
  22 struct playlist_info {
  23         /** The name of the playlist. */
  24         char *name;
  25         /** The number of entries currently in the playlist. */
  26         unsigned length;
  27 };
  28 static struct playlist_info current_playlist;
  29
  30 /**
  31  * Re-insert an audio file into the tree of admissible files.
  32  *
  33  * \param aft_row Determines the audio file.
  34  *
  35  * \return The return value of score_update().
  36  */
  37 static int playlist_update_audio_file(const struct osl_row *aft_row)
  38 {
  39         /* always re-insert to the top of the tree */
  40         return score_update(aft_row, 0);
  41 }
  42
  43 static int add_playlist_entry(char *path, void *data)
  44 {
  45         struct playlist_info *playlist = data;
  46         struct osl_row *aft_row;
  47         int ret = aft_get_row_of_path(path, &aft_row);
  48
  49         if (ret < 0) {
  50                 PARA_NOTICE_LOG("%s: %s\n", path, para_strerror(-ret));
  51                 return 1;
  52         }
  53         ret = score_add(aft_row, -playlist->length);
  54         if (ret < 0) {
  55                 PARA_ERROR_LOG("failed to add %s: %s\n", path, para_strerror(-ret));
  56                 return ret;
  57         }
  58         playlist->length++;
  59         return 1;
  60 }
  61
  62 /* returns -E_PLAYLIST_LOADED on _success_ to terminate the loop */
  63 static int load_playlist(struct osl_row *row, void *data)
  64 {
  65         struct playlist_info *playlist = data;
  66         struct osl_object playlist_def;
  67         char *playlist_name;
  68         int ret;
  69
  70         ret = pl_get_name_and_def_by_row(row, &playlist_name, &playlist_def);
  71         if (ret < 0)
  72                 goto err;
  73         playlist->length = 0;
  74         ret = for_each_line(FELF_READ_ONLY, playlist_def.data,
  75                 playlist_def.size, add_playlist_entry, playlist);
  76         osl_close_disk_object(&playlist_def);
  77         if (ret < 0)
  78                 goto err;
  79         ret = -E_PLAYLIST_EMPTY;
  80         if (!playlist->length)
  81                 goto err;
  82         playlist->name = para_strdup(playlist_name);
  83         PARA_NOTICE_LOG("loaded playlist %s (%u files)\n", playlist->name,
  84                 playlist->length);
  85         return -E_PLAYLIST_LOADED;
  86 err:
  87         if (ret != -E_DUMMY_ROW)
  88                 PARA_NOTICE_LOG("unable to load playlist (%s)\n",
  89                         para_strerror(-ret));
  90         return 1;
  91 }
  92
  93 static int check_playlist_path(char *path, void *data)
  94 {
  95         struct para_buffer *pb = data;
  96         struct osl_row *aft_row;
  97         int ret = aft_get_row_of_path(path, &aft_row);
  98
  99         if (ret < 0)
 100                 para_printf(pb, "%s: %s\n", path, para_strerror(-ret));
 101         return 1; /* do not fail the loop on bad paths */
 102 }
 103
 104 static int check_playlist(struct osl_row *row, void *data)
 105 {
 106         struct para_buffer *pb = data;
 107         struct osl_object playlist_def;
 108         char *playlist_name;
 109         int ret = pl_get_name_and_def_by_row(row, &playlist_name, &playlist_def);
 110
 111         if (ret < 0) { /* log error, but continue */
 112                 para_printf(pb, "failed to get playlist data: %s\n",
 113                         para_strerror(-ret));
 114                 return 1;
 115         }
 116         if (*playlist_name) { /* skip dummy row */
 117                 para_printf(pb, "checking playlist %s...\n", playlist_name);
 118                 for_each_line(FELF_READ_ONLY, playlist_def.data,
 119                         playlist_def.size, check_playlist_path, pb);
 120         }
 121         osl_close_disk_object(&playlist_def);
 122         return 1;
 123 }
 124
 125 /**
 126  * Check the playlist table for inconsistencies.
 127  *
 128  * \param aca This callback ignores ->query.
 129  *
 130  * \return Standard. Invalid paths are reported, but are not considered an
 131  * error.
 132  */
 133 int playlist_check_callback(struct afs_callback_arg *aca)
 134 {
 135         para_printf(&aca->pbout, "checking playlists...\n");
 136         return osl(osl_rbtree_loop(playlists_table, BLOBCOL_ID, &aca->pbout,
 137                 check_playlist));
 138 }
 139
 140 /**
 141  * Close the current playlist.
 142  *
 143  * \sa \ref playlist_open().
 144  */
 145 void playlist_close(void)
 146 {
 147         if (!current_playlist.name)
 148                 return;
 149         free(current_playlist.name);
 150         current_playlist.name = NULL;
 151 }
 152
 153 /**
 154  * Open the given playlist.
 155  *
 156  * \param name The name of the playlist to open.
 157  *
 158  * Files which are listed in the playlist, but not contained in the database
 159  * are ignored.  This is not considered an error.
 160  *
 161  * \return Standard.
 162  */
 163 int playlist_open(const char *name)
 164 {
 165         struct osl_object obj;
 166         int ret;
 167         struct osl_row *row;
 168
 169         obj.data = (char *)name;
 170         obj.size = strlen(obj.data);
 171         ret = osl(osl_get_row(playlists_table, BLOBCOL_NAME, &obj, &row));
 172         if (ret < 0) {
 173                 PARA_NOTICE_LOG("failed to load playlist %s\n", name);
 174                 return ret;
 175         }
 176         playlist_close();
 177         ret = load_playlist(row, &current_playlist);
 178         return (ret == -E_PLAYLIST_LOADED)? current_playlist.length : ret;
 179 }
 180
 181 static int search_path(char *path, void *data)
 182 {
 183         if (strcmp(path, data))
 184                 return 1;
 185         return -E_PATH_FOUND;
 186 }
 187
 188 static int handle_audio_file_event(enum afs_events event, void *data)
 189 {
 190         int ret, was_admissible = 0, is_admissible;
 191         struct osl_object playlist_def;
 192         char *new_path;
 193         const struct osl_row *row = data;
 194
 195         if (event == AUDIO_FILE_RENAME) {
 196                 ret = row_belongs_to_score_table(row, NULL);
 197                 if (ret < 0)
 198                         return ret;
 199                 was_admissible = ret;
 200         }
 201         ret = get_audio_file_path_of_row(row, &new_path);
 202         if (ret < 0)
 203                 return ret;
 204         ret = pl_get_def_by_name(current_playlist.name, &playlist_def);
 205         if (ret < 0)
 206                 return ret;
 207         ret = for_each_line(FELF_READ_ONLY, playlist_def.data,
 208                 playlist_def.size, search_path, new_path);
 209         osl_close_disk_object(&playlist_def);
 210         is_admissible = (ret < 0);
 211         if (was_admissible && is_admissible)
 212                 return 1;
 213         if (!was_admissible && !is_admissible)
 214                 return 1;
 215         if (was_admissible && !is_admissible) {
 216                 current_playlist.length--;
 217                 return score_delete(row);
 218         }
 219         /* !was_admissible && is_admissible */
 220         current_playlist.length++;
 221         return score_add(row, 0); /* play it immediately */
 222 }
 223
 224 /**
 225  * Handle afs events relevant to playlists.
 226  *
 227  * \param event The event type.
 228  * \param pb Unused.
 229  * \param data Depends on the event type.
 230  *
 231  * \return Standard.
 232  */
 233 int playlists_event_handler(enum afs_events event,
 234         __a_unused struct para_buffer *pb, void *data)
 235 {
 236         int ret;
 237         struct afsi_change_event_data *aced = data;
 238
 239         if (!current_playlist.name)
 240                 return 1;
 241         switch (event) {
 242         case AFSI_CHANGE:
 243                 return playlist_update_audio_file(aced->aft_row);
 244         case AUDIO_FILE_RENAME:
 245         case AUDIO_FILE_ADD:
 246                 return handle_audio_file_event(event, data);
 247         case AUDIO_FILE_REMOVE:
 248                 ret = row_belongs_to_score_table(data, NULL);
 249                 if (ret < 0)
 250                         return ret;
 251                 if (!ret)
 252                         return 1;
 253                 current_playlist.length--;
 254                 return score_delete(data);
 255         default:
 256                 return 1;
 257         }
 258 }