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 "playlist.h"
  72 #include "file.h"
  73 #include "dir.h"
  74 #include "sprintf.h"
  75 #include "debug.h"
  76 #include "mpeg.h"
  77 #include "lcd.h"
  78 #include "kernel.h"
  79 #include "settings.h"
  80 #include "status.h"
  81 #include "applimits.h"
  82 #include "screens.h"
  83 #include "buffer.h"
  84 #include "atoi.h"
  85 #include "misc.h"
  86 #include "button.h"
  87 #include "filetree.h"
  88 #ifdef HAVE_LCD_BITMAP
  89 #include "icons.h"
  90 #include "widgets.h"
  91 #endif
  92
  93 #include "lang.h"
  94 #include "talk.h"
  95
  96 #define PLAYLIST_CONTROL_FILE ROCKBOX_DIR "/.playlist_control"
  97 #define PLAYLIST_CONTROL_FILE_VERSION 2
  98
  99 /*
 100     Each playlist index has a flag associated with it which identifies what
 101     type of track it is.  These flags are stored in the 3 high order bits of
 102     the index.
 103
 104     NOTE: This limits the playlist file size to a max of 512M.
 105
 106     Bits 31-30:
 107         00 = Playlist track
 108         01 = Track was prepended into playlist
 109         10 = Track was inserted into playlist
 110         11 = Track was appended into playlist
 111     Bit 29:
 112         0 = Added track
 113         1 = Queued track
 114  */
 115 #define PLAYLIST_SEEK_MASK              0x1FFFFFFF
 116 #define PLAYLIST_INSERT_TYPE_MASK       0xC0000000
 117 #define PLAYLIST_QUEUE_MASK             0x20000000
 118
 119 #define PLAYLIST_INSERT_TYPE_PREPEND    0x40000000
 120 #define PLAYLIST_INSERT_TYPE_INSERT     0x80000000
 121 #define PLAYLIST_INSERT_TYPE_APPEND     0xC0000000
 122
 123 #define PLAYLIST_QUEUED                 0x20000000
 124
 125 #define PLAYLIST_DISPLAY_COUNT          10
 126
 127 static struct playlist_info current_playlist;
 128 static char now_playing[MAX_PATH+1];
 129
 130 static void empty_playlist(struct playlist_info* playlist, bool resume);
 131 static void new_playlist(struct playlist_info* playlist, const char *dir,
 132                          const char *file);
 133 static void create_control(struct playlist_info* playlist);
 134 static int  check_control(struct playlist_info* playlist);
 135 static void update_playlist_filename(struct playlist_info* playlist,
 136                                      const char *dir, const char *file);
 137 static int add_indices_to_playlist(struct playlist_info* playlist,
 138                                    char* buffer, int buflen);
 139 static int add_track_to_playlist(struct playlist_info* playlist,
 140                                  const char *filename, int position,
 141                                  bool queue, int seek_pos);
 142 static int add_directory_to_playlist(struct playlist_info* playlist,
 143                                      const char *dirname, int *position, bool queue,
 144                                      int *count, bool recurse);
 145 static int remove_track_from_playlist(struct playlist_info* playlist,
 146                                       int position, bool write);
 147 static int randomise_playlist(struct playlist_info* playlist,
 148                               unsigned int seed, bool start_current,
 149                               bool write);
 150 static int sort_playlist(struct playlist_info* playlist, bool start_current,
 151                          bool write);
 152 static int get_next_index(const struct playlist_info* playlist, int steps);
 153 static void find_and_set_playlist_index(struct playlist_info* playlist,
 154                                         unsigned int seek);
 155 static int compare(const void* p1, const void* p2);
 156 static int get_filename(struct playlist_info* playlist, int seek,
 157                         bool control_file, char *buf, int buf_length);
 158 static int format_track_path(char *dest, char *src, int buf_length, int max,
 159                              char *dir);
 160 static void display_playlist_count(int count, const char *fmt);
 161 static void display_buffer_full(void);
 162 static int flush_pending_control(struct playlist_info* playlist);
 163 static int rotate_index(const struct playlist_info* playlist, int index);
 164
 165 /*
 166  * remove any files and indices associated with the playlist
 167  */
 168 static void empty_playlist(struct playlist_info* playlist, bool resume)
 169 {
 170     playlist->filename[0] = '\0';
 171
 172     if(playlist->fd >= 0)
 173         /* If there is an already open playlist, close it. */
 174         close(playlist->fd);
 175     playlist->fd = -1;
 176
 177     if(playlist->control_fd >= 0)
 178         close(playlist->control_fd);
 179     playlist->control_fd = -1;
 180     playlist->control_created = false;
 181
 182     playlist->in_ram = false;
 183
 184     if (playlist->buffer)
 185         playlist->buffer[0] = 0;
 186
 187     playlist->buffer_end_pos = 0;
 188
 189     playlist->index = 0;
 190     playlist->first_index = 0;
 191     playlist->amount = 0;
 192     playlist->last_insert_pos = -1;
 193     playlist->seed = 0;
 194     playlist->shuffle_modified = false;
 195     playlist->deleted = false;
 196     playlist->num_inserted_tracks = 0;
 197     playlist->shuffle_flush = false;
 198
 199     if (!resume && playlist->current)
 200     {
 201         /* start with fresh playlist control file when starting new
 202            playlist */
 203         create_control(playlist);
 204
 205         /* Reset resume settings */
 206         global_settings.resume_first_index = 0;
 207         global_settings.resume_seed = -1;
 208     }
 209 }
 210
 211 /*
 212  * Initialize a new playlist for viewing/editing/playing.  dir is the
 213  * directory where the playlist is located and file is the filename.
 214  */
 215 static void new_playlist(struct playlist_info* playlist, const char *dir,
 216                          const char *file)
 217 {
 218     empty_playlist(playlist, false);
 219
 220     if (!file)
 221     {
 222         file = "";
 223
 224         if (dir && playlist->current) /* !current cannot be in_ram */
 225             playlist->in_ram = true;
 226         else
 227             dir = ""; /* empty playlist */
 228     }
 229
 230     update_playlist_filename(playlist, dir, file);
 231
 232     if (playlist->control_fd >= 0)
 233     {
 234         if (fprintf(playlist->control_fd, "P:%d:%s:%s\n",
 235             PLAYLIST_CONTROL_FILE_VERSION, dir, file) > 0)
 236             fsync(playlist->control_fd);
 237         else
 238             splash(HZ*2, true, str(LANG_PLAYLIST_CONTROL_UPDATE_ERROR));
 239     }
 240 }
 241
 242 /*
 243  * create control file for playlist
 244  */
 245 static void create_control(struct playlist_info* playlist)
 246 {
 247     playlist->control_fd = creat(playlist->control_filename, 0000200);
 248     if (playlist->control_fd < 0)
 249     {
 250         if (check_rockboxdir())
 251         {
 252             splash(HZ*2, true, "%s (%d)", str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR),
 253                 playlist->control_fd);
 254         }
 255         playlist->control_created = false;
 256     }
 257     else
 258     {
 259         playlist->control_created = true;
 260     }
 261 }
 262
 263 /*
 264  * validate the control file.  This may include creating/initializing it if
 265  * necessary;
 266  */
 267 static int check_control(struct playlist_info* playlist)
 268 {
 269     if (!playlist->control_created)
 270     {
 271         create_control(playlist);
 272
 273         if (playlist->control_fd >= 0)
 274         {
 275             char* dir = playlist->filename;
 276             char* file = playlist->filename+playlist->dirlen;
 277             char c = playlist->filename[playlist->dirlen-1];
 278
 279             playlist->filename[playlist->dirlen-1] = '\0';
 280
 281             if (fprintf(playlist->control_fd, "P:%d:%s:%s\n",
 282                 PLAYLIST_CONTROL_FILE_VERSION, dir, file) > 0)
 283                 fsync(playlist->control_fd);
 284             else
 285                 splash(HZ*2, true, str(LANG_PLAYLIST_CONTROL_UPDATE_ERROR));
 286
 287             playlist->filename[playlist->dirlen-1] = c;
 288         }
 289     }
 290
 291     if (playlist->control_fd < 0)
 292         return -1;
 293
 294     return 0;
 295 }
 296
 297 /*
 298  * store directory and name of playlist file
 299  */
 300 static void update_playlist_filename(struct playlist_info* playlist,
 301                                      const char *dir, const char *file)
 302 {
 303     char *sep="";
 304     int dirlen = strlen(dir);
 305
 306     /* If the dir does not end in trailing slash, we use a separator.
 307        Otherwise we don't. */
 308     if('/' != dir[dirlen-1])
 309     {
 310         sep="/";
 311         dirlen++;
 312     }
 313
 314     playlist->dirlen = dirlen;
 315
 316     snprintf(playlist->filename, sizeof(playlist->filename),
 317         "%s%s%s",
 318         dir, sep, file);
 319 }
 320
 321 /*
 322  * calculate track offsets within a playlist file
 323  */
 324 static int add_indices_to_playlist(struct playlist_info* playlist,
 325                                    char* buffer, int buflen)
 326 {
 327     unsigned int nread;
 328     unsigned int i = 0;
 329     unsigned int count = 0;
 330     bool store_index;
 331     unsigned char *p;
 332
 333     if(-1 == playlist->fd)
 334         playlist->fd = open(playlist->filename, O_RDONLY);
 335     if(playlist->fd < 0)
 336         return -1; /* failure */
 337
 338 #ifdef HAVE_LCD_BITMAP
 339     if(global_settings.statusbar)
 340         lcd_setmargins(0, STATUSBAR_HEIGHT);
 341     else
 342         lcd_setmargins(0, 0);
 343 #endif
 344
 345     splash(0, true, str(LANG_PLAYLIST_LOAD));
 346
 347     if (!buffer)
 348     {
 349         /* use mp3 buffer for maximum load speed */
 350         mpeg_stop();
 351         talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
 352
 353         buffer = mp3buf;
 354         buflen = (mp3end - mp3buf);
 355     }
 356
 357     store_index = true;
 358
 359     while(1)
 360     {
 361         nread = read(playlist->fd, buffer, buflen);
 362         /* Terminate on EOF */
 363         if(nread <= 0)
 364             break;
 365
 366         p = buffer;
 367
 368         for(count=0; count < nread; count++,p++) {
 369
 370             /* Are we on a new line? */
 371             if((*p == '\n') || (*p == '\r'))
 372             {
 373                 store_index = true;
 374             }
 375             else if(store_index)
 376             {
 377                 store_index = false;
 378
 379                 if(*p != '#')
 380                 {
 381                     /* Store a new entry */
 382                     playlist->indices[ playlist->amount ] = i+count;
 383                     playlist->amount++;
 384                     if ( playlist->amount >= playlist->max_playlist_size ) {
 385                         display_buffer_full();
 386                         return -1;
 387                     }
 388                 }
 389             }
 390         }
 391
 392         i+= count;
 393     }
 394
 395     return 0;
 396 }
 397
 398 /*
 399  * Add track to playlist at specified position.  There are three special
 400  * positions that can be specified:
 401  *     PLAYLIST_PREPEND      - Add track at beginning of playlist
 402  *     PLAYLIST_INSERT       - Add track after current song.  NOTE: If there
 403  *                             are already inserted tracks then track is added
 404  *                             to the end of the insertion list.
 405  *     PLAYLIST_INSERT_FIRST - Add track immediately after current song, no
 406  *                             matter what other tracks have been inserted.
 407  *     PLAYLIST_INSERT_LAST  - Add track to end of playlist
 408  */
 409 static int add_track_to_playlist(struct playlist_info* playlist,
 410                                  const char *filename, int position,
 411                                  bool queue, int seek_pos)
 412 {
 413     int insert_position = position;
 414     unsigned int flags = PLAYLIST_INSERT_TYPE_INSERT;
 415     int i;
 416
 417     if (playlist->amount >= playlist->max_playlist_size)
 418     {
 419         display_buffer_full();
 420         return -1;
 421     }
 422
 423     switch (position)
 424     {
 425         case PLAYLIST_PREPEND:
 426             insert_position = playlist->first_index;
 427             flags = PLAYLIST_INSERT_TYPE_PREPEND;
 428             break;
 429         case PLAYLIST_INSERT:
 430             /* if there are already inserted tracks then add track to end of
 431                insertion list else add after current playing track */
 432             if (playlist->last_insert_pos >= 0 &&
 433                 playlist->last_insert_pos < playlist->amount &&
 434                 (playlist->indices[playlist->last_insert_pos]&
 435                     PLAYLIST_INSERT_TYPE_MASK) == PLAYLIST_INSERT_TYPE_INSERT)
 436                 position = insert_position = playlist->last_insert_pos+1;
 437             else if (playlist->amount > 0)
 438                 position = insert_position = playlist->index + 1;
 439             else
 440                 position = insert_position = 0;
 441
 442             playlist->last_insert_pos = position;
 443             break;
 444         case PLAYLIST_INSERT_FIRST:
 445             if (playlist->amount > 0)
 446                 position = insert_position = playlist->index + 1;
 447             else
 448                 position = insert_position = 0;
 449
 450             if (playlist->last_insert_pos < 0)
 451                 playlist->last_insert_pos = position;
 452             break;
 453         case PLAYLIST_INSERT_LAST:
 454             if (playlist->first_index > 0)
 455                 insert_position = playlist->first_index;
 456             else
 457                 insert_position = playlist->amount;
 458
 459             flags = PLAYLIST_INSERT_TYPE_APPEND;
 460             break;
 461     }
 462
 463     if (queue)
 464         flags |= PLAYLIST_QUEUED;
 465
 466     /* shift indices so that track can be added */
 467     for (i=playlist->amount; i>insert_position; i--)
 468         playlist->indices[i] = playlist->indices[i-1];
 469
 470     /* update stored indices if needed */
 471     if (playlist->amount > 0 && insert_position <= playlist->index)
 472         playlist->index++;
 473
 474     if (playlist->amount > 0 && insert_position <= playlist->first_index &&
 475         position != PLAYLIST_PREPEND)
 476     {
 477         playlist->first_index++;
 478
 479         if (seek_pos < 0 && playlist->current)
 480         {
 481             global_settings.resume_first_index = playlist->first_index;
 482             settings_save();
 483         }
 484     }
 485
 486     if (insert_position < playlist->last_insert_pos ||
 487         (insert_position == playlist->last_insert_pos && position < 0))
 488         playlist->last_insert_pos++;
 489
 490     if (seek_pos < 0 && playlist->control_fd >= 0)
 491     {
 492         int result = -1;
 493
 494         if (flush_pending_control(playlist) < 0)
 495             return -1;
 496
 497         mutex_lock(&playlist->control_mutex);
 498
 499         if (lseek(playlist->control_fd, 0, SEEK_END) >= 0)
 500         {
 501             if (fprintf(playlist->control_fd, "%c:%d:%d:", (queue?'Q':'A'),
 502                     position, playlist->last_insert_pos) > 0)
 503             {
 504                 /* save the position in file where track name is written */
 505                 seek_pos = lseek(playlist->control_fd, 0, SEEK_CUR);
 506
 507                 if (fprintf(playlist->control_fd, "%s\n", filename) > 0)
 508                     result = 0;
 509             }
 510         }
 511
 512         mutex_unlock(&playlist->control_mutex);
 513
 514         if (result < 0)
 515         {
 516             splash(HZ*2, true, str(LANG_PLAYLIST_CONTROL_UPDATE_ERROR));
 517             return result;
 518         }
 519     }
 520
 521     playlist->indices[insert_position] = flags | seek_pos;
 522
 523     playlist->amount++;
 524     playlist->num_inserted_tracks++;
 525
 526     return insert_position;
 527 }
 528
 529 /*
 530  * Insert directory into playlist.  May be called recursively.
 531  */
 532 static int add_directory_to_playlist(struct playlist_info* playlist,
 533                                      const char *dirname, int *position, bool queue,
 534                                      int *count, bool recurse)
 535 {
 536     char buf[MAX_PATH+1];
 537     char *count_str;
 538     int result = 0;
 539     int num_files = 0;
 540     int i;
 541     int dirfilter = global_settings.dirfilter;
 542     struct entry *files;
 543     struct tree_context* tc = tree_get_context();
 544
 545     /* use the tree browser dircache to load files */
 546     global_settings.dirfilter = SHOW_ALL;
 547     num_files = ft_load(tc, dirname);
 548     files = (struct entry*) tc->dircache;
 549
 550     if(!num_files)
 551     {
 552         splash(HZ*2, true, str(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR));
 553         return 0;
 554     }
 555
 556     /* we've overwritten the dircache so tree browser will need to be
 557        reloaded */
 558     reload_directory();
 559
 560     if (queue)
 561         count_str = str(LANG_PLAYLIST_QUEUE_COUNT);
 562     else
 563         count_str = str(LANG_PLAYLIST_INSERT_COUNT);
 564
 565     for (i=0; i<num_files; i++)
 566     {
 567         /* user abort */
 568         if (button_get(false) == SETTINGS_CANCEL)
 569         {
 570             result = -1;
 571             break;
 572         }
 573
 574         if (files[i].attr & ATTR_DIRECTORY)
 575         {
 576             if (recurse)
 577             {
 578                 /* recursively add directories */
 579                 snprintf(buf, sizeof(buf), "%s/%s", dirname, files[i].name);
 580                 result = add_directory_to_playlist(playlist, buf, position,
 581                     queue, count, recurse);
 582                 if (result < 0)
 583                     break;
 584
 585                 /* we now need to reload our current directory */
 586                 num_files = ft_load(tc, dirname);
 587                 files = (struct entry*) tc->dircache;
 588                 if (!num_files)
 589                 {
 590                     result = -1;
 591                     break;
 592                 }
 593             }
 594             else
 595                 continue;
 596         }
 597         else if ((files[i].attr & TREE_ATTR_MASK) == TREE_ATTR_MPA)
 598         {
 599             int insert_pos;
 600
 601             snprintf(buf, sizeof(buf), "%s/%s", dirname, files[i].name);
 602
 603             insert_pos = add_track_to_playlist(playlist, buf, *position,
 604                 queue, -1);
 605             if (insert_pos < 0)
 606             {
 607                 result = -1;
 608                 break;
 609             }
 610
 611             (*count)++;
 612
 613             /* Make sure tracks are inserted in correct order if user requests
 614                INSERT_FIRST */
 615             if (*position == PLAYLIST_INSERT_FIRST || *position >= 0)
 616                 *position = insert_pos + 1;
 617
 618             if ((*count%PLAYLIST_DISPLAY_COUNT) == 0)
 619             {
 620                 display_playlist_count(*count, count_str);
 621
 622                 if (*count == PLAYLIST_DISPLAY_COUNT)
 623                     mpeg_flush_and_reload_tracks();
 624             }
 625
 626             /* let the other threads work */
 627             yield();
 628         }
 629     }
 630
 631     /* restore dirfilter */
 632     global_settings.dirfilter = dirfilter;
 633
 634     return result;
 635 }
 636
 637 /*
 638  * remove track at specified position
 639  */
 640 static int remove_track_from_playlist(struct playlist_info* playlist,
 641                                       int position, bool write)
 642 {
 643     int i;
 644     bool inserted;
 645
 646     if (playlist->amount <= 0)
 647         return -1;
 648
 649     inserted = playlist->indices[position] & PLAYLIST_INSERT_TYPE_MASK;
 650
 651     /* shift indices now that track has been removed */
 652     for (i=position; i<playlist->amount; i++)
 653         playlist->indices[i] = playlist->indices[i+1];
 654
 655     playlist->amount--;
 656
 657     if (inserted)
 658         playlist->num_inserted_tracks--;
 659     else
 660         playlist->deleted = true;
 661
 662     /* update stored indices if needed */
 663     if (position < playlist->index)
 664         playlist->index--;
 665
 666     if (position < playlist->first_index)
 667     {
 668         playlist->first_index--;
 669
 670         if (write)
 671         {
 672             global_settings.resume_first_index = playlist->first_index;
 673             settings_save();
 674         }
 675     }
 676
 677     if (position <= playlist->last_insert_pos)
 678         playlist->last_insert_pos--;
 679
 680     if (write && playlist->control_fd >= 0)
 681     {
 682         int result = -1;
 683
 684         if (flush_pending_control(playlist) < 0)
 685             return -1;
 686
 687         mutex_lock(&playlist->control_mutex);
 688
 689         if (lseek(playlist->control_fd, 0, SEEK_END) >= 0)
 690         {
 691             if (fprintf(playlist->control_fd, "D:%d\n", position) > 0)
 692             {
 693                 fsync(playlist->control_fd);
 694                 result = 0;
 695             }
 696         }
 697
 698         mutex_unlock(&playlist->control_mutex);
 699
 700         if (result < 0)
 701         {
 702             splash(HZ*2, true, str(LANG_PLAYLIST_CONTROL_UPDATE_ERROR));
 703             return result;
 704         }
 705     }
 706
 707     return 0;
 708 }
 709
 710 /*
 711  * randomly rearrange the array of indices for the playlist.  If start_current
 712  * is true then update the index to the new index of the current playing track
 713  */
 714 static int randomise_playlist(struct playlist_info* playlist,
 715                               unsigned int seed, bool start_current,
 716                               bool write)
 717 {
 718     int count;
 719     int candidate;
 720     int store;
 721     unsigned int current = playlist->indices[playlist->index];
 722
 723     /* seed 0 is used to identify sorted playlist for resume purposes */
 724     if (seed == 0)
 725         seed = 1;
 726
 727     /* seed with the given seed */
 728     srand(seed);
 729
 730     /* randomise entire indices list */
 731     for(count = playlist->amount - 1; count >= 0; count--)
 732     {
 733         /* the rand is from 0 to RAND_MAX, so adjust to our value range */
 734         candidate = rand() % (count + 1);
 735
 736         /* now swap the values at the 'count' and 'candidate' positions */
 737         store = playlist->indices[candidate];
 738         playlist->indices[candidate] = playlist->indices[count];
 739         playlist->indices[count] = store;
 740     }
 741
 742     if (start_current)
 743         find_and_set_playlist_index(playlist, current);
 744
 745     /* indices have been moved so last insert position is no longer valid */
 746     playlist->last_insert_pos = -1;
 747
 748     playlist->seed = seed;
 749     if (playlist->num_inserted_tracks > 0 || playlist->deleted)
 750         playlist->shuffle_modified = true;
 751
 752     if (write)
 753     {
 754         /* Don't write to disk immediately.  Instead, save in settings and
 755            only flush if playlist is modified (insertion/deletion) */
 756         playlist->shuffle_flush = true;
 757         global_settings.resume_seed = seed;
 758         settings_save();
 759     }
 760
 761     return 0;
 762 }
 763
 764 /*
 765  * Sort the array of indices for the playlist. If start_current is true then
 766  * set the index to the new index of the current song.
 767  */
 768 static int sort_playlist(struct playlist_info* playlist, bool start_current,
 769                          bool write)
 770 {
 771     unsigned int current = playlist->indices[playlist->index];
 772
 773     if (playlist->amount > 0)
 774         qsort(playlist->indices, playlist->amount, sizeof(playlist->indices[0]),
 775             compare);
 776
 777     if (start_current)
 778         find_and_set_playlist_index(playlist, current);
 779
 780     /* indices have been moved so last insert position is no longer valid */
 781     playlist->last_insert_pos = -1;
 782
 783     if (!playlist->num_inserted_tracks && !playlist->deleted)
 784         playlist->shuffle_modified = false;
 785     if (write && playlist->control_fd >= 0)
 786     {
 787         /* Don't write to disk immediately.  Instead, save in settings and
 788            only flush if playlist is modified (insertion/deletion) */
 789         playlist->shuffle_flush = true;
 790         global_settings.resume_seed = 0;
 791         settings_save();
 792     }
 793
 794     return 0;
 795 }
 796
 797 /*
 798  * returns the index of the track that is "steps" away from current playing
 799  * track.
 800  */
 801 static int get_next_index(const struct playlist_info* playlist, int steps)
 802 {
 803     int current_index = playlist->index;
 804     int next_index    = -1;
 805
 806     if (playlist->amount <= 0)
 807         return -1;
 808
 809     switch (global_settings.repeat_mode)
 810     {
 811         case REPEAT_OFF:
 812         {
 813             current_index = rotate_index(playlist, current_index);
 814
 815             next_index = current_index+steps;
 816             if ((next_index < 0) || (next_index >= playlist->amount))
 817                 next_index = -1;
 818             else
 819                 next_index = (next_index+playlist->first_index) %
 820                     playlist->amount;
 821
 822             break;
 823         }
 824
 825         case REPEAT_ONE:
 826             next_index = current_index;
 827             break;
 828
 829         case REPEAT_ALL:
 830         default:
 831         {
 832             next_index = (current_index+steps) % playlist->amount;
 833             while (next_index < 0)
 834                 next_index += playlist->amount;
 835
 836             if (steps >= playlist->amount)
 837             {
 838                 int i, index;
 839
 840                 index = next_index;
 841                 next_index = -1;
 842
 843                 /* second time around so skip the queued files */
 844                 for (i=0; i<playlist->amount; i++)
 845                 {
 846                     if (playlist->indices[index] & PLAYLIST_QUEUE_MASK)
 847                         index = (index+1) % playlist->amount;
 848                     else
 849                     {
 850                         next_index = index;
 851                         break;
 852                     }
 853                 }
 854             }
 855             break;
 856         }
 857     }
 858
 859     return next_index;
 860 }
 861
 862 /*
 863  * Search for the seek track and set appropriate indices.  Used after shuffle
 864  * to make sure the current index is still pointing to correct track.
 865  */
 866 static void find_and_set_playlist_index(struct playlist_info* playlist,
 867                                         unsigned int seek)
 868 {
 869     int i;
 870
 871     /* Set the index to the current song */
 872     for (i=0; i<playlist->amount; i++)
 873     {
 874         if (playlist->indices[i] == seek)
 875         {
 876             playlist->index = playlist->first_index = i;
 877
 878             if (playlist->current)
 879             {
 880                 global_settings.resume_first_index = i;
 881                 settings_save();
 882             }
 883
 884             break;
 885         }
 886     }
 887 }
 888
 889 /*
 890  * used to sort track indices.  Sort order is as follows:
 891  * 1. Prepended tracks (in prepend order)
 892  * 2. Playlist/directory tracks (in playlist order)
 893  * 3. Inserted/Appended tracks (in insert order)
 894  */
 895 static int compare(const void* p1, const void* p2)
 896 {
 897     unsigned int* e1 = (unsigned int*) p1;
 898     unsigned int* e2 = (unsigned int*) p2;
 899     unsigned int flags1 = *e1 & PLAYLIST_INSERT_TYPE_MASK;
 900     unsigned int flags2 = *e2 & PLAYLIST_INSERT_TYPE_MASK;
 901
 902     if (flags1 == flags2)
 903         return (*e1 & PLAYLIST_SEEK_MASK) - (*e2 & PLAYLIST_SEEK_MASK);
 904     else if (flags1 == PLAYLIST_INSERT_TYPE_PREPEND ||
 905         flags2 == PLAYLIST_INSERT_TYPE_APPEND)
 906         return -1;
 907     else if (flags1 == PLAYLIST_INSERT_TYPE_APPEND ||
 908         flags2 == PLAYLIST_INSERT_TYPE_PREPEND)
 909         return 1;
 910     else if (flags1 && flags2)
 911         return (*e1 & PLAYLIST_SEEK_MASK) - (*e2 & PLAYLIST_SEEK_MASK);
 912     else
 913         return *e1 - *e2;
 914 }
 915
 916 /*
 917  * gets pathname for track at seek index
 918  */
 919 static int get_filename(struct playlist_info* playlist, int seek,
 920                         bool control_file, char *buf, int buf_length)
 921 {
 922     int fd;
 923     int max = -1;
 924     char tmp_buf[MAX_PATH+1];
 925     char dir_buf[MAX_PATH+1];
 926
 927     if (buf_length > MAX_PATH+1)
 928         buf_length = MAX_PATH+1;
 929
 930     if (playlist->in_ram && !control_file)
 931     {
 932         strncpy(tmp_buf, &playlist->buffer[seek], sizeof(tmp_buf));
 933         tmp_buf[MAX_PATH] = '\0';
 934         max = strlen(tmp_buf) + 1;
 935     }
 936     else
 937     {
 938         if (control_file)
 939             fd = playlist->control_fd;
 940         else
 941         {
 942             if(-1 == playlist->fd)
 943                 playlist->fd = open(playlist->filename, O_RDONLY);
 944
 945             fd = playlist->fd;
 946         }
 947
 948         if(-1 != fd)
 949         {
 950             if (control_file)
 951                 mutex_lock(&playlist->control_mutex);
 952
 953             lseek(fd, seek, SEEK_SET);
 954             max = read(fd, tmp_buf, buf_length);
 955
 956             if (control_file)
 957                 mutex_unlock(&playlist->control_mutex);
 958         }
 959
 960         if (max < 0)
 961         {
 962             if (control_file)
 963                 splash(HZ*2, true,
 964                     str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
 965             else
 966                 splash(HZ*2, true, str(LANG_PLAYLIST_ACCESS_ERROR));
 967
 968             return max;
 969         }
 970     }
 971
 972     strncpy(dir_buf, playlist->filename, playlist->dirlen-1);
 973     dir_buf[playlist->dirlen-1] = 0;
 974
 975     return (format_track_path(buf, tmp_buf, buf_length, max, dir_buf));
 976 }
 977
 978 /*
 979  * Returns absolute path of track
 980  */
 981 static int format_track_path(char *dest, char *src, int buf_length, int max,
 982                              char *dir)
 983 {
 984     int i = 0;
 985     int j;
 986     char *temp_ptr;
 987
 988     /* Zero-terminate the file name */
 989     while((src[i] != '\n') &&
 990           (src[i] != '\r') &&
 991           (i < max))
 992         i++;
 993
 994     /* Now work back killing white space */
 995     while((src[i-1] == ' ') ||
 996           (src[i-1] == '\t'))
 997         i--;
 998
 999     src[i]=0;
1000
1001     /* replace backslashes with forward slashes */
1002     for ( j=0; j<i; j++ )
1003         if ( src[j] == '\\' )
1004             src[j] = '/';
1005
1006     if('/' == src[0])
1007     {
1008         strncpy(dest, src, buf_length);
1009     }
1010     else
1011     {
1012         /* handle dos style drive letter */
1013         if (':' == src[1])
1014             strncpy(dest, &src[2], buf_length);
1015         else if (!strncmp(src, "../", 3))
1016         {
1017             /* handle relative paths */
1018             i=3;
1019             while(!strncmp(&src[i], "../", 3))
1020                 i += 3;
1021             for (j=0; j<i/3; j++) {
1022                 temp_ptr = strrchr(dir, '/');
1023                 if (temp_ptr)
1024                     *temp_ptr = '\0';
1025                 else
1026                     break;
1027             }
1028             snprintf(dest, buf_length, "%s/%s", dir, &src[i]);
1029         }
1030         else if ( '.' == src[0] && '/' == src[1] ) {
1031             snprintf(dest, buf_length, "%s/%s", dir, &src[2]);
1032         }
1033         else {
1034             snprintf(dest, buf_length, "%s/%s", dir, src);
1035         }
1036     }
1037
1038     return 0;
1039 }
1040
1041 /*
1042  * Display splash message showing progress of playlist/directory insertion or
1043  * save.
1044  */
1045 static void display_playlist_count(int count, const char *fmt)
1046 {
1047     lcd_clear_display();
1048
1049 #ifdef HAVE_LCD_BITMAP
1050     if(global_settings.statusbar)
1051         lcd_setmargins(0, STATUSBAR_HEIGHT);
1052     else
1053         lcd_setmargins(0, 0);
1054 #endif
1055
1056     splash(0, true, fmt, count,
1057 #if CONFIG_KEYPAD == PLAYER_PAD
1058            str(LANG_STOP_ABORT)
1059 #else
1060            str(LANG_OFF_ABORT)
1061 #endif
1062         );
1063 }
1064
1065 /*
1066  * Display buffer full message
1067  */
1068 static void display_buffer_full(void)
1069 {
1070     splash(HZ*2, true, "%s %s",
1071            str(LANG_PLAYINDICES_PLAYLIST),
1072            str(LANG_PLAYINDICES_BUFFER));
1073 }
1074
1075 /*
1076  * Flush any pending control commands to disk.  Called when playlist is being
1077  * modified.  Returns 0 on success and -1 on failure.
1078  */
1079 static int flush_pending_control(struct playlist_info* playlist)
1080 {
1081     int result = 0;
1082
1083     if (playlist->shuffle_flush && global_settings.resume_seed >= 0)
1084     {
1085         /* pending shuffle */
1086         mutex_lock(&playlist->control_mutex);
1087
1088         if (lseek(playlist->control_fd, 0, SEEK_END) >= 0)
1089         {
1090             if (global_settings.resume_seed == 0)
1091                 result = fprintf(playlist->control_fd, "U:%d\n",
1092                     playlist->first_index);
1093             else
1094                 result = fprintf(playlist->control_fd, "S:%d:%d\n",
1095                     global_settings.resume_seed, playlist->first_index);
1096
1097             if (result > 0)
1098             {
1099                 fsync(playlist->control_fd);
1100
1101                 playlist->shuffle_flush = false;
1102                 global_settings.resume_seed = -1;
1103                 settings_save();
1104
1105                 result = 0;
1106             }
1107             else
1108                 result = -1;
1109         }
1110         else
1111             result = -1;
1112
1113         mutex_unlock(&playlist->control_mutex);
1114
1115         if (result < 0)
1116         {
1117             splash(HZ*2, true, str(LANG_PLAYLIST_CONTROL_UPDATE_ERROR));
1118             return result;
1119         }
1120     }
1121
1122     return result;
1123 }
1124
1125 /*
1126  * Rotate indices such that first_index is index 0
1127  */
1128 static int rotate_index(const struct playlist_info* playlist, int index)
1129 {
1130     index -= playlist->first_index;
1131     if (index < 0)
1132         index += playlist->amount;
1133
1134     return index;
1135 }
1136
1137 /*
1138  * Initialize playlist entries at startup
1139  */
1140 void playlist_init(void)
1141 {
1142     struct playlist_info* playlist = &current_playlist;
1143
1144     playlist->current = true;
1145     snprintf(playlist->control_filename, sizeof(playlist->control_filename),
1146         "%s", PLAYLIST_CONTROL_FILE);
1147     playlist->fd = -1;
1148     playlist->control_fd = -1;
1149     playlist->max_playlist_size = global_settings.max_files_in_playlist;
1150     playlist->indices = buffer_alloc(playlist->max_playlist_size * sizeof(int));
1151     playlist->buffer_size =
1152         AVERAGE_FILENAME_LENGTH * global_settings.max_files_in_dir;
1153     playlist->buffer = buffer_alloc(playlist->buffer_size);
1154     mutex_init(&playlist->control_mutex);
1155     empty_playlist(playlist, true);
1156 }
1157
1158 /*
1159  * Create new playlist
1160  */
1161 int playlist_create(const char *dir, const char *file)
1162 {
1163     struct playlist_info* playlist = &current_playlist;
1164
1165     new_playlist(playlist, dir, file);
1166
1167     if (file)
1168         /* load the playlist file */
1169         add_indices_to_playlist(playlist, NULL, 0);
1170
1171     return 0;
1172 }
1173
1174 #define PLAYLIST_COMMAND_SIZE (MAX_PATH+12)
1175
1176 /*
1177  * Restore the playlist state based on control file commands.  Called to
1178  * resume playback after shutdown.
1179  */
1180 int playlist_resume(void)
1181 {
1182     struct playlist_info* playlist = &current_playlist;
1183     char *buffer;
1184     int buflen;
1185     int nread;
1186     int total_read = 0;
1187     int control_file_size = 0;
1188     bool first = true;
1189     bool sorted = true;
1190
1191     enum {
1192         resume_playlist,
1193         resume_add,
1194         resume_queue,
1195         resume_delete,
1196         resume_shuffle,
1197         resume_unshuffle,
1198         resume_reset,
1199         resume_comment
1200     };
1201
1202     /* use mp3 buffer for maximum load speed */
1203     talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
1204     buflen = (mp3end - mp3buf);
1205     buffer = mp3buf;
1206
1207     empty_playlist(playlist, true);
1208
1209     playlist->control_fd = open(playlist->control_filename, O_RDWR);
1210     if (playlist->control_fd < 0)
1211     {
1212         splash(HZ*2, true, str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
1213         return -1;
1214     }
1215     playlist->control_created = true;
1216
1217     control_file_size = filesize(playlist->control_fd);
1218     if (control_file_size <= 0)
1219     {
1220         splash(HZ*2, true, str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
1221         return -1;
1222     }
1223
1224     /* read a small amount first to get the header */
1225     nread = read(playlist->control_fd, buffer,
1226         PLAYLIST_COMMAND_SIZE<buflen?PLAYLIST_COMMAND_SIZE:buflen);
1227     if(nread <= 0)
1228     {
1229         splash(HZ*2, true, str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
1230         return -1;
1231     }
1232
1233     while (1)
1234     {
1235         int result = 0;
1236         int count;
1237         int current_command = resume_comment;
1238         int last_newline = 0;
1239         int str_count = -1;
1240         bool newline = true;
1241         bool exit_loop = false;
1242         char *p = buffer;
1243         char *str1 = NULL;
1244         char *str2 = NULL;
1245         char *str3 = NULL;
1246
1247         for(count=0; count<nread && !exit_loop; count++,p++)
1248         {
1249             /* Are we on a new line? */
1250             if((*p == '\n') || (*p == '\r'))
1251             {
1252                 *p = '\0';
1253
1254                 /* save last_newline in case we need to load more data */
1255                 last_newline = count;
1256
1257                 switch (current_command)
1258                 {
1259                     case resume_playlist:
1260                     {
1261                         /* str1=version str2=dir str3=file */
1262                         int version;
1263
1264                         if (!str1)
1265                         {
1266                             result = -1;
1267                             exit_loop = true;
1268                             break;
1269                         }
1270
1271                         if (!str2)
1272                             str2 = "";
1273
1274                         if (!str3)
1275                             str3 = "";
1276
1277                         version = atoi(str1);
1278
1279                         if (version != PLAYLIST_CONTROL_FILE_VERSION)
1280                             return -1;
1281
1282                         update_playlist_filename(playlist, str2, str3);
1283
1284                         if (str3[0] != '\0')
1285                         {
1286                             /* NOTE: add_indices_to_playlist() overwrites the
1287                                mp3buf so we need to reload control file
1288                                data */
1289                             add_indices_to_playlist(playlist, NULL, 0);
1290                         }
1291                         else if (str2[0] != '\0')
1292                         {
1293                             playlist->in_ram = true;
1294                             resume_directory(str2);
1295                         }
1296
1297                         /* load the rest of the data */
1298                         first = false;
1299                         exit_loop = true;
1300
1301                         break;
1302                     }
1303                     case resume_add:
1304                     case resume_queue:
1305                     {
1306                         /* str1=position str2=last_position str3=file */
1307                         int position, last_position;
1308                         bool queue;
1309
1310                         if (!str1 || !str2 || !str3)
1311                         {
1312                             result = -1;
1313                             exit_loop = true;
1314                             break;
1315                         }
1316
1317                         position = atoi(str1);
1318                         last_position = atoi(str2);
1319
1320                         queue = (current_command == resume_add)?false:true;
1321
1322                         /* seek position is based on str3's position in
1323                            buffer */
1324                         if (add_track_to_playlist(playlist, str3, position,
1325                                 queue, total_read+(str3-buffer)) < 0)
1326                             return -1;
1327
1328                         playlist->last_insert_pos = last_position;
1329
1330                         break;
1331                     }
1332                     case resume_delete:
1333                     {
1334                         /* str1=position */
1335                         int position;
1336
1337                         if (!str1)
1338                         {
1339                             result = -1;
1340                             exit_loop = true;
1341                             break;
1342                         }
1343
1344                         position = atoi(str1);
1345
1346                         if (remove_track_from_playlist(playlist, position,
1347                                 false) < 0)
1348                             return -1;
1349
1350                         break;
1351                     }
1352                     case resume_shuffle:
1353                     {
1354                         /* str1=seed str2=first_index */
1355                         int seed;
1356
1357                         if (!str1 || !str2)
1358                         {
1359                             result = -1;
1360                             exit_loop = true;
1361                             break;
1362                         }
1363
1364                         if (!sorted)
1365                         {
1366                             /* Always sort list before shuffling */
1367                             sort_playlist(playlist, false, false);
1368                         }
1369
1370                         seed = atoi(str1);
1371                         playlist->first_index = atoi(str2);
1372
1373                         if (randomise_playlist(playlist, seed, false,
1374                                 false) < 0)
1375                             return -1;
1376
1377                         sorted = false;
1378                         break;
1379                     }
1380                     case resume_unshuffle:
1381                     {
1382                         /* str1=first_index */
1383                         if (!str1)
1384                         {
1385                             result = -1;
1386                             exit_loop = true;
1387                             break;
1388                         }
1389
1390                         playlist->first_index = atoi(str1);
1391
1392                         if (sort_playlist(playlist, false, false) < 0)
1393                             return -1;
1394
1395                         sorted = true;
1396                         break;
1397                     }
1398                     case resume_reset:
1399                     {
1400                         playlist->last_insert_pos = -1;
1401                         break;
1402                     }
1403                     case resume_comment:
1404                     default:
1405                         break;
1406                 }
1407
1408                 newline = true;
1409
1410                 /* to ignore any extra newlines */
1411                 current_command = resume_comment;
1412             }
1413             else if(newline)
1414             {
1415                 newline = false;
1416
1417                 /* first non-comment line must always specify playlist */
1418                 if (first && *p != 'P' && *p != '#')
1419                 {
1420                     result = -1;
1421                     exit_loop = true;
1422                     break;
1423                 }
1424
1425                 switch (*p)
1426                 {
1427                     case 'P':
1428                         /* playlist can only be specified once */
1429                         if (!first)
1430                         {
1431                             result = -1;
1432                             exit_loop = true;
1433                             break;
1434                         }
1435
1436                         current_command = resume_playlist;
1437                         break;
1438                     case 'A':
1439                         current_command = resume_add;
1440                         break;
1441                     case 'Q':
1442                         current_command = resume_queue;
1443                         break;
1444                     case 'D':
1445                         current_command = resume_delete;
1446                         break;
1447                     case 'S':
1448                         current_command = resume_shuffle;
1449                         break;
1450                     case 'U':
1451                         current_command = resume_unshuffle;
1452                         break;
1453                     case 'R':
1454                         current_command = resume_reset;
1455                         break;
1456                     case '#':
1457                         current_command = resume_comment;
1458                         break;
1459                     default:
1460                         result = -1;
1461                         exit_loop = true;
1462                         break;
1463                 }
1464
1465                 str_count = -1;
1466                 str1 = NULL;
1467                 str2 = NULL;
1468                 str3 = NULL;
1469             }
1470             else if(current_command != resume_comment)
1471             {
1472                 /* all control file strings are separated with a colon.
1473                    Replace the colon with 0 to get proper strings that can be
1474                    used by commands above */
1475                 if (*p == ':')
1476                 {
1477                     *p = '\0';
1478                     str_count++;
1479
1480                     if ((count+1) < nread)
1481                     {
1482                         switch (str_count)
1483                         {
1484                         case 0:
1485                             str1 = p+1;
1486                             break;
1487                         case 1:
1488                             str2 = p+1;
1489                             break;
1490                         case 2:
1491                             str3 = p+1;
1492                             break;
1493                         default:
1494                             /* allow last string to contain colons */
1495                             *p = ':';
1496                             break;
1497                         }
1498                     }
1499                 }
1500             }
1501         }
1502
1503         if (result < 0)
1504         {
1505             splash(HZ*2, true, str(LANG_PLAYLIST_CONTROL_INVALID));
1506             return result;
1507         }
1508
1509         if (!newline || (exit_loop && count<nread))
1510         {
1511             if ((total_read + count) >= control_file_size)
1512             {
1513                 /* no newline at end of control file */
1514                 splash(HZ*2, true, str(LANG_PLAYLIST_CONTROL_INVALID));
1515                 return -1;
1516             }
1517
1518             /* We didn't end on a newline or we exited loop prematurely.
1519                Either way, re-read the remainder. */
1520             count = last_newline;
1521             lseek(playlist->control_fd, total_read+count, SEEK_SET);
1522         }
1523
1524         total_read += count;
1525
1526         if (first)
1527             /* still looking for header */
1528             nread = read(playlist->control_fd, buffer,
1529                 PLAYLIST_COMMAND_SIZE<buflen?PLAYLIST_COMMAND_SIZE:buflen);
1530         else
1531             nread = read(playlist->control_fd, buffer, buflen);
1532
1533         /* Terminate on EOF */
1534         if(nread <= 0)
1535         {
1536             if (global_settings.resume_seed >= 0)
1537             {
1538                 /* Apply shuffle command saved in settings */
1539                 if (global_settings.resume_seed == 0)
1540                     sort_playlist(playlist, false, true);
1541                 else
1542                 {
1543                     if (!sorted)
1544                         sort_playlist(playlist, false, false);
1545
1546                     randomise_playlist(playlist, global_settings.resume_seed,
1547                         false, true);
1548                 }
1549
1550                 playlist->first_index = global_settings.resume_first_index;
1551             }
1552
1553             break;
1554         }
1555     }
1556
1557     return 0;
1558 }
1559
1560 /*
1561  * Add track to in_ram playlist.  Used when playing directories.
1562  */
1563 int playlist_add(const char *filename)
1564 {
1565     struct playlist_info* playlist = &current_playlist;
1566     int len = strlen(filename);
1567
1568     if((len+1 > playlist->buffer_size - playlist->buffer_end_pos) ||
1569        (playlist->amount >= playlist->max_playlist_size))
1570     {
1571         display_buffer_full();
1572         return -1;
1573     }
1574
1575     playlist->indices[playlist->amount++] = playlist->buffer_end_pos;
1576
1577     strcpy(&playlist->buffer[playlist->buffer_end_pos], filename);
1578     playlist->buffer_end_pos += len;
1579     playlist->buffer[playlist->buffer_end_pos++] = '\0';
1580
1581     return 0;
1582 }
1583
1584 /* shuffle newly created playlist using random seed. */
1585 int playlist_shuffle(int random_seed, int start_index)
1586 {
1587     struct playlist_info* playlist = &current_playlist;
1588
1589     unsigned int seek_pos = 0;
1590     bool start_current = false;
1591
1592     if (start_index >= 0 && global_settings.play_selected)
1593     {
1594         /* store the seek position before the shuffle */
1595         seek_pos = playlist->indices[start_index];
1596         playlist->index = global_settings.resume_first_index =
1597             playlist->first_index = start_index;
1598         start_current = true;
1599     }
1600
1601     splash(0, true, str(LANG_PLAYLIST_SHUFFLE));
1602
1603     randomise_playlist(playlist, random_seed, start_current, true);
1604
1605     /* Flush shuffle command to disk */
1606     flush_pending_control(playlist);
1607
1608     return playlist->index;
1609 }
1610
1611 /* start playing current playlist at specified index/offset */
1612 int playlist_start(int start_index, int offset)
1613 {
1614     struct playlist_info* playlist = &current_playlist;
1615
1616     playlist->index = start_index;
1617     talk_buffer_steal(); /* will use the mp3 buffer */
1618     mpeg_play(offset);
1619
1620     return 0;
1621 }
1622
1623 /* Returns false if 'steps' is out of bounds, else true */
1624 bool playlist_check(int steps)
1625 {
1626     struct playlist_info* playlist = &current_playlist;
1627     int index = get_next_index(playlist, steps);
1628     return (index >= 0);
1629 }
1630
1631 /* get trackname of track that is "steps" away from current playing track.
1632    NULL is used to identify end of playlist */
1633 char* playlist_peek(int steps)
1634 {
1635     struct playlist_info* playlist = &current_playlist;
1636     int seek;
1637     int fd;
1638     char *temp_ptr;
1639     int index;
1640     bool control_file;
1641
1642     index = get_next_index(playlist, steps);
1643     if (index < 0)
1644         return NULL;
1645
1646     control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
1647     seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
1648
1649     if (get_filename(playlist, seek, control_file, now_playing,
1650             MAX_PATH+1) < 0)
1651         return NULL;
1652
1653     temp_ptr = now_playing;
1654
1655     if (!playlist->in_ram || control_file)
1656     {
1657         /* remove bogus dirs from beginning of path
1658            (workaround for buggy playlist creation tools) */
1659         while (temp_ptr)
1660         {
1661             fd = open(temp_ptr, O_RDONLY);
1662             if (fd >= 0)
1663             {
1664                 close(fd);
1665                 break;
1666             }
1667
1668             temp_ptr = strchr(temp_ptr+1, '/');
1669         }
1670
1671         if (!temp_ptr)
1672         {
1673             /* Even though this is an invalid file, we still need to pass a
1674                file name to the caller because NULL is used to indicate end
1675                of playlist */
1676             return now_playing;
1677         }
1678     }
1679
1680     return temp_ptr;
1681 }
1682
1683 /*
1684  * Update indices as track has changed
1685  */
1686 int playlist_next(int steps)
1687 {
1688     struct playlist_info* playlist = &current_playlist;
1689     int index;
1690
1691     if (steps > 0 && global_settings.repeat_mode != REPEAT_ONE)
1692     {
1693         int i, j;
1694
1695         /* We need to delete all the queued songs */
1696         for (i=0, j=steps; i<j; i++)
1697         {
1698             index = get_next_index(playlist, i);
1699
1700             if (playlist->indices[index] & PLAYLIST_QUEUE_MASK)
1701             {
1702                 remove_track_from_playlist(playlist, index, true);
1703                 steps--; /* one less track */
1704             }
1705         }
1706     }
1707
1708     index = get_next_index(playlist, steps);
1709     playlist->index = index;
1710
1711     if (playlist->last_insert_pos >= 0 && steps > 0)
1712     {
1713         /* check to see if we've gone beyond the last inserted track */
1714         int cur = rotate_index(playlist, index);
1715         int last_pos = rotate_index(playlist, playlist->last_insert_pos);
1716
1717         if (cur > last_pos)
1718         {
1719             /* reset last inserted track */
1720             playlist->last_insert_pos = -1;
1721
1722             if (playlist->control_fd >= 0)
1723             {
1724                 int result = -1;
1725
1726                 mutex_lock(&playlist->control_mutex);
1727
1728                 if (lseek(playlist->control_fd, 0, SEEK_END) >= 0)
1729                 {
1730                     if (fprintf(playlist->control_fd, "R\n") > 0)
1731                     {
1732                         fsync(playlist->control_fd);
1733                         result = 0;
1734                     }
1735                 }
1736
1737                 mutex_unlock(&playlist->control_mutex);
1738
1739                 if (result < 0)
1740                 {
1741                     splash(HZ*2, true,
1742                         str(LANG_PLAYLIST_CONTROL_UPDATE_ERROR));
1743                     return result;
1744                 }
1745             }
1746         }
1747     }
1748
1749     return index;
1750 }
1751
1752 /* Get resume info for current playing song.  If return value is -1 then
1753    settings shouldn't be saved. */
1754 int playlist_get_resume_info(int *resume_index)
1755 {
1756     struct playlist_info* playlist = &current_playlist;
1757
1758     *resume_index = playlist->index;
1759
1760     return 0;
1761 }
1762
1763 /* Returns index of current playing track for display purposes.  This value
1764    should not be used for resume purposes as it doesn't represent the actual
1765    index into the playlist */
1766 int playlist_get_display_index(void)
1767 {
1768     struct playlist_info* playlist = &current_playlist;
1769
1770     /* first_index should always be index 0 for display purposes */
1771     int index = rotate_index(playlist, playlist->index);
1772
1773     return (index+1);
1774 }
1775
1776 /* returns number of tracks in current playlist */
1777 int playlist_amount(void)
1778 {
1779     return playlist_amount_ex(NULL);
1780 }
1781
1782 /*
1783  * Create a new playlist  If playlist is not NULL then we're loading a
1784  * playlist off disk for viewing/editing.  The index_buffer is used to store
1785  * playlist indices (required for and only used if !current playlist).  The
1786  * temp_buffer (if not NULL) is used as a scratchpad when loading indices.
1787  */
1788 int playlist_create_ex(struct playlist_info* playlist,
1789                        const char* dir, const char* file,
1790                        void* index_buffer, int index_buffer_size,
1791                        void* temp_buffer, int temp_buffer_size)
1792 {
1793     if (!playlist)
1794         playlist = &current_playlist;
1795     else
1796     {
1797         /* Initialize playlist structure */
1798         int r = rand() % 10;
1799         playlist->current = false;
1800
1801         /* Use random name for control file */
1802         snprintf(playlist->control_filename, sizeof(playlist->control_filename),
1803             "%s.%d", PLAYLIST_CONTROL_FILE, r);
1804         playlist->fd = -1;
1805         playlist->control_fd = -1;
1806
1807         if (index_buffer)
1808         {
1809             int num_indices = index_buffer_size / sizeof(int);
1810
1811             if (num_indices > global_settings.max_files_in_playlist)
1812                 num_indices = global_settings.max_files_in_playlist;
1813
1814             playlist->max_playlist_size = num_indices;
1815             playlist->indices = index_buffer;
1816         }
1817         else
1818         {
1819             playlist->max_playlist_size = current_playlist.max_playlist_size;
1820             playlist->indices = current_playlist.indices;
1821         }
1822
1823         playlist->buffer_size = 0;
1824         playlist->buffer = NULL;
1825         mutex_init(&playlist->control_mutex);
1826     }
1827
1828     new_playlist(playlist, dir, file);
1829
1830     if (file)
1831         /* load the playlist file */
1832         add_indices_to_playlist(playlist, temp_buffer, temp_buffer_size);
1833
1834     return 0;
1835 }
1836
1837 /*
1838  * Set the specified playlist as the current.
1839  * NOTE: You will get undefined behaviour if something is already playing so
1840  *       remember to stop before calling this.  Also, this call will
1841  *       effectively close your playlist, making it unusable.
1842  */
1843 int playlist_set_current(struct playlist_info* playlist)
1844 {
1845     if (!playlist || (check_control(playlist) < 0))
1846         return -1;
1847
1848     empty_playlist(&current_playlist, false);
1849
1850     strncpy(current_playlist.filename, playlist->filename,
1851         sizeof(current_playlist.filename));
1852
1853     current_playlist.fd = playlist->fd;
1854
1855     close(playlist->control_fd);
1856     remove(current_playlist.control_filename);
1857     if (rename(playlist->control_filename,
1858             current_playlist.control_filename) < 0)
1859         return -1;
1860     current_playlist.control_fd = open(current_playlist.control_filename,
1861         O_RDWR);
1862     if (current_playlist.control_fd < 0)
1863         return -1;
1864     current_playlist.control_created = true;
1865
1866     current_playlist.dirlen = playlist->dirlen;
1867
1868     if (playlist->indices && playlist->indices != current_playlist.indices)
1869         memcpy(current_playlist.indices, playlist->indices,
1870             playlist->max_playlist_size*sizeof(int));
1871
1872     current_playlist.first_index = playlist->first_index;
1873     current_playlist.amount = playlist->amount;
1874     current_playlist.last_insert_pos = playlist->last_insert_pos;
1875     current_playlist.seed = playlist->seed;
1876     current_playlist.shuffle_modified = playlist->shuffle_modified;
1877     current_playlist.deleted = playlist->deleted;
1878     current_playlist.num_inserted_tracks = playlist->num_inserted_tracks;
1879     current_playlist.shuffle_flush = playlist->shuffle_flush;
1880
1881     return 0;
1882 }
1883
1884 /*
1885  * Close files and delete control file for non-current playlist.
1886  */
1887 void playlist_close(struct playlist_info* playlist)
1888 {
1889     if (!playlist)
1890         return;
1891
1892     if (playlist->fd >= 0)
1893         close(playlist->fd);
1894
1895     if (playlist->control_fd >= 0)
1896         close(playlist->control_fd);
1897
1898     if (playlist->control_created)
1899         remove(playlist->control_filename);
1900 }
1901
1902 /*
1903  * Insert track into playlist at specified position (or one of the special
1904  * positions).  Returns position where track was inserted or -1 if error.
1905  */
1906 int playlist_insert_track(struct playlist_info* playlist, const char *filename,
1907                           int position, bool queue)
1908 {
1909     int result;
1910
1911     if (!playlist)
1912         playlist = &current_playlist;
1913
1914     if (check_control(playlist) < 0)
1915     {
1916         splash(HZ*2, true, str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
1917         return -1;
1918     }
1919
1920     result = add_track_to_playlist(playlist, filename, position, queue, -1);
1921
1922     if (result != -1)
1923     {
1924         fsync(playlist->control_fd);
1925         mpeg_flush_and_reload_tracks();
1926     }
1927
1928     return result;
1929 }
1930
1931 /*
1932  * Insert all tracks from specified directory into playlist.
1933  */
1934 int playlist_insert_directory(struct playlist_info* playlist,
1935                               const char *dirname, int position, bool queue,
1936                               bool recurse)
1937 {
1938     int count = 0;
1939     int result;
1940     char *count_str;
1941
1942     if (!playlist)
1943         playlist = &current_playlist;
1944
1945     if (check_control(playlist) < 0)
1946     {
1947         splash(HZ*2, true, str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
1948         return -1;
1949     }
1950
1951     if (queue)
1952         count_str = str(LANG_PLAYLIST_QUEUE_COUNT);
1953     else
1954         count_str = str(LANG_PLAYLIST_INSERT_COUNT);
1955
1956     display_playlist_count(count, count_str);
1957
1958     result = add_directory_to_playlist(playlist, dirname, &position, queue,
1959         &count, recurse);
1960     fsync(playlist->control_fd);
1961
1962     display_playlist_count(count, count_str);
1963     mpeg_flush_and_reload_tracks();
1964
1965     return result;
1966 }
1967
1968 /*
1969  * Insert all tracks from specified playlist into dynamic playlist.
1970  */
1971 int playlist_insert_playlist(struct playlist_info* playlist, char *filename,
1972                              int position, bool queue)
1973 {
1974     int fd;
1975     int max;
1976     char *temp_ptr;
1977     char *dir;
1978     char *count_str;
1979     char temp_buf[MAX_PATH+1];
1980     char trackname[MAX_PATH+1];
1981     int count = 0;
1982     int result = 0;
1983
1984     if (!playlist)
1985         playlist = &current_playlist;
1986
1987     if (check_control(playlist) < 0)
1988     {
1989         splash(HZ*2, true, str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
1990         return -1;
1991     }
1992
1993     fd = open(filename, O_RDONLY);
1994     if (fd < 0)
1995     {
1996         splash(HZ*2, true, str(LANG_PLAYLIST_ACCESS_ERROR));
1997         return -1;
1998     }
1999
2000     /* we need the directory name for formatting purposes */
2001     dir = filename;
2002
2003     temp_ptr = strrchr(filename+1,'/');
2004     if (temp_ptr)
2005         *temp_ptr = 0;
2006     else
2007         dir = "/";
2008
2009     if (queue)
2010         count_str = str(LANG_PLAYLIST_QUEUE_COUNT);
2011     else
2012         count_str = str(LANG_PLAYLIST_INSERT_COUNT);
2013
2014     display_playlist_count(count, count_str);
2015
2016     while ((max = read_line(fd, temp_buf, sizeof(temp_buf))) > 0)
2017     {
2018         /* user abort */
2019         if (button_get(false) == SETTINGS_CANCEL)
2020             break;
2021
2022         if (temp_buf[0] != '#' && temp_buf[0] != '\0')
2023         {
2024             int insert_pos;
2025
2026             /* we need to format so that relative paths are correctly
2027                handled */
2028             if (format_track_path(trackname, temp_buf, sizeof(trackname), max,
2029                     dir) < 0)
2030             {
2031                 result = -1;
2032                 break;
2033             }
2034
2035             insert_pos = add_track_to_playlist(playlist, trackname, position,
2036                 queue, -1);
2037
2038             if (insert_pos < 0)
2039             {
2040                 result = -1;
2041                 break;
2042             }
2043
2044             /* Make sure tracks are inserted in correct order if user
2045                requests INSERT_FIRST */
2046             if (position == PLAYLIST_INSERT_FIRST || position >= 0)
2047                 position = insert_pos + 1;
2048
2049             count++;
2050
2051             if ((count%PLAYLIST_DISPLAY_COUNT) == 0)
2052             {
2053                 display_playlist_count(count, count_str);
2054
2055                 if (count == PLAYLIST_DISPLAY_COUNT)
2056                     mpeg_flush_and_reload_tracks();
2057             }
2058         }
2059
2060         /* let the other threads work */
2061         yield();
2062     }
2063
2064     close(fd);
2065     fsync(playlist->control_fd);
2066
2067     if (temp_ptr)
2068         *temp_ptr = '/';
2069
2070     display_playlist_count(count, count_str);
2071     mpeg_flush_and_reload_tracks();
2072
2073     return result;
2074 }
2075
2076 /*
2077  * Delete track at specified index.  If index is PLAYLIST_DELETE_CURRENT then
2078  * we want to delete the current playing track.
2079  */
2080 int playlist_delete(struct playlist_info* playlist, int index)
2081 {
2082     int result = 0;
2083
2084     if (!playlist)
2085         playlist = &current_playlist;
2086
2087     if (check_control(playlist) < 0)
2088     {
2089         splash(HZ*2, true, str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2090         return -1;
2091     }
2092
2093     if (index == PLAYLIST_DELETE_CURRENT)
2094         index = playlist->index;
2095
2096     result = remove_track_from_playlist(playlist, index, true);
2097
2098     if (result != -1)
2099         mpeg_flush_and_reload_tracks();
2100
2101     return result;
2102 }
2103
2104 /*
2105  * Move track at index to new_index.  Tracks between the two are shifted
2106  * appropriately.  Returns 0 on success and -1 on failure.
2107  */
2108 int playlist_move(struct playlist_info* playlist, int index, int new_index)
2109 {
2110     int result;
2111     int seek;
2112     bool control_file;
2113     bool queue;
2114     bool current = false;
2115     int r;
2116     char filename[MAX_PATH];
2117
2118     if (!playlist)
2119         playlist = &current_playlist;
2120
2121     if (check_control(playlist) < 0)
2122     {
2123         splash(HZ*2, true, str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2124         return -1;
2125     }
2126
2127     if (index == new_index)
2128         return -1;
2129
2130     if (index == playlist->index)
2131         /* Moving the current track */
2132         current = true;
2133
2134     control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
2135     queue = playlist->indices[index] & PLAYLIST_QUEUE_MASK;
2136     seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
2137
2138     if (get_filename(playlist, seek, control_file, filename,
2139             sizeof(filename)) < 0)
2140         return -1;
2141
2142     /* Delete track from original position */
2143     result = remove_track_from_playlist(playlist, index, true);
2144
2145     if (result != -1)
2146     {
2147         /* We want to insert the track at the position that was specified by
2148            new_index.  This may be different then new_index because of the
2149            shifting that occurred after the delete */
2150         r = rotate_index(playlist, new_index);
2151
2152         if (r == 0)
2153             /* First index */
2154             new_index = PLAYLIST_PREPEND;
2155         else if (r == playlist->amount)
2156             /* Append */
2157             new_index = PLAYLIST_INSERT_LAST;
2158         else
2159             /* Calculate index of desired position */
2160             new_index = (r+playlist->first_index)%playlist->amount;
2161
2162         result = add_track_to_playlist(playlist, filename, new_index, queue,
2163             -1);
2164
2165         if (result != -1)
2166         {
2167             if (current)
2168             {
2169                 /* Moved the current track */
2170                 switch (new_index)
2171                 {
2172                     case PLAYLIST_PREPEND:
2173                         playlist->index = playlist->first_index;
2174                         break;
2175                     case PLAYLIST_INSERT_LAST:
2176                         playlist->index = playlist->first_index - 1;
2177                         if (playlist->index < 0)
2178                             playlist->index += playlist->amount;
2179                         break;
2180                     default:
2181                         playlist->index = new_index;
2182                         break;
2183                 }
2184             }
2185
2186             fsync(playlist->control_fd);
2187             mpeg_flush_and_reload_tracks();
2188         }
2189     }
2190
2191     return result;
2192 }
2193
2194 /* shuffle currently playing playlist */
2195 int playlist_randomise(struct playlist_info* playlist, unsigned int seed,
2196                        bool start_current)
2197 {
2198     int result;
2199
2200     if (!playlist)
2201         playlist = &current_playlist;
2202
2203     check_control(playlist);
2204
2205     result = randomise_playlist(playlist, seed, start_current, true);
2206
2207     if (result != -1)
2208         mpeg_flush_and_reload_tracks();
2209
2210     return result;
2211 }
2212
2213 /* sort currently playing playlist */
2214 int playlist_sort(struct playlist_info* playlist, bool start_current)
2215 {
2216     int result;
2217
2218     if (!playlist)
2219         playlist = &current_playlist;
2220
2221     check_control(playlist);
2222
2223     result = sort_playlist(playlist, start_current, true);
2224
2225     if (result != -1)
2226         mpeg_flush_and_reload_tracks();
2227
2228     return result;
2229 }
2230
2231 /* returns true if playlist has been modified */
2232 bool playlist_modified(const struct playlist_info* playlist)
2233 {
2234     if (!playlist)
2235         playlist = &current_playlist;
2236
2237     if (playlist->shuffle_modified ||
2238         playlist->deleted ||
2239         playlist->num_inserted_tracks > 0)
2240         return true;
2241
2242     return false;
2243 }
2244
2245 /* returns index of first track in playlist */
2246 int playlist_get_first_index(const struct playlist_info* playlist)
2247 {
2248     if (!playlist)
2249         playlist = &current_playlist;
2250
2251     return playlist->first_index;
2252 }
2253
2254 /* returns shuffle seed of playlist */
2255 int playlist_get_seed(const struct playlist_info* playlist)
2256 {
2257     if (!playlist)
2258         playlist = &current_playlist;
2259
2260     return playlist->seed;
2261 }
2262
2263 /* returns number of tracks in playlist (includes queued/inserted tracks) */
2264 int playlist_amount_ex(const struct playlist_info* playlist)
2265 {
2266     if (!playlist)
2267         playlist = &current_playlist;
2268
2269     return playlist->amount;
2270 }
2271
2272 /* returns full path of playlist (minus extension) */
2273 char *playlist_name(const struct playlist_info* playlist, char *buf,
2274                     int buf_size)
2275 {
2276     char *sep;
2277
2278     if (!playlist)
2279         playlist = &current_playlist;
2280
2281     snprintf(buf, buf_size, "%s", playlist->filename+playlist->dirlen);
2282
2283     if (!buf[0])
2284         return NULL;
2285
2286     /* Remove extension */
2287     sep = strrchr(buf, '.');
2288     if (sep)
2289         *sep = 0;
2290
2291     return buf;
2292 }
2293
2294 /* returns the playlist filename */
2295 char *playlist_get_name(const struct playlist_info* playlist, char *buf,
2296                         int buf_size)
2297 {
2298     if (!playlist)
2299         playlist = &current_playlist;
2300
2301     snprintf(buf, buf_size, "%s", playlist->filename);
2302
2303     if (!buf[0])
2304         return NULL;
2305
2306     return buf;
2307 }
2308
2309 /* Fills info structure with information about track at specified index.
2310    Returns 0 on success and -1 on failure */
2311 int playlist_get_track_info(struct playlist_info* playlist, int index,
2312                             struct playlist_track_info* info)
2313 {
2314     int seek;
2315     bool control_file;
2316
2317     if (!playlist)
2318         playlist = &current_playlist;
2319
2320     if (index < 0 || index >= playlist->amount)
2321         return -1;
2322
2323     control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
2324     seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
2325
2326     if (get_filename(playlist, seek, control_file, info->filename,
2327             sizeof(info->filename)) < 0)
2328         return -1;
2329
2330     info->attr = 0;
2331
2332     if (control_file)
2333     {
2334         if (playlist->indices[index] & PLAYLIST_QUEUE_MASK)
2335             info->attr |= PLAYLIST_ATTR_QUEUED;
2336         else
2337             info->attr |= PLAYLIST_ATTR_INSERTED;
2338     }
2339
2340     info->index = index;
2341     info->display_index = rotate_index(playlist, index) + 1;
2342
2343     return 0;
2344 }
2345
2346 /* save the current dynamic playlist to specified file */
2347 int playlist_save(struct playlist_info* playlist, char *filename)
2348 {
2349     int fd;
2350     int i, index;
2351     int count = 0;
2352     char tmp_buf[MAX_PATH+1];
2353     int result = 0;
2354
2355     if (!playlist)
2356         playlist = &current_playlist;
2357
2358     if (playlist->amount <= 0)
2359         return -1;
2360
2361     /* use current working directory as base for pathname */
2362     if (format_track_path(tmp_buf, filename, sizeof(tmp_buf),
2363                           strlen(filename)+1, getcwd(NULL, -1)) < 0)
2364         return -1;
2365
2366     fd = open(tmp_buf, O_CREAT|O_WRONLY|O_TRUNC);
2367     if (fd < 0)
2368     {
2369         splash(HZ*2, true, str(LANG_PLAYLIST_ACCESS_ERROR));
2370         return -1;
2371     }
2372
2373     display_playlist_count(count, str(LANG_PLAYLIST_SAVE_COUNT));
2374
2375     index = playlist->first_index;
2376     for (i=0; i<playlist->amount; i++)
2377     {
2378         bool control_file;
2379         bool queue;
2380         int seek;
2381
2382         /* user abort */
2383         if (button_get(false) == SETTINGS_CANCEL)
2384             break;
2385
2386         control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
2387         queue = playlist->indices[index] & PLAYLIST_QUEUE_MASK;
2388         seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
2389
2390         /* Don't save queued files */
2391         if (!queue)
2392         {
2393             if (get_filename(playlist, seek, control_file, tmp_buf,
2394                     MAX_PATH+1) < 0)
2395             {
2396                 result = -1;
2397                 break;
2398             }
2399
2400             if (fprintf(fd, "%s\n", tmp_buf) < 0)
2401             {
2402                 splash(HZ*2, true, str(LANG_PLAYLIST_CONTROL_UPDATE_ERROR));
2403                 result = -1;
2404                 break;
2405             }
2406
2407             count++;
2408
2409             if ((count % PLAYLIST_DISPLAY_COUNT) == 0)
2410                 display_playlist_count(count, str(LANG_PLAYLIST_SAVE_COUNT));
2411
2412             yield();
2413         }
2414
2415         index = (index+1)%playlist->amount;
2416     }
2417
2418     display_playlist_count(count, str(LANG_PLAYLIST_SAVE_COUNT));
2419
2420     close(fd);
2421
2422     return result;
2423 }