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