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