1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2002 by wavey@wavey.org
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
23 Dynamic playlist design (based on design originally proposed by ricII)
25 There are two files associated with a dynamic playlist:
26 1. Playlist file : This file contains the initial songs in the playlist.
27 The file is created by the user and stored on the hard
28 drive. NOTE: If we are playing the contents of a
29 directory, there will be no playlist file.
30 2. Control file : This file is automatically created when a playlist is
31 started and contains all the commands done to it.
33 The first non-comment line in a control file must begin with
34 "P:VERSION:DIR:FILE" where VERSION is the playlist control file version,
35 DIR is the directory where the playlist is located and FILE is the
36 playlist filename. For dirplay, FILE will be empty. An empty playlist
37 will have both entries as null.
39 Control file commands:
40 a. Add track (A:<position>:<last position>:<path to track>)
41 - Insert a track at the specified position in the current
42 playlist. Last position is used to specify where last insertion
44 b. Queue track (Q:<position>:<last position>:<path to track>)
45 - Queue a track at the specified position in the current
46 playlist. Queued tracks differ from added tracks in that they
47 are deleted from the playlist as soon as they are played and
48 they are not saved to disk as part of the playlist.
49 c. Delete track (D:<position>)
50 - Delete track from specified position in the current playlist.
51 d. Shuffle playlist (S:<seed>:<index>)
52 - Shuffle entire playlist with specified seed. The index
53 identifies the first index in the newly shuffled playlist
54 (needed for repeat mode).
55 e. Unshuffle playlist (U:<index>)
56 - Unshuffle entire playlist. The index identifies the first index
57 in the newly unshuffled playlist.
58 f. Reset last insert position (R)
59 - Needed so that insertions work properly after resume
62 The only resume info that needs to be saved is the current index in the
63 playlist and the position in the track. When resuming, all the commands
64 in the control file will be reapplied so that the playlist indices are
65 exactly the same as before shutdown. To avoid unnecessary disk
66 accesses, the shuffle mode settings are also saved in settings and only
67 flushed to disk when required.
73 #include "string-extra.h"
75 #include "ata_idle_notify.h"
85 #include "applimits.h"
87 #include "core_alloc.h"
89 #include "filefuncs.h"
95 #include "filetypes.h"
96 #ifdef HAVE_LCD_BITMAP
104 #include "rbunicode.h"
105 #include "root_menu.h"
106 #include "plugin.h" /* To borrow a temp buffer to rewrite a .m3u8 file */
108 #define PLAYLIST_CONTROL_FILE_VERSION 2
111 Each playlist index has a flag associated with it which identifies what
112 type of track it is. These flags are stored in the 4 high order bits of
115 NOTE: This limits the playlist file size to a max of 256M.
119 01 = Track was prepended into playlist
120 10 = Track was inserted into playlist
121 11 = Track was appended into playlist
126 0 = Track entry is valid
127 1 = Track does not exist on disk and should be skipped
129 #define PLAYLIST_SEEK_MASK 0x0FFFFFFF
130 #define PLAYLIST_INSERT_TYPE_MASK 0xC0000000
131 #define PLAYLIST_QUEUE_MASK 0x20000000
133 #define PLAYLIST_INSERT_TYPE_PREPEND 0x40000000
134 #define PLAYLIST_INSERT_TYPE_INSERT 0x80000000
135 #define PLAYLIST_INSERT_TYPE_APPEND 0xC0000000
137 #define PLAYLIST_QUEUED 0x20000000
138 #define PLAYLIST_SKIPPED 0x10000000
140 struct directory_search_context
{
141 struct playlist_info
* playlist
;
147 static struct playlist_info current_playlist
;
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
, const char *subdir
, bool recurse
);
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 SHAREDBSS_ATTR
;
197 static long playlist_stack
[(DEFAULT_STACK_SIZE
+ 0x800)/sizeof(long)];
198 static const char playlist_thread_name
[] = "playlist cachectrl";
201 static struct mutex current_playlist_mutex SHAREDBSS_ATTR
;
202 static struct mutex created_playlist_mutex SHAREDBSS_ATTR
;
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);
214 /* Convert a filename in an M3U playlist to UTF-8.
216 * buf - the filename to convert; can contain more than one line from the
218 * buf_len - amount of buf that is used.
219 * buf_max - total size of buf.
220 * temp - temporary conversion buffer, at least buf_max bytes.
222 * Returns the length of the converted filename.
224 static int convert_m3u(char* buf
, int buf_len
, int buf_max
, char* temp
)
230 while ((buf
[i
] != '\n') && (buf
[i
] != '\r') && (i
< buf_len
))
235 /* Work back killing white space. */
236 while ((i
> 0) && isspace(buf
[i
- 1]))
244 /* Convert char by char, so as to not overflow temp (iso_decode should
245 * preferably handle this). No more than 4 bytes should be generated for
248 for (i
= 0; i
< buf_len
&& dest
< (temp
+ buf_max
- 4); i
++)
250 dest
= iso_decode(&buf
[i
], dest
, -1, 1);
259 * remove any files and indices associated with the playlist
261 static void empty_playlist(struct playlist_info
* playlist
, bool resume
)
263 playlist
->filename
[0] = '\0';
264 playlist
->utf8
= true;
266 if(playlist
->fd
>= 0)
267 /* If there is an already open playlist, close it. */
271 if(playlist
->control_fd
>= 0)
272 close(playlist
->control_fd
);
273 playlist
->control_fd
= -1;
274 playlist
->control_created
= false;
276 playlist
->in_ram
= false;
278 if (playlist
->buffer
)
279 playlist
->buffer
[0] = 0;
281 playlist
->buffer_end_pos
= 0;
284 playlist
->first_index
= 0;
285 playlist
->amount
= 0;
286 playlist
->last_insert_pos
= -1;
288 playlist
->shuffle_modified
= false;
289 playlist
->deleted
= false;
290 playlist
->num_inserted_tracks
= 0;
291 playlist
->started
= false;
293 playlist
->num_cached
= 0;
294 playlist
->pending_control_sync
= false;
296 if (!resume
&& playlist
->current
)
298 /* start with fresh playlist control file when starting new
300 create_control(playlist
);
305 * Initialize a new playlist for viewing/editing/playing. dir is the
306 * directory where the playlist is located and file is the filename.
308 static void new_playlist(struct playlist_info
* playlist
, const char *dir
,
311 const char *fileused
= file
;
312 const char *dirused
= dir
;
313 empty_playlist(playlist
, false);
319 if (dirused
&& playlist
->current
) /* !current cannot be in_ram */
320 playlist
->in_ram
= true;
322 dirused
= ""; /* empty playlist */
325 update_playlist_filename(playlist
, dirused
, fileused
);
327 if (playlist
->control_fd
>= 0)
329 update_control(playlist
, PLAYLIST_COMMAND_PLAYLIST
,
330 PLAYLIST_CONTROL_FILE_VERSION
, -1, dirused
, fileused
, NULL
);
331 sync_control(playlist
, false);
336 * create control file for playlist
338 static void create_control(struct playlist_info
* playlist
)
340 playlist
->control_fd
= open(playlist
->control_filename
,
341 O_CREAT
|O_RDWR
|O_TRUNC
, 0666);
342 if (playlist
->control_fd
< 0)
344 if (check_rockboxdir())
346 cond_talk_ids_fq(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
);
347 splashf(HZ
*2, (unsigned char *)"%s (%d)",
348 str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
),
349 playlist
->control_fd
);
351 playlist
->control_created
= false;
355 playlist
->control_created
= true;
360 * validate the control file. This may include creating/initializing it if
363 static int check_control(struct playlist_info
* playlist
)
365 if (!playlist
->control_created
)
367 create_control(playlist
);
369 if (playlist
->control_fd
>= 0)
371 char* dir
= playlist
->filename
;
372 char* file
= playlist
->filename
+playlist
->dirlen
;
373 char c
= playlist
->filename
[playlist
->dirlen
-1];
375 playlist
->filename
[playlist
->dirlen
-1] = '\0';
377 update_control(playlist
, PLAYLIST_COMMAND_PLAYLIST
,
378 PLAYLIST_CONTROL_FILE_VERSION
, -1, dir
, file
, NULL
);
379 sync_control(playlist
, false);
380 playlist
->filename
[playlist
->dirlen
-1] = c
;
384 if (playlist
->control_fd
< 0)
391 * recreate the control file based on current playlist entries
393 static int recreate_control(struct playlist_info
* playlist
)
395 char temp_file
[MAX_PATH
+1];
400 if(playlist
->control_fd
>= 0)
402 char* dir
= playlist
->filename
;
403 char* file
= playlist
->filename
+playlist
->dirlen
;
404 char c
= playlist
->filename
[playlist
->dirlen
-1];
406 close(playlist
->control_fd
);
408 snprintf(temp_file
, sizeof(temp_file
), "%s_temp",
409 playlist
->control_filename
);
411 if (rename(playlist
->control_filename
, temp_file
) < 0)
414 temp_fd
= open(temp_file
, O_RDONLY
);
418 playlist
->control_fd
= open(playlist
->control_filename
,
419 O_CREAT
|O_RDWR
|O_TRUNC
, 0666);
420 if (playlist
->control_fd
< 0)
426 playlist
->filename
[playlist
->dirlen
-1] = '\0';
428 /* cannot call update_control() because of mutex */
429 result
= fdprintf(playlist
->control_fd
, "P:%d:%s:%s\n",
430 PLAYLIST_CONTROL_FILE_VERSION
, dir
, file
);
432 playlist
->filename
[playlist
->dirlen
-1] = c
;
442 playlist
->shuffle_modified
= false;
443 playlist
->deleted
= false;
444 playlist
->num_inserted_tracks
= 0;
446 for (i
=0; i
<playlist
->amount
; i
++)
448 if (playlist
->indices
[i
] & PLAYLIST_INSERT_TYPE_MASK
)
450 bool queue
= playlist
->indices
[i
] & PLAYLIST_QUEUE_MASK
;
451 char inserted_file
[MAX_PATH
+1];
453 lseek(temp_fd
, playlist
->indices
[i
] & PLAYLIST_SEEK_MASK
,
455 read_line(temp_fd
, inserted_file
, sizeof(inserted_file
));
457 result
= fdprintf(playlist
->control_fd
, "%c:%d:%d:",
458 queue
?'Q':'A', i
, playlist
->last_insert_pos
);
461 /* save the position in file where name is written */
462 int seek_pos
= lseek(playlist
->control_fd
, 0, SEEK_CUR
);
464 result
= fdprintf(playlist
->control_fd
, "%s\n",
467 playlist
->indices
[i
] =
468 (playlist
->indices
[i
] & ~PLAYLIST_SEEK_MASK
) | seek_pos
;
474 playlist
->num_inserted_tracks
++;
480 fsync(playlist
->control_fd
);
489 * store directory and name of playlist file
491 static void update_playlist_filename(struct playlist_info
* playlist
,
492 const char *dir
, const char *file
)
495 int dirlen
= strlen(dir
);
497 playlist
->utf8
= is_m3u8(file
);
499 /* If the dir does not end in trailing slash, we use a separator.
500 Otherwise we don't. */
501 if('/' != dir
[dirlen
-1])
507 playlist
->dirlen
= dirlen
;
509 snprintf(playlist
->filename
, sizeof(playlist
->filename
),
510 "%s%s%s", dir
, sep
, file
);
514 * calculate track offsets within a playlist file
516 static int add_indices_to_playlist(struct playlist_info
* playlist
,
517 char* buffer
, size_t buflen
)
521 unsigned int count
= 0;
526 if(-1 == playlist
->fd
)
527 playlist
->fd
= open_utf8(playlist
->filename
, O_RDONLY
);
529 return -1; /* failure */
530 if((i
= lseek(playlist
->fd
, 0, SEEK_CUR
)) > 0)
531 playlist
->utf8
= true; /* Override any earlier indication. */
533 splash(0, ID2P(LANG_WAIT
));
537 /* use mp3 buffer for maximum load speed */
539 buffer
= audio_get_buffer(false, &buflen
);
546 nread
= read(playlist
->fd
, buffer
, buflen
);
547 /* Terminate on EOF */
551 p
= (unsigned char *)buffer
;
553 for(count
=0; count
< nread
; count
++,p
++) {
555 /* Are we on a new line? */
556 if((*p
== '\n') || (*p
== '\r'))
566 if ( playlist
->amount
>= playlist
->max_playlist_size
) {
567 display_buffer_full();
572 /* Store a new entry */
573 playlist
->indices
[ playlist
->amount
] = i
+count
;
575 if (playlist
->filenames
)
576 playlist
->filenames
[ playlist
->amount
] = -1;
588 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
595 * Utility function to create a new playlist, fill it with the next or
596 * previous directory, shuffle it if needed, and start playback.
597 * If play_last is true and direction zero or negative, start playing
598 * the last file in the directory, otherwise start playing the first.
600 static int create_and_play_dir(int direction
, bool play_last
)
602 char dir
[MAX_PATH
+ 1];
607 res
= get_next_directory(dir
);
609 res
= get_previous_directory(dir
);
613 if (playlist_create(dir
, NULL
) != -1)
615 ft_build_playlist(tree_get_context(), 0);
617 if (global_settings
.playlist_shuffle
)
618 playlist_shuffle(current_tick
, -1);
620 if (play_last
&& direction
<= 0)
621 index
= current_playlist
.amount
- 1;
625 #if (CONFIG_CODEC == SWCODEC)
626 current_playlist
.started
= true;
628 playlist_start(index
, 0);
632 /* we've overwritten the dircache when getting the next/previous dir,
633 so the tree browser context will need to be reloaded */
641 * Removes all tracks, from the playlist, leaving the presently playing
644 int playlist_remove_all_tracks(struct playlist_info
*playlist
)
648 if (playlist
== NULL
)
649 playlist
= ¤t_playlist
;
651 while (playlist
->index
> 0)
652 if ((result
= remove_track_from_playlist(playlist
, 0, true)) < 0)
655 while (playlist
->amount
> 1)
656 if ((result
= remove_track_from_playlist(playlist
, 1, true)) < 0)
659 if (playlist
->amount
== 1) {
660 playlist
->indices
[0] |= PLAYLIST_QUEUED
;
668 * Add track to playlist at specified position. There are seven special
669 * positions that can be specified:
670 * PLAYLIST_PREPEND - Add track at beginning of playlist
671 * PLAYLIST_INSERT - Add track after current song. NOTE: If
672 * there are already inserted tracks then track
673 * is added to the end of the insertion list
674 * PLAYLIST_INSERT_FIRST - Add track immediately after current song, no
675 * matter what other tracks have been inserted
676 * PLAYLIST_INSERT_LAST - Add track to end of playlist
677 * PLAYLIST_INSERT_SHUFFLED - Add track at some random point between the
678 * current playing track and end of playlist
679 * PLAYLIST_INSERT_LAST_SHUFFLED - Add tracks in random order to the end of
681 * PLAYLIST_REPLACE - Erase current playlist, Cue the current track
682 * and inster this track at the end.
684 static int add_track_to_playlist(struct playlist_info
* playlist
,
685 const char *filename
, int position
,
686 bool queue
, int seek_pos
)
688 int insert_position
, orig_position
;
689 unsigned long flags
= PLAYLIST_INSERT_TYPE_INSERT
;
692 insert_position
= orig_position
= position
;
694 if (playlist
->amount
>= playlist
->max_playlist_size
)
696 display_buffer_full();
702 case PLAYLIST_PREPEND
:
703 position
= insert_position
= playlist
->first_index
;
705 case PLAYLIST_INSERT
:
706 /* if there are already inserted tracks then add track to end of
707 insertion list else add after current playing track */
708 if (playlist
->last_insert_pos
>= 0 &&
709 playlist
->last_insert_pos
< playlist
->amount
&&
710 (playlist
->indices
[playlist
->last_insert_pos
]&
711 PLAYLIST_INSERT_TYPE_MASK
) == PLAYLIST_INSERT_TYPE_INSERT
)
712 position
= insert_position
= playlist
->last_insert_pos
+1;
713 else if (playlist
->amount
> 0)
714 position
= insert_position
= playlist
->index
+ 1;
716 position
= insert_position
= 0;
718 playlist
->last_insert_pos
= position
;
720 case PLAYLIST_INSERT_FIRST
:
721 if (playlist
->amount
> 0)
722 position
= insert_position
= playlist
->index
+ 1;
724 position
= insert_position
= 0;
726 playlist
->last_insert_pos
= position
;
728 case PLAYLIST_INSERT_LAST
:
729 if (playlist
->first_index
> 0)
730 position
= insert_position
= playlist
->first_index
;
732 position
= insert_position
= playlist
->amount
;
734 playlist
->last_insert_pos
= position
;
736 case PLAYLIST_INSERT_SHUFFLED
:
738 if (playlist
->started
)
741 int n
= playlist
->amount
-
742 rotate_index(playlist
, playlist
->index
);
749 position
= playlist
->index
+ offset
+ 1;
750 if (position
>= playlist
->amount
)
751 position
-= playlist
->amount
;
753 insert_position
= position
;
756 position
= insert_position
= (rand() % (playlist
->amount
+1));
759 case PLAYLIST_INSERT_LAST_SHUFFLED
:
761 position
= insert_position
= playlist
->last_shuffled_start
+
762 rand() % (playlist
->amount
- playlist
->last_shuffled_start
+ 1);
765 case PLAYLIST_REPLACE
:
766 if (playlist_remove_all_tracks(playlist
) < 0)
769 playlist
->last_insert_pos
= position
= insert_position
= playlist
->index
+ 1;
774 flags
|= PLAYLIST_QUEUED
;
776 /* shift indices so that track can be added */
777 for (i
=playlist
->amount
; i
>insert_position
; i
--)
779 playlist
->indices
[i
] = playlist
->indices
[i
-1];
781 if (playlist
->filenames
)
782 playlist
->filenames
[i
] = playlist
->filenames
[i
-1];
786 /* update stored indices if needed */
788 if (orig_position
< 0)
790 if (playlist
->amount
> 0 && insert_position
<= playlist
->index
&&
794 if (playlist
->amount
> 0 && insert_position
<= playlist
->first_index
&&
795 orig_position
!= PLAYLIST_PREPEND
&& playlist
->started
)
796 playlist
->first_index
++;
799 if (insert_position
< playlist
->last_insert_pos
||
800 (insert_position
== playlist
->last_insert_pos
&& position
< 0))
801 playlist
->last_insert_pos
++;
803 if (seek_pos
< 0 && playlist
->control_fd
>= 0)
805 int result
= update_control(playlist
,
806 (queue
?PLAYLIST_COMMAND_QUEUE
:PLAYLIST_COMMAND_ADD
), position
,
807 playlist
->last_insert_pos
, filename
, NULL
, &seek_pos
);
813 playlist
->indices
[insert_position
] = flags
| seek_pos
;
816 if (playlist
->filenames
)
817 playlist
->filenames
[insert_position
] = -1;
821 playlist
->num_inserted_tracks
++;
823 return insert_position
;
827 * Callback for playlist_directory_tracksearch to insert track into
830 static int directory_search_callback(char* filename
, void* context
)
832 struct directory_search_context
* c
=
833 (struct directory_search_context
*) context
;
836 insert_pos
= add_track_to_playlist(c
->playlist
, filename
, c
->position
,
844 /* Make sure tracks are inserted in correct order if user requests
846 if (c
->position
== PLAYLIST_INSERT_FIRST
|| c
->position
>= 0)
847 c
->position
= insert_pos
+ 1;
849 if (((c
->count
)%PLAYLIST_DISPLAY_COUNT
) == 0)
851 unsigned char* count_str
;
854 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
856 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
858 display_playlist_count(c
->count
, count_str
, false);
860 if ((c
->count
) == PLAYLIST_DISPLAY_COUNT
&&
861 (audio_status() & AUDIO_STATUS_PLAY
) &&
862 c
->playlist
->started
)
863 audio_flush_and_reload_tracks();
870 * remove track at specified position
872 static int remove_track_from_playlist(struct playlist_info
* playlist
,
873 int position
, bool write
)
878 if (playlist
->amount
<= 0)
881 inserted
= playlist
->indices
[position
] & PLAYLIST_INSERT_TYPE_MASK
;
883 /* shift indices now that track has been removed */
884 for (i
=position
; i
<playlist
->amount
; i
++)
886 playlist
->indices
[i
] = playlist
->indices
[i
+1];
888 if (playlist
->filenames
)
889 playlist
->filenames
[i
] = playlist
->filenames
[i
+1];
896 playlist
->num_inserted_tracks
--;
898 playlist
->deleted
= true;
900 /* update stored indices if needed */
901 if (position
< playlist
->index
)
904 if (position
< playlist
->first_index
)
906 playlist
->first_index
--;
909 if (position
<= playlist
->last_insert_pos
)
910 playlist
->last_insert_pos
--;
912 if (write
&& playlist
->control_fd
>= 0)
914 int result
= update_control(playlist
, PLAYLIST_COMMAND_DELETE
,
915 position
, -1, NULL
, NULL
, NULL
);
920 sync_control(playlist
, false);
927 * randomly rearrange the array of indices for the playlist. If start_current
928 * is true then update the index to the new index of the current playing track
930 static int randomise_playlist(struct playlist_info
* playlist
,
931 unsigned int seed
, bool start_current
,
937 unsigned int current
= playlist
->indices
[playlist
->index
];
939 /* seed 0 is used to identify sorted playlist for resume purposes */
943 /* seed with the given seed */
946 /* randomise entire indices list */
947 for(count
= playlist
->amount
- 1; count
>= 0; count
--)
949 /* the rand is from 0 to RAND_MAX, so adjust to our value range */
950 candidate
= rand() % (count
+ 1);
952 /* now swap the values at the 'count' and 'candidate' positions */
953 store
= playlist
->indices
[candidate
];
954 playlist
->indices
[candidate
] = playlist
->indices
[count
];
955 playlist
->indices
[count
] = store
;
957 if (playlist
->filenames
)
959 store
= playlist
->filenames
[candidate
];
960 playlist
->filenames
[candidate
] = playlist
->filenames
[count
];
961 playlist
->filenames
[count
] = store
;
967 find_and_set_playlist_index(playlist
, current
);
969 /* indices have been moved so last insert position is no longer valid */
970 playlist
->last_insert_pos
= -1;
972 playlist
->seed
= seed
;
973 if (playlist
->num_inserted_tracks
> 0 || playlist
->deleted
)
974 playlist
->shuffle_modified
= true;
978 update_control(playlist
, PLAYLIST_COMMAND_SHUFFLE
, seed
,
979 playlist
->first_index
, NULL
, NULL
, NULL
);
986 * Sort the array of indices for the playlist. If start_current is true then
987 * set the index to the new index of the current song.
988 * Also while going to unshuffled mode set the first_index to 0.
990 static int sort_playlist(struct playlist_info
* playlist
, bool start_current
,
993 unsigned int current
= playlist
->indices
[playlist
->index
];
995 if (playlist
->amount
> 0)
996 qsort((void*)playlist
->indices
, playlist
->amount
,
997 sizeof(playlist
->indices
[0]), compare
);
1000 /** We need to re-check the song names from disk because qsort can't
1001 * sort two arrays at once :/
1002 * FIXME: Please implement a better way to do this. */
1003 memset((void*)playlist
->filenames
, 0xff, playlist
->max_playlist_size
* sizeof(int));
1004 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
1008 find_and_set_playlist_index(playlist
, current
);
1010 /* indices have been moved so last insert position is no longer valid */
1011 playlist
->last_insert_pos
= -1;
1013 if (!playlist
->num_inserted_tracks
&& !playlist
->deleted
)
1014 playlist
->shuffle_modified
= false;
1015 if (write
&& playlist
->control_fd
>= 0)
1017 playlist
->first_index
= 0;
1018 update_control(playlist
, PLAYLIST_COMMAND_UNSHUFFLE
,
1019 playlist
->first_index
, -1, NULL
, NULL
, NULL
);
1025 /* Calculate how many steps we have to really step when skipping entries
1028 static int calculate_step_count(const struct playlist_info
*playlist
, int steps
)
1030 int i
, count
, direction
;
1032 int stepped_count
= 0;
1045 index
= playlist
->index
;
1048 /* Boundary check */
1050 index
+= playlist
->amount
;
1051 if (index
>= playlist
->amount
)
1052 index
-= playlist
->amount
;
1054 /* Check if we found a bad entry. */
1055 if (playlist
->indices
[index
] & PLAYLIST_SKIPPED
)
1058 /* Are all entries bad? */
1059 if (stepped_count
++ > playlist
->amount
)
1066 } while (i
<= count
);
1071 /* Marks the index of the track to be skipped that is "steps" away from
1072 * current playing track.
1074 void playlist_skip_entry(struct playlist_info
*playlist
, int steps
)
1078 if (playlist
== NULL
)
1079 playlist
= ¤t_playlist
;
1081 /* need to account for already skipped tracks */
1082 steps
= calculate_step_count(playlist
, steps
);
1084 index
= playlist
->index
+ steps
;
1086 index
+= playlist
->amount
;
1087 else if (index
>= playlist
->amount
)
1088 index
-= playlist
->amount
;
1090 playlist
->indices
[index
] |= PLAYLIST_SKIPPED
;
1094 * returns the index of the track that is "steps" away from current playing
1097 static int get_next_index(const struct playlist_info
* playlist
, int steps
,
1100 int current_index
= playlist
->index
;
1101 int next_index
= -1;
1103 if (playlist
->amount
<= 0)
1106 if (repeat_mode
== -1)
1107 repeat_mode
= global_settings
.repeat_mode
;
1109 if (repeat_mode
== REPEAT_SHUFFLE
&& playlist
->amount
<= 1)
1110 repeat_mode
= REPEAT_ALL
;
1112 steps
= calculate_step_count(playlist
, steps
);
1113 switch (repeat_mode
)
1115 case REPEAT_SHUFFLE
:
1116 /* Treat repeat shuffle just like repeat off. At end of playlist,
1117 play will be resumed in playlist_next() */
1120 current_index
= rotate_index(playlist
, current_index
);
1121 next_index
= current_index
+steps
;
1122 if ((next_index
< 0) || (next_index
>= playlist
->amount
))
1125 next_index
= (next_index
+playlist
->first_index
) %
1132 #ifdef AB_REPEAT_ENABLE
1135 next_index
= current_index
;
1141 next_index
= (current_index
+steps
) % playlist
->amount
;
1142 while (next_index
< 0)
1143 next_index
+= playlist
->amount
;
1145 if (steps
>= playlist
->amount
)
1152 /* second time around so skip the queued files */
1153 for (i
=0; i
<playlist
->amount
; i
++)
1155 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
1156 index
= (index
+1) % playlist
->amount
;
1168 /* No luck if the whole playlist was bad. */
1169 if (playlist
->indices
[next_index
] & PLAYLIST_SKIPPED
)
1176 * Search for the seek track and set appropriate indices. Used after shuffle
1177 * to make sure the current index is still pointing to correct track.
1179 static void find_and_set_playlist_index(struct playlist_info
* playlist
,
1184 /* Set the index to the current song */
1185 for (i
=0; i
<playlist
->amount
; i
++)
1187 if (playlist
->indices
[i
] == seek
)
1189 playlist
->index
= playlist
->first_index
= i
;
1197 * used to sort track indices. Sort order is as follows:
1198 * 1. Prepended tracks (in prepend order)
1199 * 2. Playlist/directory tracks (in playlist order)
1200 * 3. Inserted/Appended tracks (in insert order)
1202 static int compare(const void* p1
, const void* p2
)
1204 unsigned long* e1
= (unsigned long*) p1
;
1205 unsigned long* e2
= (unsigned long*) p2
;
1206 unsigned long flags1
= *e1
& PLAYLIST_INSERT_TYPE_MASK
;
1207 unsigned long flags2
= *e2
& PLAYLIST_INSERT_TYPE_MASK
;
1209 if (flags1
== flags2
)
1210 return (*e1
& PLAYLIST_SEEK_MASK
) - (*e2
& PLAYLIST_SEEK_MASK
);
1211 else if (flags1
== PLAYLIST_INSERT_TYPE_PREPEND
||
1212 flags2
== PLAYLIST_INSERT_TYPE_APPEND
)
1214 else if (flags1
== PLAYLIST_INSERT_TYPE_APPEND
||
1215 flags2
== PLAYLIST_INSERT_TYPE_PREPEND
)
1217 else if (flags1
&& flags2
)
1218 return (*e1
& PLAYLIST_SEEK_MASK
) - (*e2
& PLAYLIST_SEEK_MASK
);
1223 #ifdef HAVE_DIRCACHE
1225 * Thread to update filename pointers to dircache on background
1226 * without affecting playlist load up performance. This thread also flushes
1227 * any pending control commands when the disk spins up.
1229 static void playlist_flush_callback(void *param
)
1232 struct playlist_info
*playlist
;
1233 playlist
= ¤t_playlist
;
1234 if (playlist
->control_fd
>= 0)
1236 if (playlist
->num_cached
> 0)
1238 mutex_lock(playlist
->control_mutex
);
1239 flush_cached_control(playlist
);
1240 mutex_unlock(playlist
->control_mutex
);
1242 sync_control(playlist
, true);
1246 static bool is_dircache_pointers_intact(void)
1248 return dircache_get_appflag(DIRCACHE_APPFLAG_PLAYLIST
) ? true : false;
1251 static void playlist_thread(void)
1253 struct queue_event ev
;
1254 bool dirty_pointers
= false;
1255 static char tmp
[MAX_PATH
+1];
1257 struct playlist_info
*playlist
;
1264 #ifdef HAVE_DISK_STORAGE
1265 if (global_settings
.disk_spindown
> 1 &&
1266 global_settings
.disk_spindown
<= 5)
1267 sleep_time
= global_settings
.disk_spindown
- 1;
1272 queue_wait_w_tmo(&playlist_queue
, &ev
, HZ
*sleep_time
);
1276 case PLAYLIST_LOAD_POINTERS
:
1277 dirty_pointers
= true;
1280 /* Start the background scanning after either the disk spindown
1281 timeout or 5s, whichever is less */
1284 playlist
= ¤t_playlist
;
1285 if (playlist
->control_fd
>= 0)
1287 if (playlist
->num_cached
> 0)
1288 register_storage_idle_func(playlist_flush_callback
);
1291 if (!dircache_is_enabled() || !playlist
->filenames
1292 || playlist
->amount
<= 0)
1297 /* Check if previously loaded pointers are intact. */
1298 if (is_dircache_pointers_intact() && !dirty_pointers
)
1301 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1304 for (index
= 0; index
< playlist
->amount
1305 && queue_empty(&playlist_queue
); index
++)
1307 /* Process only pointers that are not already loaded. */
1308 if (is_dircache_pointers_intact() && playlist
->filenames
[index
] >= 0)
1311 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
1312 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
1314 /* Load the filename from playlist file. */
1315 if (get_filename(playlist
, index
, seek
, control_file
, tmp
,
1321 /* Set the dircache entry pointer. */
1322 playlist
->filenames
[index
] = dircache_get_entry_id(tmp
);
1324 /* And be on background so user doesn't notice any delays. */
1328 if (dircache_is_enabled())
1329 dircache_set_appflag(DIRCACHE_APPFLAG_PLAYLIST
);
1331 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1334 if (index
== playlist
->amount
)
1335 dirty_pointers
= false;
1340 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
1341 case SYS_USB_CONNECTED
:
1342 usb_acknowledge(SYS_USB_CONNECTED_ACK
);
1343 usb_wait_for_disconnect(&playlist_queue
);
1352 * gets pathname for track at seek index
1354 static int get_filename(struct playlist_info
* playlist
, int index
, int seek
,
1355 bool control_file
, char *buf
, int buf_length
)
1359 char tmp_buf
[MAX_PATH
+1];
1360 char dir_buf
[MAX_PATH
+1];
1361 bool utf8
= playlist
->utf8
;
1363 if (buf_length
> MAX_PATH
+1)
1364 buf_length
= MAX_PATH
+1;
1366 #ifdef HAVE_DIRCACHE
1367 if (is_dircache_pointers_intact() && playlist
->filenames
)
1369 if (playlist
->filenames
[index
] >= 0)
1371 max
= dircache_copy_path(playlist
->filenames
[index
],
1372 tmp_buf
, sizeof(tmp_buf
)-1);
1379 if (playlist
->in_ram
&& !control_file
&& max
< 0)
1381 max
= strlcpy(tmp_buf
, (char*)&playlist
->buffer
[seek
], sizeof(tmp_buf
));
1385 mutex_lock(playlist
->control_mutex
);
1389 fd
= playlist
->control_fd
;
1394 if(-1 == playlist
->fd
)
1395 playlist
->fd
= open(playlist
->filename
, O_RDONLY
);
1403 if (lseek(fd
, seek
, SEEK_SET
) != seek
)
1407 max
= read(fd
, tmp_buf
, MIN((size_t) buf_length
, sizeof(tmp_buf
)));
1409 if ((max
> 0) && !utf8
)
1411 /* Use dir_buf as a temporary buffer. Note that dir_buf must
1412 * be as large as tmp_buf.
1414 max
= convert_m3u(tmp_buf
, max
, sizeof(tmp_buf
), dir_buf
);
1419 mutex_unlock(playlist
->control_mutex
);
1424 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
1426 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
1432 strlcpy(dir_buf
, playlist
->filename
, playlist
->dirlen
);
1434 return (format_track_path(buf
, tmp_buf
, buf_length
, max
, dir_buf
));
1437 static int get_next_directory(char *dir
){
1438 return get_next_dir(dir
,true,false);
1441 static int get_previous_directory(char *dir
){
1442 return get_next_dir(dir
,false,false);
1446 * search through all the directories (starting with the current) to find
1447 * one that has tracks to play
1449 static int get_next_dir(char *dir
, bool is_forward
, bool recursion
)
1451 struct playlist_info
* playlist
= ¤t_playlist
;
1453 char *start_dir
= NULL
;
1456 struct tree_context
* tc
= tree_get_context();
1457 int saved_dirfilter
= *(tc
->dirfilter
);
1459 /* process random folder advance */
1460 if (global_settings
.next_folder
== FOLDER_ADVANCE_RANDOM
)
1462 int fd
= open(ROCKBOX_DIR
"/folder_advance_list.dat", O_RDONLY
);
1465 char buffer
[MAX_PATH
];
1466 int folder_count
= 0;
1467 srand(current_tick
);
1468 *(tc
->dirfilter
) = SHOW_MUSIC
;
1469 tc
->sort_dir
= global_settings
.sort_dir
;
1470 read(fd
,&folder_count
,sizeof(int));
1475 i
= rand()%folder_count
;
1476 lseek(fd
,sizeof(int) + (MAX_PATH
*i
),SEEK_SET
);
1477 read(fd
,buffer
,MAX_PATH
);
1478 if (check_subdir_for_music(buffer
, "", false) ==0)
1484 *(tc
->dirfilter
) = saved_dirfilter
;
1485 tc
->sort_dir
= global_settings
.sort_dir
;
1491 /* not random folder advance (or random folder advance unavailable) */
1494 /* start with root */
1499 /* start with current directory */
1500 strlcpy(dir
, playlist
->filename
, playlist
->dirlen
);
1503 /* use the tree browser dircache to load files */
1504 *(tc
->dirfilter
) = SHOW_ALL
;
1506 /* set up sorting/direction */
1507 tc
->sort_dir
= global_settings
.sort_dir
;
1510 static const char sortpairs
[] =
1512 [SORT_ALPHA
] = SORT_ALPHA_REVERSED
,
1513 [SORT_DATE
] = SORT_DATE_REVERSED
,
1514 [SORT_TYPE
] = SORT_TYPE_REVERSED
,
1515 [SORT_ALPHA_REVERSED
] = SORT_ALPHA
,
1516 [SORT_DATE_REVERSED
] = SORT_DATE
,
1517 [SORT_TYPE_REVERSED
] = SORT_TYPE
,
1520 if ((unsigned)tc
->sort_dir
< sizeof(sortpairs
))
1521 tc
->sort_dir
= sortpairs
[tc
->sort_dir
];
1526 struct entry
*files
;
1530 if (ft_load(tc
, (dir
[0]=='\0')?"/":dir
) < 0)
1537 files
= tree_get_entries(tc
);
1538 num_files
= tc
->filesindir
;
1540 tree_lock_cache(tc
);
1541 for (i
=0; i
<num_files
; i
++)
1544 if (action_userabort(TIMEOUT_NOBLOCK
))
1551 if (files
[i
].attr
& ATTR_DIRECTORY
)
1555 result
= check_subdir_for_music(dir
, files
[i
].name
, true);
1562 else if (!strcmp(start_dir
, files
[i
].name
))
1566 tree_unlock_cache(tc
);
1570 /* move down to parent directory. current directory name is
1571 stored as the starting point for the search in parent */
1572 start_dir
= strrchr(dir
, '/');
1583 /* restore dirfilter */
1584 *(tc
->dirfilter
) = saved_dirfilter
;
1585 tc
->sort_dir
= global_settings
.sort_dir
;
1587 /* special case if nothing found: try start searching again from root */
1588 if (result
== -1 && !recursion
){
1589 result
= get_next_dir(dir
, is_forward
, true);
1596 * Checks if there are any music files in the dir or any of its
1597 * subdirectories. May be called recursively.
1599 static int check_subdir_for_music(char *dir
, const char *subdir
, bool recurse
)
1602 int dirlen
= strlen(dir
);
1605 struct entry
*files
;
1606 bool has_music
= false;
1607 bool has_subdir
= false;
1608 struct tree_context
* tc
= tree_get_context();
1610 snprintf(dir
+dirlen
, MAX_PATH
-dirlen
, "/%s", subdir
);
1612 if (ft_load(tc
, dir
) < 0)
1617 files
= tree_get_entries(tc
);
1618 num_files
= tc
->filesindir
;
1620 for (i
=0; i
<num_files
; i
++)
1622 if (files
[i
].attr
& ATTR_DIRECTORY
)
1624 else if ((files
[i
].attr
& FILE_ATTR_MASK
) == FILE_ATTR_AUDIO
)
1634 tree_lock_cache(tc
);
1635 if (has_subdir
&& recurse
)
1637 for (i
=0; i
<num_files
; i
++)
1639 if (action_userabort(TIMEOUT_NOBLOCK
))
1645 if (files
[i
].attr
& ATTR_DIRECTORY
)
1647 result
= check_subdir_for_music(dir
, files
[i
].name
, true);
1653 tree_unlock_cache(tc
);
1666 /* we now need to reload our current directory */
1667 if(ft_load(tc
, dir
) < 0)
1668 splash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
1674 * Returns absolute path of track
1676 static int format_track_path(char *dest
, char *src
, int buf_length
, int max
,
1683 /* Look for the end of the string */
1690 /* Now work back killing white space */
1692 ((src
[i
-1] == ' ') ||
1693 (src
[i
-1] == '\t')))
1696 /* Zero-terminate the file name */
1699 /* replace backslashes with forward slashes */
1700 for ( j
=0; j
<i
; j
++ )
1701 if ( src
[j
] == '\\' )
1706 strlcpy(dest
, src
, buf_length
);
1710 /* handle dos style drive letter */
1712 strlcpy(dest
, &src
[2], buf_length
);
1713 else if (!strncmp(src
, "../", 3))
1715 /* handle relative paths */
1717 while(!strncmp(&src
[i
], "../", 3))
1719 for (j
=0; j
<i
/3; j
++) {
1720 temp_ptr
= strrchr(dir
, '/');
1726 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[i
]);
1728 else if ( '.' == src
[0] && '/' == src
[1] ) {
1729 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[2]);
1732 snprintf(dest
, buf_length
, "%s/%s", dir
, src
);
1740 * Display splash message showing progress of playlist/directory insertion or
1743 static void display_playlist_count(int count
, const unsigned char *fmt
,
1746 static long talked_tick
= 0;
1747 long id
= P2ID(fmt
);
1748 if(global_settings
.talk_menu
&& id
>=0)
1750 if(final
|| (count
&& (talked_tick
== 0
1751 || TIME_AFTER(current_tick
, talked_tick
+5*HZ
))))
1753 talked_tick
= current_tick
;
1754 talk_number(count
, false);
1760 splashf(0, fmt
, count
, str(LANG_OFF_ABORT
));
1764 * Display buffer full message
1766 static void display_buffer_full(void)
1768 splash(HZ
*2, ID2P(LANG_PLAYLIST_BUFFER_FULL
));
1772 * Flush any cached control commands to disk. Called when playlist is being
1773 * modified. Returns 0 on success and -1 on failure.
1775 static int flush_cached_control(struct playlist_info
* playlist
)
1780 if (!playlist
->num_cached
)
1783 lseek(playlist
->control_fd
, 0, SEEK_END
);
1785 for (i
=0; i
<playlist
->num_cached
; i
++)
1787 struct playlist_control_cache
* cache
=
1788 &(playlist
->control_cache
[i
]);
1790 switch (cache
->command
)
1792 case PLAYLIST_COMMAND_PLAYLIST
:
1793 result
= fdprintf(playlist
->control_fd
, "P:%d:%s:%s\n",
1794 cache
->i1
, cache
->s1
, cache
->s2
);
1796 case PLAYLIST_COMMAND_ADD
:
1797 case PLAYLIST_COMMAND_QUEUE
:
1798 result
= fdprintf(playlist
->control_fd
, "%c:%d:%d:",
1799 (cache
->command
== PLAYLIST_COMMAND_ADD
)?'A':'Q',
1800 cache
->i1
, cache
->i2
);
1803 /* save the position in file where name is written */
1804 int* seek_pos
= (int *)cache
->data
;
1805 *seek_pos
= lseek(playlist
->control_fd
, 0, SEEK_CUR
);
1806 result
= fdprintf(playlist
->control_fd
, "%s\n",
1810 case PLAYLIST_COMMAND_DELETE
:
1811 result
= fdprintf(playlist
->control_fd
, "D:%d\n", cache
->i1
);
1813 case PLAYLIST_COMMAND_SHUFFLE
:
1814 result
= fdprintf(playlist
->control_fd
, "S:%d:%d\n",
1815 cache
->i1
, cache
->i2
);
1817 case PLAYLIST_COMMAND_UNSHUFFLE
:
1818 result
= fdprintf(playlist
->control_fd
, "U:%d\n", cache
->i1
);
1820 case PLAYLIST_COMMAND_RESET
:
1821 result
= fdprintf(playlist
->control_fd
, "R\n");
1833 playlist
->num_cached
= 0;
1834 playlist
->pending_control_sync
= true;
1841 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_UPDATE_ERROR
));
1848 * Update control data with new command. Depending on the command, it may be
1849 * cached or flushed to disk.
1851 static int update_control(struct playlist_info
* playlist
,
1852 enum playlist_command command
, int i1
, int i2
,
1853 const char* s1
, const char* s2
, void* data
)
1856 struct playlist_control_cache
* cache
;
1859 mutex_lock(playlist
->control_mutex
);
1861 cache
= &(playlist
->control_cache
[playlist
->num_cached
++]);
1863 cache
->command
= command
;
1872 case PLAYLIST_COMMAND_PLAYLIST
:
1873 case PLAYLIST_COMMAND_ADD
:
1874 case PLAYLIST_COMMAND_QUEUE
:
1875 #ifndef HAVE_DIRCACHE
1876 case PLAYLIST_COMMAND_DELETE
:
1877 case PLAYLIST_COMMAND_RESET
:
1881 case PLAYLIST_COMMAND_SHUFFLE
:
1882 case PLAYLIST_COMMAND_UNSHUFFLE
:
1884 /* only flush when needed */
1888 if (flush
|| playlist
->num_cached
== PLAYLIST_MAX_CACHE
)
1889 result
= flush_cached_control(playlist
);
1891 mutex_unlock(playlist
->control_mutex
);
1897 * sync control file to disk
1899 static void sync_control(struct playlist_info
* playlist
, bool force
)
1901 #ifdef HAVE_DIRCACHE
1902 if (playlist
->started
&& force
)
1906 if (playlist
->started
)
1909 if (playlist
->pending_control_sync
)
1911 mutex_lock(playlist
->control_mutex
);
1912 fsync(playlist
->control_fd
);
1913 playlist
->pending_control_sync
= false;
1914 mutex_unlock(playlist
->control_mutex
);
1920 * Rotate indices such that first_index is index 0
1922 static int rotate_index(const struct playlist_info
* playlist
, int index
)
1924 index
-= playlist
->first_index
;
1926 index
+= playlist
->amount
;
1932 * Need no movement protection since all 3 allocations are not passed to
1933 * other functions which can yield().
1935 static int move_callback(int handle
, void* current
, void* new)
1938 struct playlist_info
* playlist
= ¤t_playlist
;
1939 if (current
== playlist
->indices
)
1940 playlist
->indices
= new;
1941 else if (current
== playlist
->filenames
)
1942 playlist
->filenames
= new;
1943 /* buffer can possibly point to a new buffer temporarily (playlist_save()).
1944 * just don't overwrite the pointer to that temp buffer */
1945 else if (current
== playlist
->buffer
)
1946 playlist
->buffer
= new;
1948 return BUFLIB_CB_OK
;
1952 static struct buflib_callbacks ops
= {
1953 .move_callback
= move_callback
,
1954 .shrink_callback
= NULL
,
1957 * Initialize playlist entries at startup
1959 void playlist_init(void)
1962 struct playlist_info
* playlist
= ¤t_playlist
;
1964 mutex_init(¤t_playlist_mutex
);
1965 mutex_init(&created_playlist_mutex
);
1967 playlist
->current
= true;
1968 strlcpy(playlist
->control_filename
, PLAYLIST_CONTROL_FILE
,
1969 sizeof(playlist
->control_filename
));
1971 playlist
->control_fd
= -1;
1972 playlist
->max_playlist_size
= global_settings
.max_files_in_playlist
;
1973 handle
= core_alloc_ex("playlist idx",
1974 playlist
->max_playlist_size
* sizeof(int), &ops
);
1975 playlist
->indices
= core_get_data(handle
);
1976 playlist
->buffer_size
=
1977 AVERAGE_FILENAME_LENGTH
* global_settings
.max_files_in_dir
;
1978 handle
= core_alloc_ex("playlist buf",
1979 playlist
->buffer_size
, &ops
);
1980 playlist
->buffer
= core_get_data(handle
);
1981 playlist
->control_mutex
= ¤t_playlist_mutex
;
1983 empty_playlist(playlist
, true);
1985 #ifdef HAVE_DIRCACHE
1986 handle
= core_alloc_ex("playlist dc",
1987 playlist
->max_playlist_size
* sizeof(int), &ops
);
1988 playlist
->filenames
= core_get_data(handle
);
1989 memset((void*)playlist
->filenames
, 0xff,
1990 playlist
->max_playlist_size
* sizeof(int));
1991 create_thread(playlist_thread
, playlist_stack
, sizeof(playlist_stack
),
1992 0, playlist_thread_name
IF_PRIO(, PRIORITY_BACKGROUND
)
1994 queue_init(&playlist_queue
, true);
1999 * Clean playlist at shutdown
2001 void playlist_shutdown(void)
2003 struct playlist_info
* playlist
= ¤t_playlist
;
2005 if (playlist
->control_fd
>= 0)
2007 mutex_lock(playlist
->control_mutex
);
2009 if (playlist
->num_cached
> 0)
2010 flush_cached_control(playlist
);
2012 close(playlist
->control_fd
);
2014 mutex_unlock(playlist
->control_mutex
);
2019 * Create new playlist
2021 int playlist_create(const char *dir
, const char *file
)
2023 struct playlist_info
* playlist
= ¤t_playlist
;
2025 new_playlist(playlist
, dir
, file
);
2028 /* load the playlist file */
2029 add_indices_to_playlist(playlist
, NULL
, 0);
2034 #define PLAYLIST_COMMAND_SIZE (MAX_PATH+12)
2037 * Restore the playlist state based on control file commands. Called to
2038 * resume playback after shutdown.
2040 int playlist_resume(void)
2042 struct playlist_info
* playlist
= ¤t_playlist
;
2047 int control_file_size
= 0;
2051 /* use mp3 buffer for maximum load speed */
2052 buffer
= (char *)audio_get_buffer(false, &buflen
);
2054 empty_playlist(playlist
, true);
2056 splash(0, ID2P(LANG_WAIT
));
2057 playlist
->control_fd
= open(playlist
->control_filename
, O_RDWR
);
2058 if (playlist
->control_fd
< 0)
2060 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2063 playlist
->control_created
= true;
2065 control_file_size
= filesize(playlist
->control_fd
);
2066 if (control_file_size
<= 0)
2068 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2072 /* read a small amount first to get the header */
2073 nread
= read(playlist
->control_fd
, buffer
,
2074 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
2077 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2081 playlist
->started
= true;
2087 enum playlist_command current_command
= PLAYLIST_COMMAND_COMMENT
;
2088 int last_newline
= 0;
2090 bool newline
= true;
2091 bool exit_loop
= false;
2096 unsigned long last_tick
= current_tick
;
2097 bool useraborted
= false;
2099 for(count
=0; count
<nread
&& !exit_loop
&& !useraborted
; count
++,p
++)
2101 /* So a splash while we are loading. */
2102 if (TIME_AFTER(current_tick
, last_tick
+ HZ
/4))
2104 splashf(0, str(LANG_LOADING_PERCENT
),
2105 (total_read
+count
)*100/control_file_size
,
2106 str(LANG_OFF_ABORT
));
2107 if (action_userabort(TIMEOUT_NOBLOCK
))
2112 last_tick
= current_tick
;
2115 /* Are we on a new line? */
2116 if((*p
== '\n') || (*p
== '\r'))
2120 /* save last_newline in case we need to load more data */
2121 last_newline
= count
;
2123 switch (current_command
)
2125 case PLAYLIST_COMMAND_PLAYLIST
:
2127 /* str1=version str2=dir str3=file */
2143 version
= atoi(str1
);
2145 if (version
!= PLAYLIST_CONTROL_FILE_VERSION
)
2148 update_playlist_filename(playlist
, str2
, str3
);
2150 if (str3
[0] != '\0')
2152 /* NOTE: add_indices_to_playlist() overwrites the
2153 audiobuf so we need to reload control file
2155 add_indices_to_playlist(playlist
, NULL
, 0);
2157 else if (str2
[0] != '\0')
2159 playlist
->in_ram
= true;
2160 resume_directory(str2
);
2163 /* load the rest of the data */
2169 case PLAYLIST_COMMAND_ADD
:
2170 case PLAYLIST_COMMAND_QUEUE
:
2172 /* str1=position str2=last_position str3=file */
2173 int position
, last_position
;
2176 if (!str1
|| !str2
|| !str3
)
2183 position
= atoi(str1
);
2184 last_position
= atoi(str2
);
2186 queue
= (current_command
== PLAYLIST_COMMAND_ADD
)?
2189 /* seek position is based on str3's position in
2191 if (add_track_to_playlist(playlist
, str3
, position
,
2192 queue
, total_read
+(str3
-buffer
)) < 0)
2195 playlist
->last_insert_pos
= last_position
;
2199 case PLAYLIST_COMMAND_DELETE
:
2211 position
= atoi(str1
);
2213 if (remove_track_from_playlist(playlist
, position
,
2219 case PLAYLIST_COMMAND_SHUFFLE
:
2221 /* str1=seed str2=first_index */
2233 /* Always sort list before shuffling */
2234 sort_playlist(playlist
, false, false);
2238 playlist
->first_index
= atoi(str2
);
2240 if (randomise_playlist(playlist
, seed
, false,
2246 case PLAYLIST_COMMAND_UNSHUFFLE
:
2248 /* str1=first_index */
2256 playlist
->first_index
= atoi(str1
);
2258 if (sort_playlist(playlist
, false, false) < 0)
2264 case PLAYLIST_COMMAND_RESET
:
2266 playlist
->last_insert_pos
= -1;
2269 case PLAYLIST_COMMAND_COMMENT
:
2276 /* to ignore any extra newlines */
2277 current_command
= PLAYLIST_COMMAND_COMMENT
;
2283 /* first non-comment line must always specify playlist */
2284 if (first
&& *p
!= 'P' && *p
!= '#')
2294 /* playlist can only be specified once */
2302 current_command
= PLAYLIST_COMMAND_PLAYLIST
;
2305 current_command
= PLAYLIST_COMMAND_ADD
;
2308 current_command
= PLAYLIST_COMMAND_QUEUE
;
2311 current_command
= PLAYLIST_COMMAND_DELETE
;
2314 current_command
= PLAYLIST_COMMAND_SHUFFLE
;
2317 current_command
= PLAYLIST_COMMAND_UNSHUFFLE
;
2320 current_command
= PLAYLIST_COMMAND_RESET
;
2323 current_command
= PLAYLIST_COMMAND_COMMENT
;
2336 else if(current_command
!= PLAYLIST_COMMAND_COMMENT
)
2338 /* all control file strings are separated with a colon.
2339 Replace the colon with 0 to get proper strings that can be
2340 used by commands above */
2346 if ((count
+1) < nread
)
2360 /* allow last string to contain colons */
2371 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID
));
2377 splash(HZ
*2, ID2P(LANG_CANCEL
));
2380 if (!newline
|| (exit_loop
&& count
<nread
))
2382 if ((total_read
+ count
) >= control_file_size
)
2384 /* no newline at end of control file */
2385 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID
));
2389 /* We didn't end on a newline or we exited loop prematurely.
2390 Either way, re-read the remainder. */
2391 count
= last_newline
;
2392 lseek(playlist
->control_fd
, total_read
+count
, SEEK_SET
);
2395 total_read
+= count
;
2398 /* still looking for header */
2399 nread
= read(playlist
->control_fd
, buffer
,
2400 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
2402 nread
= read(playlist
->control_fd
, buffer
, buflen
);
2404 /* Terminate on EOF */
2411 #ifdef HAVE_DIRCACHE
2412 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2419 * Add track to in_ram playlist. Used when playing directories.
2421 int playlist_add(const char *filename
)
2423 struct playlist_info
* playlist
= ¤t_playlist
;
2424 int len
= strlen(filename
);
2426 if((len
+1 > playlist
->buffer_size
- playlist
->buffer_end_pos
) ||
2427 (playlist
->amount
>= playlist
->max_playlist_size
))
2429 display_buffer_full();
2433 playlist
->indices
[playlist
->amount
] = playlist
->buffer_end_pos
;
2434 #ifdef HAVE_DIRCACHE
2435 playlist
->filenames
[playlist
->amount
] = -1;
2439 strcpy((char*)&playlist
->buffer
[playlist
->buffer_end_pos
], filename
);
2440 playlist
->buffer_end_pos
+= len
;
2441 playlist
->buffer
[playlist
->buffer_end_pos
++] = '\0';
2446 /* shuffle newly created playlist using random seed. */
2447 int playlist_shuffle(int random_seed
, int start_index
)
2449 struct playlist_info
* playlist
= ¤t_playlist
;
2451 bool start_current
= false;
2453 if (start_index
>= 0 && global_settings
.play_selected
)
2455 /* store the seek position before the shuffle */
2456 playlist
->index
= playlist
->first_index
= start_index
;
2457 start_current
= true;
2460 randomise_playlist(playlist
, random_seed
, start_current
, true);
2462 return playlist
->index
;
2465 /* start playing current playlist at specified index/offset */
2466 void playlist_start(int start_index
, int offset
)
2468 struct playlist_info
* playlist
= ¤t_playlist
;
2470 /* Cancel FM radio selection as previous music. For cases where we start
2471 playback without going to the WPS, such as playlist insert.. or
2472 playlist catalog. */
2473 previous_music_is_wps();
2475 playlist
->index
= start_index
;
2477 playlist
->started
= true;
2478 sync_control(playlist
, false);
2482 /* Returns false if 'steps' is out of bounds, else true */
2483 bool playlist_check(int steps
)
2485 struct playlist_info
* playlist
= ¤t_playlist
;
2487 /* always allow folder navigation */
2488 if (global_settings
.next_folder
&& playlist
->in_ram
)
2491 int index
= get_next_index(playlist
, steps
, -1);
2493 if (index
< 0 && steps
>= 0 && global_settings
.repeat_mode
== REPEAT_SHUFFLE
)
2494 index
= get_next_index(playlist
, steps
, REPEAT_ALL
);
2496 return (index
>= 0);
2499 /* get trackname of track that is "steps" away from current playing track.
2500 NULL is used to identify end of playlist */
2501 const char* playlist_peek(int steps
, char* buf
, size_t buf_size
)
2503 struct playlist_info
* playlist
= ¤t_playlist
;
2509 index
= get_next_index(playlist
, steps
, -1);
2513 #if CONFIG_CODEC == SWCODEC
2514 /* Just testing - don't care about the file name */
2515 if (!buf
|| !buf_size
)
2519 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
2520 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
2522 if (get_filename(playlist
, index
, seek
, control_file
, buf
,
2528 if (!playlist
->in_ram
|| control_file
)
2530 /* remove bogus dirs from beginning of path
2531 (workaround for buggy playlist creation tools) */
2534 if (file_exists(temp_ptr
))
2537 temp_ptr
= strchr(temp_ptr
+1, '/');
2542 /* Even though this is an invalid file, we still need to pass a
2543 file name to the caller because NULL is used to indicate end
2553 * Update indices as track has changed
2555 int playlist_next(int steps
)
2557 struct playlist_info
* playlist
= ¤t_playlist
;
2561 #ifdef AB_REPEAT_ENABLE
2562 && (global_settings
.repeat_mode
!= REPEAT_AB
)
2564 && (global_settings
.repeat_mode
!= REPEAT_ONE
) )
2568 /* We need to delete all the queued songs */
2569 for (i
=0, j
=steps
; i
<j
; i
++)
2571 index
= get_next_index(playlist
, i
, -1);
2573 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
2575 remove_track_from_playlist(playlist
, index
, true);
2576 steps
--; /* one less track */
2581 index
= get_next_index(playlist
, steps
, -1);
2585 /* end of playlist... or is it */
2586 if (global_settings
.repeat_mode
== REPEAT_SHUFFLE
&&
2587 playlist
->amount
> 1)
2589 /* Repeat shuffle mode. Re-shuffle playlist and resume play */
2590 playlist
->first_index
= 0;
2591 sort_playlist(playlist
, false, false);
2592 randomise_playlist(playlist
, current_tick
, false, true);
2594 #if CONFIG_CODEC == SWCODEC
2595 playlist
->started
= true;
2597 playlist_start(0, 0);
2599 playlist
->index
= 0;
2602 else if (playlist
->in_ram
&& global_settings
.next_folder
)
2604 index
= create_and_play_dir(steps
, true);
2608 playlist
->index
= index
;
2615 playlist
->index
= index
;
2617 if (playlist
->last_insert_pos
>= 0 && steps
> 0)
2619 /* check to see if we've gone beyond the last inserted track */
2620 int cur
= rotate_index(playlist
, index
);
2621 int last_pos
= rotate_index(playlist
, playlist
->last_insert_pos
);
2625 /* reset last inserted track */
2626 playlist
->last_insert_pos
= -1;
2628 if (playlist
->control_fd
>= 0)
2630 int result
= update_control(playlist
, PLAYLIST_COMMAND_RESET
,
2631 -1, -1, NULL
, NULL
, NULL
);
2636 sync_control(playlist
, false);
2644 /* try playing next or previous folder */
2645 bool playlist_next_dir(int direction
)
2647 /* not to mess up real playlists */
2648 if(!current_playlist
.in_ram
)
2651 return create_and_play_dir(direction
, false) >= 0;
2654 /* Get resume info for current playing song. If return value is -1 then
2655 settings shouldn't be saved. */
2656 int playlist_get_resume_info(int *resume_index
)
2658 struct playlist_info
* playlist
= ¤t_playlist
;
2660 *resume_index
= playlist
->index
;
2665 /* Update resume info for current playing song. Returns -1 on error. */
2666 int playlist_update_resume_info(const struct mp3entry
* id3
)
2668 struct playlist_info
* playlist
= ¤t_playlist
;
2672 if (global_status
.resume_index
!= playlist
->index
||
2673 global_status
.resume_offset
!= id3
->offset
)
2675 global_status
.resume_index
= playlist
->index
;
2676 global_status
.resume_offset
= id3
->offset
;
2682 global_status
.resume_index
= -1;
2683 global_status
.resume_offset
= -1;
2690 /* Returns index of current playing track for display purposes. This value
2691 should not be used for resume purposes as it doesn't represent the actual
2692 index into the playlist */
2693 int playlist_get_display_index(void)
2695 struct playlist_info
* playlist
= ¤t_playlist
;
2697 /* first_index should always be index 0 for display purposes */
2698 int index
= rotate_index(playlist
, playlist
->index
);
2703 /* returns number of tracks in current playlist */
2704 int playlist_amount(void)
2706 return playlist_amount_ex(NULL
);
2708 /* set playlist->last_shuffle_start to playlist->amount for
2709 PLAYLIST_INSERT_LAST_SHUFFLED command purposes*/
2710 void playlist_set_last_shuffled_start(void)
2712 struct playlist_info
* playlist
= ¤t_playlist
;
2713 playlist
->last_shuffled_start
= playlist
->amount
;
2716 * Create a new playlist If playlist is not NULL then we're loading a
2717 * playlist off disk for viewing/editing. The index_buffer is used to store
2718 * playlist indices (required for and only used if !current playlist). The
2719 * temp_buffer (if not NULL) is used as a scratchpad when loading indices.
2721 int playlist_create_ex(struct playlist_info
* playlist
,
2722 const char* dir
, const char* file
,
2723 void* index_buffer
, int index_buffer_size
,
2724 void* temp_buffer
, int temp_buffer_size
)
2727 playlist
= ¤t_playlist
;
2730 /* Initialize playlist structure */
2731 int r
= rand() % 10;
2732 playlist
->current
= false;
2734 /* Use random name for control file */
2735 snprintf(playlist
->control_filename
, sizeof(playlist
->control_filename
),
2736 "%s.%d", PLAYLIST_CONTROL_FILE
, r
);
2738 playlist
->control_fd
= -1;
2742 int num_indices
= index_buffer_size
/ sizeof(int);
2744 #ifdef HAVE_DIRCACHE
2747 if (num_indices
> global_settings
.max_files_in_playlist
)
2748 num_indices
= global_settings
.max_files_in_playlist
;
2750 playlist
->max_playlist_size
= num_indices
;
2751 playlist
->indices
= index_buffer
;
2752 #ifdef HAVE_DIRCACHE
2753 playlist
->filenames
= (int*)&playlist
->indices
[num_indices
];
2758 playlist
->max_playlist_size
= current_playlist
.max_playlist_size
;
2759 playlist
->indices
= current_playlist
.indices
;
2760 #ifdef HAVE_DIRCACHE
2761 playlist
->filenames
= current_playlist
.filenames
;
2765 playlist
->buffer_size
= 0;
2766 playlist
->buffer_handle
= -1;
2767 playlist
->buffer
= NULL
;
2768 playlist
->control_mutex
= &created_playlist_mutex
;
2771 new_playlist(playlist
, dir
, file
);
2774 /* load the playlist file */
2775 add_indices_to_playlist(playlist
, temp_buffer
, temp_buffer_size
);
2781 * Set the specified playlist as the current.
2782 * NOTE: You will get undefined behaviour if something is already playing so
2783 * remember to stop before calling this. Also, this call will
2784 * effectively close your playlist, making it unusable.
2786 int playlist_set_current(struct playlist_info
* playlist
)
2788 if (!playlist
|| (check_control(playlist
) < 0))
2791 empty_playlist(¤t_playlist
, false);
2793 strlcpy(current_playlist
.filename
, playlist
->filename
,
2794 sizeof(current_playlist
.filename
));
2796 current_playlist
.utf8
= playlist
->utf8
;
2797 current_playlist
.fd
= playlist
->fd
;
2799 close(playlist
->control_fd
);
2800 close(current_playlist
.control_fd
);
2801 remove(current_playlist
.control_filename
);
2802 if (rename(playlist
->control_filename
,
2803 current_playlist
.control_filename
) < 0)
2805 current_playlist
.control_fd
= open(current_playlist
.control_filename
,
2807 if (current_playlist
.control_fd
< 0)
2809 current_playlist
.control_created
= true;
2811 current_playlist
.dirlen
= playlist
->dirlen
;
2813 if (playlist
->indices
&& playlist
->indices
!= current_playlist
.indices
)
2815 memcpy((void*)current_playlist
.indices
, (void*)playlist
->indices
,
2816 playlist
->max_playlist_size
*sizeof(int));
2817 #ifdef HAVE_DIRCACHE
2818 memcpy((void*)current_playlist
.filenames
, (void*)playlist
->filenames
,
2819 playlist
->max_playlist_size
*sizeof(int));
2823 current_playlist
.first_index
= playlist
->first_index
;
2824 current_playlist
.amount
= playlist
->amount
;
2825 current_playlist
.last_insert_pos
= playlist
->last_insert_pos
;
2826 current_playlist
.seed
= playlist
->seed
;
2827 current_playlist
.shuffle_modified
= playlist
->shuffle_modified
;
2828 current_playlist
.deleted
= playlist
->deleted
;
2829 current_playlist
.num_inserted_tracks
= playlist
->num_inserted_tracks
;
2831 memcpy(current_playlist
.control_cache
, playlist
->control_cache
,
2832 sizeof(current_playlist
.control_cache
));
2833 current_playlist
.num_cached
= playlist
->num_cached
;
2834 current_playlist
.pending_control_sync
= playlist
->pending_control_sync
;
2838 struct playlist_info
*playlist_get_current(void)
2840 return ¤t_playlist
;
2843 * Close files and delete control file for non-current playlist.
2845 void playlist_close(struct playlist_info
* playlist
)
2850 if (playlist
->fd
>= 0)
2851 close(playlist
->fd
);
2853 if (playlist
->control_fd
>= 0)
2854 close(playlist
->control_fd
);
2856 if (playlist
->control_created
)
2857 remove(playlist
->control_filename
);
2860 void playlist_sync(struct playlist_info
* playlist
)
2863 playlist
= ¤t_playlist
;
2865 sync_control(playlist
, false);
2866 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2867 audio_flush_and_reload_tracks();
2869 #ifdef HAVE_DIRCACHE
2870 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2875 * Insert track into playlist at specified position (or one of the special
2876 * positions). Returns position where track was inserted or -1 if error.
2878 int playlist_insert_track(struct playlist_info
* playlist
, const char *filename
,
2879 int position
, bool queue
, bool sync
)
2884 playlist
= ¤t_playlist
;
2886 if (check_control(playlist
) < 0)
2888 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2892 result
= add_track_to_playlist(playlist
, filename
, position
, queue
, -1);
2894 /* Check if we want manually sync later. For example when adding
2895 * bunch of files from tagcache, syncing after every file wouldn't be
2896 * a good thing to do. */
2897 if (sync
&& result
>= 0)
2898 playlist_sync(playlist
);
2904 * Insert all tracks from specified directory into playlist.
2906 int playlist_insert_directory(struct playlist_info
* playlist
,
2907 const char *dirname
, int position
, bool queue
,
2911 unsigned char *count_str
;
2912 struct directory_search_context context
;
2915 playlist
= ¤t_playlist
;
2917 if (check_control(playlist
) < 0)
2919 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2923 if (position
== PLAYLIST_REPLACE
)
2925 if (playlist_remove_all_tracks(playlist
) == 0)
2926 position
= PLAYLIST_INSERT_LAST
;
2932 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
2934 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
2936 display_playlist_count(0, count_str
, false);
2938 context
.playlist
= playlist
;
2939 context
.position
= position
;
2940 context
.queue
= queue
;
2945 result
= playlist_directory_tracksearch(dirname
, recurse
,
2946 directory_search_callback
, &context
);
2948 sync_control(playlist
, false);
2952 display_playlist_count(context
.count
, count_str
, true);
2954 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2955 audio_flush_and_reload_tracks();
2957 #ifdef HAVE_DIRCACHE
2958 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2965 * Insert all tracks from specified playlist into dynamic playlist.
2967 int playlist_insert_playlist(struct playlist_info
* playlist
, const char *filename
,
2968 int position
, bool queue
)
2974 unsigned char *count_str
;
2975 char temp_buf
[MAX_PATH
+1];
2976 char trackname
[MAX_PATH
+1];
2979 bool utf8
= is_m3u8(filename
);
2982 playlist
= ¤t_playlist
;
2984 if (check_control(playlist
) < 0)
2986 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2990 fd
= open_utf8(filename
, O_RDONLY
);
2993 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
2997 /* we need the directory name for formatting purposes */
3000 temp_ptr
= strrchr(filename
+1,'/');
3007 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
3009 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
3011 display_playlist_count(count
, count_str
, false);
3013 if (position
== PLAYLIST_REPLACE
)
3015 if (playlist_remove_all_tracks(playlist
) == 0)
3016 position
= PLAYLIST_INSERT_LAST
;
3022 while ((max
= read_line(fd
, temp_buf
, sizeof(temp_buf
))) > 0)
3025 if (action_userabort(TIMEOUT_NOBLOCK
))
3028 if (temp_buf
[0] != '#' && temp_buf
[0] != '\0')
3034 /* Use trackname as a temporay buffer. Note that trackname must
3035 * be as large as temp_buf.
3037 max
= convert_m3u(temp_buf
, max
, sizeof(temp_buf
), trackname
);
3040 /* we need to format so that relative paths are correctly
3042 if (format_track_path(trackname
, temp_buf
, sizeof(trackname
), max
,
3049 insert_pos
= add_track_to_playlist(playlist
, trackname
, position
,
3058 /* Make sure tracks are inserted in correct order if user
3059 requests INSERT_FIRST */
3060 if (position
== PLAYLIST_INSERT_FIRST
|| position
>= 0)
3061 position
= insert_pos
+ 1;
3065 if ((count
%PLAYLIST_DISPLAY_COUNT
) == 0)
3067 display_playlist_count(count
, count_str
, false);
3069 if (count
== PLAYLIST_DISPLAY_COUNT
&&
3070 (audio_status() & AUDIO_STATUS_PLAY
) &&
3072 audio_flush_and_reload_tracks();
3076 /* let the other threads work */
3085 sync_control(playlist
, false);
3089 display_playlist_count(count
, count_str
, true);
3091 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3092 audio_flush_and_reload_tracks();
3094 #ifdef HAVE_DIRCACHE
3095 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3102 * Delete track at specified index. If index is PLAYLIST_DELETE_CURRENT then
3103 * we want to delete the current playing track.
3105 int playlist_delete(struct playlist_info
* playlist
, int index
)
3110 playlist
= ¤t_playlist
;
3112 if (check_control(playlist
) < 0)
3114 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3118 if (index
== PLAYLIST_DELETE_CURRENT
)
3119 index
= playlist
->index
;
3121 result
= remove_track_from_playlist(playlist
, index
, true);
3123 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3125 audio_flush_and_reload_tracks();
3131 * Move track at index to new_index. Tracks between the two are shifted
3132 * appropriately. Returns 0 on success and -1 on failure.
3134 int playlist_move(struct playlist_info
* playlist
, int index
, int new_index
)
3140 bool current
= false;
3142 char filename
[MAX_PATH
];
3145 playlist
= ¤t_playlist
;
3147 if (check_control(playlist
) < 0)
3149 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3153 if (index
== new_index
)
3156 if (index
== playlist
->index
)
3157 /* Moving the current track */
3160 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3161 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3162 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3164 if (get_filename(playlist
, index
, seek
, control_file
, filename
,
3165 sizeof(filename
)) < 0)
3168 /* We want to insert the track at the position that was specified by
3169 new_index. This may be different then new_index because of the
3170 shifting that will occur after the delete.
3171 We calculate this before we do the remove as it depends on the
3172 size of the playlist before the track removal */
3173 r
= rotate_index(playlist
, new_index
);
3175 /* Delete track from original position */
3176 result
= remove_track_from_playlist(playlist
, index
, true);
3182 new_index
= PLAYLIST_PREPEND
;
3183 else if (r
== playlist
->amount
)
3185 new_index
= PLAYLIST_INSERT_LAST
;
3187 /* Calculate index of desired position */
3188 new_index
= (r
+playlist
->first_index
)%playlist
->amount
;
3190 result
= add_track_to_playlist(playlist
, filename
, new_index
, queue
,
3197 /* Moved the current track */
3200 case PLAYLIST_PREPEND
:
3201 playlist
->index
= playlist
->first_index
;
3203 case PLAYLIST_INSERT_LAST
:
3204 playlist
->index
= playlist
->first_index
- 1;
3205 if (playlist
->index
< 0)
3206 playlist
->index
+= playlist
->amount
;
3209 playlist
->index
= new_index
;
3214 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3215 audio_flush_and_reload_tracks();
3219 #ifdef HAVE_DIRCACHE
3220 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3226 /* shuffle currently playing playlist */
3227 int playlist_randomise(struct playlist_info
* playlist
, unsigned int seed
,
3233 playlist
= ¤t_playlist
;
3235 check_control(playlist
);
3237 result
= randomise_playlist(playlist
, seed
, start_current
, true);
3239 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3241 audio_flush_and_reload_tracks();
3246 /* sort currently playing playlist */
3247 int playlist_sort(struct playlist_info
* playlist
, bool start_current
)
3252 playlist
= ¤t_playlist
;
3254 check_control(playlist
);
3256 result
= sort_playlist(playlist
, start_current
, true);
3258 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3260 audio_flush_and_reload_tracks();
3265 /* returns true if playlist has been modified */
3266 bool playlist_modified(const struct playlist_info
* playlist
)
3269 playlist
= ¤t_playlist
;
3271 if (playlist
->shuffle_modified
||
3272 playlist
->deleted
||
3273 playlist
->num_inserted_tracks
> 0)
3279 /* returns index of first track in playlist */
3280 int playlist_get_first_index(const struct playlist_info
* playlist
)
3283 playlist
= ¤t_playlist
;
3285 return playlist
->first_index
;
3288 /* returns shuffle seed of playlist */
3289 int playlist_get_seed(const struct playlist_info
* playlist
)
3292 playlist
= ¤t_playlist
;
3294 return playlist
->seed
;
3297 /* returns number of tracks in playlist (includes queued/inserted tracks) */
3298 int playlist_amount_ex(const struct playlist_info
* playlist
)
3301 playlist
= ¤t_playlist
;
3303 return playlist
->amount
;
3306 /* returns full path of playlist (minus extension) */
3307 char *playlist_name(const struct playlist_info
* playlist
, char *buf
,
3313 playlist
= ¤t_playlist
;
3315 strlcpy(buf
, playlist
->filename
+playlist
->dirlen
, buf_size
);
3320 /* Remove extension */
3321 sep
= strrchr(buf
, '.');
3328 /* returns the playlist filename */
3329 char *playlist_get_name(const struct playlist_info
* playlist
, char *buf
,
3333 playlist
= ¤t_playlist
;
3335 strlcpy(buf
, playlist
->filename
, buf_size
);
3343 /* Fills info structure with information about track at specified index.
3344 Returns 0 on success and -1 on failure */
3345 int playlist_get_track_info(struct playlist_info
* playlist
, int index
,
3346 struct playlist_track_info
* info
)
3352 playlist
= ¤t_playlist
;
3354 if (index
< 0 || index
>= playlist
->amount
)
3357 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3358 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3360 if (get_filename(playlist
, index
, seek
, control_file
, info
->filename
,
3361 sizeof(info
->filename
)) < 0)
3368 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
3369 info
->attr
|= PLAYLIST_ATTR_QUEUED
;
3371 info
->attr
|= PLAYLIST_ATTR_INSERTED
;
3375 if (playlist
->indices
[index
] & PLAYLIST_SKIPPED
)
3376 info
->attr
|= PLAYLIST_ATTR_SKIPPED
;
3378 info
->index
= index
;
3379 info
->display_index
= rotate_index(playlist
, index
) + 1;
3384 /* save the current dynamic playlist to specified file */
3385 int playlist_save(struct playlist_info
* playlist
, char *filename
)
3390 char path
[MAX_PATH
+1];
3391 char tmp_buf
[MAX_PATH
+1];
3393 bool overwrite_current
= false;
3394 int old_handle
= -1;
3395 char* old_buffer
= NULL
;
3396 size_t old_buffer_size
= 0;
3399 playlist
= ¤t_playlist
;
3401 if (playlist
->amount
<= 0)
3404 /* use current working directory as base for pathname */
3405 if (format_track_path(path
, filename
, sizeof(tmp_buf
),
3406 strlen(filename
)+1, getcwd(NULL
, -1)) < 0)
3409 if (!strncmp(playlist
->filename
, path
, strlen(path
)))
3411 /* Attempting to overwrite current playlist file.*/
3413 if (playlist
->buffer_size
< (int)(playlist
->amount
* sizeof(int)))
3415 /* not enough buffer space to store updated indices */
3416 /* Try to get a buffer */
3417 old_handle
= playlist
->buffer_handle
;
3418 /* can ignore volatile here, because core_get_data() is called later */
3419 old_buffer
= (char*)playlist
->buffer
;
3420 old_buffer_size
= playlist
->buffer_size
;
3421 playlist
->buffer
= plugin_get_buffer((size_t*)&playlist
->buffer_size
);
3422 if (playlist
->buffer_size
< (int)(playlist
->amount
* sizeof(int)))
3424 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3426 goto reset_old_buffer
;
3430 /* use temporary pathname */
3431 snprintf(path
, sizeof(path
), "%s_temp", playlist
->filename
);
3432 overwrite_current
= true;
3437 fd
= open_utf8(path
, O_CREAT
|O_WRONLY
|O_TRUNC
);
3441 /* some applications require a BOM to read the file properly */
3442 fd
= open(path
, O_CREAT
|O_WRONLY
|O_TRUNC
, 0666);
3446 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3448 goto reset_old_buffer
;
3451 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
), false);
3455 index
= playlist
->first_index
;
3456 for (i
=0; i
<playlist
->amount
; i
++)
3463 if (action_userabort(TIMEOUT_NOBLOCK
))
3469 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3470 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3471 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3473 /* Don't save queued files */
3476 if (get_filename(playlist
, index
, seek
, control_file
, tmp_buf
,
3483 if (overwrite_current
)
3484 playlist
->seek_buf
[count
] = lseek(fd
, 0, SEEK_CUR
);
3486 if (fdprintf(fd
, "%s\n", tmp_buf
) < 0)
3488 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3495 if ((count
% PLAYLIST_DISPLAY_COUNT
) == 0)
3496 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
),
3502 index
= (index
+1)%playlist
->amount
;
3505 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
), true);
3509 if (overwrite_current
&& result
>= 0)
3513 mutex_lock(playlist
->control_mutex
);
3515 /* Replace the current playlist with the new one and update indices */
3516 close(playlist
->fd
);
3517 if (remove(playlist
->filename
) >= 0)
3519 if (rename(path
, playlist
->filename
) >= 0)
3521 playlist
->fd
= open_utf8(playlist
->filename
, O_RDONLY
);
3522 if (playlist
->fd
>= 0)
3524 index
= playlist
->first_index
;
3525 for (i
=0, count
=0; i
<playlist
->amount
; i
++)
3527 if (!(playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
))
3529 playlist
->indices
[index
] = playlist
->seek_buf
[count
];
3532 index
= (index
+1)%playlist
->amount
;
3535 /* we need to recreate control because inserted tracks are
3536 now part of the playlist and shuffle has been
3538 result
= recreate_control(playlist
);
3543 mutex_unlock(playlist
->control_mutex
);
3551 old_buffer
= core_get_data(old_handle
);
3552 playlist
->buffer
= old_buffer
;
3553 playlist
->buffer_size
= old_buffer_size
;
3559 * Search specified directory for tracks and notify via callback. May be
3560 * called recursively.
3562 int playlist_directory_tracksearch(const char* dirname
, bool recurse
,
3563 int (*callback
)(char*, void*),
3566 char buf
[MAX_PATH
+1];
3570 struct tree_context
* tc
= tree_get_context();
3571 struct tree_cache
* cache
= &tc
->cache
;
3572 int old_dirfilter
= *(tc
->dirfilter
);
3577 /* use the tree browser dircache to load files */
3578 *(tc
->dirfilter
) = SHOW_ALL
;
3580 if (ft_load(tc
, dirname
) < 0)
3582 splash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
3583 *(tc
->dirfilter
) = old_dirfilter
;
3587 num_files
= tc
->filesindir
;
3589 /* we've overwritten the dircache so tree browser will need to be
3593 for (i
=0; i
<num_files
; i
++)
3596 if (action_userabort(TIMEOUT_NOBLOCK
))
3602 struct entry
*files
= core_get_data(cache
->entries_handle
);
3603 if (files
[i
].attr
& ATTR_DIRECTORY
)
3607 /* recursively add directories */
3608 snprintf(buf
, sizeof(buf
), "%s/%s",
3609 dirname
[1]? dirname
: "", files
[i
].name
);
3610 result
= playlist_directory_tracksearch(buf
, recurse
,
3615 /* we now need to reload our current directory */
3616 if(ft_load(tc
, dirname
) < 0)
3622 num_files
= tc
->filesindir
;
3632 else if ((files
[i
].attr
& FILE_ATTR_MASK
) == FILE_ATTR_AUDIO
)
3634 snprintf(buf
, sizeof(buf
), "%s/%s",
3635 dirname
[1]? dirname
: "", files
[i
].name
);
3637 if (callback(buf
, context
) != 0)
3643 /* let the other threads work */
3648 /* restore dirfilter */
3649 *(tc
->dirfilter
) = old_dirfilter
;