?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
We have a 3.9 release, update builds.pm
[maemo-rb.git] / apps / plugins / lrcplayer.c
bloba124863cc3ccce2febf6378a0a0cfea2dc92bd38
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (C) 2008-2009 Teruaki Kawashima
11 *
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.
16 *
17 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
18 * KIND, either express or implied.
19 *
20 ****************************************************************************/
21 #include "plugin.h"
22 #include "lib/playback_control.h"
23 #include "lib/configfile.h"
24 #include "lib/helper.h"
25 #include <ctype.h>
26
27
28
29 #define MAX_LINE_LEN 256
30 #define LRC_BUFFER_SIZE 0x3000 /* 12 kiB */
31 #if PLUGIN_BUFFER_SIZE >= 0x10000 /* no id3 support for low mem targets */
32 /* define this to read lyrics in id3 tag */
33 #define LRC_SUPPORT_ID3
34 #endif
35 /* define this to show debug info in menu */
36 /* #define LRC_DEBUG */
37
38 enum lrc_screen {
39 PLUGIN_OTHER = 0x200,
40 LRC_GOTO_MAIN,
41 LRC_GOTO_MENU,
42 LRC_GOTO_EDITOR,
43 };
44
45 struct lrc_word {
46 long time_start;
47 short count;
48 short width;
49 unsigned char *word;
50 };
51
52 struct lrc_brpos {
53 short count;
54 short width;
55 };
56
57 struct lrc_line {
58 long time_start;
59 long old_time_start;
60 off_t file_offset; /* offset of time tag in file */
61 short nword;
62 short width;
63 short nline[NB_SCREENS];
64 struct lrc_line *next;
65 struct lrc_word *words;
66 };
67
68 struct preferences {
69 /* display settings */
70 #if LCD_DEPTH > 1
71 unsigned active_color;
72 unsigned inactive_color;
73 #endif
74 #ifdef HAVE_LCD_BITMAP
75 bool wrap;
76 bool wipe;
77 bool active_one_line;
78 int align; /* 0: left, 1: center, 2: right */
79 bool statusbar_on;
80 bool display_title;
81 #endif
82 bool display_time;
83 bool backlight_on;
84
85 /* file settings */
86 char lrc_directory[64];
87 int encoding;
88 #ifdef LRC_SUPPORT_ID3
89 bool read_id3;
90 #endif
91 };
92
93 static struct preferences prefs, old_prefs;
94 static unsigned char *lrc_buffer;
95 static size_t lrc_buffer_size;
96 static size_t lrc_buffer_used, lrc_buffer_end;
97 enum extention_types {LRC, LRC8, SNC, TXT, NUM_TYPES, ID3_SYLT, ID3_USLT};
98 static const char *extentions[NUM_TYPES] = {
99 ".lrc", ".lrc8", ".snc", ".txt",
100 };
101 static struct lrc_info {
102 struct mp3entry *id3;
103 long elapsed;
104 long length;
105 long ff_rewind;
106 int audio_status;
107 char mp3_file[MAX_PATH];
108 char lrc_file[MAX_PATH];
109 char *title; /* use lrc_buffer */
110 char *artist; /* use lrc_buffer */
111 enum extention_types type;
112 long offset; /* msec */
113 off_t offset_file_offset; /* offset of offset tag in file */
114 int nlrcbrpos;
115 int nlrcline;
116 struct lrc_line *ll_head, **ll_tail;
117 bool found_lrc;
118 bool loaded_lrc;
119 bool changed_lrc;
120 bool too_many_lines; /* true if nlrcline >= max_lrclines after calc pos */
121 #ifdef HAVE_LCD_BITMAP
122 bool wipe; /* false if lyrics is unsynched */
123 #endif
124 } current;
125 static char temp_buf[MAX(MAX_LINE_LEN,MAX_PATH)];
126 #ifdef HAVE_LCD_BITMAP
127 static int font_ui_height = 1;
128 static struct viewport vp_info[NB_SCREENS];
129 #endif
130 static struct viewport vp_lyrics[NB_SCREENS];
131
132 #define AUDIO_PAUSE (current.audio_status & AUDIO_STATUS_PAUSE)
133 #define AUDIO_PLAY (current.audio_status & AUDIO_STATUS_PLAY)
134 #define AUDIO_STOP (!(current.audio_status & AUDIO_STATUS_PLAY))
135
136 /*******************************
137 * lrc_set_time
138 *******************************/
139 #define LST_SET_MSEC 0x00010000
140 #define LST_SET_SEC 0x00020000
141 #define LST_SET_MIN 0x00040000
142 #define LST_SET_HOUR 0x00080000
143
144 #include "lib/pluginlib_actions.h"
145 #define LST_SET_TIME (LST_SET_MSEC|LST_SET_SEC|LST_SET_MIN|LST_SET_HOUR)
146 #ifdef HAVE_LCD_CHARCELLS
147 #define LST_OFF_Y 0
148 #else /* HAVE_LCD_BITMAP */
149 #define LST_OFF_Y 1
150 #endif
151 int lrc_set_time(const char *title, const char *unit, long *pval,
152 int step, int min, int max, int flags)
153 {
154 const struct button_mapping *lst_contexts[] = {
155 pla_main_ctx,
156 #ifdef HAVE_REMOTE_LCD
157 pla_remote_ctx,
158 #endif
159 };
160 /* how many */
161 const unsigned char formats[4][8] = {"%03ld.", "%02ld.", "%02ld:", "%02ld:"};
162 const unsigned int maxs[4] = {1000, 60, 60, 24};
163 const unsigned int scls[4] = {1, 1000, 60*1000, 60*60*1000};
164 char buffer[32];
165 long value = *pval, scl_step = step, i = 0;
166 int pos = 0, last_pos = 0, pos_min = 3, pos_max = 0;
167 int x = 0, y = 0, p_start = 0, p_end = 0;
168 int ret = 10;
169
170 if (!(flags&LST_SET_TIME))
171 return -1;
172
173 for (i = 0; i < 4; i++)
174 {
175 if (flags&(LST_SET_MSEC<<i))
176 {
177 if (pos_min > i) pos_min = i;
178 if (pos_max < i) pos_max = i;
179 }
180 }
181 pos = pos_min;
182
183 rb->button_clear_queue();
184 rb->lcd_clear_display();
185 rb->lcd_puts_scroll(0, LST_OFF_Y, title);
186 while (ret == 10)
187 {
188 int len = 0;
189 long abs_val = value;
190 long segvals[4] = {-1, -1, -1, -1};
191 /* show negative value like -00:01 but 00:-1 */
192 if (value < 0)
193 {
194 buffer[len++] = '-';
195 abs_val = -value;
196 }
197 buffer[len] = 0;
198 /* calc value of each segments */
199 for (i = pos_min; i <= pos_max; i++)
200 {
201 segvals[i] = abs_val % maxs[i];
202 abs_val /= maxs[i];
203 }
204 segvals[i-1] += abs_val * maxs[i-1];
205 for (i = pos_max; i >= pos_min; i--)
206 {
207 if (pos == i)
208 {
209 rb->lcd_getstringsize(buffer, &x, &y);
210 p_start = len;
211 }
212 rb->snprintf(&buffer[len], 32-len, formats[i], segvals[i]);
213 len += rb->strlen(&buffer[len]);
214 if (pos == i)
215 p_end = len;
216 }
217 buffer[len-1] = 0; /* remove last separater */
218 if (unit != NULL)
219 {
220 rb->snprintf(&buffer[len], 32-len, " (%s)", unit);
221 }
222 rb->lcd_puts(0, LST_OFF_Y+1, buffer);
223 if (pos_min != pos_max)
224 {
225 /* draw cursor */
226 buffer[p_end-1] = 0;
227 #ifdef HAVE_LCD_BITMAP
228 rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
229 rb->lcd_putsxy(x, y*(1+LST_OFF_Y), &buffer[p_start]);
230 rb->lcd_set_drawmode(DRMODE_SOLID);
231 #else
232 rb->lcd_put_cursor(x+rb->utf8length(&buffer[p_start])-1, y, 0x7F);
233 #endif
234 }
235 rb->lcd_update();
236 int button = pluginlib_getaction(TIMEOUT_BLOCK, lst_contexts, ARRAYLEN(lst_contexts));
237 int mult = 1;
238 #ifdef HAVE_LCD_CHARCELLS
239 if (pos_min != pos_max)
240 rb->lcd_remove_cursor();
241 #endif
242 switch (button)
243 {
244 case PLA_UP_REPEAT:
245 case PLA_DOWN_REPEAT:
246 mult *= 10;
247 case PLA_DOWN:
248 case PLA_UP:
249 if (button == PLA_DOWN_REPEAT || button == PLA_DOWN)
250 mult *= -1;
251 if (pos != last_pos)
252 {
253 scl_step = ((scls[pos]/scls[pos_min]+step-1)/step) * step;
254 last_pos = pos;
255 }
256 value += scl_step * mult;
257 if (value > max)
258 value = max;
259 if (value < min)
260 value = min;
261 break;
262 case PLA_LEFT:
263 case PLA_LEFT_REPEAT:
264 if (++pos > pos_max)
265 pos = pos_min;
266 break;
267 case PLA_RIGHT:
268 case PLA_RIGHT_REPEAT:
269 if (--pos < pos_min)
270 pos = pos_max;
271 break;
272 case PLA_SELECT:
273 *pval = value;
274 ret = 0;
275 break;
276 case PLA_CANCEL:
277 case PLA_EXIT:
278 rb->splash(HZ, "Cancelled");
279 ret = -1;
280 break;
281 default:
282 if (rb->default_event_handler(button) == SYS_USB_CONNECTED)
283 ret = 1;
284 break;
285 }
286 }
287 rb->lcd_clear_display();
288 rb->lcd_update();
289 return ret;
290 }
291
292 /*******************************
293 * misc stuff
294 *******************************/
295 static void reset_current_data(void)
296 {
297 current.title = NULL;
298 current.artist = NULL;
299 current.offset = 0;
300 current.offset_file_offset = -1;
301 current.nlrcbrpos = 0;
302 current.nlrcline = 0;
303 current.ll_head = NULL;
304 current.ll_tail = &current.ll_head;
305 current.loaded_lrc = false;
306 current.changed_lrc = false;
307 current.too_many_lines = false;
308 lrc_buffer_used = 0;
309 lrc_buffer_end = lrc_buffer_size;
310 }
311
312 /* check space and add str to lrc_buffer.
313 * return NULL if there is not enough buffer. */
314 static char *lrcbufadd(const char*str, bool join)
315 {
316 if (join) lrc_buffer_used--;
317 size_t siz = rb->strlen(str)+1;
318 char *pos = &lrc_buffer[lrc_buffer_used];
319 if (lrc_buffer_used + siz > lrc_buffer_end)
320 return NULL;
321 rb->strcpy(pos, str);
322 lrc_buffer_used += siz;
323 return pos;
324 }
325 static void *alloc_buf(size_t siz)
326 {
327 siz = (siz+3) & ~3;
328 if (lrc_buffer_used + siz > lrc_buffer_end)
329 return NULL;
330 lrc_buffer_end -= siz;
331 return &lrc_buffer[lrc_buffer_end];
332 }
333 static void *new_lrc_word(long time_start, char *word, bool join)
334 {
335 struct lrc_word *lrc_word;
336 if ((lrc_word = alloc_buf(sizeof(struct lrc_word))) == NULL)
337 return NULL;
338 if ((lrc_word->word = lrcbufadd(word, join)) == NULL)
339 return NULL;
340 lrc_word->time_start = time_start;
341 return lrc_word;
342 }
343 static bool add_lrc_line(struct lrc_line *lrc_line, char *word)
344 {
345 lrc_line->nword = 0;
346 lrc_line->next = NULL;
347 lrc_line->words = NULL;
348 if (word)
349 {
350 if ((lrc_line->words = new_lrc_word(-1, word, false)) == NULL)
351 return false;
352 lrc_line->nword++;
353 }
354 *current.ll_tail = lrc_line;
355 current.ll_tail = &(lrc_line->next);
356 current.nlrcline++;
357 return true;
358 }
359 static struct lrc_line *get_lrc_line(int idx)
360 {
361 static struct lrc_line *lrc_line = NULL;
362 static int n = 0;
363 if (idx < n)
364 {
365 lrc_line = current.ll_head;
366 n = 0;
367 }
368 while (n < idx && lrc_line)
369 {
370 lrc_line = lrc_line->next;
371 n++;
372 }
373 return lrc_line;
374 }
375 static char *get_lrc_str(struct lrc_line *lrc_line)
376 {
377 return lrc_line->words[lrc_line->nword-1].word;
378 }
379 static long get_time_start(struct lrc_line *lrc_line)
380 {
381 if (!lrc_line) return current.length+20;
382 long time = lrc_line->time_start + current.offset;
383 return time < 0? 0: time;
384 }
385 static void set_time_start(struct lrc_line *lrc_line, long time_start)
386 {
387 time_start -= current.offset;
388 time_start -= time_start%10;
389 if (lrc_line->time_start != time_start)
390 {
391 lrc_line->time_start = time_start;
392 current.changed_lrc = true;
393 }
394 }
395 #define get_word_time_start(x) get_time_start((struct lrc_line *)(x))
396 #define set_word_time_start(x, t) set_time_start((struct lrc_line *)(x), (t))
397
398 static int format_time_tag(char *buf, long t)
399 {
400 return rb->snprintf(buf, 16, "%02ld:%02ld.%02ld",
401 t/60000, (t/1000)%60, (t/10)%100);
402 }
403 /* find start of next line */
404 static const char *lrc_skip_space(const char *str)
405 {
406 #ifdef HAVE_LCD_BITMAP
407 if (prefs.wrap)
408 {
409 while (*str && *str != '\n' && isspace(*str))
410 str++;
411 }
412 #endif
413 if (*str == '\n')
414 str++;
415 return str;
416 }
417
418 #ifdef HAVE_LCD_BITMAP
419 static bool isbrchr(const unsigned char *str, int len)
420 {
421 const unsigned char *p = "!,-.:;?　、。！，．：；？―";
422 if (isspace(*str))
423 return true;
424
425 while(*p)
426 {
427 int n = rb->utf8seek(p, 1);
428 if (len == n && !rb->strncmp(p, str, len))
429 return true;
430 p += n;
431 }
432 return false;
433 }
434 #endif
435
436 /* calculate how many lines is needed to display and store it.
437 * create cache if there is enough space in lrc_buffer. */
438 static struct lrc_brpos *calc_brpos(struct lrc_line *lrc_line, int i)
439 {
440 struct lrc_brpos *lrc_brpos;
441 struct lrc_word *lrc_word;
442 int nlrcbrpos = 0, max_lrcbrpos;
443 #ifdef HAVE_LCD_BITMAP
444 struct font* pf = rb->font_get(FONT_UI);
445 unsigned short ch;
446 #endif
447 struct snap {
448 int count, width;
449 int nword;
450 int word_count, word_width;
451 const unsigned char *str;
452 } sp, cr;
453
454 lrc_buffer_used = (lrc_buffer_used+3)&~3; /* 4 bytes aligned */
455 lrc_brpos = (struct lrc_brpos *) &lrc_buffer[lrc_buffer_used];
456 max_lrcbrpos = (lrc_buffer_end-lrc_buffer_used) / sizeof(struct lrc_brpos);
457
458 if (!lrc_line)
459 {
460 /* calc info for all lrcs and store them if possible */
461 size_t buffer_used = lrc_buffer_used;
462 bool too_many_lines = false;
463 current.too_many_lines = true;
464 for (lrc_line = current.ll_head; lrc_line; lrc_line = lrc_line->next)
465 {
466 FOR_NB_SCREENS(i)
467 {
468 lrc_brpos = calc_brpos(lrc_line, i);
469 if (!too_many_lines)
470 {
471 lrc_buffer_used += lrc_line->nline[i]*sizeof(struct lrc_brpos);
472 if (nlrcbrpos + lrc_line->nline[i] >= max_lrcbrpos)
473 {
474 too_many_lines = true;
475 lrc_buffer_used = buffer_used;
476 calc_brpos(lrc_line, i);
477 }
478 }
479 nlrcbrpos += lrc_line->nline[i];
480 }
481 }
482 current.too_many_lines = too_many_lines;
483 lrc_buffer_used = buffer_used;
484 current.nlrcbrpos = nlrcbrpos;
485 return NULL;
486 }
487
488 if (!current.too_many_lines)
489 {
490 /* use stored infos. */
491 struct lrc_line *temp_lrc = current.ll_head;
492 for (; temp_lrc != lrc_line; temp_lrc = temp_lrc->next)
493 {
494 lrc_brpos += temp_lrc->nline[SCREEN_MAIN];
495 #ifdef HAVE_REMOTE_LCD
496 lrc_brpos += temp_lrc->nline[SCREEN_REMOTE];
497 #endif
498 }
499 #if NB_SCREENS >= 2
500 while (i)
501 lrc_brpos += lrc_line->nline[--i];
502 #endif
503 return lrc_brpos;
504 }
505
506 /* calculate number of lines, line width and char count for each line. */
507 lrc_line->width = 0;
508 cr.nword = lrc_line->nword;
509 lrc_word = lrc_line->words+cr.nword;
510 cr.str = (lrc_word-1)->word;
511 sp.word_count = 0;
512 sp.word_width = 0;
513 sp.nword = 0;
514 sp.count = 0;
515 sp.width = 0;
516 do {
517 cr.count = 0;
518 cr.width = 0;
519 sp.str = NULL;
520
521 while (1)
522 {
523 while(cr.nword > 0 && cr.str >= (lrc_word-1)->word)
524 {
525 cr.nword--;
526 lrc_word--;
527 lrc_word->count = 0;
528 lrc_word->width = 0;
529 }
530 if (*cr.str == 0 || *cr.str == '\n')
531 break;
532
533 int c, w;
534 #ifdef HAVE_LCD_CHARCELLS
535 c = rb->utf8seek(cr.str, 1);
536 w = 1;
537 #else
538 c = ((long)rb->utf8decode(cr.str, &ch) - (long)cr.str);
539 if (rb->is_diacritic(ch, NULL))
540 w = 0;
541 else
542 w = rb->font_get_width(pf, ch);
543 if (cr.count && prefs.wrap && isbrchr(cr.str, c))
544 {
545 /* remember position of last space */
546 rb->memcpy(&sp, &cr, sizeof(struct snap));
547 sp.word_count = lrc_word->count;
548 sp.word_width = lrc_word->width;
549 if (!isspace(*cr.str) && cr.width+w <= vp_lyrics[i].width)
550 {
551 sp.count += c;
552 sp.width += w;
553 sp.word_count += c;
554 sp.word_width += w;
555 sp.str += c;
556 }
557 }
558 if (cr.count && cr.width+w > vp_lyrics[i].width)
559 {
560 if (sp.str != NULL) /* wrap */
561 {
562 rb->memcpy(&cr, &sp, sizeof(struct snap));
563 lrc_word = lrc_line->words+cr.nword;
564 lrc_word->count = sp.word_count;
565 lrc_word->width = sp.word_width;
566 }
567 break;
568 }
569 #endif
570 cr.count += c;
571 cr.width += w;
572 lrc_word->count += c;
573 lrc_word->width += w;
574 cr.str += c;
575 }
576 lrc_line->width += cr.width;
577 lrc_brpos->count = cr.count;
578 lrc_brpos->width = cr.width;
579 nlrcbrpos++;
580 lrc_brpos++;
581 cr.str = lrc_skip_space(cr.str);
582 } while (*cr.str && nlrcbrpos < max_lrcbrpos);
583 lrc_line->nline[i] = nlrcbrpos;
584
585 while (cr.nword > 0)
586 {
587 cr.nword--;
588 lrc_word--;
589 lrc_word->count = 0;
590 lrc_word->width = 0;
591 }
592 return lrc_brpos-nlrcbrpos;
593 }
594
595 /* sort lyrics by time using stable sort. */
596 static void sort_lrcs(void)
597 {
598 struct lrc_line *p = current.ll_head, **q = NULL, *t;
599 long time_max = 0;
600
601 current.ll_head = NULL;
602 current.ll_tail = &current.ll_head;
603 while (p != NULL)
604 {
605 t = p->next;
606 /* remove problematic lrc_lines.
607 * it would cause problem in display_lrc_line() if nword is 0. */
608 if (p->nword)
609 {
610 q = p->time_start >= time_max? current.ll_tail: &current.ll_head;
611 while ((*q) && (*q)->time_start <= p->time_start)
612 q = &((*q)->next);
613 p->next = *q;
614 *q = p;
615 if (!p->next)
616 {
617 time_max = p->time_start;
618 current.ll_tail = &p->next;
619 }
620 }
621 p = t;
622 }
623 if (!current.too_many_lines)
624 calc_brpos(NULL, 0); /* stored data depends on order of lrcs if exist */
625 }
626 static void init_time_tag(void)
627 {
628 struct lrc_line *lrc_line = current.ll_head;
629 int nline = 0;
630 if (current.type == TXT || current.type == ID3_USLT)
631 {
632 /* set time tag according to length of audio and total line count
633 * for not synched lyrics, so that scroll speed is almost constant. */
634 for (; lrc_line; lrc_line = lrc_line->next)
635 {
636 lrc_line->time_start = nline * current.length / current.nlrcbrpos;
637 lrc_line->time_start -= lrc_line->time_start%10;
638 lrc_line->old_time_start = -1;
639 nline += lrc_line->nline[SCREEN_MAIN];
640 #ifdef HAVE_REMOTE_LCD
641 nline += lrc_line->nline[SCREEN_REMOTE];
642 #endif
643 }
644 }
645 else
646 {
647 /* reset timetags to the value read from file */
648 for (; lrc_line; lrc_line = lrc_line->next)
649 {
650 lrc_line->time_start = lrc_line->old_time_start;
651 }
652 sort_lrcs();
653 }
654 current.changed_lrc = false;
655 }
656
657 /*******************************
658 * Serch lrc file.
659 *******************************/
660
661 /* search in same or parent directries of playing file.
662 * assume playing file is /aaa/bbb/ccc/ddd.mp3,
663 * this function searchs lrc file following order.
664 * /aaa/bbb/ccc/ddd.lrc
665 * /aaa/bbb/ddd.lrc
666 * /aaa/ddd.lrc
667 * /ddd.lrc
668 */
669
670 /* taken from apps/recorder/albumart.c */
671 static void fix_filename(char* name)
672 {
673 static const char invalid_chars[] = "*/:<>?\\|";
674
675 while (1)
676 {
677 if (*name == 0)
678 return;
679 if (*name == '"')
680 *name = '\'';
681 else if (rb->strchr(invalid_chars, *name))
682 *name = '_';
683 name++;
684 }
685 }
686 static bool find_lrc_file_helper(const char *base_dir)
687 {
688 char fname[MAX_PATH];
689 char *names[3] = {NULL, NULL, NULL};
690 char *p, *dir;
691 int i, len;
692 /* /aaa/bbb/ccc/ddd.mp3
693 * dir <--q names[0]
694 */
695
696 /* assuming file name starts with '/' */
697 rb->strcpy(temp_buf, current.mp3_file);
698 /* get file name and remove extension */
699 names[0] = rb->strrchr(temp_buf, '/')+1;
700 if ((p = rb->strrchr(names[0], '.')) != NULL)
701 *p = 0;
702 if (current.id3->title && rb->strcmp(names[0], current.id3->title))
703 {
704 rb->strlcpy(fname, current.id3->title, sizeof(fname));
705 fix_filename(fname);
706 names[1] = fname;
707 }
708
709 dir = temp_buf;
710 p = names[0]-1;
711 do {
712 int n;
713 *p = 0;
714 for (n = 0; ; n++)
715 {
716 if (n == 0)
717 {
718 len = rb->snprintf(current.lrc_file, MAX_PATH, "%s%s/",
719 base_dir, dir);
720 }
721 else if (n == 1)
722 {
723 /* check file in subfolder named prefs.lrc_directory
724 * in the directory of mp3 file. */
725 if (prefs.lrc_directory[0] == '/')
726 {
727 len = rb->snprintf(current.lrc_file, MAX_PATH, "%s%s/",
728 dir, prefs.lrc_directory);
729 }
730 else
731 continue;
732 }
733 else
734 break;
735 DEBUGF("check file in %s\n", current.lrc_file);
736 if (!rb->dir_exists(current.lrc_file))
737 continue;
738 for (current.type = 0; current.type < NUM_TYPES; current.type++)
739 {
740 for (i = 0; names[i] != NULL; i++)
741 {
742 rb->snprintf(&current.lrc_file[len], MAX_PATH-len,
743 "%s%s", names[i], extentions[current.type]);
744 if (rb->file_exists(current.lrc_file))
745 {
746 DEBUGF("found: `%s'\n", current.lrc_file);
747 return true;
748 }
749 }
750 }
751 }
752 } while ((p = rb->strrchr(dir, '/')) != NULL);
753 return false;
754 }
755
756 /* return true if a lrc file is found */
757 static bool find_lrc_file(void)
758 {
759 reset_current_data();
760
761 DEBUGF("find lrc file for `%s'\n", current.mp3_file);
762 /* find .lrc file */
763 if (find_lrc_file_helper(""))
764 return true;
765 if (prefs.lrc_directory[0] == '/' && rb->dir_exists(prefs.lrc_directory))
766 {
767 if (find_lrc_file_helper(prefs.lrc_directory))
768 return true;
769 }
770
771 current.lrc_file[0] = 0;
772 return false;
773 }
774
775 /*******************************
776 * Load file.
777 *******************************/
778
779 /* check tag format and calculate value of the tag.
780 * supported tag: ti, ar, offset
781 * supported format of time tag: [mm:ss], [mm:ss.xx], [mm:ss.xxx]
782 * returns value of timega if tag is time tag, -1 if tag is supported tag,
783 * -10 otherwise.
784 */
785 static char *parse_int(char *ptr, int *val)
786 {
787 *val = rb->atoi(ptr);
788 while (isdigit(*ptr)) ptr++;
789 return ptr;
790 }
791 static long get_time_value(char *tag, bool read_id_tags, off_t file_offset)
792 {
793 long time;
794 char *ptr;
795 int val;
796
797 if (read_id_tags)
798 {
799 if (!rb->strncmp(tag, "ti:", 3))
800 {
801 if (!current.id3->title || rb->strcmp(&tag[3], current.id3->title))
802 current.title = lrcbufadd(&tag[3], false);
803 return -1;
804 }
805 if (!rb->strncmp(tag, "ar:", 3))
806 {
807 if (!current.id3->artist || rb->strcmp(&tag[3], current.id3->artist))
808 current.artist = lrcbufadd(&tag[3], false);
809 return -1;
810 }
811 if (!rb->strncmp(tag, "offset:", 7))
812 {
813 current.offset = rb->atoi(&tag[7]);
814 current.offset_file_offset = file_offset;
815 return -1;
816 }
817 }
818
819 /* minute */
820 ptr = parse_int(tag, &val);
821 if (ptr-tag < 1 || ptr-tag > 2 || *ptr != ':')
822 return -10;
823 time = val * 60000;
824 /* second */
825 tag = ptr+1;
826 ptr = parse_int(tag, &val);
827 if (ptr-tag != 2 || (*ptr != '.' && *ptr != ':' && *ptr != '\0'))
828 return -10;
829 time += val * 1000;
830
831 if (*ptr != '\0')
832 {
833 /* milliseccond */
834 tag = ptr+1;
835 ptr = parse_int(tag, &val);
836 if (ptr-tag < 2 || ptr-tag > 3 || *ptr != '\0')
837 return -10;
838 time += ((ptr-tag)==3 ?val: val*10);
839 }
840
841 return time;
842 }
843
844 /* format:
845 * [time tag]line
846 * [time tag]...[time tag]line
847 * [time tag]<word time tag>word<word time tag>...<word time tag>
848 */
849 static bool parse_lrc_line(char *line, off_t file_offset)
850 {
851 struct lrc_line *lrc_line = NULL, *first_lrc_line = NULL;
852 long time, time_start;
853 char *str, *tagstart, *tagend;
854 struct lrc_word *lrc_word;
855 int nword = 0;
856
857 /* parse [time tag]...[time tag] type tags */
858 str = line;
859 while (1)
860 {
861 if (*str != '[') break;
862 tagend = rb->strchr(str, ']');
863 if (tagend == NULL) break;
864 *tagend = 0;
865 time = get_time_value(str+1, !lrc_line, file_offset);
866 *tagend++ = ']';
867 if (time < 0)
868 break;
869 lrc_line = alloc_buf(sizeof(struct lrc_line));
870 if (lrc_line == NULL)
871 return false;
872 if (!first_lrc_line)
873 first_lrc_line = lrc_line;
874 lrc_line->file_offset = file_offset;
875 lrc_line->time_start = (time/10)*10;
876 lrc_line->old_time_start = lrc_line->time_start;
877 add_lrc_line(lrc_line, NULL);
878 file_offset += (long)tagend - (long)str;
879 str = tagend;
880 }
881 if (!first_lrc_line)
882 return true; /* no time tag in line */
883
884 lrc_line = first_lrc_line;
885 if (lrcbufadd("", false) == NULL)
886 return false;
887
888 /* parse <word time tag>...<word time tag> type tags */
889 /* [time tag]...[time tag]line type tags share lrc_line->words and can't
890 * use lrc_line->words->timestart. use lrc_line->time_start instead. */
891 time_start = -1;
892 tagstart = str;
893 while (*tagstart)
894 {
895 tagstart = rb->strchr(tagstart, '<');
896 if (!tagstart) break;
897 tagend = rb->strchr(tagstart, '>');
898 if (!tagend) break;
899 *tagend = 0;
900 time = get_time_value(tagstart+1, false,
901 file_offset + ((long)tagstart - (long)str));
902 *tagend++ = '>';
903 if (time < 0)
904 {
905 tagstart++;
906 continue;
907 }
908 *tagstart = 0;
909 /* found word time tag. */
910 if (*str || time_start != -1)
911 {
912 if ((lrc_word = new_lrc_word(time_start, str, true)) == NULL)
913 return false;
914 nword++;
915 }
916 file_offset += (long)tagend - (long)str;
917 tagstart = str = tagend;
918 time_start = time;
919 }
920 if ((lrc_word = new_lrc_word(time_start, str, true)) == NULL)
921 return false;
922 nword++;
923
924 /* duplicate lrc_lines */
925 while (lrc_line)
926 {
927 lrc_line->nword = nword;
928 lrc_line->words = lrc_word;
929 lrc_line = lrc_line->next;
930 }
931
932 return true;
933 }
934
935 /* format:
936 * \xa2\xe2hhmmssxx\xa2\xd0
937 * line 1
938 * line 2
939 * \xa2\xe2hhmmssxx\xa2\xd0
940 * line 3
941 * ...
942 */
943 static bool parse_snc_line(char *line, off_t file_offset)
944 {
945 #define SNC_TAG_START "\xa2\xe2"
946 #define SNC_TAG_END "\xa2\xd0"
947
948 /* SNC_TAG can be dencoded, so use
949 * temp_buf which contains native data */
950 if (!rb->memcmp(temp_buf, SNC_TAG_START, 2)
951 && !rb->memcmp(temp_buf+10, SNC_TAG_END, 2)) /* time tag */
952 {
953 const char *pos = temp_buf+2; /* skip SNC_TAG_START */
954 int hh, mm, ss, xx;
955
956 hh = (pos[0]-'0')*10+(pos[1]-'0'); pos += 2;
957 mm = (pos[0]-'0')*10+(pos[1]-'0'); pos += 2;
958 ss = (pos[0]-'0')*10+(pos[1]-'0'); pos += 2;
959 xx = (pos[0]-'0')*10+(pos[1]-'0'); pos += 2;
960 pos += 2; /* skip SNC_TAG_END */
961
962 /* initialize */
963 struct lrc_line *lrc_line = alloc_buf(sizeof(struct lrc_line));
964 if (lrc_line == NULL)
965 return false;
966 lrc_line->file_offset = file_offset+2;
967 lrc_line->time_start = hh*3600000+mm*60000+ss*1000+xx*10;
968 lrc_line->old_time_start = lrc_line->time_start;
969 if (!add_lrc_line(lrc_line, ""))
970 return false;
971 if (pos[0]==0)
972 return true;
973
974 /* encode rest of line and add to buffer */
975 rb->iso_decode(pos, line, prefs.encoding, rb->strlen(pos)+1);
976 }
977 if (current.ll_head)
978 {
979 rb->strcat(line, "\n");
980 if (lrcbufadd(line, true) == NULL)
981 return false;
982 }
983 return true;
984 }
985
986 static bool parse_txt_line(char *line, off_t file_offset)
987 {
988 /* initialize */
989 struct lrc_line *lrc_line = alloc_buf(sizeof(struct lrc_line));
990 if (lrc_line == NULL)
991 return false;
992 lrc_line->file_offset = file_offset;
993 lrc_line->time_start = 0;
994 lrc_line->old_time_start = -1;
995 if (!add_lrc_line(lrc_line, line))
996 return false;
997 return true;
998 }
999
1000 static void load_lrc_file(void)
1001 {
1002 char utf8line[MAX_LINE_LEN*3];
1003 int fd;
1004 int encoding = prefs.encoding;
1005 bool (*line_parser)(char *line, off_t) = NULL;
1006 off_t file_offset, readsize;
1007
1008 switch(current.type)
1009 {
1010 case LRC8:
1011 encoding = UTF_8; /* .lrc8 is utf8 */
1012 /* fall through */
1013 case LRC:
1014 line_parser = parse_lrc_line;
1015 break;
1016 case SNC:
1017 line_parser = parse_snc_line;
1018 break;
1019 case TXT:
1020 line_parser = parse_txt_line;
1021 break;
1022 default:
1023 return;
1024 }
1025
1026 fd = rb->open(current.lrc_file, O_RDONLY);
1027 if (fd < 0) return;
1028
1029 {
1030 /* check encoding */
1031 #define BOM "\xef\xbb\xbf"
1032 #define BOM_SIZE 3
1033 unsigned char header[BOM_SIZE];
1034 unsigned char* (*utf_decode)(const unsigned char *,
1035 unsigned char *, int) = NULL;
1036 rb->read(fd, header, BOM_SIZE);
1037 if (!rb->memcmp(header, BOM, BOM_SIZE)) /* UTF-8 */
1038 {
1039 encoding = UTF_8;
1040 }
1041 else if (!rb->memcmp(header, "\xff\xfe", 2)) /* UTF-16LE */
1042 {
1043 utf_decode = rb->utf16LEdecode;
1044 }
1045 else if (!rb->memcmp(header, "\xfe\xff", 2)) /* UTF-16BE */
1046 {
1047 utf_decode = rb->utf16BEdecode;
1048 }
1049 else
1050 {
1051 rb->lseek(fd, 0, SEEK_SET);
1052 }
1053
1054 if (utf_decode)
1055 {
1056 /* convert encoding of file from UTF-16 to UTF-8 */
1057 char temp_file[MAX_PATH];
1058 int fe;
1059 rb->lseek(fd, 2, SEEK_SET);
1060 rb->snprintf(temp_file, MAX_PATH, "%s~", current.lrc_file);
1061 fe = rb->creat(temp_file, 0666);
1062 if (fe < 0)
1063 {
1064 rb->close(fd);
1065 return;
1066 }
1067 rb->write(fe, BOM, BOM_SIZE);
1068 while ((readsize = rb->read(fd, temp_buf, MAX_LINE_LEN)) > 0)
1069 {
1070 char *end = utf_decode(temp_buf, utf8line, readsize/2);
1071 rb->write(fe, utf8line, end-utf8line);
1072 }
1073 rb->close(fe);
1074 rb->close(fd);
1075 rb->remove(current.lrc_file);
1076 rb->rename(temp_file, current.lrc_file);
1077 fd = rb->open(current.lrc_file, O_RDONLY);
1078 if (fd < 0) return;
1079 rb->lseek(fd, BOM_SIZE, SEEK_SET); /* skip bom */
1080 encoding = UTF_8;
1081 }
1082 }
1083
1084 file_offset = rb->lseek(fd, 0, SEEK_CUR); /* used in line_parser */
1085 while ((readsize = rb->read_line(fd, temp_buf, MAX_LINE_LEN)) > 0)
1086 {
1087 /* note: parse_snc_line() reads temp_buf for native data. */
1088 rb->iso_decode(temp_buf, utf8line, encoding, readsize+1);
1089 if (!line_parser(utf8line, file_offset))
1090 break;
1091 file_offset += readsize;
1092 }
1093 rb->close(fd);
1094
1095 current.loaded_lrc = true;
1096 calc_brpos(NULL, 0);
1097 init_time_tag();
1098
1099 return;
1100 }
1101
1102 #ifdef LRC_SUPPORT_ID3
1103 /*******************************
1104 * read lyrics from id3
1105 *******************************/
1106 /* taken from apps/metadata/mp3.c */
1107 static unsigned long unsync(unsigned long b0, unsigned long b1,
1108 unsigned long b2, unsigned long b3)
1109 {
1110 return (((long)(b0 & 0x7F) << (3*7)) |
1111 ((long)(b1 & 0x7F) << (2*7)) |
1112 ((long)(b2 & 0x7F) << (1*7)) |
1113 ((long)(b3 & 0x7F) << (0*7)));
1114 }
1115
1116 static unsigned long bytes2int(unsigned long b0, unsigned long b1,
1117 unsigned long b2, unsigned long b3)
1118 {
1119 return (((long)(b0 & 0xFF) << (3*8)) |
1120 ((long)(b1 & 0xFF) << (2*8)) |
1121 ((long)(b2 & 0xFF) << (1*8)) |
1122 ((long)(b3 & 0xFF) << (0*8)));
1123 }
1124
1125 static int unsynchronize(char* tag, int len, bool *ff_found)
1126 {
1127 int i;
1128 unsigned char c;
1129 unsigned char *rp, *wp;
1130 bool _ff_found = false;
1131 if(ff_found) _ff_found = *ff_found;
1132
1133 wp = rp = (unsigned char *)tag;
1134
1135 rp = (unsigned char *)tag;
1136 for(i = 0; i<len; i++) {
1137 /* Read the next byte and write it back, but don't increment the
1138 write pointer */
1139 c = *rp++;
1140 *wp = c;
1141 if(_ff_found) {
1142 /* Increment the write pointer if it isn't an unsynch pattern */
1143 if(c != 0)
1144 wp++;
1145 _ff_found = false;
1146 } else {
1147 if(c == 0xff)
1148 _ff_found = true;
1149 wp++;
1150 }
1151 }
1152 if(ff_found) *ff_found = _ff_found;
1153 return (long)wp - (long)tag;
1154 }
1155
1156 static int read_unsynched(int fd, void *buf, int len, bool *ff_found)
1157 {
1158 int i;
1159 int rc;
1160 int remaining = len;
1161 char *wp;
1162
1163 wp = buf;
1164
1165 while(remaining) {
1166 rc = rb->read(fd, wp, remaining);
1167 if(rc <= 0)
1168 return rc;
1169
1170 i = unsynchronize(wp, remaining, ff_found);
1171 remaining -= i;
1172 wp += i;
1173 }
1174
1175 return len;
1176 }
1177
1178 static unsigned char* utf8cpy(const unsigned char *src,
1179 unsigned char *dst, int count)
1180 {
1181 rb->strlcpy(dst, src, count+1);
1182 return dst+rb->strlen(dst);
1183 }
1184
1185 static void parse_id3v2(int fd)
1186 {
1187 int minframesize;
1188 int size;
1189 long framelen;
1190 char header[10];
1191 char tmp[8];
1192 unsigned char version;
1193 int bytesread = 0;
1194 unsigned char global_flags;
1195 int flags;
1196 bool global_unsynch = false;
1197 bool global_ff_found = false;
1198 bool unsynch = false;
1199 int rc;
1200 enum {NOLT, SYLT, USLT} type = NOLT;
1201
1202 /* Bail out if the tag is shorter than 10 bytes */
1203 if(current.id3->id3v2len < 10)
1204 return;
1205
1206 /* Read the ID3 tag version from the header */
1207 if(10 != rb->read(fd, header, 10))
1208 return;
1209
1210 /* Get the total ID3 tag size */
1211 size = current.id3->id3v2len - 10;
1212
1213 version = current.id3->id3version;
1214 switch ( version )
1215 {
1216 case ID3_VER_2_2:
1217 minframesize = 8;
1218 break;
1219
1220 case ID3_VER_2_3:
1221 minframesize = 12;
1222 break;
1223
1224 case ID3_VER_2_4:
1225 minframesize = 12;
1226 break;
1227
1228 default:
1229 /* unsupported id3 version */
1230 return;
1231 }
1232
1233 global_flags = header[5];
1234
1235 /* Skip the extended header if it is present */
1236 if(global_flags & 0x40) {
1237
1238 if(version == ID3_VER_2_3) {
1239 if(10 != rb->read(fd, header, 10))
1240 return;
1241 /* The 2.3 extended header size doesn't include the header size
1242 field itself. Also, it is not unsynched. */
1243 framelen =
1244 bytes2int(header[0], header[1], header[2], header[3]) + 4;
1245
1246 /* Skip the rest of the header */
1247 rb->lseek(fd, framelen - 10, SEEK_CUR);
1248 }
1249
1250 if(version >= ID3_VER_2_4) {
1251 if(4 != rb->read(fd, header, 4))
1252 return;
1253
1254 /* The 2.4 extended header size does include the entire header,
1255 so here we can just skip it. This header is unsynched. */
1256 framelen = unsync(header[0], header[1],
1257 header[2], header[3]);
1258
1259 rb->lseek(fd, framelen - 4, SEEK_CUR);
1260 }
1261 }
1262
1263 /* Is unsynchronization applied? */
1264 if(global_flags & 0x80) {
1265 global_unsynch = true;
1266 }
1267
1268 /* We must have at least minframesize bytes left for the
1269 * remaining frames to be interesting */
1270 while (size >= minframesize) {
1271 flags = 0;
1272
1273 /* Read frame header and check length */
1274 if(version >= ID3_VER_2_3) {
1275 if(global_unsynch && version <= ID3_VER_2_3)
1276 rc = read_unsynched(fd, header, 10, &global_ff_found);
1277 else
1278 rc = rb->read(fd, header, 10);
1279 if(rc != 10)
1280 return;
1281 /* Adjust for the 10 bytes we read */
1282 size -= 10;
1283
1284 flags = bytes2int(0, 0, header[8], header[9]);
1285
1286 if (version >= ID3_VER_2_4) {
1287 framelen = unsync(header[4], header[5],
1288 header[6], header[7]);
1289 } else {
1290 /* version .3 files don't use synchsafe ints for
1291 * size */
1292 framelen = bytes2int(header[4], header[5],
1293 header[6], header[7]);
1294 }
1295 } else {
1296 if(6 != rb->read(fd, header, 6))
1297 return;
1298 /* Adjust for the 6 bytes we read */
1299 size -= 6;
1300
1301 framelen = bytes2int(0, header[3], header[4], header[5]);
1302 }
1303
1304 if(framelen == 0){
1305 if (header[0] == 0 && header[1] == 0 && header[2] == 0)
1306 return;
1307 else
1308 continue;
1309 }
1310
1311 unsynch = false;
1312
1313 if(flags)
1314 {
1315 if (version >= ID3_VER_2_4) {
1316 if(flags & 0x0040) { /* Grouping identity */
1317 rb->lseek(fd, 1, SEEK_CUR); /* Skip 1 byte */
1318 framelen--;
1319 }
1320 } else {
1321 if(flags & 0x0020) { /* Grouping identity */
1322 rb->lseek(fd, 1, SEEK_CUR); /* Skip 1 byte */
1323 framelen--;
1324 }
1325 }
1326
1327 if(flags & 0x000c) /* Compression or encryption */
1328 {
1329 /* Skip it */
1330 size -= framelen;
1331 rb->lseek(fd, framelen, SEEK_CUR);
1332 continue;
1333 }
1334
1335 if(flags & 0x0002) /* Unsynchronization */
1336 unsynch = true;
1337
1338 if (version >= ID3_VER_2_4) {
1339 if(flags & 0x0001) { /* Data length indicator */
1340 if(4 != rb->read(fd, tmp, 4))
1341 return;
1342
1343 /* We don't need the data length */
1344 framelen -= 4;
1345 }
1346 }
1347 }
1348
1349 if (framelen == 0)
1350 continue;
1351
1352 if (framelen < 0)
1353 return;
1354
1355 if(!rb->memcmp( header, "SLT", 3 ) ||
1356 !rb->memcmp( header, "SYLT", 4 ))
1357 {
1358 /* found a supported tag */
1359 type = SYLT;
1360 break;
1361 }
1362 else if(!rb->memcmp( header, "ULT", 3 ) ||
1363 !rb->memcmp( header, "USLT", 4 ))
1364 {
1365 /* found a supported tag */
1366 type = USLT;
1367 break;
1368 }
1369 else
1370 {
1371 /* not a supported tag*/
1372 if(global_unsynch && version <= ID3_VER_2_3) {
1373 size -= read_unsynched(fd, lrc_buffer, framelen, &global_ff_found);
1374 } else {
1375 size -= framelen;
1376 if( rb->lseek(fd, framelen, SEEK_CUR) == -1 )
1377 return;
1378 }
1379 }
1380 }
1381 if(type == NOLT)
1382 return;
1383
1384 int encoding = 0, chsiz;
1385 char *tag, *p, utf8line[MAX_LINE_LEN*3];
1386 unsigned char* (*utf_decode)(const unsigned char *,
1387 unsigned char *, int) = NULL;
1388 /* use middle of lrc_buffer to store tag data. */
1389 if(framelen >= LRC_BUFFER_SIZE/3)
1390 framelen = LRC_BUFFER_SIZE/3-1;
1391 tag = lrc_buffer+LRC_BUFFER_SIZE*2/3-framelen-1;
1392 if(global_unsynch && version <= ID3_VER_2_3)
1393 bytesread = read_unsynched(fd, tag, framelen, &global_ff_found);
1394 else
1395 bytesread = rb->read(fd, tag, framelen);
1396
1397 if( bytesread != framelen )
1398 return;
1399
1400 if(unsynch || (global_unsynch && version >= ID3_VER_2_4))
1401 bytesread = unsynchronize(tag, bytesread, NULL);
1402
1403 tag[bytesread] = 0;
1404 encoding = tag[0];
1405 p = tag;
1406 /* skip some data */
1407 if(type == SYLT) {
1408 p += 6;
1409 } else {
1410 p += 4;
1411 }
1412
1413 /* check encoding and skip content descriptor */
1414 switch (encoding) {
1415 case 0x01: /* Unicode with or without BOM */
1416 case 0x02:
1417
1418 /* Now check if there is a BOM
1419 (zero-width non-breaking space, 0xfeff)
1420 and if it is in little or big endian format */
1421 if(!rb->memcmp(p, "\xff\xfe", 2)) { /* Little endian? */
1422 utf_decode = rb->utf16LEdecode;
1423 } else if(!rb->memcmp(p, "\xfe\xff", 2)) { /* Big endian? */
1424 utf_decode = rb->utf16BEdecode;
1425 } else
1426 utf_decode = NULL;
1427
1428 encoding = NUM_CODEPAGES;
1429 do {
1430 size = p[0] | p[1];
1431 p += 2;
1432 } while(size);
1433 chsiz = 2;
1434 break;
1435
1436 default:
1437 utf_decode = utf8cpy;
1438 if(encoding == 0x03) /* UTF-8 encoded string */
1439 encoding = UTF_8;
1440 else
1441 encoding = prefs.encoding;
1442 p += rb->strlen(p)+1;
1443 chsiz = 1;
1444 break;
1445 }
1446 if(encoding == NUM_CODEPAGES)
1447 {
1448 /* check if there is a BOM */
1449 if(!rb->memcmp(p, "\xff\xfe", 2)) { /* Little endian? */
1450 utf_decode = rb->utf16LEdecode;
1451 p += 2;
1452 } else if(!rb->memcmp(p, "\xfe\xff", 2)) { /* Big endian? */
1453 utf_decode = rb->utf16BEdecode;
1454 p += 2;
1455 } else if(!utf_decode) {
1456 /* If there is no BOM (which is a specification violation),
1457 let's try to guess it. If one of the bytes is 0x00, it is
1458 probably the most significant one. */
1459 if(p[1] == 0)
1460 utf_decode = rb->utf16LEdecode;
1461 else
1462 utf_decode = rb->utf16BEdecode;
1463 }
1464 }
1465 bytesread -= (long)p - (long)tag;
1466 tag = p;
1467
1468 while ( bytesread > 0
1469 && lrc_buffer_used+bytesread < LRC_BUFFER_SIZE*2/3
1470 && LRC_BUFFER_SIZE*2/3 < lrc_buffer_end)
1471 {
1472 bool is_crlf = false;
1473 struct lrc_line *lrc_line = alloc_buf(sizeof(struct lrc_line));
1474 if(!lrc_line)
1475 break;
1476 lrc_line->file_offset = -1;
1477 if(type == USLT)
1478 {
1479 /* replace 0x0a and 0x0d with 0x00 */
1480 p = tag;
1481 while(1) {
1482 utf_decode(p, tmp, 2);
1483 if(!tmp[0]) break;
1484 if(tmp[0] == 0x0d || tmp[0] == 0x0a)
1485 {
1486 if(tmp[0] == 0x0d && tmp[1] == 0x0a)
1487 is_crlf = true;
1488 p[0] = 0;
1489 p[chsiz-1] = 0;
1490 break;
1491 }
1492 p += chsiz;
1493 }
1494 }
1495 if(encoding == NUM_CODEPAGES)
1496 {
1497 unsigned char* utf8 = utf8line;
1498 p = tag;
1499 do {
1500 utf8 = utf_decode(p, utf8, 1);
1501 p += 2;
1502 } while(*(utf8-1));
1503 }
1504 else
1505 {
1506 size = rb->strlen(tag)+1;
1507 rb->iso_decode(tag, utf8line, encoding, size);
1508 p = tag+size;
1509 }
1510
1511 if(type == SYLT) { /* timestamp */
1512 lrc_line->time_start = bytes2int(p[0], p[1], p[2], p[3]);
1513 lrc_line->old_time_start = lrc_line->time_start;
1514 p += 4;
1515 utf_decode(p, tmp, 1);
1516 if(tmp[0] == 0x0a)
1517 p += chsiz;
1518 } else { /* USLT */
1519 lrc_line->time_start = 0;
1520 lrc_line->old_time_start = -1;
1521 if(is_crlf) p += chsiz;
1522 }
1523 bytesread -= (long)p - (long)tag;
1524 tag = p;
1525 if(!add_lrc_line(lrc_line, utf8line))
1526 break;
1527 }
1528
1529 current.type = ID3_SYLT-SYLT+type;
1530 rb->strcpy(current.lrc_file, current.mp3_file);
1531
1532 current.loaded_lrc = true;
1533 calc_brpos(NULL, 0);
1534 init_time_tag();
1535
1536 return;
1537 }
1538
1539 static bool read_id3(void)
1540 {
1541 int fd;
1542
1543 if(current.id3->codectype != AFMT_MPA_L1
1544 && current.id3->codectype != AFMT_MPA_L2
1545 && current.id3->codectype != AFMT_MPA_L3)
1546 return false;
1547
1548 fd = rb->open(current.mp3_file, O_RDONLY);
1549 if(fd < 0) return false;
1550 current.loaded_lrc = false;
1551 parse_id3v2(fd);
1552 rb->close(fd);
1553 return current.loaded_lrc;
1554 }
1555 #endif /* LRC_SUPPORT_ID3 */
1556
1557 /*******************************
1558 * Display information
1559 *******************************/
1560 static void display_state(void)
1561 {
1562 const char *str = NULL;
1563
1564 if (AUDIO_STOP)
1565 str = "Audio Stopped";
1566 else if (current.found_lrc)
1567 {
1568 if (!current.loaded_lrc)
1569 str = "Loading lrc";
1570 else if (!current.ll_head)
1571 str = "No lyrics";
1572 }
1573
1574 #ifdef HAVE_LCD_BITMAP
1575 const char *info = NULL;
1576
1577 if (AUDIO_PLAY && prefs.display_title)
1578 {
1579 char *title = (current.title? current.title: current.id3->title);
1580 char *artist = (current.artist? current.artist: current.id3->artist);
1581
1582 if (artist != NULL && title != NULL)
1583 {
1584 rb->snprintf(temp_buf, MAX_LINE_LEN, "%s/%s", title, artist);
1585 info = temp_buf;
1586 }
1587 else if (title != NULL)
1588 info = title;
1589 else if (current.mp3_file[0] == '/')
1590 info = rb->strrchr(current.mp3_file, '/')+1;
1591 else
1592 info = "(no info)";
1593 }
1594
1595 int i, w, h;
1596 struct screen* display;
1597 FOR_NB_SCREENS(i)
1598 {
1599 display = rb->screens[i];
1600 display->set_viewport(&vp_info[i]);
1601 display->clear_viewport();
1602 if (info)
1603 display->puts_scroll(0, 0, info);
1604 if (str)
1605 {
1606 display->set_viewport(&vp_lyrics[i]);
1607 display->clear_viewport();
1608 display->getstringsize(str, &w, &h);
1609 if (vp_lyrics[i].width - w < 0)
1610 display->puts_scroll(0, vp_lyrics[i].height/font_ui_height/2,
1611 str);
1612 else
1613 display->putsxy((vp_lyrics[i].width - w)*prefs.align/2,
1614 (vp_lyrics[i].height-font_ui_height)/2, str);
1615 display->set_viewport(&vp_info[i]);
1616 }
1617 display->update_viewport();
1618 display->set_viewport(NULL);
1619 }
1620 #else
1621 /* there is no place to display title or artist. */
1622 rb->lcd_clear_display();
1623 if (str)
1624 rb->lcd_puts_scroll(0, 0, str);
1625 rb->lcd_update();
1626 #endif /* HAVE_LCD_BITMAP */
1627 }
1628
1629 static void display_time(void)
1630 {
1631 rb->snprintf(temp_buf, MAX_LINE_LEN, "%ld:%02ld/%ld:%02ld",
1632 current.elapsed/60000, (current.elapsed/1000)%60,
1633 current.length/60000, (current.length)/1000%60);
1634 #ifdef HAVE_LCD_BITMAP
1635 int y = (prefs.display_title? font_ui_height:0), i;
1636 FOR_NB_SCREENS(i)
1637 {
1638 struct screen* display = rb->screens[i];
1639 display->set_viewport(&vp_info[i]);
1640 display->setfont(FONT_SYSFIXED);
1641 display->putsxy(0, y, temp_buf);
1642 rb->gui_scrollbar_draw(display, 0, y+SYSFONT_HEIGHT+1,
1643 vp_info[i].width, SYSFONT_HEIGHT-2,
1644 current.length, 0, current.elapsed, HORIZONTAL);
1645 display->update_viewport_rect(0, y, vp_info[i].width, SYSFONT_HEIGHT*2);
1646 display->setfont(FONT_UI);
1647 display->set_viewport(NULL);
1648 }
1649 #else
1650 rb->lcd_puts(0, 0, temp_buf);
1651 rb->lcd_update();
1652 #endif /* HAVE_LCD_BITMAP */
1653 }
1654
1655 /*******************************
1656 * Display lyrics
1657 *******************************/
1658 #ifdef HAVE_LCD_BITMAP
1659 static inline void set_to_default(struct screen *display)
1660 {
1661 #if (LCD_DEPTH > 1)
1662 #ifdef HAVE_REMOTE_LCD
1663 if (display->screen_type != SCREEN_REMOTE)
1664 #endif
1665 display->set_foreground(prefs.active_color);
1666 #endif
1667 display->set_drawmode(DRMODE_SOLID);
1668 }
1669 static inline void set_to_active(struct screen *display)
1670 {
1671 #if (LCD_DEPTH > 1)
1672 #ifdef HAVE_REMOTE_LCD
1673 if (display->screen_type == SCREEN_REMOTE)
1674 display->set_drawmode(DRMODE_INVERSEVID);
1675 else
1676 #endif
1677 {
1678 display->set_foreground(prefs.active_color);
1679 display->set_drawmode(DRMODE_SOLID);
1680 }
1681 #else /* LCD_DEPTH == 1 */
1682 display->set_drawmode(DRMODE_INVERSEVID);
1683 #endif
1684 }
1685 static inline void set_to_inactive(struct screen *display)
1686 {
1687 #if (LCD_DEPTH > 1)
1688 #ifdef HAVE_REMOTE_LCD
1689 if (display->screen_type != SCREEN_REMOTE)
1690 #endif
1691 display->set_foreground(prefs.inactive_color);
1692 #endif
1693 display->set_drawmode(DRMODE_SOLID);
1694 }
1695
1696 static int display_lrc_line(struct lrc_line *lrc_line, int ypos, int i)
1697 {
1698 struct screen *display = rb->screens[i];
1699 struct lrc_word *lrc_word;
1700 struct lrc_brpos *lrc_brpos;
1701 long time_start, time_end, elapsed;
1702 int count, width, nword;
1703 int xpos;
1704 const char *str;
1705 bool active_line;
1706
1707 time_start = get_time_start(lrc_line);
1708 time_end = get_time_start(lrc_line->next);
1709 active_line = (time_start <= current.elapsed
1710 && time_end > current.elapsed);
1711
1712 if (!lrc_line->width)
1713 {
1714 /* empty line. draw bar during interval. */
1715 long rin = current.elapsed - time_start;
1716 long len = time_end - time_start;
1717 if (current.wipe && active_line && len >= 3500)
1718 {
1719 elapsed = rin * vp_lyrics[i].width / len;
1720 set_to_inactive(display);
1721 display->fillrect(elapsed, ypos+font_ui_height/4+1,
1722 vp_lyrics[i].width-elapsed-1, font_ui_height/2-2);
1723 set_to_active(display);
1724 display->drawrect(0, ypos+font_ui_height/4,
1725 vp_lyrics[i].width, font_ui_height/2);
1726 display->fillrect(1, ypos+font_ui_height/4+1,
1727 elapsed-1, font_ui_height/2-2);
1728 set_to_default(display);
1729 }
1730 return ypos + font_ui_height;
1731 }
1732
1733 lrc_brpos = calc_brpos(lrc_line, i);
1734 /* initialize line */
1735 xpos = (vp_lyrics[i].width - lrc_brpos->width)*prefs.align/2;
1736 count = 0;
1737 width = 0;
1738
1739 active_line = active_line || !prefs.active_one_line;
1740 nword = lrc_line->nword-1;
1741 lrc_word = lrc_line->words + nword;
1742 str = lrc_word->word;
1743 /* only time_start of first word could be -1 */
1744 if (lrc_word->time_start != -1)
1745 time_end = get_word_time_start(lrc_word);
1746 else
1747 time_end = time_start;
1748 do {
1749 time_start = time_end;
1750 if (nword > 0)
1751 time_end = get_word_time_start(lrc_word-1);
1752 else
1753 time_end = get_time_start(lrc_line->next);
1754
1755 if (time_start > current.elapsed || !active_line)
1756 {
1757 /* inactive */
1758 elapsed = 0;
1759 }
1760 else if (!current.wipe || time_end <= current.elapsed)
1761 {
1762 /* active whole word */
1763 elapsed = lrc_word->width;
1764 }
1765 else
1766 {
1767 /* wipe word */
1768 long rin = current.elapsed - time_start;
1769 long len = time_end - time_start;
1770 elapsed = rin * lrc_word->width / len;
1771 }
1772
1773 int word_count = lrc_word->count;
1774 int word_width = lrc_word->width;
1775 set_to_active(display);
1776 while (word_count > 0 && word_width > 0)
1777 {
1778 int c = lrc_brpos->count - count;
1779 int w = lrc_brpos->width - width;
1780 if (c > word_count || w > word_width)
1781 {
1782 c = word_count;
1783 w = word_width;
1784 }
1785 if (elapsed <= 0)
1786 {
1787 set_to_inactive(display);
1788 }
1789 else if (elapsed < w)
1790 {
1791 /* wipe text */
1792 display->fillrect(xpos, ypos, elapsed, font_ui_height);
1793 set_to_inactive(display);
1794 display->fillrect(xpos+elapsed, ypos,
1795 w-elapsed, font_ui_height);
1796 #if (LCD_DEPTH > 1)
1797 #ifdef HAVE_REMOTE_LCD
1798 if (display->screen_type == SCREEN_REMOTE)
1799 display->set_drawmode(DRMODE_INVERSEVID);
1800 else
1801 #endif
1802 display->set_drawmode(DRMODE_BG);
1803 #else
1804 display->set_drawmode(DRMODE_INVERSEVID);
1805 #endif
1806 }
1807 rb->strlcpy(temp_buf, str, c+1);
1808 display->putsxy(xpos, ypos, temp_buf);
1809 str += c;
1810 xpos += w;
1811 count += c;
1812 width += w;
1813 word_count -= c;
1814 word_width -= w;
1815 elapsed -= w;
1816 if (count >= lrc_brpos->count || width >= lrc_brpos->width)
1817 {
1818 /* prepare for next line */
1819 lrc_brpos++;
1820 str = lrc_skip_space(str);
1821 xpos = (vp_lyrics[i].width - lrc_brpos->width)*prefs.align/2;
1822 ypos += font_ui_height;
1823 count = 0;
1824 width = 0;
1825 }
1826 }
1827 lrc_word--;
1828 } while (nword--);
1829 set_to_default(display);
1830 return ypos;
1831 }
1832 #endif /* HAVE_LCD_BITMAP */
1833
1834 static void display_lrcs(void)
1835 {
1836 long time_start, time_end, rin, len;
1837 int i, nline[NB_SCREENS] = {0};
1838 struct lrc_line *lrc_center = current.ll_head;
1839
1840 if (!lrc_center) return;
1841
1842 while (get_time_start(lrc_center->next) <= current.elapsed)
1843 {
1844 nline[SCREEN_MAIN] += lrc_center->nline[SCREEN_MAIN];
1845 #ifdef HAVE_REMOTE_LCD
1846 nline[SCREEN_REMOTE] += lrc_center->nline[SCREEN_REMOTE];
1847 #endif
1848 lrc_center = lrc_center->next;
1849 }
1850
1851 time_start = get_time_start(lrc_center);
1852 time_end = get_time_start(lrc_center->next);
1853 rin = current.elapsed - time_start;
1854 len = time_end - time_start;
1855
1856 struct screen *display;
1857 FOR_NB_SCREENS(i)
1858 {
1859 display = rb->screens[i];
1860 /* display current line at the center of the viewport */
1861 display->set_viewport(&vp_lyrics[i]);
1862 display->clear_viewport();
1863 #ifdef HAVE_LCD_BITMAP
1864 struct lrc_line *lrc_line;
1865 int y, ypos = 0, nblines = vp_lyrics[i].height/font_ui_height;
1866 y = (nblines-1)/2;
1867 if (rin < 0)
1868 {
1869 /* current.elapsed < time of first lrc */
1870 if (!current.wipe)
1871 ypos = (time_start - current.elapsed)
1872 * font_ui_height / time_start;
1873 else
1874 y++;
1875 }
1876 else if (len > 0)
1877 {
1878 if (!current.wipe)
1879 ypos = - rin * lrc_center->nline[i] * font_ui_height / len;
1880 else
1881 {
1882 long elapsed = rin * lrc_center->width / len;
1883 struct lrc_brpos *lrc_brpos = calc_brpos(lrc_center, i);
1884 while (elapsed > lrc_brpos->width)
1885 {
1886 elapsed -= lrc_brpos->width;
1887 y--;
1888 lrc_brpos++;
1889 }
1890 }
1891 }
1892
1893 /* find first line to display */
1894 y -= nline[i];
1895 lrc_line = current.ll_head;
1896 while (y < -lrc_line->nline[i])
1897 {
1898 y += lrc_line->nline[i];
1899 lrc_line = lrc_line->next;
1900 }
1901
1902 ypos += y*font_ui_height;
1903 while (lrc_line && ypos < vp_lyrics[i].height)
1904 {
1905 ypos = display_lrc_line(lrc_line, ypos, i);
1906 lrc_line = lrc_line->next;
1907 }
1908 if (!lrc_line && ypos < vp_lyrics[i].height)
1909 display->putsxy(0, ypos, "[end]");
1910 #else /* HAVE_LCD_CHARCELLS */
1911 struct lrc_line *lrc_line = lrc_center;
1912 struct lrc_brpos *lrc_brpos = calc_brpos(lrc_line, i);
1913 long elapsed = 0;
1914 const char *str = get_lrc_str(lrc_line);
1915 int x = vp_lyrics[i].width/2, y = 0;
1916
1917 if (rin >= 0 && len > 0)
1918 {
1919 elapsed = rin * lrc_center->width / len;
1920 while (elapsed > lrc_brpos->width)
1921 {
1922 elapsed -= lrc_brpos->width;
1923 str = lrc_skip_space(str+lrc_brpos->count);
1924 lrc_brpos++;
1925 }
1926 }
1927 rb->strlcpy(temp_buf, str, lrc_brpos->count+1);
1928
1929 x -= elapsed;
1930 if (x < 0)
1931 display->puts(0, y, temp_buf + rb->utf8seek(temp_buf, -x));
1932 else
1933 display->puts(x, y, temp_buf);
1934 x += rb->utf8length(temp_buf)+1;
1935 lrc_line = lrc_line->next;
1936 if (!lrc_line && x < vp_lyrics[i].width)
1937 {
1938 if (x < vp_lyrics[i].width/2)
1939 x = vp_lyrics[i].width/2;
1940 display->puts(x, y, "[end]");
1941 }
1942 #endif /* HAVE_LCD_BITMAP */
1943 display->update_viewport();
1944 display->set_viewport(NULL);
1945 }
1946 }
1947
1948 /*******************************
1949 * Browse lyrics and edit time.
1950 *******************************/
1951 /* point playing line in lyrics */
1952 static enum themable_icons get_icon(int selected, void * data)
1953 {
1954 (void) data;
1955 struct lrc_line *lrc_line = get_lrc_line(selected);
1956 if (lrc_line)
1957 {
1958 long time_start = get_time_start(lrc_line);
1959 long time_end = get_time_start(lrc_line->next);
1960 long elapsed = current.id3->elapsed;
1961 if (time_start <= elapsed && time_end > elapsed)
1962 return Icon_Moving;
1963 }
1964 return Icon_NOICON;
1965 }
1966 static const char *get_lrc_timeline(int selected, void *data,
1967 char *buffer, size_t buffer_len)
1968 {
1969 (void) data;
1970 struct lrc_line *lrc_line = get_lrc_line(selected);
1971 if (lrc_line)
1972 {
1973 format_time_tag(temp_buf, get_time_start(lrc_line));
1974 rb->snprintf(buffer, buffer_len, "[%s]%s",
1975 temp_buf, get_lrc_str(lrc_line));
1976 return buffer;
1977 }
1978 return NULL;
1979 }
1980
1981 static void save_changes(void)
1982 {
1983 char new_file[MAX_PATH], *p;
1984 bool success = false;
1985 int fd, fe;
1986 if (!current.changed_lrc)
1987 return;
1988 rb->splash(HZ/2, "Saving changes...");
1989 if (current.type == TXT || current.type > NUM_TYPES)
1990 {
1991 /* save changes to new .lrc file */
1992 rb->strcpy(new_file, current.lrc_file);
1993 p = rb->strrchr(new_file, '.');
1994 rb->strcpy(p, extentions[LRC]);
1995 }
1996 else
1997 {
1998 /* file already exists. use temp file. */
1999 rb->snprintf(new_file, MAX_PATH, "%s~", current.lrc_file);
2000 }
2001 fd = rb->creat(new_file, 0666);
2002 fe = rb->open(current.lrc_file, O_RDONLY);
2003 if (fd >= 0 && fe >= 0)
2004 {
2005 struct lrc_line *lrc_line, *temp_lrc;
2006 off_t curr = 0, next = 0, size = 0, offset = 0;
2007 for (lrc_line = current.ll_head; lrc_line;
2008 lrc_line = lrc_line->next)
2009 {
2010 /* apply offset and set old_time_start -1 to indicate
2011 that time tag is not saved yet. */
2012 lrc_line->time_start = get_time_start(lrc_line);
2013 lrc_line->old_time_start = -1;
2014 }
2015 current.offset = 0;
2016 if (current.type > NUM_TYPES)
2017 {
2018 curr = -1;
2019 rb->write(fd, BOM, BOM_SIZE);
2020 }
2021 else
2022 size = rb->filesize(fe);
2023 while (curr < size)
2024 {
2025 /* find offset of next tag */
2026 lrc_line = NULL;
2027 for (temp_lrc = current.ll_head, next = size;
2028 temp_lrc; temp_lrc = temp_lrc->next)
2029 {
2030 offset = temp_lrc->file_offset;
2031 if (offset < next && temp_lrc->old_time_start == -1)
2032 {
2033 lrc_line = temp_lrc;
2034 next = offset;
2035 if (offset <= curr) break;
2036 }
2037 }
2038 offset = current.offset_file_offset;
2039 if (offset >= 0 && offset < next)
2040 {
2041 lrc_line = NULL;
2042 next = offset;
2043 current.offset_file_offset = -1;
2044 }
2045 if (next > curr)
2046 {
2047 if (curr == -1) curr = 0;
2048 /* copy before the next tag */
2049 while (curr < next)
2050 {
2051 ssize_t count = next-curr;
2052 if (count > MAX_LINE_LEN)
2053 count = MAX_LINE_LEN;
2054 if (rb->read(fe, temp_buf, count)!=count)
2055 break;
2056 rb->write(fd, temp_buf, count);
2057 curr += count;
2058 }
2059 if (curr < next || curr >= size) break;
2060 }
2061 /* write tag to new file and skip tag in backup */
2062 if (lrc_line != NULL)
2063 {
2064 lrc_line->file_offset = rb->lseek(fd, 0, SEEK_CUR);
2065 lrc_line->old_time_start = lrc_line->time_start;
2066 long t = lrc_line->time_start;
2067 if (current.type == SNC)
2068 {
2069 rb->fdprintf(fd, "%02ld%02ld%02ld%02ld", (t/3600000)%100,
2070 (t/60000)%60, (t/1000)%60, (t/10)%100);
2071 /* skip time tag */
2072 curr += rb->read(fe, temp_buf, 8);
2073 }
2074 else /* LRC || LRC8 */
2075 {
2076 format_time_tag(temp_buf, t);
2077 rb->fdprintf(fd, "[%s]", temp_buf);
2078 }
2079 if (next == -1)
2080 {
2081 rb->fdprintf(fd, "%s\n", get_lrc_str(lrc_line));
2082 }
2083 }
2084 if (current.type == LRC || current.type == LRC8)
2085 {
2086 /* skip both time tag and offset tag */
2087 while (curr++<size && rb->read(fe, temp_buf, 1)==1)
2088 if (temp_buf[0]==']') break;
2089 }
2090 }
2091 success = (curr>=size);
2092 }
2093 if (fe >= 0) rb->close(fe);
2094 if (fd >= 0) rb->close(fd);
2095
2096 if (success)
2097 {
2098 if (current.type == TXT || current.type > NUM_TYPES)
2099 {
2100 current.type = LRC;
2101 rb->strcpy(current.lrc_file, new_file);
2102 }
2103 else
2104 {
2105 rb->remove(current.lrc_file);
2106 rb->rename(new_file, current.lrc_file);
2107 }
2108 }
2109 else
2110 {
2111 rb->remove(new_file);
2112 rb->splash(HZ, "Could not save changes.");
2113 }
2114 rb->reload_directory();
2115 current.changed_lrc = false;
2116 }
2117 static int timetag_editor(void)
2118 {
2119 struct gui_synclist gui_editor;
2120 struct lrc_line *lrc_line;
2121 bool exit = false;
2122 int button, idx, selected = 0;
2123
2124 if (current.id3 == NULL || !current.ll_head)
2125 {
2126 rb->splash(HZ, "No lyrics");
2127 return LRC_GOTO_MAIN;
2128 }
2129
2130 get_lrc_line(-1); /* initialize static variables */
2131
2132 for (lrc_line = current.ll_head, idx = 0;
2133 lrc_line; lrc_line = lrc_line->next, idx++)
2134 {
2135 long time_start = get_time_start(lrc_line);
2136 long time_end = get_time_start(lrc_line->next);
2137 long elapsed = current.id3->elapsed;
2138 if (time_start <= elapsed && time_end > elapsed)
2139 selected = idx;
2140 }
2141
2142 rb->gui_synclist_init(&gui_editor, &get_lrc_timeline, NULL, false, 1, NULL);
2143 rb->gui_synclist_set_nb_items(&gui_editor, current.nlrcline);
2144 rb->gui_synclist_set_icon_callback(&gui_editor, get_icon);
2145 rb->gui_synclist_set_title(&gui_editor, "Timetag Editor",
2146 Icon_Menu_functioncall);
2147 rb->gui_synclist_select_item(&gui_editor, selected);
2148 rb->gui_synclist_draw(&gui_editor);
2149
2150 while (!exit)
2151 {
2152 button = rb->get_action(CONTEXT_TREE, TIMEOUT_BLOCK);
2153 if (rb->gui_synclist_do_button(&gui_editor, &button,
2154 LIST_WRAP_UNLESS_HELD))
2155 continue;
2156
2157 switch (button)
2158 {
2159 case ACTION_STD_OK:
2160 idx = rb->gui_synclist_get_sel_pos(&gui_editor);
2161 lrc_line = get_lrc_line(idx);
2162 if (lrc_line)
2163 {
2164 set_time_start(lrc_line, current.id3->elapsed-500);
2165 rb->gui_synclist_draw(&gui_editor);
2166 }
2167 break;
2168 case ACTION_STD_CONTEXT:
2169 idx = rb->gui_synclist_get_sel_pos(&gui_editor);
2170 lrc_line = get_lrc_line(idx);
2171 if (lrc_line)
2172 {
2173 long temp_time = get_time_start(lrc_line);
2174 if (lrc_set_time(get_lrc_str(lrc_line), NULL,
2175 &temp_time, 10, 0, current.length,
2176 LST_SET_MSEC|LST_SET_SEC|LST_SET_MIN) == 1)
2177 return PLUGIN_USB_CONNECTED;
2178 set_time_start(lrc_line, temp_time);
2179 rb->gui_synclist_draw(&gui_editor);
2180 }
2181 break;
2182 case ACTION_TREE_STOP:
2183 case ACTION_STD_CANCEL:
2184 exit = true;
2185 break;
2186 default:
2187 if (rb->default_event_handler(button) == SYS_USB_CONNECTED)
2188 return PLUGIN_USB_CONNECTED;
2189 break;
2190 }
2191 }
2192
2193 FOR_NB_SCREENS(idx)
2194 rb->screens[idx]->stop_scroll();
2195
2196 if (current.changed_lrc)
2197 {
2198 MENUITEM_STRINGLIST(save_menu, "Save Changes?", NULL,
2199 "Yes", "No (save later)", "Discard All Changes")
2200 button = 0;
2201 exit = false;
2202 while (!exit)
2203 {
2204 switch (rb->do_menu(&save_menu, &button, NULL, false))
2205 {
2206 case 0:
2207 sort_lrcs();
2208 save_changes();
2209 exit = true;
2210 break;
2211 case 1:
2212 sort_lrcs();
2213 exit = true;
2214 break;
2215 case 2:
2216 init_time_tag();
2217 exit = true;
2218 break;
2219 case MENU_ATTACHED_USB:
2220 return PLUGIN_USB_CONNECTED;
2221 }
2222 }
2223 }
2224 return LRC_GOTO_MAIN;
2225 }
2226
2227 /*******************************
2228 * Settings.
2229 *******************************/
2230 static void load_or_save_settings(bool save)
2231 {
2232 static const char config_file[] = "lrcplayer.cfg";
2233 static struct configdata config[] = {
2234 #ifdef HAVE_LCD_COLOR
2235 { TYPE_INT, 0, 0xffffff, { .int_p = &prefs.inactive_color },
2236 "inactive color", NULL },
2237 #endif
2238 #ifdef HAVE_LCD_BITMAP
2239 { TYPE_BOOL, 0, 1, { .bool_p = &prefs.wrap }, "wrap", NULL },
2240 { TYPE_BOOL, 0, 1, { .bool_p = &prefs.wipe }, "wipe", NULL },
2241 { TYPE_BOOL, 0, 1, { .bool_p = &prefs.active_one_line },
2242 "active one line", NULL },
2243 { TYPE_INT, 0, 2, { .int_p = &prefs.align }, "align", NULL },
2244 { TYPE_BOOL, 0, 1, { .bool_p = &prefs.statusbar_on },
2245 "statusbar on", NULL },
2246 { TYPE_BOOL, 0, 1, { .bool_p = &prefs.display_title },
2247 "display title", NULL },
2248 #endif
2249 { TYPE_BOOL, 0, 1, { .bool_p = &prefs.display_time },
2250 "display time", NULL },
2251 { TYPE_BOOL, 0, 1, { .bool_p = &prefs.backlight_on },
2252 "backlight on", NULL },
2253
2254 { TYPE_STRING, 0, sizeof(prefs.lrc_directory),
2255 { .string = prefs.lrc_directory }, "lrc directory", NULL },
2256 { TYPE_INT, -1, NUM_CODEPAGES-1, { .int_p = &prefs.encoding },
2257 "encoding", NULL },
2258 #ifdef LRC_SUPPORT_ID3
2259 { TYPE_BOOL, 0, 1, { .bool_p = &prefs.read_id3 }, "read id3", NULL },
2260 #endif
2261 };
2262
2263 if (!save)
2264 {
2265 /* initialize setting */
2266 #if LCD_DEPTH > 1
2267 prefs.active_color = rb->lcd_get_foreground();
2268 prefs.inactive_color = LCD_LIGHTGRAY;
2269 #endif
2270 #ifdef HAVE_LCD_BITMAP
2271 prefs.wrap = true;
2272 prefs.wipe = true;
2273 prefs.active_one_line = false;
2274 prefs.align = 1; /* center */
2275 prefs.statusbar_on = false;
2276 prefs.display_title = true;
2277 #endif
2278 prefs.display_time = true;
2279 prefs.backlight_on = false;
2280 #ifdef LRC_SUPPORT_ID3
2281 prefs.read_id3 = true;
2282 #endif
2283 rb->strcpy(prefs.lrc_directory, "/Lyrics");
2284 prefs.encoding = -1; /* default codepage */
2285
2286 configfile_load(config_file, config, ARRAYLEN(config), 0);
2287 }
2288 else if (rb->memcmp(&old_prefs, &prefs, sizeof(prefs)))
2289 {
2290 rb->splash(0, "Saving Settings");
2291 configfile_save(config_file, config, ARRAYLEN(config), 0);
2292 }
2293 rb->memcpy(&old_prefs, &prefs, sizeof(prefs));
2294 }
2295
2296 static bool lrc_theme_menu(void)
2297 {
2298 enum {
2299 #ifdef HAVE_LCD_BITMAP
2300 LRC_MENU_STATUSBAR,
2301 LRC_MENU_DISP_TITLE,
2302 #endif
2303 LRC_MENU_DISP_TIME,
2304 #ifdef HAVE_LCD_COLOR
2305 LRC_MENU_INACTIVE_COLOR,
2306 #endif
2307 LRC_MENU_BACKLIGHT,
2308 };
2309
2310 int selected = 0;
2311 bool exit = false, usb = false;
2312
2313 MENUITEM_STRINGLIST(menu, "Theme Settings", NULL,
2314 #ifdef HAVE_LCD_BITMAP
2315 "Show Statusbar", "Display Title",
2316 #endif
2317 "Display Time",
2318 #ifdef HAVE_LCD_COLOR
2319 "Inactive Colour",
2320 #endif
2321 "Backlight Always On");
2322
2323 while (!exit && !usb)
2324 {
2325 switch (rb->do_menu(&menu, &selected, NULL, false))
2326 {
2327 #ifdef HAVE_LCD_BITMAP
2328 case LRC_MENU_STATUSBAR:
2329 usb = rb->set_bool("Show Statusbar", &prefs.statusbar_on);
2330 break;
2331 case LRC_MENU_DISP_TITLE:
2332 usb = rb->set_bool("Display Title", &prefs.display_title);
2333 break;
2334 #endif
2335 case LRC_MENU_DISP_TIME:
2336 usb = rb->set_bool("Display Time", &prefs.display_time);
2337 break;
2338 #ifdef HAVE_LCD_COLOR
2339 case LRC_MENU_INACTIVE_COLOR:
2340 usb = rb->set_color(NULL, "Inactive Colour",
2341 &prefs.inactive_color, -1);
2342 break;
2343 #endif
2344 case LRC_MENU_BACKLIGHT:
2345 usb = rb->set_bool("Backlight Always On", &prefs.backlight_on);
2346 break;
2347 case MENU_ATTACHED_USB:
2348 usb = true;
2349 break;
2350 default:
2351 exit = true;
2352 break;
2353 }
2354 }
2355
2356 return usb;
2357 }
2358
2359 #ifdef HAVE_LCD_BITMAP
2360 static bool lrc_display_menu(void)
2361 {
2362 enum {
2363 LRC_MENU_WRAP,
2364 LRC_MENU_WIPE,
2365 LRC_MENU_ALIGN,
2366 LRC_MENU_LINE_MODE,
2367 };
2368
2369 int selected = 0;
2370 bool exit = false, usb = false;
2371
2372 MENUITEM_STRINGLIST(menu, "Display Settings", NULL,
2373 "Wrap", "Wipe", "Alignment",
2374 "Activate Only Current Line");
2375
2376 struct opt_items align_names[] = {
2377 {"Left", -1}, {"Centre", -1}, {"Right", -1},
2378 };
2379
2380 while (!exit && !usb)
2381 {
2382 switch (rb->do_menu(&menu, &selected, NULL, false))
2383 {
2384 case LRC_MENU_WRAP:
2385 usb = rb->set_bool("Wrap", &prefs.wrap);
2386 break;
2387 case LRC_MENU_WIPE:
2388 usb = rb->set_bool("Wipe", &prefs.wipe);
2389 break;
2390 case LRC_MENU_ALIGN:
2391 usb = rb->set_option("Alignment", &prefs.align, INT,
2392 align_names, 3, NULL);
2393 break;
2394 case LRC_MENU_LINE_MODE:
2395 usb = rb->set_bool("Activate Only Current Line",
2396 &prefs.active_one_line);
2397 break;
2398 case MENU_ATTACHED_USB:
2399 usb = true;
2400 break;
2401 default:
2402 exit = true;
2403 break;
2404 }
2405 }
2406
2407 return usb;
2408 }
2409 #endif /* HAVE_LCD_BITMAP */
2410
2411 static bool lrc_lyrics_menu(void)
2412 {
2413 enum {
2414 LRC_MENU_ENCODING,
2415 #ifdef LRC_SUPPORT_ID3
2416 LRC_MENU_READ_ID3,
2417 #endif
2418 LRC_MENU_LRC_DIR,
2419 };
2420
2421 int selected = 0;
2422 bool exit = false, usb = false;
2423
2424 struct opt_items cp_names[NUM_CODEPAGES+1];
2425 int old_val;
2426
2427 MENUITEM_STRINGLIST(menu, "Lyrics Settings", NULL,
2428 "Encoding",
2429 #ifdef LRC_SUPPORT_ID3
2430 "Read ID3 tag",
2431 #endif
2432 "Lrc Directry");
2433
2434 cp_names[0].string = "Use default codepage";
2435 cp_names[0].voice_id = -1;
2436 for (old_val = 1; old_val < NUM_CODEPAGES+1; old_val++)
2437 {
2438 cp_names[old_val].string = rb->get_codepage_name(old_val-1);
2439 cp_names[old_val].voice_id = -1;
2440 }
2441
2442 while (!exit && !usb)
2443 {
2444 switch (rb->do_menu(&menu, &selected, NULL, false))
2445 {
2446 case LRC_MENU_ENCODING:
2447 prefs.encoding++;
2448 old_val = prefs.encoding;
2449 usb = rb->set_option("Encoding", &prefs.encoding, INT,
2450 cp_names, NUM_CODEPAGES+1, NULL);
2451 if (prefs.encoding != old_val)
2452 {
2453 save_changes();
2454 if (current.type < NUM_TYPES)
2455 {
2456 /* let reload lrc file to apply encoding setting */
2457 reset_current_data();
2458 }
2459 }
2460 prefs.encoding--;
2461 break;
2462 #ifdef LRC_SUPPORT_ID3
2463 case LRC_MENU_READ_ID3:
2464 usb = rb->set_bool("Read ID3 tag", &prefs.read_id3);
2465 break;
2466 #endif
2467 case LRC_MENU_LRC_DIR:
2468 rb->strcpy(temp_buf, prefs.lrc_directory);
2469 if (!rb->kbd_input(temp_buf, sizeof(prefs.lrc_directory)))
2470 rb->strcpy(prefs.lrc_directory, temp_buf);
2471 break;
2472 case MENU_ATTACHED_USB:
2473 usb = true;
2474 break;
2475 default:
2476 exit = true;
2477 break;
2478 }
2479 }
2480
2481 return usb;
2482 }
2483
2484 #ifdef LRC_DEBUG
2485 static const char* lrc_debug_data(int selected, void * data,
2486 char * buffer, size_t buffer_len)
2487 {
2488 (void)data;
2489 switch (selected)
2490 {
2491 case 0:
2492 rb->strlcpy(buffer, current.mp3_file, buffer_len);
2493 break;
2494 case 1:
2495 rb->strlcpy(buffer, current.lrc_file, buffer_len);
2496 break;
2497 case 2:
2498 rb->snprintf(buffer, buffer_len, "buf usage: %d,%d/%d",
2499 (int)lrc_buffer_used, (int)lrc_buffer_end,
2500 (int)lrc_buffer_size);
2501 break;
2502 case 3:
2503 rb->snprintf(buffer, buffer_len, "line count: %d,%d",
2504 current.nlrcline, current.nlrcbrpos);
2505 break;
2506 case 4:
2507 rb->snprintf(buffer, buffer_len, "loaded lrc? %s",
2508 current.loaded_lrc?"yes":"no");
2509 break;
2510 case 5:
2511 rb->snprintf(buffer, buffer_len, "too many lines? %s",
2512 current.too_many_lines?"yes":"no");
2513 break;
2514 default:
2515 return NULL;
2516 }
2517 return buffer;
2518 }
2519
2520 static bool lrc_debug_menu(void)
2521 {
2522 struct simplelist_info info;
2523 rb->simplelist_info_init(&info, "Debug Menu", 6, NULL);
2524 info.hide_selection = true;
2525 info.scroll_all = true;
2526 info.get_name = lrc_debug_data;
2527 return rb->simplelist_show_list(&info);
2528 }
2529 #endif
2530
2531 /* returns one of enum lrc_screen or enum plugin_status */
2532 static int lrc_menu(void)
2533 {
2534 enum {
2535 LRC_MENU_THEME,
2536 #ifdef HAVE_LCD_BITMAP
2537 LRC_MENU_DISPLAY,
2538 #endif
2539 LRC_MENU_LYRICS,
2540 LRC_MENU_PLAYBACK,
2541 #ifdef LRC_DEBUG
2542 LRC_MENU_DEBUG,
2543 #endif
2544 LRC_MENU_OFFSET,
2545 LRC_MENU_TIMETAG_EDITOR,
2546 LRC_MENU_QUIT,
2547 };
2548
2549 MENUITEM_STRINGLIST(menu, "Lrcplayer Menu", NULL,
2550 "Theme Settings",
2551 #ifdef HAVE_LCD_BITMAP
2552 "Display Settings",
2553 #endif
2554 "Lyrics Settings",
2555 "Playback Control",
2556 #ifdef LRC_DEBUG
2557 "Debug Menu",
2558 #endif
2559 "Time Offset", "Timetag Editor",
2560 "Quit");
2561 int selected = 0, ret = LRC_GOTO_MENU;
2562 bool usb = false;
2563
2564 while (ret == LRC_GOTO_MENU)
2565 {
2566 switch (rb->do_menu(&menu, &selected, NULL, false))
2567 {
2568 case LRC_MENU_THEME:
2569 usb = lrc_theme_menu();
2570 break;
2571 #ifdef HAVE_LCD_BITMAP
2572 case LRC_MENU_DISPLAY:
2573 usb = lrc_display_menu();
2574 break;
2575 #endif
2576 case LRC_MENU_LYRICS:
2577 usb = lrc_lyrics_menu();
2578 break;
2579 case LRC_MENU_PLAYBACK:
2580 usb = playback_control(NULL);
2581 ret = LRC_GOTO_MAIN;
2582 break;
2583 #ifdef LRC_DEBUG
2584 case LRC_MENU_DEBUG:
2585 usb = lrc_debug_menu();
2586 ret = LRC_GOTO_MAIN;
2587 break;
2588 #endif
2589 case LRC_MENU_OFFSET:
2590 usb = (lrc_set_time("Time Offset", "sec", &current.offset,
2591 10, -60*1000, 60*1000,
2592 LST_SET_MSEC|LST_SET_SEC) == 1);
2593 ret = LRC_GOTO_MAIN;
2594 break;
2595 case LRC_MENU_TIMETAG_EDITOR:
2596 ret = LRC_GOTO_EDITOR;
2597 break;
2598 case LRC_MENU_QUIT:
2599 ret = PLUGIN_OK;
2600 break;
2601 case MENU_ATTACHED_USB:
2602 usb = true;
2603 break;
2604 default:
2605 ret = LRC_GOTO_MAIN;
2606 break;
2607 }
2608 if (usb)
2609 ret = PLUGIN_USB_CONNECTED;
2610 }
2611 return ret;
2612 }
2613
2614 /*******************************
2615 * Main.
2616 *******************************/
2617 /* returns true if song has changed to know when to load new lyrics. */
2618 static bool check_audio_status(void)
2619 {
2620 static int last_audio_status = 0;
2621 if (current.ff_rewind == -1)
2622 current.audio_status = rb->audio_status();
2623 current.id3 = rb->audio_current_track();
2624 if ((last_audio_status^current.audio_status)&AUDIO_STATUS_PLAY)
2625 {
2626 last_audio_status = current.audio_status;
2627 return true;
2628 }
2629 if (AUDIO_STOP || current.id3 == NULL)
2630 return false;
2631 if (rb->strcmp(current.mp3_file, current.id3->path))
2632 {
2633 return true;
2634 }
2635 return false;
2636 }
2637 static void ff_rewind(long time, bool resume)
2638 {
2639 if (AUDIO_PLAY)
2640 {
2641 if (!AUDIO_PAUSE)
2642 {
2643 resume = true;
2644 rb->audio_pause();
2645 }
2646 rb->audio_ff_rewind(time);
2647 rb->sleep(HZ/10); /* take affect seeking */
2648 if (resume)
2649 rb->audio_resume();
2650 }
2651 }
2652
2653 static int handle_button(void)
2654 {
2655 int ret = LRC_GOTO_MAIN;
2656 static int step = 0;
2657 int limit, button = rb->get_action(CONTEXT_WPS, HZ/10);
2658 switch (button)
2659 {
2660 case ACTION_WPS_BROWSE:
2661 #if CONFIG_KEYPAD == ONDIO_PAD
2662 /* ondio doesn't have ACTION_WPS_MENU,
2663 so use ACTION_WPS_BROWSE for menu */
2664 ret = LRC_GOTO_MENU;
2665 break;
2666 #endif
2667 case ACTION_WPS_STOP:
2668 save_changes();
2669 ret = PLUGIN_OK;
2670 break;
2671 case ACTION_WPS_PLAY:
2672 if (AUDIO_STOP && rb->global_status->resume_index != -1)
2673 {
2674 if (rb->playlist_resume() != -1)
2675 {
2676 rb->playlist_start(rb->global_status->resume_index,
2677 rb->global_status->resume_offset);
2678 }
2679 }
2680 else if (AUDIO_PAUSE)
2681 rb->audio_resume();
2682 else
2683 rb->audio_pause();
2684 break;
2685 case ACTION_WPS_SEEKFWD:
2686 case ACTION_WPS_SEEKBACK:
2687 if (AUDIO_STOP)
2688 break;
2689 if (current.ff_rewind > -1)
2690 {
2691 if (button == ACTION_WPS_SEEKFWD)
2692 /* fast forwarding, calc max step relative to end */
2693 limit = (current.length - current.ff_rewind) * 3 / 100;
2694 else
2695 /* rewinding, calc max step relative to start */
2696 limit = (current.ff_rewind) * 3 / 100;
2697 limit = MAX(limit, 500);
2698
2699 if (step > limit)
2700 step = limit;
2701
2702 if (button == ACTION_WPS_SEEKFWD)
2703 current.ff_rewind += step;
2704 else
2705 current.ff_rewind -= step;
2706
2707 if (current.ff_rewind > current.length-100)
2708 current.ff_rewind = current.length-100;
2709 if (current.ff_rewind < 0)
2710 current.ff_rewind = 0;
2711
2712 /* smooth seeking by multiplying step by: 1 + (2 ^ -accel) */
2713 step += step >> (rb->global_settings->ff_rewind_accel + 3);
2714 }
2715 else
2716 {
2717 current.ff_rewind = current.elapsed;
2718 if (!AUDIO_PAUSE)
2719 rb->audio_pause();
2720 step = 1000 * rb->global_settings->ff_rewind_min_step;
2721 }
2722 break;
2723 case ACTION_WPS_STOPSEEK:
2724 if (current.ff_rewind == -1)
2725 break;
2726 ff_rewind(current.ff_rewind, !AUDIO_PAUSE);
2727 current.elapsed = current.ff_rewind;
2728 current.ff_rewind = -1;
2729 break;
2730 case ACTION_WPS_SKIPNEXT:
2731 rb->audio_next();
2732 break;
2733 case ACTION_WPS_SKIPPREV:
2734 if (current.elapsed < 3000)
2735 rb->audio_prev();
2736 else
2737 ff_rewind(0, false);
2738 break;
2739 case ACTION_WPS_VOLDOWN:
2740 limit = rb->sound_min(SOUND_VOLUME);
2741 if (--rb->global_settings->volume < limit)
2742 rb->global_settings->volume = limit;
2743 rb->sound_set(SOUND_VOLUME, rb->global_settings->volume);
2744 break;
2745 case ACTION_WPS_VOLUP:
2746 limit = rb->sound_max(SOUND_VOLUME);
2747 if (++rb->global_settings->volume > limit)
2748 rb->global_settings->volume = limit;
2749 rb->sound_set(SOUND_VOLUME, rb->global_settings->volume);
2750 break;
2751 case ACTION_WPS_CONTEXT:
2752 ret = LRC_GOTO_EDITOR;
2753 break;
2754 case ACTION_WPS_MENU:
2755 ret = LRC_GOTO_MENU;
2756 break;
2757 default:
2758 if(rb->default_event_handler(button) == SYS_USB_CONNECTED)
2759 ret = PLUGIN_USB_CONNECTED;
2760 break;
2761 }
2762 return ret;
2763 }
2764
2765 static int lrc_main(void)
2766 {
2767 int ret = LRC_GOTO_MAIN;
2768 int i;
2769 long id3_timeout = 0;
2770 bool update_display_state = true;
2771
2772 #ifdef HAVE_LCD_BITMAP
2773 /* y offset of vp_lyrics */
2774 int h = (prefs.display_title?font_ui_height:0)+
2775 (prefs.display_time?SYSFONT_HEIGHT*2:0);
2776
2777 #endif
2778
2779 FOR_NB_SCREENS(i)
2780 {
2781 #ifdef HAVE_LCD_BITMAP
2782 rb->viewportmanager_theme_enable(i, prefs.statusbar_on, &vp_info[i]);
2783 vp_lyrics[i] = vp_info[i];
2784 vp_lyrics[i].flags &= ~VP_FLAG_ALIGNMENT_MASK;
2785 vp_lyrics[i].y += h;
2786 vp_lyrics[i].height -= h;
2787 #else
2788 rb->viewport_set_defaults(&vp_lyrics[i], i);
2789 if (prefs.display_time)
2790 {
2791 vp_lyrics[i].y += 1; /* time */
2792 vp_lyrics[i].height -= 1;
2793 }
2794 #endif
2795 }
2796
2797 if (prefs.backlight_on)
2798 backlight_ignore_timeout();
2799
2800 #ifdef HAVE_LCD_BITMAP
2801 /* in case settings that may affect break position
2802 * are changed (statusbar_on and wrap). */
2803 if (!current.too_many_lines)
2804 calc_brpos(NULL, 0);
2805 #endif
2806
2807 while (ret == LRC_GOTO_MAIN)
2808 {
2809 if (check_audio_status())
2810 {
2811 update_display_state = true;
2812 if (AUDIO_STOP)
2813 {
2814 current.id3 = NULL;
2815 id3_timeout = 0;
2816 }
2817 else if (rb->strcmp(current.mp3_file, current.id3->path))
2818 {
2819 save_changes();
2820 reset_current_data();
2821 rb->strcpy(current.mp3_file, current.id3->path);
2822 id3_timeout = *rb->current_tick+HZ*3;
2823 current.found_lrc = false;
2824 }
2825 }
2826 if (current.id3 && current.id3->length)
2827 {
2828 if (current.ff_rewind == -1)
2829 {
2830 long di = current.id3->elapsed - current.elapsed;
2831 if (di < -250 || di > 0)
2832 current.elapsed = current.id3->elapsed;
2833 }
2834 else
2835 current.elapsed = current.ff_rewind;
2836 current.length = current.id3->length;
2837 if (current.elapsed > current.length)
2838 current.elapsed = current.length;
2839 }
2840 else
2841 {
2842 current.elapsed = 0;
2843 current.length = 1;
2844 }
2845
2846 if (current.id3 && id3_timeout &&
2847 (TIME_AFTER(*rb->current_tick, id3_timeout) ||
2848 current.id3->artist))
2849 {
2850 update_display_state = true;
2851 id3_timeout = 0;
2852
2853 current.found_lrc = find_lrc_file();
2854 #ifdef LRC_SUPPORT_ID3
2855 if (!current.found_lrc && prefs.read_id3)
2856 {
2857 /* no lyrics file found. try to read from id3 tag. */
2858 current.found_lrc = read_id3();
2859 }
2860 #endif
2861 }
2862 else if (current.found_lrc && !current.loaded_lrc)
2863 {
2864 /* current.loaded_lrc is false after changing encode setting */
2865 update_display_state = true;
2866 display_state();
2867 load_lrc_file();
2868 }
2869 if (update_display_state)
2870 {
2871 #ifdef HAVE_LCD_BITMAP
2872 if (current.type == TXT || current.type == ID3_USLT)
2873 current.wipe = false;
2874 else
2875 current.wipe = prefs.wipe;
2876 #endif
2877 display_state();
2878 update_display_state = false;
2879 }
2880 if (AUDIO_PLAY)
2881 {
2882 if (prefs.display_time)
2883 display_time();
2884 if (!id3_timeout)
2885 display_lrcs();
2886 }
2887
2888 ret = handle_button();
2889 }
2890
2891 #ifdef HAVE_LCD_BITMAP
2892 FOR_NB_SCREENS(i)
2893 rb->viewportmanager_theme_undo(i, false);
2894 #endif
2895 if (prefs.backlight_on)
2896 backlight_use_settings();
2897
2898 return ret;
2899 }
2900
2901 /* this is the plugin entry point */
2902 enum plugin_status plugin_start(const void* parameter)
2903 {
2904 int ret = LRC_GOTO_MAIN;
2905
2906 /* initialize settings. */
2907 load_or_save_settings(false);
2908
2909 #ifdef HAVE_LCD_BITMAP
2910 rb->lcd_getstringsize("O", NULL, &font_ui_height);
2911 #endif
2912
2913 lrc_buffer = rb->plugin_get_buffer(&lrc_buffer_size);
2914 lrc_buffer = (void *)(((long)lrc_buffer+3)&~3); /* 4 bytes aligned */
2915 lrc_buffer_size = (lrc_buffer_size - 4)&~3;
2916
2917 reset_current_data();
2918 current.id3 = NULL;
2919 current.mp3_file[0] = 0;
2920 current.lrc_file[0] = 0;
2921 current.ff_rewind = -1;
2922 current.found_lrc = false;
2923 if (parameter && check_audio_status())
2924 {
2925 const char *ext;
2926 rb->strcpy(current.mp3_file, current.id3->path);
2927 /* use passed parameter as lrc file. */
2928 rb->strcpy(current.lrc_file, parameter);
2929 if (!rb->file_exists(current.lrc_file))
2930 {
2931 rb->splash(HZ, "Specified file dose not exist.");
2932 return PLUGIN_ERROR;
2933 }
2934 ext = rb->strrchr(current.lrc_file, '.');
2935 if (!ext) ext = current.lrc_file;
2936 for (current.type = 0; current.type < NUM_TYPES; current.type++)
2937 {
2938 if (!rb->strcasecmp(ext, extentions[current.type]))
2939 break;
2940 }
2941 if (current.type == NUM_TYPES)
2942 {
2943 rb->splashf(HZ, "%s is not supported", ext);
2944 return PLUGIN_ERROR;
2945 }
2946 current.found_lrc = true;
2947 }
2948
2949 while (ret >= PLUGIN_OTHER)
2950 {
2951 switch (ret)
2952 {
2953 case LRC_GOTO_MAIN:
2954 ret = lrc_main();
2955 break;
2956 case LRC_GOTO_MENU:
2957 ret = lrc_menu();
2958 break;
2959 case LRC_GOTO_EDITOR:
2960 ret = timetag_editor();
2961 break;
2962 default:
2963 ret = PLUGIN_ERROR;
2964 break;
2965 }
2966 }
2967
2968 load_or_save_settings(true);
2969 return ret;
2970 }
thomasjfox's rockbox modifications (mameo port)