1 /***************************************************************************
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
10 * Copyright (C) 2002 by wavey@wavey.org
12 * All files in this archive are subject to the GNU General Public License.
13 * See the file COPYING in the source tree root for full license agreement.
15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
16 * KIND, either express or implied.
18 ****************************************************************************/
21 Dynamic playlist design (based on design originally proposed by ricII)
23 There are two files associated with a dynamic playlist:
24 1. Playlist file : This file contains the initial songs in the playlist.
25 The file is created by the user and stored on the hard
26 drive. NOTE: If we are playing the contents of a
27 directory, there will be no playlist file.
28 2. Control file : This file is automatically created when a playlist is
29 started and contains all the commands done to it.
31 The first non-comment line in a control file must begin with
32 "P:VERSION:DIR:FILE" where VERSION is the playlist control file version,
33 DIR is the directory where the playlist is located and FILE is the
34 playlist filename. For dirplay, FILE will be empty. An empty playlist
35 will have both entries as null.
37 Control file commands:
38 a. Add track (A:<position>:<last position>:<path to track>)
39 - Insert a track at the specified position in the current
40 playlist. Last position is used to specify where last insertion
42 b. Queue track (Q:<position>:<last position>:<path to track>)
43 - Queue a track at the specified position in the current
44 playlist. Queued tracks differ from added tracks in that they
45 are deleted from the playlist as soon as they are played and
46 they are not saved to disk as part of the playlist.
47 c. Delete track (D:<position>)
48 - Delete track from specified position in the current playlist.
49 d. Shuffle playlist (S:<seed>:<index>)
50 - Shuffle entire playlist with specified seed. The index
51 identifies the first index in the newly shuffled playlist
52 (needed for repeat mode).
53 e. Unshuffle playlist (U:<index>)
54 - Unshuffle entire playlist. The index identifies the first index
55 in the newly unshuffled playlist.
56 f. Reset last insert position (R)
57 - Needed so that insertions work properly after resume
60 The only resume info that needs to be saved is the current index in the
61 playlist and the position in the track. When resuming, all the commands
62 in the control file will be reapplied so that the playlist indices are
63 exactly the same as before shutdown. To avoid unnecessary disk
64 accesses, the shuffle mode settings are also saved in settings and only
65 flushed to disk when required.
81 #include "applimits.h"
88 #ifdef HAVE_LCD_BITMAP
96 #define PLAYLIST_CONTROL_FILE ROCKBOX_DIR "/.playlist_control"
97 #define PLAYLIST_CONTROL_FILE_VERSION 2
100 Each playlist index has a flag associated with it which identifies what
101 type of track it is. These flags are stored in the 3 high order bits of
104 NOTE: This limits the playlist file size to a max of 512M.
108 01 = Track was prepended into playlist
109 10 = Track was inserted into playlist
110 11 = Track was appended into playlist
115 #define PLAYLIST_SEEK_MASK 0x1FFFFFFF
116 #define PLAYLIST_INSERT_TYPE_MASK 0xC0000000
117 #define PLAYLIST_QUEUE_MASK 0x20000000
119 #define PLAYLIST_INSERT_TYPE_PREPEND 0x40000000
120 #define PLAYLIST_INSERT_TYPE_INSERT 0x80000000
121 #define PLAYLIST_INSERT_TYPE_APPEND 0xC0000000
123 #define PLAYLIST_QUEUED 0x20000000
125 #define PLAYLIST_DISPLAY_COUNT 10
127 static struct playlist_info current_playlist
;
128 static char now_playing
[MAX_PATH
+1];
130 static void empty_playlist(struct playlist_info
* playlist
, bool resume
);
131 static void new_playlist(struct playlist_info
* playlist
, const char *dir
,
133 static void create_control(struct playlist_info
* playlist
);
134 static int check_control(struct playlist_info
* playlist
);
135 static void update_playlist_filename(struct playlist_info
* playlist
,
136 const char *dir
, const char *file
);
137 static int add_indices_to_playlist(struct playlist_info
* playlist
,
138 char* buffer
, int buflen
);
139 static int add_track_to_playlist(struct playlist_info
* playlist
,
140 const char *filename
, int position
,
141 bool queue
, int seek_pos
);
142 static int add_directory_to_playlist(struct playlist_info
* playlist
,
143 const char *dirname
, int *position
, bool queue
,
144 int *count
, bool recurse
);
145 static int remove_track_from_playlist(struct playlist_info
* playlist
,
146 int position
, bool write
);
147 static int randomise_playlist(struct playlist_info
* playlist
,
148 unsigned int seed
, bool start_current
,
150 static int sort_playlist(struct playlist_info
* playlist
, bool start_current
,
152 static int get_next_index(const struct playlist_info
* playlist
, int steps
);
153 static void find_and_set_playlist_index(struct playlist_info
* playlist
,
155 static int compare(const void* p1
, const void* p2
);
156 static int get_filename(struct playlist_info
* playlist
, int seek
,
157 bool control_file
, char *buf
, int buf_length
);
158 static int format_track_path(char *dest
, char *src
, int buf_length
, int max
,
160 static void display_playlist_count(int count
, const char *fmt
);
161 static void display_buffer_full(void);
162 static int flush_pending_control(struct playlist_info
* playlist
);
163 static int rotate_index(const struct playlist_info
* playlist
, int index
);
166 * remove any files and indices associated with the playlist
168 static void empty_playlist(struct playlist_info
* playlist
, bool resume
)
170 playlist
->filename
[0] = '\0';
172 if(playlist
->fd
>= 0)
173 /* If there is an already open playlist, close it. */
177 if(playlist
->control_fd
>= 0)
178 close(playlist
->control_fd
);
179 playlist
->control_fd
= -1;
180 playlist
->control_created
= false;
182 playlist
->in_ram
= false;
184 if (playlist
->buffer
)
185 playlist
->buffer
[0] = 0;
187 playlist
->buffer_end_pos
= 0;
190 playlist
->first_index
= 0;
191 playlist
->amount
= 0;
192 playlist
->last_insert_pos
= -1;
194 playlist
->shuffle_modified
= false;
195 playlist
->deleted
= false;
196 playlist
->num_inserted_tracks
= 0;
197 playlist
->shuffle_flush
= false;
199 if (!resume
&& playlist
->current
)
201 /* start with fresh playlist control file when starting new
203 create_control(playlist
);
205 /* Reset resume settings */
206 global_settings
.resume_first_index
= 0;
207 global_settings
.resume_seed
= -1;
212 * Initialize a new playlist for viewing/editing/playing. dir is the
213 * directory where the playlist is located and file is the filename.
215 static void new_playlist(struct playlist_info
* playlist
, const char *dir
,
218 empty_playlist(playlist
, false);
224 if (dir
&& playlist
->current
) /* !current cannot be in_ram */
225 playlist
->in_ram
= true;
227 dir
= ""; /* empty playlist */
230 update_playlist_filename(playlist
, dir
, file
);
232 if (playlist
->control_fd
>= 0)
234 if (fprintf(playlist
->control_fd
, "P:%d:%s:%s\n",
235 PLAYLIST_CONTROL_FILE_VERSION
, dir
, file
) > 0)
236 fsync(playlist
->control_fd
);
238 splash(HZ
*2, true, str(LANG_PLAYLIST_CONTROL_UPDATE_ERROR
));
243 * create control file for playlist
245 static void create_control(struct playlist_info
* playlist
)
247 playlist
->control_fd
= open(playlist
->control_filename
,
248 O_CREAT
|O_RDWR
|O_TRUNC
);
249 if (playlist
->control_fd
< 0)
251 if (check_rockboxdir())
253 splash(HZ
*2, true, "%s (%d)", str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
),
254 playlist
->control_fd
);
256 playlist
->control_created
= false;
260 playlist
->control_created
= true;
265 * validate the control file. This may include creating/initializing it if
268 static int check_control(struct playlist_info
* playlist
)
270 if (!playlist
->control_created
)
272 create_control(playlist
);
274 if (playlist
->control_fd
>= 0)
276 char* dir
= playlist
->filename
;
277 char* file
= playlist
->filename
+playlist
->dirlen
;
278 char c
= playlist
->filename
[playlist
->dirlen
-1];
280 playlist
->filename
[playlist
->dirlen
-1] = '\0';
282 if (fprintf(playlist
->control_fd
, "P:%d:%s:%s\n",
283 PLAYLIST_CONTROL_FILE_VERSION
, dir
, file
) > 0)
284 fsync(playlist
->control_fd
);
286 splash(HZ
*2, true, str(LANG_PLAYLIST_CONTROL_UPDATE_ERROR
));
288 playlist
->filename
[playlist
->dirlen
-1] = c
;
292 if (playlist
->control_fd
< 0)
299 * store directory and name of playlist file
301 static void update_playlist_filename(struct playlist_info
* playlist
,
302 const char *dir
, const char *file
)
305 int dirlen
= strlen(dir
);
307 /* If the dir does not end in trailing slash, we use a separator.
308 Otherwise we don't. */
309 if('/' != dir
[dirlen
-1])
315 playlist
->dirlen
= dirlen
;
317 snprintf(playlist
->filename
, sizeof(playlist
->filename
),
323 * calculate track offsets within a playlist file
325 static int add_indices_to_playlist(struct playlist_info
* playlist
,
326 char* buffer
, int buflen
)
330 unsigned int count
= 0;
334 if(-1 == playlist
->fd
)
335 playlist
->fd
= open(playlist
->filename
, O_RDONLY
);
337 return -1; /* failure */
339 #ifdef HAVE_LCD_BITMAP
340 if(global_settings
.statusbar
)
341 lcd_setmargins(0, STATUSBAR_HEIGHT
);
343 lcd_setmargins(0, 0);
346 splash(0, true, str(LANG_PLAYLIST_LOAD
));
350 /* use mp3 buffer for maximum load speed */
352 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
355 buflen
= (mp3end
- mp3buf
);
362 nread
= read(playlist
->fd
, buffer
, buflen
);
363 /* Terminate on EOF */
369 for(count
=0; count
< nread
; count
++,p
++) {
371 /* Are we on a new line? */
372 if((*p
== '\n') || (*p
== '\r'))
382 /* Store a new entry */
383 playlist
->indices
[ playlist
->amount
] = i
+count
;
385 if ( playlist
->amount
>= playlist
->max_playlist_size
) {
386 display_buffer_full();
400 * Add track to playlist at specified position. There are three special
401 * positions that can be specified:
402 * PLAYLIST_PREPEND - Add track at beginning of playlist
403 * PLAYLIST_INSERT - Add track after current song. NOTE: If there
404 * are already inserted tracks then track is added
405 * to the end of the insertion list.
406 * PLAYLIST_INSERT_FIRST - Add track immediately after current song, no
407 * matter what other tracks have been inserted.
408 * PLAYLIST_INSERT_LAST - Add track to end of playlist
410 static int add_track_to_playlist(struct playlist_info
* playlist
,
411 const char *filename
, int position
,
412 bool queue
, int seek_pos
)
414 int insert_position
= position
;
415 unsigned int flags
= PLAYLIST_INSERT_TYPE_INSERT
;
418 if (playlist
->amount
>= playlist
->max_playlist_size
)
420 display_buffer_full();
426 case PLAYLIST_PREPEND
:
427 insert_position
= playlist
->first_index
;
428 flags
= PLAYLIST_INSERT_TYPE_PREPEND
;
430 case PLAYLIST_INSERT
:
431 /* if there are already inserted tracks then add track to end of
432 insertion list else add after current playing track */
433 if (playlist
->last_insert_pos
>= 0 &&
434 playlist
->last_insert_pos
< playlist
->amount
&&
435 (playlist
->indices
[playlist
->last_insert_pos
]&
436 PLAYLIST_INSERT_TYPE_MASK
) == PLAYLIST_INSERT_TYPE_INSERT
)
437 position
= insert_position
= playlist
->last_insert_pos
+1;
438 else if (playlist
->amount
> 0)
439 position
= insert_position
= playlist
->index
+ 1;
441 position
= insert_position
= 0;
443 playlist
->last_insert_pos
= position
;
445 case PLAYLIST_INSERT_FIRST
:
446 if (playlist
->amount
> 0)
447 position
= insert_position
= playlist
->index
+ 1;
449 position
= insert_position
= 0;
451 if (playlist
->last_insert_pos
< 0)
452 playlist
->last_insert_pos
= position
;
454 case PLAYLIST_INSERT_LAST
:
455 if (playlist
->first_index
> 0)
456 insert_position
= playlist
->first_index
;
458 insert_position
= playlist
->amount
;
460 flags
= PLAYLIST_INSERT_TYPE_APPEND
;
465 flags
|= PLAYLIST_QUEUED
;
467 /* shift indices so that track can be added */
468 for (i
=playlist
->amount
; i
>insert_position
; i
--)
469 playlist
->indices
[i
] = playlist
->indices
[i
-1];
471 /* update stored indices if needed */
472 if (playlist
->amount
> 0 && insert_position
<= playlist
->index
)
475 if (playlist
->amount
> 0 && insert_position
<= playlist
->first_index
&&
476 position
!= PLAYLIST_PREPEND
)
478 playlist
->first_index
++;
480 if (seek_pos
< 0 && playlist
->current
)
482 global_settings
.resume_first_index
= playlist
->first_index
;
487 if (insert_position
< playlist
->last_insert_pos
||
488 (insert_position
== playlist
->last_insert_pos
&& position
< 0))
489 playlist
->last_insert_pos
++;
491 if (seek_pos
< 0 && playlist
->control_fd
>= 0)
495 if (flush_pending_control(playlist
) < 0)
498 mutex_lock(&playlist
->control_mutex
);
500 if (lseek(playlist
->control_fd
, 0, SEEK_END
) >= 0)
502 if (fprintf(playlist
->control_fd
, "%c:%d:%d:", (queue
?'Q':'A'),
503 position
, playlist
->last_insert_pos
) > 0)
505 /* save the position in file where track name is written */
506 seek_pos
= lseek(playlist
->control_fd
, 0, SEEK_CUR
);
508 if (fprintf(playlist
->control_fd
, "%s\n", filename
) > 0)
513 mutex_unlock(&playlist
->control_mutex
);
517 splash(HZ
*2, true, str(LANG_PLAYLIST_CONTROL_UPDATE_ERROR
));
522 playlist
->indices
[insert_position
] = flags
| seek_pos
;
525 playlist
->num_inserted_tracks
++;
527 return insert_position
;
531 * Insert directory into playlist. May be called recursively.
533 static int add_directory_to_playlist(struct playlist_info
* playlist
,
534 const char *dirname
, int *position
, bool queue
,
535 int *count
, bool recurse
)
537 char buf
[MAX_PATH
+1];
542 int dirfilter
= global_settings
.dirfilter
;
544 struct tree_context
* tc
= tree_get_context();
546 /* use the tree browser dircache to load files */
547 global_settings
.dirfilter
= SHOW_ALL
;
548 num_files
= ft_load(tc
, dirname
);
549 files
= (struct entry
*) tc
->dircache
;
553 splash(HZ
*2, true, str(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR
));
557 /* we've overwritten the dircache so tree browser will need to be
562 count_str
= str(LANG_PLAYLIST_QUEUE_COUNT
);
564 count_str
= str(LANG_PLAYLIST_INSERT_COUNT
);
566 for (i
=0; i
<num_files
; i
++)
569 if (button_get(false) == SETTINGS_CANCEL
)
575 if (files
[i
].attr
& ATTR_DIRECTORY
)
579 /* recursively add directories */
580 snprintf(buf
, sizeof(buf
), "%s/%s", dirname
, files
[i
].name
);
581 result
= add_directory_to_playlist(playlist
, buf
, position
,
582 queue
, count
, recurse
);
586 /* we now need to reload our current directory */
587 num_files
= ft_load(tc
, dirname
);
588 files
= (struct entry
*) tc
->dircache
;
598 else if ((files
[i
].attr
& TREE_ATTR_MASK
) == TREE_ATTR_MPA
)
602 snprintf(buf
, sizeof(buf
), "%s/%s", dirname
, files
[i
].name
);
604 insert_pos
= add_track_to_playlist(playlist
, buf
, *position
,
614 /* Make sure tracks are inserted in correct order if user requests
616 if (*position
== PLAYLIST_INSERT_FIRST
|| *position
>= 0)
617 *position
= insert_pos
+ 1;
619 if ((*count
%PLAYLIST_DISPLAY_COUNT
) == 0)
621 display_playlist_count(*count
, count_str
);
623 if (*count
== PLAYLIST_DISPLAY_COUNT
)
624 mpeg_flush_and_reload_tracks();
627 /* let the other threads work */
632 /* restore dirfilter */
633 global_settings
.dirfilter
= dirfilter
;
639 * remove track at specified position
641 static int remove_track_from_playlist(struct playlist_info
* playlist
,
642 int position
, bool write
)
647 if (playlist
->amount
<= 0)
650 inserted
= playlist
->indices
[position
] & PLAYLIST_INSERT_TYPE_MASK
;
652 /* shift indices now that track has been removed */
653 for (i
=position
; i
<playlist
->amount
; i
++)
654 playlist
->indices
[i
] = playlist
->indices
[i
+1];
659 playlist
->num_inserted_tracks
--;
661 playlist
->deleted
= true;
663 /* update stored indices if needed */
664 if (position
< playlist
->index
)
667 if (position
< playlist
->first_index
)
669 playlist
->first_index
--;
673 global_settings
.resume_first_index
= playlist
->first_index
;
678 if (position
<= playlist
->last_insert_pos
)
679 playlist
->last_insert_pos
--;
681 if (write
&& playlist
->control_fd
>= 0)
685 if (flush_pending_control(playlist
) < 0)
688 mutex_lock(&playlist
->control_mutex
);
690 if (lseek(playlist
->control_fd
, 0, SEEK_END
) >= 0)
692 if (fprintf(playlist
->control_fd
, "D:%d\n", position
) > 0)
694 fsync(playlist
->control_fd
);
699 mutex_unlock(&playlist
->control_mutex
);
703 splash(HZ
*2, true, str(LANG_PLAYLIST_CONTROL_UPDATE_ERROR
));
712 * randomly rearrange the array of indices for the playlist. If start_current
713 * is true then update the index to the new index of the current playing track
715 static int randomise_playlist(struct playlist_info
* playlist
,
716 unsigned int seed
, bool start_current
,
722 unsigned int current
= playlist
->indices
[playlist
->index
];
724 /* seed 0 is used to identify sorted playlist for resume purposes */
728 /* seed with the given seed */
731 /* randomise entire indices list */
732 for(count
= playlist
->amount
- 1; count
>= 0; count
--)
734 /* the rand is from 0 to RAND_MAX, so adjust to our value range */
735 candidate
= rand() % (count
+ 1);
737 /* now swap the values at the 'count' and 'candidate' positions */
738 store
= playlist
->indices
[candidate
];
739 playlist
->indices
[candidate
] = playlist
->indices
[count
];
740 playlist
->indices
[count
] = store
;
744 find_and_set_playlist_index(playlist
, current
);
746 /* indices have been moved so last insert position is no longer valid */
747 playlist
->last_insert_pos
= -1;
749 playlist
->seed
= seed
;
750 if (playlist
->num_inserted_tracks
> 0 || playlist
->deleted
)
751 playlist
->shuffle_modified
= true;
755 /* Don't write to disk immediately. Instead, save in settings and
756 only flush if playlist is modified (insertion/deletion) */
757 playlist
->shuffle_flush
= true;
758 global_settings
.resume_seed
= seed
;
766 * Sort the array of indices for the playlist. If start_current is true then
767 * set the index to the new index of the current song.
769 static int sort_playlist(struct playlist_info
* playlist
, bool start_current
,
772 unsigned int current
= playlist
->indices
[playlist
->index
];
774 if (playlist
->amount
> 0)
775 qsort(playlist
->indices
, playlist
->amount
, sizeof(playlist
->indices
[0]),
779 find_and_set_playlist_index(playlist
, current
);
781 /* indices have been moved so last insert position is no longer valid */
782 playlist
->last_insert_pos
= -1;
784 if (!playlist
->num_inserted_tracks
&& !playlist
->deleted
)
785 playlist
->shuffle_modified
= false;
786 if (write
&& playlist
->control_fd
>= 0)
788 /* Don't write to disk immediately. Instead, save in settings and
789 only flush if playlist is modified (insertion/deletion) */
790 playlist
->shuffle_flush
= true;
791 global_settings
.resume_seed
= 0;
799 * returns the index of the track that is "steps" away from current playing
802 static int get_next_index(const struct playlist_info
* playlist
, int steps
)
804 int current_index
= playlist
->index
;
807 if (playlist
->amount
<= 0)
810 switch (global_settings
.repeat_mode
)
814 current_index
= rotate_index(playlist
, current_index
);
816 next_index
= current_index
+steps
;
817 if ((next_index
< 0) || (next_index
>= playlist
->amount
))
820 next_index
= (next_index
+playlist
->first_index
) %
827 next_index
= current_index
;
833 next_index
= (current_index
+steps
) % playlist
->amount
;
834 while (next_index
< 0)
835 next_index
+= playlist
->amount
;
837 if (steps
>= playlist
->amount
)
844 /* second time around so skip the queued files */
845 for (i
=0; i
<playlist
->amount
; i
++)
847 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
848 index
= (index
+1) % playlist
->amount
;
864 * Search for the seek track and set appropriate indices. Used after shuffle
865 * to make sure the current index is still pointing to correct track.
867 static void find_and_set_playlist_index(struct playlist_info
* playlist
,
872 /* Set the index to the current song */
873 for (i
=0; i
<playlist
->amount
; i
++)
875 if (playlist
->indices
[i
] == seek
)
877 playlist
->index
= playlist
->first_index
= i
;
879 if (playlist
->current
)
881 global_settings
.resume_first_index
= i
;
891 * used to sort track indices. Sort order is as follows:
892 * 1. Prepended tracks (in prepend order)
893 * 2. Playlist/directory tracks (in playlist order)
894 * 3. Inserted/Appended tracks (in insert order)
896 static int compare(const void* p1
, const void* p2
)
898 unsigned int* e1
= (unsigned int*) p1
;
899 unsigned int* e2
= (unsigned int*) p2
;
900 unsigned int flags1
= *e1
& PLAYLIST_INSERT_TYPE_MASK
;
901 unsigned int flags2
= *e2
& PLAYLIST_INSERT_TYPE_MASK
;
903 if (flags1
== flags2
)
904 return (*e1
& PLAYLIST_SEEK_MASK
) - (*e2
& PLAYLIST_SEEK_MASK
);
905 else if (flags1
== PLAYLIST_INSERT_TYPE_PREPEND
||
906 flags2
== PLAYLIST_INSERT_TYPE_APPEND
)
908 else if (flags1
== PLAYLIST_INSERT_TYPE_APPEND
||
909 flags2
== PLAYLIST_INSERT_TYPE_PREPEND
)
911 else if (flags1
&& flags2
)
912 return (*e1
& PLAYLIST_SEEK_MASK
) - (*e2
& PLAYLIST_SEEK_MASK
);
918 * gets pathname for track at seek index
920 static int get_filename(struct playlist_info
* playlist
, int seek
,
921 bool control_file
, char *buf
, int buf_length
)
925 char tmp_buf
[MAX_PATH
+1];
926 char dir_buf
[MAX_PATH
+1];
928 if (buf_length
> MAX_PATH
+1)
929 buf_length
= MAX_PATH
+1;
931 if (playlist
->in_ram
&& !control_file
)
933 strncpy(tmp_buf
, &playlist
->buffer
[seek
], sizeof(tmp_buf
));
934 tmp_buf
[MAX_PATH
] = '\0';
935 max
= strlen(tmp_buf
) + 1;
940 fd
= playlist
->control_fd
;
943 if(-1 == playlist
->fd
)
944 playlist
->fd
= open(playlist
->filename
, O_RDONLY
);
952 mutex_lock(&playlist
->control_mutex
);
954 if (lseek(fd
, seek
, SEEK_SET
) != seek
)
957 max
= read(fd
, tmp_buf
, buf_length
);
960 mutex_unlock(&playlist
->control_mutex
);
966 splash(HZ
*2, true, str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
968 splash(HZ
*2, true, str(LANG_PLAYLIST_ACCESS_ERROR
));
974 strncpy(dir_buf
, playlist
->filename
, playlist
->dirlen
-1);
975 dir_buf
[playlist
->dirlen
-1] = 0;
977 return (format_track_path(buf
, tmp_buf
, buf_length
, max
, dir_buf
));
981 * Returns absolute path of track
983 static int format_track_path(char *dest
, char *src
, int buf_length
, int max
,
990 /* Zero-terminate the file name */
991 while((src
[i
] != '\n') &&
996 /* Now work back killing white space */
997 while((src
[i
-1] == ' ') ||
1003 /* replace backslashes with forward slashes */
1004 for ( j
=0; j
<i
; j
++ )
1005 if ( src
[j
] == '\\' )
1010 strncpy(dest
, src
, buf_length
);
1014 /* handle dos style drive letter */
1016 strncpy(dest
, &src
[2], buf_length
);
1017 else if (!strncmp(src
, "../", 3))
1019 /* handle relative paths */
1021 while(!strncmp(&src
[i
], "../", 3))
1023 for (j
=0; j
<i
/3; j
++) {
1024 temp_ptr
= strrchr(dir
, '/');
1030 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[i
]);
1032 else if ( '.' == src
[0] && '/' == src
[1] ) {
1033 snprintf(dest
, buf_length
, "%s/%s", dir
, &src
[2]);
1036 snprintf(dest
, buf_length
, "%s/%s", dir
, src
);
1044 * Display splash message showing progress of playlist/directory insertion or
1047 static void display_playlist_count(int count
, const char *fmt
)
1049 lcd_clear_display();
1051 #ifdef HAVE_LCD_BITMAP
1052 if(global_settings
.statusbar
)
1053 lcd_setmargins(0, STATUSBAR_HEIGHT
);
1055 lcd_setmargins(0, 0);
1058 splash(0, true, fmt
, count
,
1059 #if CONFIG_KEYPAD == PLAYER_PAD
1060 str(LANG_STOP_ABORT
)
1068 * Display buffer full message
1070 static void display_buffer_full(void)
1072 splash(HZ
*2, true, "%s %s",
1073 str(LANG_PLAYINDICES_PLAYLIST
),
1074 str(LANG_PLAYINDICES_BUFFER
));
1078 * Flush any pending control commands to disk. Called when playlist is being
1079 * modified. Returns 0 on success and -1 on failure.
1081 static int flush_pending_control(struct playlist_info
* playlist
)
1085 if (playlist
->shuffle_flush
&& global_settings
.resume_seed
>= 0)
1087 /* pending shuffle */
1088 mutex_lock(&playlist
->control_mutex
);
1090 if (lseek(playlist
->control_fd
, 0, SEEK_END
) >= 0)
1092 if (global_settings
.resume_seed
== 0)
1093 result
= fprintf(playlist
->control_fd
, "U:%d\n",
1094 playlist
->first_index
);
1096 result
= fprintf(playlist
->control_fd
, "S:%d:%d\n",
1097 global_settings
.resume_seed
, playlist
->first_index
);
1101 fsync(playlist
->control_fd
);
1103 playlist
->shuffle_flush
= false;
1104 global_settings
.resume_seed
= -1;
1115 mutex_unlock(&playlist
->control_mutex
);
1119 splash(HZ
*2, true, str(LANG_PLAYLIST_CONTROL_UPDATE_ERROR
));
1128 * Rotate indices such that first_index is index 0
1130 static int rotate_index(const struct playlist_info
* playlist
, int index
)
1132 index
-= playlist
->first_index
;
1134 index
+= playlist
->amount
;
1140 * Initialize playlist entries at startup
1142 void playlist_init(void)
1144 struct playlist_info
* playlist
= ¤t_playlist
;
1146 playlist
->current
= true;
1147 snprintf(playlist
->control_filename
, sizeof(playlist
->control_filename
),
1148 "%s", PLAYLIST_CONTROL_FILE
);
1150 playlist
->control_fd
= -1;
1151 playlist
->max_playlist_size
= global_settings
.max_files_in_playlist
;
1152 playlist
->indices
= buffer_alloc(playlist
->max_playlist_size
* sizeof(int));
1153 playlist
->buffer_size
=
1154 AVERAGE_FILENAME_LENGTH
* global_settings
.max_files_in_dir
;
1155 playlist
->buffer
= buffer_alloc(playlist
->buffer_size
);
1156 mutex_init(&playlist
->control_mutex
);
1157 empty_playlist(playlist
, true);
1161 * Create new playlist
1163 int playlist_create(const char *dir
, const char *file
)
1165 struct playlist_info
* playlist
= ¤t_playlist
;
1167 new_playlist(playlist
, dir
, file
);
1170 /* load the playlist file */
1171 add_indices_to_playlist(playlist
, NULL
, 0);
1176 #define PLAYLIST_COMMAND_SIZE (MAX_PATH+12)
1179 * Restore the playlist state based on control file commands. Called to
1180 * resume playback after shutdown.
1182 int playlist_resume(void)
1184 struct playlist_info
* playlist
= ¤t_playlist
;
1189 int control_file_size
= 0;
1204 /* use mp3 buffer for maximum load speed */
1205 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
1206 buflen
= (mp3end
- mp3buf
);
1209 empty_playlist(playlist
, true);
1211 playlist
->control_fd
= open(playlist
->control_filename
, O_RDWR
);
1212 if (playlist
->control_fd
< 0)
1214 splash(HZ
*2, true, str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
1217 playlist
->control_created
= true;
1219 control_file_size
= filesize(playlist
->control_fd
);
1220 if (control_file_size
<= 0)
1222 splash(HZ
*2, true, str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
1226 /* read a small amount first to get the header */
1227 nread
= read(playlist
->control_fd
, buffer
,
1228 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
1231 splash(HZ
*2, true, str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
1239 int current_command
= resume_comment
;
1240 int last_newline
= 0;
1242 bool newline
= true;
1243 bool exit_loop
= false;
1249 for(count
=0; count
<nread
&& !exit_loop
; count
++,p
++)
1251 /* Are we on a new line? */
1252 if((*p
== '\n') || (*p
== '\r'))
1256 /* save last_newline in case we need to load more data */
1257 last_newline
= count
;
1259 switch (current_command
)
1261 case resume_playlist
:
1263 /* str1=version str2=dir str3=file */
1279 version
= atoi(str1
);
1281 if (version
!= PLAYLIST_CONTROL_FILE_VERSION
)
1284 update_playlist_filename(playlist
, str2
, str3
);
1286 if (str3
[0] != '\0')
1288 /* NOTE: add_indices_to_playlist() overwrites the
1289 mp3buf so we need to reload control file
1291 add_indices_to_playlist(playlist
, NULL
, 0);
1293 else if (str2
[0] != '\0')
1295 playlist
->in_ram
= true;
1296 resume_directory(str2
);
1299 /* load the rest of the data */
1308 /* str1=position str2=last_position str3=file */
1309 int position
, last_position
;
1312 if (!str1
|| !str2
|| !str3
)
1319 position
= atoi(str1
);
1320 last_position
= atoi(str2
);
1322 queue
= (current_command
== resume_add
)?false:true;
1324 /* seek position is based on str3's position in
1326 if (add_track_to_playlist(playlist
, str3
, position
,
1327 queue
, total_read
+(str3
-buffer
)) < 0)
1330 playlist
->last_insert_pos
= last_position
;
1346 position
= atoi(str1
);
1348 if (remove_track_from_playlist(playlist
, position
,
1354 case resume_shuffle
:
1356 /* str1=seed str2=first_index */
1368 /* Always sort list before shuffling */
1369 sort_playlist(playlist
, false, false);
1373 playlist
->first_index
= atoi(str2
);
1375 if (randomise_playlist(playlist
, seed
, false,
1382 case resume_unshuffle
:
1384 /* str1=first_index */
1392 playlist
->first_index
= atoi(str1
);
1394 if (sort_playlist(playlist
, false, false) < 0)
1402 playlist
->last_insert_pos
= -1;
1405 case resume_comment
:
1412 /* to ignore any extra newlines */
1413 current_command
= resume_comment
;
1419 /* first non-comment line must always specify playlist */
1420 if (first
&& *p
!= 'P' && *p
!= '#')
1430 /* playlist can only be specified once */
1438 current_command
= resume_playlist
;
1441 current_command
= resume_add
;
1444 current_command
= resume_queue
;
1447 current_command
= resume_delete
;
1450 current_command
= resume_shuffle
;
1453 current_command
= resume_unshuffle
;
1456 current_command
= resume_reset
;
1459 current_command
= resume_comment
;
1472 else if(current_command
!= resume_comment
)
1474 /* all control file strings are separated with a colon.
1475 Replace the colon with 0 to get proper strings that can be
1476 used by commands above */
1482 if ((count
+1) < nread
)
1496 /* allow last string to contain colons */
1507 splash(HZ
*2, true, str(LANG_PLAYLIST_CONTROL_INVALID
));
1511 if (!newline
|| (exit_loop
&& count
<nread
))
1513 if ((total_read
+ count
) >= control_file_size
)
1515 /* no newline at end of control file */
1516 splash(HZ
*2, true, str(LANG_PLAYLIST_CONTROL_INVALID
));
1520 /* We didn't end on a newline or we exited loop prematurely.
1521 Either way, re-read the remainder. */
1522 count
= last_newline
;
1523 lseek(playlist
->control_fd
, total_read
+count
, SEEK_SET
);
1526 total_read
+= count
;
1529 /* still looking for header */
1530 nread
= read(playlist
->control_fd
, buffer
,
1531 PLAYLIST_COMMAND_SIZE
<buflen
?PLAYLIST_COMMAND_SIZE
:buflen
);
1533 nread
= read(playlist
->control_fd
, buffer
, buflen
);
1535 /* Terminate on EOF */
1538 if (global_settings
.resume_seed
>= 0)
1540 /* Apply shuffle command saved in settings */
1541 if (global_settings
.resume_seed
== 0)
1542 sort_playlist(playlist
, false, true);
1546 sort_playlist(playlist
, false, false);
1548 randomise_playlist(playlist
, global_settings
.resume_seed
,
1552 playlist
->first_index
= global_settings
.resume_first_index
;
1563 * Add track to in_ram playlist. Used when playing directories.
1565 int playlist_add(const char *filename
)
1567 struct playlist_info
* playlist
= ¤t_playlist
;
1568 int len
= strlen(filename
);
1570 if((len
+1 > playlist
->buffer_size
- playlist
->buffer_end_pos
) ||
1571 (playlist
->amount
>= playlist
->max_playlist_size
))
1573 display_buffer_full();
1577 playlist
->indices
[playlist
->amount
++] = playlist
->buffer_end_pos
;
1579 strcpy(&playlist
->buffer
[playlist
->buffer_end_pos
], filename
);
1580 playlist
->buffer_end_pos
+= len
;
1581 playlist
->buffer
[playlist
->buffer_end_pos
++] = '\0';
1586 /* shuffle newly created playlist using random seed. */
1587 int playlist_shuffle(int random_seed
, int start_index
)
1589 struct playlist_info
* playlist
= ¤t_playlist
;
1591 unsigned int seek_pos
= 0;
1592 bool start_current
= false;
1594 if (start_index
>= 0 && global_settings
.play_selected
)
1596 /* store the seek position before the shuffle */
1597 seek_pos
= playlist
->indices
[start_index
];
1598 playlist
->index
= global_settings
.resume_first_index
=
1599 playlist
->first_index
= start_index
;
1600 start_current
= true;
1603 splash(0, true, str(LANG_PLAYLIST_SHUFFLE
));
1605 randomise_playlist(playlist
, random_seed
, start_current
, true);
1607 /* Flush shuffle command to disk */
1608 flush_pending_control(playlist
);
1610 return playlist
->index
;
1613 /* start playing current playlist at specified index/offset */
1614 int playlist_start(int start_index
, int offset
)
1616 struct playlist_info
* playlist
= ¤t_playlist
;
1618 playlist
->index
= start_index
;
1619 talk_buffer_steal(); /* will use the mp3 buffer */
1625 /* Returns false if 'steps' is out of bounds, else true */
1626 bool playlist_check(int steps
)
1628 struct playlist_info
* playlist
= ¤t_playlist
;
1629 int index
= get_next_index(playlist
, steps
);
1630 return (index
>= 0);
1633 /* get trackname of track that is "steps" away from current playing track.
1634 NULL is used to identify end of playlist */
1635 char* playlist_peek(int steps
)
1637 struct playlist_info
* playlist
= ¤t_playlist
;
1644 index
= get_next_index(playlist
, steps
);
1648 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
1649 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
1651 if (get_filename(playlist
, seek
, control_file
, now_playing
,
1655 temp_ptr
= now_playing
;
1657 if (!playlist
->in_ram
|| control_file
)
1659 /* remove bogus dirs from beginning of path
1660 (workaround for buggy playlist creation tools) */
1663 fd
= open(temp_ptr
, O_RDONLY
);
1670 temp_ptr
= strchr(temp_ptr
+1, '/');
1675 /* Even though this is an invalid file, we still need to pass a
1676 file name to the caller because NULL is used to indicate end
1686 * Update indices as track has changed
1688 int playlist_next(int steps
)
1690 struct playlist_info
* playlist
= ¤t_playlist
;
1693 if (steps
> 0 && global_settings
.repeat_mode
!= REPEAT_ONE
)
1697 /* We need to delete all the queued songs */
1698 for (i
=0, j
=steps
; i
<j
; i
++)
1700 index
= get_next_index(playlist
, i
);
1702 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
1704 remove_track_from_playlist(playlist
, index
, true);
1705 steps
--; /* one less track */
1710 index
= get_next_index(playlist
, steps
);
1711 playlist
->index
= index
;
1713 if (playlist
->last_insert_pos
>= 0 && steps
> 0)
1715 /* check to see if we've gone beyond the last inserted track */
1716 int cur
= rotate_index(playlist
, index
);
1717 int last_pos
= rotate_index(playlist
, playlist
->last_insert_pos
);
1721 /* reset last inserted track */
1722 playlist
->last_insert_pos
= -1;
1724 if (playlist
->control_fd
>= 0)
1728 mutex_lock(&playlist
->control_mutex
);
1730 if (lseek(playlist
->control_fd
, 0, SEEK_END
) >= 0)
1732 if (fprintf(playlist
->control_fd
, "R\n") > 0)
1734 fsync(playlist
->control_fd
);
1739 mutex_unlock(&playlist
->control_mutex
);
1744 str(LANG_PLAYLIST_CONTROL_UPDATE_ERROR
));
1754 /* Get resume info for current playing song. If return value is -1 then
1755 settings shouldn't be saved. */
1756 int playlist_get_resume_info(int *resume_index
)
1758 struct playlist_info
* playlist
= ¤t_playlist
;
1760 *resume_index
= playlist
->index
;
1765 /* Returns index of current playing track for display purposes. This value
1766 should not be used for resume purposes as it doesn't represent the actual
1767 index into the playlist */
1768 int playlist_get_display_index(void)
1770 struct playlist_info
* playlist
= ¤t_playlist
;
1772 /* first_index should always be index 0 for display purposes */
1773 int index
= rotate_index(playlist
, playlist
->index
);
1778 /* returns number of tracks in current playlist */
1779 int playlist_amount(void)
1781 return playlist_amount_ex(NULL
);
1785 * Create a new playlist If playlist is not NULL then we're loading a
1786 * playlist off disk for viewing/editing. The index_buffer is used to store
1787 * playlist indices (required for and only used if !current playlist). The
1788 * temp_buffer (if not NULL) is used as a scratchpad when loading indices.
1790 int playlist_create_ex(struct playlist_info
* playlist
,
1791 const char* dir
, const char* file
,
1792 void* index_buffer
, int index_buffer_size
,
1793 void* temp_buffer
, int temp_buffer_size
)
1796 playlist
= ¤t_playlist
;
1799 /* Initialize playlist structure */
1800 int r
= rand() % 10;
1801 playlist
->current
= false;
1803 /* Use random name for control file */
1804 snprintf(playlist
->control_filename
, sizeof(playlist
->control_filename
),
1805 "%s.%d", PLAYLIST_CONTROL_FILE
, r
);
1807 playlist
->control_fd
= -1;
1811 int num_indices
= index_buffer_size
/ sizeof(int);
1813 if (num_indices
> global_settings
.max_files_in_playlist
)
1814 num_indices
= global_settings
.max_files_in_playlist
;
1816 playlist
->max_playlist_size
= num_indices
;
1817 playlist
->indices
= index_buffer
;
1821 playlist
->max_playlist_size
= current_playlist
.max_playlist_size
;
1822 playlist
->indices
= current_playlist
.indices
;
1825 playlist
->buffer_size
= 0;
1826 playlist
->buffer
= NULL
;
1827 mutex_init(&playlist
->control_mutex
);
1830 new_playlist(playlist
, dir
, file
);
1833 /* load the playlist file */
1834 add_indices_to_playlist(playlist
, temp_buffer
, temp_buffer_size
);
1840 * Set the specified playlist as the current.
1841 * NOTE: You will get undefined behaviour if something is already playing so
1842 * remember to stop before calling this. Also, this call will
1843 * effectively close your playlist, making it unusable.
1845 int playlist_set_current(struct playlist_info
* playlist
)
1847 if (!playlist
|| (check_control(playlist
) < 0))
1850 empty_playlist(¤t_playlist
, false);
1852 strncpy(current_playlist
.filename
, playlist
->filename
,
1853 sizeof(current_playlist
.filename
));
1855 current_playlist
.fd
= playlist
->fd
;
1857 close(playlist
->control_fd
);
1858 remove(current_playlist
.control_filename
);
1859 if (rename(playlist
->control_filename
,
1860 current_playlist
.control_filename
) < 0)
1862 current_playlist
.control_fd
= open(current_playlist
.control_filename
,
1864 if (current_playlist
.control_fd
< 0)
1866 current_playlist
.control_created
= true;
1868 current_playlist
.dirlen
= playlist
->dirlen
;
1870 if (playlist
->indices
&& playlist
->indices
!= current_playlist
.indices
)
1871 memcpy(current_playlist
.indices
, playlist
->indices
,
1872 playlist
->max_playlist_size
*sizeof(int));
1874 current_playlist
.first_index
= playlist
->first_index
;
1875 current_playlist
.amount
= playlist
->amount
;
1876 current_playlist
.last_insert_pos
= playlist
->last_insert_pos
;
1877 current_playlist
.seed
= playlist
->seed
;
1878 current_playlist
.shuffle_modified
= playlist
->shuffle_modified
;
1879 current_playlist
.deleted
= playlist
->deleted
;
1880 current_playlist
.num_inserted_tracks
= playlist
->num_inserted_tracks
;
1881 current_playlist
.shuffle_flush
= playlist
->shuffle_flush
;
1887 * Close files and delete control file for non-current playlist.
1889 void playlist_close(struct playlist_info
* playlist
)
1894 if (playlist
->fd
>= 0)
1895 close(playlist
->fd
);
1897 if (playlist
->control_fd
>= 0)
1898 close(playlist
->control_fd
);
1900 if (playlist
->control_created
)
1901 remove(playlist
->control_filename
);
1905 * Insert track into playlist at specified position (or one of the special
1906 * positions). Returns position where track was inserted or -1 if error.
1908 int playlist_insert_track(struct playlist_info
* playlist
, const char *filename
,
1909 int position
, bool queue
)
1914 playlist
= ¤t_playlist
;
1916 if (check_control(playlist
) < 0)
1918 splash(HZ
*2, true, str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
1922 result
= add_track_to_playlist(playlist
, filename
, position
, queue
, -1);
1926 fsync(playlist
->control_fd
);
1927 mpeg_flush_and_reload_tracks();
1934 * Insert all tracks from specified directory into playlist.
1936 int playlist_insert_directory(struct playlist_info
* playlist
,
1937 const char *dirname
, int position
, bool queue
,
1945 playlist
= ¤t_playlist
;
1947 if (check_control(playlist
) < 0)
1949 splash(HZ
*2, true, str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
1954 count_str
= str(LANG_PLAYLIST_QUEUE_COUNT
);
1956 count_str
= str(LANG_PLAYLIST_INSERT_COUNT
);
1958 display_playlist_count(count
, count_str
);
1960 result
= add_directory_to_playlist(playlist
, dirname
, &position
, queue
,
1962 fsync(playlist
->control_fd
);
1964 display_playlist_count(count
, count_str
);
1965 mpeg_flush_and_reload_tracks();
1971 * Insert all tracks from specified playlist into dynamic playlist.
1973 int playlist_insert_playlist(struct playlist_info
* playlist
, char *filename
,
1974 int position
, bool queue
)
1981 char temp_buf
[MAX_PATH
+1];
1982 char trackname
[MAX_PATH
+1];
1987 playlist
= ¤t_playlist
;
1989 if (check_control(playlist
) < 0)
1991 splash(HZ
*2, true, str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
1995 fd
= open(filename
, O_RDONLY
);
1998 splash(HZ
*2, true, str(LANG_PLAYLIST_ACCESS_ERROR
));
2002 /* we need the directory name for formatting purposes */
2005 temp_ptr
= strrchr(filename
+1,'/');
2012 count_str
= str(LANG_PLAYLIST_QUEUE_COUNT
);
2014 count_str
= str(LANG_PLAYLIST_INSERT_COUNT
);
2016 display_playlist_count(count
, count_str
);
2018 while ((max
= read_line(fd
, temp_buf
, sizeof(temp_buf
))) > 0)
2021 if (button_get(false) == SETTINGS_CANCEL
)
2024 if (temp_buf
[0] != '#' && temp_buf
[0] != '\0')
2028 /* we need to format so that relative paths are correctly
2030 if (format_track_path(trackname
, temp_buf
, sizeof(trackname
), max
,
2037 insert_pos
= add_track_to_playlist(playlist
, trackname
, position
,
2046 /* Make sure tracks are inserted in correct order if user
2047 requests INSERT_FIRST */
2048 if (position
== PLAYLIST_INSERT_FIRST
|| position
>= 0)
2049 position
= insert_pos
+ 1;
2053 if ((count
%PLAYLIST_DISPLAY_COUNT
) == 0)
2055 display_playlist_count(count
, count_str
);
2057 if (count
== PLAYLIST_DISPLAY_COUNT
)
2058 mpeg_flush_and_reload_tracks();
2062 /* let the other threads work */
2067 fsync(playlist
->control_fd
);
2072 display_playlist_count(count
, count_str
);
2073 mpeg_flush_and_reload_tracks();
2079 * Delete track at specified index. If index is PLAYLIST_DELETE_CURRENT then
2080 * we want to delete the current playing track.
2082 int playlist_delete(struct playlist_info
* playlist
, int index
)
2087 playlist
= ¤t_playlist
;
2089 if (check_control(playlist
) < 0)
2091 splash(HZ
*2, true, str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2095 if (index
== PLAYLIST_DELETE_CURRENT
)
2096 index
= playlist
->index
;
2098 result
= remove_track_from_playlist(playlist
, index
, true);
2101 mpeg_flush_and_reload_tracks();
2107 * Move track at index to new_index. Tracks between the two are shifted
2108 * appropriately. Returns 0 on success and -1 on failure.
2110 int playlist_move(struct playlist_info
* playlist
, int index
, int new_index
)
2116 bool current
= false;
2118 char filename
[MAX_PATH
];
2121 playlist
= ¤t_playlist
;
2123 if (check_control(playlist
) < 0)
2125 splash(HZ
*2, true, str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR
));
2129 if (index
== new_index
)
2132 if (index
== playlist
->index
)
2133 /* Moving the current track */
2136 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
2137 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
2138 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
2140 if (get_filename(playlist
, seek
, control_file
, filename
,
2141 sizeof(filename
)) < 0)
2144 /* Delete track from original position */
2145 result
= remove_track_from_playlist(playlist
, index
, true);
2149 /* We want to insert the track at the position that was specified by
2150 new_index. This may be different then new_index because of the
2151 shifting that occurred after the delete */
2152 r
= rotate_index(playlist
, new_index
);
2156 new_index
= PLAYLIST_PREPEND
;
2157 else if (r
== playlist
->amount
)
2159 new_index
= PLAYLIST_INSERT_LAST
;
2161 /* Calculate index of desired position */
2162 new_index
= (r
+playlist
->first_index
)%playlist
->amount
;
2164 result
= add_track_to_playlist(playlist
, filename
, new_index
, queue
,
2171 /* Moved the current track */
2174 case PLAYLIST_PREPEND
:
2175 playlist
->index
= playlist
->first_index
;
2177 case PLAYLIST_INSERT_LAST
:
2178 playlist
->index
= playlist
->first_index
- 1;
2179 if (playlist
->index
< 0)
2180 playlist
->index
+= playlist
->amount
;
2183 playlist
->index
= new_index
;
2188 fsync(playlist
->control_fd
);
2189 mpeg_flush_and_reload_tracks();
2196 /* shuffle currently playing playlist */
2197 int playlist_randomise(struct playlist_info
* playlist
, unsigned int seed
,
2203 playlist
= ¤t_playlist
;
2205 check_control(playlist
);
2207 result
= randomise_playlist(playlist
, seed
, start_current
, true);
2210 mpeg_flush_and_reload_tracks();
2215 /* sort currently playing playlist */
2216 int playlist_sort(struct playlist_info
* playlist
, bool start_current
)
2221 playlist
= ¤t_playlist
;
2223 check_control(playlist
);
2225 result
= sort_playlist(playlist
, start_current
, true);
2228 mpeg_flush_and_reload_tracks();
2233 /* returns true if playlist has been modified */
2234 bool playlist_modified(const struct playlist_info
* playlist
)
2237 playlist
= ¤t_playlist
;
2239 if (playlist
->shuffle_modified
||
2240 playlist
->deleted
||
2241 playlist
->num_inserted_tracks
> 0)
2247 /* returns index of first track in playlist */
2248 int playlist_get_first_index(const struct playlist_info
* playlist
)
2251 playlist
= ¤t_playlist
;
2253 return playlist
->first_index
;
2256 /* returns shuffle seed of playlist */
2257 int playlist_get_seed(const struct playlist_info
* playlist
)
2260 playlist
= ¤t_playlist
;
2262 return playlist
->seed
;
2265 /* returns number of tracks in playlist (includes queued/inserted tracks) */
2266 int playlist_amount_ex(const struct playlist_info
* playlist
)
2269 playlist
= ¤t_playlist
;
2271 return playlist
->amount
;
2274 /* returns full path of playlist (minus extension) */
2275 char *playlist_name(const struct playlist_info
* playlist
, char *buf
,
2281 playlist
= ¤t_playlist
;
2283 snprintf(buf
, buf_size
, "%s", playlist
->filename
+playlist
->dirlen
);
2288 /* Remove extension */
2289 sep
= strrchr(buf
, '.');
2296 /* returns the playlist filename */
2297 char *playlist_get_name(const struct playlist_info
* playlist
, char *buf
,
2301 playlist
= ¤t_playlist
;
2303 snprintf(buf
, buf_size
, "%s", playlist
->filename
);
2311 /* Fills info structure with information about track at specified index.
2312 Returns 0 on success and -1 on failure */
2313 int playlist_get_track_info(struct playlist_info
* playlist
, int index
,
2314 struct playlist_track_info
* info
)
2320 playlist
= ¤t_playlist
;
2322 if (index
< 0 || index
>= playlist
->amount
)
2325 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
2326 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
2328 if (get_filename(playlist
, seek
, control_file
, info
->filename
,
2329 sizeof(info
->filename
)) < 0)
2336 if (playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
)
2337 info
->attr
|= PLAYLIST_ATTR_QUEUED
;
2339 info
->attr
|= PLAYLIST_ATTR_INSERTED
;
2342 info
->index
= index
;
2343 info
->display_index
= rotate_index(playlist
, index
) + 1;
2348 /* save the current dynamic playlist to specified file */
2349 int playlist_save(struct playlist_info
* playlist
, char *filename
)
2354 char tmp_buf
[MAX_PATH
+1];
2358 playlist
= ¤t_playlist
;
2360 if (playlist
->amount
<= 0)
2363 /* use current working directory as base for pathname */
2364 if (format_track_path(tmp_buf
, filename
, sizeof(tmp_buf
),
2365 strlen(filename
)+1, getcwd(NULL
, -1)) < 0)
2368 fd
= open(tmp_buf
, O_CREAT
|O_WRONLY
|O_TRUNC
);
2371 splash(HZ
*2, true, str(LANG_PLAYLIST_ACCESS_ERROR
));
2375 display_playlist_count(count
, str(LANG_PLAYLIST_SAVE_COUNT
));
2377 index
= playlist
->first_index
;
2378 for (i
=0; i
<playlist
->amount
; i
++)
2385 if (button_get(false) == SETTINGS_CANCEL
)
2388 control_file
= playlist
->indices
[index
] & PLAYLIST_INSERT_TYPE_MASK
;
2389 queue
= playlist
->indices
[index
] & PLAYLIST_QUEUE_MASK
;
2390 seek
= playlist
->indices
[index
] & PLAYLIST_SEEK_MASK
;
2392 /* Don't save queued files */
2395 if (get_filename(playlist
, seek
, control_file
, tmp_buf
,
2402 if (fprintf(fd
, "%s\n", tmp_buf
) < 0)
2404 splash(HZ
*2, true, str(LANG_PLAYLIST_CONTROL_UPDATE_ERROR
));
2411 if ((count
% PLAYLIST_DISPLAY_COUNT
) == 0)
2412 display_playlist_count(count
, str(LANG_PLAYLIST_SAVE_COUNT
));
2417 index
= (index
+1)%playlist
->amount
;
2420 display_playlist_count(count
, str(LANG_PLAYLIST_SAVE_COUNT
));