1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2002 by wavey@wavey.org
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
23 Dynamic playlist design (based on design originally proposed by ricII)
25 There are two files associated with a dynamic playlist:
26 1. Playlist file : This file contains the initial songs in the playlist.
27 The file is created by the user and stored on the hard
28 drive. NOTE: If we are playing the contents of a
29 directory, there will be no playlist file.
30 2. Control file : This file is automatically created when a playlist is
31 started and contains all the commands done to it.
33 The first non-comment line in a control file must begin with
34 "P:VERSION:DIR:FILE" where VERSION is the playlist control file version,
35 DIR is the directory where the playlist is located and FILE is the
36 playlist filename. For dirplay, FILE will be empty. An empty playlist
37 will have both entries as null.
39 Control file commands:
40 a. Add track (A:<position>:<last position>:<path to track>)
41 - Insert a track at the specified position in the current
42 playlist. Last position is used to specify where last insertion
44 b. Queue track (Q:<position>:<last position>:<path to track>)
45 - Queue a track at the specified position in the current
46 playlist. Queued tracks differ from added tracks in that they
47 are deleted from the playlist as soon as they are played and
48 they are not saved to disk as part of the playlist.
49 c. Delete track (D:<position>)
50 - Delete track from specified position in the current playlist.
51 d. Shuffle playlist (S:<seed>:<index>)
52 - Shuffle entire playlist with specified seed. The index
53 identifies the first index in the newly shuffled playlist
54 (needed for repeat mode).
55 e. Unshuffle playlist (U:<index>)
56 - Unshuffle entire playlist. The index identifies the first index
57 in the newly unshuffled playlist.
58 f. Reset last insert position (R)
59 - Needed so that insertions work properly after resume
62 The only resume info that needs to be saved is the current index in the
63 playlist and the position in the track. When resuming, all the commands
64 in the control file will be reapplied so that the playlist indices are
65 exactly the same as before shutdown. To avoid unnecessary disk
66 accesses, the shuffle mode settings are also saved in settings and only
67 flushed to disk when required.
73 #include "string-extra.h"
75 #include "ata_idle_notify.h"
85 #include "applimits.h"
89 #include "filefuncs.h"
95 #include "filetypes.h"
96 #ifdef HAVE_LCD_BITMAP
104 #include "rbunicode.h"
105 #include "root_menu.h"
107 #define PLAYLIST_CONTROL_FILE_VERSION 2
110 Each playlist index has a flag associated with it which identifies what
111 type of track it is. These flags are stored in the 4 high order bits of
114 NOTE: This limits the playlist file size to a max of 256M.
118 01 = Track was prepended into playlist
119 10 = Track was inserted into playlist
120 11 = Track was appended into playlist
125 0 = Track entry is valid
126 1 = Track does not exist on disk and should be skipped
128 #define PLAYLIST_SEEK_MASK 0x0FFFFFFF
129 #define PLAYLIST_INSERT_TYPE_MASK 0xC0000000
130 #define PLAYLIST_QUEUE_MASK 0x20000000
132 #define PLAYLIST_INSERT_TYPE_PREPEND 0x40000000
133 #define PLAYLIST_INSERT_TYPE_INSERT 0x80000000
134 #define PLAYLIST_INSERT_TYPE_APPEND 0xC0000000
136 #define PLAYLIST_QUEUED 0x20000000
137 #define PLAYLIST_SKIPPED 0x10000000
139 struct directory_search_context
{
140 struct playlist_info
* playlist
;
146 static struct playlist_info current_playlist
;
148 static void empty_playlist(struct playlist_info
* playlist
, bool resume
);
149 static void new_playlist(struct playlist_info
* playlist
, const char *dir
,
151 static void create_control(struct playlist_info
* playlist
);
152 static int check_control(struct playlist_info
* playlist
);
153 static int recreate_control(struct playlist_info
* playlist
);
154 static void update_playlist_filename(struct playlist_info
* playlist
,
155 const char *dir
, const char *file
);
156 static int add_indices_to_playlist(struct playlist_info
* playlist
,
157 char* buffer
, size_t buflen
);
158 static int add_track_to_playlist(struct playlist_info
* playlist
,
159 const char *filename
, int position
,
160 bool queue
, int seek_pos
);
161 static int directory_search_callback(char* filename
, void* context
);
162 static int remove_track_from_playlist(struct playlist_info
* playlist
,
163 int position
, bool write
);
164 static int randomise_playlist(struct playlist_info
* playlist
,
165 unsigned int seed
, bool start_current
,
167 static int sort_playlist(struct playlist_info
* playlist
, bool start_current
,
169 static int get_next_index(const struct playlist_info
* playlist
, int steps
,
171 static void find_and_set_playlist_index(struct playlist_info
* playlist
,
173 static int compare(const void* p1
, const void* p2
);
174 static int get_filename(struct playlist_info
* playlist
, int index
, int seek
,
175 bool control_file
, char *buf
, int buf_length
);
176 static int get_next_directory(char *dir
);
177 static int get_next_dir(char *dir
, bool is_forward
, bool recursion
);
178 static int get_previous_directory(char *dir
);
179 static int check_subdir_for_music(char *dir
, const char *subdir
, bool recurse
);
180 static int format_track_path(char *dest
, char *src
, int buf_length
, int max
,
182 static void display_playlist_count(int count
, const unsigned char *fmt
,
184 static void display_buffer_full(void);
185 static int flush_cached_control(struct playlist_info
* playlist
);
186 static int update_control(struct playlist_info
* playlist
,
187 enum playlist_command command
, int i1
, int i2
,
188 const char* s1
, const char* s2
, void* data
);
189 static void sync_control(struct playlist_info
* playlist
, bool force
);
190 static int rotate_index(const struct playlist_info
* playlist
, int index
);
193 #define PLAYLIST_LOAD_POINTERS 1
195 static struct event_queue playlist_queue
;
196 static long playlist_stack
[(DEFAULT_STACK_SIZE
+ 0x800)/sizeof(long)];
197 static const char playlist_thread_name
[] = "playlist cachectrl";
200 /* Check if the filename suggests M3U or M3U8 format. */
201 static bool is_m3u8(const char* filename
)
203 int len
= strlen(filename
);
205 /* Default to M3U8 unless explicitly told otherwise. */
206 return !(len
> 4 && strcasecmp(&filename
[len
- 4], ".m3u") == 0);
210 /* Convert a filename in an M3U playlist to UTF-8.
212 * buf - the filename to convert; can contain more than one line from the
214 * buf_len - amount of buf that is used.
215 * buf_max - total size of buf.
216 * temp - temporary conversion buffer, at least buf_max bytes.
218 * Returns the length of the converted filename.
220 static int convert_m3u(char* buf
, int buf_len
, int buf_max
, char* temp
)
226 while ((buf
[i
] != '\n') && (buf
[i
] != '\r') && (i
< buf_len
))
231 /* Work back killing white space. */
232 while ((i
> 0) && isspace(buf
[i
- 1]))
240 /* Convert char by char, so as to not overflow temp (iso_decode should
241 * preferably handle this). No more than 4 bytes should be generated for
244 for (i
= 0; i
< buf_len
&& dest
< (temp
+ buf_max
- 4); i
++)
246 dest
= iso_decode(&buf
[i
], dest
, -1, 1);
255 * remove any files and indices associated with the playlist
257 static void empty_playlist(struct playlist_info
* playlist
, bool resume
)
259 playlist
->filename
[0] = '\0';
260 playlist
->utf8
= true;
262 if(playlist
->fd
>= 0)
263 /* If there is an already open playlist, close it. */
267 if(playlist
->control_fd
>= 0)
268 close(playlist
->control_fd
);
269 playlist
->control_fd
= -1;
270 playlist
->control_created
= false;
272 playlist
->in_ram
= false;
274 if (playlist
->buffer
)
275 playlist
->buffer
[0] = 0;
277 playlist
->buffer_end_pos
= 0;
280 playlist
->first_index
= 0;
281 playlist
->amount
= 0;
282 playlist
->last_insert_pos
= -1;
284 playlist
->shuffle_modified
= false;
285 playlist
->deleted
= false;
286 playlist
->num_inserted_tracks
= 0;
287 playlist
->started
= false;
289 playlist
->num_cached
= 0;
290 playlist
->pending_control_sync
= false;
292 if (!resume
&& playlist
->current
)
294 /* start with fresh playlist control file when starting new
296 create_control(playlist
);
301 * Initialize a new playlist for viewing/editing/playing. dir is the
302 * directory where the playlist is located and file is the filename.
304 static void new_playlist(struct playlist_info
* playlist
, const char *dir
,
307 const char *fileused
= file
;
308 const char *dirused
= dir
;
309 empty_playlist(playlist
, false);
315 if (dirused
&& playlist
->current
) /* !current cannot be in_ram */
316 playlist
->in_ram
= true;
318 dirused
= ""; /* empty playlist */
321 update_playlist_filename(playlist
, dirused
, fileused
);
323 if (playlist
->control_fd
>= 0)
325 update_control(playlist
, PLAYLIST_COMMAND_PLAYLIST
,
326 PLAYLIST_CONTROL_FILE_VERSION
, -1, dirused
, fileused
, NULL
);
327 sync_control(playlist
, false);
332 * create control file for playlist
334 static void create_control(struct playlist_info
* playlist
)
336 playlist
->control_fd
= open(playlist
->control_filename
,
337 O_CREAT
|O_RDWR
|O_TRUNC
, 0666);
338 if (playlist
->control_fd
< 0)
340 if (check_rockboxdir())
342 cond_talk_ids_fq(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
);
343 splashf(HZ
*2, (unsigned char *)"%s (%d)",
344 str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
),
345 playlist
->control_fd
);
347 playlist
->control_created
= false;
351 playlist
->control_created
= true;
356 * validate the control file. This may include creating/initializing it if
359 static int check_control(struct playlist_info
* playlist
)
361 if (!playlist
->control_created
)
363 create_control(playlist
);
365 if (playlist
->control_fd
>= 0)
367 char* dir
= playlist
->filename
;
368 char* file
= playlist
->filename
+playlist
->dirlen
;
369 char c
= playlist
->filename
[playlist
->dirlen
-1];
371 playlist
->filename
[playlist
->dirlen
-1] = '\0';
373 update_control(playlist
, PLAYLIST_COMMAND_PLAYLIST
,
374 PLAYLIST_CONTROL_FILE_VERSION
, -1, dir
, file
, NULL
);
375 sync_control(playlist
, false);
376 playlist
->filename
[playlist
->dirlen
-1] = c
;
380 if (playlist
->control_fd
< 0)
387 * recreate the control file based on current playlist entries
389 static int recreate_control(struct playlist_info
* playlist
)
391 char temp_file
[MAX_PATH
+1];
396 if(playlist
->control_fd
>= 0)
398 char* dir
= playlist
->filename
;
399 char* file
= playlist
->filename
+playlist
->dirlen
;
400 char c
= playlist
->filename
[playlist
->dirlen
-1];
402 close(playlist
->control_fd
);
404 snprintf(temp_file
, sizeof(temp_file
), "%s_temp",
405 playlist
->control_filename
);
407 if (rename(playlist
->control_filename
, temp_file
) < 0)
410 temp_fd
= open(temp_file
, O_RDONLY
);
414 playlist
->control_fd
= open(playlist
->control_filename
,
415 O_CREAT
|O_RDWR
|O_TRUNC
, 0666);
416 if (playlist
->control_fd
< 0)
419 playlist
->filename
[playlist
->dirlen
-1] = '\0';
421 /* cannot call update_control() because of mutex */
422 result
= fdprintf(playlist
->control_fd
, "P:%d:%s:%s\n",
423 PLAYLIST_CONTROL_FILE_VERSION
, dir
, file
);
425 playlist
->filename
[playlist
->dirlen
-1] = c
;
435 playlist
->shuffle_modified
= false;
436 playlist
->deleted
= false;
437 playlist
->num_inserted_tracks
= 0;
439 for (i
=0; i
<playlist
->amount
; i
++)
441 if (playlist
->indices
[i
] & PLAYLIST_INSERT_TYPE_MASK
)
443 bool queue
= playlist
->indices
[i
] & PLAYLIST_QUEUE_MASK
;
444 char inserted_file
[MAX_PATH
+1];
446 lseek(temp_fd
, playlist
->indices
[i
] & PLAYLIST_SEEK_MASK
,
448 read_line(temp_fd
, inserted_file
, sizeof(inserted_file
));
450 result
= fdprintf(playlist
->control_fd
, "%c:%d:%d:",
451 queue
?'Q':'A', i
, playlist
->last_insert_pos
);
454 /* save the position in file where name is written */
455 int seek_pos
= lseek(playlist
->control_fd
, 0, SEEK_CUR
);
457 result
= fdprintf(playlist
->control_fd
, "%s\n",
460 playlist
->indices
[i
] =
461 (playlist
->indices
[i
] & ~PLAYLIST_SEEK_MASK
) | seek_pos
;
467 playlist
->num_inserted_tracks
++;
473 fsync(playlist
->control_fd
);
482 * store directory and name of playlist file
484 static void update_playlist_filename(struct playlist_info
* playlist
,
485 const char *dir
, const char *file
)
488 int dirlen
= strlen(dir
);
490 playlist
->utf8
= is_m3u8(file
);
492 /* If the dir does not end in trailing slash, we use a separator.
493 Otherwise we don't. */
494 if('/' != dir
[dirlen
-1])
500 playlist
->dirlen
= dirlen
;
502 snprintf(playlist
->filename
, sizeof(playlist
->filename
),
503 "%s%s%s", dir
, sep
, file
);
507 * calculate track offsets within a playlist file
509 static int add_indices_to_playlist(struct playlist_info
* playlist
,
510 char* buffer
, size_t buflen
)
514 unsigned int count
= 0;
519 if(-1 == playlist
->fd
)
520 playlist
->fd
= open_utf8(playlist
->filename
, O_RDONLY
);
522 return -1; /* failure */
523 if((i
= lseek(playlist
->fd
, 0, SEEK_CUR
)) > 0)
524 playlist
->utf8
= true; /* Override any earlier indication. */
526 splash(0, ID2P(LANG_WAIT
));
530 /* use mp3 buffer for maximum load speed */
532 #if CONFIG_CODEC != SWCODEC
533 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
534 buflen
= (audiobufend
- audiobuf
);
535 buffer
= (char *)audiobuf
;
537 buffer
= (char *)audio_get_buffer(false, &buflen
);
545 nread
= read(playlist
->fd
, buffer
, buflen
);
546 /* Terminate on EOF */
550 p
= (unsigned char *)buffer
;
552 for(count
=0; count
< nread
; count
++,p
++) {
554 /* Are we on a new line? */
555 if((*p
== '\n') || (*p
== '\r'))
565 if ( playlist
->amount
>= playlist
->max_playlist_size
) {
566 display_buffer_full();
571 /* Store a new entry */
572 playlist
->indices
[ playlist
->amount
] = i
+count
;
574 if (playlist
->filenames
)
575 playlist
->filenames
[ playlist
->amount
] = NULL
;
587 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
594 * Utility function to create a new playlist, fill it with the next or
595 * previous directory, shuffle it if needed, and start playback.
596 * If play_last is true and direction zero or negative, start playing
597 * the last file in the directory, otherwise start playing the first.
599 static int create_and_play_dir(int direction
, bool play_last
)
601 char dir
[MAX_PATH
+ 1];
606 res
= get_next_directory(dir
);
608 res
= get_previous_directory(dir
);
612 if (playlist_create(dir
, NULL
) != -1)
614 ft_build_playlist(tree_get_context(), 0);
616 if (global_settings
.playlist_shuffle
)
617 playlist_shuffle(current_tick
, -1);
619 if (play_last
&& direction
<= 0)
620 index
= current_playlist
.amount
- 1;
624 #if (CONFIG_CODEC != SWCODEC)
625 playlist_start(index
, 0);
629 /* we've overwritten the dircache when getting the next/previous dir,
630 so the tree browser context will need to be reloaded */
638 * Removes all tracks, from the playlist, leaving the presently playing
641 int playlist_remove_all_tracks(struct playlist_info
*playlist
)
645 if (playlist
== NULL
)
646 playlist
= ¤t_playlist
;
648 while (playlist
->index
> 0)
649 if ((result
= remove_track_from_playlist(playlist
, 0, true)) < 0)
652 while (playlist
->amount
> 1)
653 if ((result
= remove_track_from_playlist(playlist
, 1, true)) < 0)
656 if (playlist
->amount
== 1) {
657 playlist
->indices
[0] |= PLAYLIST_QUEUED
;
665 * Add track to playlist at specified position. There are seven special
666 * positions that can be specified:
667 * PLAYLIST_PREPEND - Add track at beginning of playlist
668 * PLAYLIST_INSERT - Add track after current song. NOTE: If
669 * there are already inserted tracks then track
670 * is added to the end of the insertion list
671 * PLAYLIST_INSERT_FIRST - Add track immediately after current song, no
672 * matter what other tracks have been inserted
673 * PLAYLIST_INSERT_LAST - Add track to end of playlist
674 * PLAYLIST_INSERT_SHUFFLED - Add track at some random point between the
675 * current playing track and end of playlist
676 * PLAYLIST_INSERT_LAST_SHUFFLED - Add tracks in random order to the end of
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_INSERT_LAST_SHUFFLED
:
758 position
= insert_position
= playlist
->last_shuffled_start
+
759 rand() % (playlist
->amount
- playlist
->last_shuffled_start
+ 1);
762 case PLAYLIST_REPLACE
:
763 if (playlist_remove_all_tracks(playlist
) < 0)
766 playlist
->last_insert_pos
= position
= insert_position
= playlist
->index
+ 1;
771 flags
|= PLAYLIST_QUEUED
;
773 /* shift indices so that track can be added */
774 for (i
=playlist
->amount
; i
>insert_position
; i
--)
776 playlist
->indices
[i
] = playlist
->indices
[i
-1];
778 if (playlist
->filenames
)
779 playlist
->filenames
[i
] = playlist
->filenames
[i
-1];
783 /* update stored indices if needed */
785 if (orig_position
< 0)
787 if (playlist
->amount
> 0 && insert_position
<= playlist
->index
&&
791 if (playlist
->amount
> 0 && insert_position
<= playlist
->first_index
&&
792 orig_position
!= PLAYLIST_PREPEND
&& playlist
->started
)
793 playlist
->first_index
++;
796 if (insert_position
< playlist
->last_insert_pos
||
797 (insert_position
== playlist
->last_insert_pos
&& position
< 0))
798 playlist
->last_insert_pos
++;
800 if (seek_pos
< 0 && playlist
->control_fd
>= 0)
802 int result
= update_control(playlist
,
803 (queue
?PLAYLIST_COMMAND_QUEUE
:PLAYLIST_COMMAND_ADD
), position
,
804 playlist
->last_insert_pos
, filename
, NULL
, &seek_pos
);
810 playlist
->indices
[insert_position
] = flags
| seek_pos
;
813 if (playlist
->filenames
)
814 playlist
->filenames
[insert_position
] = NULL
;
818 playlist
->num_inserted_tracks
++;
820 return insert_position
;
824 * Callback for playlist_directory_tracksearch to insert track into
827 static int directory_search_callback(char* filename
, void* context
)
829 struct directory_search_context
* c
=
830 (struct directory_search_context
*) context
;
833 insert_pos
= add_track_to_playlist(c
->playlist
, filename
, c
->position
,
841 /* Make sure tracks are inserted in correct order if user requests
843 if (c
->position
== PLAYLIST_INSERT_FIRST
|| c
->position
>= 0)
844 c
->position
= insert_pos
+ 1;
846 if (((c
->count
)%PLAYLIST_DISPLAY_COUNT
) == 0)
848 unsigned char* count_str
;
851 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
853 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
855 display_playlist_count(c
->count
, count_str
, false);
857 if ((c
->count
) == PLAYLIST_DISPLAY_COUNT
&&
858 (audio_status() & AUDIO_STATUS_PLAY
) &&
859 c
->playlist
->started
)
860 audio_flush_and_reload_tracks();
867 * remove track at specified position
869 static int remove_track_from_playlist(struct playlist_info
* playlist
,
870 int position
, bool write
)
875 if (playlist
->amount
<= 0)
878 inserted
= playlist
->indices
[position
] & PLAYLIST_INSERT_TYPE_MASK
;
880 /* shift indices now that track has been removed */
881 for (i
=position
; i
<playlist
->amount
; i
++)
883 playlist
->indices
[i
] = playlist
->indices
[i
+1];
885 if (playlist
->filenames
)
886 playlist
->filenames
[i
] = playlist
->filenames
[i
+1];
893 playlist
->num_inserted_tracks
--;
895 playlist
->deleted
= true;
897 /* update stored indices if needed */
898 if (position
< playlist
->index
)
901 if (position
< playlist
->first_index
)
903 playlist
->first_index
--;
906 if (position
<= playlist
->last_insert_pos
)
907 playlist
->last_insert_pos
--;
909 if (write
&& playlist
->control_fd
>= 0)
911 int result
= update_control(playlist
, PLAYLIST_COMMAND_DELETE
,
912 position
, -1, NULL
, NULL
, NULL
);
917 sync_control(playlist
, false);
924 * randomly rearrange the array of indices for the playlist. If start_current
925 * is true then update the index to the new index of the current playing track
927 static int randomise_playlist(struct playlist_info
* playlist
,
928 unsigned int seed
, bool start_current
,
934 unsigned int current
= playlist
->indices
[playlist
->index
];
936 /* seed 0 is used to identify sorted playlist for resume purposes */
940 /* seed with the given seed */
943 /* randomise entire indices list */
944 for(count
= playlist
->amount
- 1; count
>= 0; count
--)
946 /* the rand is from 0 to RAND_MAX, so adjust to our value range */
947 candidate
= rand() % (count
+ 1);
949 /* now swap the values at the 'count' and 'candidate' positions */
950 store
= playlist
->indices
[candidate
];
951 playlist
->indices
[candidate
] = playlist
->indices
[count
];
952 playlist
->indices
[count
] = store
;
954 if (playlist
->filenames
)
956 store
= (long)playlist
->filenames
[candidate
];
957 playlist
->filenames
[candidate
] = playlist
->filenames
[count
];
958 playlist
->filenames
[count
] = (struct dircache_entry
*)store
;
964 find_and_set_playlist_index(playlist
, current
);
966 /* indices have been moved so last insert position is no longer valid */
967 playlist
->last_insert_pos
= -1;
969 playlist
->seed
= seed
;
970 if (playlist
->num_inserted_tracks
> 0 || playlist
->deleted
)
971 playlist
->shuffle_modified
= true;
975 update_control(playlist
, PLAYLIST_COMMAND_SHUFFLE
, seed
,
976 playlist
->first_index
, NULL
, NULL
, NULL
);
983 * Sort the array of indices for the playlist. If start_current is true then
984 * set the index to the new index of the current song.
985 * Also while going to unshuffled mode set the first_index to 0.
987 static int sort_playlist(struct playlist_info
* playlist
, bool start_current
,
990 unsigned int current
= playlist
->indices
[playlist
->index
];
992 if (playlist
->amount
> 0)
993 qsort(playlist
->indices
, playlist
->amount
,
994 sizeof(playlist
->indices
[0]), compare
);
997 /** We need to re-check the song names from disk because qsort can't
998 * sort two arrays at once :/
999 * FIXME: Please implement a better way to do this. */
1000 memset(playlist
->filenames
, 0, playlist
->max_playlist_size
* sizeof(int));
1001 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
1005 find_and_set_playlist_index(playlist
, current
);
1007 /* indices have been moved so last insert position is no longer valid */
1008 playlist
->last_insert_pos
= -1;
1010 if (!playlist
->num_inserted_tracks
&& !playlist
->deleted
)
1011 playlist
->shuffle_modified
= false;
1012 if (write
&& playlist
->control_fd
>= 0)
1014 playlist
->first_index
= 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;
1320 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
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 char folder_advance_list
[MAX_PATH
];
1443 get_user_file_path(ROCKBOX_DIR
, FORCE_BUFFER_COPY
,
1444 folder_advance_list
, sizeof(folder_advance_list
));
1445 strlcat(folder_advance_list
, "/folder_advance_list.dat",
1446 sizeof(folder_advance_list
));
1447 int fd
= open(folder_advance_list
, O_RDONLY
);
1450 char buffer
[MAX_PATH
];
1451 int folder_count
= 0;
1452 srand(current_tick
);
1453 *(tc
->dirfilter
) = SHOW_MUSIC
;
1454 tc
->sort_dir
= global_settings
.sort_dir
;
1455 read(fd
,&folder_count
,sizeof(int));
1460 i
= rand()%folder_count
;
1461 lseek(fd
,sizeof(int) + (MAX_PATH
*i
),SEEK_SET
);
1462 read(fd
,buffer
,MAX_PATH
);
1463 if (check_subdir_for_music(buffer
, "", false) ==0)
1469 *(tc
->dirfilter
) = saved_dirfilter
;
1470 tc
->sort_dir
= global_settings
.sort_dir
;
1476 /* not random folder advance (or random folder advance unavailable) */
1479 /* start with root */
1484 /* start with current directory */
1485 strlcpy(dir
, playlist
->filename
, playlist
->dirlen
);
1488 /* use the tree browser dircache to load files */
1489 *(tc
->dirfilter
) = SHOW_ALL
;
1491 /* set up sorting/direction */
1492 tc
->sort_dir
= global_settings
.sort_dir
;
1495 static const char sortpairs
[] =
1497 [SORT_ALPHA
] = SORT_ALPHA_REVERSED
,
1498 [SORT_DATE
] = SORT_DATE_REVERSED
,
1499 [SORT_TYPE
] = SORT_TYPE_REVERSED
,
1500 [SORT_ALPHA_REVERSED
] = SORT_ALPHA
,
1501 [SORT_DATE_REVERSED
] = SORT_DATE
,
1502 [SORT_TYPE_REVERSED
] = SORT_TYPE
,
1505 if ((unsigned)tc
->sort_dir
< sizeof(sortpairs
))
1506 tc
->sort_dir
= sortpairs
[tc
->sort_dir
];
1511 struct entry
*files
;
1515 if (ft_load(tc
, (dir
[0]=='\0')?"/":dir
) < 0)
1522 files
= (struct entry
*) tc
->dircache
;
1523 num_files
= tc
->filesindir
;
1525 for (i
=0; i
<num_files
; i
++)
1528 if (action_userabort(TIMEOUT_NOBLOCK
))
1535 if (files
[i
].attr
& ATTR_DIRECTORY
)
1539 result
= check_subdir_for_music(dir
, files
[i
].name
, true);
1546 else if (!strcmp(start_dir
, files
[i
].name
))
1553 /* move down to parent directory. current directory name is
1554 stored as the starting point for the search in parent */
1555 start_dir
= strrchr(dir
, '/');
1566 /* restore dirfilter */
1567 *(tc
->dirfilter
) = saved_dirfilter
;
1568 tc
->sort_dir
= global_settings
.sort_dir
;
1570 /* special case if nothing found: try start searching again from root */
1571 if (result
== -1 && !recursion
){
1572 result
= get_next_dir(dir
, is_forward
, true);
1579 * Checks if there are any music files in the dir or any of its
1580 * subdirectories. May be called recursively.
1582 static int check_subdir_for_music(char *dir
, const char *subdir
, bool recurse
)
1585 int dirlen
= strlen(dir
);
1588 struct entry
*files
;
1589 bool has_music
= false;
1590 bool has_subdir
= false;
1591 struct tree_context
* tc
= tree_get_context();
1593 snprintf(dir
+dirlen
, MAX_PATH
-dirlen
, "/%s", subdir
);
1595 if (ft_load(tc
, dir
) < 0)
1600 files
= (struct entry
*) tc
->dircache
;
1601 num_files
= tc
->filesindir
;
1603 for (i
=0; i
<num_files
; i
++)
1605 if (files
[i
].attr
& ATTR_DIRECTORY
)
1607 else if ((files
[i
].attr
& FILE_ATTR_MASK
) == FILE_ATTR_AUDIO
)
1617 if (has_subdir
&& recurse
)
1619 for (i
=0; i
<num_files
; i
++)
1621 if (action_userabort(TIMEOUT_NOBLOCK
))
1627 if (files
[i
].attr
& ATTR_DIRECTORY
)
1629 result
= check_subdir_for_music(dir
, files
[i
].name
, true);
1647 /* we now need to reload our current directory */
1648 if(ft_load(tc
, dir
) < 0)
1649 splash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
1655 * Returns absolute path of track
1657 static int format_track_path(char *dest
, char *src
, int buf_length
, int max
,
1664 /* Zero-terminate the file name */
1665 while((src
[i
] != '\n') &&
1670 /* Now work back killing white space */
1671 while((src
[i
-1] == ' ') ||
1677 /* replace backslashes with forward slashes */
1678 for ( j
=0; j
<i
; j
++ )
1679 if ( src
[j
] == '\\' )
1684 strlcpy(dest
, src
, buf_length
);
1688 /* handle dos style drive letter */
1690 strlcpy(dest
, &src
[2], buf_length
);
1691 else if (!strncmp(src
, "../", 3))
1693 /* handle relative paths */
1695 while(!strncmp(&src
[i
], "../", 3))
1697 for (j
=0; j
<i
/3; j
++) {
1698 temp_ptr
= strrchr(dir
, '/');
1704 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[i
]);
1706 else if ( '.' == src
[0] && '/' == src
[1] ) {
1707 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[2]);
1710 snprintf(dest
, buf_length
, "%s/%s", dir
, src
);
1718 * Display splash message showing progress of playlist/directory insertion or
1721 static void display_playlist_count(int count
, const unsigned char *fmt
,
1724 static long talked_tick
= 0;
1725 long id
= P2ID(fmt
);
1726 if(global_settings
.talk_menu
&& id
>=0)
1728 if(final
|| (count
&& (talked_tick
== 0
1729 || TIME_AFTER(current_tick
, talked_tick
+5*HZ
))))
1731 talked_tick
= current_tick
;
1732 talk_number(count
, false);
1738 splashf(0, fmt
, count
, str(LANG_OFF_ABORT
));
1742 * Display buffer full message
1744 static void display_buffer_full(void)
1746 splash(HZ
*2, ID2P(LANG_PLAYLIST_BUFFER_FULL
));
1750 * Flush any cached control commands to disk. Called when playlist is being
1751 * modified. Returns 0 on success and -1 on failure.
1753 static int flush_cached_control(struct playlist_info
* playlist
)
1758 if (!playlist
->num_cached
)
1761 lseek(playlist
->control_fd
, 0, SEEK_END
);
1763 for (i
=0; i
<playlist
->num_cached
; i
++)
1765 struct playlist_control_cache
* cache
=
1766 &(playlist
->control_cache
[i
]);
1768 switch (cache
->command
)
1770 case PLAYLIST_COMMAND_PLAYLIST
:
1771 result
= fdprintf(playlist
->control_fd
, "P:%d:%s:%s\n",
1772 cache
->i1
, cache
->s1
, cache
->s2
);
1774 case PLAYLIST_COMMAND_ADD
:
1775 case PLAYLIST_COMMAND_QUEUE
:
1776 result
= fdprintf(playlist
->control_fd
, "%c:%d:%d:",
1777 (cache
->command
== PLAYLIST_COMMAND_ADD
)?'A':'Q',
1778 cache
->i1
, cache
->i2
);
1781 /* save the position in file where name is written */
1782 int* seek_pos
= (int *)cache
->data
;
1783 *seek_pos
= lseek(playlist
->control_fd
, 0, SEEK_CUR
);
1784 result
= fdprintf(playlist
->control_fd
, "%s\n",
1788 case PLAYLIST_COMMAND_DELETE
:
1789 result
= fdprintf(playlist
->control_fd
, "D:%d\n", cache
->i1
);
1791 case PLAYLIST_COMMAND_SHUFFLE
:
1792 result
= fdprintf(playlist
->control_fd
, "S:%d:%d\n",
1793 cache
->i1
, cache
->i2
);
1795 case PLAYLIST_COMMAND_UNSHUFFLE
:
1796 result
= fdprintf(playlist
->control_fd
, "U:%d\n", cache
->i1
);
1798 case PLAYLIST_COMMAND_RESET
:
1799 result
= fdprintf(playlist
->control_fd
, "R\n");
1811 playlist
->num_cached
= 0;
1812 playlist
->pending_control_sync
= true;
1819 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_UPDATE_ERROR
));
1826 * Update control data with new command. Depending on the command, it may be
1827 * cached or flushed to disk.
1829 static int update_control(struct playlist_info
* playlist
,
1830 enum playlist_command command
, int i1
, int i2
,
1831 const char* s1
, const char* s2
, void* data
)
1834 struct playlist_control_cache
* cache
;
1837 mutex_lock(&playlist
->control_mutex
);
1839 cache
= &(playlist
->control_cache
[playlist
->num_cached
++]);
1841 cache
->command
= command
;
1850 case PLAYLIST_COMMAND_PLAYLIST
:
1851 case PLAYLIST_COMMAND_ADD
:
1852 case PLAYLIST_COMMAND_QUEUE
:
1853 #ifndef HAVE_DIRCACHE
1854 case PLAYLIST_COMMAND_DELETE
:
1855 case PLAYLIST_COMMAND_RESET
:
1859 case PLAYLIST_COMMAND_SHUFFLE
:
1860 case PLAYLIST_COMMAND_UNSHUFFLE
:
1862 /* only flush when needed */
1866 if (flush
|| playlist
->num_cached
== PLAYLIST_MAX_CACHE
)
1867 result
= flush_cached_control(playlist
);
1869 mutex_unlock(&playlist
->control_mutex
);
1875 * sync control file to disk
1877 static void sync_control(struct playlist_info
* playlist
, bool force
)
1879 #ifdef HAVE_DIRCACHE
1880 if (playlist
->started
&& force
)
1884 if (playlist
->started
)
1887 if (playlist
->pending_control_sync
)
1889 mutex_lock(&playlist
->control_mutex
);
1890 fsync(playlist
->control_fd
);
1891 playlist
->pending_control_sync
= false;
1892 mutex_unlock(&playlist
->control_mutex
);
1898 * Rotate indices such that first_index is index 0
1900 static int rotate_index(const struct playlist_info
* playlist
, int index
)
1902 index
-= playlist
->first_index
;
1904 index
+= playlist
->amount
;
1910 * Initialize playlist entries at startup
1912 void playlist_init(void)
1914 struct playlist_info
* playlist
= ¤t_playlist
;
1916 playlist
->current
= true;
1917 get_user_file_path(PLAYLIST_CONTROL_FILE
, IS_FILE
|NEED_WRITE
|FORCE_BUFFER_COPY
,
1918 playlist
->control_filename
,
1919 sizeof(playlist
->control_filename
));
1921 playlist
->control_fd
= -1;
1922 playlist
->max_playlist_size
= global_settings
.max_files_in_playlist
;
1923 playlist
->indices
= buffer_alloc(
1924 playlist
->max_playlist_size
* sizeof(int));
1925 playlist
->buffer_size
=
1926 AVERAGE_FILENAME_LENGTH
* global_settings
.max_files_in_dir
;
1927 playlist
->buffer
= buffer_alloc(playlist
->buffer_size
);
1928 mutex_init(&playlist
->control_mutex
);
1929 empty_playlist(playlist
, true);
1931 #ifdef HAVE_DIRCACHE
1932 playlist
->filenames
= buffer_alloc(
1933 playlist
->max_playlist_size
* sizeof(int));
1934 memset(playlist
->filenames
, 0,
1935 playlist
->max_playlist_size
* sizeof(int));
1936 create_thread(playlist_thread
, playlist_stack
, sizeof(playlist_stack
),
1937 0, playlist_thread_name
IF_PRIO(, PRIORITY_BACKGROUND
)
1939 queue_init(&playlist_queue
, true);
1944 * Clean playlist at shutdown
1946 void playlist_shutdown(void)
1948 struct playlist_info
* playlist
= ¤t_playlist
;
1950 if (playlist
->control_fd
>= 0)
1952 mutex_lock(&playlist
->control_mutex
);
1954 if (playlist
->num_cached
> 0)
1955 flush_cached_control(playlist
);
1957 close(playlist
->control_fd
);
1959 mutex_unlock(&playlist
->control_mutex
);
1964 * Create new playlist
1966 int playlist_create(const char *dir
, const char *file
)
1968 struct playlist_info
* playlist
= ¤t_playlist
;
1970 new_playlist(playlist
, dir
, file
);
1973 /* load the playlist file */
1974 add_indices_to_playlist(playlist
, NULL
, 0);
1979 #define PLAYLIST_COMMAND_SIZE (MAX_PATH+12)
1982 * Restore the playlist state based on control file commands. Called to
1983 * resume playback after shutdown.
1985 int playlist_resume(void)
1987 struct playlist_info
* playlist
= ¤t_playlist
;
1992 int control_file_size
= 0;
1996 /* use mp3 buffer for maximum load speed */
1997 #if CONFIG_CODEC != SWCODEC
1998 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
1999 buflen
= (audiobufend
- audiobuf
);
2000 buffer
= (char *)audiobuf
;
2002 buffer
= (char *)audio_get_buffer(false, &buflen
);
2005 empty_playlist(playlist
, true);
2007 splash(0, ID2P(LANG_WAIT
));
2008 playlist
->control_fd
= open(playlist
->control_filename
, O_RDWR
);
2009 if (playlist
->control_fd
< 0)
2011 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2014 playlist
->control_created
= true;
2016 control_file_size
= filesize(playlist
->control_fd
);
2017 if (control_file_size
<= 0)
2019 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2023 /* read a small amount first to get the header */
2024 nread
= read(playlist
->control_fd
, buffer
,
2025 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
2028 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2032 playlist
->started
= true;
2038 enum playlist_command current_command
= PLAYLIST_COMMAND_COMMENT
;
2039 int last_newline
= 0;
2041 bool newline
= true;
2042 bool exit_loop
= false;
2047 unsigned long last_tick
= current_tick
;
2048 bool useraborted
= false;
2050 for(count
=0; count
<nread
&& !exit_loop
&& !useraborted
; count
++,p
++)
2052 /* So a splash while we are loading. */
2053 if (TIME_AFTER(current_tick
, last_tick
+ HZ
/4))
2055 splashf(0, str(LANG_LOADING_PERCENT
),
2056 (total_read
+count
)*100/control_file_size
,
2057 str(LANG_OFF_ABORT
));
2058 if (action_userabort(TIMEOUT_NOBLOCK
))
2063 last_tick
= current_tick
;
2066 /* Are we on a new line? */
2067 if((*p
== '\n') || (*p
== '\r'))
2071 /* save last_newline in case we need to load more data */
2072 last_newline
= count
;
2074 switch (current_command
)
2076 case PLAYLIST_COMMAND_PLAYLIST
:
2078 /* str1=version str2=dir str3=file */
2094 version
= atoi(str1
);
2096 if (version
!= PLAYLIST_CONTROL_FILE_VERSION
)
2099 update_playlist_filename(playlist
, str2
, str3
);
2101 if (str3
[0] != '\0')
2103 /* NOTE: add_indices_to_playlist() overwrites the
2104 audiobuf so we need to reload control file
2106 add_indices_to_playlist(playlist
, NULL
, 0);
2108 else if (str2
[0] != '\0')
2110 playlist
->in_ram
= true;
2111 resume_directory(str2
);
2114 /* load the rest of the data */
2120 case PLAYLIST_COMMAND_ADD
:
2121 case PLAYLIST_COMMAND_QUEUE
:
2123 /* str1=position str2=last_position str3=file */
2124 int position
, last_position
;
2127 if (!str1
|| !str2
|| !str3
)
2134 position
= atoi(str1
);
2135 last_position
= atoi(str2
);
2137 queue
= (current_command
== PLAYLIST_COMMAND_ADD
)?
2140 /* seek position is based on str3's position in
2142 if (add_track_to_playlist(playlist
, str3
, position
,
2143 queue
, total_read
+(str3
-buffer
)) < 0)
2146 playlist
->last_insert_pos
= last_position
;
2150 case PLAYLIST_COMMAND_DELETE
:
2162 position
= atoi(str1
);
2164 if (remove_track_from_playlist(playlist
, position
,
2170 case PLAYLIST_COMMAND_SHUFFLE
:
2172 /* str1=seed str2=first_index */
2184 /* Always sort list before shuffling */
2185 sort_playlist(playlist
, false, false);
2189 playlist
->first_index
= atoi(str2
);
2191 if (randomise_playlist(playlist
, seed
, false,
2197 case PLAYLIST_COMMAND_UNSHUFFLE
:
2199 /* str1=first_index */
2207 playlist
->first_index
= atoi(str1
);
2209 if (sort_playlist(playlist
, false, false) < 0)
2215 case PLAYLIST_COMMAND_RESET
:
2217 playlist
->last_insert_pos
= -1;
2220 case PLAYLIST_COMMAND_COMMENT
:
2227 /* to ignore any extra newlines */
2228 current_command
= PLAYLIST_COMMAND_COMMENT
;
2234 /* first non-comment line must always specify playlist */
2235 if (first
&& *p
!= 'P' && *p
!= '#')
2245 /* playlist can only be specified once */
2253 current_command
= PLAYLIST_COMMAND_PLAYLIST
;
2256 current_command
= PLAYLIST_COMMAND_ADD
;
2259 current_command
= PLAYLIST_COMMAND_QUEUE
;
2262 current_command
= PLAYLIST_COMMAND_DELETE
;
2265 current_command
= PLAYLIST_COMMAND_SHUFFLE
;
2268 current_command
= PLAYLIST_COMMAND_UNSHUFFLE
;
2271 current_command
= PLAYLIST_COMMAND_RESET
;
2274 current_command
= PLAYLIST_COMMAND_COMMENT
;
2287 else if(current_command
!= PLAYLIST_COMMAND_COMMENT
)
2289 /* all control file strings are separated with a colon.
2290 Replace the colon with 0 to get proper strings that can be
2291 used by commands above */
2297 if ((count
+1) < nread
)
2311 /* allow last string to contain colons */
2322 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID
));
2328 splash(HZ
*2, ID2P(LANG_CANCEL
));
2331 if (!newline
|| (exit_loop
&& count
<nread
))
2333 if ((total_read
+ count
) >= control_file_size
)
2335 /* no newline at end of control file */
2336 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID
));
2340 /* We didn't end on a newline or we exited loop prematurely.
2341 Either way, re-read the remainder. */
2342 count
= last_newline
;
2343 lseek(playlist
->control_fd
, total_read
+count
, SEEK_SET
);
2346 total_read
+= count
;
2349 /* still looking for header */
2350 nread
= read(playlist
->control_fd
, buffer
,
2351 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
2353 nread
= read(playlist
->control_fd
, buffer
, buflen
);
2355 /* Terminate on EOF */
2362 #ifdef HAVE_DIRCACHE
2363 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2370 * Add track to in_ram playlist. Used when playing directories.
2372 int playlist_add(const char *filename
)
2374 struct playlist_info
* playlist
= ¤t_playlist
;
2375 int len
= strlen(filename
);
2377 if((len
+1 > playlist
->buffer_size
- playlist
->buffer_end_pos
) ||
2378 (playlist
->amount
>= playlist
->max_playlist_size
))
2380 display_buffer_full();
2384 playlist
->indices
[playlist
->amount
] = playlist
->buffer_end_pos
;
2385 #ifdef HAVE_DIRCACHE
2386 playlist
->filenames
[playlist
->amount
] = NULL
;
2390 strcpy(&playlist
->buffer
[playlist
->buffer_end_pos
], filename
);
2391 playlist
->buffer_end_pos
+= len
;
2392 playlist
->buffer
[playlist
->buffer_end_pos
++] = '\0';
2397 /* shuffle newly created playlist using random seed. */
2398 int playlist_shuffle(int random_seed
, int start_index
)
2400 struct playlist_info
* playlist
= ¤t_playlist
;
2402 unsigned int seek_pos
= 0;
2403 bool start_current
= false;
2405 if (start_index
>= 0 && global_settings
.play_selected
)
2407 /* store the seek position before the shuffle */
2408 seek_pos
= playlist
->indices
[start_index
];
2409 playlist
->index
= playlist
->first_index
= start_index
;
2410 start_current
= true;
2413 randomise_playlist(playlist
, random_seed
, start_current
, true);
2415 return playlist
->index
;
2418 /* start playing current playlist at specified index/offset */
2419 void playlist_start(int start_index
, int offset
)
2421 struct playlist_info
* playlist
= ¤t_playlist
;
2423 /* Cancel FM radio selection as previous music. For cases where we start
2424 playback without going to the WPS, such as playlist insert.. or
2425 playlist catalog. */
2426 previous_music_is_wps();
2428 playlist
->index
= start_index
;
2430 #if CONFIG_CODEC != SWCODEC
2431 talk_buffer_steal(); /* will use the mp3 buffer */
2434 playlist
->started
= true;
2435 sync_control(playlist
, false);
2439 /* Returns false if 'steps' is out of bounds, else true */
2440 bool playlist_check(int steps
)
2442 struct playlist_info
* playlist
= ¤t_playlist
;
2444 /* always allow folder navigation */
2445 if (global_settings
.next_folder
&& playlist
->in_ram
)
2448 int index
= get_next_index(playlist
, steps
, -1);
2450 if (index
< 0 && steps
>= 0 && global_settings
.repeat_mode
== REPEAT_SHUFFLE
)
2451 index
= get_next_index(playlist
, steps
, REPEAT_ALL
);
2453 return (index
>= 0);
2456 /* get trackname of track that is "steps" away from current playing track.
2457 NULL is used to identify end of playlist */
2458 const char* playlist_peek(int steps
, char* buf
, size_t buf_size
)
2460 struct playlist_info
* playlist
= ¤t_playlist
;
2466 index
= get_next_index(playlist
, steps
, -1);
2470 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
2471 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
2473 if (get_filename(playlist
, index
, seek
, control_file
, buf
,
2479 if (!playlist
->in_ram
|| control_file
)
2481 /* remove bogus dirs from beginning of path
2482 (workaround for buggy playlist creation tools) */
2485 if (file_exists(temp_ptr
))
2488 temp_ptr
= strchr(temp_ptr
+1, '/');
2493 /* Even though this is an invalid file, we still need to pass a
2494 file name to the caller because NULL is used to indicate end
2504 * Update indices as track has changed
2506 int playlist_next(int steps
)
2508 struct playlist_info
* playlist
= ¤t_playlist
;
2512 #ifdef AB_REPEAT_ENABLE
2513 && (global_settings
.repeat_mode
!= REPEAT_AB
)
2515 && (global_settings
.repeat_mode
!= REPEAT_ONE
) )
2519 /* We need to delete all the queued songs */
2520 for (i
=0, j
=steps
; i
<j
; i
++)
2522 index
= get_next_index(playlist
, i
, -1);
2524 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
2526 remove_track_from_playlist(playlist
, index
, true);
2527 steps
--; /* one less track */
2532 index
= get_next_index(playlist
, steps
, -1);
2536 /* end of playlist... or is it */
2537 if (global_settings
.repeat_mode
== REPEAT_SHUFFLE
&&
2538 playlist
->amount
> 1)
2540 /* Repeat shuffle mode. Re-shuffle playlist and resume play */
2541 playlist
->first_index
= 0;
2542 sort_playlist(playlist
, false, false);
2543 randomise_playlist(playlist
, current_tick
, false, true);
2544 #if CONFIG_CODEC != SWCODEC
2545 playlist_start(0, 0);
2547 playlist
->index
= 0;
2550 else if (playlist
->in_ram
&& global_settings
.next_folder
)
2552 index
= create_and_play_dir(steps
, true);
2556 playlist
->index
= index
;
2563 playlist
->index
= index
;
2565 if (playlist
->last_insert_pos
>= 0 && steps
> 0)
2567 /* check to see if we've gone beyond the last inserted track */
2568 int cur
= rotate_index(playlist
, index
);
2569 int last_pos
= rotate_index(playlist
, playlist
->last_insert_pos
);
2573 /* reset last inserted track */
2574 playlist
->last_insert_pos
= -1;
2576 if (playlist
->control_fd
>= 0)
2578 int result
= update_control(playlist
, PLAYLIST_COMMAND_RESET
,
2579 -1, -1, NULL
, NULL
, NULL
);
2584 sync_control(playlist
, false);
2592 /* try playing next or previous folder */
2593 bool playlist_next_dir(int direction
)
2595 /* not to mess up real playlists */
2596 if(!current_playlist
.in_ram
)
2599 return create_and_play_dir(direction
, false) >= 0;
2602 /* Get resume info for current playing song. If return value is -1 then
2603 settings shouldn't be saved. */
2604 int playlist_get_resume_info(int *resume_index
)
2606 struct playlist_info
* playlist
= ¤t_playlist
;
2608 *resume_index
= playlist
->index
;
2613 /* Update resume info for current playing song. Returns -1 on error. */
2614 int playlist_update_resume_info(const struct mp3entry
* id3
)
2616 struct playlist_info
* playlist
= ¤t_playlist
;
2620 if (global_status
.resume_index
!= playlist
->index
||
2621 global_status
.resume_offset
!= id3
->offset
)
2623 global_status
.resume_index
= playlist
->index
;
2624 global_status
.resume_offset
= id3
->offset
;
2630 global_status
.resume_index
= -1;
2631 global_status
.resume_offset
= -1;
2638 /* Returns index of current playing track for display purposes. This value
2639 should not be used for resume purposes as it doesn't represent the actual
2640 index into the playlist */
2641 int playlist_get_display_index(void)
2643 struct playlist_info
* playlist
= ¤t_playlist
;
2645 /* first_index should always be index 0 for display purposes */
2646 int index
= rotate_index(playlist
, playlist
->index
);
2651 /* returns number of tracks in current playlist */
2652 int playlist_amount(void)
2654 return playlist_amount_ex(NULL
);
2656 /* set playlist->last_shuffle_start to playlist->amount for
2657 PLAYLIST_INSERT_LAST_SHUFFLED command purposes*/
2658 void playlist_set_last_shuffled_start(void)
2660 struct playlist_info
* playlist
= ¤t_playlist
;
2661 playlist
->last_shuffled_start
= playlist
->amount
;
2664 * Create a new playlist If playlist is not NULL then we're loading a
2665 * playlist off disk for viewing/editing. The index_buffer is used to store
2666 * playlist indices (required for and only used if !current playlist). The
2667 * temp_buffer (if not NULL) is used as a scratchpad when loading indices.
2669 int playlist_create_ex(struct playlist_info
* playlist
,
2670 const char* dir
, const char* file
,
2671 void* index_buffer
, int index_buffer_size
,
2672 void* temp_buffer
, int temp_buffer_size
)
2675 playlist
= ¤t_playlist
;
2678 /* Initialize playlist structure */
2679 int r
= rand() % 10;
2680 playlist
->current
= false;
2682 /* Use random name for control file */
2683 snprintf(playlist
->control_filename
, sizeof(playlist
->control_filename
),
2684 "%s.%d", PLAYLIST_CONTROL_FILE
, r
);
2686 playlist
->control_fd
= -1;
2690 int num_indices
= index_buffer_size
/ sizeof(int);
2692 #ifdef HAVE_DIRCACHE
2695 if (num_indices
> global_settings
.max_files_in_playlist
)
2696 num_indices
= global_settings
.max_files_in_playlist
;
2698 playlist
->max_playlist_size
= num_indices
;
2699 playlist
->indices
= index_buffer
;
2700 #ifdef HAVE_DIRCACHE
2701 playlist
->filenames
= (const struct dircache_entry
**)
2702 &playlist
->indices
[num_indices
];
2707 playlist
->max_playlist_size
= current_playlist
.max_playlist_size
;
2708 playlist
->indices
= current_playlist
.indices
;
2709 #ifdef HAVE_DIRCACHE
2710 playlist
->filenames
= current_playlist
.filenames
;
2714 playlist
->buffer_size
= 0;
2715 playlist
->buffer
= NULL
;
2716 mutex_init(&playlist
->control_mutex
);
2719 new_playlist(playlist
, dir
, file
);
2722 /* load the playlist file */
2723 add_indices_to_playlist(playlist
, temp_buffer
, temp_buffer_size
);
2729 * Set the specified playlist as the current.
2730 * NOTE: You will get undefined behaviour if something is already playing so
2731 * remember to stop before calling this. Also, this call will
2732 * effectively close your playlist, making it unusable.
2734 int playlist_set_current(struct playlist_info
* playlist
)
2736 if (!playlist
|| (check_control(playlist
) < 0))
2739 empty_playlist(¤t_playlist
, false);
2741 strlcpy(current_playlist
.filename
, playlist
->filename
,
2742 sizeof(current_playlist
.filename
));
2744 current_playlist
.utf8
= playlist
->utf8
;
2745 current_playlist
.fd
= playlist
->fd
;
2747 close(playlist
->control_fd
);
2748 close(current_playlist
.control_fd
);
2749 remove(current_playlist
.control_filename
);
2750 if (rename(playlist
->control_filename
,
2751 current_playlist
.control_filename
) < 0)
2753 current_playlist
.control_fd
= open(current_playlist
.control_filename
,
2755 if (current_playlist
.control_fd
< 0)
2757 current_playlist
.control_created
= true;
2759 current_playlist
.dirlen
= playlist
->dirlen
;
2761 if (playlist
->indices
&& playlist
->indices
!= current_playlist
.indices
)
2763 memcpy(current_playlist
.indices
, playlist
->indices
,
2764 playlist
->max_playlist_size
*sizeof(int));
2765 #ifdef HAVE_DIRCACHE
2766 memcpy(current_playlist
.filenames
, playlist
->filenames
,
2767 playlist
->max_playlist_size
*sizeof(int));
2771 current_playlist
.first_index
= playlist
->first_index
;
2772 current_playlist
.amount
= playlist
->amount
;
2773 current_playlist
.last_insert_pos
= playlist
->last_insert_pos
;
2774 current_playlist
.seed
= playlist
->seed
;
2775 current_playlist
.shuffle_modified
= playlist
->shuffle_modified
;
2776 current_playlist
.deleted
= playlist
->deleted
;
2777 current_playlist
.num_inserted_tracks
= playlist
->num_inserted_tracks
;
2779 memcpy(current_playlist
.control_cache
, playlist
->control_cache
,
2780 sizeof(current_playlist
.control_cache
));
2781 current_playlist
.num_cached
= playlist
->num_cached
;
2782 current_playlist
.pending_control_sync
= playlist
->pending_control_sync
;
2786 struct playlist_info
*playlist_get_current(void)
2788 return ¤t_playlist
;
2791 * Close files and delete control file for non-current playlist.
2793 void playlist_close(struct playlist_info
* playlist
)
2798 if (playlist
->fd
>= 0)
2799 close(playlist
->fd
);
2801 if (playlist
->control_fd
>= 0)
2802 close(playlist
->control_fd
);
2804 if (playlist
->control_created
)
2805 remove(playlist
->control_filename
);
2808 void playlist_sync(struct playlist_info
* playlist
)
2811 playlist
= ¤t_playlist
;
2813 sync_control(playlist
, false);
2814 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2815 audio_flush_and_reload_tracks();
2817 #ifdef HAVE_DIRCACHE
2818 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2823 * Insert track into playlist at specified position (or one of the special
2824 * positions). Returns position where track was inserted or -1 if error.
2826 int playlist_insert_track(struct playlist_info
* playlist
, const char *filename
,
2827 int position
, bool queue
, bool sync
)
2832 playlist
= ¤t_playlist
;
2834 if (check_control(playlist
) < 0)
2836 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2840 result
= add_track_to_playlist(playlist
, filename
, position
, queue
, -1);
2842 /* Check if we want manually sync later. For example when adding
2843 * bunch of files from tagcache, syncing after every file wouldn't be
2844 * a good thing to do. */
2845 if (sync
&& result
>= 0)
2846 playlist_sync(playlist
);
2852 * Insert all tracks from specified directory into playlist.
2854 int playlist_insert_directory(struct playlist_info
* playlist
,
2855 const char *dirname
, int position
, bool queue
,
2859 unsigned char *count_str
;
2860 struct directory_search_context context
;
2863 playlist
= ¤t_playlist
;
2865 if (check_control(playlist
) < 0)
2867 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2871 if (position
== PLAYLIST_REPLACE
)
2873 if (playlist_remove_all_tracks(playlist
) == 0)
2874 position
= PLAYLIST_INSERT_LAST
;
2880 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
2882 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
2884 display_playlist_count(0, count_str
, false);
2886 context
.playlist
= playlist
;
2887 context
.position
= position
;
2888 context
.queue
= queue
;
2893 result
= playlist_directory_tracksearch(dirname
, recurse
,
2894 directory_search_callback
, &context
);
2896 sync_control(playlist
, false);
2900 display_playlist_count(context
.count
, count_str
, true);
2902 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2903 audio_flush_and_reload_tracks();
2905 #ifdef HAVE_DIRCACHE
2906 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2913 * Insert all tracks from specified playlist into dynamic playlist.
2915 int playlist_insert_playlist(struct playlist_info
* playlist
, const char *filename
,
2916 int position
, bool queue
)
2922 unsigned char *count_str
;
2923 char temp_buf
[MAX_PATH
+1];
2924 char trackname
[MAX_PATH
+1];
2927 bool utf8
= is_m3u8(filename
);
2930 playlist
= ¤t_playlist
;
2932 if (check_control(playlist
) < 0)
2934 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2938 fd
= open_utf8(filename
, O_RDONLY
);
2941 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
2945 /* we need the directory name for formatting purposes */
2948 temp_ptr
= strrchr(filename
+1,'/');
2955 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
2957 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
2959 display_playlist_count(count
, count_str
, false);
2961 if (position
== PLAYLIST_REPLACE
)
2963 if (playlist_remove_all_tracks(playlist
) == 0)
2964 position
= PLAYLIST_INSERT_LAST
;
2970 while ((max
= read_line(fd
, temp_buf
, sizeof(temp_buf
))) > 0)
2973 if (action_userabort(TIMEOUT_NOBLOCK
))
2976 if (temp_buf
[0] != '#' && temp_buf
[0] != '\0')
2982 /* Use trackname as a temporay buffer. Note that trackname must
2983 * be as large as temp_buf.
2985 max
= convert_m3u(temp_buf
, max
, sizeof(temp_buf
), trackname
);
2988 /* we need to format so that relative paths are correctly
2990 if (format_track_path(trackname
, temp_buf
, sizeof(trackname
), max
,
2997 insert_pos
= add_track_to_playlist(playlist
, trackname
, position
,
3006 /* Make sure tracks are inserted in correct order if user
3007 requests INSERT_FIRST */
3008 if (position
== PLAYLIST_INSERT_FIRST
|| position
>= 0)
3009 position
= insert_pos
+ 1;
3013 if ((count
%PLAYLIST_DISPLAY_COUNT
) == 0)
3015 display_playlist_count(count
, count_str
, false);
3017 if (count
== PLAYLIST_DISPLAY_COUNT
&&
3018 (audio_status() & AUDIO_STATUS_PLAY
) &&
3020 audio_flush_and_reload_tracks();
3024 /* let the other threads work */
3033 sync_control(playlist
, false);
3037 display_playlist_count(count
, count_str
, true);
3039 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3040 audio_flush_and_reload_tracks();
3042 #ifdef HAVE_DIRCACHE
3043 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3050 * Delete track at specified index. If index is PLAYLIST_DELETE_CURRENT then
3051 * we want to delete the current playing track.
3053 int playlist_delete(struct playlist_info
* playlist
, int index
)
3058 playlist
= ¤t_playlist
;
3060 if (check_control(playlist
) < 0)
3062 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3066 if (index
== PLAYLIST_DELETE_CURRENT
)
3067 index
= playlist
->index
;
3069 result
= remove_track_from_playlist(playlist
, index
, true);
3071 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3073 audio_flush_and_reload_tracks();
3079 * Move track at index to new_index. Tracks between the two are shifted
3080 * appropriately. Returns 0 on success and -1 on failure.
3082 int playlist_move(struct playlist_info
* playlist
, int index
, int new_index
)
3088 bool current
= false;
3090 char filename
[MAX_PATH
];
3093 playlist
= ¤t_playlist
;
3095 if (check_control(playlist
) < 0)
3097 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3101 if (index
== new_index
)
3104 if (index
== playlist
->index
)
3105 /* Moving the current track */
3108 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3109 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3110 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3112 if (get_filename(playlist
, index
, seek
, control_file
, filename
,
3113 sizeof(filename
)) < 0)
3116 /* We want to insert the track at the position that was specified by
3117 new_index. This may be different then new_index because of the
3118 shifting that will occur after the delete.
3119 We calculate this before we do the remove as it depends on the
3120 size of the playlist before the track removal */
3121 r
= rotate_index(playlist
, new_index
);
3123 /* Delete track from original position */
3124 result
= remove_track_from_playlist(playlist
, index
, true);
3130 new_index
= PLAYLIST_PREPEND
;
3131 else if (r
== playlist
->amount
)
3133 new_index
= PLAYLIST_INSERT_LAST
;
3135 /* Calculate index of desired position */
3136 new_index
= (r
+playlist
->first_index
)%playlist
->amount
;
3138 result
= add_track_to_playlist(playlist
, filename
, new_index
, queue
,
3145 /* Moved the current track */
3148 case PLAYLIST_PREPEND
:
3149 playlist
->index
= playlist
->first_index
;
3151 case PLAYLIST_INSERT_LAST
:
3152 playlist
->index
= playlist
->first_index
- 1;
3153 if (playlist
->index
< 0)
3154 playlist
->index
+= playlist
->amount
;
3157 playlist
->index
= new_index
;
3162 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3163 audio_flush_and_reload_tracks();
3167 #ifdef HAVE_DIRCACHE
3168 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3174 /* shuffle currently playing playlist */
3175 int playlist_randomise(struct playlist_info
* playlist
, unsigned int seed
,
3181 playlist
= ¤t_playlist
;
3183 check_control(playlist
);
3185 result
= randomise_playlist(playlist
, seed
, start_current
, true);
3187 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3189 audio_flush_and_reload_tracks();
3194 /* sort currently playing playlist */
3195 int playlist_sort(struct playlist_info
* playlist
, bool start_current
)
3200 playlist
= ¤t_playlist
;
3202 check_control(playlist
);
3204 result
= sort_playlist(playlist
, start_current
, true);
3206 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3208 audio_flush_and_reload_tracks();
3213 /* returns true if playlist has been modified */
3214 bool playlist_modified(const struct playlist_info
* playlist
)
3217 playlist
= ¤t_playlist
;
3219 if (playlist
->shuffle_modified
||
3220 playlist
->deleted
||
3221 playlist
->num_inserted_tracks
> 0)
3227 /* returns index of first track in playlist */
3228 int playlist_get_first_index(const struct playlist_info
* playlist
)
3231 playlist
= ¤t_playlist
;
3233 return playlist
->first_index
;
3236 /* returns shuffle seed of playlist */
3237 int playlist_get_seed(const struct playlist_info
* playlist
)
3240 playlist
= ¤t_playlist
;
3242 return playlist
->seed
;
3245 /* returns number of tracks in playlist (includes queued/inserted tracks) */
3246 int playlist_amount_ex(const struct playlist_info
* playlist
)
3249 playlist
= ¤t_playlist
;
3251 return playlist
->amount
;
3254 /* returns full path of playlist (minus extension) */
3255 char *playlist_name(const struct playlist_info
* playlist
, char *buf
,
3261 playlist
= ¤t_playlist
;
3263 strlcpy(buf
, playlist
->filename
+playlist
->dirlen
, buf_size
);
3268 /* Remove extension */
3269 sep
= strrchr(buf
, '.');
3276 /* returns the playlist filename */
3277 char *playlist_get_name(const struct playlist_info
* playlist
, char *buf
,
3281 playlist
= ¤t_playlist
;
3283 strlcpy(buf
, playlist
->filename
, buf_size
);
3291 /* Fills info structure with information about track at specified index.
3292 Returns 0 on success and -1 on failure */
3293 int playlist_get_track_info(struct playlist_info
* playlist
, int index
,
3294 struct playlist_track_info
* info
)
3300 playlist
= ¤t_playlist
;
3302 if (index
< 0 || index
>= playlist
->amount
)
3305 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3306 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3308 if (get_filename(playlist
, index
, seek
, control_file
, info
->filename
,
3309 sizeof(info
->filename
)) < 0)
3316 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
3317 info
->attr
|= PLAYLIST_ATTR_QUEUED
;
3319 info
->attr
|= PLAYLIST_ATTR_INSERTED
;
3323 if (playlist
->indices
[index
] & PLAYLIST_SKIPPED
)
3324 info
->attr
|= PLAYLIST_ATTR_SKIPPED
;
3326 info
->index
= index
;
3327 info
->display_index
= rotate_index(playlist
, index
) + 1;
3332 /* save the current dynamic playlist to specified file */
3333 int playlist_save(struct playlist_info
* playlist
, char *filename
)
3338 char path
[MAX_PATH
+1];
3339 char tmp_buf
[MAX_PATH
+1];
3341 bool overwrite_current
= false;
3342 int* index_buf
= NULL
;
3345 playlist
= ¤t_playlist
;
3347 if (playlist
->amount
<= 0)
3350 /* use current working directory as base for pathname */
3351 if (format_track_path(path
, filename
, sizeof(tmp_buf
),
3352 strlen(filename
)+1, getcwd(NULL
, -1)) < 0)
3355 if (!strncmp(playlist
->filename
, path
, strlen(path
)))
3357 /* Attempting to overwrite current playlist file.*/
3359 if (playlist
->buffer_size
< (int)(playlist
->amount
* sizeof(int)))
3361 /* not enough buffer space to store updated indices */
3362 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3366 /* in_ram buffer is unused for m3u files so we'll use for storing
3368 index_buf
= (int*)playlist
->buffer
;
3370 /* use temporary pathname */
3371 snprintf(path
, sizeof(path
), "%s_temp", playlist
->filename
);
3372 overwrite_current
= true;
3377 fd
= open_utf8(path
, O_CREAT
|O_WRONLY
|O_TRUNC
);
3381 /* some applications require a BOM to read the file properly */
3382 fd
= open(path
, O_CREAT
|O_WRONLY
|O_TRUNC
, 0666);
3386 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3390 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
), false);
3394 index
= playlist
->first_index
;
3395 for (i
=0; i
<playlist
->amount
; i
++)
3402 if (action_userabort(TIMEOUT_NOBLOCK
))
3408 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3409 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3410 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3412 /* Don't save queued files */
3415 if (get_filename(playlist
, index
, seek
, control_file
, tmp_buf
,
3422 if (overwrite_current
)
3423 index_buf
[count
] = lseek(fd
, 0, SEEK_CUR
);
3425 if (fdprintf(fd
, "%s\n", tmp_buf
) < 0)
3427 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3434 if ((count
% PLAYLIST_DISPLAY_COUNT
) == 0)
3435 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
),
3441 index
= (index
+1)%playlist
->amount
;
3444 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
), true);
3448 if (overwrite_current
&& result
>= 0)
3452 mutex_lock(&playlist
->control_mutex
);
3454 /* Replace the current playlist with the new one and update indices */
3455 close(playlist
->fd
);
3456 if (remove(playlist
->filename
) >= 0)
3458 if (rename(path
, playlist
->filename
) >= 0)
3460 playlist
->fd
= open_utf8(playlist
->filename
, O_RDONLY
);
3461 if (playlist
->fd
>= 0)
3463 index
= playlist
->first_index
;
3464 for (i
=0, count
=0; i
<playlist
->amount
; i
++)
3466 if (!(playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
))
3468 playlist
->indices
[index
] = index_buf
[count
];
3471 index
= (index
+1)%playlist
->amount
;
3474 /* we need to recreate control because inserted tracks are
3475 now part of the playlist and shuffle has been
3477 result
= recreate_control(playlist
);
3482 mutex_unlock(&playlist
->control_mutex
);
3492 * Search specified directory for tracks and notify via callback. May be
3493 * called recursively.
3495 int playlist_directory_tracksearch(const char* dirname
, bool recurse
,
3496 int (*callback
)(char*, void*),
3499 char buf
[MAX_PATH
+1];
3503 struct entry
*files
;
3504 struct tree_context
* tc
= tree_get_context();
3505 int old_dirfilter
= *(tc
->dirfilter
);
3510 /* use the tree browser dircache to load files */
3511 *(tc
->dirfilter
) = SHOW_ALL
;
3513 if (ft_load(tc
, dirname
) < 0)
3515 splash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
3516 *(tc
->dirfilter
) = old_dirfilter
;
3520 files
= (struct entry
*) tc
->dircache
;
3521 num_files
= tc
->filesindir
;
3523 /* we've overwritten the dircache so tree browser will need to be
3527 for (i
=0; i
<num_files
; i
++)
3530 if (action_userabort(TIMEOUT_NOBLOCK
))
3536 if (files
[i
].attr
& ATTR_DIRECTORY
)
3540 /* recursively add directories */
3541 snprintf(buf
, sizeof(buf
), "%s/%s", dirname
, files
[i
].name
);
3542 result
= playlist_directory_tracksearch(buf
, recurse
,
3547 /* we now need to reload our current directory */
3548 if(ft_load(tc
, dirname
) < 0)
3554 files
= (struct entry
*) tc
->dircache
;
3555 num_files
= tc
->filesindir
;
3565 else if ((files
[i
].attr
& FILE_ATTR_MASK
) == FILE_ATTR_AUDIO
)
3567 snprintf(buf
, sizeof(buf
), "%s/%s", dirname
, files
[i
].name
);
3569 if (callback(buf
, context
) != 0)
3575 /* let the other threads work */
3580 /* restore dirfilter */
3581 *(tc
->dirfilter
) = old_dirfilter
;