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"
89 #include "filefuncs.h"
95 #include "filetypes.h"
96 #ifdef HAVE_LCD_BITMAP
104 #include "rbunicode.h"
105 #include "root_menu.h"
107 #define PLAYLIST_CONTROL_FILE_VERSION 2
110 Each playlist index has a flag associated with it which identifies what
111 type of track it is. These flags are stored in the 4 high order bits of
114 NOTE: This limits the playlist file size to a max of 256M.
118 01 = Track was prepended into playlist
119 10 = Track was inserted into playlist
120 11 = Track was appended into playlist
125 0 = Track entry is valid
126 1 = Track does not exist on disk and should be skipped
128 #define PLAYLIST_SEEK_MASK 0x0FFFFFFF
129 #define PLAYLIST_INSERT_TYPE_MASK 0xC0000000
130 #define PLAYLIST_QUEUE_MASK 0x20000000
132 #define PLAYLIST_INSERT_TYPE_PREPEND 0x40000000
133 #define PLAYLIST_INSERT_TYPE_INSERT 0x80000000
134 #define PLAYLIST_INSERT_TYPE_APPEND 0xC0000000
136 #define PLAYLIST_QUEUED 0x20000000
137 #define PLAYLIST_SKIPPED 0x10000000
139 struct directory_search_context
{
140 struct playlist_info
* playlist
;
146 static struct playlist_info current_playlist
;
148 static void empty_playlist(struct playlist_info
* playlist
, bool resume
);
149 static void new_playlist(struct playlist_info
* playlist
, const char *dir
,
151 static void create_control(struct playlist_info
* playlist
);
152 static int check_control(struct playlist_info
* playlist
);
153 static int recreate_control(struct playlist_info
* playlist
);
154 static void update_playlist_filename(struct playlist_info
* playlist
,
155 const char *dir
, const char *file
);
156 static int add_indices_to_playlist(struct playlist_info
* playlist
,
157 char* buffer
, size_t buflen
);
158 static int add_track_to_playlist(struct playlist_info
* playlist
,
159 const char *filename
, int position
,
160 bool queue
, int seek_pos
);
161 static int directory_search_callback(char* filename
, void* context
);
162 static int remove_track_from_playlist(struct playlist_info
* playlist
,
163 int position
, bool write
);
164 static int randomise_playlist(struct playlist_info
* playlist
,
165 unsigned int seed
, bool start_current
,
167 static int sort_playlist(struct playlist_info
* playlist
, bool start_current
,
169 static int get_next_index(const struct playlist_info
* playlist
, int steps
,
171 static void find_and_set_playlist_index(struct playlist_info
* playlist
,
173 static int compare(const void* p1
, const void* p2
);
174 static int get_filename(struct playlist_info
* playlist
, int index
, int seek
,
175 bool control_file
, char *buf
, int buf_length
);
176 static int get_next_directory(char *dir
);
177 static int get_next_dir(char *dir
, bool is_forward
, bool recursion
);
178 static int get_previous_directory(char *dir
);
179 static int check_subdir_for_music(char *dir
, const char *subdir
, bool recurse
);
180 static int format_track_path(char *dest
, char *src
, int buf_length
, int max
,
182 static void display_playlist_count(int count
, const unsigned char *fmt
,
184 static void display_buffer_full(void);
185 static int flush_cached_control(struct playlist_info
* playlist
);
186 static int update_control(struct playlist_info
* playlist
,
187 enum playlist_command command
, int i1
, int i2
,
188 const char* s1
, const char* s2
, void* data
);
189 static void sync_control(struct playlist_info
* playlist
, bool force
);
190 static int rotate_index(const struct playlist_info
* playlist
, int index
);
193 #define PLAYLIST_LOAD_POINTERS 1
195 static struct event_queue playlist_queue SHAREDBSS_ATTR
;
196 static long playlist_stack
[(DEFAULT_STACK_SIZE
+ 0x800)/sizeof(long)];
197 static const char playlist_thread_name
[] = "playlist cachectrl";
200 static struct mutex current_playlist_mutex SHAREDBSS_ATTR
;
201 static struct mutex created_playlist_mutex SHAREDBSS_ATTR
;
203 /* Check if the filename suggests M3U or M3U8 format. */
204 static bool is_m3u8(const char* filename
)
206 int len
= strlen(filename
);
208 /* Default to M3U8 unless explicitly told otherwise. */
209 return !(len
> 4 && strcasecmp(&filename
[len
- 4], ".m3u") == 0);
213 /* Convert a filename in an M3U playlist to UTF-8.
215 * buf - the filename to convert; can contain more than one line from the
217 * buf_len - amount of buf that is used.
218 * buf_max - total size of buf.
219 * temp - temporary conversion buffer, at least buf_max bytes.
221 * Returns the length of the converted filename.
223 static int convert_m3u(char* buf
, int buf_len
, int buf_max
, char* temp
)
229 while ((buf
[i
] != '\n') && (buf
[i
] != '\r') && (i
< buf_len
))
234 /* Work back killing white space. */
235 while ((i
> 0) && isspace(buf
[i
- 1]))
243 /* Convert char by char, so as to not overflow temp (iso_decode should
244 * preferably handle this). No more than 4 bytes should be generated for
247 for (i
= 0; i
< buf_len
&& dest
< (temp
+ buf_max
- 4); i
++)
249 dest
= iso_decode(&buf
[i
], dest
, -1, 1);
258 * remove any files and indices associated with the playlist
260 static void empty_playlist(struct playlist_info
* playlist
, bool resume
)
262 playlist
->filename
[0] = '\0';
263 playlist
->utf8
= true;
265 if(playlist
->fd
>= 0)
266 /* If there is an already open playlist, close it. */
270 if(playlist
->control_fd
>= 0)
271 close(playlist
->control_fd
);
272 playlist
->control_fd
= -1;
273 playlist
->control_created
= false;
275 playlist
->in_ram
= false;
277 if (playlist
->buffer
)
278 playlist
->buffer
[0] = 0;
280 playlist
->buffer_end_pos
= 0;
283 playlist
->first_index
= 0;
284 playlist
->amount
= 0;
285 playlist
->last_insert_pos
= -1;
287 playlist
->shuffle_modified
= false;
288 playlist
->deleted
= false;
289 playlist
->num_inserted_tracks
= 0;
290 playlist
->started
= false;
292 playlist
->num_cached
= 0;
293 playlist
->pending_control_sync
= false;
295 if (!resume
&& playlist
->current
)
297 /* start with fresh playlist control file when starting new
299 create_control(playlist
);
304 * Initialize a new playlist for viewing/editing/playing. dir is the
305 * directory where the playlist is located and file is the filename.
307 static void new_playlist(struct playlist_info
* playlist
, const char *dir
,
310 const char *fileused
= file
;
311 const char *dirused
= dir
;
312 empty_playlist(playlist
, false);
318 if (dirused
&& playlist
->current
) /* !current cannot be in_ram */
319 playlist
->in_ram
= true;
321 dirused
= ""; /* empty playlist */
324 update_playlist_filename(playlist
, dirused
, fileused
);
326 if (playlist
->control_fd
>= 0)
328 update_control(playlist
, PLAYLIST_COMMAND_PLAYLIST
,
329 PLAYLIST_CONTROL_FILE_VERSION
, -1, dirused
, fileused
, NULL
);
330 sync_control(playlist
, false);
335 * create control file for playlist
337 static void create_control(struct playlist_info
* playlist
)
339 playlist
->control_fd
= open(playlist
->control_filename
,
340 O_CREAT
|O_RDWR
|O_TRUNC
, 0666);
341 if (playlist
->control_fd
< 0)
343 if (check_rockboxdir())
345 cond_talk_ids_fq(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
);
346 splashf(HZ
*2, (unsigned char *)"%s (%d)",
347 str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
),
348 playlist
->control_fd
);
350 playlist
->control_created
= false;
354 playlist
->control_created
= true;
359 * validate the control file. This may include creating/initializing it if
362 static int check_control(struct playlist_info
* playlist
)
364 if (!playlist
->control_created
)
366 create_control(playlist
);
368 if (playlist
->control_fd
>= 0)
370 char* dir
= playlist
->filename
;
371 char* file
= playlist
->filename
+playlist
->dirlen
;
372 char c
= playlist
->filename
[playlist
->dirlen
-1];
374 playlist
->filename
[playlist
->dirlen
-1] = '\0';
376 update_control(playlist
, PLAYLIST_COMMAND_PLAYLIST
,
377 PLAYLIST_CONTROL_FILE_VERSION
, -1, dir
, file
, NULL
);
378 sync_control(playlist
, false);
379 playlist
->filename
[playlist
->dirlen
-1] = c
;
383 if (playlist
->control_fd
< 0)
390 * recreate the control file based on current playlist entries
392 static int recreate_control(struct playlist_info
* playlist
)
394 char temp_file
[MAX_PATH
+1];
399 if(playlist
->control_fd
>= 0)
401 char* dir
= playlist
->filename
;
402 char* file
= playlist
->filename
+playlist
->dirlen
;
403 char c
= playlist
->filename
[playlist
->dirlen
-1];
405 close(playlist
->control_fd
);
407 snprintf(temp_file
, sizeof(temp_file
), "%s_temp",
408 playlist
->control_filename
);
410 if (rename(playlist
->control_filename
, temp_file
) < 0)
413 temp_fd
= open(temp_file
, O_RDONLY
);
417 playlist
->control_fd
= open(playlist
->control_filename
,
418 O_CREAT
|O_RDWR
|O_TRUNC
, 0666);
419 if (playlist
->control_fd
< 0)
422 playlist
->filename
[playlist
->dirlen
-1] = '\0';
424 /* cannot call update_control() because of mutex */
425 result
= fdprintf(playlist
->control_fd
, "P:%d:%s:%s\n",
426 PLAYLIST_CONTROL_FILE_VERSION
, dir
, file
);
428 playlist
->filename
[playlist
->dirlen
-1] = c
;
438 playlist
->shuffle_modified
= false;
439 playlist
->deleted
= false;
440 playlist
->num_inserted_tracks
= 0;
442 for (i
=0; i
<playlist
->amount
; i
++)
444 if (playlist
->indices
[i
] & PLAYLIST_INSERT_TYPE_MASK
)
446 bool queue
= playlist
->indices
[i
] & PLAYLIST_QUEUE_MASK
;
447 char inserted_file
[MAX_PATH
+1];
449 lseek(temp_fd
, playlist
->indices
[i
] & PLAYLIST_SEEK_MASK
,
451 read_line(temp_fd
, inserted_file
, sizeof(inserted_file
));
453 result
= fdprintf(playlist
->control_fd
, "%c:%d:%d:",
454 queue
?'Q':'A', i
, playlist
->last_insert_pos
);
457 /* save the position in file where name is written */
458 int seek_pos
= lseek(playlist
->control_fd
, 0, SEEK_CUR
);
460 result
= fdprintf(playlist
->control_fd
, "%s\n",
463 playlist
->indices
[i
] =
464 (playlist
->indices
[i
] & ~PLAYLIST_SEEK_MASK
) | seek_pos
;
470 playlist
->num_inserted_tracks
++;
476 fsync(playlist
->control_fd
);
485 * store directory and name of playlist file
487 static void update_playlist_filename(struct playlist_info
* playlist
,
488 const char *dir
, const char *file
)
491 int dirlen
= strlen(dir
);
493 playlist
->utf8
= is_m3u8(file
);
495 /* If the dir does not end in trailing slash, we use a separator.
496 Otherwise we don't. */
497 if('/' != dir
[dirlen
-1])
503 playlist
->dirlen
= dirlen
;
505 snprintf(playlist
->filename
, sizeof(playlist
->filename
),
506 "%s%s%s", dir
, sep
, file
);
510 * calculate track offsets within a playlist file
512 static int add_indices_to_playlist(struct playlist_info
* playlist
,
513 char* buffer
, size_t buflen
)
517 unsigned int count
= 0;
522 if(-1 == playlist
->fd
)
523 playlist
->fd
= open_utf8(playlist
->filename
, O_RDONLY
);
525 return -1; /* failure */
526 if((i
= lseek(playlist
->fd
, 0, SEEK_CUR
)) > 0)
527 playlist
->utf8
= true; /* Override any earlier indication. */
529 splash(0, ID2P(LANG_WAIT
));
533 /* use mp3 buffer for maximum load speed */
535 #if CONFIG_CODEC != SWCODEC
536 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
537 buflen
= (audiobufend
- audiobuf
);
538 buffer
= (char *)audiobuf
;
540 buffer
= (char *)audio_get_buffer(false, &buflen
);
548 nread
= read(playlist
->fd
, buffer
, buflen
);
549 /* Terminate on EOF */
553 p
= (unsigned char *)buffer
;
555 for(count
=0; count
< nread
; count
++,p
++) {
557 /* Are we on a new line? */
558 if((*p
== '\n') || (*p
== '\r'))
568 if ( playlist
->amount
>= playlist
->max_playlist_size
) {
569 display_buffer_full();
574 /* Store a new entry */
575 playlist
->indices
[ playlist
->amount
] = i
+count
;
577 if (playlist
->filenames
)
578 playlist
->filenames
[ playlist
->amount
] = NULL
;
590 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
597 * Utility function to create a new playlist, fill it with the next or
598 * previous directory, shuffle it if needed, and start playback.
599 * If play_last is true and direction zero or negative, start playing
600 * the last file in the directory, otherwise start playing the first.
602 static int create_and_play_dir(int direction
, bool play_last
)
604 char dir
[MAX_PATH
+ 1];
609 res
= get_next_directory(dir
);
611 res
= get_previous_directory(dir
);
615 if (playlist_create(dir
, NULL
) != -1)
617 ft_build_playlist(tree_get_context(), 0);
619 if (global_settings
.playlist_shuffle
)
620 playlist_shuffle(current_tick
, -1);
622 if (play_last
&& direction
<= 0)
623 index
= current_playlist
.amount
- 1;
627 #if (CONFIG_CODEC != SWCODEC)
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
] = NULL
;
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
= (long)playlist
->filenames
[candidate
];
960 playlist
->filenames
[candidate
] = playlist
->filenames
[count
];
961 playlist
->filenames
[count
] = (struct dircache_entry
*)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(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(playlist
->filenames
, 0, 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 void playlist_thread(void)
1248 struct queue_event ev
;
1249 bool dirty_pointers
= false;
1250 static char tmp
[MAX_PATH
+1];
1252 struct playlist_info
*playlist
;
1259 #ifdef HAVE_DISK_STORAGE
1260 if (global_settings
.disk_spindown
> 1 &&
1261 global_settings
.disk_spindown
<= 5)
1262 sleep_time
= global_settings
.disk_spindown
- 1;
1267 queue_wait_w_tmo(&playlist_queue
, &ev
, HZ
*sleep_time
);
1271 case PLAYLIST_LOAD_POINTERS
:
1272 dirty_pointers
= true;
1275 /* Start the background scanning after either the disk spindown
1276 timeout or 5s, whichever is less */
1278 playlist
= ¤t_playlist
;
1279 if (playlist
->control_fd
>= 0)
1281 if (playlist
->num_cached
> 0)
1282 register_storage_idle_func(playlist_flush_callback
);
1285 if (!dirty_pointers
)
1288 if (!dircache_is_enabled() || !playlist
->filenames
1289 || playlist
->amount
<= 0)
1292 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1295 for (index
= 0; index
< playlist
->amount
1296 && queue_empty(&playlist_queue
); index
++)
1298 /* Process only pointers that are not already loaded. */
1299 if (playlist
->filenames
[index
])
1302 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
1303 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
1305 /* Load the filename from playlist file. */
1306 if (get_filename(playlist
, index
, seek
, control_file
, tmp
,
1310 /* Set the dircache entry pointer. */
1311 playlist
->filenames
[index
] = dircache_get_entry_ptr(tmp
);
1313 /* And be on background so user doesn't notice any delays. */
1317 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1320 dirty_pointers
= false;
1323 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
1324 case SYS_USB_CONNECTED
:
1325 usb_acknowledge(SYS_USB_CONNECTED_ACK
);
1326 usb_wait_for_disconnect(&playlist_queue
);
1335 * gets pathname for track at seek index
1337 static int get_filename(struct playlist_info
* playlist
, int index
, int seek
,
1338 bool control_file
, char *buf
, int buf_length
)
1342 char tmp_buf
[MAX_PATH
+1];
1343 char dir_buf
[MAX_PATH
+1];
1344 bool utf8
= playlist
->utf8
;
1346 if (buf_length
> MAX_PATH
+1)
1347 buf_length
= MAX_PATH
+1;
1349 #ifdef HAVE_DIRCACHE
1350 if (dircache_is_enabled() && playlist
->filenames
)
1352 if (playlist
->filenames
[index
] != NULL
)
1354 dircache_copy_path(playlist
->filenames
[index
], tmp_buf
, sizeof(tmp_buf
)-1);
1355 max
= strlen(tmp_buf
);
1362 if (playlist
->in_ram
&& !control_file
&& max
< 0)
1364 max
= strlcpy(tmp_buf
, &playlist
->buffer
[seek
], sizeof(tmp_buf
));
1368 mutex_lock(playlist
->control_mutex
);
1372 fd
= playlist
->control_fd
;
1377 if(-1 == playlist
->fd
)
1378 playlist
->fd
= open(playlist
->filename
, O_RDONLY
);
1386 if (lseek(fd
, seek
, SEEK_SET
) != seek
)
1390 max
= read(fd
, tmp_buf
, MIN((size_t) buf_length
, sizeof(tmp_buf
)));
1392 if ((max
> 0) && !utf8
)
1394 /* Use dir_buf as a temporary buffer. Note that dir_buf must
1395 * be as large as tmp_buf.
1397 max
= convert_m3u(tmp_buf
, max
, sizeof(tmp_buf
), dir_buf
);
1402 mutex_unlock(playlist
->control_mutex
);
1407 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
1409 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
1415 strlcpy(dir_buf
, playlist
->filename
, playlist
->dirlen
);
1417 return (format_track_path(buf
, tmp_buf
, buf_length
, max
, dir_buf
));
1420 static int get_next_directory(char *dir
){
1421 return get_next_dir(dir
,true,false);
1424 static int get_previous_directory(char *dir
){
1425 return get_next_dir(dir
,false,false);
1429 * search through all the directories (starting with the current) to find
1430 * one that has tracks to play
1432 static int get_next_dir(char *dir
, bool is_forward
, bool recursion
)
1434 struct playlist_info
* playlist
= ¤t_playlist
;
1436 char *start_dir
= NULL
;
1439 struct tree_context
* tc
= tree_get_context();
1440 int saved_dirfilter
= *(tc
->dirfilter
);
1442 /* process random folder advance */
1443 if (global_settings
.next_folder
== FOLDER_ADVANCE_RANDOM
)
1445 int fd
= open(ROCKBOX_DIR
"/folder_advance_list.dat", O_RDONLY
);
1448 char buffer
[MAX_PATH
];
1449 int folder_count
= 0;
1450 srand(current_tick
);
1451 *(tc
->dirfilter
) = SHOW_MUSIC
;
1452 tc
->sort_dir
= global_settings
.sort_dir
;
1453 read(fd
,&folder_count
,sizeof(int));
1458 i
= rand()%folder_count
;
1459 lseek(fd
,sizeof(int) + (MAX_PATH
*i
),SEEK_SET
);
1460 read(fd
,buffer
,MAX_PATH
);
1461 if (check_subdir_for_music(buffer
, "", false) ==0)
1467 *(tc
->dirfilter
) = saved_dirfilter
;
1468 tc
->sort_dir
= global_settings
.sort_dir
;
1474 /* not random folder advance (or random folder advance unavailable) */
1477 /* start with root */
1482 /* start with current directory */
1483 strlcpy(dir
, playlist
->filename
, playlist
->dirlen
);
1486 /* use the tree browser dircache to load files */
1487 *(tc
->dirfilter
) = SHOW_ALL
;
1489 /* set up sorting/direction */
1490 tc
->sort_dir
= global_settings
.sort_dir
;
1493 static const char sortpairs
[] =
1495 [SORT_ALPHA
] = SORT_ALPHA_REVERSED
,
1496 [SORT_DATE
] = SORT_DATE_REVERSED
,
1497 [SORT_TYPE
] = SORT_TYPE_REVERSED
,
1498 [SORT_ALPHA_REVERSED
] = SORT_ALPHA
,
1499 [SORT_DATE_REVERSED
] = SORT_DATE
,
1500 [SORT_TYPE_REVERSED
] = SORT_TYPE
,
1503 if ((unsigned)tc
->sort_dir
< sizeof(sortpairs
))
1504 tc
->sort_dir
= sortpairs
[tc
->sort_dir
];
1509 struct entry
*files
;
1513 if (ft_load(tc
, (dir
[0]=='\0')?"/":dir
) < 0)
1520 files
= (struct entry
*) tc
->dircache
;
1521 num_files
= tc
->filesindir
;
1523 for (i
=0; i
<num_files
; i
++)
1526 if (action_userabort(TIMEOUT_NOBLOCK
))
1533 if (files
[i
].attr
& ATTR_DIRECTORY
)
1537 result
= check_subdir_for_music(dir
, files
[i
].name
, true);
1544 else if (!strcmp(start_dir
, files
[i
].name
))
1551 /* move down to parent directory. current directory name is
1552 stored as the starting point for the search in parent */
1553 start_dir
= strrchr(dir
, '/');
1564 /* restore dirfilter */
1565 *(tc
->dirfilter
) = saved_dirfilter
;
1566 tc
->sort_dir
= global_settings
.sort_dir
;
1568 /* special case if nothing found: try start searching again from root */
1569 if (result
== -1 && !recursion
){
1570 result
= get_next_dir(dir
, is_forward
, true);
1577 * Checks if there are any music files in the dir or any of its
1578 * subdirectories. May be called recursively.
1580 static int check_subdir_for_music(char *dir
, const char *subdir
, bool recurse
)
1583 int dirlen
= strlen(dir
);
1586 struct entry
*files
;
1587 bool has_music
= false;
1588 bool has_subdir
= false;
1589 struct tree_context
* tc
= tree_get_context();
1591 snprintf(dir
+dirlen
, MAX_PATH
-dirlen
, "/%s", subdir
);
1593 if (ft_load(tc
, dir
) < 0)
1598 files
= (struct entry
*) tc
->dircache
;
1599 num_files
= tc
->filesindir
;
1601 for (i
=0; i
<num_files
; i
++)
1603 if (files
[i
].attr
& ATTR_DIRECTORY
)
1605 else if ((files
[i
].attr
& FILE_ATTR_MASK
) == FILE_ATTR_AUDIO
)
1615 if (has_subdir
&& recurse
)
1617 for (i
=0; i
<num_files
; i
++)
1619 if (action_userabort(TIMEOUT_NOBLOCK
))
1625 if (files
[i
].attr
& ATTR_DIRECTORY
)
1627 result
= check_subdir_for_music(dir
, files
[i
].name
, true);
1645 /* we now need to reload our current directory */
1646 if(ft_load(tc
, dir
) < 0)
1647 splash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
1653 * Returns absolute path of track
1655 static int format_track_path(char *dest
, char *src
, int buf_length
, int max
,
1662 /* Zero-terminate the file name */
1668 /* Now work back killing white space */
1669 while((src
[i
-1] == ' ') ||
1675 /* replace backslashes with forward slashes */
1676 for ( j
=0; j
<i
; j
++ )
1677 if ( src
[j
] == '\\' )
1682 strlcpy(dest
, src
, buf_length
);
1686 /* handle dos style drive letter */
1688 strlcpy(dest
, &src
[2], buf_length
);
1689 else if (!strncmp(src
, "../", 3))
1691 /* handle relative paths */
1693 while(!strncmp(&src
[i
], "../", 3))
1695 for (j
=0; j
<i
/3; j
++) {
1696 temp_ptr
= strrchr(dir
, '/');
1702 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[i
]);
1704 else if ( '.' == src
[0] && '/' == src
[1] ) {
1705 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[2]);
1708 snprintf(dest
, buf_length
, "%s/%s", dir
, src
);
1716 * Display splash message showing progress of playlist/directory insertion or
1719 static void display_playlist_count(int count
, const unsigned char *fmt
,
1722 static long talked_tick
= 0;
1723 long id
= P2ID(fmt
);
1724 if(global_settings
.talk_menu
&& id
>=0)
1726 if(final
|| (count
&& (talked_tick
== 0
1727 || TIME_AFTER(current_tick
, talked_tick
+5*HZ
))))
1729 talked_tick
= current_tick
;
1730 talk_number(count
, false);
1736 splashf(0, fmt
, count
, str(LANG_OFF_ABORT
));
1740 * Display buffer full message
1742 static void display_buffer_full(void)
1744 splash(HZ
*2, ID2P(LANG_PLAYLIST_BUFFER_FULL
));
1748 * Flush any cached control commands to disk. Called when playlist is being
1749 * modified. Returns 0 on success and -1 on failure.
1751 static int flush_cached_control(struct playlist_info
* playlist
)
1756 if (!playlist
->num_cached
)
1759 lseek(playlist
->control_fd
, 0, SEEK_END
);
1761 for (i
=0; i
<playlist
->num_cached
; i
++)
1763 struct playlist_control_cache
* cache
=
1764 &(playlist
->control_cache
[i
]);
1766 switch (cache
->command
)
1768 case PLAYLIST_COMMAND_PLAYLIST
:
1769 result
= fdprintf(playlist
->control_fd
, "P:%d:%s:%s\n",
1770 cache
->i1
, cache
->s1
, cache
->s2
);
1772 case PLAYLIST_COMMAND_ADD
:
1773 case PLAYLIST_COMMAND_QUEUE
:
1774 result
= fdprintf(playlist
->control_fd
, "%c:%d:%d:",
1775 (cache
->command
== PLAYLIST_COMMAND_ADD
)?'A':'Q',
1776 cache
->i1
, cache
->i2
);
1779 /* save the position in file where name is written */
1780 int* seek_pos
= (int *)cache
->data
;
1781 *seek_pos
= lseek(playlist
->control_fd
, 0, SEEK_CUR
);
1782 result
= fdprintf(playlist
->control_fd
, "%s\n",
1786 case PLAYLIST_COMMAND_DELETE
:
1787 result
= fdprintf(playlist
->control_fd
, "D:%d\n", cache
->i1
);
1789 case PLAYLIST_COMMAND_SHUFFLE
:
1790 result
= fdprintf(playlist
->control_fd
, "S:%d:%d\n",
1791 cache
->i1
, cache
->i2
);
1793 case PLAYLIST_COMMAND_UNSHUFFLE
:
1794 result
= fdprintf(playlist
->control_fd
, "U:%d\n", cache
->i1
);
1796 case PLAYLIST_COMMAND_RESET
:
1797 result
= fdprintf(playlist
->control_fd
, "R\n");
1809 playlist
->num_cached
= 0;
1810 playlist
->pending_control_sync
= true;
1817 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_UPDATE_ERROR
));
1824 * Update control data with new command. Depending on the command, it may be
1825 * cached or flushed to disk.
1827 static int update_control(struct playlist_info
* playlist
,
1828 enum playlist_command command
, int i1
, int i2
,
1829 const char* s1
, const char* s2
, void* data
)
1832 struct playlist_control_cache
* cache
;
1835 mutex_lock(playlist
->control_mutex
);
1837 cache
= &(playlist
->control_cache
[playlist
->num_cached
++]);
1839 cache
->command
= command
;
1848 case PLAYLIST_COMMAND_PLAYLIST
:
1849 case PLAYLIST_COMMAND_ADD
:
1850 case PLAYLIST_COMMAND_QUEUE
:
1851 #ifndef HAVE_DIRCACHE
1852 case PLAYLIST_COMMAND_DELETE
:
1853 case PLAYLIST_COMMAND_RESET
:
1857 case PLAYLIST_COMMAND_SHUFFLE
:
1858 case PLAYLIST_COMMAND_UNSHUFFLE
:
1860 /* only flush when needed */
1864 if (flush
|| playlist
->num_cached
== PLAYLIST_MAX_CACHE
)
1865 result
= flush_cached_control(playlist
);
1867 mutex_unlock(playlist
->control_mutex
);
1873 * sync control file to disk
1875 static void sync_control(struct playlist_info
* playlist
, bool force
)
1877 #ifdef HAVE_DIRCACHE
1878 if (playlist
->started
&& force
)
1882 if (playlist
->started
)
1885 if (playlist
->pending_control_sync
)
1887 mutex_lock(playlist
->control_mutex
);
1888 fsync(playlist
->control_fd
);
1889 playlist
->pending_control_sync
= false;
1890 mutex_unlock(playlist
->control_mutex
);
1896 * Rotate indices such that first_index is index 0
1898 static int rotate_index(const struct playlist_info
* playlist
, int index
)
1900 index
-= playlist
->first_index
;
1902 index
+= playlist
->amount
;
1908 * Initialize playlist entries at startup
1910 void playlist_init(void)
1912 struct playlist_info
* playlist
= ¤t_playlist
;
1914 mutex_init(¤t_playlist_mutex
);
1915 mutex_init(&created_playlist_mutex
);
1917 playlist
->current
= true;
1918 strlcpy(playlist
->control_filename
, PLAYLIST_CONTROL_FILE
,
1919 sizeof(playlist
->control_filename
));
1921 playlist
->control_fd
= -1;
1922 playlist
->max_playlist_size
= global_settings
.max_files_in_playlist
;
1923 playlist
->indices
= buffer_alloc(
1924 playlist
->max_playlist_size
* sizeof(int));
1925 playlist
->buffer_size
=
1926 AVERAGE_FILENAME_LENGTH
* global_settings
.max_files_in_dir
;
1927 playlist
->buffer
= buffer_alloc(playlist
->buffer_size
);
1928 playlist
->control_mutex
= ¤t_playlist_mutex
;
1930 empty_playlist(playlist
, true);
1932 #ifdef HAVE_DIRCACHE
1933 playlist
->filenames
= buffer_alloc(
1934 playlist
->max_playlist_size
* sizeof(int));
1935 memset(playlist
->filenames
, 0,
1936 playlist
->max_playlist_size
* sizeof(int));
1937 create_thread(playlist_thread
, playlist_stack
, sizeof(playlist_stack
),
1938 0, playlist_thread_name
IF_PRIO(, PRIORITY_BACKGROUND
)
1940 queue_init(&playlist_queue
, true);
1945 * Clean playlist at shutdown
1947 void playlist_shutdown(void)
1949 struct playlist_info
* playlist
= ¤t_playlist
;
1951 if (playlist
->control_fd
>= 0)
1953 mutex_lock(playlist
->control_mutex
);
1955 if (playlist
->num_cached
> 0)
1956 flush_cached_control(playlist
);
1958 close(playlist
->control_fd
);
1960 mutex_unlock(playlist
->control_mutex
);
1965 * Create new playlist
1967 int playlist_create(const char *dir
, const char *file
)
1969 struct playlist_info
* playlist
= ¤t_playlist
;
1971 new_playlist(playlist
, dir
, file
);
1974 /* load the playlist file */
1975 add_indices_to_playlist(playlist
, NULL
, 0);
1980 #define PLAYLIST_COMMAND_SIZE (MAX_PATH+12)
1983 * Restore the playlist state based on control file commands. Called to
1984 * resume playback after shutdown.
1986 int playlist_resume(void)
1988 struct playlist_info
* playlist
= ¤t_playlist
;
1993 int control_file_size
= 0;
1997 /* use mp3 buffer for maximum load speed */
1998 #if CONFIG_CODEC != SWCODEC
1999 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
2000 buflen
= (audiobufend
- audiobuf
);
2001 buffer
= (char *)audiobuf
;
2003 buffer
= (char *)audio_get_buffer(false, &buflen
);
2006 empty_playlist(playlist
, true);
2008 splash(0, ID2P(LANG_WAIT
));
2009 playlist
->control_fd
= open(playlist
->control_filename
, O_RDWR
);
2010 if (playlist
->control_fd
< 0)
2012 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2015 playlist
->control_created
= true;
2017 control_file_size
= filesize(playlist
->control_fd
);
2018 if (control_file_size
<= 0)
2020 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2024 /* read a small amount first to get the header */
2025 nread
= read(playlist
->control_fd
, buffer
,
2026 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
2029 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2033 playlist
->started
= true;
2039 enum playlist_command current_command
= PLAYLIST_COMMAND_COMMENT
;
2040 int last_newline
= 0;
2042 bool newline
= true;
2043 bool exit_loop
= false;
2048 unsigned long last_tick
= current_tick
;
2049 bool useraborted
= false;
2051 for(count
=0; count
<nread
&& !exit_loop
&& !useraborted
; count
++,p
++)
2053 /* So a splash while we are loading. */
2054 if (TIME_AFTER(current_tick
, last_tick
+ HZ
/4))
2056 splashf(0, str(LANG_LOADING_PERCENT
),
2057 (total_read
+count
)*100/control_file_size
,
2058 str(LANG_OFF_ABORT
));
2059 if (action_userabort(TIMEOUT_NOBLOCK
))
2064 last_tick
= current_tick
;
2067 /* Are we on a new line? */
2068 if((*p
== '\n') || (*p
== '\r'))
2072 /* save last_newline in case we need to load more data */
2073 last_newline
= count
;
2075 switch (current_command
)
2077 case PLAYLIST_COMMAND_PLAYLIST
:
2079 /* str1=version str2=dir str3=file */
2095 version
= atoi(str1
);
2097 if (version
!= PLAYLIST_CONTROL_FILE_VERSION
)
2100 update_playlist_filename(playlist
, str2
, str3
);
2102 if (str3
[0] != '\0')
2104 /* NOTE: add_indices_to_playlist() overwrites the
2105 audiobuf so we need to reload control file
2107 add_indices_to_playlist(playlist
, NULL
, 0);
2109 else if (str2
[0] != '\0')
2111 playlist
->in_ram
= true;
2112 resume_directory(str2
);
2115 /* load the rest of the data */
2121 case PLAYLIST_COMMAND_ADD
:
2122 case PLAYLIST_COMMAND_QUEUE
:
2124 /* str1=position str2=last_position str3=file */
2125 int position
, last_position
;
2128 if (!str1
|| !str2
|| !str3
)
2135 position
= atoi(str1
);
2136 last_position
= atoi(str2
);
2138 queue
= (current_command
== PLAYLIST_COMMAND_ADD
)?
2141 /* seek position is based on str3's position in
2143 if (add_track_to_playlist(playlist
, str3
, position
,
2144 queue
, total_read
+(str3
-buffer
)) < 0)
2147 playlist
->last_insert_pos
= last_position
;
2151 case PLAYLIST_COMMAND_DELETE
:
2163 position
= atoi(str1
);
2165 if (remove_track_from_playlist(playlist
, position
,
2171 case PLAYLIST_COMMAND_SHUFFLE
:
2173 /* str1=seed str2=first_index */
2185 /* Always sort list before shuffling */
2186 sort_playlist(playlist
, false, false);
2190 playlist
->first_index
= atoi(str2
);
2192 if (randomise_playlist(playlist
, seed
, false,
2198 case PLAYLIST_COMMAND_UNSHUFFLE
:
2200 /* str1=first_index */
2208 playlist
->first_index
= atoi(str1
);
2210 if (sort_playlist(playlist
, false, false) < 0)
2216 case PLAYLIST_COMMAND_RESET
:
2218 playlist
->last_insert_pos
= -1;
2221 case PLAYLIST_COMMAND_COMMENT
:
2228 /* to ignore any extra newlines */
2229 current_command
= PLAYLIST_COMMAND_COMMENT
;
2235 /* first non-comment line must always specify playlist */
2236 if (first
&& *p
!= 'P' && *p
!= '#')
2246 /* playlist can only be specified once */
2254 current_command
= PLAYLIST_COMMAND_PLAYLIST
;
2257 current_command
= PLAYLIST_COMMAND_ADD
;
2260 current_command
= PLAYLIST_COMMAND_QUEUE
;
2263 current_command
= PLAYLIST_COMMAND_DELETE
;
2266 current_command
= PLAYLIST_COMMAND_SHUFFLE
;
2269 current_command
= PLAYLIST_COMMAND_UNSHUFFLE
;
2272 current_command
= PLAYLIST_COMMAND_RESET
;
2275 current_command
= PLAYLIST_COMMAND_COMMENT
;
2288 else if(current_command
!= PLAYLIST_COMMAND_COMMENT
)
2290 /* all control file strings are separated with a colon.
2291 Replace the colon with 0 to get proper strings that can be
2292 used by commands above */
2298 if ((count
+1) < nread
)
2312 /* allow last string to contain colons */
2323 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID
));
2329 splash(HZ
*2, ID2P(LANG_CANCEL
));
2332 if (!newline
|| (exit_loop
&& count
<nread
))
2334 if ((total_read
+ count
) >= control_file_size
)
2336 /* no newline at end of control file */
2337 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID
));
2341 /* We didn't end on a newline or we exited loop prematurely.
2342 Either way, re-read the remainder. */
2343 count
= last_newline
;
2344 lseek(playlist
->control_fd
, total_read
+count
, SEEK_SET
);
2347 total_read
+= count
;
2350 /* still looking for header */
2351 nread
= read(playlist
->control_fd
, buffer
,
2352 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
2354 nread
= read(playlist
->control_fd
, buffer
, buflen
);
2356 /* Terminate on EOF */
2363 #ifdef HAVE_DIRCACHE
2364 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2371 * Add track to in_ram playlist. Used when playing directories.
2373 int playlist_add(const char *filename
)
2375 struct playlist_info
* playlist
= ¤t_playlist
;
2376 int len
= strlen(filename
);
2378 if((len
+1 > playlist
->buffer_size
- playlist
->buffer_end_pos
) ||
2379 (playlist
->amount
>= playlist
->max_playlist_size
))
2381 display_buffer_full();
2385 playlist
->indices
[playlist
->amount
] = playlist
->buffer_end_pos
;
2386 #ifdef HAVE_DIRCACHE
2387 playlist
->filenames
[playlist
->amount
] = NULL
;
2391 strcpy(&playlist
->buffer
[playlist
->buffer_end_pos
], filename
);
2392 playlist
->buffer_end_pos
+= len
;
2393 playlist
->buffer
[playlist
->buffer_end_pos
++] = '\0';
2398 /* shuffle newly created playlist using random seed. */
2399 int playlist_shuffle(int random_seed
, int start_index
)
2401 struct playlist_info
* playlist
= ¤t_playlist
;
2403 bool start_current
= false;
2405 if (start_index
>= 0 && global_settings
.play_selected
)
2407 /* store the seek position before the shuffle */
2408 playlist
->index
= playlist
->first_index
= start_index
;
2409 start_current
= true;
2412 randomise_playlist(playlist
, random_seed
, start_current
, true);
2414 return playlist
->index
;
2417 /* start playing current playlist at specified index/offset */
2418 void playlist_start(int start_index
, int offset
)
2420 struct playlist_info
* playlist
= ¤t_playlist
;
2422 /* Cancel FM radio selection as previous music. For cases where we start
2423 playback without going to the WPS, such as playlist insert.. or
2424 playlist catalog. */
2425 previous_music_is_wps();
2427 playlist
->index
= start_index
;
2429 #if CONFIG_CODEC != SWCODEC
2430 talk_buffer_steal(); /* will use the mp3 buffer */
2433 playlist
->started
= true;
2434 sync_control(playlist
, false);
2438 /* Returns false if 'steps' is out of bounds, else true */
2439 bool playlist_check(int steps
)
2441 struct playlist_info
* playlist
= ¤t_playlist
;
2443 /* always allow folder navigation */
2444 if (global_settings
.next_folder
&& playlist
->in_ram
)
2447 int index
= get_next_index(playlist
, steps
, -1);
2449 if (index
< 0 && steps
>= 0 && global_settings
.repeat_mode
== REPEAT_SHUFFLE
)
2450 index
= get_next_index(playlist
, steps
, REPEAT_ALL
);
2452 return (index
>= 0);
2455 /* get trackname of track that is "steps" away from current playing track.
2456 NULL is used to identify end of playlist */
2457 const char* playlist_peek(int steps
, char* buf
, size_t buf_size
)
2459 struct playlist_info
* playlist
= ¤t_playlist
;
2465 index
= get_next_index(playlist
, steps
, -1);
2469 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
2470 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
2472 if (get_filename(playlist
, index
, seek
, control_file
, buf
,
2478 if (!playlist
->in_ram
|| control_file
)
2480 /* remove bogus dirs from beginning of path
2481 (workaround for buggy playlist creation tools) */
2484 if (file_exists(temp_ptr
))
2487 temp_ptr
= strchr(temp_ptr
+1, '/');
2492 /* Even though this is an invalid file, we still need to pass a
2493 file name to the caller because NULL is used to indicate end
2503 * Update indices as track has changed
2505 int playlist_next(int steps
)
2507 struct playlist_info
* playlist
= ¤t_playlist
;
2511 #ifdef AB_REPEAT_ENABLE
2512 && (global_settings
.repeat_mode
!= REPEAT_AB
)
2514 && (global_settings
.repeat_mode
!= REPEAT_ONE
) )
2518 /* We need to delete all the queued songs */
2519 for (i
=0, j
=steps
; i
<j
; i
++)
2521 index
= get_next_index(playlist
, i
, -1);
2523 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
2525 remove_track_from_playlist(playlist
, index
, true);
2526 steps
--; /* one less track */
2531 index
= get_next_index(playlist
, steps
, -1);
2535 /* end of playlist... or is it */
2536 if (global_settings
.repeat_mode
== REPEAT_SHUFFLE
&&
2537 playlist
->amount
> 1)
2539 /* Repeat shuffle mode. Re-shuffle playlist and resume play */
2540 playlist
->first_index
= 0;
2541 sort_playlist(playlist
, false, false);
2542 randomise_playlist(playlist
, current_tick
, false, true);
2543 #if CONFIG_CODEC != SWCODEC
2544 playlist_start(0, 0);
2546 playlist
->index
= 0;
2549 else if (playlist
->in_ram
&& global_settings
.next_folder
)
2551 index
= create_and_play_dir(steps
, true);
2555 playlist
->index
= index
;
2562 playlist
->index
= index
;
2564 if (playlist
->last_insert_pos
>= 0 && steps
> 0)
2566 /* check to see if we've gone beyond the last inserted track */
2567 int cur
= rotate_index(playlist
, index
);
2568 int last_pos
= rotate_index(playlist
, playlist
->last_insert_pos
);
2572 /* reset last inserted track */
2573 playlist
->last_insert_pos
= -1;
2575 if (playlist
->control_fd
>= 0)
2577 int result
= update_control(playlist
, PLAYLIST_COMMAND_RESET
,
2578 -1, -1, NULL
, NULL
, NULL
);
2583 sync_control(playlist
, false);
2591 /* try playing next or previous folder */
2592 bool playlist_next_dir(int direction
)
2594 /* not to mess up real playlists */
2595 if(!current_playlist
.in_ram
)
2598 return create_and_play_dir(direction
, false) >= 0;
2601 /* Get resume info for current playing song. If return value is -1 then
2602 settings shouldn't be saved. */
2603 int playlist_get_resume_info(int *resume_index
)
2605 struct playlist_info
* playlist
= ¤t_playlist
;
2607 *resume_index
= playlist
->index
;
2612 /* Update resume info for current playing song. Returns -1 on error. */
2613 int playlist_update_resume_info(const struct mp3entry
* id3
)
2615 struct playlist_info
* playlist
= ¤t_playlist
;
2619 if (global_status
.resume_index
!= playlist
->index
||
2620 global_status
.resume_offset
!= id3
->offset
)
2622 global_status
.resume_index
= playlist
->index
;
2623 global_status
.resume_offset
= id3
->offset
;
2629 global_status
.resume_index
= -1;
2630 global_status
.resume_offset
= -1;
2637 /* Returns index of current playing track for display purposes. This value
2638 should not be used for resume purposes as it doesn't represent the actual
2639 index into the playlist */
2640 int playlist_get_display_index(void)
2642 struct playlist_info
* playlist
= ¤t_playlist
;
2644 /* first_index should always be index 0 for display purposes */
2645 int index
= rotate_index(playlist
, playlist
->index
);
2650 /* returns number of tracks in current playlist */
2651 int playlist_amount(void)
2653 return playlist_amount_ex(NULL
);
2655 /* set playlist->last_shuffle_start to playlist->amount for
2656 PLAYLIST_INSERT_LAST_SHUFFLED command purposes*/
2657 void playlist_set_last_shuffled_start(void)
2659 struct playlist_info
* playlist
= ¤t_playlist
;
2660 playlist
->last_shuffled_start
= playlist
->amount
;
2663 * Create a new playlist If playlist is not NULL then we're loading a
2664 * playlist off disk for viewing/editing. The index_buffer is used to store
2665 * playlist indices (required for and only used if !current playlist). The
2666 * temp_buffer (if not NULL) is used as a scratchpad when loading indices.
2668 int playlist_create_ex(struct playlist_info
* playlist
,
2669 const char* dir
, const char* file
,
2670 void* index_buffer
, int index_buffer_size
,
2671 void* temp_buffer
, int temp_buffer_size
)
2674 playlist
= ¤t_playlist
;
2677 /* Initialize playlist structure */
2678 int r
= rand() % 10;
2679 playlist
->current
= false;
2681 /* Use random name for control file */
2682 snprintf(playlist
->control_filename
, sizeof(playlist
->control_filename
),
2683 "%s.%d", PLAYLIST_CONTROL_FILE
, r
);
2685 playlist
->control_fd
= -1;
2689 int num_indices
= index_buffer_size
/ sizeof(int);
2691 #ifdef HAVE_DIRCACHE
2694 if (num_indices
> global_settings
.max_files_in_playlist
)
2695 num_indices
= global_settings
.max_files_in_playlist
;
2697 playlist
->max_playlist_size
= num_indices
;
2698 playlist
->indices
= index_buffer
;
2699 #ifdef HAVE_DIRCACHE
2700 playlist
->filenames
= (const struct dircache_entry
**)
2701 &playlist
->indices
[num_indices
];
2706 playlist
->max_playlist_size
= current_playlist
.max_playlist_size
;
2707 playlist
->indices
= current_playlist
.indices
;
2708 #ifdef HAVE_DIRCACHE
2709 playlist
->filenames
= current_playlist
.filenames
;
2713 playlist
->buffer_size
= 0;
2714 playlist
->buffer
= NULL
;
2715 playlist
->control_mutex
= &created_playlist_mutex
;
2718 new_playlist(playlist
, dir
, file
);
2721 /* load the playlist file */
2722 add_indices_to_playlist(playlist
, temp_buffer
, temp_buffer_size
);
2728 * Set the specified playlist as the current.
2729 * NOTE: You will get undefined behaviour if something is already playing so
2730 * remember to stop before calling this. Also, this call will
2731 * effectively close your playlist, making it unusable.
2733 int playlist_set_current(struct playlist_info
* playlist
)
2735 if (!playlist
|| (check_control(playlist
) < 0))
2738 empty_playlist(¤t_playlist
, false);
2740 strlcpy(current_playlist
.filename
, playlist
->filename
,
2741 sizeof(current_playlist
.filename
));
2743 current_playlist
.utf8
= playlist
->utf8
;
2744 current_playlist
.fd
= playlist
->fd
;
2746 close(playlist
->control_fd
);
2747 close(current_playlist
.control_fd
);
2748 remove(current_playlist
.control_filename
);
2749 if (rename(playlist
->control_filename
,
2750 current_playlist
.control_filename
) < 0)
2752 current_playlist
.control_fd
= open(current_playlist
.control_filename
,
2754 if (current_playlist
.control_fd
< 0)
2756 current_playlist
.control_created
= true;
2758 current_playlist
.dirlen
= playlist
->dirlen
;
2760 if (playlist
->indices
&& playlist
->indices
!= current_playlist
.indices
)
2762 memcpy(current_playlist
.indices
, playlist
->indices
,
2763 playlist
->max_playlist_size
*sizeof(int));
2764 #ifdef HAVE_DIRCACHE
2765 memcpy(current_playlist
.filenames
, playlist
->filenames
,
2766 playlist
->max_playlist_size
*sizeof(int));
2770 current_playlist
.first_index
= playlist
->first_index
;
2771 current_playlist
.amount
= playlist
->amount
;
2772 current_playlist
.last_insert_pos
= playlist
->last_insert_pos
;
2773 current_playlist
.seed
= playlist
->seed
;
2774 current_playlist
.shuffle_modified
= playlist
->shuffle_modified
;
2775 current_playlist
.deleted
= playlist
->deleted
;
2776 current_playlist
.num_inserted_tracks
= playlist
->num_inserted_tracks
;
2778 memcpy(current_playlist
.control_cache
, playlist
->control_cache
,
2779 sizeof(current_playlist
.control_cache
));
2780 current_playlist
.num_cached
= playlist
->num_cached
;
2781 current_playlist
.pending_control_sync
= playlist
->pending_control_sync
;
2785 struct playlist_info
*playlist_get_current(void)
2787 return ¤t_playlist
;
2790 * Close files and delete control file for non-current playlist.
2792 void playlist_close(struct playlist_info
* playlist
)
2797 if (playlist
->fd
>= 0)
2798 close(playlist
->fd
);
2800 if (playlist
->control_fd
>= 0)
2801 close(playlist
->control_fd
);
2803 if (playlist
->control_created
)
2804 remove(playlist
->control_filename
);
2807 void playlist_sync(struct playlist_info
* playlist
)
2810 playlist
= ¤t_playlist
;
2812 sync_control(playlist
, false);
2813 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2814 audio_flush_and_reload_tracks();
2816 #ifdef HAVE_DIRCACHE
2817 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2822 * Insert track into playlist at specified position (or one of the special
2823 * positions). Returns position where track was inserted or -1 if error.
2825 int playlist_insert_track(struct playlist_info
* playlist
, const char *filename
,
2826 int position
, bool queue
, bool sync
)
2831 playlist
= ¤t_playlist
;
2833 if (check_control(playlist
) < 0)
2835 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2839 result
= add_track_to_playlist(playlist
, filename
, position
, queue
, -1);
2841 /* Check if we want manually sync later. For example when adding
2842 * bunch of files from tagcache, syncing after every file wouldn't be
2843 * a good thing to do. */
2844 if (sync
&& result
>= 0)
2845 playlist_sync(playlist
);
2851 * Insert all tracks from specified directory into playlist.
2853 int playlist_insert_directory(struct playlist_info
* playlist
,
2854 const char *dirname
, int position
, bool queue
,
2858 unsigned char *count_str
;
2859 struct directory_search_context context
;
2862 playlist
= ¤t_playlist
;
2864 if (check_control(playlist
) < 0)
2866 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2870 if (position
== PLAYLIST_REPLACE
)
2872 if (playlist_remove_all_tracks(playlist
) == 0)
2873 position
= PLAYLIST_INSERT_LAST
;
2879 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
2881 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
2883 display_playlist_count(0, count_str
, false);
2885 context
.playlist
= playlist
;
2886 context
.position
= position
;
2887 context
.queue
= queue
;
2892 result
= playlist_directory_tracksearch(dirname
, recurse
,
2893 directory_search_callback
, &context
);
2895 sync_control(playlist
, false);
2899 display_playlist_count(context
.count
, count_str
, true);
2901 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2902 audio_flush_and_reload_tracks();
2904 #ifdef HAVE_DIRCACHE
2905 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2912 * Insert all tracks from specified playlist into dynamic playlist.
2914 int playlist_insert_playlist(struct playlist_info
* playlist
, const char *filename
,
2915 int position
, bool queue
)
2921 unsigned char *count_str
;
2922 char temp_buf
[MAX_PATH
+1];
2923 char trackname
[MAX_PATH
+1];
2926 bool utf8
= is_m3u8(filename
);
2929 playlist
= ¤t_playlist
;
2931 if (check_control(playlist
) < 0)
2933 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2937 fd
= open_utf8(filename
, O_RDONLY
);
2940 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
2944 /* we need the directory name for formatting purposes */
2947 temp_ptr
= strrchr(filename
+1,'/');
2954 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
2956 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
2958 display_playlist_count(count
, count_str
, false);
2960 if (position
== PLAYLIST_REPLACE
)
2962 if (playlist_remove_all_tracks(playlist
) == 0)
2963 position
= PLAYLIST_INSERT_LAST
;
2969 while ((max
= read_line(fd
, temp_buf
, sizeof(temp_buf
))) > 0)
2972 if (action_userabort(TIMEOUT_NOBLOCK
))
2975 if (temp_buf
[0] != '#' && temp_buf
[0] != '\0')
2981 /* Use trackname as a temporay buffer. Note that trackname must
2982 * be as large as temp_buf.
2984 max
= convert_m3u(temp_buf
, max
, sizeof(temp_buf
), trackname
);
2987 /* we need to format so that relative paths are correctly
2989 if (format_track_path(trackname
, temp_buf
, sizeof(trackname
), max
,
2996 insert_pos
= add_track_to_playlist(playlist
, trackname
, position
,
3005 /* Make sure tracks are inserted in correct order if user
3006 requests INSERT_FIRST */
3007 if (position
== PLAYLIST_INSERT_FIRST
|| position
>= 0)
3008 position
= insert_pos
+ 1;
3012 if ((count
%PLAYLIST_DISPLAY_COUNT
) == 0)
3014 display_playlist_count(count
, count_str
, false);
3016 if (count
== PLAYLIST_DISPLAY_COUNT
&&
3017 (audio_status() & AUDIO_STATUS_PLAY
) &&
3019 audio_flush_and_reload_tracks();
3023 /* let the other threads work */
3032 sync_control(playlist
, false);
3036 display_playlist_count(count
, count_str
, true);
3038 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3039 audio_flush_and_reload_tracks();
3041 #ifdef HAVE_DIRCACHE
3042 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3049 * Delete track at specified index. If index is PLAYLIST_DELETE_CURRENT then
3050 * we want to delete the current playing track.
3052 int playlist_delete(struct playlist_info
* playlist
, int index
)
3057 playlist
= ¤t_playlist
;
3059 if (check_control(playlist
) < 0)
3061 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3065 if (index
== PLAYLIST_DELETE_CURRENT
)
3066 index
= playlist
->index
;
3068 result
= remove_track_from_playlist(playlist
, index
, true);
3070 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3072 audio_flush_and_reload_tracks();
3078 * Move track at index to new_index. Tracks between the two are shifted
3079 * appropriately. Returns 0 on success and -1 on failure.
3081 int playlist_move(struct playlist_info
* playlist
, int index
, int new_index
)
3087 bool current
= false;
3089 char filename
[MAX_PATH
];
3092 playlist
= ¤t_playlist
;
3094 if (check_control(playlist
) < 0)
3096 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3100 if (index
== new_index
)
3103 if (index
== playlist
->index
)
3104 /* Moving the current track */
3107 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3108 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3109 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3111 if (get_filename(playlist
, index
, seek
, control_file
, filename
,
3112 sizeof(filename
)) < 0)
3115 /* We want to insert the track at the position that was specified by
3116 new_index. This may be different then new_index because of the
3117 shifting that will occur after the delete.
3118 We calculate this before we do the remove as it depends on the
3119 size of the playlist before the track removal */
3120 r
= rotate_index(playlist
, new_index
);
3122 /* Delete track from original position */
3123 result
= remove_track_from_playlist(playlist
, index
, true);
3129 new_index
= PLAYLIST_PREPEND
;
3130 else if (r
== playlist
->amount
)
3132 new_index
= PLAYLIST_INSERT_LAST
;
3134 /* Calculate index of desired position */
3135 new_index
= (r
+playlist
->first_index
)%playlist
->amount
;
3137 result
= add_track_to_playlist(playlist
, filename
, new_index
, queue
,
3144 /* Moved the current track */
3147 case PLAYLIST_PREPEND
:
3148 playlist
->index
= playlist
->first_index
;
3150 case PLAYLIST_INSERT_LAST
:
3151 playlist
->index
= playlist
->first_index
- 1;
3152 if (playlist
->index
< 0)
3153 playlist
->index
+= playlist
->amount
;
3156 playlist
->index
= new_index
;
3161 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3162 audio_flush_and_reload_tracks();
3166 #ifdef HAVE_DIRCACHE
3167 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3173 /* shuffle currently playing playlist */
3174 int playlist_randomise(struct playlist_info
* playlist
, unsigned int seed
,
3180 playlist
= ¤t_playlist
;
3182 check_control(playlist
);
3184 result
= randomise_playlist(playlist
, seed
, start_current
, true);
3186 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3188 audio_flush_and_reload_tracks();
3193 /* sort currently playing playlist */
3194 int playlist_sort(struct playlist_info
* playlist
, bool start_current
)
3199 playlist
= ¤t_playlist
;
3201 check_control(playlist
);
3203 result
= sort_playlist(playlist
, start_current
, true);
3205 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3207 audio_flush_and_reload_tracks();
3212 /* returns true if playlist has been modified */
3213 bool playlist_modified(const struct playlist_info
* playlist
)
3216 playlist
= ¤t_playlist
;
3218 if (playlist
->shuffle_modified
||
3219 playlist
->deleted
||
3220 playlist
->num_inserted_tracks
> 0)
3226 /* returns index of first track in playlist */
3227 int playlist_get_first_index(const struct playlist_info
* playlist
)
3230 playlist
= ¤t_playlist
;
3232 return playlist
->first_index
;
3235 /* returns shuffle seed of playlist */
3236 int playlist_get_seed(const struct playlist_info
* playlist
)
3239 playlist
= ¤t_playlist
;
3241 return playlist
->seed
;
3244 /* returns number of tracks in playlist (includes queued/inserted tracks) */
3245 int playlist_amount_ex(const struct playlist_info
* playlist
)
3248 playlist
= ¤t_playlist
;
3250 return playlist
->amount
;
3253 /* returns full path of playlist (minus extension) */
3254 char *playlist_name(const struct playlist_info
* playlist
, char *buf
,
3260 playlist
= ¤t_playlist
;
3262 strlcpy(buf
, playlist
->filename
+playlist
->dirlen
, buf_size
);
3267 /* Remove extension */
3268 sep
= strrchr(buf
, '.');
3275 /* returns the playlist filename */
3276 char *playlist_get_name(const struct playlist_info
* playlist
, char *buf
,
3280 playlist
= ¤t_playlist
;
3282 strlcpy(buf
, playlist
->filename
, buf_size
);
3290 /* Fills info structure with information about track at specified index.
3291 Returns 0 on success and -1 on failure */
3292 int playlist_get_track_info(struct playlist_info
* playlist
, int index
,
3293 struct playlist_track_info
* info
)
3299 playlist
= ¤t_playlist
;
3301 if (index
< 0 || index
>= playlist
->amount
)
3304 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3305 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3307 if (get_filename(playlist
, index
, seek
, control_file
, info
->filename
,
3308 sizeof(info
->filename
)) < 0)
3315 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
3316 info
->attr
|= PLAYLIST_ATTR_QUEUED
;
3318 info
->attr
|= PLAYLIST_ATTR_INSERTED
;
3322 if (playlist
->indices
[index
] & PLAYLIST_SKIPPED
)
3323 info
->attr
|= PLAYLIST_ATTR_SKIPPED
;
3325 info
->index
= index
;
3326 info
->display_index
= rotate_index(playlist
, index
) + 1;
3331 /* save the current dynamic playlist to specified file */
3332 int playlist_save(struct playlist_info
* playlist
, char *filename
)
3337 char path
[MAX_PATH
+1];
3338 char tmp_buf
[MAX_PATH
+1];
3340 bool overwrite_current
= false;
3341 int* index_buf
= NULL
;
3344 playlist
= ¤t_playlist
;
3346 if (playlist
->amount
<= 0)
3349 /* use current working directory as base for pathname */
3350 if (format_track_path(path
, filename
, sizeof(tmp_buf
),
3351 strlen(filename
)+1, getcwd(NULL
, -1)) < 0)
3354 if (!strncmp(playlist
->filename
, path
, strlen(path
)))
3356 /* Attempting to overwrite current playlist file.*/
3358 if (playlist
->buffer_size
< (int)(playlist
->amount
* sizeof(int)))
3360 /* not enough buffer space to store updated indices */
3361 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3365 /* in_ram buffer is unused for m3u files so we'll use for storing
3367 index_buf
= (int*)playlist
->buffer
;
3369 /* use temporary pathname */
3370 snprintf(path
, sizeof(path
), "%s_temp", playlist
->filename
);
3371 overwrite_current
= true;
3376 fd
= open_utf8(path
, O_CREAT
|O_WRONLY
|O_TRUNC
);
3380 /* some applications require a BOM to read the file properly */
3381 fd
= open(path
, O_CREAT
|O_WRONLY
|O_TRUNC
, 0666);
3385 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3389 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
), false);
3393 index
= playlist
->first_index
;
3394 for (i
=0; i
<playlist
->amount
; i
++)
3401 if (action_userabort(TIMEOUT_NOBLOCK
))
3407 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3408 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3409 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3411 /* Don't save queued files */
3414 if (get_filename(playlist
, index
, seek
, control_file
, tmp_buf
,
3421 if (overwrite_current
)
3422 index_buf
[count
] = lseek(fd
, 0, SEEK_CUR
);
3424 if (fdprintf(fd
, "%s\n", tmp_buf
) < 0)
3426 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3433 if ((count
% PLAYLIST_DISPLAY_COUNT
) == 0)
3434 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
),
3440 index
= (index
+1)%playlist
->amount
;
3443 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
), true);
3447 if (overwrite_current
&& result
>= 0)
3451 mutex_lock(playlist
->control_mutex
);
3453 /* Replace the current playlist with the new one and update indices */
3454 close(playlist
->fd
);
3455 if (remove(playlist
->filename
) >= 0)
3457 if (rename(path
, playlist
->filename
) >= 0)
3459 playlist
->fd
= open_utf8(playlist
->filename
, O_RDONLY
);
3460 if (playlist
->fd
>= 0)
3462 index
= playlist
->first_index
;
3463 for (i
=0, count
=0; i
<playlist
->amount
; i
++)
3465 if (!(playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
))
3467 playlist
->indices
[index
] = index_buf
[count
];
3470 index
= (index
+1)%playlist
->amount
;
3473 /* we need to recreate control because inserted tracks are
3474 now part of the playlist and shuffle has been
3476 result
= recreate_control(playlist
);
3481 mutex_unlock(playlist
->control_mutex
);
3491 * Search specified directory for tracks and notify via callback. May be
3492 * called recursively.
3494 int playlist_directory_tracksearch(const char* dirname
, bool recurse
,
3495 int (*callback
)(char*, void*),
3498 char buf
[MAX_PATH
+1];
3502 struct entry
*files
;
3503 struct tree_context
* tc
= tree_get_context();
3504 int old_dirfilter
= *(tc
->dirfilter
);
3509 /* use the tree browser dircache to load files */
3510 *(tc
->dirfilter
) = SHOW_ALL
;
3512 if (ft_load(tc
, dirname
) < 0)
3514 splash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
3515 *(tc
->dirfilter
) = old_dirfilter
;
3519 files
= (struct entry
*) tc
->dircache
;
3520 num_files
= tc
->filesindir
;
3522 /* we've overwritten the dircache so tree browser will need to be
3526 for (i
=0; i
<num_files
; i
++)
3529 if (action_userabort(TIMEOUT_NOBLOCK
))
3535 if (files
[i
].attr
& ATTR_DIRECTORY
)
3539 /* recursively add directories */
3540 snprintf(buf
, sizeof(buf
), "%s/%s",
3541 dirname
[1]? dirname
: "", files
[i
].name
);
3542 result
= playlist_directory_tracksearch(buf
, recurse
,
3547 /* we now need to reload our current directory */
3548 if(ft_load(tc
, dirname
) < 0)
3554 files
= (struct entry
*) tc
->dircache
;
3555 num_files
= tc
->filesindir
;
3565 else if ((files
[i
].attr
& FILE_ATTR_MASK
) == FILE_ATTR_AUDIO
)
3567 snprintf(buf
, sizeof(buf
), "%s/%s",
3568 dirname
[1]? dirname
: "", files
[i
].name
);
3570 if (callback(buf
, context
) != 0)
3576 /* let the other threads work */
3581 /* restore dirfilter */
3582 *(tc
->dirfilter
) = old_dirfilter
;