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 ] = -1;
 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] = -1;
 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 = playlist->filenames[candidate];
 962             playlist->filenames[candidate] = playlist->filenames[count];
 963             playlist->filenames[count] = 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, 0xff, 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 bool is_dircache_pointers_intact(void)
1249 {
1250     return dircache_get_appflag(DIRCACHE_APPFLAG_PLAYLIST) ? true : false;
1251 }
1252
1253 static void playlist_thread(void)
1254 {
1255     struct queue_event ev;
1256     bool dirty_pointers = false;
1257     static char tmp[MAX_PATH+1];
1258
1259     struct playlist_info *playlist;
1260     int index;
1261     int seek;
1262     bool control_file;
1263
1264     int sleep_time = 5;
1265
1266 #ifdef HAVE_DISK_STORAGE
1267     if (global_settings.disk_spindown > 1 &&
1268         global_settings.disk_spindown <= 5)
1269         sleep_time = global_settings.disk_spindown - 1;
1270 #endif
1271
1272     while (1)
1273     {
1274         queue_wait_w_tmo(&playlist_queue, &ev, HZ*sleep_time);
1275
1276         switch (ev.id)
1277         {
1278             case PLAYLIST_LOAD_POINTERS:
1279                 dirty_pointers = true;
1280                 break ;
1281
1282             /* Start the background scanning after either the disk spindown
1283                timeout or 5s, whichever is less */
1284             case SYS_TIMEOUT:
1285             {
1286                 playlist = &current_playlist;
1287                 if (playlist->control_fd >= 0)
1288                 {
1289                     if (playlist->num_cached > 0)
1290                         register_storage_idle_func(playlist_flush_callback);
1291                 }
1292
1293                 if (!dircache_is_enabled() || !playlist->filenames
1294                      || playlist->amount <= 0)
1295                 {
1296                     break ;
1297                 }
1298
1299                 /* Check if previously loaded pointers are intact. */
1300                 if (is_dircache_pointers_intact() && !dirty_pointers)
1301                     break ;
1302
1303 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1304                 cpu_boost(true);
1305 #endif
1306                 for (index = 0; index < playlist->amount
1307                      && queue_empty(&playlist_queue); index++)
1308                 {
1309                     /* Process only pointers that are not already loaded. */
1310                     if (is_dircache_pointers_intact() && playlist->filenames[index] >= 0)
1311                         continue ;
1312
1313                     control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
1314                     seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
1315
1316                     /* Load the filename from playlist file. */
1317                     if (get_filename(playlist, index, seek, control_file, tmp,
1318                         sizeof(tmp)) < 0)
1319                     {
1320                         break ;
1321                     }
1322
1323                     /* Set the dircache entry pointer. */
1324                     playlist->filenames[index] = dircache_get_entry_id(tmp);
1325
1326                     /* And be on background so user doesn't notice any delays. */
1327                     yield();
1328                 }
1329
1330                 if (dircache_is_enabled())
1331                     dircache_set_appflag(DIRCACHE_APPFLAG_PLAYLIST);
1332
1333 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1334                 cpu_boost(false);
1335 #endif
1336                 if (index == playlist->amount)
1337                     dirty_pointers = false;
1338
1339                 break ;
1340             }
1341
1342 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
1343             case SYS_USB_CONNECTED:
1344                 usb_acknowledge(SYS_USB_CONNECTED_ACK);
1345                 usb_wait_for_disconnect(&playlist_queue);
1346                 break ;
1347 #endif
1348         }
1349     }
1350 }
1351 #endif
1352
1353 /*
1354  * gets pathname for track at seek index
1355  */
1356 static int get_filename(struct playlist_info* playlist, int index, int seek,
1357                         bool control_file, char *buf, int buf_length)
1358 {
1359     int fd;
1360     int max = -1;
1361     char tmp_buf[MAX_PATH+1];
1362     char dir_buf[MAX_PATH+1];
1363     bool utf8 = playlist->utf8;
1364
1365     if (buf_length > MAX_PATH+1)
1366         buf_length = MAX_PATH+1;
1367
1368 #ifdef HAVE_DIRCACHE
1369     if (is_dircache_pointers_intact() && playlist->filenames)
1370     {
1371         if (playlist->filenames[index] >= 0)
1372         {
1373             max = dircache_copy_path(playlist->filenames[index],
1374                                      tmp_buf, sizeof(tmp_buf)-1);
1375         }
1376     }
1377 #else
1378     (void)index;
1379 #endif
1380
1381     if (playlist->in_ram && !control_file && max < 0)
1382     {
1383         max = strlcpy(tmp_buf, &playlist->buffer[seek], sizeof(tmp_buf));
1384     }
1385     else if (max < 0)
1386     {
1387         mutex_lock(playlist->control_mutex);
1388
1389         if (control_file)
1390         {
1391             fd = playlist->control_fd;
1392             utf8 = true;
1393         }
1394         else
1395         {
1396             if(-1 == playlist->fd)
1397                 playlist->fd = open(playlist->filename, O_RDONLY);
1398
1399             fd = playlist->fd;
1400         }
1401
1402         if(-1 != fd)
1403         {
1404
1405             if (lseek(fd, seek, SEEK_SET) != seek)
1406                 max = -1;
1407             else
1408             {
1409                 max = read(fd, tmp_buf, MIN((size_t) buf_length, sizeof(tmp_buf)));
1410
1411                 if ((max > 0) && !utf8)
1412                 {
1413                     /* Use dir_buf as a temporary buffer. Note that dir_buf must
1414                      * be as large as tmp_buf.
1415                      */
1416                     max = convert_m3u(tmp_buf, max, sizeof(tmp_buf), dir_buf);
1417                 }
1418             }
1419         }
1420
1421         mutex_unlock(playlist->control_mutex);
1422
1423         if (max < 0)
1424         {
1425             if (control_file)
1426                 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
1427             else
1428                 splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
1429
1430             return max;
1431         }
1432     }
1433
1434     strlcpy(dir_buf, playlist->filename, playlist->dirlen);
1435
1436     return (format_track_path(buf, tmp_buf, buf_length, max, dir_buf));
1437 }
1438
1439 static int get_next_directory(char *dir){
1440   return get_next_dir(dir,true,false);
1441 }
1442
1443 static int get_previous_directory(char *dir){
1444   return get_next_dir(dir,false,false);
1445 }
1446
1447 /*
1448  * search through all the directories (starting with the current) to find
1449  * one that has tracks to play
1450  */
1451 static int get_next_dir(char *dir, bool is_forward, bool recursion)
1452 {
1453     struct playlist_info* playlist = &current_playlist;
1454     int result = -1;
1455     char *start_dir = NULL;
1456     bool exit = false;
1457     int i;
1458     struct tree_context* tc = tree_get_context();
1459     int saved_dirfilter = *(tc->dirfilter);
1460
1461     /* process random folder advance */
1462     if (global_settings.next_folder == FOLDER_ADVANCE_RANDOM)
1463     {
1464         int fd = open(ROCKBOX_DIR "/folder_advance_list.dat", O_RDONLY);
1465         if (fd >= 0)
1466         {
1467             char buffer[MAX_PATH];
1468             int folder_count = 0;
1469             srand(current_tick);
1470             *(tc->dirfilter) = SHOW_MUSIC;
1471             tc->sort_dir = global_settings.sort_dir;
1472             read(fd,&folder_count,sizeof(int));
1473             if (!folder_count)
1474                 exit = true;
1475             while (!exit)
1476             {
1477                 i = rand()%folder_count;
1478                 lseek(fd,sizeof(int) + (MAX_PATH*i),SEEK_SET);
1479                 read(fd,buffer,MAX_PATH);
1480                 if (check_subdir_for_music(buffer, "", false) ==0)
1481                     exit = true;
1482             }
1483             if (folder_count)
1484                 strcpy(dir,buffer);
1485             close(fd);
1486             *(tc->dirfilter) = saved_dirfilter;
1487             tc->sort_dir = global_settings.sort_dir;
1488             reload_directory();
1489             return 0;
1490         }
1491     }
1492
1493     /* not random folder advance (or random folder advance unavailable) */
1494     if (recursion)
1495     {
1496        /* start with root */
1497        dir[0] = '\0';
1498     }
1499     else
1500     {
1501         /* start with current directory */
1502         strlcpy(dir, playlist->filename, playlist->dirlen);
1503     }
1504
1505     /* use the tree browser dircache to load files */
1506     *(tc->dirfilter) = SHOW_ALL;
1507
1508     /* set up sorting/direction */
1509     tc->sort_dir = global_settings.sort_dir;
1510     if (!is_forward)
1511     {
1512         static const char sortpairs[] =
1513         {
1514             [SORT_ALPHA] = SORT_ALPHA_REVERSED,
1515             [SORT_DATE] = SORT_DATE_REVERSED,
1516             [SORT_TYPE] = SORT_TYPE_REVERSED,
1517             [SORT_ALPHA_REVERSED] = SORT_ALPHA,
1518             [SORT_DATE_REVERSED] = SORT_DATE,
1519             [SORT_TYPE_REVERSED] = SORT_TYPE,
1520         };
1521
1522         if ((unsigned)tc->sort_dir < sizeof(sortpairs))
1523             tc->sort_dir = sortpairs[tc->sort_dir];
1524     }
1525
1526     while (!exit)
1527     {
1528         struct entry *files;
1529         int num_files = 0;
1530         int i;
1531
1532         if (ft_load(tc, (dir[0]=='\0')?"/":dir) < 0)
1533         {
1534             exit = true;
1535             result = -1;
1536             break;
1537         }
1538
1539         files = (struct entry*) tc->dircache;
1540         num_files = tc->filesindir;
1541
1542         for (i=0; i<num_files; i++)
1543         {
1544             /* user abort */
1545             if (action_userabort(TIMEOUT_NOBLOCK))
1546             {
1547                 result = -1;
1548                 exit = true;
1549                 break;
1550             }
1551
1552             if (files[i].attr & ATTR_DIRECTORY)
1553             {
1554                 if (!start_dir)
1555                 {
1556                     result = check_subdir_for_music(dir, files[i].name, true);
1557                     if (result != -1)
1558                     {
1559                         exit = true;
1560                         break;
1561                     }
1562                 }
1563                 else if (!strcmp(start_dir, files[i].name))
1564                     start_dir = NULL;
1565             }
1566         }
1567
1568         if (!exit)
1569         {
1570             /* move down to parent directory.  current directory name is
1571                stored as the starting point for the search in parent */
1572             start_dir = strrchr(dir, '/');
1573             if (start_dir)
1574             {
1575                 *start_dir = '\0';
1576                 start_dir++;
1577             }
1578             else
1579                 break;
1580         }
1581     }
1582
1583     /* restore dirfilter */
1584     *(tc->dirfilter) = saved_dirfilter;
1585     tc->sort_dir = global_settings.sort_dir;
1586
1587     /* special case if nothing found: try start searching again from root */
1588     if (result == -1 && !recursion){
1589         result = get_next_dir(dir, is_forward, true);
1590     }
1591
1592     return result;
1593 }
1594
1595 /*
1596  * Checks if there are any music files in the dir or any of its
1597  * subdirectories.  May be called recursively.
1598  */
1599 static int check_subdir_for_music(char *dir, const char *subdir, bool recurse)
1600 {
1601     int result = -1;
1602     int dirlen = strlen(dir);
1603     int num_files = 0;
1604     int i;
1605     struct entry *files;
1606     bool has_music = false;
1607     bool has_subdir = false;
1608     struct tree_context* tc = tree_get_context();
1609
1610     snprintf(dir+dirlen, MAX_PATH-dirlen, "/%s", subdir);
1611
1612     if (ft_load(tc, dir) < 0)
1613     {
1614         return -2;
1615     }
1616
1617     files = (struct entry*) tc->dircache;
1618     num_files = tc->filesindir;
1619
1620     for (i=0; i<num_files; i++)
1621     {
1622         if (files[i].attr & ATTR_DIRECTORY)
1623             has_subdir = true;
1624         else if ((files[i].attr & FILE_ATTR_MASK) == FILE_ATTR_AUDIO)
1625         {
1626             has_music = true;
1627             break;
1628         }
1629     }
1630
1631     if (has_music)
1632         return 0;
1633
1634     if (has_subdir && recurse)
1635     {
1636         for (i=0; i<num_files; i++)
1637         {
1638             if (action_userabort(TIMEOUT_NOBLOCK))
1639             {
1640                 result = -2;
1641                 break;
1642             }
1643
1644             if (files[i].attr & ATTR_DIRECTORY)
1645             {
1646                 result = check_subdir_for_music(dir, files[i].name, true);
1647                 if (!result)
1648                     break;
1649             }
1650         }
1651     }
1652
1653     if (result < 0)
1654     {
1655         if (dirlen)
1656         {
1657             dir[dirlen] = '\0';
1658         }
1659         else
1660         {
1661             strcpy(dir, "/");
1662         }
1663
1664         /* we now need to reload our current directory */
1665         if(ft_load(tc, dir) < 0)
1666             splash(HZ*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR));
1667     }
1668     return result;
1669 }
1670
1671 /*
1672  * Returns absolute path of track
1673  */
1674 static int format_track_path(char *dest, char *src, int buf_length, int max,
1675                              const char *dir)
1676 {
1677     int i = 0;
1678     int j;
1679     char *temp_ptr;
1680
1681     /* Look for the end of the string */
1682     while((i < max) &&
1683           (src[i] != '\n') &&
1684           (src[i] != '\r') &&
1685           (src[i] != '\0'))
1686         i++;
1687
1688     /* Now work back killing white space */
1689     while((i > 0) &&
1690           ((src[i-1] == ' ') ||
1691           (src[i-1] == '\t')))
1692         i--;
1693
1694     /* Zero-terminate the file name */
1695     src[i]=0;
1696
1697     /* replace backslashes with forward slashes */
1698     for ( j=0; j<i; j++ )
1699         if ( src[j] == '\\' )
1700             src[j] = '/';
1701
1702     if('/' == src[0])
1703     {
1704         strlcpy(dest, src, buf_length);
1705     }
1706     else
1707     {
1708         /* handle dos style drive letter */
1709         if (':' == src[1])
1710             strlcpy(dest, &src[2], buf_length);
1711         else if (!strncmp(src, "../", 3))
1712         {
1713             /* handle relative paths */
1714             i=3;
1715             while(!strncmp(&src[i], "../", 3))
1716                 i += 3;
1717             for (j=0; j<i/3; j++) {
1718                 temp_ptr = strrchr(dir, '/');
1719                 if (temp_ptr)
1720                     *temp_ptr = '\0';
1721                 else
1722                     break;
1723             }
1724             snprintf(dest, buf_length, "%s/%s", dir, &src[i]);
1725         }
1726         else if ( '.' == src[0] && '/' == src[1] ) {
1727             snprintf(dest, buf_length, "%s/%s", dir, &src[2]);
1728         }
1729         else {
1730             snprintf(dest, buf_length, "%s/%s", dir, src);
1731         }
1732     }
1733
1734     return 0;
1735 }
1736
1737 /*
1738  * Display splash message showing progress of playlist/directory insertion or
1739  * save.
1740  */
1741 static void display_playlist_count(int count, const unsigned char *fmt,
1742                                    bool final)
1743 {
1744     static long talked_tick = 0;
1745     long id = P2ID(fmt);
1746     if(global_settings.talk_menu && id>=0)
1747     {
1748         if(final || (count && (talked_tick == 0
1749                                || TIME_AFTER(current_tick, talked_tick+5*HZ))))
1750         {
1751             talked_tick = current_tick;
1752             talk_number(count, false);
1753             talk_id(id, true);
1754         }
1755     }
1756     fmt = P2STR(fmt);
1757
1758     splashf(0, fmt, count, str(LANG_OFF_ABORT));
1759 }
1760
1761 /*
1762  * Display buffer full message
1763  */
1764 static void display_buffer_full(void)
1765 {
1766     splash(HZ*2, ID2P(LANG_PLAYLIST_BUFFER_FULL));
1767 }
1768
1769 /*
1770  * Flush any cached control commands to disk.  Called when playlist is being
1771  * modified.  Returns 0 on success and -1 on failure.
1772  */
1773 static int flush_cached_control(struct playlist_info* playlist)
1774 {
1775     int result = 0;
1776     int i;
1777
1778     if (!playlist->num_cached)
1779         return 0;
1780
1781     lseek(playlist->control_fd, 0, SEEK_END);
1782
1783     for (i=0; i<playlist->num_cached; i++)
1784     {
1785         struct playlist_control_cache* cache =
1786             &(playlist->control_cache[i]);
1787
1788         switch (cache->command)
1789         {
1790             case PLAYLIST_COMMAND_PLAYLIST:
1791                 result = fdprintf(playlist->control_fd, "P:%d:%s:%s\n",
1792                     cache->i1, cache->s1, cache->s2);
1793                 break;
1794             case PLAYLIST_COMMAND_ADD:
1795             case PLAYLIST_COMMAND_QUEUE:
1796                 result = fdprintf(playlist->control_fd, "%c:%d:%d:",
1797                     (cache->command == PLAYLIST_COMMAND_ADD)?'A':'Q',
1798                     cache->i1, cache->i2);
1799                 if (result > 0)
1800                 {
1801                     /* save the position in file where name is written */
1802                     int* seek_pos = (int *)cache->data;
1803                     *seek_pos = lseek(playlist->control_fd, 0, SEEK_CUR);
1804                     result = fdprintf(playlist->control_fd, "%s\n",
1805                         cache->s1);
1806                 }
1807                 break;
1808             case PLAYLIST_COMMAND_DELETE:
1809                 result = fdprintf(playlist->control_fd, "D:%d\n", cache->i1);
1810                 break;
1811             case PLAYLIST_COMMAND_SHUFFLE:
1812                 result = fdprintf(playlist->control_fd, "S:%d:%d\n",
1813                     cache->i1, cache->i2);
1814                 break;
1815             case PLAYLIST_COMMAND_UNSHUFFLE:
1816                 result = fdprintf(playlist->control_fd, "U:%d\n", cache->i1);
1817                 break;
1818             case PLAYLIST_COMMAND_RESET:
1819                 result = fdprintf(playlist->control_fd, "R\n");
1820                 break;
1821             default:
1822                 break;
1823         }
1824
1825         if (result <= 0)
1826             break;
1827     }
1828
1829     if (result > 0)
1830     {
1831         playlist->num_cached = 0;
1832         playlist->pending_control_sync = true;
1833
1834         result = 0;
1835     }
1836     else
1837     {
1838         result = -1;
1839         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_UPDATE_ERROR));
1840     }
1841
1842     return result;
1843 }
1844
1845 /*
1846  * Update control data with new command.  Depending on the command, it may be
1847  * cached or flushed to disk.
1848  */
1849 static int update_control(struct playlist_info* playlist,
1850                           enum playlist_command command, int i1, int i2,
1851                           const char* s1, const char* s2, void* data)
1852 {
1853     int result = 0;
1854     struct playlist_control_cache* cache;
1855     bool flush = false;
1856
1857     mutex_lock(playlist->control_mutex);
1858
1859     cache = &(playlist->control_cache[playlist->num_cached++]);
1860
1861     cache->command = command;
1862     cache->i1 = i1;
1863     cache->i2 = i2;
1864     cache->s1 = s1;
1865     cache->s2 = s2;
1866     cache->data = data;
1867
1868     switch (command)
1869     {
1870         case PLAYLIST_COMMAND_PLAYLIST:
1871         case PLAYLIST_COMMAND_ADD:
1872         case PLAYLIST_COMMAND_QUEUE:
1873 #ifndef HAVE_DIRCACHE
1874         case PLAYLIST_COMMAND_DELETE:
1875         case PLAYLIST_COMMAND_RESET:
1876 #endif
1877             flush = true;
1878             break;
1879         case PLAYLIST_COMMAND_SHUFFLE:
1880         case PLAYLIST_COMMAND_UNSHUFFLE:
1881         default:
1882             /* only flush when needed */
1883             break;
1884     }
1885
1886     if (flush || playlist->num_cached == PLAYLIST_MAX_CACHE)
1887         result = flush_cached_control(playlist);
1888
1889     mutex_unlock(playlist->control_mutex);
1890
1891     return result;
1892 }
1893
1894 /*
1895  * sync control file to disk
1896  */
1897 static void sync_control(struct playlist_info* playlist, bool force)
1898 {
1899 #ifdef HAVE_DIRCACHE
1900     if (playlist->started && force)
1901 #else
1902     (void) force;
1903
1904     if (playlist->started)
1905 #endif
1906     {
1907         if (playlist->pending_control_sync)
1908         {
1909             mutex_lock(playlist->control_mutex);
1910             fsync(playlist->control_fd);
1911             playlist->pending_control_sync = false;
1912             mutex_unlock(playlist->control_mutex);
1913         }
1914     }
1915 }
1916
1917 /*
1918  * Rotate indices such that first_index is index 0
1919  */
1920 static int rotate_index(const struct playlist_info* playlist, int index)
1921 {
1922     index -= playlist->first_index;
1923     if (index < 0)
1924         index += playlist->amount;
1925
1926     return index;
1927 }
1928
1929 /*
1930  * Initialize playlist entries at startup
1931  */
1932 void playlist_init(void)
1933 {
1934     struct playlist_info* playlist = &current_playlist;
1935
1936     mutex_init(&current_playlist_mutex);
1937     mutex_init(&created_playlist_mutex);
1938
1939     playlist->current = true;
1940     strlcpy(playlist->control_filename, PLAYLIST_CONTROL_FILE,
1941             sizeof(playlist->control_filename));
1942     playlist->fd = -1;
1943     playlist->control_fd = -1;
1944     playlist->max_playlist_size = global_settings.max_files_in_playlist;
1945     playlist->indices = buffer_alloc(
1946         playlist->max_playlist_size * sizeof(int));
1947     playlist->buffer_size =
1948         AVERAGE_FILENAME_LENGTH * global_settings.max_files_in_dir;
1949     playlist->buffer = buffer_alloc(playlist->buffer_size);
1950     playlist->control_mutex = &current_playlist_mutex;
1951
1952     empty_playlist(playlist, true);
1953
1954 #ifdef HAVE_DIRCACHE
1955     playlist->filenames = buffer_alloc(
1956         playlist->max_playlist_size * sizeof(int));
1957     memset(playlist->filenames, 0xff,
1958            playlist->max_playlist_size * sizeof(int));
1959     create_thread(playlist_thread, playlist_stack, sizeof(playlist_stack),
1960                   0, playlist_thread_name IF_PRIO(, PRIORITY_BACKGROUND)
1961                        IF_COP(, CPU));
1962     queue_init(&playlist_queue, true);
1963 #endif
1964 }
1965
1966 /*
1967  * Clean playlist at shutdown
1968  */
1969 void playlist_shutdown(void)
1970 {
1971     struct playlist_info* playlist = &current_playlist;
1972
1973     if (playlist->control_fd >= 0)
1974     {
1975         mutex_lock(playlist->control_mutex);
1976
1977         if (playlist->num_cached > 0)
1978             flush_cached_control(playlist);
1979
1980         close(playlist->control_fd);
1981
1982         mutex_unlock(playlist->control_mutex);
1983     }
1984 }
1985
1986 /*
1987  * Create new playlist
1988  */
1989 int playlist_create(const char *dir, const char *file)
1990 {
1991     struct playlist_info* playlist = &current_playlist;
1992
1993     new_playlist(playlist, dir, file);
1994
1995     if (file)
1996         /* load the playlist file */
1997         add_indices_to_playlist(playlist, NULL, 0);
1998
1999     return 0;
2000 }
2001
2002 #define PLAYLIST_COMMAND_SIZE (MAX_PATH+12)
2003
2004 /*
2005  * Restore the playlist state based on control file commands.  Called to
2006  * resume playback after shutdown.
2007  */
2008 int playlist_resume(void)
2009 {
2010     struct playlist_info* playlist = &current_playlist;
2011     char *buffer;
2012     size_t buflen;
2013     int nread;
2014     int total_read = 0;
2015     int control_file_size = 0;
2016     bool first = true;
2017     bool sorted = true;
2018
2019     /* use mp3 buffer for maximum load speed */
2020 #if CONFIG_CODEC != SWCODEC
2021     talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
2022     buflen = (audiobufend - audiobuf);
2023     buffer = (char *)audiobuf;
2024 #else
2025     buffer = (char *)audio_get_buffer(false, &buflen);
2026 #endif
2027
2028     empty_playlist(playlist, true);
2029
2030     splash(0, ID2P(LANG_WAIT));
2031     playlist->control_fd = open(playlist->control_filename, O_RDWR);
2032     if (playlist->control_fd < 0)
2033     {
2034         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2035         return -1;
2036     }
2037     playlist->control_created = true;
2038
2039     control_file_size = filesize(playlist->control_fd);
2040     if (control_file_size <= 0)
2041     {
2042         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2043         return -1;
2044     }
2045
2046     /* read a small amount first to get the header */
2047     nread = read(playlist->control_fd, buffer,
2048         PLAYLIST_COMMAND_SIZE<buflen?PLAYLIST_COMMAND_SIZE:buflen);
2049     if(nread <= 0)
2050     {
2051         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2052         return -1;
2053     }
2054
2055     playlist->started = true;
2056
2057     while (1)
2058     {
2059         int result = 0;
2060         int count;
2061         enum playlist_command current_command = PLAYLIST_COMMAND_COMMENT;
2062         int last_newline = 0;
2063         int str_count = -1;
2064         bool newline = true;
2065         bool exit_loop = false;
2066         char *p = buffer;
2067         char *str1 = NULL;
2068         char *str2 = NULL;
2069         char *str3 = NULL;
2070         unsigned long last_tick = current_tick;
2071         bool useraborted = false;
2072
2073         for(count=0; count<nread && !exit_loop && !useraborted; count++,p++)
2074         {
2075             /* So a splash while we are loading. */
2076             if (TIME_AFTER(current_tick, last_tick + HZ/4))
2077             {
2078                 splashf(0, str(LANG_LOADING_PERCENT),
2079                            (total_read+count)*100/control_file_size,
2080                            str(LANG_OFF_ABORT));
2081                 if (action_userabort(TIMEOUT_NOBLOCK))
2082                 {
2083                     useraborted = true;
2084                     break;
2085                 }
2086                 last_tick = current_tick;
2087             }
2088
2089             /* Are we on a new line? */
2090             if((*p == '\n') || (*p == '\r'))
2091             {
2092                 *p = '\0';
2093
2094                 /* save last_newline in case we need to load more data */
2095                 last_newline = count;
2096
2097                 switch (current_command)
2098                 {
2099                     case PLAYLIST_COMMAND_PLAYLIST:
2100                     {
2101                         /* str1=version str2=dir str3=file */
2102                         int version;
2103
2104                         if (!str1)
2105                         {
2106                             result = -1;
2107                             exit_loop = true;
2108                             break;
2109                         }
2110
2111                         if (!str2)
2112                             str2 = "";
2113
2114                         if (!str3)
2115                             str3 = "";
2116
2117                         version = atoi(str1);
2118
2119                         if (version != PLAYLIST_CONTROL_FILE_VERSION)
2120                             return -1;
2121
2122                         update_playlist_filename(playlist, str2, str3);
2123
2124                         if (str3[0] != '\0')
2125                         {
2126                             /* NOTE: add_indices_to_playlist() overwrites the
2127                                audiobuf so we need to reload control file
2128                                data */
2129                             add_indices_to_playlist(playlist, NULL, 0);
2130                         }
2131                         else if (str2[0] != '\0')
2132                         {
2133                             playlist->in_ram = true;
2134                             resume_directory(str2);
2135                         }
2136
2137                         /* load the rest of the data */
2138                         first = false;
2139                         exit_loop = true;
2140
2141                         break;
2142                     }
2143                     case PLAYLIST_COMMAND_ADD:
2144                     case PLAYLIST_COMMAND_QUEUE:
2145                     {
2146                         /* str1=position str2=last_position str3=file */
2147                         int position, last_position;
2148                         bool queue;
2149
2150                         if (!str1 || !str2 || !str3)
2151                         {
2152                             result = -1;
2153                             exit_loop = true;
2154                             break;
2155                         }
2156
2157                         position = atoi(str1);
2158                         last_position = atoi(str2);
2159
2160                         queue = (current_command == PLAYLIST_COMMAND_ADD)?
2161                             false:true;
2162
2163                         /* seek position is based on str3's position in
2164                            buffer */
2165                         if (add_track_to_playlist(playlist, str3, position,
2166                                 queue, total_read+(str3-buffer)) < 0)
2167                         return -1;
2168
2169                         playlist->last_insert_pos = last_position;
2170
2171                         break;
2172                     }
2173                     case PLAYLIST_COMMAND_DELETE:
2174                     {
2175                         /* str1=position */
2176                         int position;
2177
2178                         if (!str1)
2179                         {
2180                             result = -1;
2181                             exit_loop = true;
2182                             break;
2183                         }
2184
2185                         position = atoi(str1);
2186
2187                         if (remove_track_from_playlist(playlist, position,
2188                                 false) < 0)
2189                             return -1;
2190
2191                         break;
2192                     }
2193                     case PLAYLIST_COMMAND_SHUFFLE:
2194                     {
2195                         /* str1=seed str2=first_index */
2196                         int seed;
2197
2198                         if (!str1 || !str2)
2199                         {
2200                             result = -1;
2201                             exit_loop = true;
2202                             break;
2203                         }
2204
2205                         if (!sorted)
2206                         {
2207                             /* Always sort list before shuffling */
2208                             sort_playlist(playlist, false, false);
2209                         }
2210
2211                         seed = atoi(str1);
2212                         playlist->first_index = atoi(str2);
2213
2214                         if (randomise_playlist(playlist, seed, false,
2215                                 false) < 0)
2216                             return -1;
2217                         sorted = false;
2218                         break;
2219                     }
2220                     case PLAYLIST_COMMAND_UNSHUFFLE:
2221                     {
2222                         /* str1=first_index */
2223                         if (!str1)
2224                         {
2225                             result = -1;
2226                             exit_loop = true;
2227                             break;
2228                         }
2229
2230                         playlist->first_index = atoi(str1);
2231
2232                         if (sort_playlist(playlist, false, false) < 0)
2233                             return -1;
2234
2235                         sorted = true;
2236                         break;
2237                     }
2238                     case PLAYLIST_COMMAND_RESET:
2239                     {
2240                         playlist->last_insert_pos = -1;
2241                         break;
2242                     }
2243                     case PLAYLIST_COMMAND_COMMENT:
2244                     default:
2245                         break;
2246                 }
2247
2248                 newline = true;
2249
2250                 /* to ignore any extra newlines */
2251                 current_command = PLAYLIST_COMMAND_COMMENT;
2252             }
2253             else if(newline)
2254             {
2255                 newline = false;
2256
2257                 /* first non-comment line must always specify playlist */
2258                 if (first && *p != 'P' && *p != '#')
2259                 {
2260                     result = -1;
2261                     exit_loop = true;
2262                     break;
2263                 }
2264
2265                 switch (*p)
2266                 {
2267                     case 'P':
2268                         /* playlist can only be specified once */
2269                         if (!first)
2270                         {
2271                             result = -1;
2272                             exit_loop = true;
2273                             break;
2274                         }
2275
2276                         current_command = PLAYLIST_COMMAND_PLAYLIST;
2277                         break;
2278                     case 'A':
2279                         current_command = PLAYLIST_COMMAND_ADD;
2280                         break;
2281                     case 'Q':
2282                         current_command = PLAYLIST_COMMAND_QUEUE;
2283                         break;
2284                     case 'D':
2285                         current_command = PLAYLIST_COMMAND_DELETE;
2286                         break;
2287                     case 'S':
2288                         current_command = PLAYLIST_COMMAND_SHUFFLE;
2289                         break;
2290                     case 'U':
2291                         current_command = PLAYLIST_COMMAND_UNSHUFFLE;
2292                         break;
2293                     case 'R':
2294                         current_command = PLAYLIST_COMMAND_RESET;
2295                         break;
2296                     case '#':
2297                         current_command = PLAYLIST_COMMAND_COMMENT;
2298                         break;
2299                     default:
2300                         result = -1;
2301                         exit_loop = true;
2302                         break;
2303                 }
2304
2305                 str_count = -1;
2306                 str1 = NULL;
2307                 str2 = NULL;
2308                 str3 = NULL;
2309             }
2310             else if(current_command != PLAYLIST_COMMAND_COMMENT)
2311             {
2312                 /* all control file strings are separated with a colon.
2313                    Replace the colon with 0 to get proper strings that can be
2314                    used by commands above */
2315                 if (*p == ':')
2316                 {
2317                     *p = '\0';
2318                     str_count++;
2319
2320                     if ((count+1) < nread)
2321                     {
2322                         switch (str_count)
2323                         {
2324                         case 0:
2325                             str1 = p+1;
2326                             break;
2327                         case 1:
2328                             str2 = p+1;
2329                             break;
2330                         case 2:
2331                             str3 = p+1;
2332                             break;
2333                         default:
2334                             /* allow last string to contain colons */
2335                             *p = ':';
2336                             break;
2337                         }
2338                     }
2339                 }
2340             }
2341         }
2342
2343         if (result < 0)
2344         {
2345             splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID));
2346             return result;
2347         }
2348
2349         if (useraborted)
2350         {
2351             splash(HZ*2, ID2P(LANG_CANCEL));
2352             return -1;
2353         }
2354         if (!newline || (exit_loop && count<nread))
2355         {
2356             if ((total_read + count) >= control_file_size)
2357             {
2358                 /* no newline at end of control file */
2359                 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID));
2360                 return -1;
2361             }
2362
2363             /* We didn't end on a newline or we exited loop prematurely.
2364                Either way, re-read the remainder. */
2365             count = last_newline;
2366             lseek(playlist->control_fd, total_read+count, SEEK_SET);
2367         }
2368
2369         total_read += count;
2370
2371         if (first)
2372             /* still looking for header */
2373             nread = read(playlist->control_fd, buffer,
2374                 PLAYLIST_COMMAND_SIZE<buflen?PLAYLIST_COMMAND_SIZE:buflen);
2375         else
2376             nread = read(playlist->control_fd, buffer, buflen);
2377
2378         /* Terminate on EOF */
2379         if(nread <= 0)
2380         {
2381             break;
2382         }
2383     }
2384
2385 #ifdef HAVE_DIRCACHE
2386     queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
2387 #endif
2388
2389     return 0;
2390 }
2391
2392 /*
2393  * Add track to in_ram playlist.  Used when playing directories.
2394  */
2395 int playlist_add(const char *filename)
2396 {
2397     struct playlist_info* playlist = &current_playlist;
2398     int len = strlen(filename);
2399
2400     if((len+1 > playlist->buffer_size - playlist->buffer_end_pos) ||
2401        (playlist->amount >= playlist->max_playlist_size))
2402     {
2403         display_buffer_full();
2404         return -1;
2405     }
2406
2407     playlist->indices[playlist->amount] = playlist->buffer_end_pos;
2408 #ifdef HAVE_DIRCACHE
2409     playlist->filenames[playlist->amount] = -1;
2410 #endif
2411     playlist->amount++;
2412
2413     strcpy(&playlist->buffer[playlist->buffer_end_pos], filename);
2414     playlist->buffer_end_pos += len;
2415     playlist->buffer[playlist->buffer_end_pos++] = '\0';
2416
2417     return 0;
2418 }
2419
2420 /* shuffle newly created playlist using random seed. */
2421 int playlist_shuffle(int random_seed, int start_index)
2422 {
2423     struct playlist_info* playlist = &current_playlist;
2424
2425     bool start_current = false;
2426
2427     if (start_index >= 0 && global_settings.play_selected)
2428     {
2429         /* store the seek position before the shuffle */
2430         playlist->index = playlist->first_index = start_index;
2431         start_current = true;
2432     }
2433
2434     randomise_playlist(playlist, random_seed, start_current, true);
2435
2436     return playlist->index;
2437 }
2438
2439 /* start playing current playlist at specified index/offset */
2440 void playlist_start(int start_index, int offset)
2441 {
2442     struct playlist_info* playlist = &current_playlist;
2443
2444     /* Cancel FM radio selection as previous music. For cases where we start
2445        playback without going to the WPS, such as playlist insert.. or
2446        playlist catalog. */
2447     previous_music_is_wps();
2448
2449     playlist->index = start_index;
2450
2451 #if CONFIG_CODEC != SWCODEC
2452     talk_buffer_steal(); /* will use the mp3 buffer */
2453 #endif
2454
2455     playlist->started = true;
2456     sync_control(playlist, false);
2457     audio_play(offset);
2458 }
2459
2460 /* Returns false if 'steps' is out of bounds, else true */
2461 bool playlist_check(int steps)
2462 {
2463     struct playlist_info* playlist = &current_playlist;
2464
2465     /* always allow folder navigation */
2466     if (global_settings.next_folder && playlist->in_ram)
2467         return true;
2468
2469     int index = get_next_index(playlist, steps, -1);
2470
2471     if (index < 0 && steps >= 0 && global_settings.repeat_mode == REPEAT_SHUFFLE)
2472         index = get_next_index(playlist, steps, REPEAT_ALL);
2473
2474     return (index >= 0);
2475 }
2476
2477 /* get trackname of track that is "steps" away from current playing track.
2478    NULL is used to identify end of playlist */
2479 const char* playlist_peek(int steps, char* buf, size_t buf_size)
2480 {
2481     struct playlist_info* playlist = &current_playlist;
2482     int seek;
2483     char *temp_ptr;
2484     int index;
2485     bool control_file;
2486
2487     index = get_next_index(playlist, steps, -1);
2488     if (index < 0)
2489         return NULL;
2490
2491 #if CONFIG_CODEC == SWCODEC
2492     /* Just testing - don't care about the file name */
2493     if (!buf || !buf_size)
2494         return "";
2495 #endif
2496
2497     control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
2498     seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
2499
2500     if (get_filename(playlist, index, seek, control_file, buf,
2501         buf_size) < 0)
2502         return NULL;
2503
2504     temp_ptr = buf;
2505
2506     if (!playlist->in_ram || control_file)
2507     {
2508         /* remove bogus dirs from beginning of path
2509            (workaround for buggy playlist creation tools) */
2510         while (temp_ptr)
2511         {
2512             if (file_exists(temp_ptr))
2513                 break;
2514
2515             temp_ptr = strchr(temp_ptr+1, '/');
2516         }
2517
2518         if (!temp_ptr)
2519         {
2520             /* Even though this is an invalid file, we still need to pass a
2521                file name to the caller because NULL is used to indicate end
2522                of playlist */
2523             return buf;
2524         }
2525     }
2526
2527     return temp_ptr;
2528 }
2529
2530 /*
2531  * Update indices as track has changed
2532  */
2533 int playlist_next(int steps)
2534 {
2535     struct playlist_info* playlist = &current_playlist;
2536     int index;
2537
2538     if ( (steps > 0)
2539 #ifdef AB_REPEAT_ENABLE
2540     && (global_settings.repeat_mode != REPEAT_AB)
2541 #endif
2542     && (global_settings.repeat_mode != REPEAT_ONE) )
2543     {
2544         int i, j;
2545
2546         /* We need to delete all the queued songs */
2547         for (i=0, j=steps; i<j; i++)
2548         {
2549             index = get_next_index(playlist, i, -1);
2550
2551             if (playlist->indices[index] & PLAYLIST_QUEUE_MASK)
2552             {
2553                 remove_track_from_playlist(playlist, index, true);
2554                 steps--; /* one less track */
2555             }
2556         }
2557     }
2558
2559     index = get_next_index(playlist, steps, -1);
2560
2561     if (index < 0)
2562     {
2563         /* end of playlist... or is it */
2564         if (global_settings.repeat_mode == REPEAT_SHUFFLE &&
2565             playlist->amount > 1)
2566         {
2567             /* Repeat shuffle mode.  Re-shuffle playlist and resume play */
2568             playlist->first_index = 0;
2569             sort_playlist(playlist, false, false);
2570             randomise_playlist(playlist, current_tick, false, true);
2571
2572 #if CONFIG_CODEC == SWCODEC
2573             playlist->started = true;
2574 #else
2575             playlist_start(0, 0);
2576 #endif
2577             playlist->index = 0;
2578             index = 0;
2579         }
2580         else if (playlist->in_ram && global_settings.next_folder)
2581         {
2582             index = create_and_play_dir(steps, true);
2583
2584             if (index >= 0)
2585             {
2586                 playlist->index = index;
2587             }
2588         }
2589
2590         return index;
2591     }
2592
2593     playlist->index = index;
2594
2595     if (playlist->last_insert_pos >= 0 && steps > 0)
2596     {
2597         /* check to see if we've gone beyond the last inserted track */
2598         int cur = rotate_index(playlist, index);
2599         int last_pos = rotate_index(playlist, playlist->last_insert_pos);
2600
2601         if (cur > last_pos)
2602         {
2603             /* reset last inserted track */
2604             playlist->last_insert_pos = -1;
2605
2606             if (playlist->control_fd >= 0)
2607             {
2608                 int result = update_control(playlist, PLAYLIST_COMMAND_RESET,
2609                     -1, -1, NULL, NULL, NULL);
2610
2611                 if (result < 0)
2612                     return result;
2613
2614                 sync_control(playlist, false);
2615             }
2616         }
2617     }
2618
2619     return index;
2620 }
2621
2622 /* try playing next or previous folder */
2623 bool playlist_next_dir(int direction)
2624 {
2625     /* not to mess up real playlists */
2626     if(!current_playlist.in_ram)
2627        return false;
2628
2629     return create_and_play_dir(direction, false) >= 0;
2630 }
2631
2632 /* Get resume info for current playing song.  If return value is -1 then
2633    settings shouldn't be saved. */
2634 int playlist_get_resume_info(int *resume_index)
2635 {
2636     struct playlist_info* playlist = &current_playlist;
2637
2638     *resume_index = playlist->index;
2639
2640     return 0;
2641 }
2642
2643 /* Update resume info for current playing song.  Returns -1 on error. */
2644 int playlist_update_resume_info(const struct mp3entry* id3)
2645 {
2646     struct playlist_info* playlist = &current_playlist;
2647
2648     if (id3)
2649     {
2650         if (global_status.resume_index  != playlist->index ||
2651             global_status.resume_offset != id3->offset)
2652         {
2653             global_status.resume_index  = playlist->index;
2654             global_status.resume_offset = id3->offset;
2655             status_save();
2656         }
2657     }
2658     else
2659     {
2660         global_status.resume_index  = -1;
2661         global_status.resume_offset = -1;
2662         status_save();
2663     }
2664
2665     return 0;
2666 }
2667
2668 /* Returns index of current playing track for display purposes.  This value
2669    should not be used for resume purposes as it doesn't represent the actual
2670    index into the playlist */
2671 int playlist_get_display_index(void)
2672 {
2673     struct playlist_info* playlist = &current_playlist;
2674
2675     /* first_index should always be index 0 for display purposes */
2676     int index = rotate_index(playlist, playlist->index);
2677
2678     return (index+1);
2679 }
2680
2681 /* returns number of tracks in current playlist */
2682 int playlist_amount(void)
2683 {
2684     return playlist_amount_ex(NULL);
2685 }
2686 /* set playlist->last_shuffle_start to playlist->amount for
2687    PLAYLIST_INSERT_LAST_SHUFFLED command purposes*/
2688 void playlist_set_last_shuffled_start(void)
2689 {
2690     struct playlist_info* playlist = &current_playlist;
2691     playlist->last_shuffled_start = playlist->amount;
2692 }
2693 /*
2694  * Create a new playlist  If playlist is not NULL then we're loading a
2695  * playlist off disk for viewing/editing.  The index_buffer is used to store
2696  * playlist indices (required for and only used if !current playlist).  The
2697  * temp_buffer (if not NULL) is used as a scratchpad when loading indices.
2698  */
2699 int playlist_create_ex(struct playlist_info* playlist,
2700                        const char* dir, const char* file,
2701                        void* index_buffer, int index_buffer_size,
2702                        void* temp_buffer, int temp_buffer_size)
2703 {
2704     if (!playlist)
2705         playlist = &current_playlist;
2706     else
2707     {
2708         /* Initialize playlist structure */
2709         int r = rand() % 10;
2710         playlist->current = false;
2711
2712         /* Use random name for control file */
2713         snprintf(playlist->control_filename, sizeof(playlist->control_filename),
2714             "%s.%d", PLAYLIST_CONTROL_FILE, r);
2715         playlist->fd = -1;
2716         playlist->control_fd = -1;
2717
2718         if (index_buffer)
2719         {
2720             int num_indices = index_buffer_size / sizeof(int);
2721
2722 #ifdef HAVE_DIRCACHE
2723             num_indices /= 2;
2724 #endif
2725             if (num_indices > global_settings.max_files_in_playlist)
2726                 num_indices = global_settings.max_files_in_playlist;
2727
2728             playlist->max_playlist_size = num_indices;
2729             playlist->indices = index_buffer;
2730 #ifdef HAVE_DIRCACHE
2731             playlist->filenames = (int*)&playlist->indices[num_indices];
2732 #endif
2733         }
2734         else
2735         {
2736             playlist->max_playlist_size = current_playlist.max_playlist_size;
2737             playlist->indices = current_playlist.indices;
2738 #ifdef HAVE_DIRCACHE
2739             playlist->filenames = current_playlist.filenames;
2740 #endif
2741         }
2742
2743         playlist->buffer_size = 0;
2744         playlist->buffer = NULL;
2745         playlist->control_mutex = &created_playlist_mutex;
2746     }
2747
2748     new_playlist(playlist, dir, file);
2749
2750     if (file)
2751         /* load the playlist file */
2752         add_indices_to_playlist(playlist, temp_buffer, temp_buffer_size);
2753
2754     return 0;
2755 }
2756
2757 /*
2758  * Set the specified playlist as the current.
2759  * NOTE: You will get undefined behaviour if something is already playing so
2760  *       remember to stop before calling this.  Also, this call will
2761  *       effectively close your playlist, making it unusable.
2762  */
2763 int playlist_set_current(struct playlist_info* playlist)
2764 {
2765     if (!playlist || (check_control(playlist) < 0))
2766         return -1;
2767
2768     empty_playlist(&current_playlist, false);
2769
2770     strlcpy(current_playlist.filename, playlist->filename,
2771         sizeof(current_playlist.filename));
2772
2773     current_playlist.utf8 = playlist->utf8;
2774     current_playlist.fd = playlist->fd;
2775
2776     close(playlist->control_fd);
2777     close(current_playlist.control_fd);
2778     remove(current_playlist.control_filename);
2779     if (rename(playlist->control_filename,
2780             current_playlist.control_filename) < 0)
2781         return -1;
2782     current_playlist.control_fd = open(current_playlist.control_filename,
2783         O_RDWR);
2784     if (current_playlist.control_fd < 0)
2785         return -1;
2786     current_playlist.control_created = true;
2787
2788     current_playlist.dirlen = playlist->dirlen;
2789
2790     if (playlist->indices && playlist->indices != current_playlist.indices)
2791     {
2792         memcpy(current_playlist.indices, playlist->indices,
2793                playlist->max_playlist_size*sizeof(int));
2794 #ifdef HAVE_DIRCACHE
2795         memcpy(current_playlist.filenames, playlist->filenames,
2796                playlist->max_playlist_size*sizeof(int));
2797 #endif
2798     }
2799
2800     current_playlist.first_index = playlist->first_index;
2801     current_playlist.amount = playlist->amount;
2802     current_playlist.last_insert_pos = playlist->last_insert_pos;
2803     current_playlist.seed = playlist->seed;
2804     current_playlist.shuffle_modified = playlist->shuffle_modified;
2805     current_playlist.deleted = playlist->deleted;
2806     current_playlist.num_inserted_tracks = playlist->num_inserted_tracks;
2807
2808     memcpy(current_playlist.control_cache, playlist->control_cache,
2809         sizeof(current_playlist.control_cache));
2810     current_playlist.num_cached = playlist->num_cached;
2811     current_playlist.pending_control_sync = playlist->pending_control_sync;
2812
2813     return 0;
2814 }
2815 struct playlist_info *playlist_get_current(void)
2816 {
2817     return &current_playlist;
2818 }
2819 /*
2820  * Close files and delete control file for non-current playlist.
2821  */
2822 void playlist_close(struct playlist_info* playlist)
2823 {
2824     if (!playlist)
2825         return;
2826
2827     if (playlist->fd >= 0)
2828         close(playlist->fd);
2829
2830     if (playlist->control_fd >= 0)
2831         close(playlist->control_fd);
2832
2833     if (playlist->control_created)
2834         remove(playlist->control_filename);
2835 }
2836
2837 void playlist_sync(struct playlist_info* playlist)
2838 {
2839     if (!playlist)
2840         playlist = &current_playlist;
2841
2842     sync_control(playlist, false);
2843     if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
2844         audio_flush_and_reload_tracks();
2845
2846 #ifdef HAVE_DIRCACHE
2847     queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
2848 #endif
2849 }
2850
2851 /*
2852  * Insert track into playlist at specified position (or one of the special
2853  * positions).  Returns position where track was inserted or -1 if error.
2854  */
2855 int playlist_insert_track(struct playlist_info* playlist, const char *filename,
2856                           int position, bool queue, bool sync)
2857 {
2858     int result;
2859
2860     if (!playlist)
2861         playlist = &current_playlist;
2862
2863     if (check_control(playlist) < 0)
2864     {
2865         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2866         return -1;
2867     }
2868
2869     result = add_track_to_playlist(playlist, filename, position, queue, -1);
2870
2871     /* Check if we want manually sync later. For example when adding
2872      * bunch of files from tagcache, syncing after every file wouldn't be
2873      * a good thing to do. */
2874     if (sync && result >= 0)
2875         playlist_sync(playlist);
2876
2877     return result;
2878 }
2879
2880 /*
2881  * Insert all tracks from specified directory into playlist.
2882  */
2883 int playlist_insert_directory(struct playlist_info* playlist,
2884                               const char *dirname, int position, bool queue,
2885                               bool recurse)
2886 {
2887     int result;
2888     unsigned char *count_str;
2889     struct directory_search_context context;
2890
2891     if (!playlist)
2892         playlist = &current_playlist;
2893
2894     if (check_control(playlist) < 0)
2895     {
2896         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2897         return -1;
2898     }
2899
2900     if (position == PLAYLIST_REPLACE)
2901     {
2902         if (playlist_remove_all_tracks(playlist) == 0)
2903             position = PLAYLIST_INSERT_LAST;
2904         else
2905             return -1;
2906     }
2907
2908     if (queue)
2909         count_str = ID2P(LANG_PLAYLIST_QUEUE_COUNT);
2910     else
2911         count_str = ID2P(LANG_PLAYLIST_INSERT_COUNT);
2912
2913     display_playlist_count(0, count_str, false);
2914
2915     context.playlist = playlist;
2916     context.position = position;
2917     context.queue = queue;
2918     context.count = 0;
2919
2920     cpu_boost(true);
2921
2922     result = playlist_directory_tracksearch(dirname, recurse,
2923         directory_search_callback, &context);
2924
2925     sync_control(playlist, false);
2926
2927     cpu_boost(false);
2928
2929     display_playlist_count(context.count, count_str, true);
2930
2931     if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
2932         audio_flush_and_reload_tracks();
2933
2934 #ifdef HAVE_DIRCACHE
2935     queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
2936 #endif
2937
2938     return result;
2939 }
2940
2941 /*
2942  * Insert all tracks from specified playlist into dynamic playlist.
2943  */
2944 int playlist_insert_playlist(struct playlist_info* playlist, const char *filename,
2945                              int position, bool queue)
2946 {
2947     int fd;
2948     int max;
2949     char *temp_ptr;
2950     const char *dir;
2951     unsigned char *count_str;
2952     char temp_buf[MAX_PATH+1];
2953     char trackname[MAX_PATH+1];
2954     int count = 0;
2955     int result = 0;
2956     bool utf8 = is_m3u8(filename);
2957
2958     if (!playlist)
2959         playlist = &current_playlist;
2960
2961     if (check_control(playlist) < 0)
2962     {
2963         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2964         return -1;
2965     }
2966
2967     fd = open_utf8(filename, O_RDONLY);
2968     if (fd < 0)
2969     {
2970         splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
2971         return -1;
2972     }
2973
2974     /* we need the directory name for formatting purposes */
2975     dir = filename;
2976
2977     temp_ptr = strrchr(filename+1,'/');
2978     if (temp_ptr)
2979         *temp_ptr = 0;
2980     else
2981         dir = "/";
2982
2983     if (queue)
2984         count_str = ID2P(LANG_PLAYLIST_QUEUE_COUNT);
2985     else
2986         count_str = ID2P(LANG_PLAYLIST_INSERT_COUNT);
2987
2988     display_playlist_count(count, count_str, false);
2989
2990     if (position == PLAYLIST_REPLACE)
2991     {
2992         if (playlist_remove_all_tracks(playlist) == 0)
2993             position = PLAYLIST_INSERT_LAST;
2994         else return -1;
2995     }
2996
2997     cpu_boost(true);
2998
2999     while ((max = read_line(fd, temp_buf, sizeof(temp_buf))) > 0)
3000     {
3001         /* user abort */
3002         if (action_userabort(TIMEOUT_NOBLOCK))
3003             break;
3004
3005         if (temp_buf[0] != '#' && temp_buf[0] != '\0')
3006         {
3007             int insert_pos;
3008
3009             if (!utf8)
3010             {
3011                 /* Use trackname as a temporay buffer. Note that trackname must
3012                  * be as large as temp_buf.
3013                  */
3014                 max = convert_m3u(temp_buf, max, sizeof(temp_buf), trackname);
3015             }
3016
3017             /* we need to format so that relative paths are correctly
3018                handled */
3019             if (format_track_path(trackname, temp_buf, sizeof(trackname), max,
3020                     dir) < 0)
3021             {
3022                 result = -1;
3023                 break;
3024             }
3025
3026             insert_pos = add_track_to_playlist(playlist, trackname, position,
3027                 queue, -1);
3028
3029             if (insert_pos < 0)
3030             {
3031                 result = -1;
3032                 break;
3033             }
3034
3035             /* Make sure tracks are inserted in correct order if user
3036                requests INSERT_FIRST */
3037             if (position == PLAYLIST_INSERT_FIRST || position >= 0)
3038                 position = insert_pos + 1;
3039
3040             count++;
3041
3042             if ((count%PLAYLIST_DISPLAY_COUNT) == 0)
3043             {
3044                 display_playlist_count(count, count_str, false);
3045
3046                 if (count == PLAYLIST_DISPLAY_COUNT &&
3047                     (audio_status() & AUDIO_STATUS_PLAY) &&
3048                     playlist->started)
3049                     audio_flush_and_reload_tracks();
3050             }
3051         }
3052
3053         /* let the other threads work */
3054         yield();
3055     }
3056
3057     close(fd);
3058
3059     if (temp_ptr)
3060         *temp_ptr = '/';
3061
3062     sync_control(playlist, false);
3063
3064     cpu_boost(false);
3065
3066     display_playlist_count(count, count_str, true);
3067
3068     if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
3069         audio_flush_and_reload_tracks();
3070
3071 #ifdef HAVE_DIRCACHE
3072     queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
3073 #endif
3074
3075     return result;
3076 }
3077
3078 /*
3079  * Delete track at specified index.  If index is PLAYLIST_DELETE_CURRENT then
3080  * we want to delete the current playing track.
3081  */
3082 int playlist_delete(struct playlist_info* playlist, int index)
3083 {
3084     int result = 0;
3085
3086     if (!playlist)
3087         playlist = &current_playlist;
3088
3089     if (check_control(playlist) < 0)
3090     {
3091         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
3092         return -1;
3093     }
3094
3095     if (index == PLAYLIST_DELETE_CURRENT)
3096         index = playlist->index;
3097
3098     result = remove_track_from_playlist(playlist, index, true);
3099
3100     if (result != -1 && (audio_status() & AUDIO_STATUS_PLAY) &&
3101         playlist->started)
3102         audio_flush_and_reload_tracks();
3103
3104     return result;
3105 }
3106
3107 /*
3108  * Move track at index to new_index.  Tracks between the two are shifted
3109  * appropriately.  Returns 0 on success and -1 on failure.
3110  */
3111 int playlist_move(struct playlist_info* playlist, int index, int new_index)
3112 {
3113     int result;
3114     int seek;
3115     bool control_file;
3116     bool queue;
3117     bool current = false;
3118     int r;
3119     char filename[MAX_PATH];
3120
3121     if (!playlist)
3122         playlist = &current_playlist;
3123
3124     if (check_control(playlist) < 0)
3125     {
3126         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
3127         return -1;
3128     }
3129
3130     if (index == new_index)
3131         return -1;
3132
3133     if (index == playlist->index)
3134         /* Moving the current track */
3135         current = true;
3136
3137     control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
3138     queue = playlist->indices[index] & PLAYLIST_QUEUE_MASK;
3139     seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
3140
3141     if (get_filename(playlist, index, seek, control_file, filename,
3142             sizeof(filename)) < 0)
3143         return -1;
3144
3145     /* We want to insert the track at the position that was specified by
3146        new_index.  This may be different then new_index because of the
3147        shifting that will occur after the delete.
3148        We calculate this before we do the remove as it depends on the
3149        size of the playlist before the track removal */
3150     r = rotate_index(playlist, new_index);
3151
3152     /* Delete track from original position */
3153     result = remove_track_from_playlist(playlist, index, true);
3154
3155     if (result != -1)
3156     {
3157         if (r == 0)
3158             /* First index */
3159             new_index = PLAYLIST_PREPEND;
3160         else if (r == playlist->amount)
3161             /* Append */
3162             new_index = PLAYLIST_INSERT_LAST;
3163         else
3164             /* Calculate index of desired position */
3165             new_index = (r+playlist->first_index)%playlist->amount;
3166
3167         result = add_track_to_playlist(playlist, filename, new_index, queue,
3168             -1);
3169
3170         if (result != -1)
3171         {
3172             if (current)
3173             {
3174                 /* Moved the current track */
3175                 switch (new_index)
3176                 {
3177                     case PLAYLIST_PREPEND:
3178                         playlist->index = playlist->first_index;
3179                         break;
3180                     case PLAYLIST_INSERT_LAST:
3181                         playlist->index = playlist->first_index - 1;
3182                         if (playlist->index < 0)
3183                             playlist->index += playlist->amount;
3184                         break;
3185                     default:
3186                         playlist->index = new_index;
3187                         break;
3188                 }
3189             }
3190
3191             if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
3192                 audio_flush_and_reload_tracks();
3193         }
3194     }
3195
3196 #ifdef HAVE_DIRCACHE
3197     queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
3198 #endif
3199
3200     return result;
3201 }
3202
3203 /* shuffle currently playing playlist */
3204 int playlist_randomise(struct playlist_info* playlist, unsigned int seed,
3205                        bool start_current)
3206 {
3207     int result;
3208
3209     if (!playlist)
3210         playlist = &current_playlist;
3211
3212     check_control(playlist);
3213
3214     result = randomise_playlist(playlist, seed, start_current, true);
3215
3216     if (result != -1 && (audio_status() & AUDIO_STATUS_PLAY) &&
3217         playlist->started)
3218         audio_flush_and_reload_tracks();
3219
3220     return result;
3221 }
3222
3223 /* sort currently playing playlist */
3224 int playlist_sort(struct playlist_info* playlist, bool start_current)
3225 {
3226     int result;
3227
3228     if (!playlist)
3229         playlist = &current_playlist;
3230
3231     check_control(playlist);
3232
3233     result = sort_playlist(playlist, start_current, true);
3234
3235     if (result != -1 && (audio_status() & AUDIO_STATUS_PLAY) &&
3236         playlist->started)
3237         audio_flush_and_reload_tracks();
3238
3239     return result;
3240 }
3241
3242 /* returns true if playlist has been modified */
3243 bool playlist_modified(const struct playlist_info* playlist)
3244 {
3245     if (!playlist)
3246         playlist = &current_playlist;
3247
3248     if (playlist->shuffle_modified ||
3249         playlist->deleted ||
3250         playlist->num_inserted_tracks > 0)
3251         return true;
3252
3253     return false;
3254 }
3255
3256 /* returns index of first track in playlist */
3257 int playlist_get_first_index(const struct playlist_info* playlist)
3258 {
3259     if (!playlist)
3260         playlist = &current_playlist;
3261
3262     return playlist->first_index;
3263 }
3264
3265 /* returns shuffle seed of playlist */
3266 int playlist_get_seed(const struct playlist_info* playlist)
3267 {
3268     if (!playlist)
3269         playlist = &current_playlist;
3270
3271     return playlist->seed;
3272 }
3273
3274 /* returns number of tracks in playlist (includes queued/inserted tracks) */
3275 int playlist_amount_ex(const struct playlist_info* playlist)
3276 {
3277     if (!playlist)
3278         playlist = &current_playlist;
3279
3280     return playlist->amount;
3281 }
3282
3283 /* returns full path of playlist (minus extension) */
3284 char *playlist_name(const struct playlist_info* playlist, char *buf,
3285                     int buf_size)
3286 {
3287     char *sep;
3288
3289     if (!playlist)
3290         playlist = &current_playlist;
3291
3292     strlcpy(buf, playlist->filename+playlist->dirlen, buf_size);
3293
3294     if (!buf[0])
3295         return NULL;
3296
3297     /* Remove extension */
3298     sep = strrchr(buf, '.');
3299     if (sep)
3300         *sep = 0;
3301
3302     return buf;
3303 }
3304
3305 /* returns the playlist filename */
3306 char *playlist_get_name(const struct playlist_info* playlist, char *buf,
3307                         int buf_size)
3308 {
3309     if (!playlist)
3310         playlist = &current_playlist;
3311
3312     strlcpy(buf, playlist->filename, buf_size);
3313
3314     if (!buf[0])
3315         return NULL;
3316
3317     return buf;
3318 }
3319
3320 /* Fills info structure with information about track at specified index.
3321    Returns 0 on success and -1 on failure */
3322 int playlist_get_track_info(struct playlist_info* playlist, int index,
3323                             struct playlist_track_info* info)
3324 {
3325     int seek;
3326     bool control_file;
3327
3328     if (!playlist)
3329         playlist = &current_playlist;
3330
3331     if (index < 0 || index >= playlist->amount)
3332         return -1;
3333
3334     control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
3335     seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
3336
3337     if (get_filename(playlist, index, seek, control_file, info->filename,
3338             sizeof(info->filename)) < 0)
3339         return -1;
3340
3341     info->attr = 0;
3342
3343     if (control_file)
3344     {
3345         if (playlist->indices[index] & PLAYLIST_QUEUE_MASK)
3346             info->attr |= PLAYLIST_ATTR_QUEUED;
3347         else
3348             info->attr |= PLAYLIST_ATTR_INSERTED;
3349
3350     }
3351
3352     if (playlist->indices[index] & PLAYLIST_SKIPPED)
3353         info->attr |= PLAYLIST_ATTR_SKIPPED;
3354
3355     info->index = index;
3356     info->display_index = rotate_index(playlist, index) + 1;
3357
3358     return 0;
3359 }
3360
3361 /* save the current dynamic playlist to specified file */
3362 int playlist_save(struct playlist_info* playlist, char *filename)
3363 {
3364     int fd;
3365     int i, index;
3366     int count = 0;
3367     char path[MAX_PATH+1];
3368     char tmp_buf[MAX_PATH+1];
3369     int result = 0;
3370     bool overwrite_current = false;
3371     int* index_buf = NULL;
3372
3373     if (!playlist)
3374         playlist = &current_playlist;
3375
3376     if (playlist->amount <= 0)
3377         return -1;
3378
3379     /* use current working directory as base for pathname */
3380     if (format_track_path(path, filename, sizeof(tmp_buf),
3381                           strlen(filename)+1, getcwd(NULL, -1)) < 0)
3382         return -1;
3383
3384     if (!strncmp(playlist->filename, path, strlen(path)))
3385     {
3386         /* Attempting to overwrite current playlist file.*/
3387
3388         if (playlist->buffer_size < (int)(playlist->amount * sizeof(int)))
3389         {
3390             /* not enough buffer space to store updated indices */
3391             splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
3392             return -1;
3393         }
3394
3395         /* in_ram buffer is unused for m3u files so we'll use for storing
3396            updated indices */
3397         index_buf = (int*)playlist->buffer;
3398
3399         /* use temporary pathname */
3400         snprintf(path, sizeof(path), "%s_temp", playlist->filename);
3401         overwrite_current = true;
3402     }
3403
3404     if (is_m3u8(path))
3405     {
3406         fd = open_utf8(path, O_CREAT|O_WRONLY|O_TRUNC);
3407     }
3408     else
3409     {
3410         /* some applications require a BOM to read the file properly */
3411         fd = open(path, O_CREAT|O_WRONLY|O_TRUNC, 0666);
3412     }
3413     if (fd < 0)
3414     {
3415         splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
3416         return -1;
3417     }
3418
3419     display_playlist_count(count, ID2P(LANG_PLAYLIST_SAVE_COUNT), false);
3420
3421     cpu_boost(true);
3422
3423     index = playlist->first_index;
3424     for (i=0; i<playlist->amount; i++)
3425     {
3426         bool control_file;
3427         bool queue;
3428         int seek;
3429
3430         /* user abort */
3431         if (action_userabort(TIMEOUT_NOBLOCK))
3432         {
3433             result = -1;
3434             break;
3435         }
3436
3437         control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
3438         queue = playlist->indices[index] & PLAYLIST_QUEUE_MASK;
3439         seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
3440
3441         /* Don't save queued files */
3442         if (!queue)
3443         {
3444             if (get_filename(playlist, index, seek, control_file, tmp_buf,
3445                     MAX_PATH+1) < 0)
3446             {
3447                 result = -1;
3448                 break;
3449             }
3450
3451             if (overwrite_current)
3452                 index_buf[count] = lseek(fd, 0, SEEK_CUR);
3453
3454             if (fdprintf(fd, "%s\n", tmp_buf) < 0)
3455             {
3456                 splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
3457                 result = -1;
3458                 break;
3459             }
3460
3461             count++;
3462
3463             if ((count % PLAYLIST_DISPLAY_COUNT) == 0)
3464                 display_playlist_count(count, ID2P(LANG_PLAYLIST_SAVE_COUNT),
3465                                        false);
3466
3467             yield();
3468         }
3469
3470         index = (index+1)%playlist->amount;
3471     }
3472
3473     display_playlist_count(count, ID2P(LANG_PLAYLIST_SAVE_COUNT), true);
3474
3475     close(fd);
3476
3477     if (overwrite_current && result >= 0)
3478     {
3479         result = -1;
3480
3481         mutex_lock(playlist->control_mutex);
3482
3483         /* Replace the current playlist with the new one and update indices */
3484         close(playlist->fd);
3485         if (remove(playlist->filename) >= 0)
3486         {
3487             if (rename(path, playlist->filename) >= 0)
3488             {
3489                 playlist->fd = open_utf8(playlist->filename, O_RDONLY);
3490                 if (playlist->fd >= 0)
3491                 {
3492                     index = playlist->first_index;
3493                     for (i=0, count=0; i<playlist->amount; i++)
3494                     {
3495                         if (!(playlist->indices[index] & PLAYLIST_QUEUE_MASK))
3496                         {
3497                             playlist->indices[index] = index_buf[count];
3498                             count++;
3499                         }
3500                         index = (index+1)%playlist->amount;
3501                     }
3502
3503                     /* we need to recreate control because inserted tracks are
3504                        now part of the playlist and shuffle has been
3505                        invalidated */
3506                     result = recreate_control(playlist);
3507                 }
3508             }
3509        }
3510
3511        mutex_unlock(playlist->control_mutex);
3512
3513     }
3514
3515     cpu_boost(false);
3516
3517     return result;
3518 }
3519
3520 /*
3521  * Search specified directory for tracks and notify via callback.  May be
3522  * called recursively.
3523  */
3524 int playlist_directory_tracksearch(const char* dirname, bool recurse,
3525                                    int (*callback)(char*, void*),
3526                                    void* context)
3527 {
3528     char buf[MAX_PATH+1];
3529     int result = 0;
3530     int num_files = 0;
3531     int i;
3532     struct entry *files;
3533     struct tree_context* tc = tree_get_context();
3534     int old_dirfilter = *(tc->dirfilter);
3535
3536     if (!callback)
3537         return -1;
3538
3539     /* use the tree browser dircache to load files */
3540     *(tc->dirfilter) = SHOW_ALL;
3541
3542     if (ft_load(tc, dirname) < 0)
3543     {
3544         splash(HZ*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR));
3545         *(tc->dirfilter) = old_dirfilter;
3546         return -1;
3547     }
3548
3549     files = (struct entry*) tc->dircache;
3550     num_files = tc->filesindir;
3551
3552     /* we've overwritten the dircache so tree browser will need to be
3553        reloaded */
3554     reload_directory();
3555
3556     for (i=0; i<num_files; i++)
3557     {
3558         /* user abort */
3559         if (action_userabort(TIMEOUT_NOBLOCK))
3560         {
3561             result = -1;
3562             break;
3563         }
3564
3565         if (files[i].attr & ATTR_DIRECTORY)
3566         {
3567             if (recurse)
3568             {
3569                 /* recursively add directories */
3570                 snprintf(buf, sizeof(buf), "%s/%s",
3571                             dirname[1]? dirname: "", files[i].name);
3572                 result = playlist_directory_tracksearch(buf, recurse,
3573                     callback, context);
3574                 if (result < 0)
3575                     break;
3576
3577                 /* we now need to reload our current directory */
3578                 if(ft_load(tc, dirname) < 0)
3579                 {
3580                     result = -1;
3581                     break;
3582                 }
3583
3584                 files = (struct entry*) tc->dircache;
3585                 num_files = tc->filesindir;
3586                 if (!num_files)
3587                 {
3588                     result = -1;
3589                     break;
3590                 }
3591             }
3592             else
3593                 continue;
3594         }
3595         else if ((files[i].attr & FILE_ATTR_MASK) == FILE_ATTR_AUDIO)
3596         {
3597             snprintf(buf, sizeof(buf), "%s/%s",
3598                         dirname[1]? dirname: "", files[i].name);
3599
3600             if (callback(buf, context) != 0)
3601             {
3602                 result = -1;
3603                 break;
3604             }
3605
3606             /* let the other threads work */
3607             yield();
3608         }
3609     }
3610
3611     /* restore dirfilter */
3612     *(tc->dirfilter) = old_dirfilter;
3613
3614     return result;
3615 }