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