apps/playlist.c

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