summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorJonathan Gordon <rockbox@jdgordon.info>2010-05-17 15:03:59 +0000
committerJonathan Gordon <rockbox@jdgordon.info>2010-05-17 15:03:59 +0000
commitb6867dc9980d19ff6d0954a2a5c7aff7b2b713c3 (patch)
tree2be5d3bfa85a9363711eff0bccec74d3c13e5d4d
parent4862fe4451e3cf17f1c0e369991c37150d9ba560 (diff)
downloadrockbox-b6867dc9980d19ff6d0954a2a5c7aff7b2b713c3.tar.gz
rockbox-b6867dc9980d19ff6d0954a2a5c7aff7b2b713c3.zip
split the radio code into multiple files in the hope that makes it more likely for someone to want to work on! :D
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@26109 a1c6a512-1295-4272-9138-f99709370657
Diffstat
-rw-r--r--apps/SOURCES13
-rw-r--r--apps/radio/presets.c614
-rw-r--r--apps/radio/radio.c (renamed from apps/recorder/radio.c)855
-rw-r--r--apps/radio/radio.h (renamed from apps/recorder/radio.h)15
-rw-r--r--apps/radio/radio_skin.c118
-rw-r--r--apps/radio/radioart.c180
-rwxr-xr-xtools/configure132
7 files changed, 1060 insertions, 867 deletions
diff --git a/apps/SOURCES b/apps/SOURCES
index 98efec944a..93ec93fe27 100644
--- a/apps/SOURCES
+++ b/apps/SOURCES
@@ -132,12 +132,19 @@ recorder/albumart.c
132gui/color_picker.c 132gui/color_picker.c
133#endif 133#endif
134#endif 134#endif
135#if CONFIG_TUNER
136recorder/radio.c
137#endif
138#ifdef HAVE_RECORDING 135#ifdef HAVE_RECORDING
139recorder/recording.c 136recorder/recording.c
140#endif 137#endif
138
139#if CONFIG_TUNER
140radio/radio.c
141radio/presets.c
142radio/radio_skin.c
143#ifdef HAVE_ALBUMART
144radio/radioart.c
145#endif
146#endif
147
141#if CONFIG_CODEC == SWCODEC 148#if CONFIG_CODEC == SWCODEC
142#if INPUT_SRC_CAPS != 0 149#if INPUT_SRC_CAPS != 0
143audio_path.c 150audio_path.c
diff --git a/apps/radio/presets.c b/apps/radio/presets.c
new file mode 100644
index 0000000000..b996e68443
--- /dev/null
+++ b/apps/radio/presets.c
@@ -0,0 +1,614 @@
1/***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id: radio.c -1 $
9 *
10 * Copyright (C) 2003 Linus Nielsen Feltzing
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
22#include "config.h"
23#include <stdio.h>
24#include <stdbool.h>
25#include <stdlib.h>
26#include "settings.h"
27#include "general.h"
28#include "radio.h"
29#include "tuner.h"
30#include "file.h"
31#include "string-extra.h"
32#include "misc.h"
33#include "lang.h"
34#include "action.h"
35#include "list.h"
36#include "splash.h"
37#include "menu.h"
38#include "yesno.h"
39#include "keyboard.h"
40#include "talk.h"
41#include "filetree.h"
42#include "dir.h"
43
44static int curr_preset = -1;
45
46extern int curr_freq; /* from radio.c.. naughty but meh */
47extern int radio_mode;
48int snap_freq_to_grid(int freq);
49void remember_frequency(void);
50void talk_freq(int freq, bool enqueue);
51
52#define MAX_PRESETS 64
53static bool presets_loaded = false, presets_changed = false;
54static struct fmstation presets[MAX_PRESETS];
55
56static char filepreset[MAX_PATH]; /* preset filename variable */
57
58static int num_presets = 0; /* The number of presets in the preset list */
59
60bool yesno_pop(const char* text); /* radio.c */
61
62int radio_current_preset(void)
63{
64 return curr_preset;
65}
66int radio_preset_count(void)
67{
68 return num_presets;
69}
70const struct fmstation *radio_get_preset(int preset)
71{
72 return &presets[preset];
73}
74
75bool has_presets_changed(void)
76{
77 return presets_changed;
78}
79
80
81/* Find a matching preset to freq */
82int find_preset(int freq)
83{
84 int i;
85 if(num_presets < 1)
86 return -1;
87 for(i = 0;i < MAX_PRESETS;i++)
88 {
89 if(freq == presets[i].frequency)
90 return i;
91 }
92
93 return -1;
94}
95
96/* Return the closest preset encountered in the search direction with
97 wraparound. */
98int find_closest_preset(int freq, int direction)
99{
100 int i;
101 int lowpreset = 0;
102 int highpreset = 0;
103 int closest = -1;
104
105 if (direction == 0) /* direction == 0 isn't really used */
106 return 0;
107
108 for (i = 0; i < num_presets; i++)
109 {
110 int f = presets[i].frequency;
111 if (f == freq)
112 return i; /* Exact match = stop */
113
114 /* remember the highest and lowest presets for wraparound */
115 if (f < presets[lowpreset].frequency)
116 lowpreset = i;
117 if (f > presets[highpreset].frequency)
118 highpreset = i;
119
120 /* find the closest preset in the given direction */
121 if (direction > 0 && f > freq)
122 {
123 if (closest < 0 || f < presets[closest].frequency)
124 closest = i;
125 }
126 else if (direction < 0 && f < freq)
127 {
128 if (closest < 0 || f > presets[closest].frequency)
129 closest = i;
130 }
131 }
132
133 if (closest < 0)
134 {
135 /* no presets in the given direction */
136 /* wrap around depending on direction */
137 if (direction < 0)
138 closest = highpreset;
139 else
140 closest = lowpreset;
141 }
142
143 return closest;
144}
145
146void next_preset(int direction)
147{
148 if (num_presets < 1)
149 return;
150
151 if (curr_preset == -1)
152 curr_preset = find_closest_preset(curr_freq, direction);
153 else
154 curr_preset = (curr_preset + direction + num_presets) % num_presets;
155
156 /* Must stay on the current grid for the region */
157 curr_freq = snap_freq_to_grid(presets[curr_preset].frequency);
158
159 tuner_set(RADIO_FREQUENCY, curr_freq);
160 remember_frequency();
161}
162
163void set_current_preset(int preset)
164{
165 curr_preset = preset;
166}
167
168/* Speak a preset by number or by spelling its name, depending on settings. */
169void talk_preset(int preset, bool fallback, bool enqueue)
170{
171 if (global_settings.talk_file == 1) /* number */
172 talk_number(preset + 1, enqueue);
173 else
174 { /* spell */
175 if(presets[preset].name[0])
176 talk_spell(presets[preset].name, enqueue);
177 else if(fallback)
178 talk_freq(presets[preset].frequency, enqueue);
179 }
180}
181
182
183void radio_save_presets(void)
184{
185 int fd;
186 int i;
187
188 fd = creat(filepreset, 0666);
189 if(fd >= 0)
190 {
191 for(i = 0;i < num_presets;i++)
192 {
193 fdprintf(fd, "%d:%s\n", presets[i].frequency, presets[i].name);
194 }
195 close(fd);
196
197 if(!strncasecmp(FMPRESET_PATH, filepreset, strlen(FMPRESET_PATH)))
198 set_file(filepreset, global_settings.fmr_file, MAX_FILENAME);
199 presets_changed = false;
200 }
201 else
202 {
203 splash(HZ, ID2P(LANG_FM_PRESET_SAVE_FAILED));
204 }
205}
206
207void radio_load_presets(char *filename)
208{
209 int fd;
210 int rc;
211 char buf[128];
212 char *freq;
213 char *name;
214 bool done = false;
215 int f;
216
217 memset(presets, 0, sizeof(presets));
218 num_presets = 0;
219
220 /* No Preset in configuration. */
221 if(filename[0] == '\0')
222 {
223 filepreset[0] = '\0';
224 return;
225 }
226 /* Temporary preset, loaded until player shuts down. */
227 else if(filename[0] == '/')
228 strlcpy(filepreset, filename, sizeof(filepreset));
229 /* Preset from default directory. */
230 else
231 snprintf(filepreset, sizeof(filepreset), "%s/%s.fmr",
232 FMPRESET_PATH, filename);
233
234 fd = open_utf8(filepreset, O_RDONLY);
235 if(fd >= 0)
236 {
237 while(!done && num_presets < MAX_PRESETS)
238 {
239 rc = read_line(fd, buf, 128);
240 if(rc > 0)
241 {
242 if(settings_parseline(buf, &freq, &name))
243 {
244 f = atoi(freq);
245 if(f) /* For backwards compatibility */
246 {
247 struct fmstation * const fms = &presets[num_presets];
248 fms->frequency = f;
249 strlcpy(fms->name, name, MAX_FMPRESET_LEN+1);
250 num_presets++;
251 }
252 }
253 }
254 else
255 done = true;
256 }
257 close(fd);
258 }
259 else /* invalid file name? */
260 filepreset[0] = '\0';
261
262 presets_loaded = num_presets > 0;
263 presets_changed = false;
264}
265
266const char* radio_get_preset_name(int preset)
267{
268 if (preset < num_presets)
269 return presets[preset].name;
270 return NULL;
271}
272
273int radio_add_preset(void)
274{
275 char buf[MAX_FMPRESET_LEN + 1];
276
277 if(num_presets < MAX_PRESETS)
278 {
279 buf[0] = '\0';
280
281 if (!kbd_input(buf, MAX_FMPRESET_LEN + 1))
282 {
283 struct fmstation * const fms = &presets[num_presets];
284 strcpy(fms->name, buf);
285 fms->frequency = curr_freq;
286 num_presets++;
287 presets_changed = true;
288 presets_loaded = num_presets > 0;
289 return true;
290 }
291 }
292 else
293 {
294 splash(HZ, ID2P(LANG_FM_NO_FREE_PRESETS));
295 }
296 return false;
297}
298
299/* needed to know which preset we are edit/delete-ing */
300static int selected_preset = -1;
301static int radio_edit_preset(void)
302{
303 char buf[MAX_FMPRESET_LEN + 1];
304
305 if (num_presets > 0)
306 {
307 struct fmstation * const fms = &presets[selected_preset];
308
309 strcpy(buf, fms->name);
310
311 if (!kbd_input(buf, MAX_FMPRESET_LEN + 1))
312 {
313 strcpy(fms->name, buf);
314 presets_changed = true;
315 }
316 }
317
318 return 1;
319}
320
321static int radio_delete_preset(void)
322{
323 if (num_presets > 0)
324 {
325 struct fmstation * const fms = &presets[selected_preset];
326
327 if (selected_preset >= --num_presets)
328 selected_preset = num_presets - 1;
329
330 memmove(fms, fms + 1, (uintptr_t)(fms + num_presets) -
331 (uintptr_t)fms);
332
333 if (curr_preset >= num_presets)
334 --curr_preset;
335 }
336
337 /* Don't ask to save when all presets are deleted. */
338 presets_changed = num_presets > 0;
339
340 if (!presets_changed)
341 {
342 /* The preset list will be cleared, switch to Scan Mode. */
343 radio_mode = RADIO_SCAN_MODE;
344 curr_preset = -1;
345 presets_loaded = false;
346 }
347
348 return 1;
349}
350
351int load_preset_list(void)
352{
353 return !rockbox_browse(FMPRESET_PATH, SHOW_FMR);
354}
355
356int save_preset_list(void)
357{
358 if(num_presets > 0)
359 {
360 bool bad_file_name = true;
361
362 if(!dir_exists(FMPRESET_PATH)) /* Check if there is preset folder */
363 mkdir(FMPRESET_PATH);
364
365 create_numbered_filename(filepreset, FMPRESET_PATH, "preset",
366 ".fmr", 2 IF_CNFN_NUM_(, NULL));
367
368 while(bad_file_name)
369 {
370 if(!kbd_input(filepreset, sizeof(filepreset)))
371 {
372 /* check the name: max MAX_FILENAME (20) chars */
373 char* p2;
374 char* p1;
375 int len;
376 p1 = strrchr(filepreset, '/');
377 p2 = p1;
378 while((p1) && (*p2) && (*p2 != '.'))
379 p2++;
380 len = (int)(p2-p1) - 1;
381 if((!p1) || (len > MAX_FILENAME) || (len == 0))
382 {
383 /* no slash, too long or too short */
384 splash(HZ, ID2P(LANG_INVALID_FILENAME));
385 }
386 else
387 {
388 /* add correct extension (easier to always write)
389 at this point, p2 points to 0 or the extension dot */
390 *p2 = '\0';
391 strcat(filepreset,".fmr");
392 bad_file_name = false;
393 radio_save_presets();
394 }
395 }
396 else
397 {
398 /* user aborted */
399 return false;
400 }
401 }
402 }
403 else
404 splash(HZ, ID2P(LANG_FM_NO_PRESETS));
405
406 return true;
407}
408
409int clear_preset_list(void)
410{
411 /* Clear all the preset entries */
412 memset(presets, 0, sizeof (presets));
413
414 num_presets = 0;
415 presets_loaded = false;
416 /* The preset list will be cleared switch to Scan Mode. */
417 radio_mode = RADIO_SCAN_MODE;
418 curr_preset = -1;
419 presets_changed = false; /* Don't ask to save when clearing the list. */
420
421 return true;
422}
423
424MENUITEM_FUNCTION(radio_edit_preset_item, MENU_FUNC_CHECK_RETVAL,
425 ID2P(LANG_FM_EDIT_PRESET),
426 radio_edit_preset, NULL, NULL, Icon_NOICON);
427MENUITEM_FUNCTION(radio_delete_preset_item, MENU_FUNC_CHECK_RETVAL,
428 ID2P(LANG_FM_DELETE_PRESET),
429 radio_delete_preset, NULL, NULL, Icon_NOICON);
430static int radio_preset_callback(int action,
431 const struct menu_item_ex *this_item)
432{
433 if (action == ACTION_STD_OK)
434 action = ACTION_EXIT_AFTER_THIS_MENUITEM;
435 return action;
436 (void)this_item;
437}
438MAKE_MENU(handle_radio_preset_menu, ID2P(LANG_PRESET),
439 radio_preset_callback, Icon_NOICON, &radio_edit_preset_item,
440 &radio_delete_preset_item);
441/* present a list of preset stations */
442static const char* presets_get_name(int selected_item, void *data,
443 char *buffer, size_t buffer_len)
444{
445 (void)data;
446 struct fmstation *p = &presets[selected_item];
447 if(p->name[0])
448 return p->name;
449 int freq = p->frequency / 10000;
450 int frac = freq % 100;
451 freq /= 100;
452 snprintf(buffer, buffer_len,
453 str(LANG_FM_DEFAULT_PRESET_NAME), freq, frac);
454 return buffer;
455}
456
457static int presets_speak_name(int selected_item, void * data)
458{
459 (void)data;
460 talk_preset(selected_item, true, false);
461 return 0;
462}
463
464int handle_radio_presets(void)
465{
466 struct gui_synclist lists;
467 int result = 0;
468 int action = ACTION_NONE;
469#ifdef HAVE_BUTTONBAR
470 struct gui_buttonbar buttonbar;
471#endif
472
473 if(presets_loaded == false)
474 return result;
475
476#ifdef HAVE_BUTTONBAR
477 gui_buttonbar_init(&buttonbar);
478 gui_buttonbar_set_display(&buttonbar, &(screens[SCREEN_MAIN]) );
479 gui_buttonbar_set(&buttonbar, str(LANG_FM_BUTTONBAR_ADD),
480 str(LANG_FM_BUTTONBAR_EXIT),
481 str(LANG_FM_BUTTONBAR_ACTION));
482 gui_buttonbar_draw(&buttonbar);
483#endif
484 gui_synclist_init(&lists, presets_get_name, NULL, false, 1, NULL);
485 gui_synclist_set_title(&lists, str(LANG_PRESET), NOICON);
486 gui_synclist_set_icon_callback(&lists, NULL);
487 if(global_settings.talk_file)
488 gui_synclist_set_voice_callback(&lists, presets_speak_name);
489 gui_synclist_set_nb_items(&lists, num_presets);
490 gui_synclist_select_item(&lists, curr_preset<0 ? 0 : curr_preset);
491 gui_synclist_speak_item(&lists);
492
493 while (result == 0)
494 {
495 gui_synclist_draw(&lists);
496 list_do_action(CONTEXT_STD, TIMEOUT_BLOCK,
497 &lists, &action, LIST_WRAP_UNLESS_HELD);
498 switch (action)
499 {
500 case ACTION_STD_MENU:
501 if (radio_add_preset())
502 {
503 gui_synclist_set_nb_items(&lists, num_presets);
504 gui_synclist_select_item(&lists, num_presets - 1);
505 }
506 break;
507 case ACTION_STD_CANCEL:
508 result = 1;
509 break;
510 case ACTION_STD_OK:
511 curr_preset = gui_synclist_get_sel_pos(&lists);
512 curr_freq = presets[curr_preset].frequency;
513 next_station(0);
514 remember_frequency();
515 result = 1;
516 break;
517 case ACTION_F3:
518 case ACTION_STD_CONTEXT:
519 selected_preset = gui_synclist_get_sel_pos(&lists);
520 do_menu(&handle_radio_preset_menu, NULL, NULL, false);
521 gui_synclist_set_nb_items(&lists, num_presets);
522 gui_synclist_select_item(&lists, selected_preset);
523 gui_synclist_speak_item(&lists);
524 break;
525 default:
526 if(default_event_handler(action) == SYS_USB_CONNECTED)
527 result = 2;
528 }
529 }
530 return result - 1;
531}
532
533
534int scan_presets(void *viewports)
535{
536 bool do_scan = true;
537 int i;
538 struct viewport *vp = (struct viewport *)viewports;
539
540 FOR_NB_SCREENS(i)
541 screens[i].set_viewport(vp?&vp[i]:NULL);
542 if(num_presets > 0) /* Do that to avoid 2 questions. */
543 do_scan = yesno_pop(ID2P(LANG_FM_CLEAR_PRESETS));
544
545 if(do_scan)
546 {
547 const struct fm_region_data * const fmr =
548 &fm_region_data[global_settings.fm_region];
549
550 curr_freq = fmr->freq_min;
551 num_presets = 0;
552 memset(presets, 0, sizeof(presets));
553
554 tuner_set(RADIO_MUTE, 1);
555
556 while(curr_freq <= fmr->freq_max)
557 {
558 int freq, frac;
559 if(num_presets >= MAX_PRESETS || action_userabort(TIMEOUT_NOBLOCK))
560 break;
561
562 freq = curr_freq / 10000;
563 frac = freq % 100;
564 freq /= 100;
565
566 splashf(0, str(LANG_FM_SCANNING), freq, frac);
567
568 if(tuner_set(RADIO_SCAN_FREQUENCY, curr_freq))
569 {
570 /* add preset */
571 presets[num_presets].name[0] = '\0';
572 presets[num_presets].frequency = curr_freq;
573 num_presets++;
574 }
575
576 curr_freq += fmr->freq_step;
577 }
578
579 if (get_radio_status() == FMRADIO_PLAYING)
580 tuner_set(RADIO_MUTE, 0);
581
582 presets_changed = true;
583
584 FOR_NB_SCREENS(i)
585 {
586 screens[i].clear_viewport();
587 screens[i].update_viewport();
588 }
589
590 if(num_presets > 0)
591 {
592 curr_freq = presets[0].frequency;
593 radio_mode = RADIO_PRESET_MODE;
594 presets_loaded = true;
595 next_station(0);
596 }
597 else
598 {
599 /* Wrap it to beginning or we'll be past end of band */
600 presets_loaded = false;
601 next_station(1);
602 }
603 }
604 return true;
605}
606
607
608void presets_save(void)
609{
610 if(filepreset[0] == '\0')
611 save_preset_list();
612 else
613 radio_save_presets();
614}
diff --git a/apps/recorder/radio.c b/apps/radio/radio.c
index 5425e8a2ab..b3540610f1 100644
--- a/apps/recorder/radio.c
+++ b/apps/radio/radio.c
@@ -131,34 +131,33 @@
131 131
132#endif 132#endif
133 133
134#define RADIO_SCAN_MODE 0 134/* presets.c needs these so keep unstatic or redo the whole thing! */
135#define RADIO_PRESET_MODE 1 135int curr_freq; /* current frequency in Hz */
136 136/* these are all in presets.c... someone PLEASE rework this ! */
137static int curr_preset = -1; 137int handle_radio_presets(void);
138static int curr_freq; /* current frequency in Hz */ 138static bool radio_menu(void);
139static int radio_mode = RADIO_SCAN_MODE; 139int radio_add_preset(void);
140int save_preset_list(void);
141int load_preset_list(void);
142int clear_preset_list(void);
143void next_preset(int direction);
144void set_current_preset(int preset);
145int scan_presets(void *viewports);
146int find_preset(int freq);
147void radio_save_presets(void);
148bool has_presets_changed(void);
149void talk_preset(int preset, bool fallback, bool enqueue);
150void presets_save(void);
151
152
153
154int radio_mode = RADIO_SCAN_MODE;
140static int search_dir = 0; 155static int search_dir = 0;
141 156
142static int radio_status = FMRADIO_OFF; 157static int radio_status = FMRADIO_OFF;
143static bool in_screen = false; 158static bool in_screen = false;
144 159
145#define MAX_PRESETS 64
146static bool presets_loaded = false, presets_changed = false;
147static struct fmstation presets[MAX_PRESETS];
148
149static char filepreset[MAX_PATH]; /* preset filename variable */
150
151static int num_presets = 0; /* The number of presets in the preset list */
152
153static void radio_save_presets(void);
154static int handle_radio_presets(void);
155static bool radio_menu(void);
156static int radio_add_preset(void);
157static int save_preset_list(void);
158static int load_preset_list(void);
159static int clear_preset_list(void);
160 160
161static int scan_presets(void *viewports);
162static void radio_off(void); 161static void radio_off(void);
163 162
164bool radio_scan_mode(void) 163bool radio_scan_mode(void)
@@ -175,21 +174,9 @@ int radio_current_frequency(void)
175 return curr_freq; 174 return curr_freq;
176} 175}
177 176
178int radio_current_preset(void)
179{
180 return curr_preset;
181}
182int radio_preset_count(void)
183{
184 return num_presets;
185}
186const struct fmstation *radio_get_preset(int preset)
187{
188 return &presets[preset];
189}
190/* Function to manipulate all yesno dialogues. 177/* Function to manipulate all yesno dialogues.
191 This function needs the output text as an argument. */ 178 This function needs the output text as an argument. */
192static bool yesno_pop(const char* text) 179bool yesno_pop(const char* text)
193{ 180{
194 int i; 181 int i;
195 const char *lines[]={text}; 182 const char *lines[]={text};
@@ -200,17 +187,12 @@ static bool yesno_pop(const char* text)
200 return ret; 187 return ret;
201} 188}
202 189
203#if defined(HAVE_RECORDING) && defined(HAVE_ALBUMART)
204static void recording_started_handler(void *data);
205static void recording_stopped_handler(void *data);
206#endif
207void radio_init(void) 190void radio_init(void)
208{ 191{
209 tuner_init(); 192 tuner_init();
210 radio_off(); 193 radio_off();
211#if defined(HAVE_RECORDING) && defined(HAVE_ALBUMART) 194#ifdef HAVE_ALBUMART
212 add_event(RECORDING_EVENT_START, false, recording_started_handler); 195 radioart_init(false);
213 add_event(RECORDING_EVENT_STOP, false, recording_stopped_handler);
214#endif 196#endif
215} 197}
216 198
@@ -324,7 +306,7 @@ bool radio_hardware_present(void)
324} 306}
325 307
326/* Keep freq on the grid for the current region */ 308/* Keep freq on the grid for the current region */
327static int snap_freq_to_grid(int freq) 309int snap_freq_to_grid(int freq)
328{ 310{
329 const struct fm_region_data * const fmr = 311 const struct fm_region_data * const fmr =
330 &fm_region_data[global_settings.fm_region]; 312 &fm_region_data[global_settings.fm_region];
@@ -341,72 +323,7 @@ static int snap_freq_to_grid(int freq)
341 return freq; 323 return freq;
342} 324}
343 325
344/* Find a matching preset to freq */ 326void remember_frequency(void)
345static int find_preset(int freq)
346{
347 int i;
348 if(num_presets < 1)
349 return -1;
350 for(i = 0;i < MAX_PRESETS;i++)
351 {
352 if(freq == presets[i].frequency)
353 return i;
354 }
355
356 return -1;
357}
358
359/* Return the closest preset encountered in the search direction with
360 wraparound. */
361static int find_closest_preset(int freq, int direction)
362{
363 int i;
364 int lowpreset = 0;
365 int highpreset = 0;
366 int closest = -1;
367
368 if (direction == 0) /* direction == 0 isn't really used */
369 return 0;
370
371 for (i = 0; i < num_presets; i++)
372 {
373 int f = presets[i].frequency;
374 if (f == freq)
375 return i; /* Exact match = stop */
376
377 /* remember the highest and lowest presets for wraparound */
378 if (f < presets[lowpreset].frequency)
379 lowpreset = i;
380 if (f > presets[highpreset].frequency)
381 highpreset = i;
382
383 /* find the closest preset in the given direction */
384 if (direction > 0 && f > freq)
385 {
386 if (closest < 0 || f < presets[closest].frequency)
387 closest = i;
388 }
389 else if (direction < 0 && f < freq)
390 {
391 if (closest < 0 || f > presets[closest].frequency)
392 closest = i;
393 }
394 }
395
396 if (closest < 0)
397 {
398 /* no presets in the given direction */
399 /* wrap around depending on direction */
400 if (direction < 0)
401 closest = highpreset;
402 else
403 closest = lowpreset;
404 }
405
406 return closest;
407}
408
409static void remember_frequency(void)
410{ 327{
411 const struct fm_region_data * const fmr = 328 const struct fm_region_data * const fmr =
412 &fm_region_data[global_settings.fm_region]; 329 &fm_region_data[global_settings.fm_region];
@@ -415,23 +332,6 @@ static void remember_frequency(void)
415 status_save(); 332 status_save();
416} 333}
417 334
418static void next_preset(int direction)
419{
420 if (num_presets < 1)
421 return;
422
423 if (curr_preset == -1)
424 curr_preset = find_closest_preset(curr_freq, direction);
425 else
426 curr_preset = (curr_preset + direction + num_presets) % num_presets;
427
428 /* Must stay on the current grid for the region */
429 curr_freq = snap_freq_to_grid(presets[curr_preset].frequency);
430
431 tuner_set(RADIO_FREQUENCY, curr_freq);
432 remember_frequency();
433}
434
435/* Step to the next or previous frequency */ 335/* Step to the next or previous frequency */
436static int step_freq(int freq, int direction) 336static int step_freq(int freq, int direction)
437{ 337{
@@ -452,7 +352,7 @@ static int step_freq(int freq, int direction)
452} 352}
453 353
454/* Step to the next or previous station */ 354/* Step to the next or previous station */
455static void next_station(int direction) 355void next_station(int direction)
456{ 356{
457 if (direction != 0 && radio_mode != RADIO_SCAN_MODE) 357 if (direction != 0 && radio_mode != RADIO_SCAN_MODE)
458 { 358 {
@@ -470,7 +370,7 @@ static void next_station(int direction)
470 if (radio_status == FMRADIO_PLAYING) 370 if (radio_status == FMRADIO_PLAYING)
471 tuner_set(RADIO_MUTE, 0); 371 tuner_set(RADIO_MUTE, 0);
472 372
473 curr_preset = find_preset(curr_freq); 373 set_current_preset(find_preset(curr_freq));
474 remember_frequency(); 374 remember_frequency();
475} 375}
476 376
@@ -483,7 +383,7 @@ static void end_search(void)
483} 383}
484 384
485/* Speak a frequency. */ 385/* Speak a frequency. */
486static void talk_freq(int freq, bool enqueue) 386void talk_freq(int freq, bool enqueue)
487{ 387{
488 freq /= 10000; 388 freq /= 10000;
489 talk_number(freq / 100, enqueue); 389 talk_number(freq / 100, enqueue);
@@ -493,224 +393,6 @@ static void talk_freq(int freq, bool enqueue)
493 talk_number(freq % 10, true); 393 talk_number(freq % 10, true);
494} 394}
495 395
496/* Speak a preset by number or by spelling its name, depending on settings. */
497static void talk_preset(int preset, bool fallback, bool enqueue)
498{
499 if (global_settings.talk_file == 1) /* number */
500 talk_number(preset + 1, enqueue);
501 else
502 { /* spell */
503 if(presets[preset].name[0])
504 talk_spell(presets[preset].name, enqueue);
505 else if(fallback)
506 talk_freq(presets[preset].frequency, enqueue);
507 }
508}
509
510/* Skin stuff */
511extern struct wps_state wps_state; /* from wps.c */
512static struct gui_wps fms_skin[NB_SCREENS] = {{ .data = NULL }};
513static struct wps_data fms_skin_data[NB_SCREENS] = {{ .wps_loaded = 0 }};
514static struct wps_sync_data fms_skin_sync_data = { .do_full_update = false };
515
516#ifdef HAVE_ALBUMART
517#define MAX_RADIOART_IMAGES 10
518struct radioart {
519 int handle;
520 long last_tick;
521 struct dim dim;
522 char name[MAX_FMPRESET_LEN+1];
523};
524
525static struct radioart radioart[MAX_RADIOART_IMAGES];
526#ifdef HAVE_RECORDING
527static bool allow_buffer_access = true; /* If we are recording dont touch the buffers! */
528#endif
529static int find_oldest_image(void)
530{
531 int i;
532 long oldest_tick = radioart[0].last_tick;
533 int oldest_idx = 0;
534 for(i=1;i<MAX_RADIOART_IMAGES;i++)
535 {
536 if (radioart[i].last_tick < oldest_tick)
537 {
538 oldest_tick = radioart[i].last_tick;
539 oldest_idx = i;
540 }
541 }
542 return oldest_idx;
543}
544static int load_radioart_image(struct radioart *ra, char* preset_name, struct dim *dim)
545{
546 char path[MAX_PATH];
547#ifndef HAVE_NOISY_IDLE_MODE
548 cpu_idle_mode(false);
549#endif
550 snprintf(path, sizeof(path), FMPRESET_PATH "/%s.bmp",preset_name);
551 if (!file_exists(path))
552 snprintf(path, sizeof(path), FMPRESET_PATH "/%s.jpg",preset_name);
553 if (!file_exists(path))
554 {
555#ifndef HAVE_NOISY_IDLE_MODE
556 cpu_idle_mode(true);
557#endif
558 return -1;
559 }
560 strlcpy(ra->name, preset_name, MAX_FMPRESET_LEN+1);
561 ra->dim.height = dim->height;
562 ra->dim.width = dim->width;
563 ra->last_tick = current_tick;
564 ra->handle = bufopen(path, 0, TYPE_BITMAP, &ra->dim);
565 if (ra->handle == ERR_BUFFER_FULL)
566 {
567 int i = find_oldest_image();
568 bufclose(i);
569 ra->handle = bufopen(path, 0, TYPE_BITMAP, &ra->dim);
570 }
571#ifndef HAVE_NOISY_IDLE_MODE
572 cpu_idle_mode(true);
573#endif
574 return ra->handle;
575}
576int radio_get_art_hid(struct dim *requested_dim)
577{
578 int preset = radio_current_preset();
579 int i, free_idx = -1;
580 if ((radio_mode != RADIO_PRESET_MODE) || preset < 0)
581 return -1;
582#ifdef HAVE_RECORDING
583 if (!allow_buffer_access)
584 return -1;
585#endif
586 for(i=0;i<MAX_RADIOART_IMAGES;i++)
587 {
588 if (radioart[i].handle < 0)
589 {
590 free_idx = i;
591 }
592 else if (!strcmp(radioart[i].name, presets[preset].name) &&
593 radioart[i].dim.width == requested_dim->width &&
594 radioart[i].dim.height == requested_dim->height)
595 {
596 radioart[i].last_tick = current_tick;
597 return radioart[i].handle;
598 }
599 }
600 if (free_idx >= 0)
601 {
602 return load_radioart_image(&radioart[free_idx],
603 presets[preset].name, requested_dim);
604 }
605 else
606 {
607 int i = find_oldest_image();
608 bufclose(radioart[i].handle);
609 return load_radioart_image(&radioart[i],
610 presets[preset].name, requested_dim);
611 }
612
613 return -1;
614}
615static void playback_restarting_handler(void *data)
616{
617 (void)data;
618 int i;
619 for(i=0;i<MAX_RADIOART_IMAGES;i++)
620 {
621 if (radioart[i].handle >= 0)
622 bufclose(radioart[i].handle);
623 radioart[i].handle = -1;
624 radioart[i].name[0] = '\0';
625 }
626}
627#ifdef HAVE_RECORDING
628static void recording_started_handler(void *data)
629{
630 (void)data;
631 allow_buffer_access = false;
632 playback_restarting_handler(NULL);
633}
634static void recording_stopped_handler(void *data)
635{
636 (void)data;
637 allow_buffer_access = true;
638}
639#endif
640#endif
641
642void fms_data_load(enum screen_type screen, const char *buf, bool isfile)
643{
644 struct wps_data *data = fms_skin[screen].data;
645 int success;
646 success = buf && skin_data_load(screen, data, buf, isfile);
647
648 if (!success ) /* load the default */
649 {
650 const char default_fms[] = "%Sx|Station:| %tf\n"
651 "%?ts<%Sx|Stereo||%Sx|Mono|>\n"
652 "%?tm<%Sx|Mode:| %Sx|Scan||%Sx|Preset|: %Ti. %?Tn<%Tn|%Tf>>\n"
653 "%pb\n"
654#if CONFIG_CODEC != SWCODEC && !defined(SIMULATOR)
655 "%?Rr<%Sx|Time:| %Rh:%Rn:%Rs|"
656 "%?St|prerecording time|<%Sx|Prerecord Time| %Rs|%pm>>\n"
657#endif
658#ifdef HAVE_RDS_CAP
659 "\n%s%ty\n"
660 "%s%tz\n"
661#endif
662 ;
663 skin_data_load(screen, data, default_fms, false);
664 }
665}
666enum fms_exiting {
667 FMS_EXIT,
668 FMS_ENTER
669};
670void fms_fix_displays(enum fms_exiting toggle_state)
671{
672 int i;
673 FOR_NB_SCREENS(i)
674 {
675 if (toggle_state == FMS_ENTER)
676 {
677 viewportmanager_theme_enable(i, skin_has_sbs(i, fms_skin[i].data), NULL);
678#if LCD_DEPTH > 1 || defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
679 screens[i].backdrop_show(fms_skin[i].data->backdrop);
680#endif
681 screens[i].clear_display();
682 /* force statusbar/skin update since we just cleared the whole screen */
683 send_event(GUI_EVENT_ACTIONUPDATE, (void*)1);
684 }
685 else
686 {
687 screens[i].stop_scroll();
688#if LCD_DEPTH > 1 || defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
689 screens[i].backdrop_show(sb_get_backdrop(i));
690#endif
691 viewportmanager_theme_undo(i, skin_has_sbs(i, fms_skin[i].data));
692 }
693 }
694}
695
696
697void fms_skin_init(void)
698{
699 int i;
700 FOR_NB_SCREENS(i)
701 {
702#ifdef HAVE_ALBUMART
703 fms_skin_data[i].albumart = NULL;
704 fms_skin_data[i].playback_aa_slot = -1;
705#endif
706 fms_skin[i].data = &fms_skin_data[i];
707 fms_skin[i].display = &screens[i];
708 /* Currently no seperate wps_state needed/possible
709 so use the only available ( "global" ) one */
710 fms_skin[i].state = &wps_state;
711 fms_skin[i].sync_data = &fms_skin_sync_data;
712 }
713}
714 396
715int radio_screen(void) 397int radio_screen(void)
716{ 398{
@@ -743,17 +425,12 @@ int radio_screen(void)
743 /* change status to "in screen" */ 425 /* change status to "in screen" */
744 in_screen = true; 426 in_screen = true;
745 427
746 if(num_presets <= 0) 428 if(radio_preset_count() <= 0)
747 { 429 {
748 radio_load_presets(global_settings.fmr_file); 430 radio_load_presets(global_settings.fmr_file);
749 } 431 }
750#ifdef HAVE_ALBUMART 432#ifdef HAVE_ALBUMART
751 for(i=0;i<MAX_RADIOART_IMAGES;i++) 433 radioart_init(true);
752 {
753 radioart[i].handle = -1;
754 radioart[i].name[0] = '\0';
755 }
756 add_event(PLAYBACK_EVENT_START_PLAYBACK, true, playback_restarting_handler);
757#endif 434#endif
758 435
759 if(radio_status == FMRADIO_OFF) 436 if(radio_status == FMRADIO_OFF)
@@ -793,11 +470,11 @@ int radio_screen(void)
793 radio_start(); 470 radio_start();
794#endif 471#endif
795 472
796 if(num_presets < 1 && yesno_pop(ID2P(LANG_FM_FIRST_AUTOSCAN))) 473 if(radio_preset_count() < 1 && yesno_pop(ID2P(LANG_FM_FIRST_AUTOSCAN)))
797 scan_presets(NULL); 474 scan_presets(NULL);
798 475
799 curr_preset = find_preset(curr_freq); 476 set_current_preset(find_preset(curr_freq));
800 if(curr_preset != -1) 477 if(radio_current_preset() != -1)
801 radio_mode = RADIO_PRESET_MODE; 478 radio_mode = RADIO_PRESET_MODE;
802 479
803#ifndef HAVE_NOISY_IDLE_MODE 480#ifndef HAVE_NOISY_IDLE_MODE
@@ -813,7 +490,7 @@ int radio_screen(void)
813 490
814 if(tuner_set(RADIO_SCAN_FREQUENCY, curr_freq)) 491 if(tuner_set(RADIO_SCAN_FREQUENCY, curr_freq))
815 { 492 {
816 curr_preset = find_preset(curr_freq); 493 set_current_preset(find_preset(curr_freq));
817 remember_frequency(); 494 remember_frequency();
818 end_search(); 495 end_search();
819 talk = true; 496 talk = true;
@@ -826,8 +503,7 @@ int radio_screen(void)
826 cancel_cpu_boost(); 503 cancel_cpu_boost();
827 } 504 }
828 505
829 button = skin_wait_for_action(fms_skin, CONTEXT_FM, 506 button = fms_do_button_loop(update_screen);
830 update_screen ? TIMEOUT_NOBLOCK : HZ);
831 507
832#ifndef HAVE_NOISY_IDLE_MODE 508#ifndef HAVE_NOISY_IDLE_MODE
833 if (button != ACTION_NONE) 509 if (button != ACTION_NONE)
@@ -848,14 +524,11 @@ int radio_screen(void)
848#endif 524#endif
849 { 525 {
850 done = true; 526 done = true;
851 if(presets_changed) 527 if(has_presets_changed())
852 { 528 {
853 if(yesno_pop(ID2P(LANG_FM_SAVE_CHANGES))) 529 if(yesno_pop(ID2P(LANG_FM_SAVE_CHANGES)))
854 { 530 {
855 if(filepreset[0] == '\0') 531 presets_save();
856 save_preset_list();
857 else
858 radio_save_presets();
859 } 532 }
860 } 533 }
861 } 534 }
@@ -901,14 +574,11 @@ int radio_screen(void)
901 keep_playing = true; 574 keep_playing = true;
902 done = true; 575 done = true;
903 ret_val = GO_TO_ROOT; 576 ret_val = GO_TO_ROOT;
904 if(presets_changed) 577 if(has_presets_changed())
905 { 578 {
906 if(yesno_pop(ID2P(LANG_FM_SAVE_CHANGES))) 579 if(yesno_pop(ID2P(LANG_FM_SAVE_CHANGES)))
907 { 580 {
908 if(filepreset[0] == '\0') 581 presets_save();
909 save_preset_list();
910 else
911 radio_save_presets();
912 } 582 }
913 } 583 }
914 584
@@ -971,14 +641,14 @@ int radio_screen(void)
971 case ACTION_FM_MENU: 641 case ACTION_FM_MENU:
972 fms_fix_displays(FMS_EXIT); 642 fms_fix_displays(FMS_EXIT);
973 radio_menu(); 643 radio_menu();
974 curr_preset = find_preset(curr_freq); 644 set_current_preset(find_preset(curr_freq));
975 update_screen = true; 645 update_screen = true;
976 restore = true; 646 restore = true;
977 break; 647 break;
978 648
979#ifdef FM_PRESET 649#ifdef FM_PRESET
980 case ACTION_FM_PRESET: 650 case ACTION_FM_PRESET:
981 if(num_presets < 1) 651 if(radio_preset_count() < 1)
982 { 652 {
983 splash(HZ, ID2P(LANG_FM_NO_PRESETS)); 653 splash(HZ, ID2P(LANG_FM_NO_PRESETS));
984 update_screen = true; 654 update_screen = true;
@@ -1024,7 +694,7 @@ int radio_screen(void)
1024 if(radio_mode == RADIO_SCAN_MODE) 694 if(radio_mode == RADIO_SCAN_MODE)
1025 { 695 {
1026 /* Force scan mode if there are no presets. */ 696 /* Force scan mode if there are no presets. */
1027 if(num_presets > 0) 697 if(radio_preset_count() > 0)
1028 radio_mode = RADIO_PRESET_MODE; 698 radio_mode = RADIO_PRESET_MODE;
1029 } 699 }
1030 else 700 else
@@ -1069,14 +739,11 @@ int radio_screen(void)
1069 keep_playing = false; 739 keep_playing = false;
1070 done = true; 740 done = true;
1071 ret_val = GO_TO_ROOT; 741 ret_val = GO_TO_ROOT;
1072 if(presets_changed) 742 if(has_presets_changed())
1073 { 743 {
1074 if(yesno_pop(ID2P(LANG_FM_SAVE_CHANGES))) 744 if(yesno_pop(ID2P(LANG_FM_SAVE_CHANGES)))
1075 { 745 {
1076 if(filepreset[0] == '\0') 746 radio_save_presets();
1077 save_preset_list();
1078 else
1079 radio_save_presets();
1080 } 747 }
1081 } 748 }
1082 749
@@ -1132,7 +799,7 @@ int radio_screen(void)
1132 if (restore) 799 if (restore)
1133 fms_fix_displays(FMS_ENTER); 800 fms_fix_displays(FMS_ENTER);
1134 FOR_NB_SCREENS(i) 801 FOR_NB_SCREENS(i)
1135 skin_update(&fms_skin[i], WPS_REFRESH_ALL); 802 skin_update(fms_get(i), WPS_REFRESH_ALL);
1136 restore = false; 803 restore = false;
1137 } 804 }
1138 } 805 }
@@ -1148,8 +815,8 @@ int radio_screen(void)
1148 talk_freq(curr_freq, enqueue); 815 talk_freq(curr_freq, enqueue);
1149 enqueue = true; 816 enqueue = true;
1150 } 817 }
1151 if (curr_preset >= 0) 818 if (radio_current_preset() >= 0)
1152 talk_preset(curr_preset, radio_mode == RADIO_PRESET_MODE, 819 talk_preset(radio_current_preset(), radio_mode == RADIO_PRESET_MODE,
1153 enqueue); 820 enqueue);
1154 } 821 }
1155 822
@@ -1224,350 +891,6 @@ int radio_screen(void)
1224#endif 891#endif
1225} /* radio_screen */ 892} /* radio_screen */
1226 893
1227static void radio_save_presets(void)
1228{
1229 int fd;
1230 int i;
1231
1232 fd = creat(filepreset, 0666);
1233 if(fd >= 0)
1234 {
1235 for(i = 0;i < num_presets;i++)
1236 {
1237 fdprintf(fd, "%d:%s\n", presets[i].frequency, presets[i].name);
1238 }
1239 close(fd);
1240
1241 if(!strncasecmp(FMPRESET_PATH, filepreset, strlen(FMPRESET_PATH)))
1242 set_file(filepreset, global_settings.fmr_file, MAX_FILENAME);
1243 presets_changed = false;
1244 }
1245 else
1246 {
1247 splash(HZ, ID2P(LANG_FM_PRESET_SAVE_FAILED));
1248 }
1249}
1250
1251void radio_load_presets(char *filename)
1252{
1253 int fd;
1254 int rc;
1255 char buf[128];
1256 char *freq;
1257 char *name;
1258 bool done = false;
1259 int f;
1260
1261 memset(presets, 0, sizeof(presets));
1262 num_presets = 0;
1263
1264 /* No Preset in configuration. */
1265 if(filename[0] == '\0')
1266 {
1267 filepreset[0] = '\0';
1268 return;
1269 }
1270 /* Temporary preset, loaded until player shuts down. */
1271 else if(filename[0] == '/')
1272 strlcpy(filepreset, filename, sizeof(filepreset));
1273 /* Preset from default directory. */
1274 else
1275 snprintf(filepreset, sizeof(filepreset), "%s/%s.fmr",
1276 FMPRESET_PATH, filename);
1277
1278 fd = open_utf8(filepreset, O_RDONLY);
1279 if(fd >= 0)
1280 {
1281 while(!done && num_presets < MAX_PRESETS)
1282 {
1283 rc = read_line(fd, buf, 128);
1284 if(rc > 0)
1285 {
1286 if(settings_parseline(buf, &freq, &name))
1287 {
1288 f = atoi(freq);
1289 if(f) /* For backwards compatibility */
1290 {
1291 struct fmstation * const fms = &presets[num_presets];
1292 fms->frequency = f;
1293 strlcpy(fms->name, name, MAX_FMPRESET_LEN+1);
1294 num_presets++;
1295 }
1296 }
1297 }
1298 else
1299 done = true;
1300 }
1301 close(fd);
1302 }
1303 else /* invalid file name? */
1304 filepreset[0] = '\0';
1305
1306 presets_loaded = num_presets > 0;
1307 presets_changed = false;
1308}
1309
1310
1311static int radio_add_preset(void)
1312{
1313 char buf[MAX_FMPRESET_LEN + 1];
1314
1315 if(num_presets < MAX_PRESETS)
1316 {
1317 buf[0] = '\0';
1318
1319 if (!kbd_input(buf, MAX_FMPRESET_LEN + 1))
1320 {
1321 struct fmstation * const fms = &presets[num_presets];
1322 strcpy(fms->name, buf);
1323 fms->frequency = curr_freq;
1324 num_presets++;
1325 presets_changed = true;
1326 presets_loaded = num_presets > 0;
1327 return true;
1328 }
1329 }
1330 else
1331 {
1332 splash(HZ, ID2P(LANG_FM_NO_FREE_PRESETS));
1333 }
1334 return false;
1335}
1336
1337/* needed to know which preset we are edit/delete-ing */
1338static int selected_preset = -1;
1339static int radio_edit_preset(void)
1340{
1341 char buf[MAX_FMPRESET_LEN + 1];
1342
1343 if (num_presets > 0)
1344 {
1345 struct fmstation * const fms = &presets[selected_preset];
1346
1347 strcpy(buf, fms->name);
1348
1349 if (!kbd_input(buf, MAX_FMPRESET_LEN + 1))
1350 {
1351 strcpy(fms->name, buf);
1352 presets_changed = true;
1353 }
1354 }
1355
1356 return 1;
1357}
1358
1359static int radio_delete_preset(void)
1360{
1361 if (num_presets > 0)
1362 {
1363 struct fmstation * const fms = &presets[selected_preset];
1364
1365 if (selected_preset >= --num_presets)
1366 selected_preset = num_presets - 1;
1367
1368 memmove(fms, fms + 1, (uintptr_t)(fms + num_presets) -
1369 (uintptr_t)fms);
1370
1371 if (curr_preset >= num_presets)
1372 --curr_preset;
1373 }
1374
1375 /* Don't ask to save when all presets are deleted. */
1376 presets_changed = num_presets > 0;
1377
1378 if (!presets_changed)
1379 {
1380 /* The preset list will be cleared, switch to Scan Mode. */
1381 radio_mode = RADIO_SCAN_MODE;
1382 curr_preset = -1;
1383 presets_loaded = false;
1384 }
1385
1386 return 1;
1387}
1388
1389static int load_preset_list(void)
1390{
1391 return !rockbox_browse(FMPRESET_PATH, SHOW_FMR);
1392}
1393
1394static int save_preset_list(void)
1395{
1396 if(num_presets > 0)
1397 {
1398 bool bad_file_name = true;
1399
1400 if(!dir_exists(FMPRESET_PATH)) /* Check if there is preset folder */
1401 mkdir(FMPRESET_PATH);
1402
1403 create_numbered_filename(filepreset, FMPRESET_PATH, "preset",
1404 ".fmr", 2 IF_CNFN_NUM_(, NULL));
1405
1406 while(bad_file_name)
1407 {
1408 if(!kbd_input(filepreset, sizeof(filepreset)))
1409 {
1410 /* check the name: max MAX_FILENAME (20) chars */
1411 char* p2;
1412 char* p1;
1413 int len;
1414 p1 = strrchr(filepreset, '/');
1415 p2 = p1;
1416 while((p1) && (*p2) && (*p2 != '.'))
1417 p2++;
1418 len = (int)(p2-p1) - 1;
1419 if((!p1) || (len > MAX_FILENAME) || (len == 0))
1420 {
1421 /* no slash, too long or too short */
1422 splash(HZ, ID2P(LANG_INVALID_FILENAME));
1423 }
1424 else
1425 {
1426 /* add correct extension (easier to always write)
1427 at this point, p2 points to 0 or the extension dot */
1428 *p2 = '\0';
1429 strcat(filepreset,".fmr");
1430 bad_file_name = false;
1431 radio_save_presets();
1432 }
1433 }
1434 else
1435 {
1436 /* user aborted */
1437 return false;
1438 }
1439 }
1440 }
1441 else
1442 splash(HZ, ID2P(LANG_FM_NO_PRESETS));
1443
1444 return true;
1445}
1446
1447static int clear_preset_list(void)
1448{
1449 /* Clear all the preset entries */
1450 memset(presets, 0, sizeof (presets));
1451
1452 num_presets = 0;
1453 presets_loaded = false;
1454 /* The preset list will be cleared switch to Scan Mode. */
1455 radio_mode = RADIO_SCAN_MODE;
1456 curr_preset = -1;
1457 presets_changed = false; /* Don't ask to save when clearing the list. */
1458
1459 return true;
1460}
1461
1462MENUITEM_FUNCTION(radio_edit_preset_item, MENU_FUNC_CHECK_RETVAL,
1463 ID2P(LANG_FM_EDIT_PRESET),
1464 radio_edit_preset, NULL, NULL, Icon_NOICON);
1465MENUITEM_FUNCTION(radio_delete_preset_item, MENU_FUNC_CHECK_RETVAL,
1466 ID2P(LANG_FM_DELETE_PRESET),
1467 radio_delete_preset, NULL, NULL, Icon_NOICON);
1468static int radio_preset_callback(int action,
1469 const struct menu_item_ex *this_item)
1470{
1471 if (action == ACTION_STD_OK)
1472 action = ACTION_EXIT_AFTER_THIS_MENUITEM;
1473 return action;
1474 (void)this_item;
1475}
1476MAKE_MENU(handle_radio_preset_menu, ID2P(LANG_PRESET),
1477 radio_preset_callback, Icon_NOICON, &radio_edit_preset_item,
1478 &radio_delete_preset_item);
1479/* present a list of preset stations */
1480static const char* presets_get_name(int selected_item, void *data,
1481 char *buffer, size_t buffer_len)
1482{
1483 (void)data;
1484 struct fmstation *p = &presets[selected_item];
1485 if(p->name[0])
1486 return p->name;
1487 int freq = p->frequency / 10000;
1488 int frac = freq % 100;
1489 freq /= 100;
1490 snprintf(buffer, buffer_len,
1491 str(LANG_FM_DEFAULT_PRESET_NAME), freq, frac);
1492 return buffer;
1493}
1494
1495static int presets_speak_name(int selected_item, void * data)
1496{
1497 (void)data;
1498 talk_preset(selected_item, true, false);
1499 return 0;
1500}
1501
1502static int handle_radio_presets(void)
1503{
1504 struct gui_synclist lists;
1505 int result = 0;
1506 int action = ACTION_NONE;
1507#ifdef HAVE_BUTTONBAR
1508 struct gui_buttonbar buttonbar;
1509#endif
1510
1511 if(presets_loaded == false)
1512 return result;
1513
1514#ifdef HAVE_BUTTONBAR
1515 gui_buttonbar_init(&buttonbar);
1516 gui_buttonbar_set_display(&buttonbar, &(screens[SCREEN_MAIN]) );
1517 gui_buttonbar_set(&buttonbar, str(LANG_FM_BUTTONBAR_ADD),
1518 str(LANG_FM_BUTTONBAR_EXIT),
1519 str(LANG_FM_BUTTONBAR_ACTION));
1520 gui_buttonbar_draw(&buttonbar);
1521#endif
1522 gui_synclist_init(&lists, presets_get_name, NULL, false, 1, NULL);
1523 gui_synclist_set_title(&lists, str(LANG_PRESET), NOICON);
1524 gui_synclist_set_icon_callback(&lists, NULL);
1525 if(global_settings.talk_file)
1526 gui_synclist_set_voice_callback(&lists, presets_speak_name);
1527 gui_synclist_set_nb_items(&lists, num_presets);
1528 gui_synclist_select_item(&lists, curr_preset<0 ? 0 : curr_preset);
1529 gui_synclist_speak_item(&lists);
1530
1531 while (result == 0)
1532 {
1533 gui_synclist_draw(&lists);
1534 list_do_action(CONTEXT_STD, TIMEOUT_BLOCK,
1535 &lists, &action, LIST_WRAP_UNLESS_HELD);
1536 switch (action)
1537 {
1538 case ACTION_STD_MENU:
1539 if (radio_add_preset())
1540 {
1541 gui_synclist_set_nb_items(&lists, num_presets);
1542 gui_synclist_select_item(&lists, num_presets - 1);
1543 }
1544 break;
1545 case ACTION_STD_CANCEL:
1546 result = 1;
1547 break;
1548 case ACTION_STD_OK:
1549 curr_preset = gui_synclist_get_sel_pos(&lists);
1550 curr_freq = presets[curr_preset].frequency;
1551 next_station(0);
1552 remember_frequency();
1553 result = 1;
1554 break;
1555 case ACTION_F3:
1556 case ACTION_STD_CONTEXT:
1557 selected_preset = gui_synclist_get_sel_pos(&lists);
1558 do_menu(&handle_radio_preset_menu, NULL, NULL, false);
1559 gui_synclist_set_nb_items(&lists, num_presets);
1560 gui_synclist_select_item(&lists, selected_preset);
1561 gui_synclist_speak_item(&lists);
1562 break;
1563 default:
1564 if(default_event_handler(action) == SYS_USB_CONNECTED)
1565 result = 2;
1566 }
1567 }
1568 return result - 1;
1569}
1570
1571void toggle_mono_mode(bool mono) 894void toggle_mono_mode(bool mono)
1572{ 895{
1573 tuner_set(RADIO_FORCE_MONO, mono); 896 tuner_set(RADIO_FORCE_MONO, mono);
@@ -1607,78 +930,6 @@ MENUITEM_FUNCTION_DYNTEXT(radio_mode_item, 0,
1607 get_mode_text, NULL, NULL, NULL, Icon_NOICON); 930 get_mode_text, NULL, NULL, NULL, Icon_NOICON);
1608#endif 931#endif
1609 932
1610static int scan_presets(void *viewports)
1611{
1612 bool do_scan = true;
1613 int i;
1614 struct viewport *vp = (struct viewport *)viewports;
1615
1616 FOR_NB_SCREENS(i)
1617 screens[i].set_viewport(vp?&vp[i]:NULL);
1618 if(num_presets > 0) /* Do that to avoid 2 questions. */
1619 do_scan = yesno_pop(ID2P(LANG_FM_CLEAR_PRESETS));
1620
1621 if(do_scan)
1622 {
1623 const struct fm_region_data * const fmr =
1624 &fm_region_data[global_settings.fm_region];
1625
1626 curr_freq = fmr->freq_min;
1627 num_presets = 0;
1628 memset(presets, 0, sizeof(presets));
1629
1630 tuner_set(RADIO_MUTE, 1);
1631
1632 while(curr_freq <= fmr->freq_max)
1633 {
1634 int freq, frac;
1635 if(num_presets >= MAX_PRESETS || action_userabort(TIMEOUT_NOBLOCK))
1636 break;
1637
1638 freq = curr_freq / 10000;
1639 frac = freq % 100;
1640 freq /= 100;
1641
1642 splashf(0, str(LANG_FM_SCANNING), freq, frac);
1643
1644 if(tuner_set(RADIO_SCAN_FREQUENCY, curr_freq))
1645 {
1646 /* add preset */
1647 presets[num_presets].name[0] = '\0';
1648 presets[num_presets].frequency = curr_freq;
1649 num_presets++;
1650 }
1651
1652 curr_freq += fmr->freq_step;
1653 }
1654
1655 if (radio_status == FMRADIO_PLAYING)
1656 tuner_set(RADIO_MUTE, 0);
1657
1658 presets_changed = true;
1659
1660 FOR_NB_SCREENS(i)
1661 {
1662 screens[i].clear_viewport();
1663 screens[i].update_viewport();
1664 }
1665
1666 if(num_presets > 0)
1667 {
1668 curr_freq = presets[0].frequency;
1669 radio_mode = RADIO_PRESET_MODE;
1670 presets_loaded = true;
1671 next_station(0);
1672 }
1673 else
1674 {
1675 /* Wrap it to beginning or we'll be past end of band */
1676 presets_loaded = false;
1677 next_station(1);
1678 }
1679 }
1680 return true;
1681}
1682 933
1683 934
1684#ifdef HAVE_RECORDING 935#ifdef HAVE_RECORDING
@@ -1733,10 +984,18 @@ MENUITEM_FUNCTION(recsettings_item, 0, ID2P(LANG_RECORDING_SETTINGS),
1733 fm_recording_settings, NULL, NULL, Icon_Recording); 984 fm_recording_settings, NULL, NULL, Icon_Recording);
1734#endif 985#endif
1735#ifndef FM_PRESET 986#ifndef FM_PRESET
987int handle_radio_presets_menu(void)
988{
989 return handle_radio_presets();
990}
1736MENUITEM_FUNCTION(radio_presets_item, 0, ID2P(LANG_PRESET), 991MENUITEM_FUNCTION(radio_presets_item, 0, ID2P(LANG_PRESET),
1737 handle_radio_presets, NULL, NULL, Icon_NOICON); 992 handle_radio_presets_menu, NULL, NULL, Icon_NOICON);
1738#endif 993#endif
1739#ifndef FM_PRESET_ADD 994#ifndef FM_PRESET_ADD
995int handle_radio_addpreset_menu(void)
996{
997 return radio_add_preset();
998}
1740MENUITEM_FUNCTION(radio_addpreset_item, 0, ID2P(LANG_FM_ADD_PRESET), 999MENUITEM_FUNCTION(radio_addpreset_item, 0, ID2P(LANG_FM_ADD_PRESET),
1741 radio_add_preset, NULL, NULL, Icon_NOICON); 1000 radio_add_preset, NULL, NULL, Icon_NOICON);
1742#endif 1001#endif
diff --git a/apps/recorder/radio.h b/apps/radio/radio.h
index db23ee5e84..f7b0a0e80b 100644
--- a/apps/recorder/radio.h
+++ b/apps/radio/radio.h
@@ -27,6 +27,11 @@
27#include "screen_access.h" 27#include "screen_access.h"
28#include "bmp.h" 28#include "bmp.h"
29 29
30enum {
31 RADIO_SCAN_MODE = 0,
32 RADIO_PRESET_MODE,
33};
34
30#if CONFIG_TUNER 35#if CONFIG_TUNER
31void radio_load_presets(char *filename); 36void radio_load_presets(char *filename);
32void radio_init(void) INIT_ATTR; 37void radio_init(void) INIT_ATTR;
@@ -59,11 +64,21 @@ struct fmstation
59 int frequency; /* In Hz */ 64 int frequency; /* In Hz */
60 char name[MAX_FMPRESET_LEN+1]; 65 char name[MAX_FMPRESET_LEN+1];
61}; 66};
67const char* radio_get_preset_name(int preset);
62 68
63#ifdef HAVE_ALBUMART 69#ifdef HAVE_ALBUMART
70void radioart_init(bool entering_screen);
64int radio_get_art_hid(struct dim *requested_dim); 71int radio_get_art_hid(struct dim *requested_dim);
65#endif 72#endif
66 73
74void next_station(int direction);
75
76
77enum fms_exiting {
78 FMS_EXIT,
79 FMS_ENTER
80};
81
67#endif /* CONFIG_TUNER */ 82#endif /* CONFIG_TUNER */
68 83
69#endif /* RADIO_H */ 84#endif /* RADIO_H */
diff --git a/apps/radio/radio_skin.c b/apps/radio/radio_skin.c
new file mode 100644
index 0000000000..f9713703ac
--- /dev/null
+++ b/apps/radio/radio_skin.c
@@ -0,0 +1,118 @@
1/***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id: radio.c -1 $
9 *
10 * Copyright (C) 2010 Jonathan Gordon
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
22
23#include "config.h"
24#include <stdio.h>
25#include <stdbool.h>
26#include <stdlib.h>
27#include "skin_engine/skin_engine.h"
28#include "settings.h"
29#include "radio.h"
30#include "action.h"
31#include "appevents.h"
32#include "statusbar-skinned.h"
33
34
35extern struct wps_state wps_state; /* from wps.c */
36static struct gui_wps fms_skin[NB_SCREENS] = {{ .data = NULL }};
37static struct wps_data fms_skin_data[NB_SCREENS] = {{ .wps_loaded = 0 }};
38static struct wps_sync_data fms_skin_sync_data = { .do_full_update = false };
39
40void fms_data_load(enum screen_type screen, const char *buf, bool isfile)
41{
42 struct wps_data *data = fms_skin[screen].data;
43 int success;
44 success = buf && skin_data_load(screen, data, buf, isfile);
45
46 if (!success ) /* load the default */
47 {
48 const char default_fms[] = "%Sx|Station:| %tf\n"
49 "%?ts<%Sx|Stereo||%Sx|Mono|>\n"
50 "%?tm<%Sx|Mode:| %Sx|Scan||%Sx|Preset|: %Ti. %?Tn<%Tn|%Tf>>\n"
51 "%pb\n"
52#if CONFIG_CODEC != SWCODEC && !defined(SIMULATOR)
53 "%?Rr<%Sx|Time:| %Rh:%Rn:%Rs|"
54 "%?St|prerecording time|<%Sx|Prerecord Time| %Rs|%pm>>\n"
55#endif
56#ifdef HAVE_RDS_CAP
57 "\n%s%ty\n"
58 "%s%tz\n"
59#endif
60 ;
61 skin_data_load(screen, data, default_fms, false);
62 }
63}
64void fms_fix_displays(enum fms_exiting toggle_state)
65{
66 int i;
67 FOR_NB_SCREENS(i)
68 {
69 if (toggle_state == FMS_ENTER)
70 {
71 viewportmanager_theme_enable(i, skin_has_sbs(i, fms_skin[i].data), NULL);
72#if LCD_DEPTH > 1 || defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
73 screens[i].backdrop_show(fms_skin[i].data->backdrop);
74#endif
75 screens[i].clear_display();
76 /* force statusbar/skin update since we just cleared the whole screen */
77 send_event(GUI_EVENT_ACTIONUPDATE, (void*)1);
78 }
79 else
80 {
81 screens[i].stop_scroll();
82#if LCD_DEPTH > 1 || defined(HAVE_REMOTE_LCD) && LCD_REMOTE_DEPTH > 1
83 screens[i].backdrop_show(sb_get_backdrop(i));
84#endif
85 viewportmanager_theme_undo(i, skin_has_sbs(i, fms_skin[i].data));
86 }
87 }
88}
89
90
91void fms_skin_init(void)
92{
93 int i;
94 FOR_NB_SCREENS(i)
95 {
96#ifdef HAVE_ALBUMART
97 fms_skin_data[i].albumart = NULL;
98 fms_skin_data[i].playback_aa_slot = -1;
99#endif
100 fms_skin[i].data = &fms_skin_data[i];
101 fms_skin[i].display = &screens[i];
102 /* Currently no seperate wps_state needed/possible
103 so use the only available ( "global" ) one */
104 fms_skin[i].state = &wps_state;
105 fms_skin[i].sync_data = &fms_skin_sync_data;
106 }
107}
108
109int fms_do_button_loop(bool update_screen)
110{
111 return skin_wait_for_action(fms_skin, CONTEXT_FM,
112 update_screen ? TIMEOUT_NOBLOCK : HZ);
113}
114
115struct gui_wps *fms_get(enum screen_type screen)
116{
117 return &fms_skin[screen];
118}
diff --git a/apps/radio/radioart.c b/apps/radio/radioart.c
new file mode 100644
index 0000000000..319f254144
--- /dev/null
+++ b/apps/radio/radioart.c
@@ -0,0 +1,180 @@
1/***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id: radio.c -1 $
9 *
10 * Copyright (C) 2010 Jonathan Gordon
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
22#include "config.h"
23#include <stdio.h>
24#include <stdbool.h>
25#include <stdlib.h>
26#include "settings.h"
27#include "radio.h"
28#include "buffering.h"
29#include "file.h"
30#include "kernel.h"
31#include "string-extra.h"
32#include "misc.h"
33
34#define MAX_RADIOART_IMAGES 10
35struct radioart {
36 int handle;
37 long last_tick;
38 struct dim dim;
39 char name[MAX_FMPRESET_LEN+1];
40};
41
42static struct radioart radioart[MAX_RADIOART_IMAGES];
43#ifdef HAVE_RECORDING
44static bool allow_buffer_access = true; /* If we are recording dont touch the buffers! */
45#endif
46static int find_oldest_image(void)
47{
48 int i;
49 long oldest_tick = radioart[0].last_tick;
50 int oldest_idx = 0;
51 for(i=1;i<MAX_RADIOART_IMAGES;i++)
52 {
53 if (radioart[i].last_tick < oldest_tick)
54 {
55 oldest_tick = radioart[i].last_tick;
56 oldest_idx = i;
57 }
58 }
59 return oldest_idx;
60}
61static int load_radioart_image(struct radioart *ra, const char* preset_name,
62 struct dim *dim)
63{
64 char path[MAX_PATH];
65#ifndef HAVE_NOISY_IDLE_MODE
66 cpu_idle_mode(false);
67#endif
68 snprintf(path, sizeof(path), FMPRESET_PATH "/%s.bmp",preset_name);
69 if (!file_exists(path))
70 snprintf(path, sizeof(path), FMPRESET_PATH "/%s.jpg",preset_name);
71 if (!file_exists(path))
72 {
73#ifndef HAVE_NOISY_IDLE_MODE
74 cpu_idle_mode(true);
75#endif
76 return -1;
77 }
78 strlcpy(ra->name, preset_name, MAX_FMPRESET_LEN+1);
79 ra->dim.height = dim->height;
80 ra->dim.width = dim->width;
81 ra->last_tick = current_tick;
82 ra->handle = bufopen(path, 0, TYPE_BITMAP, &ra->dim);
83 if (ra->handle == ERR_BUFFER_FULL)
84 {
85 int i = find_oldest_image();
86 bufclose(i);
87 ra->handle = bufopen(path, 0, TYPE_BITMAP, &ra->dim);
88 }
89#ifndef HAVE_NOISY_IDLE_MODE
90 cpu_idle_mode(true);
91#endif
92 return ra->handle;
93}
94int radio_get_art_hid(struct dim *requested_dim)
95{
96 int preset = radio_current_preset();
97 int i, free_idx = -1;
98 const char* preset_name;
99 if (radio_scan_mode() || preset < 0)
100 return -1;
101#ifdef HAVE_RECORDING
102 if (!allow_buffer_access)
103 return -1;
104#endif
105 preset_name = radio_get_preset_name(preset);
106 for(i=0;i<MAX_RADIOART_IMAGES;i++)
107 {
108 if (radioart[i].handle < 0)
109 {
110 free_idx = i;
111 }
112 else if (!strcmp(radioart[i].name, preset_name) &&
113 radioart[i].dim.width == requested_dim->width &&
114 radioart[i].dim.height == requested_dim->height)
115 {
116 radioart[i].last_tick = current_tick;
117 return radioart[i].handle;
118 }
119 }
120 if (free_idx >= 0)
121 {
122 return load_radioart_image(&radioart[free_idx],
123 preset_name, requested_dim);
124 }
125 else
126 {
127 int i = find_oldest_image();
128 bufclose(radioart[i].handle);
129 return load_radioart_image(&radioart[i],
130 preset_name, requested_dim);
131 }
132
133 return -1;
134}
135static void playback_restarting_handler(void *data)
136{
137 (void)data;
138 int i;
139 for(i=0;i<MAX_RADIOART_IMAGES;i++)
140 {
141 if (radioart[i].handle >= 0)
142 bufclose(radioart[i].handle);
143 radioart[i].handle = -1;
144 radioart[i].name[0] = '\0';
145 }
146}
147#ifdef HAVE_RECORDING
148static void recording_started_handler(void *data)
149{
150 (void)data;
151 allow_buffer_access = false;
152 playback_restarting_handler(NULL);
153}
154static void recording_stopped_handler(void *data)
155{
156 (void)data;
157 allow_buffer_access = true;
158}
159#endif
160
161void radioart_init(bool entering_screen)
162{
163 int i;
164 if (entering_screen)
165 {
166 for(i=0;i<MAX_RADIOART_IMAGES;i++)
167 {
168 radioart[i].handle = -1;
169 radioart[i].name[0] = '\0';
170 }
171 add_event(PLAYBACK_EVENT_START_PLAYBACK, true, playback_restarting_handler);
172 }
173 else
174 {
175#if defined(HAVE_RECORDING)
176 add_event(RECORDING_EVENT_START, false, recording_started_handler);
177 add_event(RECORDING_EVENT_STOP, false, recording_stopped_handler);
178#endif
179 }
180}
diff --git a/tools/configure b/tools/configure
index bf49be8a9e..ef4d73ad29 100755
--- a/tools/configure
+++ b/tools/configure
@@ -1030,7 +1030,7 @@ fi
1030 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1030 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1031 bmp2rb_native="$rootdir/tools/bmp2rb -f 0" 1031 bmp2rb_native="$rootdir/tools/bmp2rb -f 0"
1032 output="ajbrec.ajz" 1032 output="ajbrec.ajz"
1033 appextra="recorder:gui" 1033 appextra="recorder:gui:radio"
1034 #archosrom="$pwd/rombox.ucl" 1034 #archosrom="$pwd/rombox.ucl"
1035 flash="$pwd/rockbox.ucl" 1035 flash="$pwd/rockbox.ucl"
1036 plugins="yes" 1036 plugins="yes"
@@ -1052,7 +1052,7 @@ fi
1052 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1052 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1053 bmp2rb_native="$rootdir/tools/bmp2rb -f 0" 1053 bmp2rb_native="$rootdir/tools/bmp2rb -f 0"
1054 output="ajbrec.ajz" 1054 output="ajbrec.ajz"
1055 appextra="recorder:gui" 1055 appextra="recorder:gui:radio"
1056 #archosrom="$pwd/rombox.ucl" 1056 #archosrom="$pwd/rombox.ucl"
1057 flash="$pwd/rockbox.ucl" 1057 flash="$pwd/rockbox.ucl"
1058 plugins="yes" 1058 plugins="yes"
@@ -1074,7 +1074,7 @@ fi
1074 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1074 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1075 bmp2rb_native="$rootdir/tools/bmp2rb -f 0" 1075 bmp2rb_native="$rootdir/tools/bmp2rb -f 0"
1076 output="ajbrec.ajz" 1076 output="ajbrec.ajz"
1077 appextra="recorder:gui" 1077 appextra="recorder:gui:radio"
1078 #archosrom="$pwd/rombox.ucl" 1078 #archosrom="$pwd/rombox.ucl"
1079 flash="$pwd/rockbox.ucl" 1079 flash="$pwd/rockbox.ucl"
1080 plugins="yes" 1080 plugins="yes"
@@ -1096,7 +1096,7 @@ fi
1096 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1096 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1097 bmp2rb_native="$rootdir/tools/bmp2rb -f 0" 1097 bmp2rb_native="$rootdir/tools/bmp2rb -f 0"
1098 output="ajbrec.ajz" 1098 output="ajbrec.ajz"
1099 appextra="recorder:gui" 1099 appextra="recorder:gui:radio"
1100 #archosrom="$pwd/rombox.ucl" 1100 #archosrom="$pwd/rombox.ucl"
1101 flash="$pwd/rockbox.ucl" 1101 flash="$pwd/rockbox.ucl"
1102 plugins="yes" 1102 plugins="yes"
@@ -1118,7 +1118,7 @@ fi
1118 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1118 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1119 bmp2rb_native="$rootdir/tools/bmp2rb -f 0" 1119 bmp2rb_native="$rootdir/tools/bmp2rb -f 0"
1120 output="ajbrec.ajz" 1120 output="ajbrec.ajz"
1121 appextra="recorder:gui" 1121 appextra="recorder:gui:radio"
1122 #archosrom="$pwd/rombox.ucl" 1122 #archosrom="$pwd/rombox.ucl"
1123 flash="$pwd/rockbox.ucl" 1123 flash="$pwd/rockbox.ucl"
1124 plugins="yes" 1124 plugins="yes"
@@ -1139,7 +1139,7 @@ fi
1139 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1139 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1140 bmp2rb_native="$rootdir/tools/bmp2rb -f 6" 1140 bmp2rb_native="$rootdir/tools/bmp2rb -f 6"
1141 output="cjbm.ajz" 1141 output="cjbm.ajz"
1142 appextra="recorder:gui" 1142 appextra="recorder:gui:radio"
1143 plugins="yes" 1143 plugins="yes"
1144 swcodec="" 1144 swcodec=""
1145 # toolset is the tools within the tools directory that we build for 1145 # toolset is the tools within the tools directory that we build for
@@ -1164,7 +1164,7 @@ fi
1164 bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0" 1164 bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0"
1165 output="rockbox.iriver" 1165 output="rockbox.iriver"
1166 bootoutput="bootloader.iriver" 1166 bootoutput="bootloader.iriver"
1167 appextra="recorder:gui" 1167 appextra="recorder:gui:radio"
1168 flash="$pwd/rombox.iriver" 1168 flash="$pwd/rombox.iriver"
1169 plugins="yes" 1169 plugins="yes"
1170 swcodec="yes" 1170 swcodec="yes"
@@ -1188,7 +1188,7 @@ fi
1188 bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0" 1188 bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0"
1189 bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0" 1189 bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0"
1190 output="rockbox.iriver" 1190 output="rockbox.iriver"
1191 appextra="recorder:gui" 1191 appextra="recorder:gui:radio"
1192 plugins="yes" 1192 plugins="yes"
1193 swcodec="yes" 1193 swcodec="yes"
1194 # toolset is the tools within the tools directory that we build for 1194 # toolset is the tools within the tools directory that we build for
@@ -1212,7 +1212,7 @@ fi
1212 bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0" 1212 bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0"
1213 output="rockbox.iriver" 1213 output="rockbox.iriver"
1214 bootoutput="bootloader.iriver" 1214 bootoutput="bootloader.iriver"
1215 appextra="recorder:gui" 1215 appextra="recorder:gui:radio"
1216 flash="$pwd/rombox.iriver" 1216 flash="$pwd/rombox.iriver"
1217 plugins="yes" 1217 plugins="yes"
1218 swcodec="yes" 1218 swcodec="yes"
@@ -1234,7 +1234,7 @@ fi
1234 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1234 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1235 bmp2rb_native="$rootdir/tools/bmp2rb -f 0" 1235 bmp2rb_native="$rootdir/tools/bmp2rb -f 0"
1236 output="rockbox.wma" 1236 output="rockbox.wma"
1237 appextra="recorder:gui" 1237 appextra="recorder:gui:radio"
1238 plugins="yes" 1238 plugins="yes"
1239 swcodec="yes" 1239 swcodec="yes"
1240 # toolset is the tools within the tools directory that we build for 1240 # toolset is the tools within the tools directory that we build for
@@ -1255,7 +1255,7 @@ fi
1255 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1255 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1256 bmp2rb_native="$rootdir/tools/bmp2rb -f 5" 1256 bmp2rb_native="$rootdir/tools/bmp2rb -f 5"
1257 output="rockbox.mi4" 1257 output="rockbox.mi4"
1258 appextra="recorder:gui" 1258 appextra="recorder:gui:radio"
1259 plugins="yes" 1259 plugins="yes"
1260 swcodec="yes" 1260 swcodec="yes"
1261 boottool="$rootdir/tools/scramble -mi4v3 -model=h10 -type=RBBL" 1261 boottool="$rootdir/tools/scramble -mi4v3 -model=h10 -type=RBBL"
@@ -1279,7 +1279,7 @@ fi
1279 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1279 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1280 bmp2rb_native="$rootdir/tools/bmp2rb -f 5" 1280 bmp2rb_native="$rootdir/tools/bmp2rb -f 5"
1281 output="rockbox.mi4" 1281 output="rockbox.mi4"
1282 appextra="recorder:gui" 1282 appextra="recorder:gui:radio"
1283 plugins="yes" 1283 plugins="yes"
1284 swcodec="yes" 1284 swcodec="yes"
1285 boottool="$rootdir/tools/scramble -mi4v2 -model=h105 -type=RBBL" 1285 boottool="$rootdir/tools/scramble -mi4v2 -model=h105 -type=RBBL"
@@ -1303,7 +1303,7 @@ fi
1303 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1303 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1304 bmp2rb_native="$rootdir/tools/bmp2rb -f 5" 1304 bmp2rb_native="$rootdir/tools/bmp2rb -f 5"
1305 output="rockbox.ipod" 1305 output="rockbox.ipod"
1306 appextra="recorder:gui" 1306 appextra="recorder:gui:radio"
1307 plugins="yes" 1307 plugins="yes"
1308 swcodec="yes" 1308 swcodec="yes"
1309 bootoutput="bootloader-$modelname.ipod" 1309 bootoutput="bootloader-$modelname.ipod"
@@ -1326,7 +1326,7 @@ fi
1326 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1326 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1327 bmp2rb_native="$rootdir/tools/bmp2rb -f 5" 1327 bmp2rb_native="$rootdir/tools/bmp2rb -f 5"
1328 output="rockbox.ipod" 1328 output="rockbox.ipod"
1329 appextra="recorder:gui" 1329 appextra="recorder:gui:radio"
1330 plugins="yes" 1330 plugins="yes"
1331 swcodec="yes" 1331 swcodec="yes"
1332 bootoutput="bootloader-$modelname.ipod" 1332 bootoutput="bootloader-$modelname.ipod"
@@ -1348,7 +1348,7 @@ fi
1348 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1348 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1349 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 1349 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
1350 output="rockbox.ipod" 1350 output="rockbox.ipod"
1351 appextra="recorder:gui" 1351 appextra="recorder:gui:radio"
1352 plugins="yes" 1352 plugins="yes"
1353 swcodec="yes" 1353 swcodec="yes"
1354 bootoutput="bootloader-$modelname.ipod" 1354 bootoutput="bootloader-$modelname.ipod"
@@ -1371,7 +1371,7 @@ fi
1371 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1371 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1372 bmp2rb_native="$rootdir/tools/bmp2rb -f 6" 1372 bmp2rb_native="$rootdir/tools/bmp2rb -f 6"
1373 output="rockbox.ipod" 1373 output="rockbox.ipod"
1374 appextra="recorder:gui" 1374 appextra="recorder:gui:radio"
1375 plugins="yes" 1375 plugins="yes"
1376 swcodec="yes" 1376 swcodec="yes"
1377 bootoutput="bootloader-$modelname.ipod" 1377 bootoutput="bootloader-$modelname.ipod"
@@ -1394,7 +1394,7 @@ fi
1394 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1394 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1395 bmp2rb_native="$rootdir/tools/bmp2rb -f 6" 1395 bmp2rb_native="$rootdir/tools/bmp2rb -f 6"
1396 output="rockbox.ipod" 1396 output="rockbox.ipod"
1397 appextra="recorder:gui" 1397 appextra="recorder:gui:radio"
1398 plugins="yes" 1398 plugins="yes"
1399 swcodec="yes" 1399 swcodec="yes"
1400 bootoutput="bootloader-$modelname.ipod" 1400 bootoutput="bootloader-$modelname.ipod"
@@ -1417,7 +1417,7 @@ fi
1417 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1417 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1418 bmp2rb_native="$rootdir/tools/bmp2rb -f 6" 1418 bmp2rb_native="$rootdir/tools/bmp2rb -f 6"
1419 output="rockbox.ipod" 1419 output="rockbox.ipod"
1420 appextra="recorder:gui" 1420 appextra="recorder:gui:radio"
1421 plugins="yes" 1421 plugins="yes"
1422 swcodec="yes" 1422 swcodec="yes"
1423 bootoutput="bootloader-$modelname.ipod" 1423 bootoutput="bootloader-$modelname.ipod"
@@ -1440,7 +1440,7 @@ fi
1440 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1440 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1441 bmp2rb_native="$rootdir/tools/bmp2rb -f 6" 1441 bmp2rb_native="$rootdir/tools/bmp2rb -f 6"
1442 output="rockbox.ipod" 1442 output="rockbox.ipod"
1443 appextra="recorder:gui" 1443 appextra="recorder:gui:radio"
1444 plugins="yes" 1444 plugins="yes"
1445 swcodec="yes" 1445 swcodec="yes"
1446 bootoutput="bootloader-$modelname.ipod" 1446 bootoutput="bootloader-$modelname.ipod"
@@ -1463,7 +1463,7 @@ fi
1463 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1463 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1464 bmp2rb_native="$rootdir/tools/bmp2rb -f 6" 1464 bmp2rb_native="$rootdir/tools/bmp2rb -f 6"
1465 output="rockbox.ipod" 1465 output="rockbox.ipod"
1466 appextra="recorder:gui" 1466 appextra="recorder:gui:radio"
1467 plugins="yes" 1467 plugins="yes"
1468 swcodec="yes" 1468 swcodec="yes"
1469 bootoutput="bootloader-$modelname.ipod" 1469 bootoutput="bootloader-$modelname.ipod"
@@ -1486,7 +1486,7 @@ fi
1486 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1486 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1487 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 1487 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
1488 output="rockbox.ipod" 1488 output="rockbox.ipod"
1489 appextra="recorder:gui" 1489 appextra="recorder:gui:radio"
1490 plugins="yes" 1490 plugins="yes"
1491 swcodec="yes" 1491 swcodec="yes"
1492 bootoutput="bootloader-$modelname.ipod" 1492 bootoutput="bootloader-$modelname.ipod"
@@ -1511,7 +1511,7 @@ fi
1511 bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0" 1511 bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0"
1512 bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 7" 1512 bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 7"
1513 output="rockbox.iaudio" 1513 output="rockbox.iaudio"
1514 appextra="recorder:gui" 1514 appextra="recorder:gui:radio"
1515 plugins="yes" 1515 plugins="yes"
1516 swcodec="yes" 1516 swcodec="yes"
1517 # toolset is the tools within the tools directory that we build for 1517 # toolset is the tools within the tools directory that we build for
@@ -1535,7 +1535,7 @@ fi
1535 bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0" 1535 bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0"
1536 bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 7" 1536 bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 7"
1537 output="rockbox.iaudio" 1537 output="rockbox.iaudio"
1538 appextra="recorder:gui" 1538 appextra="recorder:gui:radio"
1539 plugins="yes" 1539 plugins="yes"
1540 swcodec="yes" 1540 swcodec="yes"
1541 # toolset is the tools within the tools directory that we build for 1541 # toolset is the tools within the tools directory that we build for
@@ -1558,7 +1558,7 @@ fi
1558 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1558 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1559 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 1559 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
1560 output="rockbox.iaudio" 1560 output="rockbox.iaudio"
1561 appextra="recorder:gui" 1561 appextra="recorder:gui:radio"
1562 plugins="yes" 1562 plugins="yes"
1563 swcodec="yes" 1563 swcodec="yes"
1564 bootoutput="I7_FW.BIN" 1564 bootoutput="I7_FW.BIN"
@@ -1583,7 +1583,7 @@ fi
1583 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 1583 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
1584 output="rockbox.d2" 1584 output="rockbox.d2"
1585 bootoutput="bootloader-cowond2.bin" 1585 bootoutput="bootloader-cowond2.bin"
1586 appextra="recorder:gui" 1586 appextra="recorder:gui:radio"
1587 plugins="yes" 1587 plugins="yes"
1588 swcodec="yes" 1588 swcodec="yes"
1589 toolset="$tccbitmaptools" 1589 toolset="$tccbitmaptools"
@@ -1603,7 +1603,7 @@ fi
1603 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1603 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1604 bmp2rb_native="$rootdir/tools/bmp2rb -f 7" 1604 bmp2rb_native="$rootdir/tools/bmp2rb -f 7"
1605 output="rockbox.iaudio" 1605 output="rockbox.iaudio"
1606 appextra="recorder:gui" 1606 appextra="recorder:gui:radio"
1607 plugins="yes" 1607 plugins="yes"
1608 swcodec="yes" 1608 swcodec="yes"
1609 # toolset is the tools within the tools directory that we build for 1609 # toolset is the tools within the tools directory that we build for
@@ -1625,7 +1625,7 @@ fi
1625 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1625 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1626 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 1626 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
1627 output="rockbox.gigabeat" 1627 output="rockbox.gigabeat"
1628 appextra="recorder:gui" 1628 appextra="recorder:gui:radio"
1629 plugins="yes" 1629 plugins="yes"
1630 swcodec="yes" 1630 swcodec="yes"
1631 toolset=$gigabeatbitmaptools 1631 toolset=$gigabeatbitmaptools
@@ -1647,7 +1647,7 @@ fi
1647 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1647 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1648 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 1648 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
1649 output="rockbox.gigabeat" 1649 output="rockbox.gigabeat"
1650 appextra="recorder:gui" 1650 appextra="recorder:gui:radio"
1651 plugins="yes" 1651 plugins="yes"
1652 swcodec="yes" 1652 swcodec="yes"
1653 toolset="$gigabeatbitmaptools" 1653 toolset="$gigabeatbitmaptools"
@@ -1671,7 +1671,7 @@ fi
1671 bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0" 1671 bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0"
1672 bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0" 1672 bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0"
1673 output="rockbox.mrobe500" 1673 output="rockbox.mrobe500"
1674 appextra="recorder:gui" 1674 appextra="recorder:gui:radio"
1675 plugins="yes" 1675 plugins="yes"
1676 swcodec="yes" 1676 swcodec="yes"
1677 toolset=$gigabeatbitmaptools 1677 toolset=$gigabeatbitmaptools
@@ -1695,7 +1695,7 @@ fi
1695 bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0" 1695 bmp2rb_remotemono="$rootdir/tools/bmp2rb -f 0"
1696 bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0" 1696 bmp2rb_remotenative="$rootdir/tools/bmp2rb -f 0"
1697 output="rockbox.mi4" 1697 output="rockbox.mi4"
1698 appextra="recorder:gui" 1698 appextra="recorder:gui:radio"
1699 plugins="yes" 1699 plugins="yes"
1700 swcodec="yes" 1700 swcodec="yes"
1701 boottool="$rootdir/tools/scramble -mi4v2 -model=m100 -type=RBBL" 1701 boottool="$rootdir/tools/scramble -mi4v2 -model=m100 -type=RBBL"
@@ -1721,7 +1721,7 @@ fi
1721 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1721 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1722 bmp2rb_native="$rootdir/tools/bmp2rb -f 0" 1722 bmp2rb_native="$rootdir/tools/bmp2rb -f 0"
1723 output="rockbox.logik" 1723 output="rockbox.logik"
1724 appextra="recorder:gui" 1724 appextra="recorder:gui:radio"
1725 plugins="" 1725 plugins=""
1726 swcodec="yes" 1726 swcodec="yes"
1727 # toolset is the tools within the tools directory that we build for 1727 # toolset is the tools within the tools directory that we build for
@@ -1744,7 +1744,7 @@ fi
1744 tool="$rootdir/tools/scramble -creative=zvm" 1744 tool="$rootdir/tools/scramble -creative=zvm"
1745 USE_ELF="yes" 1745 USE_ELF="yes"
1746 output="rockbox.zvm" 1746 output="rockbox.zvm"
1747 appextra="recorder:gui" 1747 appextra="recorder:gui:radio"
1748 plugins="yes" 1748 plugins="yes"
1749 swcodec="yes" 1749 swcodec="yes"
1750 toolset=$ipodbitmaptools 1750 toolset=$ipodbitmaptools
@@ -1767,7 +1767,7 @@ fi
1767 tool="$rootdir/tools/scramble -creative=zvm60 -no-ciff" 1767 tool="$rootdir/tools/scramble -creative=zvm60 -no-ciff"
1768 USE_ELF="yes" 1768 USE_ELF="yes"
1769 output="rockbox.zvm60" 1769 output="rockbox.zvm60"
1770 appextra="recorder:gui" 1770 appextra="recorder:gui:radio"
1771 plugins="yes" 1771 plugins="yes"
1772 swcodec="yes" 1772 swcodec="yes"
1773 toolset=$ipodbitmaptools 1773 toolset=$ipodbitmaptools
@@ -1790,7 +1790,7 @@ fi
1790 tool="$rootdir/tools/scramble -creative=zenvision -no-ciff" 1790 tool="$rootdir/tools/scramble -creative=zenvision -no-ciff"
1791 USE_ELF="yes" 1791 USE_ELF="yes"
1792 output="rockbox.zv" 1792 output="rockbox.zv"
1793 appextra="recorder:gui" 1793 appextra="recorder:gui:radio"
1794 plugins="" 1794 plugins=""
1795 swcodec="yes" 1795 swcodec="yes"
1796 toolset=$ipodbitmaptools 1796 toolset=$ipodbitmaptools
@@ -1812,7 +1812,7 @@ fi
1812 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1812 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1813 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 1813 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
1814 output="rockbox.mi4" 1814 output="rockbox.mi4"
1815 appextra="recorder:gui" 1815 appextra="recorder:gui:radio"
1816 plugins="yes" 1816 plugins="yes"
1817 swcodec="yes" 1817 swcodec="yes"
1818 boottool="$rootdir/tools/scramble -mi4v3 -model=e200 -type=RBBL" 1818 boottool="$rootdir/tools/scramble -mi4v3 -model=e200 -type=RBBL"
@@ -1839,7 +1839,7 @@ fi
1839 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1839 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1840 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 1840 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
1841 output="rockbox.mi4" 1841 output="rockbox.mi4"
1842 appextra="recorder:gui" 1842 appextra="recorder:gui:radio"
1843 plugins="yes" 1843 plugins="yes"
1844 swcodec="yes" 1844 swcodec="yes"
1845 boottool="$rootdir/tools/scramble -mi4r -model=e20r -type=RBBL" 1845 boottool="$rootdir/tools/scramble -mi4r -model=e20r -type=RBBL"
@@ -1863,7 +1863,7 @@ fi
1863 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1863 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1864 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 1864 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
1865 output="rockbox.mi4" 1865 output="rockbox.mi4"
1866 appextra="recorder:gui" 1866 appextra="recorder:gui:radio"
1867 plugins="yes" 1867 plugins="yes"
1868 swcodec="yes" 1868 swcodec="yes"
1869 boottool="$rootdir/tools/scramble -mi4v3 -model=c200 -type=RBBL" 1869 boottool="$rootdir/tools/scramble -mi4v3 -model=c200 -type=RBBL"
@@ -1889,7 +1889,7 @@ fi
1889 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1889 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1890 bmp2rb_native="$rootdir/tools/bmp2rb -f 0" 1890 bmp2rb_native="$rootdir/tools/bmp2rb -f 0"
1891 output="rockbox.m200" 1891 output="rockbox.m200"
1892 appextra="recorder:gui" 1892 appextra="recorder:gui:radio"
1893 plugins="" 1893 plugins=""
1894 swcodec="yes" 1894 swcodec="yes"
1895 # toolset is the tools within the tools directory that we build for 1895 # toolset is the tools within the tools directory that we build for
@@ -1913,7 +1913,7 @@ fi
1913 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 1913 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
1914 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 1914 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
1915 output="rockbox.c100" 1915 output="rockbox.c100"
1916 appextra="recorder:gui" 1916 appextra="recorder:gui:radio"
1917 plugins="" 1917 plugins=""
1918 swcodec="yes" 1918 swcodec="yes"
1919 # toolset is the tools within the tools directory that we build for 1919 # toolset is the tools within the tools directory that we build for
@@ -1935,7 +1935,7 @@ fi
1935 tool="$rootdir/tools/scramble -add=clip" 1935 tool="$rootdir/tools/scramble -add=clip"
1936 output="rockbox.sansa" 1936 output="rockbox.sansa"
1937 bootoutput="bootloader-clip.sansa" 1937 bootoutput="bootloader-clip.sansa"
1938 appextra="recorder:gui" 1938 appextra="recorder:gui:radio"
1939 plugins="yes" 1939 plugins="yes"
1940 swcodec="yes" 1940 swcodec="yes"
1941 toolset=$scramblebitmaptools 1941 toolset=$scramblebitmaptools
@@ -1956,7 +1956,7 @@ fi
1956 tool="$rootdir/tools/scramble -add=e2v2" 1956 tool="$rootdir/tools/scramble -add=e2v2"
1957 output="rockbox.sansa" 1957 output="rockbox.sansa"
1958 bootoutput="bootloader-e200v2.sansa" 1958 bootoutput="bootloader-e200v2.sansa"
1959 appextra="recorder:gui" 1959 appextra="recorder:gui:radio"
1960 plugins="yes" 1960 plugins="yes"
1961 swcodec="yes" 1961 swcodec="yes"
1962 toolset=$scramblebitmaptools 1962 toolset=$scramblebitmaptools
@@ -1977,7 +1977,7 @@ fi
1977 tool="$rootdir/tools/scramble -add=m2v4" 1977 tool="$rootdir/tools/scramble -add=m2v4"
1978 output="rockbox.sansa" 1978 output="rockbox.sansa"
1979 bootoutput="bootloader-m200v4.sansa" 1979 bootoutput="bootloader-m200v4.sansa"
1980 appextra="recorder:gui" 1980 appextra="recorder:gui:radio"
1981 plugins="yes" 1981 plugins="yes"
1982 swcodec="yes" 1982 swcodec="yes"
1983 toolset=$scramblebitmaptools 1983 toolset=$scramblebitmaptools
@@ -1998,7 +1998,7 @@ fi
1998 tool="$rootdir/tools/scramble -add=fuze" 1998 tool="$rootdir/tools/scramble -add=fuze"
1999 output="rockbox.sansa" 1999 output="rockbox.sansa"
2000 bootoutput="bootloader-fuze.sansa" 2000 bootoutput="bootloader-fuze.sansa"
2001 appextra="recorder:gui" 2001 appextra="recorder:gui:radio"
2002 plugins="yes" 2002 plugins="yes"
2003 swcodec="yes" 2003 swcodec="yes"
2004 toolset=$scramblebitmaptools 2004 toolset=$scramblebitmaptools
@@ -2019,7 +2019,7 @@ fi
2019 tool="$rootdir/tools/scramble -add=c2v2" 2019 tool="$rootdir/tools/scramble -add=c2v2"
2020 output="rockbox.sansa" 2020 output="rockbox.sansa"
2021 bootoutput="bootloader-c200v2.sansa" 2021 bootoutput="bootloader-c200v2.sansa"
2022 appextra="recorder:gui" 2022 appextra="recorder:gui:radio"
2023 plugins="yes" 2023 plugins="yes"
2024 swcodec="yes" 2024 swcodec="yes"
2025 # toolset is the tools within the tools directory that we build for 2025 # toolset is the tools within the tools directory that we build for
@@ -2042,7 +2042,7 @@ fi
2042 tool="$rootdir/tools/scramble -add=clv2" 2042 tool="$rootdir/tools/scramble -add=clv2"
2043 output="rockbox.sansa" 2043 output="rockbox.sansa"
2044 bootoutput="bootloader-clipv2.sansa" 2044 bootoutput="bootloader-clipv2.sansa"
2045 appextra="recorder:gui" 2045 appextra="recorder:gui:radio"
2046 plugins="yes" 2046 plugins="yes"
2047 swcodec="yes" 2047 swcodec="yes"
2048 toolset=$scramblebitmaptools 2048 toolset=$scramblebitmaptools
@@ -2086,7 +2086,7 @@ fi
2086 tool="$rootdir/tools/scramble -add=cli+" 2086 tool="$rootdir/tools/scramble -add=cli+"
2087 output="rockbox.sansa" 2087 output="rockbox.sansa"
2088 bootoutput="bootloader-clipplus.sansa" 2088 bootoutput="bootloader-clipplus.sansa"
2089 appextra="recorder:gui" 2089 appextra="recorder:gui:radio"
2090 plugins="yes" 2090 plugins="yes"
2091 swcodec="yes" 2091 swcodec="yes"
2092 toolset=$scramblebitmaptools 2092 toolset=$scramblebitmaptools
@@ -2106,7 +2106,7 @@ fi
2106 tool="$rootdir/tools/scramble -add=fuz2" 2106 tool="$rootdir/tools/scramble -add=fuz2"
2107 output="rockbox.sansa" 2107 output="rockbox.sansa"
2108 bootoutput="bootloader-fuzev2.sansa" 2108 bootoutput="bootloader-fuzev2.sansa"
2109 appextra="recorder:gui" 2109 appextra="recorder:gui:radio"
2110 plugins="yes" 2110 plugins="yes"
2111 swcodec="yes" 2111 swcodec="yes"
2112 toolset=$scramblebitmaptools 2112 toolset=$scramblebitmaptools
@@ -2126,7 +2126,7 @@ fi
2126 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 2126 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
2127 bmp2rb_native="$rootdir/tools/bmp2rb -f 5" 2127 bmp2rb_native="$rootdir/tools/bmp2rb -f 5"
2128 output="rockbox.elio" 2128 output="rockbox.elio"
2129 appextra="recorder:gui" 2129 appextra="recorder:gui:radio"
2130 plugins="yes" 2130 plugins="yes"
2131 swcodec="yes" 2131 swcodec="yes"
2132 boottool="$rootdir/tools/scramble -mi4v2" 2132 boottool="$rootdir/tools/scramble -mi4v2"
@@ -2150,7 +2150,7 @@ fi
2150 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 2150 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
2151 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 2151 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
2152 output="rockbox.mi4" 2152 output="rockbox.mi4"
2153 appextra="recorder:gui" 2153 appextra="recorder:gui:radio"
2154 plugins="" 2154 plugins=""
2155 swcodec="yes" 2155 swcodec="yes"
2156 boottool="$rootdir/tools/scramble -mi4v3 -model=9200 -type=RBBL" 2156 boottool="$rootdir/tools/scramble -mi4v3 -model=9200 -type=RBBL"
@@ -2174,7 +2174,7 @@ fi
2174 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 2174 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
2175 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 2175 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
2176 output="rockbox.mi4" 2176 output="rockbox.mi4"
2177 appextra="recorder:gui" 2177 appextra="recorder:gui:radio"
2178 plugins="yes" 2178 plugins="yes"
2179 swcodec="yes" 2179 swcodec="yes"
2180 boottool="$rootdir/tools/scramble -mi4v3 -model=1630 -type=RBBL" 2180 boottool="$rootdir/tools/scramble -mi4v3 -model=1630 -type=RBBL"
@@ -2198,7 +2198,7 @@ fi
2198 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 2198 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
2199 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 2199 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
2200 output="rockbox.mi4" 2200 output="rockbox.mi4"
2201 appextra="recorder:gui" 2201 appextra="recorder:gui:radio"
2202 plugins="" 2202 plugins=""
2203 swcodec="yes" 2203 swcodec="yes"
2204 boottool="$rootdir/tools/scramble -mi4v3 -model=6330 -type=RBBL" 2204 boottool="$rootdir/tools/scramble -mi4v3 -model=6330 -type=RBBL"
@@ -2222,7 +2222,7 @@ fi
2222 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 2222 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
2223 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 2223 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
2224 output="rockbox.meizu" 2224 output="rockbox.meizu"
2225 appextra="recorder:gui" 2225 appextra="recorder:gui:radio"
2226 plugins="no" #FIXME 2226 plugins="no" #FIXME
2227 swcodec="yes" 2227 swcodec="yes"
2228 toolset=$genericbitmaptools 2228 toolset=$genericbitmaptools
@@ -2244,7 +2244,7 @@ fi
2244 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 2244 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
2245 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 2245 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
2246 output="rockbox.meizu" 2246 output="rockbox.meizu"
2247 appextra="recorder:gui" 2247 appextra="recorder:gui:radio"
2248 plugins="no" #FIXME 2248 plugins="no" #FIXME
2249 swcodec="yes" 2249 swcodec="yes"
2250 toolset=$genericbitmaptools 2250 toolset=$genericbitmaptools
@@ -2266,7 +2266,7 @@ fi
2266 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 2266 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
2267 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 2267 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
2268 output="rockbox.meizu" 2268 output="rockbox.meizu"
2269 appextra="recorder:gui" 2269 appextra="recorder:gui:radio"
2270 plugins="no" #FIXME 2270 plugins="no" #FIXME
2271 swcodec="yes" 2271 swcodec="yes"
2272 toolset=$genericbitmaptools 2272 toolset=$genericbitmaptools
@@ -2288,7 +2288,7 @@ fi
2288 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 2288 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
2289 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 2289 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
2290 output="rockbox.vx747" 2290 output="rockbox.vx747"
2291 appextra="recorder:gui" 2291 appextra="recorder:gui:radio"
2292 plugins="yes" 2292 plugins="yes"
2293 swcodec="yes" 2293 swcodec="yes"
2294 toolset=$genericbitmaptools 2294 toolset=$genericbitmaptools
@@ -2310,7 +2310,7 @@ fi
2310 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 2310 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
2311 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 2311 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
2312 output="rockbox.vx767" 2312 output="rockbox.vx767"
2313 appextra="recorder:gui" 2313 appextra="recorder:gui:radio"
2314 plugins="" #FIXME 2314 plugins="" #FIXME
2315 swcodec="yes" 2315 swcodec="yes"
2316 toolset=$genericbitmaptools 2316 toolset=$genericbitmaptools
@@ -2332,7 +2332,7 @@ fi
2332 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 2332 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
2333 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 2333 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
2334 output="rockbox.vx747p" 2334 output="rockbox.vx747p"
2335 appextra="recorder:gui" 2335 appextra="recorder:gui:radio"
2336 plugins="yes" 2336 plugins="yes"
2337 swcodec="yes" 2337 swcodec="yes"
2338 toolset=$genericbitmaptools 2338 toolset=$genericbitmaptools
@@ -2354,7 +2354,7 @@ fi
2354 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 2354 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
2355 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 2355 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
2356 output="rockbox.vx777" 2356 output="rockbox.vx777"
2357 appextra="recorder:gui" 2357 appextra="recorder:gui:radio"
2358 plugins="yes" 2358 plugins="yes"
2359 swcodec="yes" 2359 swcodec="yes"
2360 toolset=$genericbitmaptools 2360 toolset=$genericbitmaptools
@@ -2376,7 +2376,7 @@ fi
2376 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 2376 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
2377 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 2377 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
2378 output="rockbox.lyre" 2378 output="rockbox.lyre"
2379 appextra="recorder:gui" 2379 appextra="recorder:gui:radio"
2380 plugins="" 2380 plugins=""
2381 swcodec="yes" 2381 swcodec="yes"
2382 toolset=$scramblebitmaptools 2382 toolset=$scramblebitmaptools
@@ -2398,7 +2398,7 @@ fi
2398 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 2398 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
2399 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 2399 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
2400 output="rockbox.mini2440" 2400 output="rockbox.mini2440"
2401 appextra="recorder:gui" 2401 appextra="recorder:gui:radio"
2402 plugins="" 2402 plugins=""
2403 swcodec="yes" 2403 swcodec="yes"
2404 toolset=$scramblebitmaptools 2404 toolset=$scramblebitmaptools
@@ -2420,7 +2420,7 @@ fi
2420 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 2420 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
2421 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 2421 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
2422 output="rockbox.mi4" 2422 output="rockbox.mi4"
2423 appextra="recorder:gui" 2423 appextra="recorder:gui:radio"
2424 plugins="yes" 2424 plugins="yes"
2425 swcodec="yes" 2425 swcodec="yes"
2426 boottool="$rootdir/tools/scramble -mi4v2 -model=y820 -type=RBBL" 2426 boottool="$rootdir/tools/scramble -mi4v2 -model=y820 -type=RBBL"
@@ -2444,7 +2444,7 @@ fi
2444 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 2444 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
2445 bmp2rb_native="$rootdir/tools/bmp2rb -f 2" 2445 bmp2rb_native="$rootdir/tools/bmp2rb -f 2"
2446 output="rockbox.mi4" 2446 output="rockbox.mi4"
2447 appextra="recorder:gui" 2447 appextra="recorder:gui:radio"
2448 plugins="yes" 2448 plugins="yes"
2449 swcodec="yes" 2449 swcodec="yes"
2450 boottool="$rootdir/tools/scramble -mi4v2 -model=y920 -type=RBBL" 2450 boottool="$rootdir/tools/scramble -mi4v2 -model=y920 -type=RBBL"
@@ -2468,7 +2468,7 @@ fi
2468 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 2468 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
2469 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 2469 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
2470 output="rockbox.mi4" 2470 output="rockbox.mi4"
2471 appextra="recorder:gui" 2471 appextra="recorder:gui:radio"
2472 plugins="yes" 2472 plugins="yes"
2473 swcodec="yes" 2473 swcodec="yes"
2474 boottool="$rootdir/tools/scramble -mi4v2 -model=y925 -type=RBBL" 2474 boottool="$rootdir/tools/scramble -mi4v2 -model=y925 -type=RBBL"
@@ -2492,7 +2492,7 @@ fi
2492 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 2492 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
2493 bmp2rb_native="$rootdir/tools/bmp2rb -f 4" 2493 bmp2rb_native="$rootdir/tools/bmp2rb -f 4"
2494 output="rockbox.yps3" 2494 output="rockbox.yps3"
2495 appextra="recorder:gui" 2495 appextra="recorder:gui:radio"
2496 plugins="no" #FIXME 2496 plugins="no" #FIXME
2497 swcodec="yes" 2497 swcodec="yes"
2498 toolset=$genericbitmaptools 2498 toolset=$genericbitmaptools
@@ -2514,7 +2514,7 @@ fi
2514 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0" 2514 bmp2rb_mono="$rootdir/tools/bmp2rb -f 0"
2515 bmp2rb_native="$rootdir/tools/bmp2rb -f 5" 2515 bmp2rb_native="$rootdir/tools/bmp2rb -f 5"
2516 output="rockbox.mi4" 2516 output="rockbox.mi4"
2517 appextra="recorder:gui" 2517 appextra="recorder:gui:radio"
2518 plugins="yes" 2518 plugins="yes"
2519 swcodec="yes" 2519 swcodec="yes"
2520 boottool="$rootdir/tools/scramble -mi4v3 -model=v500 -type=RBBL" 2520 boottool="$rootdir/tools/scramble -mi4v3 -model=v500 -type=RBBL"
@@ -2539,7 +2539,7 @@ fi
2539 bmp2rb_native="$rootdir/tools/bmp2rb -f 7" 2539 bmp2rb_native="$rootdir/tools/bmp2rb -f 7"
2540 output="rockbox.mpio" 2540 output="rockbox.mpio"
2541 bootoutput="bootloader.mpio" 2541 bootoutput="bootloader.mpio"
2542 appextra="recorder:gui" 2542 appextra="recorder:gui:radio"
2543 plugins="yes" 2543 plugins="yes"
2544 swcodec="yes" 2544 swcodec="yes"
2545 # toolset is the tools within the tools directory that we build for 2545 # toolset is the tools within the tools directory that we build for
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-16 03:35:45 +0000