1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2002 by wavey@wavey.org
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.
15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
16 * KIND, either express or implied.
18 ****************************************************************************/
21 Dynamic playlist design (based on design originally proposed by ricII)
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.
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.
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
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
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.
83 #include "applimits.h"
93 #include "filetypes.h"
94 #ifdef HAVE_LCD_BITMAP
101 #include "rbunicode.h"
102 #include "root_menu.h"
104 #define PLAYLIST_CONTROL_FILE ROCKBOX_DIR "/.playlist_control"
105 #define PLAYLIST_CONTROL_FILE_VERSION 2
108 Each playlist index has a flag associated with it which identifies what
109 type of track it is. These flags are stored in the 4 high order bits of
112 NOTE: This limits the playlist file size to a max of 256M.
116 01 = Track was prepended into playlist
117 10 = Track was inserted into playlist
118 11 = Track was appended into playlist
123 0 = Track entry is valid
124 1 = Track does not exist on disk and should be skipped
126 #define PLAYLIST_SEEK_MASK 0x0FFFFFFF
127 #define PLAYLIST_INSERT_TYPE_MASK 0xC0000000
128 #define PLAYLIST_QUEUE_MASK 0x20000000
130 #define PLAYLIST_INSERT_TYPE_PREPEND 0x40000000
131 #define PLAYLIST_INSERT_TYPE_INSERT 0x80000000
132 #define PLAYLIST_INSERT_TYPE_APPEND 0xC0000000
134 #define PLAYLIST_QUEUED 0x20000000
135 #define PLAYLIST_SKIPPED 0x10000000
137 #define PLAYLIST_DISPLAY_COUNT 10
139 struct directory_search_context
{
140 struct playlist_info
* playlist
;
146 static struct playlist_info current_playlist
;
147 static char now_playing
[MAX_PATH
+1];
149 static void empty_playlist(struct playlist_info
* playlist
, bool resume
);
150 static void new_playlist(struct playlist_info
* playlist
, const char *dir
,
152 static void create_control(struct playlist_info
* playlist
);
153 static int check_control(struct playlist_info
* playlist
);
154 static int recreate_control(struct playlist_info
* playlist
);
155 static void update_playlist_filename(struct playlist_info
* playlist
,
156 const char *dir
, const char *file
);
157 static int add_indices_to_playlist(struct playlist_info
* playlist
,
158 char* buffer
, size_t buflen
);
159 static int add_track_to_playlist(struct playlist_info
* playlist
,
160 const char *filename
, int position
,
161 bool queue
, int seek_pos
);
162 static int directory_search_callback(char* filename
, void* context
);
163 static int remove_track_from_playlist(struct playlist_info
* playlist
,
164 int position
, bool write
);
165 static int randomise_playlist(struct playlist_info
* playlist
,
166 unsigned int seed
, bool start_current
,
168 static int sort_playlist(struct playlist_info
* playlist
, bool start_current
,
170 static int get_next_index(const struct playlist_info
* playlist
, int steps
,
172 static void find_and_set_playlist_index(struct playlist_info
* playlist
,
174 static int compare(const void* p1
, const void* p2
);
175 static int get_filename(struct playlist_info
* playlist
, int index
, int seek
,
176 bool control_file
, char *buf
, int buf_length
);
177 static int get_next_directory(char *dir
);
178 static int get_next_dir(char *dir
, bool is_forward
, bool recursion
);
179 static int get_previous_directory(char *dir
);
180 static int check_subdir_for_music(char *dir
, char *subdir
);
181 static int format_track_path(char *dest
, char *src
, int buf_length
, int max
,
183 static void display_playlist_count(int count
, const unsigned char *fmt
,
185 static void display_buffer_full(void);
186 static int flush_cached_control(struct playlist_info
* playlist
);
187 static int update_control(struct playlist_info
* playlist
,
188 enum playlist_command command
, int i1
, int i2
,
189 const char* s1
, const char* s2
, void* data
);
190 static void sync_control(struct playlist_info
* playlist
, bool force
);
191 static int rotate_index(const struct playlist_info
* playlist
, int index
);
194 #define PLAYLIST_LOAD_POINTERS 1
196 static struct event_queue playlist_queue
;
197 static long playlist_stack
[(DEFAULT_STACK_SIZE
+ 0x800)/sizeof(long)];
198 static const char playlist_thread_name
[] = "playlist cachectrl";
201 #define BOM "\xef\xbb\xbf"
204 /* Check if the filename suggests M3U or M3U8 format. */
205 static bool is_m3u8(const char* filename
)
207 int len
= strlen(filename
);
209 /* Default to M3U8 unless explicitly told otherwise. */
210 return !(len
> 4 && strcasecmp(&filename
[len
- 4], ".m3u") == 0);
213 /* Check if a strings starts with an UTF-8 byte-order mark. */
214 static bool is_utf8_bom(const char* str
, int len
)
216 return len
>= BOM_SIZE
&& memcmp(str
, BOM
, BOM_SIZE
) == 0;
219 /* Convert a filename in an M3U playlist to UTF-8.
221 * buf - the filename to convert; can contain more than one line from the
223 * buf_len - amount of buf that is used.
224 * buf_max - total size of buf.
225 * temp - temporary conversion buffer, at least buf_max bytes.
227 * Returns the length of the converted filename.
229 static int convert_m3u(char* buf
, int buf_len
, int buf_max
, char* temp
)
235 while ((buf
[i
] != '\n') && (buf
[i
] != '\r') && (i
< buf_len
))
240 /* Work back killing white space. */
241 while ((i
> 0) && isspace(buf
[i
- 1]))
249 /* Convert char by char, so as to not overflow temp (iso_decode should
250 * preferably handle this). No more than 4 bytes should be generated for
253 for (i
= 0; i
< buf_len
&& dest
< (temp
+ buf_max
- 4); i
++)
255 dest
= iso_decode(&buf
[i
], dest
, -1, 1);
264 * remove any files and indices associated with the playlist
266 static void empty_playlist(struct playlist_info
* playlist
, bool resume
)
268 playlist
->filename
[0] = '\0';
269 playlist
->utf8
= true;
271 if(playlist
->fd
>= 0)
272 /* If there is an already open playlist, close it. */
276 if(playlist
->control_fd
>= 0)
277 close(playlist
->control_fd
);
278 playlist
->control_fd
= -1;
279 playlist
->control_created
= false;
281 playlist
->in_ram
= false;
283 if (playlist
->buffer
)
284 playlist
->buffer
[0] = 0;
286 playlist
->buffer_end_pos
= 0;
289 playlist
->first_index
= 0;
290 playlist
->amount
= 0;
291 playlist
->last_insert_pos
= -1;
293 playlist
->shuffle_modified
= false;
294 playlist
->deleted
= false;
295 playlist
->num_inserted_tracks
= 0;
296 playlist
->started
= false;
298 playlist
->num_cached
= 0;
299 playlist
->pending_control_sync
= false;
301 if (!resume
&& playlist
->current
)
303 /* start with fresh playlist control file when starting new
305 create_control(playlist
);
307 /* Reset resume settings */
308 global_status
.resume_first_index
= 0;
309 global_status
.resume_seed
= -1;
314 * Initialize a new playlist for viewing/editing/playing. dir is the
315 * directory where the playlist is located and file is the filename.
317 static void new_playlist(struct playlist_info
* playlist
, const char *dir
,
320 empty_playlist(playlist
, false);
326 if (dir
&& playlist
->current
) /* !current cannot be in_ram */
327 playlist
->in_ram
= true;
329 dir
= ""; /* empty playlist */
332 update_playlist_filename(playlist
, dir
, file
);
334 if (playlist
->control_fd
>= 0)
336 update_control(playlist
, PLAYLIST_COMMAND_PLAYLIST
,
337 PLAYLIST_CONTROL_FILE_VERSION
, -1, dir
, file
, NULL
);
338 sync_control(playlist
, false);
343 * create control file for playlist
345 static void create_control(struct playlist_info
* playlist
)
347 playlist
->control_fd
= open(playlist
->control_filename
,
348 O_CREAT
|O_RDWR
|O_TRUNC
);
349 if (playlist
->control_fd
< 0)
351 if (check_rockboxdir())
353 cond_talk_ids_fq(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
);
354 gui_syncsplash(HZ
*2, (unsigned char *)"%s (%d)",
355 str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
),
356 playlist
->control_fd
);
358 playlist
->control_created
= false;
362 playlist
->control_created
= true;
367 * validate the control file. This may include creating/initializing it if
370 static int check_control(struct playlist_info
* playlist
)
372 if (!playlist
->control_created
)
374 create_control(playlist
);
376 if (playlist
->control_fd
>= 0)
378 char* dir
= playlist
->filename
;
379 char* file
= playlist
->filename
+playlist
->dirlen
;
380 char c
= playlist
->filename
[playlist
->dirlen
-1];
382 playlist
->filename
[playlist
->dirlen
-1] = '\0';
384 update_control(playlist
, PLAYLIST_COMMAND_PLAYLIST
,
385 PLAYLIST_CONTROL_FILE_VERSION
, -1, dir
, file
, NULL
);
386 sync_control(playlist
, false);
387 playlist
->filename
[playlist
->dirlen
-1] = c
;
391 if (playlist
->control_fd
< 0)
398 * recreate the control file based on current playlist entries
400 static int recreate_control(struct playlist_info
* playlist
)
402 char temp_file
[MAX_PATH
+1];
407 if(playlist
->control_fd
>= 0)
409 char* dir
= playlist
->filename
;
410 char* file
= playlist
->filename
+playlist
->dirlen
;
411 char c
= playlist
->filename
[playlist
->dirlen
-1];
413 close(playlist
->control_fd
);
415 snprintf(temp_file
, sizeof(temp_file
), "%s_temp",
416 playlist
->control_filename
);
418 if (rename(playlist
->control_filename
, temp_file
) < 0)
421 temp_fd
= open(temp_file
, O_RDONLY
);
425 playlist
->control_fd
= open(playlist
->control_filename
,
426 O_CREAT
|O_RDWR
|O_TRUNC
);
427 if (playlist
->control_fd
< 0)
430 playlist
->filename
[playlist
->dirlen
-1] = '\0';
432 /* cannot call update_control() because of mutex */
433 result
= fdprintf(playlist
->control_fd
, "P:%d:%s:%s\n",
434 PLAYLIST_CONTROL_FILE_VERSION
, dir
, file
);
436 playlist
->filename
[playlist
->dirlen
-1] = c
;
446 playlist
->shuffle_modified
= false;
447 playlist
->deleted
= false;
448 playlist
->num_inserted_tracks
= 0;
450 if (playlist
->current
)
452 global_status
.resume_seed
= -1;
456 for (i
=0; i
<playlist
->amount
; i
++)
458 if (playlist
->indices
[i
] & PLAYLIST_INSERT_TYPE_MASK
)
460 bool queue
= playlist
->indices
[i
] & PLAYLIST_QUEUE_MASK
;
461 char inserted_file
[MAX_PATH
+1];
463 lseek(temp_fd
, playlist
->indices
[i
] & PLAYLIST_SEEK_MASK
,
465 read_line(temp_fd
, inserted_file
, sizeof(inserted_file
));
467 result
= fdprintf(playlist
->control_fd
, "%c:%d:%d:",
468 queue
?'Q':'A', i
, playlist
->last_insert_pos
);
471 /* save the position in file where name is written */
472 int seek_pos
= lseek(playlist
->control_fd
, 0, SEEK_CUR
);
474 result
= fdprintf(playlist
->control_fd
, "%s\n",
477 playlist
->indices
[i
] =
478 (playlist
->indices
[i
] & ~PLAYLIST_SEEK_MASK
) | seek_pos
;
484 playlist
->num_inserted_tracks
++;
490 fsync(playlist
->control_fd
);
499 * store directory and name of playlist file
501 static void update_playlist_filename(struct playlist_info
* playlist
,
502 const char *dir
, const char *file
)
505 int dirlen
= strlen(dir
);
507 playlist
->utf8
= is_m3u8(file
);
509 /* If the dir does not end in trailing slash, we use a separator.
510 Otherwise we don't. */
511 if('/' != dir
[dirlen
-1])
517 playlist
->dirlen
= dirlen
;
519 snprintf(playlist
->filename
, sizeof(playlist
->filename
),
520 "%s%s%s", dir
, sep
, file
);
524 * calculate track offsets within a playlist file
526 static int add_indices_to_playlist(struct playlist_info
* playlist
,
527 char* buffer
, size_t buflen
)
531 unsigned int count
= 0;
536 if(-1 == playlist
->fd
)
537 playlist
->fd
= open(playlist
->filename
, O_RDONLY
);
539 return -1; /* failure */
541 gui_syncsplash(0, ID2P(LANG_WAIT
));
545 /* use mp3 buffer for maximum load speed */
547 #if CONFIG_CODEC != SWCODEC
548 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
549 buflen
= (audiobufend
- audiobuf
);
550 buffer
= (char *)audiobuf
;
552 buffer
= (char *)audio_get_buffer(false, &buflen
);
560 nread
= read(playlist
->fd
, buffer
, buflen
);
561 /* Terminate on EOF */
565 p
= (unsigned char *)buffer
;
567 /* utf8 BOM at beginning of file? */
568 if(i
== 0 && is_utf8_bom(p
, nread
)) {
572 playlist
->utf8
= true; /* Override any earlier indication. */
575 for(count
=0; count
< nread
; count
++,p
++) {
577 /* Are we on a new line? */
578 if((*p
== '\n') || (*p
== '\r'))
588 if ( playlist
->amount
>= playlist
->max_playlist_size
) {
589 display_buffer_full();
594 /* Store a new entry */
595 playlist
->indices
[ playlist
->amount
] = i
+count
;
597 if (playlist
->filenames
)
598 playlist
->filenames
[ playlist
->amount
] = NULL
;
610 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
617 * Utility function to create a new playlist, fill it with the next or
618 * previous directory, shuffle it if needed, and start playback.
619 * If play_last is true and direction zero or negative, start playing
620 * the last file in the directory, otherwise start playing the first.
622 static int create_and_play_dir(int direction
, bool play_last
)
624 char dir
[MAX_PATH
+ 1];
629 res
= get_next_directory(dir
);
631 res
= get_previous_directory(dir
);
635 if (playlist_create(dir
, NULL
) != -1)
637 ft_build_playlist(tree_get_context(), 0);
639 if (global_settings
.playlist_shuffle
)
640 playlist_shuffle(current_tick
, -1);
642 if (play_last
&& direction
<= 0)
643 index
= current_playlist
.amount
- 1;
647 #if (CONFIG_CODEC != SWCODEC)
648 playlist_start(index
, 0);
652 /* we've overwritten the dircache when getting the next/previous dir,
653 so the tree browser context will need to be reloaded */
661 * Removes all tracks, from the playlist, leaving the presently playing
664 int remove_all_tracks(struct playlist_info
*playlist
)
668 if (playlist
== NULL
)
669 playlist
= ¤t_playlist
;
671 while (playlist
->index
> 0)
672 if ((result
= remove_track_from_playlist(playlist
, 0, true)) < 0)
675 while (playlist
->amount
> 1)
676 if ((result
= remove_track_from_playlist(playlist
, 1, true)) < 0)
679 if (playlist
->amount
== 1) {
680 playlist
->indices
[0] |= PLAYLIST_QUEUED
;
688 * Add track to playlist at specified position. There are five special
689 * positions that can be specified:
690 * PLAYLIST_PREPEND - Add track at beginning of playlist
691 * PLAYLIST_INSERT - Add track after current song. NOTE: If
692 * there are already inserted tracks then track
693 * is added to the end of the insertion list
694 * PLAYLIST_INSERT_FIRST - Add track immediately after current song, no
695 * matter what other tracks have been inserted
696 * PLAYLIST_INSERT_LAST - Add track to end of playlist
697 * PLAYLIST_INSERT_SHUFFLED - Add track at some random point between the
698 * current playing track and end of playlist
699 * PLAYLIST_REPLACE - Erase current playlist, Cue the current track
700 * and inster this track at the end.
702 static int add_track_to_playlist(struct playlist_info
* playlist
,
703 const char *filename
, int position
,
704 bool queue
, int seek_pos
)
706 int insert_position
, orig_position
;
707 unsigned long flags
= PLAYLIST_INSERT_TYPE_INSERT
;
710 insert_position
= orig_position
= position
;
712 if (playlist
->amount
>= playlist
->max_playlist_size
)
714 display_buffer_full();
720 case PLAYLIST_PREPEND
:
721 position
= insert_position
= playlist
->first_index
;
723 case PLAYLIST_INSERT
:
724 /* if there are already inserted tracks then add track to end of
725 insertion list else add after current playing track */
726 if (playlist
->last_insert_pos
>= 0 &&
727 playlist
->last_insert_pos
< playlist
->amount
&&
728 (playlist
->indices
[playlist
->last_insert_pos
]&
729 PLAYLIST_INSERT_TYPE_MASK
) == PLAYLIST_INSERT_TYPE_INSERT
)
730 position
= insert_position
= playlist
->last_insert_pos
+1;
731 else if (playlist
->amount
> 0)
732 position
= insert_position
= playlist
->index
+ 1;
734 position
= insert_position
= 0;
736 if (playlist
->started
)
737 playlist
->last_insert_pos
= position
;
739 case PLAYLIST_INSERT_FIRST
:
740 if (playlist
->amount
> 0)
741 position
= insert_position
= playlist
->index
+ 1;
743 position
= insert_position
= 0;
745 if (playlist
->last_insert_pos
< 0 && playlist
->started
)
746 playlist
->last_insert_pos
= position
;
748 case PLAYLIST_INSERT_LAST
:
749 if (playlist
->first_index
> 0)
750 position
= insert_position
= playlist
->first_index
;
752 position
= insert_position
= playlist
->amount
;
754 case PLAYLIST_INSERT_SHUFFLED
:
756 if (playlist
->started
)
759 int n
= playlist
->amount
-
760 rotate_index(playlist
, playlist
->index
);
767 position
= playlist
->index
+ offset
+ 1;
768 if (position
>= playlist
->amount
)
769 position
-= playlist
->amount
;
771 insert_position
= position
;
774 position
= insert_position
= (rand() % (playlist
->amount
+1));
777 case PLAYLIST_REPLACE
:
778 if (remove_all_tracks(playlist
) < 0)
781 position
= insert_position
= playlist
->index
+ 1;
786 flags
|= PLAYLIST_QUEUED
;
788 /* shift indices so that track can be added */
789 for (i
=playlist
->amount
; i
>insert_position
; i
--)
791 playlist
->indices
[i
] = playlist
->indices
[i
-1];
793 if (playlist
->filenames
)
794 playlist
->filenames
[i
] = playlist
->filenames
[i
-1];
798 /* update stored indices if needed */
799 if (playlist
->amount
> 0 && insert_position
<= playlist
->index
&&
803 if (playlist
->amount
> 0 && insert_position
<= playlist
->first_index
&&
804 orig_position
!= PLAYLIST_PREPEND
&& playlist
->started
)
806 playlist
->first_index
++;
808 if (seek_pos
< 0 && playlist
->current
)
810 global_status
.resume_first_index
= playlist
->first_index
;
815 if (insert_position
< playlist
->last_insert_pos
||
816 (insert_position
== playlist
->last_insert_pos
&& position
< 0))
817 playlist
->last_insert_pos
++;
819 if (seek_pos
< 0 && playlist
->control_fd
>= 0)
821 int result
= update_control(playlist
,
822 (queue
?PLAYLIST_COMMAND_QUEUE
:PLAYLIST_COMMAND_ADD
), position
,
823 playlist
->last_insert_pos
, filename
, NULL
, &seek_pos
);
829 playlist
->indices
[insert_position
] = flags
| seek_pos
;
832 if (playlist
->filenames
)
833 playlist
->filenames
[insert_position
] = NULL
;
837 playlist
->num_inserted_tracks
++;
839 return insert_position
;
843 * Callback for playlist_directory_tracksearch to insert track into
846 static int directory_search_callback(char* filename
, void* context
)
848 struct directory_search_context
* c
=
849 (struct directory_search_context
*) context
;
852 insert_pos
= add_track_to_playlist(c
->playlist
, filename
, c
->position
,
860 /* Make sure tracks are inserted in correct order if user requests
862 if (c
->position
== PLAYLIST_INSERT_FIRST
|| c
->position
>= 0)
863 c
->position
= insert_pos
+ 1;
865 if (((c
->count
)%PLAYLIST_DISPLAY_COUNT
) == 0)
867 unsigned char* count_str
;
870 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
872 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
874 display_playlist_count(c
->count
, count_str
, false);
876 if ((c
->count
) == PLAYLIST_DISPLAY_COUNT
&&
877 (audio_status() & AUDIO_STATUS_PLAY
) &&
878 c
->playlist
->started
)
879 audio_flush_and_reload_tracks();
886 * remove track at specified position
888 static int remove_track_from_playlist(struct playlist_info
* playlist
,
889 int position
, bool write
)
894 if (playlist
->amount
<= 0)
897 inserted
= playlist
->indices
[position
] & PLAYLIST_INSERT_TYPE_MASK
;
899 /* shift indices now that track has been removed */
900 for (i
=position
; i
<playlist
->amount
; i
++)
902 playlist
->indices
[i
] = playlist
->indices
[i
+1];
904 if (playlist
->filenames
)
905 playlist
->filenames
[i
] = playlist
->filenames
[i
+1];
912 playlist
->num_inserted_tracks
--;
914 playlist
->deleted
= true;
916 /* update stored indices if needed */
917 if (position
< playlist
->index
)
920 if (position
< playlist
->first_index
)
922 playlist
->first_index
--;
926 global_status
.resume_first_index
= playlist
->first_index
;
931 if (position
<= playlist
->last_insert_pos
)
932 playlist
->last_insert_pos
--;
934 if (write
&& playlist
->control_fd
>= 0)
936 int result
= update_control(playlist
, PLAYLIST_COMMAND_DELETE
,
937 position
, -1, NULL
, NULL
, NULL
);
942 sync_control(playlist
, false);
949 * randomly rearrange the array of indices for the playlist. If start_current
950 * is true then update the index to the new index of the current playing track
952 static int randomise_playlist(struct playlist_info
* playlist
,
953 unsigned int seed
, bool start_current
,
959 unsigned int current
= playlist
->indices
[playlist
->index
];
961 /* seed 0 is used to identify sorted playlist for resume purposes */
965 /* seed with the given seed */
968 /* randomise entire indices list */
969 for(count
= playlist
->amount
- 1; count
>= 0; count
--)
971 /* the rand is from 0 to RAND_MAX, so adjust to our value range */
972 candidate
= rand() % (count
+ 1);
974 /* now swap the values at the 'count' and 'candidate' positions */
975 store
= playlist
->indices
[candidate
];
976 playlist
->indices
[candidate
] = playlist
->indices
[count
];
977 playlist
->indices
[count
] = store
;
979 if (playlist
->filenames
)
981 store
= (long)playlist
->filenames
[candidate
];
982 playlist
->filenames
[candidate
] = playlist
->filenames
[count
];
983 playlist
->filenames
[count
] = (struct dircache_entry
*)store
;
989 find_and_set_playlist_index(playlist
, current
);
991 /* indices have been moved so last insert position is no longer valid */
992 playlist
->last_insert_pos
= -1;
994 playlist
->seed
= seed
;
995 if (playlist
->num_inserted_tracks
> 0 || playlist
->deleted
)
996 playlist
->shuffle_modified
= true;
1000 update_control(playlist
, PLAYLIST_COMMAND_SHUFFLE
, seed
,
1001 playlist
->first_index
, NULL
, NULL
, NULL
);
1002 global_status
.resume_seed
= seed
;
1010 * Sort the array of indices for the playlist. If start_current is true then
1011 * set the index to the new index of the current song.
1013 static int sort_playlist(struct playlist_info
* playlist
, bool start_current
,
1016 unsigned int current
= playlist
->indices
[playlist
->index
];
1018 if (playlist
->amount
> 0)
1019 qsort(playlist
->indices
, playlist
->amount
,
1020 sizeof(playlist
->indices
[0]), compare
);
1022 #ifdef HAVE_DIRCACHE
1023 /** We need to re-check the song names from disk because qsort can't
1024 * sort two arrays at once :/
1025 * FIXME: Please implement a better way to do this. */
1026 memset(playlist
->filenames
, 0, playlist
->max_playlist_size
* sizeof(int));
1027 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
1031 find_and_set_playlist_index(playlist
, current
);
1033 /* indices have been moved so last insert position is no longer valid */
1034 playlist
->last_insert_pos
= -1;
1036 if (!playlist
->num_inserted_tracks
&& !playlist
->deleted
)
1037 playlist
->shuffle_modified
= false;
1038 if (write
&& playlist
->control_fd
>= 0)
1040 update_control(playlist
, PLAYLIST_COMMAND_UNSHUFFLE
,
1041 playlist
->first_index
, -1, NULL
, NULL
, NULL
);
1042 global_status
.resume_seed
= 0;
1049 /* Calculate how many steps we have to really step when skipping entries
1052 static int calculate_step_count(const struct playlist_info
*playlist
, int steps
)
1054 int i
, count
, direction
;
1056 int stepped_count
= 0;
1069 index
= playlist
->index
;
1072 /* Boundary check */
1074 index
+= playlist
->amount
;
1075 if (index
>= playlist
->amount
)
1076 index
-= playlist
->amount
;
1078 /* Check if we found a bad entry. */
1079 if (playlist
->indices
[index
] & PLAYLIST_SKIPPED
)
1082 /* Are all entries bad? */
1083 if (stepped_count
++ > playlist
->amount
)
1090 } while (i
<= count
);
1095 /* Marks the index of the track to be skipped that is "steps" away from
1096 * current playing track.
1098 void playlist_skip_entry(struct playlist_info
*playlist
, int steps
)
1102 if (playlist
== NULL
)
1103 playlist
= ¤t_playlist
;
1105 /* need to account for already skipped tracks */
1106 steps
= calculate_step_count(playlist
, steps
);
1108 index
= playlist
->index
+ steps
;
1110 index
+= playlist
->amount
;
1111 else if (index
>= playlist
->amount
)
1112 index
-= playlist
->amount
;
1114 playlist
->indices
[index
] |= PLAYLIST_SKIPPED
;
1118 * returns the index of the track that is "steps" away from current playing
1121 static int get_next_index(const struct playlist_info
* playlist
, int steps
,
1124 int current_index
= playlist
->index
;
1125 int next_index
= -1;
1127 if (playlist
->amount
<= 0)
1130 if (repeat_mode
== -1)
1131 repeat_mode
= global_settings
.repeat_mode
;
1133 if (repeat_mode
== REPEAT_SHUFFLE
&& playlist
->amount
<= 1)
1134 repeat_mode
= REPEAT_ALL
;
1136 steps
= calculate_step_count(playlist
, steps
);
1137 switch (repeat_mode
)
1139 case REPEAT_SHUFFLE
:
1140 /* Treat repeat shuffle just like repeat off. At end of playlist,
1141 play will be resumed in playlist_next() */
1144 current_index
= rotate_index(playlist
, current_index
);
1145 next_index
= current_index
+steps
;
1146 if ((next_index
< 0) || (next_index
>= playlist
->amount
))
1149 next_index
= (next_index
+playlist
->first_index
) %
1156 #ifdef AB_REPEAT_ENABLE
1159 next_index
= current_index
;
1165 next_index
= (current_index
+steps
) % playlist
->amount
;
1166 while (next_index
< 0)
1167 next_index
+= playlist
->amount
;
1169 if (steps
>= playlist
->amount
)
1176 /* second time around so skip the queued files */
1177 for (i
=0; i
<playlist
->amount
; i
++)
1179 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
1180 index
= (index
+1) % playlist
->amount
;
1192 /* No luck if the whole playlist was bad. */
1193 if (playlist
->indices
[next_index
] & PLAYLIST_SKIPPED
)
1200 * Search for the seek track and set appropriate indices. Used after shuffle
1201 * to make sure the current index is still pointing to correct track.
1203 static void find_and_set_playlist_index(struct playlist_info
* playlist
,
1208 /* Set the index to the current song */
1209 for (i
=0; i
<playlist
->amount
; i
++)
1211 if (playlist
->indices
[i
] == seek
)
1213 playlist
->index
= playlist
->first_index
= i
;
1215 if (playlist
->current
)
1217 global_status
.resume_first_index
= i
;
1227 * used to sort track indices. Sort order is as follows:
1228 * 1. Prepended tracks (in prepend order)
1229 * 2. Playlist/directory tracks (in playlist order)
1230 * 3. Inserted/Appended tracks (in insert order)
1232 static int compare(const void* p1
, const void* p2
)
1234 unsigned long* e1
= (unsigned long*) p1
;
1235 unsigned long* e2
= (unsigned long*) p2
;
1236 unsigned long flags1
= *e1
& PLAYLIST_INSERT_TYPE_MASK
;
1237 unsigned long flags2
= *e2
& PLAYLIST_INSERT_TYPE_MASK
;
1239 if (flags1
== flags2
)
1240 return (*e1
& PLAYLIST_SEEK_MASK
) - (*e2
& PLAYLIST_SEEK_MASK
);
1241 else if (flags1
== PLAYLIST_INSERT_TYPE_PREPEND
||
1242 flags2
== PLAYLIST_INSERT_TYPE_APPEND
)
1244 else if (flags1
== PLAYLIST_INSERT_TYPE_APPEND
||
1245 flags2
== PLAYLIST_INSERT_TYPE_PREPEND
)
1247 else if (flags1
&& flags2
)
1248 return (*e1
& PLAYLIST_SEEK_MASK
) - (*e2
& PLAYLIST_SEEK_MASK
);
1253 #ifdef HAVE_DIRCACHE
1255 * Thread to update filename pointers to dircache on background
1256 * without affecting playlist load up performance. This thread also flushes
1257 * any pending control commands when the disk spins up.
1259 static void playlist_thread(void)
1261 struct queue_event ev
;
1262 bool dirty_pointers
= false;
1263 static char tmp
[MAX_PATH
+1];
1265 struct playlist_info
*playlist
;
1272 #ifndef HAVE_FLASH_STORAGE
1273 if (global_settings
.disk_spindown
> 1 &&
1274 global_settings
.disk_spindown
<= 5)
1275 sleep_time
= global_settings
.disk_spindown
- 1;
1280 queue_wait_w_tmo(&playlist_queue
, &ev
, HZ
*sleep_time
);
1284 case PLAYLIST_LOAD_POINTERS
:
1285 dirty_pointers
= true;
1288 /* Start the background scanning after either the disk spindown
1289 timeout or 5s, whichever is less */
1291 playlist
= ¤t_playlist
;
1293 if (playlist
->control_fd
>= 0
1295 && ata_disk_is_active()
1299 if (playlist
->num_cached
> 0)
1301 mutex_lock(&playlist
->control_mutex
);
1302 flush_cached_control(playlist
);
1303 mutex_unlock(&playlist
->control_mutex
);
1306 sync_control(playlist
, true);
1309 if (!dirty_pointers
)
1312 if (!dircache_is_enabled() || !playlist
->filenames
1313 || playlist
->amount
<= 0)
1316 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1319 for (index
= 0; index
< playlist
->amount
1320 && queue_empty(&playlist_queue
); index
++)
1322 /* Process only pointers that are not already loaded. */
1323 if (playlist
->filenames
[index
])
1326 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
1327 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
1329 /* Load the filename from playlist file. */
1330 if (get_filename(playlist
, index
, seek
, control_file
, tmp
,
1334 /* Set the dircache entry pointer. */
1335 playlist
->filenames
[index
] = dircache_get_entry_ptr(tmp
);
1337 /* And be on background so user doesn't notice any delays. */
1341 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1344 dirty_pointers
= false;
1348 case SYS_USB_CONNECTED
:
1349 usb_acknowledge(SYS_USB_CONNECTED_ACK
);
1350 usb_wait_for_disconnect(&playlist_queue
);
1359 * gets pathname for track at seek index
1361 static int get_filename(struct playlist_info
* playlist
, int index
, int seek
,
1362 bool control_file
, char *buf
, int buf_length
)
1366 char tmp_buf
[MAX_PATH
+1];
1367 char dir_buf
[MAX_PATH
+1];
1368 bool utf8
= playlist
->utf8
;
1370 if (buf_length
> MAX_PATH
+1)
1371 buf_length
= MAX_PATH
+1;
1373 #ifdef HAVE_DIRCACHE
1374 if (dircache_is_enabled() && playlist
->filenames
)
1376 if (playlist
->filenames
[index
] != NULL
)
1378 dircache_copy_path(playlist
->filenames
[index
], tmp_buf
, sizeof(tmp_buf
)-1);
1379 max
= strlen(tmp_buf
) + 1;
1386 if (playlist
->in_ram
&& !control_file
&& max
< 0)
1388 strncpy(tmp_buf
, &playlist
->buffer
[seek
], sizeof(tmp_buf
));
1389 tmp_buf
[MAX_PATH
] = '\0';
1390 max
= strlen(tmp_buf
) + 1;
1394 mutex_lock(&playlist
->control_mutex
);
1398 fd
= playlist
->control_fd
;
1403 if(-1 == playlist
->fd
)
1404 playlist
->fd
= open(playlist
->filename
, O_RDONLY
);
1412 if (lseek(fd
, seek
, SEEK_SET
) != seek
)
1416 max
= read(fd
, tmp_buf
, MIN((size_t) buf_length
, sizeof(tmp_buf
)));
1418 if ((max
> 0) && !utf8
)
1420 /* Use dir_buf as a temporary buffer. Note that dir_buf must
1421 * be as large as tmp_buf.
1423 max
= convert_m3u(tmp_buf
, max
, sizeof(tmp_buf
), dir_buf
);
1428 mutex_unlock(&playlist
->control_mutex
);
1433 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
1435 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
1441 strncpy(dir_buf
, playlist
->filename
, playlist
->dirlen
-1);
1442 dir_buf
[playlist
->dirlen
-1] = 0;
1444 return (format_track_path(buf
, tmp_buf
, buf_length
, max
, dir_buf
));
1447 static int get_next_directory(char *dir
){
1448 return get_next_dir(dir
,true,false);
1451 static int get_previous_directory(char *dir
){
1452 return get_next_dir(dir
,false,false);
1456 * search through all the directories (starting with the current) to find
1457 * one that has tracks to play
1459 static int get_next_dir(char *dir
, bool is_forward
, bool recursion
)
1461 struct playlist_info
* playlist
= ¤t_playlist
;
1463 int sort_dir
= global_settings
.sort_dir
;
1464 char *start_dir
= NULL
;
1466 struct tree_context
* tc
= tree_get_context();
1467 int dirfilter
= *(tc
->dirfilter
);
1469 if (global_settings
.next_folder
== FOLDER_ADVANCE_RANDOM
)
1471 int fd
= open(ROCKBOX_DIR
"/folder_advance_list.dat",O_RDONLY
);
1472 char buffer
[MAX_PATH
];
1473 int folder_count
= 0,i
;
1474 srand(current_tick
);
1475 *(tc
->dirfilter
) = SHOW_MUSIC
;
1478 read(fd
,&folder_count
,sizeof(int));
1481 i
= rand()%folder_count
;
1482 lseek(fd
,sizeof(int) + (MAX_PATH
*i
),SEEK_SET
);
1483 read(fd
,buffer
,MAX_PATH
);
1484 if (check_subdir_for_music(buffer
,"") ==0)
1489 *(tc
->dirfilter
) = dirfilter
;
1494 /* not random folder advance */
1496 /* start with root */
1500 /* start with current directory */
1501 strncpy(dir
, playlist
->filename
, playlist
->dirlen
-1);
1502 dir
[playlist
->dirlen
-1] = '\0';
1505 /* use the tree browser dircache to load files */
1506 *(tc
->dirfilter
) = SHOW_ALL
;
1508 /* sort in another direction if previous dir is requested */
1510 if ((global_settings
.sort_dir
== 0) || (global_settings
.sort_dir
== 3))
1511 global_settings
.sort_dir
= 4;
1512 else if (global_settings
.sort_dir
== 1)
1513 global_settings
.sort_dir
= 2;
1514 else if (global_settings
.sort_dir
== 2)
1515 global_settings
.sort_dir
= 1;
1516 else if (global_settings
.sort_dir
== 4)
1517 global_settings
.sort_dir
= 0;
1522 struct entry
*files
;
1526 if (ft_load(tc
, (dir
[0]=='\0')?"/":dir
) < 0)
1528 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
1534 files
= (struct entry
*) tc
->dircache
;
1535 num_files
= tc
->filesindir
;
1537 for (i
=0; i
<num_files
; i
++)
1540 if (action_userabort(TIMEOUT_NOBLOCK
))
1547 if (files
[i
].attr
& ATTR_DIRECTORY
)
1551 result
= check_subdir_for_music(dir
, files
[i
].name
);
1558 else if (!strcmp(start_dir
, files
[i
].name
))
1565 /* move down to parent directory. current directory name is
1566 stored as the starting point for the search in parent */
1567 start_dir
= strrchr(dir
, '/');
1578 /* restore dirfilter & sort_dir */
1579 *(tc
->dirfilter
) = dirfilter
;
1580 global_settings
.sort_dir
= sort_dir
;
1582 /* special case if nothing found: try start searching again from root */
1583 if (result
== -1 && !recursion
){
1584 result
= get_next_dir(dir
,is_forward
, true);
1591 * Checks if there are any music files in the dir or any of its
1592 * subdirectories. May be called recursively.
1594 static int check_subdir_for_music(char *dir
, char *subdir
)
1597 int dirlen
= strlen(dir
);
1600 struct entry
*files
;
1601 bool has_music
= false;
1602 bool has_subdir
= false;
1603 struct tree_context
* tc
= tree_get_context();
1605 snprintf(dir
+dirlen
, MAX_PATH
-dirlen
, "/%s", subdir
);
1607 if (ft_load(tc
, dir
) < 0)
1609 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
1613 files
= (struct entry
*) tc
->dircache
;
1614 num_files
= tc
->filesindir
;
1616 for (i
=0; i
<num_files
; i
++)
1618 if (files
[i
].attr
& ATTR_DIRECTORY
)
1620 else if ((files
[i
].attr
& FILE_ATTR_MASK
) == FILE_ATTR_AUDIO
)
1632 for (i
=0; i
<num_files
; i
++)
1634 if (action_userabort(TIMEOUT_NOBLOCK
))
1640 if (files
[i
].attr
& ATTR_DIRECTORY
)
1642 result
= check_subdir_for_music(dir
, files
[i
].name
);
1660 /* we now need to reload our current directory */
1661 if(ft_load(tc
, dir
) < 0)
1662 gui_syncsplash(HZ
*2,
1663 ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
1670 * Returns absolute path of track
1672 static int format_track_path(char *dest
, char *src
, int buf_length
, int max
,
1679 /* Zero-terminate the file name */
1680 while((src
[i
] != '\n') &&
1685 /* Now work back killing white space */
1686 while((src
[i
-1] == ' ') ||
1692 /* replace backslashes with forward slashes */
1693 for ( j
=0; j
<i
; j
++ )
1694 if ( src
[j
] == '\\' )
1699 strncpy(dest
, src
, buf_length
);
1703 /* handle dos style drive letter */
1705 strncpy(dest
, &src
[2], buf_length
);
1706 else if (!strncmp(src
, "../", 3))
1708 /* handle relative paths */
1710 while(!strncmp(&src
[i
], "../", 3))
1712 for (j
=0; j
<i
/3; j
++) {
1713 temp_ptr
= strrchr(dir
, '/');
1719 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[i
]);
1721 else if ( '.' == src
[0] && '/' == src
[1] ) {
1722 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[2]);
1725 snprintf(dest
, buf_length
, "%s/%s", dir
, src
);
1733 * Display splash message showing progress of playlist/directory insertion or
1736 static void display_playlist_count(int count
, const unsigned char *fmt
,
1739 static long talked_tick
= 0;
1740 long id
= P2ID(fmt
);
1741 if(global_settings
.talk_menu
&& id
>=0)
1743 if(final
|| (count
&& (talked_tick
== 0
1744 || TIME_AFTER(current_tick
, talked_tick
+5*HZ
))))
1746 talked_tick
= current_tick
;
1747 talk_number(count
, false);
1753 lcd_clear_display();
1755 #ifdef HAVE_LCD_BITMAP
1756 if(global_settings
.statusbar
)
1757 lcd_setmargins(0, STATUSBAR_HEIGHT
);
1759 lcd_setmargins(0, 0);
1762 gui_syncsplash(0, fmt
, count
, str(LANG_OFF_ABORT
));
1766 * Display buffer full message
1768 static void display_buffer_full(void)
1770 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_BUFFER_FULL
));
1774 * Flush any cached control commands to disk. Called when playlist is being
1775 * modified. Returns 0 on success and -1 on failure.
1777 static int flush_cached_control(struct playlist_info
* playlist
)
1782 if (!playlist
->num_cached
)
1785 lseek(playlist
->control_fd
, 0, SEEK_END
);
1787 for (i
=0; i
<playlist
->num_cached
; i
++)
1789 struct playlist_control_cache
* cache
=
1790 &(playlist
->control_cache
[i
]);
1792 switch (cache
->command
)
1794 case PLAYLIST_COMMAND_PLAYLIST
:
1795 result
= fdprintf(playlist
->control_fd
, "P:%d:%s:%s\n",
1796 cache
->i1
, cache
->s1
, cache
->s2
);
1798 case PLAYLIST_COMMAND_ADD
:
1799 case PLAYLIST_COMMAND_QUEUE
:
1800 result
= fdprintf(playlist
->control_fd
, "%c:%d:%d:",
1801 (cache
->command
== PLAYLIST_COMMAND_ADD
)?'A':'Q',
1802 cache
->i1
, cache
->i2
);
1805 /* save the position in file where name is written */
1806 int* seek_pos
= (int *)cache
->data
;
1807 *seek_pos
= lseek(playlist
->control_fd
, 0, SEEK_CUR
);
1808 result
= fdprintf(playlist
->control_fd
, "%s\n",
1812 case PLAYLIST_COMMAND_DELETE
:
1813 result
= fdprintf(playlist
->control_fd
, "D:%d\n", cache
->i1
);
1815 case PLAYLIST_COMMAND_SHUFFLE
:
1816 result
= fdprintf(playlist
->control_fd
, "S:%d:%d\n",
1817 cache
->i1
, cache
->i2
);
1819 case PLAYLIST_COMMAND_UNSHUFFLE
:
1820 result
= fdprintf(playlist
->control_fd
, "U:%d\n", cache
->i1
);
1822 case PLAYLIST_COMMAND_RESET
:
1823 result
= fdprintf(playlist
->control_fd
, "R\n");
1835 if (global_status
.resume_seed
>= 0)
1837 global_status
.resume_seed
= -1;
1841 playlist
->num_cached
= 0;
1842 playlist
->pending_control_sync
= true;
1849 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_UPDATE_ERROR
));
1856 * Update control data with new command. Depending on the command, it may be
1857 * cached or flushed to disk.
1859 static int update_control(struct playlist_info
* playlist
,
1860 enum playlist_command command
, int i1
, int i2
,
1861 const char* s1
, const char* s2
, void* data
)
1864 struct playlist_control_cache
* cache
;
1867 mutex_lock(&playlist
->control_mutex
);
1869 cache
= &(playlist
->control_cache
[playlist
->num_cached
++]);
1871 cache
->command
= command
;
1880 case PLAYLIST_COMMAND_PLAYLIST
:
1881 case PLAYLIST_COMMAND_ADD
:
1882 case PLAYLIST_COMMAND_QUEUE
:
1883 #ifndef HAVE_DIRCACHE
1884 case PLAYLIST_COMMAND_DELETE
:
1885 case PLAYLIST_COMMAND_RESET
:
1889 case PLAYLIST_COMMAND_SHUFFLE
:
1890 case PLAYLIST_COMMAND_UNSHUFFLE
:
1892 /* only flush when needed */
1896 if (flush
|| playlist
->num_cached
== PLAYLIST_MAX_CACHE
)
1897 result
= flush_cached_control(playlist
);
1899 mutex_unlock(&playlist
->control_mutex
);
1905 * sync control file to disk
1907 static void sync_control(struct playlist_info
* playlist
, bool force
)
1909 #ifdef HAVE_DIRCACHE
1910 if (playlist
->started
&& force
)
1914 if (playlist
->started
)
1917 if (playlist
->pending_control_sync
)
1919 mutex_lock(&playlist
->control_mutex
);
1920 fsync(playlist
->control_fd
);
1921 playlist
->pending_control_sync
= false;
1922 mutex_unlock(&playlist
->control_mutex
);
1928 * Rotate indices such that first_index is index 0
1930 static int rotate_index(const struct playlist_info
* playlist
, int index
)
1932 index
-= playlist
->first_index
;
1934 index
+= playlist
->amount
;
1940 * Initialize playlist entries at startup
1942 void playlist_init(void)
1944 struct playlist_info
* playlist
= ¤t_playlist
;
1946 playlist
->current
= true;
1947 snprintf(playlist
->control_filename
, sizeof(playlist
->control_filename
),
1948 "%s", PLAYLIST_CONTROL_FILE
);
1950 playlist
->control_fd
= -1;
1951 playlist
->max_playlist_size
= global_settings
.max_files_in_playlist
;
1952 playlist
->indices
= buffer_alloc(
1953 playlist
->max_playlist_size
* sizeof(int));
1954 playlist
->buffer_size
=
1955 AVERAGE_FILENAME_LENGTH
* global_settings
.max_files_in_dir
;
1956 playlist
->buffer
= buffer_alloc(playlist
->buffer_size
);
1957 mutex_init(&playlist
->control_mutex
);
1958 empty_playlist(playlist
, true);
1960 #ifdef HAVE_DIRCACHE
1961 playlist
->filenames
= buffer_alloc(
1962 playlist
->max_playlist_size
* sizeof(int));
1963 memset(playlist
->filenames
, 0,
1964 playlist
->max_playlist_size
* sizeof(int));
1965 create_thread(playlist_thread
, playlist_stack
, sizeof(playlist_stack
),
1966 0, playlist_thread_name
IF_PRIO(, PRIORITY_BACKGROUND
)
1968 queue_init(&playlist_queue
, true);
1973 * Clean playlist at shutdown
1975 void playlist_shutdown(void)
1977 struct playlist_info
* playlist
= ¤t_playlist
;
1979 if (playlist
->control_fd
>= 0)
1981 mutex_lock(&playlist
->control_mutex
);
1983 if (playlist
->num_cached
> 0)
1984 flush_cached_control(playlist
);
1986 close(playlist
->control_fd
);
1988 mutex_unlock(&playlist
->control_mutex
);
1993 * Create new playlist
1995 int playlist_create(const char *dir
, const char *file
)
1997 struct playlist_info
* playlist
= ¤t_playlist
;
1999 new_playlist(playlist
, dir
, file
);
2002 /* load the playlist file */
2003 add_indices_to_playlist(playlist
, NULL
, 0);
2008 #define PLAYLIST_COMMAND_SIZE (MAX_PATH+12)
2011 * Restore the playlist state based on control file commands. Called to
2012 * resume playback after shutdown.
2014 int playlist_resume(void)
2016 struct playlist_info
* playlist
= ¤t_playlist
;
2021 int control_file_size
= 0;
2025 /* use mp3 buffer for maximum load speed */
2026 #if CONFIG_CODEC != SWCODEC
2027 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
2028 buflen
= (audiobufend
- audiobuf
);
2029 buffer
= (char *)audiobuf
;
2031 buffer
= (char *)audio_get_buffer(false, &buflen
);
2034 empty_playlist(playlist
, true);
2036 gui_syncsplash(0, ID2P(LANG_WAIT
));
2037 playlist
->control_fd
= open(playlist
->control_filename
, O_RDWR
);
2038 if (playlist
->control_fd
< 0)
2040 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2043 playlist
->control_created
= true;
2045 control_file_size
= filesize(playlist
->control_fd
);
2046 if (control_file_size
<= 0)
2048 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2052 /* read a small amount first to get the header */
2053 nread
= read(playlist
->control_fd
, buffer
,
2054 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
2057 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2061 playlist
->started
= true;
2067 enum playlist_command current_command
= PLAYLIST_COMMAND_COMMENT
;
2068 int last_newline
= 0;
2070 bool newline
= true;
2071 bool exit_loop
= false;
2076 unsigned long last_tick
= current_tick
;
2078 for(count
=0; count
<nread
&& !exit_loop
; count
++,p
++)
2080 /* So a splash while we are loading. */
2081 if (current_tick
- last_tick
> HZ
/4)
2083 gui_syncsplash(0, str(LANG_LOADING_PERCENT
),
2084 (total_read
+count
)*100/control_file_size
,
2085 str(LANG_OFF_ABORT
));
2086 if (action_userabort(TIMEOUT_NOBLOCK
))
2089 * Not sure how to implement this, somebody more familiar
2090 * with the code, please fix this. */
2092 last_tick
= current_tick
;
2095 /* Are we on a new line? */
2096 if((*p
== '\n') || (*p
== '\r'))
2100 /* save last_newline in case we need to load more data */
2101 last_newline
= count
;
2103 switch (current_command
)
2105 case PLAYLIST_COMMAND_PLAYLIST
:
2107 /* str1=version str2=dir str3=file */
2123 version
= atoi(str1
);
2125 if (version
!= PLAYLIST_CONTROL_FILE_VERSION
)
2128 update_playlist_filename(playlist
, str2
, str3
);
2130 if (str3
[0] != '\0')
2132 /* NOTE: add_indices_to_playlist() overwrites the
2133 audiobuf so we need to reload control file
2135 add_indices_to_playlist(playlist
, NULL
, 0);
2137 else if (str2
[0] != '\0')
2139 playlist
->in_ram
= true;
2140 resume_directory(str2
);
2143 /* load the rest of the data */
2149 case PLAYLIST_COMMAND_ADD
:
2150 case PLAYLIST_COMMAND_QUEUE
:
2152 /* str1=position str2=last_position str3=file */
2153 int position
, last_position
;
2156 if (!str1
|| !str2
|| !str3
)
2163 position
= atoi(str1
);
2164 last_position
= atoi(str2
);
2166 queue
= (current_command
== PLAYLIST_COMMAND_ADD
)?
2169 /* seek position is based on str3's position in
2171 if (add_track_to_playlist(playlist
, str3
, position
,
2172 queue
, total_read
+(str3
-buffer
)) < 0)
2175 playlist
->last_insert_pos
= last_position
;
2179 case PLAYLIST_COMMAND_DELETE
:
2191 position
= atoi(str1
);
2193 if (remove_track_from_playlist(playlist
, position
,
2199 case PLAYLIST_COMMAND_SHUFFLE
:
2201 /* str1=seed str2=first_index */
2213 /* Always sort list before shuffling */
2214 sort_playlist(playlist
, false, false);
2218 playlist
->first_index
= atoi(str2
);
2220 if (randomise_playlist(playlist
, seed
, false,
2227 case PLAYLIST_COMMAND_UNSHUFFLE
:
2229 /* str1=first_index */
2237 playlist
->first_index
= atoi(str1
);
2239 if (sort_playlist(playlist
, false, false) < 0)
2245 case PLAYLIST_COMMAND_RESET
:
2247 playlist
->last_insert_pos
= -1;
2250 case PLAYLIST_COMMAND_COMMENT
:
2257 /* to ignore any extra newlines */
2258 current_command
= PLAYLIST_COMMAND_COMMENT
;
2264 /* first non-comment line must always specify playlist */
2265 if (first
&& *p
!= 'P' && *p
!= '#')
2275 /* playlist can only be specified once */
2283 current_command
= PLAYLIST_COMMAND_PLAYLIST
;
2286 current_command
= PLAYLIST_COMMAND_ADD
;
2289 current_command
= PLAYLIST_COMMAND_QUEUE
;
2292 current_command
= PLAYLIST_COMMAND_DELETE
;
2295 current_command
= PLAYLIST_COMMAND_SHUFFLE
;
2298 current_command
= PLAYLIST_COMMAND_UNSHUFFLE
;
2301 current_command
= PLAYLIST_COMMAND_RESET
;
2304 current_command
= PLAYLIST_COMMAND_COMMENT
;
2317 else if(current_command
!= PLAYLIST_COMMAND_COMMENT
)
2319 /* all control file strings are separated with a colon.
2320 Replace the colon with 0 to get proper strings that can be
2321 used by commands above */
2327 if ((count
+1) < nread
)
2341 /* allow last string to contain colons */
2352 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID
));
2356 if (!newline
|| (exit_loop
&& count
<nread
))
2358 if ((total_read
+ count
) >= control_file_size
)
2360 /* no newline at end of control file */
2361 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID
));
2365 /* We didn't end on a newline or we exited loop prematurely.
2366 Either way, re-read the remainder. */
2367 count
= last_newline
;
2368 lseek(playlist
->control_fd
, total_read
+count
, SEEK_SET
);
2371 total_read
+= count
;
2374 /* still looking for header */
2375 nread
= read(playlist
->control_fd
, buffer
,
2376 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
2378 nread
= read(playlist
->control_fd
, buffer
, buflen
);
2380 /* Terminate on EOF */
2383 if (global_status
.resume_seed
>= 0)
2385 /* Apply shuffle command saved in settings */
2386 if (global_status
.resume_seed
== 0)
2387 sort_playlist(playlist
, false, true);
2391 sort_playlist(playlist
, false, false);
2393 randomise_playlist(playlist
, global_status
.resume_seed
,
2398 playlist
->first_index
= global_status
.resume_first_index
;
2403 #ifdef HAVE_DIRCACHE
2404 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2411 * Add track to in_ram playlist. Used when playing directories.
2413 int playlist_add(const char *filename
)
2415 struct playlist_info
* playlist
= ¤t_playlist
;
2416 int len
= strlen(filename
);
2418 if((len
+1 > playlist
->buffer_size
- playlist
->buffer_end_pos
) ||
2419 (playlist
->amount
>= playlist
->max_playlist_size
))
2421 display_buffer_full();
2425 playlist
->indices
[playlist
->amount
] = playlist
->buffer_end_pos
;
2426 #ifdef HAVE_DIRCACHE
2427 playlist
->filenames
[playlist
->amount
] = NULL
;
2431 strcpy(&playlist
->buffer
[playlist
->buffer_end_pos
], filename
);
2432 playlist
->buffer_end_pos
+= len
;
2433 playlist
->buffer
[playlist
->buffer_end_pos
++] = '\0';
2438 /* shuffle newly created playlist using random seed. */
2439 int playlist_shuffle(int random_seed
, int start_index
)
2441 struct playlist_info
* playlist
= ¤t_playlist
;
2443 unsigned int seek_pos
= 0;
2444 bool start_current
= false;
2446 if (start_index
>= 0 && global_settings
.play_selected
)
2448 /* store the seek position before the shuffle */
2449 seek_pos
= playlist
->indices
[start_index
];
2450 playlist
->index
= global_status
.resume_first_index
=
2451 playlist
->first_index
= start_index
;
2452 start_current
= true;
2455 randomise_playlist(playlist
, random_seed
, start_current
, true);
2457 return playlist
->index
;
2460 /* start playing current playlist at specified index/offset */
2461 int playlist_start(int start_index
, int offset
)
2463 struct playlist_info
* playlist
= ¤t_playlist
;
2465 /* Cancel FM radio selection as previous music. For cases where we start
2466 playback without going to the WPS, such as playlist insert.. or
2467 playlist catalog. */
2468 previous_music_is_wps();
2470 playlist
->index
= start_index
;
2472 #if CONFIG_CODEC != SWCODEC
2473 talk_buffer_steal(); /* will use the mp3 buffer */
2476 playlist
->started
= true;
2477 sync_control(playlist
, false);
2483 /* Returns false if 'steps' would pass end of playlist */
2484 bool playlist_checkend(int steps
)
2486 struct playlist_info
* playlist
= ¤t_playlist
;
2488 int index
= get_next_index(playlist
, steps
, -1);
2490 if (index
< 0 && steps
>= 0 && global_settings
.repeat_mode
== REPEAT_SHUFFLE
)
2491 index
= get_next_index(playlist
, steps
, REPEAT_ALL
);
2493 return (index
>= 0);
2496 /* Returns false if 'steps' is out of bounds, else true */
2497 bool playlist_check(int steps
)
2499 struct playlist_info
* playlist
= ¤t_playlist
;
2501 /* always allow folder navigation */
2502 if (global_settings
.next_folder
&& playlist
->in_ram
)
2505 int index
= get_next_index(playlist
, steps
, -1);
2507 if (index
< 0 && steps
>= 0 && global_settings
.repeat_mode
== REPEAT_SHUFFLE
)
2508 index
= get_next_index(playlist
, steps
, REPEAT_ALL
);
2510 return (index
>= 0);
2513 /* get trackname of track that is "steps" away from current playing track.
2514 NULL is used to identify end of playlist */
2515 char* playlist_peek(int steps
)
2517 struct playlist_info
* playlist
= ¤t_playlist
;
2524 index
= get_next_index(playlist
, steps
, -1);
2528 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
2529 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
2531 if (get_filename(playlist
, index
, seek
, control_file
, now_playing
,
2535 temp_ptr
= now_playing
;
2537 if (!playlist
->in_ram
|| control_file
)
2539 /* remove bogus dirs from beginning of path
2540 (workaround for buggy playlist creation tools) */
2543 #ifdef HAVE_DIRCACHE
2544 if (dircache_is_enabled())
2546 if (dircache_get_entry_ptr(temp_ptr
))
2552 fd
= open(temp_ptr
, O_RDONLY
);
2560 temp_ptr
= strchr(temp_ptr
+1, '/');
2565 /* Even though this is an invalid file, we still need to pass a
2566 file name to the caller because NULL is used to indicate end
2576 * Update indices as track has changed
2578 int playlist_next(int steps
)
2580 struct playlist_info
* playlist
= ¤t_playlist
;
2584 #ifdef AB_REPEAT_ENABLE
2585 && (global_settings
.repeat_mode
!= REPEAT_AB
)
2587 && (global_settings
.repeat_mode
!= REPEAT_ONE
) )
2591 /* We need to delete all the queued songs */
2592 for (i
=0, j
=steps
; i
<j
; i
++)
2594 index
= get_next_index(playlist
, i
, -1);
2596 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
2598 remove_track_from_playlist(playlist
, index
, true);
2599 steps
--; /* one less track */
2604 index
= get_next_index(playlist
, steps
, -1);
2608 /* end of playlist... or is it */
2609 if (global_settings
.repeat_mode
== REPEAT_SHUFFLE
&&
2610 playlist
->amount
> 1)
2612 /* Repeat shuffle mode. Re-shuffle playlist and resume play */
2613 playlist
->first_index
= global_status
.resume_first_index
= 0;
2614 sort_playlist(playlist
, false, false);
2615 randomise_playlist(playlist
, current_tick
, false, true);
2616 #if CONFIG_CODEC != SWCODEC
2617 playlist_start(0, 0);
2619 playlist
->index
= 0;
2622 else if (playlist
->in_ram
&& global_settings
.next_folder
)
2624 index
= create_and_play_dir(steps
, true);
2628 playlist
->index
= index
;
2635 playlist
->index
= index
;
2637 if (playlist
->last_insert_pos
>= 0 && steps
> 0)
2639 /* check to see if we've gone beyond the last inserted track */
2640 int cur
= rotate_index(playlist
, index
);
2641 int last_pos
= rotate_index(playlist
, playlist
->last_insert_pos
);
2645 /* reset last inserted track */
2646 playlist
->last_insert_pos
= -1;
2648 if (playlist
->control_fd
>= 0)
2650 int result
= update_control(playlist
, PLAYLIST_COMMAND_RESET
,
2651 -1, -1, NULL
, NULL
, NULL
);
2656 sync_control(playlist
, false);
2664 /* try playing next or previous folder */
2665 bool playlist_next_dir(int direction
)
2667 /* not to mess up real playlists */
2668 if(!current_playlist
.in_ram
)
2671 return create_and_play_dir(direction
, false) >= 0;
2674 /* Get resume info for current playing song. If return value is -1 then
2675 settings shouldn't be saved. */
2676 int playlist_get_resume_info(int *resume_index
)
2678 struct playlist_info
* playlist
= ¤t_playlist
;
2680 *resume_index
= playlist
->index
;
2685 /* Update resume info for current playing song. Returns -1 on error. */
2686 int playlist_update_resume_info(const struct mp3entry
* id3
)
2688 struct playlist_info
* playlist
= ¤t_playlist
;
2692 if (global_status
.resume_index
!= playlist
->index
||
2693 global_status
.resume_offset
!= id3
->offset
)
2695 global_status
.resume_index
= playlist
->index
;
2696 global_status
.resume_offset
= id3
->offset
;
2702 global_status
.resume_index
= -1;
2703 global_status
.resume_offset
= -1;
2710 /* Returns index of current playing track for display purposes. This value
2711 should not be used for resume purposes as it doesn't represent the actual
2712 index into the playlist */
2713 int playlist_get_display_index(void)
2715 struct playlist_info
* playlist
= ¤t_playlist
;
2717 /* first_index should always be index 0 for display purposes */
2718 int index
= rotate_index(playlist
, playlist
->index
);
2723 /* returns number of tracks in current playlist */
2724 int playlist_amount(void)
2726 return playlist_amount_ex(NULL
);
2730 * Create a new playlist If playlist is not NULL then we're loading a
2731 * playlist off disk for viewing/editing. The index_buffer is used to store
2732 * playlist indices (required for and only used if !current playlist). The
2733 * temp_buffer (if not NULL) is used as a scratchpad when loading indices.
2735 int playlist_create_ex(struct playlist_info
* playlist
,
2736 const char* dir
, const char* file
,
2737 void* index_buffer
, int index_buffer_size
,
2738 void* temp_buffer
, int temp_buffer_size
)
2741 playlist
= ¤t_playlist
;
2744 /* Initialize playlist structure */
2745 int r
= rand() % 10;
2746 playlist
->current
= false;
2748 /* Use random name for control file */
2749 snprintf(playlist
->control_filename
, sizeof(playlist
->control_filename
),
2750 "%s.%d", PLAYLIST_CONTROL_FILE
, r
);
2752 playlist
->control_fd
= -1;
2756 int num_indices
= index_buffer_size
/ sizeof(int);
2758 #ifdef HAVE_DIRCACHE
2761 if (num_indices
> global_settings
.max_files_in_playlist
)
2762 num_indices
= global_settings
.max_files_in_playlist
;
2764 playlist
->max_playlist_size
= num_indices
;
2765 playlist
->indices
= index_buffer
;
2766 #ifdef HAVE_DIRCACHE
2767 playlist
->filenames
= (const struct dircache_entry
**)
2768 &playlist
->indices
[num_indices
];
2773 playlist
->max_playlist_size
= current_playlist
.max_playlist_size
;
2774 playlist
->indices
= current_playlist
.indices
;
2775 #ifdef HAVE_DIRCACHE
2776 playlist
->filenames
= current_playlist
.filenames
;
2780 playlist
->buffer_size
= 0;
2781 playlist
->buffer
= NULL
;
2782 mutex_init(&playlist
->control_mutex
);
2785 new_playlist(playlist
, dir
, file
);
2788 /* load the playlist file */
2789 add_indices_to_playlist(playlist
, temp_buffer
, temp_buffer_size
);
2795 * Set the specified playlist as the current.
2796 * NOTE: You will get undefined behaviour if something is already playing so
2797 * remember to stop before calling this. Also, this call will
2798 * effectively close your playlist, making it unusable.
2800 int playlist_set_current(struct playlist_info
* playlist
)
2802 if (!playlist
|| (check_control(playlist
) < 0))
2805 empty_playlist(¤t_playlist
, false);
2807 strncpy(current_playlist
.filename
, playlist
->filename
,
2808 sizeof(current_playlist
.filename
));
2810 current_playlist
.utf8
= playlist
->utf8
;
2811 current_playlist
.fd
= playlist
->fd
;
2813 close(playlist
->control_fd
);
2814 close(current_playlist
.control_fd
);
2815 remove(current_playlist
.control_filename
);
2816 if (rename(playlist
->control_filename
,
2817 current_playlist
.control_filename
) < 0)
2819 current_playlist
.control_fd
= open(current_playlist
.control_filename
,
2821 if (current_playlist
.control_fd
< 0)
2823 current_playlist
.control_created
= true;
2825 current_playlist
.dirlen
= playlist
->dirlen
;
2827 if (playlist
->indices
&& playlist
->indices
!= current_playlist
.indices
)
2829 memcpy(current_playlist
.indices
, playlist
->indices
,
2830 playlist
->max_playlist_size
*sizeof(int));
2831 #ifdef HAVE_DIRCACHE
2832 memcpy(current_playlist
.filenames
, playlist
->filenames
,
2833 playlist
->max_playlist_size
*sizeof(int));
2837 current_playlist
.first_index
= playlist
->first_index
;
2838 current_playlist
.amount
= playlist
->amount
;
2839 current_playlist
.last_insert_pos
= playlist
->last_insert_pos
;
2840 current_playlist
.seed
= playlist
->seed
;
2841 current_playlist
.shuffle_modified
= playlist
->shuffle_modified
;
2842 current_playlist
.deleted
= playlist
->deleted
;
2843 current_playlist
.num_inserted_tracks
= playlist
->num_inserted_tracks
;
2845 memcpy(current_playlist
.control_cache
, playlist
->control_cache
,
2846 sizeof(current_playlist
.control_cache
));
2847 current_playlist
.num_cached
= playlist
->num_cached
;
2848 current_playlist
.pending_control_sync
= playlist
->pending_control_sync
;
2854 * Close files and delete control file for non-current playlist.
2856 void playlist_close(struct playlist_info
* playlist
)
2861 if (playlist
->fd
>= 0)
2862 close(playlist
->fd
);
2864 if (playlist
->control_fd
>= 0)
2865 close(playlist
->control_fd
);
2867 if (playlist
->control_created
)
2868 remove(playlist
->control_filename
);
2871 void playlist_sync(struct playlist_info
* playlist
)
2874 playlist
= ¤t_playlist
;
2876 sync_control(playlist
, false);
2877 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2878 audio_flush_and_reload_tracks();
2880 #ifdef HAVE_DIRCACHE
2881 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2886 * Insert track into playlist at specified position (or one of the special
2887 * positions). Returns position where track was inserted or -1 if error.
2889 int playlist_insert_track(struct playlist_info
* playlist
, const char *filename
,
2890 int position
, bool queue
, bool sync
)
2895 playlist
= ¤t_playlist
;
2897 if (check_control(playlist
) < 0)
2899 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2903 result
= add_track_to_playlist(playlist
, filename
, position
, queue
, -1);
2905 /* Check if we want manually sync later. For example when adding
2906 * bunch of files from tagcache, syncing after every file wouldn't be
2907 * a good thing to do. */
2908 if (sync
&& result
>= 0)
2909 playlist_sync(playlist
);
2915 * Insert all tracks from specified directory into playlist.
2917 int playlist_insert_directory(struct playlist_info
* playlist
,
2918 const char *dirname
, int position
, bool queue
,
2922 unsigned char *count_str
;
2923 struct directory_search_context context
;
2926 playlist
= ¤t_playlist
;
2928 if (check_control(playlist
) < 0)
2930 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2934 if (position
== PLAYLIST_REPLACE
)
2936 if (remove_all_tracks(playlist
) == 0)
2937 position
= PLAYLIST_INSERT_LAST
;
2943 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
2945 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
2947 display_playlist_count(0, count_str
, false);
2949 context
.playlist
= playlist
;
2950 context
.position
= position
;
2951 context
.queue
= queue
;
2956 result
= playlist_directory_tracksearch(dirname
, recurse
,
2957 directory_search_callback
, &context
);
2959 sync_control(playlist
, false);
2963 display_playlist_count(context
.count
, count_str
, true);
2965 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2966 audio_flush_and_reload_tracks();
2968 #ifdef HAVE_DIRCACHE
2969 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2976 * Insert all tracks from specified playlist into dynamic playlist.
2978 int playlist_insert_playlist(struct playlist_info
* playlist
, char *filename
,
2979 int position
, bool queue
)
2985 unsigned char *count_str
;
2986 char temp_buf
[MAX_PATH
+1];
2987 char trackname
[MAX_PATH
+1];
2990 bool utf8
= is_m3u8(filename
);
2993 playlist
= ¤t_playlist
;
2995 if (check_control(playlist
) < 0)
2997 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3001 fd
= open(filename
, O_RDONLY
);
3004 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3008 /* we need the directory name for formatting purposes */
3011 temp_ptr
= strrchr(filename
+1,'/');
3018 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
3020 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
3022 display_playlist_count(count
, count_str
, false);
3024 if (position
== PLAYLIST_REPLACE
)
3026 if (remove_all_tracks(playlist
) == 0)
3027 position
= PLAYLIST_INSERT_LAST
;
3033 while ((max
= read_line(fd
, temp_buf
, sizeof(temp_buf
))) > 0)
3036 if (action_userabort(TIMEOUT_NOBLOCK
))
3039 if (count
== 0 && is_utf8_bom(temp_buf
, max
))
3042 memmove(temp_buf
, temp_buf
+ BOM_SIZE
, max
);
3045 if (temp_buf
[0] != '#' && temp_buf
[0] != '\0')
3051 /* Use trackname as a temporay buffer. Note that trackname must
3052 * be as large as temp_buf.
3054 max
= convert_m3u(temp_buf
, max
, sizeof(temp_buf
), trackname
);
3057 /* we need to format so that relative paths are correctly
3059 if (format_track_path(trackname
, temp_buf
, sizeof(trackname
), max
,
3066 insert_pos
= add_track_to_playlist(playlist
, trackname
, position
,
3075 /* Make sure tracks are inserted in correct order if user
3076 requests INSERT_FIRST */
3077 if (position
== PLAYLIST_INSERT_FIRST
|| position
>= 0)
3078 position
= insert_pos
+ 1;
3082 if ((count
%PLAYLIST_DISPLAY_COUNT
) == 0)
3084 display_playlist_count(count
, count_str
, false);
3086 if (count
== PLAYLIST_DISPLAY_COUNT
&&
3087 (audio_status() & AUDIO_STATUS_PLAY
) &&
3089 audio_flush_and_reload_tracks();
3093 /* let the other threads work */
3102 sync_control(playlist
, false);
3106 display_playlist_count(count
, count_str
, true);
3108 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3109 audio_flush_and_reload_tracks();
3111 #ifdef HAVE_DIRCACHE
3112 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3119 * Delete track at specified index. If index is PLAYLIST_DELETE_CURRENT then
3120 * we want to delete the current playing track.
3122 int playlist_delete(struct playlist_info
* playlist
, int index
)
3127 playlist
= ¤t_playlist
;
3129 if (check_control(playlist
) < 0)
3131 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3135 if (index
== PLAYLIST_DELETE_CURRENT
)
3136 index
= playlist
->index
;
3138 result
= remove_track_from_playlist(playlist
, index
, true);
3140 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3142 audio_flush_and_reload_tracks();
3148 * Move track at index to new_index. Tracks between the two are shifted
3149 * appropriately. Returns 0 on success and -1 on failure.
3151 int playlist_move(struct playlist_info
* playlist
, int index
, int new_index
)
3157 bool current
= false;
3159 char filename
[MAX_PATH
];
3162 playlist
= ¤t_playlist
;
3164 if (check_control(playlist
) < 0)
3166 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3170 if (index
== new_index
)
3173 if (index
== playlist
->index
)
3174 /* Moving the current track */
3177 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3178 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3179 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3181 if (get_filename(playlist
, index
, seek
, control_file
, filename
,
3182 sizeof(filename
)) < 0)
3185 /* Delete track from original position */
3186 result
= remove_track_from_playlist(playlist
, index
, true);
3190 /* We want to insert the track at the position that was specified by
3191 new_index. This may be different then new_index because of the
3192 shifting that occurred after the delete */
3193 r
= rotate_index(playlist
, new_index
);
3197 new_index
= PLAYLIST_PREPEND
;
3198 else if (r
== playlist
->amount
)
3200 new_index
= PLAYLIST_INSERT_LAST
;
3202 /* Calculate index of desired position */
3203 new_index
= (r
+playlist
->first_index
)%playlist
->amount
;
3205 result
= add_track_to_playlist(playlist
, filename
, new_index
, queue
,
3212 /* Moved the current track */
3215 case PLAYLIST_PREPEND
:
3216 playlist
->index
= playlist
->first_index
;
3218 case PLAYLIST_INSERT_LAST
:
3219 playlist
->index
= playlist
->first_index
- 1;
3220 if (playlist
->index
< 0)
3221 playlist
->index
+= playlist
->amount
;
3224 playlist
->index
= new_index
;
3229 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3230 audio_flush_and_reload_tracks();
3234 #ifdef HAVE_DIRCACHE
3235 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3241 /* shuffle currently playing playlist */
3242 int playlist_randomise(struct playlist_info
* playlist
, unsigned int seed
,
3248 playlist
= ¤t_playlist
;
3250 check_control(playlist
);
3252 result
= randomise_playlist(playlist
, seed
, start_current
, true);
3254 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3256 audio_flush_and_reload_tracks();
3261 /* sort currently playing playlist */
3262 int playlist_sort(struct playlist_info
* playlist
, bool start_current
)
3267 playlist
= ¤t_playlist
;
3269 check_control(playlist
);
3271 result
= sort_playlist(playlist
, start_current
, true);
3273 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3275 audio_flush_and_reload_tracks();
3280 /* returns true if playlist has been modified */
3281 bool playlist_modified(const struct playlist_info
* playlist
)
3284 playlist
= ¤t_playlist
;
3286 if (playlist
->shuffle_modified
||
3287 playlist
->deleted
||
3288 playlist
->num_inserted_tracks
> 0)
3294 /* returns index of first track in playlist */
3295 int playlist_get_first_index(const struct playlist_info
* playlist
)
3298 playlist
= ¤t_playlist
;
3300 return playlist
->first_index
;
3303 /* returns shuffle seed of playlist */
3304 int playlist_get_seed(const struct playlist_info
* playlist
)
3307 playlist
= ¤t_playlist
;
3309 return playlist
->seed
;
3312 /* returns number of tracks in playlist (includes queued/inserted tracks) */
3313 int playlist_amount_ex(const struct playlist_info
* playlist
)
3316 playlist
= ¤t_playlist
;
3318 return playlist
->amount
;
3321 /* returns full path of playlist (minus extension) */
3322 char *playlist_name(const struct playlist_info
* playlist
, char *buf
,
3328 playlist
= ¤t_playlist
;
3330 snprintf(buf
, buf_size
, "%s", playlist
->filename
+playlist
->dirlen
);
3335 /* Remove extension */
3336 sep
= strrchr(buf
, '.');
3343 /* returns the playlist filename */
3344 char *playlist_get_name(const struct playlist_info
* playlist
, char *buf
,
3348 playlist
= ¤t_playlist
;
3350 snprintf(buf
, buf_size
, "%s", playlist
->filename
);
3358 /* Fills info structure with information about track at specified index.
3359 Returns 0 on success and -1 on failure */
3360 int playlist_get_track_info(struct playlist_info
* playlist
, int index
,
3361 struct playlist_track_info
* info
)
3367 playlist
= ¤t_playlist
;
3369 if (index
< 0 || index
>= playlist
->amount
)
3372 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3373 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3375 if (get_filename(playlist
, index
, seek
, control_file
, info
->filename
,
3376 sizeof(info
->filename
)) < 0)
3383 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
3384 info
->attr
|= PLAYLIST_ATTR_QUEUED
;
3386 info
->attr
|= PLAYLIST_ATTR_INSERTED
;
3390 if (playlist
->indices
[index
] & PLAYLIST_SKIPPED
)
3391 info
->attr
|= PLAYLIST_ATTR_SKIPPED
;
3393 info
->index
= index
;
3394 info
->display_index
= rotate_index(playlist
, index
) + 1;
3399 /* save the current dynamic playlist to specified file */
3400 int playlist_save(struct playlist_info
* playlist
, char *filename
)
3405 char path
[MAX_PATH
+1];
3406 char tmp_buf
[MAX_PATH
+1];
3408 bool overwrite_current
= false;
3409 int* index_buf
= NULL
;
3412 playlist
= ¤t_playlist
;
3414 if (playlist
->amount
<= 0)
3417 /* use current working directory as base for pathname */
3418 if (format_track_path(path
, filename
, sizeof(tmp_buf
),
3419 strlen(filename
)+1, getcwd(NULL
, -1)) < 0)
3422 if (!strncmp(playlist
->filename
, path
, strlen(path
)))
3424 /* Attempting to overwrite current playlist file.*/
3426 if (playlist
->buffer_size
< (int)(playlist
->amount
* sizeof(int)))
3428 /* not enough buffer space to store updated indices */
3429 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3433 /* in_ram buffer is unused for m3u files so we'll use for storing
3435 index_buf
= (int*)playlist
->buffer
;
3437 /* use temporary pathname */
3438 snprintf(path
, sizeof(path
), "%s_temp", playlist
->filename
);
3439 overwrite_current
= true;
3442 fd
= open(path
, O_CREAT
|O_WRONLY
|O_TRUNC
);
3445 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3449 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
), false);
3453 index
= playlist
->first_index
;
3454 for (i
=0; i
<playlist
->amount
; i
++)
3461 if (action_userabort(TIMEOUT_NOBLOCK
))
3467 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3468 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3469 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3471 /* Don't save queued files */
3474 if (get_filename(playlist
, index
, seek
, control_file
, tmp_buf
,
3481 if (overwrite_current
)
3482 index_buf
[count
] = lseek(fd
, 0, SEEK_CUR
);
3484 if (fdprintf(fd
, "%s\n", tmp_buf
) < 0)
3486 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3493 if ((count
% PLAYLIST_DISPLAY_COUNT
) == 0)
3494 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
),
3500 index
= (index
+1)%playlist
->amount
;
3503 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
), true);
3507 if (overwrite_current
&& result
>= 0)
3511 mutex_lock(&playlist
->control_mutex
);
3513 /* Replace the current playlist with the new one and update indices */
3514 close(playlist
->fd
);
3515 if (remove(playlist
->filename
) >= 0)
3517 if (rename(path
, playlist
->filename
) >= 0)
3519 playlist
->fd
= open(playlist
->filename
, O_RDONLY
);
3520 if (playlist
->fd
>= 0)
3522 index
= playlist
->first_index
;
3523 for (i
=0, count
=0; i
<playlist
->amount
; i
++)
3525 if (!(playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
))
3527 playlist
->indices
[index
] = index_buf
[count
];
3530 index
= (index
+1)%playlist
->amount
;
3533 /* we need to recreate control because inserted tracks are
3534 now part of the playlist and shuffle has been
3536 result
= recreate_control(playlist
);
3541 mutex_unlock(&playlist
->control_mutex
);
3551 * Search specified directory for tracks and notify via callback. May be
3552 * called recursively.
3554 int playlist_directory_tracksearch(const char* dirname
, bool recurse
,
3555 int (*callback
)(char*, void*),
3558 char buf
[MAX_PATH
+1];
3562 struct entry
*files
;
3563 struct tree_context
* tc
= tree_get_context();
3564 int old_dirfilter
= *(tc
->dirfilter
);
3569 /* use the tree browser dircache to load files */
3570 *(tc
->dirfilter
) = SHOW_ALL
;
3572 if (ft_load(tc
, dirname
) < 0)
3574 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
3575 *(tc
->dirfilter
) = old_dirfilter
;
3579 files
= (struct entry
*) tc
->dircache
;
3580 num_files
= tc
->filesindir
;
3582 /* we've overwritten the dircache so tree browser will need to be
3586 for (i
=0; i
<num_files
; i
++)
3589 if (action_userabort(TIMEOUT_NOBLOCK
))
3595 if (files
[i
].attr
& ATTR_DIRECTORY
)
3599 /* recursively add directories */
3600 snprintf(buf
, sizeof(buf
), "%s/%s", dirname
, files
[i
].name
);
3601 result
= playlist_directory_tracksearch(buf
, recurse
,
3606 /* we now need to reload our current directory */
3607 if(ft_load(tc
, dirname
) < 0)
3613 files
= (struct entry
*) tc
->dircache
;
3614 num_files
= tc
->filesindir
;
3624 else if ((files
[i
].attr
& FILE_ATTR_MASK
) == FILE_ATTR_AUDIO
)
3626 snprintf(buf
, sizeof(buf
), "%s/%s", dirname
, files
[i
].name
);
3628 if (callback(buf
, context
) != 0)
3634 /* let the other threads work */
3639 /* restore dirfilter */
3640 *(tc
->dirfilter
) = old_dirfilter
;