1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2002 by wavey@wavey.org
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version 2
15 * of the License, or (at your option) any later version.
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
20 ****************************************************************************/
23 Dynamic playlist design (based on design originally proposed by ricII)
25 There are two files associated with a dynamic playlist:
26 1. Playlist file : This file contains the initial songs in the playlist.
27 The file is created by the user and stored on the hard
28 drive. NOTE: If we are playing the contents of a
29 directory, there will be no playlist file.
30 2. Control file : This file is automatically created when a playlist is
31 started and contains all the commands done to it.
33 The first non-comment line in a control file must begin with
34 "P:VERSION:DIR:FILE" where VERSION is the playlist control file version,
35 DIR is the directory where the playlist is located and FILE is the
36 playlist filename. For dirplay, FILE will be empty. An empty playlist
37 will have both entries as null.
39 Control file commands:
40 a. Add track (A:<position>:<last position>:<path to track>)
41 - Insert a track at the specified position in the current
42 playlist. Last position is used to specify where last insertion
44 b. Queue track (Q:<position>:<last position>:<path to track>)
45 - Queue a track at the specified position in the current
46 playlist. Queued tracks differ from added tracks in that they
47 are deleted from the playlist as soon as they are played and
48 they are not saved to disk as part of the playlist.
49 c. Delete track (D:<position>)
50 - Delete track from specified position in the current playlist.
51 d. Shuffle playlist (S:<seed>:<index>)
52 - Shuffle entire playlist with specified seed. The index
53 identifies the first index in the newly shuffled playlist
54 (needed for repeat mode).
55 e. Unshuffle playlist (U:<index>)
56 - Unshuffle entire playlist. The index identifies the first index
57 in the newly unshuffled playlist.
58 f. Reset last insert position (R)
59 - Needed so that insertions work properly after resume
62 The only resume info that needs to be saved is the current index in the
63 playlist and the position in the track. When resuming, all the commands
64 in the control file will be reapplied so that the playlist indices are
65 exactly the same as before shutdown. To avoid unnecessary disk
66 accesses, the shuffle mode settings are also saved in settings and only
67 flushed to disk when required.
75 #include "ata_idle_notify.h"
86 #include "applimits.h"
95 #include "filetypes.h"
96 #ifdef HAVE_LCD_BITMAP
103 #include "rbunicode.h"
104 #include "root_menu.h"
106 #define PLAYLIST_CONTROL_FILE ROCKBOX_DIR "/.playlist_control"
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 #define PLAYLIST_DISPLAY_COUNT 10
141 struct directory_search_context
{
142 struct playlist_info
* playlist
;
148 static struct playlist_info current_playlist
;
149 static char now_playing
[MAX_PATH
+1];
151 static void empty_playlist(struct playlist_info
* playlist
, bool resume
);
152 static void new_playlist(struct playlist_info
* playlist
, const char *dir
,
154 static void create_control(struct playlist_info
* playlist
);
155 static int check_control(struct playlist_info
* playlist
);
156 static int recreate_control(struct playlist_info
* playlist
);
157 static void update_playlist_filename(struct playlist_info
* playlist
,
158 const char *dir
, const char *file
);
159 static int add_indices_to_playlist(struct playlist_info
* playlist
,
160 char* buffer
, size_t buflen
);
161 static int add_track_to_playlist(struct playlist_info
* playlist
,
162 const char *filename
, int position
,
163 bool queue
, int seek_pos
);
164 static int directory_search_callback(char* filename
, void* context
);
165 static int remove_track_from_playlist(struct playlist_info
* playlist
,
166 int position
, bool write
);
167 static int randomise_playlist(struct playlist_info
* playlist
,
168 unsigned int seed
, bool start_current
,
170 static int sort_playlist(struct playlist_info
* playlist
, bool start_current
,
172 static int get_next_index(const struct playlist_info
* playlist
, int steps
,
174 static void find_and_set_playlist_index(struct playlist_info
* playlist
,
176 static int compare(const void* p1
, const void* p2
);
177 static int get_filename(struct playlist_info
* playlist
, int index
, int seek
,
178 bool control_file
, char *buf
, int buf_length
);
179 static int get_next_directory(char *dir
);
180 static int get_next_dir(char *dir
, bool is_forward
, bool recursion
);
181 static int get_previous_directory(char *dir
);
182 static int check_subdir_for_music(char *dir
, char *subdir
);
183 static int format_track_path(char *dest
, char *src
, int buf_length
, int max
,
185 static void display_playlist_count(int count
, const unsigned char *fmt
,
187 static void display_buffer_full(void);
188 static int flush_cached_control(struct playlist_info
* playlist
);
189 static int update_control(struct playlist_info
* playlist
,
190 enum playlist_command command
, int i1
, int i2
,
191 const char* s1
, const char* s2
, void* data
);
192 static void sync_control(struct playlist_info
* playlist
, bool force
);
193 static int rotate_index(const struct playlist_info
* playlist
, int index
);
196 #define PLAYLIST_LOAD_POINTERS 1
198 static struct event_queue playlist_queue
;
199 static long playlist_stack
[(DEFAULT_STACK_SIZE
+ 0x800)/sizeof(long)];
200 static const char playlist_thread_name
[] = "playlist cachectrl";
203 #define BOM "\xef\xbb\xbf"
206 /* Check if the filename suggests M3U or M3U8 format. */
207 static bool is_m3u8(const char* filename
)
209 int len
= strlen(filename
);
211 /* Default to M3U8 unless explicitly told otherwise. */
212 return !(len
> 4 && strcasecmp(&filename
[len
- 4], ".m3u") == 0);
215 /* Check if a strings starts with an UTF-8 byte-order mark. */
216 static bool is_utf8_bom(const char* str
, int len
)
218 return len
>= BOM_SIZE
&& memcmp(str
, BOM
, BOM_SIZE
) == 0;
221 /* Convert a filename in an M3U playlist to UTF-8.
223 * buf - the filename to convert; can contain more than one line from the
225 * buf_len - amount of buf that is used.
226 * buf_max - total size of buf.
227 * temp - temporary conversion buffer, at least buf_max bytes.
229 * Returns the length of the converted filename.
231 static int convert_m3u(char* buf
, int buf_len
, int buf_max
, char* temp
)
237 while ((buf
[i
] != '\n') && (buf
[i
] != '\r') && (i
< buf_len
))
242 /* Work back killing white space. */
243 while ((i
> 0) && isspace(buf
[i
- 1]))
251 /* Convert char by char, so as to not overflow temp (iso_decode should
252 * preferably handle this). No more than 4 bytes should be generated for
255 for (i
= 0; i
< buf_len
&& dest
< (temp
+ buf_max
- 4); i
++)
257 dest
= iso_decode(&buf
[i
], dest
, -1, 1);
266 * remove any files and indices associated with the playlist
268 static void empty_playlist(struct playlist_info
* playlist
, bool resume
)
270 playlist
->filename
[0] = '\0';
271 playlist
->utf8
= true;
273 if(playlist
->fd
>= 0)
274 /* If there is an already open playlist, close it. */
278 if(playlist
->control_fd
>= 0)
279 close(playlist
->control_fd
);
280 playlist
->control_fd
= -1;
281 playlist
->control_created
= false;
283 playlist
->in_ram
= false;
285 if (playlist
->buffer
)
286 playlist
->buffer
[0] = 0;
288 playlist
->buffer_end_pos
= 0;
291 playlist
->first_index
= 0;
292 playlist
->amount
= 0;
293 playlist
->last_insert_pos
= -1;
295 playlist
->shuffle_modified
= false;
296 playlist
->deleted
= false;
297 playlist
->num_inserted_tracks
= 0;
298 playlist
->started
= false;
300 playlist
->num_cached
= 0;
301 playlist
->pending_control_sync
= false;
303 if (!resume
&& playlist
->current
)
305 /* start with fresh playlist control file when starting new
307 create_control(playlist
);
309 /* Reset resume settings */
310 global_status
.resume_first_index
= 0;
311 global_status
.resume_seed
= -1;
316 * Initialize a new playlist for viewing/editing/playing. dir is the
317 * directory where the playlist is located and file is the filename.
319 static void new_playlist(struct playlist_info
* playlist
, const char *dir
,
322 const char *fileused
= file
;
323 const char *dirused
= dir
;
324 empty_playlist(playlist
, false);
330 if (dirused
&& playlist
->current
) /* !current cannot be in_ram */
331 playlist
->in_ram
= true;
333 dirused
= ""; /* empty playlist */
336 update_playlist_filename(playlist
, dirused
, fileused
);
338 if (playlist
->control_fd
>= 0)
340 update_control(playlist
, PLAYLIST_COMMAND_PLAYLIST
,
341 PLAYLIST_CONTROL_FILE_VERSION
, -1, dirused
, fileused
, NULL
);
342 sync_control(playlist
, false);
347 * create control file for playlist
349 static void create_control(struct playlist_info
* playlist
)
351 playlist
->control_fd
= open(playlist
->control_filename
,
352 O_CREAT
|O_RDWR
|O_TRUNC
);
353 if (playlist
->control_fd
< 0)
355 if (check_rockboxdir())
357 cond_talk_ids_fq(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
);
358 gui_syncsplash(HZ
*2, (unsigned char *)"%s (%d)",
359 str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
),
360 playlist
->control_fd
);
362 playlist
->control_created
= false;
366 playlist
->control_created
= true;
371 * validate the control file. This may include creating/initializing it if
374 static int check_control(struct playlist_info
* playlist
)
376 if (!playlist
->control_created
)
378 create_control(playlist
);
380 if (playlist
->control_fd
>= 0)
382 char* dir
= playlist
->filename
;
383 char* file
= playlist
->filename
+playlist
->dirlen
;
384 char c
= playlist
->filename
[playlist
->dirlen
-1];
386 playlist
->filename
[playlist
->dirlen
-1] = '\0';
388 update_control(playlist
, PLAYLIST_COMMAND_PLAYLIST
,
389 PLAYLIST_CONTROL_FILE_VERSION
, -1, dir
, file
, NULL
);
390 sync_control(playlist
, false);
391 playlist
->filename
[playlist
->dirlen
-1] = c
;
395 if (playlist
->control_fd
< 0)
402 * recreate the control file based on current playlist entries
404 static int recreate_control(struct playlist_info
* playlist
)
406 char temp_file
[MAX_PATH
+1];
411 if(playlist
->control_fd
>= 0)
413 char* dir
= playlist
->filename
;
414 char* file
= playlist
->filename
+playlist
->dirlen
;
415 char c
= playlist
->filename
[playlist
->dirlen
-1];
417 close(playlist
->control_fd
);
419 snprintf(temp_file
, sizeof(temp_file
), "%s_temp",
420 playlist
->control_filename
);
422 if (rename(playlist
->control_filename
, temp_file
) < 0)
425 temp_fd
= open(temp_file
, O_RDONLY
);
429 playlist
->control_fd
= open(playlist
->control_filename
,
430 O_CREAT
|O_RDWR
|O_TRUNC
);
431 if (playlist
->control_fd
< 0)
434 playlist
->filename
[playlist
->dirlen
-1] = '\0';
436 /* cannot call update_control() because of mutex */
437 result
= fdprintf(playlist
->control_fd
, "P:%d:%s:%s\n",
438 PLAYLIST_CONTROL_FILE_VERSION
, dir
, file
);
440 playlist
->filename
[playlist
->dirlen
-1] = c
;
450 playlist
->shuffle_modified
= false;
451 playlist
->deleted
= false;
452 playlist
->num_inserted_tracks
= 0;
454 if (playlist
->current
)
456 global_status
.resume_seed
= -1;
460 for (i
=0; i
<playlist
->amount
; i
++)
462 if (playlist
->indices
[i
] & PLAYLIST_INSERT_TYPE_MASK
)
464 bool queue
= playlist
->indices
[i
] & PLAYLIST_QUEUE_MASK
;
465 char inserted_file
[MAX_PATH
+1];
467 lseek(temp_fd
, playlist
->indices
[i
] & PLAYLIST_SEEK_MASK
,
469 read_line(temp_fd
, inserted_file
, sizeof(inserted_file
));
471 result
= fdprintf(playlist
->control_fd
, "%c:%d:%d:",
472 queue
?'Q':'A', i
, playlist
->last_insert_pos
);
475 /* save the position in file where name is written */
476 int seek_pos
= lseek(playlist
->control_fd
, 0, SEEK_CUR
);
478 result
= fdprintf(playlist
->control_fd
, "%s\n",
481 playlist
->indices
[i
] =
482 (playlist
->indices
[i
] & ~PLAYLIST_SEEK_MASK
) | seek_pos
;
488 playlist
->num_inserted_tracks
++;
494 fsync(playlist
->control_fd
);
503 * store directory and name of playlist file
505 static void update_playlist_filename(struct playlist_info
* playlist
,
506 const char *dir
, const char *file
)
509 int dirlen
= strlen(dir
);
511 playlist
->utf8
= is_m3u8(file
);
513 /* If the dir does not end in trailing slash, we use a separator.
514 Otherwise we don't. */
515 if('/' != dir
[dirlen
-1])
521 playlist
->dirlen
= dirlen
;
523 snprintf(playlist
->filename
, sizeof(playlist
->filename
),
524 "%s%s%s", dir
, sep
, file
);
528 * calculate track offsets within a playlist file
530 static int add_indices_to_playlist(struct playlist_info
* playlist
,
531 char* buffer
, size_t buflen
)
535 unsigned int count
= 0;
540 if(-1 == playlist
->fd
)
541 playlist
->fd
= open(playlist
->filename
, O_RDONLY
);
543 return -1; /* failure */
545 gui_syncsplash(0, ID2P(LANG_WAIT
));
549 /* use mp3 buffer for maximum load speed */
551 #if CONFIG_CODEC != SWCODEC
552 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
553 buflen
= (audiobufend
- audiobuf
);
554 buffer
= (char *)audiobuf
;
556 buffer
= (char *)audio_get_buffer(false, &buflen
);
564 nread
= read(playlist
->fd
, buffer
, buflen
);
565 /* Terminate on EOF */
569 p
= (unsigned char *)buffer
;
571 /* utf8 BOM at beginning of file? */
572 if(i
== 0 && is_utf8_bom(p
, nread
)) {
576 playlist
->utf8
= true; /* Override any earlier indication. */
579 for(count
=0; count
< nread
; count
++,p
++) {
581 /* Are we on a new line? */
582 if((*p
== '\n') || (*p
== '\r'))
592 if ( playlist
->amount
>= playlist
->max_playlist_size
) {
593 display_buffer_full();
598 /* Store a new entry */
599 playlist
->indices
[ playlist
->amount
] = i
+count
;
601 if (playlist
->filenames
)
602 playlist
->filenames
[ playlist
->amount
] = NULL
;
614 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
621 * Utility function to create a new playlist, fill it with the next or
622 * previous directory, shuffle it if needed, and start playback.
623 * If play_last is true and direction zero or negative, start playing
624 * the last file in the directory, otherwise start playing the first.
626 static int create_and_play_dir(int direction
, bool play_last
)
628 char dir
[MAX_PATH
+ 1];
633 res
= get_next_directory(dir
);
635 res
= get_previous_directory(dir
);
639 if (playlist_create(dir
, NULL
) != -1)
641 ft_build_playlist(tree_get_context(), 0);
643 if (global_settings
.playlist_shuffle
)
644 playlist_shuffle(current_tick
, -1);
646 if (play_last
&& direction
<= 0)
647 index
= current_playlist
.amount
- 1;
651 #if (CONFIG_CODEC != SWCODEC)
652 playlist_start(index
, 0);
656 /* we've overwritten the dircache when getting the next/previous dir,
657 so the tree browser context will need to be reloaded */
665 * Removes all tracks, from the playlist, leaving the presently playing
668 int playlist_remove_all_tracks(struct playlist_info
*playlist
)
672 if (playlist
== NULL
)
673 playlist
= ¤t_playlist
;
675 while (playlist
->index
> 0)
676 if ((result
= remove_track_from_playlist(playlist
, 0, true)) < 0)
679 while (playlist
->amount
> 1)
680 if ((result
= remove_track_from_playlist(playlist
, 1, true)) < 0)
683 if (playlist
->amount
== 1) {
684 playlist
->indices
[0] |= PLAYLIST_QUEUED
;
692 * Add track to playlist at specified position. There are five special
693 * positions that can be specified:
694 * PLAYLIST_PREPEND - Add track at beginning of playlist
695 * PLAYLIST_INSERT - Add track after current song. NOTE: If
696 * there are already inserted tracks then track
697 * is added to the end of the insertion list
698 * PLAYLIST_INSERT_FIRST - Add track immediately after current song, no
699 * matter what other tracks have been inserted
700 * PLAYLIST_INSERT_LAST - Add track to end of playlist
701 * PLAYLIST_INSERT_SHUFFLED - Add track at some random point between the
702 * current playing track and end of playlist
703 * PLAYLIST_REPLACE - Erase current playlist, Cue the current track
704 * and inster this track at the end.
706 static int add_track_to_playlist(struct playlist_info
* playlist
,
707 const char *filename
, int position
,
708 bool queue
, int seek_pos
)
710 int insert_position
, orig_position
;
711 unsigned long flags
= PLAYLIST_INSERT_TYPE_INSERT
;
714 insert_position
= orig_position
= position
;
716 if (playlist
->amount
>= playlist
->max_playlist_size
)
718 display_buffer_full();
724 case PLAYLIST_PREPEND
:
725 position
= insert_position
= playlist
->first_index
;
727 case PLAYLIST_INSERT
:
728 /* if there are already inserted tracks then add track to end of
729 insertion list else add after current playing track */
730 if (playlist
->last_insert_pos
>= 0 &&
731 playlist
->last_insert_pos
< playlist
->amount
&&
732 (playlist
->indices
[playlist
->last_insert_pos
]&
733 PLAYLIST_INSERT_TYPE_MASK
) == PLAYLIST_INSERT_TYPE_INSERT
)
734 position
= insert_position
= playlist
->last_insert_pos
+1;
735 else if (playlist
->amount
> 0)
736 position
= insert_position
= playlist
->index
+ 1;
738 position
= insert_position
= 0;
740 if (playlist
->started
)
741 playlist
->last_insert_pos
= position
;
743 case PLAYLIST_INSERT_FIRST
:
744 if (playlist
->amount
> 0)
745 position
= insert_position
= playlist
->index
+ 1;
747 position
= insert_position
= 0;
749 if (playlist
->last_insert_pos
< 0 && playlist
->started
)
750 playlist
->last_insert_pos
= position
;
752 case PLAYLIST_INSERT_LAST
:
753 if (playlist
->first_index
> 0)
754 position
= insert_position
= playlist
->first_index
;
756 position
= insert_position
= playlist
->amount
;
758 case PLAYLIST_INSERT_SHUFFLED
:
760 if (playlist
->started
)
763 int n
= playlist
->amount
-
764 rotate_index(playlist
, playlist
->index
);
771 position
= playlist
->index
+ offset
+ 1;
772 if (position
>= playlist
->amount
)
773 position
-= playlist
->amount
;
775 insert_position
= position
;
778 position
= insert_position
= (rand() % (playlist
->amount
+1));
781 case PLAYLIST_REPLACE
:
782 if (playlist_remove_all_tracks(playlist
) < 0)
785 position
= insert_position
= playlist
->index
+ 1;
790 flags
|= PLAYLIST_QUEUED
;
792 /* shift indices so that track can be added */
793 for (i
=playlist
->amount
; i
>insert_position
; i
--)
795 playlist
->indices
[i
] = playlist
->indices
[i
-1];
797 if (playlist
->filenames
)
798 playlist
->filenames
[i
] = playlist
->filenames
[i
-1];
802 /* update stored indices if needed */
803 if (playlist
->amount
> 0 && insert_position
<= playlist
->index
&&
807 if (playlist
->amount
> 0 && insert_position
<= playlist
->first_index
&&
808 orig_position
!= PLAYLIST_PREPEND
&& playlist
->started
)
810 playlist
->first_index
++;
812 if (seek_pos
< 0 && playlist
->current
)
814 global_status
.resume_first_index
= playlist
->first_index
;
819 if (insert_position
< playlist
->last_insert_pos
||
820 (insert_position
== playlist
->last_insert_pos
&& position
< 0))
821 playlist
->last_insert_pos
++;
823 if (seek_pos
< 0 && playlist
->control_fd
>= 0)
825 int result
= update_control(playlist
,
826 (queue
?PLAYLIST_COMMAND_QUEUE
:PLAYLIST_COMMAND_ADD
), position
,
827 playlist
->last_insert_pos
, filename
, NULL
, &seek_pos
);
833 playlist
->indices
[insert_position
] = flags
| seek_pos
;
836 if (playlist
->filenames
)
837 playlist
->filenames
[insert_position
] = NULL
;
841 playlist
->num_inserted_tracks
++;
843 return insert_position
;
847 * Callback for playlist_directory_tracksearch to insert track into
850 static int directory_search_callback(char* filename
, void* context
)
852 struct directory_search_context
* c
=
853 (struct directory_search_context
*) context
;
856 insert_pos
= add_track_to_playlist(c
->playlist
, filename
, c
->position
,
864 /* Make sure tracks are inserted in correct order if user requests
866 if (c
->position
== PLAYLIST_INSERT_FIRST
|| c
->position
>= 0)
867 c
->position
= insert_pos
+ 1;
869 if (((c
->count
)%PLAYLIST_DISPLAY_COUNT
) == 0)
871 unsigned char* count_str
;
874 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
876 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
878 display_playlist_count(c
->count
, count_str
, false);
880 if ((c
->count
) == PLAYLIST_DISPLAY_COUNT
&&
881 (audio_status() & AUDIO_STATUS_PLAY
) &&
882 c
->playlist
->started
)
883 audio_flush_and_reload_tracks();
890 * remove track at specified position
892 static int remove_track_from_playlist(struct playlist_info
* playlist
,
893 int position
, bool write
)
898 if (playlist
->amount
<= 0)
901 inserted
= playlist
->indices
[position
] & PLAYLIST_INSERT_TYPE_MASK
;
903 /* shift indices now that track has been removed */
904 for (i
=position
; i
<playlist
->amount
; i
++)
906 playlist
->indices
[i
] = playlist
->indices
[i
+1];
908 if (playlist
->filenames
)
909 playlist
->filenames
[i
] = playlist
->filenames
[i
+1];
916 playlist
->num_inserted_tracks
--;
918 playlist
->deleted
= true;
920 /* update stored indices if needed */
921 if (position
< playlist
->index
)
924 if (position
< playlist
->first_index
)
926 playlist
->first_index
--;
930 global_status
.resume_first_index
= playlist
->first_index
;
935 if (position
<= playlist
->last_insert_pos
)
936 playlist
->last_insert_pos
--;
938 if (write
&& playlist
->control_fd
>= 0)
940 int result
= update_control(playlist
, PLAYLIST_COMMAND_DELETE
,
941 position
, -1, NULL
, NULL
, NULL
);
946 sync_control(playlist
, false);
953 * randomly rearrange the array of indices for the playlist. If start_current
954 * is true then update the index to the new index of the current playing track
956 static int randomise_playlist(struct playlist_info
* playlist
,
957 unsigned int seed
, bool start_current
,
963 unsigned int current
= playlist
->indices
[playlist
->index
];
965 /* seed 0 is used to identify sorted playlist for resume purposes */
969 /* seed with the given seed */
972 /* randomise entire indices list */
973 for(count
= playlist
->amount
- 1; count
>= 0; count
--)
975 /* the rand is from 0 to RAND_MAX, so adjust to our value range */
976 candidate
= rand() % (count
+ 1);
978 /* now swap the values at the 'count' and 'candidate' positions */
979 store
= playlist
->indices
[candidate
];
980 playlist
->indices
[candidate
] = playlist
->indices
[count
];
981 playlist
->indices
[count
] = store
;
983 if (playlist
->filenames
)
985 store
= (long)playlist
->filenames
[candidate
];
986 playlist
->filenames
[candidate
] = playlist
->filenames
[count
];
987 playlist
->filenames
[count
] = (struct dircache_entry
*)store
;
993 find_and_set_playlist_index(playlist
, current
);
995 /* indices have been moved so last insert position is no longer valid */
996 playlist
->last_insert_pos
= -1;
998 playlist
->seed
= seed
;
999 if (playlist
->num_inserted_tracks
> 0 || playlist
->deleted
)
1000 playlist
->shuffle_modified
= true;
1004 update_control(playlist
, PLAYLIST_COMMAND_SHUFFLE
, seed
,
1005 playlist
->first_index
, NULL
, NULL
, NULL
);
1006 global_status
.resume_seed
= seed
;
1014 * Sort the array of indices for the playlist. If start_current is true then
1015 * set the index to the new index of the current song.
1017 static int sort_playlist(struct playlist_info
* playlist
, bool start_current
,
1020 unsigned int current
= playlist
->indices
[playlist
->index
];
1022 if (playlist
->amount
> 0)
1023 qsort(playlist
->indices
, playlist
->amount
,
1024 sizeof(playlist
->indices
[0]), compare
);
1026 #ifdef HAVE_DIRCACHE
1027 /** We need to re-check the song names from disk because qsort can't
1028 * sort two arrays at once :/
1029 * FIXME: Please implement a better way to do this. */
1030 memset(playlist
->filenames
, 0, playlist
->max_playlist_size
* sizeof(int));
1031 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
1035 find_and_set_playlist_index(playlist
, current
);
1037 /* indices have been moved so last insert position is no longer valid */
1038 playlist
->last_insert_pos
= -1;
1040 if (!playlist
->num_inserted_tracks
&& !playlist
->deleted
)
1041 playlist
->shuffle_modified
= false;
1042 if (write
&& playlist
->control_fd
>= 0)
1044 update_control(playlist
, PLAYLIST_COMMAND_UNSHUFFLE
,
1045 playlist
->first_index
, -1, NULL
, NULL
, NULL
);
1046 global_status
.resume_seed
= 0;
1053 /* Calculate how many steps we have to really step when skipping entries
1056 static int calculate_step_count(const struct playlist_info
*playlist
, int steps
)
1058 int i
, count
, direction
;
1060 int stepped_count
= 0;
1073 index
= playlist
->index
;
1076 /* Boundary check */
1078 index
+= playlist
->amount
;
1079 if (index
>= playlist
->amount
)
1080 index
-= playlist
->amount
;
1082 /* Check if we found a bad entry. */
1083 if (playlist
->indices
[index
] & PLAYLIST_SKIPPED
)
1086 /* Are all entries bad? */
1087 if (stepped_count
++ > playlist
->amount
)
1094 } while (i
<= count
);
1099 /* Marks the index of the track to be skipped that is "steps" away from
1100 * current playing track.
1102 void playlist_skip_entry(struct playlist_info
*playlist
, int steps
)
1106 if (playlist
== NULL
)
1107 playlist
= ¤t_playlist
;
1109 /* need to account for already skipped tracks */
1110 steps
= calculate_step_count(playlist
, steps
);
1112 index
= playlist
->index
+ steps
;
1114 index
+= playlist
->amount
;
1115 else if (index
>= playlist
->amount
)
1116 index
-= playlist
->amount
;
1118 playlist
->indices
[index
] |= PLAYLIST_SKIPPED
;
1122 * returns the index of the track that is "steps" away from current playing
1125 static int get_next_index(const struct playlist_info
* playlist
, int steps
,
1128 int current_index
= playlist
->index
;
1129 int next_index
= -1;
1131 if (playlist
->amount
<= 0)
1134 if (repeat_mode
== -1)
1135 repeat_mode
= global_settings
.repeat_mode
;
1137 if (repeat_mode
== REPEAT_SHUFFLE
&& playlist
->amount
<= 1)
1138 repeat_mode
= REPEAT_ALL
;
1140 steps
= calculate_step_count(playlist
, steps
);
1141 switch (repeat_mode
)
1143 case REPEAT_SHUFFLE
:
1144 /* Treat repeat shuffle just like repeat off. At end of playlist,
1145 play will be resumed in playlist_next() */
1148 current_index
= rotate_index(playlist
, current_index
);
1149 next_index
= current_index
+steps
;
1150 if ((next_index
< 0) || (next_index
>= playlist
->amount
))
1153 next_index
= (next_index
+playlist
->first_index
) %
1160 #ifdef AB_REPEAT_ENABLE
1163 next_index
= current_index
;
1169 next_index
= (current_index
+steps
) % playlist
->amount
;
1170 while (next_index
< 0)
1171 next_index
+= playlist
->amount
;
1173 if (steps
>= playlist
->amount
)
1180 /* second time around so skip the queued files */
1181 for (i
=0; i
<playlist
->amount
; i
++)
1183 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
1184 index
= (index
+1) % playlist
->amount
;
1196 /* No luck if the whole playlist was bad. */
1197 if (playlist
->indices
[next_index
] & PLAYLIST_SKIPPED
)
1204 * Search for the seek track and set appropriate indices. Used after shuffle
1205 * to make sure the current index is still pointing to correct track.
1207 static void find_and_set_playlist_index(struct playlist_info
* playlist
,
1212 /* Set the index to the current song */
1213 for (i
=0; i
<playlist
->amount
; i
++)
1215 if (playlist
->indices
[i
] == seek
)
1217 playlist
->index
= playlist
->first_index
= i
;
1219 if (playlist
->current
)
1221 global_status
.resume_first_index
= i
;
1231 * used to sort track indices. Sort order is as follows:
1232 * 1. Prepended tracks (in prepend order)
1233 * 2. Playlist/directory tracks (in playlist order)
1234 * 3. Inserted/Appended tracks (in insert order)
1236 static int compare(const void* p1
, const void* p2
)
1238 unsigned long* e1
= (unsigned long*) p1
;
1239 unsigned long* e2
= (unsigned long*) p2
;
1240 unsigned long flags1
= *e1
& PLAYLIST_INSERT_TYPE_MASK
;
1241 unsigned long flags2
= *e2
& PLAYLIST_INSERT_TYPE_MASK
;
1243 if (flags1
== flags2
)
1244 return (*e1
& PLAYLIST_SEEK_MASK
) - (*e2
& PLAYLIST_SEEK_MASK
);
1245 else if (flags1
== PLAYLIST_INSERT_TYPE_PREPEND
||
1246 flags2
== PLAYLIST_INSERT_TYPE_APPEND
)
1248 else if (flags1
== PLAYLIST_INSERT_TYPE_APPEND
||
1249 flags2
== PLAYLIST_INSERT_TYPE_PREPEND
)
1251 else if (flags1
&& flags2
)
1252 return (*e1
& PLAYLIST_SEEK_MASK
) - (*e2
& PLAYLIST_SEEK_MASK
);
1257 #ifdef HAVE_DIRCACHE
1259 * Thread to update filename pointers to dircache on background
1260 * without affecting playlist load up performance. This thread also flushes
1261 * any pending control commands when the disk spins up.
1263 static bool playlist_flush_callback(void)
1265 struct playlist_info
*playlist
;
1266 playlist
= ¤t_playlist
;
1267 if (playlist
->control_fd
>= 0)
1269 if (playlist
->num_cached
> 0)
1271 mutex_lock(&playlist
->control_mutex
);
1272 flush_cached_control(playlist
);
1273 mutex_unlock(&playlist
->control_mutex
);
1275 sync_control(playlist
, true);
1280 static void playlist_thread(void)
1282 struct queue_event ev
;
1283 bool dirty_pointers
= false;
1284 static char tmp
[MAX_PATH
+1];
1286 struct playlist_info
*playlist
;
1293 #ifndef HAVE_FLASH_STORAGE
1294 if (global_settings
.disk_spindown
> 1 &&
1295 global_settings
.disk_spindown
<= 5)
1296 sleep_time
= global_settings
.disk_spindown
- 1;
1301 queue_wait_w_tmo(&playlist_queue
, &ev
, HZ
*sleep_time
);
1305 case PLAYLIST_LOAD_POINTERS
:
1306 dirty_pointers
= true;
1309 /* Start the background scanning after either the disk spindown
1310 timeout or 5s, whichever is less */
1312 playlist
= ¤t_playlist
;
1313 if (playlist
->control_fd
>= 0)
1315 if (playlist
->num_cached
> 0)
1316 register_ata_idle_func(playlist_flush_callback
);
1319 if (!dirty_pointers
)
1322 if (!dircache_is_enabled() || !playlist
->filenames
1323 || playlist
->amount
<= 0)
1326 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1329 for (index
= 0; index
< playlist
->amount
1330 && queue_empty(&playlist_queue
); index
++)
1332 /* Process only pointers that are not already loaded. */
1333 if (playlist
->filenames
[index
])
1336 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
1337 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
1339 /* Load the filename from playlist file. */
1340 if (get_filename(playlist
, index
, seek
, control_file
, tmp
,
1344 /* Set the dircache entry pointer. */
1345 playlist
->filenames
[index
] = dircache_get_entry_ptr(tmp
);
1347 /* And be on background so user doesn't notice any delays. */
1351 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1354 dirty_pointers
= false;
1358 case SYS_USB_CONNECTED
:
1359 usb_acknowledge(SYS_USB_CONNECTED_ACK
);
1360 usb_wait_for_disconnect(&playlist_queue
);
1369 * gets pathname for track at seek index
1371 static int get_filename(struct playlist_info
* playlist
, int index
, int seek
,
1372 bool control_file
, char *buf
, int buf_length
)
1376 char tmp_buf
[MAX_PATH
+1];
1377 char dir_buf
[MAX_PATH
+1];
1378 bool utf8
= playlist
->utf8
;
1380 if (buf_length
> MAX_PATH
+1)
1381 buf_length
= MAX_PATH
+1;
1383 #ifdef HAVE_DIRCACHE
1384 if (dircache_is_enabled() && playlist
->filenames
)
1386 if (playlist
->filenames
[index
] != NULL
)
1388 dircache_copy_path(playlist
->filenames
[index
], tmp_buf
, sizeof(tmp_buf
)-1);
1389 max
= strlen(tmp_buf
) + 1;
1396 if (playlist
->in_ram
&& !control_file
&& max
< 0)
1398 strncpy(tmp_buf
, &playlist
->buffer
[seek
], sizeof(tmp_buf
));
1399 tmp_buf
[MAX_PATH
] = '\0';
1400 max
= strlen(tmp_buf
) + 1;
1404 mutex_lock(&playlist
->control_mutex
);
1408 fd
= playlist
->control_fd
;
1413 if(-1 == playlist
->fd
)
1414 playlist
->fd
= open(playlist
->filename
, O_RDONLY
);
1422 if (lseek(fd
, seek
, SEEK_SET
) != seek
)
1426 max
= read(fd
, tmp_buf
, MIN((size_t) buf_length
, sizeof(tmp_buf
)));
1428 if ((max
> 0) && !utf8
)
1430 /* Use dir_buf as a temporary buffer. Note that dir_buf must
1431 * be as large as tmp_buf.
1433 max
= convert_m3u(tmp_buf
, max
, sizeof(tmp_buf
), dir_buf
);
1438 mutex_unlock(&playlist
->control_mutex
);
1443 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
1445 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
1451 strncpy(dir_buf
, playlist
->filename
, playlist
->dirlen
-1);
1452 dir_buf
[playlist
->dirlen
-1] = 0;
1454 return (format_track_path(buf
, tmp_buf
, buf_length
, max
, dir_buf
));
1457 static int get_next_directory(char *dir
){
1458 return get_next_dir(dir
,true,false);
1461 static int get_previous_directory(char *dir
){
1462 return get_next_dir(dir
,false,false);
1466 * search through all the directories (starting with the current) to find
1467 * one that has tracks to play
1469 static int get_next_dir(char *dir
, bool is_forward
, bool recursion
)
1471 struct playlist_info
* playlist
= ¤t_playlist
;
1473 int sort_dir
= global_settings
.sort_dir
;
1474 char *start_dir
= NULL
;
1476 struct tree_context
* tc
= tree_get_context();
1477 int dirfilter
= *(tc
->dirfilter
);
1479 if (global_settings
.next_folder
== FOLDER_ADVANCE_RANDOM
)
1481 int fd
= open(ROCKBOX_DIR
"/folder_advance_list.dat",O_RDONLY
);
1482 char buffer
[MAX_PATH
];
1483 int folder_count
= 0,i
;
1484 srand(current_tick
);
1485 *(tc
->dirfilter
) = SHOW_MUSIC
;
1488 read(fd
,&folder_count
,sizeof(int));
1493 i
= rand()%folder_count
;
1494 lseek(fd
,sizeof(int) + (MAX_PATH
*i
),SEEK_SET
);
1495 read(fd
,buffer
,MAX_PATH
);
1496 if (check_subdir_for_music(buffer
,"") ==0)
1502 *(tc
->dirfilter
) = dirfilter
;
1507 /* not random folder advance */
1509 /* start with root */
1513 /* start with current directory */
1514 strncpy(dir
, playlist
->filename
, playlist
->dirlen
-1);
1515 dir
[playlist
->dirlen
-1] = '\0';
1518 /* use the tree browser dircache to load files */
1519 *(tc
->dirfilter
) = SHOW_ALL
;
1521 /* sort in another direction if previous dir is requested */
1523 if ((global_settings
.sort_dir
== 0) || (global_settings
.sort_dir
== 3))
1524 global_settings
.sort_dir
= 4;
1525 else if (global_settings
.sort_dir
== 1)
1526 global_settings
.sort_dir
= 2;
1527 else if (global_settings
.sort_dir
== 2)
1528 global_settings
.sort_dir
= 1;
1529 else if (global_settings
.sort_dir
== 4)
1530 global_settings
.sort_dir
= 0;
1535 struct entry
*files
;
1539 if (ft_load(tc
, (dir
[0]=='\0')?"/":dir
) < 0)
1541 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
1547 files
= (struct entry
*) tc
->dircache
;
1548 num_files
= tc
->filesindir
;
1550 for (i
=0; i
<num_files
; i
++)
1553 if (action_userabort(TIMEOUT_NOBLOCK
))
1560 if (files
[i
].attr
& ATTR_DIRECTORY
)
1564 result
= check_subdir_for_music(dir
, files
[i
].name
);
1571 else if (!strcmp(start_dir
, files
[i
].name
))
1578 /* move down to parent directory. current directory name is
1579 stored as the starting point for the search in parent */
1580 start_dir
= strrchr(dir
, '/');
1591 /* restore dirfilter & sort_dir */
1592 *(tc
->dirfilter
) = dirfilter
;
1593 global_settings
.sort_dir
= sort_dir
;
1595 /* special case if nothing found: try start searching again from root */
1596 if (result
== -1 && !recursion
){
1597 result
= get_next_dir(dir
,is_forward
, true);
1604 * Checks if there are any music files in the dir or any of its
1605 * subdirectories. May be called recursively.
1607 static int check_subdir_for_music(char *dir
, char *subdir
)
1610 int dirlen
= strlen(dir
);
1613 struct entry
*files
;
1614 bool has_music
= false;
1615 bool has_subdir
= false;
1616 struct tree_context
* tc
= tree_get_context();
1618 snprintf(dir
+dirlen
, MAX_PATH
-dirlen
, "/%s", subdir
);
1620 if (ft_load(tc
, dir
) < 0)
1622 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
1626 files
= (struct entry
*) tc
->dircache
;
1627 num_files
= tc
->filesindir
;
1629 for (i
=0; i
<num_files
; i
++)
1631 if (files
[i
].attr
& ATTR_DIRECTORY
)
1633 else if ((files
[i
].attr
& FILE_ATTR_MASK
) == FILE_ATTR_AUDIO
)
1645 for (i
=0; i
<num_files
; i
++)
1647 if (action_userabort(TIMEOUT_NOBLOCK
))
1653 if (files
[i
].attr
& ATTR_DIRECTORY
)
1655 result
= check_subdir_for_music(dir
, files
[i
].name
);
1673 /* we now need to reload our current directory */
1674 if(ft_load(tc
, dir
) < 0)
1675 gui_syncsplash(HZ
*2,
1676 ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
1683 * Returns absolute path of track
1685 static int format_track_path(char *dest
, char *src
, int buf_length
, int max
,
1692 /* Zero-terminate the file name */
1693 while((src
[i
] != '\n') &&
1698 /* Now work back killing white space */
1699 while((src
[i
-1] == ' ') ||
1705 /* replace backslashes with forward slashes */
1706 for ( j
=0; j
<i
; j
++ )
1707 if ( src
[j
] == '\\' )
1712 strncpy(dest
, src
, buf_length
);
1716 /* handle dos style drive letter */
1718 strncpy(dest
, &src
[2], buf_length
);
1719 else if (!strncmp(src
, "../", 3))
1721 /* handle relative paths */
1723 while(!strncmp(&src
[i
], "../", 3))
1725 for (j
=0; j
<i
/3; j
++) {
1726 temp_ptr
= strrchr(dir
, '/');
1732 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[i
]);
1734 else if ( '.' == src
[0] && '/' == src
[1] ) {
1735 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[2]);
1738 snprintf(dest
, buf_length
, "%s/%s", dir
, src
);
1746 * Display splash message showing progress of playlist/directory insertion or
1749 static void display_playlist_count(int count
, const unsigned char *fmt
,
1752 static long talked_tick
= 0;
1753 long id
= P2ID(fmt
);
1754 if(global_settings
.talk_menu
&& id
>=0)
1756 if(final
|| (count
&& (talked_tick
== 0
1757 || TIME_AFTER(current_tick
, talked_tick
+5*HZ
))))
1759 talked_tick
= current_tick
;
1760 talk_number(count
, false);
1766 gui_syncsplash(0, fmt
, count
, str(LANG_OFF_ABORT
));
1770 * Display buffer full message
1772 static void display_buffer_full(void)
1774 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_BUFFER_FULL
));
1778 * Flush any cached control commands to disk. Called when playlist is being
1779 * modified. Returns 0 on success and -1 on failure.
1781 static int flush_cached_control(struct playlist_info
* playlist
)
1786 if (!playlist
->num_cached
)
1789 lseek(playlist
->control_fd
, 0, SEEK_END
);
1791 for (i
=0; i
<playlist
->num_cached
; i
++)
1793 struct playlist_control_cache
* cache
=
1794 &(playlist
->control_cache
[i
]);
1796 switch (cache
->command
)
1798 case PLAYLIST_COMMAND_PLAYLIST
:
1799 result
= fdprintf(playlist
->control_fd
, "P:%d:%s:%s\n",
1800 cache
->i1
, cache
->s1
, cache
->s2
);
1802 case PLAYLIST_COMMAND_ADD
:
1803 case PLAYLIST_COMMAND_QUEUE
:
1804 result
= fdprintf(playlist
->control_fd
, "%c:%d:%d:",
1805 (cache
->command
== PLAYLIST_COMMAND_ADD
)?'A':'Q',
1806 cache
->i1
, cache
->i2
);
1809 /* save the position in file where name is written */
1810 int* seek_pos
= (int *)cache
->data
;
1811 *seek_pos
= lseek(playlist
->control_fd
, 0, SEEK_CUR
);
1812 result
= fdprintf(playlist
->control_fd
, "%s\n",
1816 case PLAYLIST_COMMAND_DELETE
:
1817 result
= fdprintf(playlist
->control_fd
, "D:%d\n", cache
->i1
);
1819 case PLAYLIST_COMMAND_SHUFFLE
:
1820 result
= fdprintf(playlist
->control_fd
, "S:%d:%d\n",
1821 cache
->i1
, cache
->i2
);
1823 case PLAYLIST_COMMAND_UNSHUFFLE
:
1824 result
= fdprintf(playlist
->control_fd
, "U:%d\n", cache
->i1
);
1826 case PLAYLIST_COMMAND_RESET
:
1827 result
= fdprintf(playlist
->control_fd
, "R\n");
1839 if (global_status
.resume_seed
>= 0)
1841 global_status
.resume_seed
= -1;
1845 playlist
->num_cached
= 0;
1846 playlist
->pending_control_sync
= true;
1853 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_UPDATE_ERROR
));
1860 * Update control data with new command. Depending on the command, it may be
1861 * cached or flushed to disk.
1863 static int update_control(struct playlist_info
* playlist
,
1864 enum playlist_command command
, int i1
, int i2
,
1865 const char* s1
, const char* s2
, void* data
)
1868 struct playlist_control_cache
* cache
;
1871 mutex_lock(&playlist
->control_mutex
);
1873 cache
= &(playlist
->control_cache
[playlist
->num_cached
++]);
1875 cache
->command
= command
;
1884 case PLAYLIST_COMMAND_PLAYLIST
:
1885 case PLAYLIST_COMMAND_ADD
:
1886 case PLAYLIST_COMMAND_QUEUE
:
1887 #ifndef HAVE_DIRCACHE
1888 case PLAYLIST_COMMAND_DELETE
:
1889 case PLAYLIST_COMMAND_RESET
:
1893 case PLAYLIST_COMMAND_SHUFFLE
:
1894 case PLAYLIST_COMMAND_UNSHUFFLE
:
1896 /* only flush when needed */
1900 if (flush
|| playlist
->num_cached
== PLAYLIST_MAX_CACHE
)
1901 result
= flush_cached_control(playlist
);
1903 mutex_unlock(&playlist
->control_mutex
);
1909 * sync control file to disk
1911 static void sync_control(struct playlist_info
* playlist
, bool force
)
1913 #ifdef HAVE_DIRCACHE
1914 if (playlist
->started
&& force
)
1918 if (playlist
->started
)
1921 if (playlist
->pending_control_sync
)
1923 mutex_lock(&playlist
->control_mutex
);
1924 fsync(playlist
->control_fd
);
1925 playlist
->pending_control_sync
= false;
1926 mutex_unlock(&playlist
->control_mutex
);
1932 * Rotate indices such that first_index is index 0
1934 static int rotate_index(const struct playlist_info
* playlist
, int index
)
1936 index
-= playlist
->first_index
;
1938 index
+= playlist
->amount
;
1944 * Initialize playlist entries at startup
1946 void playlist_init(void)
1948 struct playlist_info
* playlist
= ¤t_playlist
;
1950 playlist
->current
= true;
1951 snprintf(playlist
->control_filename
, sizeof(playlist
->control_filename
),
1952 "%s", PLAYLIST_CONTROL_FILE
);
1954 playlist
->control_fd
= -1;
1955 playlist
->max_playlist_size
= global_settings
.max_files_in_playlist
;
1956 playlist
->indices
= buffer_alloc(
1957 playlist
->max_playlist_size
* sizeof(int));
1958 playlist
->buffer_size
=
1959 AVERAGE_FILENAME_LENGTH
* global_settings
.max_files_in_dir
;
1960 playlist
->buffer
= buffer_alloc(playlist
->buffer_size
);
1961 mutex_init(&playlist
->control_mutex
);
1962 empty_playlist(playlist
, true);
1964 #ifdef HAVE_DIRCACHE
1965 playlist
->filenames
= buffer_alloc(
1966 playlist
->max_playlist_size
* sizeof(int));
1967 memset(playlist
->filenames
, 0,
1968 playlist
->max_playlist_size
* sizeof(int));
1969 create_thread(playlist_thread
, playlist_stack
, sizeof(playlist_stack
),
1970 0, playlist_thread_name
IF_PRIO(, PRIORITY_BACKGROUND
)
1972 queue_init(&playlist_queue
, true);
1977 * Clean playlist at shutdown
1979 void playlist_shutdown(void)
1981 struct playlist_info
* playlist
= ¤t_playlist
;
1983 if (playlist
->control_fd
>= 0)
1985 mutex_lock(&playlist
->control_mutex
);
1987 if (playlist
->num_cached
> 0)
1988 flush_cached_control(playlist
);
1990 close(playlist
->control_fd
);
1992 mutex_unlock(&playlist
->control_mutex
);
1997 * Create new playlist
1999 int playlist_create(const char *dir
, const char *file
)
2001 struct playlist_info
* playlist
= ¤t_playlist
;
2003 new_playlist(playlist
, dir
, file
);
2006 /* load the playlist file */
2007 add_indices_to_playlist(playlist
, NULL
, 0);
2012 #define PLAYLIST_COMMAND_SIZE (MAX_PATH+12)
2015 * Restore the playlist state based on control file commands. Called to
2016 * resume playback after shutdown.
2018 int playlist_resume(void)
2020 struct playlist_info
* playlist
= ¤t_playlist
;
2025 int control_file_size
= 0;
2029 /* use mp3 buffer for maximum load speed */
2030 #if CONFIG_CODEC != SWCODEC
2031 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
2032 buflen
= (audiobufend
- audiobuf
);
2033 buffer
= (char *)audiobuf
;
2035 buffer
= (char *)audio_get_buffer(false, &buflen
);
2038 empty_playlist(playlist
, true);
2040 gui_syncsplash(0, ID2P(LANG_WAIT
));
2041 playlist
->control_fd
= open(playlist
->control_filename
, O_RDWR
);
2042 if (playlist
->control_fd
< 0)
2044 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2047 playlist
->control_created
= true;
2049 control_file_size
= filesize(playlist
->control_fd
);
2050 if (control_file_size
<= 0)
2052 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2056 /* read a small amount first to get the header */
2057 nread
= read(playlist
->control_fd
, buffer
,
2058 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
2061 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2065 playlist
->started
= true;
2071 enum playlist_command current_command
= PLAYLIST_COMMAND_COMMENT
;
2072 int last_newline
= 0;
2074 bool newline
= true;
2075 bool exit_loop
= false;
2080 unsigned long last_tick
= current_tick
;
2082 for(count
=0; count
<nread
&& !exit_loop
; count
++,p
++)
2084 /* So a splash while we are loading. */
2085 if (current_tick
- last_tick
> HZ
/4)
2087 gui_syncsplash(0, str(LANG_LOADING_PERCENT
),
2088 (total_read
+count
)*100/control_file_size
,
2089 str(LANG_OFF_ABORT
));
2090 if (action_userabort(TIMEOUT_NOBLOCK
))
2093 * Not sure how to implement this, somebody more familiar
2094 * with the code, please fix this. */
2096 last_tick
= current_tick
;
2099 /* Are we on a new line? */
2100 if((*p
== '\n') || (*p
== '\r'))
2104 /* save last_newline in case we need to load more data */
2105 last_newline
= count
;
2107 switch (current_command
)
2109 case PLAYLIST_COMMAND_PLAYLIST
:
2111 /* str1=version str2=dir str3=file */
2127 version
= atoi(str1
);
2129 if (version
!= PLAYLIST_CONTROL_FILE_VERSION
)
2132 update_playlist_filename(playlist
, str2
, str3
);
2134 if (str3
[0] != '\0')
2136 /* NOTE: add_indices_to_playlist() overwrites the
2137 audiobuf so we need to reload control file
2139 add_indices_to_playlist(playlist
, NULL
, 0);
2141 else if (str2
[0] != '\0')
2143 playlist
->in_ram
= true;
2144 resume_directory(str2
);
2147 /* load the rest of the data */
2153 case PLAYLIST_COMMAND_ADD
:
2154 case PLAYLIST_COMMAND_QUEUE
:
2156 /* str1=position str2=last_position str3=file */
2157 int position
, last_position
;
2160 if (!str1
|| !str2
|| !str3
)
2167 position
= atoi(str1
);
2168 last_position
= atoi(str2
);
2170 queue
= (current_command
== PLAYLIST_COMMAND_ADD
)?
2173 /* seek position is based on str3's position in
2175 if (add_track_to_playlist(playlist
, str3
, position
,
2176 queue
, total_read
+(str3
-buffer
)) < 0)
2179 playlist
->last_insert_pos
= last_position
;
2183 case PLAYLIST_COMMAND_DELETE
:
2195 position
= atoi(str1
);
2197 if (remove_track_from_playlist(playlist
, position
,
2203 case PLAYLIST_COMMAND_SHUFFLE
:
2205 /* str1=seed str2=first_index */
2217 /* Always sort list before shuffling */
2218 sort_playlist(playlist
, false, false);
2222 playlist
->first_index
= atoi(str2
);
2224 if (randomise_playlist(playlist
, seed
, false,
2231 case PLAYLIST_COMMAND_UNSHUFFLE
:
2233 /* str1=first_index */
2241 playlist
->first_index
= atoi(str1
);
2243 if (sort_playlist(playlist
, false, false) < 0)
2249 case PLAYLIST_COMMAND_RESET
:
2251 playlist
->last_insert_pos
= -1;
2254 case PLAYLIST_COMMAND_COMMENT
:
2261 /* to ignore any extra newlines */
2262 current_command
= PLAYLIST_COMMAND_COMMENT
;
2268 /* first non-comment line must always specify playlist */
2269 if (first
&& *p
!= 'P' && *p
!= '#')
2279 /* playlist can only be specified once */
2287 current_command
= PLAYLIST_COMMAND_PLAYLIST
;
2290 current_command
= PLAYLIST_COMMAND_ADD
;
2293 current_command
= PLAYLIST_COMMAND_QUEUE
;
2296 current_command
= PLAYLIST_COMMAND_DELETE
;
2299 current_command
= PLAYLIST_COMMAND_SHUFFLE
;
2302 current_command
= PLAYLIST_COMMAND_UNSHUFFLE
;
2305 current_command
= PLAYLIST_COMMAND_RESET
;
2308 current_command
= PLAYLIST_COMMAND_COMMENT
;
2321 else if(current_command
!= PLAYLIST_COMMAND_COMMENT
)
2323 /* all control file strings are separated with a colon.
2324 Replace the colon with 0 to get proper strings that can be
2325 used by commands above */
2331 if ((count
+1) < nread
)
2345 /* allow last string to contain colons */
2356 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID
));
2360 if (!newline
|| (exit_loop
&& count
<nread
))
2362 if ((total_read
+ count
) >= control_file_size
)
2364 /* no newline at end of control file */
2365 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID
));
2369 /* We didn't end on a newline or we exited loop prematurely.
2370 Either way, re-read the remainder. */
2371 count
= last_newline
;
2372 lseek(playlist
->control_fd
, total_read
+count
, SEEK_SET
);
2375 total_read
+= count
;
2378 /* still looking for header */
2379 nread
= read(playlist
->control_fd
, buffer
,
2380 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
2382 nread
= read(playlist
->control_fd
, buffer
, buflen
);
2384 /* Terminate on EOF */
2387 if (global_status
.resume_seed
>= 0)
2389 /* Apply shuffle command saved in settings */
2390 if (global_status
.resume_seed
== 0)
2391 sort_playlist(playlist
, false, true);
2395 sort_playlist(playlist
, false, false);
2397 randomise_playlist(playlist
, global_status
.resume_seed
,
2402 playlist
->first_index
= global_status
.resume_first_index
;
2407 #ifdef HAVE_DIRCACHE
2408 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2415 * Add track to in_ram playlist. Used when playing directories.
2417 int playlist_add(const char *filename
)
2419 struct playlist_info
* playlist
= ¤t_playlist
;
2420 int len
= strlen(filename
);
2422 if((len
+1 > playlist
->buffer_size
- playlist
->buffer_end_pos
) ||
2423 (playlist
->amount
>= playlist
->max_playlist_size
))
2425 display_buffer_full();
2429 playlist
->indices
[playlist
->amount
] = playlist
->buffer_end_pos
;
2430 #ifdef HAVE_DIRCACHE
2431 playlist
->filenames
[playlist
->amount
] = NULL
;
2435 strcpy(&playlist
->buffer
[playlist
->buffer_end_pos
], filename
);
2436 playlist
->buffer_end_pos
+= len
;
2437 playlist
->buffer
[playlist
->buffer_end_pos
++] = '\0';
2442 /* shuffle newly created playlist using random seed. */
2443 int playlist_shuffle(int random_seed
, int start_index
)
2445 struct playlist_info
* playlist
= ¤t_playlist
;
2447 unsigned int seek_pos
= 0;
2448 bool start_current
= false;
2450 if (start_index
>= 0 && global_settings
.play_selected
)
2452 /* store the seek position before the shuffle */
2453 seek_pos
= playlist
->indices
[start_index
];
2454 playlist
->index
= global_status
.resume_first_index
=
2455 playlist
->first_index
= start_index
;
2456 start_current
= true;
2459 randomise_playlist(playlist
, random_seed
, start_current
, true);
2461 return playlist
->index
;
2464 /* start playing current playlist at specified index/offset */
2465 int playlist_start(int start_index
, int offset
)
2467 struct playlist_info
* playlist
= ¤t_playlist
;
2469 /* Cancel FM radio selection as previous music. For cases where we start
2470 playback without going to the WPS, such as playlist insert.. or
2471 playlist catalog. */
2472 previous_music_is_wps();
2474 playlist
->index
= start_index
;
2476 #if CONFIG_CODEC != SWCODEC
2477 talk_buffer_steal(); /* will use the mp3 buffer */
2480 playlist
->started
= true;
2481 sync_control(playlist
, false);
2487 /* Returns false if 'steps' is out of bounds, else true */
2488 bool playlist_check(int steps
)
2490 struct playlist_info
* playlist
= ¤t_playlist
;
2492 /* always allow folder navigation */
2493 if (global_settings
.next_folder
&& playlist
->in_ram
)
2496 int index
= get_next_index(playlist
, steps
, -1);
2498 if (index
< 0 && steps
>= 0 && global_settings
.repeat_mode
== REPEAT_SHUFFLE
)
2499 index
= get_next_index(playlist
, steps
, REPEAT_ALL
);
2501 return (index
>= 0);
2504 /* get trackname of track that is "steps" away from current playing track.
2505 NULL is used to identify end of playlist */
2506 char* playlist_peek(int steps
)
2508 struct playlist_info
* playlist
= ¤t_playlist
;
2514 index
= get_next_index(playlist
, steps
, -1);
2518 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
2519 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
2521 if (get_filename(playlist
, index
, seek
, control_file
, now_playing
,
2525 temp_ptr
= now_playing
;
2527 if (!playlist
->in_ram
|| control_file
)
2529 /* remove bogus dirs from beginning of path
2530 (workaround for buggy playlist creation tools) */
2533 if (file_exists(temp_ptr
))
2536 temp_ptr
= strchr(temp_ptr
+1, '/');
2541 /* Even though this is an invalid file, we still need to pass a
2542 file name to the caller because NULL is used to indicate end
2552 * Update indices as track has changed
2554 int playlist_next(int steps
)
2556 struct playlist_info
* playlist
= ¤t_playlist
;
2560 #ifdef AB_REPEAT_ENABLE
2561 && (global_settings
.repeat_mode
!= REPEAT_AB
)
2563 && (global_settings
.repeat_mode
!= REPEAT_ONE
) )
2567 /* We need to delete all the queued songs */
2568 for (i
=0, j
=steps
; i
<j
; i
++)
2570 index
= get_next_index(playlist
, i
, -1);
2572 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
2574 remove_track_from_playlist(playlist
, index
, true);
2575 steps
--; /* one less track */
2580 index
= get_next_index(playlist
, steps
, -1);
2584 /* end of playlist... or is it */
2585 if (global_settings
.repeat_mode
== REPEAT_SHUFFLE
&&
2586 playlist
->amount
> 1)
2588 /* Repeat shuffle mode. Re-shuffle playlist and resume play */
2589 playlist
->first_index
= global_status
.resume_first_index
= 0;
2590 sort_playlist(playlist
, false, false);
2591 randomise_playlist(playlist
, current_tick
, false, true);
2592 #if CONFIG_CODEC != SWCODEC
2593 playlist_start(0, 0);
2595 playlist
->index
= 0;
2598 else if (playlist
->in_ram
&& global_settings
.next_folder
)
2600 index
= create_and_play_dir(steps
, true);
2604 playlist
->index
= index
;
2611 playlist
->index
= index
;
2613 if (playlist
->last_insert_pos
>= 0 && steps
> 0)
2615 /* check to see if we've gone beyond the last inserted track */
2616 int cur
= rotate_index(playlist
, index
);
2617 int last_pos
= rotate_index(playlist
, playlist
->last_insert_pos
);
2621 /* reset last inserted track */
2622 playlist
->last_insert_pos
= -1;
2624 if (playlist
->control_fd
>= 0)
2626 int result
= update_control(playlist
, PLAYLIST_COMMAND_RESET
,
2627 -1, -1, NULL
, NULL
, NULL
);
2632 sync_control(playlist
, false);
2640 /* try playing next or previous folder */
2641 bool playlist_next_dir(int direction
)
2643 /* not to mess up real playlists */
2644 if(!current_playlist
.in_ram
)
2647 return create_and_play_dir(direction
, false) >= 0;
2650 /* Get resume info for current playing song. If return value is -1 then
2651 settings shouldn't be saved. */
2652 int playlist_get_resume_info(int *resume_index
)
2654 struct playlist_info
* playlist
= ¤t_playlist
;
2656 *resume_index
= playlist
->index
;
2661 /* Update resume info for current playing song. Returns -1 on error. */
2662 int playlist_update_resume_info(const struct mp3entry
* id3
)
2664 struct playlist_info
* playlist
= ¤t_playlist
;
2668 if (global_status
.resume_index
!= playlist
->index
||
2669 global_status
.resume_offset
!= id3
->offset
)
2671 global_status
.resume_index
= playlist
->index
;
2672 global_status
.resume_offset
= id3
->offset
;
2678 global_status
.resume_index
= -1;
2679 global_status
.resume_offset
= -1;
2686 /* Returns index of current playing track for display purposes. This value
2687 should not be used for resume purposes as it doesn't represent the actual
2688 index into the playlist */
2689 int playlist_get_display_index(void)
2691 struct playlist_info
* playlist
= ¤t_playlist
;
2693 /* first_index should always be index 0 for display purposes */
2694 int index
= rotate_index(playlist
, playlist
->index
);
2699 /* returns number of tracks in current playlist */
2700 int playlist_amount(void)
2702 return playlist_amount_ex(NULL
);
2706 * Create a new playlist If playlist is not NULL then we're loading a
2707 * playlist off disk for viewing/editing. The index_buffer is used to store
2708 * playlist indices (required for and only used if !current playlist). The
2709 * temp_buffer (if not NULL) is used as a scratchpad when loading indices.
2711 int playlist_create_ex(struct playlist_info
* playlist
,
2712 const char* dir
, const char* file
,
2713 void* index_buffer
, int index_buffer_size
,
2714 void* temp_buffer
, int temp_buffer_size
)
2717 playlist
= ¤t_playlist
;
2720 /* Initialize playlist structure */
2721 int r
= rand() % 10;
2722 playlist
->current
= false;
2724 /* Use random name for control file */
2725 snprintf(playlist
->control_filename
, sizeof(playlist
->control_filename
),
2726 "%s.%d", PLAYLIST_CONTROL_FILE
, r
);
2728 playlist
->control_fd
= -1;
2732 int num_indices
= index_buffer_size
/ sizeof(int);
2734 #ifdef HAVE_DIRCACHE
2737 if (num_indices
> global_settings
.max_files_in_playlist
)
2738 num_indices
= global_settings
.max_files_in_playlist
;
2740 playlist
->max_playlist_size
= num_indices
;
2741 playlist
->indices
= index_buffer
;
2742 #ifdef HAVE_DIRCACHE
2743 playlist
->filenames
= (const struct dircache_entry
**)
2744 &playlist
->indices
[num_indices
];
2749 playlist
->max_playlist_size
= current_playlist
.max_playlist_size
;
2750 playlist
->indices
= current_playlist
.indices
;
2751 #ifdef HAVE_DIRCACHE
2752 playlist
->filenames
= current_playlist
.filenames
;
2756 playlist
->buffer_size
= 0;
2757 playlist
->buffer
= NULL
;
2758 mutex_init(&playlist
->control_mutex
);
2761 new_playlist(playlist
, dir
, file
);
2764 /* load the playlist file */
2765 add_indices_to_playlist(playlist
, temp_buffer
, temp_buffer_size
);
2771 * Set the specified playlist as the current.
2772 * NOTE: You will get undefined behaviour if something is already playing so
2773 * remember to stop before calling this. Also, this call will
2774 * effectively close your playlist, making it unusable.
2776 int playlist_set_current(struct playlist_info
* playlist
)
2778 if (!playlist
|| (check_control(playlist
) < 0))
2781 empty_playlist(¤t_playlist
, false);
2783 strncpy(current_playlist
.filename
, playlist
->filename
,
2784 sizeof(current_playlist
.filename
));
2786 current_playlist
.utf8
= playlist
->utf8
;
2787 current_playlist
.fd
= playlist
->fd
;
2789 close(playlist
->control_fd
);
2790 close(current_playlist
.control_fd
);
2791 remove(current_playlist
.control_filename
);
2792 if (rename(playlist
->control_filename
,
2793 current_playlist
.control_filename
) < 0)
2795 current_playlist
.control_fd
= open(current_playlist
.control_filename
,
2797 if (current_playlist
.control_fd
< 0)
2799 current_playlist
.control_created
= true;
2801 current_playlist
.dirlen
= playlist
->dirlen
;
2803 if (playlist
->indices
&& playlist
->indices
!= current_playlist
.indices
)
2805 memcpy(current_playlist
.indices
, playlist
->indices
,
2806 playlist
->max_playlist_size
*sizeof(int));
2807 #ifdef HAVE_DIRCACHE
2808 memcpy(current_playlist
.filenames
, playlist
->filenames
,
2809 playlist
->max_playlist_size
*sizeof(int));
2813 current_playlist
.first_index
= playlist
->first_index
;
2814 current_playlist
.amount
= playlist
->amount
;
2815 current_playlist
.last_insert_pos
= playlist
->last_insert_pos
;
2816 current_playlist
.seed
= playlist
->seed
;
2817 current_playlist
.shuffle_modified
= playlist
->shuffle_modified
;
2818 current_playlist
.deleted
= playlist
->deleted
;
2819 current_playlist
.num_inserted_tracks
= playlist
->num_inserted_tracks
;
2821 memcpy(current_playlist
.control_cache
, playlist
->control_cache
,
2822 sizeof(current_playlist
.control_cache
));
2823 current_playlist
.num_cached
= playlist
->num_cached
;
2824 current_playlist
.pending_control_sync
= playlist
->pending_control_sync
;
2830 * Close files and delete control file for non-current playlist.
2832 void playlist_close(struct playlist_info
* playlist
)
2837 if (playlist
->fd
>= 0)
2838 close(playlist
->fd
);
2840 if (playlist
->control_fd
>= 0)
2841 close(playlist
->control_fd
);
2843 if (playlist
->control_created
)
2844 remove(playlist
->control_filename
);
2847 void playlist_sync(struct playlist_info
* playlist
)
2850 playlist
= ¤t_playlist
;
2852 sync_control(playlist
, false);
2853 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2854 audio_flush_and_reload_tracks();
2856 #ifdef HAVE_DIRCACHE
2857 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2862 * Insert track into playlist at specified position (or one of the special
2863 * positions). Returns position where track was inserted or -1 if error.
2865 int playlist_insert_track(struct playlist_info
* playlist
, const char *filename
,
2866 int position
, bool queue
, bool sync
)
2871 playlist
= ¤t_playlist
;
2873 if (check_control(playlist
) < 0)
2875 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2879 result
= add_track_to_playlist(playlist
, filename
, position
, queue
, -1);
2881 /* Check if we want manually sync later. For example when adding
2882 * bunch of files from tagcache, syncing after every file wouldn't be
2883 * a good thing to do. */
2884 if (sync
&& result
>= 0)
2885 playlist_sync(playlist
);
2891 * Insert all tracks from specified directory into playlist.
2893 int playlist_insert_directory(struct playlist_info
* playlist
,
2894 const char *dirname
, int position
, bool queue
,
2898 unsigned char *count_str
;
2899 struct directory_search_context context
;
2902 playlist
= ¤t_playlist
;
2904 if (check_control(playlist
) < 0)
2906 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2910 if (position
== PLAYLIST_REPLACE
)
2912 if (playlist_remove_all_tracks(playlist
) == 0)
2913 position
= PLAYLIST_INSERT_LAST
;
2919 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
2921 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
2923 display_playlist_count(0, count_str
, false);
2925 context
.playlist
= playlist
;
2926 context
.position
= position
;
2927 context
.queue
= queue
;
2932 result
= playlist_directory_tracksearch(dirname
, recurse
,
2933 directory_search_callback
, &context
);
2935 sync_control(playlist
, false);
2939 display_playlist_count(context
.count
, count_str
, true);
2941 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
2942 audio_flush_and_reload_tracks();
2944 #ifdef HAVE_DIRCACHE
2945 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
2952 * Insert all tracks from specified playlist into dynamic playlist.
2954 int playlist_insert_playlist(struct playlist_info
* playlist
, const char *filename
,
2955 int position
, bool queue
)
2961 unsigned char *count_str
;
2962 char temp_buf
[MAX_PATH
+1];
2963 char trackname
[MAX_PATH
+1];
2966 bool utf8
= is_m3u8(filename
);
2969 playlist
= ¤t_playlist
;
2971 if (check_control(playlist
) < 0)
2973 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2977 fd
= open(filename
, O_RDONLY
);
2980 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
2984 /* we need the directory name for formatting purposes */
2987 temp_ptr
= strrchr(filename
+1,'/');
2994 count_str
= ID2P(LANG_PLAYLIST_QUEUE_COUNT
);
2996 count_str
= ID2P(LANG_PLAYLIST_INSERT_COUNT
);
2998 display_playlist_count(count
, count_str
, false);
3000 if (position
== PLAYLIST_REPLACE
)
3002 if (playlist_remove_all_tracks(playlist
) == 0)
3003 position
= PLAYLIST_INSERT_LAST
;
3009 while ((max
= read_line(fd
, temp_buf
, sizeof(temp_buf
))) > 0)
3012 if (action_userabort(TIMEOUT_NOBLOCK
))
3015 if (count
== 0 && is_utf8_bom(temp_buf
, max
))
3018 memmove(temp_buf
, temp_buf
+ BOM_SIZE
, max
);
3021 if (temp_buf
[0] != '#' && temp_buf
[0] != '\0')
3027 /* Use trackname as a temporay buffer. Note that trackname must
3028 * be as large as temp_buf.
3030 max
= convert_m3u(temp_buf
, max
, sizeof(temp_buf
), trackname
);
3033 /* we need to format so that relative paths are correctly
3035 if (format_track_path(trackname
, temp_buf
, sizeof(trackname
), max
,
3042 insert_pos
= add_track_to_playlist(playlist
, trackname
, position
,
3051 /* Make sure tracks are inserted in correct order if user
3052 requests INSERT_FIRST */
3053 if (position
== PLAYLIST_INSERT_FIRST
|| position
>= 0)
3054 position
= insert_pos
+ 1;
3058 if ((count
%PLAYLIST_DISPLAY_COUNT
) == 0)
3060 display_playlist_count(count
, count_str
, false);
3062 if (count
== PLAYLIST_DISPLAY_COUNT
&&
3063 (audio_status() & AUDIO_STATUS_PLAY
) &&
3065 audio_flush_and_reload_tracks();
3069 /* let the other threads work */
3078 sync_control(playlist
, false);
3082 display_playlist_count(count
, count_str
, true);
3084 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3085 audio_flush_and_reload_tracks();
3087 #ifdef HAVE_DIRCACHE
3088 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3095 * Delete track at specified index. If index is PLAYLIST_DELETE_CURRENT then
3096 * we want to delete the current playing track.
3098 int playlist_delete(struct playlist_info
* playlist
, int index
)
3103 playlist
= ¤t_playlist
;
3105 if (check_control(playlist
) < 0)
3107 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3111 if (index
== PLAYLIST_DELETE_CURRENT
)
3112 index
= playlist
->index
;
3114 result
= remove_track_from_playlist(playlist
, index
, true);
3116 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3118 audio_flush_and_reload_tracks();
3124 * Move track at index to new_index. Tracks between the two are shifted
3125 * appropriately. Returns 0 on success and -1 on failure.
3127 int playlist_move(struct playlist_info
* playlist
, int index
, int new_index
)
3133 bool current
= false;
3135 char filename
[MAX_PATH
];
3138 playlist
= ¤t_playlist
;
3140 if (check_control(playlist
) < 0)
3142 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
3146 if (index
== new_index
)
3149 if (index
== playlist
->index
)
3150 /* Moving the current track */
3153 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3154 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3155 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3157 if (get_filename(playlist
, index
, seek
, control_file
, filename
,
3158 sizeof(filename
)) < 0)
3161 /* Delete track from original position */
3162 result
= remove_track_from_playlist(playlist
, index
, true);
3166 /* We want to insert the track at the position that was specified by
3167 new_index. This may be different then new_index because of the
3168 shifting that occurred after the delete */
3169 r
= rotate_index(playlist
, new_index
);
3173 new_index
= PLAYLIST_PREPEND
;
3174 else if (r
== playlist
->amount
)
3176 new_index
= PLAYLIST_INSERT_LAST
;
3178 /* Calculate index of desired position */
3179 new_index
= (r
+playlist
->first_index
)%playlist
->amount
;
3181 result
= add_track_to_playlist(playlist
, filename
, new_index
, queue
,
3188 /* Moved the current track */
3191 case PLAYLIST_PREPEND
:
3192 playlist
->index
= playlist
->first_index
;
3194 case PLAYLIST_INSERT_LAST
:
3195 playlist
->index
= playlist
->first_index
- 1;
3196 if (playlist
->index
< 0)
3197 playlist
->index
+= playlist
->amount
;
3200 playlist
->index
= new_index
;
3205 if ((audio_status() & AUDIO_STATUS_PLAY
) && playlist
->started
)
3206 audio_flush_and_reload_tracks();
3210 #ifdef HAVE_DIRCACHE
3211 queue_post(&playlist_queue
, PLAYLIST_LOAD_POINTERS
, 0);
3217 /* shuffle currently playing playlist */
3218 int playlist_randomise(struct playlist_info
* playlist
, unsigned int seed
,
3224 playlist
= ¤t_playlist
;
3226 check_control(playlist
);
3228 result
= randomise_playlist(playlist
, seed
, start_current
, true);
3230 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3232 audio_flush_and_reload_tracks();
3237 /* sort currently playing playlist */
3238 int playlist_sort(struct playlist_info
* playlist
, bool start_current
)
3243 playlist
= ¤t_playlist
;
3245 check_control(playlist
);
3247 result
= sort_playlist(playlist
, start_current
, true);
3249 if (result
!= -1 && (audio_status() & AUDIO_STATUS_PLAY
) &&
3251 audio_flush_and_reload_tracks();
3256 /* returns true if playlist has been modified */
3257 bool playlist_modified(const struct playlist_info
* playlist
)
3260 playlist
= ¤t_playlist
;
3262 if (playlist
->shuffle_modified
||
3263 playlist
->deleted
||
3264 playlist
->num_inserted_tracks
> 0)
3270 /* returns index of first track in playlist */
3271 int playlist_get_first_index(const struct playlist_info
* playlist
)
3274 playlist
= ¤t_playlist
;
3276 return playlist
->first_index
;
3279 /* returns shuffle seed of playlist */
3280 int playlist_get_seed(const struct playlist_info
* playlist
)
3283 playlist
= ¤t_playlist
;
3285 return playlist
->seed
;
3288 /* returns number of tracks in playlist (includes queued/inserted tracks) */
3289 int playlist_amount_ex(const struct playlist_info
* playlist
)
3292 playlist
= ¤t_playlist
;
3294 return playlist
->amount
;
3297 /* returns full path of playlist (minus extension) */
3298 char *playlist_name(const struct playlist_info
* playlist
, char *buf
,
3304 playlist
= ¤t_playlist
;
3306 snprintf(buf
, buf_size
, "%s", playlist
->filename
+playlist
->dirlen
);
3311 /* Remove extension */
3312 sep
= strrchr(buf
, '.');
3319 /* returns the playlist filename */
3320 char *playlist_get_name(const struct playlist_info
* playlist
, char *buf
,
3324 playlist
= ¤t_playlist
;
3326 snprintf(buf
, buf_size
, "%s", playlist
->filename
);
3334 /* Fills info structure with information about track at specified index.
3335 Returns 0 on success and -1 on failure */
3336 int playlist_get_track_info(struct playlist_info
* playlist
, int index
,
3337 struct playlist_track_info
* info
)
3343 playlist
= ¤t_playlist
;
3345 if (index
< 0 || index
>= playlist
->amount
)
3348 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3349 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3351 if (get_filename(playlist
, index
, seek
, control_file
, info
->filename
,
3352 sizeof(info
->filename
)) < 0)
3359 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
3360 info
->attr
|= PLAYLIST_ATTR_QUEUED
;
3362 info
->attr
|= PLAYLIST_ATTR_INSERTED
;
3366 if (playlist
->indices
[index
] & PLAYLIST_SKIPPED
)
3367 info
->attr
|= PLAYLIST_ATTR_SKIPPED
;
3369 info
->index
= index
;
3370 info
->display_index
= rotate_index(playlist
, index
) + 1;
3375 /* save the current dynamic playlist to specified file */
3376 int playlist_save(struct playlist_info
* playlist
, char *filename
)
3381 char path
[MAX_PATH
+1];
3382 char tmp_buf
[MAX_PATH
+1];
3384 bool overwrite_current
= false;
3385 int* index_buf
= NULL
;
3388 playlist
= ¤t_playlist
;
3390 if (playlist
->amount
<= 0)
3393 /* use current working directory as base for pathname */
3394 if (format_track_path(path
, filename
, sizeof(tmp_buf
),
3395 strlen(filename
)+1, getcwd(NULL
, -1)) < 0)
3398 if (!strncmp(playlist
->filename
, path
, strlen(path
)))
3400 /* Attempting to overwrite current playlist file.*/
3402 if (playlist
->buffer_size
< (int)(playlist
->amount
* sizeof(int)))
3404 /* not enough buffer space to store updated indices */
3405 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3409 /* in_ram buffer is unused for m3u files so we'll use for storing
3411 index_buf
= (int*)playlist
->buffer
;
3413 /* use temporary pathname */
3414 snprintf(path
, sizeof(path
), "%s_temp", playlist
->filename
);
3415 overwrite_current
= true;
3418 fd
= open(path
, O_CREAT
|O_WRONLY
|O_TRUNC
);
3421 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3425 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
), false);
3431 /* some applications require a BOM to read the file properly */
3432 write(fd
, BOM
, BOM_SIZE
);
3435 index
= playlist
->first_index
;
3436 for (i
=0; i
<playlist
->amount
; i
++)
3443 if (action_userabort(TIMEOUT_NOBLOCK
))
3449 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
3450 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
3451 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
3453 /* Don't save queued files */
3456 if (get_filename(playlist
, index
, seek
, control_file
, tmp_buf
,
3463 if (overwrite_current
)
3464 index_buf
[count
] = lseek(fd
, 0, SEEK_CUR
);
3466 if (fdprintf(fd
, "%s\n", tmp_buf
) < 0)
3468 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR
));
3475 if ((count
% PLAYLIST_DISPLAY_COUNT
) == 0)
3476 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
),
3482 index
= (index
+1)%playlist
->amount
;
3485 display_playlist_count(count
, ID2P(LANG_PLAYLIST_SAVE_COUNT
), true);
3489 if (overwrite_current
&& result
>= 0)
3493 mutex_lock(&playlist
->control_mutex
);
3495 /* Replace the current playlist with the new one and update indices */
3496 close(playlist
->fd
);
3497 if (remove(playlist
->filename
) >= 0)
3499 if (rename(path
, playlist
->filename
) >= 0)
3501 playlist
->fd
= open(playlist
->filename
, O_RDONLY
);
3502 if (playlist
->fd
>= 0)
3504 index
= playlist
->first_index
;
3505 for (i
=0, count
=0; i
<playlist
->amount
; i
++)
3507 if (!(playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
))
3509 playlist
->indices
[index
] = index_buf
[count
];
3512 index
= (index
+1)%playlist
->amount
;
3515 /* we need to recreate control because inserted tracks are
3516 now part of the playlist and shuffle has been
3518 result
= recreate_control(playlist
);
3523 mutex_unlock(&playlist
->control_mutex
);
3533 * Search specified directory for tracks and notify via callback. May be
3534 * called recursively.
3536 int playlist_directory_tracksearch(const char* dirname
, bool recurse
,
3537 int (*callback
)(char*, void*),
3540 char buf
[MAX_PATH
+1];
3544 struct entry
*files
;
3545 struct tree_context
* tc
= tree_get_context();
3546 int old_dirfilter
= *(tc
->dirfilter
);
3551 /* use the tree browser dircache to load files */
3552 *(tc
->dirfilter
) = SHOW_ALL
;
3554 if (ft_load(tc
, dirname
) < 0)
3556 gui_syncsplash(HZ
*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
3557 *(tc
->dirfilter
) = old_dirfilter
;
3561 files
= (struct entry
*) tc
->dircache
;
3562 num_files
= tc
->filesindir
;
3564 /* we've overwritten the dircache so tree browser will need to be
3568 for (i
=0; i
<num_files
; i
++)
3571 if (action_userabort(TIMEOUT_NOBLOCK
))
3577 if (files
[i
].attr
& ATTR_DIRECTORY
)
3581 /* recursively add directories */
3582 snprintf(buf
, sizeof(buf
), "%s/%s", dirname
, files
[i
].name
);
3583 result
= playlist_directory_tracksearch(buf
, recurse
,
3588 /* we now need to reload our current directory */
3589 if(ft_load(tc
, dirname
) < 0)
3595 files
= (struct entry
*) tc
->dircache
;
3596 num_files
= tc
->filesindir
;
3606 else if ((files
[i
].attr
& FILE_ATTR_MASK
) == FILE_ATTR_AUDIO
)
3608 snprintf(buf
, sizeof(buf
), "%s/%s", dirname
, files
[i
].name
);
3610 if (callback(buf
, context
) != 0)
3616 /* let the other threads work */
3621 /* restore dirfilter */
3622 *(tc
->dirfilter
) = old_dirfilter
;