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