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 #if CONFIG_CODEC == SWCODEC
1072 /* Marks the index of the track to be skipped that is "steps" away from
1073 * current playing track.
1075 void playlist_skip_entry(struct playlist_info
*playlist
, int steps
)
1079 if (playlist
== NULL
)
1080 playlist
= ¤t_playlist
;
1082 /* need to account for already skipped tracks */
1083 steps
= calculate_step_count(playlist
, steps
);
1085 index
= playlist
->index
+ steps
;
1087 index
+= playlist
->amount
;
1088 else if (index
>= playlist
->amount
)
1089 index
-= playlist
->amount
;
1091 playlist
->indices
[index
] |= PLAYLIST_SKIPPED
;
1093 #endif /* CONFIG_CODEC == SWCODEC */
1096 * returns the index of the track that is "steps" away from current playing
1099 static int get_next_index(const struct playlist_info
* playlist
, int steps
,
1102 int current_index
= playlist
->index
;
1103 int next_index
= -1;
1105 if (playlist
->amount
<= 0)
1108 if (repeat_mode
== -1)
1109 repeat_mode
= global_settings
.repeat_mode
;
1111 if (repeat_mode
== REPEAT_SHUFFLE
&& playlist
->amount
<= 1)
1112 repeat_mode
= REPEAT_ALL
;
1114 steps
= calculate_step_count(playlist
, steps
);
1115 switch (repeat_mode
)
1117 case REPEAT_SHUFFLE
:
1118 /* Treat repeat shuffle just like repeat off. At end of playlist,
1119 play will be resumed in playlist_next() */
1122 current_index
= rotate_index(playlist
, current_index
);
1123 next_index
= current_index
+steps
;
1124 if ((next_index
< 0) || (next_index
>= playlist
->amount
))
1127 next_index
= (next_index
+playlist
->first_index
) %
1134 #ifdef AB_REPEAT_ENABLE
1137 next_index
= current_index
;
1143 next_index
= (current_index
+steps
) % playlist
->amount
;
1144 while (next_index
< 0)
1145 next_index
+= playlist
->amount
;
1147 if (steps
>= playlist
->amount
)
1154 /* second time around so skip the queued files */
1155 for (i
=0; i
<playlist
->amount
; i
++)
1157 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
1158 index
= (index
+1) % playlist
->amount
;
1170 /* No luck if the whole playlist was bad. */
1171 if (playlist
->indices
[next_index
] & PLAYLIST_SKIPPED
)
1178 * Search for the seek track and set appropriate indices. Used after shuffle
1179 * to make sure the current index is still pointing to correct track.
1181 static void find_and_set_playlist_index(struct playlist_info
* playlist
,
1186 /* Set the index to the current song */
1187 for (i
=0; i
<playlist
->amount
; i
++)
1189 if (playlist
->indices
[i
] == seek
)
1191 playlist
->index
= playlist
->first_index
= i
;
1199 * used to sort track indices. Sort order is as follows:
1200 * 1. Prepended tracks (in prepend order)
1201 * 2. Playlist/directory tracks (in playlist order)
1202 * 3. Inserted/Appended tracks (in insert order)
1204 static int compare(const void* p1
, const void* p2
)
1206 unsigned long* e1
= (unsigned long*) p1
;
1207 unsigned long* e2
= (unsigned long*) p2
;
1208 unsigned long flags1
= *e1
& PLAYLIST_INSERT_TYPE_MASK
;
1209 unsigned long flags2
= *e2
& PLAYLIST_INSERT_TYPE_MASK
;
1211 if (flags1
== flags2
)
1212 return (*e1
& PLAYLIST_SEEK_MASK
) - (*e2
& PLAYLIST_SEEK_MASK
);
1213 else if (flags1
== PLAYLIST_INSERT_TYPE_PREPEND
||
1214 flags2
== PLAYLIST_INSERT_TYPE_APPEND
)
1216 else if (flags1
== PLAYLIST_INSERT_TYPE_APPEND
||
1217 flags2
== PLAYLIST_INSERT_TYPE_PREPEND
)
1219 else if (flags1
&& flags2
)
1220 return (*e1
& PLAYLIST_SEEK_MASK
) - (*e2
& PLAYLIST_SEEK_MASK
);
1225 #ifdef HAVE_DIRCACHE
1227 * Thread to update filename pointers to dircache on background
1228 * without affecting playlist load up performance. This thread also flushes
1229 * any pending control commands when the disk spins up.
1231 static void playlist_flush_callback(void *param
)
1234 struct playlist_info
*playlist
;
1235 playlist
= ¤t_playlist
;
1236 if (playlist
->control_fd
>= 0)
1238 if (playlist
->num_cached
> 0)
1240 mutex_lock(playlist
->control_mutex
);
1241 flush_cached_control(playlist
);
1242 mutex_unlock(playlist
->control_mutex
);
1244 sync_control(playlist
, true);
1248 static bool is_dircache_pointers_intact(void)
1250 return dircache_get_appflag(DIRCACHE_APPFLAG_PLAYLIST
) ? true : false;
1253 static void playlist_thread(void)
1255 struct queue_event ev
;
1256 bool dirty_pointers
= false;
1257 static char tmp
[MAX_PATH
+1];
1259 struct playlist_info
*playlist
;
1266 #ifdef HAVE_DISK_STORAGE
1267 if (global_settings
.disk_spindown
> 1 &&
1268 global_settings
.disk_spindown
<= 5)
1269 sleep_time
= global_settings
.disk_spindown
- 1;
1274 queue_wait_w_tmo(&playlist_queue
, &ev
, HZ
*sleep_time
);
1278 case PLAYLIST_LOAD_POINTERS
:
1279 dirty_pointers
= true;
1282 /* Start the background scanning after either the disk spindown
1283 timeout or 5s, whichever is less */
1286 playlist
= ¤t_playlist
;
1287 if (playlist
->control_fd
>= 0)
1289 if (playlist
->num_cached
> 0)
1290 register_storage_idle_func(playlist_flush_callback
);
1293 if (!dircache_is_enabled() || !playlist
->filenames
1294 || playlist
->amount
<= 0)
1299 /* Check if previously loaded pointers are intact. */
1300 if (is_dircache_pointers_intact() && !dirty_pointers
)
1303 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1306 for (index
= 0; index
< playlist
->amount
1307 && queue_empty(&playlist_queue
); index
++)
1309 /* Process only pointers that are not already loaded. */
1310 if (is_dircache_pointers_intact() && playlist
->filenames
[index
] >= 0)
1313 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
1314 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
1316 /* Load the filename from playlist file. */
1317 if (get_filename(playlist
, index
, seek
, control_file
, tmp
,
1323 /* Set the dircache entry pointer. */
1324 playlist
->filenames
[index
] = dircache_get_entry_id(tmp
);
1326 /* And be on background so user doesn't notice any delays. */
1330 if (dircache_is_enabled())
1331 dircache_set_appflag(DIRCACHE_APPFLAG_PLAYLIST
);
1333 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1336 if (index
== playlist
->amount
)
1337 dirty_pointers
= false;
1342 case SYS_USB_CONNECTED
:
1343 usb_acknowledge(SYS_USB_CONNECTED_ACK
);
1344 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
;
1455 struct tree_context
* tc
= tree_get_context();
1456 int saved_dirfilter
= *(tc
->dirfilter
);
1458 /* process random folder advance */
1459 if (global_settings
.next_folder
== FOLDER_ADVANCE_RANDOM
)
1461 int fd
= open(ROCKBOX_DIR
"/folder_advance_list.dat", O_RDONLY
);
1464 char buffer
[MAX_PATH
];
1465 int folder_count
= 0;
1466 srand(current_tick
);
1467 *(tc
->dirfilter
) = SHOW_MUSIC
;
1468 tc
->sort_dir
= global_settings
.sort_dir
;
1469 read(fd
,&folder_count
,sizeof(int));
1474 int i
= rand()%folder_count
;
1475 lseek(fd
,sizeof(int) + (MAX_PATH
*i
),SEEK_SET
);
1476 read(fd
,buffer
,MAX_PATH
);
1477 if (check_subdir_for_music(buffer
, "", false) ==0)
1483 *(tc
->dirfilter
) = saved_dirfilter
;
1484 tc
->sort_dir
= global_settings
.sort_dir
;
1490 /* not random folder advance (or random folder advance unavailable) */
1493 /* start with root */
1498 /* start with current directory */
1499 strlcpy(dir
, playlist
->filename
, playlist
->dirlen
);
1502 /* use the tree browser dircache to load files */
1503 *(tc
->dirfilter
) = SHOW_ALL
;
1505 /* set up sorting/direction */
1506 tc
->sort_dir
= global_settings
.sort_dir
;
1509 static const char sortpairs
[] =
1511 [SORT_ALPHA
] = SORT_ALPHA_REVERSED
,
1512 [SORT_DATE
] = SORT_DATE_REVERSED
,
1513 [SORT_TYPE
] = SORT_TYPE_REVERSED
,
1514 [SORT_ALPHA_REVERSED
] = SORT_ALPHA
,
1515 [SORT_DATE_REVERSED
] = SORT_DATE
,
1516 [SORT_TYPE_REVERSED
] = SORT_TYPE
,
1519 if ((unsigned)tc
->sort_dir
< sizeof(sortpairs
))
1520 tc
->sort_dir
= sortpairs
[tc
->sort_dir
];
1525 struct entry
*files
;
1529 if (ft_load(tc
, (dir
[0]=='\0')?"/":dir
) < 0)
1536 files
= tree_get_entries(tc
);
1537 num_files
= tc
->filesindir
;
1539 tree_lock_cache(tc
);
1540 for (i
=0; i
<num_files
; i
++)
1543 if (action_userabort(TIMEOUT_NOBLOCK
))
1550 if (files
[i
].attr
& ATTR_DIRECTORY
)
1554 result
= check_subdir_for_music(dir
, files
[i
].name
, true);
1561 else if (!strcmp(start_dir
, files
[i
].name
))
1565 tree_unlock_cache(tc
);
1569 /* move down to parent directory. current directory name is
1570 stored as the starting point for the search in parent */
1571 start_dir
= strrchr(dir
, '/');
1582 /* restore dirfilter */
1583 *(tc
->dirfilter
) = saved_dirfilter
;
1584 tc
->sort_dir
= global_settings
.sort_dir
;
1586 /* special case if nothing found: try start searching again from root */
1587 if (result
== -1 && !recursion
){
1588 result
= get_next_dir(dir
, is_forward
, true);
1595 * Checks if there are any music files in the dir or any of its
1596 * subdirectories. May be called recursively.
1598 static int check_subdir_for_music(char *dir
, const char *subdir
, bool recurse
)
1601 int dirlen
= strlen(dir
);
1604 struct entry
*files
;
1605 bool has_music
= false;
1606 bool has_subdir
= false;
1607 struct tree_context
* tc
= tree_get_context();
1609 snprintf(dir
+dirlen
, MAX_PATH
-dirlen
, "/%s", subdir
);
1611 if (ft_load(tc
, dir
) < 0)
1616 files
= tree_get_entries(tc
);
1617 num_files
= tc
->filesindir
;
1619 for (i
=0; i
<num_files
; i
++)
1621 if (files
[i
].attr
& ATTR_DIRECTORY
)
1623 else if ((files
[i
].attr
& FILE_ATTR_MASK
) == FILE_ATTR_AUDIO
)
1633 tree_lock_cache(tc
);
1634 if (has_subdir
&& recurse
)
1636 for (i
=0; i
<num_files
; i
++)
1638 if (action_userabort(TIMEOUT_NOBLOCK
))
1644 if (files
[i
].attr
& ATTR_DIRECTORY
)
1646 result
= check_subdir_for_music(dir
, files
[i
].name
, true);
1652 tree_unlock_cache(tc
);
1665 /* we now need to reload our current directory */
1666 if(ft_load(tc
, dir
) < 0)
1667 splash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
1673 * Returns absolute path of track
1675 static int format_track_path(char *dest
, char *src
, int buf_length
, int max
,
1682 /* Look for the end of the string */
1689 /* Now work back killing white space */
1691 ((src
[i
-1] == ' ') ||
1692 (src
[i
-1] == '\t')))
1695 /* Zero-terminate the file name */
1698 /* replace backslashes with forward slashes */
1699 for ( j
=0; j
<i
; j
++ )
1700 if ( src
[j
] == '\\' )
1705 strlcpy(dest
, src
, buf_length
);
1709 /* handle dos style drive letter */
1711 strlcpy(dest
, &src
[2], buf_length
);
1712 else if (!strncmp(src
, "../", 3))
1714 /* handle relative paths */
1716 while(!strncmp(&src
[i
], "../", 3))
1718 for (j
=0; j
<i
/3; j
++) {
1719 temp_ptr
= strrchr(dir
, '/');
1725 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[i
]);
1727 else if ( '.' == src
[0] && '/' == src
[1] ) {
1728 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[2]);
1731 snprintf(dest
, buf_length
, "%s/%s", dir
, src
);
1739 * Display splash message showing progress of playlist/directory insertion or
1742 static void display_playlist_count(int count
, const unsigned char *fmt
,
1745 static long talked_tick
= 0;
1746 long id
= P2ID(fmt
);
1747 if(global_settings
.talk_menu
&& id
>=0)
1749 if(final
|| (count
&& (talked_tick
== 0
1750 || TIME_AFTER(current_tick
, talked_tick
+5*HZ
))))
1752 talked_tick
= current_tick
;
1753 talk_number(count
, false);
1759 splashf(0, fmt
, count
, str(LANG_OFF_ABORT
));
1763 * Display buffer full message
1765 static void display_buffer_full(void)
1767 splash(HZ
*2, ID2P(LANG_PLAYLIST_BUFFER_FULL
));
1771 * Flush any cached control commands to disk. Called when playlist is being
1772 * modified. Returns 0 on success and -1 on failure.
1774 static int flush_cached_control(struct playlist_info
* playlist
)
1779 if (!playlist
->num_cached
)
1782 lseek(playlist
->control_fd
, 0, SEEK_END
);
1784 for (i
=0; i
<playlist
->num_cached
; i
++)
1786 struct playlist_control_cache
* cache
=
1787 &(playlist
->control_cache
[i
]);
1789 switch (cache
->command
)
1791 case PLAYLIST_COMMAND_PLAYLIST
:
1792 result
= fdprintf(playlist
->control_fd
, "P:%d:%s:%s\n",
1793 cache
->i1
, cache
->s1
, cache
->s2
);
1795 case PLAYLIST_COMMAND_ADD
:
1796 case PLAYLIST_COMMAND_QUEUE
:
1797 result
= fdprintf(playlist
->control_fd
, "%c:%d:%d:",
1798 (cache
->command
== PLAYLIST_COMMAND_ADD
)?'A':'Q',
1799 cache
->i1
, cache
->i2
);
1802 /* save the position in file where name is written */
1803 int* seek_pos
= (int *)cache
->data
;
1804 *seek_pos
= lseek(playlist
->control_fd
, 0, SEEK_CUR
);
1805 result
= fdprintf(playlist
->control_fd
, "%s\n",
1809 case PLAYLIST_COMMAND_DELETE
:
1810 result
= fdprintf(playlist
->control_fd
, "D:%d\n", cache
->i1
);
1812 case PLAYLIST_COMMAND_SHUFFLE
:
1813 result
= fdprintf(playlist
->control_fd
, "S:%d:%d\n",
1814 cache
->i1
, cache
->i2
);
1816 case PLAYLIST_COMMAND_UNSHUFFLE
:
1817 result
= fdprintf(playlist
->control_fd
, "U:%d\n", cache
->i1
);
1819 case PLAYLIST_COMMAND_RESET
:
1820 result
= fdprintf(playlist
->control_fd
, "R\n");
1832 playlist
->num_cached
= 0;
1833 playlist
->pending_control_sync
= true;
1840 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_UPDATE_ERROR
));
1847 * Update control data with new command. Depending on the command, it may be
1848 * cached or flushed to disk.
1850 static int update_control(struct playlist_info
* playlist
,
1851 enum playlist_command command
, int i1
, int i2
,
1852 const char* s1
, const char* s2
, void* data
)
1855 struct playlist_control_cache
* cache
;
1858 mutex_lock(playlist
->control_mutex
);
1860 cache
= &(playlist
->control_cache
[playlist
->num_cached
++]);
1862 cache
->command
= command
;
1871 case PLAYLIST_COMMAND_PLAYLIST
:
1872 case PLAYLIST_COMMAND_ADD
:
1873 case PLAYLIST_COMMAND_QUEUE
:
1874 #ifndef HAVE_DIRCACHE
1875 case PLAYLIST_COMMAND_DELETE
:
1876 case PLAYLIST_COMMAND_RESET
:
1880 case PLAYLIST_COMMAND_SHUFFLE
:
1881 case PLAYLIST_COMMAND_UNSHUFFLE
:
1883 /* only flush when needed */
1887 if (flush
|| playlist
->num_cached
== PLAYLIST_MAX_CACHE
)
1888 result
= flush_cached_control(playlist
);
1890 mutex_unlock(playlist
->control_mutex
);
1896 * sync control file to disk
1898 static void sync_control(struct playlist_info
* playlist
, bool force
)
1900 #ifdef HAVE_DIRCACHE
1901 if (playlist
->started
&& force
)
1905 if (playlist
->started
)
1908 if (playlist
->pending_control_sync
)
1910 mutex_lock(playlist
->control_mutex
);
1911 fsync(playlist
->control_fd
);
1912 playlist
->pending_control_sync
= false;
1913 mutex_unlock(playlist
->control_mutex
);
1919 * Rotate indices such that first_index is index 0
1921 static int rotate_index(const struct playlist_info
* playlist
, int index
)
1923 index
-= playlist
->first_index
;
1925 index
+= playlist
->amount
;
1931 * Need no movement protection since all 3 allocations are not passed to
1932 * other functions which can yield().
1934 static int move_callback(int handle
, void* current
, void* new)
1937 struct playlist_info
* playlist
= ¤t_playlist
;
1938 if (current
== playlist
->indices
)
1939 playlist
->indices
= new;
1940 else if (current
== playlist
->filenames
)
1941 playlist
->filenames
= new;
1942 /* buffer can possibly point to a new buffer temporarily (playlist_save()).
1943 * just don't overwrite the pointer to that temp buffer */
1944 else if (current
== playlist
->buffer
)
1945 playlist
->buffer
= new;
1947 return BUFLIB_CB_OK
;
1951 static struct buflib_callbacks ops
= {
1952 .move_callback
= move_callback
,
1953 .shrink_callback
= NULL
,
1956 * Initialize playlist entries at startup
1958 void playlist_init(void)
1961 struct playlist_info
* playlist
= ¤t_playlist
;
1963 mutex_init(¤t_playlist_mutex
);
1964 mutex_init(&created_playlist_mutex
);
1966 playlist
->current
= true;
1967 strlcpy(playlist
->control_filename
, PLAYLIST_CONTROL_FILE
,
1968 sizeof(playlist
->control_filename
));
1970 playlist
->control_fd
= -1;
1971 playlist
->max_playlist_size
= global_settings
.max_files_in_playlist
;
1972 handle
= core_alloc_ex("playlist idx",
1973 playlist
->max_playlist_size
* sizeof(int), &ops
);
1974 playlist
->indices
= core_get_data(handle
);
1975 playlist
->buffer_size
=
1976 AVERAGE_FILENAME_LENGTH
* global_settings
.max_files_in_dir
;
1977 handle
= core_alloc_ex("playlist buf",
1978 playlist
->buffer_size
, &ops
);
1979 playlist
->buffer
= core_get_data(handle
);
1980 playlist
->buffer_handle
= 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 #if CONFIG_CODEC == SWCODEC
2645 /* try playing next or previous folder */
2646 bool playlist_next_dir(int direction
)
2648 /* not to mess up real playlists */
2649 if(!current_playlist
.in_ram
)
2652 return create_and_play_dir(direction
, false) >= 0;
2654 #endif /* CONFIG_CODEC == SWCODEC */
2656 /* Get resume info for current playing song. If return value is -1 then
2657 settings shouldn't be saved. */
2658 int playlist_get_resume_info(int *resume_index
)
2660 struct playlist_info
* playlist
= ¤t_playlist
;
2662 *resume_index
= playlist
->index
;
2667 /* Update resume info for current playing song. Returns -1 on error. */
2668 int playlist_update_resume_info(const struct mp3entry
* id3
)
2670 struct playlist_info
* playlist
= ¤t_playlist
;
2674 if (global_status
.resume_index
!= playlist
->index
||
2675 global_status
.resume_offset
!= id3
->offset
)
2677 global_status
.resume_index
= playlist
->index
;
2678 global_status
.resume_offset
= id3
->offset
;
2684 global_status
.resume_index
= -1;
2685 global_status
.resume_offset
= -1;
2692 /* Returns index of current playing track for display purposes. This value
2693 should not be used for resume purposes as it doesn't represent the actual
2694 index into the playlist */
2695 int playlist_get_display_index(void)
2697 struct playlist_info
* playlist
= ¤t_playlist
;
2699 /* first_index should always be index 0 for display purposes */
2700 int index
= rotate_index(playlist
, playlist
->index
);
2705 /* returns number of tracks in current playlist */
2706 int playlist_amount(void)
2708 return playlist_amount_ex(NULL
);
2710 /* set playlist->last_shuffle_start to playlist->amount for
2711 PLAYLIST_INSERT_LAST_SHUFFLED command purposes*/
2712 void playlist_set_last_shuffled_start(void)
2714 struct playlist_info
* playlist
= ¤t_playlist
;
2715 playlist
->last_shuffled_start
= playlist
->amount
;
2718 * Create a new playlist If playlist is not NULL then we're loading a
2719 * playlist off disk for viewing/editing. The index_buffer is used to store
2720 * playlist indices (required for and only used if !current playlist). The
2721 * temp_buffer (if not NULL) is used as a scratchpad when loading indices.
2723 int playlist_create_ex(struct playlist_info
* playlist
,
2724 const char* dir
, const char* file
,
2725 void* index_buffer
, int index_buffer_size
,
2726 void* temp_buffer
, int temp_buffer_size
)
2729 playlist
= ¤t_playlist
;
2732 /* Initialize playlist structure */
2733 int r
= rand() % 10;
2734 playlist
->current
= false;
2736 /* Use random name for control file */
2737 snprintf(playlist
->control_filename
, sizeof(playlist
->control_filename
),
2738 "%s.%d", PLAYLIST_CONTROL_FILE
, r
);
2740 playlist
->control_fd
= -1;
2744 int num_indices
= index_buffer_size
/ sizeof(int);
2746 #ifdef HAVE_DIRCACHE
2749 if (num_indices
> global_settings
.max_files_in_playlist
)
2750 num_indices
= global_settings
.max_files_in_playlist
;
2752 playlist
->max_playlist_size
= num_indices
;
2753 playlist
->indices
= index_buffer
;
2754 #ifdef HAVE_DIRCACHE
2755 playlist
->filenames
= (int*)&playlist
->indices
[num_indices
];
2760 playlist
->max_playlist_size
= current_playlist
.max_playlist_size
;
2761 playlist
->indices
= current_playlist
.indices
;
2762 #ifdef HAVE_DIRCACHE
2763 playlist
->filenames
= current_playlist
.filenames
;
2767 playlist
->buffer_size
= 0;
2768 playlist
->buffer_handle
= -1;
2769 playlist
->buffer
= NULL
;
2770 playlist
->control_mutex
= &created_playlist_mutex
;
2773 new_playlist(playlist
, dir
, file
);
2776 /* load the playlist file */
2777 add_indices_to_playlist(playlist
, temp_buffer
, temp_buffer_size
);
2783 * Set the specified playlist as the current.
2784 * NOTE: You will get undefined behaviour if something is already playing so
2785 * remember to stop before calling this. Also, this call will
2786 * effectively close your playlist, making it unusable.
2788 int playlist_set_current(struct playlist_info
* playlist
)
2790 if (!playlist
|| (check_control(playlist
) < 0))
2793 empty_playlist(¤t_playlist
, false);
2795 strlcpy(current_playlist
.filename
, playlist
->filename
,
2796 sizeof(current_playlist
.filename
));
2798 current_playlist
.utf8
= playlist
->utf8
;
2799 current_playlist
.fd
= playlist
->fd
;
2801 close(playlist
->control_fd
);
2802 close(current_playlist
.control_fd
);
2803 remove(current_playlist
.control_filename
);
2804 if (rename(playlist
->control_filename
,
2805 current_playlist
.control_filename
) < 0)
2807 current_playlist
.control_fd
= open(current_playlist
.control_filename
,
2809 if (current_playlist
.control_fd
< 0)
2811 current_playlist
.control_created
= true;
2813 current_playlist
.dirlen
= playlist
->dirlen
;
2815 if (playlist
->indices
&& playlist
->indices
!= current_playlist
.indices
)
2817 memcpy((void*)current_playlist
.indices
, (void*)playlist
->indices
,
2818 playlist
->max_playlist_size
*sizeof(int));
2819 #ifdef HAVE_DIRCACHE
2820 memcpy((void*)current_playlist
.filenames
, (void*)playlist
->filenames
,
2821 playlist
->max_playlist_size
*sizeof(int));
2825 current_playlist
.first_index
= playlist
->first_index
;
2826 current_playlist
.amount
= playlist
->amount
;
2827 current_playlist
.last_insert_pos
= playlist
->last_insert_pos
;
2828 current_playlist
.seed
= playlist
->seed
;
2829 current_playlist
.shuffle_modified
= playlist
->shuffle_modified
;
2830 current_playlist
.deleted
= playlist
->deleted
;
2831 current_playlist
.num_inserted_tracks
= playlist
->num_inserted_tracks
;
2833 memcpy(current_playlist
.control_cache
, playlist
->control_cache
,
2834 sizeof(current_playlist
.control_cache
));
2835 current_playlist
.num_cached
= playlist
->num_cached
;
2836 current_playlist
.pending_control_sync
= playlist
->pending_control_sync
;
2840 struct playlist_info
*playlist_get_current(void)
2842 return ¤t_playlist
;
2845 * Close files and delete control file for non-current playlist.
2847 void playlist_close(struct playlist_info
* playlist
)
2852 if (playlist
->fd
>= 0)
2853 close(playlist
->fd
);
2855 if (playlist
->control_fd
>= 0)
2856 close(playlist
->control_fd
);
2858 if (playlist
->control_created
)
2859 remove(playlist
->control_filename
);
2862 void playlist_sync(struct playlist_info
* playlist
)
2865 playlist
= ¤t_playlist
;
2867 sync_control(playlist
, false);
2868 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2869 audio_flush_and_reload_tracks();
2871 #ifdef HAVE_DIRCACHE
2872 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2877 * Insert track into playlist at specified position (or one of the special
2878 * positions). Returns position where track was inserted or -1 if error.
2880 int playlist_insert_track(struct playlist_info
* playlist
, const char *filename
,
2881 int position
, bool queue
, bool sync
)
2886 playlist
= ¤t_playlist
;
2888 if (check_control(playlist
) < 0)
2890 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2894 result
= add_track_to_playlist(playlist
, filename
, position
, queue
, -1);
2896 /* Check if we want manually sync later. For example when adding
2897 * bunch of files from tagcache, syncing after every file wouldn't be
2898 * a good thing to do. */
2899 if (sync
&& result
>= 0)
2900 playlist_sync(playlist
);
2906 * Insert all tracks from specified directory into playlist.
2908 int playlist_insert_directory(struct playlist_info
* playlist
,
2909 const char *dirname
, int position
, bool queue
,
2913 unsigned char *count_str
;
2914 struct directory_search_context context
;
2917 playlist
= ¤t_playlist
;
2919 if (check_control(playlist
) < 0)
2921 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2925 if (position
== PLAYLIST_REPLACE
)
2927 if (playlist_remove_all_tracks(playlist
) == 0)
2928 position
= PLAYLIST_INSERT_LAST
;
2934 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
2936 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
2938 display_playlist_count(0, count_str
, false);
2940 context
.playlist
= playlist
;
2941 context
.position
= position
;
2942 context
.queue
= queue
;
2947 result
= playlist_directory_tracksearch(dirname
, recurse
,
2948 directory_search_callback
, &context
);
2950 sync_control(playlist
, false);
2954 display_playlist_count(context
.count
, count_str
, true);
2956 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2957 audio_flush_and_reload_tracks();
2959 #ifdef HAVE_DIRCACHE
2960 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2967 * Insert all tracks from specified playlist into dynamic playlist.
2969 int playlist_insert_playlist(struct playlist_info
* playlist
, const char *filename
,
2970 int position
, bool queue
)
2976 unsigned char *count_str
;
2977 char temp_buf
[MAX_PATH
+1];
2978 char trackname
[MAX_PATH
+1];
2981 bool utf8
= is_m3u8(filename
);
2984 playlist
= ¤t_playlist
;
2986 if (check_control(playlist
) < 0)
2988 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2992 fd
= open_utf8(filename
, O_RDONLY
);
2995 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
2999 /* we need the directory name for formatting purposes */
3002 temp_ptr
= strrchr(filename
+1,'/');
3009 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
3011 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
3013 display_playlist_count(count
, count_str
, false);
3015 if (position
== PLAYLIST_REPLACE
)
3017 if (playlist_remove_all_tracks(playlist
) == 0)
3018 position
= PLAYLIST_INSERT_LAST
;
3024 while ((max
= read_line(fd
, temp_buf
, sizeof(temp_buf
))) > 0)
3027 if (action_userabort(TIMEOUT_NOBLOCK
))
3030 if (temp_buf
[0] != '#' && temp_buf
[0] != '\0')
3036 /* Use trackname as a temporay buffer. Note that trackname must
3037 * be as large as temp_buf.
3039 max
= convert_m3u(temp_buf
, max
, sizeof(temp_buf
), trackname
);
3042 /* we need to format so that relative paths are correctly
3044 if (format_track_path(trackname
, temp_buf
, sizeof(trackname
), max
,
3051 insert_pos
= add_track_to_playlist(playlist
, trackname
, position
,
3060 /* Make sure tracks are inserted in correct order if user
3061 requests INSERT_FIRST */
3062 if (position
== PLAYLIST_INSERT_FIRST
|| position
>= 0)
3063 position
= insert_pos
+ 1;
3067 if ((count
%PLAYLIST_DISPLAY_COUNT
) == 0)
3069 display_playlist_count(count
, count_str
, false);
3071 if (count
== PLAYLIST_DISPLAY_COUNT
&&
3072 (audio_status() & AUDIO_STATUS_PLAY
) &&
3074 audio_flush_and_reload_tracks();
3078 /* let the other threads work */
3087 sync_control(playlist
, false);
3091 display_playlist_count(count
, count_str
, true);
3093 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3094 audio_flush_and_reload_tracks();
3096 #ifdef HAVE_DIRCACHE
3097 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3104 * Delete track at specified index. If index is PLAYLIST_DELETE_CURRENT then
3105 * we want to delete the current playing track.
3107 int playlist_delete(struct playlist_info
* playlist
, int index
)
3112 playlist
= ¤t_playlist
;
3114 if (check_control(playlist
) < 0)
3116 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3120 if (index
== PLAYLIST_DELETE_CURRENT
)
3121 index
= playlist
->index
;
3123 result
= remove_track_from_playlist(playlist
, index
, true);
3125 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3127 audio_flush_and_reload_tracks();
3133 * Move track at index to new_index. Tracks between the two are shifted
3134 * appropriately. Returns 0 on success and -1 on failure.
3136 int playlist_move(struct playlist_info
* playlist
, int index
, int new_index
)
3142 bool current
= false;
3144 char filename
[MAX_PATH
];
3147 playlist
= ¤t_playlist
;
3149 if (check_control(playlist
) < 0)
3151 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3155 if (index
== new_index
)
3158 if (index
== playlist
->index
)
3159 /* Moving the current track */
3162 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3163 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3164 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3166 if (get_filename(playlist
, index
, seek
, control_file
, filename
,
3167 sizeof(filename
)) < 0)
3170 /* We want to insert the track at the position that was specified by
3171 new_index. This may be different then new_index because of the
3172 shifting that will occur after the delete.
3173 We calculate this before we do the remove as it depends on the
3174 size of the playlist before the track removal */
3175 r
= rotate_index(playlist
, new_index
);
3177 /* Delete track from original position */
3178 result
= remove_track_from_playlist(playlist
, index
, true);
3184 new_index
= PLAYLIST_PREPEND
;
3185 else if (r
== playlist
->amount
)
3187 new_index
= PLAYLIST_INSERT_LAST
;
3189 /* Calculate index of desired position */
3190 new_index
= (r
+playlist
->first_index
)%playlist
->amount
;
3192 result
= add_track_to_playlist(playlist
, filename
, new_index
, queue
,
3199 /* Moved the current track */
3202 case PLAYLIST_PREPEND
:
3203 playlist
->index
= playlist
->first_index
;
3205 case PLAYLIST_INSERT_LAST
:
3206 playlist
->index
= playlist
->first_index
- 1;
3207 if (playlist
->index
< 0)
3208 playlist
->index
+= playlist
->amount
;
3211 playlist
->index
= new_index
;
3216 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3217 audio_flush_and_reload_tracks();
3221 #ifdef HAVE_DIRCACHE
3222 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3228 /* shuffle currently playing playlist */
3229 int playlist_randomise(struct playlist_info
* playlist
, unsigned int seed
,
3235 playlist
= ¤t_playlist
;
3237 check_control(playlist
);
3239 result
= randomise_playlist(playlist
, seed
, start_current
, true);
3241 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3243 audio_flush_and_reload_tracks();
3248 /* sort currently playing playlist */
3249 int playlist_sort(struct playlist_info
* playlist
, bool start_current
)
3254 playlist
= ¤t_playlist
;
3256 check_control(playlist
);
3258 result
= sort_playlist(playlist
, start_current
, true);
3260 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3262 audio_flush_and_reload_tracks();
3267 /* returns true if playlist has been modified */
3268 bool playlist_modified(const struct playlist_info
* playlist
)
3271 playlist
= ¤t_playlist
;
3273 if (playlist
->shuffle_modified
||
3274 playlist
->deleted
||
3275 playlist
->num_inserted_tracks
> 0)
3281 /* returns index of first track in playlist */
3282 int playlist_get_first_index(const struct playlist_info
* playlist
)
3285 playlist
= ¤t_playlist
;
3287 return playlist
->first_index
;
3290 /* returns shuffle seed of playlist */
3291 int playlist_get_seed(const struct playlist_info
* playlist
)
3294 playlist
= ¤t_playlist
;
3296 return playlist
->seed
;
3299 /* returns number of tracks in playlist (includes queued/inserted tracks) */
3300 int playlist_amount_ex(const struct playlist_info
* playlist
)
3303 playlist
= ¤t_playlist
;
3305 return playlist
->amount
;
3308 /* returns full path of playlist (minus extension) */
3309 char *playlist_name(const struct playlist_info
* playlist
, char *buf
,
3315 playlist
= ¤t_playlist
;
3317 strlcpy(buf
, playlist
->filename
+playlist
->dirlen
, buf_size
);
3322 /* Remove extension */
3323 sep
= strrchr(buf
, '.');
3330 /* returns the playlist filename */
3331 char *playlist_get_name(const struct playlist_info
* playlist
, char *buf
,
3335 playlist
= ¤t_playlist
;
3337 strlcpy(buf
, playlist
->filename
, buf_size
);
3345 /* Fills info structure with information about track at specified index.
3346 Returns 0 on success and -1 on failure */
3347 int playlist_get_track_info(struct playlist_info
* playlist
, int index
,
3348 struct playlist_track_info
* info
)
3354 playlist
= ¤t_playlist
;
3356 if (index
< 0 || index
>= playlist
->amount
)
3359 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3360 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3362 if (get_filename(playlist
, index
, seek
, control_file
, info
->filename
,
3363 sizeof(info
->filename
)) < 0)
3370 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
3371 info
->attr
|= PLAYLIST_ATTR_QUEUED
;
3373 info
->attr
|= PLAYLIST_ATTR_INSERTED
;
3377 if (playlist
->indices
[index
] & PLAYLIST_SKIPPED
)
3378 info
->attr
|= PLAYLIST_ATTR_SKIPPED
;
3380 info
->index
= index
;
3381 info
->display_index
= rotate_index(playlist
, index
) + 1;
3386 /* save the current dynamic playlist to specified file */
3387 int playlist_save(struct playlist_info
* playlist
, char *filename
)
3392 char path
[MAX_PATH
+1];
3393 char tmp_buf
[MAX_PATH
+1];
3395 bool overwrite_current
= false;
3398 playlist
= ¤t_playlist
;
3400 if (playlist
->amount
<= 0)
3403 /* use current working directory as base for pathname */
3404 if (format_track_path(path
, filename
, sizeof(tmp_buf
),
3405 strlen(filename
)+1, getcwd(NULL
, -1)) < 0)
3408 /* can ignore volatile here, because core_get_data() is called later */
3409 char* old_buffer
= (char*)playlist
->buffer
;
3410 size_t old_buffer_size
= playlist
->buffer_size
;
3412 if (!strncmp(playlist
->filename
, path
, strlen(path
)))
3414 /* Attempting to overwrite current playlist file.*/
3416 if (playlist
->buffer_size
< (int)(playlist
->amount
* sizeof(int)))
3418 /* not enough buffer space to store updated indices */
3419 /* Try to get a buffer */
3420 playlist
->buffer
= plugin_get_buffer((size_t*)&playlist
->buffer_size
);
3421 if (playlist
->buffer_size
< (int)(playlist
->amount
* sizeof(int)))
3423 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3425 goto reset_old_buffer
;
3429 /* use temporary pathname */
3430 snprintf(path
, sizeof(path
), "%s_temp", playlist
->filename
);
3431 overwrite_current
= true;
3436 fd
= open_utf8(path
, O_CREAT
|O_WRONLY
|O_TRUNC
);
3440 /* some applications require a BOM to read the file properly */
3441 fd
= open(path
, O_CREAT
|O_WRONLY
|O_TRUNC
, 0666);
3445 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3447 goto reset_old_buffer
;
3450 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
), false);
3454 index
= playlist
->first_index
;
3455 for (i
=0; i
<playlist
->amount
; i
++)
3462 if (action_userabort(TIMEOUT_NOBLOCK
))
3468 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3469 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3470 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3472 /* Don't save queued files */
3475 if (get_filename(playlist
, index
, seek
, control_file
, tmp_buf
,
3482 if (overwrite_current
)
3483 playlist
->seek_buf
[count
] = lseek(fd
, 0, SEEK_CUR
);
3485 if (fdprintf(fd
, "%s\n", tmp_buf
) < 0)
3487 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3494 if ((count
% PLAYLIST_DISPLAY_COUNT
) == 0)
3495 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
),
3501 index
= (index
+1)%playlist
->amount
;
3504 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
), true);
3508 if (overwrite_current
&& result
>= 0)
3512 mutex_lock(playlist
->control_mutex
);
3514 /* Replace the current playlist with the new one and update indices */
3515 close(playlist
->fd
);
3516 if (remove(playlist
->filename
) >= 0)
3518 if (rename(path
, playlist
->filename
) >= 0)
3520 playlist
->fd
= open_utf8(playlist
->filename
, O_RDONLY
);
3521 if (playlist
->fd
>= 0)
3523 index
= playlist
->first_index
;
3524 for (i
=0, count
=0; i
<playlist
->amount
; i
++)
3526 if (!(playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
))
3528 playlist
->indices
[index
] = playlist
->seek_buf
[count
];
3531 index
= (index
+1)%playlist
->amount
;
3534 /* we need to recreate control because inserted tracks are
3535 now part of the playlist and shuffle has been
3537 result
= recreate_control(playlist
);
3542 mutex_unlock(playlist
->control_mutex
);
3549 if (playlist
->buffer_handle
> 0)
3550 old_buffer
= core_get_data(playlist
->buffer_handle
);
3551 playlist
->buffer
= old_buffer
;
3552 playlist
->buffer_size
= old_buffer_size
;
3558 * Search specified directory for tracks and notify via callback. May be
3559 * called recursively.
3561 int playlist_directory_tracksearch(const char* dirname
, bool recurse
,
3562 int (*callback
)(char*, void*),
3565 char buf
[MAX_PATH
+1];
3569 struct tree_context
* tc
= tree_get_context();
3570 struct tree_cache
* cache
= &tc
->cache
;
3571 int old_dirfilter
= *(tc
->dirfilter
);
3576 /* use the tree browser dircache to load files */
3577 *(tc
->dirfilter
) = SHOW_ALL
;
3579 if (ft_load(tc
, dirname
) < 0)
3581 splash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
3582 *(tc
->dirfilter
) = old_dirfilter
;
3586 num_files
= tc
->filesindir
;
3588 /* we've overwritten the dircache so tree browser will need to be
3592 for (i
=0; i
<num_files
; i
++)
3595 if (action_userabort(TIMEOUT_NOBLOCK
))
3601 struct entry
*files
= core_get_data(cache
->entries_handle
);
3602 if (files
[i
].attr
& ATTR_DIRECTORY
)
3606 /* recursively add directories */
3607 snprintf(buf
, sizeof(buf
), "%s/%s",
3608 dirname
[1]? dirname
: "", files
[i
].name
);
3609 result
= playlist_directory_tracksearch(buf
, recurse
,
3614 /* we now need to reload our current directory */
3615 if(ft_load(tc
, dirname
) < 0)
3621 num_files
= tc
->filesindir
;
3631 else if ((files
[i
].attr
& FILE_ATTR_MASK
) == FILE_ATTR_AUDIO
)
3633 snprintf(buf
, sizeof(buf
), "%s/%s",
3634 dirname
[1]? dirname
: "", files
[i
].name
);
3636 if (callback(buf
, context
) != 0)
3642 /* let the other threads work */
3647 /* restore dirfilter */
3648 *(tc
->dirfilter
) = old_dirfilter
;