lib.c

   1 /*
   2  * Copyright 2004-2006 Timo Hirvonen
   3  */
   4
   5 #include "lib.h"
   6 #include "editable.h"
   7 #include "options.h"
   8 #include "xmalloc.h"
   9 #include "debug.h"
  10
  11 #include <pthread.h>
  12 #include <string.h>
  13
  14 struct editable lib_editable;
  15 LIST_HEAD(lib_shuffle_head);
  16 struct tree_track *lib_cur_track = NULL;
  17 unsigned int play_sorted = 0;
  18 enum aaa_mode aaa_mode = AAA_MODE_ALL;
  19
  20 static struct expr *filter = NULL;
  21 static int remove_from_hash = 1;
  22
  23 static inline struct tree_track *to_sorted(const struct list_head *item)
  24 {
  25         return (struct tree_track *)container_of(item, struct simple_track, node);
  26 }
  27
  28 static inline void sorted_track_to_iter(struct tree_track *track, struct iter *iter)
  29 {
  30         iter->data0 = &lib_editable.head;
  31         iter->data1 = track;
  32         iter->data2 = NULL;
  33 }
  34
  35 static void all_wins_changed(void)
  36 {
  37         lib_tree_win->changed = 1;
  38         lib_track_win->changed = 1;
  39         lib_editable.win->changed = 1;
  40 }
  41
  42 static void shuffle_add(struct tree_track *track)
  43 {
  44         shuffle_list_add_track(&lib_shuffle_head, &track->shuffle_track.node, lib_editable.nr_tracks);
  45 }
  46
  47 static void views_add_track(struct track_info *ti)
  48 {
  49         struct tree_track *track = xnew(struct tree_track, 1);
  50
  51         /* NOTE: does not ref ti */
  52         simple_track_init((struct simple_track *)track, ti);
  53
  54         /* both the hash table and views have refs */
  55         track_info_ref(ti);
  56
  57         tree_add_track(track);
  58         shuffle_add(track);
  59         editable_add(&lib_editable, (struct simple_track *)track);
  60 }
  61
  62 struct fh_entry {
  63         struct fh_entry *next;
  64
  65         /* ref count is increased when added to this hash */
  66         struct track_info *ti;
  67 };
  68
  69 #define FH_SIZE (1024)
  70 static struct fh_entry *ti_hash[FH_SIZE] = { NULL, };
  71
  72 /* this is from glib */
  73 static unsigned int str_hash(const char *str)
  74 {
  75         unsigned int hash = 0;
  76         int i;
  77
  78         for (i = 0; str[i]; i++)
  79                 hash = (hash << 5) - hash + str[i];
  80         return hash;
  81 }
  82
  83 static int hash_insert(struct track_info *ti)
  84 {
  85         const char *filename = ti->filename;
  86         unsigned int pos = str_hash(filename) % FH_SIZE;
  87         struct fh_entry **entryp;
  88         struct fh_entry *e;
  89
  90         entryp = &ti_hash[pos];
  91         e = *entryp;
  92         while (e) {
  93                 if (strcmp(e->ti->filename, filename) == 0) {
  94                         /* found, don't insert */
  95                         return 0;
  96                 }
  97                 e = e->next;
  98         }
  99
 100         e = xnew(struct fh_entry, 1);
 101         track_info_ref(ti);
 102         e->ti = ti;
 103         e->next = *entryp;
 104         *entryp = e;
 105         return 1;
 106 }
 107
 108 static void hash_remove(struct track_info *ti)
 109 {
 110         const char *filename = ti->filename;
 111         unsigned int pos = str_hash(filename) % FH_SIZE;
 112         struct fh_entry **entryp;
 113
 114         entryp = &ti_hash[pos];
 115         while (1) {
 116                 struct fh_entry *e = *entryp;
 117
 118                 BUG_ON(e == NULL);
 119                 if (strcmp(e->ti->filename, filename) == 0) {
 120                         *entryp = e->next;
 121                         track_info_unref(e->ti);
 122                         free(e);
 123                         break;
 124                 }
 125                 entryp = &e->next;
 126         }
 127 }
 128
 129 void lib_add_track(struct track_info *ti)
 130 {
 131         if (!hash_insert(ti)) {
 132                 /* duplicate files not allowed */
 133                 return;
 134         }
 135         if (filter == NULL || expr_eval(filter, ti))
 136                 views_add_track(ti);
 137 }
 138
 139 static struct tree_track *album_first_track(const struct album *album)
 140 {
 141         return to_tree_track(album->track_head.next);
 142 }
 143
 144 static struct tree_track *artist_first_track(const struct artist *artist)
 145 {
 146         return album_first_track(to_album(artist->album_head.next));
 147 }
 148
 149 static struct tree_track *normal_get_first(void)
 150 {
 151         return artist_first_track(to_artist(lib_artist_head.next));
 152 }
 153
 154 static struct tree_track *album_last_track(const struct album *album)
 155 {
 156         return to_tree_track(album->track_head.prev);
 157 }
 158
 159 static struct tree_track *artist_last_track(const struct artist *artist)
 160 {
 161         return album_last_track(to_album(artist->album_head.prev));
 162 }
 163
 164 static int aaa_mode_filter(const struct simple_track *track)
 165 {
 166         const struct album *album = ((struct tree_track *)track)->album;
 167
 168         if (aaa_mode == AAA_MODE_ALBUM)
 169                 return CUR_ALBUM == album;
 170
 171         if (aaa_mode == AAA_MODE_ARTIST)
 172                 return CUR_ARTIST == album->artist;
 173
 174         /* AAA_MODE_ALL */
 175         return 1;
 176 }
 177
 178 /* set next/prev (tree) {{{ */
 179
 180 static struct tree_track *normal_get_next(void)
 181 {
 182         if (lib_cur_track == NULL)
 183                 return normal_get_first();
 184
 185         /* not last track of the album? */
 186         if (lib_cur_track->node.next != &CUR_ALBUM->track_head) {
 187                 /* next track of the current album */
 188                 return to_tree_track(lib_cur_track->node.next);
 189         }
 190
 191         if (aaa_mode == AAA_MODE_ALBUM) {
 192                 if (!repeat)
 193                         return NULL;
 194                 /* first track of the current album */
 195                 return album_first_track(CUR_ALBUM);
 196         }
 197
 198         /* not last album of the artist? */
 199         if (CUR_ALBUM->node.next != &CUR_ARTIST->album_head) {
 200                 /* first track of the next album */
 201                 return album_first_track(to_album(CUR_ALBUM->node.next));
 202         }
 203
 204         if (aaa_mode == AAA_MODE_ARTIST) {
 205                 if (!repeat)
 206                         return NULL;
 207                 /* first track of the first album of the current artist */
 208                 return artist_first_track(CUR_ARTIST);
 209         }
 210
 211         /* not last artist of the library? */
 212         if (CUR_ARTIST->node.next != &lib_artist_head) {
 213                 /* first track of the next artist */
 214                 return artist_first_track(to_artist(CUR_ARTIST->node.next));
 215         }
 216
 217         if (!repeat)
 218                 return NULL;
 219
 220         /* first track */
 221         return normal_get_first();
 222 }
 223
 224 static struct tree_track *normal_get_prev(void)
 225 {
 226         if (lib_cur_track == NULL)
 227                 return normal_get_first();
 228
 229         /* not first track of the album? */
 230         if (lib_cur_track->node.prev != &CUR_ALBUM->track_head) {
 231                 /* prev track of the album */
 232                 return to_tree_track(lib_cur_track->node.prev);
 233         }
 234
 235         if (aaa_mode == AAA_MODE_ALBUM) {
 236                 if (!repeat)
 237                         return NULL;
 238                 /* last track of the album */
 239                 return to_tree_track(CUR_ALBUM->track_head.prev);
 240         }
 241
 242         /* not first album of the artist? */
 243         if (CUR_ALBUM->node.prev != &CUR_ARTIST->album_head) {
 244                 /* last track of the prev album of the artist */
 245                 return album_last_track(to_album(CUR_ALBUM->node.prev));
 246         }
 247
 248         if (aaa_mode == AAA_MODE_ARTIST) {
 249                 if (!repeat)
 250                         return NULL;
 251                 /* last track of the last album of the artist */
 252                 return album_last_track(to_album(CUR_ARTIST->album_head.prev));
 253         }
 254
 255         /* not first artist of the library? */
 256         if (CUR_ARTIST->node.prev != &lib_artist_head) {
 257                 /* last track of the last album of the prev artist */
 258                 return artist_last_track(to_artist(CUR_ARTIST->node.prev));
 259         }
 260
 261         if (!repeat)
 262                 return NULL;
 263
 264         /* last track */
 265         return artist_last_track(to_artist(lib_artist_head.prev));
 266 }
 267
 268 /* set next/prev (tree) }}} */
 269
 270 void lib_reshuffle(void)
 271 {
 272         reshuffle(&lib_shuffle_head);
 273 }
 274
 275 static void free_lib_track(struct list_head *item)
 276 {
 277         struct tree_track *track = (struct tree_track *)to_simple_track(item);
 278         struct track_info *ti = tree_track_info(track);
 279
 280         if (track == lib_cur_track)
 281                 lib_cur_track = NULL;
 282
 283         if (remove_from_hash)
 284                 hash_remove(ti);
 285
 286         list_del(&track->shuffle_track.node);
 287         tree_remove(track);
 288
 289         track_info_unref(ti);
 290         free(track);
 291 }
 292
 293 void lib_init(void)
 294 {
 295         editable_init(&lib_editable, free_lib_track);
 296         tree_init();
 297         srand(time(NULL));
 298 }
 299
 300 struct track_info *lib_set_next(void)
 301 {
 302         struct tree_track *track;
 303         struct track_info *ti = NULL;
 304
 305         if (list_empty(&lib_artist_head)) {
 306                 BUG_ON(lib_cur_track != NULL);
 307                 return NULL;
 308         }
 309         if (shuffle) {
 310                 track = (struct tree_track *)shuffle_list_get_next(&lib_shuffle_head,
 311                                 (struct shuffle_track *)lib_cur_track, aaa_mode_filter);
 312         } else if (play_sorted) {
 313                 track = (struct tree_track *)simple_list_get_next(&lib_editable.head,
 314                                 (struct simple_track *)lib_cur_track, aaa_mode_filter);
 315         } else {
 316                 track = normal_get_next();
 317         }
 318         if (track) {
 319                 lib_cur_track = track;
 320                 ti = tree_track_info(track);
 321
 322                 track_info_ref(ti);
 323                 all_wins_changed();
 324         }
 325         return ti;
 326 }
 327
 328 struct track_info *lib_set_prev(void)
 329 {
 330         struct tree_track *track;
 331         struct track_info *ti = NULL;
 332
 333         if (list_empty(&lib_artist_head)) {
 334                 BUG_ON(lib_cur_track != NULL);
 335                 return NULL;
 336         }
 337         if (shuffle) {
 338                 track = (struct tree_track *)shuffle_list_get_prev(&lib_shuffle_head,
 339                                 (struct shuffle_track *)lib_cur_track, aaa_mode_filter);
 340         } else if (play_sorted) {
 341                 track = (struct tree_track *)simple_list_get_prev(&lib_editable.head,
 342                                 (struct simple_track *)lib_cur_track, aaa_mode_filter);
 343         } else {
 344                 track = normal_get_prev();
 345         }
 346         if (track) {
 347                 lib_cur_track = track;
 348                 ti = tree_track_info(track);
 349
 350                 track_info_ref(ti);
 351                 all_wins_changed();
 352         }
 353         return ti;
 354 }
 355
 356 struct track_info *sorted_set_selected(void)
 357 {
 358         struct track_info *info;
 359         struct iter sel;
 360
 361         if (list_empty(&lib_editable.head))
 362                 return NULL;
 363
 364         window_get_sel(lib_editable.win, &sel);
 365         lib_cur_track = iter_to_sorted_track(&sel);
 366         info = tree_track_info(lib_cur_track);
 367         track_info_ref(info);
 368         all_wins_changed();
 369         return info;
 370 }
 371
 372 void lib_set_filter(struct expr *expr)
 373 {
 374         static const char *tmp_keys[1] = { NULL };
 375         struct track_info *cur_ti = NULL;
 376         const char **sort_keys;
 377         int i;
 378
 379         /* try to save cur_track */
 380         if (lib_cur_track) {
 381                 cur_ti = tree_track_info(lib_cur_track);
 382                 track_info_ref(cur_ti);
 383         }
 384
 385         remove_from_hash = 0;
 386         editable_clear(&lib_editable);
 387         remove_from_hash = 1;
 388
 389         if (filter)
 390                 expr_free(filter);
 391         filter = expr;
 392
 393         /* disable sorting temporarily */
 394         sort_keys = lib_editable.sort_keys;
 395         lib_editable.sort_keys = tmp_keys;
 396
 397         for (i = 0; i < FH_SIZE; i++) {
 398                 struct fh_entry *e;
 399
 400                 e = ti_hash[i];
 401                 while (e) {
 402                         struct track_info *ti = e->ti;
 403
 404                         if (filter == NULL || expr_eval(filter, ti))
 405                                 views_add_track(ti);
 406                         e = e->next;
 407                 }
 408         }
 409
 410         /* enable sorting */
 411         lib_editable.sort_keys = sort_keys;
 412         editable_sort(&lib_editable);
 413
 414         lib_cur_win = lib_tree_win;
 415         window_goto_top(lib_tree_win);
 416
 417         /* restore cur_track */
 418         if (cur_ti) {
 419                 struct simple_track *track;
 420
 421                 list_for_each_entry(track, &lib_editable.head, node) {
 422                         if (strcmp(track->info->filename, cur_ti->filename) == 0) {
 423                                 struct tree_track *tt = (struct tree_track *)track;
 424
 425                                 lib_cur_track = tt;
 426                                 break;
 427                         }
 428                 }
 429                 track_info_unref(cur_ti);
 430         }
 431 }
 432
 433 void lib_remove(struct track_info *ti)
 434 {
 435         struct simple_track *track;
 436
 437         list_for_each_entry(track, &lib_editable.head, node) {
 438                 if (track->info == ti) {
 439                         editable_remove_track(&lib_editable, track);
 440                         break;
 441                 }
 442         }
 443 }
 444
 445 void lib_clear_store(void)
 446 {
 447         int i;
 448
 449         for (i = 0; i < FH_SIZE; i++) {
 450                 struct fh_entry *e, *next;
 451
 452                 e = ti_hash[i];
 453                 while (e) {
 454                         next = e->next;
 455                         track_info_unref(e->ti);
 456                         free(e);
 457                         e = next;
 458                 }
 459                 ti_hash[i] = NULL;
 460         }
 461 }
 462
 463 void sorted_sel_current(void)
 464 {
 465         if (lib_cur_track) {
 466                 struct iter iter;
 467
 468                 sorted_track_to_iter(lib_cur_track, &iter);
 469                 window_set_sel(lib_editable.win, &iter);
 470         }
 471 }
 472
 473 static int ti_filename_cmp(const void *a, const void *b)
 474 {
 475         const struct track_info *tia = *(const struct track_info **)a;
 476         const struct track_info *tib = *(const struct track_info **)b;
 477
 478         return strcmp(tia->filename, tib->filename);
 479 }
 480
 481 int lib_for_each(int (*cb)(void *data, struct track_info *ti), void *data)
 482 {
 483         int i, rc = 0, count = 0, size = 1024;
 484         struct track_info **tis;
 485
 486         tis = xnew(struct track_info *, size);
 487
 488         /* collect all track_infos */
 489         for (i = 0; i < FH_SIZE; i++) {
 490                 struct fh_entry *e;
 491
 492                 e = ti_hash[i];
 493                 while (e) {
 494                         if (count == size) {
 495                                 size *= 2;
 496                                 tis = xrenew(struct track_info *, tis, size);
 497                         }
 498                         tis[count++] = e->ti;
 499                         e = e->next;
 500                 }
 501         }
 502
 503         /* sort them by filename and call cb for each */
 504         qsort(tis, count, sizeof(struct track_info *), ti_filename_cmp);
 505         for (i = 0; i < count; i++) {
 506                 rc = cb(data, tis[i]);
 507                 if (rc)
 508                         break;
 509         }
 510
 511         free(tis);
 512         return rc;
 513 }