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.
75 #include "ata_idle_notify.h"
86 #include "applimits.h"
95 #include "filetypes.h"
96 #ifdef HAVE_LCD_BITMAP
104 #include "rbunicode.h"
105 #include "root_menu.h"
107 #define PLAYLIST_CONTROL_FILE ROCKBOX_DIR "/.playlist_control"
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
;
148 static char now_playing
[MAX_PATH
+1];
150 static void empty_playlist(struct playlist_info
* playlist
, bool resume
);
151 static void new_playlist(struct playlist_info
* playlist
, const char *dir
,
153 static void create_control(struct playlist_info
* playlist
);
154 static int check_control(struct playlist_info
* playlist
);
155 static int recreate_control(struct playlist_info
* playlist
);
156 static void update_playlist_filename(struct playlist_info
* playlist
,
157 const char *dir
, const char *file
);
158 static int add_indices_to_playlist(struct playlist_info
* playlist
,
159 char* buffer
, size_t buflen
);
160 static int add_track_to_playlist(struct playlist_info
* playlist
,
161 const char *filename
, int position
,
162 bool queue
, int seek_pos
);
163 static int directory_search_callback(char* filename
, void* context
);
164 static int remove_track_from_playlist(struct playlist_info
* playlist
,
165 int position
, bool write
);
166 static int randomise_playlist(struct playlist_info
* playlist
,
167 unsigned int seed
, bool start_current
,
169 static int sort_playlist(struct playlist_info
* playlist
, bool start_current
,
171 static int get_next_index(const struct playlist_info
* playlist
, int steps
,
173 static void find_and_set_playlist_index(struct playlist_info
* playlist
,
175 static int compare(const void* p1
, const void* p2
);
176 static int get_filename(struct playlist_info
* playlist
, int index
, int seek
,
177 bool control_file
, char *buf
, int buf_length
);
178 static int get_next_directory(char *dir
);
179 static int get_next_dir(char *dir
, bool is_forward
, bool recursion
);
180 static int get_previous_directory(char *dir
);
181 static int check_subdir_for_music(char *dir
, const char *subdir
, bool recurse
);
182 static int format_track_path(char *dest
, char *src
, int buf_length
, int max
,
184 static void display_playlist_count(int count
, const unsigned char *fmt
,
186 static void display_buffer_full(void);
187 static int flush_cached_control(struct playlist_info
* playlist
);
188 static int update_control(struct playlist_info
* playlist
,
189 enum playlist_command command
, int i1
, int i2
,
190 const char* s1
, const char* s2
, void* data
);
191 static void sync_control(struct playlist_info
* playlist
, bool force
);
192 static int rotate_index(const struct playlist_info
* playlist
, int index
);
195 #define PLAYLIST_LOAD_POINTERS 1
197 static struct event_queue playlist_queue
;
198 static long playlist_stack
[(DEFAULT_STACK_SIZE
+ 0x800)/sizeof(long)];
199 static const char playlist_thread_name
[] = "playlist cachectrl";
202 /* Check if the filename suggests M3U or M3U8 format. */
203 static bool is_m3u8(const char* filename
)
205 int len
= strlen(filename
);
207 /* Default to M3U8 unless explicitly told otherwise. */
208 return !(len
> 4 && strcasecmp(&filename
[len
- 4], ".m3u") == 0);
212 /* Convert a filename in an M3U playlist to UTF-8.
214 * buf - the filename to convert; can contain more than one line from the
216 * buf_len - amount of buf that is used.
217 * buf_max - total size of buf.
218 * temp - temporary conversion buffer, at least buf_max bytes.
220 * Returns the length of the converted filename.
222 static int convert_m3u(char* buf
, int buf_len
, int buf_max
, char* temp
)
228 while ((buf
[i
] != '\n') && (buf
[i
] != '\r') && (i
< buf_len
))
233 /* Work back killing white space. */
234 while ((i
> 0) && isspace(buf
[i
- 1]))
242 /* Convert char by char, so as to not overflow temp (iso_decode should
243 * preferably handle this). No more than 4 bytes should be generated for
246 for (i
= 0; i
< buf_len
&& dest
< (temp
+ buf_max
- 4); i
++)
248 dest
= iso_decode(&buf
[i
], dest
, -1, 1);
257 * remove any files and indices associated with the playlist
259 static void empty_playlist(struct playlist_info
* playlist
, bool resume
)
261 playlist
->filename
[0] = '\0';
262 playlist
->utf8
= true;
264 if(playlist
->fd
>= 0)
265 /* If there is an already open playlist, close it. */
269 if(playlist
->control_fd
>= 0)
270 close(playlist
->control_fd
);
271 playlist
->control_fd
= -1;
272 playlist
->control_created
= false;
274 playlist
->in_ram
= false;
276 if (playlist
->buffer
)
277 playlist
->buffer
[0] = 0;
279 playlist
->buffer_end_pos
= 0;
282 playlist
->first_index
= 0;
283 playlist
->amount
= 0;
284 playlist
->last_insert_pos
= -1;
286 playlist
->shuffle_modified
= false;
287 playlist
->deleted
= false;
288 playlist
->num_inserted_tracks
= 0;
289 playlist
->started
= false;
291 playlist
->num_cached
= 0;
292 playlist
->pending_control_sync
= false;
294 if (!resume
&& playlist
->current
)
296 /* start with fresh playlist control file when starting new
298 create_control(playlist
);
303 * Initialize a new playlist for viewing/editing/playing. dir is the
304 * directory where the playlist is located and file is the filename.
306 static void new_playlist(struct playlist_info
* playlist
, const char *dir
,
309 const char *fileused
= file
;
310 const char *dirused
= dir
;
311 empty_playlist(playlist
, false);
317 if (dirused
&& playlist
->current
) /* !current cannot be in_ram */
318 playlist
->in_ram
= true;
320 dirused
= ""; /* empty playlist */
323 update_playlist_filename(playlist
, dirused
, fileused
);
325 if (playlist
->control_fd
>= 0)
327 update_control(playlist
, PLAYLIST_COMMAND_PLAYLIST
,
328 PLAYLIST_CONTROL_FILE_VERSION
, -1, dirused
, fileused
, NULL
);
329 sync_control(playlist
, false);
334 * create control file for playlist
336 static void create_control(struct playlist_info
* playlist
)
338 playlist
->control_fd
= open(playlist
->control_filename
,
339 O_CREAT
|O_RDWR
|O_TRUNC
);
340 if (playlist
->control_fd
< 0)
342 if (check_rockboxdir())
344 cond_talk_ids_fq(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
);
345 splashf(HZ
*2, (unsigned char *)"%s (%d)",
346 str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
),
347 playlist
->control_fd
);
349 playlist
->control_created
= false;
353 playlist
->control_created
= true;
358 * validate the control file. This may include creating/initializing it if
361 static int check_control(struct playlist_info
* playlist
)
363 if (!playlist
->control_created
)
365 create_control(playlist
);
367 if (playlist
->control_fd
>= 0)
369 char* dir
= playlist
->filename
;
370 char* file
= playlist
->filename
+playlist
->dirlen
;
371 char c
= playlist
->filename
[playlist
->dirlen
-1];
373 playlist
->filename
[playlist
->dirlen
-1] = '\0';
375 update_control(playlist
, PLAYLIST_COMMAND_PLAYLIST
,
376 PLAYLIST_CONTROL_FILE_VERSION
, -1, dir
, file
, NULL
);
377 sync_control(playlist
, false);
378 playlist
->filename
[playlist
->dirlen
-1] = c
;
382 if (playlist
->control_fd
< 0)
389 * recreate the control file based on current playlist entries
391 static int recreate_control(struct playlist_info
* playlist
)
393 char temp_file
[MAX_PATH
+1];
398 if(playlist
->control_fd
>= 0)
400 char* dir
= playlist
->filename
;
401 char* file
= playlist
->filename
+playlist
->dirlen
;
402 char c
= playlist
->filename
[playlist
->dirlen
-1];
404 close(playlist
->control_fd
);
406 snprintf(temp_file
, sizeof(temp_file
), "%s_temp",
407 playlist
->control_filename
);
409 if (rename(playlist
->control_filename
, temp_file
) < 0)
412 temp_fd
= open(temp_file
, O_RDONLY
);
416 playlist
->control_fd
= open(playlist
->control_filename
,
417 O_CREAT
|O_RDWR
|O_TRUNC
);
418 if (playlist
->control_fd
< 0)
421 playlist
->filename
[playlist
->dirlen
-1] = '\0';
423 /* cannot call update_control() because of mutex */
424 result
= fdprintf(playlist
->control_fd
, "P:%d:%s:%s\n",
425 PLAYLIST_CONTROL_FILE_VERSION
, dir
, file
);
427 playlist
->filename
[playlist
->dirlen
-1] = c
;
437 playlist
->shuffle_modified
= false;
438 playlist
->deleted
= false;
439 playlist
->num_inserted_tracks
= 0;
441 for (i
=0; i
<playlist
->amount
; i
++)
443 if (playlist
->indices
[i
] & PLAYLIST_INSERT_TYPE_MASK
)
445 bool queue
= playlist
->indices
[i
] & PLAYLIST_QUEUE_MASK
;
446 char inserted_file
[MAX_PATH
+1];
448 lseek(temp_fd
, playlist
->indices
[i
] & PLAYLIST_SEEK_MASK
,
450 read_line(temp_fd
, inserted_file
, sizeof(inserted_file
));
452 result
= fdprintf(playlist
->control_fd
, "%c:%d:%d:",
453 queue
?'Q':'A', i
, playlist
->last_insert_pos
);
456 /* save the position in file where name is written */
457 int seek_pos
= lseek(playlist
->control_fd
, 0, SEEK_CUR
);
459 result
= fdprintf(playlist
->control_fd
, "%s\n",
462 playlist
->indices
[i
] =
463 (playlist
->indices
[i
] & ~PLAYLIST_SEEK_MASK
) | seek_pos
;
469 playlist
->num_inserted_tracks
++;
475 fsync(playlist
->control_fd
);
484 * store directory and name of playlist file
486 static void update_playlist_filename(struct playlist_info
* playlist
,
487 const char *dir
, const char *file
)
490 int dirlen
= strlen(dir
);
492 playlist
->utf8
= is_m3u8(file
);
494 /* If the dir does not end in trailing slash, we use a separator.
495 Otherwise we don't. */
496 if('/' != dir
[dirlen
-1])
502 playlist
->dirlen
= dirlen
;
504 snprintf(playlist
->filename
, sizeof(playlist
->filename
),
505 "%s%s%s", dir
, sep
, file
);
509 * calculate track offsets within a playlist file
511 static int add_indices_to_playlist(struct playlist_info
* playlist
,
512 char* buffer
, size_t buflen
)
516 unsigned int count
= 0;
521 if(-1 == playlist
->fd
)
522 playlist
->fd
= open_utf8(playlist
->filename
, O_RDONLY
);
524 return -1; /* failure */
525 if((i
= lseek(playlist
->fd
, 0, SEEK_CUR
)) > 0)
526 playlist
->utf8
= true; /* Override any earlier indication. */
528 splash(0, ID2P(LANG_WAIT
));
532 /* use mp3 buffer for maximum load speed */
534 #if CONFIG_CODEC != SWCODEC
535 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
536 buflen
= (audiobufend
- audiobuf
);
537 buffer
= (char *)audiobuf
;
539 buffer
= (char *)audio_get_buffer(false, &buflen
);
547 nread
= read(playlist
->fd
, buffer
, buflen
);
548 /* Terminate on EOF */
552 p
= (unsigned char *)buffer
;
554 for(count
=0; count
< nread
; count
++,p
++) {
556 /* Are we on a new line? */
557 if((*p
== '\n') || (*p
== '\r'))
567 if ( playlist
->amount
>= playlist
->max_playlist_size
) {
568 display_buffer_full();
573 /* Store a new entry */
574 playlist
->indices
[ playlist
->amount
] = i
+count
;
576 if (playlist
->filenames
)
577 playlist
->filenames
[ playlist
->amount
] = NULL
;
589 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
596 * Utility function to create a new playlist, fill it with the next or
597 * previous directory, shuffle it if needed, and start playback.
598 * If play_last is true and direction zero or negative, start playing
599 * the last file in the directory, otherwise start playing the first.
601 static int create_and_play_dir(int direction
, bool play_last
)
603 char dir
[MAX_PATH
+ 1];
608 res
= get_next_directory(dir
);
610 res
= get_previous_directory(dir
);
614 if (playlist_create(dir
, NULL
) != -1)
616 ft_build_playlist(tree_get_context(), 0);
618 if (global_settings
.playlist_shuffle
)
619 playlist_shuffle(current_tick
, -1);
621 if (play_last
&& direction
<= 0)
622 index
= current_playlist
.amount
- 1;
626 #if (CONFIG_CODEC != SWCODEC)
627 playlist_start(index
, 0);
631 /* we've overwritten the dircache when getting the next/previous dir,
632 so the tree browser context will need to be reloaded */
640 * Removes all tracks, from the playlist, leaving the presently playing
643 int playlist_remove_all_tracks(struct playlist_info
*playlist
)
647 if (playlist
== NULL
)
648 playlist
= ¤t_playlist
;
650 while (playlist
->index
> 0)
651 if ((result
= remove_track_from_playlist(playlist
, 0, true)) < 0)
654 while (playlist
->amount
> 1)
655 if ((result
= remove_track_from_playlist(playlist
, 1, true)) < 0)
658 if (playlist
->amount
== 1) {
659 playlist
->indices
[0] |= PLAYLIST_QUEUED
;
667 * Add track to playlist at specified position. There are seven special
668 * positions that can be specified:
669 * PLAYLIST_PREPEND - Add track at beginning of playlist
670 * PLAYLIST_INSERT - Add track after current song. NOTE: If
671 * there are already inserted tracks then track
672 * is added to the end of the insertion list
673 * PLAYLIST_INSERT_FIRST - Add track immediately after current song, no
674 * matter what other tracks have been inserted
675 * PLAYLIST_INSERT_LAST - Add track to end of playlist
676 * PLAYLIST_INSERT_SHUFFLED - Add track at some random point between the
677 * current playing track and end of playlist
678 * PLAYLIST_INSERT_LAST_SHUFFLED - Add tracks in random order to the end of
680 * PLAYLIST_REPLACE - Erase current playlist, Cue the current track
681 * and inster this track at the end.
683 static int add_track_to_playlist(struct playlist_info
* playlist
,
684 const char *filename
, int position
,
685 bool queue
, int seek_pos
)
687 int insert_position
, orig_position
;
688 unsigned long flags
= PLAYLIST_INSERT_TYPE_INSERT
;
691 insert_position
= orig_position
= position
;
693 if (playlist
->amount
>= playlist
->max_playlist_size
)
695 display_buffer_full();
701 case PLAYLIST_PREPEND
:
702 position
= insert_position
= playlist
->first_index
;
704 case PLAYLIST_INSERT
:
705 /* if there are already inserted tracks then add track to end of
706 insertion list else add after current playing track */
707 if (playlist
->last_insert_pos
>= 0 &&
708 playlist
->last_insert_pos
< playlist
->amount
&&
709 (playlist
->indices
[playlist
->last_insert_pos
]&
710 PLAYLIST_INSERT_TYPE_MASK
) == PLAYLIST_INSERT_TYPE_INSERT
)
711 position
= insert_position
= playlist
->last_insert_pos
+1;
712 else if (playlist
->amount
> 0)
713 position
= insert_position
= playlist
->index
+ 1;
715 position
= insert_position
= 0;
717 playlist
->last_insert_pos
= position
;
719 case PLAYLIST_INSERT_FIRST
:
720 if (playlist
->amount
> 0)
721 position
= insert_position
= playlist
->index
+ 1;
723 position
= insert_position
= 0;
725 playlist
->last_insert_pos
= position
;
727 case PLAYLIST_INSERT_LAST
:
728 if (playlist
->first_index
> 0)
729 position
= insert_position
= playlist
->first_index
;
731 position
= insert_position
= playlist
->amount
;
733 playlist
->last_insert_pos
= position
;
735 case PLAYLIST_INSERT_SHUFFLED
:
737 if (playlist
->started
)
740 int n
= playlist
->amount
-
741 rotate_index(playlist
, playlist
->index
);
748 position
= playlist
->index
+ offset
+ 1;
749 if (position
>= playlist
->amount
)
750 position
-= playlist
->amount
;
752 insert_position
= position
;
755 position
= insert_position
= (rand() % (playlist
->amount
+1));
758 case PLAYLIST_INSERT_LAST_SHUFFLED
:
760 position
= insert_position
= playlist
->last_shuffled_start
+
761 rand() % (playlist
->amount
- playlist
->last_shuffled_start
+ 1);
764 case PLAYLIST_REPLACE
:
765 if (playlist_remove_all_tracks(playlist
) < 0)
768 playlist
->last_insert_pos
= position
= insert_position
= playlist
->index
+ 1;
773 flags
|= PLAYLIST_QUEUED
;
775 /* shift indices so that track can be added */
776 for (i
=playlist
->amount
; i
>insert_position
; i
--)
778 playlist
->indices
[i
] = playlist
->indices
[i
-1];
780 if (playlist
->filenames
)
781 playlist
->filenames
[i
] = playlist
->filenames
[i
-1];
785 /* update stored indices if needed */
787 if (orig_position
< 0)
789 if (playlist
->amount
> 0 && insert_position
<= playlist
->index
&&
793 if (playlist
->amount
> 0 && insert_position
<= playlist
->first_index
&&
794 orig_position
!= PLAYLIST_PREPEND
&& playlist
->started
)
795 playlist
->first_index
++;
798 if (insert_position
< playlist
->last_insert_pos
||
799 (insert_position
== playlist
->last_insert_pos
&& position
< 0))
800 playlist
->last_insert_pos
++;
802 if (seek_pos
< 0 && playlist
->control_fd
>= 0)
804 int result
= update_control(playlist
,
805 (queue
?PLAYLIST_COMMAND_QUEUE
:PLAYLIST_COMMAND_ADD
), position
,
806 playlist
->last_insert_pos
, filename
, NULL
, &seek_pos
);
812 playlist
->indices
[insert_position
] = flags
| seek_pos
;
815 if (playlist
->filenames
)
816 playlist
->filenames
[insert_position
] = NULL
;
820 playlist
->num_inserted_tracks
++;
822 return insert_position
;
826 * Callback for playlist_directory_tracksearch to insert track into
829 static int directory_search_callback(char* filename
, void* context
)
831 struct directory_search_context
* c
=
832 (struct directory_search_context
*) context
;
835 insert_pos
= add_track_to_playlist(c
->playlist
, filename
, c
->position
,
843 /* Make sure tracks are inserted in correct order if user requests
845 if (c
->position
== PLAYLIST_INSERT_FIRST
|| c
->position
>= 0)
846 c
->position
= insert_pos
+ 1;
848 if (((c
->count
)%PLAYLIST_DISPLAY_COUNT
) == 0)
850 unsigned char* count_str
;
853 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
855 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
857 display_playlist_count(c
->count
, count_str
, false);
859 if ((c
->count
) == PLAYLIST_DISPLAY_COUNT
&&
860 (audio_status() & AUDIO_STATUS_PLAY
) &&
861 c
->playlist
->started
)
862 audio_flush_and_reload_tracks();
869 * remove track at specified position
871 static int remove_track_from_playlist(struct playlist_info
* playlist
,
872 int position
, bool write
)
877 if (playlist
->amount
<= 0)
880 inserted
= playlist
->indices
[position
] & PLAYLIST_INSERT_TYPE_MASK
;
882 /* shift indices now that track has been removed */
883 for (i
=position
; i
<playlist
->amount
; i
++)
885 playlist
->indices
[i
] = playlist
->indices
[i
+1];
887 if (playlist
->filenames
)
888 playlist
->filenames
[i
] = playlist
->filenames
[i
+1];
895 playlist
->num_inserted_tracks
--;
897 playlist
->deleted
= true;
899 /* update stored indices if needed */
900 if (position
< playlist
->index
)
903 if (position
< playlist
->first_index
)
905 playlist
->first_index
--;
908 if (position
<= playlist
->last_insert_pos
)
909 playlist
->last_insert_pos
--;
911 if (write
&& playlist
->control_fd
>= 0)
913 int result
= update_control(playlist
, PLAYLIST_COMMAND_DELETE
,
914 position
, -1, NULL
, NULL
, NULL
);
919 sync_control(playlist
, false);
926 * randomly rearrange the array of indices for the playlist. If start_current
927 * is true then update the index to the new index of the current playing track
929 static int randomise_playlist(struct playlist_info
* playlist
,
930 unsigned int seed
, bool start_current
,
936 unsigned int current
= playlist
->indices
[playlist
->index
];
938 /* seed 0 is used to identify sorted playlist for resume purposes */
942 /* seed with the given seed */
945 /* randomise entire indices list */
946 for(count
= playlist
->amount
- 1; count
>= 0; count
--)
948 /* the rand is from 0 to RAND_MAX, so adjust to our value range */
949 candidate
= rand() % (count
+ 1);
951 /* now swap the values at the 'count' and 'candidate' positions */
952 store
= playlist
->indices
[candidate
];
953 playlist
->indices
[candidate
] = playlist
->indices
[count
];
954 playlist
->indices
[count
] = store
;
956 if (playlist
->filenames
)
958 store
= (long)playlist
->filenames
[candidate
];
959 playlist
->filenames
[candidate
] = playlist
->filenames
[count
];
960 playlist
->filenames
[count
] = (struct dircache_entry
*)store
;
966 find_and_set_playlist_index(playlist
, current
);
968 /* indices have been moved so last insert position is no longer valid */
969 playlist
->last_insert_pos
= -1;
971 playlist
->seed
= seed
;
972 if (playlist
->num_inserted_tracks
> 0 || playlist
->deleted
)
973 playlist
->shuffle_modified
= true;
977 update_control(playlist
, PLAYLIST_COMMAND_SHUFFLE
, seed
,
978 playlist
->first_index
, NULL
, NULL
, NULL
);
985 * Sort the array of indices for the playlist. If start_current is true then
986 * set the index to the new index of the current song.
988 static int sort_playlist(struct playlist_info
* playlist
, bool start_current
,
991 unsigned int current
= playlist
->indices
[playlist
->index
];
993 if (playlist
->amount
> 0)
994 qsort(playlist
->indices
, playlist
->amount
,
995 sizeof(playlist
->indices
[0]), compare
);
998 /** We need to re-check the song names from disk because qsort can't
999 * sort two arrays at once :/
1000 * FIXME: Please implement a better way to do this. */
1001 memset(playlist
->filenames
, 0, playlist
->max_playlist_size
* sizeof(int));
1002 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
1006 find_and_set_playlist_index(playlist
, current
);
1008 /* indices have been moved so last insert position is no longer valid */
1009 playlist
->last_insert_pos
= -1;
1011 if (!playlist
->num_inserted_tracks
&& !playlist
->deleted
)
1012 playlist
->shuffle_modified
= false;
1013 if (write
&& playlist
->control_fd
>= 0)
1015 update_control(playlist
, PLAYLIST_COMMAND_UNSHUFFLE
,
1016 playlist
->first_index
, -1, NULL
, NULL
, NULL
);
1022 /* Calculate how many steps we have to really step when skipping entries
1025 static int calculate_step_count(const struct playlist_info
*playlist
, int steps
)
1027 int i
, count
, direction
;
1029 int stepped_count
= 0;
1042 index
= playlist
->index
;
1045 /* Boundary check */
1047 index
+= playlist
->amount
;
1048 if (index
>= playlist
->amount
)
1049 index
-= playlist
->amount
;
1051 /* Check if we found a bad entry. */
1052 if (playlist
->indices
[index
] & PLAYLIST_SKIPPED
)
1055 /* Are all entries bad? */
1056 if (stepped_count
++ > playlist
->amount
)
1063 } while (i
<= count
);
1068 /* Marks the index of the track to be skipped that is "steps" away from
1069 * current playing track.
1071 void playlist_skip_entry(struct playlist_info
*playlist
, int steps
)
1075 if (playlist
== NULL
)
1076 playlist
= ¤t_playlist
;
1078 /* need to account for already skipped tracks */
1079 steps
= calculate_step_count(playlist
, steps
);
1081 index
= playlist
->index
+ steps
;
1083 index
+= playlist
->amount
;
1084 else if (index
>= playlist
->amount
)
1085 index
-= playlist
->amount
;
1087 playlist
->indices
[index
] |= PLAYLIST_SKIPPED
;
1091 * returns the index of the track that is "steps" away from current playing
1094 static int get_next_index(const struct playlist_info
* playlist
, int steps
,
1097 int current_index
= playlist
->index
;
1098 int next_index
= -1;
1100 if (playlist
->amount
<= 0)
1103 if (repeat_mode
== -1)
1104 repeat_mode
= global_settings
.repeat_mode
;
1106 if (repeat_mode
== REPEAT_SHUFFLE
&& playlist
->amount
<= 1)
1107 repeat_mode
= REPEAT_ALL
;
1109 steps
= calculate_step_count(playlist
, steps
);
1110 switch (repeat_mode
)
1112 case REPEAT_SHUFFLE
:
1113 /* Treat repeat shuffle just like repeat off. At end of playlist,
1114 play will be resumed in playlist_next() */
1117 current_index
= rotate_index(playlist
, current_index
);
1118 next_index
= current_index
+steps
;
1119 if ((next_index
< 0) || (next_index
>= playlist
->amount
))
1122 next_index
= (next_index
+playlist
->first_index
) %
1129 #ifdef AB_REPEAT_ENABLE
1132 next_index
= current_index
;
1138 next_index
= (current_index
+steps
) % playlist
->amount
;
1139 while (next_index
< 0)
1140 next_index
+= playlist
->amount
;
1142 if (steps
>= playlist
->amount
)
1149 /* second time around so skip the queued files */
1150 for (i
=0; i
<playlist
->amount
; i
++)
1152 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
1153 index
= (index
+1) % playlist
->amount
;
1165 /* No luck if the whole playlist was bad. */
1166 if (playlist
->indices
[next_index
] & PLAYLIST_SKIPPED
)
1173 * Search for the seek track and set appropriate indices. Used after shuffle
1174 * to make sure the current index is still pointing to correct track.
1176 static void find_and_set_playlist_index(struct playlist_info
* playlist
,
1181 /* Set the index to the current song */
1182 for (i
=0; i
<playlist
->amount
; i
++)
1184 if (playlist
->indices
[i
] == seek
)
1186 playlist
->index
= playlist
->first_index
= i
;
1194 * used to sort track indices. Sort order is as follows:
1195 * 1. Prepended tracks (in prepend order)
1196 * 2. Playlist/directory tracks (in playlist order)
1197 * 3. Inserted/Appended tracks (in insert order)
1199 static int compare(const void* p1
, const void* p2
)
1201 unsigned long* e1
= (unsigned long*) p1
;
1202 unsigned long* e2
= (unsigned long*) p2
;
1203 unsigned long flags1
= *e1
& PLAYLIST_INSERT_TYPE_MASK
;
1204 unsigned long flags2
= *e2
& PLAYLIST_INSERT_TYPE_MASK
;
1206 if (flags1
== flags2
)
1207 return (*e1
& PLAYLIST_SEEK_MASK
) - (*e2
& PLAYLIST_SEEK_MASK
);
1208 else if (flags1
== PLAYLIST_INSERT_TYPE_PREPEND
||
1209 flags2
== PLAYLIST_INSERT_TYPE_APPEND
)
1211 else if (flags1
== PLAYLIST_INSERT_TYPE_APPEND
||
1212 flags2
== PLAYLIST_INSERT_TYPE_PREPEND
)
1214 else if (flags1
&& flags2
)
1215 return (*e1
& PLAYLIST_SEEK_MASK
) - (*e2
& PLAYLIST_SEEK_MASK
);
1220 #ifdef HAVE_DIRCACHE
1222 * Thread to update filename pointers to dircache on background
1223 * without affecting playlist load up performance. This thread also flushes
1224 * any pending control commands when the disk spins up.
1226 static void playlist_flush_callback(void *param
)
1229 struct playlist_info
*playlist
;
1230 playlist
= ¤t_playlist
;
1231 if (playlist
->control_fd
>= 0)
1233 if (playlist
->num_cached
> 0)
1235 mutex_lock(&playlist
->control_mutex
);
1236 flush_cached_control(playlist
);
1237 mutex_unlock(&playlist
->control_mutex
);
1239 sync_control(playlist
, true);
1243 static void playlist_thread(void)
1245 struct queue_event ev
;
1246 bool dirty_pointers
= false;
1247 static char tmp
[MAX_PATH
+1];
1249 struct playlist_info
*playlist
;
1256 #ifdef HAVE_DISK_STORAGE
1257 if (global_settings
.disk_spindown
> 1 &&
1258 global_settings
.disk_spindown
<= 5)
1259 sleep_time
= global_settings
.disk_spindown
- 1;
1264 queue_wait_w_tmo(&playlist_queue
, &ev
, HZ
*sleep_time
);
1268 case PLAYLIST_LOAD_POINTERS
:
1269 dirty_pointers
= true;
1272 /* Start the background scanning after either the disk spindown
1273 timeout or 5s, whichever is less */
1275 playlist
= ¤t_playlist
;
1276 if (playlist
->control_fd
>= 0)
1278 if (playlist
->num_cached
> 0)
1279 register_storage_idle_func(playlist_flush_callback
);
1282 if (!dirty_pointers
)
1285 if (!dircache_is_enabled() || !playlist
->filenames
1286 || playlist
->amount
<= 0)
1289 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1292 for (index
= 0; index
< playlist
->amount
1293 && queue_empty(&playlist_queue
); index
++)
1295 /* Process only pointers that are not already loaded. */
1296 if (playlist
->filenames
[index
])
1299 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
1300 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
1302 /* Load the filename from playlist file. */
1303 if (get_filename(playlist
, index
, seek
, control_file
, tmp
,
1307 /* Set the dircache entry pointer. */
1308 playlist
->filenames
[index
] = dircache_get_entry_ptr(tmp
);
1310 /* And be on background so user doesn't notice any delays. */
1314 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1317 dirty_pointers
= false;
1321 case SYS_USB_CONNECTED
:
1322 usb_acknowledge(SYS_USB_CONNECTED_ACK
);
1323 usb_wait_for_disconnect(&playlist_queue
);
1332 * gets pathname for track at seek index
1334 static int get_filename(struct playlist_info
* playlist
, int index
, int seek
,
1335 bool control_file
, char *buf
, int buf_length
)
1339 char tmp_buf
[MAX_PATH
+1];
1340 char dir_buf
[MAX_PATH
+1];
1341 bool utf8
= playlist
->utf8
;
1343 if (buf_length
> MAX_PATH
+1)
1344 buf_length
= MAX_PATH
+1;
1346 #ifdef HAVE_DIRCACHE
1347 if (dircache_is_enabled() && playlist
->filenames
)
1349 if (playlist
->filenames
[index
] != NULL
)
1351 dircache_copy_path(playlist
->filenames
[index
], tmp_buf
, sizeof(tmp_buf
)-1);
1352 max
= strlen(tmp_buf
);
1359 if (playlist
->in_ram
&& !control_file
&& max
< 0)
1361 max
= strlcpy(tmp_buf
, &playlist
->buffer
[seek
], sizeof(tmp_buf
));
1365 mutex_lock(&playlist
->control_mutex
);
1369 fd
= playlist
->control_fd
;
1374 if(-1 == playlist
->fd
)
1375 playlist
->fd
= open(playlist
->filename
, O_RDONLY
);
1383 if (lseek(fd
, seek
, SEEK_SET
) != seek
)
1387 max
= read(fd
, tmp_buf
, MIN((size_t) buf_length
, sizeof(tmp_buf
)));
1389 if ((max
> 0) && !utf8
)
1391 /* Use dir_buf as a temporary buffer. Note that dir_buf must
1392 * be as large as tmp_buf.
1394 max
= convert_m3u(tmp_buf
, max
, sizeof(tmp_buf
), dir_buf
);
1399 mutex_unlock(&playlist
->control_mutex
);
1404 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
1406 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
1412 strlcpy(dir_buf
, playlist
->filename
, playlist
->dirlen
);
1414 return (format_track_path(buf
, tmp_buf
, buf_length
, max
, dir_buf
));
1417 static int get_next_directory(char *dir
){
1418 return get_next_dir(dir
,true,false);
1421 static int get_previous_directory(char *dir
){
1422 return get_next_dir(dir
,false,false);
1426 * search through all the directories (starting with the current) to find
1427 * one that has tracks to play
1429 static int get_next_dir(char *dir
, bool is_forward
, bool recursion
)
1431 struct playlist_info
* playlist
= ¤t_playlist
;
1433 char *start_dir
= NULL
;
1436 struct tree_context
* tc
= tree_get_context();
1437 int saved_dirfilter
= *(tc
->dirfilter
);
1439 /* process random folder advance */
1440 if (global_settings
.next_folder
== FOLDER_ADVANCE_RANDOM
)
1442 int fd
= open(ROCKBOX_DIR
"/folder_advance_list.dat", O_RDONLY
);
1445 char buffer
[MAX_PATH
];
1446 int folder_count
= 0;
1447 srand(current_tick
);
1448 *(tc
->dirfilter
) = SHOW_MUSIC
;
1449 tc
->sort_dir
= global_settings
.sort_dir
;
1450 read(fd
,&folder_count
,sizeof(int));
1455 i
= rand()%folder_count
;
1456 lseek(fd
,sizeof(int) + (MAX_PATH
*i
),SEEK_SET
);
1457 read(fd
,buffer
,MAX_PATH
);
1458 if (check_subdir_for_music(buffer
, "", false) ==0)
1464 *(tc
->dirfilter
) = saved_dirfilter
;
1465 tc
->sort_dir
= global_settings
.sort_dir
;
1471 /* not random folder advance (or random folder advance unavailable) */
1474 /* start with root */
1479 /* start with current directory */
1480 strlcpy(dir
, playlist
->filename
, playlist
->dirlen
);
1483 /* use the tree browser dircache to load files */
1484 *(tc
->dirfilter
) = SHOW_ALL
;
1486 /* set up sorting/direction */
1487 tc
->sort_dir
= global_settings
.sort_dir
;
1490 static const char sortpairs
[] =
1492 [SORT_ALPHA
] = SORT_ALPHA_REVERSED
,
1493 [SORT_DATE
] = SORT_DATE_REVERSED
,
1494 [SORT_TYPE
] = SORT_TYPE_REVERSED
,
1495 [SORT_ALPHA_REVERSED
] = SORT_ALPHA
,
1496 [SORT_DATE_REVERSED
] = SORT_DATE
,
1497 [SORT_TYPE_REVERSED
] = SORT_TYPE
,
1500 if ((unsigned)tc
->sort_dir
< sizeof(sortpairs
))
1501 tc
->sort_dir
= sortpairs
[tc
->sort_dir
];
1506 struct entry
*files
;
1510 if (ft_load(tc
, (dir
[0]=='\0')?"/":dir
) < 0)
1517 files
= (struct entry
*) tc
->dircache
;
1518 num_files
= tc
->filesindir
;
1520 for (i
=0; i
<num_files
; i
++)
1523 if (action_userabort(TIMEOUT_NOBLOCK
))
1530 if (files
[i
].attr
& ATTR_DIRECTORY
)
1534 result
= check_subdir_for_music(dir
, files
[i
].name
, true);
1541 else if (!strcmp(start_dir
, files
[i
].name
))
1548 /* move down to parent directory. current directory name is
1549 stored as the starting point for the search in parent */
1550 start_dir
= strrchr(dir
, '/');
1561 /* restore dirfilter */
1562 *(tc
->dirfilter
) = saved_dirfilter
;
1563 tc
->sort_dir
= global_settings
.sort_dir
;
1565 /* special case if nothing found: try start searching again from root */
1566 if (result
== -1 && !recursion
){
1567 result
= get_next_dir(dir
, is_forward
, true);
1574 * Checks if there are any music files in the dir or any of its
1575 * subdirectories. May be called recursively.
1577 static int check_subdir_for_music(char *dir
, const char *subdir
, bool recurse
)
1580 int dirlen
= strlen(dir
);
1583 struct entry
*files
;
1584 bool has_music
= false;
1585 bool has_subdir
= false;
1586 struct tree_context
* tc
= tree_get_context();
1588 snprintf(dir
+dirlen
, MAX_PATH
-dirlen
, "/%s", subdir
);
1590 if (ft_load(tc
, dir
) < 0)
1595 files
= (struct entry
*) tc
->dircache
;
1596 num_files
= tc
->filesindir
;
1598 for (i
=0; i
<num_files
; i
++)
1600 if (files
[i
].attr
& ATTR_DIRECTORY
)
1602 else if ((files
[i
].attr
& FILE_ATTR_MASK
) == FILE_ATTR_AUDIO
)
1612 if (has_subdir
&& recurse
)
1614 for (i
=0; i
<num_files
; i
++)
1616 if (action_userabort(TIMEOUT_NOBLOCK
))
1622 if (files
[i
].attr
& ATTR_DIRECTORY
)
1624 result
= check_subdir_for_music(dir
, files
[i
].name
, true);
1642 /* we now need to reload our current directory */
1643 if(ft_load(tc
, dir
) < 0)
1644 splash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
1650 * Returns absolute path of track
1652 static int format_track_path(char *dest
, char *src
, int buf_length
, int max
,
1659 /* Zero-terminate the file name */
1660 while((src
[i
] != '\n') &&
1665 /* Now work back killing white space */
1666 while((src
[i
-1] == ' ') ||
1672 /* replace backslashes with forward slashes */
1673 for ( j
=0; j
<i
; j
++ )
1674 if ( src
[j
] == '\\' )
1679 strlcpy(dest
, src
, buf_length
);
1683 /* handle dos style drive letter */
1685 strlcpy(dest
, &src
[2], buf_length
);
1686 else if (!strncmp(src
, "../", 3))
1688 /* handle relative paths */
1690 while(!strncmp(&src
[i
], "../", 3))
1692 for (j
=0; j
<i
/3; j
++) {
1693 temp_ptr
= strrchr(dir
, '/');
1699 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[i
]);
1701 else if ( '.' == src
[0] && '/' == src
[1] ) {
1702 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[2]);
1705 snprintf(dest
, buf_length
, "%s/%s", dir
, src
);
1713 * Display splash message showing progress of playlist/directory insertion or
1716 static void display_playlist_count(int count
, const unsigned char *fmt
,
1719 static long talked_tick
= 0;
1720 long id
= P2ID(fmt
);
1721 if(global_settings
.talk_menu
&& id
>=0)
1723 if(final
|| (count
&& (talked_tick
== 0
1724 || TIME_AFTER(current_tick
, talked_tick
+5*HZ
))))
1726 talked_tick
= current_tick
;
1727 talk_number(count
, false);
1733 splashf(0, fmt
, count
, str(LANG_OFF_ABORT
));
1737 * Display buffer full message
1739 static void display_buffer_full(void)
1741 splash(HZ
*2, ID2P(LANG_PLAYLIST_BUFFER_FULL
));
1745 * Flush any cached control commands to disk. Called when playlist is being
1746 * modified. Returns 0 on success and -1 on failure.
1748 static int flush_cached_control(struct playlist_info
* playlist
)
1753 if (!playlist
->num_cached
)
1756 lseek(playlist
->control_fd
, 0, SEEK_END
);
1758 for (i
=0; i
<playlist
->num_cached
; i
++)
1760 struct playlist_control_cache
* cache
=
1761 &(playlist
->control_cache
[i
]);
1763 switch (cache
->command
)
1765 case PLAYLIST_COMMAND_PLAYLIST
:
1766 result
= fdprintf(playlist
->control_fd
, "P:%d:%s:%s\n",
1767 cache
->i1
, cache
->s1
, cache
->s2
);
1769 case PLAYLIST_COMMAND_ADD
:
1770 case PLAYLIST_COMMAND_QUEUE
:
1771 result
= fdprintf(playlist
->control_fd
, "%c:%d:%d:",
1772 (cache
->command
== PLAYLIST_COMMAND_ADD
)?'A':'Q',
1773 cache
->i1
, cache
->i2
);
1776 /* save the position in file where name is written */
1777 int* seek_pos
= (int *)cache
->data
;
1778 *seek_pos
= lseek(playlist
->control_fd
, 0, SEEK_CUR
);
1779 result
= fdprintf(playlist
->control_fd
, "%s\n",
1783 case PLAYLIST_COMMAND_DELETE
:
1784 result
= fdprintf(playlist
->control_fd
, "D:%d\n", cache
->i1
);
1786 case PLAYLIST_COMMAND_SHUFFLE
:
1787 result
= fdprintf(playlist
->control_fd
, "S:%d:%d\n",
1788 cache
->i1
, cache
->i2
);
1790 case PLAYLIST_COMMAND_UNSHUFFLE
:
1791 result
= fdprintf(playlist
->control_fd
, "U:%d\n", cache
->i1
);
1793 case PLAYLIST_COMMAND_RESET
:
1794 result
= fdprintf(playlist
->control_fd
, "R\n");
1806 playlist
->num_cached
= 0;
1807 playlist
->pending_control_sync
= true;
1814 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_UPDATE_ERROR
));
1821 * Update control data with new command. Depending on the command, it may be
1822 * cached or flushed to disk.
1824 static int update_control(struct playlist_info
* playlist
,
1825 enum playlist_command command
, int i1
, int i2
,
1826 const char* s1
, const char* s2
, void* data
)
1829 struct playlist_control_cache
* cache
;
1832 mutex_lock(&playlist
->control_mutex
);
1834 cache
= &(playlist
->control_cache
[playlist
->num_cached
++]);
1836 cache
->command
= command
;
1845 case PLAYLIST_COMMAND_PLAYLIST
:
1846 case PLAYLIST_COMMAND_ADD
:
1847 case PLAYLIST_COMMAND_QUEUE
:
1848 #ifndef HAVE_DIRCACHE
1849 case PLAYLIST_COMMAND_DELETE
:
1850 case PLAYLIST_COMMAND_RESET
:
1854 case PLAYLIST_COMMAND_SHUFFLE
:
1855 case PLAYLIST_COMMAND_UNSHUFFLE
:
1857 /* only flush when needed */
1861 if (flush
|| playlist
->num_cached
== PLAYLIST_MAX_CACHE
)
1862 result
= flush_cached_control(playlist
);
1864 mutex_unlock(&playlist
->control_mutex
);
1870 * sync control file to disk
1872 static void sync_control(struct playlist_info
* playlist
, bool force
)
1874 #ifdef HAVE_DIRCACHE
1875 if (playlist
->started
&& force
)
1879 if (playlist
->started
)
1882 if (playlist
->pending_control_sync
)
1884 mutex_lock(&playlist
->control_mutex
);
1885 fsync(playlist
->control_fd
);
1886 playlist
->pending_control_sync
= false;
1887 mutex_unlock(&playlist
->control_mutex
);
1893 * Rotate indices such that first_index is index 0
1895 static int rotate_index(const struct playlist_info
* playlist
, int index
)
1897 index
-= playlist
->first_index
;
1899 index
+= playlist
->amount
;
1905 * Initialize playlist entries at startup
1907 void playlist_init(void)
1909 struct playlist_info
* playlist
= ¤t_playlist
;
1911 playlist
->current
= true;
1912 strlcpy(playlist
->control_filename
, PLAYLIST_CONTROL_FILE
,
1913 sizeof(playlist
->control_filename
));
1915 playlist
->control_fd
= -1;
1916 playlist
->max_playlist_size
= global_settings
.max_files_in_playlist
;
1917 playlist
->indices
= buffer_alloc(
1918 playlist
->max_playlist_size
* sizeof(int));
1919 playlist
->buffer_size
=
1920 AVERAGE_FILENAME_LENGTH
* global_settings
.max_files_in_dir
;
1921 playlist
->buffer
= buffer_alloc(playlist
->buffer_size
);
1922 mutex_init(&playlist
->control_mutex
);
1923 empty_playlist(playlist
, true);
1925 #ifdef HAVE_DIRCACHE
1926 playlist
->filenames
= buffer_alloc(
1927 playlist
->max_playlist_size
* sizeof(int));
1928 memset(playlist
->filenames
, 0,
1929 playlist
->max_playlist_size
* sizeof(int));
1930 create_thread(playlist_thread
, playlist_stack
, sizeof(playlist_stack
),
1931 0, playlist_thread_name
IF_PRIO(, PRIORITY_BACKGROUND
)
1933 queue_init(&playlist_queue
, true);
1938 * Clean playlist at shutdown
1940 void playlist_shutdown(void)
1942 struct playlist_info
* playlist
= ¤t_playlist
;
1944 if (playlist
->control_fd
>= 0)
1946 mutex_lock(&playlist
->control_mutex
);
1948 if (playlist
->num_cached
> 0)
1949 flush_cached_control(playlist
);
1951 close(playlist
->control_fd
);
1953 mutex_unlock(&playlist
->control_mutex
);
1958 * Create new playlist
1960 int playlist_create(const char *dir
, const char *file
)
1962 struct playlist_info
* playlist
= ¤t_playlist
;
1964 new_playlist(playlist
, dir
, file
);
1967 /* load the playlist file */
1968 add_indices_to_playlist(playlist
, NULL
, 0);
1973 #define PLAYLIST_COMMAND_SIZE (MAX_PATH+12)
1976 * Restore the playlist state based on control file commands. Called to
1977 * resume playback after shutdown.
1979 int playlist_resume(void)
1981 struct playlist_info
* playlist
= ¤t_playlist
;
1986 int control_file_size
= 0;
1990 /* use mp3 buffer for maximum load speed */
1991 #if CONFIG_CODEC != SWCODEC
1992 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
1993 buflen
= (audiobufend
- audiobuf
);
1994 buffer
= (char *)audiobuf
;
1996 buffer
= (char *)audio_get_buffer(false, &buflen
);
1999 empty_playlist(playlist
, true);
2001 splash(0, ID2P(LANG_WAIT
));
2002 playlist
->control_fd
= open(playlist
->control_filename
, O_RDWR
);
2003 if (playlist
->control_fd
< 0)
2005 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2008 playlist
->control_created
= true;
2010 control_file_size
= filesize(playlist
->control_fd
);
2011 if (control_file_size
<= 0)
2013 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2017 /* read a small amount first to get the header */
2018 nread
= read(playlist
->control_fd
, buffer
,
2019 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
2022 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2026 playlist
->started
= true;
2032 enum playlist_command current_command
= PLAYLIST_COMMAND_COMMENT
;
2033 int last_newline
= 0;
2035 bool newline
= true;
2036 bool exit_loop
= false;
2041 unsigned long last_tick
= current_tick
;
2042 bool useraborted
= false;
2044 for(count
=0; count
<nread
&& !exit_loop
&& !useraborted
; count
++,p
++)
2046 /* So a splash while we are loading. */
2047 if (TIME_AFTER(current_tick
, last_tick
+ HZ
/4))
2049 splashf(0, str(LANG_LOADING_PERCENT
),
2050 (total_read
+count
)*100/control_file_size
,
2051 str(LANG_OFF_ABORT
));
2052 if (action_userabort(TIMEOUT_NOBLOCK
))
2057 last_tick
= current_tick
;
2060 /* Are we on a new line? */
2061 if((*p
== '\n') || (*p
== '\r'))
2065 /* save last_newline in case we need to load more data */
2066 last_newline
= count
;
2068 switch (current_command
)
2070 case PLAYLIST_COMMAND_PLAYLIST
:
2072 /* str1=version str2=dir str3=file */
2088 version
= atoi(str1
);
2090 if (version
!= PLAYLIST_CONTROL_FILE_VERSION
)
2093 update_playlist_filename(playlist
, str2
, str3
);
2095 if (str3
[0] != '\0')
2097 /* NOTE: add_indices_to_playlist() overwrites the
2098 audiobuf so we need to reload control file
2100 add_indices_to_playlist(playlist
, NULL
, 0);
2102 else if (str2
[0] != '\0')
2104 playlist
->in_ram
= true;
2105 resume_directory(str2
);
2108 /* load the rest of the data */
2114 case PLAYLIST_COMMAND_ADD
:
2115 case PLAYLIST_COMMAND_QUEUE
:
2117 /* str1=position str2=last_position str3=file */
2118 int position
, last_position
;
2121 if (!str1
|| !str2
|| !str3
)
2128 position
= atoi(str1
);
2129 last_position
= atoi(str2
);
2131 queue
= (current_command
== PLAYLIST_COMMAND_ADD
)?
2134 /* seek position is based on str3's position in
2136 if (add_track_to_playlist(playlist
, str3
, position
,
2137 queue
, total_read
+(str3
-buffer
)) < 0)
2140 playlist
->last_insert_pos
= last_position
;
2144 case PLAYLIST_COMMAND_DELETE
:
2156 position
= atoi(str1
);
2158 if (remove_track_from_playlist(playlist
, position
,
2164 case PLAYLIST_COMMAND_SHUFFLE
:
2166 /* str1=seed str2=first_index */
2178 /* Always sort list before shuffling */
2179 sort_playlist(playlist
, false, false);
2183 playlist
->first_index
= atoi(str2
);
2185 if (randomise_playlist(playlist
, seed
, false,
2191 case PLAYLIST_COMMAND_UNSHUFFLE
:
2193 /* str1=first_index */
2201 playlist
->first_index
= atoi(str1
);
2203 if (sort_playlist(playlist
, false, false) < 0)
2209 case PLAYLIST_COMMAND_RESET
:
2211 playlist
->last_insert_pos
= -1;
2214 case PLAYLIST_COMMAND_COMMENT
:
2221 /* to ignore any extra newlines */
2222 current_command
= PLAYLIST_COMMAND_COMMENT
;
2228 /* first non-comment line must always specify playlist */
2229 if (first
&& *p
!= 'P' && *p
!= '#')
2239 /* playlist can only be specified once */
2247 current_command
= PLAYLIST_COMMAND_PLAYLIST
;
2250 current_command
= PLAYLIST_COMMAND_ADD
;
2253 current_command
= PLAYLIST_COMMAND_QUEUE
;
2256 current_command
= PLAYLIST_COMMAND_DELETE
;
2259 current_command
= PLAYLIST_COMMAND_SHUFFLE
;
2262 current_command
= PLAYLIST_COMMAND_UNSHUFFLE
;
2265 current_command
= PLAYLIST_COMMAND_RESET
;
2268 current_command
= PLAYLIST_COMMAND_COMMENT
;
2281 else if(current_command
!= PLAYLIST_COMMAND_COMMENT
)
2283 /* all control file strings are separated with a colon.
2284 Replace the colon with 0 to get proper strings that can be
2285 used by commands above */
2291 if ((count
+1) < nread
)
2305 /* allow last string to contain colons */
2316 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID
));
2322 splash(HZ
*2, ID2P(LANG_CANCEL
));
2325 if (!newline
|| (exit_loop
&& count
<nread
))
2327 if ((total_read
+ count
) >= control_file_size
)
2329 /* no newline at end of control file */
2330 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID
));
2334 /* We didn't end on a newline or we exited loop prematurely.
2335 Either way, re-read the remainder. */
2336 count
= last_newline
;
2337 lseek(playlist
->control_fd
, total_read
+count
, SEEK_SET
);
2340 total_read
+= count
;
2343 /* still looking for header */
2344 nread
= read(playlist
->control_fd
, buffer
,
2345 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
2347 nread
= read(playlist
->control_fd
, buffer
, buflen
);
2349 /* Terminate on EOF */
2356 #ifdef HAVE_DIRCACHE
2357 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2364 * Add track to in_ram playlist. Used when playing directories.
2366 int playlist_add(const char *filename
)
2368 struct playlist_info
* playlist
= ¤t_playlist
;
2369 int len
= strlen(filename
);
2371 if((len
+1 > playlist
->buffer_size
- playlist
->buffer_end_pos
) ||
2372 (playlist
->amount
>= playlist
->max_playlist_size
))
2374 display_buffer_full();
2378 playlist
->indices
[playlist
->amount
] = playlist
->buffer_end_pos
;
2379 #ifdef HAVE_DIRCACHE
2380 playlist
->filenames
[playlist
->amount
] = NULL
;
2384 strcpy(&playlist
->buffer
[playlist
->buffer_end_pos
], filename
);
2385 playlist
->buffer_end_pos
+= len
;
2386 playlist
->buffer
[playlist
->buffer_end_pos
++] = '\0';
2391 /* shuffle newly created playlist using random seed. */
2392 int playlist_shuffle(int random_seed
, int start_index
)
2394 struct playlist_info
* playlist
= ¤t_playlist
;
2396 unsigned int seek_pos
= 0;
2397 bool start_current
= false;
2399 if (start_index
>= 0 && global_settings
.play_selected
)
2401 /* store the seek position before the shuffle */
2402 seek_pos
= playlist
->indices
[start_index
];
2403 playlist
->index
= playlist
->first_index
= start_index
;
2404 start_current
= true;
2407 randomise_playlist(playlist
, random_seed
, start_current
, true);
2409 return playlist
->index
;
2412 /* start playing current playlist at specified index/offset */
2413 void playlist_start(int start_index
, int offset
)
2415 struct playlist_info
* playlist
= ¤t_playlist
;
2417 /* Cancel FM radio selection as previous music. For cases where we start
2418 playback without going to the WPS, such as playlist insert.. or
2419 playlist catalog. */
2420 previous_music_is_wps();
2422 playlist
->index
= start_index
;
2424 #if CONFIG_CODEC != SWCODEC
2425 talk_buffer_steal(); /* will use the mp3 buffer */
2428 playlist
->started
= true;
2429 sync_control(playlist
, false);
2433 /* Returns false if 'steps' is out of bounds, else true */
2434 bool playlist_check(int steps
)
2436 struct playlist_info
* playlist
= ¤t_playlist
;
2438 /* always allow folder navigation */
2439 if (global_settings
.next_folder
&& playlist
->in_ram
)
2442 int index
= get_next_index(playlist
, steps
, -1);
2444 if (index
< 0 && steps
>= 0 && global_settings
.repeat_mode
== REPEAT_SHUFFLE
)
2445 index
= get_next_index(playlist
, steps
, REPEAT_ALL
);
2447 return (index
>= 0);
2450 /* get trackname of track that is "steps" away from current playing track.
2451 NULL is used to identify end of playlist */
2452 char* playlist_peek(int steps
)
2454 struct playlist_info
* playlist
= ¤t_playlist
;
2460 index
= get_next_index(playlist
, steps
, -1);
2464 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
2465 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
2467 if (get_filename(playlist
, index
, seek
, control_file
, now_playing
,
2471 temp_ptr
= now_playing
;
2473 if (!playlist
->in_ram
|| control_file
)
2475 /* remove bogus dirs from beginning of path
2476 (workaround for buggy playlist creation tools) */
2479 if (file_exists(temp_ptr
))
2482 temp_ptr
= strchr(temp_ptr
+1, '/');
2487 /* Even though this is an invalid file, we still need to pass a
2488 file name to the caller because NULL is used to indicate end
2498 * Update indices as track has changed
2500 int playlist_next(int steps
)
2502 struct playlist_info
* playlist
= ¤t_playlist
;
2506 #ifdef AB_REPEAT_ENABLE
2507 && (global_settings
.repeat_mode
!= REPEAT_AB
)
2509 && (global_settings
.repeat_mode
!= REPEAT_ONE
) )
2513 /* We need to delete all the queued songs */
2514 for (i
=0, j
=steps
; i
<j
; i
++)
2516 index
= get_next_index(playlist
, i
, -1);
2518 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
2520 remove_track_from_playlist(playlist
, index
, true);
2521 steps
--; /* one less track */
2526 index
= get_next_index(playlist
, steps
, -1);
2530 /* end of playlist... or is it */
2531 if (global_settings
.repeat_mode
== REPEAT_SHUFFLE
&&
2532 playlist
->amount
> 1)
2534 /* Repeat shuffle mode. Re-shuffle playlist and resume play */
2535 playlist
->first_index
= 0;
2536 sort_playlist(playlist
, false, false);
2537 randomise_playlist(playlist
, current_tick
, false, true);
2538 #if CONFIG_CODEC != SWCODEC
2539 playlist_start(0, 0);
2541 playlist
->index
= 0;
2544 else if (playlist
->in_ram
&& global_settings
.next_folder
)
2546 index
= create_and_play_dir(steps
, true);
2550 playlist
->index
= index
;
2557 playlist
->index
= index
;
2559 if (playlist
->last_insert_pos
>= 0 && steps
> 0)
2561 /* check to see if we've gone beyond the last inserted track */
2562 int cur
= rotate_index(playlist
, index
);
2563 int last_pos
= rotate_index(playlist
, playlist
->last_insert_pos
);
2567 /* reset last inserted track */
2568 playlist
->last_insert_pos
= -1;
2570 if (playlist
->control_fd
>= 0)
2572 int result
= update_control(playlist
, PLAYLIST_COMMAND_RESET
,
2573 -1, -1, NULL
, NULL
, NULL
);
2578 sync_control(playlist
, false);
2586 /* try playing next or previous folder */
2587 bool playlist_next_dir(int direction
)
2589 /* not to mess up real playlists */
2590 if(!current_playlist
.in_ram
)
2593 return create_and_play_dir(direction
, false) >= 0;
2596 /* Get resume info for current playing song. If return value is -1 then
2597 settings shouldn't be saved. */
2598 int playlist_get_resume_info(int *resume_index
)
2600 struct playlist_info
* playlist
= ¤t_playlist
;
2602 *resume_index
= playlist
->index
;
2607 /* Update resume info for current playing song. Returns -1 on error. */
2608 int playlist_update_resume_info(const struct mp3entry
* id3
)
2610 struct playlist_info
* playlist
= ¤t_playlist
;
2614 if (global_status
.resume_index
!= playlist
->index
||
2615 global_status
.resume_offset
!= id3
->offset
)
2617 global_status
.resume_index
= playlist
->index
;
2618 global_status
.resume_offset
= id3
->offset
;
2624 global_status
.resume_index
= -1;
2625 global_status
.resume_offset
= -1;
2632 /* Returns index of current playing track for display purposes. This value
2633 should not be used for resume purposes as it doesn't represent the actual
2634 index into the playlist */
2635 int playlist_get_display_index(void)
2637 struct playlist_info
* playlist
= ¤t_playlist
;
2639 /* first_index should always be index 0 for display purposes */
2640 int index
= rotate_index(playlist
, playlist
->index
);
2645 /* returns number of tracks in current playlist */
2646 int playlist_amount(void)
2648 return playlist_amount_ex(NULL
);
2650 /* set playlist->last_shuffle_start to playlist->amount for
2651 PLAYLIST_INSERT_LAST_SHUFFLED command purposes*/
2652 void playlist_set_last_shuffled_start(void)
2654 struct playlist_info
* playlist
= ¤t_playlist
;
2655 playlist
->last_shuffled_start
= playlist
->amount
;
2658 * Create a new playlist If playlist is not NULL then we're loading a
2659 * playlist off disk for viewing/editing. The index_buffer is used to store
2660 * playlist indices (required for and only used if !current playlist). The
2661 * temp_buffer (if not NULL) is used as a scratchpad when loading indices.
2663 int playlist_create_ex(struct playlist_info
* playlist
,
2664 const char* dir
, const char* file
,
2665 void* index_buffer
, int index_buffer_size
,
2666 void* temp_buffer
, int temp_buffer_size
)
2669 playlist
= ¤t_playlist
;
2672 /* Initialize playlist structure */
2673 int r
= rand() % 10;
2674 playlist
->current
= false;
2676 /* Use random name for control file */
2677 snprintf(playlist
->control_filename
, sizeof(playlist
->control_filename
),
2678 "%s.%d", PLAYLIST_CONTROL_FILE
, r
);
2680 playlist
->control_fd
= -1;
2684 int num_indices
= index_buffer_size
/ sizeof(int);
2686 #ifdef HAVE_DIRCACHE
2689 if (num_indices
> global_settings
.max_files_in_playlist
)
2690 num_indices
= global_settings
.max_files_in_playlist
;
2692 playlist
->max_playlist_size
= num_indices
;
2693 playlist
->indices
= index_buffer
;
2694 #ifdef HAVE_DIRCACHE
2695 playlist
->filenames
= (const struct dircache_entry
**)
2696 &playlist
->indices
[num_indices
];
2701 playlist
->max_playlist_size
= current_playlist
.max_playlist_size
;
2702 playlist
->indices
= current_playlist
.indices
;
2703 #ifdef HAVE_DIRCACHE
2704 playlist
->filenames
= current_playlist
.filenames
;
2708 playlist
->buffer_size
= 0;
2709 playlist
->buffer
= NULL
;
2710 mutex_init(&playlist
->control_mutex
);
2713 new_playlist(playlist
, dir
, file
);
2716 /* load the playlist file */
2717 add_indices_to_playlist(playlist
, temp_buffer
, temp_buffer_size
);
2723 * Set the specified playlist as the current.
2724 * NOTE: You will get undefined behaviour if something is already playing so
2725 * remember to stop before calling this. Also, this call will
2726 * effectively close your playlist, making it unusable.
2728 int playlist_set_current(struct playlist_info
* playlist
)
2730 if (!playlist
|| (check_control(playlist
) < 0))
2733 empty_playlist(¤t_playlist
, false);
2735 strlcpy(current_playlist
.filename
, playlist
->filename
,
2736 sizeof(current_playlist
.filename
));
2738 current_playlist
.utf8
= playlist
->utf8
;
2739 current_playlist
.fd
= playlist
->fd
;
2741 close(playlist
->control_fd
);
2742 close(current_playlist
.control_fd
);
2743 remove(current_playlist
.control_filename
);
2744 if (rename(playlist
->control_filename
,
2745 current_playlist
.control_filename
) < 0)
2747 current_playlist
.control_fd
= open(current_playlist
.control_filename
,
2749 if (current_playlist
.control_fd
< 0)
2751 current_playlist
.control_created
= true;
2753 current_playlist
.dirlen
= playlist
->dirlen
;
2755 if (playlist
->indices
&& playlist
->indices
!= current_playlist
.indices
)
2757 memcpy(current_playlist
.indices
, playlist
->indices
,
2758 playlist
->max_playlist_size
*sizeof(int));
2759 #ifdef HAVE_DIRCACHE
2760 memcpy(current_playlist
.filenames
, playlist
->filenames
,
2761 playlist
->max_playlist_size
*sizeof(int));
2765 current_playlist
.first_index
= playlist
->first_index
;
2766 current_playlist
.amount
= playlist
->amount
;
2767 current_playlist
.last_insert_pos
= playlist
->last_insert_pos
;
2768 current_playlist
.seed
= playlist
->seed
;
2769 current_playlist
.shuffle_modified
= playlist
->shuffle_modified
;
2770 current_playlist
.deleted
= playlist
->deleted
;
2771 current_playlist
.num_inserted_tracks
= playlist
->num_inserted_tracks
;
2773 memcpy(current_playlist
.control_cache
, playlist
->control_cache
,
2774 sizeof(current_playlist
.control_cache
));
2775 current_playlist
.num_cached
= playlist
->num_cached
;
2776 current_playlist
.pending_control_sync
= playlist
->pending_control_sync
;
2780 struct playlist_info
*playlist_get_current(void)
2782 return ¤t_playlist
;
2785 * Close files and delete control file for non-current playlist.
2787 void playlist_close(struct playlist_info
* playlist
)
2792 if (playlist
->fd
>= 0)
2793 close(playlist
->fd
);
2795 if (playlist
->control_fd
>= 0)
2796 close(playlist
->control_fd
);
2798 if (playlist
->control_created
)
2799 remove(playlist
->control_filename
);
2802 void playlist_sync(struct playlist_info
* playlist
)
2805 playlist
= ¤t_playlist
;
2807 sync_control(playlist
, false);
2808 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2809 audio_flush_and_reload_tracks();
2811 #ifdef HAVE_DIRCACHE
2812 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2817 * Insert track into playlist at specified position (or one of the special
2818 * positions). Returns position where track was inserted or -1 if error.
2820 int playlist_insert_track(struct playlist_info
* playlist
, const char *filename
,
2821 int position
, bool queue
, bool sync
)
2826 playlist
= ¤t_playlist
;
2828 if (check_control(playlist
) < 0)
2830 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2834 result
= add_track_to_playlist(playlist
, filename
, position
, queue
, -1);
2836 /* Check if we want manually sync later. For example when adding
2837 * bunch of files from tagcache, syncing after every file wouldn't be
2838 * a good thing to do. */
2839 if (sync
&& result
>= 0)
2840 playlist_sync(playlist
);
2846 * Insert all tracks from specified directory into playlist.
2848 int playlist_insert_directory(struct playlist_info
* playlist
,
2849 const char *dirname
, int position
, bool queue
,
2853 unsigned char *count_str
;
2854 struct directory_search_context context
;
2857 playlist
= ¤t_playlist
;
2859 if (check_control(playlist
) < 0)
2861 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2865 if (position
== PLAYLIST_REPLACE
)
2867 if (playlist_remove_all_tracks(playlist
) == 0)
2868 position
= PLAYLIST_INSERT_LAST
;
2874 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
2876 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
2878 display_playlist_count(0, count_str
, false);
2880 context
.playlist
= playlist
;
2881 context
.position
= position
;
2882 context
.queue
= queue
;
2887 result
= playlist_directory_tracksearch(dirname
, recurse
,
2888 directory_search_callback
, &context
);
2890 sync_control(playlist
, false);
2894 display_playlist_count(context
.count
, count_str
, true);
2896 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2897 audio_flush_and_reload_tracks();
2899 #ifdef HAVE_DIRCACHE
2900 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2907 * Insert all tracks from specified playlist into dynamic playlist.
2909 int playlist_insert_playlist(struct playlist_info
* playlist
, const char *filename
,
2910 int position
, bool queue
)
2916 unsigned char *count_str
;
2917 char temp_buf
[MAX_PATH
+1];
2918 char trackname
[MAX_PATH
+1];
2921 bool utf8
= is_m3u8(filename
);
2924 playlist
= ¤t_playlist
;
2926 if (check_control(playlist
) < 0)
2928 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2932 fd
= open_utf8(filename
, O_RDONLY
);
2935 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
2939 /* we need the directory name for formatting purposes */
2942 temp_ptr
= strrchr(filename
+1,'/');
2949 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
2951 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
2953 display_playlist_count(count
, count_str
, false);
2955 if (position
== PLAYLIST_REPLACE
)
2957 if (playlist_remove_all_tracks(playlist
) == 0)
2958 position
= PLAYLIST_INSERT_LAST
;
2964 while ((max
= read_line(fd
, temp_buf
, sizeof(temp_buf
))) > 0)
2967 if (action_userabort(TIMEOUT_NOBLOCK
))
2970 if (temp_buf
[0] != '#' && temp_buf
[0] != '\0')
2976 /* Use trackname as a temporay buffer. Note that trackname must
2977 * be as large as temp_buf.
2979 max
= convert_m3u(temp_buf
, max
, sizeof(temp_buf
), trackname
);
2982 /* we need to format so that relative paths are correctly
2984 if (format_track_path(trackname
, temp_buf
, sizeof(trackname
), max
,
2991 insert_pos
= add_track_to_playlist(playlist
, trackname
, position
,
3000 /* Make sure tracks are inserted in correct order if user
3001 requests INSERT_FIRST */
3002 if (position
== PLAYLIST_INSERT_FIRST
|| position
>= 0)
3003 position
= insert_pos
+ 1;
3007 if ((count
%PLAYLIST_DISPLAY_COUNT
) == 0)
3009 display_playlist_count(count
, count_str
, false);
3011 if (count
== PLAYLIST_DISPLAY_COUNT
&&
3012 (audio_status() & AUDIO_STATUS_PLAY
) &&
3014 audio_flush_and_reload_tracks();
3018 /* let the other threads work */
3027 sync_control(playlist
, false);
3031 display_playlist_count(count
, count_str
, true);
3033 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3034 audio_flush_and_reload_tracks();
3036 #ifdef HAVE_DIRCACHE
3037 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3044 * Delete track at specified index. If index is PLAYLIST_DELETE_CURRENT then
3045 * we want to delete the current playing track.
3047 int playlist_delete(struct playlist_info
* playlist
, int index
)
3052 playlist
= ¤t_playlist
;
3054 if (check_control(playlist
) < 0)
3056 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3060 if (index
== PLAYLIST_DELETE_CURRENT
)
3061 index
= playlist
->index
;
3063 result
= remove_track_from_playlist(playlist
, index
, true);
3065 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3067 audio_flush_and_reload_tracks();
3073 * Move track at index to new_index. Tracks between the two are shifted
3074 * appropriately. Returns 0 on success and -1 on failure.
3076 int playlist_move(struct playlist_info
* playlist
, int index
, int new_index
)
3082 bool current
= false;
3084 char filename
[MAX_PATH
];
3087 playlist
= ¤t_playlist
;
3089 if (check_control(playlist
) < 0)
3091 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3095 if (index
== new_index
)
3098 if (index
== playlist
->index
)
3099 /* Moving the current track */
3102 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3103 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3104 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3106 if (get_filename(playlist
, index
, seek
, control_file
, filename
,
3107 sizeof(filename
)) < 0)
3110 /* We want to insert the track at the position that was specified by
3111 new_index. This may be different then new_index because of the
3112 shifting that will occur after the delete.
3113 We calculate this before we do the remove as it depends on the
3114 size of the playlist before the track removal */
3115 r
= rotate_index(playlist
, new_index
);
3117 /* Delete track from original position */
3118 result
= remove_track_from_playlist(playlist
, index
, true);
3124 new_index
= PLAYLIST_PREPEND
;
3125 else if (r
== playlist
->amount
)
3127 new_index
= PLAYLIST_INSERT_LAST
;
3129 /* Calculate index of desired position */
3130 new_index
= (r
+playlist
->first_index
)%playlist
->amount
;
3132 result
= add_track_to_playlist(playlist
, filename
, new_index
, queue
,
3139 /* Moved the current track */
3142 case PLAYLIST_PREPEND
:
3143 playlist
->index
= playlist
->first_index
;
3145 case PLAYLIST_INSERT_LAST
:
3146 playlist
->index
= playlist
->first_index
- 1;
3147 if (playlist
->index
< 0)
3148 playlist
->index
+= playlist
->amount
;
3151 playlist
->index
= new_index
;
3156 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3157 audio_flush_and_reload_tracks();
3161 #ifdef HAVE_DIRCACHE
3162 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3168 /* shuffle currently playing playlist */
3169 int playlist_randomise(struct playlist_info
* playlist
, unsigned int seed
,
3175 playlist
= ¤t_playlist
;
3177 check_control(playlist
);
3179 result
= randomise_playlist(playlist
, seed
, start_current
, true);
3181 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3183 audio_flush_and_reload_tracks();
3188 /* sort currently playing playlist */
3189 int playlist_sort(struct playlist_info
* playlist
, bool start_current
)
3194 playlist
= ¤t_playlist
;
3196 check_control(playlist
);
3198 result
= sort_playlist(playlist
, start_current
, true);
3200 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3202 audio_flush_and_reload_tracks();
3207 /* returns true if playlist has been modified */
3208 bool playlist_modified(const struct playlist_info
* playlist
)
3211 playlist
= ¤t_playlist
;
3213 if (playlist
->shuffle_modified
||
3214 playlist
->deleted
||
3215 playlist
->num_inserted_tracks
> 0)
3221 /* returns index of first track in playlist */
3222 int playlist_get_first_index(const struct playlist_info
* playlist
)
3225 playlist
= ¤t_playlist
;
3227 return playlist
->first_index
;
3230 /* returns shuffle seed of playlist */
3231 int playlist_get_seed(const struct playlist_info
* playlist
)
3234 playlist
= ¤t_playlist
;
3236 return playlist
->seed
;
3239 /* returns number of tracks in playlist (includes queued/inserted tracks) */
3240 int playlist_amount_ex(const struct playlist_info
* playlist
)
3243 playlist
= ¤t_playlist
;
3245 return playlist
->amount
;
3248 /* returns full path of playlist (minus extension) */
3249 char *playlist_name(const struct playlist_info
* playlist
, char *buf
,
3255 playlist
= ¤t_playlist
;
3257 strlcpy(buf
, playlist
->filename
+playlist
->dirlen
, buf_size
);
3262 /* Remove extension */
3263 sep
= strrchr(buf
, '.');
3270 /* returns the playlist filename */
3271 char *playlist_get_name(const struct playlist_info
* playlist
, char *buf
,
3275 playlist
= ¤t_playlist
;
3277 strlcpy(buf
, playlist
->filename
, buf_size
);
3285 /* Fills info structure with information about track at specified index.
3286 Returns 0 on success and -1 on failure */
3287 int playlist_get_track_info(struct playlist_info
* playlist
, int index
,
3288 struct playlist_track_info
* info
)
3294 playlist
= ¤t_playlist
;
3296 if (index
< 0 || index
>= playlist
->amount
)
3299 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3300 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3302 if (get_filename(playlist
, index
, seek
, control_file
, info
->filename
,
3303 sizeof(info
->filename
)) < 0)
3310 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
3311 info
->attr
|= PLAYLIST_ATTR_QUEUED
;
3313 info
->attr
|= PLAYLIST_ATTR_INSERTED
;
3317 if (playlist
->indices
[index
] & PLAYLIST_SKIPPED
)
3318 info
->attr
|= PLAYLIST_ATTR_SKIPPED
;
3320 info
->index
= index
;
3321 info
->display_index
= rotate_index(playlist
, index
) + 1;
3326 /* save the current dynamic playlist to specified file */
3327 int playlist_save(struct playlist_info
* playlist
, char *filename
)
3332 char path
[MAX_PATH
+1];
3333 char tmp_buf
[MAX_PATH
+1];
3335 bool overwrite_current
= false;
3336 int* index_buf
= NULL
;
3339 playlist
= ¤t_playlist
;
3341 if (playlist
->amount
<= 0)
3344 /* use current working directory as base for pathname */
3345 if (format_track_path(path
, filename
, sizeof(tmp_buf
),
3346 strlen(filename
)+1, getcwd(NULL
, -1)) < 0)
3349 if (!strncmp(playlist
->filename
, path
, strlen(path
)))
3351 /* Attempting to overwrite current playlist file.*/
3353 if (playlist
->buffer_size
< (int)(playlist
->amount
* sizeof(int)))
3355 /* not enough buffer space to store updated indices */
3356 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3360 /* in_ram buffer is unused for m3u files so we'll use for storing
3362 index_buf
= (int*)playlist
->buffer
;
3364 /* use temporary pathname */
3365 snprintf(path
, sizeof(path
), "%s_temp", playlist
->filename
);
3366 overwrite_current
= true;
3371 fd
= open_utf8(path
, O_CREAT
|O_WRONLY
|O_TRUNC
);
3375 /* some applications require a BOM to read the file properly */
3376 fd
= open(path
, O_CREAT
|O_WRONLY
|O_TRUNC
);
3380 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3384 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
), false);
3388 index
= playlist
->first_index
;
3389 for (i
=0; i
<playlist
->amount
; i
++)
3396 if (action_userabort(TIMEOUT_NOBLOCK
))
3402 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3403 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3404 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3406 /* Don't save queued files */
3409 if (get_filename(playlist
, index
, seek
, control_file
, tmp_buf
,
3416 if (overwrite_current
)
3417 index_buf
[count
] = lseek(fd
, 0, SEEK_CUR
);
3419 if (fdprintf(fd
, "%s\n", tmp_buf
) < 0)
3421 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3428 if ((count
% PLAYLIST_DISPLAY_COUNT
) == 0)
3429 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
),
3435 index
= (index
+1)%playlist
->amount
;
3438 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
), true);
3442 if (overwrite_current
&& result
>= 0)
3446 mutex_lock(&playlist
->control_mutex
);
3448 /* Replace the current playlist with the new one and update indices */
3449 close(playlist
->fd
);
3450 if (remove(playlist
->filename
) >= 0)
3452 if (rename(path
, playlist
->filename
) >= 0)
3454 playlist
->fd
= open_utf8(playlist
->filename
, O_RDONLY
);
3455 if (playlist
->fd
>= 0)
3457 index
= playlist
->first_index
;
3458 for (i
=0, count
=0; i
<playlist
->amount
; i
++)
3460 if (!(playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
))
3462 playlist
->indices
[index
] = index_buf
[count
];
3465 index
= (index
+1)%playlist
->amount
;
3468 /* we need to recreate control because inserted tracks are
3469 now part of the playlist and shuffle has been
3471 result
= recreate_control(playlist
);
3476 mutex_unlock(&playlist
->control_mutex
);
3486 * Search specified directory for tracks and notify via callback. May be
3487 * called recursively.
3489 int playlist_directory_tracksearch(const char* dirname
, bool recurse
,
3490 int (*callback
)(char*, void*),
3493 char buf
[MAX_PATH
+1];
3497 struct entry
*files
;
3498 struct tree_context
* tc
= tree_get_context();
3499 int old_dirfilter
= *(tc
->dirfilter
);
3504 /* use the tree browser dircache to load files */
3505 *(tc
->dirfilter
) = SHOW_ALL
;
3507 if (ft_load(tc
, dirname
) < 0)
3509 splash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
3510 *(tc
->dirfilter
) = old_dirfilter
;
3514 files
= (struct entry
*) tc
->dircache
;
3515 num_files
= tc
->filesindir
;
3517 /* we've overwritten the dircache so tree browser will need to be
3521 for (i
=0; i
<num_files
; i
++)
3524 if (action_userabort(TIMEOUT_NOBLOCK
))
3530 if (files
[i
].attr
& ATTR_DIRECTORY
)
3534 /* recursively add directories */
3535 snprintf(buf
, sizeof(buf
), "%s/%s", dirname
, files
[i
].name
);
3536 result
= playlist_directory_tracksearch(buf
, recurse
,
3541 /* we now need to reload our current directory */
3542 if(ft_load(tc
, dirname
) < 0)
3548 files
= (struct entry
*) tc
->dircache
;
3549 num_files
= tc
->filesindir
;
3559 else if ((files
[i
].attr
& FILE_ATTR_MASK
) == FILE_ATTR_AUDIO
)
3561 snprintf(buf
, sizeof(buf
), "%s/%s", dirname
, files
[i
].name
);
3563 if (callback(buf
, context
) != 0)
3569 /* let the other threads work */
3574 /* restore dirfilter */
3575 *(tc
->dirfilter
) = old_dirfilter
;