diff options
author | Jonathan Gordon <rockbox@jdgordon.info> | 2009-07-27 07:21:05 +0000 |
---|---|---|
committer | Jonathan Gordon <rockbox@jdgordon.info> | 2009-07-27 07:21:05 +0000 |
commit | 5e5fc64cb2e74024e15cb33eab6b832610c2a60b (patch) | |
tree | 915ce63e39060b2f7223d60d730ce8f8fa2cf67f | |
parent | 4e16015427287381e4ef826a61118408c96658f0 (diff) | |
download | rockbox-5e5fc64cb2e74024e15cb33eab6b832610c2a60b.tar.gz rockbox-5e5fc64cb2e74024e15cb33eab6b832610c2a60b.zip |
Start of some apps/ and wps cleanup work... Move everything related to the actual drawing of the wps into apps/gui/wps_engine, things related to the actual screen are in apps/gui/music_screen.c (names are temporary unless noone comes up with anything better)
No real code changes.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@22062 a1c6a512-1295-4272-9138-f99709370657
-rw-r--r-- | apps/SOURCES | 11 | ||||
-rw-r--r-- | apps/filetree.c | 3 | ||||
-rw-r--r-- | apps/gui/music_screen.c (renamed from apps/gui/gwps.c) | 233 | ||||
-rw-r--r-- | apps/gui/music_screen.h (renamed from apps/gui/gwps-common.h) | 34 | ||||
-rw-r--r-- | apps/gui/wps_engine/gwps.h (renamed from apps/gui/gwps.h) | 0 | ||||
-rw-r--r-- | apps/gui/wps_engine/wps_debug.c (renamed from apps/gui/wps_debug.c) | 2 | ||||
-rw-r--r-- | apps/gui/wps_engine/wps_display.c (renamed from apps/gui/gwps-common.c) | 976 | ||||
-rw-r--r-- | apps/gui/wps_engine/wps_engine.h | 49 | ||||
-rw-r--r-- | apps/gui/wps_engine/wps_internals.h | 556 | ||||
-rw-r--r-- | apps/gui/wps_engine/wps_parser.c (renamed from apps/gui/wps_parser.c) | 2 | ||||
-rw-r--r-- | apps/gui/wps_engine/wps_tokens.c | 807 | ||||
-rw-r--r-- | apps/iap.c | 2 | ||||
-rw-r--r-- | apps/main.c | 2 | ||||
-rw-r--r-- | apps/menu.c | 1 | ||||
-rw-r--r-- | apps/menus/main_menu.c | 2 | ||||
-rw-r--r-- | apps/misc.c | 3 | ||||
-rw-r--r-- | apps/recorder/albumart.c | 1 | ||||
-rw-r--r-- | apps/recorder/albumart.h | 2 | ||||
-rw-r--r-- | apps/root_menu.c | 2 | ||||
-rw-r--r-- | apps/settings.c | 2 | ||||
-rw-r--r-- | apps/tree.c | 3 |
21 files changed, 1672 insertions, 1021 deletions
diff --git a/apps/SOURCES b/apps/SOURCES index 8166dbe4e2..e1d85a75f0 100644 --- a/apps/SOURCES +++ b/apps/SOURCES | |||
@@ -60,8 +60,6 @@ screen_access.c | |||
60 | #ifdef HAVE_BUTTONBAR | 60 | #ifdef HAVE_BUTTONBAR |
61 | gui/buttonbar.c | 61 | gui/buttonbar.c |
62 | #endif | 62 | #endif |
63 | gui/gwps.c | ||
64 | gui/gwps-common.c | ||
65 | #ifdef HAVE_LCD_BITMAP | 63 | #ifdef HAVE_LCD_BITMAP |
66 | gui/icon.c | 64 | gui/icon.c |
67 | #endif | 65 | #endif |
@@ -78,14 +76,19 @@ gui/pitchscreen.c | |||
78 | #ifdef HAVE_QUICKSCREEN | 76 | #ifdef HAVE_QUICKSCREEN |
79 | gui/quickscreen.c | 77 | gui/quickscreen.c |
80 | #endif | 78 | #endif |
79 | |||
80 | gui/music_screen.c | ||
81 | gui/scrollbar.c | 81 | gui/scrollbar.c |
82 | gui/splash.c | 82 | gui/splash.c |
83 | gui/statusbar.c | 83 | gui/statusbar.c |
84 | gui/yesno.c | 84 | gui/yesno.c |
85 | gui/wps_debug.c | ||
86 | gui/wps_parser.c | ||
87 | gui/viewport.c | 85 | gui/viewport.c |
88 | 86 | ||
87 | gui/wps_engine/wps_debug.c | ||
88 | gui/wps_engine/wps_display.c | ||
89 | gui/wps_engine/wps_parser.c | ||
90 | gui/wps_engine/wps_tokens.c | ||
91 | |||
89 | #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)) | 92 | #if (LCD_DEPTH > 1) || (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)) |
90 | gui/backdrop.c | 93 | gui/backdrop.c |
91 | #endif | 94 | #endif |
diff --git a/apps/filetree.c b/apps/filetree.c index 87ac37c2e0..458d553e27 100644 --- a/apps/filetree.c +++ b/apps/filetree.c | |||
@@ -33,7 +33,6 @@ | |||
33 | #include "filetypes.h" | 33 | #include "filetypes.h" |
34 | #include "talk.h" | 34 | #include "talk.h" |
35 | #include "playlist.h" | 35 | #include "playlist.h" |
36 | #include "gwps.h" | ||
37 | #include "lang.h" | 36 | #include "lang.h" |
38 | #include "language.h" | 37 | #include "language.h" |
39 | #include "screens.h" | 38 | #include "screens.h" |
@@ -52,7 +51,7 @@ | |||
52 | #if CONFIG_TUNER | 51 | #if CONFIG_TUNER |
53 | #include "radio.h" | 52 | #include "radio.h" |
54 | #endif | 53 | #endif |
55 | 54 | #include "wps_engine/wps_internals.h" /* FIXME: REMOVE ME */ | |
56 | #include "backdrop.h" | 55 | #include "backdrop.h" |
57 | 56 | ||
58 | static int compare_sort_dir; /* qsort key for sorting directories */ | 57 | static int compare_sort_dir; /* qsort key for sorting directories */ |
diff --git a/apps/gui/gwps.c b/apps/gui/music_screen.c index 10c2a6806b..39d5e0e85b 100644 --- a/apps/gui/gwps.c +++ b/apps/gui/music_screen.c | |||
@@ -34,8 +34,8 @@ | |||
34 | #include "debug.h" | 34 | #include "debug.h" |
35 | #include "sprintf.h" | 35 | #include "sprintf.h" |
36 | #include "settings.h" | 36 | #include "settings.h" |
37 | #include "gwps.h" | 37 | #include "wps_engine/wps_engine.h" |
38 | #include "gwps-common.h" | 38 | #include "mp3_playback.h" |
39 | #include "audio.h" | 39 | #include "audio.h" |
40 | #include "usb.h" | 40 | #include "usb.h" |
41 | #include "status.h" | 41 | #include "status.h" |
@@ -66,6 +66,7 @@ | |||
66 | #include "option_select.h" | 66 | #include "option_select.h" |
67 | #include "dsp.h" | 67 | #include "dsp.h" |
68 | #include "playlist_viewer.h" | 68 | #include "playlist_viewer.h" |
69 | #include "music_screen.h" | ||
69 | 70 | ||
70 | #define RESTORE_WPS_INSTANTLY 0l | 71 | #define RESTORE_WPS_INSTANTLY 0l |
71 | #define RESTORE_WPS_NEXT_SECOND ((long)(HZ+current_tick)) | 72 | #define RESTORE_WPS_NEXT_SECOND ((long)(HZ+current_tick)) |
@@ -84,6 +85,234 @@ static void track_changed_callback(void *param); | |||
84 | static void nextid3available_callback(void* param); | 85 | static void nextid3available_callback(void* param); |
85 | 86 | ||
86 | 87 | ||
88 | |||
89 | #define FF_REWIND_MAX_PERCENT 3 /* cap ff/rewind step size at max % of file */ | ||
90 | /* 3% of 30min file == 54s step size */ | ||
91 | #define MIN_FF_REWIND_STEP 500 | ||
92 | |||
93 | bool wps_fading_out = false; | ||
94 | void fade(bool fade_in, bool updatewps) | ||
95 | { | ||
96 | int fp_global_vol = global_settings.volume << 8; | ||
97 | int fp_min_vol = sound_min(SOUND_VOLUME) << 8; | ||
98 | int fp_step = (fp_global_vol - fp_min_vol) / 30; | ||
99 | int i; | ||
100 | wps_fading_out = !fade_in; | ||
101 | if (fade_in) { | ||
102 | /* fade in */ | ||
103 | int fp_volume = fp_min_vol; | ||
104 | |||
105 | /* zero out the sound */ | ||
106 | sound_set_volume(fp_min_vol >> 8); | ||
107 | |||
108 | sleep(HZ/10); /* let audio thread run */ | ||
109 | audio_resume(); | ||
110 | |||
111 | while (fp_volume < fp_global_vol - fp_step) { | ||
112 | fp_volume += fp_step; | ||
113 | sound_set_volume(fp_volume >> 8); | ||
114 | if (updatewps) | ||
115 | { | ||
116 | FOR_NB_SCREENS(i) | ||
117 | gui_wps_redraw(&gui_wps[i], 0, WPS_REFRESH_NON_STATIC); | ||
118 | } | ||
119 | sleep(1); | ||
120 | } | ||
121 | sound_set_volume(global_settings.volume); | ||
122 | } | ||
123 | else { | ||
124 | /* fade out */ | ||
125 | int fp_volume = fp_global_vol; | ||
126 | |||
127 | while (fp_volume > fp_min_vol + fp_step) { | ||
128 | fp_volume -= fp_step; | ||
129 | sound_set_volume(fp_volume >> 8); | ||
130 | if (updatewps) | ||
131 | { | ||
132 | FOR_NB_SCREENS(i) | ||
133 | gui_wps_redraw(&gui_wps[i], 0, WPS_REFRESH_NON_STATIC); | ||
134 | } | ||
135 | sleep(1); | ||
136 | } | ||
137 | audio_pause(); | ||
138 | wps_fading_out = false; | ||
139 | #if CONFIG_CODEC != SWCODEC | ||
140 | #ifndef SIMULATOR | ||
141 | /* let audio thread run and wait for the mas to run out of data */ | ||
142 | while (!mp3_pause_done()) | ||
143 | #endif | ||
144 | sleep(HZ/10); | ||
145 | #endif | ||
146 | |||
147 | /* reset volume to what it was before the fade */ | ||
148 | sound_set_volume(global_settings.volume); | ||
149 | } | ||
150 | } | ||
151 | bool is_wps_fading(void) | ||
152 | { | ||
153 | return wps_fading_out; | ||
154 | } | ||
155 | |||
156 | bool update_onvol_change(struct gui_wps * gwps) | ||
157 | { | ||
158 | gui_wps_redraw(gwps, 0, WPS_REFRESH_NON_STATIC); | ||
159 | |||
160 | #ifdef HAVE_LCD_CHARCELLS | ||
161 | splashf(0, "Vol: %3d dB", | ||
162 | sound_val2phys(SOUND_VOLUME, global_settings.volume)); | ||
163 | return true; | ||
164 | #endif | ||
165 | return false; | ||
166 | } | ||
167 | |||
168 | bool ffwd_rew(int button) | ||
169 | { | ||
170 | unsigned int step = 0; /* current ff/rewind step */ | ||
171 | unsigned int max_step = 0; /* maximum ff/rewind step */ | ||
172 | int ff_rewind_count = 0; /* current ff/rewind count (in ticks) */ | ||
173 | int direction = -1; /* forward=1 or backward=-1 */ | ||
174 | bool exit = false; | ||
175 | bool usb = false; | ||
176 | int i = 0; | ||
177 | const long ff_rw_accel = (global_settings.ff_rewind_accel + 3); | ||
178 | |||
179 | if (button == ACTION_NONE) | ||
180 | { | ||
181 | status_set_ffmode(0); | ||
182 | return usb; | ||
183 | } | ||
184 | while (!exit) | ||
185 | { | ||
186 | switch ( button ) | ||
187 | { | ||
188 | case ACTION_WPS_SEEKFWD: | ||
189 | direction = 1; | ||
190 | case ACTION_WPS_SEEKBACK: | ||
191 | if (wps_state.ff_rewind) | ||
192 | { | ||
193 | if (direction == 1) | ||
194 | { | ||
195 | /* fast forwarding, calc max step relative to end */ | ||
196 | max_step = (wps_state.id3->length - | ||
197 | (wps_state.id3->elapsed + | ||
198 | ff_rewind_count)) * | ||
199 | FF_REWIND_MAX_PERCENT / 100; | ||
200 | } | ||
201 | else | ||
202 | { | ||
203 | /* rewinding, calc max step relative to start */ | ||
204 | max_step = (wps_state.id3->elapsed + ff_rewind_count) * | ||
205 | FF_REWIND_MAX_PERCENT / 100; | ||
206 | } | ||
207 | |||
208 | max_step = MAX(max_step, MIN_FF_REWIND_STEP); | ||
209 | |||
210 | if (step > max_step) | ||
211 | step = max_step; | ||
212 | |||
213 | ff_rewind_count += step * direction; | ||
214 | |||
215 | /* smooth seeking by multiplying step by: 1 + (2 ^ -accel) */ | ||
216 | step += step >> ff_rw_accel; | ||
217 | } | ||
218 | else | ||
219 | { | ||
220 | if ( (audio_status() & AUDIO_STATUS_PLAY) && | ||
221 | wps_state.id3 && wps_state.id3->length ) | ||
222 | { | ||
223 | if (!wps_state.paused) | ||
224 | #if (CONFIG_CODEC == SWCODEC) | ||
225 | audio_pre_ff_rewind(); | ||
226 | #else | ||
227 | audio_pause(); | ||
228 | #endif | ||
229 | #if CONFIG_KEYPAD == PLAYER_PAD | ||
230 | FOR_NB_SCREENS(i) | ||
231 | gui_wps[i].display->stop_scroll(); | ||
232 | #endif | ||
233 | if (direction > 0) | ||
234 | status_set_ffmode(STATUS_FASTFORWARD); | ||
235 | else | ||
236 | status_set_ffmode(STATUS_FASTBACKWARD); | ||
237 | |||
238 | wps_state.ff_rewind = true; | ||
239 | |||
240 | step = 1000 * global_settings.ff_rewind_min_step; | ||
241 | } | ||
242 | else | ||
243 | break; | ||
244 | } | ||
245 | |||
246 | if (direction > 0) { | ||
247 | if ((wps_state.id3->elapsed + ff_rewind_count) > | ||
248 | wps_state.id3->length) | ||
249 | ff_rewind_count = wps_state.id3->length - | ||
250 | wps_state.id3->elapsed; | ||
251 | } | ||
252 | else { | ||
253 | if ((int)(wps_state.id3->elapsed + ff_rewind_count) < 0) | ||
254 | ff_rewind_count = -wps_state.id3->elapsed; | ||
255 | } | ||
256 | |||
257 | FOR_NB_SCREENS(i) | ||
258 | gui_wps_redraw(&gui_wps[i], | ||
259 | (wps_state.wps_time_countup == false)? | ||
260 | ff_rewind_count:-ff_rewind_count, | ||
261 | WPS_REFRESH_PLAYER_PROGRESS | | ||
262 | WPS_REFRESH_DYNAMIC); | ||
263 | |||
264 | break; | ||
265 | |||
266 | case ACTION_WPS_STOPSEEK: | ||
267 | wps_state.id3->elapsed = wps_state.id3->elapsed+ff_rewind_count; | ||
268 | audio_ff_rewind(wps_state.id3->elapsed); | ||
269 | ff_rewind_count = 0; | ||
270 | wps_state.ff_rewind = false; | ||
271 | status_set_ffmode(0); | ||
272 | #if (CONFIG_CODEC != SWCODEC) | ||
273 | if (!wps_state.paused) | ||
274 | audio_resume(); | ||
275 | #endif | ||
276 | #ifdef HAVE_LCD_CHARCELLS | ||
277 | FOR_NB_SCREENS(i) | ||
278 | gui_wps_redraw(&gui_wps[i],0, WPS_REFRESH_ALL); | ||
279 | #endif | ||
280 | exit = true; | ||
281 | break; | ||
282 | |||
283 | default: | ||
284 | if(default_event_handler(button) == SYS_USB_CONNECTED) { | ||
285 | status_set_ffmode(0); | ||
286 | usb = true; | ||
287 | exit = true; | ||
288 | } | ||
289 | break; | ||
290 | } | ||
291 | if (!exit) | ||
292 | { | ||
293 | button = get_action(CONTEXT_WPS|ALLOW_SOFTLOCK,TIMEOUT_BLOCK); | ||
294 | #ifdef HAVE_TOUCHSCREEN | ||
295 | if (button == ACTION_TOUCHSCREEN) | ||
296 | button = wps_get_touchaction(gui_wps[SCREEN_MAIN].data); | ||
297 | #endif | ||
298 | } | ||
299 | } | ||
300 | return usb; | ||
301 | } | ||
302 | |||
303 | |||
304 | void display_keylock_text(bool locked) | ||
305 | { | ||
306 | int i; | ||
307 | FOR_NB_SCREENS(i) | ||
308 | gui_wps[i].display->stop_scroll(); | ||
309 | |||
310 | splash(HZ, locked ? ID2P(LANG_KEYLOCK_ON) : ID2P(LANG_KEYLOCK_OFF)); | ||
311 | } | ||
312 | |||
313 | |||
314 | |||
315 | |||
87 | #if defined(HAVE_BACKLIGHT) || defined(HAVE_REMOTE_LCD) | 316 | #if defined(HAVE_BACKLIGHT) || defined(HAVE_REMOTE_LCD) |
88 | static void gwps_caption_backlight(struct wps_state *state) | 317 | static void gwps_caption_backlight(struct wps_state *state) |
89 | { | 318 | { |
diff --git a/apps/gui/gwps-common.h b/apps/gui/music_screen.h index 0d196b28e4..90614cb65b 100644 --- a/apps/gui/gwps-common.h +++ b/apps/gui/music_screen.h | |||
@@ -5,7 +5,7 @@ | |||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | 5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < |
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | 6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ |
7 | * \/ \/ \/ \/ \/ | 7 | * \/ \/ \/ \/ \/ |
8 | * $Id$ | 8 | * $Id: gwps-common.h 20492 2009-03-23 17:19:48Z alle $ |
9 | * | 9 | * |
10 | * Copyright (C) 2002 Björn Stenberg | 10 | * Copyright (C) 2002 Björn Stenberg |
11 | * | 11 | * |
@@ -18,36 +18,20 @@ | |||
18 | * KIND, either express or implied. | 18 | * KIND, either express or implied. |
19 | * | 19 | * |
20 | ****************************************************************************/ | 20 | ****************************************************************************/ |
21 | #ifndef _GWPS_COMMON_ | 21 | #ifndef _MUSICSCREEN_H_ |
22 | #define _GWPS_COMMON_ | 22 | #define _MUSICSCREEN_H_ |
23 | #include <stdbool.h> | 23 | #include <stdbool.h> |
24 | #include <sys/types.h> /* for size_t */ | 24 | |
25 | 25 | long gui_wps_show(void); | |
26 | #include "gwps.h" | 26 | |
27 | |||
28 | void gui_sync_wps_init(void); | ||
27 | 29 | ||
28 | /* fades the volume, e.g. on pause or stop */ | 30 | /* fades the volume, e.g. on pause or stop */ |
29 | void fade(bool fade_in, bool updatewps); | 31 | void fade(bool fade_in, bool updatewps); |
30 | 32 | ||
31 | /* Initially display the wps, can fall back to the built-in wps | ||
32 | * if the chosen wps is invalid. | ||
33 | * | ||
34 | * Return true on success, otherwise false */ | ||
35 | bool gui_wps_display(struct gui_wps *gui_wps); | ||
36 | |||
37 | /* return true if screen restore is needed | ||
38 | return false otherwise */ | ||
39 | bool update_onvol_change(struct gui_wps * gwps); | ||
40 | |||
41 | /* Update track info related stuff, handle cue sheets as well, and redraw */ | ||
42 | bool gui_wps_update(struct gui_wps *gwps); | ||
43 | |||
44 | bool ffwd_rew(int button); | 33 | bool ffwd_rew(int button); |
45 | void display_keylock_text(bool locked); | 34 | void display_keylock_text(bool locked); |
46 | 35 | ||
47 | /* Refresh the WPS according to refresh_mode. | 36 | bool is_wps_fading(void); |
48 | * | ||
49 | * Return true on success, otherwise false */ | ||
50 | bool gui_wps_redraw(struct gui_wps *gwps, | ||
51 | int ffwd_offset, | ||
52 | unsigned refresh_mode); | ||
53 | #endif | 37 | #endif |
diff --git a/apps/gui/gwps.h b/apps/gui/wps_engine/gwps.h index 2acde0dc39..2acde0dc39 100644 --- a/apps/gui/gwps.h +++ b/apps/gui/wps_engine/gwps.h | |||
diff --git a/apps/gui/wps_debug.c b/apps/gui/wps_engine/wps_debug.c index 727d9078c6..a89f61af9d 100644 --- a/apps/gui/wps_debug.c +++ b/apps/gui/wps_engine/wps_debug.c | |||
@@ -23,7 +23,7 @@ | |||
23 | 23 | ||
24 | #include <stdio.h> | 24 | #include <stdio.h> |
25 | #include <string.h> | 25 | #include <string.h> |
26 | #include "gwps.h" | 26 | #include "wps_internals.h" |
27 | #ifdef __PCTOOL__ | 27 | #ifdef __PCTOOL__ |
28 | #ifdef WPSEDITOR | 28 | #ifdef WPSEDITOR |
29 | #include "proxy.h" | 29 | #include "proxy.h" |
diff --git a/apps/gui/gwps-common.c b/apps/gui/wps_engine/wps_display.c index 721682f248..c74e2cedfa 100644 --- a/apps/gui/gwps-common.c +++ b/apps/gui/wps_engine/wps_display.c | |||
@@ -19,7 +19,6 @@ | |||
19 | * KIND, either express or implied. | 19 | * KIND, either express or implied. |
20 | * | 20 | * |
21 | ****************************************************************************/ | 21 | ****************************************************************************/ |
22 | #include "gwps-common.h" | ||
23 | #include "font.h" | 22 | #include "font.h" |
24 | #include <stdio.h> | 23 | #include <stdio.h> |
25 | #include <string.h> | 24 | #include <string.h> |
@@ -62,222 +61,9 @@ | |||
62 | #include "backdrop.h" | 61 | #include "backdrop.h" |
63 | #include "viewport.h" | 62 | #include "viewport.h" |
64 | 63 | ||
65 | #define FF_REWIND_MAX_PERCENT 3 /* cap ff/rewind step size at max % of file */ | ||
66 | /* 3% of 30min file == 54s step size */ | ||
67 | #define MIN_FF_REWIND_STEP 500 | ||
68 | 64 | ||
69 | /* Timeout unit expressed in HZ. In WPS, all timeouts are given in seconds | 65 | #include "wps_internals.h" |
70 | (possibly with a decimal fraction) but stored as integer values. | 66 | #include "wps_engine.h" |
71 | E.g. 2.5 is stored as 25. This means 25 tenth of a second, i.e. 25 units. | ||
72 | */ | ||
73 | #define TIMEOUT_UNIT (HZ/10) /* I.e. 0.1 sec */ | ||
74 | #define DEFAULT_SUBLINE_TIME_MULTIPLIER 20 /* In TIMEOUT_UNIT's */ | ||
75 | |||
76 | bool wps_fading_out = false; | ||
77 | void fade(bool fade_in, bool updatewps) | ||
78 | { | ||
79 | int fp_global_vol = global_settings.volume << 8; | ||
80 | int fp_min_vol = sound_min(SOUND_VOLUME) << 8; | ||
81 | int fp_step = (fp_global_vol - fp_min_vol) / 30; | ||
82 | int i; | ||
83 | wps_fading_out = !fade_in; | ||
84 | if (fade_in) { | ||
85 | /* fade in */ | ||
86 | int fp_volume = fp_min_vol; | ||
87 | |||
88 | /* zero out the sound */ | ||
89 | sound_set_volume(fp_min_vol >> 8); | ||
90 | |||
91 | sleep(HZ/10); /* let audio thread run */ | ||
92 | audio_resume(); | ||
93 | |||
94 | while (fp_volume < fp_global_vol - fp_step) { | ||
95 | fp_volume += fp_step; | ||
96 | sound_set_volume(fp_volume >> 8); | ||
97 | if (updatewps) | ||
98 | { | ||
99 | FOR_NB_SCREENS(i) | ||
100 | gui_wps_redraw(&gui_wps[i], 0, WPS_REFRESH_NON_STATIC); | ||
101 | } | ||
102 | sleep(1); | ||
103 | } | ||
104 | sound_set_volume(global_settings.volume); | ||
105 | } | ||
106 | else { | ||
107 | /* fade out */ | ||
108 | int fp_volume = fp_global_vol; | ||
109 | |||
110 | while (fp_volume > fp_min_vol + fp_step) { | ||
111 | fp_volume -= fp_step; | ||
112 | sound_set_volume(fp_volume >> 8); | ||
113 | if (updatewps) | ||
114 | { | ||
115 | FOR_NB_SCREENS(i) | ||
116 | gui_wps_redraw(&gui_wps[i], 0, WPS_REFRESH_NON_STATIC); | ||
117 | } | ||
118 | sleep(1); | ||
119 | } | ||
120 | audio_pause(); | ||
121 | wps_fading_out = false; | ||
122 | #if CONFIG_CODEC != SWCODEC | ||
123 | #ifndef SIMULATOR | ||
124 | /* let audio thread run and wait for the mas to run out of data */ | ||
125 | while (!mp3_pause_done()) | ||
126 | #endif | ||
127 | sleep(HZ/10); | ||
128 | #endif | ||
129 | |||
130 | /* reset volume to what it was before the fade */ | ||
131 | sound_set_volume(global_settings.volume); | ||
132 | } | ||
133 | } | ||
134 | |||
135 | bool update_onvol_change(struct gui_wps * gwps) | ||
136 | { | ||
137 | gui_wps_redraw(gwps, 0, WPS_REFRESH_NON_STATIC); | ||
138 | |||
139 | #ifdef HAVE_LCD_CHARCELLS | ||
140 | splashf(0, "Vol: %3d dB", | ||
141 | sound_val2phys(SOUND_VOLUME, global_settings.volume)); | ||
142 | return true; | ||
143 | #endif | ||
144 | return false; | ||
145 | } | ||
146 | |||
147 | bool ffwd_rew(int button) | ||
148 | { | ||
149 | unsigned int step = 0; /* current ff/rewind step */ | ||
150 | unsigned int max_step = 0; /* maximum ff/rewind step */ | ||
151 | int ff_rewind_count = 0; /* current ff/rewind count (in ticks) */ | ||
152 | int direction = -1; /* forward=1 or backward=-1 */ | ||
153 | bool exit = false; | ||
154 | bool usb = false; | ||
155 | int i = 0; | ||
156 | const long ff_rw_accel = (global_settings.ff_rewind_accel + 3); | ||
157 | |||
158 | if (button == ACTION_NONE) | ||
159 | { | ||
160 | status_set_ffmode(0); | ||
161 | return usb; | ||
162 | } | ||
163 | while (!exit) | ||
164 | { | ||
165 | switch ( button ) | ||
166 | { | ||
167 | case ACTION_WPS_SEEKFWD: | ||
168 | direction = 1; | ||
169 | case ACTION_WPS_SEEKBACK: | ||
170 | if (wps_state.ff_rewind) | ||
171 | { | ||
172 | if (direction == 1) | ||
173 | { | ||
174 | /* fast forwarding, calc max step relative to end */ | ||
175 | max_step = (wps_state.id3->length - | ||
176 | (wps_state.id3->elapsed + | ||
177 | ff_rewind_count)) * | ||
178 | FF_REWIND_MAX_PERCENT / 100; | ||
179 | } | ||
180 | else | ||
181 | { | ||
182 | /* rewinding, calc max step relative to start */ | ||
183 | max_step = (wps_state.id3->elapsed + ff_rewind_count) * | ||
184 | FF_REWIND_MAX_PERCENT / 100; | ||
185 | } | ||
186 | |||
187 | max_step = MAX(max_step, MIN_FF_REWIND_STEP); | ||
188 | |||
189 | if (step > max_step) | ||
190 | step = max_step; | ||
191 | |||
192 | ff_rewind_count += step * direction; | ||
193 | |||
194 | /* smooth seeking by multiplying step by: 1 + (2 ^ -accel) */ | ||
195 | step += step >> ff_rw_accel; | ||
196 | } | ||
197 | else | ||
198 | { | ||
199 | if ( (audio_status() & AUDIO_STATUS_PLAY) && | ||
200 | wps_state.id3 && wps_state.id3->length ) | ||
201 | { | ||
202 | if (!wps_state.paused) | ||
203 | #if (CONFIG_CODEC == SWCODEC) | ||
204 | audio_pre_ff_rewind(); | ||
205 | #else | ||
206 | audio_pause(); | ||
207 | #endif | ||
208 | #if CONFIG_KEYPAD == PLAYER_PAD | ||
209 | FOR_NB_SCREENS(i) | ||
210 | gui_wps[i].display->stop_scroll(); | ||
211 | #endif | ||
212 | if (direction > 0) | ||
213 | status_set_ffmode(STATUS_FASTFORWARD); | ||
214 | else | ||
215 | status_set_ffmode(STATUS_FASTBACKWARD); | ||
216 | |||
217 | wps_state.ff_rewind = true; | ||
218 | |||
219 | step = 1000 * global_settings.ff_rewind_min_step; | ||
220 | } | ||
221 | else | ||
222 | break; | ||
223 | } | ||
224 | |||
225 | if (direction > 0) { | ||
226 | if ((wps_state.id3->elapsed + ff_rewind_count) > | ||
227 | wps_state.id3->length) | ||
228 | ff_rewind_count = wps_state.id3->length - | ||
229 | wps_state.id3->elapsed; | ||
230 | } | ||
231 | else { | ||
232 | if ((int)(wps_state.id3->elapsed + ff_rewind_count) < 0) | ||
233 | ff_rewind_count = -wps_state.id3->elapsed; | ||
234 | } | ||
235 | |||
236 | FOR_NB_SCREENS(i) | ||
237 | gui_wps_redraw(&gui_wps[i], | ||
238 | (wps_state.wps_time_countup == false)? | ||
239 | ff_rewind_count:-ff_rewind_count, | ||
240 | WPS_REFRESH_PLAYER_PROGRESS | | ||
241 | WPS_REFRESH_DYNAMIC); | ||
242 | |||
243 | break; | ||
244 | |||
245 | case ACTION_WPS_STOPSEEK: | ||
246 | wps_state.id3->elapsed = wps_state.id3->elapsed+ff_rewind_count; | ||
247 | audio_ff_rewind(wps_state.id3->elapsed); | ||
248 | ff_rewind_count = 0; | ||
249 | wps_state.ff_rewind = false; | ||
250 | status_set_ffmode(0); | ||
251 | #if (CONFIG_CODEC != SWCODEC) | ||
252 | if (!wps_state.paused) | ||
253 | audio_resume(); | ||
254 | #endif | ||
255 | #ifdef HAVE_LCD_CHARCELLS | ||
256 | FOR_NB_SCREENS(i) | ||
257 | gui_wps_redraw(&gui_wps[i],0, WPS_REFRESH_ALL); | ||
258 | #endif | ||
259 | exit = true; | ||
260 | break; | ||
261 | |||
262 | default: | ||
263 | if(default_event_handler(button) == SYS_USB_CONNECTED) { | ||
264 | status_set_ffmode(0); | ||
265 | usb = true; | ||
266 | exit = true; | ||
267 | } | ||
268 | break; | ||
269 | } | ||
270 | if (!exit) | ||
271 | { | ||
272 | button = get_action(CONTEXT_WPS|ALLOW_SOFTLOCK,TIMEOUT_BLOCK); | ||
273 | #ifdef HAVE_TOUCHSCREEN | ||
274 | if (button == ACTION_TOUCHSCREEN) | ||
275 | button = wps_get_touchaction(gui_wps[SCREEN_MAIN].data); | ||
276 | #endif | ||
277 | } | ||
278 | } | ||
279 | return usb; | ||
280 | } | ||
281 | 67 | ||
282 | bool gui_wps_display(struct gui_wps *gwps) | 68 | bool gui_wps_display(struct gui_wps *gwps) |
283 | { | 69 | { |
@@ -364,15 +150,6 @@ bool gui_wps_update(struct gui_wps *gwps) | |||
364 | } | 150 | } |
365 | 151 | ||
366 | 152 | ||
367 | void display_keylock_text(bool locked) | ||
368 | { | ||
369 | int i; | ||
370 | FOR_NB_SCREENS(i) | ||
371 | gui_wps[i].display->stop_scroll(); | ||
372 | |||
373 | splash(HZ, locked ? ID2P(LANG_KEYLOCK_ON) : ID2P(LANG_KEYLOCK_OFF)); | ||
374 | } | ||
375 | |||
376 | #ifdef HAVE_LCD_BITMAP | 153 | #ifdef HAVE_LCD_BITMAP |
377 | 154 | ||
378 | static void draw_progressbar(struct gui_wps *gwps, | 155 | static void draw_progressbar(struct gui_wps *gwps, |
@@ -605,755 +382,6 @@ static void draw_player_fullbar(struct gui_wps *gwps, char* buf, int buf_size) | |||
605 | 382 | ||
606 | #endif /* HAVE_LCD_CHARCELL */ | 383 | #endif /* HAVE_LCD_CHARCELL */ |
607 | 384 | ||
608 | static char* get_codectype(const struct mp3entry* id3) | ||
609 | { | ||
610 | if (id3->codectype < AFMT_NUM_CODECS) { | ||
611 | return (char*)audio_formats[id3->codectype].label; | ||
612 | } else { | ||
613 | return NULL; | ||
614 | } | ||
615 | } | ||
616 | |||
617 | /* Extract a part from a path. | ||
618 | * | ||
619 | * buf - buffer extract part to. | ||
620 | * buf_size - size of buffer. | ||
621 | * path - path to extract from. | ||
622 | * level - what to extract. 0 is file name, 1 is parent of file, 2 is | ||
623 | * parent of parent, etc. | ||
624 | * | ||
625 | * Returns buf if the desired level was found, NULL otherwise. | ||
626 | */ | ||
627 | static char* get_dir(char* buf, int buf_size, const char* path, int level) | ||
628 | { | ||
629 | const char* sep; | ||
630 | const char* last_sep; | ||
631 | int len; | ||
632 | |||
633 | sep = path + strlen(path); | ||
634 | last_sep = sep; | ||
635 | |||
636 | while (sep > path) | ||
637 | { | ||
638 | if ('/' == *(--sep)) | ||
639 | { | ||
640 | if (!level) | ||
641 | break; | ||
642 | |||
643 | level--; | ||
644 | last_sep = sep - 1; | ||
645 | } | ||
646 | } | ||
647 | |||
648 | if (level || (last_sep <= sep)) | ||
649 | return NULL; | ||
650 | |||
651 | len = MIN(last_sep - sep, buf_size - 1); | ||
652 | strlcpy(buf, sep + 1, len + 1); | ||
653 | return buf; | ||
654 | } | ||
655 | |||
656 | /* Return the tag found at index i and write its value in buf. | ||
657 | The return value is buf if the tag had a value, or NULL if not. | ||
658 | |||
659 | intval is used with conditionals/enums: when this function is called, | ||
660 | intval should contain the number of options in the conditional/enum. | ||
661 | When this function returns, intval is -1 if the tag is non numeric or, | ||
662 | if the tag is numeric, *intval is the enum case we want to go to (between 1 | ||
663 | and the original value of *intval, inclusive). | ||
664 | When not treating a conditional/enum, intval should be NULL. | ||
665 | */ | ||
666 | static const char *get_token_value(struct gui_wps *gwps, | ||
667 | struct wps_token *token, | ||
668 | char *buf, int buf_size, | ||
669 | int *intval) | ||
670 | { | ||
671 | if (!gwps) | ||
672 | return NULL; | ||
673 | |||
674 | struct wps_data *data = gwps->data; | ||
675 | struct wps_state *state = gwps->state; | ||
676 | |||
677 | if (!data || !state) | ||
678 | return NULL; | ||
679 | |||
680 | struct mp3entry *id3; | ||
681 | |||
682 | if (token->next) | ||
683 | id3 = state->nid3; | ||
684 | else | ||
685 | id3 = state->id3; | ||
686 | |||
687 | if (!id3) | ||
688 | return NULL; | ||
689 | |||
690 | #if CONFIG_RTC | ||
691 | struct tm* tm = NULL; | ||
692 | |||
693 | /* if the token is an RTC one, update the time | ||
694 | and do the necessary checks */ | ||
695 | if (token->type >= WPS_TOKENS_RTC_BEGIN | ||
696 | && token->type <= WPS_TOKENS_RTC_END) | ||
697 | { | ||
698 | tm = get_time(); | ||
699 | |||
700 | if (!valid_time(tm)) | ||
701 | return NULL; | ||
702 | } | ||
703 | #endif | ||
704 | |||
705 | int limit = 1; | ||
706 | if (intval) | ||
707 | { | ||
708 | limit = *intval; | ||
709 | *intval = -1; | ||
710 | } | ||
711 | |||
712 | switch (token->type) | ||
713 | { | ||
714 | case WPS_TOKEN_CHARACTER: | ||
715 | return &(token->value.c); | ||
716 | |||
717 | case WPS_TOKEN_STRING: | ||
718 | return data->strings[token->value.i]; | ||
719 | |||
720 | case WPS_TOKEN_TRACK_TIME_ELAPSED: | ||
721 | format_time(buf, buf_size, | ||
722 | id3->elapsed + state->ff_rewind_count); | ||
723 | return buf; | ||
724 | |||
725 | case WPS_TOKEN_TRACK_TIME_REMAINING: | ||
726 | format_time(buf, buf_size, | ||
727 | id3->length - id3->elapsed - | ||
728 | state->ff_rewind_count); | ||
729 | return buf; | ||
730 | |||
731 | case WPS_TOKEN_TRACK_LENGTH: | ||
732 | format_time(buf, buf_size, id3->length); | ||
733 | return buf; | ||
734 | |||
735 | case WPS_TOKEN_PLAYLIST_ENTRIES: | ||
736 | snprintf(buf, buf_size, "%d", playlist_amount()); | ||
737 | return buf; | ||
738 | |||
739 | case WPS_TOKEN_PLAYLIST_NAME: | ||
740 | return playlist_name(NULL, buf, buf_size); | ||
741 | |||
742 | case WPS_TOKEN_PLAYLIST_POSITION: | ||
743 | snprintf(buf, buf_size, "%d", playlist_get_display_index()); | ||
744 | return buf; | ||
745 | |||
746 | case WPS_TOKEN_PLAYLIST_SHUFFLE: | ||
747 | if ( global_settings.playlist_shuffle ) | ||
748 | return "s"; | ||
749 | else | ||
750 | return NULL; | ||
751 | break; | ||
752 | |||
753 | case WPS_TOKEN_VOLUME: | ||
754 | snprintf(buf, buf_size, "%d", global_settings.volume); | ||
755 | if (intval) | ||
756 | { | ||
757 | if (global_settings.volume == sound_min(SOUND_VOLUME)) | ||
758 | { | ||
759 | *intval = 1; | ||
760 | } | ||
761 | else if (global_settings.volume == 0) | ||
762 | { | ||
763 | *intval = limit - 1; | ||
764 | } | ||
765 | else if (global_settings.volume > 0) | ||
766 | { | ||
767 | *intval = limit; | ||
768 | } | ||
769 | else | ||
770 | { | ||
771 | *intval = (limit - 3) * (global_settings.volume | ||
772 | - sound_min(SOUND_VOLUME) - 1) | ||
773 | / (-1 - sound_min(SOUND_VOLUME)) + 2; | ||
774 | } | ||
775 | } | ||
776 | return buf; | ||
777 | |||
778 | case WPS_TOKEN_TRACK_ELAPSED_PERCENT: | ||
779 | if (id3->length <= 0) | ||
780 | return NULL; | ||
781 | |||
782 | if (intval) | ||
783 | { | ||
784 | *intval = limit * (id3->elapsed + state->ff_rewind_count) | ||
785 | / id3->length + 1; | ||
786 | } | ||
787 | snprintf(buf, buf_size, "%d", | ||
788 | 100*(id3->elapsed + state->ff_rewind_count) / id3->length); | ||
789 | return buf; | ||
790 | |||
791 | case WPS_TOKEN_METADATA_ARTIST: | ||
792 | return id3->artist; | ||
793 | |||
794 | case WPS_TOKEN_METADATA_COMPOSER: | ||
795 | return id3->composer; | ||
796 | |||
797 | case WPS_TOKEN_METADATA_ALBUM: | ||
798 | return id3->album; | ||
799 | |||
800 | case WPS_TOKEN_METADATA_ALBUM_ARTIST: | ||
801 | return id3->albumartist; | ||
802 | |||
803 | case WPS_TOKEN_METADATA_GROUPING: | ||
804 | return id3->grouping; | ||
805 | |||
806 | case WPS_TOKEN_METADATA_GENRE: | ||
807 | return id3->genre_string; | ||
808 | |||
809 | case WPS_TOKEN_METADATA_DISC_NUMBER: | ||
810 | if (id3->disc_string) | ||
811 | return id3->disc_string; | ||
812 | if (id3->discnum) { | ||
813 | snprintf(buf, buf_size, "%d", id3->discnum); | ||
814 | return buf; | ||
815 | } | ||
816 | return NULL; | ||
817 | |||
818 | case WPS_TOKEN_METADATA_TRACK_NUMBER: | ||
819 | if (id3->track_string) | ||
820 | return id3->track_string; | ||
821 | |||
822 | if (id3->tracknum) { | ||
823 | snprintf(buf, buf_size, "%d", id3->tracknum); | ||
824 | return buf; | ||
825 | } | ||
826 | return NULL; | ||
827 | |||
828 | case WPS_TOKEN_METADATA_TRACK_TITLE: | ||
829 | return id3->title; | ||
830 | |||
831 | case WPS_TOKEN_METADATA_VERSION: | ||
832 | switch (id3->id3version) | ||
833 | { | ||
834 | case ID3_VER_1_0: | ||
835 | return "1"; | ||
836 | |||
837 | case ID3_VER_1_1: | ||
838 | return "1.1"; | ||
839 | |||
840 | case ID3_VER_2_2: | ||
841 | return "2.2"; | ||
842 | |||
843 | case ID3_VER_2_3: | ||
844 | return "2.3"; | ||
845 | |||
846 | case ID3_VER_2_4: | ||
847 | return "2.4"; | ||
848 | |||
849 | default: | ||
850 | return NULL; | ||
851 | } | ||
852 | |||
853 | case WPS_TOKEN_METADATA_YEAR: | ||
854 | if( id3->year_string ) | ||
855 | return id3->year_string; | ||
856 | |||
857 | if (id3->year) { | ||
858 | snprintf(buf, buf_size, "%d", id3->year); | ||
859 | return buf; | ||
860 | } | ||
861 | return NULL; | ||
862 | |||
863 | case WPS_TOKEN_METADATA_COMMENT: | ||
864 | return id3->comment; | ||
865 | |||
866 | #ifdef HAVE_ALBUMART | ||
867 | case WPS_TOKEN_ALBUMART_DISPLAY: | ||
868 | draw_album_art(gwps, audio_current_aa_hid(), false); | ||
869 | return NULL; | ||
870 | |||
871 | case WPS_TOKEN_ALBUMART_FOUND: | ||
872 | if (audio_current_aa_hid() >= 0) { | ||
873 | return "C"; | ||
874 | } | ||
875 | return NULL; | ||
876 | #endif | ||
877 | |||
878 | case WPS_TOKEN_FILE_BITRATE: | ||
879 | if(id3->bitrate) | ||
880 | snprintf(buf, buf_size, "%d", id3->bitrate); | ||
881 | else | ||
882 | return "?"; | ||
883 | return buf; | ||
884 | |||
885 | case WPS_TOKEN_FILE_CODEC: | ||
886 | if (intval) | ||
887 | { | ||
888 | if(id3->codectype == AFMT_UNKNOWN) | ||
889 | *intval = AFMT_NUM_CODECS; | ||
890 | else | ||
891 | *intval = id3->codectype; | ||
892 | } | ||
893 | return get_codectype(id3); | ||
894 | |||
895 | case WPS_TOKEN_FILE_FREQUENCY: | ||
896 | snprintf(buf, buf_size, "%ld", id3->frequency); | ||
897 | return buf; | ||
898 | |||
899 | case WPS_TOKEN_FILE_FREQUENCY_KHZ: | ||
900 | /* ignore remainders < 100, so 22050 Hz becomes just 22k */ | ||
901 | if ((id3->frequency % 1000) < 100) | ||
902 | snprintf(buf, buf_size, "%ld", id3->frequency / 1000); | ||
903 | else | ||
904 | snprintf(buf, buf_size, "%ld.%d", | ||
905 | id3->frequency / 1000, | ||
906 | (id3->frequency % 1000) / 100); | ||
907 | return buf; | ||
908 | |||
909 | case WPS_TOKEN_FILE_NAME: | ||
910 | if (get_dir(buf, buf_size, id3->path, 0)) { | ||
911 | /* Remove extension */ | ||
912 | char* sep = strrchr(buf, '.'); | ||
913 | if (NULL != sep) { | ||
914 | *sep = 0; | ||
915 | } | ||
916 | return buf; | ||
917 | } | ||
918 | else { | ||
919 | return NULL; | ||
920 | } | ||
921 | |||
922 | case WPS_TOKEN_FILE_NAME_WITH_EXTENSION: | ||
923 | return get_dir(buf, buf_size, id3->path, 0); | ||
924 | |||
925 | case WPS_TOKEN_FILE_PATH: | ||
926 | return id3->path; | ||
927 | |||
928 | case WPS_TOKEN_FILE_SIZE: | ||
929 | snprintf(buf, buf_size, "%ld", id3->filesize / 1024); | ||
930 | return buf; | ||
931 | |||
932 | case WPS_TOKEN_FILE_VBR: | ||
933 | return id3->vbr ? "(avg)" : NULL; | ||
934 | |||
935 | case WPS_TOKEN_FILE_DIRECTORY: | ||
936 | return get_dir(buf, buf_size, id3->path, token->value.i); | ||
937 | |||
938 | case WPS_TOKEN_BATTERY_PERCENT: | ||
939 | { | ||
940 | int l = battery_level(); | ||
941 | |||
942 | if (intval) | ||
943 | { | ||
944 | limit = MAX(limit, 2); | ||
945 | if (l > -1) { | ||
946 | /* First enum is used for "unknown level". */ | ||
947 | *intval = (limit - 1) * l / 100 + 2; | ||
948 | } else { | ||
949 | *intval = 1; | ||
950 | } | ||
951 | } | ||
952 | |||
953 | if (l > -1) { | ||
954 | snprintf(buf, buf_size, "%d", l); | ||
955 | return buf; | ||
956 | } else { | ||
957 | return "?"; | ||
958 | } | ||
959 | } | ||
960 | |||
961 | case WPS_TOKEN_BATTERY_VOLTS: | ||
962 | { | ||
963 | unsigned int v = battery_voltage(); | ||
964 | snprintf(buf, buf_size, "%d.%02d", v / 1000, (v % 1000) / 10); | ||
965 | return buf; | ||
966 | } | ||
967 | |||
968 | case WPS_TOKEN_BATTERY_TIME: | ||
969 | { | ||
970 | int t = battery_time(); | ||
971 | if (t >= 0) | ||
972 | snprintf(buf, buf_size, "%dh %dm", t / 60, t % 60); | ||
973 | else | ||
974 | return "?h ?m"; | ||
975 | return buf; | ||
976 | } | ||
977 | |||
978 | #if CONFIG_CHARGING | ||
979 | case WPS_TOKEN_BATTERY_CHARGER_CONNECTED: | ||
980 | { | ||
981 | if(charger_input_state==CHARGER) | ||
982 | return "p"; | ||
983 | else | ||
984 | return NULL; | ||
985 | } | ||
986 | #endif | ||
987 | #if CONFIG_CHARGING >= CHARGING_MONITOR | ||
988 | case WPS_TOKEN_BATTERY_CHARGING: | ||
989 | { | ||
990 | if (charge_state == CHARGING || charge_state == TOPOFF) { | ||
991 | return "c"; | ||
992 | } else { | ||
993 | return NULL; | ||
994 | } | ||
995 | } | ||
996 | #endif | ||
997 | case WPS_TOKEN_BATTERY_SLEEPTIME: | ||
998 | { | ||
999 | if (get_sleep_timer() == 0) | ||
1000 | return NULL; | ||
1001 | else | ||
1002 | { | ||
1003 | format_time(buf, buf_size, get_sleep_timer() * 1000); | ||
1004 | return buf; | ||
1005 | } | ||
1006 | } | ||
1007 | |||
1008 | case WPS_TOKEN_PLAYBACK_STATUS: | ||
1009 | { | ||
1010 | int status = audio_status(); | ||
1011 | int mode = 1; | ||
1012 | if (status == AUDIO_STATUS_PLAY) | ||
1013 | mode = 2; | ||
1014 | if (wps_fading_out || | ||
1015 | (status & AUDIO_STATUS_PAUSE && !status_get_ffmode())) | ||
1016 | mode = 3; | ||
1017 | if (status_get_ffmode() == STATUS_FASTFORWARD) | ||
1018 | mode = 4; | ||
1019 | if (status_get_ffmode() == STATUS_FASTBACKWARD) | ||
1020 | mode = 5; | ||
1021 | |||
1022 | if (intval) { | ||
1023 | *intval = mode; | ||
1024 | } | ||
1025 | |||
1026 | snprintf(buf, buf_size, "%d", mode-1); | ||
1027 | return buf; | ||
1028 | } | ||
1029 | |||
1030 | case WPS_TOKEN_REPEAT_MODE: | ||
1031 | if (intval) | ||
1032 | *intval = global_settings.repeat_mode + 1; | ||
1033 | snprintf(buf, buf_size, "%d", global_settings.repeat_mode); | ||
1034 | return buf; | ||
1035 | |||
1036 | case WPS_TOKEN_RTC_PRESENT: | ||
1037 | #if CONFIG_RTC | ||
1038 | return "c"; | ||
1039 | #else | ||
1040 | return NULL; | ||
1041 | #endif | ||
1042 | |||
1043 | #if CONFIG_RTC | ||
1044 | case WPS_TOKEN_RTC_12HOUR_CFG: | ||
1045 | if (intval) | ||
1046 | *intval = global_settings.timeformat + 1; | ||
1047 | snprintf(buf, buf_size, "%d", global_settings.timeformat); | ||
1048 | return buf; | ||
1049 | |||
1050 | case WPS_TOKEN_RTC_DAY_OF_MONTH: | ||
1051 | /* d: day of month (01..31) */ | ||
1052 | snprintf(buf, buf_size, "%02d", tm->tm_mday); | ||
1053 | return buf; | ||
1054 | |||
1055 | case WPS_TOKEN_RTC_DAY_OF_MONTH_BLANK_PADDED: | ||
1056 | /* e: day of month, blank padded ( 1..31) */ | ||
1057 | snprintf(buf, buf_size, "%2d", tm->tm_mday); | ||
1058 | return buf; | ||
1059 | |||
1060 | case WPS_TOKEN_RTC_HOUR_24_ZERO_PADDED: | ||
1061 | /* H: hour (00..23) */ | ||
1062 | snprintf(buf, buf_size, "%02d", tm->tm_hour); | ||
1063 | return buf; | ||
1064 | |||
1065 | case WPS_TOKEN_RTC_HOUR_24: | ||
1066 | /* k: hour ( 0..23) */ | ||
1067 | snprintf(buf, buf_size, "%2d", tm->tm_hour); | ||
1068 | return buf; | ||
1069 | |||
1070 | case WPS_TOKEN_RTC_HOUR_12_ZERO_PADDED: | ||
1071 | /* I: hour (01..12) */ | ||
1072 | snprintf(buf, buf_size, "%02d", | ||
1073 | (tm->tm_hour % 12 == 0) ? 12 : tm->tm_hour % 12); | ||
1074 | return buf; | ||
1075 | |||
1076 | case WPS_TOKEN_RTC_HOUR_12: | ||
1077 | /* l: hour ( 1..12) */ | ||
1078 | snprintf(buf, buf_size, "%2d", | ||
1079 | (tm->tm_hour % 12 == 0) ? 12 : tm->tm_hour % 12); | ||
1080 | return buf; | ||
1081 | |||
1082 | case WPS_TOKEN_RTC_MONTH: | ||
1083 | /* m: month (01..12) */ | ||
1084 | if (intval) | ||
1085 | *intval = tm->tm_mon + 1; | ||
1086 | snprintf(buf, buf_size, "%02d", tm->tm_mon + 1); | ||
1087 | return buf; | ||
1088 | |||
1089 | case WPS_TOKEN_RTC_MINUTE: | ||
1090 | /* M: minute (00..59) */ | ||
1091 | snprintf(buf, buf_size, "%02d", tm->tm_min); | ||
1092 | return buf; | ||
1093 | |||
1094 | case WPS_TOKEN_RTC_SECOND: | ||
1095 | /* S: second (00..59) */ | ||
1096 | snprintf(buf, buf_size, "%02d", tm->tm_sec); | ||
1097 | return buf; | ||
1098 | |||
1099 | case WPS_TOKEN_RTC_YEAR_2_DIGITS: | ||
1100 | /* y: last two digits of year (00..99) */ | ||
1101 | snprintf(buf, buf_size, "%02d", tm->tm_year % 100); | ||
1102 | return buf; | ||
1103 | |||
1104 | case WPS_TOKEN_RTC_YEAR_4_DIGITS: | ||
1105 | /* Y: year (1970...) */ | ||
1106 | snprintf(buf, buf_size, "%04d", tm->tm_year + 1900); | ||
1107 | return buf; | ||
1108 | |||
1109 | case WPS_TOKEN_RTC_AM_PM_UPPER: | ||
1110 | /* p: upper case AM or PM indicator */ | ||
1111 | return tm->tm_hour/12 == 0 ? "AM" : "PM"; | ||
1112 | |||
1113 | case WPS_TOKEN_RTC_AM_PM_LOWER: | ||
1114 | /* P: lower case am or pm indicator */ | ||
1115 | return tm->tm_hour/12 == 0 ? "am" : "pm"; | ||
1116 | |||
1117 | case WPS_TOKEN_RTC_WEEKDAY_NAME: | ||
1118 | /* a: abbreviated weekday name (Sun..Sat) */ | ||
1119 | return str(LANG_WEEKDAY_SUNDAY + tm->tm_wday); | ||
1120 | |||
1121 | case WPS_TOKEN_RTC_MONTH_NAME: | ||
1122 | /* b: abbreviated month name (Jan..Dec) */ | ||
1123 | return str(LANG_MONTH_JANUARY + tm->tm_mon); | ||
1124 | |||
1125 | case WPS_TOKEN_RTC_DAY_OF_WEEK_START_MON: | ||
1126 | /* u: day of week (1..7); 1 is Monday */ | ||
1127 | if (intval) | ||
1128 | *intval = (tm->tm_wday == 0) ? 7 : tm->tm_wday; | ||
1129 | snprintf(buf, buf_size, "%1d", tm->tm_wday + 1); | ||
1130 | return buf; | ||
1131 | |||
1132 | case WPS_TOKEN_RTC_DAY_OF_WEEK_START_SUN: | ||
1133 | /* w: day of week (0..6); 0 is Sunday */ | ||
1134 | if (intval) | ||
1135 | *intval = tm->tm_wday + 1; | ||
1136 | snprintf(buf, buf_size, "%1d", tm->tm_wday); | ||
1137 | return buf; | ||
1138 | #else | ||
1139 | case WPS_TOKEN_RTC_DAY_OF_MONTH: | ||
1140 | case WPS_TOKEN_RTC_DAY_OF_MONTH_BLANK_PADDED: | ||
1141 | case WPS_TOKEN_RTC_HOUR_24_ZERO_PADDED: | ||
1142 | case WPS_TOKEN_RTC_HOUR_24: | ||
1143 | case WPS_TOKEN_RTC_HOUR_12_ZERO_PADDED: | ||
1144 | case WPS_TOKEN_RTC_HOUR_12: | ||
1145 | case WPS_TOKEN_RTC_MONTH: | ||
1146 | case WPS_TOKEN_RTC_MINUTE: | ||
1147 | case WPS_TOKEN_RTC_SECOND: | ||
1148 | case WPS_TOKEN_RTC_AM_PM_UPPER: | ||
1149 | case WPS_TOKEN_RTC_AM_PM_LOWER: | ||
1150 | case WPS_TOKEN_RTC_YEAR_2_DIGITS: | ||
1151 | return "--"; | ||
1152 | case WPS_TOKEN_RTC_YEAR_4_DIGITS: | ||
1153 | return "----"; | ||
1154 | case WPS_TOKEN_RTC_WEEKDAY_NAME: | ||
1155 | case WPS_TOKEN_RTC_MONTH_NAME: | ||
1156 | return "---"; | ||
1157 | case WPS_TOKEN_RTC_DAY_OF_WEEK_START_MON: | ||
1158 | case WPS_TOKEN_RTC_DAY_OF_WEEK_START_SUN: | ||
1159 | return "-"; | ||
1160 | #endif | ||
1161 | |||
1162 | #ifdef HAVE_LCD_CHARCELLS | ||
1163 | case WPS_TOKEN_PROGRESSBAR: | ||
1164 | { | ||
1165 | char *end = utf8encode(data->wps_progress_pat[0], buf); | ||
1166 | *end = '\0'; | ||
1167 | return buf; | ||
1168 | } | ||
1169 | |||
1170 | case WPS_TOKEN_PLAYER_PROGRESSBAR: | ||
1171 | if(is_new_player()) | ||
1172 | { | ||
1173 | /* we need 11 characters (full line) for | ||
1174 | progress-bar */ | ||
1175 | strlcpy(buf, " ", buf_size); | ||
1176 | } | ||
1177 | else | ||
1178 | { | ||
1179 | /* Tell the user if we have an OldPlayer */ | ||
1180 | strlcpy(buf, " <Old LCD> ", buf_size); | ||
1181 | } | ||
1182 | return buf; | ||
1183 | #endif | ||
1184 | |||
1185 | #ifdef HAVE_TAGCACHE | ||
1186 | case WPS_TOKEN_DATABASE_PLAYCOUNT: | ||
1187 | if (intval) { | ||
1188 | *intval = id3->playcount + 1; | ||
1189 | } | ||
1190 | snprintf(buf, buf_size, "%ld", id3->playcount); | ||
1191 | return buf; | ||
1192 | |||
1193 | case WPS_TOKEN_DATABASE_RATING: | ||
1194 | if (intval) { | ||
1195 | *intval = id3->rating + 1; | ||
1196 | } | ||
1197 | snprintf(buf, buf_size, "%d", id3->rating); | ||
1198 | return buf; | ||
1199 | |||
1200 | case WPS_TOKEN_DATABASE_AUTOSCORE: | ||
1201 | if (intval) | ||
1202 | *intval = id3->score + 1; | ||
1203 | |||
1204 | snprintf(buf, buf_size, "%d", id3->score); | ||
1205 | return buf; | ||
1206 | #endif | ||
1207 | |||
1208 | #if (CONFIG_CODEC == SWCODEC) | ||
1209 | case WPS_TOKEN_CROSSFADE: | ||
1210 | if (intval) | ||
1211 | *intval = global_settings.crossfade + 1; | ||
1212 | snprintf(buf, buf_size, "%d", global_settings.crossfade); | ||
1213 | return buf; | ||
1214 | |||
1215 | case WPS_TOKEN_REPLAYGAIN: | ||
1216 | { | ||
1217 | int val; | ||
1218 | |||
1219 | if (global_settings.replaygain_type == REPLAYGAIN_OFF) | ||
1220 | val = 1; /* off */ | ||
1221 | else | ||
1222 | { | ||
1223 | int type = | ||
1224 | get_replaygain_mode(id3->track_gain_string != NULL, | ||
1225 | id3->album_gain_string != NULL); | ||
1226 | if (type < 0) | ||
1227 | val = 6; /* no tag */ | ||
1228 | else | ||
1229 | val = type + 2; | ||
1230 | |||
1231 | if (global_settings.replaygain_type == REPLAYGAIN_SHUFFLE) | ||
1232 | val += 2; | ||
1233 | } | ||
1234 | |||
1235 | if (intval) | ||
1236 | *intval = val; | ||
1237 | |||
1238 | switch (val) | ||
1239 | { | ||
1240 | case 1: | ||
1241 | case 6: | ||
1242 | return "+0.00 dB"; | ||
1243 | break; | ||
1244 | case 2: | ||
1245 | case 4: | ||
1246 | strlcpy(buf, id3->track_gain_string, buf_size); | ||
1247 | break; | ||
1248 | case 3: | ||
1249 | case 5: | ||
1250 | strlcpy(buf, id3->album_gain_string, buf_size); | ||
1251 | break; | ||
1252 | } | ||
1253 | return buf; | ||
1254 | } | ||
1255 | #endif /* (CONFIG_CODEC == SWCODEC) */ | ||
1256 | |||
1257 | #if (CONFIG_CODEC != MAS3507D) | ||
1258 | case WPS_TOKEN_SOUND_PITCH: | ||
1259 | { | ||
1260 | int val = sound_get_pitch(); | ||
1261 | snprintf(buf, buf_size, "%d.%d", | ||
1262 | val / 10, val % 10); | ||
1263 | return buf; | ||
1264 | } | ||
1265 | #endif | ||
1266 | |||
1267 | case WPS_TOKEN_MAIN_HOLD: | ||
1268 | #ifdef HAS_BUTTON_HOLD | ||
1269 | if (button_hold()) | ||
1270 | #else | ||
1271 | if (is_keys_locked()) | ||
1272 | #endif /*hold switch or softlock*/ | ||
1273 | return "h"; | ||
1274 | else | ||
1275 | return NULL; | ||
1276 | |||
1277 | #ifdef HAS_REMOTE_BUTTON_HOLD | ||
1278 | case WPS_TOKEN_REMOTE_HOLD: | ||
1279 | if (remote_button_hold()) | ||
1280 | return "r"; | ||
1281 | else | ||
1282 | return NULL; | ||
1283 | #endif | ||
1284 | |||
1285 | #if (CONFIG_LED == LED_VIRTUAL) || defined(HAVE_REMOTE_LCD) | ||
1286 | case WPS_TOKEN_VLED_HDD: | ||
1287 | if(led_read(HZ/2)) | ||
1288 | return "h"; | ||
1289 | else | ||
1290 | return NULL; | ||
1291 | #endif | ||
1292 | case WPS_TOKEN_BUTTON_VOLUME: | ||
1293 | if (data->button_time_volume && | ||
1294 | TIME_BEFORE(current_tick, data->button_time_volume + | ||
1295 | token->value.i * TIMEOUT_UNIT)) | ||
1296 | return "v"; | ||
1297 | return NULL; | ||
1298 | case WPS_TOKEN_LASTTOUCH: | ||
1299 | #ifdef HAVE_TOUCHSCREEN | ||
1300 | if (TIME_BEFORE(current_tick, token->value.i * TIMEOUT_UNIT + | ||
1301 | touchscreen_last_touch())) | ||
1302 | return "t"; | ||
1303 | #endif | ||
1304 | return NULL; | ||
1305 | |||
1306 | case WPS_TOKEN_SETTING: | ||
1307 | { | ||
1308 | if (intval) | ||
1309 | { | ||
1310 | /* Handle contionals */ | ||
1311 | const struct settings_list *s = settings+token->value.i; | ||
1312 | switch (s->flags&F_T_MASK) | ||
1313 | { | ||
1314 | case F_T_INT: | ||
1315 | case F_T_UINT: | ||
1316 | if (s->flags&F_RGB) | ||
1317 | /* %?St|name|<#000000|#000001|...|#FFFFFF> */ | ||
1318 | /* shouldn't overflow since colors are stored | ||
1319 | * on 16 bits ... | ||
1320 | * but this is pretty useless anyway */ | ||
1321 | *intval = *(int*)s->setting + 1; | ||
1322 | else if (s->cfg_vals == NULL) | ||
1323 | /* %?St|name|<1st choice|2nd choice|...> */ | ||
1324 | *intval = (*(int*)s->setting-s->int_setting->min) | ||
1325 | /s->int_setting->step + 1; | ||
1326 | else | ||
1327 | /* %?St|name|<1st choice|2nd choice|...> */ | ||
1328 | /* Not sure about this one. cfg_name/vals are | ||
1329 | * indexed from 0 right? */ | ||
1330 | *intval = *(int*)s->setting + 1; | ||
1331 | break; | ||
1332 | case F_T_BOOL: | ||
1333 | /* %?St|name|<if true|if false> */ | ||
1334 | *intval = *(bool*)s->setting?1:2; | ||
1335 | break; | ||
1336 | case F_T_CHARPTR: | ||
1337 | /* %?St|name|<if non empty string|if empty> | ||
1338 | * The string's emptyness discards the setting's | ||
1339 | * prefix and suffix */ | ||
1340 | *intval = ((char*)s->setting)[0]?1:2; | ||
1341 | break; | ||
1342 | default: | ||
1343 | /* This shouldn't happen ... but you never know */ | ||
1344 | *intval = -1; | ||
1345 | break; | ||
1346 | } | ||
1347 | } | ||
1348 | cfg_to_string(token->value.i,buf,buf_size); | ||
1349 | return buf; | ||
1350 | } | ||
1351 | |||
1352 | default: | ||
1353 | return NULL; | ||
1354 | } | ||
1355 | } | ||
1356 | |||
1357 | /* Return the index to the end token for the conditional token at index. | 385 | /* Return the index to the end token for the conditional token at index. |
1358 | The conditional token can be either a start token or a separator | 386 | The conditional token can be either a start token or a separator |
1359 | (i.e. option) token. | 387 | (i.e. option) token. |
diff --git a/apps/gui/wps_engine/wps_engine.h b/apps/gui/wps_engine/wps_engine.h new file mode 100644 index 0000000000..fe034f9138 --- /dev/null +++ b/apps/gui/wps_engine/wps_engine.h | |||
@@ -0,0 +1,49 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id: gwps.h 22003 2009-07-22 22:10:25Z kugel $ | ||
9 | * | ||
10 | * Copyright (C) 2007 Nicolas Pennequin | ||
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 | /** Use this for stuff which external code needs to include **/ | ||
23 | |||
24 | #ifndef _WPS_ENGINE_H | ||
25 | #define _WPS_ENGINE_H | ||
26 | #include <stdbool.h> | ||
27 | #include "wps_internals.h" /* TODO: remove this line.. shoudlnt be needed */ | ||
28 | |||
29 | |||
30 | #ifdef HAVE_TOUCHSCREEN | ||
31 | int wps_get_touchaction(struct wps_data *data); | ||
32 | #endif | ||
33 | |||
34 | #ifdef HAVE_ALBUMART | ||
35 | /* gives back if WPS contains an albumart tag */ | ||
36 | bool gui_sync_wps_uses_albumart(void); | ||
37 | #endif | ||
38 | |||
39 | /* setup and display a WPS for the first time */ | ||
40 | bool gui_wps_display(struct gui_wps *gwps); | ||
41 | /* do a requested redraw */ | ||
42 | bool gui_wps_redraw(struct gui_wps *gwps, | ||
43 | int ffwd_offset, | ||
44 | unsigned refresh_mode); | ||
45 | /* do a partial redraw, or full if required, also do any housekeeping | ||
46 | * which might be needed */ | ||
47 | bool gui_wps_update(struct gui_wps *gwps); | ||
48 | |||
49 | #endif | ||
diff --git a/apps/gui/wps_engine/wps_internals.h b/apps/gui/wps_engine/wps_internals.h new file mode 100644 index 0000000000..581763fb9a --- /dev/null +++ b/apps/gui/wps_engine/wps_internals.h | |||
@@ -0,0 +1,556 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2007 Nicolas Pennequin | ||
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 | /* This stuff is for the wps engine only.. anyone caught using this outside | ||
23 | * of apps/gui/wps_engine will be shot on site! */ | ||
24 | |||
25 | #ifndef _WPS_ENGINE_INTERNALS_ | ||
26 | #define _WPS_ENGINE_INTERNALS_ | ||
27 | /* Timeout unit expressed in HZ. In WPS, all timeouts are given in seconds | ||
28 | (possibly with a decimal fraction) but stored as integer values. | ||
29 | E.g. 2.5 is stored as 25. This means 25 tenth of a second, i.e. 25 units. | ||
30 | */ | ||
31 | #define TIMEOUT_UNIT (HZ/10) /* I.e. 0.1 sec */ | ||
32 | #define DEFAULT_SUBLINE_TIME_MULTIPLIER 20 /* In TIMEOUT_UNIT's */ | ||
33 | |||
34 | |||
35 | |||
36 | |||
37 | /* TODO: sort this mess out */ | ||
38 | |||
39 | #include "screen_access.h" | ||
40 | #include "statusbar.h" | ||
41 | #include "metadata.h" | ||
42 | |||
43 | /* constants used in line_type and as refresh_mode for wps_refresh */ | ||
44 | #define WPS_REFRESH_STATIC (1u<<0) /* line doesn't change over time */ | ||
45 | #define WPS_REFRESH_DYNAMIC (1u<<1) /* line may change (e.g. time flag) */ | ||
46 | #define WPS_REFRESH_SCROLL (1u<<2) /* line scrolls */ | ||
47 | #define WPS_REFRESH_PLAYER_PROGRESS (1u<<3) /* line contains a progress bar */ | ||
48 | #define WPS_REFRESH_PEAK_METER (1u<<4) /* line contains a peak meter */ | ||
49 | #define WPS_REFRESH_STATUSBAR (1u<<5) /* refresh statusbar */ | ||
50 | #define WPS_REFRESH_ALL (0xffffffffu) /* to refresh all line types */ | ||
51 | |||
52 | /* to refresh only those lines that change over time */ | ||
53 | #define WPS_REFRESH_NON_STATIC (WPS_REFRESH_DYNAMIC| \ | ||
54 | WPS_REFRESH_PLAYER_PROGRESS| \ | ||
55 | WPS_REFRESH_PEAK_METER) | ||
56 | /* alignments */ | ||
57 | #define WPS_ALIGN_RIGHT 32 | ||
58 | #define WPS_ALIGN_CENTER 64 | ||
59 | #define WPS_ALIGN_LEFT 128 | ||
60 | |||
61 | #ifdef HAVE_ALBUMART | ||
62 | |||
63 | /* albumart definitions */ | ||
64 | #define WPS_ALBUMART_NONE 0 /* WPS does not contain AA tag */ | ||
65 | #define WPS_ALBUMART_CHECK 1 /* WPS contains AA conditional tag */ | ||
66 | #define WPS_ALBUMART_LOAD 2 /* WPS contains AA tag */ | ||
67 | |||
68 | #define WPS_ALBUMART_ALIGN_RIGHT 1 /* x align: right */ | ||
69 | #define WPS_ALBUMART_ALIGN_CENTER 2 /* x/y align: center */ | ||
70 | #define WPS_ALBUMART_ALIGN_LEFT 4 /* x align: left */ | ||
71 | #define WPS_ALBUMART_ALIGN_TOP 1 /* y align: top */ | ||
72 | #define WPS_ALBUMART_ALIGN_BOTTOM 4 /* y align: bottom */ | ||
73 | |||
74 | #endif /* HAVE_ALBUMART */ | ||
75 | |||
76 | /* wps_data*/ | ||
77 | |||
78 | #ifdef HAVE_LCD_BITMAP | ||
79 | struct gui_img { | ||
80 | struct bitmap bm; | ||
81 | struct viewport* vp; /* The viewport to display this image in */ | ||
82 | short int x; /* x-pos */ | ||
83 | short int y; /* y-pos */ | ||
84 | short int num_subimages; /* number of sub-images */ | ||
85 | short int subimage_height; /* height of each sub-image */ | ||
86 | short int display; /* -1 for no display, 0..n to display a subimage */ | ||
87 | bool loaded; /* load state */ | ||
88 | bool always_display; /* not using the preload/display mechanism */ | ||
89 | }; | ||
90 | |||
91 | struct progressbar { | ||
92 | /* regular pb */ | ||
93 | short x; | ||
94 | /* >=0: explicitly set in the tag -> y-coord within the viewport | ||
95 | <0 : not set in the tag -> negated 1-based line number within | ||
96 | the viewport. y-coord will be computed based on the font height */ | ||
97 | short y; | ||
98 | short width; | ||
99 | short height; | ||
100 | /*progressbar image*/ | ||
101 | struct bitmap bm; | ||
102 | bool have_bitmap_pb; | ||
103 | }; | ||
104 | #endif | ||
105 | |||
106 | |||
107 | |||
108 | struct align_pos { | ||
109 | char* left; | ||
110 | char* center; | ||
111 | char* right; | ||
112 | }; | ||
113 | |||
114 | #ifdef HAVE_LCD_BITMAP | ||
115 | |||
116 | #define MAX_IMAGES (26*2) /* a-z and A-Z */ | ||
117 | #define MAX_PROGRESSBARS 3 | ||
118 | |||
119 | /* The image buffer is big enough to store one full-screen native bitmap, | ||
120 | plus two full-screen mono bitmaps. */ | ||
121 | |||
122 | #define IMG_BUFSIZE ((LCD_HEIGHT*LCD_WIDTH*LCD_DEPTH/8) \ | ||
123 | + (2*LCD_HEIGHT*LCD_WIDTH/8)) | ||
124 | |||
125 | #define WPS_MAX_VIEWPORTS 24 | ||
126 | #define WPS_MAX_LINES ((LCD_HEIGHT/5+1) * 2) | ||
127 | #define WPS_MAX_SUBLINES (WPS_MAX_LINES*3) | ||
128 | #define WPS_MAX_TOKENS 1024 | ||
129 | #define WPS_MAX_STRINGS 128 | ||
130 | #define STRING_BUFFER_SIZE 1024 | ||
131 | #define WPS_MAX_COND_LEVEL 10 | ||
132 | |||
133 | #else | ||
134 | |||
135 | #define WPS_MAX_VIEWPORTS 2 | ||
136 | #define WPS_MAX_LINES 2 | ||
137 | #define WPS_MAX_SUBLINES 12 | ||
138 | #define WPS_MAX_TOKENS 64 | ||
139 | #define WPS_MAX_STRINGS 32 | ||
140 | #define STRING_BUFFER_SIZE 64 | ||
141 | #define WPS_MAX_COND_LEVEL 5 | ||
142 | |||
143 | #endif | ||
144 | |||
145 | #define SUBLINE_RESET -1 | ||
146 | |||
147 | enum wps_parse_error { | ||
148 | PARSE_OK, | ||
149 | PARSE_FAIL_UNCLOSED_COND, | ||
150 | PARSE_FAIL_INVALID_CHAR, | ||
151 | PARSE_FAIL_COND_SYNTAX_ERROR, | ||
152 | PARSE_FAIL_COND_INVALID_PARAM, | ||
153 | PARSE_FAIL_LIMITS_EXCEEDED, | ||
154 | }; | ||
155 | |||
156 | enum wps_token_type { | ||
157 | WPS_NO_TOKEN, /* for WPS tags we don't want to save as tokens */ | ||
158 | WPS_TOKEN_UNKNOWN, | ||
159 | |||
160 | /* Markers */ | ||
161 | WPS_TOKEN_CHARACTER, | ||
162 | WPS_TOKEN_STRING, | ||
163 | |||
164 | /* Alignment */ | ||
165 | WPS_TOKEN_ALIGN_LEFT, | ||
166 | WPS_TOKEN_ALIGN_CENTER, | ||
167 | WPS_TOKEN_ALIGN_RIGHT, | ||
168 | |||
169 | /* Sublines */ | ||
170 | WPS_TOKEN_SUBLINE_TIMEOUT, | ||
171 | |||
172 | /* Battery */ | ||
173 | WPS_TOKEN_BATTERY_PERCENT, | ||
174 | WPS_TOKEN_BATTERY_VOLTS, | ||
175 | WPS_TOKEN_BATTERY_TIME, | ||
176 | WPS_TOKEN_BATTERY_CHARGER_CONNECTED, | ||
177 | WPS_TOKEN_BATTERY_CHARGING, | ||
178 | WPS_TOKEN_BATTERY_SLEEPTIME, | ||
179 | |||
180 | /* Sound */ | ||
181 | #if (CONFIG_CODEC != MAS3507D) | ||
182 | WPS_TOKEN_SOUND_PITCH, | ||
183 | #endif | ||
184 | #if (CONFIG_CODEC == SWCODEC) | ||
185 | WPS_TOKEN_REPLAYGAIN, | ||
186 | WPS_TOKEN_CROSSFADE, | ||
187 | #endif | ||
188 | |||
189 | /* Time */ | ||
190 | |||
191 | WPS_TOKEN_RTC_PRESENT, | ||
192 | |||
193 | /* The begin/end values allow us to know if a token is an RTC one. | ||
194 | New RTC tokens should be added between the markers. */ | ||
195 | |||
196 | WPS_TOKENS_RTC_BEGIN, /* just the start marker, not an actual token */ | ||
197 | |||
198 | WPS_TOKEN_RTC_DAY_OF_MONTH, | ||
199 | WPS_TOKEN_RTC_DAY_OF_MONTH_BLANK_PADDED, | ||
200 | WPS_TOKEN_RTC_12HOUR_CFG, | ||
201 | WPS_TOKEN_RTC_HOUR_24_ZERO_PADDED, | ||
202 | WPS_TOKEN_RTC_HOUR_24, | ||
203 | WPS_TOKEN_RTC_HOUR_12_ZERO_PADDED, | ||
204 | WPS_TOKEN_RTC_HOUR_12, | ||
205 | WPS_TOKEN_RTC_MONTH, | ||
206 | WPS_TOKEN_RTC_MINUTE, | ||
207 | WPS_TOKEN_RTC_SECOND, | ||
208 | WPS_TOKEN_RTC_YEAR_2_DIGITS, | ||
209 | WPS_TOKEN_RTC_YEAR_4_DIGITS, | ||
210 | WPS_TOKEN_RTC_AM_PM_UPPER, | ||
211 | WPS_TOKEN_RTC_AM_PM_LOWER, | ||
212 | WPS_TOKEN_RTC_WEEKDAY_NAME, | ||
213 | WPS_TOKEN_RTC_MONTH_NAME, | ||
214 | WPS_TOKEN_RTC_DAY_OF_WEEK_START_MON, | ||
215 | WPS_TOKEN_RTC_DAY_OF_WEEK_START_SUN, | ||
216 | |||
217 | WPS_TOKENS_RTC_END, /* just the end marker, not an actual token */ | ||
218 | |||
219 | /* Conditional */ | ||
220 | WPS_TOKEN_CONDITIONAL, | ||
221 | WPS_TOKEN_CONDITIONAL_START, | ||
222 | WPS_TOKEN_CONDITIONAL_OPTION, | ||
223 | WPS_TOKEN_CONDITIONAL_END, | ||
224 | |||
225 | /* Database */ | ||
226 | #ifdef HAVE_TAGCACHE | ||
227 | WPS_TOKEN_DATABASE_PLAYCOUNT, | ||
228 | WPS_TOKEN_DATABASE_RATING, | ||
229 | WPS_TOKEN_DATABASE_AUTOSCORE, | ||
230 | #endif | ||
231 | |||
232 | /* File */ | ||
233 | WPS_TOKEN_FILE_BITRATE, | ||
234 | WPS_TOKEN_FILE_CODEC, | ||
235 | WPS_TOKEN_FILE_FREQUENCY, | ||
236 | WPS_TOKEN_FILE_FREQUENCY_KHZ, | ||
237 | WPS_TOKEN_FILE_NAME, | ||
238 | WPS_TOKEN_FILE_NAME_WITH_EXTENSION, | ||
239 | WPS_TOKEN_FILE_PATH, | ||
240 | WPS_TOKEN_FILE_SIZE, | ||
241 | WPS_TOKEN_FILE_VBR, | ||
242 | WPS_TOKEN_FILE_DIRECTORY, | ||
243 | |||
244 | #ifdef HAVE_LCD_BITMAP | ||
245 | /* Image */ | ||
246 | WPS_TOKEN_IMAGE_BACKDROP, | ||
247 | WPS_TOKEN_IMAGE_PROGRESS_BAR, | ||
248 | WPS_TOKEN_IMAGE_PRELOAD, | ||
249 | WPS_TOKEN_IMAGE_PRELOAD_DISPLAY, | ||
250 | WPS_TOKEN_IMAGE_DISPLAY, | ||
251 | #endif | ||
252 | |||
253 | #ifdef HAVE_ALBUMART | ||
254 | /* Albumart */ | ||
255 | WPS_TOKEN_ALBUMART_DISPLAY, | ||
256 | WPS_TOKEN_ALBUMART_FOUND, | ||
257 | #endif | ||
258 | |||
259 | /* Metadata */ | ||
260 | WPS_TOKEN_METADATA_ARTIST, | ||
261 | WPS_TOKEN_METADATA_COMPOSER, | ||
262 | WPS_TOKEN_METADATA_ALBUM_ARTIST, | ||
263 | WPS_TOKEN_METADATA_GROUPING, | ||
264 | WPS_TOKEN_METADATA_ALBUM, | ||
265 | WPS_TOKEN_METADATA_GENRE, | ||
266 | WPS_TOKEN_METADATA_DISC_NUMBER, | ||
267 | WPS_TOKEN_METADATA_TRACK_NUMBER, | ||
268 | WPS_TOKEN_METADATA_TRACK_TITLE, | ||
269 | WPS_TOKEN_METADATA_VERSION, | ||
270 | WPS_TOKEN_METADATA_YEAR, | ||
271 | WPS_TOKEN_METADATA_COMMENT, | ||
272 | |||
273 | /* Mode */ | ||
274 | WPS_TOKEN_REPEAT_MODE, | ||
275 | WPS_TOKEN_PLAYBACK_STATUS, | ||
276 | |||
277 | WPS_TOKEN_MAIN_HOLD, | ||
278 | |||
279 | #ifdef HAS_REMOTE_BUTTON_HOLD | ||
280 | WPS_TOKEN_REMOTE_HOLD, | ||
281 | #endif | ||
282 | |||
283 | /* Progressbar */ | ||
284 | WPS_TOKEN_PROGRESSBAR, | ||
285 | #ifdef HAVE_LCD_CHARCELLS | ||
286 | WPS_TOKEN_PLAYER_PROGRESSBAR, | ||
287 | #endif | ||
288 | |||
289 | #ifdef HAVE_LCD_BITMAP | ||
290 | /* Peakmeter */ | ||
291 | WPS_TOKEN_PEAKMETER, | ||
292 | #endif | ||
293 | |||
294 | /* Volume level */ | ||
295 | WPS_TOKEN_VOLUME, | ||
296 | |||
297 | /* Current track */ | ||
298 | WPS_TOKEN_TRACK_ELAPSED_PERCENT, | ||
299 | WPS_TOKEN_TRACK_TIME_ELAPSED, | ||
300 | WPS_TOKEN_TRACK_TIME_REMAINING, | ||
301 | WPS_TOKEN_TRACK_LENGTH, | ||
302 | |||
303 | /* Playlist */ | ||
304 | WPS_TOKEN_PLAYLIST_ENTRIES, | ||
305 | WPS_TOKEN_PLAYLIST_NAME, | ||
306 | WPS_TOKEN_PLAYLIST_POSITION, | ||
307 | WPS_TOKEN_PLAYLIST_SHUFFLE, | ||
308 | |||
309 | #if (CONFIG_LED == LED_VIRTUAL) || defined(HAVE_REMOTE_LCD) | ||
310 | /* Virtual LED */ | ||
311 | WPS_TOKEN_VLED_HDD, | ||
312 | #endif | ||
313 | |||
314 | /* Viewport display */ | ||
315 | WPS_VIEWPORT_ENABLE, | ||
316 | |||
317 | /* buttons */ | ||
318 | WPS_TOKEN_BUTTON_VOLUME, | ||
319 | WPS_TOKEN_LASTTOUCH, | ||
320 | |||
321 | /* Setting option */ | ||
322 | WPS_TOKEN_SETTING, | ||
323 | }; | ||
324 | |||
325 | struct wps_token { | ||
326 | unsigned char type; /* enough to store the token type */ | ||
327 | |||
328 | /* Whether the tag (e.g. track name or the album) refers the | ||
329 | current or the next song (false=current, true=next) */ | ||
330 | bool next; | ||
331 | |||
332 | union { | ||
333 | char c; | ||
334 | unsigned short i; | ||
335 | } value; | ||
336 | }; | ||
337 | |||
338 | /* Description of a subline on the WPS */ | ||
339 | struct wps_subline { | ||
340 | |||
341 | /* Index of the first token for this subline in the token array. | ||
342 | Tokens of this subline end where tokens for the next subline | ||
343 | begin. */ | ||
344 | unsigned short first_token_idx; | ||
345 | |||
346 | /* Bit or'ed WPS_REFRESH_xxx */ | ||
347 | unsigned char line_type; | ||
348 | |||
349 | /* How long the subline should be displayed, in 10ths of sec */ | ||
350 | unsigned char time_mult; | ||
351 | }; | ||
352 | |||
353 | /* Description of a line on the WPS. A line is a set of sublines. | ||
354 | A subline is displayed for a certain amount of time. After that, | ||
355 | the next subline of the line is displayed. And so on. */ | ||
356 | struct wps_line { | ||
357 | |||
358 | /* Number of sublines in this line */ | ||
359 | signed char num_sublines; | ||
360 | |||
361 | /* Number (0-based) of the subline within this line currently being displayed */ | ||
362 | signed char curr_subline; | ||
363 | |||
364 | /* Index of the first subline of this line in the subline array. | ||
365 | Sublines for this line end where sublines for the next line begin. */ | ||
366 | unsigned short first_subline_idx; | ||
367 | |||
368 | /* When the next subline of this line should be displayed | ||
369 | (absolute time value in ticks) */ | ||
370 | long subline_expire_time; | ||
371 | }; | ||
372 | |||
373 | #define VP_DRAW_HIDEABLE 0x1 | ||
374 | #define VP_DRAW_HIDDEN 0x2 | ||
375 | #define VP_DRAW_WASHIDDEN 0x4 | ||
376 | struct wps_viewport { | ||
377 | struct viewport vp; /* The LCD viewport struct */ | ||
378 | struct progressbar *pb; | ||
379 | /* Indexes of the first and last lines belonging to this viewport in the | ||
380 | lines[] array */ | ||
381 | int first_line, last_line; | ||
382 | char hidden_flags; | ||
383 | char label; | ||
384 | }; | ||
385 | |||
386 | #ifdef HAVE_TOUCHSCREEN | ||
387 | struct touchregion { | ||
388 | struct wps_viewport* wvp;/* The viewport this region is in */ | ||
389 | short int x; /* x-pos */ | ||
390 | short int y; /* y-pos */ | ||
391 | short int width; /* width */ | ||
392 | short int height; /* height */ | ||
393 | bool repeat; /* requires the area be held for the action */ | ||
394 | int action; /* action this button will return */ | ||
395 | }; | ||
396 | #define MAX_TOUCHREGIONS 15 | ||
397 | #endif | ||
398 | /* wps_data | ||
399 | this struct holds all necessary data which describes the | ||
400 | viewable content of a wps */ | ||
401 | struct wps_data | ||
402 | { | ||
403 | #ifdef HAVE_LCD_BITMAP | ||
404 | struct gui_img img[MAX_IMAGES]; | ||
405 | unsigned char img_buf[IMG_BUFSIZE]; | ||
406 | unsigned char* img_buf_ptr; | ||
407 | int img_buf_free; | ||
408 | bool wps_sb_tag; | ||
409 | bool show_sb_on_wps; | ||
410 | |||
411 | struct progressbar progressbar[MAX_PROGRESSBARS]; | ||
412 | short progressbar_count; | ||
413 | |||
414 | bool peak_meter_enabled; | ||
415 | |||
416 | #ifdef HAVE_ALBUMART | ||
417 | /* Album art support */ | ||
418 | unsigned char wps_uses_albumart; /* WPS_ALBUMART_NONE, _CHECK, _LOAD */ | ||
419 | short albumart_x; | ||
420 | short albumart_y; | ||
421 | unsigned char albumart_xalign; /* WPS_ALBUMART_ALIGN_LEFT, _CENTER, _RIGHT */ | ||
422 | unsigned char albumart_yalign; /* WPS_ALBUMART_ALIGN_TOP, _CENTER, _BOTTOM */ | ||
423 | short albumart_max_width; | ||
424 | short albumart_max_height; | ||
425 | |||
426 | int albumart_cond_index; | ||
427 | #endif | ||
428 | |||
429 | #else /*HAVE_LCD_CHARCELLS */ | ||
430 | unsigned short wps_progress_pat[8]; | ||
431 | bool full_line_progressbar; | ||
432 | #endif | ||
433 | |||
434 | #ifdef HAVE_TOUCHSCREEN | ||
435 | struct touchregion touchregion[MAX_TOUCHREGIONS]; | ||
436 | short touchregion_count; | ||
437 | #endif | ||
438 | |||
439 | #ifdef HAVE_REMOTE_LCD | ||
440 | bool remote_wps; | ||
441 | #endif | ||
442 | |||
443 | /* Number of lines in the WPS. During WPS parsing, this is | ||
444 | the index of the line being parsed. */ | ||
445 | int num_lines; | ||
446 | |||
447 | /* Number of viewports in the WPS */ | ||
448 | int num_viewports; | ||
449 | struct wps_viewport viewports[WPS_MAX_VIEWPORTS]; | ||
450 | |||
451 | struct wps_line lines[WPS_MAX_LINES]; | ||
452 | |||
453 | /* Total number of sublines in the WPS. During WPS parsing, this is | ||
454 | the index of the subline where the parsed tokens are added to. */ | ||
455 | int num_sublines; | ||
456 | struct wps_subline sublines[WPS_MAX_SUBLINES]; | ||
457 | |||
458 | /* Total number of tokens in the WPS. During WPS parsing, this is | ||
459 | the index of the token being parsed. */ | ||
460 | int num_tokens; | ||
461 | struct wps_token tokens[WPS_MAX_TOKENS]; | ||
462 | |||
463 | char string_buffer[STRING_BUFFER_SIZE]; | ||
464 | char *strings[WPS_MAX_STRINGS]; | ||
465 | int num_strings; | ||
466 | |||
467 | bool wps_loaded; | ||
468 | |||
469 | /* tick the volume button was last pressed */ | ||
470 | unsigned int button_time_volume; | ||
471 | }; | ||
472 | |||
473 | /* initial setup of wps_data */ | ||
474 | void wps_data_init(struct wps_data *wps_data); | ||
475 | |||
476 | /* to setup up the wps-data from a format-buffer (isfile = false) | ||
477 | from a (wps-)file (isfile = true)*/ | ||
478 | bool wps_data_load(struct wps_data *wps_data, | ||
479 | struct screen *display, | ||
480 | const char *buf, | ||
481 | bool isfile); | ||
482 | |||
483 | /* Redraw statusbars if necessary */ | ||
484 | void gwps_draw_statusbars(void); | ||
485 | |||
486 | /* Returns the index of the subline in the subline array | ||
487 | line - 0-based line number | ||
488 | subline - 0-based subline number within the line | ||
489 | */ | ||
490 | int wps_subline_index(struct wps_data *wps_data, int line, int subline); | ||
491 | |||
492 | /* Returns the index of the first subline's token in the token array | ||
493 | line - 0-based line number | ||
494 | subline - 0-based subline number within the line | ||
495 | */ | ||
496 | int wps_first_token_index(struct wps_data *data, int line, int subline); | ||
497 | |||
498 | /* Returns the index of the last subline's token in the token array. | ||
499 | line - 0-based line number | ||
500 | subline - 0-based subline number within the line | ||
501 | */ | ||
502 | int wps_last_token_index(struct wps_data *data, int line, int subline); | ||
503 | |||
504 | /* wps_data end */ | ||
505 | |||
506 | /* wps_state | ||
507 | holds the data which belongs to the current played track, | ||
508 | the track which will be played afterwards, current path to the track | ||
509 | and some status infos */ | ||
510 | struct wps_state | ||
511 | { | ||
512 | bool ff_rewind; | ||
513 | bool paused; | ||
514 | int ff_rewind_count; | ||
515 | bool wps_time_countup; | ||
516 | struct mp3entry* id3; | ||
517 | struct mp3entry* nid3; | ||
518 | bool do_full_update; | ||
519 | }; | ||
520 | |||
521 | |||
522 | /* change the ff/rew-status | ||
523 | if ff_rew = true then we are in skipping mode | ||
524 | else we are in normal mode */ | ||
525 | /* void wps_state_update_ff_rew(bool ff_rew); Currently unused */ | ||
526 | |||
527 | /* change the tag-information of the current played track | ||
528 | and the following track */ | ||
529 | /* void wps_state_update_id3_nid3(struct mp3entry *id3, struct mp3entry *nid3); Currently unused */ | ||
530 | /* wps_state end*/ | ||
531 | |||
532 | /* gui_wps | ||
533 | defines a wps with its data, state, | ||
534 | and the screen on which the wps-content should be drawn */ | ||
535 | struct gui_wps | ||
536 | { | ||
537 | struct screen *display; | ||
538 | struct wps_data *data; | ||
539 | struct wps_state *state; | ||
540 | }; | ||
541 | |||
542 | /* gui_wps end */ | ||
543 | |||
544 | |||
545 | /* currently only on wps_state is needed */ | ||
546 | extern struct wps_state wps_state; | ||
547 | extern struct gui_wps gui_wps[NB_SCREENS]; | ||
548 | |||
549 | /***** wps_tokens.c ******/ | ||
550 | |||
551 | const char *get_token_value(struct gui_wps *gwps, | ||
552 | struct wps_token *token, | ||
553 | char *buf, int buf_size, | ||
554 | int *intval); | ||
555 | |||
556 | #endif | ||
diff --git a/apps/gui/wps_parser.c b/apps/gui/wps_engine/wps_parser.c index fb0b3ac4c6..15acc1401d 100644 --- a/apps/gui/wps_parser.c +++ b/apps/gui/wps_engine/wps_parser.c | |||
@@ -43,7 +43,7 @@ | |||
43 | #include <stdbool.h> | 43 | #include <stdbool.h> |
44 | #include "font.h" | 44 | #include "font.h" |
45 | 45 | ||
46 | #include "gwps.h" | 46 | #include "wps_internals.h" |
47 | #include "settings.h" | 47 | #include "settings.h" |
48 | #include "settings_list.h" | 48 | #include "settings_list.h" |
49 | 49 | ||
diff --git a/apps/gui/wps_engine/wps_tokens.c b/apps/gui/wps_engine/wps_tokens.c new file mode 100644 index 0000000000..3852251916 --- /dev/null +++ b/apps/gui/wps_engine/wps_tokens.c | |||
@@ -0,0 +1,807 @@ | |||
1 | /*************************************************************************** | ||
2 | * __________ __ ___. | ||
3 | * Open \______ \ ____ ____ | | _\_ |__ _______ ___ | ||
4 | * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / | ||
5 | * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < | ||
6 | * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ | ||
7 | * \/ \/ \/ \/ \/ | ||
8 | * $Id$ | ||
9 | * | ||
10 | * Copyright (C) 2002-2007 Björn Stenberg | ||
11 | * Copyright (C) 2007-2008 Nicolas Pennequin | ||
12 | * | ||
13 | * This program is free software; you can redistribute it and/or | ||
14 | * modify it under the terms of the GNU General Public License | ||
15 | * as published by the Free Software Foundation; either version 2 | ||
16 | * of the License, or (at your option) any later version. | ||
17 | * | ||
18 | * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY | ||
19 | * KIND, either express or implied. | ||
20 | * | ||
21 | ****************************************************************************/ | ||
22 | #include "font.h" | ||
23 | #include <stdio.h> | ||
24 | #include <string.h> | ||
25 | #include <stdlib.h> | ||
26 | #include "action.h" | ||
27 | #include "system.h" | ||
28 | #include "settings.h" | ||
29 | #include "settings_list.h" | ||
30 | #include "rbunicode.h" | ||
31 | #include "timefuncs.h" | ||
32 | #include "audio.h" | ||
33 | #include "status.h" | ||
34 | #include "power.h" | ||
35 | #include "powermgmt.h" | ||
36 | #include "sound.h" | ||
37 | #include "debug.h" | ||
38 | #ifdef HAVE_LCD_CHARCELLS | ||
39 | #include "hwcompat.h" | ||
40 | #endif | ||
41 | #include "abrepeat.h" | ||
42 | #include "mp3_playback.h" | ||
43 | #include "lang.h" | ||
44 | #include "misc.h" | ||
45 | #include "led.h" | ||
46 | #ifdef HAVE_LCD_BITMAP | ||
47 | /* Image stuff */ | ||
48 | #include "albumart.h" | ||
49 | #endif | ||
50 | #include "dsp.h" | ||
51 | #include "playlist.h" | ||
52 | #if CONFIG_CODEC == SWCODEC | ||
53 | #include "playback.h" | ||
54 | #endif | ||
55 | #include "viewport.h" | ||
56 | |||
57 | #include "wps_internals.h" | ||
58 | #include "music_screen.h" | ||
59 | |||
60 | static char* get_codectype(const struct mp3entry* id3) | ||
61 | { | ||
62 | if (id3->codectype < AFMT_NUM_CODECS) { | ||
63 | return (char*)audio_formats[id3->codectype].label; | ||
64 | } else { | ||
65 | return NULL; | ||
66 | } | ||
67 | } | ||
68 | |||
69 | /* Extract a part from a path. | ||
70 | * | ||
71 | * buf - buffer extract part to. | ||
72 | * buf_size - size of buffer. | ||
73 | * path - path to extract from. | ||
74 | * level - what to extract. 0 is file name, 1 is parent of file, 2 is | ||
75 | * parent of parent, etc. | ||
76 | * | ||
77 | * Returns buf if the desired level was found, NULL otherwise. | ||
78 | */ | ||
79 | static char* get_dir(char* buf, int buf_size, const char* path, int level) | ||
80 | { | ||
81 | const char* sep; | ||
82 | const char* last_sep; | ||
83 | int len; | ||
84 | |||
85 | sep = path + strlen(path); | ||
86 | last_sep = sep; | ||
87 | |||
88 | while (sep > path) | ||
89 | { | ||
90 | if ('/' == *(--sep)) | ||
91 | { | ||
92 | if (!level) | ||
93 | break; | ||
94 | |||
95 | level--; | ||
96 | last_sep = sep - 1; | ||
97 | } | ||
98 | } | ||
99 | |||
100 | if (level || (last_sep <= sep)) | ||
101 | return NULL; | ||
102 | |||
103 | len = MIN(last_sep - sep, buf_size - 1); | ||
104 | strlcpy(buf, sep + 1, len + 1); | ||
105 | return buf; | ||
106 | } | ||
107 | |||
108 | /* Return the tag found at index i and write its value in buf. | ||
109 | The return value is buf if the tag had a value, or NULL if not. | ||
110 | |||
111 | intval is used with conditionals/enums: when this function is called, | ||
112 | intval should contain the number of options in the conditional/enum. | ||
113 | When this function returns, intval is -1 if the tag is non numeric or, | ||
114 | if the tag is numeric, *intval is the enum case we want to go to (between 1 | ||
115 | and the original value of *intval, inclusive). | ||
116 | When not treating a conditional/enum, intval should be NULL. | ||
117 | */ | ||
118 | const char *get_token_value(struct gui_wps *gwps, | ||
119 | struct wps_token *token, | ||
120 | char *buf, int buf_size, | ||
121 | int *intval) | ||
122 | { | ||
123 | if (!gwps) | ||
124 | return NULL; | ||
125 | |||
126 | struct wps_data *data = gwps->data; | ||
127 | struct wps_state *state = gwps->state; | ||
128 | |||
129 | if (!data || !state) | ||
130 | return NULL; | ||
131 | |||
132 | struct mp3entry *id3; | ||
133 | |||
134 | if (token->next) | ||
135 | id3 = state->nid3; | ||
136 | else | ||
137 | id3 = state->id3; | ||
138 | |||
139 | if (!id3) | ||
140 | return NULL; | ||
141 | |||
142 | #if CONFIG_RTC | ||
143 | struct tm* tm = NULL; | ||
144 | |||
145 | /* if the token is an RTC one, update the time | ||
146 | and do the necessary checks */ | ||
147 | if (token->type >= WPS_TOKENS_RTC_BEGIN | ||
148 | && token->type <= WPS_TOKENS_RTC_END) | ||
149 | { | ||
150 | tm = get_time(); | ||
151 | |||
152 | if (!valid_time(tm)) | ||
153 | return NULL; | ||
154 | } | ||
155 | #endif | ||
156 | |||
157 | int limit = 1; | ||
158 | if (intval) | ||
159 | { | ||
160 | limit = *intval; | ||
161 | *intval = -1; | ||
162 | } | ||
163 | |||
164 | switch (token->type) | ||
165 | { | ||
166 | case WPS_TOKEN_CHARACTER: | ||
167 | return &(token->value.c); | ||
168 | |||
169 | case WPS_TOKEN_STRING: | ||
170 | return data->strings[token->value.i]; | ||
171 | |||
172 | case WPS_TOKEN_TRACK_TIME_ELAPSED: | ||
173 | format_time(buf, buf_size, | ||
174 | id3->elapsed + state->ff_rewind_count); | ||
175 | return buf; | ||
176 | |||
177 | case WPS_TOKEN_TRACK_TIME_REMAINING: | ||
178 | format_time(buf, buf_size, | ||
179 | id3->length - id3->elapsed - | ||
180 | state->ff_rewind_count); | ||
181 | return buf; | ||
182 | |||
183 | case WPS_TOKEN_TRACK_LENGTH: | ||
184 | format_time(buf, buf_size, id3->length); | ||
185 | return buf; | ||
186 | |||
187 | case WPS_TOKEN_PLAYLIST_ENTRIES: | ||
188 | snprintf(buf, buf_size, "%d", playlist_amount()); | ||
189 | return buf; | ||
190 | |||
191 | case WPS_TOKEN_PLAYLIST_NAME: | ||
192 | return playlist_name(NULL, buf, buf_size); | ||
193 | |||
194 | case WPS_TOKEN_PLAYLIST_POSITION: | ||
195 | snprintf(buf, buf_size, "%d", playlist_get_display_index()); | ||
196 | return buf; | ||
197 | |||
198 | case WPS_TOKEN_PLAYLIST_SHUFFLE: | ||
199 | if ( global_settings.playlist_shuffle ) | ||
200 | return "s"; | ||
201 | else | ||
202 | return NULL; | ||
203 | break; | ||
204 | |||
205 | case WPS_TOKEN_VOLUME: | ||
206 | snprintf(buf, buf_size, "%d", global_settings.volume); | ||
207 | if (intval) | ||
208 | { | ||
209 | if (global_settings.volume == sound_min(SOUND_VOLUME)) | ||
210 | { | ||
211 | *intval = 1; | ||
212 | } | ||
213 | else if (global_settings.volume == 0) | ||
214 | { | ||
215 | *intval = limit - 1; | ||
216 | } | ||
217 | else if (global_settings.volume > 0) | ||
218 | { | ||
219 | *intval = limit; | ||
220 | } | ||
221 | else | ||
222 | { | ||
223 | *intval = (limit - 3) * (global_settings.volume | ||
224 | - sound_min(SOUND_VOLUME) - 1) | ||
225 | / (-1 - sound_min(SOUND_VOLUME)) + 2; | ||
226 | } | ||
227 | } | ||
228 | return buf; | ||
229 | |||
230 | case WPS_TOKEN_TRACK_ELAPSED_PERCENT: | ||
231 | if (id3->length <= 0) | ||
232 | return NULL; | ||
233 | |||
234 | if (intval) | ||
235 | { | ||
236 | *intval = limit * (id3->elapsed + state->ff_rewind_count) | ||
237 | / id3->length + 1; | ||
238 | } | ||
239 | snprintf(buf, buf_size, "%d", | ||
240 | 100*(id3->elapsed + state->ff_rewind_count) / id3->length); | ||
241 | return buf; | ||
242 | |||
243 | case WPS_TOKEN_METADATA_ARTIST: | ||
244 | return id3->artist; | ||
245 | |||
246 | case WPS_TOKEN_METADATA_COMPOSER: | ||
247 | return id3->composer; | ||
248 | |||
249 | case WPS_TOKEN_METADATA_ALBUM: | ||
250 | return id3->album; | ||
251 | |||
252 | case WPS_TOKEN_METADATA_ALBUM_ARTIST: | ||
253 | return id3->albumartist; | ||
254 | |||
255 | case WPS_TOKEN_METADATA_GROUPING: | ||
256 | return id3->grouping; | ||
257 | |||
258 | case WPS_TOKEN_METADATA_GENRE: | ||
259 | return id3->genre_string; | ||
260 | |||
261 | case WPS_TOKEN_METADATA_DISC_NUMBER: | ||
262 | if (id3->disc_string) | ||
263 | return id3->disc_string; | ||
264 | if (id3->discnum) { | ||
265 | snprintf(buf, buf_size, "%d", id3->discnum); | ||
266 | return buf; | ||
267 | } | ||
268 | return NULL; | ||
269 | |||
270 | case WPS_TOKEN_METADATA_TRACK_NUMBER: | ||
271 | if (id3->track_string) | ||
272 | return id3->track_string; | ||
273 | |||
274 | if (id3->tracknum) { | ||
275 | snprintf(buf, buf_size, "%d", id3->tracknum); | ||
276 | return buf; | ||
277 | } | ||
278 | return NULL; | ||
279 | |||
280 | case WPS_TOKEN_METADATA_TRACK_TITLE: | ||
281 | return id3->title; | ||
282 | |||
283 | case WPS_TOKEN_METADATA_VERSION: | ||
284 | switch (id3->id3version) | ||
285 | { | ||
286 | case ID3_VER_1_0: | ||
287 | return "1"; | ||
288 | |||
289 | case ID3_VER_1_1: | ||
290 | return "1.1"; | ||
291 | |||
292 | case ID3_VER_2_2: | ||
293 | return "2.2"; | ||
294 | |||
295 | case ID3_VER_2_3: | ||
296 | return "2.3"; | ||
297 | |||
298 | case ID3_VER_2_4: | ||
299 | return "2.4"; | ||
300 | |||
301 | default: | ||
302 | return NULL; | ||
303 | } | ||
304 | |||
305 | case WPS_TOKEN_METADATA_YEAR: | ||
306 | if( id3->year_string ) | ||
307 | return id3->year_string; | ||
308 | |||
309 | if (id3->year) { | ||
310 | snprintf(buf, buf_size, "%d", id3->year); | ||
311 | return buf; | ||
312 | } | ||
313 | return NULL; | ||
314 | |||
315 | case WPS_TOKEN_METADATA_COMMENT: | ||
316 | return id3->comment; | ||
317 | |||
318 | #ifdef HAVE_ALBUMART | ||
319 | case WPS_TOKEN_ALBUMART_DISPLAY: | ||
320 | draw_album_art(gwps, audio_current_aa_hid(), false); | ||
321 | return NULL; | ||
322 | |||
323 | case WPS_TOKEN_ALBUMART_FOUND: | ||
324 | if (audio_current_aa_hid() >= 0) { | ||
325 | return "C"; | ||
326 | } | ||
327 | return NULL; | ||
328 | #endif | ||
329 | |||
330 | case WPS_TOKEN_FILE_BITRATE: | ||
331 | if(id3->bitrate) | ||
332 | snprintf(buf, buf_size, "%d", id3->bitrate); | ||
333 | else | ||
334 | return "?"; | ||
335 | return buf; | ||
336 | |||
337 | case WPS_TOKEN_FILE_CODEC: | ||
338 | if (intval) | ||
339 | { | ||
340 | if(id3->codectype == AFMT_UNKNOWN) | ||
341 | *intval = AFMT_NUM_CODECS; | ||
342 | else | ||
343 | *intval = id3->codectype; | ||
344 | } | ||
345 | return get_codectype(id3); | ||
346 | |||
347 | case WPS_TOKEN_FILE_FREQUENCY: | ||
348 | snprintf(buf, buf_size, "%ld", id3->frequency); | ||
349 | return buf; | ||
350 | |||
351 | case WPS_TOKEN_FILE_FREQUENCY_KHZ: | ||
352 | /* ignore remainders < 100, so 22050 Hz becomes just 22k */ | ||
353 | if ((id3->frequency % 1000) < 100) | ||
354 | snprintf(buf, buf_size, "%ld", id3->frequency / 1000); | ||
355 | else | ||
356 | snprintf(buf, buf_size, "%ld.%d", | ||
357 | id3->frequency / 1000, | ||
358 | (id3->frequency % 1000) / 100); | ||
359 | return buf; | ||
360 | |||
361 | case WPS_TOKEN_FILE_NAME: | ||
362 | if (get_dir(buf, buf_size, id3->path, 0)) { | ||
363 | /* Remove extension */ | ||
364 | char* sep = strrchr(buf, '.'); | ||
365 | if (NULL != sep) { | ||
366 | *sep = 0; | ||
367 | } | ||
368 | return buf; | ||
369 | } | ||
370 | else { | ||
371 | return NULL; | ||
372 | } | ||
373 | |||
374 | case WPS_TOKEN_FILE_NAME_WITH_EXTENSION: | ||
375 | return get_dir(buf, buf_size, id3->path, 0); | ||
376 | |||
377 | case WPS_TOKEN_FILE_PATH: | ||
378 | return id3->path; | ||
379 | |||
380 | case WPS_TOKEN_FILE_SIZE: | ||
381 | snprintf(buf, buf_size, "%ld", id3->filesize / 1024); | ||
382 | return buf; | ||
383 | |||
384 | case WPS_TOKEN_FILE_VBR: | ||
385 | return id3->vbr ? "(avg)" : NULL; | ||
386 | |||
387 | case WPS_TOKEN_FILE_DIRECTORY: | ||
388 | return get_dir(buf, buf_size, id3->path, token->value.i); | ||
389 | |||
390 | case WPS_TOKEN_BATTERY_PERCENT: | ||
391 | { | ||
392 | int l = battery_level(); | ||
393 | |||
394 | if (intval) | ||
395 | { | ||
396 | limit = MAX(limit, 2); | ||
397 | if (l > -1) { | ||
398 | /* First enum is used for "unknown level". */ | ||
399 | *intval = (limit - 1) * l / 100 + 2; | ||
400 | } else { | ||
401 | *intval = 1; | ||
402 | } | ||
403 | } | ||
404 | |||
405 | if (l > -1) { | ||
406 | snprintf(buf, buf_size, "%d", l); | ||
407 | return buf; | ||
408 | } else { | ||
409 | return "?"; | ||
410 | } | ||
411 | } | ||
412 | |||
413 | case WPS_TOKEN_BATTERY_VOLTS: | ||
414 | { | ||
415 | unsigned int v = battery_voltage(); | ||
416 | snprintf(buf, buf_size, "%d.%02d", v / 1000, (v % 1000) / 10); | ||
417 | return buf; | ||
418 | } | ||
419 | |||
420 | case WPS_TOKEN_BATTERY_TIME: | ||
421 | { | ||
422 | int t = battery_time(); | ||
423 | if (t >= 0) | ||
424 | snprintf(buf, buf_size, "%dh %dm", t / 60, t % 60); | ||
425 | else | ||
426 | return "?h ?m"; | ||
427 | return buf; | ||
428 | } | ||
429 | |||
430 | #if CONFIG_CHARGING | ||
431 | case WPS_TOKEN_BATTERY_CHARGER_CONNECTED: | ||
432 | { | ||
433 | if(charger_input_state==CHARGER) | ||
434 | return "p"; | ||
435 | else | ||
436 | return NULL; | ||
437 | } | ||
438 | #endif | ||
439 | #if CONFIG_CHARGING >= CHARGING_MONITOR | ||
440 | case WPS_TOKEN_BATTERY_CHARGING: | ||
441 | { | ||
442 | if (charge_state == CHARGING || charge_state == TOPOFF) { | ||
443 | return "c"; | ||
444 | } else { | ||
445 | return NULL; | ||
446 | } | ||
447 | } | ||
448 | #endif | ||
449 | case WPS_TOKEN_BATTERY_SLEEPTIME: | ||
450 | { | ||
451 | if (get_sleep_timer() == 0) | ||
452 | return NULL; | ||
453 | else | ||
454 | { | ||
455 | format_time(buf, buf_size, get_sleep_timer() * 1000); | ||
456 | return buf; | ||
457 | } | ||
458 | } | ||
459 | |||
460 | case WPS_TOKEN_PLAYBACK_STATUS: | ||
461 | { | ||
462 | int status = audio_status(); | ||
463 | int mode = 1; | ||
464 | if (status == AUDIO_STATUS_PLAY) | ||
465 | mode = 2; | ||
466 | if (is_wps_fading() || | ||
467 | (status & AUDIO_STATUS_PAUSE && !status_get_ffmode())) | ||
468 | mode = 3; | ||
469 | if (status_get_ffmode() == STATUS_FASTFORWARD) | ||
470 | mode = 4; | ||
471 | if (status_get_ffmode() == STATUS_FASTBACKWARD) | ||
472 | mode = 5; | ||
473 | |||
474 | if (intval) { | ||
475 | *intval = mode; | ||
476 | } | ||
477 | |||
478 | snprintf(buf, buf_size, "%d", mode-1); | ||
479 | return buf; | ||
480 | } | ||
481 | |||
482 | case WPS_TOKEN_REPEAT_MODE: | ||
483 | if (intval) | ||
484 | *intval = global_settings.repeat_mode + 1; | ||
485 | snprintf(buf, buf_size, "%d", global_settings.repeat_mode); | ||
486 | return buf; | ||
487 | |||
488 | case WPS_TOKEN_RTC_PRESENT: | ||
489 | #if CONFIG_RTC | ||
490 | return "c"; | ||
491 | #else | ||
492 | return NULL; | ||
493 | #endif | ||
494 | |||
495 | #if CONFIG_RTC | ||
496 | case WPS_TOKEN_RTC_12HOUR_CFG: | ||
497 | if (intval) | ||
498 | *intval = global_settings.timeformat + 1; | ||
499 | snprintf(buf, buf_size, "%d", global_settings.timeformat); | ||
500 | return buf; | ||
501 | |||
502 | case WPS_TOKEN_RTC_DAY_OF_MONTH: | ||
503 | /* d: day of month (01..31) */ | ||
504 | snprintf(buf, buf_size, "%02d", tm->tm_mday); | ||
505 | return buf; | ||
506 | |||
507 | case WPS_TOKEN_RTC_DAY_OF_MONTH_BLANK_PADDED: | ||
508 | /* e: day of month, blank padded ( 1..31) */ | ||
509 | snprintf(buf, buf_size, "%2d", tm->tm_mday); | ||
510 | return buf; | ||
511 | |||
512 | case WPS_TOKEN_RTC_HOUR_24_ZERO_PADDED: | ||
513 | /* H: hour (00..23) */ | ||
514 | snprintf(buf, buf_size, "%02d", tm->tm_hour); | ||
515 | return buf; | ||
516 | |||
517 | case WPS_TOKEN_RTC_HOUR_24: | ||
518 | /* k: hour ( 0..23) */ | ||
519 | snprintf(buf, buf_size, "%2d", tm->tm_hour); | ||
520 | return buf; | ||
521 | |||
522 | case WPS_TOKEN_RTC_HOUR_12_ZERO_PADDED: | ||
523 | /* I: hour (01..12) */ | ||
524 | snprintf(buf, buf_size, "%02d", | ||
525 | (tm->tm_hour % 12 == 0) ? 12 : tm->tm_hour % 12); | ||
526 | return buf; | ||
527 | |||
528 | case WPS_TOKEN_RTC_HOUR_12: | ||
529 | /* l: hour ( 1..12) */ | ||
530 | snprintf(buf, buf_size, "%2d", | ||
531 | (tm->tm_hour % 12 == 0) ? 12 : tm->tm_hour % 12); | ||
532 | return buf; | ||
533 | |||
534 | case WPS_TOKEN_RTC_MONTH: | ||
535 | /* m: month (01..12) */ | ||
536 | if (intval) | ||
537 | *intval = tm->tm_mon + 1; | ||
538 | snprintf(buf, buf_size, "%02d", tm->tm_mon + 1); | ||
539 | return buf; | ||
540 | |||
541 | case WPS_TOKEN_RTC_MINUTE: | ||
542 | /* M: minute (00..59) */ | ||
543 | snprintf(buf, buf_size, "%02d", tm->tm_min); | ||
544 | return buf; | ||
545 | |||
546 | case WPS_TOKEN_RTC_SECOND: | ||
547 | /* S: second (00..59) */ | ||
548 | snprintf(buf, buf_size, "%02d", tm->tm_sec); | ||
549 | return buf; | ||
550 | |||
551 | case WPS_TOKEN_RTC_YEAR_2_DIGITS: | ||
552 | /* y: last two digits of year (00..99) */ | ||
553 | snprintf(buf, buf_size, "%02d", tm->tm_year % 100); | ||
554 | return buf; | ||
555 | |||
556 | case WPS_TOKEN_RTC_YEAR_4_DIGITS: | ||
557 | /* Y: year (1970...) */ | ||
558 | snprintf(buf, buf_size, "%04d", tm->tm_year + 1900); | ||
559 | return buf; | ||
560 | |||
561 | case WPS_TOKEN_RTC_AM_PM_UPPER: | ||
562 | /* p: upper case AM or PM indicator */ | ||
563 | return tm->tm_hour/12 == 0 ? "AM" : "PM"; | ||
564 | |||
565 | case WPS_TOKEN_RTC_AM_PM_LOWER: | ||
566 | /* P: lower case am or pm indicator */ | ||
567 | return tm->tm_hour/12 == 0 ? "am" : "pm"; | ||
568 | |||
569 | case WPS_TOKEN_RTC_WEEKDAY_NAME: | ||
570 | /* a: abbreviated weekday name (Sun..Sat) */ | ||
571 | return str(LANG_WEEKDAY_SUNDAY + tm->tm_wday); | ||
572 | |||
573 | case WPS_TOKEN_RTC_MONTH_NAME: | ||
574 | /* b: abbreviated month name (Jan..Dec) */ | ||
575 | return str(LANG_MONTH_JANUARY + tm->tm_mon); | ||
576 | |||
577 | case WPS_TOKEN_RTC_DAY_OF_WEEK_START_MON: | ||
578 | /* u: day of week (1..7); 1 is Monday */ | ||
579 | if (intval) | ||
580 | *intval = (tm->tm_wday == 0) ? 7 : tm->tm_wday; | ||
581 | snprintf(buf, buf_size, "%1d", tm->tm_wday + 1); | ||
582 | return buf; | ||
583 | |||
584 | case WPS_TOKEN_RTC_DAY_OF_WEEK_START_SUN: | ||
585 | /* w: day of week (0..6); 0 is Sunday */ | ||
586 | if (intval) | ||
587 | *intval = tm->tm_wday + 1; | ||
588 | snprintf(buf, buf_size, "%1d", tm->tm_wday); | ||
589 | return buf; | ||
590 | #else | ||
591 | case WPS_TOKEN_RTC_DAY_OF_MONTH: | ||
592 | case WPS_TOKEN_RTC_DAY_OF_MONTH_BLANK_PADDED: | ||
593 | case WPS_TOKEN_RTC_HOUR_24_ZERO_PADDED: | ||
594 | case WPS_TOKEN_RTC_HOUR_24: | ||
595 | case WPS_TOKEN_RTC_HOUR_12_ZERO_PADDED: | ||
596 | case WPS_TOKEN_RTC_HOUR_12: | ||
597 | case WPS_TOKEN_RTC_MONTH: | ||
598 | case WPS_TOKEN_RTC_MINUTE: | ||
599 | case WPS_TOKEN_RTC_SECOND: | ||
600 | case WPS_TOKEN_RTC_AM_PM_UPPER: | ||
601 | case WPS_TOKEN_RTC_AM_PM_LOWER: | ||
602 | case WPS_TOKEN_RTC_YEAR_2_DIGITS: | ||
603 | return "--"; | ||
604 | case WPS_TOKEN_RTC_YEAR_4_DIGITS: | ||
605 | return "----"; | ||
606 | case WPS_TOKEN_RTC_WEEKDAY_NAME: | ||
607 | case WPS_TOKEN_RTC_MONTH_NAME: | ||
608 | return "---"; | ||
609 | case WPS_TOKEN_RTC_DAY_OF_WEEK_START_MON: | ||
610 | case WPS_TOKEN_RTC_DAY_OF_WEEK_START_SUN: | ||
611 | return "-"; | ||
612 | #endif | ||
613 | |||
614 | #ifdef HAVE_LCD_CHARCELLS | ||
615 | case WPS_TOKEN_PROGRESSBAR: | ||
616 | { | ||
617 | char *end = utf8encode(data->wps_progress_pat[0], buf); | ||
618 | *end = '\0'; | ||
619 | return buf; | ||
620 | } | ||
621 | |||
622 | case WPS_TOKEN_PLAYER_PROGRESSBAR: | ||
623 | if(is_new_player()) | ||
624 | { | ||
625 | /* we need 11 characters (full line) for | ||
626 | progress-bar */ | ||
627 | strlcpy(buf, " ", buf_size); | ||
628 | } | ||
629 | else | ||
630 | { | ||
631 | /* Tell the user if we have an OldPlayer */ | ||
632 | strlcpy(buf, " <Old LCD> ", buf_size); | ||
633 | } | ||
634 | return buf; | ||
635 | #endif | ||
636 | |||
637 | #ifdef HAVE_TAGCACHE | ||
638 | case WPS_TOKEN_DATABASE_PLAYCOUNT: | ||
639 | if (intval) { | ||
640 | *intval = id3->playcount + 1; | ||
641 | } | ||
642 | snprintf(buf, buf_size, "%ld", id3->playcount); | ||
643 | return buf; | ||
644 | |||
645 | case WPS_TOKEN_DATABASE_RATING: | ||
646 | if (intval) { | ||
647 | *intval = id3->rating + 1; | ||
648 | } | ||
649 | snprintf(buf, buf_size, "%d", id3->rating); | ||
650 | return buf; | ||
651 | |||
652 | case WPS_TOKEN_DATABASE_AUTOSCORE: | ||
653 | if (intval) | ||
654 | *intval = id3->score + 1; | ||
655 | |||
656 | snprintf(buf, buf_size, "%d", id3->score); | ||
657 | return buf; | ||
658 | #endif | ||
659 | |||
660 | #if (CONFIG_CODEC == SWCODEC) | ||
661 | case WPS_TOKEN_CROSSFADE: | ||
662 | if (intval) | ||
663 | *intval = global_settings.crossfade + 1; | ||
664 | snprintf(buf, buf_size, "%d", global_settings.crossfade); | ||
665 | return buf; | ||
666 | |||
667 | case WPS_TOKEN_REPLAYGAIN: | ||
668 | { | ||
669 | int val; | ||
670 | |||
671 | if (global_settings.replaygain_type == REPLAYGAIN_OFF) | ||
672 | val = 1; /* off */ | ||
673 | else | ||
674 | { | ||
675 | int type = | ||
676 | get_replaygain_mode(id3->track_gain_string != NULL, | ||
677 | id3->album_gain_string != NULL); | ||
678 | if (type < 0) | ||
679 | val = 6; /* no tag */ | ||
680 | else | ||
681 | val = type + 2; | ||
682 | |||
683 | if (global_settings.replaygain_type == REPLAYGAIN_SHUFFLE) | ||
684 | val += 2; | ||
685 | } | ||
686 | |||
687 | if (intval) | ||
688 | *intval = val; | ||
689 | |||
690 | switch (val) | ||
691 | { | ||
692 | case 1: | ||
693 | case 6: | ||
694 | return "+0.00 dB"; | ||
695 | break; | ||
696 | case 2: | ||
697 | case 4: | ||
698 | strlcpy(buf, id3->track_gain_string, buf_size); | ||
699 | break; | ||
700 | case 3: | ||
701 | case 5: | ||
702 | strlcpy(buf, id3->album_gain_string, buf_size); | ||
703 | break; | ||
704 | } | ||
705 | return buf; | ||
706 | } | ||
707 | #endif /* (CONFIG_CODEC == SWCODEC) */ | ||
708 | |||
709 | #if (CONFIG_CODEC != MAS3507D) | ||
710 | case WPS_TOKEN_SOUND_PITCH: | ||
711 | { | ||
712 | int val = sound_get_pitch(); | ||
713 | snprintf(buf, buf_size, "%d.%d", | ||
714 | val / 10, val % 10); | ||
715 | return buf; | ||
716 | } | ||
717 | #endif | ||
718 | |||
719 | case WPS_TOKEN_MAIN_HOLD: | ||
720 | #ifdef HAS_BUTTON_HOLD | ||
721 | if (button_hold()) | ||
722 | #else | ||
723 | if (is_keys_locked()) | ||
724 | #endif /*hold switch or softlock*/ | ||
725 | return "h"; | ||
726 | else | ||
727 | return NULL; | ||
728 | |||
729 | #ifdef HAS_REMOTE_BUTTON_HOLD | ||
730 | case WPS_TOKEN_REMOTE_HOLD: | ||
731 | if (remote_button_hold()) | ||
732 | return "r"; | ||
733 | else | ||
734 | return NULL; | ||
735 | #endif | ||
736 | |||
737 | #if (CONFIG_LED == LED_VIRTUAL) || defined(HAVE_REMOTE_LCD) | ||
738 | case WPS_TOKEN_VLED_HDD: | ||
739 | if(led_read(HZ/2)) | ||
740 | return "h"; | ||
741 | else | ||
742 | return NULL; | ||
743 | #endif | ||
744 | case WPS_TOKEN_BUTTON_VOLUME: | ||
745 | if (data->button_time_volume && | ||
746 | TIME_BEFORE(current_tick, data->button_time_volume + | ||
747 | token->value.i * TIMEOUT_UNIT)) | ||
748 | return "v"; | ||
749 | return NULL; | ||
750 | case WPS_TOKEN_LASTTOUCH: | ||
751 | #ifdef HAVE_TOUCHSCREEN | ||
752 | if (TIME_BEFORE(current_tick, token->value.i * TIMEOUT_UNIT + | ||
753 | touchscreen_last_touch())) | ||
754 | return "t"; | ||
755 | #endif | ||
756 | return NULL; | ||
757 | |||
758 | case WPS_TOKEN_SETTING: | ||
759 | { | ||
760 | if (intval) | ||
761 | { | ||
762 | /* Handle contionals */ | ||
763 | const struct settings_list *s = settings+token->value.i; | ||
764 | switch (s->flags&F_T_MASK) | ||
765 | { | ||
766 | case F_T_INT: | ||
767 | case F_T_UINT: | ||
768 | if (s->flags&F_RGB) | ||
769 | /* %?St|name|<#000000|#000001|...|#FFFFFF> */ | ||
770 | /* shouldn't overflow since colors are stored | ||
771 | * on 16 bits ... | ||
772 | * but this is pretty useless anyway */ | ||
773 | *intval = *(int*)s->setting + 1; | ||
774 | else if (s->cfg_vals == NULL) | ||
775 | /* %?St|name|<1st choice|2nd choice|...> */ | ||
776 | *intval = (*(int*)s->setting-s->int_setting->min) | ||
777 | /s->int_setting->step + 1; | ||
778 | else | ||
779 | /* %?St|name|<1st choice|2nd choice|...> */ | ||
780 | /* Not sure about this one. cfg_name/vals are | ||
781 | * indexed from 0 right? */ | ||
782 | *intval = *(int*)s->setting + 1; | ||
783 | break; | ||
784 | case F_T_BOOL: | ||
785 | /* %?St|name|<if true|if false> */ | ||
786 | *intval = *(bool*)s->setting?1:2; | ||
787 | break; | ||
788 | case F_T_CHARPTR: | ||
789 | /* %?St|name|<if non empty string|if empty> | ||
790 | * The string's emptyness discards the setting's | ||
791 | * prefix and suffix */ | ||
792 | *intval = ((char*)s->setting)[0]?1:2; | ||
793 | break; | ||
794 | default: | ||
795 | /* This shouldn't happen ... but you never know */ | ||
796 | *intval = -1; | ||
797 | break; | ||
798 | } | ||
799 | } | ||
800 | cfg_to_string(token->value.i,buf,buf_size); | ||
801 | return buf; | ||
802 | } | ||
803 | |||
804 | default: | ||
805 | return NULL; | ||
806 | } | ||
807 | } | ||
diff --git a/apps/iap.c b/apps/iap.c index 592bbdbbf8..f7a808d8b2 100644 --- a/apps/iap.c +++ b/apps/iap.c | |||
@@ -36,7 +36,7 @@ | |||
36 | #include "audio.h" | 36 | #include "audio.h" |
37 | #include "settings.h" | 37 | #include "settings.h" |
38 | #include "metadata.h" | 38 | #include "metadata.h" |
39 | #include "gwps.h" | 39 | #include "wps_engine/wps_engine.h" |
40 | 40 | ||
41 | #include "action.h" | 41 | #include "action.h" |
42 | 42 | ||
diff --git a/apps/main.c b/apps/main.c index 929c946334..2cf9ce7175 100644 --- a/apps/main.c +++ b/apps/main.c | |||
@@ -52,7 +52,7 @@ | |||
52 | #include "sprintf.h" | 52 | #include "sprintf.h" |
53 | #include "font.h" | 53 | #include "font.h" |
54 | #include "language.h" | 54 | #include "language.h" |
55 | #include "gwps.h" | 55 | #include "music_screen.h" |
56 | #include "playlist.h" | 56 | #include "playlist.h" |
57 | #include "buffer.h" | 57 | #include "buffer.h" |
58 | #include "rolo.h" | 58 | #include "rolo.h" |
diff --git a/apps/menu.c b/apps/menu.c index f6d0ef967d..6690972e50 100644 --- a/apps/menu.c +++ b/apps/menu.c | |||
@@ -48,7 +48,6 @@ | |||
48 | #include "string.h" | 48 | #include "string.h" |
49 | #include "root_menu.h" | 49 | #include "root_menu.h" |
50 | #include "bookmark.h" | 50 | #include "bookmark.h" |
51 | #include "gwps-common.h" /* for fade() */ | ||
52 | #include "audio.h" | 51 | #include "audio.h" |
53 | #include "viewport.h" | 52 | #include "viewport.h" |
54 | #include "quickscreen.h" | 53 | #include "quickscreen.h" |
diff --git a/apps/menus/main_menu.c b/apps/menus/main_menu.c index 76ed01d9ba..4009566c44 100644 --- a/apps/menus/main_menu.c +++ b/apps/menus/main_menu.c | |||
@@ -50,7 +50,7 @@ | |||
50 | #endif | 50 | #endif |
51 | #include "version.h" | 51 | #include "version.h" |
52 | #include "time.h" | 52 | #include "time.h" |
53 | #include "gwps.h" | 53 | #include "gui/wps_engine/wps_engine.h" |
54 | 54 | ||
55 | static const struct browse_folder_info config = {ROCKBOX_DIR, SHOW_CFG}; | 55 | static const struct browse_folder_info config = {ROCKBOX_DIR, SHOW_CFG}; |
56 | 56 | ||
diff --git a/apps/misc.c b/apps/misc.c index e6f8ca840b..2e7051cbd3 100644 --- a/apps/misc.c +++ b/apps/misc.c | |||
@@ -75,9 +75,8 @@ | |||
75 | #include "bmp.h" | 75 | #include "bmp.h" |
76 | #include "icons.h" | 76 | #include "icons.h" |
77 | #endif /* End HAVE_LCD_BITMAP */ | 77 | #endif /* End HAVE_LCD_BITMAP */ |
78 | #include "gui/gwps-common.h" | ||
79 | #include "bookmark.h" | 78 | #include "bookmark.h" |
80 | 79 | #include "music_screen.h" | |
81 | #include "playback.h" | 80 | #include "playback.h" |
82 | 81 | ||
83 | #ifdef BOOTFILE | 82 | #ifdef BOOTFILE |
diff --git a/apps/recorder/albumart.c b/apps/recorder/albumart.c index a378c332b3..f1315da71f 100644 --- a/apps/recorder/albumart.c +++ b/apps/recorder/albumart.c | |||
@@ -24,7 +24,6 @@ | |||
24 | #include "system.h" | 24 | #include "system.h" |
25 | #include "albumart.h" | 25 | #include "albumart.h" |
26 | #include "metadata.h" | 26 | #include "metadata.h" |
27 | #include "gwps.h" | ||
28 | #include "buffering.h" | 27 | #include "buffering.h" |
29 | #include "dircache.h" | 28 | #include "dircache.h" |
30 | #include "misc.h" | 29 | #include "misc.h" |
diff --git a/apps/recorder/albumart.h b/apps/recorder/albumart.h index edf464fb7a..82e0b79aec 100644 --- a/apps/recorder/albumart.h +++ b/apps/recorder/albumart.h | |||
@@ -26,7 +26,7 @@ | |||
26 | 26 | ||
27 | #include <stdbool.h> | 27 | #include <stdbool.h> |
28 | #include "metadata.h" | 28 | #include "metadata.h" |
29 | #include "gwps.h" | 29 | #include "wps_engine/wps_engine.h" |
30 | 30 | ||
31 | /* Look for albumart bitmap in the same dir as the track and in its parent dir. | 31 | /* Look for albumart bitmap in the same dir as the track and in its parent dir. |
32 | * Stores the found filename in the buf parameter. | 32 | * Stores the found filename in the buf parameter. |
diff --git a/apps/root_menu.c b/apps/root_menu.c index 15bc524cce..37fda98cb3 100644 --- a/apps/root_menu.c +++ b/apps/root_menu.c | |||
@@ -53,7 +53,7 @@ | |||
53 | #ifdef HAVE_RECORDING | 53 | #ifdef HAVE_RECORDING |
54 | #include "recording.h" | 54 | #include "recording.h" |
55 | #endif | 55 | #endif |
56 | #include "gwps-common.h" | 56 | #include "music_screen.h" |
57 | #include "bookmark.h" | 57 | #include "bookmark.h" |
58 | #include "playlist.h" | 58 | #include "playlist.h" |
59 | #include "tagtree.h" | 59 | #include "tagtree.h" |
diff --git a/apps/settings.c b/apps/settings.c index 29360f14d3..800cc59a56 100644 --- a/apps/settings.c +++ b/apps/settings.c | |||
@@ -52,7 +52,6 @@ | |||
52 | #endif | 52 | #endif |
53 | #include "lang.h" | 53 | #include "lang.h" |
54 | #include "language.h" | 54 | #include "language.h" |
55 | #include "gwps.h" | ||
56 | #include "powermgmt.h" | 55 | #include "powermgmt.h" |
57 | #include "sprintf.h" | 56 | #include "sprintf.h" |
58 | #include "keyboard.h" | 57 | #include "keyboard.h" |
@@ -70,6 +69,7 @@ | |||
70 | #if CONFIG_TUNER | 69 | #if CONFIG_TUNER |
71 | #include "radio.h" | 70 | #include "radio.h" |
72 | #endif | 71 | #endif |
72 | #include "wps_engine/wps_engine.h" | ||
73 | 73 | ||
74 | #if CONFIG_CODEC == MAS3507D | 74 | #if CONFIG_CODEC == MAS3507D |
75 | void dac_line_in(bool enable); | 75 | void dac_line_in(bool enable); |
diff --git a/apps/tree.c b/apps/tree.c index 576453a3ad..2c6c85f2a8 100644 --- a/apps/tree.c +++ b/apps/tree.c | |||
@@ -36,7 +36,7 @@ | |||
36 | #include "audio.h" | 36 | #include "audio.h" |
37 | #include "playlist.h" | 37 | #include "playlist.h" |
38 | #include "menu.h" | 38 | #include "menu.h" |
39 | #include "gwps.h" | 39 | #include "wps_engine/wps_engine.h" |
40 | #include "settings.h" | 40 | #include "settings.h" |
41 | #include "debug.h" | 41 | #include "debug.h" |
42 | #include "storage.h" | 42 | #include "storage.h" |
@@ -64,7 +64,6 @@ | |||
64 | #include "tagcache.h" | 64 | #include "tagcache.h" |
65 | #endif | 65 | #endif |
66 | #include "yesno.h" | 66 | #include "yesno.h" |
67 | #include "gwps-common.h" | ||
68 | #include "eeprom_settings.h" | 67 | #include "eeprom_settings.h" |
69 | #include "playlist_catalog.h" | 68 | #include "playlist_catalog.h" |
70 | 69 | ||