apps/playlist.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by wavey@wavey.org
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 /*
  23     Dynamic playlist design (based on design originally proposed by ricII)
  24
  25     There are two files associated with a dynamic playlist:
  26     1. Playlist file : This file contains the initial songs in the playlist.
  27                        The file is created by the user and stored on the hard
  28                        drive.  NOTE: If we are playing the contents of a
  29                        directory, there will be no playlist file.
  30     2. Control file :  This file is automatically created when a playlist is
  31                        started and contains all the commands done to it.
  32
  33     The first non-comment line in a control file must begin with
  34     "P:VERSION:DIR:FILE" where VERSION is the playlist control file version,
  35     DIR is the directory where the playlist is located and FILE is the
  36     playlist filename.  For dirplay, FILE will be empty.  An empty playlist
  37     will have both entries as null.
  38
  39     Control file commands:
  40         a. Add track (A:<position>:<last position>:<path to track>)
  41             - Insert a track at the specified position in the current
  42               playlist.  Last position is used to specify where last insertion
  43               occurred.
  44         b. Queue track (Q:<position>:<last position>:<path to track>)
  45             - Queue a track at the specified position in the current
  46               playlist.  Queued tracks differ from added tracks in that they
  47               are deleted from the playlist as soon as they are played and
  48               they are not saved to disk as part of the playlist.
  49         c. Delete track (D:<position>)
  50             - Delete track from specified position in the current playlist.
  51         d. Shuffle playlist (S:<seed>:<index>)
  52             - Shuffle entire playlist with specified seed.  The index
  53               identifies the first index in the newly shuffled playlist
  54               (needed for repeat mode).
  55         e. Unshuffle playlist (U:<index>)
  56             - Unshuffle entire playlist.  The index identifies the first index
  57               in the newly unshuffled playlist.
  58         f. Reset last insert position (R)
  59             - Needed so that insertions work properly after resume
  60
  61   Resume:
  62       The only resume info that needs to be saved is the current index in the
  63       playlist and the position in the track.  When resuming, all the commands
  64       in the control file will be reapplied so that the playlist indices are
  65       exactly the same as before shutdown.  To avoid unnecessary disk
  66       accesses, the shuffle mode settings are also saved in settings and only
  67       flushed to disk when required.
  68  */
  69
  70 #include <stdio.h>
  71 #include <stdlib.h>
  72 #include <ctype.h>
  73 #include "string-extra.h"
  74 #include "playlist.h"
  75 #include "ata_idle_notify.h"
  76 #include "file.h"
  77 #include "action.h"
  78 #include "dir.h"
  79 #include "debug.h"
  80 #include "audio.h"
  81 #include "lcd.h"
  82 #include "kernel.h"
  83 #include "settings.h"
  84 #include "status.h"
  85 #include "applimits.h"
  86 #include "screens.h"
  87 #include "core_alloc.h"
  88 #include "misc.h"
  89 #include "filefuncs.h"
  90 #include "button.h"
  91 #include "filetree.h"
  92 #include "abrepeat.h"
  93 #include "thread.h"
  94 #include "usb.h"
  95 #include "filetypes.h"
  96 #ifdef HAVE_LCD_BITMAP
  97 #include "icons.h"
  98 #endif
  99 #include "system.h"
 100
 101 #include "lang.h"
 102 #include "talk.h"
 103 #include "splash.h"
 104 #include "rbunicode.h"
 105 #include "root_menu.h"
 106 #include "plugin.h" /* To borrow a temp buffer to rewrite a .m3u8 file */
 107
 108 #define PLAYLIST_CONTROL_FILE_VERSION 2
 109
 110 /*
 111     Each playlist index has a flag associated with it which identifies what
 112     type of track it is.  These flags are stored in the 4 high order bits of
 113     the index.
 114
 115     NOTE: This limits the playlist file size to a max of 256M.
 116
 117     Bits 31-30:
 118         00 = Playlist track
 119         01 = Track was prepended into playlist
 120         10 = Track was inserted into playlist
 121         11 = Track was appended into playlist
 122     Bit 29:
 123         0 = Added track
 124         1 = Queued track
 125     Bit 28:
 126         0 = Track entry is valid
 127         1 = Track does not exist on disk and should be skipped
 128  */
 129 #define PLAYLIST_SEEK_MASK              0x0FFFFFFF
 130 #define PLAYLIST_INSERT_TYPE_MASK       0xC0000000
 131 #define PLAYLIST_QUEUE_MASK             0x20000000
 132
 133 #define PLAYLIST_INSERT_TYPE_PREPEND    0x40000000
 134 #define PLAYLIST_INSERT_TYPE_INSERT     0x80000000
 135 #define PLAYLIST_INSERT_TYPE_APPEND     0xC0000000
 136
 137 #define PLAYLIST_QUEUED                 0x20000000
 138 #define PLAYLIST_SKIPPED                0x10000000
 139
 140 struct directory_search_context {
 141     struct playlist_info* playlist;
 142     int position;
 143     bool queue;
 144     int count;
 145 };
 146
 147 static struct playlist_info current_playlist;
 148
 149 static void empty_playlist(struct playlist_info* playlist, bool resume);
 150 static void new_playlist(struct playlist_info* playlist, const char *dir,
 151                          const char *file);
 152 static void create_control(struct playlist_info* playlist);
 153 static int  check_control(struct playlist_info* playlist);
 154 static int  recreate_control(struct playlist_info* playlist);
 155 static void update_playlist_filename(struct playlist_info* playlist,
 156                                      const char *dir, const char *file);
 157 static int add_indices_to_playlist(struct playlist_info* playlist,
 158                                    char* buffer, size_t buflen);
 159 static int add_track_to_playlist(struct playlist_info* playlist,
 160                                  const char *filename, int position,
 161                                  bool queue, int seek_pos);
 162 static int directory_search_callback(char* filename, void* context);
 163 static int remove_track_from_playlist(struct playlist_info* playlist,
 164                                       int position, bool write);
 165 static int randomise_playlist(struct playlist_info* playlist,
 166                               unsigned int seed, bool start_current,
 167                               bool write);
 168 static int sort_playlist(struct playlist_info* playlist, bool start_current,
 169                          bool write);
 170 static int get_next_index(const struct playlist_info* playlist, int steps,
 171                           int repeat_mode);
 172 static void find_and_set_playlist_index(struct playlist_info* playlist,
 173                                         unsigned int seek);
 174 static int compare(const void* p1, const void* p2);
 175 static int get_filename(struct playlist_info* playlist, int index, int seek,
 176                         bool control_file, char *buf, int buf_length);
 177 static int get_next_directory(char *dir);
 178 static int get_next_dir(char *dir, bool is_forward);
 179 static int get_previous_directory(char *dir);
 180 static int check_subdir_for_music(char *dir, const char *subdir, bool recurse);
 181 static int format_track_path(char *dest, char *src, int buf_length, int max,
 182                              const char *dir);
 183 static void display_playlist_count(int count, const unsigned char *fmt,
 184                                    bool final);
 185 static void display_buffer_full(void);
 186 static int flush_cached_control(struct playlist_info* playlist);
 187 static int update_control(struct playlist_info* playlist,
 188                           enum playlist_command command, int i1, int i2,
 189                           const char* s1, const char* s2, void* data);
 190 static void sync_control(struct playlist_info* playlist, bool force);
 191 static int rotate_index(const struct playlist_info* playlist, int index);
 192
 193 #ifdef HAVE_DIRCACHE
 194 #define PLAYLIST_LOAD_POINTERS 1
 195
 196 static struct event_queue playlist_queue SHAREDBSS_ATTR;
 197 static long playlist_stack[(DEFAULT_STACK_SIZE + 0x800)/sizeof(long)];
 198 static const char playlist_thread_name[] = "playlist cachectrl";
 199 #endif
 200
 201 static struct mutex current_playlist_mutex SHAREDBSS_ATTR;
 202 static struct mutex created_playlist_mutex SHAREDBSS_ATTR;
 203
 204 /* Check if the filename suggests M3U or M3U8 format. */
 205 static bool is_m3u8(const char* filename)
 206 {
 207     int len = strlen(filename);
 208
 209     /* Default to M3U8 unless explicitly told otherwise. */
 210     return !(len > 4 && strcasecmp(&filename[len - 4], ".m3u") == 0);
 211 }
 212
 213
 214 /* Convert a filename in an M3U playlist to UTF-8.
 215  *
 216  * buf     - the filename to convert; can contain more than one line from the
 217  *           playlist.
 218  * buf_len - amount of buf that is used.
 219  * buf_max - total size of buf.
 220  * temp    - temporary conversion buffer, at least buf_max bytes.
 221  *
 222  * Returns the length of the converted filename.
 223  */
 224 static int convert_m3u(char* buf, int buf_len, int buf_max, char* temp)
 225 {
 226     int i = 0;
 227     char* dest;
 228
 229     /* Locate EOL. */
 230     while ((buf[i] != '\n') && (buf[i] != '\r') && (i < buf_len))
 231     {
 232         i++;
 233     }
 234
 235     /* Work back killing white space. */
 236     while ((i > 0) && isspace(buf[i - 1]))
 237     {
 238         i--;
 239     }
 240
 241     buf_len = i;
 242     dest = temp;
 243
 244     /* Convert char by char, so as to not overflow temp (iso_decode should
 245      * preferably handle this). No more than 4 bytes should be generated for
 246      * each input char.
 247      */
 248     for (i = 0; i < buf_len && dest < (temp + buf_max - 4); i++)
 249     {
 250         dest = iso_decode(&buf[i], dest, -1, 1);
 251     }
 252
 253     *dest = 0;
 254     strcpy(buf, temp);
 255     return dest - temp;
 256 }
 257
 258 /*
 259  * remove any files and indices associated with the playlist
 260  */
 261 static void empty_playlist(struct playlist_info* playlist, bool resume)
 262 {
 263     playlist->filename[0] = '\0';
 264     playlist->utf8 = true;
 265
 266     if(playlist->fd >= 0)
 267         /* If there is an already open playlist, close it. */
 268         close(playlist->fd);
 269     playlist->fd = -1;
 270
 271     if(playlist->control_fd >= 0)
 272         close(playlist->control_fd);
 273     playlist->control_fd = -1;
 274     playlist->control_created = false;
 275
 276     playlist->in_ram = false;
 277
 278     if (playlist->buffer)
 279         playlist->buffer[0] = 0;
 280
 281     playlist->buffer_end_pos = 0;
 282
 283     playlist->index = 0;
 284     playlist->first_index = 0;
 285     playlist->amount = 0;
 286     playlist->last_insert_pos = -1;
 287     playlist->seed = 0;
 288     playlist->shuffle_modified = false;
 289     playlist->deleted = false;
 290     playlist->num_inserted_tracks = 0;
 291     playlist->started = false;
 292
 293     playlist->num_cached = 0;
 294     playlist->pending_control_sync = false;
 295
 296     if (!resume && playlist->current)
 297     {
 298         /* start with fresh playlist control file when starting new
 299            playlist */
 300         create_control(playlist);
 301     }
 302 }
 303
 304 /*
 305  * Initialize a new playlist for viewing/editing/playing.  dir is the
 306  * directory where the playlist is located and file is the filename.
 307  */
 308 static void new_playlist(struct playlist_info* playlist, const char *dir,
 309                          const char *file)
 310 {
 311     const char *fileused = file;
 312     const char *dirused = dir;
 313     empty_playlist(playlist, false);
 314
 315     if (!fileused)
 316     {
 317         fileused = "";
 318
 319         if (dirused && playlist->current) /* !current cannot be in_ram */
 320             playlist->in_ram = true;
 321         else
 322             dirused = ""; /* empty playlist */
 323     }
 324
 325     update_playlist_filename(playlist, dirused, fileused);
 326
 327     if (playlist->control_fd >= 0)
 328     {
 329         update_control(playlist, PLAYLIST_COMMAND_PLAYLIST,
 330             PLAYLIST_CONTROL_FILE_VERSION, -1, dirused, fileused, NULL);
 331         sync_control(playlist, false);
 332     }
 333 }
 334
 335 /*
 336  * create control file for playlist
 337  */
 338 static void create_control(struct playlist_info* playlist)
 339 {
 340     playlist->control_fd = open(playlist->control_filename,
 341                                 O_CREAT|O_RDWR|O_TRUNC, 0666);
 342     if (playlist->control_fd < 0)
 343     {
 344         if (check_rockboxdir())
 345         {
 346             cond_talk_ids_fq(LANG_PLAYLIST_CONTROL_ACCESS_ERROR);
 347             splashf(HZ*2, (unsigned char *)"%s (%d)",
 348                            str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR),
 349                            playlist->control_fd);
 350         }
 351         playlist->control_created = false;
 352     }
 353     else
 354     {
 355         playlist->control_created = true;
 356     }
 357 }
 358
 359 /*
 360  * validate the control file.  This may include creating/initializing it if
 361  * necessary;
 362  */
 363 static int check_control(struct playlist_info* playlist)
 364 {
 365     if (!playlist->control_created)
 366     {
 367         create_control(playlist);
 368
 369         if (playlist->control_fd >= 0)
 370         {
 371             char* dir = playlist->filename;
 372             char* file = playlist->filename+playlist->dirlen;
 373             char c = playlist->filename[playlist->dirlen-1];
 374
 375             playlist->filename[playlist->dirlen-1] = '\0';
 376
 377             update_control(playlist, PLAYLIST_COMMAND_PLAYLIST,
 378                 PLAYLIST_CONTROL_FILE_VERSION, -1, dir, file, NULL);
 379             sync_control(playlist, false);
 380             playlist->filename[playlist->dirlen-1] = c;
 381         }
 382     }
 383
 384     if (playlist->control_fd < 0)
 385         return -1;
 386
 387     return 0;
 388 }
 389
 390 /*
 391  * recreate the control file based on current playlist entries
 392  */
 393 static int recreate_control(struct playlist_info* playlist)
 394 {
 395     char temp_file[MAX_PATH+1];
 396     int  temp_fd = -1;
 397     int  i;
 398     int  result = 0;
 399
 400     if(playlist->control_fd >= 0)
 401     {
 402         char* dir = playlist->filename;
 403         char* file = playlist->filename+playlist->dirlen;
 404         char c = playlist->filename[playlist->dirlen-1];
 405
 406         close(playlist->control_fd);
 407
 408         snprintf(temp_file, sizeof(temp_file), "%s_temp",
 409             playlist->control_filename);
 410
 411         if (rename(playlist->control_filename, temp_file) < 0)
 412             return -1;
 413
 414         temp_fd = open(temp_file, O_RDONLY);
 415         if (temp_fd < 0)
 416             return -1;
 417
 418         playlist->control_fd = open(playlist->control_filename,
 419             O_CREAT|O_RDWR|O_TRUNC, 0666);
 420         if (playlist->control_fd < 0)
 421         {
 422             close(temp_fd);
 423             return -1;
 424         }
 425
 426         playlist->filename[playlist->dirlen-1] = '\0';
 427
 428         /* cannot call update_control() because of mutex */
 429         result = fdprintf(playlist->control_fd, "P:%d:%s:%s\n",
 430             PLAYLIST_CONTROL_FILE_VERSION, dir, file);
 431
 432         playlist->filename[playlist->dirlen-1] = c;
 433
 434         if (result < 0)
 435         {
 436             close(temp_fd);
 437             return result;
 438         }
 439     }
 440
 441     playlist->seed = 0;
 442     playlist->shuffle_modified = false;
 443     playlist->deleted = false;
 444     playlist->num_inserted_tracks = 0;
 445
 446     for (i=0; i<playlist->amount; i++)
 447     {
 448         if (playlist->indices[i] & PLAYLIST_INSERT_TYPE_MASK)
 449         {
 450             bool queue = playlist->indices[i] & PLAYLIST_QUEUE_MASK;
 451             char inserted_file[MAX_PATH+1];
 452
 453             lseek(temp_fd, playlist->indices[i] & PLAYLIST_SEEK_MASK,
 454                 SEEK_SET);
 455             read_line(temp_fd, inserted_file, sizeof(inserted_file));
 456
 457             result = fdprintf(playlist->control_fd, "%c:%d:%d:",
 458                 queue?'Q':'A', i, playlist->last_insert_pos);
 459             if (result > 0)
 460             {
 461                 /* save the position in file where name is written */
 462                 int seek_pos = lseek(playlist->control_fd, 0, SEEK_CUR);
 463
 464                 result = fdprintf(playlist->control_fd, "%s\n",
 465                     inserted_file);
 466
 467                 playlist->indices[i] =
 468                     (playlist->indices[i] & ~PLAYLIST_SEEK_MASK) | seek_pos;
 469             }
 470
 471             if (result < 0)
 472                 break;
 473
 474             playlist->num_inserted_tracks++;
 475         }
 476     }
 477
 478     close(temp_fd);
 479     remove(temp_file);
 480     fsync(playlist->control_fd);
 481
 482     if (result < 0)
 483         return result;
 484
 485     return 0;
 486 }
 487
 488 /*
 489  * store directory and name of playlist file
 490  */
 491 static void update_playlist_filename(struct playlist_info* playlist,
 492                                      const char *dir, const char *file)
 493 {
 494     char *sep="";
 495     int dirlen = strlen(dir);
 496
 497     playlist->utf8 = is_m3u8(file);
 498
 499     /* If the dir does not end in trailing slash, we use a separator.
 500        Otherwise we don't. */
 501     if('/' != dir[dirlen-1])
 502     {
 503         sep="/";
 504         dirlen++;
 505     }
 506
 507     playlist->dirlen = dirlen;
 508
 509     snprintf(playlist->filename, sizeof(playlist->filename),
 510         "%s%s%s", dir, sep, file);
 511 }
 512
 513 /*
 514  * calculate track offsets within a playlist file
 515  */
 516 static int add_indices_to_playlist(struct playlist_info* playlist,
 517                                    char* buffer, size_t buflen)
 518 {
 519     unsigned int nread;
 520     unsigned int i = 0;
 521     unsigned int count = 0;
 522     bool store_index;
 523     unsigned char *p;
 524     int result = 0;
 525
 526     if(-1 == playlist->fd)
 527         playlist->fd = open_utf8(playlist->filename, O_RDONLY);
 528     if(playlist->fd < 0)
 529         return -1; /* failure */
 530     if((i = lseek(playlist->fd, 0, SEEK_CUR)) > 0)
 531         playlist->utf8 = true; /* Override any earlier indication. */
 532
 533     splash(0, ID2P(LANG_WAIT));
 534
 535     if (!buffer)
 536     {
 537         /* use mp3 buffer for maximum load speed */
 538         audio_stop();
 539         buffer = audio_get_buffer(false, &buflen);
 540     }
 541
 542     store_index = true;
 543
 544     while(1)
 545     {
 546         nread = read(playlist->fd, buffer, buflen);
 547         /* Terminate on EOF */
 548         if(nread <= 0)
 549             break;
 550
 551         p = (unsigned char *)buffer;
 552
 553         for(count=0; count < nread; count++,p++) {
 554
 555             /* Are we on a new line? */
 556             if((*p == '\n') || (*p == '\r'))
 557             {
 558                 store_index = true;
 559             }
 560             else if(store_index)
 561             {
 562                 store_index = false;
 563
 564                 if(*p != '#')
 565                 {
 566                     if ( playlist->amount >= playlist->max_playlist_size ) {
 567                         display_buffer_full();
 568                         result = -1;
 569                         goto exit;
 570                     }
 571
 572                     /* Store a new entry */
 573                     playlist->indices[ playlist->amount ] = i+count;
 574 #ifdef HAVE_DIRCACHE
 575                     if (playlist->filenames)
 576                         playlist->filenames[ playlist->amount ] = -1;
 577 #endif
 578                     playlist->amount++;
 579                 }
 580             }
 581         }
 582
 583         i+= count;
 584     }
 585
 586 exit:
 587 #ifdef HAVE_DIRCACHE
 588     queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
 589 #endif
 590
 591     return result;
 592 }
 593
 594 /*
 595  * Utility function to create a new playlist, fill it with the next or
 596  * previous directory, shuffle it if needed, and start playback.
 597  * If play_last is true and direction zero or negative, start playing
 598  * the last file in the directory, otherwise start playing the first.
 599  */
 600 static int create_and_play_dir(int direction, bool play_last)
 601 {
 602     char dir[MAX_PATH + 1];
 603     int res;
 604     int index = -1;
 605
 606     if(direction > 0)
 607       res = get_next_directory(dir);
 608     else
 609       res = get_previous_directory(dir);
 610
 611     if (res < 0)
 612         /* return the error encountered */
 613         return res;
 614
 615     if (playlist_create(dir, NULL) != -1)
 616     {
 617         ft_build_playlist(tree_get_context(), 0);
 618
 619         if (global_settings.playlist_shuffle)
 620              playlist_shuffle(current_tick, -1);
 621
 622         if (play_last && direction <= 0)
 623             index = current_playlist.amount - 1;
 624         else
 625             index = 0;
 626
 627 #if (CONFIG_CODEC == SWCODEC)
 628         current_playlist.started = true;
 629 #else
 630         playlist_start(index, 0);
 631 #endif
 632     }
 633
 634     /* we've overwritten the dircache when getting the next/previous dir,
 635        so the tree browser context will need to be reloaded */
 636     reload_directory();
 637
 638     return index;
 639 }
 640
 641 /*
 642  * Removes all tracks, from the playlist, leaving the presently playing
 643  * track queued.
 644  */
 645 int playlist_remove_all_tracks(struct playlist_info *playlist)
 646 {
 647     int result;
 648
 649     if (playlist == NULL)
 650         playlist = &current_playlist;
 651
 652     while (playlist->index > 0)
 653         if ((result = remove_track_from_playlist(playlist, 0, true)) < 0)
 654             return result;
 655
 656     while (playlist->amount > 1)
 657         if ((result = remove_track_from_playlist(playlist, 1, true)) < 0)
 658             return result;
 659
 660     if (playlist->amount == 1) {
 661         playlist->indices[0] |= PLAYLIST_QUEUED;
 662     }
 663
 664     return 0;
 665 }
 666
 667
 668 /*
 669  * Add track to playlist at specified position. There are seven special
 670  * positions that can be specified:
 671  *  PLAYLIST_PREPEND              - Add track at beginning of playlist
 672  *  PLAYLIST_INSERT               - Add track after current song.  NOTE: If
 673  *                                  there are already inserted tracks then track
 674  *                                  is added to the end of the insertion list
 675  *  PLAYLIST_INSERT_FIRST         - Add track immediately after current song, no
 676  *                                  matter what other tracks have been inserted
 677  *  PLAYLIST_INSERT_LAST          - Add track to end of playlist
 678  *  PLAYLIST_INSERT_SHUFFLED      - Add track at some random point between the
 679  *                                  current playing track and end of playlist
 680  *  PLAYLIST_INSERT_LAST_SHUFFLED - Add tracks in random order to the end of
 681  *                                  the playlist.
 682  *  PLAYLIST_REPLACE              - Erase current playlist, Cue the current track
 683  *                                  and inster this track at the end.
 684  */
 685 static int add_track_to_playlist(struct playlist_info* playlist,
 686                                  const char *filename, int position,
 687                                  bool queue, int seek_pos)
 688 {
 689     int insert_position, orig_position;
 690     unsigned long flags = PLAYLIST_INSERT_TYPE_INSERT;
 691     int i;
 692
 693     insert_position = orig_position = position;
 694
 695     if (playlist->amount >= playlist->max_playlist_size)
 696     {
 697         display_buffer_full();
 698         return -1;
 699     }
 700
 701     switch (position)
 702     {
 703         case PLAYLIST_PREPEND:
 704             position = insert_position = playlist->first_index;
 705             break;
 706         case PLAYLIST_INSERT:
 707             /* if there are already inserted tracks then add track to end of
 708                insertion list else add after current playing track */
 709             if (playlist->last_insert_pos >= 0 &&
 710                 playlist->last_insert_pos < playlist->amount &&
 711                 (playlist->indices[playlist->last_insert_pos]&
 712                     PLAYLIST_INSERT_TYPE_MASK) == PLAYLIST_INSERT_TYPE_INSERT)
 713                 position = insert_position = playlist->last_insert_pos+1;
 714             else if (playlist->amount > 0)
 715                 position = insert_position = playlist->index + 1;
 716             else
 717                 position = insert_position = 0;
 718
 719             playlist->last_insert_pos = position;
 720             break;
 721         case PLAYLIST_INSERT_FIRST:
 722             if (playlist->amount > 0)
 723                 position = insert_position = playlist->index + 1;
 724             else
 725                 position = insert_position = 0;
 726
 727             playlist->last_insert_pos = position;
 728             break;
 729         case PLAYLIST_INSERT_LAST:
 730             if (playlist->first_index > 0)
 731                 position = insert_position = playlist->first_index;
 732             else
 733                 position = insert_position = playlist->amount;
 734
 735             playlist->last_insert_pos = position;
 736             break;
 737         case PLAYLIST_INSERT_SHUFFLED:
 738         {
 739             if (playlist->started)
 740             {
 741                 int offset;
 742                 int n = playlist->amount -
 743                     rotate_index(playlist, playlist->index);
 744
 745                 if (n > 0)
 746                     offset = rand() % n;
 747                 else
 748                     offset = 0;
 749
 750                 position = playlist->index + offset + 1;
 751                 if (position >= playlist->amount)
 752                     position -= playlist->amount;
 753
 754                 insert_position = position;
 755             }
 756             else
 757                 position = insert_position = (rand() % (playlist->amount+1));
 758             break;
 759         }
 760         case PLAYLIST_INSERT_LAST_SHUFFLED:
 761         {
 762             position = insert_position = playlist->last_shuffled_start +
 763                           rand() % (playlist->amount - playlist->last_shuffled_start + 1);
 764             break;
 765         }
 766         case PLAYLIST_REPLACE:
 767             if (playlist_remove_all_tracks(playlist) < 0)
 768                 return -1;
 769
 770             playlist->last_insert_pos = position = insert_position = playlist->index + 1;
 771             break;
 772     }
 773
 774     if (queue)
 775         flags |= PLAYLIST_QUEUED;
 776
 777     /* shift indices so that track can be added */
 778     for (i=playlist->amount; i>insert_position; i--)
 779     {
 780         playlist->indices[i] = playlist->indices[i-1];
 781 #ifdef HAVE_DIRCACHE
 782         if (playlist->filenames)
 783             playlist->filenames[i] = playlist->filenames[i-1];
 784 #endif
 785     }
 786
 787     /* update stored indices if needed */
 788
 789     if (orig_position < 0)
 790     {
 791         if (playlist->amount > 0 && insert_position <= playlist->index &&
 792             playlist->started)
 793             playlist->index++;
 794
 795         if (playlist->amount > 0 && insert_position <= playlist->first_index &&
 796             orig_position != PLAYLIST_PREPEND && playlist->started)
 797             playlist->first_index++;
 798     }
 799
 800     if (insert_position < playlist->last_insert_pos ||
 801         (insert_position == playlist->last_insert_pos && position < 0))
 802         playlist->last_insert_pos++;
 803
 804     if (seek_pos < 0 && playlist->control_fd >= 0)
 805     {
 806         int result = update_control(playlist,
 807             (queue?PLAYLIST_COMMAND_QUEUE:PLAYLIST_COMMAND_ADD), position,
 808             playlist->last_insert_pos, filename, NULL, &seek_pos);
 809
 810         if (result < 0)
 811             return result;
 812     }
 813
 814     playlist->indices[insert_position] = flags | seek_pos;
 815
 816 #ifdef HAVE_DIRCACHE
 817     if (playlist->filenames)
 818         playlist->filenames[insert_position] = -1;
 819 #endif
 820
 821     playlist->amount++;
 822     playlist->num_inserted_tracks++;
 823
 824     return insert_position;
 825 }
 826
 827 /*
 828  * Callback for playlist_directory_tracksearch to insert track into
 829  * playlist.
 830  */
 831 static int directory_search_callback(char* filename, void* context)
 832 {
 833     struct directory_search_context* c =
 834         (struct directory_search_context*) context;
 835     int insert_pos;
 836
 837     insert_pos = add_track_to_playlist(c->playlist, filename, c->position,
 838         c->queue, -1);
 839
 840     if (insert_pos < 0)
 841         return -1;
 842
 843     (c->count)++;
 844
 845     /* Make sure tracks are inserted in correct order if user requests
 846        INSERT_FIRST */
 847     if (c->position == PLAYLIST_INSERT_FIRST || c->position >= 0)
 848         c->position = insert_pos + 1;
 849
 850     if (((c->count)%PLAYLIST_DISPLAY_COUNT) == 0)
 851     {
 852         unsigned char* count_str;
 853
 854         if (c->queue)
 855             count_str = ID2P(LANG_PLAYLIST_QUEUE_COUNT);
 856         else
 857             count_str = ID2P(LANG_PLAYLIST_INSERT_COUNT);
 858
 859         display_playlist_count(c->count, count_str, false);
 860
 861         if ((c->count) == PLAYLIST_DISPLAY_COUNT &&
 862             (audio_status() & AUDIO_STATUS_PLAY) &&
 863             c->playlist->started)
 864             audio_flush_and_reload_tracks();
 865     }
 866
 867     return 0;
 868 }
 869
 870 /*
 871  * remove track at specified position
 872  */
 873 static int remove_track_from_playlist(struct playlist_info* playlist,
 874                                       int position, bool write)
 875 {
 876     int i;
 877     bool inserted;
 878
 879     if (playlist->amount <= 0)
 880         return -1;
 881
 882     inserted = playlist->indices[position] & PLAYLIST_INSERT_TYPE_MASK;
 883
 884     /* shift indices now that track has been removed */
 885     for (i=position; i<playlist->amount; i++)
 886     {
 887         playlist->indices[i] = playlist->indices[i+1];
 888 #ifdef HAVE_DIRCACHE
 889         if (playlist->filenames)
 890             playlist->filenames[i] = playlist->filenames[i+1];
 891 #endif
 892     }
 893
 894     playlist->amount--;
 895
 896     if (inserted)
 897         playlist->num_inserted_tracks--;
 898     else
 899         playlist->deleted = true;
 900
 901     /* update stored indices if needed */
 902     if (position < playlist->index)
 903         playlist->index--;
 904
 905     if (position < playlist->first_index)
 906     {
 907         playlist->first_index--;
 908     }
 909
 910     if (position <= playlist->last_insert_pos)
 911         playlist->last_insert_pos--;
 912
 913     if (write && playlist->control_fd >= 0)
 914     {
 915         int result = update_control(playlist, PLAYLIST_COMMAND_DELETE,
 916             position, -1, NULL, NULL, NULL);
 917
 918         if (result < 0)
 919             return result;
 920
 921         sync_control(playlist, false);
 922     }
 923
 924     return 0;
 925 }
 926
 927 /*
 928  * randomly rearrange the array of indices for the playlist.  If start_current
 929  * is true then update the index to the new index of the current playing track
 930  */
 931 static int randomise_playlist(struct playlist_info* playlist,
 932                               unsigned int seed, bool start_current,
 933                               bool write)
 934 {
 935     int count;
 936     int candidate;
 937     long store;
 938     unsigned int current = playlist->indices[playlist->index];
 939
 940     /* seed 0 is used to identify sorted playlist for resume purposes */
 941     if (seed == 0)
 942         seed = 1;
 943
 944     /* seed with the given seed */
 945     srand(seed);
 946
 947     /* randomise entire indices list */
 948     for(count = playlist->amount - 1; count >= 0; count--)
 949     {
 950         /* the rand is from 0 to RAND_MAX, so adjust to our value range */
 951         candidate = rand() % (count + 1);
 952
 953         /* now swap the values at the 'count' and 'candidate' positions */
 954         store = playlist->indices[candidate];
 955         playlist->indices[candidate] = playlist->indices[count];
 956         playlist->indices[count] = store;
 957 #ifdef HAVE_DIRCACHE
 958         if (playlist->filenames)
 959         {
 960             store = playlist->filenames[candidate];
 961             playlist->filenames[candidate] = playlist->filenames[count];
 962             playlist->filenames[count] = store;
 963         }
 964 #endif
 965     }
 966
 967     if (start_current)
 968         find_and_set_playlist_index(playlist, current);
 969
 970     /* indices have been moved so last insert position is no longer valid */
 971     playlist->last_insert_pos = -1;
 972
 973     playlist->seed = seed;
 974     if (playlist->num_inserted_tracks > 0 || playlist->deleted)
 975         playlist->shuffle_modified = true;
 976
 977     if (write)
 978     {
 979         update_control(playlist, PLAYLIST_COMMAND_SHUFFLE, seed,
 980             playlist->first_index, NULL, NULL, NULL);
 981     }
 982
 983     return 0;
 984 }
 985
 986 /*
 987  * Sort the array of indices for the playlist. If start_current is true then
 988  * set the index to the new index of the current song.
 989  * Also while going to unshuffled mode set the first_index to 0.
 990  */
 991 static int sort_playlist(struct playlist_info* playlist, bool start_current,
 992                          bool write)
 993 {
 994     unsigned int current = playlist->indices[playlist->index];
 995
 996     if (playlist->amount > 0)
 997         qsort((void*)playlist->indices, playlist->amount,
 998             sizeof(playlist->indices[0]), compare);
 999
1000 #ifdef HAVE_DIRCACHE
1001     /** We need to re-check the song names from disk because qsort can't
1002      * sort two arrays at once :/
1003      * FIXME: Please implement a better way to do this. */
1004     memset((void*)playlist->filenames, 0xff, playlist->max_playlist_size * sizeof(int));
1005     queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
1006 #endif
1007
1008     if (start_current)
1009         find_and_set_playlist_index(playlist, current);
1010
1011     /* indices have been moved so last insert position is no longer valid */
1012     playlist->last_insert_pos = -1;
1013
1014     if (!playlist->num_inserted_tracks && !playlist->deleted)
1015         playlist->shuffle_modified = false;
1016     if (write && playlist->control_fd >= 0)
1017     {
1018         playlist->first_index = 0;
1019         update_control(playlist, PLAYLIST_COMMAND_UNSHUFFLE,
1020             playlist->first_index, -1, NULL, NULL, NULL);
1021     }
1022
1023     return 0;
1024 }
1025
1026 /* Calculate how many steps we have to really step when skipping entries
1027  * marked as bad.
1028  */
1029 static int calculate_step_count(const struct playlist_info *playlist, int steps)
1030 {
1031     int i, count, direction;
1032     int index;
1033     int stepped_count = 0;
1034
1035     if (steps < 0)
1036     {
1037         direction = -1;
1038         count = -steps;
1039     }
1040     else
1041     {
1042         direction = 1;
1043         count = steps;
1044     }
1045
1046     index = playlist->index;
1047     i = 0;
1048     do {
1049         /* Boundary check */
1050         if (index < 0)
1051             index += playlist->amount;
1052         if (index >= playlist->amount)
1053             index -= playlist->amount;
1054
1055         /* Check if we found a bad entry. */
1056         if (playlist->indices[index] & PLAYLIST_SKIPPED)
1057         {
1058             steps += direction;
1059             /* Are all entries bad? */
1060             if (stepped_count++ > playlist->amount)
1061                 break ;
1062         }
1063         else
1064             i++;
1065
1066         index += direction;
1067     } while (i <= count);
1068
1069     return steps;
1070 }
1071
1072 #if CONFIG_CODEC == SWCODEC
1073 /* Marks the index of the track to be skipped that is "steps" away from
1074  * current playing track.
1075  */
1076 void playlist_skip_entry(struct playlist_info *playlist, int steps)
1077 {
1078     int index;
1079
1080     if (playlist == NULL)
1081         playlist = &current_playlist;
1082
1083     /* need to account for already skipped tracks */
1084     steps = calculate_step_count(playlist, steps);
1085
1086     index = playlist->index + steps;
1087     if (index < 0)
1088         index += playlist->amount;
1089     else if (index >= playlist->amount)
1090         index -= playlist->amount;
1091
1092     playlist->indices[index] |= PLAYLIST_SKIPPED;
1093 }
1094 #endif /* CONFIG_CODEC == SWCODEC */
1095
1096 /*
1097  * returns the index of the track that is "steps" away from current playing
1098  * track.
1099  */
1100 static int get_next_index(const struct playlist_info* playlist, int steps,
1101                           int repeat_mode)
1102 {
1103     int current_index = playlist->index;
1104     int next_index    = -1;
1105
1106     if (playlist->amount <= 0)
1107         return -1;
1108
1109     if (repeat_mode == -1)
1110         repeat_mode = global_settings.repeat_mode;
1111
1112     if (repeat_mode == REPEAT_SHUFFLE && playlist->amount <= 1)
1113         repeat_mode = REPEAT_ALL;
1114
1115     steps = calculate_step_count(playlist, steps);
1116     switch (repeat_mode)
1117     {
1118         case REPEAT_SHUFFLE:
1119             /* Treat repeat shuffle just like repeat off.  At end of playlist,
1120                play will be resumed in playlist_next() */
1121         case REPEAT_OFF:
1122         {
1123             current_index = rotate_index(playlist, current_index);
1124             next_index = current_index+steps;
1125             if ((next_index < 0) || (next_index >= playlist->amount))
1126                 next_index = -1;
1127             else
1128                 next_index = (next_index+playlist->first_index) %
1129                     playlist->amount;
1130
1131             break;
1132         }
1133
1134         case REPEAT_ONE:
1135 #ifdef AB_REPEAT_ENABLE
1136         case REPEAT_AB:
1137 #endif
1138             next_index = current_index;
1139             break;
1140
1141         case REPEAT_ALL:
1142         default:
1143         {
1144             next_index = (current_index+steps) % playlist->amount;
1145             while (next_index < 0)
1146                 next_index += playlist->amount;
1147
1148             if (steps >= playlist->amount)
1149             {
1150                 int i, index;
1151
1152                 index = next_index;
1153                 next_index = -1;
1154
1155                 /* second time around so skip the queued files */
1156                 for (i=0; i<playlist->amount; i++)
1157                 {
1158                     if (playlist->indices[index] & PLAYLIST_QUEUE_MASK)
1159                         index = (index+1) % playlist->amount;
1160                     else
1161                     {
1162                         next_index = index;
1163                         break;
1164                     }
1165                 }
1166             }
1167             break;
1168         }
1169     }
1170
1171     /* No luck if the whole playlist was bad. */
1172     if (playlist->indices[next_index] & PLAYLIST_SKIPPED)
1173         return -1;
1174
1175     return next_index;
1176 }
1177
1178 /*
1179  * Search for the seek track and set appropriate indices.  Used after shuffle
1180  * to make sure the current index is still pointing to correct track.
1181  */
1182 static void find_and_set_playlist_index(struct playlist_info* playlist,
1183                                         unsigned int seek)
1184 {
1185     int i;
1186
1187     /* Set the index to the current song */
1188     for (i=0; i<playlist->amount; i++)
1189     {
1190         if (playlist->indices[i] == seek)
1191         {
1192             playlist->index = playlist->first_index = i;
1193
1194             break;
1195         }
1196     }
1197 }
1198
1199 /*
1200  * used to sort track indices.  Sort order is as follows:
1201  * 1. Prepended tracks (in prepend order)
1202  * 2. Playlist/directory tracks (in playlist order)
1203  * 3. Inserted/Appended tracks (in insert order)
1204  */
1205 static int compare(const void* p1, const void* p2)
1206 {
1207     unsigned long* e1 = (unsigned long*) p1;
1208     unsigned long* e2 = (unsigned long*) p2;
1209     unsigned long flags1 = *e1 & PLAYLIST_INSERT_TYPE_MASK;
1210     unsigned long flags2 = *e2 & PLAYLIST_INSERT_TYPE_MASK;
1211
1212     if (flags1 == flags2)
1213         return (*e1 & PLAYLIST_SEEK_MASK) - (*e2 & PLAYLIST_SEEK_MASK);
1214     else if (flags1 == PLAYLIST_INSERT_TYPE_PREPEND ||
1215         flags2 == PLAYLIST_INSERT_TYPE_APPEND)
1216         return -1;
1217     else if (flags1 == PLAYLIST_INSERT_TYPE_APPEND ||
1218         flags2 == PLAYLIST_INSERT_TYPE_PREPEND)
1219         return 1;
1220     else if (flags1 && flags2)
1221         return (*e1 & PLAYLIST_SEEK_MASK) - (*e2 & PLAYLIST_SEEK_MASK);
1222     else
1223         return *e1 - *e2;
1224 }
1225
1226 #ifdef HAVE_DIRCACHE
1227 /**
1228  * Thread to update filename pointers to dircache on background
1229  * without affecting playlist load up performance.  This thread also flushes
1230  * any pending control commands when the disk spins up.
1231  */
1232 static void playlist_flush_callback(void *param)
1233 {
1234     (void)param;
1235     struct playlist_info *playlist;
1236     playlist = &current_playlist;
1237     if (playlist->control_fd >= 0)
1238     {
1239         if (playlist->num_cached > 0)
1240         {
1241             mutex_lock(playlist->control_mutex);
1242             flush_cached_control(playlist);
1243             mutex_unlock(playlist->control_mutex);
1244         }
1245         sync_control(playlist, true);
1246     }
1247 }
1248
1249 static bool is_dircache_pointers_intact(void)
1250 {
1251     return dircache_get_appflag(DIRCACHE_APPFLAG_PLAYLIST) ? true : false;
1252 }
1253
1254 static void playlist_thread(void)
1255 {
1256     struct queue_event ev;
1257     bool dirty_pointers = false;
1258     static char tmp[MAX_PATH+1];
1259
1260     struct playlist_info *playlist;
1261     int index;
1262     int seek;
1263     bool control_file;
1264
1265     int sleep_time = 5;
1266
1267 #ifdef HAVE_DISK_STORAGE
1268     if (global_settings.disk_spindown > 1 &&
1269         global_settings.disk_spindown <= 5)
1270         sleep_time = global_settings.disk_spindown - 1;
1271 #endif
1272
1273     while (1)
1274     {
1275         queue_wait_w_tmo(&playlist_queue, &ev, HZ*sleep_time);
1276
1277         switch (ev.id)
1278         {
1279             case PLAYLIST_LOAD_POINTERS:
1280                 dirty_pointers = true;
1281                 break ;
1282
1283             /* Start the background scanning after either the disk spindown
1284                timeout or 5s, whichever is less */
1285             case SYS_TIMEOUT:
1286             {
1287                 playlist = &current_playlist;
1288                 if (playlist->control_fd >= 0)
1289                 {
1290                     if (playlist->num_cached > 0)
1291                         register_storage_idle_func(playlist_flush_callback);
1292                 }
1293
1294                 if (!dircache_is_enabled() || !playlist->filenames
1295                      || playlist->amount <= 0)
1296                 {
1297                     break ;
1298                 }
1299
1300                 /* Check if previously loaded pointers are intact. */
1301                 if (is_dircache_pointers_intact() && !dirty_pointers)
1302                     break ;
1303
1304 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1305                 cpu_boost(true);
1306 #endif
1307                 for (index = 0; index < playlist->amount
1308                      && queue_empty(&playlist_queue); index++)
1309                 {
1310                     /* Process only pointers that are not already loaded. */
1311                     if (is_dircache_pointers_intact() && playlist->filenames[index] >= 0)
1312                         continue ;
1313
1314                     control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
1315                     seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
1316
1317                     /* Load the filename from playlist file. */
1318                     if (get_filename(playlist, index, seek, control_file, tmp,
1319                         sizeof(tmp)) < 0)
1320                     {
1321                         break ;
1322                     }
1323
1324                     /* Set the dircache entry pointer. */
1325                     playlist->filenames[index] = dircache_get_entry_id(tmp);
1326
1327                     /* And be on background so user doesn't notice any delays. */
1328                     yield();
1329                 }
1330
1331                 if (dircache_is_enabled())
1332                     dircache_set_appflag(DIRCACHE_APPFLAG_PLAYLIST);
1333
1334 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1335                 cpu_boost(false);
1336 #endif
1337                 if (index == playlist->amount)
1338                     dirty_pointers = false;
1339
1340                 break ;
1341             }
1342
1343             case SYS_USB_CONNECTED:
1344                 usb_acknowledge(SYS_USB_CONNECTED_ACK);
1345                 usb_wait_for_disconnect(&playlist_queue);
1346                 break ;
1347         }
1348     }
1349 }
1350 #endif
1351
1352 /*
1353  * gets pathname for track at seek index
1354  */
1355 static int get_filename(struct playlist_info* playlist, int index, int seek,
1356                         bool control_file, char *buf, int buf_length)
1357 {
1358     int fd;
1359     int max = -1;
1360     char tmp_buf[MAX_PATH+1];
1361     char dir_buf[MAX_PATH+1];
1362     bool utf8 = playlist->utf8;
1363
1364     if (buf_length > MAX_PATH+1)
1365         buf_length = MAX_PATH+1;
1366
1367 #ifdef HAVE_DIRCACHE
1368     if (is_dircache_pointers_intact() && playlist->filenames)
1369     {
1370         if (playlist->filenames[index] >= 0)
1371         {
1372             max = dircache_copy_path(playlist->filenames[index],
1373                                      tmp_buf, sizeof(tmp_buf)-1);
1374         }
1375     }
1376 #else
1377     (void)index;
1378 #endif
1379
1380     if (playlist->in_ram && !control_file && max < 0)
1381     {
1382         max = strlcpy(tmp_buf, (char*)&playlist->buffer[seek], sizeof(tmp_buf));
1383     }
1384     else if (max < 0)
1385     {
1386         mutex_lock(playlist->control_mutex);
1387
1388         if (control_file)
1389         {
1390             fd = playlist->control_fd;
1391             utf8 = true;
1392         }
1393         else
1394         {
1395             if(-1 == playlist->fd)
1396                 playlist->fd = open(playlist->filename, O_RDONLY);
1397
1398             fd = playlist->fd;
1399         }
1400
1401         if(-1 != fd)
1402         {
1403
1404             if (lseek(fd, seek, SEEK_SET) != seek)
1405                 max = -1;
1406             else
1407             {
1408                 max = read(fd, tmp_buf, MIN((size_t) buf_length, sizeof(tmp_buf)));
1409
1410                 if ((max > 0) && !utf8)
1411                 {
1412                     /* Use dir_buf as a temporary buffer. Note that dir_buf must
1413                      * be as large as tmp_buf.
1414                      */
1415                     max = convert_m3u(tmp_buf, max, sizeof(tmp_buf), dir_buf);
1416                 }
1417             }
1418         }
1419
1420         mutex_unlock(playlist->control_mutex);
1421
1422         if (max < 0)
1423         {
1424             if (control_file)
1425                 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
1426             else
1427                 splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
1428
1429             return max;
1430         }
1431     }
1432
1433     strlcpy(dir_buf, playlist->filename, playlist->dirlen);
1434
1435     return (format_track_path(buf, tmp_buf, buf_length, max, dir_buf));
1436 }
1437
1438 static int get_next_directory(char *dir){
1439     return get_next_dir(dir, true);
1440 }
1441
1442 static int get_previous_directory(char *dir){
1443     return get_next_dir(dir, false);
1444 }
1445
1446 /*
1447  * search through all the directories (starting with the current) to find
1448  * one that has tracks to play
1449  */
1450 static int get_next_dir(char *dir, bool is_forward)
1451 {
1452     struct playlist_info* playlist = &current_playlist;
1453     int result = -1;
1454     char *start_dir = NULL;
1455     bool exit = false;
1456     struct tree_context* tc = tree_get_context();
1457     int saved_dirfilter = *(tc->dirfilter);
1458     unsigned int base_len;
1459
1460     if (global_settings.constrain_next_folder)
1461     {
1462         /* constrain results to directories below user's start directory */
1463         strcpy(dir, global_settings.start_directory);
1464         base_len = strlen(dir);
1465
1466         /* strip any trailing slash from base directory */
1467         if (base_len > 0 && dir[base_len - 1] == '/')
1468         {
1469             base_len--;
1470             dir[base_len] = '\0';
1471         }
1472     }
1473     else
1474     {
1475         /* start from root directory */
1476         dir[0] = '\0';
1477         base_len = 0;
1478     }
1479
1480     /* process random folder advance */
1481     if (global_settings.next_folder == FOLDER_ADVANCE_RANDOM)
1482     {
1483         int fd = open(ROCKBOX_DIR "/folder_advance_list.dat", O_RDONLY);
1484         if (fd >= 0)
1485         {
1486             int folder_count = 0;
1487             read(fd,&folder_count,sizeof(int));
1488             if (folder_count)
1489             {
1490                 char buffer[MAX_PATH];
1491                 /* give up looking for a directory after we've had four
1492                    times as many tries as there are directories. */
1493                 unsigned long allowed_tries = folder_count * 4;
1494                 int i;
1495                 srand(current_tick);
1496                 *(tc->dirfilter) = SHOW_MUSIC;
1497                 tc->sort_dir = global_settings.sort_dir;
1498                 while (!exit && allowed_tries--)
1499                 {
1500                     i = rand() % folder_count;
1501                     lseek(fd, sizeof(int) + (MAX_PATH * i), SEEK_SET);
1502                     read(fd, buffer, MAX_PATH);
1503                     /* is the current dir within our base dir and has music? */
1504                     if ((base_len == 0 || !strncmp(buffer, dir, base_len))
1505                         && check_subdir_for_music(buffer, "", false) == 0)
1506                             exit = true;
1507                 }
1508                 close(fd);
1509                 *(tc->dirfilter) = saved_dirfilter;
1510                 tc->sort_dir = global_settings.sort_dir;
1511                 reload_directory();
1512                 if (exit)
1513                 {
1514                     strcpy(dir,buffer);
1515                     return 0;
1516                 }
1517             }
1518             else
1519                 close(fd);
1520         }
1521     }
1522
1523     /* if the current file is within our base dir, use its dir instead */
1524     if (base_len == 0 || !strncmp(playlist->filename, dir, base_len))
1525         strlcpy(dir, playlist->filename, playlist->dirlen);
1526
1527     /* use the tree browser dircache to load files */
1528     *(tc->dirfilter) = SHOW_ALL;
1529
1530     /* set up sorting/direction */
1531     tc->sort_dir = global_settings.sort_dir;
1532     if (!is_forward)
1533     {
1534         static const char sortpairs[] =
1535         {
1536             [SORT_ALPHA] = SORT_ALPHA_REVERSED,
1537             [SORT_DATE] = SORT_DATE_REVERSED,
1538             [SORT_TYPE] = SORT_TYPE_REVERSED,
1539             [SORT_ALPHA_REVERSED] = SORT_ALPHA,
1540             [SORT_DATE_REVERSED] = SORT_DATE,
1541             [SORT_TYPE_REVERSED] = SORT_TYPE,
1542         };
1543
1544         if ((unsigned)tc->sort_dir < sizeof(sortpairs))
1545             tc->sort_dir = sortpairs[tc->sort_dir];
1546     }
1547
1548     while (!exit)
1549     {
1550         struct entry *files;
1551         int num_files = 0;
1552         int i;
1553
1554         if (ft_load(tc, (dir[0]=='\0')?"/":dir) < 0)
1555         {
1556             exit = true;
1557             result = -1;
1558             break;
1559         }
1560
1561         files = tree_get_entries(tc);
1562         num_files = tc->filesindir;
1563
1564         tree_lock_cache(tc);
1565         for (i=0; i<num_files; i++)
1566         {
1567             /* user abort */
1568             if (action_userabort(TIMEOUT_NOBLOCK))
1569             {
1570                 result = -1;
1571                 exit = true;
1572                 break;
1573             }
1574
1575             if (files[i].attr & ATTR_DIRECTORY)
1576             {
1577                 if (!start_dir)
1578                 {
1579                     result = check_subdir_for_music(dir, files[i].name, true);
1580                     if (result != -1)
1581                     {
1582                         exit = true;
1583                         break;
1584                     }
1585                 }
1586                 else if (!strcmp(start_dir, files[i].name))
1587                     start_dir = NULL;
1588             }
1589         }
1590         tree_unlock_cache(tc);
1591
1592         if (!exit)
1593         {
1594             /* we've already descended to the base dir with nothing found,
1595                check whether that contains music */
1596             if (strlen(dir) <= base_len)
1597             {
1598                 result = check_subdir_for_music(dir, "", true);
1599                 if (result == -1)
1600                     /* there's no music files in the base directory,
1601                        treat as a fatal error */
1602                     result = -2;
1603                 break;
1604             }
1605             else
1606             {
1607                 /* move down to parent directory.  current directory name is
1608                    stored as the starting point for the search in parent */
1609                 start_dir = strrchr(dir, '/');
1610                 if (start_dir)
1611                 {
1612                     *start_dir = '\0';
1613                     start_dir++;
1614                 }
1615                 else
1616                     break;
1617             }
1618         }
1619     }
1620
1621     /* restore dirfilter */
1622     *(tc->dirfilter) = saved_dirfilter;
1623     tc->sort_dir = global_settings.sort_dir;
1624
1625     return result;
1626 }
1627
1628 /*
1629  * Checks if there are any music files in the dir or any of its
1630  * subdirectories.  May be called recursively.
1631  */
1632 static int check_subdir_for_music(char *dir, const char *subdir, bool recurse)
1633 {
1634     int result = -1;
1635     int dirlen = strlen(dir);
1636     int num_files = 0;
1637     int i;
1638     struct entry *files;
1639     bool has_music = false;
1640     bool has_subdir = false;
1641     struct tree_context* tc = tree_get_context();
1642
1643     snprintf(
1644         dir + dirlen, MAX_PATH - dirlen,
1645         /* only add a trailing slash if we need one */
1646         dirlen && dir[dirlen - 1] == '/' ? "%s" : "/%s",
1647         subdir
1648     );
1649
1650     if (ft_load(tc, dir) < 0)
1651     {
1652         return -2;
1653     }
1654
1655     files = tree_get_entries(tc);
1656     num_files = tc->filesindir;
1657
1658     for (i=0; i<num_files; i++)
1659     {
1660         if (files[i].attr & ATTR_DIRECTORY)
1661             has_subdir = true;
1662         else if ((files[i].attr & FILE_ATTR_MASK) == FILE_ATTR_AUDIO)
1663         {
1664             has_music = true;
1665             break;
1666         }
1667     }
1668
1669     if (has_music)
1670         return 0;
1671
1672     tree_lock_cache(tc);
1673     if (has_subdir && recurse)
1674     {
1675         for (i=0; i<num_files; i++)
1676         {
1677             if (action_userabort(TIMEOUT_NOBLOCK))
1678             {
1679                 result = -2;
1680                 break;
1681             }
1682
1683             if (files[i].attr & ATTR_DIRECTORY)
1684             {
1685                 result = check_subdir_for_music(dir, files[i].name, true);
1686                 if (!result)
1687                     break;
1688             }
1689         }
1690     }
1691     tree_unlock_cache(tc);
1692
1693     if (result < 0)
1694     {
1695         if (dirlen)
1696         {
1697             dir[dirlen] = '\0';
1698         }
1699         else
1700         {
1701             strcpy(dir, "/");
1702         }
1703
1704         /* we now need to reload our current directory */
1705         if(ft_load(tc, dir) < 0)
1706             splash(HZ*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR));
1707     }
1708     return result;
1709 }
1710
1711 /*
1712  * Returns absolute path of track
1713  */
1714 static int format_track_path(char *dest, char *src, int buf_length, int max,
1715                              const char *dir)
1716 {
1717     int i = 0;
1718     int j;
1719     char *temp_ptr;
1720
1721     /* Look for the end of the string */
1722     while((i < max) &&
1723           (src[i] != '\n') &&
1724           (src[i] != '\r') &&
1725           (src[i] != '\0'))
1726         i++;
1727
1728     /* Now work back killing white space */
1729     while((i > 0) &&
1730           ((src[i-1] == ' ') ||
1731           (src[i-1] == '\t')))
1732         i--;
1733
1734     /* Zero-terminate the file name */
1735     src[i]=0;
1736
1737     /* replace backslashes with forward slashes */
1738     for ( j=0; j<i; j++ )
1739         if ( src[j] == '\\' )
1740             src[j] = '/';
1741
1742     if('/' == src[0])
1743     {
1744         strlcpy(dest, src, buf_length);
1745     }
1746     else
1747     {
1748         /* handle dos style drive letter */
1749         if (':' == src[1])
1750             strlcpy(dest, &src[2], buf_length);
1751         else if (!strncmp(src, "../", 3))
1752         {
1753             /* handle relative paths */
1754             i=3;
1755             while(!strncmp(&src[i], "../", 3))
1756                 i += 3;
1757             for (j=0; j<i/3; j++) {
1758                 temp_ptr = strrchr(dir, '/');
1759                 if (temp_ptr)
1760                     *temp_ptr = '\0';
1761                 else
1762                     break;
1763             }
1764             snprintf(dest, buf_length, "%s/%s", dir, &src[i]);
1765         }
1766         else if ( '.' == src[0] && '/' == src[1] ) {
1767             snprintf(dest, buf_length, "%s/%s", dir, &src[2]);
1768         }
1769         else {
1770             snprintf(dest, buf_length, "%s/%s", dir, src);
1771         }
1772     }
1773 #ifdef HAVE_MULTIVOLUME
1774
1775     char vol_string[VOL_ENUM_POS + 8];
1776     snprintf(vol_string, sizeof(vol_string), "/"VOL_NAMES, 1);
1777
1778     /*check if the playlist is on a external card, and correct path if needed */
1779     if(strstr(dir, vol_string) && (strstr(dest, vol_string) == NULL)){
1780         char temp[buf_length];
1781         strlcpy(temp, dest, buf_length);
1782         snprintf(dest, buf_length, "%s%s", vol_string, temp);
1783     }
1784 #endif
1785
1786     return 0;
1787 }
1788
1789 /*
1790  * Display splash message showing progress of playlist/directory insertion or
1791  * save.
1792  */
1793 static void display_playlist_count(int count, const unsigned char *fmt,
1794                                    bool final)
1795 {
1796     static long talked_tick = 0;
1797     long id = P2ID(fmt);
1798     if(global_settings.talk_menu && id>=0)
1799     {
1800         if(final || (count && (talked_tick == 0
1801                                || TIME_AFTER(current_tick, talked_tick+5*HZ))))
1802         {
1803             talked_tick = current_tick;
1804             talk_number(count, false);
1805             talk_id(id, true);
1806         }
1807     }
1808     fmt = P2STR(fmt);
1809
1810     splashf(0, fmt, count, str(LANG_OFF_ABORT));
1811 }
1812
1813 /*
1814  * Display buffer full message
1815  */
1816 static void display_buffer_full(void)
1817 {
1818     splash(HZ*2, ID2P(LANG_PLAYLIST_BUFFER_FULL));
1819 }
1820
1821 /*
1822  * Flush any cached control commands to disk.  Called when playlist is being
1823  * modified.  Returns 0 on success and -1 on failure.
1824  */
1825 static int flush_cached_control(struct playlist_info* playlist)
1826 {
1827     int result = 0;
1828     int i;
1829
1830     if (!playlist->num_cached)
1831         return 0;
1832
1833     lseek(playlist->control_fd, 0, SEEK_END);
1834
1835     for (i=0; i<playlist->num_cached; i++)
1836     {
1837         struct playlist_control_cache* cache =
1838             &(playlist->control_cache[i]);
1839
1840         switch (cache->command)
1841         {
1842             case PLAYLIST_COMMAND_PLAYLIST:
1843                 result = fdprintf(playlist->control_fd, "P:%d:%s:%s\n",
1844                     cache->i1, cache->s1, cache->s2);
1845                 break;
1846             case PLAYLIST_COMMAND_ADD:
1847             case PLAYLIST_COMMAND_QUEUE:
1848                 result = fdprintf(playlist->control_fd, "%c:%d:%d:",
1849                     (cache->command == PLAYLIST_COMMAND_ADD)?'A':'Q',
1850                     cache->i1, cache->i2);
1851                 if (result > 0)
1852                 {
1853                     /* save the position in file where name is written */
1854                     int* seek_pos = (int *)cache->data;
1855                     *seek_pos = lseek(playlist->control_fd, 0, SEEK_CUR);
1856                     result = fdprintf(playlist->control_fd, "%s\n",
1857                         cache->s1);
1858                 }
1859                 break;
1860             case PLAYLIST_COMMAND_DELETE:
1861                 result = fdprintf(playlist->control_fd, "D:%d\n", cache->i1);
1862                 break;
1863             case PLAYLIST_COMMAND_SHUFFLE:
1864                 result = fdprintf(playlist->control_fd, "S:%d:%d\n",
1865                     cache->i1, cache->i2);
1866                 break;
1867             case PLAYLIST_COMMAND_UNSHUFFLE:
1868                 result = fdprintf(playlist->control_fd, "U:%d\n", cache->i1);
1869                 break;
1870             case PLAYLIST_COMMAND_RESET:
1871                 result = fdprintf(playlist->control_fd, "R\n");
1872                 break;
1873             default:
1874                 break;
1875         }
1876
1877         if (result <= 0)
1878             break;
1879     }
1880
1881     if (result > 0)
1882     {
1883         playlist->num_cached = 0;
1884         playlist->pending_control_sync = true;
1885
1886         result = 0;
1887     }
1888     else
1889     {
1890         result = -1;
1891         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_UPDATE_ERROR));
1892     }
1893
1894     return result;
1895 }
1896
1897 /*
1898  * Update control data with new command.  Depending on the command, it may be
1899  * cached or flushed to disk.
1900  */
1901 static int update_control(struct playlist_info* playlist,
1902                           enum playlist_command command, int i1, int i2,
1903                           const char* s1, const char* s2, void* data)
1904 {
1905     int result = 0;
1906     struct playlist_control_cache* cache;
1907     bool flush = false;
1908
1909     mutex_lock(playlist->control_mutex);
1910
1911     cache = &(playlist->control_cache[playlist->num_cached++]);
1912
1913     cache->command = command;
1914     cache->i1 = i1;
1915     cache->i2 = i2;
1916     cache->s1 = s1;
1917     cache->s2 = s2;
1918     cache->data = data;
1919
1920     switch (command)
1921     {
1922         case PLAYLIST_COMMAND_PLAYLIST:
1923         case PLAYLIST_COMMAND_ADD:
1924         case PLAYLIST_COMMAND_QUEUE:
1925 #ifndef HAVE_DIRCACHE
1926         case PLAYLIST_COMMAND_DELETE:
1927         case PLAYLIST_COMMAND_RESET:
1928 #endif
1929             flush = true;
1930             break;
1931         case PLAYLIST_COMMAND_SHUFFLE:
1932         case PLAYLIST_COMMAND_UNSHUFFLE:
1933         default:
1934             /* only flush when needed */
1935             break;
1936     }
1937
1938     if (flush || playlist->num_cached == PLAYLIST_MAX_CACHE)
1939         result = flush_cached_control(playlist);
1940
1941     mutex_unlock(playlist->control_mutex);
1942
1943     return result;
1944 }
1945
1946 /*
1947  * sync control file to disk
1948  */
1949 static void sync_control(struct playlist_info* playlist, bool force)
1950 {
1951 #ifdef HAVE_DIRCACHE
1952     if (playlist->started && force)
1953 #else
1954     (void) force;
1955
1956     if (playlist->started)
1957 #endif
1958     {
1959         if (playlist->pending_control_sync)
1960         {
1961             mutex_lock(playlist->control_mutex);
1962             fsync(playlist->control_fd);
1963             playlist->pending_control_sync = false;
1964             mutex_unlock(playlist->control_mutex);
1965         }
1966     }
1967 }
1968
1969 /*
1970  * Rotate indices such that first_index is index 0
1971  */
1972 static int rotate_index(const struct playlist_info* playlist, int index)
1973 {
1974     index -= playlist->first_index;
1975     if (index < 0)
1976         index += playlist->amount;
1977
1978     return index;
1979 }
1980
1981 /*
1982  * Need no movement protection since all 3 allocations are not passed to
1983  * other functions which can yield().
1984  */
1985 static int move_callback(int handle, void* current, void* new)
1986 {
1987     (void)handle;
1988     struct playlist_info* playlist = &current_playlist;
1989     if (current == playlist->indices)
1990         playlist->indices = new;
1991     else if (current == playlist->filenames)
1992         playlist->filenames = new;
1993     /* buffer can possibly point to a new buffer temporarily (playlist_save()).
1994      * just don't overwrite the pointer to that temp buffer */
1995     else if (current == playlist->buffer)
1996         playlist->buffer = new;
1997
1998     return BUFLIB_CB_OK;
1999 }
2000
2001
2002 static struct buflib_callbacks ops = {
2003     .move_callback = move_callback,
2004     .shrink_callback = NULL,
2005 };
2006 /*
2007  * Initialize playlist entries at startup
2008  */
2009 void playlist_init(void)
2010 {
2011     int handle;
2012     struct playlist_info* playlist = &current_playlist;
2013
2014     mutex_init(&current_playlist_mutex);
2015     mutex_init(&created_playlist_mutex);
2016
2017     playlist->current = true;
2018     strlcpy(playlist->control_filename, PLAYLIST_CONTROL_FILE,
2019             sizeof(playlist->control_filename));
2020     playlist->fd = -1;
2021     playlist->control_fd = -1;
2022     playlist->max_playlist_size = global_settings.max_files_in_playlist;
2023     handle = core_alloc_ex("playlist idx",
2024                                 playlist->max_playlist_size * sizeof(int), &ops);
2025     playlist->indices = core_get_data(handle);
2026     playlist->buffer_size =
2027         AVERAGE_FILENAME_LENGTH * global_settings.max_files_in_dir;
2028     handle = core_alloc_ex("playlist buf",
2029                                 playlist->buffer_size, &ops);
2030     playlist->buffer = core_get_data(handle);
2031     playlist->buffer_handle = handle;
2032     playlist->control_mutex = &current_playlist_mutex;
2033
2034     empty_playlist(playlist, true);
2035
2036 #ifdef HAVE_DIRCACHE
2037     handle = core_alloc_ex("playlist dc",
2038         playlist->max_playlist_size * sizeof(int), &ops);
2039     playlist->filenames = core_get_data(handle);
2040     memset((void*)playlist->filenames, 0xff,
2041            playlist->max_playlist_size * sizeof(int));
2042     create_thread(playlist_thread, playlist_stack, sizeof(playlist_stack),
2043                   0, playlist_thread_name IF_PRIO(, PRIORITY_BACKGROUND)
2044                        IF_COP(, CPU));
2045     queue_init(&playlist_queue, true);
2046 #endif
2047 }
2048
2049 /*
2050  * Clean playlist at shutdown
2051  */
2052 void playlist_shutdown(void)
2053 {
2054     struct playlist_info* playlist = &current_playlist;
2055
2056     if (playlist->control_fd >= 0)
2057     {
2058         mutex_lock(playlist->control_mutex);
2059
2060         if (playlist->num_cached > 0)
2061             flush_cached_control(playlist);
2062
2063         close(playlist->control_fd);
2064         playlist->control_fd = -1;
2065
2066         mutex_unlock(playlist->control_mutex);
2067     }
2068 }
2069
2070 /*
2071  * Create new playlist
2072  */
2073 int playlist_create(const char *dir, const char *file)
2074 {
2075     struct playlist_info* playlist = &current_playlist;
2076
2077     new_playlist(playlist, dir, file);
2078
2079     if (file)
2080         /* load the playlist file */
2081         add_indices_to_playlist(playlist, NULL, 0);
2082
2083     return 0;
2084 }
2085
2086 #define PLAYLIST_COMMAND_SIZE (MAX_PATH+12)
2087
2088 /*
2089  * Restore the playlist state based on control file commands.  Called to
2090  * resume playback after shutdown.
2091  */
2092 int playlist_resume(void)
2093 {
2094     struct playlist_info* playlist = &current_playlist;
2095     char *buffer;
2096     size_t buflen;
2097     int nread;
2098     int total_read = 0;
2099     int control_file_size = 0;
2100     bool first = true;
2101     bool sorted = true;
2102
2103     /* use mp3 buffer for maximum load speed */
2104     buffer = (char *)audio_get_buffer(false, &buflen);
2105
2106     empty_playlist(playlist, true);
2107
2108     splash(0, ID2P(LANG_WAIT));
2109     playlist->control_fd = open(playlist->control_filename, O_RDWR);
2110     if (playlist->control_fd < 0)
2111     {
2112         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2113         return -1;
2114     }
2115     playlist->control_created = true;
2116
2117     control_file_size = filesize(playlist->control_fd);
2118     if (control_file_size <= 0)
2119     {
2120         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2121         return -1;
2122     }
2123
2124     /* read a small amount first to get the header */
2125     nread = read(playlist->control_fd, buffer,
2126         PLAYLIST_COMMAND_SIZE<buflen?PLAYLIST_COMMAND_SIZE:buflen);
2127     if(nread <= 0)
2128     {
2129         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2130         return -1;
2131     }
2132
2133     playlist->started = true;
2134
2135     while (1)
2136     {
2137         int result = 0;
2138         int count;
2139         enum playlist_command current_command = PLAYLIST_COMMAND_COMMENT;
2140         int last_newline = 0;
2141         int str_count = -1;
2142         bool newline = true;
2143         bool exit_loop = false;
2144         char *p = buffer;
2145         char *str1 = NULL;
2146         char *str2 = NULL;
2147         char *str3 = NULL;
2148         unsigned long last_tick = current_tick;
2149         bool useraborted = false;
2150
2151         for(count=0; count<nread && !exit_loop && !useraborted; count++,p++)
2152         {
2153             /* So a splash while we are loading. */
2154             if (TIME_AFTER(current_tick, last_tick + HZ/4))
2155             {
2156                 splashf(0, str(LANG_LOADING_PERCENT),
2157                            (total_read+count)*100/control_file_size,
2158                            str(LANG_OFF_ABORT));
2159                 if (action_userabort(TIMEOUT_NOBLOCK))
2160                 {
2161                     useraborted = true;
2162                     break;
2163                 }
2164                 last_tick = current_tick;
2165             }
2166
2167             /* Are we on a new line? */
2168             if((*p == '\n') || (*p == '\r'))
2169             {
2170                 *p = '\0';
2171
2172                 /* save last_newline in case we need to load more data */
2173                 last_newline = count;
2174
2175                 switch (current_command)
2176                 {
2177                     case PLAYLIST_COMMAND_PLAYLIST:
2178                     {
2179                         /* str1=version str2=dir str3=file */
2180                         int version;
2181
2182                         if (!str1)
2183                         {
2184                             result = -1;
2185                             exit_loop = true;
2186                             break;
2187                         }
2188
2189                         if (!str2)
2190                             str2 = "";
2191
2192                         if (!str3)
2193                             str3 = "";
2194
2195                         version = atoi(str1);
2196
2197                         if (version != PLAYLIST_CONTROL_FILE_VERSION)
2198                             return -1;
2199
2200                         update_playlist_filename(playlist, str2, str3);
2201
2202                         if (str3[0] != '\0')
2203                         {
2204                             /* NOTE: add_indices_to_playlist() overwrites the
2205                                audiobuf so we need to reload control file
2206                                data */
2207                             add_indices_to_playlist(playlist, NULL, 0);
2208                         }
2209                         else if (str2[0] != '\0')
2210                         {
2211                             playlist->in_ram = true;
2212                             resume_directory(str2);
2213                         }
2214
2215                         /* load the rest of the data */
2216                         first = false;
2217                         exit_loop = true;
2218
2219                         break;
2220                     }
2221                     case PLAYLIST_COMMAND_ADD:
2222                     case PLAYLIST_COMMAND_QUEUE:
2223                     {
2224                         /* str1=position str2=last_position str3=file */
2225                         int position, last_position;
2226                         bool queue;
2227
2228                         if (!str1 || !str2 || !str3)
2229                         {
2230                             result = -1;
2231                             exit_loop = true;
2232                             break;
2233                         }
2234
2235                         position = atoi(str1);
2236                         last_position = atoi(str2);
2237
2238                         queue = (current_command == PLAYLIST_COMMAND_ADD)?
2239                             false:true;
2240
2241                         /* seek position is based on str3's position in
2242                            buffer */
2243                         if (add_track_to_playlist(playlist, str3, position,
2244                                 queue, total_read+(str3-buffer)) < 0)
2245                         return -1;
2246
2247                         playlist->last_insert_pos = last_position;
2248
2249                         break;
2250                     }
2251                     case PLAYLIST_COMMAND_DELETE:
2252                     {
2253                         /* str1=position */
2254                         int position;
2255
2256                         if (!str1)
2257                         {
2258                             result = -1;
2259                             exit_loop = true;
2260                             break;
2261                         }
2262
2263                         position = atoi(str1);
2264
2265                         if (remove_track_from_playlist(playlist, position,
2266                                 false) < 0)
2267                             return -1;
2268
2269                         break;
2270                     }
2271                     case PLAYLIST_COMMAND_SHUFFLE:
2272                     {
2273                         /* str1=seed str2=first_index */
2274                         int seed;
2275
2276                         if (!str1 || !str2)
2277                         {
2278                             result = -1;
2279                             exit_loop = true;
2280                             break;
2281                         }
2282
2283                         if (!sorted)
2284                         {
2285                             /* Always sort list before shuffling */
2286                             sort_playlist(playlist, false, false);
2287                         }
2288
2289                         seed = atoi(str1);
2290                         playlist->first_index = atoi(str2);
2291
2292                         if (randomise_playlist(playlist, seed, false,
2293                                 false) < 0)
2294                             return -1;
2295                         sorted = false;
2296                         break;
2297                     }
2298                     case PLAYLIST_COMMAND_UNSHUFFLE:
2299                     {
2300                         /* str1=first_index */
2301                         if (!str1)
2302                         {
2303                             result = -1;
2304                             exit_loop = true;
2305                             break;
2306                         }
2307
2308                         playlist->first_index = atoi(str1);
2309
2310                         if (sort_playlist(playlist, false, false) < 0)
2311                             return -1;
2312
2313                         sorted = true;
2314                         break;
2315                     }
2316                     case PLAYLIST_COMMAND_RESET:
2317                     {
2318                         playlist->last_insert_pos = -1;
2319                         break;
2320                     }
2321                     case PLAYLIST_COMMAND_COMMENT:
2322                     default:
2323                         break;
2324                 }
2325
2326                 newline = true;
2327
2328                 /* to ignore any extra newlines */
2329                 current_command = PLAYLIST_COMMAND_COMMENT;
2330             }
2331             else if(newline)
2332             {
2333                 newline = false;
2334
2335                 /* first non-comment line must always specify playlist */
2336                 if (first && *p != 'P' && *p != '#')
2337                 {
2338                     result = -1;
2339                     exit_loop = true;
2340                     break;
2341                 }
2342
2343                 switch (*p)
2344                 {
2345                     case 'P':
2346                         /* playlist can only be specified once */
2347                         if (!first)
2348                         {
2349                             result = -1;
2350                             exit_loop = true;
2351                             break;
2352                         }
2353
2354                         current_command = PLAYLIST_COMMAND_PLAYLIST;
2355                         break;
2356                     case 'A':
2357                         current_command = PLAYLIST_COMMAND_ADD;
2358                         break;
2359                     case 'Q':
2360                         current_command = PLAYLIST_COMMAND_QUEUE;
2361                         break;
2362                     case 'D':
2363                         current_command = PLAYLIST_COMMAND_DELETE;
2364                         break;
2365                     case 'S':
2366                         current_command = PLAYLIST_COMMAND_SHUFFLE;
2367                         break;
2368                     case 'U':
2369                         current_command = PLAYLIST_COMMAND_UNSHUFFLE;
2370                         break;
2371                     case 'R':
2372                         current_command = PLAYLIST_COMMAND_RESET;
2373                         break;
2374                     case '#':
2375                         current_command = PLAYLIST_COMMAND_COMMENT;
2376                         break;
2377                     default:
2378                         result = -1;
2379                         exit_loop = true;
2380                         break;
2381                 }
2382
2383                 str_count = -1;
2384                 str1 = NULL;
2385                 str2 = NULL;
2386                 str3 = NULL;
2387             }
2388             else if(current_command != PLAYLIST_COMMAND_COMMENT)
2389             {
2390                 /* all control file strings are separated with a colon.
2391                    Replace the colon with 0 to get proper strings that can be
2392                    used by commands above */
2393                 if (*p == ':')
2394                 {
2395                     *p = '\0';
2396                     str_count++;
2397
2398                     if ((count+1) < nread)
2399                     {
2400                         switch (str_count)
2401                         {
2402                         case 0:
2403                             str1 = p+1;
2404                             break;
2405                         case 1:
2406                             str2 = p+1;
2407                             break;
2408                         case 2:
2409                             str3 = p+1;
2410                             break;
2411                         default:
2412                             /* allow last string to contain colons */
2413                             *p = ':';
2414                             break;
2415                         }
2416                     }
2417                 }
2418             }
2419         }
2420
2421         if (result < 0)
2422         {
2423             splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID));
2424             return result;
2425         }
2426
2427         if (useraborted)
2428         {
2429             splash(HZ*2, ID2P(LANG_CANCEL));
2430             return -1;
2431         }
2432         if (!newline || (exit_loop && count<nread))
2433         {
2434             if ((total_read + count) >= control_file_size)
2435             {
2436                 /* no newline at end of control file */
2437                 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID));
2438                 return -1;
2439             }
2440
2441             /* We didn't end on a newline or we exited loop prematurely.
2442                Either way, re-read the remainder. */
2443             count = last_newline;
2444             lseek(playlist->control_fd, total_read+count, SEEK_SET);
2445         }
2446
2447         total_read += count;
2448
2449         if (first)
2450             /* still looking for header */
2451             nread = read(playlist->control_fd, buffer,
2452                 PLAYLIST_COMMAND_SIZE<buflen?PLAYLIST_COMMAND_SIZE:buflen);
2453         else
2454             nread = read(playlist->control_fd, buffer, buflen);
2455
2456         /* Terminate on EOF */
2457         if(nread <= 0)
2458         {
2459             break;
2460         }
2461     }
2462
2463 #ifdef HAVE_DIRCACHE
2464     queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
2465 #endif
2466
2467     return 0;
2468 }
2469
2470 /*
2471  * Add track to in_ram playlist.  Used when playing directories.
2472  */
2473 int playlist_add(const char *filename)
2474 {
2475     struct playlist_info* playlist = &current_playlist;
2476     int len = strlen(filename);
2477
2478     if((len+1 > playlist->buffer_size - playlist->buffer_end_pos) ||
2479        (playlist->amount >= playlist->max_playlist_size))
2480     {
2481         display_buffer_full();
2482         return -1;
2483     }
2484
2485     playlist->indices[playlist->amount] = playlist->buffer_end_pos;
2486 #ifdef HAVE_DIRCACHE
2487     playlist->filenames[playlist->amount] = -1;
2488 #endif
2489     playlist->amount++;
2490
2491     strcpy((char*)&playlist->buffer[playlist->buffer_end_pos], filename);
2492     playlist->buffer_end_pos += len;
2493     playlist->buffer[playlist->buffer_end_pos++] = '\0';
2494
2495     return 0;
2496 }
2497
2498 /* shuffle newly created playlist using random seed. */
2499 int playlist_shuffle(int random_seed, int start_index)
2500 {
2501     struct playlist_info* playlist = &current_playlist;
2502
2503     bool start_current = false;
2504
2505     if (start_index >= 0 && global_settings.play_selected)
2506     {
2507         /* store the seek position before the shuffle */
2508         playlist->index = playlist->first_index = start_index;
2509         start_current = true;
2510     }
2511
2512     randomise_playlist(playlist, random_seed, start_current, true);
2513
2514     return playlist->index;
2515 }
2516
2517 /* start playing current playlist at specified index/offset */
2518 void playlist_start(int start_index, int offset)
2519 {
2520     struct playlist_info* playlist = &current_playlist;
2521
2522     /* Cancel FM radio selection as previous music. For cases where we start
2523        playback without going to the WPS, such as playlist insert.. or
2524        playlist catalog. */
2525     previous_music_is_wps();
2526
2527     playlist->index = start_index;
2528
2529     playlist->started = true;
2530     sync_control(playlist, false);
2531     audio_play(offset);
2532 }
2533
2534 /* Returns false if 'steps' is out of bounds, else true */
2535 bool playlist_check(int steps)
2536 {
2537     struct playlist_info* playlist = &current_playlist;
2538
2539     /* always allow folder navigation */
2540     if (global_settings.next_folder && playlist->in_ram)
2541         return true;
2542
2543     int index = get_next_index(playlist, steps, -1);
2544
2545     if (index < 0 && steps >= 0 && global_settings.repeat_mode == REPEAT_SHUFFLE)
2546         index = get_next_index(playlist, steps, REPEAT_ALL);
2547
2548     return (index >= 0);
2549 }
2550
2551 /* get trackname of track that is "steps" away from current playing track.
2552    NULL is used to identify end of playlist */
2553 const char* playlist_peek(int steps, char* buf, size_t buf_size)
2554 {
2555     struct playlist_info* playlist = &current_playlist;
2556     int seek;
2557     char *temp_ptr;
2558     int index;
2559     bool control_file;
2560
2561     index = get_next_index(playlist, steps, -1);
2562     if (index < 0)
2563         return NULL;
2564
2565 #if CONFIG_CODEC == SWCODEC
2566     /* Just testing - don't care about the file name */
2567     if (!buf || !buf_size)
2568         return "";
2569 #endif
2570
2571     control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
2572     seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
2573
2574     if (get_filename(playlist, index, seek, control_file, buf,
2575         buf_size) < 0)
2576         return NULL;
2577
2578     temp_ptr = buf;
2579
2580     if (!playlist->in_ram || control_file)
2581     {
2582         /* remove bogus dirs from beginning of path
2583            (workaround for buggy playlist creation tools) */
2584         while (temp_ptr)
2585         {
2586             if (file_exists(temp_ptr))
2587                 break;
2588
2589             temp_ptr = strchr(temp_ptr+1, '/');
2590         }
2591
2592         if (!temp_ptr)
2593         {
2594             /* Even though this is an invalid file, we still need to pass a
2595                file name to the caller because NULL is used to indicate end
2596                of playlist */
2597             return buf;
2598         }
2599     }
2600
2601     return temp_ptr;
2602 }
2603
2604 /*
2605  * Update indices as track has changed
2606  */
2607 int playlist_next(int steps)
2608 {
2609     struct playlist_info* playlist = &current_playlist;
2610     int index;
2611
2612     if ( (steps > 0)
2613 #ifdef AB_REPEAT_ENABLE
2614     && (global_settings.repeat_mode != REPEAT_AB)
2615 #endif
2616     && (global_settings.repeat_mode != REPEAT_ONE) )
2617     {
2618         int i, j;
2619
2620         /* We need to delete all the queued songs */
2621         for (i=0, j=steps; i<j; i++)
2622         {
2623             index = get_next_index(playlist, i, -1);
2624
2625             if (playlist->indices[index] & PLAYLIST_QUEUE_MASK)
2626             {
2627                 remove_track_from_playlist(playlist, index, true);
2628                 steps--; /* one less track */
2629             }
2630         }
2631     }
2632
2633     index = get_next_index(playlist, steps, -1);
2634
2635     if (index < 0)
2636     {
2637         /* end of playlist... or is it */
2638         if (global_settings.repeat_mode == REPEAT_SHUFFLE &&
2639             playlist->amount > 1)
2640         {
2641             /* Repeat shuffle mode.  Re-shuffle playlist and resume play */
2642             playlist->first_index = 0;
2643             sort_playlist(playlist, false, false);
2644             randomise_playlist(playlist, current_tick, false, true);
2645
2646 #if CONFIG_CODEC == SWCODEC
2647             playlist->started = true;
2648 #else
2649             playlist_start(0, 0);
2650 #endif
2651             playlist->index = 0;
2652             index = 0;
2653         }
2654         else if (playlist->in_ram && global_settings.next_folder)
2655         {
2656             index = create_and_play_dir(steps, true);
2657
2658             if (index >= 0)
2659             {
2660                 playlist->index = index;
2661             }
2662         }
2663
2664         return index;
2665     }
2666
2667     playlist->index = index;
2668
2669     if (playlist->last_insert_pos >= 0 && steps > 0)
2670     {
2671         /* check to see if we've gone beyond the last inserted track */
2672         int cur = rotate_index(playlist, index);
2673         int last_pos = rotate_index(playlist, playlist->last_insert_pos);
2674
2675         if (cur > last_pos)
2676         {
2677             /* reset last inserted track */
2678             playlist->last_insert_pos = -1;
2679
2680             if (playlist->control_fd >= 0)
2681             {
2682                 int result = update_control(playlist, PLAYLIST_COMMAND_RESET,
2683                     -1, -1, NULL, NULL, NULL);
2684
2685                 if (result < 0)
2686                     return result;
2687
2688                 sync_control(playlist, false);
2689             }
2690         }
2691     }
2692
2693     return index;
2694 }
2695
2696 #if CONFIG_CODEC == SWCODEC
2697 /* try playing next or previous folder */
2698 bool playlist_next_dir(int direction)
2699 {
2700     /* not to mess up real playlists */
2701     if(!current_playlist.in_ram)
2702        return false;
2703
2704     return create_and_play_dir(direction, false) >= 0;
2705 }
2706 #endif /* CONFIG_CODEC == SWCODEC */
2707
2708 /* Get resume info for current playing song.  If return value is -1 then
2709    settings shouldn't be saved. */
2710 int playlist_get_resume_info(int *resume_index)
2711 {
2712     struct playlist_info* playlist = &current_playlist;
2713
2714     *resume_index = playlist->index;
2715
2716     return 0;
2717 }
2718
2719 /* Update resume info for current playing song.  Returns -1 on error. */
2720 int playlist_update_resume_info(const struct mp3entry* id3)
2721 {
2722     struct playlist_info* playlist = &current_playlist;
2723
2724     if (id3)
2725     {
2726         if (global_status.resume_index  != playlist->index ||
2727             global_status.resume_offset != id3->offset)
2728         {
2729             global_status.resume_index  = playlist->index;
2730             global_status.resume_offset = id3->offset;
2731             status_save();
2732         }
2733     }
2734     else
2735     {
2736         global_status.resume_index  = -1;
2737         global_status.resume_offset = -1;
2738         status_save();
2739     }
2740
2741     return 0;
2742 }
2743
2744 /* Returns index of current playing track for display purposes.  This value
2745    should not be used for resume purposes as it doesn't represent the actual
2746    index into the playlist */
2747 int playlist_get_display_index(void)
2748 {
2749     struct playlist_info* playlist = &current_playlist;
2750
2751     /* first_index should always be index 0 for display purposes */
2752     int index = rotate_index(playlist, playlist->index);
2753
2754     return (index+1);
2755 }
2756
2757 /* returns number of tracks in current playlist */
2758 int playlist_amount(void)
2759 {
2760     return playlist_amount_ex(NULL);
2761 }
2762 /* set playlist->last_shuffle_start to playlist->amount for
2763    PLAYLIST_INSERT_LAST_SHUFFLED command purposes*/
2764 void playlist_set_last_shuffled_start(void)
2765 {
2766     struct playlist_info* playlist = &current_playlist;
2767     playlist->last_shuffled_start = playlist->amount;
2768 }
2769 /*
2770  * Create a new playlist  If playlist is not NULL then we're loading a
2771  * playlist off disk for viewing/editing.  The index_buffer is used to store
2772  * playlist indices (required for and only used if !current playlist).  The
2773  * temp_buffer (if not NULL) is used as a scratchpad when loading indices.
2774  */
2775 int playlist_create_ex(struct playlist_info* playlist,
2776                        const char* dir, const char* file,
2777                        void* index_buffer, int index_buffer_size,
2778                        void* temp_buffer, int temp_buffer_size)
2779 {
2780     if (!playlist)
2781         playlist = &current_playlist;
2782     else
2783     {
2784         /* Initialize playlist structure */
2785         int r = rand() % 10;
2786         playlist->current = false;
2787
2788         /* Use random name for control file */
2789         snprintf(playlist->control_filename, sizeof(playlist->control_filename),
2790             "%s.%d", PLAYLIST_CONTROL_FILE, r);
2791         playlist->fd = -1;
2792         playlist->control_fd = -1;
2793
2794         if (index_buffer)
2795         {
2796             int num_indices = index_buffer_size / sizeof(int);
2797
2798 #ifdef HAVE_DIRCACHE
2799             num_indices /= 2;
2800 #endif
2801             if (num_indices > global_settings.max_files_in_playlist)
2802                 num_indices = global_settings.max_files_in_playlist;
2803
2804             playlist->max_playlist_size = num_indices;
2805             playlist->indices = index_buffer;
2806 #ifdef HAVE_DIRCACHE
2807             playlist->filenames = (int*)&playlist->indices[num_indices];
2808 #endif
2809         }
2810         else
2811         {
2812             playlist->max_playlist_size = current_playlist.max_playlist_size;
2813             playlist->indices = current_playlist.indices;
2814 #ifdef HAVE_DIRCACHE
2815             playlist->filenames = current_playlist.filenames;
2816 #endif
2817         }
2818
2819         playlist->buffer_size = 0;
2820         playlist->buffer_handle = -1;
2821         playlist->buffer = NULL;
2822         playlist->control_mutex = &created_playlist_mutex;
2823     }
2824
2825     new_playlist(playlist, dir, file);
2826
2827     if (file)
2828         /* load the playlist file */
2829         add_indices_to_playlist(playlist, temp_buffer, temp_buffer_size);
2830
2831     return 0;
2832 }
2833
2834 /*
2835  * Set the specified playlist as the current.
2836  * NOTE: You will get undefined behaviour if something is already playing so
2837  *       remember to stop before calling this.  Also, this call will
2838  *       effectively close your playlist, making it unusable.
2839  */
2840 int playlist_set_current(struct playlist_info* playlist)
2841 {
2842     if (!playlist || (check_control(playlist) < 0))
2843         return -1;
2844
2845     empty_playlist(&current_playlist, false);
2846
2847     strlcpy(current_playlist.filename, playlist->filename,
2848         sizeof(current_playlist.filename));
2849
2850     current_playlist.utf8 = playlist->utf8;
2851     current_playlist.fd = playlist->fd;
2852
2853     close(playlist->control_fd);
2854     playlist->control_fd = -1;
2855     close(current_playlist.control_fd);
2856     current_playlist.control_fd = -1;
2857     remove(current_playlist.control_filename);
2858     current_playlist.control_created = false;
2859     if (rename(playlist->control_filename,
2860             current_playlist.control_filename) < 0)
2861         return -1;
2862     current_playlist.control_fd = open(current_playlist.control_filename,
2863         O_RDWR);
2864     if (current_playlist.control_fd < 0)
2865         return -1;
2866     current_playlist.control_created = true;
2867
2868     current_playlist.dirlen = playlist->dirlen;
2869
2870     if (playlist->indices && playlist->indices != current_playlist.indices)
2871     {
2872         memcpy((void*)current_playlist.indices, (void*)playlist->indices,
2873                playlist->max_playlist_size*sizeof(int));
2874 #ifdef HAVE_DIRCACHE
2875         memcpy((void*)current_playlist.filenames, (void*)playlist->filenames,
2876                playlist->max_playlist_size*sizeof(int));
2877 #endif
2878     }
2879
2880     current_playlist.first_index = playlist->first_index;
2881     current_playlist.amount = playlist->amount;
2882     current_playlist.last_insert_pos = playlist->last_insert_pos;
2883     current_playlist.seed = playlist->seed;
2884     current_playlist.shuffle_modified = playlist->shuffle_modified;
2885     current_playlist.deleted = playlist->deleted;
2886     current_playlist.num_inserted_tracks = playlist->num_inserted_tracks;
2887
2888     memcpy(current_playlist.control_cache, playlist->control_cache,
2889         sizeof(current_playlist.control_cache));
2890     current_playlist.num_cached = playlist->num_cached;
2891     current_playlist.pending_control_sync = playlist->pending_control_sync;
2892
2893     return 0;
2894 }
2895 struct playlist_info *playlist_get_current(void)
2896 {
2897     return &current_playlist;
2898 }
2899 /*
2900  * Close files and delete control file for non-current playlist.
2901  */
2902 void playlist_close(struct playlist_info* playlist)
2903 {
2904     if (!playlist)
2905         return;
2906
2907     if (playlist->fd >= 0) {
2908         close(playlist->fd);
2909         playlist->fd = -1;
2910     }
2911
2912     if (playlist->control_fd >= 0) {
2913         close(playlist->control_fd);
2914         playlist->control_fd = -1;
2915     }
2916
2917     if (playlist->control_created) {
2918         remove(playlist->control_filename);
2919         playlist->control_created = false;
2920     }
2921 }
2922
2923 void playlist_sync(struct playlist_info* playlist)
2924 {
2925     if (!playlist)
2926         playlist = &current_playlist;
2927
2928     sync_control(playlist, false);
2929     if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
2930         audio_flush_and_reload_tracks();
2931
2932 #ifdef HAVE_DIRCACHE
2933     queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
2934 #endif
2935 }
2936
2937 /*
2938  * Insert track into playlist at specified position (or one of the special
2939  * positions).  Returns position where track was inserted or -1 if error.
2940  */
2941 int playlist_insert_track(struct playlist_info* playlist, const char *filename,
2942                           int position, bool queue, bool sync)
2943 {
2944     int result;
2945
2946     if (!playlist)
2947         playlist = &current_playlist;
2948
2949     if (check_control(playlist) < 0)
2950     {
2951         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2952         return -1;
2953     }
2954
2955     result = add_track_to_playlist(playlist, filename, position, queue, -1);
2956
2957     /* Check if we want manually sync later. For example when adding
2958      * bunch of files from tagcache, syncing after every file wouldn't be
2959      * a good thing to do. */
2960     if (sync && result >= 0)
2961         playlist_sync(playlist);
2962
2963     return result;
2964 }
2965
2966 /*
2967  * Insert all tracks from specified directory into playlist.
2968  */
2969 int playlist_insert_directory(struct playlist_info* playlist,
2970                               const char *dirname, int position, bool queue,
2971                               bool recurse)
2972 {
2973     int result;
2974     unsigned char *count_str;
2975     struct directory_search_context context;
2976
2977     if (!playlist)
2978         playlist = &current_playlist;
2979
2980     if (check_control(playlist) < 0)
2981     {
2982         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2983         return -1;
2984     }
2985
2986     if (position == PLAYLIST_REPLACE)
2987     {
2988         if (playlist_remove_all_tracks(playlist) == 0)
2989             position = PLAYLIST_INSERT_LAST;
2990         else
2991             return -1;
2992     }
2993
2994     if (queue)
2995         count_str = ID2P(LANG_PLAYLIST_QUEUE_COUNT);
2996     else
2997         count_str = ID2P(LANG_PLAYLIST_INSERT_COUNT);
2998
2999     display_playlist_count(0, count_str, false);
3000
3001     context.playlist = playlist;
3002     context.position = position;
3003     context.queue = queue;
3004     context.count = 0;
3005
3006     cpu_boost(true);
3007
3008     result = playlist_directory_tracksearch(dirname, recurse,
3009         directory_search_callback, &context);
3010
3011     sync_control(playlist, false);
3012
3013     cpu_boost(false);
3014
3015     display_playlist_count(context.count, count_str, true);
3016
3017     if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
3018         audio_flush_and_reload_tracks();
3019
3020 #ifdef HAVE_DIRCACHE
3021     queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
3022 #endif
3023
3024     return result;
3025 }
3026
3027 /*
3028  * Insert all tracks from specified playlist into dynamic playlist.
3029  */
3030 int playlist_insert_playlist(struct playlist_info* playlist, const char *filename,
3031                              int position, bool queue)
3032 {
3033     int fd;
3034     int max;
3035     char *temp_ptr;
3036     const char *dir;
3037     unsigned char *count_str;
3038     char temp_buf[MAX_PATH+1];
3039     char trackname[MAX_PATH+1];
3040     int count = 0;
3041     int result = 0;
3042     bool utf8 = is_m3u8(filename);
3043
3044     if (!playlist)
3045         playlist = &current_playlist;
3046
3047     if (check_control(playlist) < 0)
3048     {
3049         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
3050         return -1;
3051     }
3052
3053     fd = open_utf8(filename, O_RDONLY);
3054     if (fd < 0)
3055     {
3056         splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
3057         return -1;
3058     }
3059
3060     /* we need the directory name for formatting purposes */
3061     dir = filename;
3062
3063     temp_ptr = strrchr(filename+1,'/');
3064     if (temp_ptr)
3065         *temp_ptr = 0;
3066     else
3067         dir = "/";
3068
3069     if (queue)
3070         count_str = ID2P(LANG_PLAYLIST_QUEUE_COUNT);
3071     else
3072         count_str = ID2P(LANG_PLAYLIST_INSERT_COUNT);
3073
3074     display_playlist_count(count, count_str, false);
3075
3076     if (position == PLAYLIST_REPLACE)
3077     {
3078         if (playlist_remove_all_tracks(playlist) == 0)
3079             position = PLAYLIST_INSERT_LAST;
3080         else return -1;
3081     }
3082
3083     cpu_boost(true);
3084
3085     while ((max = read_line(fd, temp_buf, sizeof(temp_buf))) > 0)
3086     {
3087         /* user abort */
3088         if (action_userabort(TIMEOUT_NOBLOCK))
3089             break;
3090
3091         if (temp_buf[0] != '#' && temp_buf[0] != '\0')
3092         {
3093             int insert_pos;
3094
3095             if (!utf8)
3096             {
3097                 /* Use trackname as a temporay buffer. Note that trackname must
3098                  * be as large as temp_buf.
3099                  */
3100                 max = convert_m3u(temp_buf, max, sizeof(temp_buf), trackname);
3101             }
3102
3103             /* we need to format so that relative paths are correctly
3104                handled */
3105             if (format_track_path(trackname, temp_buf, sizeof(trackname), max,
3106                     dir) < 0)
3107             {
3108                 result = -1;
3109                 break;
3110             }
3111
3112             insert_pos = add_track_to_playlist(playlist, trackname, position,
3113                 queue, -1);
3114
3115             if (insert_pos < 0)
3116             {
3117                 result = -1;
3118                 break;
3119             }
3120
3121             /* Make sure tracks are inserted in correct order if user
3122                requests INSERT_FIRST */
3123             if (position == PLAYLIST_INSERT_FIRST || position >= 0)
3124                 position = insert_pos + 1;
3125
3126             count++;
3127
3128             if ((count%PLAYLIST_DISPLAY_COUNT) == 0)
3129             {
3130                 display_playlist_count(count, count_str, false);
3131
3132                 if (count == PLAYLIST_DISPLAY_COUNT &&
3133                     (audio_status() & AUDIO_STATUS_PLAY) &&
3134                     playlist->started)
3135                     audio_flush_and_reload_tracks();
3136             }
3137         }
3138
3139         /* let the other threads work */
3140         yield();
3141     }
3142
3143     close(fd);
3144
3145     if (temp_ptr)
3146         *temp_ptr = '/';
3147
3148     sync_control(playlist, false);
3149
3150     cpu_boost(false);
3151
3152     display_playlist_count(count, count_str, true);
3153
3154     if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
3155         audio_flush_and_reload_tracks();
3156
3157 #ifdef HAVE_DIRCACHE
3158     queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
3159 #endif
3160
3161     return result;
3162 }
3163
3164 /*
3165  * Delete track at specified index.  If index is PLAYLIST_DELETE_CURRENT then
3166  * we want to delete the current playing track.
3167  */
3168 int playlist_delete(struct playlist_info* playlist, int index)
3169 {
3170     int result = 0;
3171
3172     if (!playlist)
3173         playlist = &current_playlist;
3174
3175     if (check_control(playlist) < 0)
3176     {
3177         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
3178         return -1;
3179     }
3180
3181     if (index == PLAYLIST_DELETE_CURRENT)
3182         index = playlist->index;
3183
3184     result = remove_track_from_playlist(playlist, index, true);
3185
3186     if (result != -1 && (audio_status() & AUDIO_STATUS_PLAY) &&
3187         playlist->started)
3188         audio_flush_and_reload_tracks();
3189
3190     return result;
3191 }
3192
3193 /*
3194  * Move track at index to new_index.  Tracks between the two are shifted
3195  * appropriately.  Returns 0 on success and -1 on failure.
3196  */
3197 int playlist_move(struct playlist_info* playlist, int index, int new_index)
3198 {
3199     int result;
3200     int seek;
3201     bool control_file;
3202     bool queue;
3203     bool current = false;
3204     int r;
3205     char filename[MAX_PATH];
3206
3207     if (!playlist)
3208         playlist = &current_playlist;
3209
3210     if (check_control(playlist) < 0)
3211     {
3212         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
3213         return -1;
3214     }
3215
3216     if (index == new_index)
3217         return -1;
3218
3219     if (index == playlist->index)
3220         /* Moving the current track */
3221         current = true;
3222
3223     control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
3224     queue = playlist->indices[index] & PLAYLIST_QUEUE_MASK;
3225     seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
3226
3227     if (get_filename(playlist, index, seek, control_file, filename,
3228             sizeof(filename)) < 0)
3229         return -1;
3230
3231     /* We want to insert the track at the position that was specified by
3232        new_index.  This may be different then new_index because of the
3233        shifting that will occur after the delete.
3234        We calculate this before we do the remove as it depends on the
3235        size of the playlist before the track removal */
3236     r = rotate_index(playlist, new_index);
3237
3238     /* Delete track from original position */
3239     result = remove_track_from_playlist(playlist, index, true);
3240
3241     if (result != -1)
3242     {
3243         if (r == 0)
3244             /* First index */
3245             new_index = PLAYLIST_PREPEND;
3246         else if (r == playlist->amount)
3247             /* Append */
3248             new_index = PLAYLIST_INSERT_LAST;
3249         else
3250             /* Calculate index of desired position */
3251             new_index = (r+playlist->first_index)%playlist->amount;
3252
3253         result = add_track_to_playlist(playlist, filename, new_index, queue,
3254             -1);
3255
3256         if (result != -1)
3257         {
3258             if (current)
3259             {
3260                 /* Moved the current track */
3261                 switch (new_index)
3262                 {
3263                     case PLAYLIST_PREPEND:
3264                         playlist->index = playlist->first_index;
3265                         break;
3266                     case PLAYLIST_INSERT_LAST:
3267                         playlist->index = playlist->first_index - 1;
3268                         if (playlist->index < 0)
3269                             playlist->index += playlist->amount;
3270                         break;
3271                     default:
3272                         playlist->index = new_index;
3273                         break;
3274                 }
3275             }
3276
3277             if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
3278                 audio_flush_and_reload_tracks();
3279         }
3280     }
3281
3282 #ifdef HAVE_DIRCACHE
3283     queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
3284 #endif
3285
3286     return result;
3287 }
3288
3289 /* shuffle currently playing playlist */
3290 int playlist_randomise(struct playlist_info* playlist, unsigned int seed,
3291                        bool start_current)
3292 {
3293     int result;
3294
3295     if (!playlist)
3296         playlist = &current_playlist;
3297
3298     check_control(playlist);
3299
3300     result = randomise_playlist(playlist, seed, start_current, true);
3301
3302     if (result != -1 && (audio_status() & AUDIO_STATUS_PLAY) &&
3303         playlist->started)
3304         audio_flush_and_reload_tracks();
3305
3306     return result;
3307 }
3308
3309 /* sort currently playing playlist */
3310 int playlist_sort(struct playlist_info* playlist, bool start_current)
3311 {
3312     int result;
3313
3314     if (!playlist)
3315         playlist = &current_playlist;
3316
3317     check_control(playlist);
3318
3319     result = sort_playlist(playlist, start_current, true);
3320
3321     if (result != -1 && (audio_status() & AUDIO_STATUS_PLAY) &&
3322         playlist->started)
3323         audio_flush_and_reload_tracks();
3324
3325     return result;
3326 }
3327
3328 /* returns true if playlist has been modified */
3329 bool playlist_modified(const struct playlist_info* playlist)
3330 {
3331     if (!playlist)
3332         playlist = &current_playlist;
3333
3334     if (playlist->shuffle_modified ||
3335         playlist->deleted ||
3336         playlist->num_inserted_tracks > 0)
3337         return true;
3338
3339     return false;
3340 }
3341
3342 /* returns index of first track in playlist */
3343 int playlist_get_first_index(const struct playlist_info* playlist)
3344 {
3345     if (!playlist)
3346         playlist = &current_playlist;
3347
3348     return playlist->first_index;
3349 }
3350
3351 /* returns shuffle seed of playlist */
3352 int playlist_get_seed(const struct playlist_info* playlist)
3353 {
3354     if (!playlist)
3355         playlist = &current_playlist;
3356
3357     return playlist->seed;
3358 }
3359
3360 /* returns number of tracks in playlist (includes queued/inserted tracks) */
3361 int playlist_amount_ex(const struct playlist_info* playlist)
3362 {
3363     if (!playlist)
3364         playlist = &current_playlist;
3365
3366     return playlist->amount;
3367 }
3368
3369 /* returns full path of playlist (minus extension) */
3370 char *playlist_name(const struct playlist_info* playlist, char *buf,
3371                     int buf_size)
3372 {
3373     char *sep;
3374
3375     if (!playlist)
3376         playlist = &current_playlist;
3377
3378     strlcpy(buf, playlist->filename+playlist->dirlen, buf_size);
3379
3380     if (!buf[0])
3381         return NULL;
3382
3383     /* Remove extension */
3384     sep = strrchr(buf, '.');
3385     if (sep)
3386         *sep = 0;
3387
3388     return buf;
3389 }
3390
3391 /* returns the playlist filename */
3392 char *playlist_get_name(const struct playlist_info* playlist, char *buf,
3393                         int buf_size)
3394 {
3395     if (!playlist)
3396         playlist = &current_playlist;
3397
3398     strlcpy(buf, playlist->filename, buf_size);
3399
3400     if (!buf[0])
3401         return NULL;
3402
3403     return buf;
3404 }
3405
3406 /* Fills info structure with information about track at specified index.
3407    Returns 0 on success and -1 on failure */
3408 int playlist_get_track_info(struct playlist_info* playlist, int index,
3409                             struct playlist_track_info* info)
3410 {
3411     int seek;
3412     bool control_file;
3413
3414     if (!playlist)
3415         playlist = &current_playlist;
3416
3417     if (index < 0 || index >= playlist->amount)
3418         return -1;
3419
3420     control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
3421     seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
3422
3423     if (get_filename(playlist, index, seek, control_file, info->filename,
3424             sizeof(info->filename)) < 0)
3425         return -1;
3426
3427     info->attr = 0;
3428
3429     if (control_file)
3430     {
3431         if (playlist->indices[index] & PLAYLIST_QUEUE_MASK)
3432             info->attr |= PLAYLIST_ATTR_QUEUED;
3433         else
3434             info->attr |= PLAYLIST_ATTR_INSERTED;
3435
3436     }
3437
3438     if (playlist->indices[index] & PLAYLIST_SKIPPED)
3439         info->attr |= PLAYLIST_ATTR_SKIPPED;
3440
3441     info->index = index;
3442     info->display_index = rotate_index(playlist, index) + 1;
3443
3444     return 0;
3445 }
3446
3447 /* save the current dynamic playlist to specified file */
3448 int playlist_save(struct playlist_info* playlist, char *filename)
3449 {
3450     int fd;
3451     int i, index;
3452     int count = 0;
3453     char path[MAX_PATH+1];
3454     char tmp_buf[MAX_PATH+1];
3455     int result = 0;
3456     bool overwrite_current = false;
3457
3458     if (!playlist)
3459         playlist = &current_playlist;
3460
3461     if (playlist->amount <= 0)
3462         return -1;
3463
3464     /* use current working directory as base for pathname */
3465     if (format_track_path(path, filename, sizeof(tmp_buf),
3466                           strlen(filename)+1, "/") < 0)
3467         return -1;
3468
3469     /* can ignore volatile here, because core_get_data() is called later */
3470     char* old_buffer = (char*)playlist->buffer;
3471     size_t old_buffer_size = playlist->buffer_size;
3472
3473     if (!strncmp(playlist->filename, path, strlen(path)))
3474     {
3475         /* Attempting to overwrite current playlist file.*/
3476
3477         if (playlist->buffer_size < (int)(playlist->amount * sizeof(int)))
3478         {
3479             /* not enough buffer space to store updated indices */
3480             /* Try to get a buffer */
3481             playlist->buffer = plugin_get_buffer((size_t*)&playlist->buffer_size);
3482             if (playlist->buffer_size < (int)(playlist->amount * sizeof(int)))
3483             {
3484                 splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
3485                 result = -1;
3486                 goto reset_old_buffer;
3487             }
3488         }
3489
3490         /* use temporary pathname */
3491         snprintf(path, sizeof(path), "%s_temp", playlist->filename);
3492         overwrite_current = true;
3493     }
3494
3495     if (is_m3u8(path))
3496     {
3497         fd = open_utf8(path, O_CREAT|O_WRONLY|O_TRUNC);
3498     }
3499     else
3500     {
3501         /* some applications require a BOM to read the file properly */
3502         fd = open(path, O_CREAT|O_WRONLY|O_TRUNC, 0666);
3503     }
3504     if (fd < 0)
3505     {
3506         splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
3507         result = -1;
3508         goto reset_old_buffer;
3509     }
3510
3511     display_playlist_count(count, ID2P(LANG_PLAYLIST_SAVE_COUNT), false);
3512
3513     cpu_boost(true);
3514
3515     index = playlist->first_index;
3516     for (i=0; i<playlist->amount; i++)
3517     {
3518         bool control_file;
3519         bool queue;
3520         int seek;
3521
3522         /* user abort */
3523         if (action_userabort(TIMEOUT_NOBLOCK))
3524         {
3525             result = -1;
3526             break;
3527         }
3528
3529         control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
3530         queue = playlist->indices[index] & PLAYLIST_QUEUE_MASK;
3531         seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
3532
3533         /* Don't save queued files */
3534         if (!queue)
3535         {
3536             if (get_filename(playlist, index, seek, control_file, tmp_buf,
3537                     MAX_PATH+1) < 0)
3538             {
3539                 result = -1;
3540                 break;
3541             }
3542
3543             if (overwrite_current)
3544                 playlist->seek_buf[count] = lseek(fd, 0, SEEK_CUR);
3545
3546             if (fdprintf(fd, "%s\n", tmp_buf) < 0)
3547             {
3548                 splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
3549                 result = -1;
3550                 break;
3551             }
3552
3553             count++;
3554
3555             if ((count % PLAYLIST_DISPLAY_COUNT) == 0)
3556                 display_playlist_count(count, ID2P(LANG_PLAYLIST_SAVE_COUNT),
3557                                        false);
3558
3559             yield();
3560         }
3561
3562         index = (index+1)%playlist->amount;
3563     }
3564
3565     display_playlist_count(count, ID2P(LANG_PLAYLIST_SAVE_COUNT), true);
3566
3567     close(fd);
3568
3569     if (overwrite_current && result >= 0)
3570     {
3571         result = -1;
3572
3573         mutex_lock(playlist->control_mutex);
3574
3575         /* Replace the current playlist with the new one and update indices */
3576         close(playlist->fd);
3577         playlist->fd = -1;
3578         if (remove(playlist->filename) >= 0)
3579         {
3580             if (rename(path, playlist->filename) >= 0)
3581             {
3582                 playlist->fd = open_utf8(playlist->filename, O_RDONLY);
3583                 if (playlist->fd >= 0)
3584                 {
3585                     index = playlist->first_index;
3586                     for (i=0, count=0; i<playlist->amount; i++)
3587                     {
3588                         if (!(playlist->indices[index] & PLAYLIST_QUEUE_MASK))
3589                         {
3590                             playlist->indices[index] = playlist->seek_buf[count];
3591                             count++;
3592                         }
3593                         index = (index+1)%playlist->amount;
3594                     }
3595
3596                     /* we need to recreate control because inserted tracks are
3597                        now part of the playlist and shuffle has been
3598                        invalidated */
3599                     result = recreate_control(playlist);
3600                 }
3601             }
3602        }
3603
3604        mutex_unlock(playlist->control_mutex);
3605
3606     }
3607
3608     cpu_boost(false);
3609
3610 reset_old_buffer:
3611     if (playlist->buffer_handle > 0)
3612         old_buffer = core_get_data(playlist->buffer_handle);
3613     playlist->buffer = old_buffer;
3614     playlist->buffer_size = old_buffer_size;
3615
3616     return result;
3617 }
3618
3619 /*
3620  * Search specified directory for tracks and notify via callback.  May be
3621  * called recursively.
3622  */
3623 int playlist_directory_tracksearch(const char* dirname, bool recurse,
3624                                    int (*callback)(char*, void*),
3625                                    void* context)
3626 {
3627     char buf[MAX_PATH+1];
3628     int result = 0;
3629     int num_files = 0;
3630     int i;;
3631     struct tree_context* tc = tree_get_context();
3632     struct tree_cache* cache = &tc->cache;
3633     int old_dirfilter = *(tc->dirfilter);
3634
3635     if (!callback)
3636         return -1;
3637
3638     /* use the tree browser dircache to load files */
3639     *(tc->dirfilter) = SHOW_ALL;
3640
3641     if (ft_load(tc, dirname) < 0)
3642     {
3643         splash(HZ*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR));
3644         *(tc->dirfilter) = old_dirfilter;
3645         return -1;
3646     }
3647
3648     num_files = tc->filesindir;
3649
3650     /* we've overwritten the dircache so tree browser will need to be
3651        reloaded */
3652     reload_directory();
3653
3654     for (i=0; i<num_files; i++)
3655     {
3656         /* user abort */
3657         if (action_userabort(TIMEOUT_NOBLOCK))
3658         {
3659             result = -1;
3660             break;
3661         }
3662
3663         struct entry *files = core_get_data(cache->entries_handle);
3664         if (files[i].attr & ATTR_DIRECTORY)
3665         {
3666             if (recurse)
3667             {
3668                 /* recursively add directories */
3669                 snprintf(buf, sizeof(buf), "%s/%s",
3670                             dirname[1]? dirname: "", files[i].name);
3671                 result = playlist_directory_tracksearch(buf, recurse,
3672                     callback, context);
3673                 if (result < 0)
3674                     break;
3675
3676                 /* we now need to reload our current directory */
3677                 if(ft_load(tc, dirname) < 0)
3678                 {
3679                     result = -1;
3680                     break;
3681                 }
3682
3683                 num_files = tc->filesindir;
3684                 if (!num_files)
3685                 {
3686                     result = -1;
3687                     break;
3688                 }
3689             }
3690             else
3691                 continue;
3692         }
3693         else if ((files[i].attr & FILE_ATTR_MASK) == FILE_ATTR_AUDIO)
3694         {
3695             snprintf(buf, sizeof(buf), "%s/%s",
3696                         dirname[1]? dirname: "", files[i].name);
3697
3698             if (callback(buf, context) != 0)
3699             {
3700                 result = -1;
3701                 break;
3702             }
3703
3704             /* let the other threads work */
3705             yield();
3706         }
3707     }
3708
3709     /* restore dirfilter */
3710     *(tc->dirfilter) = old_dirfilter;
3711
3712     return result;
3713 }