$rbdir => $temp_dir where appropriate, shadowing $rbdir with the temp dir broke wpsbu...
[kugel-rb.git] / apps / playlist.c
blob818c361d004524c6b2d71f6078d3eab728cf94cd
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
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
43 occurred.
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
61 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.
70 #include <stdio.h>
71 #include <stdlib.h>
72 #include <ctype.h>
73 #include "string-extra.h"
74 #include "playlist.h"
75 #include "ata_idle_notify.h"
76 #include "file.h"
77 #include "action.h"
78 #include "dir.h"
79 #include "debug.h"
80 #include "audio.h"
81 #include "lcd.h"
82 #include "kernel.h"
83 #include "settings.h"
84 #include "status.h"
85 #include "applimits.h"
86 #include "screens.h"
87 #include "buffer.h"
88 #include "misc.h"
89 #include "button.h"
90 #include "filetree.h"
91 #include "abrepeat.h"
92 #include "thread.h"
93 #include "usb.h"
94 #include "filetypes.h"
95 #ifdef HAVE_LCD_BITMAP
96 #include "icons.h"
97 #endif
98 #include "system.h"
100 #include "lang.h"
101 #include "talk.h"
102 #include "splash.h"
103 #include "rbunicode.h"
104 #include "root_menu.h"
106 #define PLAYLIST_CONTROL_FILE_VERSION 2
109 Each playlist index has a flag associated with it which identifies what
110 type of track it is. These flags are stored in the 4 high order bits of
111 the index.
113 NOTE: This limits the playlist file size to a max of 256M.
115 Bits 31-30:
116 00 = Playlist track
117 01 = Track was prepended into playlist
118 10 = Track was inserted into playlist
119 11 = Track was appended into playlist
120 Bit 29:
121 0 = Added track
122 1 = Queued track
123 Bit 28:
124 0 = Track entry is valid
125 1 = Track does not exist on disk and should be skipped
127 #define PLAYLIST_SEEK_MASK 0x0FFFFFFF
128 #define PLAYLIST_INSERT_TYPE_MASK 0xC0000000
129 #define PLAYLIST_QUEUE_MASK 0x20000000
131 #define PLAYLIST_INSERT_TYPE_PREPEND 0x40000000
132 #define PLAYLIST_INSERT_TYPE_INSERT 0x80000000
133 #define PLAYLIST_INSERT_TYPE_APPEND 0xC0000000
135 #define PLAYLIST_QUEUED 0x20000000
136 #define PLAYLIST_SKIPPED 0x10000000
138 struct directory_search_context {
139 struct playlist_info* playlist;
140 int position;
141 bool queue;
142 int count;
145 static struct playlist_info current_playlist;
146 static char now_playing[MAX_PATH+1];
148 static void empty_playlist(struct playlist_info* playlist, bool resume);
149 static void new_playlist(struct playlist_info* playlist, const char *dir,
150 const char *file);
151 static void create_control(struct playlist_info* playlist);
152 static int check_control(struct playlist_info* playlist);
153 static int recreate_control(struct playlist_info* playlist);
154 static void update_playlist_filename(struct playlist_info* playlist,
155 const char *dir, const char *file);
156 static int add_indices_to_playlist(struct playlist_info* playlist,
157 char* buffer, size_t buflen);
158 static int add_track_to_playlist(struct playlist_info* playlist,
159 const char *filename, int position,
160 bool queue, int seek_pos);
161 static int directory_search_callback(char* filename, void* context);
162 static int remove_track_from_playlist(struct playlist_info* playlist,
163 int position, bool write);
164 static int randomise_playlist(struct playlist_info* playlist,
165 unsigned int seed, bool start_current,
166 bool write);
167 static int sort_playlist(struct playlist_info* playlist, bool start_current,
168 bool write);
169 static int get_next_index(const struct playlist_info* playlist, int steps,
170 int repeat_mode);
171 static void find_and_set_playlist_index(struct playlist_info* playlist,
172 unsigned int seek);
173 static int compare(const void* p1, const void* p2);
174 static int get_filename(struct playlist_info* playlist, int index, int seek,
175 bool control_file, char *buf, int buf_length);
176 static int get_next_directory(char *dir);
177 static int get_next_dir(char *dir, bool is_forward, bool recursion);
178 static int get_previous_directory(char *dir);
179 static int check_subdir_for_music(char *dir, const char *subdir, bool recurse);
180 static int format_track_path(char *dest, char *src, int buf_length, int max,
181 const char *dir);
182 static void display_playlist_count(int count, const unsigned char *fmt,
183 bool final);
184 static void display_buffer_full(void);
185 static int flush_cached_control(struct playlist_info* playlist);
186 static int update_control(struct playlist_info* playlist,
187 enum playlist_command command, int i1, int i2,
188 const char* s1, const char* s2, void* data);
189 static void sync_control(struct playlist_info* playlist, bool force);
190 static int rotate_index(const struct playlist_info* playlist, int index);
192 #ifdef HAVE_DIRCACHE
193 #define PLAYLIST_LOAD_POINTERS 1
195 static struct event_queue playlist_queue;
196 static long playlist_stack[(DEFAULT_STACK_SIZE + 0x800)/sizeof(long)];
197 static const char playlist_thread_name[] = "playlist cachectrl";
198 #endif
200 /* Check if the filename suggests M3U or M3U8 format. */
201 static bool is_m3u8(const char* filename)
203 int len = strlen(filename);
205 /* Default to M3U8 unless explicitly told otherwise. */
206 return !(len > 4 && strcasecmp(&filename[len - 4], ".m3u") == 0);
210 /* Convert a filename in an M3U playlist to UTF-8.
212 * buf - the filename to convert; can contain more than one line from the
213 * playlist.
214 * buf_len - amount of buf that is used.
215 * buf_max - total size of buf.
216 * temp - temporary conversion buffer, at least buf_max bytes.
218 * Returns the length of the converted filename.
220 static int convert_m3u(char* buf, int buf_len, int buf_max, char* temp)
222 int i = 0;
223 char* dest;
225 /* Locate EOL. */
226 while ((buf[i] != '\n') && (buf[i] != '\r') && (i < buf_len))
228 i++;
231 /* Work back killing white space. */
232 while ((i > 0) && isspace(buf[i - 1]))
234 i--;
237 buf_len = i;
238 dest = temp;
240 /* Convert char by char, so as to not overflow temp (iso_decode should
241 * preferably handle this). No more than 4 bytes should be generated for
242 * each input char.
244 for (i = 0; i < buf_len && dest < (temp + buf_max - 4); i++)
246 dest = iso_decode(&buf[i], dest, -1, 1);
249 *dest = 0;
250 strcpy(buf, temp);
251 return dest - temp;
255 * remove any files and indices associated with the playlist
257 static void empty_playlist(struct playlist_info* playlist, bool resume)
259 playlist->filename[0] = '\0';
260 playlist->utf8 = true;
262 if(playlist->fd >= 0)
263 /* If there is an already open playlist, close it. */
264 close(playlist->fd);
265 playlist->fd = -1;
267 if(playlist->control_fd >= 0)
268 close(playlist->control_fd);
269 playlist->control_fd = -1;
270 playlist->control_created = false;
272 playlist->in_ram = false;
274 if (playlist->buffer)
275 playlist->buffer[0] = 0;
277 playlist->buffer_end_pos = 0;
279 playlist->index = 0;
280 playlist->first_index = 0;
281 playlist->amount = 0;
282 playlist->last_insert_pos = -1;
283 playlist->seed = 0;
284 playlist->shuffle_modified = false;
285 playlist->deleted = false;
286 playlist->num_inserted_tracks = 0;
287 playlist->started = false;
289 playlist->num_cached = 0;
290 playlist->pending_control_sync = false;
292 if (!resume && playlist->current)
294 /* start with fresh playlist control file when starting new
295 playlist */
296 create_control(playlist);
301 * Initialize a new playlist for viewing/editing/playing. dir is the
302 * directory where the playlist is located and file is the filename.
304 static void new_playlist(struct playlist_info* playlist, const char *dir,
305 const char *file)
307 const char *fileused = file;
308 const char *dirused = dir;
309 empty_playlist(playlist, false);
311 if (!fileused)
313 fileused = "";
315 if (dirused && playlist->current) /* !current cannot be in_ram */
316 playlist->in_ram = true;
317 else
318 dirused = ""; /* empty playlist */
321 update_playlist_filename(playlist, dirused, fileused);
323 if (playlist->control_fd >= 0)
325 update_control(playlist, PLAYLIST_COMMAND_PLAYLIST,
326 PLAYLIST_CONTROL_FILE_VERSION, -1, dirused, fileused, NULL);
327 sync_control(playlist, false);
332 * create control file for playlist
334 static void create_control(struct playlist_info* playlist)
336 playlist->control_fd = open(playlist->control_filename,
337 O_CREAT|O_RDWR|O_TRUNC, 0666);
338 if (playlist->control_fd < 0)
340 if (check_rockboxdir())
342 cond_talk_ids_fq(LANG_PLAYLIST_CONTROL_ACCESS_ERROR);
343 splashf(HZ*2, (unsigned char *)"%s (%d)",
344 str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR),
345 playlist->control_fd);
347 playlist->control_created = false;
349 else
351 playlist->control_created = true;
356 * validate the control file. This may include creating/initializing it if
357 * necessary;
359 static int check_control(struct playlist_info* playlist)
361 if (!playlist->control_created)
363 create_control(playlist);
365 if (playlist->control_fd >= 0)
367 char* dir = playlist->filename;
368 char* file = playlist->filename+playlist->dirlen;
369 char c = playlist->filename[playlist->dirlen-1];
371 playlist->filename[playlist->dirlen-1] = '\0';
373 update_control(playlist, PLAYLIST_COMMAND_PLAYLIST,
374 PLAYLIST_CONTROL_FILE_VERSION, -1, dir, file, NULL);
375 sync_control(playlist, false);
376 playlist->filename[playlist->dirlen-1] = c;
380 if (playlist->control_fd < 0)
381 return -1;
383 return 0;
387 * recreate the control file based on current playlist entries
389 static int recreate_control(struct playlist_info* playlist)
391 char temp_file[MAX_PATH+1];
392 int temp_fd = -1;
393 int i;
394 int result = 0;
396 if(playlist->control_fd >= 0)
398 char* dir = playlist->filename;
399 char* file = playlist->filename+playlist->dirlen;
400 char c = playlist->filename[playlist->dirlen-1];
402 close(playlist->control_fd);
404 snprintf(temp_file, sizeof(temp_file), "%s_temp",
405 playlist->control_filename);
407 if (rename(playlist->control_filename, temp_file) < 0)
408 return -1;
410 temp_fd = open(temp_file, O_RDONLY);
411 if (temp_fd < 0)
412 return -1;
414 playlist->control_fd = open(playlist->control_filename,
415 O_CREAT|O_RDWR|O_TRUNC, 0666);
416 if (playlist->control_fd < 0)
417 return -1;
419 playlist->filename[playlist->dirlen-1] = '\0';
421 /* cannot call update_control() because of mutex */
422 result = fdprintf(playlist->control_fd, "P:%d:%s:%s\n",
423 PLAYLIST_CONTROL_FILE_VERSION, dir, file);
425 playlist->filename[playlist->dirlen-1] = c;
427 if (result < 0)
429 close(temp_fd);
430 return result;
434 playlist->seed = 0;
435 playlist->shuffle_modified = false;
436 playlist->deleted = false;
437 playlist->num_inserted_tracks = 0;
439 for (i=0; i<playlist->amount; i++)
441 if (playlist->indices[i] & PLAYLIST_INSERT_TYPE_MASK)
443 bool queue = playlist->indices[i] & PLAYLIST_QUEUE_MASK;
444 char inserted_file[MAX_PATH+1];
446 lseek(temp_fd, playlist->indices[i] & PLAYLIST_SEEK_MASK,
447 SEEK_SET);
448 read_line(temp_fd, inserted_file, sizeof(inserted_file));
450 result = fdprintf(playlist->control_fd, "%c:%d:%d:",
451 queue?'Q':'A', i, playlist->last_insert_pos);
452 if (result > 0)
454 /* save the position in file where name is written */
455 int seek_pos = lseek(playlist->control_fd, 0, SEEK_CUR);
457 result = fdprintf(playlist->control_fd, "%s\n",
458 inserted_file);
460 playlist->indices[i] =
461 (playlist->indices[i] & ~PLAYLIST_SEEK_MASK) | seek_pos;
464 if (result < 0)
465 break;
467 playlist->num_inserted_tracks++;
471 close(temp_fd);
472 remove(temp_file);
473 fsync(playlist->control_fd);
475 if (result < 0)
476 return result;
478 return 0;
482 * store directory and name of playlist file
484 static void update_playlist_filename(struct playlist_info* playlist,
485 const char *dir, const char *file)
487 char *sep="";
488 int dirlen = strlen(dir);
490 playlist->utf8 = is_m3u8(file);
492 /* If the dir does not end in trailing slash, we use a separator.
493 Otherwise we don't. */
494 if('/' != dir[dirlen-1])
496 sep="/";
497 dirlen++;
500 playlist->dirlen = dirlen;
502 snprintf(playlist->filename, sizeof(playlist->filename),
503 "%s%s%s", dir, sep, file);
507 * calculate track offsets within a playlist file
509 static int add_indices_to_playlist(struct playlist_info* playlist,
510 char* buffer, size_t buflen)
512 unsigned int nread;
513 unsigned int i = 0;
514 unsigned int count = 0;
515 bool store_index;
516 unsigned char *p;
517 int result = 0;
519 if(-1 == playlist->fd)
520 playlist->fd = open_utf8(playlist->filename, O_RDONLY);
521 if(playlist->fd < 0)
522 return -1; /* failure */
523 if((i = lseek(playlist->fd, 0, SEEK_CUR)) > 0)
524 playlist->utf8 = true; /* Override any earlier indication. */
526 splash(0, ID2P(LANG_WAIT));
528 if (!buffer)
530 /* use mp3 buffer for maximum load speed */
531 audio_stop();
532 #if CONFIG_CODEC != SWCODEC
533 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
534 buflen = (audiobufend - audiobuf);
535 buffer = (char *)audiobuf;
536 #else
537 buffer = (char *)audio_get_buffer(false, &buflen);
538 #endif
541 store_index = true;
543 while(1)
545 nread = read(playlist->fd, buffer, buflen);
546 /* Terminate on EOF */
547 if(nread <= 0)
548 break;
550 p = (unsigned char *)buffer;
552 for(count=0; count < nread; count++,p++) {
554 /* Are we on a new line? */
555 if((*p == '\n') || (*p == '\r'))
557 store_index = true;
559 else if(store_index)
561 store_index = false;
563 if(*p != '#')
565 if ( playlist->amount >= playlist->max_playlist_size ) {
566 display_buffer_full();
567 result = -1;
568 goto exit;
571 /* Store a new entry */
572 playlist->indices[ playlist->amount ] = i+count;
573 #ifdef HAVE_DIRCACHE
574 if (playlist->filenames)
575 playlist->filenames[ playlist->amount ] = NULL;
576 #endif
577 playlist->amount++;
582 i+= count;
585 exit:
586 #ifdef HAVE_DIRCACHE
587 queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
588 #endif
590 return result;
594 * Utility function to create a new playlist, fill it with the next or
595 * previous directory, shuffle it if needed, and start playback.
596 * If play_last is true and direction zero or negative, start playing
597 * the last file in the directory, otherwise start playing the first.
599 static int create_and_play_dir(int direction, bool play_last)
601 char dir[MAX_PATH + 1];
602 int res;
603 int index = -1;
605 if(direction > 0)
606 res = get_next_directory(dir);
607 else
608 res = get_previous_directory(dir);
610 if (!res)
612 if (playlist_create(dir, NULL) != -1)
614 ft_build_playlist(tree_get_context(), 0);
616 if (global_settings.playlist_shuffle)
617 playlist_shuffle(current_tick, -1);
619 if (play_last && direction <= 0)
620 index = current_playlist.amount - 1;
621 else
622 index = 0;
624 #if (CONFIG_CODEC != SWCODEC)
625 playlist_start(index, 0);
626 #endif
629 /* we've overwritten the dircache when getting the next/previous dir,
630 so the tree browser context will need to be reloaded */
631 reload_directory();
634 return index;
638 * Removes all tracks, from the playlist, leaving the presently playing
639 * track queued.
641 int playlist_remove_all_tracks(struct playlist_info *playlist)
643 int result;
645 if (playlist == NULL)
646 playlist = &current_playlist;
648 while (playlist->index > 0)
649 if ((result = remove_track_from_playlist(playlist, 0, true)) < 0)
650 return result;
652 while (playlist->amount > 1)
653 if ((result = remove_track_from_playlist(playlist, 1, true)) < 0)
654 return result;
656 if (playlist->amount == 1) {
657 playlist->indices[0] |= PLAYLIST_QUEUED;
660 return 0;
665 * Add track to playlist at specified position. There are seven special
666 * positions that can be specified:
667 * PLAYLIST_PREPEND - Add track at beginning of playlist
668 * PLAYLIST_INSERT - Add track after current song. NOTE: If
669 * there are already inserted tracks then track
670 * is added to the end of the insertion list
671 * PLAYLIST_INSERT_FIRST - Add track immediately after current song, no
672 * matter what other tracks have been inserted
673 * PLAYLIST_INSERT_LAST - Add track to end of playlist
674 * PLAYLIST_INSERT_SHUFFLED - Add track at some random point between the
675 * current playing track and end of playlist
676 * PLAYLIST_INSERT_LAST_SHUFFLED - Add tracks in random order to the end of
677 * the playlist.
678 * PLAYLIST_REPLACE - Erase current playlist, Cue the current track
679 * and inster this track at the end.
681 static int add_track_to_playlist(struct playlist_info* playlist,
682 const char *filename, int position,
683 bool queue, int seek_pos)
685 int insert_position, orig_position;
686 unsigned long flags = PLAYLIST_INSERT_TYPE_INSERT;
687 int i;
689 insert_position = orig_position = position;
691 if (playlist->amount >= playlist->max_playlist_size)
693 display_buffer_full();
694 return -1;
697 switch (position)
699 case PLAYLIST_PREPEND:
700 position = insert_position = playlist->first_index;
701 break;
702 case PLAYLIST_INSERT:
703 /* if there are already inserted tracks then add track to end of
704 insertion list else add after current playing track */
705 if (playlist->last_insert_pos >= 0 &&
706 playlist->last_insert_pos < playlist->amount &&
707 (playlist->indices[playlist->last_insert_pos]&
708 PLAYLIST_INSERT_TYPE_MASK) == PLAYLIST_INSERT_TYPE_INSERT)
709 position = insert_position = playlist->last_insert_pos+1;
710 else if (playlist->amount > 0)
711 position = insert_position = playlist->index + 1;
712 else
713 position = insert_position = 0;
715 playlist->last_insert_pos = position;
716 break;
717 case PLAYLIST_INSERT_FIRST:
718 if (playlist->amount > 0)
719 position = insert_position = playlist->index + 1;
720 else
721 position = insert_position = 0;
723 playlist->last_insert_pos = position;
724 break;
725 case PLAYLIST_INSERT_LAST:
726 if (playlist->first_index > 0)
727 position = insert_position = playlist->first_index;
728 else
729 position = insert_position = playlist->amount;
731 playlist->last_insert_pos = position;
732 break;
733 case PLAYLIST_INSERT_SHUFFLED:
735 if (playlist->started)
737 int offset;
738 int n = playlist->amount -
739 rotate_index(playlist, playlist->index);
741 if (n > 0)
742 offset = rand() % n;
743 else
744 offset = 0;
746 position = playlist->index + offset + 1;
747 if (position >= playlist->amount)
748 position -= playlist->amount;
750 insert_position = position;
752 else
753 position = insert_position = (rand() % (playlist->amount+1));
754 break;
756 case PLAYLIST_INSERT_LAST_SHUFFLED:
758 position = insert_position = playlist->last_shuffled_start +
759 rand() % (playlist->amount - playlist->last_shuffled_start + 1);
760 break;
762 case PLAYLIST_REPLACE:
763 if (playlist_remove_all_tracks(playlist) < 0)
764 return -1;
766 playlist->last_insert_pos = position = insert_position = playlist->index + 1;
767 break;
770 if (queue)
771 flags |= PLAYLIST_QUEUED;
773 /* shift indices so that track can be added */
774 for (i=playlist->amount; i>insert_position; i--)
776 playlist->indices[i] = playlist->indices[i-1];
777 #ifdef HAVE_DIRCACHE
778 if (playlist->filenames)
779 playlist->filenames[i] = playlist->filenames[i-1];
780 #endif
783 /* update stored indices if needed */
785 if (orig_position < 0)
787 if (playlist->amount > 0 && insert_position <= playlist->index &&
788 playlist->started)
789 playlist->index++;
791 if (playlist->amount > 0 && insert_position <= playlist->first_index &&
792 orig_position != PLAYLIST_PREPEND && playlist->started)
793 playlist->first_index++;
796 if (insert_position < playlist->last_insert_pos ||
797 (insert_position == playlist->last_insert_pos && position < 0))
798 playlist->last_insert_pos++;
800 if (seek_pos < 0 && playlist->control_fd >= 0)
802 int result = update_control(playlist,
803 (queue?PLAYLIST_COMMAND_QUEUE:PLAYLIST_COMMAND_ADD), position,
804 playlist->last_insert_pos, filename, NULL, &seek_pos);
806 if (result < 0)
807 return result;
810 playlist->indices[insert_position] = flags | seek_pos;
812 #ifdef HAVE_DIRCACHE
813 if (playlist->filenames)
814 playlist->filenames[insert_position] = NULL;
815 #endif
817 playlist->amount++;
818 playlist->num_inserted_tracks++;
820 return insert_position;
824 * Callback for playlist_directory_tracksearch to insert track into
825 * playlist.
827 static int directory_search_callback(char* filename, void* context)
829 struct directory_search_context* c =
830 (struct directory_search_context*) context;
831 int insert_pos;
833 insert_pos = add_track_to_playlist(c->playlist, filename, c->position,
834 c->queue, -1);
836 if (insert_pos < 0)
837 return -1;
839 (c->count)++;
841 /* Make sure tracks are inserted in correct order if user requests
842 INSERT_FIRST */
843 if (c->position == PLAYLIST_INSERT_FIRST || c->position >= 0)
844 c->position = insert_pos + 1;
846 if (((c->count)%PLAYLIST_DISPLAY_COUNT) == 0)
848 unsigned char* count_str;
850 if (c->queue)
851 count_str = ID2P(LANG_PLAYLIST_QUEUE_COUNT);
852 else
853 count_str = ID2P(LANG_PLAYLIST_INSERT_COUNT);
855 display_playlist_count(c->count, count_str, false);
857 if ((c->count) == PLAYLIST_DISPLAY_COUNT &&
858 (audio_status() & AUDIO_STATUS_PLAY) &&
859 c->playlist->started)
860 audio_flush_and_reload_tracks();
863 return 0;
867 * remove track at specified position
869 static int remove_track_from_playlist(struct playlist_info* playlist,
870 int position, bool write)
872 int i;
873 bool inserted;
875 if (playlist->amount <= 0)
876 return -1;
878 inserted = playlist->indices[position] & PLAYLIST_INSERT_TYPE_MASK;
880 /* shift indices now that track has been removed */
881 for (i=position; i<playlist->amount; i++)
883 playlist->indices[i] = playlist->indices[i+1];
884 #ifdef HAVE_DIRCACHE
885 if (playlist->filenames)
886 playlist->filenames[i] = playlist->filenames[i+1];
887 #endif
890 playlist->amount--;
892 if (inserted)
893 playlist->num_inserted_tracks--;
894 else
895 playlist->deleted = true;
897 /* update stored indices if needed */
898 if (position < playlist->index)
899 playlist->index--;
901 if (position < playlist->first_index)
903 playlist->first_index--;
906 if (position <= playlist->last_insert_pos)
907 playlist->last_insert_pos--;
909 if (write && playlist->control_fd >= 0)
911 int result = update_control(playlist, PLAYLIST_COMMAND_DELETE,
912 position, -1, NULL, NULL, NULL);
914 if (result < 0)
915 return result;
917 sync_control(playlist, false);
920 return 0;
924 * randomly rearrange the array of indices for the playlist. If start_current
925 * is true then update the index to the new index of the current playing track
927 static int randomise_playlist(struct playlist_info* playlist,
928 unsigned int seed, bool start_current,
929 bool write)
931 int count;
932 int candidate;
933 long store;
934 unsigned int current = playlist->indices[playlist->index];
936 /* seed 0 is used to identify sorted playlist for resume purposes */
937 if (seed == 0)
938 seed = 1;
940 /* seed with the given seed */
941 srand(seed);
943 /* randomise entire indices list */
944 for(count = playlist->amount - 1; count >= 0; count--)
946 /* the rand is from 0 to RAND_MAX, so adjust to our value range */
947 candidate = rand() % (count + 1);
949 /* now swap the values at the 'count' and 'candidate' positions */
950 store = playlist->indices[candidate];
951 playlist->indices[candidate] = playlist->indices[count];
952 playlist->indices[count] = store;
953 #ifdef HAVE_DIRCACHE
954 if (playlist->filenames)
956 store = (long)playlist->filenames[candidate];
957 playlist->filenames[candidate] = playlist->filenames[count];
958 playlist->filenames[count] = (struct dircache_entry *)store;
960 #endif
963 if (start_current)
964 find_and_set_playlist_index(playlist, current);
966 /* indices have been moved so last insert position is no longer valid */
967 playlist->last_insert_pos = -1;
969 playlist->seed = seed;
970 if (playlist->num_inserted_tracks > 0 || playlist->deleted)
971 playlist->shuffle_modified = true;
973 if (write)
975 update_control(playlist, PLAYLIST_COMMAND_SHUFFLE, seed,
976 playlist->first_index, NULL, NULL, NULL);
979 return 0;
983 * Sort the array of indices for the playlist. If start_current is true then
984 * set the index to the new index of the current song.
985 * Also while going to unshuffled mode set the first_index to 0.
987 static int sort_playlist(struct playlist_info* playlist, bool start_current,
988 bool write)
990 unsigned int current = playlist->indices[playlist->index];
992 if (playlist->amount > 0)
993 qsort(playlist->indices, playlist->amount,
994 sizeof(playlist->indices[0]), compare);
996 #ifdef HAVE_DIRCACHE
997 /** We need to re-check the song names from disk because qsort can't
998 * sort two arrays at once :/
999 * FIXME: Please implement a better way to do this. */
1000 memset(playlist->filenames, 0, playlist->max_playlist_size * sizeof(int));
1001 queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
1002 #endif
1004 if (start_current)
1005 find_and_set_playlist_index(playlist, current);
1007 /* indices have been moved so last insert position is no longer valid */
1008 playlist->last_insert_pos = -1;
1010 if (!playlist->num_inserted_tracks && !playlist->deleted)
1011 playlist->shuffle_modified = false;
1012 if (write && playlist->control_fd >= 0)
1014 playlist->first_index = 0;
1015 update_control(playlist, PLAYLIST_COMMAND_UNSHUFFLE,
1016 playlist->first_index, -1, NULL, NULL, NULL);
1019 return 0;
1022 /* Calculate how many steps we have to really step when skipping entries
1023 * marked as bad.
1025 static int calculate_step_count(const struct playlist_info *playlist, int steps)
1027 int i, count, direction;
1028 int index;
1029 int stepped_count = 0;
1031 if (steps < 0)
1033 direction = -1;
1034 count = -steps;
1036 else
1038 direction = 1;
1039 count = steps;
1042 index = playlist->index;
1043 i = 0;
1044 do {
1045 /* Boundary check */
1046 if (index < 0)
1047 index += playlist->amount;
1048 if (index >= playlist->amount)
1049 index -= playlist->amount;
1051 /* Check if we found a bad entry. */
1052 if (playlist->indices[index] & PLAYLIST_SKIPPED)
1054 steps += direction;
1055 /* Are all entries bad? */
1056 if (stepped_count++ > playlist->amount)
1057 break ;
1059 else
1060 i++;
1062 index += direction;
1063 } while (i <= count);
1065 return steps;
1068 /* Marks the index of the track to be skipped that is "steps" away from
1069 * current playing track.
1071 void playlist_skip_entry(struct playlist_info *playlist, int steps)
1073 int index;
1075 if (playlist == NULL)
1076 playlist = &current_playlist;
1078 /* need to account for already skipped tracks */
1079 steps = calculate_step_count(playlist, steps);
1081 index = playlist->index + steps;
1082 if (index < 0)
1083 index += playlist->amount;
1084 else if (index >= playlist->amount)
1085 index -= playlist->amount;
1087 playlist->indices[index] |= PLAYLIST_SKIPPED;
1091 * returns the index of the track that is "steps" away from current playing
1092 * track.
1094 static int get_next_index(const struct playlist_info* playlist, int steps,
1095 int repeat_mode)
1097 int current_index = playlist->index;
1098 int next_index = -1;
1100 if (playlist->amount <= 0)
1101 return -1;
1103 if (repeat_mode == -1)
1104 repeat_mode = global_settings.repeat_mode;
1106 if (repeat_mode == REPEAT_SHUFFLE && playlist->amount <= 1)
1107 repeat_mode = REPEAT_ALL;
1109 steps = calculate_step_count(playlist, steps);
1110 switch (repeat_mode)
1112 case REPEAT_SHUFFLE:
1113 /* Treat repeat shuffle just like repeat off. At end of playlist,
1114 play will be resumed in playlist_next() */
1115 case REPEAT_OFF:
1117 current_index = rotate_index(playlist, current_index);
1118 next_index = current_index+steps;
1119 if ((next_index < 0) || (next_index >= playlist->amount))
1120 next_index = -1;
1121 else
1122 next_index = (next_index+playlist->first_index) %
1123 playlist->amount;
1125 break;
1128 case REPEAT_ONE:
1129 #ifdef AB_REPEAT_ENABLE
1130 case REPEAT_AB:
1131 #endif
1132 next_index = current_index;
1133 break;
1135 case REPEAT_ALL:
1136 default:
1138 next_index = (current_index+steps) % playlist->amount;
1139 while (next_index < 0)
1140 next_index += playlist->amount;
1142 if (steps >= playlist->amount)
1144 int i, index;
1146 index = next_index;
1147 next_index = -1;
1149 /* second time around so skip the queued files */
1150 for (i=0; i<playlist->amount; i++)
1152 if (playlist->indices[index] & PLAYLIST_QUEUE_MASK)
1153 index = (index+1) % playlist->amount;
1154 else
1156 next_index = index;
1157 break;
1161 break;
1165 /* No luck if the whole playlist was bad. */
1166 if (playlist->indices[next_index] & PLAYLIST_SKIPPED)
1167 return -1;
1169 return next_index;
1173 * Search for the seek track and set appropriate indices. Used after shuffle
1174 * to make sure the current index is still pointing to correct track.
1176 static void find_and_set_playlist_index(struct playlist_info* playlist,
1177 unsigned int seek)
1179 int i;
1181 /* Set the index to the current song */
1182 for (i=0; i<playlist->amount; i++)
1184 if (playlist->indices[i] == seek)
1186 playlist->index = playlist->first_index = i;
1188 break;
1194 * used to sort track indices. Sort order is as follows:
1195 * 1. Prepended tracks (in prepend order)
1196 * 2. Playlist/directory tracks (in playlist order)
1197 * 3. Inserted/Appended tracks (in insert order)
1199 static int compare(const void* p1, const void* p2)
1201 unsigned long* e1 = (unsigned long*) p1;
1202 unsigned long* e2 = (unsigned long*) p2;
1203 unsigned long flags1 = *e1 & PLAYLIST_INSERT_TYPE_MASK;
1204 unsigned long flags2 = *e2 & PLAYLIST_INSERT_TYPE_MASK;
1206 if (flags1 == flags2)
1207 return (*e1 & PLAYLIST_SEEK_MASK) - (*e2 & PLAYLIST_SEEK_MASK);
1208 else if (flags1 == PLAYLIST_INSERT_TYPE_PREPEND ||
1209 flags2 == PLAYLIST_INSERT_TYPE_APPEND)
1210 return -1;
1211 else if (flags1 == PLAYLIST_INSERT_TYPE_APPEND ||
1212 flags2 == PLAYLIST_INSERT_TYPE_PREPEND)
1213 return 1;
1214 else if (flags1 && flags2)
1215 return (*e1 & PLAYLIST_SEEK_MASK) - (*e2 & PLAYLIST_SEEK_MASK);
1216 else
1217 return *e1 - *e2;
1220 #ifdef HAVE_DIRCACHE
1222 * Thread to update filename pointers to dircache on background
1223 * without affecting playlist load up performance. This thread also flushes
1224 * any pending control commands when the disk spins up.
1226 static void playlist_flush_callback(void *param)
1228 (void)param;
1229 struct playlist_info *playlist;
1230 playlist = &current_playlist;
1231 if (playlist->control_fd >= 0)
1233 if (playlist->num_cached > 0)
1235 mutex_lock(&playlist->control_mutex);
1236 flush_cached_control(playlist);
1237 mutex_unlock(&playlist->control_mutex);
1239 sync_control(playlist, true);
1243 static void playlist_thread(void)
1245 struct queue_event ev;
1246 bool dirty_pointers = false;
1247 static char tmp[MAX_PATH+1];
1249 struct playlist_info *playlist;
1250 int index;
1251 int seek;
1252 bool control_file;
1254 int sleep_time = 5;
1256 #ifdef HAVE_DISK_STORAGE
1257 if (global_settings.disk_spindown > 1 &&
1258 global_settings.disk_spindown <= 5)
1259 sleep_time = global_settings.disk_spindown - 1;
1260 #endif
1262 while (1)
1264 queue_wait_w_tmo(&playlist_queue, &ev, HZ*sleep_time);
1266 switch (ev.id)
1268 case PLAYLIST_LOAD_POINTERS:
1269 dirty_pointers = true;
1270 break ;
1272 /* Start the background scanning after either the disk spindown
1273 timeout or 5s, whichever is less */
1274 case SYS_TIMEOUT:
1275 playlist = &current_playlist;
1276 if (playlist->control_fd >= 0)
1278 if (playlist->num_cached > 0)
1279 register_storage_idle_func(playlist_flush_callback);
1282 if (!dirty_pointers)
1283 break ;
1285 if (!dircache_is_enabled() || !playlist->filenames
1286 || playlist->amount <= 0)
1287 break ;
1289 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1290 cpu_boost(true);
1291 #endif
1292 for (index = 0; index < playlist->amount
1293 && queue_empty(&playlist_queue); index++)
1295 /* Process only pointers that are not already loaded. */
1296 if (playlist->filenames[index])
1297 continue ;
1299 control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
1300 seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
1302 /* Load the filename from playlist file. */
1303 if (get_filename(playlist, index, seek, control_file, tmp,
1304 sizeof(tmp)) < 0)
1305 break ;
1307 /* Set the dircache entry pointer. */
1308 playlist->filenames[index] = dircache_get_entry_ptr(tmp);
1310 /* And be on background so user doesn't notice any delays. */
1311 yield();
1314 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1315 cpu_boost(false);
1316 #endif
1317 dirty_pointers = false;
1318 break ;
1320 #if (CONFIG_PLATFORM & PLATFORM_NATIVE)
1321 case SYS_USB_CONNECTED:
1322 usb_acknowledge(SYS_USB_CONNECTED_ACK);
1323 usb_wait_for_disconnect(&playlist_queue);
1324 break ;
1325 #endif
1329 #endif
1332 * gets pathname for track at seek index
1334 static int get_filename(struct playlist_info* playlist, int index, int seek,
1335 bool control_file, char *buf, int buf_length)
1337 int fd;
1338 int max = -1;
1339 char tmp_buf[MAX_PATH+1];
1340 char dir_buf[MAX_PATH+1];
1341 bool utf8 = playlist->utf8;
1343 if (buf_length > MAX_PATH+1)
1344 buf_length = MAX_PATH+1;
1346 #ifdef HAVE_DIRCACHE
1347 if (dircache_is_enabled() && playlist->filenames)
1349 if (playlist->filenames[index] != NULL)
1351 dircache_copy_path(playlist->filenames[index], tmp_buf, sizeof(tmp_buf)-1);
1352 max = strlen(tmp_buf);
1355 #else
1356 (void)index;
1357 #endif
1359 if (playlist->in_ram && !control_file && max < 0)
1361 max = strlcpy(tmp_buf, &playlist->buffer[seek], sizeof(tmp_buf));
1363 else if (max < 0)
1365 mutex_lock(&playlist->control_mutex);
1367 if (control_file)
1369 fd = playlist->control_fd;
1370 utf8 = true;
1372 else
1374 if(-1 == playlist->fd)
1375 playlist->fd = open(playlist->filename, O_RDONLY);
1377 fd = playlist->fd;
1380 if(-1 != fd)
1383 if (lseek(fd, seek, SEEK_SET) != seek)
1384 max = -1;
1385 else
1387 max = read(fd, tmp_buf, MIN((size_t) buf_length, sizeof(tmp_buf)));
1389 if ((max > 0) && !utf8)
1391 /* Use dir_buf as a temporary buffer. Note that dir_buf must
1392 * be as large as tmp_buf.
1394 max = convert_m3u(tmp_buf, max, sizeof(tmp_buf), dir_buf);
1399 mutex_unlock(&playlist->control_mutex);
1401 if (max < 0)
1403 if (control_file)
1404 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
1405 else
1406 splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
1408 return max;
1412 strlcpy(dir_buf, playlist->filename, playlist->dirlen);
1414 return (format_track_path(buf, tmp_buf, buf_length, max, dir_buf));
1417 static int get_next_directory(char *dir){
1418 return get_next_dir(dir,true,false);
1421 static int get_previous_directory(char *dir){
1422 return get_next_dir(dir,false,false);
1426 * search through all the directories (starting with the current) to find
1427 * one that has tracks to play
1429 static int get_next_dir(char *dir, bool is_forward, bool recursion)
1431 struct playlist_info* playlist = &current_playlist;
1432 int result = -1;
1433 char *start_dir = NULL;
1434 bool exit = false;
1435 int i;
1436 struct tree_context* tc = tree_get_context();
1437 int saved_dirfilter = *(tc->dirfilter);
1439 /* process random folder advance */
1440 if (global_settings.next_folder == FOLDER_ADVANCE_RANDOM)
1442 char folder_advance_list[MAX_PATH];
1443 snprintf(folder_advance_list, sizeof(folder_advance_list),
1444 "%s/folder_advance_list.dat", ROCKBOX_DIR);
1445 int fd = open(folder_advance_list, O_RDONLY);
1446 if (fd >= 0)
1448 char buffer[MAX_PATH];
1449 int folder_count = 0;
1450 srand(current_tick);
1451 *(tc->dirfilter) = SHOW_MUSIC;
1452 tc->sort_dir = global_settings.sort_dir;
1453 read(fd,&folder_count,sizeof(int));
1454 if (!folder_count)
1455 exit = true;
1456 while (!exit)
1458 i = rand()%folder_count;
1459 lseek(fd,sizeof(int) + (MAX_PATH*i),SEEK_SET);
1460 read(fd,buffer,MAX_PATH);
1461 if (check_subdir_for_music(buffer, "", false) ==0)
1462 exit = true;
1464 if (folder_count)
1465 strcpy(dir,buffer);
1466 close(fd);
1467 *(tc->dirfilter) = saved_dirfilter;
1468 tc->sort_dir = global_settings.sort_dir;
1469 reload_directory();
1470 return 0;
1474 /* not random folder advance (or random folder advance unavailable) */
1475 if (recursion)
1477 /* start with root */
1478 dir[0] = '\0';
1480 else
1482 /* start with current directory */
1483 strlcpy(dir, playlist->filename, playlist->dirlen);
1486 /* use the tree browser dircache to load files */
1487 *(tc->dirfilter) = SHOW_ALL;
1489 /* set up sorting/direction */
1490 tc->sort_dir = global_settings.sort_dir;
1491 if (!is_forward)
1493 static const char sortpairs[] =
1495 [SORT_ALPHA] = SORT_ALPHA_REVERSED,
1496 [SORT_DATE] = SORT_DATE_REVERSED,
1497 [SORT_TYPE] = SORT_TYPE_REVERSED,
1498 [SORT_ALPHA_REVERSED] = SORT_ALPHA,
1499 [SORT_DATE_REVERSED] = SORT_DATE,
1500 [SORT_TYPE_REVERSED] = SORT_TYPE,
1503 if ((unsigned)tc->sort_dir < sizeof(sortpairs))
1504 tc->sort_dir = sortpairs[tc->sort_dir];
1507 while (!exit)
1509 struct entry *files;
1510 int num_files = 0;
1511 int i;
1513 if (ft_load(tc, (dir[0]=='\0')?"/":dir) < 0)
1515 exit = true;
1516 result = -1;
1517 break;
1520 files = (struct entry*) tc->dircache;
1521 num_files = tc->filesindir;
1523 for (i=0; i<num_files; i++)
1525 /* user abort */
1526 if (action_userabort(TIMEOUT_NOBLOCK))
1528 result = -1;
1529 exit = true;
1530 break;
1533 if (files[i].attr & ATTR_DIRECTORY)
1535 if (!start_dir)
1537 result = check_subdir_for_music(dir, files[i].name, true);
1538 if (result != -1)
1540 exit = true;
1541 break;
1544 else if (!strcmp(start_dir, files[i].name))
1545 start_dir = NULL;
1549 if (!exit)
1551 /* move down to parent directory. current directory name is
1552 stored as the starting point for the search in parent */
1553 start_dir = strrchr(dir, '/');
1554 if (start_dir)
1556 *start_dir = '\0';
1557 start_dir++;
1559 else
1560 break;
1564 /* restore dirfilter */
1565 *(tc->dirfilter) = saved_dirfilter;
1566 tc->sort_dir = global_settings.sort_dir;
1568 /* special case if nothing found: try start searching again from root */
1569 if (result == -1 && !recursion){
1570 result = get_next_dir(dir, is_forward, true);
1573 return result;
1577 * Checks if there are any music files in the dir or any of its
1578 * subdirectories. May be called recursively.
1580 static int check_subdir_for_music(char *dir, const char *subdir, bool recurse)
1582 int result = -1;
1583 int dirlen = strlen(dir);
1584 int num_files = 0;
1585 int i;
1586 struct entry *files;
1587 bool has_music = false;
1588 bool has_subdir = false;
1589 struct tree_context* tc = tree_get_context();
1591 snprintf(dir+dirlen, MAX_PATH-dirlen, "/%s", subdir);
1593 if (ft_load(tc, dir) < 0)
1595 return -2;
1598 files = (struct entry*) tc->dircache;
1599 num_files = tc->filesindir;
1601 for (i=0; i<num_files; i++)
1603 if (files[i].attr & ATTR_DIRECTORY)
1604 has_subdir = true;
1605 else if ((files[i].attr & FILE_ATTR_MASK) == FILE_ATTR_AUDIO)
1607 has_music = true;
1608 break;
1612 if (has_music)
1613 return 0;
1615 if (has_subdir && recurse)
1617 for (i=0; i<num_files; i++)
1619 if (action_userabort(TIMEOUT_NOBLOCK))
1621 result = -2;
1622 break;
1625 if (files[i].attr & ATTR_DIRECTORY)
1627 result = check_subdir_for_music(dir, files[i].name, true);
1628 if (!result)
1629 break;
1634 if (result < 0)
1636 if (dirlen)
1638 dir[dirlen] = '\0';
1640 else
1642 strcpy(dir, "/");
1645 /* we now need to reload our current directory */
1646 if(ft_load(tc, dir) < 0)
1647 splash(HZ*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR));
1649 return result;
1653 * Returns absolute path of track
1655 static int format_track_path(char *dest, char *src, int buf_length, int max,
1656 const char *dir)
1658 int i = 0;
1659 int j;
1660 char *temp_ptr;
1662 /* Zero-terminate the file name */
1663 while((src[i] != '\n') &&
1664 (src[i] != '\r') &&
1665 (i < max))
1666 i++;
1668 /* Now work back killing white space */
1669 while((src[i-1] == ' ') ||
1670 (src[i-1] == '\t'))
1671 i--;
1673 src[i]=0;
1675 /* replace backslashes with forward slashes */
1676 for ( j=0; j<i; j++ )
1677 if ( src[j] == '\\' )
1678 src[j] = '/';
1680 if('/' == src[0])
1682 strlcpy(dest, src, buf_length);
1684 else
1686 /* handle dos style drive letter */
1687 if (':' == src[1])
1688 strlcpy(dest, &src[2], buf_length);
1689 else if (!strncmp(src, "../", 3))
1691 /* handle relative paths */
1692 i=3;
1693 while(!strncmp(&src[i], "../", 3))
1694 i += 3;
1695 for (j=0; j<i/3; j++) {
1696 temp_ptr = strrchr(dir, '/');
1697 if (temp_ptr)
1698 *temp_ptr = '\0';
1699 else
1700 break;
1702 snprintf(dest, buf_length, "%s/%s", dir, &src[i]);
1704 else if ( '.' == src[0] && '/' == src[1] ) {
1705 snprintf(dest, buf_length, "%s/%s", dir, &src[2]);
1707 else {
1708 snprintf(dest, buf_length, "%s/%s", dir, src);
1712 return 0;
1716 * Display splash message showing progress of playlist/directory insertion or
1717 * save.
1719 static void display_playlist_count(int count, const unsigned char *fmt,
1720 bool final)
1722 static long talked_tick = 0;
1723 long id = P2ID(fmt);
1724 if(global_settings.talk_menu && id>=0)
1726 if(final || (count && (talked_tick == 0
1727 || TIME_AFTER(current_tick, talked_tick+5*HZ))))
1729 talked_tick = current_tick;
1730 talk_number(count, false);
1731 talk_id(id, true);
1734 fmt = P2STR(fmt);
1736 splashf(0, fmt, count, str(LANG_OFF_ABORT));
1740 * Display buffer full message
1742 static void display_buffer_full(void)
1744 splash(HZ*2, ID2P(LANG_PLAYLIST_BUFFER_FULL));
1748 * Flush any cached control commands to disk. Called when playlist is being
1749 * modified. Returns 0 on success and -1 on failure.
1751 static int flush_cached_control(struct playlist_info* playlist)
1753 int result = 0;
1754 int i;
1756 if (!playlist->num_cached)
1757 return 0;
1759 lseek(playlist->control_fd, 0, SEEK_END);
1761 for (i=0; i<playlist->num_cached; i++)
1763 struct playlist_control_cache* cache =
1764 &(playlist->control_cache[i]);
1766 switch (cache->command)
1768 case PLAYLIST_COMMAND_PLAYLIST:
1769 result = fdprintf(playlist->control_fd, "P:%d:%s:%s\n",
1770 cache->i1, cache->s1, cache->s2);
1771 break;
1772 case PLAYLIST_COMMAND_ADD:
1773 case PLAYLIST_COMMAND_QUEUE:
1774 result = fdprintf(playlist->control_fd, "%c:%d:%d:",
1775 (cache->command == PLAYLIST_COMMAND_ADD)?'A':'Q',
1776 cache->i1, cache->i2);
1777 if (result > 0)
1779 /* save the position in file where name is written */
1780 int* seek_pos = (int *)cache->data;
1781 *seek_pos = lseek(playlist->control_fd, 0, SEEK_CUR);
1782 result = fdprintf(playlist->control_fd, "%s\n",
1783 cache->s1);
1785 break;
1786 case PLAYLIST_COMMAND_DELETE:
1787 result = fdprintf(playlist->control_fd, "D:%d\n", cache->i1);
1788 break;
1789 case PLAYLIST_COMMAND_SHUFFLE:
1790 result = fdprintf(playlist->control_fd, "S:%d:%d\n",
1791 cache->i1, cache->i2);
1792 break;
1793 case PLAYLIST_COMMAND_UNSHUFFLE:
1794 result = fdprintf(playlist->control_fd, "U:%d\n", cache->i1);
1795 break;
1796 case PLAYLIST_COMMAND_RESET:
1797 result = fdprintf(playlist->control_fd, "R\n");
1798 break;
1799 default:
1800 break;
1803 if (result <= 0)
1804 break;
1807 if (result > 0)
1809 playlist->num_cached = 0;
1810 playlist->pending_control_sync = true;
1812 result = 0;
1814 else
1816 result = -1;
1817 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_UPDATE_ERROR));
1820 return result;
1824 * Update control data with new command. Depending on the command, it may be
1825 * cached or flushed to disk.
1827 static int update_control(struct playlist_info* playlist,
1828 enum playlist_command command, int i1, int i2,
1829 const char* s1, const char* s2, void* data)
1831 int result = 0;
1832 struct playlist_control_cache* cache;
1833 bool flush = false;
1835 mutex_lock(&playlist->control_mutex);
1837 cache = &(playlist->control_cache[playlist->num_cached++]);
1839 cache->command = command;
1840 cache->i1 = i1;
1841 cache->i2 = i2;
1842 cache->s1 = s1;
1843 cache->s2 = s2;
1844 cache->data = data;
1846 switch (command)
1848 case PLAYLIST_COMMAND_PLAYLIST:
1849 case PLAYLIST_COMMAND_ADD:
1850 case PLAYLIST_COMMAND_QUEUE:
1851 #ifndef HAVE_DIRCACHE
1852 case PLAYLIST_COMMAND_DELETE:
1853 case PLAYLIST_COMMAND_RESET:
1854 #endif
1855 flush = true;
1856 break;
1857 case PLAYLIST_COMMAND_SHUFFLE:
1858 case PLAYLIST_COMMAND_UNSHUFFLE:
1859 default:
1860 /* only flush when needed */
1861 break;
1864 if (flush || playlist->num_cached == PLAYLIST_MAX_CACHE)
1865 result = flush_cached_control(playlist);
1867 mutex_unlock(&playlist->control_mutex);
1869 return result;
1873 * sync control file to disk
1875 static void sync_control(struct playlist_info* playlist, bool force)
1877 #ifdef HAVE_DIRCACHE
1878 if (playlist->started && force)
1879 #else
1880 (void) force;
1882 if (playlist->started)
1883 #endif
1885 if (playlist->pending_control_sync)
1887 mutex_lock(&playlist->control_mutex);
1888 fsync(playlist->control_fd);
1889 playlist->pending_control_sync = false;
1890 mutex_unlock(&playlist->control_mutex);
1896 * Rotate indices such that first_index is index 0
1898 static int rotate_index(const struct playlist_info* playlist, int index)
1900 index -= playlist->first_index;
1901 if (index < 0)
1902 index += playlist->amount;
1904 return index;
1908 * Initialize playlist entries at startup
1910 void playlist_init(void)
1912 struct playlist_info* playlist = &current_playlist;
1914 playlist->current = true;
1915 get_user_file_path(PLAYLIST_CONTROL_FILE, IS_FILE|NEED_WRITE|FORCE_BUFFER_COPY,
1916 playlist->control_filename,
1917 sizeof(playlist->control_filename));
1918 playlist->fd = -1;
1919 playlist->control_fd = -1;
1920 playlist->max_playlist_size = global_settings.max_files_in_playlist;
1921 playlist->indices = buffer_alloc(
1922 playlist->max_playlist_size * sizeof(int));
1923 playlist->buffer_size =
1924 AVERAGE_FILENAME_LENGTH * global_settings.max_files_in_dir;
1925 playlist->buffer = buffer_alloc(playlist->buffer_size);
1926 mutex_init(&playlist->control_mutex);
1927 empty_playlist(playlist, true);
1929 #ifdef HAVE_DIRCACHE
1930 playlist->filenames = buffer_alloc(
1931 playlist->max_playlist_size * sizeof(int));
1932 memset(playlist->filenames, 0,
1933 playlist->max_playlist_size * sizeof(int));
1934 create_thread(playlist_thread, playlist_stack, sizeof(playlist_stack),
1935 0, playlist_thread_name IF_PRIO(, PRIORITY_BACKGROUND)
1936 IF_COP(, CPU));
1937 queue_init(&playlist_queue, true);
1938 #endif
1942 * Clean playlist at shutdown
1944 void playlist_shutdown(void)
1946 struct playlist_info* playlist = &current_playlist;
1948 if (playlist->control_fd >= 0)
1950 mutex_lock(&playlist->control_mutex);
1952 if (playlist->num_cached > 0)
1953 flush_cached_control(playlist);
1955 close(playlist->control_fd);
1957 mutex_unlock(&playlist->control_mutex);
1962 * Create new playlist
1964 int playlist_create(const char *dir, const char *file)
1966 struct playlist_info* playlist = &current_playlist;
1968 new_playlist(playlist, dir, file);
1970 if (file)
1971 /* load the playlist file */
1972 add_indices_to_playlist(playlist, NULL, 0);
1974 return 0;
1977 #define PLAYLIST_COMMAND_SIZE (MAX_PATH+12)
1980 * Restore the playlist state based on control file commands. Called to
1981 * resume playback after shutdown.
1983 int playlist_resume(void)
1985 struct playlist_info* playlist = &current_playlist;
1986 char *buffer;
1987 size_t buflen;
1988 int nread;
1989 int total_read = 0;
1990 int control_file_size = 0;
1991 bool first = true;
1992 bool sorted = true;
1994 /* use mp3 buffer for maximum load speed */
1995 #if CONFIG_CODEC != SWCODEC
1996 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
1997 buflen = (audiobufend - audiobuf);
1998 buffer = (char *)audiobuf;
1999 #else
2000 buffer = (char *)audio_get_buffer(false, &buflen);
2001 #endif
2003 empty_playlist(playlist, true);
2005 splash(0, ID2P(LANG_WAIT));
2006 playlist->control_fd = open(playlist->control_filename, O_RDWR);
2007 if (playlist->control_fd < 0)
2009 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2010 return -1;
2012 playlist->control_created = true;
2014 control_file_size = filesize(playlist->control_fd);
2015 if (control_file_size <= 0)
2017 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2018 return -1;
2021 /* read a small amount first to get the header */
2022 nread = read(playlist->control_fd, buffer,
2023 PLAYLIST_COMMAND_SIZE<buflen?PLAYLIST_COMMAND_SIZE:buflen);
2024 if(nread <= 0)
2026 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2027 return -1;
2030 playlist->started = true;
2032 while (1)
2034 int result = 0;
2035 int count;
2036 enum playlist_command current_command = PLAYLIST_COMMAND_COMMENT;
2037 int last_newline = 0;
2038 int str_count = -1;
2039 bool newline = true;
2040 bool exit_loop = false;
2041 char *p = buffer;
2042 char *str1 = NULL;
2043 char *str2 = NULL;
2044 char *str3 = NULL;
2045 unsigned long last_tick = current_tick;
2046 bool useraborted = false;
2048 for(count=0; count<nread && !exit_loop && !useraborted; count++,p++)
2050 /* So a splash while we are loading. */
2051 if (TIME_AFTER(current_tick, last_tick + HZ/4))
2053 splashf(0, str(LANG_LOADING_PERCENT),
2054 (total_read+count)*100/control_file_size,
2055 str(LANG_OFF_ABORT));
2056 if (action_userabort(TIMEOUT_NOBLOCK))
2058 useraborted = true;
2059 break;
2061 last_tick = current_tick;
2064 /* Are we on a new line? */
2065 if((*p == '\n') || (*p == '\r'))
2067 *p = '\0';
2069 /* save last_newline in case we need to load more data */
2070 last_newline = count;
2072 switch (current_command)
2074 case PLAYLIST_COMMAND_PLAYLIST:
2076 /* str1=version str2=dir str3=file */
2077 int version;
2079 if (!str1)
2081 result = -1;
2082 exit_loop = true;
2083 break;
2086 if (!str2)
2087 str2 = "";
2089 if (!str3)
2090 str3 = "";
2092 version = atoi(str1);
2094 if (version != PLAYLIST_CONTROL_FILE_VERSION)
2095 return -1;
2097 update_playlist_filename(playlist, str2, str3);
2099 if (str3[0] != '\0')
2101 /* NOTE: add_indices_to_playlist() overwrites the
2102 audiobuf so we need to reload control file
2103 data */
2104 add_indices_to_playlist(playlist, NULL, 0);
2106 else if (str2[0] != '\0')
2108 playlist->in_ram = true;
2109 resume_directory(str2);
2112 /* load the rest of the data */
2113 first = false;
2114 exit_loop = true;
2116 break;
2118 case PLAYLIST_COMMAND_ADD:
2119 case PLAYLIST_COMMAND_QUEUE:
2121 /* str1=position str2=last_position str3=file */
2122 int position, last_position;
2123 bool queue;
2125 if (!str1 || !str2 || !str3)
2127 result = -1;
2128 exit_loop = true;
2129 break;
2132 position = atoi(str1);
2133 last_position = atoi(str2);
2135 queue = (current_command == PLAYLIST_COMMAND_ADD)?
2136 false:true;
2138 /* seek position is based on str3's position in
2139 buffer */
2140 if (add_track_to_playlist(playlist, str3, position,
2141 queue, total_read+(str3-buffer)) < 0)
2142 return -1;
2144 playlist->last_insert_pos = last_position;
2146 break;
2148 case PLAYLIST_COMMAND_DELETE:
2150 /* str1=position */
2151 int position;
2153 if (!str1)
2155 result = -1;
2156 exit_loop = true;
2157 break;
2160 position = atoi(str1);
2162 if (remove_track_from_playlist(playlist, position,
2163 false) < 0)
2164 return -1;
2166 break;
2168 case PLAYLIST_COMMAND_SHUFFLE:
2170 /* str1=seed str2=first_index */
2171 int seed;
2173 if (!str1 || !str2)
2175 result = -1;
2176 exit_loop = true;
2177 break;
2180 if (!sorted)
2182 /* Always sort list before shuffling */
2183 sort_playlist(playlist, false, false);
2186 seed = atoi(str1);
2187 playlist->first_index = atoi(str2);
2189 if (randomise_playlist(playlist, seed, false,
2190 false) < 0)
2191 return -1;
2192 sorted = false;
2193 break;
2195 case PLAYLIST_COMMAND_UNSHUFFLE:
2197 /* str1=first_index */
2198 if (!str1)
2200 result = -1;
2201 exit_loop = true;
2202 break;
2205 playlist->first_index = atoi(str1);
2207 if (sort_playlist(playlist, false, false) < 0)
2208 return -1;
2210 sorted = true;
2211 break;
2213 case PLAYLIST_COMMAND_RESET:
2215 playlist->last_insert_pos = -1;
2216 break;
2218 case PLAYLIST_COMMAND_COMMENT:
2219 default:
2220 break;
2223 newline = true;
2225 /* to ignore any extra newlines */
2226 current_command = PLAYLIST_COMMAND_COMMENT;
2228 else if(newline)
2230 newline = false;
2232 /* first non-comment line must always specify playlist */
2233 if (first && *p != 'P' && *p != '#')
2235 result = -1;
2236 exit_loop = true;
2237 break;
2240 switch (*p)
2242 case 'P':
2243 /* playlist can only be specified once */
2244 if (!first)
2246 result = -1;
2247 exit_loop = true;
2248 break;
2251 current_command = PLAYLIST_COMMAND_PLAYLIST;
2252 break;
2253 case 'A':
2254 current_command = PLAYLIST_COMMAND_ADD;
2255 break;
2256 case 'Q':
2257 current_command = PLAYLIST_COMMAND_QUEUE;
2258 break;
2259 case 'D':
2260 current_command = PLAYLIST_COMMAND_DELETE;
2261 break;
2262 case 'S':
2263 current_command = PLAYLIST_COMMAND_SHUFFLE;
2264 break;
2265 case 'U':
2266 current_command = PLAYLIST_COMMAND_UNSHUFFLE;
2267 break;
2268 case 'R':
2269 current_command = PLAYLIST_COMMAND_RESET;
2270 break;
2271 case '#':
2272 current_command = PLAYLIST_COMMAND_COMMENT;
2273 break;
2274 default:
2275 result = -1;
2276 exit_loop = true;
2277 break;
2280 str_count = -1;
2281 str1 = NULL;
2282 str2 = NULL;
2283 str3 = NULL;
2285 else if(current_command != PLAYLIST_COMMAND_COMMENT)
2287 /* all control file strings are separated with a colon.
2288 Replace the colon with 0 to get proper strings that can be
2289 used by commands above */
2290 if (*p == ':')
2292 *p = '\0';
2293 str_count++;
2295 if ((count+1) < nread)
2297 switch (str_count)
2299 case 0:
2300 str1 = p+1;
2301 break;
2302 case 1:
2303 str2 = p+1;
2304 break;
2305 case 2:
2306 str3 = p+1;
2307 break;
2308 default:
2309 /* allow last string to contain colons */
2310 *p = ':';
2311 break;
2318 if (result < 0)
2320 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID));
2321 return result;
2324 if (useraborted)
2326 splash(HZ*2, ID2P(LANG_CANCEL));
2327 return -1;
2329 if (!newline || (exit_loop && count<nread))
2331 if ((total_read + count) >= control_file_size)
2333 /* no newline at end of control file */
2334 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID));
2335 return -1;
2338 /* We didn't end on a newline or we exited loop prematurely.
2339 Either way, re-read the remainder. */
2340 count = last_newline;
2341 lseek(playlist->control_fd, total_read+count, SEEK_SET);
2344 total_read += count;
2346 if (first)
2347 /* still looking for header */
2348 nread = read(playlist->control_fd, buffer,
2349 PLAYLIST_COMMAND_SIZE<buflen?PLAYLIST_COMMAND_SIZE:buflen);
2350 else
2351 nread = read(playlist->control_fd, buffer, buflen);
2353 /* Terminate on EOF */
2354 if(nread <= 0)
2356 break;
2360 #ifdef HAVE_DIRCACHE
2361 queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
2362 #endif
2364 return 0;
2368 * Add track to in_ram playlist. Used when playing directories.
2370 int playlist_add(const char *filename)
2372 struct playlist_info* playlist = &current_playlist;
2373 int len = strlen(filename);
2375 if((len+1 > playlist->buffer_size - playlist->buffer_end_pos) ||
2376 (playlist->amount >= playlist->max_playlist_size))
2378 display_buffer_full();
2379 return -1;
2382 playlist->indices[playlist->amount] = playlist->buffer_end_pos;
2383 #ifdef HAVE_DIRCACHE
2384 playlist->filenames[playlist->amount] = NULL;
2385 #endif
2386 playlist->amount++;
2388 strcpy(&playlist->buffer[playlist->buffer_end_pos], filename);
2389 playlist->buffer_end_pos += len;
2390 playlist->buffer[playlist->buffer_end_pos++] = '\0';
2392 return 0;
2395 /* shuffle newly created playlist using random seed. */
2396 int playlist_shuffle(int random_seed, int start_index)
2398 struct playlist_info* playlist = &current_playlist;
2400 unsigned int seek_pos = 0;
2401 bool start_current = false;
2403 if (start_index >= 0 && global_settings.play_selected)
2405 /* store the seek position before the shuffle */
2406 seek_pos = playlist->indices[start_index];
2407 playlist->index = playlist->first_index = start_index;
2408 start_current = true;
2411 randomise_playlist(playlist, random_seed, start_current, true);
2413 return playlist->index;
2416 /* start playing current playlist at specified index/offset */
2417 void playlist_start(int start_index, int offset)
2419 struct playlist_info* playlist = &current_playlist;
2421 /* Cancel FM radio selection as previous music. For cases where we start
2422 playback without going to the WPS, such as playlist insert.. or
2423 playlist catalog. */
2424 previous_music_is_wps();
2426 playlist->index = start_index;
2428 #if CONFIG_CODEC != SWCODEC
2429 talk_buffer_steal(); /* will use the mp3 buffer */
2430 #endif
2432 playlist->started = true;
2433 sync_control(playlist, false);
2434 audio_play(offset);
2437 /* Returns false if 'steps' is out of bounds, else true */
2438 bool playlist_check(int steps)
2440 struct playlist_info* playlist = &current_playlist;
2442 /* always allow folder navigation */
2443 if (global_settings.next_folder && playlist->in_ram)
2444 return true;
2446 int index = get_next_index(playlist, steps, -1);
2448 if (index < 0 && steps >= 0 && global_settings.repeat_mode == REPEAT_SHUFFLE)
2449 index = get_next_index(playlist, steps, REPEAT_ALL);
2451 return (index >= 0);
2454 /* get trackname of track that is "steps" away from current playing track.
2455 NULL is used to identify end of playlist */
2456 const char* playlist_peek(int steps)
2458 struct playlist_info* playlist = &current_playlist;
2459 int seek;
2460 char *temp_ptr;
2461 int index;
2462 bool control_file;
2464 index = get_next_index(playlist, steps, -1);
2465 if (index < 0)
2466 return NULL;
2468 control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
2469 seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
2471 if (get_filename(playlist, index, seek, control_file, now_playing,
2472 MAX_PATH+1) < 0)
2473 return NULL;
2475 temp_ptr = now_playing;
2477 if (!playlist->in_ram || control_file)
2479 /* remove bogus dirs from beginning of path
2480 (workaround for buggy playlist creation tools) */
2481 while (temp_ptr)
2483 if (file_exists(temp_ptr))
2484 break;
2486 temp_ptr = strchr(temp_ptr+1, '/');
2489 if (!temp_ptr)
2491 /* Even though this is an invalid file, we still need to pass a
2492 file name to the caller because NULL is used to indicate end
2493 of playlist */
2494 return now_playing;
2498 return temp_ptr;
2502 * Update indices as track has changed
2504 int playlist_next(int steps)
2506 struct playlist_info* playlist = &current_playlist;
2507 int index;
2509 if ( (steps > 0)
2510 #ifdef AB_REPEAT_ENABLE
2511 && (global_settings.repeat_mode != REPEAT_AB)
2512 #endif
2513 && (global_settings.repeat_mode != REPEAT_ONE) )
2515 int i, j;
2517 /* We need to delete all the queued songs */
2518 for (i=0, j=steps; i<j; i++)
2520 index = get_next_index(playlist, i, -1);
2522 if (playlist->indices[index] & PLAYLIST_QUEUE_MASK)
2524 remove_track_from_playlist(playlist, index, true);
2525 steps--; /* one less track */
2530 index = get_next_index(playlist, steps, -1);
2532 if (index < 0)
2534 /* end of playlist... or is it */
2535 if (global_settings.repeat_mode == REPEAT_SHUFFLE &&
2536 playlist->amount > 1)
2538 /* Repeat shuffle mode. Re-shuffle playlist and resume play */
2539 playlist->first_index = 0;
2540 sort_playlist(playlist, false, false);
2541 randomise_playlist(playlist, current_tick, false, true);
2542 #if CONFIG_CODEC != SWCODEC
2543 playlist_start(0, 0);
2544 #endif
2545 playlist->index = 0;
2546 index = 0;
2548 else if (playlist->in_ram && global_settings.next_folder)
2550 index = create_and_play_dir(steps, true);
2552 if (index >= 0)
2554 playlist->index = index;
2558 return index;
2561 playlist->index = index;
2563 if (playlist->last_insert_pos >= 0 && steps > 0)
2565 /* check to see if we've gone beyond the last inserted track */
2566 int cur = rotate_index(playlist, index);
2567 int last_pos = rotate_index(playlist, playlist->last_insert_pos);
2569 if (cur > last_pos)
2571 /* reset last inserted track */
2572 playlist->last_insert_pos = -1;
2574 if (playlist->control_fd >= 0)
2576 int result = update_control(playlist, PLAYLIST_COMMAND_RESET,
2577 -1, -1, NULL, NULL, NULL);
2579 if (result < 0)
2580 return result;
2582 sync_control(playlist, false);
2587 return index;
2590 /* try playing next or previous folder */
2591 bool playlist_next_dir(int direction)
2593 /* not to mess up real playlists */
2594 if(!current_playlist.in_ram)
2595 return false;
2597 return create_and_play_dir(direction, false) >= 0;
2600 /* Get resume info for current playing song. If return value is -1 then
2601 settings shouldn't be saved. */
2602 int playlist_get_resume_info(int *resume_index)
2604 struct playlist_info* playlist = &current_playlist;
2606 *resume_index = playlist->index;
2608 return 0;
2611 /* Update resume info for current playing song. Returns -1 on error. */
2612 int playlist_update_resume_info(const struct mp3entry* id3)
2614 struct playlist_info* playlist = &current_playlist;
2616 if (id3)
2618 if (global_status.resume_index != playlist->index ||
2619 global_status.resume_offset != id3->offset)
2621 global_status.resume_index = playlist->index;
2622 global_status.resume_offset = id3->offset;
2623 status_save();
2626 else
2628 global_status.resume_index = -1;
2629 global_status.resume_offset = -1;
2630 status_save();
2633 return 0;
2636 /* Returns index of current playing track for display purposes. This value
2637 should not be used for resume purposes as it doesn't represent the actual
2638 index into the playlist */
2639 int playlist_get_display_index(void)
2641 struct playlist_info* playlist = &current_playlist;
2643 /* first_index should always be index 0 for display purposes */
2644 int index = rotate_index(playlist, playlist->index);
2646 return (index+1);
2649 /* returns number of tracks in current playlist */
2650 int playlist_amount(void)
2652 return playlist_amount_ex(NULL);
2654 /* set playlist->last_shuffle_start to playlist->amount for
2655 PLAYLIST_INSERT_LAST_SHUFFLED command purposes*/
2656 void playlist_set_last_shuffled_start(void)
2658 struct playlist_info* playlist = &current_playlist;
2659 playlist->last_shuffled_start = playlist->amount;
2662 * Create a new playlist If playlist is not NULL then we're loading a
2663 * playlist off disk for viewing/editing. The index_buffer is used to store
2664 * playlist indices (required for and only used if !current playlist). The
2665 * temp_buffer (if not NULL) is used as a scratchpad when loading indices.
2667 int playlist_create_ex(struct playlist_info* playlist,
2668 const char* dir, const char* file,
2669 void* index_buffer, int index_buffer_size,
2670 void* temp_buffer, int temp_buffer_size)
2672 if (!playlist)
2673 playlist = &current_playlist;
2674 else
2676 /* Initialize playlist structure */
2677 int r = rand() % 10;
2678 playlist->current = false;
2680 /* Use random name for control file */
2681 snprintf(playlist->control_filename, sizeof(playlist->control_filename),
2682 "%s.%d", PLAYLIST_CONTROL_FILE, r);
2683 playlist->fd = -1;
2684 playlist->control_fd = -1;
2686 if (index_buffer)
2688 int num_indices = index_buffer_size / sizeof(int);
2690 #ifdef HAVE_DIRCACHE
2691 num_indices /= 2;
2692 #endif
2693 if (num_indices > global_settings.max_files_in_playlist)
2694 num_indices = global_settings.max_files_in_playlist;
2696 playlist->max_playlist_size = num_indices;
2697 playlist->indices = index_buffer;
2698 #ifdef HAVE_DIRCACHE
2699 playlist->filenames = (const struct dircache_entry **)
2700 &playlist->indices[num_indices];
2701 #endif
2703 else
2705 playlist->max_playlist_size = current_playlist.max_playlist_size;
2706 playlist->indices = current_playlist.indices;
2707 #ifdef HAVE_DIRCACHE
2708 playlist->filenames = current_playlist.filenames;
2709 #endif
2712 playlist->buffer_size = 0;
2713 playlist->buffer = NULL;
2714 mutex_init(&playlist->control_mutex);
2717 new_playlist(playlist, dir, file);
2719 if (file)
2720 /* load the playlist file */
2721 add_indices_to_playlist(playlist, temp_buffer, temp_buffer_size);
2723 return 0;
2727 * Set the specified playlist as the current.
2728 * NOTE: You will get undefined behaviour if something is already playing so
2729 * remember to stop before calling this. Also, this call will
2730 * effectively close your playlist, making it unusable.
2732 int playlist_set_current(struct playlist_info* playlist)
2734 if (!playlist || (check_control(playlist) < 0))
2735 return -1;
2737 empty_playlist(&current_playlist, false);
2739 strlcpy(current_playlist.filename, playlist->filename,
2740 sizeof(current_playlist.filename));
2742 current_playlist.utf8 = playlist->utf8;
2743 current_playlist.fd = playlist->fd;
2745 close(playlist->control_fd);
2746 close(current_playlist.control_fd);
2747 remove(current_playlist.control_filename);
2748 if (rename(playlist->control_filename,
2749 current_playlist.control_filename) < 0)
2750 return -1;
2751 current_playlist.control_fd = open(current_playlist.control_filename,
2752 O_RDWR);
2753 if (current_playlist.control_fd < 0)
2754 return -1;
2755 current_playlist.control_created = true;
2757 current_playlist.dirlen = playlist->dirlen;
2759 if (playlist->indices && playlist->indices != current_playlist.indices)
2761 memcpy(current_playlist.indices, playlist->indices,
2762 playlist->max_playlist_size*sizeof(int));
2763 #ifdef HAVE_DIRCACHE
2764 memcpy(current_playlist.filenames, playlist->filenames,
2765 playlist->max_playlist_size*sizeof(int));
2766 #endif
2769 current_playlist.first_index = playlist->first_index;
2770 current_playlist.amount = playlist->amount;
2771 current_playlist.last_insert_pos = playlist->last_insert_pos;
2772 current_playlist.seed = playlist->seed;
2773 current_playlist.shuffle_modified = playlist->shuffle_modified;
2774 current_playlist.deleted = playlist->deleted;
2775 current_playlist.num_inserted_tracks = playlist->num_inserted_tracks;
2777 memcpy(current_playlist.control_cache, playlist->control_cache,
2778 sizeof(current_playlist.control_cache));
2779 current_playlist.num_cached = playlist->num_cached;
2780 current_playlist.pending_control_sync = playlist->pending_control_sync;
2782 return 0;
2784 struct playlist_info *playlist_get_current(void)
2786 return &current_playlist;
2789 * Close files and delete control file for non-current playlist.
2791 void playlist_close(struct playlist_info* playlist)
2793 if (!playlist)
2794 return;
2796 if (playlist->fd >= 0)
2797 close(playlist->fd);
2799 if (playlist->control_fd >= 0)
2800 close(playlist->control_fd);
2802 if (playlist->control_created)
2803 remove(playlist->control_filename);
2806 void playlist_sync(struct playlist_info* playlist)
2808 if (!playlist)
2809 playlist = &current_playlist;
2811 sync_control(playlist, false);
2812 if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
2813 audio_flush_and_reload_tracks();
2815 #ifdef HAVE_DIRCACHE
2816 queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
2817 #endif
2821 * Insert track into playlist at specified position (or one of the special
2822 * positions). Returns position where track was inserted or -1 if error.
2824 int playlist_insert_track(struct playlist_info* playlist, const char *filename,
2825 int position, bool queue, bool sync)
2827 int result;
2829 if (!playlist)
2830 playlist = &current_playlist;
2832 if (check_control(playlist) < 0)
2834 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2835 return -1;
2838 result = add_track_to_playlist(playlist, filename, position, queue, -1);
2840 /* Check if we want manually sync later. For example when adding
2841 * bunch of files from tagcache, syncing after every file wouldn't be
2842 * a good thing to do. */
2843 if (sync && result >= 0)
2844 playlist_sync(playlist);
2846 return result;
2850 * Insert all tracks from specified directory into playlist.
2852 int playlist_insert_directory(struct playlist_info* playlist,
2853 const char *dirname, int position, bool queue,
2854 bool recurse)
2856 int result;
2857 unsigned char *count_str;
2858 struct directory_search_context context;
2860 if (!playlist)
2861 playlist = &current_playlist;
2863 if (check_control(playlist) < 0)
2865 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2866 return -1;
2869 if (position == PLAYLIST_REPLACE)
2871 if (playlist_remove_all_tracks(playlist) == 0)
2872 position = PLAYLIST_INSERT_LAST;
2873 else
2874 return -1;
2877 if (queue)
2878 count_str = ID2P(LANG_PLAYLIST_QUEUE_COUNT);
2879 else
2880 count_str = ID2P(LANG_PLAYLIST_INSERT_COUNT);
2882 display_playlist_count(0, count_str, false);
2884 context.playlist = playlist;
2885 context.position = position;
2886 context.queue = queue;
2887 context.count = 0;
2889 cpu_boost(true);
2891 result = playlist_directory_tracksearch(dirname, recurse,
2892 directory_search_callback, &context);
2894 sync_control(playlist, false);
2896 cpu_boost(false);
2898 display_playlist_count(context.count, count_str, true);
2900 if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
2901 audio_flush_and_reload_tracks();
2903 #ifdef HAVE_DIRCACHE
2904 queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
2905 #endif
2907 return result;
2911 * Insert all tracks from specified playlist into dynamic playlist.
2913 int playlist_insert_playlist(struct playlist_info* playlist, const char *filename,
2914 int position, bool queue)
2916 int fd;
2917 int max;
2918 char *temp_ptr;
2919 const char *dir;
2920 unsigned char *count_str;
2921 char temp_buf[MAX_PATH+1];
2922 char trackname[MAX_PATH+1];
2923 int count = 0;
2924 int result = 0;
2925 bool utf8 = is_m3u8(filename);
2927 if (!playlist)
2928 playlist = &current_playlist;
2930 if (check_control(playlist) < 0)
2932 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2933 return -1;
2936 fd = open_utf8(filename, O_RDONLY);
2937 if (fd < 0)
2939 splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
2940 return -1;
2943 /* we need the directory name for formatting purposes */
2944 dir = filename;
2946 temp_ptr = strrchr(filename+1,'/');
2947 if (temp_ptr)
2948 *temp_ptr = 0;
2949 else
2950 dir = "/";
2952 if (queue)
2953 count_str = ID2P(LANG_PLAYLIST_QUEUE_COUNT);
2954 else
2955 count_str = ID2P(LANG_PLAYLIST_INSERT_COUNT);
2957 display_playlist_count(count, count_str, false);
2959 if (position == PLAYLIST_REPLACE)
2961 if (playlist_remove_all_tracks(playlist) == 0)
2962 position = PLAYLIST_INSERT_LAST;
2963 else return -1;
2966 cpu_boost(true);
2968 while ((max = read_line(fd, temp_buf, sizeof(temp_buf))) > 0)
2970 /* user abort */
2971 if (action_userabort(TIMEOUT_NOBLOCK))
2972 break;
2974 if (temp_buf[0] != '#' && temp_buf[0] != '\0')
2976 int insert_pos;
2978 if (!utf8)
2980 /* Use trackname as a temporay buffer. Note that trackname must
2981 * be as large as temp_buf.
2983 max = convert_m3u(temp_buf, max, sizeof(temp_buf), trackname);
2986 /* we need to format so that relative paths are correctly
2987 handled */
2988 if (format_track_path(trackname, temp_buf, sizeof(trackname), max,
2989 dir) < 0)
2991 result = -1;
2992 break;
2995 insert_pos = add_track_to_playlist(playlist, trackname, position,
2996 queue, -1);
2998 if (insert_pos < 0)
3000 result = -1;
3001 break;
3004 /* Make sure tracks are inserted in correct order if user
3005 requests INSERT_FIRST */
3006 if (position == PLAYLIST_INSERT_FIRST || position >= 0)
3007 position = insert_pos + 1;
3009 count++;
3011 if ((count%PLAYLIST_DISPLAY_COUNT) == 0)
3013 display_playlist_count(count, count_str, false);
3015 if (count == PLAYLIST_DISPLAY_COUNT &&
3016 (audio_status() & AUDIO_STATUS_PLAY) &&
3017 playlist->started)
3018 audio_flush_and_reload_tracks();
3022 /* let the other threads work */
3023 yield();
3026 close(fd);
3028 if (temp_ptr)
3029 *temp_ptr = '/';
3031 sync_control(playlist, false);
3033 cpu_boost(false);
3035 display_playlist_count(count, count_str, true);
3037 if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
3038 audio_flush_and_reload_tracks();
3040 #ifdef HAVE_DIRCACHE
3041 queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
3042 #endif
3044 return result;
3048 * Delete track at specified index. If index is PLAYLIST_DELETE_CURRENT then
3049 * we want to delete the current playing track.
3051 int playlist_delete(struct playlist_info* playlist, int index)
3053 int result = 0;
3055 if (!playlist)
3056 playlist = &current_playlist;
3058 if (check_control(playlist) < 0)
3060 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
3061 return -1;
3064 if (index == PLAYLIST_DELETE_CURRENT)
3065 index = playlist->index;
3067 result = remove_track_from_playlist(playlist, index, true);
3069 if (result != -1 && (audio_status() & AUDIO_STATUS_PLAY) &&
3070 playlist->started)
3071 audio_flush_and_reload_tracks();
3073 return result;
3077 * Move track at index to new_index. Tracks between the two are shifted
3078 * appropriately. Returns 0 on success and -1 on failure.
3080 int playlist_move(struct playlist_info* playlist, int index, int new_index)
3082 int result;
3083 int seek;
3084 bool control_file;
3085 bool queue;
3086 bool current = false;
3087 int r;
3088 char filename[MAX_PATH];
3090 if (!playlist)
3091 playlist = &current_playlist;
3093 if (check_control(playlist) < 0)
3095 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
3096 return -1;
3099 if (index == new_index)
3100 return -1;
3102 if (index == playlist->index)
3103 /* Moving the current track */
3104 current = true;
3106 control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
3107 queue = playlist->indices[index] & PLAYLIST_QUEUE_MASK;
3108 seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
3110 if (get_filename(playlist, index, seek, control_file, filename,
3111 sizeof(filename)) < 0)
3112 return -1;
3114 /* We want to insert the track at the position that was specified by
3115 new_index. This may be different then new_index because of the
3116 shifting that will occur after the delete.
3117 We calculate this before we do the remove as it depends on the
3118 size of the playlist before the track removal */
3119 r = rotate_index(playlist, new_index);
3121 /* Delete track from original position */
3122 result = remove_track_from_playlist(playlist, index, true);
3124 if (result != -1)
3126 if (r == 0)
3127 /* First index */
3128 new_index = PLAYLIST_PREPEND;
3129 else if (r == playlist->amount)
3130 /* Append */
3131 new_index = PLAYLIST_INSERT_LAST;
3132 else
3133 /* Calculate index of desired position */
3134 new_index = (r+playlist->first_index)%playlist->amount;
3136 result = add_track_to_playlist(playlist, filename, new_index, queue,
3137 -1);
3139 if (result != -1)
3141 if (current)
3143 /* Moved the current track */
3144 switch (new_index)
3146 case PLAYLIST_PREPEND:
3147 playlist->index = playlist->first_index;
3148 break;
3149 case PLAYLIST_INSERT_LAST:
3150 playlist->index = playlist->first_index - 1;
3151 if (playlist->index < 0)
3152 playlist->index += playlist->amount;
3153 break;
3154 default:
3155 playlist->index = new_index;
3156 break;
3160 if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
3161 audio_flush_and_reload_tracks();
3165 #ifdef HAVE_DIRCACHE
3166 queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
3167 #endif
3169 return result;
3172 /* shuffle currently playing playlist */
3173 int playlist_randomise(struct playlist_info* playlist, unsigned int seed,
3174 bool start_current)
3176 int result;
3178 if (!playlist)
3179 playlist = &current_playlist;
3181 check_control(playlist);
3183 result = randomise_playlist(playlist, seed, start_current, true);
3185 if (result != -1 && (audio_status() & AUDIO_STATUS_PLAY) &&
3186 playlist->started)
3187 audio_flush_and_reload_tracks();
3189 return result;
3192 /* sort currently playing playlist */
3193 int playlist_sort(struct playlist_info* playlist, bool start_current)
3195 int result;
3197 if (!playlist)
3198 playlist = &current_playlist;
3200 check_control(playlist);
3202 result = sort_playlist(playlist, start_current, true);
3204 if (result != -1 && (audio_status() & AUDIO_STATUS_PLAY) &&
3205 playlist->started)
3206 audio_flush_and_reload_tracks();
3208 return result;
3211 /* returns true if playlist has been modified */
3212 bool playlist_modified(const struct playlist_info* playlist)
3214 if (!playlist)
3215 playlist = &current_playlist;
3217 if (playlist->shuffle_modified ||
3218 playlist->deleted ||
3219 playlist->num_inserted_tracks > 0)
3220 return true;
3222 return false;
3225 /* returns index of first track in playlist */
3226 int playlist_get_first_index(const struct playlist_info* playlist)
3228 if (!playlist)
3229 playlist = &current_playlist;
3231 return playlist->first_index;
3234 /* returns shuffle seed of playlist */
3235 int playlist_get_seed(const struct playlist_info* playlist)
3237 if (!playlist)
3238 playlist = &current_playlist;
3240 return playlist->seed;
3243 /* returns number of tracks in playlist (includes queued/inserted tracks) */
3244 int playlist_amount_ex(const struct playlist_info* playlist)
3246 if (!playlist)
3247 playlist = &current_playlist;
3249 return playlist->amount;
3252 /* returns full path of playlist (minus extension) */
3253 char *playlist_name(const struct playlist_info* playlist, char *buf,
3254 int buf_size)
3256 char *sep;
3258 if (!playlist)
3259 playlist = &current_playlist;
3261 strlcpy(buf, playlist->filename+playlist->dirlen, buf_size);
3263 if (!buf[0])
3264 return NULL;
3266 /* Remove extension */
3267 sep = strrchr(buf, '.');
3268 if (sep)
3269 *sep = 0;
3271 return buf;
3274 /* returns the playlist filename */
3275 char *playlist_get_name(const struct playlist_info* playlist, char *buf,
3276 int buf_size)
3278 if (!playlist)
3279 playlist = &current_playlist;
3281 strlcpy(buf, playlist->filename, buf_size);
3283 if (!buf[0])
3284 return NULL;
3286 return buf;
3289 /* Fills info structure with information about track at specified index.
3290 Returns 0 on success and -1 on failure */
3291 int playlist_get_track_info(struct playlist_info* playlist, int index,
3292 struct playlist_track_info* info)
3294 int seek;
3295 bool control_file;
3297 if (!playlist)
3298 playlist = &current_playlist;
3300 if (index < 0 || index >= playlist->amount)
3301 return -1;
3303 control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
3304 seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
3306 if (get_filename(playlist, index, seek, control_file, info->filename,
3307 sizeof(info->filename)) < 0)
3308 return -1;
3310 info->attr = 0;
3312 if (control_file)
3314 if (playlist->indices[index] & PLAYLIST_QUEUE_MASK)
3315 info->attr |= PLAYLIST_ATTR_QUEUED;
3316 else
3317 info->attr |= PLAYLIST_ATTR_INSERTED;
3321 if (playlist->indices[index] & PLAYLIST_SKIPPED)
3322 info->attr |= PLAYLIST_ATTR_SKIPPED;
3324 info->index = index;
3325 info->display_index = rotate_index(playlist, index) + 1;
3327 return 0;
3330 /* save the current dynamic playlist to specified file */
3331 int playlist_save(struct playlist_info* playlist, char *filename)
3333 int fd;
3334 int i, index;
3335 int count = 0;
3336 char path[MAX_PATH+1];
3337 char tmp_buf[MAX_PATH+1];
3338 int result = 0;
3339 bool overwrite_current = false;
3340 int* index_buf = NULL;
3342 if (!playlist)
3343 playlist = &current_playlist;
3345 if (playlist->amount <= 0)
3346 return -1;
3348 /* use current working directory as base for pathname */
3349 if (format_track_path(path, filename, sizeof(tmp_buf),
3350 strlen(filename)+1, getcwd(NULL, -1)) < 0)
3351 return -1;
3353 if (!strncmp(playlist->filename, path, strlen(path)))
3355 /* Attempting to overwrite current playlist file.*/
3357 if (playlist->buffer_size < (int)(playlist->amount * sizeof(int)))
3359 /* not enough buffer space to store updated indices */
3360 splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
3361 return -1;
3364 /* in_ram buffer is unused for m3u files so we'll use for storing
3365 updated indices */
3366 index_buf = (int*)playlist->buffer;
3368 /* use temporary pathname */
3369 snprintf(path, sizeof(path), "%s_temp", playlist->filename);
3370 overwrite_current = true;
3373 if (is_m3u8(path))
3375 fd = open_utf8(path, O_CREAT|O_WRONLY|O_TRUNC);
3377 else
3379 /* some applications require a BOM to read the file properly */
3380 fd = open(path, O_CREAT|O_WRONLY|O_TRUNC, 0666);
3382 if (fd < 0)
3384 splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
3385 return -1;
3388 display_playlist_count(count, ID2P(LANG_PLAYLIST_SAVE_COUNT), false);
3390 cpu_boost(true);
3392 index = playlist->first_index;
3393 for (i=0; i<playlist->amount; i++)
3395 bool control_file;
3396 bool queue;
3397 int seek;
3399 /* user abort */
3400 if (action_userabort(TIMEOUT_NOBLOCK))
3402 result = -1;
3403 break;
3406 control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
3407 queue = playlist->indices[index] & PLAYLIST_QUEUE_MASK;
3408 seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
3410 /* Don't save queued files */
3411 if (!queue)
3413 if (get_filename(playlist, index, seek, control_file, tmp_buf,
3414 MAX_PATH+1) < 0)
3416 result = -1;
3417 break;
3420 if (overwrite_current)
3421 index_buf[count] = lseek(fd, 0, SEEK_CUR);
3423 if (fdprintf(fd, "%s\n", tmp_buf) < 0)
3425 splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
3426 result = -1;
3427 break;
3430 count++;
3432 if ((count % PLAYLIST_DISPLAY_COUNT) == 0)
3433 display_playlist_count(count, ID2P(LANG_PLAYLIST_SAVE_COUNT),
3434 false);
3436 yield();
3439 index = (index+1)%playlist->amount;
3442 display_playlist_count(count, ID2P(LANG_PLAYLIST_SAVE_COUNT), true);
3444 close(fd);
3446 if (overwrite_current && result >= 0)
3448 result = -1;
3450 mutex_lock(&playlist->control_mutex);
3452 /* Replace the current playlist with the new one and update indices */
3453 close(playlist->fd);
3454 if (remove(playlist->filename) >= 0)
3456 if (rename(path, playlist->filename) >= 0)
3458 playlist->fd = open_utf8(playlist->filename, O_RDONLY);
3459 if (playlist->fd >= 0)
3461 index = playlist->first_index;
3462 for (i=0, count=0; i<playlist->amount; i++)
3464 if (!(playlist->indices[index] & PLAYLIST_QUEUE_MASK))
3466 playlist->indices[index] = index_buf[count];
3467 count++;
3469 index = (index+1)%playlist->amount;
3472 /* we need to recreate control because inserted tracks are
3473 now part of the playlist and shuffle has been
3474 invalidated */
3475 result = recreate_control(playlist);
3480 mutex_unlock(&playlist->control_mutex);
3484 cpu_boost(false);
3486 return result;
3490 * Search specified directory for tracks and notify via callback. May be
3491 * called recursively.
3493 int playlist_directory_tracksearch(const char* dirname, bool recurse,
3494 int (*callback)(char*, void*),
3495 void* context)
3497 char buf[MAX_PATH+1];
3498 int result = 0;
3499 int num_files = 0;
3500 int i;
3501 struct entry *files;
3502 struct tree_context* tc = tree_get_context();
3503 int old_dirfilter = *(tc->dirfilter);
3505 if (!callback)
3506 return -1;
3508 /* use the tree browser dircache to load files */
3509 *(tc->dirfilter) = SHOW_ALL;
3511 if (ft_load(tc, dirname) < 0)
3513 splash(HZ*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR));
3514 *(tc->dirfilter) = old_dirfilter;
3515 return -1;
3518 files = (struct entry*) tc->dircache;
3519 num_files = tc->filesindir;
3521 /* we've overwritten the dircache so tree browser will need to be
3522 reloaded */
3523 reload_directory();
3525 for (i=0; i<num_files; i++)
3527 /* user abort */
3528 if (action_userabort(TIMEOUT_NOBLOCK))
3530 result = -1;
3531 break;
3534 if (files[i].attr & ATTR_DIRECTORY)
3536 if (recurse)
3538 /* recursively add directories */
3539 snprintf(buf, sizeof(buf), "%s/%s", dirname, files[i].name);
3540 result = playlist_directory_tracksearch(buf, recurse,
3541 callback, context);
3542 if (result < 0)
3543 break;
3545 /* we now need to reload our current directory */
3546 if(ft_load(tc, dirname) < 0)
3548 result = -1;
3549 break;
3552 files = (struct entry*) tc->dircache;
3553 num_files = tc->filesindir;
3554 if (!num_files)
3556 result = -1;
3557 break;
3560 else
3561 continue;
3563 else if ((files[i].attr & FILE_ATTR_MASK) == FILE_ATTR_AUDIO)
3565 snprintf(buf, sizeof(buf), "%s/%s", dirname, files[i].name);
3567 if (callback(buf, context) != 0)
3569 result = -1;
3570 break;
3573 /* let the other threads work */
3574 yield();
3578 /* restore dirfilter */
3579 *(tc->dirfilter) = old_dirfilter;
3581 return result;