1 files changed, 333 insertions, 84 deletions

diff --git a/apps/tagtree.c b/apps/tagtree.c
index ea2a756a46..60f8a795e3 100644
--- a/apps/tagtree.c
+++ b/apps/tagtree.c
@@ -56,6 +56,8 @@
 #include "playback.h"
 #include "strnatcmp.h"
 #include "panic.h"
+#include "onplay.h"
+#include "plugin.h"
 
 #define str_or_empty(x) (x ? x : "(NULL)")
 
@@ -64,6 +66,10 @@
 
 static int tagtree_play_folder(struct tree_context* c);
 
+/* reuse of tagtree data after tagtree_play_folder() */
+static uint32_t loaded_entries_crc = 0;
+
+
 /* this needs to be same size as struct entry (tree.h) and name needs to be
  * the first; so that they're compatible enough to walk arrays of both
  * derefencing the name member*/
@@ -71,6 +77,7 @@ struct tagentry {
     char* name;
     int newtable;
     int extraseek;
+    int customaction;
 };
 
 static struct tagentry* tagtree_get_entry(struct tree_context *c, int id);
@@ -78,10 +85,10 @@ static struct tagentry* tagtree_get_entry(struct tree_context *c, int id);
 #define SEARCHSTR_SIZE 256
 
 enum table {
-    ROOT = 1,
-    NAVIBROWSE,
-    ALLSUBENTRIES,
-    PLAYTRACK,
+    TABLE_ROOT = 1,
+    TABLE_NAVIBROWSE,
+    TABLE_ALLSUBENTRIES,
+    TABLE_PLAYTRACK,
 };
 
 static const struct id3_to_search_mapping {
@@ -105,9 +112,11 @@ enum variables {
     var_include,
     var_rootmenu,
     var_format,
+    menu_byfirstletter,
     menu_next,
     menu_load,
     menu_reload,
+    menu_shuffle_songs,
 };
 
 /* Capacity 10 000 entries (for example 10k different artists) */
@@ -165,11 +174,12 @@ struct display_format {
 static struct display_format *formats[TAGMENU_MAX_FMTS];
 static int format_count;
 
+#define MENUENTRY_MAX_NAME 64
 struct menu_entry {
-    char name[64];
+    char name[MENUENTRY_MAX_NAME];
     int type;
     struct search_instruction {
-        char name[64];
+        char name[MENUENTRY_MAX_NAME];
         int tagorder[MAX_TAGS];
         int tagorder_count;
         struct tagcache_search_clause *clause[MAX_TAGS][TAGCACHE_MAX_CLAUSES];
@@ -181,19 +191,12 @@ struct menu_entry {
 };
 
 struct menu_root {
-    char title[64];
+    char title[MENUENTRY_MAX_NAME];
     char id[MAX_MENU_ID_SIZE];
     int itemcount;
     struct menu_entry *items[TAGMENU_MAX_ITEMS];
 };
 
-struct match
-{
-    const char* str;
-    uint16_t len;
-    uint16_t symbol;
-};
-
 /* Statusbar text of the current view. */
 static char current_title[MAX_TAGS][128];
 
@@ -276,6 +279,20 @@ static struct buflib_callbacks ops = {
     .shrink_callback = NULL,
 };
 
+static uint32_t tagtree_data_crc(struct tree_context* c)
+{
+    char* buf;
+    uint32_t crc;
+    buf = core_get_data(tagtree_handle); /* data for the search clauses etc */
+    crc = crc_32(buf, tagtree_buf_used, c->dirlength);
+    buf = core_get_data(c->cache.name_buffer_handle); /* names */
+    crc = crc_32(buf, c->cache.name_buffer_size, crc);
+    buf = core_get_data(c->cache.entries_handle); /* tagentries */
+    crc = crc_32(buf, c->cache.max_entries * sizeof(struct tagentry), crc);
+    logf("%s 0x%x", __func__, crc);
+    return crc;
+}
+
 static void* tagtree_alloc(size_t size)
 {
     size = ALIGN_UP(size, sizeof(void*));
@@ -331,13 +348,15 @@ static int get_token_str(char *buf, int size)
 static int get_tag(int *tag)
 {
     #define TAG_MATCH(str, tag) {str, sizeof(str) - 1, tag}
+    struct match {const char* str; uint16_t len; uint16_t symbol;};
     static const struct match get_tag_match[] =
     {
-        TAG_MATCH("Lm", tag_virt_length_min),
-        TAG_MATCH("Ls", tag_virt_length_sec),
-        TAG_MATCH("Pm", tag_virt_playtime_min),
-        TAG_MATCH("Ps", tag_virt_playtime_sec),
+        TAG_MATCH("lm", tag_virt_length_min),
+        TAG_MATCH("ls", tag_virt_length_sec),
+        TAG_MATCH("pm", tag_virt_playtime_min),
+        TAG_MATCH("ps", tag_virt_playtime_sec),
         TAG_MATCH("->", menu_next),
+        TAG_MATCH("~>", menu_shuffle_songs),
 
         TAG_MATCH("==>", menu_load),
 
@@ -381,13 +400,15 @@ static int get_tag(int *tag)
         TAG_MATCH("lastelapsed", tag_lastelapsed),
         TAG_MATCH("%menu_start", var_menu_start),
 
+        TAG_MATCH("%byfirstletter", menu_byfirstletter),
         TAG_MATCH("canonicalartist", tag_virt_canonicalartist),
+
         TAG_MATCH("", 0) /* sentinel */
     };
     #undef TAG_MATCH
     const size_t max_cmd_sz = 32; /* needs to be >= to len of longest tagstr */
     const char *tagstr;
-    unsigned int tagstr_len;
+    uint16_t tagstr_len;
     const struct match *match;
 
     /* Find the start. */
@@ -820,7 +841,7 @@ static bool parse_search(struct menu_entry *entry, const char *str)
         return true;
     }
 
-    if (entry->type != menu_next)
+    if (entry->type != menu_next && entry->type != menu_shuffle_songs)
         return false;
 
     while (inst->tagorder_count < MAX_TAGS)
@@ -847,7 +868,7 @@ static bool parse_search(struct menu_entry *entry, const char *str)
 
         inst->tagorder_count++;
 
-        if (get_tag(&type) <= 0 || type != menu_next)
+        if (get_tag(&type) <= 0 || (type != menu_next && type != menu_shuffle_songs))
             break;
     }
 
@@ -1033,8 +1054,65 @@ int tagtree_import(void)
     return 0;
 }
 
-static bool parse_menu(const char *filename);
+static bool alloc_menu_parse_buf(char *buf, int type)
+{
+    /* allocate a new menu item (if needed) initialize it with data parsed
+       from buf Note: allows setting menu type, type ignored when < 0
+    */
+    /* Allocate */
+    if (menu->items[menu->itemcount] == NULL)
+        menu->items[menu->itemcount] = tagtree_alloc0(sizeof(struct menu_entry));
+    if (!menu->items[menu->itemcount])
+    {
+        logf("tagtree failed to allocate %s", "menu items");
+        return false;
+    }
 
+    /* Initialize */
+    core_pin(tagtree_handle);
+    if (parse_search(menu->items[menu->itemcount], buf))
+    {
+        if (type >= 0)
+            menu->items[menu->itemcount]->type = type;
+        menu->itemcount++;
+    }
+    core_unpin(tagtree_handle);
+    return true;
+}
+
+static void build_firstletter_menu(char *buf, size_t bufsz)
+{
+    const char *subitem = buf;
+    size_t l = strlen(buf) + 1;
+    buf+=l;
+    bufsz-=l;
+
+    const char * const fmt ="\"%s\"-> %s ? %s %c\"%c\"-> %s =\"fmt_title\"";
+    const char * const showsub = /* album subitem for canonicalartist */
+        ((strcasestr(subitem, "artist") == NULL) ? "title" : "album -> title");
+
+    /* Numeric ex: "Numeric" -> album ? album < "A" -> title = "fmt_title" */
+    snprintf(buf, bufsz, fmt,
+            str(LANG_DISPLAY_NUMERIC), subitem, subitem,'<', 'A', showsub);
+
+    if (!alloc_menu_parse_buf(buf, menu_byfirstletter))
+    {
+        return;
+    }
+
+    for (int i = 0; i < 26; i++)
+    {
+        snprintf(buf, bufsz, fmt, "#", subitem, subitem,'^', 'A' + i, showsub);
+        buf[1] = 'A' + i; /* overwrite the placeholder # with the current letter */
+        /* ex: "A" -> title ? title ^ "A" -> title = "fmt_title" */
+        if (!alloc_menu_parse_buf(buf, menu_byfirstletter))
+        {
+            return;
+        }
+    }
+}
+
+static bool parse_menu(const char *filename);
 static int parse_line(int n, char *buf, void *parameters)
 {
     char data[256];
@@ -1104,7 +1182,7 @@ static int parse_line(int n, char *buf, void *parameters)
                     logf("Load menu fail: %s", data);
                 }
                 break;
-
+            case menu_byfirstletter: /* Fallthrough */
             case var_menu_start:
                 if (menu_count >= TAGMENU_MAX_MENUS)
                 {
@@ -1146,6 +1224,19 @@ static int parse_line(int n, char *buf, void *parameters)
                     return 0;
                 }
                 logf("menu: %s", menu->title);
+
+                if (variable == menu_byfirstletter)
+                {
+                    if (get_token_str(data, sizeof(data)) < 0)
+                    {
+                        logf("%%firstletter_menu has no subitem"); /*artist,album*/
+                        return 0;
+                    }
+                    logf("A-Z Menu subitem: %s", data);
+                    read_menu = false;
+                    build_firstletter_menu(data, sizeof(data));
+                    break;
+                }
                 read_menu = true;
                 break;
 
@@ -1179,18 +1270,10 @@ static int parse_line(int n, char *buf, void *parameters)
         return 0;
     }
 
-    /* Allocate */
-    if (menu->items[menu->itemcount] == NULL)
-        menu->items[menu->itemcount] = tagtree_alloc0(sizeof(struct menu_entry));
-    if (!menu->items[menu->itemcount])
+    if (!alloc_menu_parse_buf(buf, -1))
     {
-        logf("tagtree failed to allocate %s", "menu items");
         return -2;
     }
-    core_pin(tagtree_handle);
-    if (parse_search(menu->items[menu->itemcount], buf))
-        menu->itemcount++;
-    core_unpin(tagtree_handle);
 
     return 0;
 }
@@ -1245,6 +1328,7 @@ static void tagtree_unload(struct tree_context *c)
             dptr->name = NULL;
             dptr->newtable = 0;
             dptr->extraseek = 0;
+            dptr->customaction = ONPLAY_NO_CUSTOMACTION;
             dptr++;
         }
     }
@@ -1425,6 +1509,7 @@ static void tcs_get_basename(struct tagcache_search *tcs, bool is_basename)
 
 static int retrieve_entries(struct tree_context *c, int offset, bool init)
 {
+    logf( "%s", __func__);
     char tcs_buf[TAGCACHE_BUFSZ];
     const long tcs_bufsz = sizeof(tcs_buf);
     struct tagcache_search tcs;
@@ -1452,9 +1537,9 @@ static int retrieve_entries(struct tree_context *c, int offset, bool init)
 #else
         true
 #endif
-        , 0);
+        , 0, 0, 0);
 
-    if (c->currtable == ALLSUBENTRIES)
+    if (c->currtable == TABLE_ALLSUBENTRIES)
     {
         tag = tag_title;
         level--;
@@ -1544,17 +1629,19 @@ static int retrieve_entries(struct tree_context *c, int offset, bool init)
     {
         if (offset == 0)
         {
-            dptr->newtable = ALLSUBENTRIES;
+            dptr->newtable = TABLE_ALLSUBENTRIES;
             dptr->name = str(LANG_TAGNAVI_ALL_TRACKS);
+            dptr->customaction = ONPLAY_NO_CUSTOMACTION;
             dptr++;
             current_entry_count++;
             special_entry_count++;
         }
         if (offset <= 1)
         {
-            dptr->newtable = NAVIBROWSE;
+            dptr->newtable = TABLE_NAVIBROWSE;
             dptr->name = str(LANG_TAGNAVI_RANDOM);
             dptr->extraseek = -1;
+            dptr->customaction = ONPLAY_NO_CUSTOMACTION;
             dptr++;
             current_entry_count++;
             special_entry_count++;
@@ -1568,14 +1655,15 @@ static int retrieve_entries(struct tree_context *c, int offset, bool init)
         if (total_count++ < offset)
             continue;
 
-        dptr->newtable = NAVIBROWSE;
+        dptr->newtable = TABLE_NAVIBROWSE;
         if (tag == tag_title || tag == tag_filename)
         {
-            dptr->newtable = PLAYTRACK;
+            dptr->newtable = TABLE_PLAYTRACK;
             dptr->extraseek = tcs.idx_id;
         }
         else
             dptr->extraseek = tcs.result_seek;
+        dptr->customaction = ONPLAY_NO_CUSTOMACTION;
 
         fmt = NULL;
         /* Check the format */
@@ -1676,7 +1764,7 @@ entry_skip_formatter:
 
         if (init)
         {
-            if (!show_search_progress(false, total_count))
+            if (!show_search_progress(false, total_count, 0, 0))
             {   /* user aborted */
                 tagcache_search_finish(&tcs);
                 tree_unlock_cache(c);
@@ -1710,7 +1798,7 @@ entry_skip_formatter:
 
     while (tagcache_get_next(&tcs, tcs_buf, tcs_bufsz))
     {
-        if (!show_search_progress(false, total_count))
+        if (!show_search_progress(false, total_count, 0, 0))
             break;
         total_count++;
     }
@@ -1758,7 +1846,7 @@ static int load_root(struct tree_context *c)
     int i;
 
     tc = c;
-    c->currtable = ROOT;
+    c->currtable = TABLE_ROOT;
     if (c->dirlevel == 0)
         c->currextra = rootmenu;
 
@@ -1775,13 +1863,27 @@ static int load_root(struct tree_context *c)
         switch (menu->items[i]->type)
         {
             case menu_next:
-                dptr->newtable = NAVIBROWSE;
+                dptr->newtable = TABLE_NAVIBROWSE;
                 dptr->extraseek = i;
+                dptr->customaction = ONPLAY_NO_CUSTOMACTION;
                 break;
 
             case menu_load:
-                dptr->newtable = ROOT;
+                dptr->newtable = TABLE_ROOT;
                 dptr->extraseek = menu->items[i]->link;
+                dptr->customaction = ONPLAY_NO_CUSTOMACTION;
+                break;
+
+            case menu_shuffle_songs:
+                dptr->newtable = TABLE_NAVIBROWSE;
+                dptr->extraseek = i;
+                dptr->customaction = ONPLAY_CUSTOMACTION_SHUFFLE_SONGS;
+                break;
+
+            case menu_byfirstletter:
+                dptr->newtable = TABLE_NAVIBROWSE;
+                dptr->extraseek = i;
+                dptr->customaction = ONPLAY_CUSTOMACTION_FIRSTLETTER;
                 break;
         }
 
@@ -1796,6 +1898,8 @@ static int load_root(struct tree_context *c)
 
 int tagtree_load(struct tree_context* c)
 {
+    logf( "%s", __func__);
+
     int count;
     int table = c->currtable;
 
@@ -1804,20 +1908,32 @@ int tagtree_load(struct tree_context* c)
     if (!table)
     {
         c->dirfull = false;
-        table = ROOT;
+        table = TABLE_ROOT;
         c->currtable = table;
         c->currextra = rootmenu;
     }
 
     switch (table)
     {
-        case ROOT:
+        case TABLE_ROOT:
+            logf( "root...");
             count = load_root(c);
             break;
 
-        case ALLSUBENTRIES:
-        case NAVIBROWSE:
+        case TABLE_ALLSUBENTRIES:
+        case TABLE_NAVIBROWSE:
             logf("navibrowse...");
+
+            if (loaded_entries_crc != 0)
+            {
+                if (loaded_entries_crc == tagtree_data_crc(c))
+                {
+                    count = c->dirlength;
+                    logf("Reusing %d entries", count);
+                    break;
+                }
+            }
+
             cpu_boost(true);
             count = retrieve_entries(c, 0, true);
             cpu_boost(false);
@@ -1828,6 +1944,8 @@ int tagtree_load(struct tree_context* c)
             return -1;
     }
 
+    loaded_entries_crc = 0;
+
     if (count < 0)
     {
         if (count != RELOAD_TAGTREE)
@@ -1860,6 +1978,8 @@ int tagtree_load(struct tree_context* c)
  */
 int tagtree_enter(struct tree_context* c, bool is_visible)
 {
+    logf( "%s", __func__);
+
     int rc = 0;
     struct tagentry *dptr;
     struct mp3entry *id3;
@@ -1921,16 +2041,16 @@ int tagtree_enter(struct tree_context* c, bool is_visible)
     core_pin(tagtree_handle);
 
     switch (c->currtable) {
-        case ROOT:
+        case TABLE_ROOT:
             c->currextra = newextra;
 
-            if (newextra == ROOT)
+            if (newextra == TABLE_ROOT)
             {
                 menu = menus[seek];
                 c->currextra = seek;
             }
 
-            else if (newextra == NAVIBROWSE)
+            else if (newextra == TABLE_NAVIBROWSE)
             {
                 int i, j;
 
@@ -2005,9 +2125,9 @@ int tagtree_enter(struct tree_context* c, bool is_visible)
 
             break;
 
-        case NAVIBROWSE:
-        case ALLSUBENTRIES:
-            if (newextra == PLAYTRACK)
+        case TABLE_NAVIBROWSE:
+        case TABLE_ALLSUBENTRIES:
+            if (newextra == TABLE_PLAYTRACK)
             {
                 adjust_selection = false;
 
@@ -2059,6 +2179,7 @@ int tagtree_enter(struct tree_context* c, bool is_visible)
 /* Exits current database menu or table */
 void tagtree_exit(struct tree_context* c, bool is_visible)
 {
+    logf( "%s", __func__);
     if (is_visible) /* update selection history only for user-selected items */
     {
         if (c->selected_item != selected_item_history[c->dirlevel])
@@ -2102,44 +2223,84 @@ int tagtree_get_filename(struct tree_context* c, char *buf, int buflen)
     return 0;
 }
 
+int tagtree_get_custom_action(struct tree_context* c)
+{
+    return tagtree_get_entry(c, c->selected_item)->customaction;
+}
+
+static void swap_array_bool(bool *a, bool *b)
+{
+    bool temp = *a;
+    *a = *b;
+    *b = temp;
+}
+
+/**
+ * Randomly shuffle an array using the Fisher-Yates algorithm :
+ *  https://en.wikipedia.org/wiki/Random_permutation
+ *  This algorithm has a linear complexity.
+ *  Don't forget to srand before call to use it with a relevant seed.
+ */
+static bool* fill_random_playlist_indexes(bool *bool_array, size_t arr_sz,
+                                         size_t track_count, size_t max_slots)
+{
+    size_t i;
+    if (track_count * sizeof(bool) > arr_sz || max_slots > track_count)
+        return NULL;
+
+    for (i = 0; i < arr_sz; i++) /* fill max_slots with TRUE */
+        bool_array[i] = i < max_slots;
+
+    /* shuffle bool array */
+    for (i = track_count - 1; i > 0; i--)
+    {
+        int j = rand() % (i + 1);
+        swap_array_bool(&bool_array[i], &bool_array[j]);
+    }
+    return bool_array;
+}
 
 static bool insert_all_playlist(struct tree_context *c,
                                 const char* playlist, bool new_playlist,
                                 int position, bool queue)
 {
     struct tagcache_search tcs;
-    int i, n;
+    int n;
     int fd = -1;
     unsigned long last_tick;
+    int slots_remaining = 0;
+    bool fill_randomly = false;
+    bool *rand_bool_array = NULL;
     char buf[MAX_PATH];
+    struct playlist_insert_context context;
 
     cpu_boost(true);
+
     if (!tagcache_search(&tcs, tag_filename))
     {
         splash(HZ, ID2P(LANG_TAGCACHE_BUSY));
         cpu_boost(false);
         return false;
-    }
+    } /* NOTE: you need to close this search before returning */
 
-    if (playlist == NULL && position == PLAYLIST_REPLACE)
+    if (playlist == NULL)
     {
-        if (playlist_remove_all_tracks(NULL) == 0)
-            position = PLAYLIST_INSERT_LAST;
-        else
+        if (playlist_insert_context_create(NULL, &context, position, queue, false) < 0)
         {
+            tagcache_search_finish(&tcs);
             cpu_boost(false);
             return false;
         }
     }
-    else if (playlist != NULL)
+    else
     {
         if (new_playlist)
             fd = open_utf8(playlist, O_CREAT|O_WRONLY|O_TRUNC);
         else
             fd = open(playlist, O_CREAT|O_WRONLY|O_APPEND, 0666);
-
         if(fd < 0)
         {
+            tagcache_search_finish(&tcs);
             cpu_boost(false);
             return false;
         }
@@ -2148,45 +2309,120 @@ static bool insert_all_playlist(struct tree_context *c,
     last_tick = current_tick + HZ/2; /* Show splash after 0.5 seconds have passed */
     splash_progress_set_delay(HZ / 2); /* wait 1/2 sec before progress */
     n = c->filesindir;
-    for (i = 0; i < n; i++)
+
+    if (playlist == NULL)
     {
+        int max_playlist_size = playlist_get_current()->max_playlist_size;
+        slots_remaining = max_playlist_size - playlist_get_current()->amount;
+        if (slots_remaining <= 0)
+        {
+            logf("Playlist has no space remaining");
+            tagcache_search_finish(&tcs);
+            cpu_boost(false);
+            return false;
+        }
+
+        fill_randomly = n > slots_remaining;
+    
+        if (fill_randomly)
+        {
+            srand(current_tick);
+            size_t bufsize = 0;
+            bool *buffer = (bool *) plugin_get_buffer(&bufsize);
+            rand_bool_array = fill_random_playlist_indexes(buffer, bufsize,
+                                                           n, slots_remaining);
+
+            talk_id(LANG_RANDOM_SHUFFLE_RANDOM_SELECTIVE_SONGS_SUMMARY, true);
+            splashf(HZ * 2, str(LANG_RANDOM_SHUFFLE_RANDOM_SELECTIVE_SONGS_SUMMARY),
+                    slots_remaining);
+        }
+    }
 
-        splash_progress(i, n, "%s (%s)", str(LANG_WAIT), str(LANG_OFF_ABORT));
+    bool exit_loop_now = false;
+    for (int i = 0; i < n; i++)
+    {
         if (TIME_AFTER(current_tick, last_tick + HZ/4))
         {
+            splash_progress(i, n, "%s (%s)", str(LANG_WAIT), str(LANG_OFF_ABORT));
             if (action_userabort(TIMEOUT_NOBLOCK))
+            {
+                exit_loop_now = true;
                 break;
+            }
             last_tick = current_tick;
         }
 
-        if (!tagcache_retrieve(&tcs, tagtree_get_entry(c, i)->extraseek,
-                               tcs.type, buf, sizeof buf))
+        if (playlist == NULL)
         {
-            continue;
+            if (fill_randomly)
+            {
+                int remaining_tracks = n - i;
+                if (remaining_tracks > slots_remaining)
+                {
+                    if (rand_bool_array)
+                    {
+                        /* Skip the track if rand_bool_array[i] is FALSE */
+                        if (!rand_bool_array[i])
+                            continue;
+                    }
+                    else
+                    {
+                        /* Generate random value between 0 and remaining_tracks - 1 */
+                        int selrange = RAND_MAX / remaining_tracks; /* Improve distribution */
+                        int random;
+
+                        for (int r = 0; r < 0x0FFF; r++) /* limit loops */
+                        {
+                            random = rand() / selrange;
+                            if (random < remaining_tracks)
+                                break;
+                            else
+                                random = 0;
+                        }
+                        /* Skip the track if random >= slots_remaining */
+                        if (random >= slots_remaining)
+                            continue;
+                    }
+                }
+            }
         }
 
+        if (!tagcache_retrieve(&tcs, tagtree_get_entry(c, i)->extraseek, tcs.type, buf, sizeof buf))
+            continue;
+
         if (playlist == NULL)
         {
-            if (playlist_insert_track(NULL, buf, position, queue, false) < 0)
+            if (fill_randomly)
             {
+                if (--slots_remaining <= 0)
+                {
+                    exit_loop_now = true;
+                    break;
+                }
+            }
+
+            if (playlist_insert_context_add(&context, buf) < 0) {
                 logf("playlist_insert_track failed");
+                exit_loop_now = true;
                 break;
             }
         }
         else if (fdprintf(fd, "%s\n", buf) <= 0)
-                break;
-
-        yield();
-
-        if (playlist == NULL && position == PLAYLIST_INSERT_FIRST)
         {
-            position = PLAYLIST_INSERT;
+            exit_loop_now = true;
+            break;
         }
+        yield();
+
+        if (exit_loop_now)
+            break;
     }
+
     if (playlist == NULL)
-        playlist_sync(NULL);
+        playlist_insert_context_release(&context);
     else
         close(fd);
+
     tagcache_search_finish(&tcs);
     cpu_boost(false);
 
@@ -2196,14 +2432,14 @@ static bool insert_all_playlist(struct tree_context *c,
 static bool goto_allsubentries(int newtable)
 {
     int i = 0;
-    while (i < 2 && (newtable == NAVIBROWSE || newtable == ALLSUBENTRIES))
+    while (i < 2 && (newtable == TABLE_NAVIBROWSE || newtable == TABLE_ALLSUBENTRIES))
     {
         tagtree_enter(tc, false);
         tagtree_load(tc);
         newtable = tagtree_get_entry(tc, tc->selected_item)->newtable;
         i++;
     }
-    return (newtable == PLAYTRACK);
+    return (newtable == TABLE_PLAYTRACK);
 }
 
 static void reset_tc_to_prev(int dirlevel, int selected_item)
@@ -2229,11 +2465,11 @@ static bool tagtree_insert_selection(int position, bool queue,
 #else
         true
 #endif
-        , 0);
+        , 0, 0, 0);
 
     newtable = tagtree_get_entry(tc, tc->selected_item)->newtable;
 
-    if (newtable == PLAYTRACK) /* Insert a single track? */
+    if (newtable == TABLE_PLAYTRACK) /* Insert a single track? */
     {
         if (tagtree_get_filename(tc, buf, sizeof buf) < 0)
             return false;
@@ -2342,6 +2578,7 @@ int tagtree_add_to_playlist(const char* playlist, bool new_playlist)
 
 static int tagtree_play_folder(struct tree_context* c)
 {
+    logf( "%s", __func__);
     int start_index = c->selected_item;
 
     if (playlist_create(NULL, NULL) < 0)
@@ -2353,14 +2590,26 @@ static int tagtree_play_folder(struct tree_context* c)
     if (!insert_all_playlist(c, NULL, false, PLAYLIST_INSERT_LAST, false))
         return -2;
 
+    int n = c->filesindir;
+    bool has_playlist_been_randomized = n > playlist_get_current()->max_playlist_size;
+    if (has_playlist_been_randomized)
+    {
+        /* We need to recalculate the start index based on a percentage to put the user
+        around its desired start position and avoid out of bounds */
+
+        int percentage_start_index = 100 * start_index / n;
+        start_index = percentage_start_index * playlist_get_current()->amount / 100;
+    }
+
     if (global_settings.playlist_shuffle)
     {
-        start_index = playlist_shuffle(current_tick, c->selected_item);
+        start_index = playlist_shuffle(current_tick, start_index);
         if (!global_settings.play_selected)
             start_index = 0;
     }
 
     playlist_start(start_index, 0, 0);
+    loaded_entries_crc = tagtree_data_crc(c); /* save crc in case we return */
     return 0;
 }
 
@@ -2403,11 +2652,11 @@ char *tagtree_get_title(struct tree_context* c)
 {
     switch (c->currtable)
     {
-        case ROOT:
+        case TABLE_ROOT:
             return menu->title;
 
-        case NAVIBROWSE:
-        case ALLSUBENTRIES:
+        case TABLE_NAVIBROWSE:
+        case TABLE_ALLSUBENTRIES:
             return current_title[c->currextra];
     }
 
@@ -2419,7 +2668,7 @@ int tagtree_get_attr(struct tree_context* c)
     int attr = -1;
     switch (c->currtable)
     {
-        case NAVIBROWSE:
+        case TABLE_NAVIBROWSE:
             if (csi->tagorder[c->currextra] == tag_title
                 || csi->tagorder[c->currextra] == tag_virt_basename)
                 attr = FILE_ATTR_AUDIO;
@@ -2427,7 +2676,7 @@ int tagtree_get_attr(struct tree_context* c)
                 attr = ATTR_DIRECTORY;
             break;
 
-        case ALLSUBENTRIES:
+        case TABLE_ALLSUBENTRIES:
             attr = FILE_ATTR_AUDIO;
             break;