4 files changed, 157 insertions, 61 deletions

diff --git a/apps/playlist.c b/apps/playlist.c
index ff6ef0ed37..f834a3d5e7 100644
--- a/apps/playlist.c
+++ b/apps/playlist.c
@@ -93,14 +93,14 @@
 static struct playlist_info playlist;
 
 #define PLAYLIST_CONTROL_FILE ROCKBOX_DIR "/.playlist_control"
-#define PLAYLIST_CONTROL_FILE_VERSION 1
+#define PLAYLIST_CONTROL_FILE_VERSION 2
 
 /*
     Each playlist index has a flag associated with it which identifies what
     type of track it is.  These flags are stored in the 3 high order bits of
     the index.
     
-    NOTE: This limits the playlist file size to a max of 512K.
+    NOTE: This limits the playlist file size to a max of 512M.
 
     Bits 31-30:
         00 = Playlist track
@@ -145,6 +145,7 @@ static int format_track_path(char *dest, char *src, int buf_length, int max,
                              char *dir);
 static void display_playlist_count(int count, char *fmt);
 static void display_buffer_full(void);
+static int flush_pending_control(void);
 
 /*
  * remove any files and indices associated with the playlist
@@ -170,6 +171,7 @@ static void empty_playlist(bool resume)
     playlist.first_index = 0;
     playlist.amount = 0;
     playlist.last_insert_pos = -1;
+    playlist.shuffle_flush = false;
 
     if (!resume)
     {
@@ -180,6 +182,10 @@ static void empty_playlist(bool resume)
         fd = creat(PLAYLIST_CONTROL_FILE, 0000200);
         if (fd >= 0)
             close(fd);
+
+        /* Reset resume settings */
+        global_settings.resume_first_index = 0;
+        global_settings.resume_seed = -1;
     }
 }
 
@@ -357,8 +363,16 @@ static int add_track_to_playlist(char *filename, int position, bool queue,
 
     if (playlist.amount > 0 && insert_position <= playlist.first_index &&
         position != PLAYLIST_PREPEND)
+    {
         playlist.first_index++;
 
+        if (seek_pos < 0)
+        {
+            global_settings.resume_first_index = playlist.first_index;
+            settings_save();
+        }
+    }
+
     if (insert_position < playlist.last_insert_pos ||
         (insert_position == playlist.last_insert_pos && position < 0))
         playlist.last_insert_pos++;
@@ -367,6 +381,9 @@ static int add_track_to_playlist(char *filename, int position, bool queue,
     {
         int result = -1;
 
+        if (flush_pending_control() < 0)
+            return -1;
+
         mutex_lock(&playlist.control_mutex);
 
         if (lseek(playlist.control_fd, 0, SEEK_END) >= 0)
@@ -525,8 +542,16 @@ static int remove_track_from_playlist(int position, bool write)
         playlist.index--;
 
     if (position < playlist.first_index)
+    {
         playlist.first_index--;
 
+        if (write)
+        {
+            global_settings.resume_first_index = playlist.first_index;
+            settings_save();
+        }
+    }
+
     if (position <= playlist.last_insert_pos)
         playlist.last_insert_pos--;
 
@@ -534,6 +559,9 @@ static int remove_track_from_playlist(int position, bool write)
     {
         int result = -1;
 
+        if (flush_pending_control() < 0)
+            return -1;
+
         mutex_lock(&playlist.control_mutex);
 
         if (lseek(playlist.control_fd, 0, SEEK_END) >= 0)
@@ -568,6 +596,10 @@ static int randomise_playlist(unsigned int seed, bool start_current, bool write)
     int store;
     unsigned int current = playlist.indices[playlist.index];
     
+    /* seed 0 is used to identify sorted playlist for resume purposes */
+    if (seed == 0)
+        seed = 1;
+
     /* seed with the given seed */
     srand(seed);
 
@@ -589,29 +621,13 @@ static int randomise_playlist(unsigned int seed, bool start_current, bool write)
     /* indices have been moved so last insert position is no longer valid */
     playlist.last_insert_pos = -1;
 
-    if (write && playlist.control_fd >= 0)
+    if (write)
     {
-        int result = -1;
-
-        mutex_lock(&playlist.control_mutex);
-
-        if (lseek(playlist.control_fd, 0, SEEK_END) >= 0)
-        {
-            if (fprintf(playlist.control_fd, "S:%d:%d\n", seed,
-                    playlist.first_index) > 0)
-            {
-                fsync(playlist.control_fd);
-                result = 0;
-            }
-        }
-
-        mutex_unlock(&playlist.control_mutex);
-
-        if (result < 0)
-        {
-            splash(HZ*2, 0, true, str(LANG_PLAYLIST_CONTROL_UPDATE_ERROR));
-            return result;
-        }
+        /* Don't write to disk immediately.  Instead, save in settings and
+           only flush if playlist is modified (insertion/deletion) */
+        playlist.shuffle_flush = true;
+        global_settings.resume_seed = seed;
+        settings_save();
     }
 
     return 0;
@@ -637,27 +653,11 @@ static int sort_playlist(bool start_current, bool write)
 
     if (write && playlist.control_fd >= 0)
     {
-        int result = -1;
-
-        mutex_lock(&playlist.control_mutex);
-
-        if (lseek(playlist.control_fd, 0, SEEK_END) >= 0)
-        {
-            if (fprintf(playlist.control_fd, "U:%d\n", playlist.first_index) >
-                    0)
-            {
-                fsync(playlist.control_fd);
-                result = 0;
-            }
-        }
-
-        mutex_unlock(&playlist.control_mutex);
-
-        if (result < 0)
-        {
-            splash(HZ*2, 0, true, str(LANG_PLAYLIST_CONTROL_UPDATE_ERROR));
-            return result;
-        }
+        /* Don't write to disk immediately.  Instead, save in settings and
+           only flush if playlist is modified (insertion/deletion) */
+        playlist.shuffle_flush = true;
+        global_settings.resume_seed = 0;
+        settings_save();
     }
 
     return 0;
@@ -745,7 +745,9 @@ static void find_and_set_playlist_index(unsigned int seek)
     {
         if (playlist.indices[i] == seek)
         {
-            playlist.index = playlist.first_index = i;
+            playlist.index = global_settings.resume_first_index =
+                playlist.first_index = i;
+            settings_save();
             break;
         }
     }
@@ -941,6 +943,56 @@ static void display_buffer_full(void)
 }
 
 /*
+ * Flush any pending control commands to disk.  Called when playlist is being
+ * modified.  Returns 0 on success and -1 on failure.
+ */
+static int flush_pending_control(void)
+{
+    int result = 0;
+        
+    if (playlist.shuffle_flush && global_settings.resume_seed >= 0)
+    {
+        /* pending shuffle */
+        mutex_lock(&playlist.control_mutex);
+        
+        if (lseek(playlist.control_fd, 0, SEEK_END) >= 0)
+        {
+            if (global_settings.resume_seed == 0)
+                result = fprintf(playlist.control_fd, "U:%d\n",
+                    playlist.first_index);
+            else
+                result = fprintf(playlist.control_fd, "S:%d:%d\n",
+                    global_settings.resume_seed, playlist.first_index);
+
+            if (result > 0)
+            {
+                fsync(playlist.control_fd);
+
+                playlist.shuffle_flush = false;
+                global_settings.resume_seed = -1;
+                settings_save();
+
+                result = 0;
+            }
+            else
+                result = -1;
+        }
+        else
+            result = -1;
+        
+        mutex_unlock(&playlist.control_mutex);
+        
+        if (result < 0)
+        {
+            splash(HZ*2, 0, true, str(LANG_PLAYLIST_CONTROL_UPDATE_ERROR));
+            return result;
+        }
+    }
+
+    return result;
+}
+
+/*
  * Initialize playlist entries at startup
  */
 void playlist_init(void)
@@ -1008,6 +1060,7 @@ int playlist_resume(void)
     int nread;
     int total_read = 0;
     bool first = true;
+    bool sorted = true;
 
     enum {
         resume_playlist,
@@ -1089,11 +1142,7 @@ int playlist_resume(void)
                         version = atoi(str1);
                         
                         if (version != PLAYLIST_CONTROL_FILE_VERSION)
-                        {
-                            result = -1;
-                            exit_loop = true;
-                            break;
-                        }
+                            return -1;
                         
                         update_playlist_filename(str2, str3);
                         
@@ -1177,12 +1226,19 @@ int playlist_resume(void)
                             break;
                         }
                         
+                        if (!sorted)
+                        {
+                            /* Always sort list before shuffling */
+                            sort_playlist(false, false);
+                        }
+
                         seed = atoi(str1);
                         playlist.first_index = atoi(str2);
                         
                         if (randomise_playlist(seed, false, false) < 0)
                             return -1;
 
+                        sorted = false;
                         break;
                     }
                     case resume_unshuffle:
@@ -1200,6 +1256,7 @@ int playlist_resume(void)
                         if (sort_playlist(false, false) < 0)
                             return -1;
 
+                        sorted = true;
                         break;
                     }
                     case resume_reset:
@@ -1334,7 +1391,26 @@ int playlist_resume(void)
 
         /* Terminate on EOF */
         if(nread <= 0)
+        {
+            if (global_settings.resume_seed >= 0)
+            {
+                /* Apply shuffle command saved in settings */
+                if (global_settings.resume_seed == 0)
+                    sort_playlist(false, true);
+                else
+                {
+                    if (!sorted)
+                        sort_playlist(false, false);
+
+                    randomise_playlist(global_settings.resume_seed, false,
+                        true);
+                }
+
+                playlist.first_index = global_settings.resume_first_index;
+            }
+
             break;
+        }
     }
 
     return 0;
@@ -1557,7 +1633,8 @@ int playlist_shuffle(int random_seed, int start_index)
     {
         /* store the seek position before the shuffle */
         seek_pos = playlist.indices[start_index];        
-        playlist.index = playlist.first_index = start_index;
+        playlist.index = global_settings.resume_first_index =
+            playlist.first_index = start_index;
         start_current = true;
     }
 
@@ -1565,6 +1642,9 @@ int playlist_shuffle(int random_seed, int start_index)
     
     randomise_playlist(random_seed, start_current, true);
 
+    /* Flush shuffle command to disk */
+    flush_pending_control();
+
     return playlist.index;
 }
 
@@ -1734,7 +1814,7 @@ int playlist_next(int steps)
 
 /* Get resume info for current playing song.  If return value is -1 then
    settings shouldn't be saved. */
-int playlist_get_resume_info(int *resume_index)
+int playlist_get_resume_info(short *resume_index)
 {
     *resume_index = playlist.index;
 
diff --git a/apps/playlist.h b/apps/playlist.h
index 0b30e7a3e1..45ecba505c 100644
--- a/apps/playlist.h
+++ b/apps/playlist.h
@@ -39,10 +39,11 @@ struct playlist_info
     char *buffer;        /* buffer for in-ram playlists             */
     int  buffer_size;    /* size of buffer                          */
     int  buffer_end_pos; /* last position where buffer was written  */
-    int  index;          /* index of current playing track          */
-    int  first_index;    /* index of first song in playlist         */
+    short index;         /* index of current playing track          */
+    short first_index;   /* index of first song in playlist         */
     int  amount;         /* number of tracks in the index           */
     int  last_insert_pos; /* last position we inserted a track      */
+    bool shuffle_flush;  /* Does shuffle value need to be flushed?  */
     struct mutex control_mutex; /* mutex for control file access    */
 };
 
@@ -62,7 +63,7 @@ int playlist_start(int start_index, int offset);
 bool playlist_check(int steps);
 char *playlist_peek(int steps);
 int playlist_next(int steps);
-int playlist_get_resume_info(int *resume_index);
+int playlist_get_resume_info(short *resume_index);
 int playlist_get_display_index(void);
 int playlist_amount(void);
 char *playlist_name(char *buf, int buf_size);
diff --git a/apps/settings.c b/apps/settings.c
index 6a7fe971a2..3c56257db4 100644
--- a/apps/settings.c
+++ b/apps/settings.c
@@ -97,13 +97,14 @@ offset  abs
 0x0f    0x23    <volume type, battery type, timeformat, scroll speed>
 0x10    0x24    <ff/rewind min step, acceleration rate>
 0x11    0x25    <AVC, channel config>
-0x12    0x26    <(int) Resume playlist index, or -1 if no playlist resume>
+0x12    0x26    <(short) Resume playlist index, or -1 if no playlist resume>
+0x14    0x28    <(short) Resume playlist first index>
 0x16    0x2a    <(int) Byte offset into resume file>
 0x1a    0x2e    <time until disk spindown>
 0x1b    0x2f    <browse current, play selected, recursive dir insert>
 0x1c    0x30    <peak meter hold timeout (bit 0-4),
                  rec_editable (bit 7)>
-0x1d    0x31    <unused>
+0x1d    0x31    <(int) Resume shuffle seed, or -1 if no shuffle>
 0x21    0x35    <repeat mode (bit 0-1), rec. channels (bit 2),
                  mic gain (bit 4-7)>
 0x22    0x36    <rec. quality (bit 0-2), source (bit 3-4), frequency (bit 5-7)>
@@ -347,7 +348,8 @@ int settings_save( void )
         ((global_settings.avc & 0x03) | 
          ((global_settings.channel_config & 0x07) << 2));
 
-    memcpy(&config_block[0x12], &global_settings.resume_index, 4);
+    memcpy(&config_block[0x12], &global_settings.resume_index, 2);
+    memcpy(&config_block[0x14], &global_settings.resume_first_index, 2);
     memcpy(&config_block[0x16], &global_settings.resume_offset, 4);
     DEBUGF( "+Resume index %X offset %X\n",
             global_settings.resume_index,
@@ -362,6 +364,8 @@ int settings_save( void )
     config_block[0x1c] = (unsigned char)global_settings.peak_meter_hold |
         (global_settings.rec_editable?0x80:0);
 
+    memcpy(&config_block[0x1d], &global_settings.resume_seed, 4);
+
     config_block[0x21] = (unsigned char)
         ((global_settings.repeat_mode & 3) |
          ((global_settings.rec_channels & 1) << 2) |
@@ -636,7 +640,10 @@ void settings_load(void)
         }
 
         if (config_block[0x12] != 0xFF)
-            memcpy(&global_settings.resume_index, &config_block[0x12], 4);
+            memcpy(&global_settings.resume_index, &config_block[0x12], 2);
+
+        if (config_block[0x14] != 0xFF)
+            memcpy(&global_settings.resume_first_index, &config_block[0x14], 2);
 
         if (config_block[0x16] != 0xFF)
             memcpy(&global_settings.resume_offset, &config_block[0x16], 4);
@@ -657,6 +664,9 @@ void settings_load(void)
                 (config_block[0x1c] & 0x80)?true:false;
         }
 
+        if (config_block[0x1d] != 0xFF)
+            memcpy(&global_settings.resume_seed, &config_block[0x1d], 4);
+
         if (config_block[0x21] != 0xFF)
         {
             global_settings.repeat_mode = config_block[0x21] & 3;
@@ -1468,7 +1478,9 @@ void settings_reset(void) {
     global_settings.ff_rewind_min_step = DEFAULT_FF_REWIND_MIN_STEP;
     global_settings.ff_rewind_accel = DEFAULT_FF_REWIND_ACCEL_SETTING;
     global_settings.resume_index = -1;
+    global_settings.resume_first_index = 0;
     global_settings.resume_offset = -1;
+    global_settings.resume_seed = -1;
     global_settings.disk_spindown = 5;
     global_settings.disk_poweroff = false;
     global_settings.buffer_margin = 0;
diff --git a/apps/settings.h b/apps/settings.h
index c0e785489a..b96f4c6410 100644
--- a/apps/settings.h
+++ b/apps/settings.h
@@ -104,8 +104,11 @@ struct user_settings
     /* resume settings */
 
     int resume;        /* resume option: 0=off, 1=ask, 2=on */
-    int resume_index;  /* index in playlist (-1 for no active resume) */
+    short resume_index;  /* index in playlist (-1 for no active resume) */
+    short resume_first_index;  /* index of first track in playlist */
     int resume_offset; /* byte offset in mp3 file */
+    int resume_seed;   /* shuffle seed (-1=no resume shuffle 0=sorted
+                                        >0=shuffled) */
 
     unsigned char font_file[MAX_FILENAME+1]; /* last font */
     unsigned char wps_file[MAX_FILENAME+1];  /* last wps */