fix red
[kugel-rb.git] / apps / tagtree.c
blobde75223e0b5be886cebcf16069967a3d939d060b
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
10 * Copyright (C) 2005 by Miika Pekkarinen
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 ****************************************************************************/
22 /**
23 * Basic structure on this file was copied from dbtree.c and modified to
24 * support the tag cache interface.
27 /* #define LOGF_ENABLE */
29 #include <stdio.h>
30 #include <string.h>
31 #include <stdlib.h>
32 #include "config.h"
33 #include "system.h"
34 #include "kernel.h"
35 #include "splash.h"
36 #include "icons.h"
37 #include "tree.h"
38 #include "action.h"
39 #include "settings.h"
40 #include "tagcache.h"
41 #include "tagtree.h"
42 #include "lang.h"
43 #include "logf.h"
44 #include "playlist.h"
45 #include "keyboard.h"
46 #include "gui/list.h"
47 #include "buffer.h"
48 #include "playback.h"
49 #include "yesno.h"
50 #include "misc.h"
51 #include "filetypes.h"
52 #include "audio.h"
53 #include "appevents.h"
54 #include "storage.h"
55 #include "dir_uncached.h"
57 #define FILE_SEARCH_INSTRUCTIONS ROCKBOX_DIR "/tagnavi.config"
59 static int tagtree_play_folder(struct tree_context* c);
61 #define SEARCHSTR_SIZE 256
63 enum table {
64 ROOT = 1,
65 NAVIBROWSE,
66 ALLSUBENTRIES,
67 PLAYTRACK,
70 static const struct id3_to_search_mapping {
71 char *string;
72 size_t id3_offset;
73 } id3_to_search_mapping[] = {
74 { "", 0 }, /* offset n/a */
75 { "#directory#", 0 }, /* offset n/a */
76 { "#title#", offsetof(struct mp3entry, title) },
77 { "#artist#", offsetof(struct mp3entry, artist) },
78 { "#album#", offsetof(struct mp3entry, album) },
79 { "#genre#", offsetof(struct mp3entry, genre_string) },
80 { "#composer#", offsetof(struct mp3entry, composer) },
81 { "#albumartist#", offsetof(struct mp3entry, albumartist) },
83 enum variables {
84 var_sorttype = 100,
85 var_limit,
86 var_strip,
87 var_menu_start,
88 var_include,
89 var_rootmenu,
90 var_format,
91 menu_next,
92 menu_load,
95 /* Capacity 10 000 entries (for example 10k different artists) */
96 #define UNIQBUF_SIZE (64*1024)
97 static long *uniqbuf;
99 #define MAX_TAGS 5
100 #define MAX_MENU_ID_SIZE 32
102 static bool sort_inverse;
105 * "%3d. %s" autoscore title %sort = "inverse" %limit = "100"
107 * valid = true
108 * formatstr = "%-3d. %s"
109 * tags[0] = tag_autoscore
110 * tags[1] = tag_title
111 * tag_count = 2
113 * limit = 100
114 * sort_inverse = true
116 struct display_format {
117 char name[32];
118 struct tagcache_search_clause *clause[TAGCACHE_MAX_CLAUSES];
119 int clause_count;
120 char *formatstr;
121 int group_id;
122 int tags[MAX_TAGS];
123 int tag_count;
125 int limit;
126 int strip;
127 bool sort_inverse;
130 static struct display_format *formats[TAGMENU_MAX_FMTS];
131 static int format_count;
133 struct search_instruction {
134 char name[64];
135 int tagorder[MAX_TAGS];
136 int tagorder_count;
137 struct tagcache_search_clause *clause[MAX_TAGS][TAGCACHE_MAX_CLAUSES];
138 int format_id[MAX_TAGS];
139 int clause_count[MAX_TAGS];
140 int result_seek[MAX_TAGS];
143 struct menu_entry {
144 char name[64];
145 int type;
146 struct search_instruction *si;
147 int link;
150 struct menu_root {
151 char title[64];
152 char id[MAX_MENU_ID_SIZE];
153 int itemcount;
154 struct menu_entry *items[TAGMENU_MAX_ITEMS];
157 /* Statusbar text of the current view. */
158 static char current_title[MAX_TAGS][128];
160 static struct menu_root *menus[TAGMENU_MAX_MENUS];
161 static struct menu_root *menu;
162 static struct search_instruction *csi;
163 static const char *strp;
164 static int menu_count;
165 static int rootmenu;
167 static int current_offset;
168 static int current_entry_count;
170 static struct tree_context *tc;
172 static int get_token_str(char *buf, int size)
174 /* Find the start. */
175 while (*strp != '"' && *strp != '\0')
176 strp++;
178 if (*strp == '\0' || *(++strp) == '\0')
179 return -1;
181 /* Read the data. */
182 while (*strp != '"' && *strp != '\0' && --size > 0)
183 *(buf++) = *(strp++);
185 *buf = '\0';
186 if (*strp != '"')
187 return -2;
189 strp++;
191 return 0;
194 #define MATCH(tag,str1,str2,settag) \
195 if (!strcasecmp(str1, str2)) { \
196 *tag = settag; \
197 return 1; \
200 static int get_tag(int *tag)
202 char buf[128];
203 int i;
205 /* Find the start. */
206 while ((*strp == ' ' || *strp == '>') && *strp != '\0')
207 strp++;
209 if (*strp == '\0' || *strp == '?')
210 return 0;
212 for (i = 0; i < (int)sizeof(buf)-1; i++)
214 if (*strp == '\0' || *strp == ' ')
215 break ;
216 buf[i] = *strp;
217 strp++;
219 buf[i] = '\0';
221 MATCH(tag, buf, "album", tag_album);
222 MATCH(tag, buf, "artist", tag_artist);
223 MATCH(tag, buf, "bitrate", tag_bitrate);
224 MATCH(tag, buf, "composer", tag_composer);
225 MATCH(tag, buf, "comment", tag_comment);
226 MATCH(tag, buf, "albumartist", tag_albumartist);
227 MATCH(tag, buf, "ensemble", tag_albumartist);
228 MATCH(tag, buf, "grouping", tag_grouping);
229 MATCH(tag, buf, "genre", tag_genre);
230 MATCH(tag, buf, "length", tag_length);
231 MATCH(tag, buf, "Lm", tag_virt_length_min);
232 MATCH(tag, buf, "Ls", tag_virt_length_sec);
233 MATCH(tag, buf, "Pm", tag_virt_playtime_min);
234 MATCH(tag, buf, "Ps", tag_virt_playtime_sec);
235 MATCH(tag, buf, "title", tag_title);
236 MATCH(tag, buf, "filename", tag_filename);
237 MATCH(tag, buf, "tracknum", tag_tracknumber);
238 MATCH(tag, buf, "discnum", tag_discnumber);
239 MATCH(tag, buf, "year", tag_year);
240 MATCH(tag, buf, "playcount", tag_playcount);
241 MATCH(tag, buf, "rating", tag_rating);
242 MATCH(tag, buf, "lastplayed", tag_lastplayed);
243 MATCH(tag, buf, "commitid", tag_commitid);
244 MATCH(tag, buf, "entryage", tag_virt_entryage);
245 MATCH(tag, buf, "autoscore", tag_virt_autoscore);
246 MATCH(tag, buf, "%sort", var_sorttype);
247 MATCH(tag, buf, "%limit", var_limit);
248 MATCH(tag, buf, "%strip", var_strip);
249 MATCH(tag, buf, "%menu_start", var_menu_start);
250 MATCH(tag, buf, "%include", var_include);
251 MATCH(tag, buf, "%root_menu", var_rootmenu);
252 MATCH(tag, buf, "%format", var_format);
253 MATCH(tag, buf, "->", menu_next);
254 MATCH(tag, buf, "==>", menu_load);
256 logf("NO MATCH: %s\n", buf);
257 if (buf[0] == '?')
258 return 0;
260 return -1;
263 static int get_clause(int *condition)
265 char buf[4];
266 int i;
268 /* Find the start. */
269 while (*strp == ' ' && *strp != '\0')
270 strp++;
272 if (*strp == '\0')
273 return 0;
275 for (i = 0; i < (int)sizeof(buf)-1; i++)
277 if (*strp == '\0' || *strp == ' ')
278 break ;
279 buf[i] = *strp;
280 strp++;
282 buf[i] = '\0';
284 MATCH(condition, buf, "=", clause_is);
285 MATCH(condition, buf, "==", clause_is);
286 MATCH(condition, buf, "!=", clause_is_not);
287 MATCH(condition, buf, ">", clause_gt);
288 MATCH(condition, buf, ">=", clause_gteq);
289 MATCH(condition, buf, "<", clause_lt);
290 MATCH(condition, buf, "<=", clause_lteq);
291 MATCH(condition, buf, "~", clause_contains);
292 MATCH(condition, buf, "!~", clause_not_contains);
293 MATCH(condition, buf, "^", clause_begins_with);
294 MATCH(condition, buf, "!^", clause_not_begins_with);
295 MATCH(condition, buf, "$", clause_ends_with);
296 MATCH(condition, buf, "!$", clause_not_ends_with);
297 MATCH(condition, buf, "@", clause_oneof);
299 return 0;
302 static bool read_clause(struct tagcache_search_clause *clause)
304 char buf[SEARCHSTR_SIZE];
305 unsigned int i;
307 if (get_tag(&clause->tag) <= 0)
308 return false;
310 if (get_clause(&clause->type) <= 0)
311 return false;
313 if (get_token_str(buf, sizeof buf) < 0)
314 return false;
316 for (i=0; i<ARRAYLEN(id3_to_search_mapping); i++)
318 if (!strcasecmp(buf, id3_to_search_mapping[i].string))
319 break;
322 if (i<ARRAYLEN(id3_to_search_mapping)) /* runtime search operand found */
324 clause->source = source_runtime+i;
325 clause->str = buffer_alloc(SEARCHSTR_SIZE);
327 else
329 clause->source = source_constant;
330 clause->str = buffer_alloc(strlen(buf)+1);
331 strcpy(clause->str, buf);
334 if (TAGCACHE_IS_NUMERIC(clause->tag))
336 clause->numeric = true;
337 clause->numeric_data = atoi(clause->str);
339 else
340 clause->numeric = false;
342 logf("got clause: %d/%d [%s]", clause->tag, clause->type, clause->str);
344 return true;
347 static bool read_variable(char *buf, int size)
349 int condition;
351 if (!get_clause(&condition))
352 return false;
354 if (condition != clause_is)
355 return false;
357 if (get_token_str(buf, size) < 0)
358 return false;
360 return true;
363 /* "%3d. %s" autoscore title %sort = "inverse" %limit = "100" */
364 static int get_format_str(struct display_format *fmt)
366 int ret;
367 char buf[128];
368 int i;
370 memset(fmt, 0, sizeof(struct display_format));
372 if (get_token_str(fmt->name, sizeof fmt->name) < 0)
373 return -10;
375 /* Determine the group id */
376 fmt->group_id = 0;
377 for (i = 0; i < format_count; i++)
379 if (!strcasecmp(formats[i]->name, fmt->name))
381 fmt->group_id = formats[i]->group_id;
382 break;
385 if (formats[i]->group_id > fmt->group_id)
386 fmt->group_id = formats[i]->group_id;
389 if (i == format_count)
390 fmt->group_id++;
392 logf("format: (%d) %s", fmt->group_id, fmt->name);
394 if (get_token_str(buf, sizeof buf) < 0)
395 return -10;
397 fmt->formatstr = buffer_alloc(strlen(buf) + 1);
398 strcpy(fmt->formatstr, buf);
400 while (fmt->tag_count < MAX_TAGS)
402 ret = get_tag(&fmt->tags[fmt->tag_count]);
403 if (ret < 0)
404 return -11;
406 if (ret == 0)
407 break;
409 switch (fmt->tags[fmt->tag_count]) {
410 case var_sorttype:
411 if (!read_variable(buf, sizeof buf))
412 return -12;
413 if (!strcasecmp("inverse", buf))
414 fmt->sort_inverse = true;
415 break;
417 case var_limit:
418 if (!read_variable(buf, sizeof buf))
419 return -13;
420 fmt->limit = atoi(buf);
421 break;
423 case var_strip:
424 if (!read_variable(buf, sizeof buf))
425 return -14;
426 fmt->strip = atoi(buf);
427 break;
429 default:
430 fmt->tag_count++;
434 return 1;
437 static int add_format(const char *buf)
439 strp = buf;
441 if (formats[format_count] == NULL)
442 formats[format_count] = buffer_alloc(sizeof(struct display_format));
444 memset(formats[format_count], 0, sizeof(struct display_format));
445 if (get_format_str(formats[format_count]) < 0)
447 logf("get_format_str() parser failed!");
448 return -4;
451 while (*strp != '\0' && *strp != '?')
452 strp++;
454 if (*strp == '?')
456 int clause_count = 0;
457 strp++;
459 while (1)
461 if (clause_count >= TAGCACHE_MAX_CLAUSES)
463 logf("too many clauses");
464 break;
467 formats[format_count]->clause[clause_count] =
468 buffer_alloc(sizeof(struct tagcache_search_clause));
470 if (!read_clause(formats[format_count]->clause[clause_count]))
471 break;
473 clause_count++;
476 formats[format_count]->clause_count = clause_count;
479 format_count++;
481 return 1;
484 static int get_condition(struct search_instruction *inst)
486 int clause_count;
487 char buf[128];
489 switch (*strp)
491 case '=':
493 int i;
495 if (get_token_str(buf, sizeof buf) < 0)
496 return -1;
498 for (i = 0; i < format_count; i++)
500 if (!strcasecmp(formats[i]->name, buf))
501 break;
504 if (i == format_count)
506 logf("format not found: %s", buf);
507 return -2;
510 inst->format_id[inst->tagorder_count] = formats[i]->group_id;
511 return 1;
513 case '?':
514 case ' ':
515 case '&':
516 strp++;
517 return 1;
518 case '-':
519 case '\0':
520 return 0;
523 clause_count = inst->clause_count[inst->tagorder_count];
524 if (clause_count >= TAGCACHE_MAX_CLAUSES)
526 logf("Too many clauses");
527 return false;
530 inst->clause[inst->tagorder_count][clause_count] =
531 buffer_alloc(sizeof(struct tagcache_search_clause));
533 if (!read_clause(inst->clause[inst->tagorder_count][clause_count]))
534 return -1;
536 inst->clause_count[inst->tagorder_count]++;
538 return 1;
541 /* example search:
542 * "Best" artist ? year >= "2000" & title !^ "crap" & genre = "good genre" \
543 * : album ? year >= "2000" : songs
544 * ^ begins with
545 * * contains
546 * $ ends with
549 static bool parse_search(struct menu_entry *entry, const char *str)
551 int ret;
552 int type;
553 struct search_instruction *inst = entry->si;
554 char buf[MAX_PATH];
555 int i;
556 struct menu_root *new_menu;
558 strp = str;
560 /* Parse entry name */
561 if (get_token_str(entry->name, sizeof entry->name) < 0)
563 logf("No name found.");
564 return false;
567 /* Parse entry type */
568 if (get_tag(&entry->type) <= 0)
569 return false;
571 if (entry->type == menu_load)
573 if (get_token_str(buf, sizeof buf) < 0)
574 return false;
576 /* Find the matching root menu or "create" it */
577 for (i = 0; i < menu_count; i++)
579 if (!strcasecmp(menus[i]->id, buf))
581 entry->link = i;
582 return true;
586 if (menu_count >= TAGMENU_MAX_MENUS)
588 logf("max menucount reached");
589 return false;
592 /* Allocate a new menu unless link is found. */
593 menus[menu_count] = buffer_alloc(sizeof(struct menu_root));
594 new_menu = menus[menu_count];
595 memset(new_menu, 0, sizeof(struct menu_root));
596 strlcpy(new_menu->id, buf, MAX_MENU_ID_SIZE);
597 entry->link = menu_count;
598 ++menu_count;
600 return true;
603 if (entry->type != menu_next)
604 return false;
606 while (inst->tagorder_count < MAX_TAGS)
608 ret = get_tag(&inst->tagorder[inst->tagorder_count]);
609 if (ret < 0)
611 logf("Parse error #1");
612 logf("%s", strp);
613 return false;
616 if (ret == 0)
617 break ;
619 logf("tag: %d", inst->tagorder[inst->tagorder_count]);
621 while ( (ret = get_condition(inst)) > 0 ) ;
622 if (ret < 0)
623 return false;
625 inst->tagorder_count++;
627 if (get_tag(&type) <= 0 || type != menu_next)
628 break;
631 return true;
634 static int compare(const void *p1, const void *p2)
636 struct tagentry *e1 = (struct tagentry *)p1;
637 struct tagentry *e2 = (struct tagentry *)p2;
639 if (sort_inverse)
640 return strncasecmp(e2->name, e1->name, MAX_PATH);
642 return strncasecmp(e1->name, e2->name, MAX_PATH);
645 static void tagtree_buffer_event(struct mp3entry *id3)
647 struct tagcache_search tcs;
649 /* Do not gather data unless proper setting has been enabled. */
650 if (!global_settings.runtimedb)
651 return;
653 logf("be:%s", id3->path);
655 if (!tagcache_find_index(&tcs, id3->path))
657 logf("tc stat: not found: %s", id3->path);
658 return;
661 id3->playcount = tagcache_get_numeric(&tcs, tag_playcount);
662 if (!id3->rating)
663 id3->rating = tagcache_get_numeric(&tcs, tag_rating);
664 id3->lastplayed = tagcache_get_numeric(&tcs, tag_lastplayed);
665 id3->score = tagcache_get_numeric(&tcs, tag_virt_autoscore) / 10;
666 id3->playtime = tagcache_get_numeric(&tcs, tag_playtime);
668 /* Store our tagcache index pointer. */
669 id3->tagcache_idx = tcs.idx_id+1;
671 tagcache_search_finish(&tcs);
674 static void tagtree_track_finish_event(struct mp3entry *id3)
676 long playcount;
677 long playtime;
678 long lastplayed;
679 long tagcache_idx;
681 /* Do not gather data unless proper setting has been enabled. */
682 if (!global_settings.runtimedb)
684 logf("runtimedb gathering not enabled");
685 return;
688 tagcache_idx=id3->tagcache_idx;
689 if (!tagcache_idx)
691 logf("No tagcache index pointer found");
692 return;
694 tagcache_idx--;
696 /* Don't process unplayed tracks. */
697 if (id3->elapsed == 0)
699 logf("not logging unplayed track");
700 return;
703 playcount = id3->playcount + 1;
704 lastplayed = tagcache_increase_serial();
705 if (lastplayed < 0)
707 logf("incorrect tc serial:%ld", lastplayed);
708 return;
711 /* Ignore the last 15s (crossfade etc.) */
712 playtime = id3->playtime + MIN(id3->length, id3->elapsed + 15 * 1000);
714 logf("ube:%s", id3->path);
715 logf("-> %ld/%ld", playcount, playtime);
716 logf("-> %ld/%ld/%ld", id3->elapsed, id3->length, MIN(id3->length, id3->elapsed + 15 * 1000));
718 /* Queue the updates to the tagcache system. */
719 tagcache_update_numeric(tagcache_idx, tag_playcount, playcount);
720 tagcache_update_numeric(tagcache_idx, tag_playtime, playtime);
721 tagcache_update_numeric(tagcache_idx, tag_lastplayed, lastplayed);
724 bool tagtree_export(void)
726 struct tagcache_search tcs;
728 splash(0, str(LANG_CREATING));
729 if (!tagcache_create_changelog(&tcs))
731 splash(HZ*2, ID2P(LANG_FAILED));
734 return false;
737 bool tagtree_import(void)
739 splash(0, ID2P(LANG_WAIT));
740 if (!tagcache_import_changelog())
742 splash(HZ*2, ID2P(LANG_FAILED));
745 return false;
748 static bool parse_menu(const char *filename);
750 static int parse_line(int n, const char *buf, void *parameters)
752 char data[256];
753 int variable;
754 static bool read_menu;
755 int i;
757 (void)parameters;
759 logf("parse:%d/%s", n, buf);
761 /* First line, do initialisation. */
762 if (n == 0)
764 if (strcasecmp(TAGNAVI_VERSION, buf))
766 logf("Version mismatch");
767 return -1;
770 read_menu = false;
773 if (buf[0] == '#')
774 return 0;
776 if (buf[0] == '\0')
778 if (read_menu)
780 /* End the menu */
781 read_menu = false;
783 return 0;
786 if (!read_menu)
788 strp = buf;
789 if (get_tag(&variable) <= 0)
790 return 0;
792 switch (variable)
794 case var_format:
795 if (add_format(strp) < 0)
797 logf("Format add fail: %s", data);
799 break;
801 case var_include:
802 if (get_token_str(data, sizeof(data)) < 0)
804 logf("%%include empty");
805 return 0;
808 if (!parse_menu(data))
810 logf("Load menu fail: %s", data);
812 break;
814 case var_menu_start:
815 if (menu_count >= TAGMENU_MAX_MENUS)
817 logf("max menucount reached");
818 return 0;
821 if (get_token_str(data, sizeof data) < 0)
823 logf("%%menu_start id empty");
824 return 0;
827 menu = NULL;
828 for (i = 0; i < menu_count; i++)
830 if (!strcasecmp(menus[i]->id, data))
832 menu = menus[i];
836 if (menu == NULL)
838 menus[menu_count] = buffer_alloc(sizeof(struct menu_root));
839 menu = menus[menu_count];
840 ++menu_count;
841 memset(menu, 0, sizeof(struct menu_root));
842 strlcpy(menu->id, data, MAX_MENU_ID_SIZE);
845 if (get_token_str(menu->title, sizeof(menu->title)) < 0)
847 logf("%%menu_start title empty");
848 return 0;
850 logf("menu: %s", menu->title);
851 read_menu = true;
852 break;
854 case var_rootmenu:
855 /* Only set root menu once. */
856 if (rootmenu >= 0)
857 break;
859 if (get_token_str(data, sizeof(data)) < 0)
861 logf("%%rootmenu empty");
862 return 0;
865 for (i = 0; i < menu_count; i++)
867 if (!strcasecmp(menus[i]->id, data))
869 rootmenu = i;
872 break;
875 return 0;
878 if (menu->itemcount >= TAGMENU_MAX_ITEMS)
880 logf("max itemcount reached");
881 return 0;
884 /* Allocate */
885 if (menu->items[menu->itemcount] == NULL)
887 menu->items[menu->itemcount] = buffer_alloc(sizeof(struct menu_entry));
888 memset(menu->items[menu->itemcount], 0, sizeof(struct menu_entry));
889 menu->items[menu->itemcount]->si = buffer_alloc(sizeof(struct search_instruction));
892 memset(menu->items[menu->itemcount]->si, 0, sizeof(struct search_instruction));
893 if (!parse_search(menu->items[menu->itemcount], buf))
894 return 0;
896 menu->itemcount++;
898 return 0;
901 static bool parse_menu(const char *filename)
903 int fd;
904 char buf[1024];
906 if (menu_count >= TAGMENU_MAX_MENUS)
908 logf("max menucount reached");
909 return false;
912 fd = open(filename, O_RDONLY);
913 if (fd < 0)
915 logf("Search instruction file not found.");
916 return false;
919 /* Now read file for real, parsing into si */
920 fast_readline(fd, buf, sizeof buf, NULL, parse_line);
921 close(fd);
923 return true;
926 void tagtree_init(void)
928 format_count = 0;
929 menu_count = 0;
930 menu = NULL;
931 rootmenu = -1;
932 parse_menu(FILE_SEARCH_INSTRUCTIONS);
934 /* If no root menu is set, assume it's the first single menu
935 * we have. That shouldn't normally happen. */
936 if (rootmenu < 0)
937 rootmenu = 0;
939 uniqbuf = buffer_alloc(UNIQBUF_SIZE);
941 add_event(PLAYBACK_EVENT_TRACK_BUFFER, false, tagtree_buffer_event);
942 add_event(PLAYBACK_EVENT_TRACK_FINISH, false, tagtree_track_finish_event);
945 static bool show_search_progress(bool init, int count)
947 static int last_tick = 0;
949 /* Don't show splashes for 1/2 second after starting search */
950 if (init)
952 last_tick = current_tick + HZ/2;
953 return true;
956 /* Update progress every 1/10 of a second */
957 if (current_tick - last_tick > HZ/10)
959 splashf(0, str(LANG_PLAYLIST_SEARCH_MSG), count, str(LANG_OFF_ABORT));
960 if (action_userabort(TIMEOUT_NOBLOCK))
961 return false;
962 last_tick = current_tick;
963 yield();
966 return true;
969 static int format_str(struct tagcache_search *tcs, struct display_format *fmt,
970 char *buf, int buf_size)
972 char fmtbuf[8];
973 bool read_format = false;
974 int fmtbuf_pos = 0;
975 int parpos = 0;
976 int buf_pos = 0;
977 int i;
979 memset(buf, 0, buf_size);
980 for (i = 0; fmt->formatstr[i] != '\0'; i++)
982 if (fmt->formatstr[i] == '%')
984 read_format = true;
985 fmtbuf_pos = 0;
986 if (parpos >= fmt->tag_count)
988 logf("too many format tags");
989 return -1;
993 if (read_format)
995 fmtbuf[fmtbuf_pos++] = fmt->formatstr[i];
996 if (fmtbuf_pos >= buf_size)
998 logf("format parse error");
999 return -2;
1002 if (fmt->formatstr[i] == 's')
1004 fmtbuf[fmtbuf_pos] = '\0';
1005 read_format = false;
1006 if (fmt->tags[parpos] == tcs->type)
1008 snprintf(&buf[buf_pos], buf_size - buf_pos, fmtbuf, tcs->result);
1010 else
1012 /* Need to fetch the tag data. */
1013 if (!tagcache_retrieve(tcs, tcs->idx_id, fmt->tags[parpos],
1014 &buf[buf_pos], buf_size - buf_pos))
1016 logf("retrieve failed");
1017 return -3;
1020 buf_pos += strlen(&buf[buf_pos]);
1021 parpos++;
1023 else if (fmt->formatstr[i] == 'd')
1025 fmtbuf[fmtbuf_pos] = '\0';
1026 read_format = false;
1027 snprintf(&buf[buf_pos], buf_size - buf_pos, fmtbuf,
1028 tagcache_get_numeric(tcs, fmt->tags[parpos]));
1029 buf_pos += strlen(&buf[buf_pos]);
1030 parpos++;
1032 continue;
1035 buf[buf_pos++] = fmt->formatstr[i];
1037 if (buf_pos - 1 >= buf_size)
1039 logf("buffer overflow");
1040 return -4;
1044 buf[buf_pos++] = '\0';
1046 return 0;
1049 static int retrieve_entries(struct tree_context *c, int offset, bool init)
1051 struct tagcache_search tcs;
1052 struct tagentry *dptr = (struct tagentry *)c->dircache;
1053 struct display_format *fmt;
1054 int i;
1055 int namebufused = 0;
1056 int total_count = 0;
1057 int special_entry_count = 0;
1058 int level = c->currextra;
1059 int tag;
1060 bool sort = false;
1061 int sort_limit;
1062 int strip;
1064 if (init && (tagcache_is_busy()
1065 #ifdef HAVE_TC_RAMCACHE
1066 || !tagcache_is_ramcache()
1067 #endif
1070 /* Show search progress straight away if the disk needs to spin up,
1071 otherwise show it after the normal 1/2 second delay */
1072 show_search_progress(
1073 !tagcache_is_busy() &&
1074 #ifdef HAVE_DISK_STORAGE
1075 storage_disk_is_active()
1076 #else
1077 true
1078 #endif
1079 , 0);
1082 if (c->currtable == ALLSUBENTRIES)
1084 tag = tag_title;
1085 level--;
1087 else
1088 tag = csi->tagorder[level];
1090 if (!tagcache_search(&tcs, tag))
1091 return -1;
1093 /* Prevent duplicate entries in the search list. */
1094 tagcache_search_set_uniqbuf(&tcs, uniqbuf, UNIQBUF_SIZE);
1096 if (level || csi->clause_count[0] || TAGCACHE_IS_NUMERIC(tag))
1097 sort = true;
1099 for (i = 0; i < level; i++)
1101 if (TAGCACHE_IS_NUMERIC(csi->tagorder[i]))
1103 static struct tagcache_search_clause cc;
1105 memset(&cc, 0, sizeof(struct tagcache_search_clause));
1106 cc.tag = csi->tagorder[i];
1107 cc.type = clause_is;
1108 cc.numeric = true;
1109 cc.numeric_data = csi->result_seek[i];
1110 tagcache_search_add_clause(&tcs, &cc);
1112 else
1114 tagcache_search_add_filter(&tcs, csi->tagorder[i],
1115 csi->result_seek[i]);
1119 for (i = 0; i <= level; i++)
1121 int j;
1123 for (j = 0; j < csi->clause_count[i]; j++)
1124 tagcache_search_add_clause(&tcs, csi->clause[i][j]);
1127 current_offset = offset;
1128 current_entry_count = 0;
1129 c->dirfull = false;
1131 fmt = NULL;
1132 for (i = 0; i < format_count; i++)
1134 if (formats[i]->group_id == csi->format_id[level])
1135 fmt = formats[i];
1138 if (fmt)
1140 sort_inverse = fmt->sort_inverse;
1141 sort_limit = fmt->limit;
1142 strip = fmt->strip;
1143 sort = true;
1145 else
1147 sort_inverse = false;
1148 sort_limit = 0;
1149 strip = 0;
1152 if (tag != tag_title && tag != tag_filename)
1154 if (offset == 0)
1156 dptr->newtable = ALLSUBENTRIES;
1157 dptr->name = str(LANG_TAGNAVI_ALL_TRACKS);
1158 dptr++;
1159 current_entry_count++;
1161 if (offset <= 1)
1163 dptr->newtable = NAVIBROWSE;
1164 dptr->name = str(LANG_TAGNAVI_RANDOM);
1165 dptr->extraseek = -1;
1166 dptr++;
1167 current_entry_count++;
1169 special_entry_count+=2;
1172 total_count += special_entry_count;
1174 while (tagcache_get_next(&tcs))
1176 if (total_count++ < offset)
1177 continue;
1179 dptr->newtable = NAVIBROWSE;
1180 if (tag == tag_title || tag == tag_filename)
1182 dptr->newtable = PLAYTRACK;
1183 dptr->extraseek = tcs.idx_id;
1185 else
1186 dptr->extraseek = tcs.result_seek;
1188 fmt = NULL;
1189 /* Check the format */
1190 for (i = 0; i < format_count; i++)
1192 if (formats[i]->group_id != csi->format_id[level])
1193 continue;
1195 if (tagcache_check_clauses(&tcs, formats[i]->clause,
1196 formats[i]->clause_count))
1198 fmt = formats[i];
1199 break;
1203 if (!tcs.ramresult || fmt)
1205 char buf[MAX_PATH];
1207 if (fmt)
1209 if (format_str(&tcs, fmt, buf, sizeof buf) < 0)
1211 logf("format_str() failed");
1212 tagcache_search_finish(&tcs);
1213 return 0;
1217 dptr->name = &c->name_buffer[namebufused];
1218 if (fmt)
1219 namebufused += strlen(buf)+1;
1220 else
1221 namebufused += tcs.result_len;
1223 if (namebufused >= c->name_buffer_size)
1225 logf("chunk mode #2: %d", current_entry_count);
1226 c->dirfull = true;
1227 sort = false;
1228 break ;
1230 if (fmt)
1231 strcpy(dptr->name, buf);
1232 else
1233 strcpy(dptr->name, tcs.result);
1235 else
1236 dptr->name = tcs.result;
1238 dptr++;
1239 current_entry_count++;
1241 if (current_entry_count >= global_settings.max_files_in_dir)
1243 logf("chunk mode #3: %d", current_entry_count);
1244 c->dirfull = true;
1245 sort = false;
1246 break ;
1249 if (init && !tcs.ramsearch)
1251 if (!show_search_progress(false, total_count))
1253 tagcache_search_finish(&tcs);
1254 return current_entry_count;
1259 if (sort)
1260 qsort(c->dircache + special_entry_count * c->dentry_size,
1261 current_entry_count - special_entry_count,
1262 c->dentry_size, compare);
1264 if (!init)
1266 tagcache_search_finish(&tcs);
1267 return current_entry_count;
1270 while (tagcache_get_next(&tcs))
1272 if (!tcs.ramsearch)
1274 if (!show_search_progress(false, total_count))
1275 break;
1277 total_count++;
1280 tagcache_search_finish(&tcs);
1282 if (!sort && (sort_inverse || sort_limit))
1284 splashf(HZ*4, ID2P(LANG_SHOWDIR_BUFFER_FULL), total_count);
1285 logf("Too small dir buffer");
1286 return 0;
1289 if (sort_limit)
1290 total_count = MIN(total_count, sort_limit);
1292 if (strip)
1294 dptr = c->dircache;
1295 for (i = 0; i < total_count; i++, dptr++)
1297 int len = strlen(dptr->name);
1299 if (len < strip)
1300 continue;
1302 dptr->name = &dptr->name[strip];
1306 return total_count;
1309 static int load_root(struct tree_context *c)
1311 struct tagentry *dptr = (struct tagentry *)c->dircache;
1312 int i;
1314 tc = c;
1315 c->currtable = ROOT;
1316 if (c->dirlevel == 0)
1317 c->currextra = rootmenu;
1319 menu = menus[c->currextra];
1320 if (menu == NULL)
1321 return 0;
1323 for (i = 0; i < menu->itemcount; i++)
1325 dptr->name = menu->items[i]->name;
1326 switch (menu->items[i]->type)
1328 case menu_next:
1329 dptr->newtable = NAVIBROWSE;
1330 dptr->extraseek = i;
1331 break;
1333 case menu_load:
1334 dptr->newtable = ROOT;
1335 dptr->extraseek = menu->items[i]->link;
1336 break;
1339 dptr++;
1342 current_offset = 0;
1343 current_entry_count = i;
1345 return i;
1348 int tagtree_load(struct tree_context* c)
1350 int count;
1351 int table = c->currtable;
1353 c->dentry_size = sizeof(struct tagentry);
1354 c->dirsindir = 0;
1356 if (!table)
1358 c->dirfull = false;
1359 table = ROOT;
1360 c->currtable = table;
1361 c->currextra = rootmenu;
1364 switch (table)
1366 case ROOT:
1367 count = load_root(c);
1368 break;
1370 case ALLSUBENTRIES:
1371 case NAVIBROWSE:
1372 logf("navibrowse...");
1373 cpu_boost(true);
1374 count = retrieve_entries(c, 0, true);
1375 cpu_boost(false);
1376 break;
1378 default:
1379 logf("Unsupported table %d\n", table);
1380 return -1;
1383 if (count < 0)
1385 c->dirlevel = 0;
1386 count = load_root(c);
1387 splash(HZ, str(LANG_TAGCACHE_BUSY));
1390 /* The _total_ numer of entries available. */
1391 c->dirlength = c->filesindir = count;
1393 return count;
1396 int tagtree_enter(struct tree_context* c)
1398 int rc = 0;
1399 struct tagentry *dptr;
1400 struct mp3entry *id3;
1401 int newextra;
1402 int seek;
1403 int source;
1405 dptr = tagtree_get_entry(c, c->selected_item);
1407 c->dirfull = false;
1408 seek = dptr->extraseek;
1409 if (seek == -1)
1411 if(c->filesindir<=2)
1412 return 0;
1413 srand(current_tick);
1414 dptr = (tagtree_get_entry(c, 2+(rand() % (c->filesindir-2))));
1415 seek = dptr->extraseek;
1417 newextra = dptr->newtable;
1419 if (c->dirlevel >= MAX_DIR_LEVELS)
1420 return 0;
1422 c->selected_item_history[c->dirlevel]=c->selected_item;
1423 c->table_history[c->dirlevel] = c->currtable;
1424 c->extra_history[c->dirlevel] = c->currextra;
1425 c->pos_history[c->dirlevel] = c->firstpos;
1426 c->dirlevel++;
1428 switch (c->currtable) {
1429 case ROOT:
1430 c->currextra = newextra;
1432 if (newextra == ROOT)
1434 menu = menus[seek];
1435 c->currextra = seek;
1438 else if (newextra == NAVIBROWSE)
1440 int i, j;
1442 csi = menu->items[seek]->si;
1443 c->currextra = 0;
1445 strlcpy(current_title[c->currextra], dptr->name,
1446 sizeof(current_title[0]));
1448 /* Read input as necessary. */
1449 for (i = 0; i < csi->tagorder_count; i++)
1451 for (j = 0; j < csi->clause_count[i]; j++)
1453 char* searchstring;
1454 source = csi->clause[i][j]->source;
1456 if (source == source_constant)
1457 continue;
1459 searchstring=csi->clause[i][j]->str;
1460 *searchstring = '\0';
1462 id3 = audio_current_track();
1464 if (source == source_current_path && id3)
1466 char *e;
1467 strlcpy(searchstring, id3->path, SEARCHSTR_SIZE);
1468 e = strrchr(searchstring, '/');
1469 if (e)
1470 *e = '\0';
1472 else if (source > source_runtime && id3)
1475 int k = source-source_runtime;
1476 int offset = id3_to_search_mapping[k].id3_offset;
1477 char **src = (char**)((char*)id3 + offset);
1478 if (*src)
1480 strlcpy(searchstring, *src, SEARCHSTR_SIZE);
1483 else
1485 rc = kbd_input(searchstring, SEARCHSTR_SIZE);
1486 if (rc < 0 || !searchstring[0])
1488 tagtree_exit(c);
1489 return 0;
1491 if (csi->clause[i][j]->numeric)
1492 csi->clause[i][j]->numeric_data = atoi(searchstring);
1499 c->currtable = newextra;
1501 break;
1503 case NAVIBROWSE:
1504 case ALLSUBENTRIES:
1505 if (newextra == PLAYTRACK)
1507 if (global_settings.party_mode && audio_status()) {
1508 splash(HZ, ID2P(LANG_PARTY_MODE));
1509 break;
1511 c->dirlevel--;
1512 /* about to create a new current playlist...
1513 allow user to cancel the operation */
1514 if (!warn_on_pl_erase())
1515 break;
1517 if (tagtree_play_folder(c) >= 0)
1518 rc = 2;
1519 break;
1522 c->currtable = newextra;
1523 csi->result_seek[c->currextra] = seek;
1524 if (c->currextra < csi->tagorder_count-1)
1525 c->currextra++;
1526 else
1527 c->dirlevel--;
1529 /* Update the statusbar title */
1530 strlcpy(current_title[c->currextra], dptr->name,
1531 sizeof(current_title[0]));
1532 break;
1534 default:
1535 c->dirlevel--;
1536 break;
1539 c->selected_item=0;
1540 gui_synclist_select_item(&tree_lists, c->selected_item);
1542 return rc;
1545 void tagtree_exit(struct tree_context* c)
1547 c->dirfull = false;
1548 if (c->dirlevel > 0)
1549 c->dirlevel--;
1550 c->selected_item=c->selected_item_history[c->dirlevel];
1551 gui_synclist_select_item(&tree_lists, c->selected_item);
1552 c->currtable = c->table_history[c->dirlevel];
1553 c->currextra = c->extra_history[c->dirlevel];
1554 c->firstpos = c->pos_history[c->dirlevel];
1557 int tagtree_get_filename(struct tree_context* c, char *buf, int buflen)
1559 struct tagcache_search tcs;
1560 struct tagentry *entry;
1562 entry = tagtree_get_entry(c, c->selected_item);
1564 if (!tagcache_search(&tcs, tag_filename))
1565 return -1;
1567 if (!tagcache_retrieve(&tcs, entry->extraseek, tcs.type, buf, buflen))
1569 tagcache_search_finish(&tcs);
1570 return -2;
1573 tagcache_search_finish(&tcs);
1575 return 0;
1578 static bool insert_all_playlist(struct tree_context *c, int position, bool queue)
1580 struct tagcache_search tcs;
1581 int i;
1582 char buf[MAX_PATH];
1583 int from, to, direction;
1584 int files_left = c->filesindir;
1586 cpu_boost(true);
1587 if (!tagcache_search(&tcs, tag_filename))
1589 splash(HZ, ID2P(LANG_TAGCACHE_BUSY));
1590 cpu_boost(false);
1591 return false;
1594 if (position == PLAYLIST_REPLACE)
1596 if (playlist_remove_all_tracks(NULL) == 0)
1597 position = PLAYLIST_INSERT_LAST;
1598 else
1600 cpu_boost(false);
1601 return false;
1605 if (position == PLAYLIST_INSERT_FIRST)
1607 from = c->filesindir - 1;
1608 to = -1;
1609 direction = -1;
1611 else
1613 from = 0;
1614 to = c->filesindir;
1615 direction = 1;
1618 for (i = from; i != to; i += direction)
1620 /* Count back to zero */
1621 if (!show_search_progress(false, files_left--))
1622 break;
1624 if (!tagcache_retrieve(&tcs, tagtree_get_entry(c, i)->extraseek,
1625 tcs.type, buf, sizeof buf))
1627 continue;
1630 if (playlist_insert_track(NULL, buf, position, queue, false) < 0)
1632 logf("playlist_insert_track failed");
1633 break;
1635 yield();
1637 playlist_sync(NULL);
1638 tagcache_search_finish(&tcs);
1639 cpu_boost(false);
1641 return true;
1644 bool tagtree_insert_selection_playlist(int position, bool queue)
1646 struct tagentry *dptr;
1647 char buf[MAX_PATH];
1648 int dirlevel = tc->dirlevel;
1650 /* We need to set the table to allsubentries. */
1651 show_search_progress(!tagcache_is_busy(), 0);
1653 dptr = tagtree_get_entry(tc, tc->selected_item);
1655 /* Insert a single track? */
1656 if (dptr->newtable == PLAYTRACK)
1658 if (tagtree_get_filename(tc, buf, sizeof buf) < 0)
1660 logf("tagtree_get_filename failed");
1661 return false;
1663 playlist_insert_track(NULL, buf, position, queue, true);
1665 return true;
1668 if (dptr->newtable == NAVIBROWSE)
1670 tagtree_enter(tc);
1671 tagtree_load(tc);
1672 dptr = tagtree_get_entry(tc, tc->selected_item);
1674 else if (dptr->newtable != ALLSUBENTRIES)
1676 logf("unsupported table: %d", dptr->newtable);
1677 return false;
1680 /* Now the current table should be allsubentries. */
1681 if (dptr->newtable != PLAYTRACK)
1683 tagtree_enter(tc);
1684 tagtree_load(tc);
1685 dptr = tagtree_get_entry(tc, tc->selected_item);
1687 /* And now the newtable should be playtrack. */
1688 if (dptr->newtable != PLAYTRACK)
1690 logf("newtable: %d !!", dptr->newtable);
1691 tc->dirlevel = dirlevel;
1692 return false;
1696 if (tc->filesindir <= 0)
1697 splash(HZ, ID2P(LANG_END_PLAYLIST));
1698 else
1700 logf("insert_all_playlist");
1701 if (!insert_all_playlist(tc, position, queue))
1702 splash(HZ*2, ID2P(LANG_FAILED));
1705 /* Finally return the dirlevel to its original value. */
1706 while (tc->dirlevel > dirlevel)
1707 tagtree_exit(tc);
1708 tagtree_load(tc);
1710 return true;
1713 static int tagtree_play_folder(struct tree_context* c)
1715 if (playlist_create(NULL, NULL) < 0)
1717 logf("Failed creating playlist\n");
1718 return -1;
1721 if (!insert_all_playlist(c, PLAYLIST_INSERT_LAST, false))
1722 return -2;
1724 if (global_settings.playlist_shuffle)
1725 c->selected_item = playlist_shuffle(current_tick, c->selected_item);
1726 if (!global_settings.play_selected)
1727 c->selected_item = 0;
1728 gui_synclist_select_item(&tree_lists, c->selected_item);
1730 playlist_start(c->selected_item,0);
1732 return 0;
1735 struct tagentry* tagtree_get_entry(struct tree_context *c, int id)
1737 struct tagentry *entry = (struct tagentry *)c->dircache;
1738 int realid = id - current_offset;
1740 /* Load the next chunk if necessary. */
1741 if (realid >= current_entry_count || realid < 0)
1743 cpu_boost(true);
1744 if (retrieve_entries(c, MAX(0, id - (current_entry_count / 2)),
1745 false) < 0)
1747 logf("retrieve failed");
1748 cpu_boost(false);
1749 return NULL;
1751 realid = id - current_offset;
1752 cpu_boost(false);
1755 return &entry[realid];
1758 char *tagtree_get_title(struct tree_context* c)
1760 switch (c->currtable)
1762 case ROOT:
1763 return menu->title;
1765 case NAVIBROWSE:
1766 case ALLSUBENTRIES:
1767 return current_title[c->currextra];
1770 return "?";
1773 int tagtree_get_attr(struct tree_context* c)
1775 int attr = -1;
1776 switch (c->currtable)
1778 case NAVIBROWSE:
1779 if (csi->tagorder[c->currextra] == tag_title)
1780 attr = FILE_ATTR_AUDIO;
1781 else
1782 attr = ATTR_DIRECTORY;
1783 break;
1785 case ALLSUBENTRIES:
1786 attr = FILE_ATTR_AUDIO;
1787 break;
1789 default:
1790 attr = ATTR_DIRECTORY;
1791 break;
1794 return attr;
1797 int tagtree_get_icon(struct tree_context* c)
1799 int icon = Icon_Folder;
1801 if (tagtree_get_attr(c) == FILE_ATTR_AUDIO)
1802 icon = Icon_Audio;
1804 return icon;