1 /***************************************************************************
4 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
5 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
6 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
7 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
11 * Copyright (C) 2003 Hardeep Sidhu
13 * All files in this archive are subject to the GNU General Public License.
14 * See the file COPYING in the source tree root for full license agreement.
16 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
17 * KIND, either express or implied.
19 ****************************************************************************/
21 * Kevin Ferrare 2005/10/16
22 * multi-screen support, rewrote a lot of code
35 #include "filetypes.h"
41 #include "backlight.h"
45 #include "playlist_viewer.h"
46 #include "playlist_catalog.h"
49 #include "statusbar.h"
51 #include "playlist_menu.h"
54 /* Maximum number of tracks we can have loaded at one time */
55 #define MAX_PLAYLIST_ENTRIES 200
57 /* The number of items between the selected one and the end/start of
58 * the buffer under which the buffer must reload */
59 #define MIN_BUFFER_MARGIN (screens[0].nb_lines+1)
61 /* Information about a specific track */
62 struct playlist_entry
{
63 char *name
; /* Formatted track name */
64 int index
; /* Playlist index */
65 int display_index
; /* Display index */
66 bool queued
; /* Is track queued? */
67 bool skipped
; /* Is track marked as bad? */
76 struct playlist_buffer
78 char *name_buffer
; /* Buffer used to store track names */
79 int buffer_size
; /* Size of name buffer */
81 int first_index
; /* Real index of first track loaded inside
84 enum direction direction
; /* Direction of the buffer (if the buffer
85 was loaded BACKWARD, the last track in
86 the buffer has a real index < to the
87 real index of the the first track)*/
89 struct playlist_entry tracks
[MAX_PLAYLIST_ENTRIES
];
90 int num_loaded
; /* Number of track entries loaded in buffer */
93 /* Global playlist viewer settings */
94 struct playlist_viewer
{
95 struct playlist_info
* playlist
; /* playlist being viewed */
96 int num_tracks
; /* Number of tracks in playlist */
97 int current_playing_track
; /* Index of current playing track */
98 int selected_track
; /* The selected track, relative (first is 0)*/
99 int move_track
; /* Playlist index of track to move or -1 */
100 struct playlist_buffer buffer
;
103 static struct playlist_viewer viewer
;
105 /* Used when viewing playlists on disk */
106 static struct playlist_info temp_playlist
;
108 static void playlist_buffer_init(struct playlist_buffer
*pb
, char *names_buffer
,
109 int names_buffer_size
);
110 static void playlist_buffer_load_entries(struct playlist_buffer
* pb
, int index
,
111 enum direction direction
);
112 static int playlist_entry_load(struct playlist_entry
*entry
, int index
,
113 char* name_buffer
, int remaining_size
);
115 static struct playlist_entry
* playlist_buffer_get_track(struct playlist_buffer
*pb
,
118 static bool playlist_viewer_init(struct playlist_viewer
* viewer
,
119 char* filename
, bool reload
);
121 static void format_name(char* dest
, const char* src
);
122 static void format_line(const struct playlist_entry
* track
, char* str
,
125 static bool update_playlist(bool force
);
126 static int onplay_menu(int index
);
127 static bool viewer_menu(void);
128 static int save_playlist_func(void);
130 static void playlist_buffer_init(struct playlist_buffer
*pb
, char *names_buffer
,
131 int names_buffer_size
)
133 pb
->name_buffer
=names_buffer
;
134 pb
->buffer_size
=names_buffer_size
;
140 * Loads the entries following 'index' in the playlist buffer
142 static void playlist_buffer_load_entries(struct playlist_buffer
*pb
, int index
,
143 enum direction direction
)
145 int num_entries
= viewer
.num_tracks
;
146 char* p
= pb
->name_buffer
;
147 int remaining
= pb
->buffer_size
;
150 pb
->first_index
= index
;
151 if (num_entries
> MAX_PLAYLIST_ENTRIES
)
152 num_entries
= MAX_PLAYLIST_ENTRIES
;
154 for(i
=0; i
<num_entries
; i
++)
156 int len
= playlist_entry_load(&(pb
->tracks
[i
]), index
, p
, remaining
);
159 /* Out of name buffer space */
167 if(direction
==FORWARD
)
171 index
+=viewer
.num_tracks
;
172 index
%=viewer
.num_tracks
;
174 pb
->direction
=direction
;
178 static void playlist_buffer_load_entries_screen(struct playlist_buffer
* pb
,
179 enum direction direction
)
181 if(direction
==FORWARD
)
183 int min_start
=viewer
.selected_track
-2*screens
[0].nb_lines
;
185 min_start
+=viewer
.num_tracks
;
186 min_start
%= viewer
.num_tracks
;
187 playlist_buffer_load_entries(pb
, min_start
, FORWARD
);
191 int max_start
=viewer
.selected_track
+2*screens
[0].nb_lines
;
192 max_start
%=viewer
.num_tracks
;
193 playlist_buffer_load_entries(pb
, max_start
, BACKWARD
);
197 static int playlist_entry_load(struct playlist_entry
*entry
, int index
,
198 char* name_buffer
, int remaining_size
)
200 struct playlist_track_info info
;
203 /* Playlist viewer orders songs based on display index. We need to
204 convert to real playlist index to access track */
205 index
= (index
+ playlist_get_first_index(viewer
.playlist
)) %
207 if (playlist_get_track_info(viewer
.playlist
, index
, &info
) < 0)
210 len
= strlen(info
.filename
) + 1;
212 if (len
<= remaining_size
)
214 strcpy(name_buffer
, info
.filename
);
216 entry
->name
= name_buffer
;
217 entry
->index
= info
.index
;
218 entry
->display_index
= info
.display_index
;
219 entry
->queued
= info
.attr
& PLAYLIST_ATTR_QUEUED
;
220 entry
->skipped
= info
.attr
& PLAYLIST_ATTR_SKIPPED
;
226 static int playlist_buffer_get_index(struct playlist_buffer
*pb
, int index
)
229 if(pb
->direction
==FORWARD
)
231 if(index
>=pb
->first_index
)
232 buffer_index
=index
-pb
->first_index
;
233 else /* rotation : track0 in buffer + requested track */
234 buffer_index
=(viewer
.num_tracks
-pb
->first_index
)+(index
);
238 if(index
<=pb
->first_index
)
239 buffer_index
=pb
->first_index
-index
;
240 else /* rotation : track0 in buffer + dist from the last track
241 to the requested track (num_tracks-requested track) */
242 buffer_index
=(pb
->first_index
)+(viewer
.num_tracks
-index
);
244 return(buffer_index
);
247 #define distance(a, b) \
248 a>b? (a) - (b) : (b) - (a)
249 static bool playlist_buffer_needs_reload(struct playlist_buffer
* pb
,
252 if(pb
->num_loaded
==viewer
.num_tracks
)
254 int selected_index
=playlist_buffer_get_index(pb
, track_index
);
255 int first_buffer_index
=playlist_buffer_get_index(pb
, pb
->first_index
);
256 int distance_beginning
=distance(selected_index
, first_buffer_index
);
257 if(distance_beginning
<MIN_BUFFER_MARGIN
)
260 if(pb
->num_loaded
- distance_beginning
< MIN_BUFFER_MARGIN
)
265 static struct playlist_entry
* playlist_buffer_get_track(struct playlist_buffer
*pb
,
268 int buffer_index
=playlist_buffer_get_index(pb
, index
);
269 return(&(pb
->tracks
[buffer_index
]));
272 /* Initialize the playlist viewer. */
273 static bool playlist_viewer_init(struct playlist_viewer
* viewer
,
274 char* filename
, bool reload
)
278 bool is_playing
= audio_status() & (AUDIO_STATUS_PLAY
| AUDIO_STATUS_PAUSE
);
279 bool have_list
= filename
|| is_playing
;
280 if (!have_list
&& (global_status
.resume_index
!= -1))
282 /* Try to restore the list from control file */
283 have_list
= (playlist_resume() != -1);
285 if (!have_list
&& (playlist_amount() > 0))
287 /*If dynamic playlist still exists, view it anyway even
288 if playback has reached the end of the playlist */
293 /* Nothing to view, exit */
294 gui_syncsplash(HZ
, str(LANG_CATALOG_NO_PLAYLISTS
));
298 buffer
= plugin_get_buffer(&buffer_size
);
303 viewer
->playlist
= NULL
;
306 /* Viewing playlist on disk */
307 char *dir
, *file
, *temp_ptr
;
308 char *index_buffer
= NULL
;
309 ssize_t index_buffer_size
= 0;
311 viewer
->playlist
= &temp_playlist
;
313 /* Separate directory from filename */
314 temp_ptr
= strrchr(filename
+1,'/');
329 /* Something is playing, use half the plugin buffer for playlist
331 index_buffer_size
= buffer_size
/ 2;
332 index_buffer
= buffer
;
335 playlist_create_ex(viewer
->playlist
, dir
, file
, index_buffer
,
336 index_buffer_size
, buffer
+index_buffer_size
,
337 buffer_size
-index_buffer_size
);
342 buffer
+= index_buffer_size
;
343 buffer_size
-= index_buffer_size
;
345 playlist_buffer_init(&viewer
->buffer
, buffer
, buffer_size
);
347 viewer
->move_track
= -1;
351 if (viewer
->playlist
)
352 viewer
->selected_track
= 0;
354 viewer
->selected_track
= playlist_get_display_index() - 1;
357 if (!update_playlist(true))
362 /* Format trackname for display purposes */
363 static void format_name(char* dest
, const char* src
)
365 switch (global_settings
.playlist_viewer_track_display
)
370 /* Only display the filename */
371 char* p
= strrchr(src
, '/');
375 /* Remove the extension */
387 /* Format display line */
388 static void format_line(const struct playlist_entry
* track
, char* str
,
394 format_name(name
, track
->name
);
399 if (global_settings
.playlist_viewer_indices
)
400 /* Display playlist index */
401 snprintf(str
, len
, "%d. %s%s", track
->display_index
, skipped
, name
);
403 snprintf(str
, len
, "%s%s", skipped
, name
);
407 /* Update playlist in case something has changed or forced */
408 static bool update_playlist(bool force
)
410 if (!viewer
.playlist
)
411 playlist_get_resume_info(&viewer
.current_playing_track
);
413 viewer
.current_playing_track
= -1;
414 int nb_tracks
=playlist_amount_ex(viewer
.playlist
);
415 force
=force
|| nb_tracks
!= viewer
.num_tracks
;
419 viewer
.num_tracks
= nb_tracks
;
420 if (viewer
.num_tracks
<= 0)
422 playlist_buffer_load_entries_screen(&viewer
.buffer
, FORWARD
);
423 if (viewer
.buffer
.num_loaded
<= 0)
429 /* Menu of playlist commands. Invoked via ON+PLAY on main viewer screen.
430 Returns -1 if USB attached, 0 if no playlist change, and 1 if playlist
432 static int onplay_menu(int index
)
435 struct playlist_entry
* current_track
=
436 playlist_buffer_get_track(&viewer
.buffer
, index
);
437 MENUITEM_STRINGLIST(menu_items
, ID2P(LANG_PLAYLIST
), NULL
,
438 ID2P(LANG_REMOVE
), ID2P(LANG_MOVE
),
439 ID2P(LANG_CATALOG_ADD_TO
), ID2P(LANG_CATALOG_ADD_TO_NEW
));
440 bool current
= (current_track
->index
== viewer
.current_playing_track
);
442 result
= do_menu(&menu_items
, NULL
, NULL
, false);
443 if (result
== MENU_ATTACHED_USB
)
447 else if (result
>= 0)
449 /* Abort current move */
450 viewer
.move_track
= -1;
456 playlist_delete(viewer
.playlist
, current_track
->index
);
459 if (playlist_amount_ex(viewer
.playlist
) <= 0)
463 /* Start playing new track except if it's the lasttrack
464 track in the playlist and repeat mode is disabled */
466 playlist_buffer_get_track(&viewer
.buffer
, index
);
467 if (current_track
->display_index
!=viewer
.num_tracks
||
468 global_settings
.repeat_mode
== REPEAT_ALL
)
470 #if CONFIG_CODEC != SWCODEC
471 talk_buffer_steal(); /* will use the mp3 buffer */
474 viewer
.current_playing_track
= -1;
482 viewer
.move_track
= current_track
->index
;
485 case 2: /* add to catalog */
486 case 3: /* add to a new one */
487 catalog_add_to_a_playlist(current_track
->name
,
497 /* Menu of viewer options. Invoked via F1(r) or Menu(p). */
498 MENUITEM_SETTING(show_icons
, &global_settings
.playlist_viewer_icons
, NULL
);
499 MENUITEM_SETTING(show_indices
, &global_settings
.playlist_viewer_indices
, NULL
);
500 MENUITEM_SETTING(track_display
,
501 &global_settings
.playlist_viewer_track_display
, NULL
);
502 MENUITEM_FUNCTION(save_playlist_item
, 0, ID2P(LANG_SAVE_DYNAMIC_PLAYLIST
),
503 save_playlist_func
, 0, NULL
, Icon_NOICON
);
504 MAKE_MENU(viewer_settings_menu
, ID2P(LANG_PLAYLISTVIEWER_SETTINGS
),
506 &show_icons
, &show_indices
, &track_display
, &save_playlist_item
);
507 static bool viewer_menu(void)
509 return do_menu(&viewer_settings_menu
, NULL
, NULL
, false) == MENU_ATTACHED_USB
;
512 /* Save playlist to disk */
513 static int save_playlist_func(void)
515 save_playlist_screen(viewer
.playlist
);
519 /* View current playlist */
520 bool playlist_viewer(void)
522 return playlist_viewer_ex(NULL
);
525 static int get_track_num( struct playlist_viewer
* local_viewer
,
528 if( local_viewer
->move_track
>= 0 )
530 if( local_viewer
->selected_track
== selected_item
)
532 return local_viewer
->move_track
;
534 else if( local_viewer
->selected_track
> selected_item
535 && selected_item
>= local_viewer
->move_track
)
537 return selected_item
+1;
539 else if( local_viewer
->selected_track
< selected_item
540 && selected_item
<= local_viewer
->move_track
)
542 return selected_item
-1;
545 return selected_item
;
548 static char *playlist_callback_name(int selected_item
,
553 struct playlist_viewer
* local_viewer
= (struct playlist_viewer
*)data
;
555 int track_num
= get_track_num(local_viewer
, selected_item
);
556 struct playlist_entry
*track
=
557 playlist_buffer_get_track(&(local_viewer
->buffer
), track_num
);
559 format_line(track
, buffer
, buffer_len
);
565 static int playlist_callback_icons(int selected_item
, void *data
)
567 struct playlist_viewer
* local_viewer
=(struct playlist_viewer
*)data
;
569 int track_num
= get_track_num(local_viewer
, selected_item
);
570 struct playlist_entry
*track
=
571 playlist_buffer_get_track(&(local_viewer
->buffer
), track_num
);
573 if (track
->index
== local_viewer
->current_playing_track
)
575 /* Current playing track */
578 else if (track
->index
== local_viewer
->move_track
)
580 /* Track we are moving */
583 else if (track
->queued
)
592 /* Main viewer function. Filename identifies playlist to be viewed. If NULL,
593 view current playlist. */
594 bool playlist_viewer_ex(char* filename
)
596 bool ret
= false; /* return value */
597 bool exit
=false; /* exit viewer */
599 struct gui_synclist playlist_lists
;
600 if (!playlist_viewer_init(&viewer
, filename
, false))
603 gui_synclist_init(&playlist_lists
, playlist_callback_name
,
604 &viewer
, false, 1, NULL
);
605 gui_synclist_set_icon_callback(&playlist_lists
,
606 global_settings
.playlist_viewer_icons
?
607 &playlist_callback_icons
:NULL
);
608 gui_synclist_set_nb_items(&playlist_lists
, viewer
.num_tracks
);
609 gui_synclist_select_item(&playlist_lists
, viewer
.selected_track
);
610 gui_synclist_set_title(&playlist_lists
, str(LANG_PLAYLIST
), Icon_Playlist
);
611 gui_synclist_draw(&playlist_lists
);
616 if (global_status
.resume_index
!= -1 && !viewer
.playlist
)
617 playlist_get_resume_info(&track
);
621 if (track
!= viewer
.current_playing_track
||
622 playlist_amount_ex(viewer
.playlist
) != viewer
.num_tracks
)
624 /* Playlist has changed (new track started?) */
625 if (!update_playlist(false))
627 /*Needed because update_playlist gives wrong value when
629 viewer
.current_playing_track
= track
;
630 gui_synclist_set_nb_items(&playlist_lists
, viewer
.num_tracks
);
631 /* Abort move on playlist change */
632 viewer
.move_track
= -1;
633 gui_synclist_draw(&playlist_lists
);
636 /* Timeout so we can determine if play status has changed */
637 button
= get_action(CONTEXT_TREE
,HZ
/2);
638 if( (gui_synclist_do_button(&playlist_lists
, &button
,LIST_WRAP_UNLESS_HELD
)) )
640 viewer
.selected_track
=gui_synclist_get_sel_pos(&playlist_lists
);
641 if(playlist_buffer_needs_reload(&viewer
.buffer
,
642 viewer
.selected_track
))
643 playlist_buffer_load_entries_screen(&viewer
.buffer
,
644 button
==ACTION_STD_NEXT
?
649 gui_synclist_draw(&playlist_lists
);
653 case ACTION_TREE_WPS
:
654 case ACTION_STD_CANCEL
:
656 if (viewer
.move_track
>= 0)
658 viewer
.selected_track
= viewer
.move_track
;
659 gui_synclist_select_item(&playlist_lists
, viewer
.move_track
);
660 viewer
.move_track
= -1;
661 gui_synclist_draw(&playlist_lists
);
669 struct playlist_entry
* current_track
=
670 playlist_buffer_get_track(&viewer
.buffer
,
671 viewer
.selected_track
);
672 if (viewer
.move_track
>= 0)
677 ret_val
= playlist_move(viewer
.playlist
, viewer
.move_track
,
678 current_track
->index
);
680 gui_syncsplash(HZ
, (unsigned char *)"%s %s",
681 str(LANG_MOVE
), str(LANG_FAILED
));
682 update_playlist(true);
683 viewer
.move_track
= -1;
685 else if (!viewer
.playlist
)
688 playlist_start(current_track
->index
, 0);
689 update_playlist(false);
694 if (playlist_set_current(viewer
.playlist
) < 0)
697 playlist_start(current_track
->index
, 0);
699 /* Our playlist is now the current list */
700 if (!playlist_viewer_init(&viewer
, NULL
, true))
703 gui_synclist_draw(&playlist_lists
);
707 case ACTION_STD_CONTEXT
:
712 ret_val
= onplay_menu(viewer
.selected_track
);
721 /* Playlist changed */
722 gui_synclist_del_item(&playlist_lists
);
723 update_playlist(true);
724 if (viewer
.num_tracks
<= 0)
726 if(viewer
.selected_track
>= viewer
.num_tracks
)
727 viewer
.selected_track
= viewer
.num_tracks
-1;
729 gui_synclist_draw(&playlist_lists
);
732 case ACTION_STD_MENU
:
738 gui_synclist_set_icon_callback(
740 global_settings
.playlist_viewer_icons
?
741 &playlist_callback_icons
:NULL
743 gui_synclist_draw(&playlist_lists
);
747 gui_syncstatusbar_draw(&statusbars
, false);
751 if(default_event_handler(button
) == SYS_USB_CONNECTED
)
762 playlist_close(viewer
.playlist
);
766 static char *playlist_search_callback_name(int selected_item
, void * data
,
767 char *buffer
, size_t buffer_len
)
769 (void)buffer_len
; /* this should probably be used */
770 int *found_indicies
= (int*)data
;
771 static struct playlist_track_info track
;
772 playlist_get_track_info(viewer
.playlist
, found_indicies
[selected_item
], &track
);
773 format_name(buffer
, track
.filename
);
777 bool search_playlist(void)
779 char search_str
[32] = "";
780 bool ret
= false, exit
= false;
781 int i
, playlist_count
;
782 int found_indicies
[MAX_PLAYLIST_ENTRIES
],found_indicies_count
= 0;
784 struct gui_synclist playlist_lists
;
785 struct playlist_track_info track
;
787 if (!playlist_viewer_init(&viewer
, 0, false))
789 if (kbd_input(search_str
,sizeof(search_str
)) == -1)
792 playlist_count
= playlist_amount_ex(viewer
.playlist
);
793 for (i
=0;(i
<playlist_count
)&&(found_indicies_count
<MAX_PLAYLIST_ENTRIES
);i
++)
795 gui_syncsplash(0, str(LANG_PLAYLIST_SEARCH_MSG
),found_indicies_count
,
796 str(LANG_OFF_ABORT
));
797 if (action_userabort(TIMEOUT_NOBLOCK
))
799 if (!found_indicies_count
)
803 playlist_get_track_info(viewer
.playlist
,i
,&track
);
804 if (strcasestr(track
.filename
,search_str
))
806 found_indicies
[found_indicies_count
++] = track
.index
;
809 if (!found_indicies_count
)
814 gui_synclist_init(&playlist_lists
, playlist_search_callback_name
,
815 found_indicies
, false, 1, NULL
);
816 gui_synclist_set_icon_callback(&playlist_lists
, NULL
);
817 gui_synclist_set_nb_items(&playlist_lists
, found_indicies_count
);
818 gui_synclist_select_item(&playlist_lists
, 0);
819 gui_synclist_draw(&playlist_lists
);
822 button
= get_action(CONTEXT_LIST
,TIMEOUT_BLOCK
);
823 if (gui_synclist_do_button(&playlist_lists
, &button
, LIST_WRAP_UNLESS_HELD
))
827 case ACTION_STD_CANCEL
:
833 found_indicies
[gui_synclist_get_sel_pos(&playlist_lists
)]
840 if(default_event_handler(button
) == SYS_USB_CONNECTED
)