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