src/dbUtils.c

   1 /*
   2  * Copyright (C) 2003-2010 The Music Player Daemon Project
   3  * http://www.musicpd.org
   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,
  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 along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19
  20 #include "config.h"
  21 #include "dbUtils.h"
  22 #include "locate.h"
  23 #include "directory.h"
  24 #include "database.h"
  25 #include "client.h"
  26 #include "playlist.h"
  27 #include "song.h"
  28 #include "song_print.h"
  29 #include "tag.h"
  30 #include "strset.h"
  31 #include "stored_playlist.h"
  32
  33 #include <glib.h>
  34
  35 #include <stdlib.h>
  36
  37 typedef struct _ListCommandItem {
  38         int8_t tagType;
  39         const struct locate_item_list *criteria;
  40 } ListCommandItem;
  41
  42 typedef struct _SearchStats {
  43         const struct locate_item_list *criteria;
  44         int numberOfSongs;
  45         unsigned long playTime;
  46 } SearchStats;
  47
  48 static int
  49 printDirectoryInDirectory(struct directory *directory, void *data)
  50 {
  51         struct client *client = data;
  52
  53         if (!directory_is_root(directory))
  54                 client_printf(client, "directory: %s\n", directory_get_path(directory));
  55
  56         return 0;
  57 }
  58
  59 static int
  60 printSongInDirectory(struct song *song, G_GNUC_UNUSED void *data)
  61 {
  62         struct client *client = data;
  63         song_print_uri(client, song);
  64         return 0;
  65 }
  66
  67 struct search_data {
  68         struct client *client;
  69         const struct locate_item_list *criteria;
  70 };
  71
  72 static int
  73 searchInDirectory(struct song *song, void *_data)
  74 {
  75         struct search_data *data = _data;
  76
  77         if (locate_song_search(song, data->criteria))
  78                 song_print_info(data->client, song);
  79
  80         return 0;
  81 }
  82
  83 int
  84 searchForSongsIn(struct client *client, const char *name,
  85                  const struct locate_item_list *criteria)
  86 {
  87         int ret;
  88         struct locate_item_list *new_list
  89                 = locate_item_list_casefold(criteria);
  90         struct search_data data;
  91
  92         data.client = client;
  93         data.criteria = new_list;
  94
  95         ret = db_walk(name, searchInDirectory, NULL, &data);
  96
  97         locate_item_list_free(new_list);
  98
  99         return ret;
 100 }
 101
 102 static int
 103 findInDirectory(struct song *song, void *_data)
 104 {
 105         struct search_data *data = _data;
 106
 107         if (locate_song_match(song, data->criteria))
 108                 song_print_info(data->client, song);
 109
 110         return 0;
 111 }
 112
 113 int
 114 findSongsIn(struct client *client, const char *name,
 115             const struct locate_item_list *criteria)
 116 {
 117         struct search_data data;
 118
 119         data.client = client;
 120         data.criteria = criteria;
 121
 122         return db_walk(name, findInDirectory, NULL, &data);
 123 }
 124
 125 static void printSearchStats(struct client *client, SearchStats *stats)
 126 {
 127         client_printf(client, "songs: %i\n", stats->numberOfSongs);
 128         client_printf(client, "playtime: %li\n", stats->playTime);
 129 }
 130
 131 static int
 132 searchStatsInDirectory(struct song *song, void *data)
 133 {
 134         SearchStats *stats = data;
 135
 136         if (locate_song_match(song, stats->criteria)) {
 137                 stats->numberOfSongs++;
 138                 stats->playTime += song_get_duration(song);
 139         }
 140
 141         return 0;
 142 }
 143
 144 int
 145 searchStatsForSongsIn(struct client *client, const char *name,
 146                       const struct locate_item_list *criteria)
 147 {
 148         SearchStats stats;
 149         int ret;
 150
 151         stats.criteria = criteria;
 152         stats.numberOfSongs = 0;
 153         stats.playTime = 0;
 154
 155         ret = db_walk(name, searchStatsInDirectory, NULL, &stats);
 156         if (ret == 0)
 157                 printSearchStats(client, &stats);
 158
 159         return ret;
 160 }
 161
 162 int printAllIn(struct client *client, const char *name)
 163 {
 164         return db_walk(name, printSongInDirectory,
 165                        printDirectoryInDirectory, client);
 166 }
 167
 168 static int
 169 directoryAddSongToPlaylist(struct song *song, G_GNUC_UNUSED void *data)
 170 {
 171         return playlist_append_song(&g_playlist, song, NULL);
 172 }
 173
 174 struct add_data {
 175         const char *path;
 176 };
 177
 178 static int
 179 directoryAddSongToStoredPlaylist(struct song *song, void *_data)
 180 {
 181         struct add_data *data = _data;
 182
 183         if (spl_append_song(data->path, song) != 0)
 184                 return -1;
 185         return 0;
 186 }
 187
 188 int addAllIn(const char *name)
 189 {
 190         return db_walk(name, directoryAddSongToPlaylist, NULL, NULL);
 191 }
 192
 193 int addAllInToStoredPlaylist(const char *name, const char *utf8file)
 194 {
 195         struct add_data data = {
 196                 .path = utf8file,
 197         };
 198
 199         return db_walk(name, directoryAddSongToStoredPlaylist, NULL, &data);
 200 }
 201
 202 static int
 203 findAddInDirectory(struct song *song, void *_data)
 204 {
 205         struct search_data *data = _data;
 206
 207         if (locate_song_match(song, data->criteria))
 208                 return directoryAddSongToPlaylist(song, data);
 209
 210         return 0;
 211 }
 212
 213 int findAddIn(struct client *client, const char *name,
 214               const struct locate_item_list *criteria)
 215 {
 216         struct search_data data;
 217
 218         data.client   = client;
 219         data.criteria = criteria;
 220
 221         return db_walk(name, findAddInDirectory, NULL, &data);
 222 }
 223
 224 static int
 225 directoryPrintSongInfo(struct song *song, void *data)
 226 {
 227         struct client *client = data;
 228         song_print_info(client, song);
 229         return 0;
 230 }
 231
 232 int printInfoForAllIn(struct client *client, const char *name)
 233 {
 234         return db_walk(name, directoryPrintSongInfo,
 235                              printDirectoryInDirectory, client);
 236 }
 237
 238 static ListCommandItem *
 239 newListCommandItem(int tagType, const struct locate_item_list *criteria)
 240 {
 241         ListCommandItem *item = g_new(ListCommandItem, 1);
 242
 243         item->tagType = tagType;
 244         item->criteria = criteria;
 245
 246         return item;
 247 }
 248
 249 static void freeListCommandItem(ListCommandItem * item)
 250 {
 251         g_free(item);
 252 }
 253
 254 static void
 255 visitTag(struct client *client, struct strset *set,
 256          struct song *song, enum tag_type tagType)
 257 {
 258         struct tag *tag = song->tag;
 259         bool found = false;
 260
 261         if (tagType == LOCATE_TAG_FILE_TYPE) {
 262                 song_print_uri(client, song);
 263                 return;
 264         }
 265
 266         if (!tag)
 267                 return;
 268
 269         for (unsigned i = 0; i < tag->num_items; i++) {
 270                 if (tag->items[i]->type == tagType) {
 271                         strset_add(set, tag->items[i]->value);
 272                         found = true;
 273                 }
 274         }
 275
 276         if (!found)
 277                 strset_add(set, "");
 278 }
 279
 280 struct list_tags_data {
 281         struct client *client;
 282         ListCommandItem *item;
 283         struct strset *set;
 284 };
 285
 286 static int
 287 listUniqueTagsInDirectory(struct song *song, void *_data)
 288 {
 289         struct list_tags_data *data = _data;
 290         ListCommandItem *item = data->item;
 291
 292         if (locate_song_match(song, item->criteria))
 293                 visitTag(data->client, data->set, song, item->tagType);
 294
 295         return 0;
 296 }
 297
 298 int listAllUniqueTags(struct client *client, int type,
 299                       const struct locate_item_list *criteria)
 300 {
 301         int ret;
 302         ListCommandItem *item = newListCommandItem(type, criteria);
 303         struct list_tags_data data = {
 304                 .client = client,
 305                 .item = item,
 306         };
 307
 308         if (type >= 0 && type <= TAG_NUM_OF_ITEM_TYPES) {
 309                 data.set = strset_new();
 310         }
 311
 312         ret = db_walk(NULL, listUniqueTagsInDirectory, NULL, &data);
 313
 314         if (type >= 0 && type <= TAG_NUM_OF_ITEM_TYPES) {
 315                 const char *value;
 316
 317                 strset_rewind(data.set);
 318
 319                 while ((value = strset_next(data.set)) != NULL)
 320                         client_printf(client, "%s: %s\n",
 321                                       tag_item_names[type],
 322                                       value);
 323
 324                 strset_free(data.set);
 325         }
 326
 327         freeListCommandItem(item);
 328
 329         return ret;
 330 }