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
;
147 static char now_playing
[MAX_PATH
+1];
149 static void empty_playlist(struct playlist_info
* playlist
, bool resume
);
150 static void new_playlist(struct playlist_info
* playlist
, const char *dir
,
152 static void create_control(struct playlist_info
* playlist
);
153 static int check_control(struct playlist_info
* playlist
);
154 static int recreate_control(struct playlist_info
* playlist
);
155 static void update_playlist_filename(struct playlist_info
* playlist
,
156 const char *dir
, const char *file
);
157 static int add_indices_to_playlist(struct playlist_info
* playlist
,
158 char* buffer
, size_t buflen
);
159 static int add_track_to_playlist(struct playlist_info
* playlist
,
160 const char *filename
, int position
,
161 bool queue
, int seek_pos
);
162 static int directory_search_callback(char* filename
, void* context
);
163 static int remove_track_from_playlist(struct playlist_info
* playlist
,
164 int position
, bool write
);
165 static int randomise_playlist(struct playlist_info
* playlist
,
166 unsigned int seed
, bool start_current
,
168 static int sort_playlist(struct playlist_info
* playlist
, bool start_current
,
170 static int get_next_index(const struct playlist_info
* playlist
, int steps
,
172 static void find_and_set_playlist_index(struct playlist_info
* playlist
,
174 static int compare(const void* p1
, const void* p2
);
175 static int get_filename(struct playlist_info
* playlist
, int index
, int seek
,
176 bool control_file
, char *buf
, int buf_length
);
177 static int get_next_directory(char *dir
);
178 static int get_next_dir(char *dir
, bool is_forward
, bool recursion
);
179 static int get_previous_directory(char *dir
);
180 static int check_subdir_for_music(char *dir
, const char *subdir
, bool recurse
);
181 static int format_track_path(char *dest
, char *src
, int buf_length
, int max
,
183 static void display_playlist_count(int count
, const unsigned char *fmt
,
185 static void display_buffer_full(void);
186 static int flush_cached_control(struct playlist_info
* playlist
);
187 static int update_control(struct playlist_info
* playlist
,
188 enum playlist_command command
, int i1
, int i2
,
189 const char* s1
, const char* s2
, void* data
);
190 static void sync_control(struct playlist_info
* playlist
, bool force
);
191 static int rotate_index(const struct playlist_info
* playlist
, int index
);
194 #define PLAYLIST_LOAD_POINTERS 1
196 static struct event_queue playlist_queue
;
197 static long playlist_stack
[(DEFAULT_STACK_SIZE
+ 0x800)/sizeof(long)];
198 static const char playlist_thread_name
[] = "playlist cachectrl";
201 /* Check if the filename suggests M3U or M3U8 format. */
202 static bool is_m3u8(const char* filename
)
204 int len
= strlen(filename
);
206 /* Default to M3U8 unless explicitly told otherwise. */
207 return !(len
> 4 && strcasecmp(&filename
[len
- 4], ".m3u") == 0);
211 /* Convert a filename in an M3U playlist to UTF-8.
213 * buf - the filename to convert; can contain more than one line from the
215 * buf_len - amount of buf that is used.
216 * buf_max - total size of buf.
217 * temp - temporary conversion buffer, at least buf_max bytes.
219 * Returns the length of the converted filename.
221 static int convert_m3u(char* buf
, int buf_len
, int buf_max
, char* temp
)
227 while ((buf
[i
] != '\n') && (buf
[i
] != '\r') && (i
< buf_len
))
232 /* Work back killing white space. */
233 while ((i
> 0) && isspace(buf
[i
- 1]))
241 /* Convert char by char, so as to not overflow temp (iso_decode should
242 * preferably handle this). No more than 4 bytes should be generated for
245 for (i
= 0; i
< buf_len
&& dest
< (temp
+ buf_max
- 4); i
++)
247 dest
= iso_decode(&buf
[i
], dest
, -1, 1);
256 * remove any files and indices associated with the playlist
258 static void empty_playlist(struct playlist_info
* playlist
, bool resume
)
260 playlist
->filename
[0] = '\0';
261 playlist
->utf8
= true;
263 if(playlist
->fd
>= 0)
264 /* If there is an already open playlist, close it. */
268 if(playlist
->control_fd
>= 0)
269 close(playlist
->control_fd
);
270 playlist
->control_fd
= -1;
271 playlist
->control_created
= false;
273 playlist
->in_ram
= false;
275 if (playlist
->buffer
)
276 playlist
->buffer
[0] = 0;
278 playlist
->buffer_end_pos
= 0;
281 playlist
->first_index
= 0;
282 playlist
->amount
= 0;
283 playlist
->last_insert_pos
= -1;
285 playlist
->shuffle_modified
= false;
286 playlist
->deleted
= false;
287 playlist
->num_inserted_tracks
= 0;
288 playlist
->started
= false;
290 playlist
->num_cached
= 0;
291 playlist
->pending_control_sync
= false;
293 if (!resume
&& playlist
->current
)
295 /* start with fresh playlist control file when starting new
297 create_control(playlist
);
302 * Initialize a new playlist for viewing/editing/playing. dir is the
303 * directory where the playlist is located and file is the filename.
305 static void new_playlist(struct playlist_info
* playlist
, const char *dir
,
308 const char *fileused
= file
;
309 const char *dirused
= dir
;
310 empty_playlist(playlist
, false);
316 if (dirused
&& playlist
->current
) /* !current cannot be in_ram */
317 playlist
->in_ram
= true;
319 dirused
= ""; /* empty playlist */
322 update_playlist_filename(playlist
, dirused
, fileused
);
324 if (playlist
->control_fd
>= 0)
326 update_control(playlist
, PLAYLIST_COMMAND_PLAYLIST
,
327 PLAYLIST_CONTROL_FILE_VERSION
, -1, dirused
, fileused
, NULL
);
328 sync_control(playlist
, false);
333 * create control file for playlist
335 static void create_control(struct playlist_info
* playlist
)
337 playlist
->control_fd
= open(playlist
->control_filename
,
338 O_CREAT
|O_RDWR
|O_TRUNC
, 0666);
339 if (playlist
->control_fd
< 0)
341 if (check_rockboxdir())
343 cond_talk_ids_fq(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
);
344 splashf(HZ
*2, (unsigned char *)"%s (%d)",
345 str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
),
346 playlist
->control_fd
);
348 playlist
->control_created
= false;
352 playlist
->control_created
= true;
357 * validate the control file. This may include creating/initializing it if
360 static int check_control(struct playlist_info
* playlist
)
362 if (!playlist
->control_created
)
364 create_control(playlist
);
366 if (playlist
->control_fd
>= 0)
368 char* dir
= playlist
->filename
;
369 char* file
= playlist
->filename
+playlist
->dirlen
;
370 char c
= playlist
->filename
[playlist
->dirlen
-1];
372 playlist
->filename
[playlist
->dirlen
-1] = '\0';
374 update_control(playlist
, PLAYLIST_COMMAND_PLAYLIST
,
375 PLAYLIST_CONTROL_FILE_VERSION
, -1, dir
, file
, NULL
);
376 sync_control(playlist
, false);
377 playlist
->filename
[playlist
->dirlen
-1] = c
;
381 if (playlist
->control_fd
< 0)
388 * recreate the control file based on current playlist entries
390 static int recreate_control(struct playlist_info
* playlist
)
392 char temp_file
[MAX_PATH
+1];
397 if(playlist
->control_fd
>= 0)
399 char* dir
= playlist
->filename
;
400 char* file
= playlist
->filename
+playlist
->dirlen
;
401 char c
= playlist
->filename
[playlist
->dirlen
-1];
403 close(playlist
->control_fd
);
405 snprintf(temp_file
, sizeof(temp_file
), "%s_temp",
406 playlist
->control_filename
);
408 if (rename(playlist
->control_filename
, temp_file
) < 0)
411 temp_fd
= open(temp_file
, O_RDONLY
);
415 playlist
->control_fd
= open(playlist
->control_filename
,
416 O_CREAT
|O_RDWR
|O_TRUNC
, 0666);
417 if (playlist
->control_fd
< 0)
420 playlist
->filename
[playlist
->dirlen
-1] = '\0';
422 /* cannot call update_control() because of mutex */
423 result
= fdprintf(playlist
->control_fd
, "P:%d:%s:%s\n",
424 PLAYLIST_CONTROL_FILE_VERSION
, dir
, file
);
426 playlist
->filename
[playlist
->dirlen
-1] = c
;
436 playlist
->shuffle_modified
= false;
437 playlist
->deleted
= false;
438 playlist
->num_inserted_tracks
= 0;
440 for (i
=0; i
<playlist
->amount
; i
++)
442 if (playlist
->indices
[i
] & PLAYLIST_INSERT_TYPE_MASK
)
444 bool queue
= playlist
->indices
[i
] & PLAYLIST_QUEUE_MASK
;
445 char inserted_file
[MAX_PATH
+1];
447 lseek(temp_fd
, playlist
->indices
[i
] & PLAYLIST_SEEK_MASK
,
449 read_line(temp_fd
, inserted_file
, sizeof(inserted_file
));
451 result
= fdprintf(playlist
->control_fd
, "%c:%d:%d:",
452 queue
?'Q':'A', i
, playlist
->last_insert_pos
);
455 /* save the position in file where name is written */
456 int seek_pos
= lseek(playlist
->control_fd
, 0, SEEK_CUR
);
458 result
= fdprintf(playlist
->control_fd
, "%s\n",
461 playlist
->indices
[i
] =
462 (playlist
->indices
[i
] & ~PLAYLIST_SEEK_MASK
) | seek_pos
;
468 playlist
->num_inserted_tracks
++;
474 fsync(playlist
->control_fd
);
483 * store directory and name of playlist file
485 static void update_playlist_filename(struct playlist_info
* playlist
,
486 const char *dir
, const char *file
)
489 int dirlen
= strlen(dir
);
491 playlist
->utf8
= is_m3u8(file
);
493 /* If the dir does not end in trailing slash, we use a separator.
494 Otherwise we don't. */
495 if('/' != dir
[dirlen
-1])
501 playlist
->dirlen
= dirlen
;
503 snprintf(playlist
->filename
, sizeof(playlist
->filename
),
504 "%s%s%s", dir
, sep
, file
);
508 * calculate track offsets within a playlist file
510 static int add_indices_to_playlist(struct playlist_info
* playlist
,
511 char* buffer
, size_t buflen
)
515 unsigned int count
= 0;
520 if(-1 == playlist
->fd
)
521 playlist
->fd
= open_utf8(playlist
->filename
, O_RDONLY
);
523 return -1; /* failure */
524 if((i
= lseek(playlist
->fd
, 0, SEEK_CUR
)) > 0)
525 playlist
->utf8
= true; /* Override any earlier indication. */
527 splash(0, ID2P(LANG_WAIT
));
531 /* use mp3 buffer for maximum load speed */
533 #if CONFIG_CODEC != SWCODEC
534 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
535 buflen
= (audiobufend
- audiobuf
);
536 buffer
= (char *)audiobuf
;
538 buffer
= (char *)audio_get_buffer(false, &buflen
);
546 nread
= read(playlist
->fd
, buffer
, buflen
);
547 /* Terminate on EOF */
551 p
= (unsigned char *)buffer
;
553 for(count
=0; count
< nread
; count
++,p
++) {
555 /* Are we on a new line? */
556 if((*p
== '\n') || (*p
== '\r'))
566 if ( playlist
->amount
>= playlist
->max_playlist_size
) {
567 display_buffer_full();
572 /* Store a new entry */
573 playlist
->indices
[ playlist
->amount
] = i
+count
;
575 if (playlist
->filenames
)
576 playlist
->filenames
[ playlist
->amount
] = NULL
;
588 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
595 * Utility function to create a new playlist, fill it with the next or
596 * previous directory, shuffle it if needed, and start playback.
597 * If play_last is true and direction zero or negative, start playing
598 * the last file in the directory, otherwise start playing the first.
600 static int create_and_play_dir(int direction
, bool play_last
)
602 char dir
[MAX_PATH
+ 1];
607 res
= get_next_directory(dir
);
609 res
= get_previous_directory(dir
);
613 if (playlist_create(dir
, NULL
) != -1)
615 ft_build_playlist(tree_get_context(), 0);
617 if (global_settings
.playlist_shuffle
)
618 playlist_shuffle(current_tick
, -1);
620 if (play_last
&& direction
<= 0)
621 index
= current_playlist
.amount
- 1;
625 #if (CONFIG_CODEC != SWCODEC)
626 playlist_start(index
, 0);
630 /* we've overwritten the dircache when getting the next/previous dir,
631 so the tree browser context will need to be reloaded */
639 * Removes all tracks, from the playlist, leaving the presently playing
642 int playlist_remove_all_tracks(struct playlist_info
*playlist
)
646 if (playlist
== NULL
)
647 playlist
= ¤t_playlist
;
649 while (playlist
->index
> 0)
650 if ((result
= remove_track_from_playlist(playlist
, 0, true)) < 0)
653 while (playlist
->amount
> 1)
654 if ((result
= remove_track_from_playlist(playlist
, 1, true)) < 0)
657 if (playlist
->amount
== 1) {
658 playlist
->indices
[0] |= PLAYLIST_QUEUED
;
666 * Add track to playlist at specified position. There are seven special
667 * positions that can be specified:
668 * PLAYLIST_PREPEND - Add track at beginning of playlist
669 * PLAYLIST_INSERT - Add track after current song. NOTE: If
670 * there are already inserted tracks then track
671 * is added to the end of the insertion list
672 * PLAYLIST_INSERT_FIRST - Add track immediately after current song, no
673 * matter what other tracks have been inserted
674 * PLAYLIST_INSERT_LAST - Add track to end of playlist
675 * PLAYLIST_INSERT_SHUFFLED - Add track at some random point between the
676 * current playing track and end of playlist
677 * PLAYLIST_INSERT_LAST_SHUFFLED - Add tracks in random order to the end of
679 * PLAYLIST_REPLACE - Erase current playlist, Cue the current track
680 * and inster this track at the end.
682 static int add_track_to_playlist(struct playlist_info
* playlist
,
683 const char *filename
, int position
,
684 bool queue
, int seek_pos
)
686 int insert_position
, orig_position
;
687 unsigned long flags
= PLAYLIST_INSERT_TYPE_INSERT
;
690 insert_position
= orig_position
= position
;
692 if (playlist
->amount
>= playlist
->max_playlist_size
)
694 display_buffer_full();
700 case PLAYLIST_PREPEND
:
701 position
= insert_position
= playlist
->first_index
;
703 case PLAYLIST_INSERT
:
704 /* if there are already inserted tracks then add track to end of
705 insertion list else add after current playing track */
706 if (playlist
->last_insert_pos
>= 0 &&
707 playlist
->last_insert_pos
< playlist
->amount
&&
708 (playlist
->indices
[playlist
->last_insert_pos
]&
709 PLAYLIST_INSERT_TYPE_MASK
) == PLAYLIST_INSERT_TYPE_INSERT
)
710 position
= insert_position
= playlist
->last_insert_pos
+1;
711 else if (playlist
->amount
> 0)
712 position
= insert_position
= playlist
->index
+ 1;
714 position
= insert_position
= 0;
716 playlist
->last_insert_pos
= position
;
718 case PLAYLIST_INSERT_FIRST
:
719 if (playlist
->amount
> 0)
720 position
= insert_position
= playlist
->index
+ 1;
722 position
= insert_position
= 0;
724 playlist
->last_insert_pos
= position
;
726 case PLAYLIST_INSERT_LAST
:
727 if (playlist
->first_index
> 0)
728 position
= insert_position
= playlist
->first_index
;
730 position
= insert_position
= playlist
->amount
;
732 playlist
->last_insert_pos
= position
;
734 case PLAYLIST_INSERT_SHUFFLED
:
736 if (playlist
->started
)
739 int n
= playlist
->amount
-
740 rotate_index(playlist
, playlist
->index
);
747 position
= playlist
->index
+ offset
+ 1;
748 if (position
>= playlist
->amount
)
749 position
-= playlist
->amount
;
751 insert_position
= position
;
754 position
= insert_position
= (rand() % (playlist
->amount
+1));
757 case PLAYLIST_INSERT_LAST_SHUFFLED
:
759 position
= insert_position
= playlist
->last_shuffled_start
+
760 rand() % (playlist
->amount
- playlist
->last_shuffled_start
+ 1);
763 case PLAYLIST_REPLACE
:
764 if (playlist_remove_all_tracks(playlist
) < 0)
767 playlist
->last_insert_pos
= position
= insert_position
= playlist
->index
+ 1;
772 flags
|= PLAYLIST_QUEUED
;
774 /* shift indices so that track can be added */
775 for (i
=playlist
->amount
; i
>insert_position
; i
--)
777 playlist
->indices
[i
] = playlist
->indices
[i
-1];
779 if (playlist
->filenames
)
780 playlist
->filenames
[i
] = playlist
->filenames
[i
-1];
784 /* update stored indices if needed */
786 if (orig_position
< 0)
788 if (playlist
->amount
> 0 && insert_position
<= playlist
->index
&&
792 if (playlist
->amount
> 0 && insert_position
<= playlist
->first_index
&&
793 orig_position
!= PLAYLIST_PREPEND
&& playlist
->started
)
794 playlist
->first_index
++;
797 if (insert_position
< playlist
->last_insert_pos
||
798 (insert_position
== playlist
->last_insert_pos
&& position
< 0))
799 playlist
->last_insert_pos
++;
801 if (seek_pos
< 0 && playlist
->control_fd
>= 0)
803 int result
= update_control(playlist
,
804 (queue
?PLAYLIST_COMMAND_QUEUE
:PLAYLIST_COMMAND_ADD
), position
,
805 playlist
->last_insert_pos
, filename
, NULL
, &seek_pos
);
811 playlist
->indices
[insert_position
] = flags
| seek_pos
;
814 if (playlist
->filenames
)
815 playlist
->filenames
[insert_position
] = NULL
;
819 playlist
->num_inserted_tracks
++;
821 return insert_position
;
825 * Callback for playlist_directory_tracksearch to insert track into
828 static int directory_search_callback(char* filename
, void* context
)
830 struct directory_search_context
* c
=
831 (struct directory_search_context
*) context
;
834 insert_pos
= add_track_to_playlist(c
->playlist
, filename
, c
->position
,
842 /* Make sure tracks are inserted in correct order if user requests
844 if (c
->position
== PLAYLIST_INSERT_FIRST
|| c
->position
>= 0)
845 c
->position
= insert_pos
+ 1;
847 if (((c
->count
)%PLAYLIST_DISPLAY_COUNT
) == 0)
849 unsigned char* count_str
;
852 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
854 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
856 display_playlist_count(c
->count
, count_str
, false);
858 if ((c
->count
) == PLAYLIST_DISPLAY_COUNT
&&
859 (audio_status() & AUDIO_STATUS_PLAY
) &&
860 c
->playlist
->started
)
861 audio_flush_and_reload_tracks();
868 * remove track at specified position
870 static int remove_track_from_playlist(struct playlist_info
* playlist
,
871 int position
, bool write
)
876 if (playlist
->amount
<= 0)
879 inserted
= playlist
->indices
[position
] & PLAYLIST_INSERT_TYPE_MASK
;
881 /* shift indices now that track has been removed */
882 for (i
=position
; i
<playlist
->amount
; i
++)
884 playlist
->indices
[i
] = playlist
->indices
[i
+1];
886 if (playlist
->filenames
)
887 playlist
->filenames
[i
] = playlist
->filenames
[i
+1];
894 playlist
->num_inserted_tracks
--;
896 playlist
->deleted
= true;
898 /* update stored indices if needed */
899 if (position
< playlist
->index
)
902 if (position
< playlist
->first_index
)
904 playlist
->first_index
--;
907 if (position
<= playlist
->last_insert_pos
)
908 playlist
->last_insert_pos
--;
910 if (write
&& playlist
->control_fd
>= 0)
912 int result
= update_control(playlist
, PLAYLIST_COMMAND_DELETE
,
913 position
, -1, NULL
, NULL
, NULL
);
918 sync_control(playlist
, false);
925 * randomly rearrange the array of indices for the playlist. If start_current
926 * is true then update the index to the new index of the current playing track
928 static int randomise_playlist(struct playlist_info
* playlist
,
929 unsigned int seed
, bool start_current
,
935 unsigned int current
= playlist
->indices
[playlist
->index
];
937 /* seed 0 is used to identify sorted playlist for resume purposes */
941 /* seed with the given seed */
944 /* randomise entire indices list */
945 for(count
= playlist
->amount
- 1; count
>= 0; count
--)
947 /* the rand is from 0 to RAND_MAX, so adjust to our value range */
948 candidate
= rand() % (count
+ 1);
950 /* now swap the values at the 'count' and 'candidate' positions */
951 store
= playlist
->indices
[candidate
];
952 playlist
->indices
[candidate
] = playlist
->indices
[count
];
953 playlist
->indices
[count
] = store
;
955 if (playlist
->filenames
)
957 store
= (long)playlist
->filenames
[candidate
];
958 playlist
->filenames
[candidate
] = playlist
->filenames
[count
];
959 playlist
->filenames
[count
] = (struct dircache_entry
*)store
;
965 find_and_set_playlist_index(playlist
, current
);
967 /* indices have been moved so last insert position is no longer valid */
968 playlist
->last_insert_pos
= -1;
970 playlist
->seed
= seed
;
971 if (playlist
->num_inserted_tracks
> 0 || playlist
->deleted
)
972 playlist
->shuffle_modified
= true;
976 update_control(playlist
, PLAYLIST_COMMAND_SHUFFLE
, seed
,
977 playlist
->first_index
, NULL
, NULL
, NULL
);
984 * Sort the array of indices for the playlist. If start_current is true then
985 * set the index to the new index of the current song.
986 * Also while going to unshuffled mode set the first_index to 0.
988 static int sort_playlist(struct playlist_info
* playlist
, bool start_current
,
991 unsigned int current
= playlist
->indices
[playlist
->index
];
993 if (playlist
->amount
> 0)
994 qsort(playlist
->indices
, playlist
->amount
,
995 sizeof(playlist
->indices
[0]), compare
);
998 /** We need to re-check the song names from disk because qsort can't
999 * sort two arrays at once :/
1000 * FIXME: Please implement a better way to do this. */
1001 memset(playlist
->filenames
, 0, playlist
->max_playlist_size
* sizeof(int));
1002 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
1006 find_and_set_playlist_index(playlist
, current
);
1008 /* indices have been moved so last insert position is no longer valid */
1009 playlist
->last_insert_pos
= -1;
1011 if (!playlist
->num_inserted_tracks
&& !playlist
->deleted
)
1012 playlist
->shuffle_modified
= false;
1013 if (write
&& playlist
->control_fd
>= 0)
1015 playlist
->first_index
= 0;
1016 update_control(playlist
, PLAYLIST_COMMAND_UNSHUFFLE
,
1017 playlist
->first_index
, -1, NULL
, NULL
, NULL
);
1023 /* Calculate how many steps we have to really step when skipping entries
1026 static int calculate_step_count(const struct playlist_info
*playlist
, int steps
)
1028 int i
, count
, direction
;
1030 int stepped_count
= 0;
1043 index
= playlist
->index
;
1046 /* Boundary check */
1048 index
+= playlist
->amount
;
1049 if (index
>= playlist
->amount
)
1050 index
-= playlist
->amount
;
1052 /* Check if we found a bad entry. */
1053 if (playlist
->indices
[index
] & PLAYLIST_SKIPPED
)
1056 /* Are all entries bad? */
1057 if (stepped_count
++ > playlist
->amount
)
1064 } while (i
<= count
);
1069 /* Marks the index of the track to be skipped that is "steps" away from
1070 * current playing track.
1072 void playlist_skip_entry(struct playlist_info
*playlist
, int steps
)
1076 if (playlist
== NULL
)
1077 playlist
= ¤t_playlist
;
1079 /* need to account for already skipped tracks */
1080 steps
= calculate_step_count(playlist
, steps
);
1082 index
= playlist
->index
+ steps
;
1084 index
+= playlist
->amount
;
1085 else if (index
>= playlist
->amount
)
1086 index
-= playlist
->amount
;
1088 playlist
->indices
[index
] |= PLAYLIST_SKIPPED
;
1092 * returns the index of the track that is "steps" away from current playing
1095 static int get_next_index(const struct playlist_info
* playlist
, int steps
,
1098 int current_index
= playlist
->index
;
1099 int next_index
= -1;
1101 if (playlist
->amount
<= 0)
1104 if (repeat_mode
== -1)
1105 repeat_mode
= global_settings
.repeat_mode
;
1107 if (repeat_mode
== REPEAT_SHUFFLE
&& playlist
->amount
<= 1)
1108 repeat_mode
= REPEAT_ALL
;
1110 steps
= calculate_step_count(playlist
, steps
);
1111 switch (repeat_mode
)
1113 case REPEAT_SHUFFLE
:
1114 /* Treat repeat shuffle just like repeat off. At end of playlist,
1115 play will be resumed in playlist_next() */
1118 current_index
= rotate_index(playlist
, current_index
);
1119 next_index
= current_index
+steps
;
1120 if ((next_index
< 0) || (next_index
>= playlist
->amount
))
1123 next_index
= (next_index
+playlist
->first_index
) %
1130 #ifdef AB_REPEAT_ENABLE
1133 next_index
= current_index
;
1139 next_index
= (current_index
+steps
) % playlist
->amount
;
1140 while (next_index
< 0)
1141 next_index
+= playlist
->amount
;
1143 if (steps
>= playlist
->amount
)
1150 /* second time around so skip the queued files */
1151 for (i
=0; i
<playlist
->amount
; i
++)
1153 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
1154 index
= (index
+1) % playlist
->amount
;
1166 /* No luck if the whole playlist was bad. */
1167 if (playlist
->indices
[next_index
] & PLAYLIST_SKIPPED
)
1174 * Search for the seek track and set appropriate indices. Used after shuffle
1175 * to make sure the current index is still pointing to correct track.
1177 static void find_and_set_playlist_index(struct playlist_info
* playlist
,
1182 /* Set the index to the current song */
1183 for (i
=0; i
<playlist
->amount
; i
++)
1185 if (playlist
->indices
[i
] == seek
)
1187 playlist
->index
= playlist
->first_index
= i
;
1195 * used to sort track indices. Sort order is as follows:
1196 * 1. Prepended tracks (in prepend order)
1197 * 2. Playlist/directory tracks (in playlist order)
1198 * 3. Inserted/Appended tracks (in insert order)
1200 static int compare(const void* p1
, const void* p2
)
1202 unsigned long* e1
= (unsigned long*) p1
;
1203 unsigned long* e2
= (unsigned long*) p2
;
1204 unsigned long flags1
= *e1
& PLAYLIST_INSERT_TYPE_MASK
;
1205 unsigned long flags2
= *e2
& PLAYLIST_INSERT_TYPE_MASK
;
1207 if (flags1
== flags2
)
1208 return (*e1
& PLAYLIST_SEEK_MASK
) - (*e2
& PLAYLIST_SEEK_MASK
);
1209 else if (flags1
== PLAYLIST_INSERT_TYPE_PREPEND
||
1210 flags2
== PLAYLIST_INSERT_TYPE_APPEND
)
1212 else if (flags1
== PLAYLIST_INSERT_TYPE_APPEND
||
1213 flags2
== PLAYLIST_INSERT_TYPE_PREPEND
)
1215 else if (flags1
&& flags2
)
1216 return (*e1
& PLAYLIST_SEEK_MASK
) - (*e2
& PLAYLIST_SEEK_MASK
);
1221 #ifdef HAVE_DIRCACHE
1223 * Thread to update filename pointers to dircache on background
1224 * without affecting playlist load up performance. This thread also flushes
1225 * any pending control commands when the disk spins up.
1227 static void playlist_flush_callback(void *param
)
1230 struct playlist_info
*playlist
;
1231 playlist
= ¤t_playlist
;
1232 if (playlist
->control_fd
>= 0)
1234 if (playlist
->num_cached
> 0)
1236 mutex_lock(&playlist
->control_mutex
);
1237 flush_cached_control(playlist
);
1238 mutex_unlock(&playlist
->control_mutex
);
1240 sync_control(playlist
, true);
1244 static void playlist_thread(void)
1246 struct queue_event ev
;
1247 bool dirty_pointers
= false;
1248 static char tmp
[MAX_PATH
+1];
1250 struct playlist_info
*playlist
;
1257 #ifdef HAVE_DISK_STORAGE
1258 if (global_settings
.disk_spindown
> 1 &&
1259 global_settings
.disk_spindown
<= 5)
1260 sleep_time
= global_settings
.disk_spindown
- 1;
1265 queue_wait_w_tmo(&playlist_queue
, &ev
, HZ
*sleep_time
);
1269 case PLAYLIST_LOAD_POINTERS
:
1270 dirty_pointers
= true;
1273 /* Start the background scanning after either the disk spindown
1274 timeout or 5s, whichever is less */
1276 playlist
= ¤t_playlist
;
1277 if (playlist
->control_fd
>= 0)
1279 if (playlist
->num_cached
> 0)
1280 register_storage_idle_func(playlist_flush_callback
);
1283 if (!dirty_pointers
)
1286 if (!dircache_is_enabled() || !playlist
->filenames
1287 || playlist
->amount
<= 0)
1290 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1293 for (index
= 0; index
< playlist
->amount
1294 && queue_empty(&playlist_queue
); index
++)
1296 /* Process only pointers that are not already loaded. */
1297 if (playlist
->filenames
[index
])
1300 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
1301 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
1303 /* Load the filename from playlist file. */
1304 if (get_filename(playlist
, index
, seek
, control_file
, tmp
,
1308 /* Set the dircache entry pointer. */
1309 playlist
->filenames
[index
] = dircache_get_entry_ptr(tmp
);
1311 /* And be on background so user doesn't notice any delays. */
1315 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1318 dirty_pointers
= false;
1321 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
1322 case SYS_USB_CONNECTED
:
1323 usb_acknowledge(SYS_USB_CONNECTED_ACK
);
1324 usb_wait_for_disconnect(&playlist_queue
);
1333 * gets pathname for track at seek index
1335 static int get_filename(struct playlist_info
* playlist
, int index
, int seek
,
1336 bool control_file
, char *buf
, int buf_length
)
1340 char tmp_buf
[MAX_PATH
+1];
1341 char dir_buf
[MAX_PATH
+1];
1342 bool utf8
= playlist
->utf8
;
1344 if (buf_length
> MAX_PATH
+1)
1345 buf_length
= MAX_PATH
+1;
1347 #ifdef HAVE_DIRCACHE
1348 if (dircache_is_enabled() && playlist
->filenames
)
1350 if (playlist
->filenames
[index
] != NULL
)
1352 dircache_copy_path(playlist
->filenames
[index
], tmp_buf
, sizeof(tmp_buf
)-1);
1353 max
= strlen(tmp_buf
);
1360 if (playlist
->in_ram
&& !control_file
&& max
< 0)
1362 max
= strlcpy(tmp_buf
, &playlist
->buffer
[seek
], sizeof(tmp_buf
));
1366 mutex_lock(&playlist
->control_mutex
);
1370 fd
= playlist
->control_fd
;
1375 if(-1 == playlist
->fd
)
1376 playlist
->fd
= open(playlist
->filename
, O_RDONLY
);
1384 if (lseek(fd
, seek
, SEEK_SET
) != seek
)
1388 max
= read(fd
, tmp_buf
, MIN((size_t) buf_length
, sizeof(tmp_buf
)));
1390 if ((max
> 0) && !utf8
)
1392 /* Use dir_buf as a temporary buffer. Note that dir_buf must
1393 * be as large as tmp_buf.
1395 max
= convert_m3u(tmp_buf
, max
, sizeof(tmp_buf
), dir_buf
);
1400 mutex_unlock(&playlist
->control_mutex
);
1405 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
1407 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
1413 strlcpy(dir_buf
, playlist
->filename
, playlist
->dirlen
);
1415 return (format_track_path(buf
, tmp_buf
, buf_length
, max
, dir_buf
));
1418 static int get_next_directory(char *dir
){
1419 return get_next_dir(dir
,true,false);
1422 static int get_previous_directory(char *dir
){
1423 return get_next_dir(dir
,false,false);
1427 * search through all the directories (starting with the current) to find
1428 * one that has tracks to play
1430 static int get_next_dir(char *dir
, bool is_forward
, bool recursion
)
1432 struct playlist_info
* playlist
= ¤t_playlist
;
1434 char *start_dir
= NULL
;
1437 struct tree_context
* tc
= tree_get_context();
1438 int saved_dirfilter
= *(tc
->dirfilter
);
1440 /* process random folder advance */
1441 if (global_settings
.next_folder
== FOLDER_ADVANCE_RANDOM
)
1443 char folder_advance_list
[MAX_PATH
];
1444 snprintf(folder_advance_list
, sizeof(folder_advance_list
),
1445 "%s/folder_advance_list.dat", ROCKBOX_DIR
);
1446 int fd
= open(folder_advance_list
, O_RDONLY
);
1449 char buffer
[MAX_PATH
];
1450 int folder_count
= 0;
1451 srand(current_tick
);
1452 *(tc
->dirfilter
) = SHOW_MUSIC
;
1453 tc
->sort_dir
= global_settings
.sort_dir
;
1454 read(fd
,&folder_count
,sizeof(int));
1459 i
= rand()%folder_count
;
1460 lseek(fd
,sizeof(int) + (MAX_PATH
*i
),SEEK_SET
);
1461 read(fd
,buffer
,MAX_PATH
);
1462 if (check_subdir_for_music(buffer
, "", false) ==0)
1468 *(tc
->dirfilter
) = saved_dirfilter
;
1469 tc
->sort_dir
= global_settings
.sort_dir
;
1475 /* not random folder advance (or random folder advance unavailable) */
1478 /* start with root */
1483 /* start with current directory */
1484 strlcpy(dir
, playlist
->filename
, playlist
->dirlen
);
1487 /* use the tree browser dircache to load files */
1488 *(tc
->dirfilter
) = SHOW_ALL
;
1490 /* set up sorting/direction */
1491 tc
->sort_dir
= global_settings
.sort_dir
;
1494 static const char sortpairs
[] =
1496 [SORT_ALPHA
] = SORT_ALPHA_REVERSED
,
1497 [SORT_DATE
] = SORT_DATE_REVERSED
,
1498 [SORT_TYPE
] = SORT_TYPE_REVERSED
,
1499 [SORT_ALPHA_REVERSED
] = SORT_ALPHA
,
1500 [SORT_DATE_REVERSED
] = SORT_DATE
,
1501 [SORT_TYPE_REVERSED
] = SORT_TYPE
,
1504 if ((unsigned)tc
->sort_dir
< sizeof(sortpairs
))
1505 tc
->sort_dir
= sortpairs
[tc
->sort_dir
];
1510 struct entry
*files
;
1514 if (ft_load(tc
, (dir
[0]=='\0')?"/":dir
) < 0)
1521 files
= (struct entry
*) tc
->dircache
;
1522 num_files
= tc
->filesindir
;
1524 for (i
=0; i
<num_files
; i
++)
1527 if (action_userabort(TIMEOUT_NOBLOCK
))
1534 if (files
[i
].attr
& ATTR_DIRECTORY
)
1538 result
= check_subdir_for_music(dir
, files
[i
].name
, true);
1545 else if (!strcmp(start_dir
, files
[i
].name
))
1552 /* move down to parent directory. current directory name is
1553 stored as the starting point for the search in parent */
1554 start_dir
= strrchr(dir
, '/');
1565 /* restore dirfilter */
1566 *(tc
->dirfilter
) = saved_dirfilter
;
1567 tc
->sort_dir
= global_settings
.sort_dir
;
1569 /* special case if nothing found: try start searching again from root */
1570 if (result
== -1 && !recursion
){
1571 result
= get_next_dir(dir
, is_forward
, true);
1578 * Checks if there are any music files in the dir or any of its
1579 * subdirectories. May be called recursively.
1581 static int check_subdir_for_music(char *dir
, const char *subdir
, bool recurse
)
1584 int dirlen
= strlen(dir
);
1587 struct entry
*files
;
1588 bool has_music
= false;
1589 bool has_subdir
= false;
1590 struct tree_context
* tc
= tree_get_context();
1592 snprintf(dir
+dirlen
, MAX_PATH
-dirlen
, "/%s", subdir
);
1594 if (ft_load(tc
, dir
) < 0)
1599 files
= (struct entry
*) tc
->dircache
;
1600 num_files
= tc
->filesindir
;
1602 for (i
=0; i
<num_files
; i
++)
1604 if (files
[i
].attr
& ATTR_DIRECTORY
)
1606 else if ((files
[i
].attr
& FILE_ATTR_MASK
) == FILE_ATTR_AUDIO
)
1616 if (has_subdir
&& recurse
)
1618 for (i
=0; i
<num_files
; i
++)
1620 if (action_userabort(TIMEOUT_NOBLOCK
))
1626 if (files
[i
].attr
& ATTR_DIRECTORY
)
1628 result
= check_subdir_for_music(dir
, files
[i
].name
, true);
1646 /* we now need to reload our current directory */
1647 if(ft_load(tc
, dir
) < 0)
1648 splash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
1654 * Returns absolute path of track
1656 static int format_track_path(char *dest
, char *src
, int buf_length
, int max
,
1663 /* Zero-terminate the file name */
1664 while((src
[i
] != '\n') &&
1669 /* Now work back killing white space */
1670 while((src
[i
-1] == ' ') ||
1676 /* replace backslashes with forward slashes */
1677 for ( j
=0; j
<i
; j
++ )
1678 if ( src
[j
] == '\\' )
1683 strlcpy(dest
, src
, buf_length
);
1687 /* handle dos style drive letter */
1689 strlcpy(dest
, &src
[2], buf_length
);
1690 else if (!strncmp(src
, "../", 3))
1692 /* handle relative paths */
1694 while(!strncmp(&src
[i
], "../", 3))
1696 for (j
=0; j
<i
/3; j
++) {
1697 temp_ptr
= strrchr(dir
, '/');
1703 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[i
]);
1705 else if ( '.' == src
[0] && '/' == src
[1] ) {
1706 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[2]);
1709 snprintf(dest
, buf_length
, "%s/%s", dir
, src
);
1717 * Display splash message showing progress of playlist/directory insertion or
1720 static void display_playlist_count(int count
, const unsigned char *fmt
,
1723 static long talked_tick
= 0;
1724 long id
= P2ID(fmt
);
1725 if(global_settings
.talk_menu
&& id
>=0)
1727 if(final
|| (count
&& (talked_tick
== 0
1728 || TIME_AFTER(current_tick
, talked_tick
+5*HZ
))))
1730 talked_tick
= current_tick
;
1731 talk_number(count
, false);
1737 splashf(0, fmt
, count
, str(LANG_OFF_ABORT
));
1741 * Display buffer full message
1743 static void display_buffer_full(void)
1745 splash(HZ
*2, ID2P(LANG_PLAYLIST_BUFFER_FULL
));
1749 * Flush any cached control commands to disk. Called when playlist is being
1750 * modified. Returns 0 on success and -1 on failure.
1752 static int flush_cached_control(struct playlist_info
* playlist
)
1757 if (!playlist
->num_cached
)
1760 lseek(playlist
->control_fd
, 0, SEEK_END
);
1762 for (i
=0; i
<playlist
->num_cached
; i
++)
1764 struct playlist_control_cache
* cache
=
1765 &(playlist
->control_cache
[i
]);
1767 switch (cache
->command
)
1769 case PLAYLIST_COMMAND_PLAYLIST
:
1770 result
= fdprintf(playlist
->control_fd
, "P:%d:%s:%s\n",
1771 cache
->i1
, cache
->s1
, cache
->s2
);
1773 case PLAYLIST_COMMAND_ADD
:
1774 case PLAYLIST_COMMAND_QUEUE
:
1775 result
= fdprintf(playlist
->control_fd
, "%c:%d:%d:",
1776 (cache
->command
== PLAYLIST_COMMAND_ADD
)?'A':'Q',
1777 cache
->i1
, cache
->i2
);
1780 /* save the position in file where name is written */
1781 int* seek_pos
= (int *)cache
->data
;
1782 *seek_pos
= lseek(playlist
->control_fd
, 0, SEEK_CUR
);
1783 result
= fdprintf(playlist
->control_fd
, "%s\n",
1787 case PLAYLIST_COMMAND_DELETE
:
1788 result
= fdprintf(playlist
->control_fd
, "D:%d\n", cache
->i1
);
1790 case PLAYLIST_COMMAND_SHUFFLE
:
1791 result
= fdprintf(playlist
->control_fd
, "S:%d:%d\n",
1792 cache
->i1
, cache
->i2
);
1794 case PLAYLIST_COMMAND_UNSHUFFLE
:
1795 result
= fdprintf(playlist
->control_fd
, "U:%d\n", cache
->i1
);
1797 case PLAYLIST_COMMAND_RESET
:
1798 result
= fdprintf(playlist
->control_fd
, "R\n");
1810 playlist
->num_cached
= 0;
1811 playlist
->pending_control_sync
= true;
1818 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_UPDATE_ERROR
));
1825 * Update control data with new command. Depending on the command, it may be
1826 * cached or flushed to disk.
1828 static int update_control(struct playlist_info
* playlist
,
1829 enum playlist_command command
, int i1
, int i2
,
1830 const char* s1
, const char* s2
, void* data
)
1833 struct playlist_control_cache
* cache
;
1836 mutex_lock(&playlist
->control_mutex
);
1838 cache
= &(playlist
->control_cache
[playlist
->num_cached
++]);
1840 cache
->command
= command
;
1849 case PLAYLIST_COMMAND_PLAYLIST
:
1850 case PLAYLIST_COMMAND_ADD
:
1851 case PLAYLIST_COMMAND_QUEUE
:
1852 #ifndef HAVE_DIRCACHE
1853 case PLAYLIST_COMMAND_DELETE
:
1854 case PLAYLIST_COMMAND_RESET
:
1858 case PLAYLIST_COMMAND_SHUFFLE
:
1859 case PLAYLIST_COMMAND_UNSHUFFLE
:
1861 /* only flush when needed */
1865 if (flush
|| playlist
->num_cached
== PLAYLIST_MAX_CACHE
)
1866 result
= flush_cached_control(playlist
);
1868 mutex_unlock(&playlist
->control_mutex
);
1874 * sync control file to disk
1876 static void sync_control(struct playlist_info
* playlist
, bool force
)
1878 #ifdef HAVE_DIRCACHE
1879 if (playlist
->started
&& force
)
1883 if (playlist
->started
)
1886 if (playlist
->pending_control_sync
)
1888 mutex_lock(&playlist
->control_mutex
);
1889 fsync(playlist
->control_fd
);
1890 playlist
->pending_control_sync
= false;
1891 mutex_unlock(&playlist
->control_mutex
);
1897 * Rotate indices such that first_index is index 0
1899 static int rotate_index(const struct playlist_info
* playlist
, int index
)
1901 index
-= playlist
->first_index
;
1903 index
+= playlist
->amount
;
1909 * Initialize playlist entries at startup
1911 void playlist_init(void)
1913 struct playlist_info
* playlist
= ¤t_playlist
;
1915 playlist
->current
= true;
1916 get_user_file_path(PLAYLIST_CONTROL_FILE
, IS_FILE
|NEED_WRITE
|FORCE_BUFFER_COPY
,
1917 playlist
->control_filename
,
1918 sizeof(playlist
->control_filename
));
1920 playlist
->control_fd
= -1;
1921 playlist
->max_playlist_size
= global_settings
.max_files_in_playlist
;
1922 playlist
->indices
= buffer_alloc(
1923 playlist
->max_playlist_size
* sizeof(int));
1924 playlist
->buffer_size
=
1925 AVERAGE_FILENAME_LENGTH
* global_settings
.max_files_in_dir
;
1926 playlist
->buffer
= buffer_alloc(playlist
->buffer_size
);
1927 mutex_init(&playlist
->control_mutex
);
1928 empty_playlist(playlist
, true);
1930 #ifdef HAVE_DIRCACHE
1931 playlist
->filenames
= buffer_alloc(
1932 playlist
->max_playlist_size
* sizeof(int));
1933 memset(playlist
->filenames
, 0,
1934 playlist
->max_playlist_size
* sizeof(int));
1935 create_thread(playlist_thread
, playlist_stack
, sizeof(playlist_stack
),
1936 0, playlist_thread_name
IF_PRIO(, PRIORITY_BACKGROUND
)
1938 queue_init(&playlist_queue
, true);
1943 * Clean playlist at shutdown
1945 void playlist_shutdown(void)
1947 struct playlist_info
* playlist
= ¤t_playlist
;
1949 if (playlist
->control_fd
>= 0)
1951 mutex_lock(&playlist
->control_mutex
);
1953 if (playlist
->num_cached
> 0)
1954 flush_cached_control(playlist
);
1956 close(playlist
->control_fd
);
1958 mutex_unlock(&playlist
->control_mutex
);
1963 * Create new playlist
1965 int playlist_create(const char *dir
, const char *file
)
1967 struct playlist_info
* playlist
= ¤t_playlist
;
1969 new_playlist(playlist
, dir
, file
);
1972 /* load the playlist file */
1973 add_indices_to_playlist(playlist
, NULL
, 0);
1978 #define PLAYLIST_COMMAND_SIZE (MAX_PATH+12)
1981 * Restore the playlist state based on control file commands. Called to
1982 * resume playback after shutdown.
1984 int playlist_resume(void)
1986 struct playlist_info
* playlist
= ¤t_playlist
;
1991 int control_file_size
= 0;
1995 /* use mp3 buffer for maximum load speed */
1996 #if CONFIG_CODEC != SWCODEC
1997 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
1998 buflen
= (audiobufend
- audiobuf
);
1999 buffer
= (char *)audiobuf
;
2001 buffer
= (char *)audio_get_buffer(false, &buflen
);
2004 empty_playlist(playlist
, true);
2006 splash(0, ID2P(LANG_WAIT
));
2007 playlist
->control_fd
= open(playlist
->control_filename
, O_RDWR
);
2008 if (playlist
->control_fd
< 0)
2010 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2013 playlist
->control_created
= true;
2015 control_file_size
= filesize(playlist
->control_fd
);
2016 if (control_file_size
<= 0)
2018 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2022 /* read a small amount first to get the header */
2023 nread
= read(playlist
->control_fd
, buffer
,
2024 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
2027 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2031 playlist
->started
= true;
2037 enum playlist_command current_command
= PLAYLIST_COMMAND_COMMENT
;
2038 int last_newline
= 0;
2040 bool newline
= true;
2041 bool exit_loop
= false;
2046 unsigned long last_tick
= current_tick
;
2047 bool useraborted
= false;
2049 for(count
=0; count
<nread
&& !exit_loop
&& !useraborted
; count
++,p
++)
2051 /* So a splash while we are loading. */
2052 if (TIME_AFTER(current_tick
, last_tick
+ HZ
/4))
2054 splashf(0, str(LANG_LOADING_PERCENT
),
2055 (total_read
+count
)*100/control_file_size
,
2056 str(LANG_OFF_ABORT
));
2057 if (action_userabort(TIMEOUT_NOBLOCK
))
2062 last_tick
= current_tick
;
2065 /* Are we on a new line? */
2066 if((*p
== '\n') || (*p
== '\r'))
2070 /* save last_newline in case we need to load more data */
2071 last_newline
= count
;
2073 switch (current_command
)
2075 case PLAYLIST_COMMAND_PLAYLIST
:
2077 /* str1=version str2=dir str3=file */
2093 version
= atoi(str1
);
2095 if (version
!= PLAYLIST_CONTROL_FILE_VERSION
)
2098 update_playlist_filename(playlist
, str2
, str3
);
2100 if (str3
[0] != '\0')
2102 /* NOTE: add_indices_to_playlist() overwrites the
2103 audiobuf so we need to reload control file
2105 add_indices_to_playlist(playlist
, NULL
, 0);
2107 else if (str2
[0] != '\0')
2109 playlist
->in_ram
= true;
2110 resume_directory(str2
);
2113 /* load the rest of the data */
2119 case PLAYLIST_COMMAND_ADD
:
2120 case PLAYLIST_COMMAND_QUEUE
:
2122 /* str1=position str2=last_position str3=file */
2123 int position
, last_position
;
2126 if (!str1
|| !str2
|| !str3
)
2133 position
= atoi(str1
);
2134 last_position
= atoi(str2
);
2136 queue
= (current_command
== PLAYLIST_COMMAND_ADD
)?
2139 /* seek position is based on str3's position in
2141 if (add_track_to_playlist(playlist
, str3
, position
,
2142 queue
, total_read
+(str3
-buffer
)) < 0)
2145 playlist
->last_insert_pos
= last_position
;
2149 case PLAYLIST_COMMAND_DELETE
:
2161 position
= atoi(str1
);
2163 if (remove_track_from_playlist(playlist
, position
,
2169 case PLAYLIST_COMMAND_SHUFFLE
:
2171 /* str1=seed str2=first_index */
2183 /* Always sort list before shuffling */
2184 sort_playlist(playlist
, false, false);
2188 playlist
->first_index
= atoi(str2
);
2190 if (randomise_playlist(playlist
, seed
, false,
2196 case PLAYLIST_COMMAND_UNSHUFFLE
:
2198 /* str1=first_index */
2206 playlist
->first_index
= atoi(str1
);
2208 if (sort_playlist(playlist
, false, false) < 0)
2214 case PLAYLIST_COMMAND_RESET
:
2216 playlist
->last_insert_pos
= -1;
2219 case PLAYLIST_COMMAND_COMMENT
:
2226 /* to ignore any extra newlines */
2227 current_command
= PLAYLIST_COMMAND_COMMENT
;
2233 /* first non-comment line must always specify playlist */
2234 if (first
&& *p
!= 'P' && *p
!= '#')
2244 /* playlist can only be specified once */
2252 current_command
= PLAYLIST_COMMAND_PLAYLIST
;
2255 current_command
= PLAYLIST_COMMAND_ADD
;
2258 current_command
= PLAYLIST_COMMAND_QUEUE
;
2261 current_command
= PLAYLIST_COMMAND_DELETE
;
2264 current_command
= PLAYLIST_COMMAND_SHUFFLE
;
2267 current_command
= PLAYLIST_COMMAND_UNSHUFFLE
;
2270 current_command
= PLAYLIST_COMMAND_RESET
;
2273 current_command
= PLAYLIST_COMMAND_COMMENT
;
2286 else if(current_command
!= PLAYLIST_COMMAND_COMMENT
)
2288 /* all control file strings are separated with a colon.
2289 Replace the colon with 0 to get proper strings that can be
2290 used by commands above */
2296 if ((count
+1) < nread
)
2310 /* allow last string to contain colons */
2321 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID
));
2327 splash(HZ
*2, ID2P(LANG_CANCEL
));
2330 if (!newline
|| (exit_loop
&& count
<nread
))
2332 if ((total_read
+ count
) >= control_file_size
)
2334 /* no newline at end of control file */
2335 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID
));
2339 /* We didn't end on a newline or we exited loop prematurely.
2340 Either way, re-read the remainder. */
2341 count
= last_newline
;
2342 lseek(playlist
->control_fd
, total_read
+count
, SEEK_SET
);
2345 total_read
+= count
;
2348 /* still looking for header */
2349 nread
= read(playlist
->control_fd
, buffer
,
2350 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
2352 nread
= read(playlist
->control_fd
, buffer
, buflen
);
2354 /* Terminate on EOF */
2361 #ifdef HAVE_DIRCACHE
2362 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2369 * Add track to in_ram playlist. Used when playing directories.
2371 int playlist_add(const char *filename
)
2373 struct playlist_info
* playlist
= ¤t_playlist
;
2374 int len
= strlen(filename
);
2376 if((len
+1 > playlist
->buffer_size
- playlist
->buffer_end_pos
) ||
2377 (playlist
->amount
>= playlist
->max_playlist_size
))
2379 display_buffer_full();
2383 playlist
->indices
[playlist
->amount
] = playlist
->buffer_end_pos
;
2384 #ifdef HAVE_DIRCACHE
2385 playlist
->filenames
[playlist
->amount
] = NULL
;
2389 strcpy(&playlist
->buffer
[playlist
->buffer_end_pos
], filename
);
2390 playlist
->buffer_end_pos
+= len
;
2391 playlist
->buffer
[playlist
->buffer_end_pos
++] = '\0';
2396 /* shuffle newly created playlist using random seed. */
2397 int playlist_shuffle(int random_seed
, int start_index
)
2399 struct playlist_info
* playlist
= ¤t_playlist
;
2401 unsigned int seek_pos
= 0;
2402 bool start_current
= false;
2404 if (start_index
>= 0 && global_settings
.play_selected
)
2406 /* store the seek position before the shuffle */
2407 seek_pos
= playlist
->indices
[start_index
];
2408 playlist
->index
= playlist
->first_index
= start_index
;
2409 start_current
= true;
2412 randomise_playlist(playlist
, random_seed
, start_current
, true);
2414 return playlist
->index
;
2417 /* start playing current playlist at specified index/offset */
2418 void playlist_start(int start_index
, int offset
)
2420 struct playlist_info
* playlist
= ¤t_playlist
;
2422 /* Cancel FM radio selection as previous music. For cases where we start
2423 playback without going to the WPS, such as playlist insert.. or
2424 playlist catalog. */
2425 previous_music_is_wps();
2427 playlist
->index
= start_index
;
2429 #if CONFIG_CODEC != SWCODEC
2430 talk_buffer_steal(); /* will use the mp3 buffer */
2433 playlist
->started
= true;
2434 sync_control(playlist
, false);
2438 /* Returns false if 'steps' is out of bounds, else true */
2439 bool playlist_check(int steps
)
2441 struct playlist_info
* playlist
= ¤t_playlist
;
2443 /* always allow folder navigation */
2444 if (global_settings
.next_folder
&& playlist
->in_ram
)
2447 int index
= get_next_index(playlist
, steps
, -1);
2449 if (index
< 0 && steps
>= 0 && global_settings
.repeat_mode
== REPEAT_SHUFFLE
)
2450 index
= get_next_index(playlist
, steps
, REPEAT_ALL
);
2452 return (index
>= 0);
2455 /* get trackname of track that is "steps" away from current playing track.
2456 NULL is used to identify end of playlist */
2457 const char* playlist_peek(int steps
)
2459 struct playlist_info
* playlist
= ¤t_playlist
;
2465 index
= get_next_index(playlist
, steps
, -1);
2469 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
2470 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
2472 if (get_filename(playlist
, index
, seek
, control_file
, now_playing
,
2476 temp_ptr
= now_playing
;
2478 if (!playlist
->in_ram
|| control_file
)
2480 /* remove bogus dirs from beginning of path
2481 (workaround for buggy playlist creation tools) */
2484 if (file_exists(temp_ptr
))
2487 temp_ptr
= strchr(temp_ptr
+1, '/');
2492 /* Even though this is an invalid file, we still need to pass a
2493 file name to the caller because NULL is used to indicate end
2503 * Update indices as track has changed
2505 int playlist_next(int steps
)
2507 struct playlist_info
* playlist
= ¤t_playlist
;
2511 #ifdef AB_REPEAT_ENABLE
2512 && (global_settings
.repeat_mode
!= REPEAT_AB
)
2514 && (global_settings
.repeat_mode
!= REPEAT_ONE
) )
2518 /* We need to delete all the queued songs */
2519 for (i
=0, j
=steps
; i
<j
; i
++)
2521 index
= get_next_index(playlist
, i
, -1);
2523 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
2525 remove_track_from_playlist(playlist
, index
, true);
2526 steps
--; /* one less track */
2531 index
= get_next_index(playlist
, steps
, -1);
2535 /* end of playlist... or is it */
2536 if (global_settings
.repeat_mode
== REPEAT_SHUFFLE
&&
2537 playlist
->amount
> 1)
2539 /* Repeat shuffle mode. Re-shuffle playlist and resume play */
2540 playlist
->first_index
= 0;
2541 sort_playlist(playlist
, false, false);
2542 randomise_playlist(playlist
, current_tick
, false, true);
2543 #if CONFIG_CODEC != SWCODEC
2544 playlist_start(0, 0);
2546 playlist
->index
= 0;
2549 else if (playlist
->in_ram
&& global_settings
.next_folder
)
2551 index
= create_and_play_dir(steps
, true);
2555 playlist
->index
= index
;
2562 playlist
->index
= index
;
2564 if (playlist
->last_insert_pos
>= 0 && steps
> 0)
2566 /* check to see if we've gone beyond the last inserted track */
2567 int cur
= rotate_index(playlist
, index
);
2568 int last_pos
= rotate_index(playlist
, playlist
->last_insert_pos
);
2572 /* reset last inserted track */
2573 playlist
->last_insert_pos
= -1;
2575 if (playlist
->control_fd
>= 0)
2577 int result
= update_control(playlist
, PLAYLIST_COMMAND_RESET
,
2578 -1, -1, NULL
, NULL
, NULL
);
2583 sync_control(playlist
, false);
2591 /* try playing next or previous folder */
2592 bool playlist_next_dir(int direction
)
2594 /* not to mess up real playlists */
2595 if(!current_playlist
.in_ram
)
2598 return create_and_play_dir(direction
, false) >= 0;
2601 /* Get resume info for current playing song. If return value is -1 then
2602 settings shouldn't be saved. */
2603 int playlist_get_resume_info(int *resume_index
)
2605 struct playlist_info
* playlist
= ¤t_playlist
;
2607 *resume_index
= playlist
->index
;
2612 /* Update resume info for current playing song. Returns -1 on error. */
2613 int playlist_update_resume_info(const struct mp3entry
* id3
)
2615 struct playlist_info
* playlist
= ¤t_playlist
;
2619 if (global_status
.resume_index
!= playlist
->index
||
2620 global_status
.resume_offset
!= id3
->offset
)
2622 global_status
.resume_index
= playlist
->index
;
2623 global_status
.resume_offset
= id3
->offset
;
2629 global_status
.resume_index
= -1;
2630 global_status
.resume_offset
= -1;
2637 /* Returns index of current playing track for display purposes. This value
2638 should not be used for resume purposes as it doesn't represent the actual
2639 index into the playlist */
2640 int playlist_get_display_index(void)
2642 struct playlist_info
* playlist
= ¤t_playlist
;
2644 /* first_index should always be index 0 for display purposes */
2645 int index
= rotate_index(playlist
, playlist
->index
);
2650 /* returns number of tracks in current playlist */
2651 int playlist_amount(void)
2653 return playlist_amount_ex(NULL
);
2655 /* set playlist->last_shuffle_start to playlist->amount for
2656 PLAYLIST_INSERT_LAST_SHUFFLED command purposes*/
2657 void playlist_set_last_shuffled_start(void)
2659 struct playlist_info
* playlist
= ¤t_playlist
;
2660 playlist
->last_shuffled_start
= playlist
->amount
;
2663 * Create a new playlist If playlist is not NULL then we're loading a
2664 * playlist off disk for viewing/editing. The index_buffer is used to store
2665 * playlist indices (required for and only used if !current playlist). The
2666 * temp_buffer (if not NULL) is used as a scratchpad when loading indices.
2668 int playlist_create_ex(struct playlist_info
* playlist
,
2669 const char* dir
, const char* file
,
2670 void* index_buffer
, int index_buffer_size
,
2671 void* temp_buffer
, int temp_buffer_size
)
2674 playlist
= ¤t_playlist
;
2677 /* Initialize playlist structure */
2678 int r
= rand() % 10;
2679 playlist
->current
= false;
2681 /* Use random name for control file */
2682 snprintf(playlist
->control_filename
, sizeof(playlist
->control_filename
),
2683 "%s.%d", PLAYLIST_CONTROL_FILE
, r
);
2685 playlist
->control_fd
= -1;
2689 int num_indices
= index_buffer_size
/ sizeof(int);
2691 #ifdef HAVE_DIRCACHE
2694 if (num_indices
> global_settings
.max_files_in_playlist
)
2695 num_indices
= global_settings
.max_files_in_playlist
;
2697 playlist
->max_playlist_size
= num_indices
;
2698 playlist
->indices
= index_buffer
;
2699 #ifdef HAVE_DIRCACHE
2700 playlist
->filenames
= (const struct dircache_entry
**)
2701 &playlist
->indices
[num_indices
];
2706 playlist
->max_playlist_size
= current_playlist
.max_playlist_size
;
2707 playlist
->indices
= current_playlist
.indices
;
2708 #ifdef HAVE_DIRCACHE
2709 playlist
->filenames
= current_playlist
.filenames
;
2713 playlist
->buffer_size
= 0;
2714 playlist
->buffer
= NULL
;
2715 mutex_init(&playlist
->control_mutex
);
2718 new_playlist(playlist
, dir
, file
);
2721 /* load the playlist file */
2722 add_indices_to_playlist(playlist
, temp_buffer
, temp_buffer_size
);
2728 * Set the specified playlist as the current.
2729 * NOTE: You will get undefined behaviour if something is already playing so
2730 * remember to stop before calling this. Also, this call will
2731 * effectively close your playlist, making it unusable.
2733 int playlist_set_current(struct playlist_info
* playlist
)
2735 if (!playlist
|| (check_control(playlist
) < 0))
2738 empty_playlist(¤t_playlist
, false);
2740 strlcpy(current_playlist
.filename
, playlist
->filename
,
2741 sizeof(current_playlist
.filename
));
2743 current_playlist
.utf8
= playlist
->utf8
;
2744 current_playlist
.fd
= playlist
->fd
;
2746 close(playlist
->control_fd
);
2747 close(current_playlist
.control_fd
);
2748 remove(current_playlist
.control_filename
);
2749 if (rename(playlist
->control_filename
,
2750 current_playlist
.control_filename
) < 0)
2752 current_playlist
.control_fd
= open(current_playlist
.control_filename
,
2754 if (current_playlist
.control_fd
< 0)
2756 current_playlist
.control_created
= true;
2758 current_playlist
.dirlen
= playlist
->dirlen
;
2760 if (playlist
->indices
&& playlist
->indices
!= current_playlist
.indices
)
2762 memcpy(current_playlist
.indices
, playlist
->indices
,
2763 playlist
->max_playlist_size
*sizeof(int));
2764 #ifdef HAVE_DIRCACHE
2765 memcpy(current_playlist
.filenames
, playlist
->filenames
,
2766 playlist
->max_playlist_size
*sizeof(int));
2770 current_playlist
.first_index
= playlist
->first_index
;
2771 current_playlist
.amount
= playlist
->amount
;
2772 current_playlist
.last_insert_pos
= playlist
->last_insert_pos
;
2773 current_playlist
.seed
= playlist
->seed
;
2774 current_playlist
.shuffle_modified
= playlist
->shuffle_modified
;
2775 current_playlist
.deleted
= playlist
->deleted
;
2776 current_playlist
.num_inserted_tracks
= playlist
->num_inserted_tracks
;
2778 memcpy(current_playlist
.control_cache
, playlist
->control_cache
,
2779 sizeof(current_playlist
.control_cache
));
2780 current_playlist
.num_cached
= playlist
->num_cached
;
2781 current_playlist
.pending_control_sync
= playlist
->pending_control_sync
;
2785 struct playlist_info
*playlist_get_current(void)
2787 return ¤t_playlist
;
2790 * Close files and delete control file for non-current playlist.
2792 void playlist_close(struct playlist_info
* playlist
)
2797 if (playlist
->fd
>= 0)
2798 close(playlist
->fd
);
2800 if (playlist
->control_fd
>= 0)
2801 close(playlist
->control_fd
);
2803 if (playlist
->control_created
)
2804 remove(playlist
->control_filename
);
2807 void playlist_sync(struct playlist_info
* playlist
)
2810 playlist
= ¤t_playlist
;
2812 sync_control(playlist
, false);
2813 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2814 audio_flush_and_reload_tracks();
2816 #ifdef HAVE_DIRCACHE
2817 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2822 * Insert track into playlist at specified position (or one of the special
2823 * positions). Returns position where track was inserted or -1 if error.
2825 int playlist_insert_track(struct playlist_info
* playlist
, const char *filename
,
2826 int position
, bool queue
, bool sync
)
2831 playlist
= ¤t_playlist
;
2833 if (check_control(playlist
) < 0)
2835 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2839 result
= add_track_to_playlist(playlist
, filename
, position
, queue
, -1);
2841 /* Check if we want manually sync later. For example when adding
2842 * bunch of files from tagcache, syncing after every file wouldn't be
2843 * a good thing to do. */
2844 if (sync
&& result
>= 0)
2845 playlist_sync(playlist
);
2851 * Insert all tracks from specified directory into playlist.
2853 int playlist_insert_directory(struct playlist_info
* playlist
,
2854 const char *dirname
, int position
, bool queue
,
2858 unsigned char *count_str
;
2859 struct directory_search_context context
;
2862 playlist
= ¤t_playlist
;
2864 if (check_control(playlist
) < 0)
2866 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2870 if (position
== PLAYLIST_REPLACE
)
2872 if (playlist_remove_all_tracks(playlist
) == 0)
2873 position
= PLAYLIST_INSERT_LAST
;
2879 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
2881 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
2883 display_playlist_count(0, count_str
, false);
2885 context
.playlist
= playlist
;
2886 context
.position
= position
;
2887 context
.queue
= queue
;
2892 result
= playlist_directory_tracksearch(dirname
, recurse
,
2893 directory_search_callback
, &context
);
2895 sync_control(playlist
, false);
2899 display_playlist_count(context
.count
, count_str
, true);
2901 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2902 audio_flush_and_reload_tracks();
2904 #ifdef HAVE_DIRCACHE
2905 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2912 * Insert all tracks from specified playlist into dynamic playlist.
2914 int playlist_insert_playlist(struct playlist_info
* playlist
, const char *filename
,
2915 int position
, bool queue
)
2921 unsigned char *count_str
;
2922 char temp_buf
[MAX_PATH
+1];
2923 char trackname
[MAX_PATH
+1];
2926 bool utf8
= is_m3u8(filename
);
2929 playlist
= ¤t_playlist
;
2931 if (check_control(playlist
) < 0)
2933 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2937 fd
= open_utf8(filename
, O_RDONLY
);
2940 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
2944 /* we need the directory name for formatting purposes */
2947 temp_ptr
= strrchr(filename
+1,'/');
2954 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
2956 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
2958 display_playlist_count(count
, count_str
, false);
2960 if (position
== PLAYLIST_REPLACE
)
2962 if (playlist_remove_all_tracks(playlist
) == 0)
2963 position
= PLAYLIST_INSERT_LAST
;
2969 while ((max
= read_line(fd
, temp_buf
, sizeof(temp_buf
))) > 0)
2972 if (action_userabort(TIMEOUT_NOBLOCK
))
2975 if (temp_buf
[0] != '#' && temp_buf
[0] != '\0')
2981 /* Use trackname as a temporay buffer. Note that trackname must
2982 * be as large as temp_buf.
2984 max
= convert_m3u(temp_buf
, max
, sizeof(temp_buf
), trackname
);
2987 /* we need to format so that relative paths are correctly
2989 if (format_track_path(trackname
, temp_buf
, sizeof(trackname
), max
,
2996 insert_pos
= add_track_to_playlist(playlist
, trackname
, position
,
3005 /* Make sure tracks are inserted in correct order if user
3006 requests INSERT_FIRST */
3007 if (position
== PLAYLIST_INSERT_FIRST
|| position
>= 0)
3008 position
= insert_pos
+ 1;
3012 if ((count
%PLAYLIST_DISPLAY_COUNT
) == 0)
3014 display_playlist_count(count
, count_str
, false);
3016 if (count
== PLAYLIST_DISPLAY_COUNT
&&
3017 (audio_status() & AUDIO_STATUS_PLAY
) &&
3019 audio_flush_and_reload_tracks();
3023 /* let the other threads work */
3032 sync_control(playlist
, false);
3036 display_playlist_count(count
, count_str
, true);
3038 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3039 audio_flush_and_reload_tracks();
3041 #ifdef HAVE_DIRCACHE
3042 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3049 * Delete track at specified index. If index is PLAYLIST_DELETE_CURRENT then
3050 * we want to delete the current playing track.
3052 int playlist_delete(struct playlist_info
* playlist
, int index
)
3057 playlist
= ¤t_playlist
;
3059 if (check_control(playlist
) < 0)
3061 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3065 if (index
== PLAYLIST_DELETE_CURRENT
)
3066 index
= playlist
->index
;
3068 result
= remove_track_from_playlist(playlist
, index
, true);
3070 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3072 audio_flush_and_reload_tracks();
3078 * Move track at index to new_index. Tracks between the two are shifted
3079 * appropriately. Returns 0 on success and -1 on failure.
3081 int playlist_move(struct playlist_info
* playlist
, int index
, int new_index
)
3087 bool current
= false;
3089 char filename
[MAX_PATH
];
3092 playlist
= ¤t_playlist
;
3094 if (check_control(playlist
) < 0)
3096 splash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3100 if (index
== new_index
)
3103 if (index
== playlist
->index
)
3104 /* Moving the current track */
3107 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3108 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3109 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3111 if (get_filename(playlist
, index
, seek
, control_file
, filename
,
3112 sizeof(filename
)) < 0)
3115 /* We want to insert the track at the position that was specified by
3116 new_index. This may be different then new_index because of the
3117 shifting that will occur after the delete.
3118 We calculate this before we do the remove as it depends on the
3119 size of the playlist before the track removal */
3120 r
= rotate_index(playlist
, new_index
);
3122 /* Delete track from original position */
3123 result
= remove_track_from_playlist(playlist
, index
, true);
3129 new_index
= PLAYLIST_PREPEND
;
3130 else if (r
== playlist
->amount
)
3132 new_index
= PLAYLIST_INSERT_LAST
;
3134 /* Calculate index of desired position */
3135 new_index
= (r
+playlist
->first_index
)%playlist
->amount
;
3137 result
= add_track_to_playlist(playlist
, filename
, new_index
, queue
,
3144 /* Moved the current track */
3147 case PLAYLIST_PREPEND
:
3148 playlist
->index
= playlist
->first_index
;
3150 case PLAYLIST_INSERT_LAST
:
3151 playlist
->index
= playlist
->first_index
- 1;
3152 if (playlist
->index
< 0)
3153 playlist
->index
+= playlist
->amount
;
3156 playlist
->index
= new_index
;
3161 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3162 audio_flush_and_reload_tracks();
3166 #ifdef HAVE_DIRCACHE
3167 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3173 /* shuffle currently playing playlist */
3174 int playlist_randomise(struct playlist_info
* playlist
, unsigned int seed
,
3180 playlist
= ¤t_playlist
;
3182 check_control(playlist
);
3184 result
= randomise_playlist(playlist
, seed
, start_current
, true);
3186 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3188 audio_flush_and_reload_tracks();
3193 /* sort currently playing playlist */
3194 int playlist_sort(struct playlist_info
* playlist
, bool start_current
)
3199 playlist
= ¤t_playlist
;
3201 check_control(playlist
);
3203 result
= sort_playlist(playlist
, start_current
, true);
3205 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3207 audio_flush_and_reload_tracks();
3212 /* returns true if playlist has been modified */
3213 bool playlist_modified(const struct playlist_info
* playlist
)
3216 playlist
= ¤t_playlist
;
3218 if (playlist
->shuffle_modified
||
3219 playlist
->deleted
||
3220 playlist
->num_inserted_tracks
> 0)
3226 /* returns index of first track in playlist */
3227 int playlist_get_first_index(const struct playlist_info
* playlist
)
3230 playlist
= ¤t_playlist
;
3232 return playlist
->first_index
;
3235 /* returns shuffle seed of playlist */
3236 int playlist_get_seed(const struct playlist_info
* playlist
)
3239 playlist
= ¤t_playlist
;
3241 return playlist
->seed
;
3244 /* returns number of tracks in playlist (includes queued/inserted tracks) */
3245 int playlist_amount_ex(const struct playlist_info
* playlist
)
3248 playlist
= ¤t_playlist
;
3250 return playlist
->amount
;
3253 /* returns full path of playlist (minus extension) */
3254 char *playlist_name(const struct playlist_info
* playlist
, char *buf
,
3260 playlist
= ¤t_playlist
;
3262 strlcpy(buf
, playlist
->filename
+playlist
->dirlen
, buf_size
);
3267 /* Remove extension */
3268 sep
= strrchr(buf
, '.');
3275 /* returns the playlist filename */
3276 char *playlist_get_name(const struct playlist_info
* playlist
, char *buf
,
3280 playlist
= ¤t_playlist
;
3282 strlcpy(buf
, playlist
->filename
, buf_size
);
3290 /* Fills info structure with information about track at specified index.
3291 Returns 0 on success and -1 on failure */
3292 int playlist_get_track_info(struct playlist_info
* playlist
, int index
,
3293 struct playlist_track_info
* info
)
3299 playlist
= ¤t_playlist
;
3301 if (index
< 0 || index
>= playlist
->amount
)
3304 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3305 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3307 if (get_filename(playlist
, index
, seek
, control_file
, info
->filename
,
3308 sizeof(info
->filename
)) < 0)
3315 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
3316 info
->attr
|= PLAYLIST_ATTR_QUEUED
;
3318 info
->attr
|= PLAYLIST_ATTR_INSERTED
;
3322 if (playlist
->indices
[index
] & PLAYLIST_SKIPPED
)
3323 info
->attr
|= PLAYLIST_ATTR_SKIPPED
;
3325 info
->index
= index
;
3326 info
->display_index
= rotate_index(playlist
, index
) + 1;
3331 /* save the current dynamic playlist to specified file */
3332 int playlist_save(struct playlist_info
* playlist
, char *filename
)
3337 char path
[MAX_PATH
+1];
3338 char tmp_buf
[MAX_PATH
+1];
3340 bool overwrite_current
= false;
3341 int* index_buf
= NULL
;
3344 playlist
= ¤t_playlist
;
3346 if (playlist
->amount
<= 0)
3349 /* use current working directory as base for pathname */
3350 if (format_track_path(path
, filename
, sizeof(tmp_buf
),
3351 strlen(filename
)+1, getcwd(NULL
, -1)) < 0)
3354 if (!strncmp(playlist
->filename
, path
, strlen(path
)))
3356 /* Attempting to overwrite current playlist file.*/
3358 if (playlist
->buffer_size
< (int)(playlist
->amount
* sizeof(int)))
3360 /* not enough buffer space to store updated indices */
3361 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3365 /* in_ram buffer is unused for m3u files so we'll use for storing
3367 index_buf
= (int*)playlist
->buffer
;
3369 /* use temporary pathname */
3370 snprintf(path
, sizeof(path
), "%s_temp", playlist
->filename
);
3371 overwrite_current
= true;
3376 fd
= open_utf8(path
, O_CREAT
|O_WRONLY
|O_TRUNC
);
3380 /* some applications require a BOM to read the file properly */
3381 fd
= open(path
, O_CREAT
|O_WRONLY
|O_TRUNC
, 0666);
3385 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3389 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
), false);
3393 index
= playlist
->first_index
;
3394 for (i
=0; i
<playlist
->amount
; i
++)
3401 if (action_userabort(TIMEOUT_NOBLOCK
))
3407 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3408 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3409 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3411 /* Don't save queued files */
3414 if (get_filename(playlist
, index
, seek
, control_file
, tmp_buf
,
3421 if (overwrite_current
)
3422 index_buf
[count
] = lseek(fd
, 0, SEEK_CUR
);
3424 if (fdprintf(fd
, "%s\n", tmp_buf
) < 0)
3426 splash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3433 if ((count
% PLAYLIST_DISPLAY_COUNT
) == 0)
3434 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
),
3440 index
= (index
+1)%playlist
->amount
;
3443 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
), true);
3447 if (overwrite_current
&& result
>= 0)
3451 mutex_lock(&playlist
->control_mutex
);
3453 /* Replace the current playlist with the new one and update indices */
3454 close(playlist
->fd
);
3455 if (remove(playlist
->filename
) >= 0)
3457 if (rename(path
, playlist
->filename
) >= 0)
3459 playlist
->fd
= open_utf8(playlist
->filename
, O_RDONLY
);
3460 if (playlist
->fd
>= 0)
3462 index
= playlist
->first_index
;
3463 for (i
=0, count
=0; i
<playlist
->amount
; i
++)
3465 if (!(playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
))
3467 playlist
->indices
[index
] = index_buf
[count
];
3470 index
= (index
+1)%playlist
->amount
;
3473 /* we need to recreate control because inserted tracks are
3474 now part of the playlist and shuffle has been
3476 result
= recreate_control(playlist
);
3481 mutex_unlock(&playlist
->control_mutex
);
3491 * Search specified directory for tracks and notify via callback. May be
3492 * called recursively.
3494 int playlist_directory_tracksearch(const char* dirname
, bool recurse
,
3495 int (*callback
)(char*, void*),
3498 char buf
[MAX_PATH
+1];
3502 struct entry
*files
;
3503 struct tree_context
* tc
= tree_get_context();
3504 int old_dirfilter
= *(tc
->dirfilter
);
3509 /* use the tree browser dircache to load files */
3510 *(tc
->dirfilter
) = SHOW_ALL
;
3512 if (ft_load(tc
, dirname
) < 0)
3514 splash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
3515 *(tc
->dirfilter
) = old_dirfilter
;
3519 files
= (struct entry
*) tc
->dircache
;
3520 num_files
= tc
->filesindir
;
3522 /* we've overwritten the dircache so tree browser will need to be
3526 for (i
=0; i
<num_files
; i
++)
3529 if (action_userabort(TIMEOUT_NOBLOCK
))
3535 if (files
[i
].attr
& ATTR_DIRECTORY
)
3539 /* recursively add directories */
3540 snprintf(buf
, sizeof(buf
), "%s/%s", dirname
, files
[i
].name
);
3541 result
= playlist_directory_tracksearch(buf
, recurse
,
3546 /* we now need to reload our current directory */
3547 if(ft_load(tc
, dirname
) < 0)
3553 files
= (struct entry
*) tc
->dircache
;
3554 num_files
= tc
->filesindir
;
3564 else if ((files
[i
].attr
& FILE_ATTR_MASK
) == FILE_ATTR_AUDIO
)
3566 snprintf(buf
, sizeof(buf
), "%s/%s", dirname
, files
[i
].name
);
3568 if (callback(buf
, context
) != 0)
3574 /* let the other threads work */
3579 /* restore dirfilter */
3580 *(tc
->dirfilter
) = old_dirfilter
;