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
;
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
->control_mutex
= ¤t_playlist_mutex
;
1982 empty_playlist(playlist
, true);
1984 #ifdef HAVE_DIRCACHE
1985 handle
= core_alloc_ex("playlist dc",
1986 playlist
->max_playlist_size
* sizeof(int), &ops
);
1987 playlist
->filenames
= core_get_data(handle
);
1988 memset((void*)playlist
->filenames
, 0xff,
1989 playlist
->max_playlist_size
* sizeof(int));
1990 create_thread(playlist_thread
, playlist_stack
, sizeof(playlist_stack
),
1991 0, playlist_thread_name
IF_PRIO(, PRIORITY_BACKGROUND
)
1993 queue_init(&playlist_queue
, true);
1998 * Clean playlist at shutdown
2000 void playlist_shutdown(void)
2002 struct playlist_info
* playlist
= ¤t_playlist
;
2004 if (playlist
->control_fd
>= 0)
2006 mutex_lock(playlist
->control_mutex
);
2008 if (playlist
->num_cached
> 0)
2009 flush_cached_control(playlist
);
2011 close(playlist
->control_fd
);
2013 mutex_unlock(playlist
->control_mutex
);
2018 * Create new playlist
2020 int playlist_create(const char *dir
, const char *file
)
2022 struct playlist_info
* playlist
= ¤t_playlist
;
2024 new_playlist(playlist
, dir
, file
);
2027 /* load the playlist file */
2028 add_indices_to_playlist(playlist
, NULL
, 0);
2033 #define PLAYLIST_COMMAND_SIZE (MAX_PATH+12)
2036 * Restore the playlist state based on control file commands. Called to
2037 * resume playback after shutdown.
2039 int playlist_resume(void)
2041 struct playlist_info
* playlist
= ¤t_playlist
;
2046 int control_file_size
= 0;
2050 /* use mp3 buffer for maximum load speed */
2051 buffer
= (char *)audio_get_buffer(false, &buflen
);
2053 empty_playlist(playlist
, true);
2055 splash(0, ID2P(LANG_WAIT
));
2056 playlist
->control_fd
= open(playlist
->control_filename
, O_RDWR
);
2057 if (playlist
->control_fd
< 0)
2059 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2062 playlist
->control_created
= true;
2064 control_file_size
= filesize(playlist
->control_fd
);
2065 if (control_file_size
<= 0)
2067 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2071 /* read a small amount first to get the header */
2072 nread
= read(playlist
->control_fd
, buffer
,
2073 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
2076 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2080 playlist
->started
= true;
2086 enum playlist_command current_command
= PLAYLIST_COMMAND_COMMENT
;
2087 int last_newline
= 0;
2089 bool newline
= true;
2090 bool exit_loop
= false;
2095 unsigned long last_tick
= current_tick
;
2096 bool useraborted
= false;
2098 for(count
=0; count
<nread
&& !exit_loop
&& !useraborted
; count
++,p
++)
2100 /* So a splash while we are loading. */
2101 if (TIME_AFTER(current_tick
, last_tick
+ HZ
/4))
2103 splashf(0, str(LANG_LOADING_PERCENT
),
2104 (total_read
+count
)*100/control_file_size
,
2105 str(LANG_OFF_ABORT
));
2106 if (action_userabort(TIMEOUT_NOBLOCK
))
2111 last_tick
= current_tick
;
2114 /* Are we on a new line? */
2115 if((*p
== '\n') || (*p
== '\r'))
2119 /* save last_newline in case we need to load more data */
2120 last_newline
= count
;
2122 switch (current_command
)
2124 case PLAYLIST_COMMAND_PLAYLIST
:
2126 /* str1=version str2=dir str3=file */
2142 version
= atoi(str1
);
2144 if (version
!= PLAYLIST_CONTROL_FILE_VERSION
)
2147 update_playlist_filename(playlist
, str2
, str3
);
2149 if (str3
[0] != '\0')
2151 /* NOTE: add_indices_to_playlist() overwrites the
2152 audiobuf so we need to reload control file
2154 add_indices_to_playlist(playlist
, NULL
, 0);
2156 else if (str2
[0] != '\0')
2158 playlist
->in_ram
= true;
2159 resume_directory(str2
);
2162 /* load the rest of the data */
2168 case PLAYLIST_COMMAND_ADD
:
2169 case PLAYLIST_COMMAND_QUEUE
:
2171 /* str1=position str2=last_position str3=file */
2172 int position
, last_position
;
2175 if (!str1
|| !str2
|| !str3
)
2182 position
= atoi(str1
);
2183 last_position
= atoi(str2
);
2185 queue
= (current_command
== PLAYLIST_COMMAND_ADD
)?
2188 /* seek position is based on str3's position in
2190 if (add_track_to_playlist(playlist
, str3
, position
,
2191 queue
, total_read
+(str3
-buffer
)) < 0)
2194 playlist
->last_insert_pos
= last_position
;
2198 case PLAYLIST_COMMAND_DELETE
:
2210 position
= atoi(str1
);
2212 if (remove_track_from_playlist(playlist
, position
,
2218 case PLAYLIST_COMMAND_SHUFFLE
:
2220 /* str1=seed str2=first_index */
2232 /* Always sort list before shuffling */
2233 sort_playlist(playlist
, false, false);
2237 playlist
->first_index
= atoi(str2
);
2239 if (randomise_playlist(playlist
, seed
, false,
2245 case PLAYLIST_COMMAND_UNSHUFFLE
:
2247 /* str1=first_index */
2255 playlist
->first_index
= atoi(str1
);
2257 if (sort_playlist(playlist
, false, false) < 0)
2263 case PLAYLIST_COMMAND_RESET
:
2265 playlist
->last_insert_pos
= -1;
2268 case PLAYLIST_COMMAND_COMMENT
:
2275 /* to ignore any extra newlines */
2276 current_command
= PLAYLIST_COMMAND_COMMENT
;
2282 /* first non-comment line must always specify playlist */
2283 if (first
&& *p
!= 'P' && *p
!= '#')
2293 /* playlist can only be specified once */
2301 current_command
= PLAYLIST_COMMAND_PLAYLIST
;
2304 current_command
= PLAYLIST_COMMAND_ADD
;
2307 current_command
= PLAYLIST_COMMAND_QUEUE
;
2310 current_command
= PLAYLIST_COMMAND_DELETE
;
2313 current_command
= PLAYLIST_COMMAND_SHUFFLE
;
2316 current_command
= PLAYLIST_COMMAND_UNSHUFFLE
;
2319 current_command
= PLAYLIST_COMMAND_RESET
;
2322 current_command
= PLAYLIST_COMMAND_COMMENT
;
2335 else if(current_command
!= PLAYLIST_COMMAND_COMMENT
)
2337 /* all control file strings are separated with a colon.
2338 Replace the colon with 0 to get proper strings that can be
2339 used by commands above */
2345 if ((count
+1) < nread
)
2359 /* allow last string to contain colons */
2370 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID
));
2376 splash(HZ
*2, ID2P(LANG_CANCEL
));
2379 if (!newline
|| (exit_loop
&& count
<nread
))
2381 if ((total_read
+ count
) >= control_file_size
)
2383 /* no newline at end of control file */
2384 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID
));
2388 /* We didn't end on a newline or we exited loop prematurely.
2389 Either way, re-read the remainder. */
2390 count
= last_newline
;
2391 lseek(playlist
->control_fd
, total_read
+count
, SEEK_SET
);
2394 total_read
+= count
;
2397 /* still looking for header */
2398 nread
= read(playlist
->control_fd
, buffer
,
2399 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
2401 nread
= read(playlist
->control_fd
, buffer
, buflen
);
2403 /* Terminate on EOF */
2410 #ifdef HAVE_DIRCACHE
2411 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2418 * Add track to in_ram playlist. Used when playing directories.
2420 int playlist_add(const char *filename
)
2422 struct playlist_info
* playlist
= ¤t_playlist
;
2423 int len
= strlen(filename
);
2425 if((len
+1 > playlist
->buffer_size
- playlist
->buffer_end_pos
) ||
2426 (playlist
->amount
>= playlist
->max_playlist_size
))
2428 display_buffer_full();
2432 playlist
->indices
[playlist
->amount
] = playlist
->buffer_end_pos
;
2433 #ifdef HAVE_DIRCACHE
2434 playlist
->filenames
[playlist
->amount
] = -1;
2438 strcpy((char*)&playlist
->buffer
[playlist
->buffer_end_pos
], filename
);
2439 playlist
->buffer_end_pos
+= len
;
2440 playlist
->buffer
[playlist
->buffer_end_pos
++] = '\0';
2445 /* shuffle newly created playlist using random seed. */
2446 int playlist_shuffle(int random_seed
, int start_index
)
2448 struct playlist_info
* playlist
= ¤t_playlist
;
2450 bool start_current
= false;
2452 if (start_index
>= 0 && global_settings
.play_selected
)
2454 /* store the seek position before the shuffle */
2455 playlist
->index
= playlist
->first_index
= start_index
;
2456 start_current
= true;
2459 randomise_playlist(playlist
, random_seed
, start_current
, true);
2461 return playlist
->index
;
2464 /* start playing current playlist at specified index/offset */
2465 void playlist_start(int start_index
, int offset
)
2467 struct playlist_info
* playlist
= ¤t_playlist
;
2469 /* Cancel FM radio selection as previous music. For cases where we start
2470 playback without going to the WPS, such as playlist insert.. or
2471 playlist catalog. */
2472 previous_music_is_wps();
2474 playlist
->index
= start_index
;
2476 playlist
->started
= true;
2477 sync_control(playlist
, false);
2481 /* Returns false if 'steps' is out of bounds, else true */
2482 bool playlist_check(int steps
)
2484 struct playlist_info
* playlist
= ¤t_playlist
;
2486 /* always allow folder navigation */
2487 if (global_settings
.next_folder
&& playlist
->in_ram
)
2490 int index
= get_next_index(playlist
, steps
, -1);
2492 if (index
< 0 && steps
>= 0 && global_settings
.repeat_mode
== REPEAT_SHUFFLE
)
2493 index
= get_next_index(playlist
, steps
, REPEAT_ALL
);
2495 return (index
>= 0);
2498 /* get trackname of track that is "steps" away from current playing track.
2499 NULL is used to identify end of playlist */
2500 const char* playlist_peek(int steps
, char* buf
, size_t buf_size
)
2502 struct playlist_info
* playlist
= ¤t_playlist
;
2508 index
= get_next_index(playlist
, steps
, -1);
2512 #if CONFIG_CODEC == SWCODEC
2513 /* Just testing - don't care about the file name */
2514 if (!buf
|| !buf_size
)
2518 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
2519 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
2521 if (get_filename(playlist
, index
, seek
, control_file
, buf
,
2527 if (!playlist
->in_ram
|| control_file
)
2529 /* remove bogus dirs from beginning of path
2530 (workaround for buggy playlist creation tools) */
2533 if (file_exists(temp_ptr
))
2536 temp_ptr
= strchr(temp_ptr
+1, '/');
2541 /* Even though this is an invalid file, we still need to pass a
2542 file name to the caller because NULL is used to indicate end
2552 * Update indices as track has changed
2554 int playlist_next(int steps
)
2556 struct playlist_info
* playlist
= ¤t_playlist
;
2560 #ifdef AB_REPEAT_ENABLE
2561 && (global_settings
.repeat_mode
!= REPEAT_AB
)
2563 && (global_settings
.repeat_mode
!= REPEAT_ONE
) )
2567 /* We need to delete all the queued songs */
2568 for (i
=0, j
=steps
; i
<j
; i
++)
2570 index
= get_next_index(playlist
, i
, -1);
2572 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
2574 remove_track_from_playlist(playlist
, index
, true);
2575 steps
--; /* one less track */
2580 index
= get_next_index(playlist
, steps
, -1);
2584 /* end of playlist... or is it */
2585 if (global_settings
.repeat_mode
== REPEAT_SHUFFLE
&&
2586 playlist
->amount
> 1)
2588 /* Repeat shuffle mode. Re-shuffle playlist and resume play */
2589 playlist
->first_index
= 0;
2590 sort_playlist(playlist
, false, false);
2591 randomise_playlist(playlist
, current_tick
, false, true);
2593 #if CONFIG_CODEC == SWCODEC
2594 playlist
->started
= true;
2596 playlist_start(0, 0);
2598 playlist
->index
= 0;
2601 else if (playlist
->in_ram
&& global_settings
.next_folder
)
2603 index
= create_and_play_dir(steps
, true);
2607 playlist
->index
= index
;
2614 playlist
->index
= index
;
2616 if (playlist
->last_insert_pos
>= 0 && steps
> 0)
2618 /* check to see if we've gone beyond the last inserted track */
2619 int cur
= rotate_index(playlist
, index
);
2620 int last_pos
= rotate_index(playlist
, playlist
->last_insert_pos
);
2624 /* reset last inserted track */
2625 playlist
->last_insert_pos
= -1;
2627 if (playlist
->control_fd
>= 0)
2629 int result
= update_control(playlist
, PLAYLIST_COMMAND_RESET
,
2630 -1, -1, NULL
, NULL
, NULL
);
2635 sync_control(playlist
, false);
2643 /* try playing next or previous folder */
2644 bool playlist_next_dir(int direction
)
2646 /* not to mess up real playlists */
2647 if(!current_playlist
.in_ram
)
2650 return create_and_play_dir(direction
, false) >= 0;
2653 /* Get resume info for current playing song. If return value is -1 then
2654 settings shouldn't be saved. */
2655 int playlist_get_resume_info(int *resume_index
)
2657 struct playlist_info
* playlist
= ¤t_playlist
;
2659 *resume_index
= playlist
->index
;
2664 /* Update resume info for current playing song. Returns -1 on error. */
2665 int playlist_update_resume_info(const struct mp3entry
* id3
)
2667 struct playlist_info
* playlist
= ¤t_playlist
;
2671 if (global_status
.resume_index
!= playlist
->index
||
2672 global_status
.resume_offset
!= id3
->offset
)
2674 global_status
.resume_index
= playlist
->index
;
2675 global_status
.resume_offset
= id3
->offset
;
2681 global_status
.resume_index
= -1;
2682 global_status
.resume_offset
= -1;
2689 /* Returns index of current playing track for display purposes. This value
2690 should not be used for resume purposes as it doesn't represent the actual
2691 index into the playlist */
2692 int playlist_get_display_index(void)
2694 struct playlist_info
* playlist
= ¤t_playlist
;
2696 /* first_index should always be index 0 for display purposes */
2697 int index
= rotate_index(playlist
, playlist
->index
);
2702 /* returns number of tracks in current playlist */
2703 int playlist_amount(void)
2705 return playlist_amount_ex(NULL
);
2707 /* set playlist->last_shuffle_start to playlist->amount for
2708 PLAYLIST_INSERT_LAST_SHUFFLED command purposes*/
2709 void playlist_set_last_shuffled_start(void)
2711 struct playlist_info
* playlist
= ¤t_playlist
;
2712 playlist
->last_shuffled_start
= playlist
->amount
;
2715 * Create a new playlist If playlist is not NULL then we're loading a
2716 * playlist off disk for viewing/editing. The index_buffer is used to store
2717 * playlist indices (required for and only used if !current playlist). The
2718 * temp_buffer (if not NULL) is used as a scratchpad when loading indices.
2720 int playlist_create_ex(struct playlist_info
* playlist
,
2721 const char* dir
, const char* file
,
2722 void* index_buffer
, int index_buffer_size
,
2723 void* temp_buffer
, int temp_buffer_size
)
2726 playlist
= ¤t_playlist
;
2729 /* Initialize playlist structure */
2730 int r
= rand() % 10;
2731 playlist
->current
= false;
2733 /* Use random name for control file */
2734 snprintf(playlist
->control_filename
, sizeof(playlist
->control_filename
),
2735 "%s.%d", PLAYLIST_CONTROL_FILE
, r
);
2737 playlist
->control_fd
= -1;
2741 int num_indices
= index_buffer_size
/ sizeof(int);
2743 #ifdef HAVE_DIRCACHE
2746 if (num_indices
> global_settings
.max_files_in_playlist
)
2747 num_indices
= global_settings
.max_files_in_playlist
;
2749 playlist
->max_playlist_size
= num_indices
;
2750 playlist
->indices
= index_buffer
;
2751 #ifdef HAVE_DIRCACHE
2752 playlist
->filenames
= (int*)&playlist
->indices
[num_indices
];
2757 playlist
->max_playlist_size
= current_playlist
.max_playlist_size
;
2758 playlist
->indices
= current_playlist
.indices
;
2759 #ifdef HAVE_DIRCACHE
2760 playlist
->filenames
= current_playlist
.filenames
;
2764 playlist
->buffer_size
= 0;
2765 playlist
->buffer_handle
= -1;
2766 playlist
->buffer
= NULL
;
2767 playlist
->control_mutex
= &created_playlist_mutex
;
2770 new_playlist(playlist
, dir
, file
);
2773 /* load the playlist file */
2774 add_indices_to_playlist(playlist
, temp_buffer
, temp_buffer_size
);
2780 * Set the specified playlist as the current.
2781 * NOTE: You will get undefined behaviour if something is already playing so
2782 * remember to stop before calling this. Also, this call will
2783 * effectively close your playlist, making it unusable.
2785 int playlist_set_current(struct playlist_info
* playlist
)
2787 if (!playlist
|| (check_control(playlist
) < 0))
2790 empty_playlist(¤t_playlist
, false);
2792 strlcpy(current_playlist
.filename
, playlist
->filename
,
2793 sizeof(current_playlist
.filename
));
2795 current_playlist
.utf8
= playlist
->utf8
;
2796 current_playlist
.fd
= playlist
->fd
;
2798 close(playlist
->control_fd
);
2799 close(current_playlist
.control_fd
);
2800 remove(current_playlist
.control_filename
);
2801 if (rename(playlist
->control_filename
,
2802 current_playlist
.control_filename
) < 0)
2804 current_playlist
.control_fd
= open(current_playlist
.control_filename
,
2806 if (current_playlist
.control_fd
< 0)
2808 current_playlist
.control_created
= true;
2810 current_playlist
.dirlen
= playlist
->dirlen
;
2812 if (playlist
->indices
&& playlist
->indices
!= current_playlist
.indices
)
2814 memcpy((void*)current_playlist
.indices
, (void*)playlist
->indices
,
2815 playlist
->max_playlist_size
*sizeof(int));
2816 #ifdef HAVE_DIRCACHE
2817 memcpy((void*)current_playlist
.filenames
, (void*)playlist
->filenames
,
2818 playlist
->max_playlist_size
*sizeof(int));
2822 current_playlist
.first_index
= playlist
->first_index
;
2823 current_playlist
.amount
= playlist
->amount
;
2824 current_playlist
.last_insert_pos
= playlist
->last_insert_pos
;
2825 current_playlist
.seed
= playlist
->seed
;
2826 current_playlist
.shuffle_modified
= playlist
->shuffle_modified
;
2827 current_playlist
.deleted
= playlist
->deleted
;
2828 current_playlist
.num_inserted_tracks
= playlist
->num_inserted_tracks
;
2830 memcpy(current_playlist
.control_cache
, playlist
->control_cache
,
2831 sizeof(current_playlist
.control_cache
));
2832 current_playlist
.num_cached
= playlist
->num_cached
;
2833 current_playlist
.pending_control_sync
= playlist
->pending_control_sync
;
2837 struct playlist_info
*playlist_get_current(void)
2839 return ¤t_playlist
;
2842 * Close files and delete control file for non-current playlist.
2844 void playlist_close(struct playlist_info
* playlist
)
2849 if (playlist
->fd
>= 0)
2850 close(playlist
->fd
);
2852 if (playlist
->control_fd
>= 0)
2853 close(playlist
->control_fd
);
2855 if (playlist
->control_created
)
2856 remove(playlist
->control_filename
);
2859 void playlist_sync(struct playlist_info
* playlist
)
2862 playlist
= ¤t_playlist
;
2864 sync_control(playlist
, false);
2865 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2866 audio_flush_and_reload_tracks();
2868 #ifdef HAVE_DIRCACHE
2869 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2874 * Insert track into playlist at specified position (or one of the special
2875 * positions). Returns position where track was inserted or -1 if error.
2877 int playlist_insert_track(struct playlist_info
* playlist
, const char *filename
,
2878 int position
, bool queue
, bool sync
)
2883 playlist
= ¤t_playlist
;
2885 if (check_control(playlist
) < 0)
2887 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2891 result
= add_track_to_playlist(playlist
, filename
, position
, queue
, -1);
2893 /* Check if we want manually sync later. For example when adding
2894 * bunch of files from tagcache, syncing after every file wouldn't be
2895 * a good thing to do. */
2896 if (sync
&& result
>= 0)
2897 playlist_sync(playlist
);
2903 * Insert all tracks from specified directory into playlist.
2905 int playlist_insert_directory(struct playlist_info
* playlist
,
2906 const char *dirname
, int position
, bool queue
,
2910 unsigned char *count_str
;
2911 struct directory_search_context context
;
2914 playlist
= ¤t_playlist
;
2916 if (check_control(playlist
) < 0)
2918 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2922 if (position
== PLAYLIST_REPLACE
)
2924 if (playlist_remove_all_tracks(playlist
) == 0)
2925 position
= PLAYLIST_INSERT_LAST
;
2931 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
2933 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
2935 display_playlist_count(0, count_str
, false);
2937 context
.playlist
= playlist
;
2938 context
.position
= position
;
2939 context
.queue
= queue
;
2944 result
= playlist_directory_tracksearch(dirname
, recurse
,
2945 directory_search_callback
, &context
);
2947 sync_control(playlist
, false);
2951 display_playlist_count(context
.count
, count_str
, true);
2953 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2954 audio_flush_and_reload_tracks();
2956 #ifdef HAVE_DIRCACHE
2957 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2964 * Insert all tracks from specified playlist into dynamic playlist.
2966 int playlist_insert_playlist(struct playlist_info
* playlist
, const char *filename
,
2967 int position
, bool queue
)
2973 unsigned char *count_str
;
2974 char temp_buf
[MAX_PATH
+1];
2975 char trackname
[MAX_PATH
+1];
2978 bool utf8
= is_m3u8(filename
);
2981 playlist
= ¤t_playlist
;
2983 if (check_control(playlist
) < 0)
2985 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2989 fd
= open_utf8(filename
, O_RDONLY
);
2992 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
2996 /* we need the directory name for formatting purposes */
2999 temp_ptr
= strrchr(filename
+1,'/');
3006 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
3008 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
3010 display_playlist_count(count
, count_str
, false);
3012 if (position
== PLAYLIST_REPLACE
)
3014 if (playlist_remove_all_tracks(playlist
) == 0)
3015 position
= PLAYLIST_INSERT_LAST
;
3021 while ((max
= read_line(fd
, temp_buf
, sizeof(temp_buf
))) > 0)
3024 if (action_userabort(TIMEOUT_NOBLOCK
))
3027 if (temp_buf
[0] != '#' && temp_buf
[0] != '\0')
3033 /* Use trackname as a temporay buffer. Note that trackname must
3034 * be as large as temp_buf.
3036 max
= convert_m3u(temp_buf
, max
, sizeof(temp_buf
), trackname
);
3039 /* we need to format so that relative paths are correctly
3041 if (format_track_path(trackname
, temp_buf
, sizeof(trackname
), max
,
3048 insert_pos
= add_track_to_playlist(playlist
, trackname
, position
,
3057 /* Make sure tracks are inserted in correct order if user
3058 requests INSERT_FIRST */
3059 if (position
== PLAYLIST_INSERT_FIRST
|| position
>= 0)
3060 position
= insert_pos
+ 1;
3064 if ((count
%PLAYLIST_DISPLAY_COUNT
) == 0)
3066 display_playlist_count(count
, count_str
, false);
3068 if (count
== PLAYLIST_DISPLAY_COUNT
&&
3069 (audio_status() & AUDIO_STATUS_PLAY
) &&
3071 audio_flush_and_reload_tracks();
3075 /* let the other threads work */
3084 sync_control(playlist
, false);
3088 display_playlist_count(count
, count_str
, true);
3090 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3091 audio_flush_and_reload_tracks();
3093 #ifdef HAVE_DIRCACHE
3094 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3101 * Delete track at specified index. If index is PLAYLIST_DELETE_CURRENT then
3102 * we want to delete the current playing track.
3104 int playlist_delete(struct playlist_info
* playlist
, int index
)
3109 playlist
= ¤t_playlist
;
3111 if (check_control(playlist
) < 0)
3113 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3117 if (index
== PLAYLIST_DELETE_CURRENT
)
3118 index
= playlist
->index
;
3120 result
= remove_track_from_playlist(playlist
, index
, true);
3122 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3124 audio_flush_and_reload_tracks();
3130 * Move track at index to new_index. Tracks between the two are shifted
3131 * appropriately. Returns 0 on success and -1 on failure.
3133 int playlist_move(struct playlist_info
* playlist
, int index
, int new_index
)
3139 bool current
= false;
3141 char filename
[MAX_PATH
];
3144 playlist
= ¤t_playlist
;
3146 if (check_control(playlist
) < 0)
3148 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3152 if (index
== new_index
)
3155 if (index
== playlist
->index
)
3156 /* Moving the current track */
3159 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3160 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3161 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3163 if (get_filename(playlist
, index
, seek
, control_file
, filename
,
3164 sizeof(filename
)) < 0)
3167 /* We want to insert the track at the position that was specified by
3168 new_index. This may be different then new_index because of the
3169 shifting that will occur after the delete.
3170 We calculate this before we do the remove as it depends on the
3171 size of the playlist before the track removal */
3172 r
= rotate_index(playlist
, new_index
);
3174 /* Delete track from original position */
3175 result
= remove_track_from_playlist(playlist
, index
, true);
3181 new_index
= PLAYLIST_PREPEND
;
3182 else if (r
== playlist
->amount
)
3184 new_index
= PLAYLIST_INSERT_LAST
;
3186 /* Calculate index of desired position */
3187 new_index
= (r
+playlist
->first_index
)%playlist
->amount
;
3189 result
= add_track_to_playlist(playlist
, filename
, new_index
, queue
,
3196 /* Moved the current track */
3199 case PLAYLIST_PREPEND
:
3200 playlist
->index
= playlist
->first_index
;
3202 case PLAYLIST_INSERT_LAST
:
3203 playlist
->index
= playlist
->first_index
- 1;
3204 if (playlist
->index
< 0)
3205 playlist
->index
+= playlist
->amount
;
3208 playlist
->index
= new_index
;
3213 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3214 audio_flush_and_reload_tracks();
3218 #ifdef HAVE_DIRCACHE
3219 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3225 /* shuffle currently playing playlist */
3226 int playlist_randomise(struct playlist_info
* playlist
, unsigned int seed
,
3232 playlist
= ¤t_playlist
;
3234 check_control(playlist
);
3236 result
= randomise_playlist(playlist
, seed
, start_current
, true);
3238 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3240 audio_flush_and_reload_tracks();
3245 /* sort currently playing playlist */
3246 int playlist_sort(struct playlist_info
* playlist
, bool start_current
)
3251 playlist
= ¤t_playlist
;
3253 check_control(playlist
);
3255 result
= sort_playlist(playlist
, start_current
, true);
3257 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3259 audio_flush_and_reload_tracks();
3264 /* returns true if playlist has been modified */
3265 bool playlist_modified(const struct playlist_info
* playlist
)
3268 playlist
= ¤t_playlist
;
3270 if (playlist
->shuffle_modified
||
3271 playlist
->deleted
||
3272 playlist
->num_inserted_tracks
> 0)
3278 /* returns index of first track in playlist */
3279 int playlist_get_first_index(const struct playlist_info
* playlist
)
3282 playlist
= ¤t_playlist
;
3284 return playlist
->first_index
;
3287 /* returns shuffle seed of playlist */
3288 int playlist_get_seed(const struct playlist_info
* playlist
)
3291 playlist
= ¤t_playlist
;
3293 return playlist
->seed
;
3296 /* returns number of tracks in playlist (includes queued/inserted tracks) */
3297 int playlist_amount_ex(const struct playlist_info
* playlist
)
3300 playlist
= ¤t_playlist
;
3302 return playlist
->amount
;
3305 /* returns full path of playlist (minus extension) */
3306 char *playlist_name(const struct playlist_info
* playlist
, char *buf
,
3312 playlist
= ¤t_playlist
;
3314 strlcpy(buf
, playlist
->filename
+playlist
->dirlen
, buf_size
);
3319 /* Remove extension */
3320 sep
= strrchr(buf
, '.');
3327 /* returns the playlist filename */
3328 char *playlist_get_name(const struct playlist_info
* playlist
, char *buf
,
3332 playlist
= ¤t_playlist
;
3334 strlcpy(buf
, playlist
->filename
, buf_size
);
3342 /* Fills info structure with information about track at specified index.
3343 Returns 0 on success and -1 on failure */
3344 int playlist_get_track_info(struct playlist_info
* playlist
, int index
,
3345 struct playlist_track_info
* info
)
3351 playlist
= ¤t_playlist
;
3353 if (index
< 0 || index
>= playlist
->amount
)
3356 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3357 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3359 if (get_filename(playlist
, index
, seek
, control_file
, info
->filename
,
3360 sizeof(info
->filename
)) < 0)
3367 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
3368 info
->attr
|= PLAYLIST_ATTR_QUEUED
;
3370 info
->attr
|= PLAYLIST_ATTR_INSERTED
;
3374 if (playlist
->indices
[index
] & PLAYLIST_SKIPPED
)
3375 info
->attr
|= PLAYLIST_ATTR_SKIPPED
;
3377 info
->index
= index
;
3378 info
->display_index
= rotate_index(playlist
, index
) + 1;
3383 /* save the current dynamic playlist to specified file */
3384 int playlist_save(struct playlist_info
* playlist
, char *filename
)
3389 char path
[MAX_PATH
+1];
3390 char tmp_buf
[MAX_PATH
+1];
3392 bool overwrite_current
= false;
3393 int old_handle
= -1;
3394 char* old_buffer
= NULL
;
3395 size_t old_buffer_size
= 0;
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 if (!strncmp(playlist
->filename
, path
, strlen(path
)))
3410 /* Attempting to overwrite current playlist file.*/
3412 if (playlist
->buffer_size
< (int)(playlist
->amount
* sizeof(int)))
3414 /* not enough buffer space to store updated indices */
3415 /* Try to get a buffer */
3416 old_handle
= playlist
->buffer_handle
;
3417 /* can ignore volatile here, because core_get_data() is called later */
3418 old_buffer
= (char*)playlist
->buffer
;
3419 old_buffer_size
= playlist
->buffer_size
;
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
);
3550 old_buffer
= core_get_data(old_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
;