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