Include host system's header files and don't compile our c library replacements in...
[kugel-rb.git] / apps / playlist.c
blob485601cd7e09069e2a5a9071d4f7259e9f27acb5
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 ROCKBOX_DIR "/.playlist_control"
107 #define PLAYLIST_CONTROL_FILE_VERSION 2
110 Each playlist index has a flag associated with it which identifies what
111 type of track it is. These flags are stored in the 4 high order bits of
112 the index.
114 NOTE: This limits the playlist file size to a max of 256M.
116 Bits 31-30:
117 00 = Playlist track
118 01 = Track was prepended into playlist
119 10 = Track was inserted into playlist
120 11 = Track was appended into playlist
121 Bit 29:
122 0 = Added track
123 1 = Queued track
124 Bit 28:
125 0 = Track entry is valid
126 1 = Track does not exist on disk and should be skipped
128 #define PLAYLIST_SEEK_MASK 0x0FFFFFFF
129 #define PLAYLIST_INSERT_TYPE_MASK 0xC0000000
130 #define PLAYLIST_QUEUE_MASK 0x20000000
132 #define PLAYLIST_INSERT_TYPE_PREPEND 0x40000000
133 #define PLAYLIST_INSERT_TYPE_INSERT 0x80000000
134 #define PLAYLIST_INSERT_TYPE_APPEND 0xC0000000
136 #define PLAYLIST_QUEUED 0x20000000
137 #define PLAYLIST_SKIPPED 0x10000000
139 struct directory_search_context {
140 struct playlist_info* playlist;
141 int position;
142 bool queue;
143 int count;
146 static struct playlist_info current_playlist;
147 static char now_playing[MAX_PATH+1];
149 static void empty_playlist(struct playlist_info* playlist, bool resume);
150 static void new_playlist(struct playlist_info* playlist, const char *dir,
151 const char *file);
152 static void create_control(struct playlist_info* playlist);
153 static int check_control(struct playlist_info* playlist);
154 static int recreate_control(struct playlist_info* playlist);
155 static void update_playlist_filename(struct playlist_info* playlist,
156 const char *dir, const char *file);
157 static int add_indices_to_playlist(struct playlist_info* playlist,
158 char* buffer, size_t buflen);
159 static int add_track_to_playlist(struct playlist_info* playlist,
160 const char *filename, int position,
161 bool queue, int seek_pos);
162 static int directory_search_callback(char* filename, void* context);
163 static int remove_track_from_playlist(struct playlist_info* playlist,
164 int position, bool write);
165 static int randomise_playlist(struct playlist_info* playlist,
166 unsigned int seed, bool start_current,
167 bool write);
168 static int sort_playlist(struct playlist_info* playlist, bool start_current,
169 bool write);
170 static int get_next_index(const struct playlist_info* playlist, int steps,
171 int repeat_mode);
172 static void find_and_set_playlist_index(struct playlist_info* playlist,
173 unsigned int seek);
174 static int compare(const void* p1, const void* p2);
175 static int get_filename(struct playlist_info* playlist, int index, int seek,
176 bool control_file, char *buf, int buf_length);
177 static int get_next_directory(char *dir);
178 static int get_next_dir(char *dir, bool is_forward, bool recursion);
179 static int get_previous_directory(char *dir);
180 static int check_subdir_for_music(char *dir, const char *subdir, bool recurse);
181 static int format_track_path(char *dest, char *src, int buf_length, int max,
182 const char *dir);
183 static void display_playlist_count(int count, const unsigned char *fmt,
184 bool final);
185 static void display_buffer_full(void);
186 static int flush_cached_control(struct playlist_info* playlist);
187 static int update_control(struct playlist_info* playlist,
188 enum playlist_command command, int i1, int i2,
189 const char* s1, const char* s2, void* data);
190 static void sync_control(struct playlist_info* playlist, bool force);
191 static int rotate_index(const struct playlist_info* playlist, int index);
193 #ifdef HAVE_DIRCACHE
194 #define PLAYLIST_LOAD_POINTERS 1
196 static struct event_queue playlist_queue;
197 static long playlist_stack[(DEFAULT_STACK_SIZE + 0x800)/sizeof(long)];
198 static const char playlist_thread_name[] = "playlist cachectrl";
199 #endif
201 /* Check if the filename suggests M3U or M3U8 format. */
202 static bool is_m3u8(const char* filename)
204 int len = strlen(filename);
206 /* Default to M3U8 unless explicitly told otherwise. */
207 return !(len > 4 && strcasecmp(&filename[len - 4], ".m3u") == 0);
211 /* Convert a filename in an M3U playlist to UTF-8.
213 * buf - the filename to convert; can contain more than one line from the
214 * playlist.
215 * buf_len - amount of buf that is used.
216 * buf_max - total size of buf.
217 * temp - temporary conversion buffer, at least buf_max bytes.
219 * Returns the length of the converted filename.
221 static int convert_m3u(char* buf, int buf_len, int buf_max, char* temp)
223 int i = 0;
224 char* dest;
226 /* Locate EOL. */
227 while ((buf[i] != '\n') && (buf[i] != '\r') && (i < buf_len))
229 i++;
232 /* Work back killing white space. */
233 while ((i > 0) && isspace(buf[i - 1]))
235 i--;
238 buf_len = i;
239 dest = temp;
241 /* Convert char by char, so as to not overflow temp (iso_decode should
242 * preferably handle this). No more than 4 bytes should be generated for
243 * each input char.
245 for (i = 0; i < buf_len && dest < (temp + buf_max - 4); i++)
247 dest = iso_decode(&buf[i], dest, -1, 1);
250 *dest = 0;
251 strcpy(buf, temp);
252 return dest - temp;
256 * remove any files and indices associated with the playlist
258 static void empty_playlist(struct playlist_info* playlist, bool resume)
260 playlist->filename[0] = '\0';
261 playlist->utf8 = true;
263 if(playlist->fd >= 0)
264 /* If there is an already open playlist, close it. */
265 close(playlist->fd);
266 playlist->fd = -1;
268 if(playlist->control_fd >= 0)
269 close(playlist->control_fd);
270 playlist->control_fd = -1;
271 playlist->control_created = false;
273 playlist->in_ram = false;
275 if (playlist->buffer)
276 playlist->buffer[0] = 0;
278 playlist->buffer_end_pos = 0;
280 playlist->index = 0;
281 playlist->first_index = 0;
282 playlist->amount = 0;
283 playlist->last_insert_pos = -1;
284 playlist->seed = 0;
285 playlist->shuffle_modified = false;
286 playlist->deleted = false;
287 playlist->num_inserted_tracks = 0;
288 playlist->started = false;
290 playlist->num_cached = 0;
291 playlist->pending_control_sync = false;
293 if (!resume && playlist->current)
295 /* start with fresh playlist control file when starting new
296 playlist */
297 create_control(playlist);
302 * Initialize a new playlist for viewing/editing/playing. dir is the
303 * directory where the playlist is located and file is the filename.
305 static void new_playlist(struct playlist_info* playlist, const char *dir,
306 const char *file)
308 const char *fileused = file;
309 const char *dirused = dir;
310 empty_playlist(playlist, false);
312 if (!fileused)
314 fileused = "";
316 if (dirused && playlist->current) /* !current cannot be in_ram */
317 playlist->in_ram = true;
318 else
319 dirused = ""; /* empty playlist */
322 update_playlist_filename(playlist, dirused, fileused);
324 if (playlist->control_fd >= 0)
326 update_control(playlist, PLAYLIST_COMMAND_PLAYLIST,
327 PLAYLIST_CONTROL_FILE_VERSION, -1, dirused, fileused, NULL);
328 sync_control(playlist, false);
333 * create control file for playlist
335 static void create_control(struct playlist_info* playlist)
337 playlist->control_fd = open(playlist->control_filename,
338 O_CREAT|O_RDWR|O_TRUNC, 0666);
339 if (playlist->control_fd < 0)
341 if (check_rockboxdir())
343 cond_talk_ids_fq(LANG_PLAYLIST_CONTROL_ACCESS_ERROR);
344 splashf(HZ*2, (unsigned char *)"%s (%d)",
345 str(LANG_PLAYLIST_CONTROL_ACCESS_ERROR),
346 playlist->control_fd);
348 playlist->control_created = false;
350 else
352 playlist->control_created = true;
357 * validate the control file. This may include creating/initializing it if
358 * necessary;
360 static int check_control(struct playlist_info* playlist)
362 if (!playlist->control_created)
364 create_control(playlist);
366 if (playlist->control_fd >= 0)
368 char* dir = playlist->filename;
369 char* file = playlist->filename+playlist->dirlen;
370 char c = playlist->filename[playlist->dirlen-1];
372 playlist->filename[playlist->dirlen-1] = '\0';
374 update_control(playlist, PLAYLIST_COMMAND_PLAYLIST,
375 PLAYLIST_CONTROL_FILE_VERSION, -1, dir, file, NULL);
376 sync_control(playlist, false);
377 playlist->filename[playlist->dirlen-1] = c;
381 if (playlist->control_fd < 0)
382 return -1;
384 return 0;
388 * recreate the control file based on current playlist entries
390 static int recreate_control(struct playlist_info* playlist)
392 char temp_file[MAX_PATH+1];
393 int temp_fd = -1;
394 int i;
395 int result = 0;
397 if(playlist->control_fd >= 0)
399 char* dir = playlist->filename;
400 char* file = playlist->filename+playlist->dirlen;
401 char c = playlist->filename[playlist->dirlen-1];
403 close(playlist->control_fd);
405 snprintf(temp_file, sizeof(temp_file), "%s_temp",
406 playlist->control_filename);
408 if (rename(playlist->control_filename, temp_file) < 0)
409 return -1;
411 temp_fd = open(temp_file, O_RDONLY);
412 if (temp_fd < 0)
413 return -1;
415 playlist->control_fd = open(playlist->control_filename,
416 O_CREAT|O_RDWR|O_TRUNC, 0666);
417 if (playlist->control_fd < 0)
418 return -1;
420 playlist->filename[playlist->dirlen-1] = '\0';
422 /* cannot call update_control() because of mutex */
423 result = fdprintf(playlist->control_fd, "P:%d:%s:%s\n",
424 PLAYLIST_CONTROL_FILE_VERSION, dir, file);
426 playlist->filename[playlist->dirlen-1] = c;
428 if (result < 0)
430 close(temp_fd);
431 return result;
435 playlist->seed = 0;
436 playlist->shuffle_modified = false;
437 playlist->deleted = false;
438 playlist->num_inserted_tracks = 0;
440 for (i=0; i<playlist->amount; i++)
442 if (playlist->indices[i] & PLAYLIST_INSERT_TYPE_MASK)
444 bool queue = playlist->indices[i] & PLAYLIST_QUEUE_MASK;
445 char inserted_file[MAX_PATH+1];
447 lseek(temp_fd, playlist->indices[i] & PLAYLIST_SEEK_MASK,
448 SEEK_SET);
449 read_line(temp_fd, inserted_file, sizeof(inserted_file));
451 result = fdprintf(playlist->control_fd, "%c:%d:%d:",
452 queue?'Q':'A', i, playlist->last_insert_pos);
453 if (result > 0)
455 /* save the position in file where name is written */
456 int seek_pos = lseek(playlist->control_fd, 0, SEEK_CUR);
458 result = fdprintf(playlist->control_fd, "%s\n",
459 inserted_file);
461 playlist->indices[i] =
462 (playlist->indices[i] & ~PLAYLIST_SEEK_MASK) | seek_pos;
465 if (result < 0)
466 break;
468 playlist->num_inserted_tracks++;
472 close(temp_fd);
473 remove(temp_file);
474 fsync(playlist->control_fd);
476 if (result < 0)
477 return result;
479 return 0;
483 * store directory and name of playlist file
485 static void update_playlist_filename(struct playlist_info* playlist,
486 const char *dir, const char *file)
488 char *sep="";
489 int dirlen = strlen(dir);
491 playlist->utf8 = is_m3u8(file);
493 /* If the dir does not end in trailing slash, we use a separator.
494 Otherwise we don't. */
495 if('/' != dir[dirlen-1])
497 sep="/";
498 dirlen++;
501 playlist->dirlen = dirlen;
503 snprintf(playlist->filename, sizeof(playlist->filename),
504 "%s%s%s", dir, sep, file);
508 * calculate track offsets within a playlist file
510 static int add_indices_to_playlist(struct playlist_info* playlist,
511 char* buffer, size_t buflen)
513 unsigned int nread;
514 unsigned int i = 0;
515 unsigned int count = 0;
516 bool store_index;
517 unsigned char *p;
518 int result = 0;
520 if(-1 == playlist->fd)
521 playlist->fd = open_utf8(playlist->filename, O_RDONLY);
522 if(playlist->fd < 0)
523 return -1; /* failure */
524 if((i = lseek(playlist->fd, 0, SEEK_CUR)) > 0)
525 playlist->utf8 = true; /* Override any earlier indication. */
527 splash(0, ID2P(LANG_WAIT));
529 if (!buffer)
531 /* use mp3 buffer for maximum load speed */
532 audio_stop();
533 #if CONFIG_CODEC != SWCODEC
534 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
535 buflen = (audiobufend - audiobuf);
536 buffer = (char *)audiobuf;
537 #else
538 buffer = (char *)audio_get_buffer(false, &buflen);
539 #endif
542 store_index = true;
544 while(1)
546 nread = read(playlist->fd, buffer, buflen);
547 /* Terminate on EOF */
548 if(nread <= 0)
549 break;
551 p = (unsigned char *)buffer;
553 for(count=0; count < nread; count++,p++) {
555 /* Are we on a new line? */
556 if((*p == '\n') || (*p == '\r'))
558 store_index = true;
560 else if(store_index)
562 store_index = false;
564 if(*p != '#')
566 if ( playlist->amount >= playlist->max_playlist_size ) {
567 display_buffer_full();
568 result = -1;
569 goto exit;
572 /* Store a new entry */
573 playlist->indices[ playlist->amount ] = i+count;
574 #ifdef HAVE_DIRCACHE
575 if (playlist->filenames)
576 playlist->filenames[ playlist->amount ] = NULL;
577 #endif
578 playlist->amount++;
583 i+= count;
586 exit:
587 #ifdef HAVE_DIRCACHE
588 queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
589 #endif
591 return result;
595 * Utility function to create a new playlist, fill it with the next or
596 * previous directory, shuffle it if needed, and start playback.
597 * If play_last is true and direction zero or negative, start playing
598 * the last file in the directory, otherwise start playing the first.
600 static int create_and_play_dir(int direction, bool play_last)
602 char dir[MAX_PATH + 1];
603 int res;
604 int index = -1;
606 if(direction > 0)
607 res = get_next_directory(dir);
608 else
609 res = get_previous_directory(dir);
611 if (!res)
613 if (playlist_create(dir, NULL) != -1)
615 ft_build_playlist(tree_get_context(), 0);
617 if (global_settings.playlist_shuffle)
618 playlist_shuffle(current_tick, -1);
620 if (play_last && direction <= 0)
621 index = current_playlist.amount - 1;
622 else
623 index = 0;
625 #if (CONFIG_CODEC != SWCODEC)
626 playlist_start(index, 0);
627 #endif
630 /* we've overwritten the dircache when getting the next/previous dir,
631 so the tree browser context will need to be reloaded */
632 reload_directory();
635 return index;
639 * Removes all tracks, from the playlist, leaving the presently playing
640 * track queued.
642 int playlist_remove_all_tracks(struct playlist_info *playlist)
644 int result;
646 if (playlist == NULL)
647 playlist = &current_playlist;
649 while (playlist->index > 0)
650 if ((result = remove_track_from_playlist(playlist, 0, true)) < 0)
651 return result;
653 while (playlist->amount > 1)
654 if ((result = remove_track_from_playlist(playlist, 1, true)) < 0)
655 return result;
657 if (playlist->amount == 1) {
658 playlist->indices[0] |= PLAYLIST_QUEUED;
661 return 0;
666 * Add track to playlist at specified position. There are seven special
667 * positions that can be specified:
668 * PLAYLIST_PREPEND - Add track at beginning of playlist
669 * PLAYLIST_INSERT - Add track after current song. NOTE: If
670 * there are already inserted tracks then track
671 * is added to the end of the insertion list
672 * PLAYLIST_INSERT_FIRST - Add track immediately after current song, no
673 * matter what other tracks have been inserted
674 * PLAYLIST_INSERT_LAST - Add track to end of playlist
675 * PLAYLIST_INSERT_SHUFFLED - Add track at some random point between the
676 * current playing track and end of playlist
677 * PLAYLIST_INSERT_LAST_SHUFFLED - Add tracks in random order to the end of
678 * the playlist.
679 * PLAYLIST_REPLACE - Erase current playlist, Cue the current track
680 * and inster this track at the end.
682 static int add_track_to_playlist(struct playlist_info* playlist,
683 const char *filename, int position,
684 bool queue, int seek_pos)
686 int insert_position, orig_position;
687 unsigned long flags = PLAYLIST_INSERT_TYPE_INSERT;
688 int i;
690 insert_position = orig_position = position;
692 if (playlist->amount >= playlist->max_playlist_size)
694 display_buffer_full();
695 return -1;
698 switch (position)
700 case PLAYLIST_PREPEND:
701 position = insert_position = playlist->first_index;
702 break;
703 case PLAYLIST_INSERT:
704 /* if there are already inserted tracks then add track to end of
705 insertion list else add after current playing track */
706 if (playlist->last_insert_pos >= 0 &&
707 playlist->last_insert_pos < playlist->amount &&
708 (playlist->indices[playlist->last_insert_pos]&
709 PLAYLIST_INSERT_TYPE_MASK) == PLAYLIST_INSERT_TYPE_INSERT)
710 position = insert_position = playlist->last_insert_pos+1;
711 else if (playlist->amount > 0)
712 position = insert_position = playlist->index + 1;
713 else
714 position = insert_position = 0;
716 playlist->last_insert_pos = position;
717 break;
718 case PLAYLIST_INSERT_FIRST:
719 if (playlist->amount > 0)
720 position = insert_position = playlist->index + 1;
721 else
722 position = insert_position = 0;
724 playlist->last_insert_pos = position;
725 break;
726 case PLAYLIST_INSERT_LAST:
727 if (playlist->first_index > 0)
728 position = insert_position = playlist->first_index;
729 else
730 position = insert_position = playlist->amount;
732 playlist->last_insert_pos = position;
733 break;
734 case PLAYLIST_INSERT_SHUFFLED:
736 if (playlist->started)
738 int offset;
739 int n = playlist->amount -
740 rotate_index(playlist, playlist->index);
742 if (n > 0)
743 offset = rand() % n;
744 else
745 offset = 0;
747 position = playlist->index + offset + 1;
748 if (position >= playlist->amount)
749 position -= playlist->amount;
751 insert_position = position;
753 else
754 position = insert_position = (rand() % (playlist->amount+1));
755 break;
757 case PLAYLIST_INSERT_LAST_SHUFFLED:
759 position = insert_position = playlist->last_shuffled_start +
760 rand() % (playlist->amount - playlist->last_shuffled_start + 1);
761 break;
763 case PLAYLIST_REPLACE:
764 if (playlist_remove_all_tracks(playlist) < 0)
765 return -1;
767 playlist->last_insert_pos = position = insert_position = playlist->index + 1;
768 break;
771 if (queue)
772 flags |= PLAYLIST_QUEUED;
774 /* shift indices so that track can be added */
775 for (i=playlist->amount; i>insert_position; i--)
777 playlist->indices[i] = playlist->indices[i-1];
778 #ifdef HAVE_DIRCACHE
779 if (playlist->filenames)
780 playlist->filenames[i] = playlist->filenames[i-1];
781 #endif
784 /* update stored indices if needed */
786 if (orig_position < 0)
788 if (playlist->amount > 0 && insert_position <= playlist->index &&
789 playlist->started)
790 playlist->index++;
792 if (playlist->amount > 0 && insert_position <= playlist->first_index &&
793 orig_position != PLAYLIST_PREPEND && playlist->started)
794 playlist->first_index++;
797 if (insert_position < playlist->last_insert_pos ||
798 (insert_position == playlist->last_insert_pos && position < 0))
799 playlist->last_insert_pos++;
801 if (seek_pos < 0 && playlist->control_fd >= 0)
803 int result = update_control(playlist,
804 (queue?PLAYLIST_COMMAND_QUEUE:PLAYLIST_COMMAND_ADD), position,
805 playlist->last_insert_pos, filename, NULL, &seek_pos);
807 if (result < 0)
808 return result;
811 playlist->indices[insert_position] = flags | seek_pos;
813 #ifdef HAVE_DIRCACHE
814 if (playlist->filenames)
815 playlist->filenames[insert_position] = NULL;
816 #endif
818 playlist->amount++;
819 playlist->num_inserted_tracks++;
821 return insert_position;
825 * Callback for playlist_directory_tracksearch to insert track into
826 * playlist.
828 static int directory_search_callback(char* filename, void* context)
830 struct directory_search_context* c =
831 (struct directory_search_context*) context;
832 int insert_pos;
834 insert_pos = add_track_to_playlist(c->playlist, filename, c->position,
835 c->queue, -1);
837 if (insert_pos < 0)
838 return -1;
840 (c->count)++;
842 /* Make sure tracks are inserted in correct order if user requests
843 INSERT_FIRST */
844 if (c->position == PLAYLIST_INSERT_FIRST || c->position >= 0)
845 c->position = insert_pos + 1;
847 if (((c->count)%PLAYLIST_DISPLAY_COUNT) == 0)
849 unsigned char* count_str;
851 if (c->queue)
852 count_str = ID2P(LANG_PLAYLIST_QUEUE_COUNT);
853 else
854 count_str = ID2P(LANG_PLAYLIST_INSERT_COUNT);
856 display_playlist_count(c->count, count_str, false);
858 if ((c->count) == PLAYLIST_DISPLAY_COUNT &&
859 (audio_status() & AUDIO_STATUS_PLAY) &&
860 c->playlist->started)
861 audio_flush_and_reload_tracks();
864 return 0;
868 * remove track at specified position
870 static int remove_track_from_playlist(struct playlist_info* playlist,
871 int position, bool write)
873 int i;
874 bool inserted;
876 if (playlist->amount <= 0)
877 return -1;
879 inserted = playlist->indices[position] & PLAYLIST_INSERT_TYPE_MASK;
881 /* shift indices now that track has been removed */
882 for (i=position; i<playlist->amount; i++)
884 playlist->indices[i] = playlist->indices[i+1];
885 #ifdef HAVE_DIRCACHE
886 if (playlist->filenames)
887 playlist->filenames[i] = playlist->filenames[i+1];
888 #endif
891 playlist->amount--;
893 if (inserted)
894 playlist->num_inserted_tracks--;
895 else
896 playlist->deleted = true;
898 /* update stored indices if needed */
899 if (position < playlist->index)
900 playlist->index--;
902 if (position < playlist->first_index)
904 playlist->first_index--;
907 if (position <= playlist->last_insert_pos)
908 playlist->last_insert_pos--;
910 if (write && playlist->control_fd >= 0)
912 int result = update_control(playlist, PLAYLIST_COMMAND_DELETE,
913 position, -1, NULL, NULL, NULL);
915 if (result < 0)
916 return result;
918 sync_control(playlist, false);
921 return 0;
925 * randomly rearrange the array of indices for the playlist. If start_current
926 * is true then update the index to the new index of the current playing track
928 static int randomise_playlist(struct playlist_info* playlist,
929 unsigned int seed, bool start_current,
930 bool write)
932 int count;
933 int candidate;
934 long store;
935 unsigned int current = playlist->indices[playlist->index];
937 /* seed 0 is used to identify sorted playlist for resume purposes */
938 if (seed == 0)
939 seed = 1;
941 /* seed with the given seed */
942 srand(seed);
944 /* randomise entire indices list */
945 for(count = playlist->amount - 1; count >= 0; count--)
947 /* the rand is from 0 to RAND_MAX, so adjust to our value range */
948 candidate = rand() % (count + 1);
950 /* now swap the values at the 'count' and 'candidate' positions */
951 store = playlist->indices[candidate];
952 playlist->indices[candidate] = playlist->indices[count];
953 playlist->indices[count] = store;
954 #ifdef HAVE_DIRCACHE
955 if (playlist->filenames)
957 store = (long)playlist->filenames[candidate];
958 playlist->filenames[candidate] = playlist->filenames[count];
959 playlist->filenames[count] = (struct dircache_entry *)store;
961 #endif
964 if (start_current)
965 find_and_set_playlist_index(playlist, current);
967 /* indices have been moved so last insert position is no longer valid */
968 playlist->last_insert_pos = -1;
970 playlist->seed = seed;
971 if (playlist->num_inserted_tracks > 0 || playlist->deleted)
972 playlist->shuffle_modified = true;
974 if (write)
976 update_control(playlist, PLAYLIST_COMMAND_SHUFFLE, seed,
977 playlist->first_index, NULL, NULL, NULL);
980 return 0;
984 * Sort the array of indices for the playlist. If start_current is true then
985 * set the index to the new index of the current song.
986 * Also while going to unshuffled mode set the first_index to 0.
988 static int sort_playlist(struct playlist_info* playlist, bool start_current,
989 bool write)
991 unsigned int current = playlist->indices[playlist->index];
993 if (playlist->amount > 0)
994 qsort(playlist->indices, playlist->amount,
995 sizeof(playlist->indices[0]), compare);
997 #ifdef HAVE_DIRCACHE
998 /** We need to re-check the song names from disk because qsort can't
999 * sort two arrays at once :/
1000 * FIXME: Please implement a better way to do this. */
1001 memset(playlist->filenames, 0, playlist->max_playlist_size * sizeof(int));
1002 queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
1003 #endif
1005 if (start_current)
1006 find_and_set_playlist_index(playlist, current);
1008 /* indices have been moved so last insert position is no longer valid */
1009 playlist->last_insert_pos = -1;
1011 if (!playlist->num_inserted_tracks && !playlist->deleted)
1012 playlist->shuffle_modified = false;
1013 if (write && playlist->control_fd >= 0)
1015 playlist->first_index = 0;
1016 update_control(playlist, PLAYLIST_COMMAND_UNSHUFFLE,
1017 playlist->first_index, -1, NULL, NULL, NULL);
1020 return 0;
1023 /* Calculate how many steps we have to really step when skipping entries
1024 * marked as bad.
1026 static int calculate_step_count(const struct playlist_info *playlist, int steps)
1028 int i, count, direction;
1029 int index;
1030 int stepped_count = 0;
1032 if (steps < 0)
1034 direction = -1;
1035 count = -steps;
1037 else
1039 direction = 1;
1040 count = steps;
1043 index = playlist->index;
1044 i = 0;
1045 do {
1046 /* Boundary check */
1047 if (index < 0)
1048 index += playlist->amount;
1049 if (index >= playlist->amount)
1050 index -= playlist->amount;
1052 /* Check if we found a bad entry. */
1053 if (playlist->indices[index] & PLAYLIST_SKIPPED)
1055 steps += direction;
1056 /* Are all entries bad? */
1057 if (stepped_count++ > playlist->amount)
1058 break ;
1060 else
1061 i++;
1063 index += direction;
1064 } while (i <= count);
1066 return steps;
1069 /* Marks the index of the track to be skipped that is "steps" away from
1070 * current playing track.
1072 void playlist_skip_entry(struct playlist_info *playlist, int steps)
1074 int index;
1076 if (playlist == NULL)
1077 playlist = &current_playlist;
1079 /* need to account for already skipped tracks */
1080 steps = calculate_step_count(playlist, steps);
1082 index = playlist->index + steps;
1083 if (index < 0)
1084 index += playlist->amount;
1085 else if (index >= playlist->amount)
1086 index -= playlist->amount;
1088 playlist->indices[index] |= PLAYLIST_SKIPPED;
1092 * returns the index of the track that is "steps" away from current playing
1093 * track.
1095 static int get_next_index(const struct playlist_info* playlist, int steps,
1096 int repeat_mode)
1098 int current_index = playlist->index;
1099 int next_index = -1;
1101 if (playlist->amount <= 0)
1102 return -1;
1104 if (repeat_mode == -1)
1105 repeat_mode = global_settings.repeat_mode;
1107 if (repeat_mode == REPEAT_SHUFFLE && playlist->amount <= 1)
1108 repeat_mode = REPEAT_ALL;
1110 steps = calculate_step_count(playlist, steps);
1111 switch (repeat_mode)
1113 case REPEAT_SHUFFLE:
1114 /* Treat repeat shuffle just like repeat off. At end of playlist,
1115 play will be resumed in playlist_next() */
1116 case REPEAT_OFF:
1118 current_index = rotate_index(playlist, current_index);
1119 next_index = current_index+steps;
1120 if ((next_index < 0) || (next_index >= playlist->amount))
1121 next_index = -1;
1122 else
1123 next_index = (next_index+playlist->first_index) %
1124 playlist->amount;
1126 break;
1129 case REPEAT_ONE:
1130 #ifdef AB_REPEAT_ENABLE
1131 case REPEAT_AB:
1132 #endif
1133 next_index = current_index;
1134 break;
1136 case REPEAT_ALL:
1137 default:
1139 next_index = (current_index+steps) % playlist->amount;
1140 while (next_index < 0)
1141 next_index += playlist->amount;
1143 if (steps >= playlist->amount)
1145 int i, index;
1147 index = next_index;
1148 next_index = -1;
1150 /* second time around so skip the queued files */
1151 for (i=0; i<playlist->amount; i++)
1153 if (playlist->indices[index] & PLAYLIST_QUEUE_MASK)
1154 index = (index+1) % playlist->amount;
1155 else
1157 next_index = index;
1158 break;
1162 break;
1166 /* No luck if the whole playlist was bad. */
1167 if (playlist->indices[next_index] & PLAYLIST_SKIPPED)
1168 return -1;
1170 return next_index;
1174 * Search for the seek track and set appropriate indices. Used after shuffle
1175 * to make sure the current index is still pointing to correct track.
1177 static void find_and_set_playlist_index(struct playlist_info* playlist,
1178 unsigned int seek)
1180 int i;
1182 /* Set the index to the current song */
1183 for (i=0; i<playlist->amount; i++)
1185 if (playlist->indices[i] == seek)
1187 playlist->index = playlist->first_index = i;
1189 break;
1195 * used to sort track indices. Sort order is as follows:
1196 * 1. Prepended tracks (in prepend order)
1197 * 2. Playlist/directory tracks (in playlist order)
1198 * 3. Inserted/Appended tracks (in insert order)
1200 static int compare(const void* p1, const void* p2)
1202 unsigned long* e1 = (unsigned long*) p1;
1203 unsigned long* e2 = (unsigned long*) p2;
1204 unsigned long flags1 = *e1 & PLAYLIST_INSERT_TYPE_MASK;
1205 unsigned long flags2 = *e2 & PLAYLIST_INSERT_TYPE_MASK;
1207 if (flags1 == flags2)
1208 return (*e1 & PLAYLIST_SEEK_MASK) - (*e2 & PLAYLIST_SEEK_MASK);
1209 else if (flags1 == PLAYLIST_INSERT_TYPE_PREPEND ||
1210 flags2 == PLAYLIST_INSERT_TYPE_APPEND)
1211 return -1;
1212 else if (flags1 == PLAYLIST_INSERT_TYPE_APPEND ||
1213 flags2 == PLAYLIST_INSERT_TYPE_PREPEND)
1214 return 1;
1215 else if (flags1 && flags2)
1216 return (*e1 & PLAYLIST_SEEK_MASK) - (*e2 & PLAYLIST_SEEK_MASK);
1217 else
1218 return *e1 - *e2;
1221 #ifdef HAVE_DIRCACHE
1223 * Thread to update filename pointers to dircache on background
1224 * without affecting playlist load up performance. This thread also flushes
1225 * any pending control commands when the disk spins up.
1227 static void playlist_flush_callback(void *param)
1229 (void)param;
1230 struct playlist_info *playlist;
1231 playlist = &current_playlist;
1232 if (playlist->control_fd >= 0)
1234 if (playlist->num_cached > 0)
1236 mutex_lock(&playlist->control_mutex);
1237 flush_cached_control(playlist);
1238 mutex_unlock(&playlist->control_mutex);
1240 sync_control(playlist, true);
1244 static void playlist_thread(void)
1246 struct queue_event ev;
1247 bool dirty_pointers = false;
1248 static char tmp[MAX_PATH+1];
1250 struct playlist_info *playlist;
1251 int index;
1252 int seek;
1253 bool control_file;
1255 int sleep_time = 5;
1257 #ifdef HAVE_DISK_STORAGE
1258 if (global_settings.disk_spindown > 1 &&
1259 global_settings.disk_spindown <= 5)
1260 sleep_time = global_settings.disk_spindown - 1;
1261 #endif
1263 while (1)
1265 queue_wait_w_tmo(&playlist_queue, &ev, HZ*sleep_time);
1267 switch (ev.id)
1269 case PLAYLIST_LOAD_POINTERS:
1270 dirty_pointers = true;
1271 break ;
1273 /* Start the background scanning after either the disk spindown
1274 timeout or 5s, whichever is less */
1275 case SYS_TIMEOUT:
1276 playlist = &current_playlist;
1277 if (playlist->control_fd >= 0)
1279 if (playlist->num_cached > 0)
1280 register_storage_idle_func(playlist_flush_callback);
1283 if (!dirty_pointers)
1284 break ;
1286 if (!dircache_is_enabled() || !playlist->filenames
1287 || playlist->amount <= 0)
1288 break ;
1290 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1291 cpu_boost(true);
1292 #endif
1293 for (index = 0; index < playlist->amount
1294 && queue_empty(&playlist_queue); index++)
1296 /* Process only pointers that are not already loaded. */
1297 if (playlist->filenames[index])
1298 continue ;
1300 control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
1301 seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
1303 /* Load the filename from playlist file. */
1304 if (get_filename(playlist, index, seek, control_file, tmp,
1305 sizeof(tmp)) < 0)
1306 break ;
1308 /* Set the dircache entry pointer. */
1309 playlist->filenames[index] = dircache_get_entry_ptr(tmp);
1311 /* And be on background so user doesn't notice any delays. */
1312 yield();
1315 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
1316 cpu_boost(false);
1317 #endif
1318 dirty_pointers = false;
1319 break ;
1321 #ifndef SIMULATOR
1322 case SYS_USB_CONNECTED:
1323 usb_acknowledge(SYS_USB_CONNECTED_ACK);
1324 usb_wait_for_disconnect(&playlist_queue);
1325 break ;
1326 #endif
1330 #endif
1333 * gets pathname for track at seek index
1335 static int get_filename(struct playlist_info* playlist, int index, int seek,
1336 bool control_file, char *buf, int buf_length)
1338 int fd;
1339 int max = -1;
1340 char tmp_buf[MAX_PATH+1];
1341 char dir_buf[MAX_PATH+1];
1342 bool utf8 = playlist->utf8;
1344 if (buf_length > MAX_PATH+1)
1345 buf_length = MAX_PATH+1;
1347 #ifdef HAVE_DIRCACHE
1348 if (dircache_is_enabled() && playlist->filenames)
1350 if (playlist->filenames[index] != NULL)
1352 dircache_copy_path(playlist->filenames[index], tmp_buf, sizeof(tmp_buf)-1);
1353 max = strlen(tmp_buf);
1356 #else
1357 (void)index;
1358 #endif
1360 if (playlist->in_ram && !control_file && max < 0)
1362 max = strlcpy(tmp_buf, &playlist->buffer[seek], sizeof(tmp_buf));
1364 else if (max < 0)
1366 mutex_lock(&playlist->control_mutex);
1368 if (control_file)
1370 fd = playlist->control_fd;
1371 utf8 = true;
1373 else
1375 if(-1 == playlist->fd)
1376 playlist->fd = open(playlist->filename, O_RDONLY);
1378 fd = playlist->fd;
1381 if(-1 != fd)
1384 if (lseek(fd, seek, SEEK_SET) != seek)
1385 max = -1;
1386 else
1388 max = read(fd, tmp_buf, MIN((size_t) buf_length, sizeof(tmp_buf)));
1390 if ((max > 0) && !utf8)
1392 /* Use dir_buf as a temporary buffer. Note that dir_buf must
1393 * be as large as tmp_buf.
1395 max = convert_m3u(tmp_buf, max, sizeof(tmp_buf), dir_buf);
1400 mutex_unlock(&playlist->control_mutex);
1402 if (max < 0)
1404 if (control_file)
1405 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
1406 else
1407 splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
1409 return max;
1413 strlcpy(dir_buf, playlist->filename, playlist->dirlen);
1415 return (format_track_path(buf, tmp_buf, buf_length, max, dir_buf));
1418 static int get_next_directory(char *dir){
1419 return get_next_dir(dir,true,false);
1422 static int get_previous_directory(char *dir){
1423 return get_next_dir(dir,false,false);
1427 * search through all the directories (starting with the current) to find
1428 * one that has tracks to play
1430 static int get_next_dir(char *dir, bool is_forward, bool recursion)
1432 struct playlist_info* playlist = &current_playlist;
1433 int result = -1;
1434 char *start_dir = NULL;
1435 bool exit = false;
1436 int i;
1437 struct tree_context* tc = tree_get_context();
1438 int saved_dirfilter = *(tc->dirfilter);
1440 /* process random folder advance */
1441 if (global_settings.next_folder == FOLDER_ADVANCE_RANDOM)
1443 int fd = open(ROCKBOX_DIR "/folder_advance_list.dat", O_RDONLY);
1444 if (fd >= 0)
1446 char buffer[MAX_PATH];
1447 int folder_count = 0;
1448 srand(current_tick);
1449 *(tc->dirfilter) = SHOW_MUSIC;
1450 tc->sort_dir = global_settings.sort_dir;
1451 read(fd,&folder_count,sizeof(int));
1452 if (!folder_count)
1453 exit = true;
1454 while (!exit)
1456 i = rand()%folder_count;
1457 lseek(fd,sizeof(int) + (MAX_PATH*i),SEEK_SET);
1458 read(fd,buffer,MAX_PATH);
1459 if (check_subdir_for_music(buffer, "", false) ==0)
1460 exit = true;
1462 if (folder_count)
1463 strcpy(dir,buffer);
1464 close(fd);
1465 *(tc->dirfilter) = saved_dirfilter;
1466 tc->sort_dir = global_settings.sort_dir;
1467 reload_directory();
1468 return 0;
1472 /* not random folder advance (or random folder advance unavailable) */
1473 if (recursion)
1475 /* start with root */
1476 dir[0] = '\0';
1478 else
1480 /* start with current directory */
1481 strlcpy(dir, playlist->filename, playlist->dirlen);
1484 /* use the tree browser dircache to load files */
1485 *(tc->dirfilter) = SHOW_ALL;
1487 /* set up sorting/direction */
1488 tc->sort_dir = global_settings.sort_dir;
1489 if (!is_forward)
1491 static const char sortpairs[] =
1493 [SORT_ALPHA] = SORT_ALPHA_REVERSED,
1494 [SORT_DATE] = SORT_DATE_REVERSED,
1495 [SORT_TYPE] = SORT_TYPE_REVERSED,
1496 [SORT_ALPHA_REVERSED] = SORT_ALPHA,
1497 [SORT_DATE_REVERSED] = SORT_DATE,
1498 [SORT_TYPE_REVERSED] = SORT_TYPE,
1501 if ((unsigned)tc->sort_dir < sizeof(sortpairs))
1502 tc->sort_dir = sortpairs[tc->sort_dir];
1505 while (!exit)
1507 struct entry *files;
1508 int num_files = 0;
1509 int i;
1511 if (ft_load(tc, (dir[0]=='\0')?"/":dir) < 0)
1513 exit = true;
1514 result = -1;
1515 break;
1518 files = (struct entry*) tc->dircache;
1519 num_files = tc->filesindir;
1521 for (i=0; i<num_files; i++)
1523 /* user abort */
1524 if (action_userabort(TIMEOUT_NOBLOCK))
1526 result = -1;
1527 exit = true;
1528 break;
1531 if (files[i].attr & ATTR_DIRECTORY)
1533 if (!start_dir)
1535 result = check_subdir_for_music(dir, files[i].name, true);
1536 if (result != -1)
1538 exit = true;
1539 break;
1542 else if (!strcmp(start_dir, files[i].name))
1543 start_dir = NULL;
1547 if (!exit)
1549 /* move down to parent directory. current directory name is
1550 stored as the starting point for the search in parent */
1551 start_dir = strrchr(dir, '/');
1552 if (start_dir)
1554 *start_dir = '\0';
1555 start_dir++;
1557 else
1558 break;
1562 /* restore dirfilter */
1563 *(tc->dirfilter) = saved_dirfilter;
1564 tc->sort_dir = global_settings.sort_dir;
1566 /* special case if nothing found: try start searching again from root */
1567 if (result == -1 && !recursion){
1568 result = get_next_dir(dir, is_forward, true);
1571 return result;
1575 * Checks if there are any music files in the dir or any of its
1576 * subdirectories. May be called recursively.
1578 static int check_subdir_for_music(char *dir, const char *subdir, bool recurse)
1580 int result = -1;
1581 int dirlen = strlen(dir);
1582 int num_files = 0;
1583 int i;
1584 struct entry *files;
1585 bool has_music = false;
1586 bool has_subdir = false;
1587 struct tree_context* tc = tree_get_context();
1589 snprintf(dir+dirlen, MAX_PATH-dirlen, "/%s", subdir);
1591 if (ft_load(tc, dir) < 0)
1593 return -2;
1596 files = (struct entry*) tc->dircache;
1597 num_files = tc->filesindir;
1599 for (i=0; i<num_files; i++)
1601 if (files[i].attr & ATTR_DIRECTORY)
1602 has_subdir = true;
1603 else if ((files[i].attr & FILE_ATTR_MASK) == FILE_ATTR_AUDIO)
1605 has_music = true;
1606 break;
1610 if (has_music)
1611 return 0;
1613 if (has_subdir && recurse)
1615 for (i=0; i<num_files; i++)
1617 if (action_userabort(TIMEOUT_NOBLOCK))
1619 result = -2;
1620 break;
1623 if (files[i].attr & ATTR_DIRECTORY)
1625 result = check_subdir_for_music(dir, files[i].name, true);
1626 if (!result)
1627 break;
1632 if (result < 0)
1634 if (dirlen)
1636 dir[dirlen] = '\0';
1638 else
1640 strcpy(dir, "/");
1643 /* we now need to reload our current directory */
1644 if(ft_load(tc, dir) < 0)
1645 splash(HZ*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR));
1647 return result;
1651 * Returns absolute path of track
1653 static int format_track_path(char *dest, char *src, int buf_length, int max,
1654 const char *dir)
1656 int i = 0;
1657 int j;
1658 char *temp_ptr;
1660 /* Zero-terminate the file name */
1661 while((src[i] != '\n') &&
1662 (src[i] != '\r') &&
1663 (i < max))
1664 i++;
1666 /* Now work back killing white space */
1667 while((src[i-1] == ' ') ||
1668 (src[i-1] == '\t'))
1669 i--;
1671 src[i]=0;
1673 /* replace backslashes with forward slashes */
1674 for ( j=0; j<i; j++ )
1675 if ( src[j] == '\\' )
1676 src[j] = '/';
1678 if('/' == src[0])
1680 strlcpy(dest, src, buf_length);
1682 else
1684 /* handle dos style drive letter */
1685 if (':' == src[1])
1686 strlcpy(dest, &src[2], buf_length);
1687 else if (!strncmp(src, "../", 3))
1689 /* handle relative paths */
1690 i=3;
1691 while(!strncmp(&src[i], "../", 3))
1692 i += 3;
1693 for (j=0; j<i/3; j++) {
1694 temp_ptr = strrchr(dir, '/');
1695 if (temp_ptr)
1696 *temp_ptr = '\0';
1697 else
1698 break;
1700 snprintf(dest, buf_length, "%s/%s", dir, &src[i]);
1702 else if ( '.' == src[0] && '/' == src[1] ) {
1703 snprintf(dest, buf_length, "%s/%s", dir, &src[2]);
1705 else {
1706 snprintf(dest, buf_length, "%s/%s", dir, src);
1710 return 0;
1714 * Display splash message showing progress of playlist/directory insertion or
1715 * save.
1717 static void display_playlist_count(int count, const unsigned char *fmt,
1718 bool final)
1720 static long talked_tick = 0;
1721 long id = P2ID(fmt);
1722 if(global_settings.talk_menu && id>=0)
1724 if(final || (count && (talked_tick == 0
1725 || TIME_AFTER(current_tick, talked_tick+5*HZ))))
1727 talked_tick = current_tick;
1728 talk_number(count, false);
1729 talk_id(id, true);
1732 fmt = P2STR(fmt);
1734 splashf(0, fmt, count, str(LANG_OFF_ABORT));
1738 * Display buffer full message
1740 static void display_buffer_full(void)
1742 splash(HZ*2, ID2P(LANG_PLAYLIST_BUFFER_FULL));
1746 * Flush any cached control commands to disk. Called when playlist is being
1747 * modified. Returns 0 on success and -1 on failure.
1749 static int flush_cached_control(struct playlist_info* playlist)
1751 int result = 0;
1752 int i;
1754 if (!playlist->num_cached)
1755 return 0;
1757 lseek(playlist->control_fd, 0, SEEK_END);
1759 for (i=0; i<playlist->num_cached; i++)
1761 struct playlist_control_cache* cache =
1762 &(playlist->control_cache[i]);
1764 switch (cache->command)
1766 case PLAYLIST_COMMAND_PLAYLIST:
1767 result = fdprintf(playlist->control_fd, "P:%d:%s:%s\n",
1768 cache->i1, cache->s1, cache->s2);
1769 break;
1770 case PLAYLIST_COMMAND_ADD:
1771 case PLAYLIST_COMMAND_QUEUE:
1772 result = fdprintf(playlist->control_fd, "%c:%d:%d:",
1773 (cache->command == PLAYLIST_COMMAND_ADD)?'A':'Q',
1774 cache->i1, cache->i2);
1775 if (result > 0)
1777 /* save the position in file where name is written */
1778 int* seek_pos = (int *)cache->data;
1779 *seek_pos = lseek(playlist->control_fd, 0, SEEK_CUR);
1780 result = fdprintf(playlist->control_fd, "%s\n",
1781 cache->s1);
1783 break;
1784 case PLAYLIST_COMMAND_DELETE:
1785 result = fdprintf(playlist->control_fd, "D:%d\n", cache->i1);
1786 break;
1787 case PLAYLIST_COMMAND_SHUFFLE:
1788 result = fdprintf(playlist->control_fd, "S:%d:%d\n",
1789 cache->i1, cache->i2);
1790 break;
1791 case PLAYLIST_COMMAND_UNSHUFFLE:
1792 result = fdprintf(playlist->control_fd, "U:%d\n", cache->i1);
1793 break;
1794 case PLAYLIST_COMMAND_RESET:
1795 result = fdprintf(playlist->control_fd, "R\n");
1796 break;
1797 default:
1798 break;
1801 if (result <= 0)
1802 break;
1805 if (result > 0)
1807 playlist->num_cached = 0;
1808 playlist->pending_control_sync = true;
1810 result = 0;
1812 else
1814 result = -1;
1815 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_UPDATE_ERROR));
1818 return result;
1822 * Update control data with new command. Depending on the command, it may be
1823 * cached or flushed to disk.
1825 static int update_control(struct playlist_info* playlist,
1826 enum playlist_command command, int i1, int i2,
1827 const char* s1, const char* s2, void* data)
1829 int result = 0;
1830 struct playlist_control_cache* cache;
1831 bool flush = false;
1833 mutex_lock(&playlist->control_mutex);
1835 cache = &(playlist->control_cache[playlist->num_cached++]);
1837 cache->command = command;
1838 cache->i1 = i1;
1839 cache->i2 = i2;
1840 cache->s1 = s1;
1841 cache->s2 = s2;
1842 cache->data = data;
1844 switch (command)
1846 case PLAYLIST_COMMAND_PLAYLIST:
1847 case PLAYLIST_COMMAND_ADD:
1848 case PLAYLIST_COMMAND_QUEUE:
1849 #ifndef HAVE_DIRCACHE
1850 case PLAYLIST_COMMAND_DELETE:
1851 case PLAYLIST_COMMAND_RESET:
1852 #endif
1853 flush = true;
1854 break;
1855 case PLAYLIST_COMMAND_SHUFFLE:
1856 case PLAYLIST_COMMAND_UNSHUFFLE:
1857 default:
1858 /* only flush when needed */
1859 break;
1862 if (flush || playlist->num_cached == PLAYLIST_MAX_CACHE)
1863 result = flush_cached_control(playlist);
1865 mutex_unlock(&playlist->control_mutex);
1867 return result;
1871 * sync control file to disk
1873 static void sync_control(struct playlist_info* playlist, bool force)
1875 #ifdef HAVE_DIRCACHE
1876 if (playlist->started && force)
1877 #else
1878 (void) force;
1880 if (playlist->started)
1881 #endif
1883 if (playlist->pending_control_sync)
1885 mutex_lock(&playlist->control_mutex);
1886 fsync(playlist->control_fd);
1887 playlist->pending_control_sync = false;
1888 mutex_unlock(&playlist->control_mutex);
1894 * Rotate indices such that first_index is index 0
1896 static int rotate_index(const struct playlist_info* playlist, int index)
1898 index -= playlist->first_index;
1899 if (index < 0)
1900 index += playlist->amount;
1902 return index;
1906 * Initialize playlist entries at startup
1908 void playlist_init(void)
1910 struct playlist_info* playlist = &current_playlist;
1912 playlist->current = true;
1913 strlcpy(playlist->control_filename, PLAYLIST_CONTROL_FILE,
1914 sizeof(playlist->control_filename));
1915 playlist->fd = -1;
1916 playlist->control_fd = -1;
1917 playlist->max_playlist_size = global_settings.max_files_in_playlist;
1918 playlist->indices = buffer_alloc(
1919 playlist->max_playlist_size * sizeof(int));
1920 playlist->buffer_size =
1921 AVERAGE_FILENAME_LENGTH * global_settings.max_files_in_dir;
1922 playlist->buffer = buffer_alloc(playlist->buffer_size);
1923 mutex_init(&playlist->control_mutex);
1924 empty_playlist(playlist, true);
1926 #ifdef HAVE_DIRCACHE
1927 playlist->filenames = buffer_alloc(
1928 playlist->max_playlist_size * sizeof(int));
1929 memset(playlist->filenames, 0,
1930 playlist->max_playlist_size * sizeof(int));
1931 create_thread(playlist_thread, playlist_stack, sizeof(playlist_stack),
1932 0, playlist_thread_name IF_PRIO(, PRIORITY_BACKGROUND)
1933 IF_COP(, CPU));
1934 queue_init(&playlist_queue, true);
1935 #endif
1939 * Clean playlist at shutdown
1941 void playlist_shutdown(void)
1943 struct playlist_info* playlist = &current_playlist;
1945 if (playlist->control_fd >= 0)
1947 mutex_lock(&playlist->control_mutex);
1949 if (playlist->num_cached > 0)
1950 flush_cached_control(playlist);
1952 close(playlist->control_fd);
1954 mutex_unlock(&playlist->control_mutex);
1959 * Create new playlist
1961 int playlist_create(const char *dir, const char *file)
1963 struct playlist_info* playlist = &current_playlist;
1965 new_playlist(playlist, dir, file);
1967 if (file)
1968 /* load the playlist file */
1969 add_indices_to_playlist(playlist, NULL, 0);
1971 return 0;
1974 #define PLAYLIST_COMMAND_SIZE (MAX_PATH+12)
1977 * Restore the playlist state based on control file commands. Called to
1978 * resume playback after shutdown.
1980 int playlist_resume(void)
1982 struct playlist_info* playlist = &current_playlist;
1983 char *buffer;
1984 size_t buflen;
1985 int nread;
1986 int total_read = 0;
1987 int control_file_size = 0;
1988 bool first = true;
1989 bool sorted = true;
1991 /* use mp3 buffer for maximum load speed */
1992 #if CONFIG_CODEC != SWCODEC
1993 talk_buffer_steal(); /* we use the mp3 buffer, need to tell */
1994 buflen = (audiobufend - audiobuf);
1995 buffer = (char *)audiobuf;
1996 #else
1997 buffer = (char *)audio_get_buffer(false, &buflen);
1998 #endif
2000 empty_playlist(playlist, true);
2002 splash(0, ID2P(LANG_WAIT));
2003 playlist->control_fd = open(playlist->control_filename, O_RDWR);
2004 if (playlist->control_fd < 0)
2006 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2007 return -1;
2009 playlist->control_created = true;
2011 control_file_size = filesize(playlist->control_fd);
2012 if (control_file_size <= 0)
2014 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2015 return -1;
2018 /* read a small amount first to get the header */
2019 nread = read(playlist->control_fd, buffer,
2020 PLAYLIST_COMMAND_SIZE<buflen?PLAYLIST_COMMAND_SIZE:buflen);
2021 if(nread <= 0)
2023 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2024 return -1;
2027 playlist->started = true;
2029 while (1)
2031 int result = 0;
2032 int count;
2033 enum playlist_command current_command = PLAYLIST_COMMAND_COMMENT;
2034 int last_newline = 0;
2035 int str_count = -1;
2036 bool newline = true;
2037 bool exit_loop = false;
2038 char *p = buffer;
2039 char *str1 = NULL;
2040 char *str2 = NULL;
2041 char *str3 = NULL;
2042 unsigned long last_tick = current_tick;
2043 bool useraborted = false;
2045 for(count=0; count<nread && !exit_loop && !useraborted; count++,p++)
2047 /* So a splash while we are loading. */
2048 if (TIME_AFTER(current_tick, last_tick + HZ/4))
2050 splashf(0, str(LANG_LOADING_PERCENT),
2051 (total_read+count)*100/control_file_size,
2052 str(LANG_OFF_ABORT));
2053 if (action_userabort(TIMEOUT_NOBLOCK))
2055 useraborted = true;
2056 break;
2058 last_tick = current_tick;
2061 /* Are we on a new line? */
2062 if((*p == '\n') || (*p == '\r'))
2064 *p = '\0';
2066 /* save last_newline in case we need to load more data */
2067 last_newline = count;
2069 switch (current_command)
2071 case PLAYLIST_COMMAND_PLAYLIST:
2073 /* str1=version str2=dir str3=file */
2074 int version;
2076 if (!str1)
2078 result = -1;
2079 exit_loop = true;
2080 break;
2083 if (!str2)
2084 str2 = "";
2086 if (!str3)
2087 str3 = "";
2089 version = atoi(str1);
2091 if (version != PLAYLIST_CONTROL_FILE_VERSION)
2092 return -1;
2094 update_playlist_filename(playlist, str2, str3);
2096 if (str3[0] != '\0')
2098 /* NOTE: add_indices_to_playlist() overwrites the
2099 audiobuf so we need to reload control file
2100 data */
2101 add_indices_to_playlist(playlist, NULL, 0);
2103 else if (str2[0] != '\0')
2105 playlist->in_ram = true;
2106 resume_directory(str2);
2109 /* load the rest of the data */
2110 first = false;
2111 exit_loop = true;
2113 break;
2115 case PLAYLIST_COMMAND_ADD:
2116 case PLAYLIST_COMMAND_QUEUE:
2118 /* str1=position str2=last_position str3=file */
2119 int position, last_position;
2120 bool queue;
2122 if (!str1 || !str2 || !str3)
2124 result = -1;
2125 exit_loop = true;
2126 break;
2129 position = atoi(str1);
2130 last_position = atoi(str2);
2132 queue = (current_command == PLAYLIST_COMMAND_ADD)?
2133 false:true;
2135 /* seek position is based on str3's position in
2136 buffer */
2137 if (add_track_to_playlist(playlist, str3, position,
2138 queue, total_read+(str3-buffer)) < 0)
2139 return -1;
2141 playlist->last_insert_pos = last_position;
2143 break;
2145 case PLAYLIST_COMMAND_DELETE:
2147 /* str1=position */
2148 int position;
2150 if (!str1)
2152 result = -1;
2153 exit_loop = true;
2154 break;
2157 position = atoi(str1);
2159 if (remove_track_from_playlist(playlist, position,
2160 false) < 0)
2161 return -1;
2163 break;
2165 case PLAYLIST_COMMAND_SHUFFLE:
2167 /* str1=seed str2=first_index */
2168 int seed;
2170 if (!str1 || !str2)
2172 result = -1;
2173 exit_loop = true;
2174 break;
2177 if (!sorted)
2179 /* Always sort list before shuffling */
2180 sort_playlist(playlist, false, false);
2183 seed = atoi(str1);
2184 playlist->first_index = atoi(str2);
2186 if (randomise_playlist(playlist, seed, false,
2187 false) < 0)
2188 return -1;
2189 sorted = false;
2190 break;
2192 case PLAYLIST_COMMAND_UNSHUFFLE:
2194 /* str1=first_index */
2195 if (!str1)
2197 result = -1;
2198 exit_loop = true;
2199 break;
2202 playlist->first_index = atoi(str1);
2204 if (sort_playlist(playlist, false, false) < 0)
2205 return -1;
2207 sorted = true;
2208 break;
2210 case PLAYLIST_COMMAND_RESET:
2212 playlist->last_insert_pos = -1;
2213 break;
2215 case PLAYLIST_COMMAND_COMMENT:
2216 default:
2217 break;
2220 newline = true;
2222 /* to ignore any extra newlines */
2223 current_command = PLAYLIST_COMMAND_COMMENT;
2225 else if(newline)
2227 newline = false;
2229 /* first non-comment line must always specify playlist */
2230 if (first && *p != 'P' && *p != '#')
2232 result = -1;
2233 exit_loop = true;
2234 break;
2237 switch (*p)
2239 case 'P':
2240 /* playlist can only be specified once */
2241 if (!first)
2243 result = -1;
2244 exit_loop = true;
2245 break;
2248 current_command = PLAYLIST_COMMAND_PLAYLIST;
2249 break;
2250 case 'A':
2251 current_command = PLAYLIST_COMMAND_ADD;
2252 break;
2253 case 'Q':
2254 current_command = PLAYLIST_COMMAND_QUEUE;
2255 break;
2256 case 'D':
2257 current_command = PLAYLIST_COMMAND_DELETE;
2258 break;
2259 case 'S':
2260 current_command = PLAYLIST_COMMAND_SHUFFLE;
2261 break;
2262 case 'U':
2263 current_command = PLAYLIST_COMMAND_UNSHUFFLE;
2264 break;
2265 case 'R':
2266 current_command = PLAYLIST_COMMAND_RESET;
2267 break;
2268 case '#':
2269 current_command = PLAYLIST_COMMAND_COMMENT;
2270 break;
2271 default:
2272 result = -1;
2273 exit_loop = true;
2274 break;
2277 str_count = -1;
2278 str1 = NULL;
2279 str2 = NULL;
2280 str3 = NULL;
2282 else if(current_command != PLAYLIST_COMMAND_COMMENT)
2284 /* all control file strings are separated with a colon.
2285 Replace the colon with 0 to get proper strings that can be
2286 used by commands above */
2287 if (*p == ':')
2289 *p = '\0';
2290 str_count++;
2292 if ((count+1) < nread)
2294 switch (str_count)
2296 case 0:
2297 str1 = p+1;
2298 break;
2299 case 1:
2300 str2 = p+1;
2301 break;
2302 case 2:
2303 str3 = p+1;
2304 break;
2305 default:
2306 /* allow last string to contain colons */
2307 *p = ':';
2308 break;
2315 if (result < 0)
2317 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID));
2318 return result;
2321 if (useraborted)
2323 splash(HZ*2, ID2P(LANG_CANCEL));
2324 return -1;
2326 if (!newline || (exit_loop && count<nread))
2328 if ((total_read + count) >= control_file_size)
2330 /* no newline at end of control file */
2331 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_INVALID));
2332 return -1;
2335 /* We didn't end on a newline or we exited loop prematurely.
2336 Either way, re-read the remainder. */
2337 count = last_newline;
2338 lseek(playlist->control_fd, total_read+count, SEEK_SET);
2341 total_read += count;
2343 if (first)
2344 /* still looking for header */
2345 nread = read(playlist->control_fd, buffer,
2346 PLAYLIST_COMMAND_SIZE<buflen?PLAYLIST_COMMAND_SIZE:buflen);
2347 else
2348 nread = read(playlist->control_fd, buffer, buflen);
2350 /* Terminate on EOF */
2351 if(nread <= 0)
2353 break;
2357 #ifdef HAVE_DIRCACHE
2358 queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
2359 #endif
2361 return 0;
2365 * Add track to in_ram playlist. Used when playing directories.
2367 int playlist_add(const char *filename)
2369 struct playlist_info* playlist = &current_playlist;
2370 int len = strlen(filename);
2372 if((len+1 > playlist->buffer_size - playlist->buffer_end_pos) ||
2373 (playlist->amount >= playlist->max_playlist_size))
2375 display_buffer_full();
2376 return -1;
2379 playlist->indices[playlist->amount] = playlist->buffer_end_pos;
2380 #ifdef HAVE_DIRCACHE
2381 playlist->filenames[playlist->amount] = NULL;
2382 #endif
2383 playlist->amount++;
2385 strcpy(&playlist->buffer[playlist->buffer_end_pos], filename);
2386 playlist->buffer_end_pos += len;
2387 playlist->buffer[playlist->buffer_end_pos++] = '\0';
2389 return 0;
2392 /* shuffle newly created playlist using random seed. */
2393 int playlist_shuffle(int random_seed, int start_index)
2395 struct playlist_info* playlist = &current_playlist;
2397 unsigned int seek_pos = 0;
2398 bool start_current = false;
2400 if (start_index >= 0 && global_settings.play_selected)
2402 /* store the seek position before the shuffle */
2403 seek_pos = playlist->indices[start_index];
2404 playlist->index = playlist->first_index = start_index;
2405 start_current = true;
2408 randomise_playlist(playlist, random_seed, start_current, true);
2410 return playlist->index;
2413 /* start playing current playlist at specified index/offset */
2414 void playlist_start(int start_index, int offset)
2416 struct playlist_info* playlist = &current_playlist;
2418 /* Cancel FM radio selection as previous music. For cases where we start
2419 playback without going to the WPS, such as playlist insert.. or
2420 playlist catalog. */
2421 previous_music_is_wps();
2423 playlist->index = start_index;
2425 #if CONFIG_CODEC != SWCODEC
2426 talk_buffer_steal(); /* will use the mp3 buffer */
2427 #endif
2429 playlist->started = true;
2430 sync_control(playlist, false);
2431 audio_play(offset);
2434 /* Returns false if 'steps' is out of bounds, else true */
2435 bool playlist_check(int steps)
2437 struct playlist_info* playlist = &current_playlist;
2439 /* always allow folder navigation */
2440 if (global_settings.next_folder && playlist->in_ram)
2441 return true;
2443 int index = get_next_index(playlist, steps, -1);
2445 if (index < 0 && steps >= 0 && global_settings.repeat_mode == REPEAT_SHUFFLE)
2446 index = get_next_index(playlist, steps, REPEAT_ALL);
2448 return (index >= 0);
2451 /* get trackname of track that is "steps" away from current playing track.
2452 NULL is used to identify end of playlist */
2453 const char* playlist_peek(int steps)
2455 struct playlist_info* playlist = &current_playlist;
2456 int seek;
2457 char *temp_ptr;
2458 int index;
2459 bool control_file;
2461 index = get_next_index(playlist, steps, -1);
2462 if (index < 0)
2463 return NULL;
2465 control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
2466 seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
2468 if (get_filename(playlist, index, seek, control_file, now_playing,
2469 MAX_PATH+1) < 0)
2470 return NULL;
2472 temp_ptr = now_playing;
2474 if (!playlist->in_ram || control_file)
2476 /* remove bogus dirs from beginning of path
2477 (workaround for buggy playlist creation tools) */
2478 while (temp_ptr)
2480 if (file_exists(temp_ptr))
2481 break;
2483 temp_ptr = strchr(temp_ptr+1, '/');
2486 if (!temp_ptr)
2488 /* Even though this is an invalid file, we still need to pass a
2489 file name to the caller because NULL is used to indicate end
2490 of playlist */
2491 return now_playing;
2495 return temp_ptr;
2499 * Update indices as track has changed
2501 int playlist_next(int steps)
2503 struct playlist_info* playlist = &current_playlist;
2504 int index;
2506 if ( (steps > 0)
2507 #ifdef AB_REPEAT_ENABLE
2508 && (global_settings.repeat_mode != REPEAT_AB)
2509 #endif
2510 && (global_settings.repeat_mode != REPEAT_ONE) )
2512 int i, j;
2514 /* We need to delete all the queued songs */
2515 for (i=0, j=steps; i<j; i++)
2517 index = get_next_index(playlist, i, -1);
2519 if (playlist->indices[index] & PLAYLIST_QUEUE_MASK)
2521 remove_track_from_playlist(playlist, index, true);
2522 steps--; /* one less track */
2527 index = get_next_index(playlist, steps, -1);
2529 if (index < 0)
2531 /* end of playlist... or is it */
2532 if (global_settings.repeat_mode == REPEAT_SHUFFLE &&
2533 playlist->amount > 1)
2535 /* Repeat shuffle mode. Re-shuffle playlist and resume play */
2536 playlist->first_index = 0;
2537 sort_playlist(playlist, false, false);
2538 randomise_playlist(playlist, current_tick, false, true);
2539 #if CONFIG_CODEC != SWCODEC
2540 playlist_start(0, 0);
2541 #endif
2542 playlist->index = 0;
2543 index = 0;
2545 else if (playlist->in_ram && global_settings.next_folder)
2547 index = create_and_play_dir(steps, true);
2549 if (index >= 0)
2551 playlist->index = index;
2555 return index;
2558 playlist->index = index;
2560 if (playlist->last_insert_pos >= 0 && steps > 0)
2562 /* check to see if we've gone beyond the last inserted track */
2563 int cur = rotate_index(playlist, index);
2564 int last_pos = rotate_index(playlist, playlist->last_insert_pos);
2566 if (cur > last_pos)
2568 /* reset last inserted track */
2569 playlist->last_insert_pos = -1;
2571 if (playlist->control_fd >= 0)
2573 int result = update_control(playlist, PLAYLIST_COMMAND_RESET,
2574 -1, -1, NULL, NULL, NULL);
2576 if (result < 0)
2577 return result;
2579 sync_control(playlist, false);
2584 return index;
2587 /* try playing next or previous folder */
2588 bool playlist_next_dir(int direction)
2590 /* not to mess up real playlists */
2591 if(!current_playlist.in_ram)
2592 return false;
2594 return create_and_play_dir(direction, false) >= 0;
2597 /* Get resume info for current playing song. If return value is -1 then
2598 settings shouldn't be saved. */
2599 int playlist_get_resume_info(int *resume_index)
2601 struct playlist_info* playlist = &current_playlist;
2603 *resume_index = playlist->index;
2605 return 0;
2608 /* Update resume info for current playing song. Returns -1 on error. */
2609 int playlist_update_resume_info(const struct mp3entry* id3)
2611 struct playlist_info* playlist = &current_playlist;
2613 if (id3)
2615 if (global_status.resume_index != playlist->index ||
2616 global_status.resume_offset != id3->offset)
2618 global_status.resume_index = playlist->index;
2619 global_status.resume_offset = id3->offset;
2620 status_save();
2623 else
2625 global_status.resume_index = -1;
2626 global_status.resume_offset = -1;
2627 status_save();
2630 return 0;
2633 /* Returns index of current playing track for display purposes. This value
2634 should not be used for resume purposes as it doesn't represent the actual
2635 index into the playlist */
2636 int playlist_get_display_index(void)
2638 struct playlist_info* playlist = &current_playlist;
2640 /* first_index should always be index 0 for display purposes */
2641 int index = rotate_index(playlist, playlist->index);
2643 return (index+1);
2646 /* returns number of tracks in current playlist */
2647 int playlist_amount(void)
2649 return playlist_amount_ex(NULL);
2651 /* set playlist->last_shuffle_start to playlist->amount for
2652 PLAYLIST_INSERT_LAST_SHUFFLED command purposes*/
2653 void playlist_set_last_shuffled_start(void)
2655 struct playlist_info* playlist = &current_playlist;
2656 playlist->last_shuffled_start = playlist->amount;
2659 * Create a new playlist If playlist is not NULL then we're loading a
2660 * playlist off disk for viewing/editing. The index_buffer is used to store
2661 * playlist indices (required for and only used if !current playlist). The
2662 * temp_buffer (if not NULL) is used as a scratchpad when loading indices.
2664 int playlist_create_ex(struct playlist_info* playlist,
2665 const char* dir, const char* file,
2666 void* index_buffer, int index_buffer_size,
2667 void* temp_buffer, int temp_buffer_size)
2669 if (!playlist)
2670 playlist = &current_playlist;
2671 else
2673 /* Initialize playlist structure */
2674 int r = rand() % 10;
2675 playlist->current = false;
2677 /* Use random name for control file */
2678 snprintf(playlist->control_filename, sizeof(playlist->control_filename),
2679 "%s.%d", PLAYLIST_CONTROL_FILE, r);
2680 playlist->fd = -1;
2681 playlist->control_fd = -1;
2683 if (index_buffer)
2685 int num_indices = index_buffer_size / sizeof(int);
2687 #ifdef HAVE_DIRCACHE
2688 num_indices /= 2;
2689 #endif
2690 if (num_indices > global_settings.max_files_in_playlist)
2691 num_indices = global_settings.max_files_in_playlist;
2693 playlist->max_playlist_size = num_indices;
2694 playlist->indices = index_buffer;
2695 #ifdef HAVE_DIRCACHE
2696 playlist->filenames = (const struct dircache_entry **)
2697 &playlist->indices[num_indices];
2698 #endif
2700 else
2702 playlist->max_playlist_size = current_playlist.max_playlist_size;
2703 playlist->indices = current_playlist.indices;
2704 #ifdef HAVE_DIRCACHE
2705 playlist->filenames = current_playlist.filenames;
2706 #endif
2709 playlist->buffer_size = 0;
2710 playlist->buffer = NULL;
2711 mutex_init(&playlist->control_mutex);
2714 new_playlist(playlist, dir, file);
2716 if (file)
2717 /* load the playlist file */
2718 add_indices_to_playlist(playlist, temp_buffer, temp_buffer_size);
2720 return 0;
2724 * Set the specified playlist as the current.
2725 * NOTE: You will get undefined behaviour if something is already playing so
2726 * remember to stop before calling this. Also, this call will
2727 * effectively close your playlist, making it unusable.
2729 int playlist_set_current(struct playlist_info* playlist)
2731 if (!playlist || (check_control(playlist) < 0))
2732 return -1;
2734 empty_playlist(&current_playlist, false);
2736 strlcpy(current_playlist.filename, playlist->filename,
2737 sizeof(current_playlist.filename));
2739 current_playlist.utf8 = playlist->utf8;
2740 current_playlist.fd = playlist->fd;
2742 close(playlist->control_fd);
2743 close(current_playlist.control_fd);
2744 remove(current_playlist.control_filename);
2745 if (rename(playlist->control_filename,
2746 current_playlist.control_filename) < 0)
2747 return -1;
2748 current_playlist.control_fd = open(current_playlist.control_filename,
2749 O_RDWR);
2750 if (current_playlist.control_fd < 0)
2751 return -1;
2752 current_playlist.control_created = true;
2754 current_playlist.dirlen = playlist->dirlen;
2756 if (playlist->indices && playlist->indices != current_playlist.indices)
2758 memcpy(current_playlist.indices, playlist->indices,
2759 playlist->max_playlist_size*sizeof(int));
2760 #ifdef HAVE_DIRCACHE
2761 memcpy(current_playlist.filenames, playlist->filenames,
2762 playlist->max_playlist_size*sizeof(int));
2763 #endif
2766 current_playlist.first_index = playlist->first_index;
2767 current_playlist.amount = playlist->amount;
2768 current_playlist.last_insert_pos = playlist->last_insert_pos;
2769 current_playlist.seed = playlist->seed;
2770 current_playlist.shuffle_modified = playlist->shuffle_modified;
2771 current_playlist.deleted = playlist->deleted;
2772 current_playlist.num_inserted_tracks = playlist->num_inserted_tracks;
2774 memcpy(current_playlist.control_cache, playlist->control_cache,
2775 sizeof(current_playlist.control_cache));
2776 current_playlist.num_cached = playlist->num_cached;
2777 current_playlist.pending_control_sync = playlist->pending_control_sync;
2779 return 0;
2781 struct playlist_info *playlist_get_current(void)
2783 return &current_playlist;
2786 * Close files and delete control file for non-current playlist.
2788 void playlist_close(struct playlist_info* playlist)
2790 if (!playlist)
2791 return;
2793 if (playlist->fd >= 0)
2794 close(playlist->fd);
2796 if (playlist->control_fd >= 0)
2797 close(playlist->control_fd);
2799 if (playlist->control_created)
2800 remove(playlist->control_filename);
2803 void playlist_sync(struct playlist_info* playlist)
2805 if (!playlist)
2806 playlist = &current_playlist;
2808 sync_control(playlist, false);
2809 if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
2810 audio_flush_and_reload_tracks();
2812 #ifdef HAVE_DIRCACHE
2813 queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
2814 #endif
2818 * Insert track into playlist at specified position (or one of the special
2819 * positions). Returns position where track was inserted or -1 if error.
2821 int playlist_insert_track(struct playlist_info* playlist, const char *filename,
2822 int position, bool queue, bool sync)
2824 int result;
2826 if (!playlist)
2827 playlist = &current_playlist;
2829 if (check_control(playlist) < 0)
2831 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2832 return -1;
2835 result = add_track_to_playlist(playlist, filename, position, queue, -1);
2837 /* Check if we want manually sync later. For example when adding
2838 * bunch of files from tagcache, syncing after every file wouldn't be
2839 * a good thing to do. */
2840 if (sync && result >= 0)
2841 playlist_sync(playlist);
2843 return result;
2847 * Insert all tracks from specified directory into playlist.
2849 int playlist_insert_directory(struct playlist_info* playlist,
2850 const char *dirname, int position, bool queue,
2851 bool recurse)
2853 int result;
2854 unsigned char *count_str;
2855 struct directory_search_context context;
2857 if (!playlist)
2858 playlist = &current_playlist;
2860 if (check_control(playlist) < 0)
2862 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2863 return -1;
2866 if (position == PLAYLIST_REPLACE)
2868 if (playlist_remove_all_tracks(playlist) == 0)
2869 position = PLAYLIST_INSERT_LAST;
2870 else
2871 return -1;
2874 if (queue)
2875 count_str = ID2P(LANG_PLAYLIST_QUEUE_COUNT);
2876 else
2877 count_str = ID2P(LANG_PLAYLIST_INSERT_COUNT);
2879 display_playlist_count(0, count_str, false);
2881 context.playlist = playlist;
2882 context.position = position;
2883 context.queue = queue;
2884 context.count = 0;
2886 cpu_boost(true);
2888 result = playlist_directory_tracksearch(dirname, recurse,
2889 directory_search_callback, &context);
2891 sync_control(playlist, false);
2893 cpu_boost(false);
2895 display_playlist_count(context.count, count_str, true);
2897 if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
2898 audio_flush_and_reload_tracks();
2900 #ifdef HAVE_DIRCACHE
2901 queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
2902 #endif
2904 return result;
2908 * Insert all tracks from specified playlist into dynamic playlist.
2910 int playlist_insert_playlist(struct playlist_info* playlist, const char *filename,
2911 int position, bool queue)
2913 int fd;
2914 int max;
2915 char *temp_ptr;
2916 const char *dir;
2917 unsigned char *count_str;
2918 char temp_buf[MAX_PATH+1];
2919 char trackname[MAX_PATH+1];
2920 int count = 0;
2921 int result = 0;
2922 bool utf8 = is_m3u8(filename);
2924 if (!playlist)
2925 playlist = &current_playlist;
2927 if (check_control(playlist) < 0)
2929 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
2930 return -1;
2933 fd = open_utf8(filename, O_RDONLY);
2934 if (fd < 0)
2936 splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
2937 return -1;
2940 /* we need the directory name for formatting purposes */
2941 dir = filename;
2943 temp_ptr = strrchr(filename+1,'/');
2944 if (temp_ptr)
2945 *temp_ptr = 0;
2946 else
2947 dir = "/";
2949 if (queue)
2950 count_str = ID2P(LANG_PLAYLIST_QUEUE_COUNT);
2951 else
2952 count_str = ID2P(LANG_PLAYLIST_INSERT_COUNT);
2954 display_playlist_count(count, count_str, false);
2956 if (position == PLAYLIST_REPLACE)
2958 if (playlist_remove_all_tracks(playlist) == 0)
2959 position = PLAYLIST_INSERT_LAST;
2960 else return -1;
2963 cpu_boost(true);
2965 while ((max = read_line(fd, temp_buf, sizeof(temp_buf))) > 0)
2967 /* user abort */
2968 if (action_userabort(TIMEOUT_NOBLOCK))
2969 break;
2971 if (temp_buf[0] != '#' && temp_buf[0] != '\0')
2973 int insert_pos;
2975 if (!utf8)
2977 /* Use trackname as a temporay buffer. Note that trackname must
2978 * be as large as temp_buf.
2980 max = convert_m3u(temp_buf, max, sizeof(temp_buf), trackname);
2983 /* we need to format so that relative paths are correctly
2984 handled */
2985 if (format_track_path(trackname, temp_buf, sizeof(trackname), max,
2986 dir) < 0)
2988 result = -1;
2989 break;
2992 insert_pos = add_track_to_playlist(playlist, trackname, position,
2993 queue, -1);
2995 if (insert_pos < 0)
2997 result = -1;
2998 break;
3001 /* Make sure tracks are inserted in correct order if user
3002 requests INSERT_FIRST */
3003 if (position == PLAYLIST_INSERT_FIRST || position >= 0)
3004 position = insert_pos + 1;
3006 count++;
3008 if ((count%PLAYLIST_DISPLAY_COUNT) == 0)
3010 display_playlist_count(count, count_str, false);
3012 if (count == PLAYLIST_DISPLAY_COUNT &&
3013 (audio_status() & AUDIO_STATUS_PLAY) &&
3014 playlist->started)
3015 audio_flush_and_reload_tracks();
3019 /* let the other threads work */
3020 yield();
3023 close(fd);
3025 if (temp_ptr)
3026 *temp_ptr = '/';
3028 sync_control(playlist, false);
3030 cpu_boost(false);
3032 display_playlist_count(count, count_str, true);
3034 if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
3035 audio_flush_and_reload_tracks();
3037 #ifdef HAVE_DIRCACHE
3038 queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
3039 #endif
3041 return result;
3045 * Delete track at specified index. If index is PLAYLIST_DELETE_CURRENT then
3046 * we want to delete the current playing track.
3048 int playlist_delete(struct playlist_info* playlist, int index)
3050 int result = 0;
3052 if (!playlist)
3053 playlist = &current_playlist;
3055 if (check_control(playlist) < 0)
3057 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
3058 return -1;
3061 if (index == PLAYLIST_DELETE_CURRENT)
3062 index = playlist->index;
3064 result = remove_track_from_playlist(playlist, index, true);
3066 if (result != -1 && (audio_status() & AUDIO_STATUS_PLAY) &&
3067 playlist->started)
3068 audio_flush_and_reload_tracks();
3070 return result;
3074 * Move track at index to new_index. Tracks between the two are shifted
3075 * appropriately. Returns 0 on success and -1 on failure.
3077 int playlist_move(struct playlist_info* playlist, int index, int new_index)
3079 int result;
3080 int seek;
3081 bool control_file;
3082 bool queue;
3083 bool current = false;
3084 int r;
3085 char filename[MAX_PATH];
3087 if (!playlist)
3088 playlist = &current_playlist;
3090 if (check_control(playlist) < 0)
3092 splash(HZ*2, ID2P(LANG_PLAYLIST_CONTROL_ACCESS_ERROR));
3093 return -1;
3096 if (index == new_index)
3097 return -1;
3099 if (index == playlist->index)
3100 /* Moving the current track */
3101 current = true;
3103 control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
3104 queue = playlist->indices[index] & PLAYLIST_QUEUE_MASK;
3105 seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
3107 if (get_filename(playlist, index, seek, control_file, filename,
3108 sizeof(filename)) < 0)
3109 return -1;
3111 /* We want to insert the track at the position that was specified by
3112 new_index. This may be different then new_index because of the
3113 shifting that will occur after the delete.
3114 We calculate this before we do the remove as it depends on the
3115 size of the playlist before the track removal */
3116 r = rotate_index(playlist, new_index);
3118 /* Delete track from original position */
3119 result = remove_track_from_playlist(playlist, index, true);
3121 if (result != -1)
3123 if (r == 0)
3124 /* First index */
3125 new_index = PLAYLIST_PREPEND;
3126 else if (r == playlist->amount)
3127 /* Append */
3128 new_index = PLAYLIST_INSERT_LAST;
3129 else
3130 /* Calculate index of desired position */
3131 new_index = (r+playlist->first_index)%playlist->amount;
3133 result = add_track_to_playlist(playlist, filename, new_index, queue,
3134 -1);
3136 if (result != -1)
3138 if (current)
3140 /* Moved the current track */
3141 switch (new_index)
3143 case PLAYLIST_PREPEND:
3144 playlist->index = playlist->first_index;
3145 break;
3146 case PLAYLIST_INSERT_LAST:
3147 playlist->index = playlist->first_index - 1;
3148 if (playlist->index < 0)
3149 playlist->index += playlist->amount;
3150 break;
3151 default:
3152 playlist->index = new_index;
3153 break;
3157 if ((audio_status() & AUDIO_STATUS_PLAY) && playlist->started)
3158 audio_flush_and_reload_tracks();
3162 #ifdef HAVE_DIRCACHE
3163 queue_post(&playlist_queue, PLAYLIST_LOAD_POINTERS, 0);
3164 #endif
3166 return result;
3169 /* shuffle currently playing playlist */
3170 int playlist_randomise(struct playlist_info* playlist, unsigned int seed,
3171 bool start_current)
3173 int result;
3175 if (!playlist)
3176 playlist = &current_playlist;
3178 check_control(playlist);
3180 result = randomise_playlist(playlist, seed, start_current, true);
3182 if (result != -1 && (audio_status() & AUDIO_STATUS_PLAY) &&
3183 playlist->started)
3184 audio_flush_and_reload_tracks();
3186 return result;
3189 /* sort currently playing playlist */
3190 int playlist_sort(struct playlist_info* playlist, bool start_current)
3192 int result;
3194 if (!playlist)
3195 playlist = &current_playlist;
3197 check_control(playlist);
3199 result = sort_playlist(playlist, start_current, true);
3201 if (result != -1 && (audio_status() & AUDIO_STATUS_PLAY) &&
3202 playlist->started)
3203 audio_flush_and_reload_tracks();
3205 return result;
3208 /* returns true if playlist has been modified */
3209 bool playlist_modified(const struct playlist_info* playlist)
3211 if (!playlist)
3212 playlist = &current_playlist;
3214 if (playlist->shuffle_modified ||
3215 playlist->deleted ||
3216 playlist->num_inserted_tracks > 0)
3217 return true;
3219 return false;
3222 /* returns index of first track in playlist */
3223 int playlist_get_first_index(const struct playlist_info* playlist)
3225 if (!playlist)
3226 playlist = &current_playlist;
3228 return playlist->first_index;
3231 /* returns shuffle seed of playlist */
3232 int playlist_get_seed(const struct playlist_info* playlist)
3234 if (!playlist)
3235 playlist = &current_playlist;
3237 return playlist->seed;
3240 /* returns number of tracks in playlist (includes queued/inserted tracks) */
3241 int playlist_amount_ex(const struct playlist_info* playlist)
3243 if (!playlist)
3244 playlist = &current_playlist;
3246 return playlist->amount;
3249 /* returns full path of playlist (minus extension) */
3250 char *playlist_name(const struct playlist_info* playlist, char *buf,
3251 int buf_size)
3253 char *sep;
3255 if (!playlist)
3256 playlist = &current_playlist;
3258 strlcpy(buf, playlist->filename+playlist->dirlen, buf_size);
3260 if (!buf[0])
3261 return NULL;
3263 /* Remove extension */
3264 sep = strrchr(buf, '.');
3265 if (sep)
3266 *sep = 0;
3268 return buf;
3271 /* returns the playlist filename */
3272 char *playlist_get_name(const struct playlist_info* playlist, char *buf,
3273 int buf_size)
3275 if (!playlist)
3276 playlist = &current_playlist;
3278 strlcpy(buf, playlist->filename, buf_size);
3280 if (!buf[0])
3281 return NULL;
3283 return buf;
3286 /* Fills info structure with information about track at specified index.
3287 Returns 0 on success and -1 on failure */
3288 int playlist_get_track_info(struct playlist_info* playlist, int index,
3289 struct playlist_track_info* info)
3291 int seek;
3292 bool control_file;
3294 if (!playlist)
3295 playlist = &current_playlist;
3297 if (index < 0 || index >= playlist->amount)
3298 return -1;
3300 control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
3301 seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
3303 if (get_filename(playlist, index, seek, control_file, info->filename,
3304 sizeof(info->filename)) < 0)
3305 return -1;
3307 info->attr = 0;
3309 if (control_file)
3311 if (playlist->indices[index] & PLAYLIST_QUEUE_MASK)
3312 info->attr |= PLAYLIST_ATTR_QUEUED;
3313 else
3314 info->attr |= PLAYLIST_ATTR_INSERTED;
3318 if (playlist->indices[index] & PLAYLIST_SKIPPED)
3319 info->attr |= PLAYLIST_ATTR_SKIPPED;
3321 info->index = index;
3322 info->display_index = rotate_index(playlist, index) + 1;
3324 return 0;
3327 /* save the current dynamic playlist to specified file */
3328 int playlist_save(struct playlist_info* playlist, char *filename)
3330 int fd;
3331 int i, index;
3332 int count = 0;
3333 char path[MAX_PATH+1];
3334 char tmp_buf[MAX_PATH+1];
3335 int result = 0;
3336 bool overwrite_current = false;
3337 int* index_buf = NULL;
3339 if (!playlist)
3340 playlist = &current_playlist;
3342 if (playlist->amount <= 0)
3343 return -1;
3345 /* use current working directory as base for pathname */
3346 if (format_track_path(path, filename, sizeof(tmp_buf),
3347 strlen(filename)+1, getcwd(NULL, -1)) < 0)
3348 return -1;
3350 if (!strncmp(playlist->filename, path, strlen(path)))
3352 /* Attempting to overwrite current playlist file.*/
3354 if (playlist->buffer_size < (int)(playlist->amount * sizeof(int)))
3356 /* not enough buffer space to store updated indices */
3357 splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
3358 return -1;
3361 /* in_ram buffer is unused for m3u files so we'll use for storing
3362 updated indices */
3363 index_buf = (int*)playlist->buffer;
3365 /* use temporary pathname */
3366 snprintf(path, sizeof(path), "%s_temp", playlist->filename);
3367 overwrite_current = true;
3370 if (is_m3u8(path))
3372 fd = open_utf8(path, O_CREAT|O_WRONLY|O_TRUNC);
3374 else
3376 /* some applications require a BOM to read the file properly */
3377 fd = open(path, O_CREAT|O_WRONLY|O_TRUNC, 0666);
3379 if (fd < 0)
3381 splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
3382 return -1;
3385 display_playlist_count(count, ID2P(LANG_PLAYLIST_SAVE_COUNT), false);
3387 cpu_boost(true);
3389 index = playlist->first_index;
3390 for (i=0; i<playlist->amount; i++)
3392 bool control_file;
3393 bool queue;
3394 int seek;
3396 /* user abort */
3397 if (action_userabort(TIMEOUT_NOBLOCK))
3399 result = -1;
3400 break;
3403 control_file = playlist->indices[index] & PLAYLIST_INSERT_TYPE_MASK;
3404 queue = playlist->indices[index] & PLAYLIST_QUEUE_MASK;
3405 seek = playlist->indices[index] & PLAYLIST_SEEK_MASK;
3407 /* Don't save queued files */
3408 if (!queue)
3410 if (get_filename(playlist, index, seek, control_file, tmp_buf,
3411 MAX_PATH+1) < 0)
3413 result = -1;
3414 break;
3417 if (overwrite_current)
3418 index_buf[count] = lseek(fd, 0, SEEK_CUR);
3420 if (fdprintf(fd, "%s\n", tmp_buf) < 0)
3422 splash(HZ*2, ID2P(LANG_PLAYLIST_ACCESS_ERROR));
3423 result = -1;
3424 break;
3427 count++;
3429 if ((count % PLAYLIST_DISPLAY_COUNT) == 0)
3430 display_playlist_count(count, ID2P(LANG_PLAYLIST_SAVE_COUNT),
3431 false);
3433 yield();
3436 index = (index+1)%playlist->amount;
3439 display_playlist_count(count, ID2P(LANG_PLAYLIST_SAVE_COUNT), true);
3441 close(fd);
3443 if (overwrite_current && result >= 0)
3445 result = -1;
3447 mutex_lock(&playlist->control_mutex);
3449 /* Replace the current playlist with the new one and update indices */
3450 close(playlist->fd);
3451 if (remove(playlist->filename) >= 0)
3453 if (rename(path, playlist->filename) >= 0)
3455 playlist->fd = open_utf8(playlist->filename, O_RDONLY);
3456 if (playlist->fd >= 0)
3458 index = playlist->first_index;
3459 for (i=0, count=0; i<playlist->amount; i++)
3461 if (!(playlist->indices[index] & PLAYLIST_QUEUE_MASK))
3463 playlist->indices[index] = index_buf[count];
3464 count++;
3466 index = (index+1)%playlist->amount;
3469 /* we need to recreate control because inserted tracks are
3470 now part of the playlist and shuffle has been
3471 invalidated */
3472 result = recreate_control(playlist);
3477 mutex_unlock(&playlist->control_mutex);
3481 cpu_boost(false);
3483 return result;
3487 * Search specified directory for tracks and notify via callback. May be
3488 * called recursively.
3490 int playlist_directory_tracksearch(const char* dirname, bool recurse,
3491 int (*callback)(char*, void*),
3492 void* context)
3494 char buf[MAX_PATH+1];
3495 int result = 0;
3496 int num_files = 0;
3497 int i;
3498 struct entry *files;
3499 struct tree_context* tc = tree_get_context();
3500 int old_dirfilter = *(tc->dirfilter);
3502 if (!callback)
3503 return -1;
3505 /* use the tree browser dircache to load files */
3506 *(tc->dirfilter) = SHOW_ALL;
3508 if (ft_load(tc, dirname) < 0)
3510 splash(HZ*2, ID2P(LANG_PLAYLIST_DIRECTORY_ACCESS_ERROR));
3511 *(tc->dirfilter) = old_dirfilter;
3512 return -1;
3515 files = (struct entry*) tc->dircache;
3516 num_files = tc->filesindir;
3518 /* we've overwritten the dircache so tree browser will need to be
3519 reloaded */
3520 reload_directory();
3522 for (i=0; i<num_files; i++)
3524 /* user abort */
3525 if (action_userabort(TIMEOUT_NOBLOCK))
3527 result = -1;
3528 break;
3531 if (files[i].attr & ATTR_DIRECTORY)
3533 if (recurse)
3535 /* recursively add directories */
3536 snprintf(buf, sizeof(buf), "%s/%s", dirname, files[i].name);
3537 result = playlist_directory_tracksearch(buf, recurse,
3538 callback, context);
3539 if (result < 0)
3540 break;
3542 /* we now need to reload our current directory */
3543 if(ft_load(tc, dirname) < 0)
3545 result = -1;
3546 break;
3549 files = (struct entry*) tc->dircache;
3550 num_files = tc->filesindir;
3551 if (!num_files)
3553 result = -1;
3554 break;
3557 else
3558 continue;
3560 else if ((files[i].attr & FILE_ATTR_MASK) == FILE_ATTR_AUDIO)
3562 snprintf(buf, sizeof(buf), "%s/%s", dirname, files[i].name);
3564 if (callback(buf, context) != 0)
3566 result = -1;
3567 break;
3570 /* let the other threads work */
3571 yield();
3575 /* restore dirfilter */
3576 *(tc->dirfilter) = old_dirfilter;
3578 return result;