From edc5a0745c38cce54d8e38747fcd11da30662cdb Mon Sep 17 00:00:00 2001
From: Gavin Troy <gavtroy@fastmail.fm>
Date: Tue, 19 Jan 2021 21:08:05 +0000
Subject: [PATCH] Add an album shuffle mode

This is not implemented for playlists as currently they are not
album-aware. I think this is a reasonable limitation for now, as
playlists also don't offer AAA modes.

Closes #641
---
 Doc/cmus.txt   |  19 +++++--
 command_mode.c |  22 ++++++--
 lib.c          | 149 +++++++++++++++++++++++++++++++++++++++++--------
 lib.h          |  10 +++-
 options.c      |  36 ++++++++----
 options.h      |   9 +++
 pl.c           |   4 +-
 player.c       |   2 +-
 track.c        |  18 ++++--
 track.h        |   4 +-
 tree.c         |  16 ++++--
 ui_curses.c    |   2 +-
 12 files changed, 229 insertions(+), 62 deletions(-)

diff --git a/Doc/cmus.txt b/Doc/cmus.txt
index 4c6f182fe..a3a0f57b1 100644
--- a/Doc/cmus.txt
+++ b/Doc/cmus.txt
@@ -654,8 +654,8 @@ source <filename>
 	Reads and executes commands from <filename>.
 
 toggle <option>
-	Toggles the value of a toggle-able option (all booleans and tristate
-	*aaa_mode*).
+	Toggles the value of a toggle-able option (all booleans and the options
+	*shuffle*, *aaa_mode*, and *replaygain*).
 
 tqueue [NUM]
 	Queues NUM (default 1) random tracks from the library. See also
@@ -1149,9 +1149,18 @@ show_playback_position (true)
 show_remaining_time (false)
 	Display remaining time instead of elapsed time.
 
-shuffle (false)
-	Play in shuffled order. Shuffle works in the library views (1-2) and
-	playlist view (3).
+shuffle (off) [off, tracks, albums]
+	@li *off*
+	Play all tracks in order. See also *lib_sort* and *pl_sort*.
+	@li *tracks*
+	Play all tracks in the library or playlist in a shuffled order.
+	@li *albums*
+	Play each library album to completion before shuffling to the first track
+	of another library album. In playlists this option falls back to *tracks*
+	behaviour.
+
+	Filters and *aaa_mode* can be used to limit the items available for play.
+	Note that *shuffle*=`albums` will have no effect with *aaa_mode*=`album`.
 
 skip_track_info (false)
 	Don't load metadata when adding tracks. Useful when using network file
diff --git a/command_mode.c b/command_mode.c
index 5cbdd98b7..97541cc4d 100644
--- a/command_mode.c
+++ b/command_mode.c
@@ -1584,19 +1584,31 @@ static void cmd_win_activate(char *arg)
 	struct rb_root *shuffle_root = NULL;
 
 	if (cur_view == TREE_VIEW || cur_view == SORTED_VIEW) {
-		if (lib_cur_track)
-			previous = &lib_cur_track->simple_track.shuffle_info;
-		shuffle_root = &lib_shuffle_root;
+		if (shuffle == SHUFFLE_TRACKS) {
+			if (lib_cur_track)
+				previous = &lib_cur_track->simple_track.shuffle_info;
+			shuffle_root = &lib_shuffle_root;
+		} else if (shuffle == SHUFFLE_ALBUMS) {
+			if (lib_cur_track)
+				previous = &lib_cur_track->album->shuffle_info;
+			shuffle_root = &lib_album_shuffle_root;
+		}
 	}
 
 	switch (cur_view) {
 	case TREE_VIEW:
 		info = tree_activate_selected();
-		next = &lib_cur_track->simple_track.shuffle_info;
+		if (shuffle == SHUFFLE_TRACKS)
+			next = &lib_cur_track->simple_track.shuffle_info;
+		else if (shuffle == SHUFFLE_ALBUMS)
+			next = &lib_cur_track->album->shuffle_info;
 		break;
 	case SORTED_VIEW:
 		info = sorted_activate_selected();
-		next = &lib_cur_track->simple_track.shuffle_info;
+		if (shuffle == SHUFFLE_TRACKS)
+			next = &lib_cur_track->simple_track.shuffle_info;
+		else if (shuffle == SHUFFLE_ALBUMS)
+			next = &lib_cur_track->album->shuffle_info;
 		break;
 	case PLAYLIST_VIEW:
 		info = pl_play_selected_row();
diff --git a/lib.c b/lib.c
index 353b5f715..04c6424e0 100644
--- a/lib.c
+++ b/lib.c
@@ -39,6 +39,7 @@ enum aaa_mode aaa_mode = AAA_MODE_ALL;
 char *lib_live_filter = NULL;
 
 struct rb_root lib_shuffle_root;
+struct rb_root lib_album_shuffle_root;
 static struct expr *filter = NULL;
 static struct expr *add_filter = NULL;
 static int remove_from_hash = 1;
@@ -77,6 +78,16 @@ static void shuffle_add(struct tree_track *track)
 	shuffle_list_add(&track->simple_track.shuffle_info, &lib_shuffle_root, track->album);
 }
 
+static void album_shuffle_list_add(struct album *album)
+{
+	shuffle_list_add(&album->shuffle_info, &lib_album_shuffle_root, album);
+}
+
+static void album_shuffle_list_remove(struct album *album)
+{
+	rb_erase(&album->shuffle_info.tree_node, &lib_album_shuffle_root);
+}
+
 static void views_add_track(struct track_info *ti)
 {
 	struct tree_track *track = xnew(struct tree_track, 1);
@@ -87,7 +98,7 @@ static void views_add_track(struct track_info *ti)
 	/* both the hash table and views have refs */
 	track_info_ref(ti);
 
-	tree_add_track(track);
+	tree_add_track(track, album_shuffle_list_add);
 	shuffle_add(track);
 	editable_add(&lib_editable, (struct simple_track *)track);
 }
@@ -217,12 +228,20 @@ static int aaa_mode_filter(const struct album *album)
 	return 1;
 }
 
+static int cur_album_filter(const struct album *album)
+{
+	return CUR_ALBUM == album;
+}
+
 /* set next/prev (tree) {{{ */
 
-static struct tree_track *normal_get_next(void)
+static struct tree_track *normal_get_next(enum aaa_mode aaa, bool allow_repeat)
 {
-	if (lib_cur_track == NULL)
+	if (lib_cur_track == NULL) {
+		if (!allow_repeat)
+			return NULL;
 		return normal_get_first();
+	}
 
 	/* not last track of the album? */
 	if (rb_next(&lib_cur_track->tree_node)) {
@@ -230,8 +249,8 @@ static struct tree_track *normal_get_next(void)
 		return to_tree_track(rb_next(&lib_cur_track->tree_node));
 	}
 
-	if (aaa_mode == AAA_MODE_ALBUM) {
-		if (!repeat)
+	if (aaa == AAA_MODE_ALBUM) {
+		if (!allow_repeat || !repeat)
 			return NULL;
 		/* first track of the current album */
 		return album_first_track(CUR_ALBUM);
@@ -243,8 +262,8 @@ static struct tree_track *normal_get_next(void)
 		return album_first_track(to_album(rb_next(&CUR_ALBUM->tree_node)));
 	}
 
-	if (aaa_mode == AAA_MODE_ARTIST) {
-		if (!repeat)
+	if (aaa == AAA_MODE_ARTIST) {
+		if (!allow_repeat || !repeat)
 			return NULL;
 		/* first track of the first album of the current artist */
 		return artist_first_track(CUR_ARTIST);
@@ -256,17 +275,20 @@ static struct tree_track *normal_get_next(void)
 		return artist_first_track(to_artist(rb_next(&CUR_ARTIST->tree_node)));
 	}
 
-	if (!repeat)
+	if (!allow_repeat || !repeat)
 		return NULL;
 
 	/* first track */
 	return normal_get_first();
 }
 
-static struct tree_track *normal_get_prev(void)
+static struct tree_track *normal_get_prev(enum aaa_mode aaa, bool allow_repeat)
 {
-	if (lib_cur_track == NULL)
+	if (lib_cur_track == NULL) {
+		if (!allow_repeat)
+			return NULL;
 		return normal_get_last();
+	}
 
 	/* not first track of the album? */
 	if (rb_prev(&lib_cur_track->tree_node)) {
@@ -274,8 +296,8 @@ static struct tree_track *normal_get_prev(void)
 		return to_tree_track(rb_prev(&lib_cur_track->tree_node));
 	}
 
-	if (aaa_mode == AAA_MODE_ALBUM) {
-		if (!repeat)
+	if (aaa == AAA_MODE_ALBUM) {
+		if (!allow_repeat || !repeat)
 			return NULL;
 		/* last track of the album */
 		return album_last_track(CUR_ALBUM);
@@ -287,8 +309,8 @@ static struct tree_track *normal_get_prev(void)
 		return album_last_track(to_album(rb_prev(&CUR_ALBUM->tree_node)));
 	}
 
-	if (aaa_mode == AAA_MODE_ARTIST) {
-		if (!repeat)
+	if (aaa == AAA_MODE_ARTIST) {
+		if (!allow_repeat || !repeat)
 			return NULL;
 		/* last track of the last album of the artist */
 		return album_last_track(to_album(rb_last(&CUR_ARTIST->album_root)));
@@ -300,18 +322,79 @@ static struct tree_track *normal_get_prev(void)
 		return artist_last_track(to_artist(rb_prev(&CUR_ARTIST->tree_node)));
 	}
 
-	if (!repeat)
+	if (!allow_repeat || !repeat)
 		return NULL;
 
 	/* last track */
 	return normal_get_last();
 }
 
+static struct tree_track *shuffle_album_get_next(void)
+{
+	struct shuffle_info *shuffle_info = NULL;
+	struct album *album;
+
+	if (lib_cur_track != NULL)
+		shuffle_info = &lib_cur_track->album->shuffle_info;
+	album = (struct album *)shuffle_list_get_next(&lib_album_shuffle_root,
+			shuffle_info, aaa_mode_filter);
+	if (album != NULL)
+		return album_first_track(album);
+	return NULL;
+}
+
+static struct tree_track *shuffle_album_get_prev(void)
+{
+	struct shuffle_info *shuffle_info = NULL;
+	struct album *album;
+
+	if (lib_cur_track != NULL)
+		shuffle_info = &lib_cur_track->album->shuffle_info;
+	album = (struct album *)shuffle_list_get_prev(&lib_album_shuffle_root,
+			shuffle_info, aaa_mode_filter);
+	if (album != NULL)
+		return album_last_track(album);
+	return NULL;
+}
+
+static struct tree_track *sorted_album_first_track(struct tree_track *track)
+{
+	struct tree_track *prev = track;
+
+	while (true) {
+		prev = (struct tree_track *)simple_list_get_prev(&lib_editable.head,
+			   (struct simple_track *)prev, NULL, false);
+		if (prev == NULL)
+			return track;
+		if (prev->album == track->album)
+			track = prev;
+	}
+}
+
+static struct tree_track *sorted_album_last_track(struct tree_track *track)
+{
+	struct tree_track *next = track;
+
+	while (true) {
+		next = (struct tree_track *)simple_list_get_next(&lib_editable.head,
+			   (struct simple_track *)next, NULL, false);
+		if (next == NULL)
+			return track;
+		if (next->album == track->album)
+			track = next;
+	}
+}
+
 /* set next/prev (tree) }}} */
 
 void lib_reshuffle(void)
 {
 	shuffle_list_reshuffle(&lib_shuffle_root);
+	shuffle_list_reshuffle(&lib_album_shuffle_root);
+}
+
+void lib_sort_artists(void) {
+	tree_sort_artists(album_shuffle_list_add, album_shuffle_list_remove);
 }
 
 static void free_lib_track(struct editable *e, struct list_head *item)
@@ -326,7 +409,7 @@ static void free_lib_track(struct editable *e, struct list_head *item)
 		hash_remove(ti);
 
 	rb_erase(&track->simple_track.shuffle_info.tree_node, &lib_shuffle_root);
-	tree_remove(track);
+	tree_remove(track, album_shuffle_list_remove);
 
 	track_info_unref(ti);
 	free(track);
@@ -365,14 +448,25 @@ struct track_info *lib_goto_next(void)
 		BUG_ON(lib_cur_track != NULL);
 		return NULL;
 	}
-	if (shuffle) {
+	if (shuffle == SHUFFLE_TRACKS) {
 		track = (struct tree_track *)shuffle_list_get_next(&lib_shuffle_root,
 				(struct shuffle_info *)lib_cur_track, aaa_mode_filter);
+	} else if (shuffle == SHUFFLE_ALBUMS) {
+		if (play_sorted)
+			track = (struct tree_track *)simple_list_get_next(&lib_editable.head,
+					(struct simple_track *)lib_cur_track, cur_album_filter, false);
+		else
+			track = normal_get_next(AAA_MODE_ALBUM, false);
+		if (track == NULL) {
+			track = shuffle_album_get_next();
+			if (play_sorted)
+				track = sorted_album_first_track(track);
+		}
 	} else if (play_sorted) {
 		track = (struct tree_track *)simple_list_get_next(&lib_editable.head,
-				(struct simple_track *)lib_cur_track, aaa_mode_filter);
+				(struct simple_track *)lib_cur_track, aaa_mode_filter, true);
 	} else {
-		track = normal_get_next();
+		track = normal_get_next(aaa_mode, true);
 	}
 	return lib_set_track(track);
 }
@@ -385,14 +479,25 @@ struct track_info *lib_goto_prev(void)
 		BUG_ON(lib_cur_track != NULL);
 		return NULL;
 	}
-	if (shuffle) {
+	if (shuffle == SHUFFLE_TRACKS) {
 		track = (struct tree_track *)shuffle_list_get_prev(&lib_shuffle_root,
 				(struct shuffle_info *)lib_cur_track, aaa_mode_filter);
+	} else if (shuffle == SHUFFLE_ALBUMS) {
+		if (play_sorted)
+			track = (struct tree_track *)simple_list_get_prev(&lib_editable.head,
+					(struct simple_track *)lib_cur_track, cur_album_filter, false);
+		else
+			track = normal_get_prev(AAA_MODE_ALBUM, false);
+		if (track == NULL) {
+			track = shuffle_album_get_prev();
+			if (play_sorted)
+				track = sorted_album_last_track(track);
+		}
 	} else if (play_sorted) {
 		track = (struct tree_track *)simple_list_get_prev(&lib_editable.head,
-				(struct simple_track *)lib_cur_track, aaa_mode_filter);
+				(struct simple_track *)lib_cur_track, aaa_mode_filter, true);
 	} else {
-		track = normal_get_prev();
+		track = normal_get_prev(aaa_mode, true);
 	}
 	return lib_set_track(track);
 }
diff --git a/lib.h b/lib.h
index aecf09aa0..a7efa50e1 100644
--- a/lib.h
+++ b/lib.h
@@ -46,6 +46,8 @@ static inline struct tree_track *to_tree_track(const struct rb_node *node)
 
 
 struct album {
+	struct shuffle_info shuffle_info;
+
 	/* position in album search tree */
 	struct rb_node tree_node;
 
@@ -93,6 +95,7 @@ enum aaa_mode {
 extern struct editable lib_editable;
 extern struct tree_track *lib_cur_track;
 extern struct rb_root lib_shuffle_root;
+extern struct rb_root lib_album_shuffle_root;
 extern enum aaa_mode aaa_mode;
 extern unsigned int play_sorted;
 extern char *lib_live_filter;
@@ -117,6 +120,7 @@ void lib_set_add_filter(struct expr *expr);
 int lib_remove(struct track_info *ti);
 void lib_clear_store(void);
 void lib_reshuffle(void);
+void lib_sort_artists(void);
 void lib_set_view(int view);
 int lib_for_each(int (*cb)(void *data, struct track_info *ti), void *data,
 		void *opaque);
@@ -130,9 +134,9 @@ struct track_info *lib_get_cur_stored_track(void);
 
 struct tree_track *tree_get_selected(void);
 struct track_info *tree_activate_selected(void);
-void tree_sort_artists(void);
-void tree_add_track(struct tree_track *track);
-void tree_remove(struct tree_track *track);
+void tree_sort_artists(void (*add_album_cb)(struct album *), void (*remove_album_cb)(struct album *));
+void tree_add_track(struct tree_track *track, void (*add_album_cb)(struct album *));
+void tree_remove(struct tree_track *track, void (*remove_album_cb)(struct album *));
 void tree_remove_sel(void);
 void tree_toggle_active_window(void);
 void tree_toggle_expand_artist(void);
diff --git a/options.c b/options.c
index 03a2015b5..592400a4c 100644
--- a/options.c
+++ b/options.c
@@ -657,11 +657,9 @@ static void toggle_play_sorted(void *data)
 {
 	play_sorted = play_sorted ^ 1;
 
-	/* shuffle would override play_sorted... */
 	if (play_sorted) {
 		/* play_sorted makes no sense in playlist */
 		play_library = 1;
-		shuffle = 0;
 	}
 
 	update_statusline();
@@ -675,13 +673,13 @@ static void get_smart_artist_sort(void *data, char *buf, size_t size)
 static void set_smart_artist_sort(void *data, const char *buf)
 {
 	if (parse_bool(buf, &smart_artist_sort))
-		tree_sort_artists();
+		lib_sort_artists();
 }
 
 static void toggle_smart_artist_sort(void *data)
 {
 	smart_artist_sort ^= 1;
-	tree_sort_artists();
+	lib_sort_artists();
 }
 
 static void get_display_artist_sort_name(void *data, char *buf, size_t size)
@@ -1008,25 +1006,43 @@ static void toggle_set_term_title(void *data)
 	set_term_title ^= 1;
 }
 
+const char * const shuffle_names[] = {
+	"off", "tracks", "albums", "false", "true", NULL
+};
+
 static void get_shuffle(void *data, char *buf, size_t size)
 {
-	strscpy(buf, bool_names[shuffle], size);
+	strscpy(buf, shuffle_names[shuffle], size);
 }
 
 static void set_shuffle(void *data, const char *buf)
 {
-	int old = shuffle;
-	if (!parse_bool(buf, &shuffle))
+	int tmp;
+
+	if (!parse_enum(buf, 0, 4, shuffle_names, &tmp))
 		return;
-	if (old != shuffle)
+
+	if (tmp == SHUFFLE_FALSE)
+		tmp = SHUFFLE_OFF;
+	else if (tmp == SHUFFLE_TRUE)
+		tmp = SHUFFLE_TRACKS;
+
+	if (tmp != shuffle)
 		mpris_shuffle_changed();
+
+	shuffle = tmp;
 	update_statusline();
 }
 
 static void toggle_shuffle(void *data)
 {
-	shuffle ^= 1;
-	mpris_shuffle_changed();
+	shuffle++;
+	shuffle %= 3;
+
+	/* album mode makes no sense in playlist */
+	if (!play_library && shuffle == SHUFFLE_ALBUMS)
+		shuffle = SHUFFLE_OFF;
+
 	update_statusline();
 }
 
diff --git a/options.h b/options.h
index c0323c64c..13f766e4d 100644
--- a/options.h
+++ b/options.h
@@ -116,6 +116,15 @@ enum {
 	NR_ATTRS
 };
 
+enum shuffle_mode {
+	SHUFFLE_OFF,
+	SHUFFLE_TRACKS,
+	SHUFFLE_ALBUMS,
+	/* backwards compatability */
+	SHUFFLE_FALSE,
+	SHUFFLE_TRUE
+};
+
 #define BRIGHT (1 << 3)
 
 extern char *cdda_device;
diff --git a/pl.c b/pl.c
index a1f0bf607..ba8fc5566 100644
--- a/pl.c
+++ b/pl.c
@@ -359,7 +359,7 @@ static struct track_info *pl_play_first_in_pl_playing(void)
 
 static struct simple_track *pl_get_next(struct playlist *pl, struct simple_track *cur)
 {
-	return simple_list_get_next(&pl->editable.head, cur, NULL);
+	return simple_list_get_next(&pl->editable.head, cur, NULL, true);
 }
 
 static struct simple_track *pl_get_next_shuffled(struct playlist *pl,
@@ -373,7 +373,7 @@ static struct simple_track *pl_get_next_shuffled(struct playlist *pl,
 static struct simple_track *pl_get_prev(struct playlist *pl,
 		struct simple_track *cur)
 {
-	return simple_list_get_prev(&pl->editable.head, cur, NULL);
+	return simple_list_get_prev(&pl->editable.head, cur, NULL, true);
 }
 
 static struct simple_track *pl_get_prev_shuffled(struct playlist *pl,
diff --git a/player.c b/player.c
index abc185571..fb6cdf8fd 100644
--- a/player.c
+++ b/player.c
@@ -355,7 +355,7 @@ static void update_rg_scale(void)
 	if (!player_info_priv.ti || !replaygain)
 		return;
 
-	bool avoid_album_gain = replaygain == RG_SMART && (!play_library || shuffle || cmus_queue_active());
+	bool avoid_album_gain = replaygain == RG_SMART && (!play_library || shuffle == SHUFFLE_TRACKS || cmus_queue_active());
 	
 	if (replaygain == RG_TRACK || replaygain == RG_TRACK_PREFERRED || avoid_album_gain) {
 		gain = player_info_priv.ti->rg_track_gain;
diff --git a/track.c b/track.c
index bc9fcef7b..15d61d3a6 100644
--- a/track.c
+++ b/track.c
@@ -151,12 +151,15 @@ struct shuffle_info *shuffle_list_get_prev(struct rb_root *root, struct shuffle_
 }
 
 struct simple_track *simple_list_get_next(struct list_head *head, struct simple_track *cur,
-		int (*filter_callback)(const struct album *))
+		int (*filter_callback)(const struct album *), bool allow_repeat)
 {
 	struct list_head *item;
 
-	if (cur == NULL)
+	if (cur == NULL) {
+		if (!allow_repeat)
+			return NULL;
 		return to_simple_track(head->next);
+	}
 
 	item = cur->node.next;
 again:
@@ -168,18 +171,21 @@ struct simple_track *simple_list_get_next(struct list_head *head, struct simple_
 		item = item->next;
 	}
 	item = head->next;
-	if (repeat)
+	if (allow_repeat && repeat)
 		goto again;
 	return NULL;
 }
 
 struct simple_track *simple_list_get_prev(struct list_head *head, struct simple_track *cur,
-		int (*filter_callback)(const struct album *))
+		int (*filter_callback)(const struct album *), bool allow_repeat)
 {
 	struct list_head *item;
 
-	if (cur == NULL)
+	if (cur == NULL) {
+		if (!allow_repeat)
+			return NULL;
 		return to_simple_track(head->prev);
+	}
 
 	item = cur->node.prev;
 again:
@@ -191,7 +197,7 @@ struct simple_track *simple_list_get_prev(struct list_head *head, struct simple_
 		item = item->prev;
 	}
 	item = head->prev;
-	if (repeat)
+	if (allow_repeat && repeat)
 		goto again;
 	return NULL;
 }
diff --git a/track.h b/track.h
index 17fa5af6e..76f92cfe0 100644
--- a/track.h
+++ b/track.h
@@ -91,10 +91,10 @@ struct shuffle_info *shuffle_list_get_prev(struct rb_root *root, struct shuffle_
 		int (*filter)(const struct album *));
 
 struct simple_track *simple_list_get_next(struct list_head *head, struct simple_track *cur,
-		int (*filter)(const struct album *));
+		int (*filter)(const struct album *), bool allow_repeat);
 
 struct simple_track *simple_list_get_prev(struct list_head *head, struct simple_track *cur,
-		int (*filter)(const struct album *));
+		int (*filter)(const struct album *), bool allow_repeat);
 
 void sorted_list_add_track(struct list_head *head, struct rb_root *tree_root, struct simple_track *track,
 		const sort_key_t *keys, int tiebreak);
diff --git a/tree.c b/tree.c
index 105eec3fd..304ed102b 100644
--- a/tree.c
+++ b/tree.c
@@ -914,7 +914,8 @@ static void remove_artist(struct artist *artist)
 	rb_erase(&artist->tree_node, &lib_artist_root);
 }
 
-void tree_add_track(struct tree_track *track)
+void tree_add_track(struct tree_track *track,
+		void (*add_album_cb)(struct album *))
 {
 	const struct track_info *ti = tree_track_info(track);
 	const char *album_name, *artist_name, *artistsort_name = NULL;
@@ -1005,6 +1006,7 @@ void tree_add_track(struct tree_track *track)
 
 	} else if (artist) {
 		add_album(new_album);
+		add_album_cb(new_album);
 		album_add_track(new_album, track);
 
 		if (artist->expanded)
@@ -1012,6 +1014,7 @@ void tree_add_track(struct tree_track *track)
 	} else {
 		add_artist(new_artist);
 		add_album(new_album);
+		add_album_cb(new_album);
 		album_add_track(new_album, track);
 
 		window_changed(lib_tree_win);
@@ -1179,7 +1182,8 @@ static void remove_track(struct tree_track *track)
 	rb_erase(&track->tree_node, &track->album->track_root);
 }
 
-void tree_remove(struct tree_track *track)
+void tree_remove(struct tree_track *track,
+		void (*remove_album_cb)(struct album *))
 {
 	struct album *album = track->album;
 	struct artist *sel_artist;
@@ -1203,6 +1207,7 @@ void tree_remove(struct tree_track *track)
 		}
 
 		remove_album(album);
+		remove_album_cb(album);
 		album_free(album);
 
 		if (rb_root_empty(&artist->album_root)) {
@@ -1222,7 +1227,8 @@ void tree_remove_sel(void)
 	}
 }
 
-void tree_sort_artists(void)
+void tree_sort_artists(void (*add_album_cb)(struct album *),
+		void (*remove_album_cb)(struct album *))
 {
 	struct rb_node *a_node, *a_tmp;
 
@@ -1237,8 +1243,8 @@ void tree_sort_artists(void)
 			rb_for_each_safe(t_node, t_tmp, &album->track_root) {
 				struct tree_track *track = to_tree_track(t_node);
 
-				tree_remove(track);
-				tree_add_track(track);
+				tree_remove(track, remove_album_cb);
+				tree_add_track(track, add_album_cb);
 			}
 		}
 	}
diff --git a/ui_curses.c b/ui_curses.c
index 558c6977f..670a00b78 100644
--- a/ui_curses.c
+++ b/ui_curses.c
@@ -616,7 +616,7 @@ const struct format_option *get_global_fopts(void)
 	static const char *cont_strs[] = { " ", "C" };
 	static const char *follow_strs[] = { " ", "F" };
 	static const char *repeat_strs[] = { " ", "R" };
-	static const char *shuffle_strs[] = { " ", "S" };
+	static const char *shuffle_strs[] = { " ", "S", "&" };
 	int buffer_fill, vol, vol_left, vol_right;
 	int duration = -1;