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 five 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_REPLACE - Erase current playlist, Cue the current track
679 * and inster this track at the end.
681 static int add_track_to_playlist(struct playlist_info
* playlist
,
682 const char *filename
, int position
,
683 bool queue
, int seek_pos
)
685 int insert_position
, orig_position
;
686 unsigned long flags
= PLAYLIST_INSERT_TYPE_INSERT
;
689 insert_position
= orig_position
= position
;
691 if (playlist
->amount
>= playlist
->max_playlist_size
)
693 display_buffer_full();
699 case PLAYLIST_PREPEND
:
700 position
= insert_position
= playlist
->first_index
;
702 case PLAYLIST_INSERT
:
703 /* if there are already inserted tracks then add track to end of
704 insertion list else add after current playing track */
705 if (playlist
->last_insert_pos
>= 0 &&
706 playlist
->last_insert_pos
< playlist
->amount
&&
707 (playlist
->indices
[playlist
->last_insert_pos
]&
708 PLAYLIST_INSERT_TYPE_MASK
) == PLAYLIST_INSERT_TYPE_INSERT
)
709 position
= insert_position
= playlist
->last_insert_pos
+1;
710 else if (playlist
->amount
> 0)
711 position
= insert_position
= playlist
->index
+ 1;
713 position
= insert_position
= 0;
715 playlist
->last_insert_pos
= position
;
717 case PLAYLIST_INSERT_FIRST
:
718 if (playlist
->amount
> 0)
719 position
= insert_position
= playlist
->index
+ 1;
721 position
= insert_position
= 0;
723 playlist
->last_insert_pos
= position
;
725 case PLAYLIST_INSERT_LAST
:
726 if (playlist
->first_index
> 0)
727 position
= insert_position
= playlist
->first_index
;
729 position
= insert_position
= playlist
->amount
;
731 playlist
->last_insert_pos
= position
;
733 case PLAYLIST_INSERT_SHUFFLED
:
735 if (playlist
->started
)
738 int n
= playlist
->amount
-
739 rotate_index(playlist
, playlist
->index
);
746 position
= playlist
->index
+ offset
+ 1;
747 if (position
>= playlist
->amount
)
748 position
-= playlist
->amount
;
750 insert_position
= position
;
753 position
= insert_position
= (rand() % (playlist
->amount
+1));
756 case PLAYLIST_REPLACE
:
757 if (playlist_remove_all_tracks(playlist
) < 0)
760 playlist
->last_insert_pos
= position
= insert_position
= playlist
->index
+ 1;
765 flags
|= PLAYLIST_QUEUED
;
767 /* shift indices so that track can be added */
768 for (i
=playlist
->amount
; i
>insert_position
; i
--)
770 playlist
->indices
[i
] = playlist
->indices
[i
-1];
772 if (playlist
->filenames
)
773 playlist
->filenames
[i
] = playlist
->filenames
[i
-1];
777 /* update stored indices if needed */
778 if (playlist
->amount
> 0 && insert_position
<= playlist
->index
&&
782 if (playlist
->amount
> 0 && insert_position
<= playlist
->first_index
&&
783 orig_position
!= PLAYLIST_PREPEND
&& playlist
->started
)
785 playlist
->first_index
++;
789 if (insert_position
< playlist
->last_insert_pos
||
790 (insert_position
== playlist
->last_insert_pos
&& position
< 0))
791 playlist
->last_insert_pos
++;
793 if (seek_pos
< 0 && playlist
->control_fd
>= 0)
795 int result
= update_control(playlist
,
796 (queue
?PLAYLIST_COMMAND_QUEUE
:PLAYLIST_COMMAND_ADD
), position
,
797 playlist
->last_insert_pos
, filename
, NULL
, &seek_pos
);
803 playlist
->indices
[insert_position
] = flags
| seek_pos
;
806 if (playlist
->filenames
)
807 playlist
->filenames
[insert_position
] = NULL
;
811 playlist
->num_inserted_tracks
++;
813 return insert_position
;
817 * Callback for playlist_directory_tracksearch to insert track into
820 static int directory_search_callback(char* filename
, void* context
)
822 struct directory_search_context
* c
=
823 (struct directory_search_context
*) context
;
826 insert_pos
= add_track_to_playlist(c
->playlist
, filename
, c
->position
,
834 /* Make sure tracks are inserted in correct order if user requests
836 if (c
->position
== PLAYLIST_INSERT_FIRST
|| c
->position
>= 0)
837 c
->position
= insert_pos
+ 1;
839 if (((c
->count
)%PLAYLIST_DISPLAY_COUNT
) == 0)
841 unsigned char* count_str
;
844 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
846 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
848 display_playlist_count(c
->count
, count_str
, false);
850 if ((c
->count
) == PLAYLIST_DISPLAY_COUNT
&&
851 (audio_status() & AUDIO_STATUS_PLAY
) &&
852 c
->playlist
->started
)
853 audio_flush_and_reload_tracks();
860 * remove track at specified position
862 static int remove_track_from_playlist(struct playlist_info
* playlist
,
863 int position
, bool write
)
868 if (playlist
->amount
<= 0)
871 inserted
= playlist
->indices
[position
] & PLAYLIST_INSERT_TYPE_MASK
;
873 /* shift indices now that track has been removed */
874 for (i
=position
; i
<playlist
->amount
; i
++)
876 playlist
->indices
[i
] = playlist
->indices
[i
+1];
878 if (playlist
->filenames
)
879 playlist
->filenames
[i
] = playlist
->filenames
[i
+1];
886 playlist
->num_inserted_tracks
--;
888 playlist
->deleted
= true;
890 /* update stored indices if needed */
891 if (position
< playlist
->index
)
894 if (position
< playlist
->first_index
)
896 playlist
->first_index
--;
899 if (position
<= playlist
->last_insert_pos
)
900 playlist
->last_insert_pos
--;
902 if (write
&& playlist
->control_fd
>= 0)
904 int result
= update_control(playlist
, PLAYLIST_COMMAND_DELETE
,
905 position
, -1, NULL
, NULL
, NULL
);
910 sync_control(playlist
, false);
917 * randomly rearrange the array of indices for the playlist. If start_current
918 * is true then update the index to the new index of the current playing track
920 static int randomise_playlist(struct playlist_info
* playlist
,
921 unsigned int seed
, bool start_current
,
927 unsigned int current
= playlist
->indices
[playlist
->index
];
929 /* seed 0 is used to identify sorted playlist for resume purposes */
933 /* seed with the given seed */
936 /* randomise entire indices list */
937 for(count
= playlist
->amount
- 1; count
>= 0; count
--)
939 /* the rand is from 0 to RAND_MAX, so adjust to our value range */
940 candidate
= rand() % (count
+ 1);
942 /* now swap the values at the 'count' and 'candidate' positions */
943 store
= playlist
->indices
[candidate
];
944 playlist
->indices
[candidate
] = playlist
->indices
[count
];
945 playlist
->indices
[count
] = store
;
947 if (playlist
->filenames
)
949 store
= (long)playlist
->filenames
[candidate
];
950 playlist
->filenames
[candidate
] = playlist
->filenames
[count
];
951 playlist
->filenames
[count
] = (struct dircache_entry
*)store
;
957 find_and_set_playlist_index(playlist
, current
);
959 /* indices have been moved so last insert position is no longer valid */
960 playlist
->last_insert_pos
= -1;
962 playlist
->seed
= seed
;
963 if (playlist
->num_inserted_tracks
> 0 || playlist
->deleted
)
964 playlist
->shuffle_modified
= true;
968 update_control(playlist
, PLAYLIST_COMMAND_SHUFFLE
, seed
,
969 playlist
->first_index
, NULL
, NULL
, NULL
);
976 * Sort the array of indices for the playlist. If start_current is true then
977 * set the index to the new index of the current song.
979 static int sort_playlist(struct playlist_info
* playlist
, bool start_current
,
982 unsigned int current
= playlist
->indices
[playlist
->index
];
984 if (playlist
->amount
> 0)
985 qsort(playlist
->indices
, playlist
->amount
,
986 sizeof(playlist
->indices
[0]), compare
);
989 /** We need to re-check the song names from disk because qsort can't
990 * sort two arrays at once :/
991 * FIXME: Please implement a better way to do this. */
992 memset(playlist
->filenames
, 0, playlist
->max_playlist_size
* sizeof(int));
993 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
997 find_and_set_playlist_index(playlist
, current
);
999 /* indices have been moved so last insert position is no longer valid */
1000 playlist
->last_insert_pos
= -1;
1002 if (!playlist
->num_inserted_tracks
&& !playlist
->deleted
)
1003 playlist
->shuffle_modified
= false;
1004 if (write
&& playlist
->control_fd
>= 0)
1006 update_control(playlist
, PLAYLIST_COMMAND_UNSHUFFLE
,
1007 playlist
->first_index
, -1, NULL
, NULL
, NULL
);
1013 /* Calculate how many steps we have to really step when skipping entries
1016 static int calculate_step_count(const struct playlist_info
*playlist
, int steps
)
1018 int i
, count
, direction
;
1020 int stepped_count
= 0;
1033 index
= playlist
->index
;
1036 /* Boundary check */
1038 index
+= playlist
->amount
;
1039 if (index
>= playlist
->amount
)
1040 index
-= playlist
->amount
;
1042 /* Check if we found a bad entry. */
1043 if (playlist
->indices
[index
] & PLAYLIST_SKIPPED
)
1046 /* Are all entries bad? */
1047 if (stepped_count
++ > playlist
->amount
)
1054 } while (i
<= count
);
1059 /* Marks the index of the track to be skipped that is "steps" away from
1060 * current playing track.
1062 void playlist_skip_entry(struct playlist_info
*playlist
, int steps
)
1066 if (playlist
== NULL
)
1067 playlist
= ¤t_playlist
;
1069 /* need to account for already skipped tracks */
1070 steps
= calculate_step_count(playlist
, steps
);
1072 index
= playlist
->index
+ steps
;
1074 index
+= playlist
->amount
;
1075 else if (index
>= playlist
->amount
)
1076 index
-= playlist
->amount
;
1078 playlist
->indices
[index
] |= PLAYLIST_SKIPPED
;
1082 * returns the index of the track that is "steps" away from current playing
1085 static int get_next_index(const struct playlist_info
* playlist
, int steps
,
1088 int current_index
= playlist
->index
;
1089 int next_index
= -1;
1091 if (playlist
->amount
<= 0)
1094 if (repeat_mode
== -1)
1095 repeat_mode
= global_settings
.repeat_mode
;
1097 if (repeat_mode
== REPEAT_SHUFFLE
&& playlist
->amount
<= 1)
1098 repeat_mode
= REPEAT_ALL
;
1100 steps
= calculate_step_count(playlist
, steps
);
1101 switch (repeat_mode
)
1103 case REPEAT_SHUFFLE
:
1104 /* Treat repeat shuffle just like repeat off. At end of playlist,
1105 play will be resumed in playlist_next() */
1108 current_index
= rotate_index(playlist
, current_index
);
1109 next_index
= current_index
+steps
;
1110 if ((next_index
< 0) || (next_index
>= playlist
->amount
))
1113 next_index
= (next_index
+playlist
->first_index
) %
1120 #ifdef AB_REPEAT_ENABLE
1123 next_index
= current_index
;
1129 next_index
= (current_index
+steps
) % playlist
->amount
;
1130 while (next_index
< 0)
1131 next_index
+= playlist
->amount
;
1133 if (steps
>= playlist
->amount
)
1140 /* second time around so skip the queued files */
1141 for (i
=0; i
<playlist
->amount
; i
++)
1143 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
1144 index
= (index
+1) % playlist
->amount
;
1156 /* No luck if the whole playlist was bad. */
1157 if (playlist
->indices
[next_index
] & PLAYLIST_SKIPPED
)
1164 * Search for the seek track and set appropriate indices. Used after shuffle
1165 * to make sure the current index is still pointing to correct track.
1167 static void find_and_set_playlist_index(struct playlist_info
* playlist
,
1172 /* Set the index to the current song */
1173 for (i
=0; i
<playlist
->amount
; i
++)
1175 if (playlist
->indices
[i
] == seek
)
1177 playlist
->index
= playlist
->first_index
= i
;
1185 * used to sort track indices. Sort order is as follows:
1186 * 1. Prepended tracks (in prepend order)
1187 * 2. Playlist/directory tracks (in playlist order)
1188 * 3. Inserted/Appended tracks (in insert order)
1190 static int compare(const void* p1
, const void* p2
)
1192 unsigned long* e1
= (unsigned long*) p1
;
1193 unsigned long* e2
= (unsigned long*) p2
;
1194 unsigned long flags1
= *e1
& PLAYLIST_INSERT_TYPE_MASK
;
1195 unsigned long flags2
= *e2
& PLAYLIST_INSERT_TYPE_MASK
;
1197 if (flags1
== flags2
)
1198 return (*e1
& PLAYLIST_SEEK_MASK
) - (*e2
& PLAYLIST_SEEK_MASK
);
1199 else if (flags1
== PLAYLIST_INSERT_TYPE_PREPEND
||
1200 flags2
== PLAYLIST_INSERT_TYPE_APPEND
)
1202 else if (flags1
== PLAYLIST_INSERT_TYPE_APPEND
||
1203 flags2
== PLAYLIST_INSERT_TYPE_PREPEND
)
1205 else if (flags1
&& flags2
)
1206 return (*e1
& PLAYLIST_SEEK_MASK
) - (*e2
& PLAYLIST_SEEK_MASK
);
1211 #ifdef HAVE_DIRCACHE
1213 * Thread to update filename pointers to dircache on background
1214 * without affecting playlist load up performance. This thread also flushes
1215 * any pending control commands when the disk spins up.
1217 static bool playlist_flush_callback(void)
1219 struct playlist_info
*playlist
;
1220 playlist
= ¤t_playlist
;
1221 if (playlist
->control_fd
>= 0)
1223 if (playlist
->num_cached
> 0)
1225 mutex_lock(&playlist
->control_mutex
);
1226 flush_cached_control(playlist
);
1227 mutex_unlock(&playlist
->control_mutex
);
1229 sync_control(playlist
, true);
1234 static void playlist_thread(void)
1236 struct queue_event ev
;
1237 bool dirty_pointers
= false;
1238 static char tmp
[MAX_PATH
+1];
1240 struct playlist_info
*playlist
;
1247 #ifdef HAVE_DISK_STORAGE
1248 if (global_settings
.disk_spindown
> 1 &&
1249 global_settings
.disk_spindown
<= 5)
1250 sleep_time
= global_settings
.disk_spindown
- 1;
1255 queue_wait_w_tmo(&playlist_queue
, &ev
, HZ
*sleep_time
);
1259 case PLAYLIST_LOAD_POINTERS
:
1260 dirty_pointers
= true;
1263 /* Start the background scanning after either the disk spindown
1264 timeout or 5s, whichever is less */
1266 playlist
= ¤t_playlist
;
1267 if (playlist
->control_fd
>= 0)
1269 if (playlist
->num_cached
> 0)
1270 register_storage_idle_func(playlist_flush_callback
);
1273 if (!dirty_pointers
)
1276 if (!dircache_is_enabled() || !playlist
->filenames
1277 || playlist
->amount
<= 0)
1280 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1283 for (index
= 0; index
< playlist
->amount
1284 && queue_empty(&playlist_queue
); index
++)
1286 /* Process only pointers that are not already loaded. */
1287 if (playlist
->filenames
[index
])
1290 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
1291 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
1293 /* Load the filename from playlist file. */
1294 if (get_filename(playlist
, index
, seek
, control_file
, tmp
,
1298 /* Set the dircache entry pointer. */
1299 playlist
->filenames
[index
] = dircache_get_entry_ptr(tmp
);
1301 /* And be on background so user doesn't notice any delays. */
1305 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1308 dirty_pointers
= false;
1312 case SYS_USB_CONNECTED
:
1313 usb_acknowledge(SYS_USB_CONNECTED_ACK
);
1314 usb_wait_for_disconnect(&playlist_queue
);
1323 * gets pathname for track at seek index
1325 static int get_filename(struct playlist_info
* playlist
, int index
, int seek
,
1326 bool control_file
, char *buf
, int buf_length
)
1330 char tmp_buf
[MAX_PATH
+1];
1331 char dir_buf
[MAX_PATH
+1];
1332 bool utf8
= playlist
->utf8
;
1334 if (buf_length
> MAX_PATH
+1)
1335 buf_length
= MAX_PATH
+1;
1337 #ifdef HAVE_DIRCACHE
1338 if (dircache_is_enabled() && playlist
->filenames
)
1340 if (playlist
->filenames
[index
] != NULL
)
1342 dircache_copy_path(playlist
->filenames
[index
], tmp_buf
, sizeof(tmp_buf
)-1);
1343 max
= strlen(tmp_buf
) + 1;
1350 if (playlist
->in_ram
&& !control_file
&& max
< 0)
1352 strncpy(tmp_buf
, &playlist
->buffer
[seek
], sizeof(tmp_buf
));
1353 tmp_buf
[MAX_PATH
] = '\0';
1354 max
= strlen(tmp_buf
) + 1;
1358 mutex_lock(&playlist
->control_mutex
);
1362 fd
= playlist
->control_fd
;
1367 if(-1 == playlist
->fd
)
1368 playlist
->fd
= open(playlist
->filename
, O_RDONLY
);
1376 if (lseek(fd
, seek
, SEEK_SET
) != seek
)
1380 max
= read(fd
, tmp_buf
, MIN((size_t) buf_length
, sizeof(tmp_buf
)));
1382 if ((max
> 0) && !utf8
)
1384 /* Use dir_buf as a temporary buffer. Note that dir_buf must
1385 * be as large as tmp_buf.
1387 max
= convert_m3u(tmp_buf
, max
, sizeof(tmp_buf
), dir_buf
);
1392 mutex_unlock(&playlist
->control_mutex
);
1397 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
1399 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
1405 strncpy(dir_buf
, playlist
->filename
, playlist
->dirlen
-1);
1406 dir_buf
[playlist
->dirlen
-1] = 0;
1408 return (format_track_path(buf
, tmp_buf
, buf_length
, max
, dir_buf
));
1411 static int get_next_directory(char *dir
){
1412 return get_next_dir(dir
,true,false);
1415 static int get_previous_directory(char *dir
){
1416 return get_next_dir(dir
,false,false);
1420 * search through all the directories (starting with the current) to find
1421 * one that has tracks to play
1423 static int get_next_dir(char *dir
, bool is_forward
, bool recursion
)
1425 struct playlist_info
* playlist
= ¤t_playlist
;
1427 char *start_dir
= NULL
;
1430 struct tree_context
* tc
= tree_get_context();
1431 int saved_dirfilter
= *(tc
->dirfilter
);
1433 /* process random folder advance */
1434 if (global_settings
.next_folder
== FOLDER_ADVANCE_RANDOM
)
1436 int fd
= open(ROCKBOX_DIR
"/folder_advance_list.dat", O_RDONLY
);
1439 char buffer
[MAX_PATH
];
1440 int folder_count
= 0;
1441 srand(current_tick
);
1442 *(tc
->dirfilter
) = SHOW_MUSIC
;
1443 tc
->sort_dir
= global_settings
.sort_dir
;
1444 read(fd
,&folder_count
,sizeof(int));
1449 i
= rand()%folder_count
;
1450 lseek(fd
,sizeof(int) + (MAX_PATH
*i
),SEEK_SET
);
1451 read(fd
,buffer
,MAX_PATH
);
1452 if (check_subdir_for_music(buffer
, "", false) ==0)
1458 *(tc
->dirfilter
) = saved_dirfilter
;
1459 tc
->sort_dir
= global_settings
.sort_dir
;
1465 /* not random folder advance (or random folder advance unavailable) */
1468 /* start with root */
1473 /* start with current directory */
1474 strncpy(dir
, playlist
->filename
, playlist
->dirlen
-1);
1475 dir
[playlist
->dirlen
-1] = '\0';
1478 /* use the tree browser dircache to load files */
1479 *(tc
->dirfilter
) = SHOW_ALL
;
1481 /* set up sorting/direction */
1482 tc
->sort_dir
= global_settings
.sort_dir
;
1485 static const char sortpairs
[] =
1487 [SORT_ALPHA
] = SORT_ALPHA_REVERSED
,
1488 [SORT_DATE
] = SORT_DATE_REVERSED
,
1489 [SORT_TYPE
] = SORT_TYPE_REVERSED
,
1490 [SORT_ALPHA_REVERSED
] = SORT_ALPHA
,
1491 [SORT_DATE_REVERSED
] = SORT_DATE
,
1492 [SORT_TYPE_REVERSED
] = SORT_TYPE
,
1495 if ((unsigned)tc
->sort_dir
< sizeof(sortpairs
))
1496 tc
->sort_dir
= sortpairs
[tc
->sort_dir
];
1501 struct entry
*files
;
1505 if (ft_load(tc
, (dir
[0]=='\0')?"/":dir
) < 0)
1512 files
= (struct entry
*) tc
->dircache
;
1513 num_files
= tc
->filesindir
;
1515 for (i
=0; i
<num_files
; i
++)
1518 if (action_userabort(TIMEOUT_NOBLOCK
))
1525 if (files
[i
].attr
& ATTR_DIRECTORY
)
1529 result
= check_subdir_for_music(dir
, files
[i
].name
, true);
1536 else if (!strcmp(start_dir
, files
[i
].name
))
1543 /* move down to parent directory. current directory name is
1544 stored as the starting point for the search in parent */
1545 start_dir
= strrchr(dir
, '/');
1556 /* restore dirfilter */
1557 *(tc
->dirfilter
) = saved_dirfilter
;
1558 tc
->sort_dir
= global_settings
.sort_dir
;
1560 /* special case if nothing found: try start searching again from root */
1561 if (result
== -1 && !recursion
){
1562 result
= get_next_dir(dir
, is_forward
, true);
1569 * Checks if there are any music files in the dir or any of its
1570 * subdirectories. May be called recursively.
1572 static int check_subdir_for_music(char *dir
, const char *subdir
, bool recurse
)
1575 int dirlen
= strlen(dir
);
1578 struct entry
*files
;
1579 bool has_music
= false;
1580 bool has_subdir
= false;
1581 struct tree_context
* tc
= tree_get_context();
1583 snprintf(dir
+dirlen
, MAX_PATH
-dirlen
, "/%s", subdir
);
1585 if (ft_load(tc
, dir
) < 0)
1590 files
= (struct entry
*) tc
->dircache
;
1591 num_files
= tc
->filesindir
;
1593 for (i
=0; i
<num_files
; i
++)
1595 if (files
[i
].attr
& ATTR_DIRECTORY
)
1597 else if ((files
[i
].attr
& FILE_ATTR_MASK
) == FILE_ATTR_AUDIO
)
1607 if (has_subdir
&& recurse
)
1609 for (i
=0; i
<num_files
; i
++)
1611 if (action_userabort(TIMEOUT_NOBLOCK
))
1617 if (files
[i
].attr
& ATTR_DIRECTORY
)
1619 result
= check_subdir_for_music(dir
, files
[i
].name
, true);
1637 /* we now need to reload our current directory */
1638 if(ft_load(tc
, dir
) < 0)
1639 splash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
1645 * Returns absolute path of track
1647 static int format_track_path(char *dest
, char *src
, int buf_length
, int max
,
1654 /* Zero-terminate the file name */
1655 while((src
[i
] != '\n') &&
1660 /* Now work back killing white space */
1661 while((src
[i
-1] == ' ') ||
1667 /* replace backslashes with forward slashes */
1668 for ( j
=0; j
<i
; j
++ )
1669 if ( src
[j
] == '\\' )
1674 strncpy(dest
, src
, buf_length
);
1678 /* handle dos style drive letter */
1680 strncpy(dest
, &src
[2], buf_length
);
1681 else if (!strncmp(src
, "../", 3))
1683 /* handle relative paths */
1685 while(!strncmp(&src
[i
], "../", 3))
1687 for (j
=0; j
<i
/3; j
++) {
1688 temp_ptr
= strrchr(dir
, '/');
1694 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[i
]);
1696 else if ( '.' == src
[0] && '/' == src
[1] ) {
1697 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[2]);
1700 snprintf(dest
, buf_length
, "%s/%s", dir
, src
);
1708 * Display splash message showing progress of playlist/directory insertion or
1711 static void display_playlist_count(int count
, const unsigned char *fmt
,
1714 static long talked_tick
= 0;
1715 long id
= P2ID(fmt
);
1716 if(global_settings
.talk_menu
&& id
>=0)
1718 if(final
|| (count
&& (talked_tick
== 0
1719 || TIME_AFTER(current_tick
, talked_tick
+5*HZ
))))
1721 talked_tick
= current_tick
;
1722 talk_number(count
, false);
1728 splashf(0, fmt
, count
, str(LANG_OFF_ABORT
));
1732 * Display buffer full message
1734 static void display_buffer_full(void)
1736 splash(HZ
*2, ID2P(LANG_PLAYLIST_BUFFER_FULL
));
1740 * Flush any cached control commands to disk. Called when playlist is being
1741 * modified. Returns 0 on success and -1 on failure.
1743 static int flush_cached_control(struct playlist_info
* playlist
)
1748 if (!playlist
->num_cached
)
1751 lseek(playlist
->control_fd
, 0, SEEK_END
);
1753 for (i
=0; i
<playlist
->num_cached
; i
++)
1755 struct playlist_control_cache
* cache
=
1756 &(playlist
->control_cache
[i
]);
1758 switch (cache
->command
)
1760 case PLAYLIST_COMMAND_PLAYLIST
:
1761 result
= fdprintf(playlist
->control_fd
, "P:%d:%s:%s\n",
1762 cache
->i1
, cache
->s1
, cache
->s2
);
1764 case PLAYLIST_COMMAND_ADD
:
1765 case PLAYLIST_COMMAND_QUEUE
:
1766 result
= fdprintf(playlist
->control_fd
, "%c:%d:%d:",
1767 (cache
->command
== PLAYLIST_COMMAND_ADD
)?'A':'Q',
1768 cache
->i1
, cache
->i2
);
1771 /* save the position in file where name is written */
1772 int* seek_pos
= (int *)cache
->data
;
1773 *seek_pos
= lseek(playlist
->control_fd
, 0, SEEK_CUR
);
1774 result
= fdprintf(playlist
->control_fd
, "%s\n",
1778 case PLAYLIST_COMMAND_DELETE
:
1779 result
= fdprintf(playlist
->control_fd
, "D:%d\n", cache
->i1
);
1781 case PLAYLIST_COMMAND_SHUFFLE
:
1782 result
= fdprintf(playlist
->control_fd
, "S:%d:%d\n",
1783 cache
->i1
, cache
->i2
);
1785 case PLAYLIST_COMMAND_UNSHUFFLE
:
1786 result
= fdprintf(playlist
->control_fd
, "U:%d\n", cache
->i1
);
1788 case PLAYLIST_COMMAND_RESET
:
1789 result
= fdprintf(playlist
->control_fd
, "R\n");
1801 playlist
->num_cached
= 0;
1802 playlist
->pending_control_sync
= true;
1809 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_UPDATE_ERROR
));
1816 * Update control data with new command. Depending on the command, it may be
1817 * cached or flushed to disk.
1819 static int update_control(struct playlist_info
* playlist
,
1820 enum playlist_command command
, int i1
, int i2
,
1821 const char* s1
, const char* s2
, void* data
)
1824 struct playlist_control_cache
* cache
;
1827 mutex_lock(&playlist
->control_mutex
);
1829 cache
= &(playlist
->control_cache
[playlist
->num_cached
++]);
1831 cache
->command
= command
;
1840 case PLAYLIST_COMMAND_PLAYLIST
:
1841 case PLAYLIST_COMMAND_ADD
:
1842 case PLAYLIST_COMMAND_QUEUE
:
1843 #ifndef HAVE_DIRCACHE
1844 case PLAYLIST_COMMAND_DELETE
:
1845 case PLAYLIST_COMMAND_RESET
:
1849 case PLAYLIST_COMMAND_SHUFFLE
:
1850 case PLAYLIST_COMMAND_UNSHUFFLE
:
1852 /* only flush when needed */
1856 if (flush
|| playlist
->num_cached
== PLAYLIST_MAX_CACHE
)
1857 result
= flush_cached_control(playlist
);
1859 mutex_unlock(&playlist
->control_mutex
);
1865 * sync control file to disk
1867 static void sync_control(struct playlist_info
* playlist
, bool force
)
1869 #ifdef HAVE_DIRCACHE
1870 if (playlist
->started
&& force
)
1874 if (playlist
->started
)
1877 if (playlist
->pending_control_sync
)
1879 mutex_lock(&playlist
->control_mutex
);
1880 fsync(playlist
->control_fd
);
1881 playlist
->pending_control_sync
= false;
1882 mutex_unlock(&playlist
->control_mutex
);
1888 * Rotate indices such that first_index is index 0
1890 static int rotate_index(const struct playlist_info
* playlist
, int index
)
1892 index
-= playlist
->first_index
;
1894 index
+= playlist
->amount
;
1900 * Initialize playlist entries at startup
1902 void playlist_init(void)
1904 struct playlist_info
* playlist
= ¤t_playlist
;
1906 playlist
->current
= true;
1907 strncpy(playlist
->control_filename
, PLAYLIST_CONTROL_FILE
,
1908 sizeof(playlist
->control_filename
));
1910 playlist
->control_fd
= -1;
1911 playlist
->max_playlist_size
= global_settings
.max_files_in_playlist
;
1912 playlist
->indices
= buffer_alloc(
1913 playlist
->max_playlist_size
* sizeof(int));
1914 playlist
->buffer_size
=
1915 AVERAGE_FILENAME_LENGTH
* global_settings
.max_files_in_dir
;
1916 playlist
->buffer
= buffer_alloc(playlist
->buffer_size
);
1917 mutex_init(&playlist
->control_mutex
);
1918 empty_playlist(playlist
, true);
1920 #ifdef HAVE_DIRCACHE
1921 playlist
->filenames
= buffer_alloc(
1922 playlist
->max_playlist_size
* sizeof(int));
1923 memset(playlist
->filenames
, 0,
1924 playlist
->max_playlist_size
* sizeof(int));
1925 create_thread(playlist_thread
, playlist_stack
, sizeof(playlist_stack
),
1926 0, playlist_thread_name
IF_PRIO(, PRIORITY_BACKGROUND
)
1928 queue_init(&playlist_queue
, true);
1933 * Clean playlist at shutdown
1935 void playlist_shutdown(void)
1937 struct playlist_info
* playlist
= ¤t_playlist
;
1939 if (playlist
->control_fd
>= 0)
1941 mutex_lock(&playlist
->control_mutex
);
1943 if (playlist
->num_cached
> 0)
1944 flush_cached_control(playlist
);
1946 close(playlist
->control_fd
);
1948 mutex_unlock(&playlist
->control_mutex
);
1953 * Create new playlist
1955 int playlist_create(const char *dir
, const char *file
)
1957 struct playlist_info
* playlist
= ¤t_playlist
;
1959 new_playlist(playlist
, dir
, file
);
1962 /* load the playlist file */
1963 add_indices_to_playlist(playlist
, NULL
, 0);
1968 #define PLAYLIST_COMMAND_SIZE (MAX_PATH+12)
1971 * Restore the playlist state based on control file commands. Called to
1972 * resume playback after shutdown.
1974 int playlist_resume(void)
1976 struct playlist_info
* playlist
= ¤t_playlist
;
1981 int control_file_size
= 0;
1985 /* use mp3 buffer for maximum load speed */
1986 #if CONFIG_CODEC != SWCODEC
1987 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
1988 buflen
= (audiobufend
- audiobuf
);
1989 buffer
= (char *)audiobuf
;
1991 buffer
= (char *)audio_get_buffer(false, &buflen
);
1994 empty_playlist(playlist
, true);
1996 splash(0, ID2P(LANG_WAIT
));
1997 playlist
->control_fd
= open(playlist
->control_filename
, O_RDWR
);
1998 if (playlist
->control_fd
< 0)
2000 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2003 playlist
->control_created
= true;
2005 control_file_size
= filesize(playlist
->control_fd
);
2006 if (control_file_size
<= 0)
2008 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2012 /* read a small amount first to get the header */
2013 nread
= read(playlist
->control_fd
, buffer
,
2014 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
2017 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2021 playlist
->started
= true;
2027 enum playlist_command current_command
= PLAYLIST_COMMAND_COMMENT
;
2028 int last_newline
= 0;
2030 bool newline
= true;
2031 bool exit_loop
= false;
2036 unsigned long last_tick
= current_tick
;
2037 bool useraborted
= false;
2039 for(count
=0; count
<nread
&& !exit_loop
&& !useraborted
; count
++,p
++)
2041 /* So a splash while we are loading. */
2042 if (TIME_AFTER(current_tick
, last_tick
+ HZ
/4))
2044 splashf(0, str(LANG_LOADING_PERCENT
),
2045 (total_read
+count
)*100/control_file_size
,
2046 str(LANG_OFF_ABORT
));
2047 if (action_userabort(TIMEOUT_NOBLOCK
))
2052 last_tick
= current_tick
;
2055 /* Are we on a new line? */
2056 if((*p
== '\n') || (*p
== '\r'))
2060 /* save last_newline in case we need to load more data */
2061 last_newline
= count
;
2063 switch (current_command
)
2065 case PLAYLIST_COMMAND_PLAYLIST
:
2067 /* str1=version str2=dir str3=file */
2083 version
= atoi(str1
);
2085 if (version
!= PLAYLIST_CONTROL_FILE_VERSION
)
2088 update_playlist_filename(playlist
, str2
, str3
);
2090 if (str3
[0] != '\0')
2092 /* NOTE: add_indices_to_playlist() overwrites the
2093 audiobuf so we need to reload control file
2095 add_indices_to_playlist(playlist
, NULL
, 0);
2097 else if (str2
[0] != '\0')
2099 playlist
->in_ram
= true;
2100 resume_directory(str2
);
2103 /* load the rest of the data */
2109 case PLAYLIST_COMMAND_ADD
:
2110 case PLAYLIST_COMMAND_QUEUE
:
2112 /* str1=position str2=last_position str3=file */
2113 int position
, last_position
;
2116 if (!str1
|| !str2
|| !str3
)
2123 position
= atoi(str1
);
2124 last_position
= atoi(str2
);
2126 queue
= (current_command
== PLAYLIST_COMMAND_ADD
)?
2129 /* seek position is based on str3's position in
2131 if (add_track_to_playlist(playlist
, str3
, position
,
2132 queue
, total_read
+(str3
-buffer
)) < 0)
2135 playlist
->last_insert_pos
= last_position
;
2139 case PLAYLIST_COMMAND_DELETE
:
2151 position
= atoi(str1
);
2153 if (remove_track_from_playlist(playlist
, position
,
2159 case PLAYLIST_COMMAND_SHUFFLE
:
2161 /* str1=seed str2=first_index */
2173 /* Always sort list before shuffling */
2174 sort_playlist(playlist
, false, false);
2178 playlist
->first_index
= atoi(str2
);
2180 if (randomise_playlist(playlist
, seed
, false,
2186 case PLAYLIST_COMMAND_UNSHUFFLE
:
2188 /* str1=first_index */
2196 playlist
->first_index
= atoi(str1
);
2198 if (sort_playlist(playlist
, false, false) < 0)
2204 case PLAYLIST_COMMAND_RESET
:
2206 playlist
->last_insert_pos
= -1;
2209 case PLAYLIST_COMMAND_COMMENT
:
2216 /* to ignore any extra newlines */
2217 current_command
= PLAYLIST_COMMAND_COMMENT
;
2223 /* first non-comment line must always specify playlist */
2224 if (first
&& *p
!= 'P' && *p
!= '#')
2234 /* playlist can only be specified once */
2242 current_command
= PLAYLIST_COMMAND_PLAYLIST
;
2245 current_command
= PLAYLIST_COMMAND_ADD
;
2248 current_command
= PLAYLIST_COMMAND_QUEUE
;
2251 current_command
= PLAYLIST_COMMAND_DELETE
;
2254 current_command
= PLAYLIST_COMMAND_SHUFFLE
;
2257 current_command
= PLAYLIST_COMMAND_UNSHUFFLE
;
2260 current_command
= PLAYLIST_COMMAND_RESET
;
2263 current_command
= PLAYLIST_COMMAND_COMMENT
;
2276 else if(current_command
!= PLAYLIST_COMMAND_COMMENT
)
2278 /* all control file strings are separated with a colon.
2279 Replace the colon with 0 to get proper strings that can be
2280 used by commands above */
2286 if ((count
+1) < nread
)
2300 /* allow last string to contain colons */
2311 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID
));
2317 splash(HZ
*2, ID2P(LANG_CANCEL
));
2320 if (!newline
|| (exit_loop
&& count
<nread
))
2322 if ((total_read
+ count
) >= control_file_size
)
2324 /* no newline at end of control file */
2325 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID
));
2329 /* We didn't end on a newline or we exited loop prematurely.
2330 Either way, re-read the remainder. */
2331 count
= last_newline
;
2332 lseek(playlist
->control_fd
, total_read
+count
, SEEK_SET
);
2335 total_read
+= count
;
2338 /* still looking for header */
2339 nread
= read(playlist
->control_fd
, buffer
,
2340 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
2342 nread
= read(playlist
->control_fd
, buffer
, buflen
);
2344 /* Terminate on EOF */
2347 playlist
->first_index
= 0;
2352 #ifdef HAVE_DIRCACHE
2353 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2360 * Add track to in_ram playlist. Used when playing directories.
2362 int playlist_add(const char *filename
)
2364 struct playlist_info
* playlist
= ¤t_playlist
;
2365 int len
= strlen(filename
);
2367 if((len
+1 > playlist
->buffer_size
- playlist
->buffer_end_pos
) ||
2368 (playlist
->amount
>= playlist
->max_playlist_size
))
2370 display_buffer_full();
2374 playlist
->indices
[playlist
->amount
] = playlist
->buffer_end_pos
;
2375 #ifdef HAVE_DIRCACHE
2376 playlist
->filenames
[playlist
->amount
] = NULL
;
2380 strcpy(&playlist
->buffer
[playlist
->buffer_end_pos
], filename
);
2381 playlist
->buffer_end_pos
+= len
;
2382 playlist
->buffer
[playlist
->buffer_end_pos
++] = '\0';
2387 /* shuffle newly created playlist using random seed. */
2388 int playlist_shuffle(int random_seed
, int start_index
)
2390 struct playlist_info
* playlist
= ¤t_playlist
;
2392 unsigned int seek_pos
= 0;
2393 bool start_current
= false;
2395 if (start_index
>= 0 && global_settings
.play_selected
)
2397 /* store the seek position before the shuffle */
2398 seek_pos
= playlist
->indices
[start_index
];
2399 playlist
->index
= playlist
->first_index
= start_index
;
2400 start_current
= true;
2403 randomise_playlist(playlist
, random_seed
, start_current
, true);
2405 return playlist
->index
;
2408 /* start playing current playlist at specified index/offset */
2409 int playlist_start(int start_index
, int offset
)
2411 struct playlist_info
* playlist
= ¤t_playlist
;
2413 /* Cancel FM radio selection as previous music. For cases where we start
2414 playback without going to the WPS, such as playlist insert.. or
2415 playlist catalog. */
2416 previous_music_is_wps();
2418 playlist
->index
= start_index
;
2420 #if CONFIG_CODEC != SWCODEC
2421 talk_buffer_steal(); /* will use the mp3 buffer */
2424 playlist
->started
= true;
2425 sync_control(playlist
, false);
2431 /* Returns false if 'steps' is out of bounds, else true */
2432 bool playlist_check(int steps
)
2434 struct playlist_info
* playlist
= ¤t_playlist
;
2436 /* always allow folder navigation */
2437 if (global_settings
.next_folder
&& playlist
->in_ram
)
2440 int index
= get_next_index(playlist
, steps
, -1);
2442 if (index
< 0 && steps
>= 0 && global_settings
.repeat_mode
== REPEAT_SHUFFLE
)
2443 index
= get_next_index(playlist
, steps
, REPEAT_ALL
);
2445 return (index
>= 0);
2448 /* get trackname of track that is "steps" away from current playing track.
2449 NULL is used to identify end of playlist */
2450 char* playlist_peek(int steps
)
2452 struct playlist_info
* playlist
= ¤t_playlist
;
2458 index
= get_next_index(playlist
, steps
, -1);
2462 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
2463 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
2465 if (get_filename(playlist
, index
, seek
, control_file
, now_playing
,
2469 temp_ptr
= now_playing
;
2471 if (!playlist
->in_ram
|| control_file
)
2473 /* remove bogus dirs from beginning of path
2474 (workaround for buggy playlist creation tools) */
2477 if (file_exists(temp_ptr
))
2480 temp_ptr
= strchr(temp_ptr
+1, '/');
2485 /* Even though this is an invalid file, we still need to pass a
2486 file name to the caller because NULL is used to indicate end
2496 * Update indices as track has changed
2498 int playlist_next(int steps
)
2500 struct playlist_info
* playlist
= ¤t_playlist
;
2504 #ifdef AB_REPEAT_ENABLE
2505 && (global_settings
.repeat_mode
!= REPEAT_AB
)
2507 && (global_settings
.repeat_mode
!= REPEAT_ONE
) )
2511 /* We need to delete all the queued songs */
2512 for (i
=0, j
=steps
; i
<j
; i
++)
2514 index
= get_next_index(playlist
, i
, -1);
2516 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
2518 remove_track_from_playlist(playlist
, index
, true);
2519 steps
--; /* one less track */
2524 index
= get_next_index(playlist
, steps
, -1);
2528 /* end of playlist... or is it */
2529 if (global_settings
.repeat_mode
== REPEAT_SHUFFLE
&&
2530 playlist
->amount
> 1)
2532 /* Repeat shuffle mode. Re-shuffle playlist and resume play */
2533 playlist
->first_index
= 0;
2534 sort_playlist(playlist
, false, false);
2535 randomise_playlist(playlist
, current_tick
, false, true);
2536 #if CONFIG_CODEC != SWCODEC
2537 playlist_start(0, 0);
2539 playlist
->index
= 0;
2542 else if (playlist
->in_ram
&& global_settings
.next_folder
)
2544 index
= create_and_play_dir(steps
, true);
2548 playlist
->index
= index
;
2555 playlist
->index
= index
;
2557 if (playlist
->last_insert_pos
>= 0 && steps
> 0)
2559 /* check to see if we've gone beyond the last inserted track */
2560 int cur
= rotate_index(playlist
, index
);
2561 int last_pos
= rotate_index(playlist
, playlist
->last_insert_pos
);
2565 /* reset last inserted track */
2566 playlist
->last_insert_pos
= -1;
2568 if (playlist
->control_fd
>= 0)
2570 int result
= update_control(playlist
, PLAYLIST_COMMAND_RESET
,
2571 -1, -1, NULL
, NULL
, NULL
);
2576 sync_control(playlist
, false);
2584 /* try playing next or previous folder */
2585 bool playlist_next_dir(int direction
)
2587 /* not to mess up real playlists */
2588 if(!current_playlist
.in_ram
)
2591 return create_and_play_dir(direction
, false) >= 0;
2594 /* Get resume info for current playing song. If return value is -1 then
2595 settings shouldn't be saved. */
2596 int playlist_get_resume_info(int *resume_index
)
2598 struct playlist_info
* playlist
= ¤t_playlist
;
2600 *resume_index
= playlist
->index
;
2605 /* Update resume info for current playing song. Returns -1 on error. */
2606 int playlist_update_resume_info(const struct mp3entry
* id3
)
2608 struct playlist_info
* playlist
= ¤t_playlist
;
2612 if (global_status
.resume_index
!= playlist
->index
||
2613 global_status
.resume_offset
!= id3
->offset
)
2615 global_status
.resume_index
= playlist
->index
;
2616 global_status
.resume_offset
= id3
->offset
;
2622 global_status
.resume_index
= -1;
2623 global_status
.resume_offset
= -1;
2630 /* Returns index of current playing track for display purposes. This value
2631 should not be used for resume purposes as it doesn't represent the actual
2632 index into the playlist */
2633 int playlist_get_display_index(void)
2635 struct playlist_info
* playlist
= ¤t_playlist
;
2637 /* first_index should always be index 0 for display purposes */
2638 int index
= rotate_index(playlist
, playlist
->index
);
2643 /* returns number of tracks in current playlist */
2644 int playlist_amount(void)
2646 return playlist_amount_ex(NULL
);
2650 * Create a new playlist If playlist is not NULL then we're loading a
2651 * playlist off disk for viewing/editing. The index_buffer is used to store
2652 * playlist indices (required for and only used if !current playlist). The
2653 * temp_buffer (if not NULL) is used as a scratchpad when loading indices.
2655 int playlist_create_ex(struct playlist_info
* playlist
,
2656 const char* dir
, const char* file
,
2657 void* index_buffer
, int index_buffer_size
,
2658 void* temp_buffer
, int temp_buffer_size
)
2661 playlist
= ¤t_playlist
;
2664 /* Initialize playlist structure */
2665 int r
= rand() % 10;
2666 playlist
->current
= false;
2668 /* Use random name for control file */
2669 snprintf(playlist
->control_filename
, sizeof(playlist
->control_filename
),
2670 "%s.%d", PLAYLIST_CONTROL_FILE
, r
);
2672 playlist
->control_fd
= -1;
2676 int num_indices
= index_buffer_size
/ sizeof(int);
2678 #ifdef HAVE_DIRCACHE
2681 if (num_indices
> global_settings
.max_files_in_playlist
)
2682 num_indices
= global_settings
.max_files_in_playlist
;
2684 playlist
->max_playlist_size
= num_indices
;
2685 playlist
->indices
= index_buffer
;
2686 #ifdef HAVE_DIRCACHE
2687 playlist
->filenames
= (const struct dircache_entry
**)
2688 &playlist
->indices
[num_indices
];
2693 playlist
->max_playlist_size
= current_playlist
.max_playlist_size
;
2694 playlist
->indices
= current_playlist
.indices
;
2695 #ifdef HAVE_DIRCACHE
2696 playlist
->filenames
= current_playlist
.filenames
;
2700 playlist
->buffer_size
= 0;
2701 playlist
->buffer
= NULL
;
2702 mutex_init(&playlist
->control_mutex
);
2705 new_playlist(playlist
, dir
, file
);
2708 /* load the playlist file */
2709 add_indices_to_playlist(playlist
, temp_buffer
, temp_buffer_size
);
2715 * Set the specified playlist as the current.
2716 * NOTE: You will get undefined behaviour if something is already playing so
2717 * remember to stop before calling this. Also, this call will
2718 * effectively close your playlist, making it unusable.
2720 int playlist_set_current(struct playlist_info
* playlist
)
2722 if (!playlist
|| (check_control(playlist
) < 0))
2725 empty_playlist(¤t_playlist
, false);
2727 strncpy(current_playlist
.filename
, playlist
->filename
,
2728 sizeof(current_playlist
.filename
));
2730 current_playlist
.utf8
= playlist
->utf8
;
2731 current_playlist
.fd
= playlist
->fd
;
2733 close(playlist
->control_fd
);
2734 close(current_playlist
.control_fd
);
2735 remove(current_playlist
.control_filename
);
2736 if (rename(playlist
->control_filename
,
2737 current_playlist
.control_filename
) < 0)
2739 current_playlist
.control_fd
= open(current_playlist
.control_filename
,
2741 if (current_playlist
.control_fd
< 0)
2743 current_playlist
.control_created
= true;
2745 current_playlist
.dirlen
= playlist
->dirlen
;
2747 if (playlist
->indices
&& playlist
->indices
!= current_playlist
.indices
)
2749 memcpy(current_playlist
.indices
, playlist
->indices
,
2750 playlist
->max_playlist_size
*sizeof(int));
2751 #ifdef HAVE_DIRCACHE
2752 memcpy(current_playlist
.filenames
, playlist
->filenames
,
2753 playlist
->max_playlist_size
*sizeof(int));
2757 current_playlist
.first_index
= playlist
->first_index
;
2758 current_playlist
.amount
= playlist
->amount
;
2759 current_playlist
.last_insert_pos
= playlist
->last_insert_pos
;
2760 current_playlist
.seed
= playlist
->seed
;
2761 current_playlist
.shuffle_modified
= playlist
->shuffle_modified
;
2762 current_playlist
.deleted
= playlist
->deleted
;
2763 current_playlist
.num_inserted_tracks
= playlist
->num_inserted_tracks
;
2765 memcpy(current_playlist
.control_cache
, playlist
->control_cache
,
2766 sizeof(current_playlist
.control_cache
));
2767 current_playlist
.num_cached
= playlist
->num_cached
;
2768 current_playlist
.pending_control_sync
= playlist
->pending_control_sync
;
2774 * Close files and delete control file for non-current playlist.
2776 void playlist_close(struct playlist_info
* playlist
)
2781 if (playlist
->fd
>= 0)
2782 close(playlist
->fd
);
2784 if (playlist
->control_fd
>= 0)
2785 close(playlist
->control_fd
);
2787 if (playlist
->control_created
)
2788 remove(playlist
->control_filename
);
2791 void playlist_sync(struct playlist_info
* playlist
)
2794 playlist
= ¤t_playlist
;
2796 sync_control(playlist
, false);
2797 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2798 audio_flush_and_reload_tracks();
2800 #ifdef HAVE_DIRCACHE
2801 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2806 * Insert track into playlist at specified position (or one of the special
2807 * positions). Returns position where track was inserted or -1 if error.
2809 int playlist_insert_track(struct playlist_info
* playlist
, const char *filename
,
2810 int position
, bool queue
, bool sync
)
2815 playlist
= ¤t_playlist
;
2817 if (check_control(playlist
) < 0)
2819 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2823 result
= add_track_to_playlist(playlist
, filename
, position
, queue
, -1);
2825 /* Check if we want manually sync later. For example when adding
2826 * bunch of files from tagcache, syncing after every file wouldn't be
2827 * a good thing to do. */
2828 if (sync
&& result
>= 0)
2829 playlist_sync(playlist
);
2835 * Insert all tracks from specified directory into playlist.
2837 int playlist_insert_directory(struct playlist_info
* playlist
,
2838 const char *dirname
, int position
, bool queue
,
2842 unsigned char *count_str
;
2843 struct directory_search_context context
;
2846 playlist
= ¤t_playlist
;
2848 if (check_control(playlist
) < 0)
2850 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2854 if (position
== PLAYLIST_REPLACE
)
2856 if (playlist_remove_all_tracks(playlist
) == 0)
2857 position
= PLAYLIST_INSERT_LAST
;
2863 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
2865 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
2867 display_playlist_count(0, count_str
, false);
2869 context
.playlist
= playlist
;
2870 context
.position
= position
;
2871 context
.queue
= queue
;
2876 result
= playlist_directory_tracksearch(dirname
, recurse
,
2877 directory_search_callback
, &context
);
2879 sync_control(playlist
, false);
2883 display_playlist_count(context
.count
, count_str
, true);
2885 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2886 audio_flush_and_reload_tracks();
2888 #ifdef HAVE_DIRCACHE
2889 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2896 * Insert all tracks from specified playlist into dynamic playlist.
2898 int playlist_insert_playlist(struct playlist_info
* playlist
, const char *filename
,
2899 int position
, bool queue
)
2905 unsigned char *count_str
;
2906 char temp_buf
[MAX_PATH
+1];
2907 char trackname
[MAX_PATH
+1];
2910 bool utf8
= is_m3u8(filename
);
2913 playlist
= ¤t_playlist
;
2915 if (check_control(playlist
) < 0)
2917 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2921 fd
= open_utf8(filename
, O_RDONLY
);
2924 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
2928 /* we need the directory name for formatting purposes */
2931 temp_ptr
= strrchr(filename
+1,'/');
2938 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
2940 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
2942 display_playlist_count(count
, count_str
, false);
2944 if (position
== PLAYLIST_REPLACE
)
2946 if (playlist_remove_all_tracks(playlist
) == 0)
2947 position
= PLAYLIST_INSERT_LAST
;
2953 while ((max
= read_line(fd
, temp_buf
, sizeof(temp_buf
))) > 0)
2956 if (action_userabort(TIMEOUT_NOBLOCK
))
2959 if (temp_buf
[0] != '#' && temp_buf
[0] != '\0')
2965 /* Use trackname as a temporay buffer. Note that trackname must
2966 * be as large as temp_buf.
2968 max
= convert_m3u(temp_buf
, max
, sizeof(temp_buf
), trackname
);
2971 /* we need to format so that relative paths are correctly
2973 if (format_track_path(trackname
, temp_buf
, sizeof(trackname
), max
,
2980 insert_pos
= add_track_to_playlist(playlist
, trackname
, position
,
2989 /* Make sure tracks are inserted in correct order if user
2990 requests INSERT_FIRST */
2991 if (position
== PLAYLIST_INSERT_FIRST
|| position
>= 0)
2992 position
= insert_pos
+ 1;
2996 if ((count
%PLAYLIST_DISPLAY_COUNT
) == 0)
2998 display_playlist_count(count
, count_str
, false);
3000 if (count
== PLAYLIST_DISPLAY_COUNT
&&
3001 (audio_status() & AUDIO_STATUS_PLAY
) &&
3003 audio_flush_and_reload_tracks();
3007 /* let the other threads work */
3016 sync_control(playlist
, false);
3020 display_playlist_count(count
, count_str
, true);
3022 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3023 audio_flush_and_reload_tracks();
3025 #ifdef HAVE_DIRCACHE
3026 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3033 * Delete track at specified index. If index is PLAYLIST_DELETE_CURRENT then
3034 * we want to delete the current playing track.
3036 int playlist_delete(struct playlist_info
* playlist
, int index
)
3041 playlist
= ¤t_playlist
;
3043 if (check_control(playlist
) < 0)
3045 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3049 if (index
== PLAYLIST_DELETE_CURRENT
)
3050 index
= playlist
->index
;
3052 result
= remove_track_from_playlist(playlist
, index
, true);
3054 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3056 audio_flush_and_reload_tracks();
3062 * Move track at index to new_index. Tracks between the two are shifted
3063 * appropriately. Returns 0 on success and -1 on failure.
3065 int playlist_move(struct playlist_info
* playlist
, int index
, int new_index
)
3071 bool current
= false;
3073 char filename
[MAX_PATH
];
3076 playlist
= ¤t_playlist
;
3078 if (check_control(playlist
) < 0)
3080 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3084 if (index
== new_index
)
3087 if (index
== playlist
->index
)
3088 /* Moving the current track */
3091 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3092 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3093 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3095 if (get_filename(playlist
, index
, seek
, control_file
, filename
,
3096 sizeof(filename
)) < 0)
3099 /* Delete track from original position */
3100 result
= remove_track_from_playlist(playlist
, index
, true);
3104 /* We want to insert the track at the position that was specified by
3105 new_index. This may be different then new_index because of the
3106 shifting that occurred after the delete */
3107 r
= rotate_index(playlist
, new_index
);
3111 new_index
= PLAYLIST_PREPEND
;
3112 else if (r
== playlist
->amount
)
3114 new_index
= PLAYLIST_INSERT_LAST
;
3116 /* Calculate index of desired position */
3117 new_index
= (r
+playlist
->first_index
)%playlist
->amount
;
3119 result
= add_track_to_playlist(playlist
, filename
, new_index
, queue
,
3126 /* Moved the current track */
3129 case PLAYLIST_PREPEND
:
3130 playlist
->index
= playlist
->first_index
;
3132 case PLAYLIST_INSERT_LAST
:
3133 playlist
->index
= playlist
->first_index
- 1;
3134 if (playlist
->index
< 0)
3135 playlist
->index
+= playlist
->amount
;
3138 playlist
->index
= new_index
;
3143 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3144 audio_flush_and_reload_tracks();
3148 #ifdef HAVE_DIRCACHE
3149 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3155 /* shuffle currently playing playlist */
3156 int playlist_randomise(struct playlist_info
* playlist
, unsigned int seed
,
3162 playlist
= ¤t_playlist
;
3164 check_control(playlist
);
3166 result
= randomise_playlist(playlist
, seed
, start_current
, true);
3168 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3170 audio_flush_and_reload_tracks();
3175 /* sort currently playing playlist */
3176 int playlist_sort(struct playlist_info
* playlist
, bool start_current
)
3181 playlist
= ¤t_playlist
;
3183 check_control(playlist
);
3185 result
= sort_playlist(playlist
, start_current
, true);
3187 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3189 audio_flush_and_reload_tracks();
3194 /* returns true if playlist has been modified */
3195 bool playlist_modified(const struct playlist_info
* playlist
)
3198 playlist
= ¤t_playlist
;
3200 if (playlist
->shuffle_modified
||
3201 playlist
->deleted
||
3202 playlist
->num_inserted_tracks
> 0)
3208 /* returns index of first track in playlist */
3209 int playlist_get_first_index(const struct playlist_info
* playlist
)
3212 playlist
= ¤t_playlist
;
3214 return playlist
->first_index
;
3217 /* returns shuffle seed of playlist */
3218 int playlist_get_seed(const struct playlist_info
* playlist
)
3221 playlist
= ¤t_playlist
;
3223 return playlist
->seed
;
3226 /* returns number of tracks in playlist (includes queued/inserted tracks) */
3227 int playlist_amount_ex(const struct playlist_info
* playlist
)
3230 playlist
= ¤t_playlist
;
3232 return playlist
->amount
;
3235 /* returns full path of playlist (minus extension) */
3236 char *playlist_name(const struct playlist_info
* playlist
, char *buf
,
3242 playlist
= ¤t_playlist
;
3244 strncpy(buf
, playlist
->filename
+playlist
->dirlen
, buf_size
);
3249 /* Remove extension */
3250 sep
= strrchr(buf
, '.');
3257 /* returns the playlist filename */
3258 char *playlist_get_name(const struct playlist_info
* playlist
, char *buf
,
3262 playlist
= ¤t_playlist
;
3264 strncpy(buf
, playlist
->filename
, buf_size
);
3272 /* Fills info structure with information about track at specified index.
3273 Returns 0 on success and -1 on failure */
3274 int playlist_get_track_info(struct playlist_info
* playlist
, int index
,
3275 struct playlist_track_info
* info
)
3281 playlist
= ¤t_playlist
;
3283 if (index
< 0 || index
>= playlist
->amount
)
3286 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3287 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3289 if (get_filename(playlist
, index
, seek
, control_file
, info
->filename
,
3290 sizeof(info
->filename
)) < 0)
3297 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
3298 info
->attr
|= PLAYLIST_ATTR_QUEUED
;
3300 info
->attr
|= PLAYLIST_ATTR_INSERTED
;
3304 if (playlist
->indices
[index
] & PLAYLIST_SKIPPED
)
3305 info
->attr
|= PLAYLIST_ATTR_SKIPPED
;
3307 info
->index
= index
;
3308 info
->display_index
= rotate_index(playlist
, index
) + 1;
3313 /* save the current dynamic playlist to specified file */
3314 int playlist_save(struct playlist_info
* playlist
, char *filename
)
3319 char path
[MAX_PATH
+1];
3320 char tmp_buf
[MAX_PATH
+1];
3322 bool overwrite_current
= false;
3323 int* index_buf
= NULL
;
3326 playlist
= ¤t_playlist
;
3328 if (playlist
->amount
<= 0)
3331 /* use current working directory as base for pathname */
3332 if (format_track_path(path
, filename
, sizeof(tmp_buf
),
3333 strlen(filename
)+1, getcwd(NULL
, -1)) < 0)
3336 if (!strncmp(playlist
->filename
, path
, strlen(path
)))
3338 /* Attempting to overwrite current playlist file.*/
3340 if (playlist
->buffer_size
< (int)(playlist
->amount
* sizeof(int)))
3342 /* not enough buffer space to store updated indices */
3343 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3347 /* in_ram buffer is unused for m3u files so we'll use for storing
3349 index_buf
= (int*)playlist
->buffer
;
3351 /* use temporary pathname */
3352 snprintf(path
, sizeof(path
), "%s_temp", playlist
->filename
);
3353 overwrite_current
= true;
3358 fd
= open_utf8(path
, O_CREAT
|O_WRONLY
|O_TRUNC
);
3362 /* some applications require a BOM to read the file properly */
3363 fd
= open(path
, O_CREAT
|O_WRONLY
|O_TRUNC
);
3367 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3371 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
), false);
3375 index
= playlist
->first_index
;
3376 for (i
=0; i
<playlist
->amount
; i
++)
3383 if (action_userabort(TIMEOUT_NOBLOCK
))
3389 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3390 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3391 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3393 /* Don't save queued files */
3396 if (get_filename(playlist
, index
, seek
, control_file
, tmp_buf
,
3403 if (overwrite_current
)
3404 index_buf
[count
] = lseek(fd
, 0, SEEK_CUR
);
3406 if (fdprintf(fd
, "%s\n", tmp_buf
) < 0)
3408 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3415 if ((count
% PLAYLIST_DISPLAY_COUNT
) == 0)
3416 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
),
3422 index
= (index
+1)%playlist
->amount
;
3425 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
), true);
3429 if (overwrite_current
&& result
>= 0)
3433 mutex_lock(&playlist
->control_mutex
);
3435 /* Replace the current playlist with the new one and update indices */
3436 close(playlist
->fd
);
3437 if (remove(playlist
->filename
) >= 0)
3439 if (rename(path
, playlist
->filename
) >= 0)
3441 playlist
->fd
= open_utf8(playlist
->filename
, O_RDONLY
);
3442 if (playlist
->fd
>= 0)
3444 index
= playlist
->first_index
;
3445 for (i
=0, count
=0; i
<playlist
->amount
; i
++)
3447 if (!(playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
))
3449 playlist
->indices
[index
] = index_buf
[count
];
3452 index
= (index
+1)%playlist
->amount
;
3455 /* we need to recreate control because inserted tracks are
3456 now part of the playlist and shuffle has been
3458 result
= recreate_control(playlist
);
3463 mutex_unlock(&playlist
->control_mutex
);
3473 * Search specified directory for tracks and notify via callback. May be
3474 * called recursively.
3476 int playlist_directory_tracksearch(const char* dirname
, bool recurse
,
3477 int (*callback
)(char*, void*),
3480 char buf
[MAX_PATH
+1];
3484 struct entry
*files
;
3485 struct tree_context
* tc
= tree_get_context();
3486 int old_dirfilter
= *(tc
->dirfilter
);
3491 /* use the tree browser dircache to load files */
3492 *(tc
->dirfilter
) = SHOW_ALL
;
3494 if (ft_load(tc
, dirname
) < 0)
3496 splash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
3497 *(tc
->dirfilter
) = old_dirfilter
;
3501 files
= (struct entry
*) tc
->dircache
;
3502 num_files
= tc
->filesindir
;
3504 /* we've overwritten the dircache so tree browser will need to be
3508 for (i
=0; i
<num_files
; i
++)
3511 if (action_userabort(TIMEOUT_NOBLOCK
))
3517 if (files
[i
].attr
& ATTR_DIRECTORY
)
3521 /* recursively add directories */
3522 snprintf(buf
, sizeof(buf
), "%s/%s", dirname
, files
[i
].name
);
3523 result
= playlist_directory_tracksearch(buf
, recurse
,
3528 /* we now need to reload our current directory */
3529 if(ft_load(tc
, dirname
) < 0)
3535 files
= (struct entry
*) tc
->dircache
;
3536 num_files
= tc
->filesindir
;
3546 else if ((files
[i
].attr
& FILE_ATTR_MASK
) == FILE_ATTR_AUDIO
)
3548 snprintf(buf
, sizeof(buf
), "%s/%s", dirname
, files
[i
].name
);
3550 if (callback(buf
, context
) != 0)
3556 /* let the other threads work */
3561 /* restore dirfilter */
3562 *(tc
->dirfilter
) = old_dirfilter
;