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, 0, playlist->max_playlist_size * sizeof(int));
1006     queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
1007 #endif
1008
1009     if (start_current)
1010         find_and_set_playlist_index(playlist, current);
1011
1012     /* indices have been moved so last insert position is no longer valid */
1013     playlist->last_insert_pos = -1;
1014
1015     if (!playlist->num_inserted_tracks && !playlist->deleted)
1016         playlist->shuffle_modified = false;
1017     if (write && playlist->control_fd >= 0)
1018     {
1019         playlist->first_index = 0;
1020         update_control(playlist, PLAYLIST_COMMAND_UNSHUFFLE,
1021             playlist->first_index, -1, NULL, NULL, NULL);
1022     }
1023
1024     return 0;
1025 }
1026
1027 /* Calculate how many steps we have to really step when skipping entries
1028  * marked as bad.
1029  */
1030 static int calculate_step_count(const struct playlist_info *playlist, int steps)
1031 {
1032     int i, count, direction;
1033     int index;
1034     int stepped_count = 0;
1035
1036     if (steps < 0)
1037     {
1038         direction = -1;
1039         count = -steps;
1040     }
1041     else
1042     {
1043         direction = 1;
1044         count = steps;
1045     }
1046
1047     index = playlist->index;
1048     i = 0;
1049     do {
1050         /* Boundary check */
1051         if (index < 0)
1052             index += playlist->amount;
1053         if (index >= playlist->amount)
1054             index -= playlist->amount;
1055
1056         /* Check if we found a bad entry. */
1057         if (playlist->indices[index] & PLAYLIST_SKIPPED)
1058         {
1059             steps += direction;
1060             /* Are all entries bad? */
1061             if (stepped_count++ > playlist->amount)
1062                 break ;
1063         }
1064         else
1065             i++;
1066
1067         index += direction;
1068     } while (i <= count);
1069
1070     return steps;
1071 }
1072
1073 /* Marks the index of the track to be skipped that is "steps" away from
1074  * current playing track.
1075  */
1076 void playlist_skip_entry(struct playlist_info *playlist, int steps)
1077 {
1078     int index;
1079
1080     if (playlist == NULL)
1081         playlist = &current_playlist;
1082
1083     /* need to account for already skipped tracks */
1084     steps = calculate_step_count(playlist, steps);
1085
1086     index = playlist->index + steps;
1087     if (index < 0)
1088         index += playlist->amount;
1089     else if (index >= playlist->amount)
1090         index -= playlist->amount;
1091
1092     playlist->indices[index] |= PLAYLIST_SKIPPED;
1093 }
1094
1095 /*
1096  * returns the index of the track that is "steps" away from current playing
1097  * track.
1098  */
1099 static int get_next_index(const struct playlist_info* playlist, int steps,
1100                           int repeat_mode)
1101 {
1102     int current_index = playlist->index;
1103     int next_index    = -1;
1104
1105     if (playlist->amount <= 0)
1106         return -1;
1107
1108     if (repeat_mode == -1)
1109         repeat_mode = global_settings.repeat_mode;
1110
1111     if (repeat_mode == REPEAT_SHUFFLE && playlist->amount <= 1)
1112         repeat_mode = REPEAT_ALL;
1113
1114     steps = calculate_step_count(playlist, steps);
1115     switch (repeat_mode)
1116     {
1117         case REPEAT_SHUFFLE:
1118             /* Treat repeat shuffle just like repeat off.  At end of playlist,
1119                play will be resumed in playlist_next() */
1120         case REPEAT_OFF:
1121         {
1122             current_index = rotate_index(playlist, current_index);
1123             next_index = current_index+steps;
1124             if ((next_index < 0) || (next_index >= playlist->amount))
1125                 next_index = -1;
1126             else
1127                 next_index = (next_index+playlist->first_index) %
1128                     playlist->amount;
1129
1130             break;
1131         }
1132
1133         case REPEAT_ONE:
1134 #ifdef AB_REPEAT_ENABLE
1135         case REPEAT_AB:
1136 #endif
1137             next_index = current_index;
1138             break;
1139
1140         case REPEAT_ALL:
1141         default:
1142         {
1143             next_index = (current_index+steps) % playlist->amount;
1144             while (next_index < 0)
1145                 next_index += playlist->amount;
1146
1147             if (steps >= playlist->amount)
1148             {
1149                 int i, index;
1150
1151                 index = next_index;
1152                 next_index = -1;
1153
1154                 /* second time around so skip the queued files */
1155                 for (i=0; i<playlist->amount; i++)
1156                 {
1157                     if (playlist->indices[index] & PLAYLIST_QUEUE_MASK)
1158                         index = (index+1) % playlist->amount;
1159                     else
1160                     {
1161                         next_index = index;
1162                         break;
1163                     }
1164                 }
1165             }
1166             break;
1167         }
1168     }
1169
1170     /* No luck if the whole playlist was bad. */
1171     if (playlist->indices[next_index] & PLAYLIST_SKIPPED)
1172         return -1;
1173
1174     return next_index;
1175 }
1176
1177 /*
1178  * Search for the seek track and set appropriate indices.  Used after shuffle
1179  * to make sure the current index is still pointing to correct track.
1180  */
1181 static void find_and_set_playlist_index(struct playlist_info* playlist,
1182                                         unsigned int seek)
1183 {
1184     int i;
1185
1186     /* Set the index to the current song */
1187     for (i=0; i<playlist->amount; i++)
1188     {
1189         if (playlist->indices[i] == seek)
1190         {
1191             playlist->index = playlist->first_index = i;
1192
1193             break;
1194         }
1195     }
1196 }
1197
1198 /*
1199  * used to sort track indices.  Sort order is as follows:
1200  * 1. Prepended tracks (in prepend order)
1201  * 2. Playlist/directory tracks (in playlist order)
1202  * 3. Inserted/Appended tracks (in insert order)
1203  */
1204 static int compare(const void* p1, const void* p2)
1205 {
1206     unsigned long* e1 = (unsigned long*) p1;
1207     unsigned long* e2 = (unsigned long*) p2;
1208     unsigned long flags1 = *e1 & PLAYLIST_INSERT_TYPE_MASK;
1209     unsigned long flags2 = *e2 & PLAYLIST_INSERT_TYPE_MASK;
1210
1211     if (flags1 == flags2)
1212         return (*e1 & PLAYLIST_SEEK_MASK) - (*e2 & PLAYLIST_SEEK_MASK);
1213     else if (flags1 == PLAYLIST_INSERT_TYPE_PREPEND ||
1214         flags2 == PLAYLIST_INSERT_TYPE_APPEND)
1215         return -1;
1216     else if (flags1 == PLAYLIST_INSERT_TYPE_APPEND ||
1217         flags2 == PLAYLIST_INSERT_TYPE_PREPEND)
1218         return 1;
1219     else if (flags1 && flags2)
1220         return (*e1 & PLAYLIST_SEEK_MASK) - (*e2 & PLAYLIST_SEEK_MASK);
1221     else
1222         return *e1 - *e2;
1223 }
1224
1225 #ifdef HAVE_DIRCACHE
1226 /**
1227  * Thread to update filename pointers to dircache on background
1228  * without affecting playlist load up performance.  This thread also flushes
1229  * any pending control commands when the disk spins up.
1230  */
1231 static void playlist_flush_callback(void *param)
1232 {
1233     (void)param;
1234     struct playlist_info *playlist;
1235     playlist = &current_playlist;
1236     if (playlist->control_fd >= 0)
1237     {
1238         if (playlist->num_cached > 0)
1239         {
1240             mutex_lock(playlist->control_mutex);
1241             flush_cached_control(playlist);
1242             mutex_unlock(playlist->control_mutex);
1243         }
1244         sync_control(playlist, true);
1245     }
1246 }
1247
1248 static 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, 0,
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 playlist != NULL).  The
2697  * temp_buffer is used as a scratchpad when loading indices.
2698  *
2699  * returns <0 on failure
2700  */
2701 int playlist_create_ex(struct playlist_info* playlist,
2702                        const char* dir, const char* file,
2703                        void* index_buffer, int index_buffer_size,
2704                        void* temp_buffer, int temp_buffer_size)
2705 {
2706     if (!playlist)
2707         playlist = &current_playlist;
2708     else
2709     {
2710         if (!index_buffer)
2711             return -1;
2712         /* Initialize playlist structure */
2713         int r = rand() % 10;
2714         playlist->current = false;
2715
2716         /* Use random name for control file */
2717         snprintf(playlist->control_filename, sizeof(playlist->control_filename),
2718             "%s.%d", PLAYLIST_CONTROL_FILE, r);
2719         playlist->fd = -1;
2720         playlist->control_fd = -1;
2721
2722         int num_indices = index_buffer_size / sizeof(int);
2723
2724 #ifdef HAVE_DIRCACHE
2725         num_indices /= 2;
2726 #endif
2727         if (num_indices > global_settings.max_files_in_playlist)
2728             num_indices = global_settings.max_files_in_playlist;
2729
2730         playlist->max_playlist_size = num_indices;
2731         playlist->indices = index_buffer;
2732 #ifdef HAVE_DIRCACHE
2733             playlist->filenames = (int*)&playlist->indices[num_indices];
2734 #endif
2735
2736         playlist->buffer_size = 0;
2737         playlist->buffer = NULL;
2738         playlist->control_mutex = &created_playlist_mutex;
2739     }
2740
2741     new_playlist(playlist, dir, file);
2742
2743     if (file)
2744         /* load the playlist file */
2745         add_indices_to_playlist(playlist, temp_buffer, temp_buffer_size);
2746
2747     return 0;
2748 }
2749
2750 /*
2751  * Set the specified playlist as the current.
2752  * NOTE: You will get undefined behaviour if something is already playing so
2753  *       remember to stop before calling this.  Also, this call will
2754  *       effectively close your playlist, making it unusable.
2755  */
2756 int playlist_set_current(struct playlist_info* playlist)
2757 {
2758     if (!playlist || (check_control(playlist) < 0))
2759         return -1;
2760
2761     empty_playlist(&current_playlist, false);
2762
2763     strlcpy(current_playlist.filename, playlist->filename,
2764         sizeof(current_playlist.filename));
2765
2766     current_playlist.utf8 = playlist->utf8;
2767     current_playlist.fd = playlist->fd;
2768
2769     close(playlist->control_fd);
2770     close(current_playlist.control_fd);
2771     remove(current_playlist.control_filename);
2772     if (rename(playlist->control_filename,
2773             current_playlist.control_filename) < 0)
2774         return -1;
2775     current_playlist.control_fd = open(current_playlist.control_filename,
2776         O_RDWR);
2777     if (current_playlist.control_fd < 0)
2778         return -1;
2779     current_playlist.control_created = true;
2780
2781     current_playlist.dirlen = playlist->dirlen;
2782
2783     if (playlist->indices && playlist->indices != current_playlist.indices)
2784     {
2785         memcpy(current_playlist.indices, playlist->indices,
2786                playlist->max_playlist_size*sizeof(int));
2787 #ifdef HAVE_DIRCACHE
2788         memcpy(current_playlist.filenames, playlist->filenames,
2789                playlist->max_playlist_size*sizeof(int));
2790 #endif
2791     }
2792
2793     current_playlist.first_index = playlist->first_index;
2794     current_playlist.amount = playlist->amount;
2795     current_playlist.last_insert_pos = playlist->last_insert_pos;
2796     current_playlist.seed = playlist->seed;
2797     current_playlist.shuffle_modified = playlist->shuffle_modified;
2798     current_playlist.deleted = playlist->deleted;
2799     current_playlist.num_inserted_tracks = playlist->num_inserted_tracks;
2800
2801     memcpy(current_playlist.control_cache, playlist->control_cache,
2802         sizeof(current_playlist.control_cache));
2803     current_playlist.num_cached = playlist->num_cached;
2804     current_playlist.pending_control_sync = playlist->pending_control_sync;
2805
2806     return 0;
2807 }
2808 struct playlist_info *playlist_get_current(void)
2809 {
2810     return &current_playlist;
2811 }
2812 /*
2813  * Close files and delete control file for non-current playlist.
2814  */
2815 void playlist_close(struct playlist_info* playlist)
2816 {
2817     if (!playlist)
2818         return;
2819
2820     if (playlist->fd >= 0)
2821         close(playlist->fd);
2822
2823     if (playlist->control_fd >= 0)
2824         close(playlist->control_fd);
2825
2826     if (playlist->control_created)
2827         remove(playlist->control_filename);
2828 }
2829
2830 void playlist_sync(struct playlist_info* playlist)
2831 {
2832     if (!playlist)
2833         playlist = &current_playlist;
2834
2835     sync_control(playlist, false);
2836     if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
2837         audio_flush_and_reload_tracks();
2838
2839 #ifdef HAVE_DIRCACHE
2840     queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
2841 #endif
2842 }
2843
2844 /*
2845  * Insert track into playlist at specified position (or one of the special
2846  * positions).  Returns position where track was inserted or -1 if error.
2847  */
2848 int playlist_insert_track(struct playlist_info* playlist, const char *filename,
2849                           int position, bool queue, bool sync)
2850 {
2851     int result;
2852
2853     if (!playlist)
2854         playlist = &current_playlist;
2855
2856     if (check_control(playlist) < 0)
2857     {
2858         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2859         return -1;
2860     }
2861
2862     result = add_track_to_playlist(playlist, filename, position, queue, -1);
2863
2864     /* Check if we want manually sync later. For example when adding
2865      * bunch of files from tagcache, syncing after every file wouldn't be
2866      * a good thing to do. */
2867     if (sync && result >= 0)
2868         playlist_sync(playlist);
2869
2870     return result;
2871 }
2872
2873 /*
2874  * Insert all tracks from specified directory into playlist.
2875  */
2876 int playlist_insert_directory(struct playlist_info* playlist,
2877                               const char *dirname, int position, bool queue,
2878                               bool recurse)
2879 {
2880     int result;
2881     unsigned char *count_str;
2882     struct directory_search_context context;
2883
2884     if (!playlist)
2885         playlist = &current_playlist;
2886
2887     if (check_control(playlist) < 0)
2888     {
2889         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2890         return -1;
2891     }
2892
2893     if (position == PLAYLIST_REPLACE)
2894     {
2895         if (playlist_remove_all_tracks(playlist) == 0)
2896             position = PLAYLIST_INSERT_LAST;
2897         else
2898             return -1;
2899     }
2900
2901     if (queue)
2902         count_str = ID2P(LANG_PLAYLIST_QUEUE_COUNT);
2903     else
2904         count_str = ID2P(LANG_PLAYLIST_INSERT_COUNT);
2905
2906     display_playlist_count(0, count_str, false);
2907
2908     context.playlist = playlist;
2909     context.position = position;
2910     context.queue = queue;
2911     context.count = 0;
2912
2913     cpu_boost(true);
2914
2915     result = playlist_directory_tracksearch(dirname, recurse,
2916         directory_search_callback, &context);
2917
2918     sync_control(playlist, false);
2919
2920     cpu_boost(false);
2921
2922     display_playlist_count(context.count, count_str, true);
2923
2924     if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
2925         audio_flush_and_reload_tracks();
2926
2927 #ifdef HAVE_DIRCACHE
2928     queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
2929 #endif
2930
2931     return result;
2932 }
2933
2934 /*
2935  * Insert all tracks from specified playlist into dynamic playlist.
2936  */
2937 int playlist_insert_playlist(struct playlist_info* playlist, const char *filename,
2938                              int position, bool queue)
2939 {
2940     int fd;
2941     int max;
2942     char *temp_ptr;
2943     const char *dir;
2944     unsigned char *count_str;
2945     char temp_buf[MAX_PATH+1];
2946     char trackname[MAX_PATH+1];
2947     int count = 0;
2948     int result = 0;
2949     bool utf8 = is_m3u8(filename);
2950
2951     if (!playlist)
2952         playlist = &current_playlist;
2953
2954     if (check_control(playlist) < 0)
2955     {
2956         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2957         return -1;
2958     }
2959
2960     fd = open_utf8(filename, O_RDONLY);
2961     if (fd < 0)
2962     {
2963         splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
2964         return -1;
2965     }
2966
2967     /* we need the directory name for formatting purposes */
2968     dir = filename;
2969
2970     temp_ptr = strrchr(filename+1,'/');
2971     if (temp_ptr)
2972         *temp_ptr = 0;
2973     else
2974         dir = "/";
2975
2976     if (queue)
2977         count_str = ID2P(LANG_PLAYLIST_QUEUE_COUNT);
2978     else
2979         count_str = ID2P(LANG_PLAYLIST_INSERT_COUNT);
2980
2981     display_playlist_count(count, count_str, false);
2982
2983     if (position == PLAYLIST_REPLACE)
2984     {
2985         if (playlist_remove_all_tracks(playlist) == 0)
2986             position = PLAYLIST_INSERT_LAST;
2987         else return -1;
2988     }
2989
2990     cpu_boost(true);
2991
2992     while ((max = read_line(fd, temp_buf, sizeof(temp_buf))) > 0)
2993     {
2994         /* user abort */
2995         if (action_userabort(TIMEOUT_NOBLOCK))
2996             break;
2997
2998         if (temp_buf[0] != '#' && temp_buf[0] != '\0')
2999         {
3000             int insert_pos;
3001
3002             if (!utf8)
3003             {
3004                 /* Use trackname as a temporay buffer. Note that trackname must
3005                  * be as large as temp_buf.
3006                  */
3007                 max = convert_m3u(temp_buf, max, sizeof(temp_buf), trackname);
3008             }
3009
3010             /* we need to format so that relative paths are correctly
3011                handled */
3012             if (format_track_path(trackname, temp_buf, sizeof(trackname), max,
3013                     dir) < 0)
3014             {
3015                 result = -1;
3016                 break;
3017             }
3018
3019             insert_pos = add_track_to_playlist(playlist, trackname, position,
3020                 queue, -1);
3021
3022             if (insert_pos < 0)
3023             {
3024                 result = -1;
3025                 break;
3026             }
3027
3028             /* Make sure tracks are inserted in correct order if user
3029                requests INSERT_FIRST */
3030             if (position == PLAYLIST_INSERT_FIRST || position >= 0)
3031                 position = insert_pos + 1;
3032
3033             count++;
3034
3035             if ((count%PLAYLIST_DISPLAY_COUNT) == 0)
3036             {
3037                 display_playlist_count(count, count_str, false);
3038
3039                 if (count == PLAYLIST_DISPLAY_COUNT &&
3040                     (audio_status() & AUDIO_STATUS_PLAY) &&
3041                     playlist->started)
3042                     audio_flush_and_reload_tracks();
3043             }
3044         }
3045
3046         /* let the other threads work */
3047         yield();
3048     }
3049
3050     close(fd);
3051
3052     if (temp_ptr)
3053         *temp_ptr = '/';
3054
3055     sync_control(playlist, false);
3056
3057     cpu_boost(false);
3058
3059     display_playlist_count(count, count_str, true);
3060
3061     if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
3062         audio_flush_and_reload_tracks();
3063
3064 #ifdef HAVE_DIRCACHE
3065     queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
3066 #endif
3067
3068     return result;
3069 }
3070
3071 /*
3072  * Delete track at specified index.  If index is PLAYLIST_DELETE_CURRENT then
3073  * we want to delete the current playing track.
3074  */
3075 int playlist_delete(struct playlist_info* playlist, int index)
3076 {
3077     int result = 0;
3078
3079     if (!playlist)
3080         playlist = &current_playlist;
3081
3082     if (check_control(playlist) < 0)
3083     {
3084         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
3085         return -1;
3086     }
3087
3088     if (index == PLAYLIST_DELETE_CURRENT)
3089         index = playlist->index;
3090
3091     result = remove_track_from_playlist(playlist, index, true);
3092
3093     if (result != -1 && (audio_status() & AUDIO_STATUS_PLAY) &&
3094         playlist->started)
3095         audio_flush_and_reload_tracks();
3096
3097     return result;
3098 }
3099
3100 /*
3101  * Move track at index to new_index.  Tracks between the two are shifted
3102  * appropriately.  Returns 0 on success and -1 on failure.
3103  */
3104 int playlist_move(struct playlist_info* playlist, int index, int new_index)
3105 {
3106     int result;
3107     int seek;
3108     bool control_file;
3109     bool queue;
3110     bool current = false;
3111     int r;
3112     char filename[MAX_PATH];
3113
3114     if (!playlist)
3115         playlist = &current_playlist;
3116
3117     if (check_control(playlist) < 0)
3118     {
3119         splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
3120         return -1;
3121     }
3122
3123     if (index == new_index)
3124         return -1;
3125
3126     if (index == playlist->index)
3127         /* Moving the current track */
3128         current = true;
3129
3130     control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
3131     queue = playlist->indices[index] & PLAYLIST_QUEUE_MASK;
3132     seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
3133
3134     if (get_filename(playlist, index, seek, control_file, filename,
3135             sizeof(filename)) < 0)
3136         return -1;
3137
3138     /* We want to insert the track at the position that was specified by
3139        new_index.  This may be different then new_index because of the
3140        shifting that will occur after the delete.
3141        We calculate this before we do the remove as it depends on the
3142        size of the playlist before the track removal */
3143     r = rotate_index(playlist, new_index);
3144
3145     /* Delete track from original position */
3146     result = remove_track_from_playlist(playlist, index, true);
3147
3148     if (result != -1)
3149     {
3150         if (r == 0)
3151             /* First index */
3152             new_index = PLAYLIST_PREPEND;
3153         else if (r == playlist->amount)
3154             /* Append */
3155             new_index = PLAYLIST_INSERT_LAST;
3156         else
3157             /* Calculate index of desired position */
3158             new_index = (r+playlist->first_index)%playlist->amount;
3159
3160         result = add_track_to_playlist(playlist, filename, new_index, queue,
3161             -1);
3162
3163         if (result != -1)
3164         {
3165             if (current)
3166             {
3167                 /* Moved the current track */
3168                 switch (new_index)
3169                 {
3170                     case PLAYLIST_PREPEND:
3171                         playlist->index = playlist->first_index;
3172                         break;
3173                     case PLAYLIST_INSERT_LAST:
3174                         playlist->index = playlist->first_index - 1;
3175                         if (playlist->index < 0)
3176                             playlist->index += playlist->amount;
3177                         break;
3178                     default:
3179                         playlist->index = new_index;
3180                         break;
3181                 }
3182             }
3183
3184             if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
3185                 audio_flush_and_reload_tracks();
3186         }
3187     }
3188
3189 #ifdef HAVE_DIRCACHE
3190     queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
3191 #endif
3192
3193     return result;
3194 }
3195
3196 /* shuffle currently playing playlist */
3197 int playlist_randomise(struct playlist_info* playlist, unsigned int seed,
3198                        bool start_current)
3199 {
3200     int result;
3201
3202     if (!playlist)
3203         playlist = &current_playlist;
3204
3205     check_control(playlist);
3206
3207     result = randomise_playlist(playlist, seed, start_current, true);
3208
3209     if (result != -1 && (audio_status() & AUDIO_STATUS_PLAY) &&
3210         playlist->started)
3211         audio_flush_and_reload_tracks();
3212
3213     return result;
3214 }
3215
3216 /* sort currently playing playlist */
3217 int playlist_sort(struct playlist_info* playlist, bool start_current)
3218 {
3219     int result;
3220
3221     if (!playlist)
3222         playlist = &current_playlist;
3223
3224     check_control(playlist);
3225
3226     result = sort_playlist(playlist, start_current, true);
3227
3228     if (result != -1 && (audio_status() & AUDIO_STATUS_PLAY) &&
3229         playlist->started)
3230         audio_flush_and_reload_tracks();
3231
3232     return result;
3233 }
3234
3235 /* returns true if playlist has been modified */
3236 bool playlist_modified(const struct playlist_info* playlist)
3237 {
3238     if (!playlist)
3239         playlist = &current_playlist;
3240
3241     if (playlist->shuffle_modified ||
3242         playlist->deleted ||
3243         playlist->num_inserted_tracks > 0)
3244         return true;
3245
3246     return false;
3247 }
3248
3249 /* returns index of first track in playlist */
3250 int playlist_get_first_index(const struct playlist_info* playlist)
3251 {
3252     if (!playlist)
3253         playlist = &current_playlist;
3254
3255     return playlist->first_index;
3256 }
3257
3258 /* returns shuffle seed of playlist */
3259 int playlist_get_seed(const struct playlist_info* playlist)
3260 {
3261     if (!playlist)
3262         playlist = &current_playlist;
3263
3264     return playlist->seed;
3265 }
3266
3267 /* returns number of tracks in playlist (includes queued/inserted tracks) */
3268 int playlist_amount_ex(const struct playlist_info* playlist)
3269 {
3270     if (!playlist)
3271         playlist = &current_playlist;
3272
3273     return playlist->amount;
3274 }
3275
3276 /* returns full path of playlist (minus extension) */
3277 char *playlist_name(const struct playlist_info* playlist, char *buf,
3278                     int buf_size)
3279 {
3280     char *sep;
3281
3282     if (!playlist)
3283         playlist = &current_playlist;
3284
3285     strlcpy(buf, playlist->filename+playlist->dirlen, buf_size);
3286
3287     if (!buf[0])
3288         return NULL;
3289
3290     /* Remove extension */
3291     sep = strrchr(buf, '.');
3292     if (sep)
3293         *sep = 0;
3294
3295     return buf;
3296 }
3297
3298 /* returns the playlist filename */
3299 char *playlist_get_name(const struct playlist_info* playlist, char *buf,
3300                         int buf_size)
3301 {
3302     if (!playlist)
3303         playlist = &current_playlist;
3304
3305     strlcpy(buf, playlist->filename, buf_size);
3306
3307     if (!buf[0])
3308         return NULL;
3309
3310     return buf;
3311 }
3312
3313 /* Fills info structure with information about track at specified index.
3314    Returns 0 on success and -1 on failure */
3315 int playlist_get_track_info(struct playlist_info* playlist, int index,
3316                             struct playlist_track_info* info)
3317 {
3318     int seek;
3319     bool control_file;
3320
3321     if (!playlist)
3322         playlist = &current_playlist;
3323
3324     if (index < 0 || index >= playlist->amount)
3325         return -1;
3326
3327     control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
3328     seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
3329
3330     if (get_filename(playlist, index, seek, control_file, info->filename,
3331             sizeof(info->filename)) < 0)
3332         return -1;
3333
3334     info->attr = 0;
3335
3336     if (control_file)
3337     {
3338         if (playlist->indices[index] & PLAYLIST_QUEUE_MASK)
3339             info->attr |= PLAYLIST_ATTR_QUEUED;
3340         else
3341             info->attr |= PLAYLIST_ATTR_INSERTED;
3342
3343     }
3344
3345     if (playlist->indices[index] & PLAYLIST_SKIPPED)
3346         info->attr |= PLAYLIST_ATTR_SKIPPED;
3347
3348     info->index = index;
3349     info->display_index = rotate_index(playlist, index) + 1;
3350
3351     return 0;
3352 }
3353
3354 /* save the current dynamic playlist to specified file */
3355 int playlist_save(struct playlist_info* playlist, char *filename)
3356 {
3357     int fd;
3358     int i, index;
3359     int count = 0;
3360     char path[MAX_PATH+1];
3361     char tmp_buf[MAX_PATH+1];
3362     int result = 0;
3363     bool overwrite_current = false;
3364     int* index_buf = NULL;
3365
3366     if (!playlist)
3367         playlist = &current_playlist;
3368
3369     if (playlist->amount <= 0)
3370         return -1;
3371
3372     /* use current working directory as base for pathname */
3373     if (format_track_path(path, filename, sizeof(tmp_buf),
3374                           strlen(filename)+1, getcwd(NULL, -1)) < 0)
3375         return -1;
3376
3377     if (!strncmp(playlist->filename, path, strlen(path)))
3378     {
3379         /* Attempting to overwrite current playlist file.*/
3380
3381         if (playlist->buffer_size < (int)(playlist->amount * sizeof(int)))
3382         {
3383             /* not enough buffer space to store updated indices */
3384             splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
3385             return -1;
3386         }
3387
3388         /* in_ram buffer is unused for m3u files so we'll use for storing
3389            updated indices */
3390         index_buf = (int*)playlist->buffer;
3391
3392         /* use temporary pathname */
3393         snprintf(path, sizeof(path), "%s_temp", playlist->filename);
3394         overwrite_current = true;
3395     }
3396
3397     if (is_m3u8(path))
3398     {
3399         fd = open_utf8(path, O_CREAT|O_WRONLY|O_TRUNC);
3400     }
3401     else
3402     {
3403         /* some applications require a BOM to read the file properly */
3404         fd = open(path, O_CREAT|O_WRONLY|O_TRUNC, 0666);
3405     }
3406     if (fd < 0)
3407     {
3408         splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
3409         return -1;
3410     }
3411
3412     display_playlist_count(count, ID2P(LANG_PLAYLIST_SAVE_COUNT), false);
3413
3414     cpu_boost(true);
3415
3416     index = playlist->first_index;
3417     for (i=0; i<playlist->amount; i++)
3418     {
3419         bool control_file;
3420         bool queue;
3421         int seek;
3422
3423         /* user abort */
3424         if (action_userabort(TIMEOUT_NOBLOCK))
3425         {
3426             result = -1;
3427             break;
3428         }
3429
3430         control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
3431         queue = playlist->indices[index] & PLAYLIST_QUEUE_MASK;
3432         seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
3433
3434         /* Don't save queued files */
3435         if (!queue)
3436         {
3437             if (get_filename(playlist, index, seek, control_file, tmp_buf,
3438                     MAX_PATH+1) < 0)
3439             {
3440                 result = -1;
3441                 break;
3442             }
3443
3444             if (overwrite_current)
3445                 index_buf[count] = lseek(fd, 0, SEEK_CUR);
3446
3447             if (fdprintf(fd, "%s\n", tmp_buf) < 0)
3448             {
3449                 splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
3450                 result = -1;
3451                 break;
3452             }
3453
3454             count++;
3455
3456             if ((count % PLAYLIST_DISPLAY_COUNT) == 0)
3457                 display_playlist_count(count, ID2P(LANG_PLAYLIST_SAVE_COUNT),
3458                                        false);
3459
3460             yield();
3461         }
3462
3463         index = (index+1)%playlist->amount;
3464     }
3465
3466     display_playlist_count(count, ID2P(LANG_PLAYLIST_SAVE_COUNT), true);
3467
3468     close(fd);
3469
3470     if (overwrite_current && result >= 0)
3471     {
3472         result = -1;
3473
3474         mutex_lock(playlist->control_mutex);
3475
3476         /* Replace the current playlist with the new one and update indices */
3477         close(playlist->fd);
3478         if (remove(playlist->filename) >= 0)
3479         {
3480             if (rename(path, playlist->filename) >= 0)
3481             {
3482                 playlist->fd = open_utf8(playlist->filename, O_RDONLY);
3483                 if (playlist->fd >= 0)
3484                 {
3485                     index = playlist->first_index;
3486                     for (i=0, count=0; i<playlist->amount; i++)
3487                     {
3488                         if (!(playlist->indices[index] & PLAYLIST_QUEUE_MASK))
3489                         {
3490                             playlist->indices[index] = index_buf[count];
3491                             count++;
3492                         }
3493                         index = (index+1)%playlist->amount;
3494                     }
3495
3496                     /* we need to recreate control because inserted tracks are
3497                        now part of the playlist and shuffle has been
3498                        invalidated */
3499                     result = recreate_control(playlist);
3500                 }
3501             }
3502        }
3503
3504        mutex_unlock(playlist->control_mutex);
3505
3506     }
3507
3508     cpu_boost(false);
3509
3510     return result;
3511 }
3512
3513 /*
3514  * Search specified directory for tracks and notify via callback.  May be
3515  * called recursively.
3516  */
3517 int playlist_directory_tracksearch(const char* dirname, bool recurse,
3518                                    int (*callback)(char*, void*),
3519                                    void* context)
3520 {
3521     char buf[MAX_PATH+1];
3522     int result = 0;
3523     int num_files = 0;
3524     int i;
3525     struct entry *files;
3526     struct tree_context* tc = tree_get_context();
3527     int old_dirfilter = *(tc->dirfilter);
3528
3529     if (!callback)
3530         return -1;
3531
3532     /* use the tree browser dircache to load files */
3533     *(tc->dirfilter) = SHOW_ALL;
3534
3535     if (ft_load(tc, dirname) < 0)
3536     {
3537         splash(HZ*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR));
3538         *(tc->dirfilter) = old_dirfilter;
3539         return -1;
3540     }
3541
3542     files = (struct entry*) tc->dircache;
3543     num_files = tc->filesindir;
3544
3545     /* we've overwritten the dircache so tree browser will need to be
3546        reloaded */
3547     reload_directory();
3548
3549     for (i=0; i<num_files; i++)
3550     {
3551         /* user abort */
3552         if (action_userabort(TIMEOUT_NOBLOCK))
3553         {
3554             result = -1;
3555             break;
3556         }
3557
3558         if (files[i].attr & ATTR_DIRECTORY)
3559         {
3560             if (recurse)
3561             {
3562                 /* recursively add directories */
3563                 snprintf(buf, sizeof(buf), "%s/%s",
3564                             dirname[1]? dirname: "", files[i].name);
3565                 result = playlist_directory_tracksearch(buf, recurse,
3566                     callback, context);
3567                 if (result < 0)
3568                     break;
3569
3570                 /* we now need to reload our current directory */
3571                 if(ft_load(tc, dirname) < 0)
3572                 {
3573                     result = -1;
3574                     break;
3575                 }
3576
3577                 files = (struct entry*) tc->dircache;
3578                 num_files = tc->filesindir;
3579                 if (!num_files)
3580                 {
3581                     result = -1;
3582                     break;
3583                 }
3584             }
3585             else
3586                 continue;
3587         }
3588         else if ((files[i].attr & FILE_ATTR_MASK) == FILE_ATTR_AUDIO)
3589         {
3590             snprintf(buf, sizeof(buf), "%s/%s",
3591                         dirname[1]? dirname: "", files[i].name);
3592
3593             if (callback(buf, context) != 0)
3594             {
3595                 result = -1;
3596                 break;
3597             }
3598
3599             /* let the other threads work */
3600             yield();
3601         }
3602     }
3603
3604     /* restore dirfilter */
3605     *(tc->dirfilter) = old_dirfilter;
3606
3607     return result;
3608 }