Nyaaori/rockbox
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

[2/4] get rid of HAVE_LCD_CHARCELLS

Browse source 
HAVE_LCD_BITMAP is now redundant.

lcd_bitmap is always-on in features.txt so manual and lang strings
don't have to change

Change-Id: I08eeb20de48099ffc2dc23782711af368c2ec794
This commit is contained in:
Solomon Peachy 2020-07-19 19:38:45 -04:00
parent 092c340a20
commit 0c4f89370d
77 changed files with 117 additions and 6004 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
apps/SOURCES
View file

@ -83,8 +83,6 @@ gui/line.c
#ifdef HAVE_LCD_BITMAP
gui/bitmap/list.c
gui/bitmap/list-skinned.c
#else
gui/charcell/list.c
#endif
gui/option_select.c
#ifdef HAVE_PITCHCONTROL
@ -127,10 +125,6 @@ gui/skin_engine/skin_touchsupport.c
gui/backdrop.c
#endif
#ifdef HAVE_LCD_CHARCELLS
player/icons.c
player/keyboard.c
#endif
#ifdef HAVE_LCD_BITMAP
recorder/bmp.c
recorder/icons.c

4
apps/features.txt
View file

@ -231,10 +231,6 @@ disk_storage
remote_button_hold
#endif
#if defined(HAVE_LCD_CHARCELLS)
lcd_charcell
#endif
#if defined(HAVE_LCD_FLIP)
lcd_flip
#endif

7
apps/filetypes.c
View file

@ -605,13 +605,6 @@ int filetype_list_viewers(const char* current_file)
{
struct simplelist_info info;
struct cb_data data = { current_file };
#ifndef HAVE_LCD_BITMAP
if (viewer_count == 0)
{
splash(HZ*2, ID2P(LANG_NO_VIEWERS));
return PLUGIN_OK;
}
#endif
simplelist_info_init(&info, str(LANG_ONPLAY_OPEN_WITH), viewer_count, &data);
info.action_callback = openwith_action_callback;
info.get_name = openwith_get_name;

112
apps/gui/charcell/list.c
View file

@ -1,112 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2007 by Jonathan Gordon
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
/* This file contains the code to draw the list widget on BITMAP LCDs. */
#include "config.h"
#include "lcd.h"
#include "font.h"
#include "button.h"
#include "string.h"
#include "settings.h"
#include "kernel.h"
#include "system.h"
#include "file.h"
#include "list.h"
#include "screen_access.h"
#include "scrollbar.h"
#include "lang.h"
#include "sound.h"
#include "misc.h"
void gui_synclist_scroll_stop(struct gui_synclist *lists)
{
(void)lists;
FOR_NB_SCREENS(i)
{
screens[i].scroll_stop();
}
}
void list_draw(struct screen *display, struct gui_synclist *gui_list)
{
bool draw_icons = (gui_list->callback_get_item_icon != NULL);
bool selected;
int i;
int start, end;
display->set_viewport(NULL);
display->clear_display();
start = 0;
end = display->getnblines();
struct line_desc desc = {
.height = -1,
.text_color = 1,
.line_color = 1,
.line_end_color = 1,
.style = STYLE_DEFAULT
};
for (i = start; i < end; i++)
{
unsigned const char *s;
char entry_buffer[MAX_PATH];
unsigned char *entry_name;
int current_item = gui_list->start_item[display->screen_type] + i;
/* When there are less items to display than the
* current available space on the screen, we stop*/
if(current_item >= gui_list->nb_items)
break;
s = gui_list->callback_get_item_name(current_item,
gui_list->data,
entry_buffer,
sizeof(entry_buffer));
entry_name = P2STR(s);
if (gui_list->show_selection_marker &&
current_item >= gui_list->selected_item &&
current_item < gui_list->selected_item + gui_list->selected_size)
selected = true; /* The selected item must be displayed scrolling */
else
selected = false;
desc.nlines = gui_list->selected_size,
desc.line = gui_list->selected_size > 1 ? i : 0,
desc.scroll = selected ? true : gui_list->scroll_all;
if (draw_icons)
put_line(display, 0, i, &desc, "$i$i$t",
selected ? Icon_Cursor : Icon_NOICON,
gui_list->callback_get_item_icon(current_item, gui_list->data),
entry_name);
else
put_line(display, 0, i, &desc, "$i$t",
selected ? Icon_Cursor : Icon_NOICON,
entry_name);
}
display->update_viewport();
display->update();
}

15
apps/gui/icon.h
View file

@ -89,10 +89,6 @@ extern void screen_put_cursorxy(struct screen * screen, int x, int y, bool on);
*/
extern void screen_put_iconxy(struct screen * screen,
int x, int y, enum themable_icons icon);
#ifdef HAVE_LCD_CHARCELLS
# define screen_put_icon(s, x, y, i) screen_put_iconxy(s, x, y, i)
# define screen_put_icon_with_offset(s, x, y, w, h, i) screen_put_icon(s, x, y, i)
#else
/* For both of these, the icon will be placed in the center of the rectangle */
/* as above, but x,y are letter position, NOT PIXEL */
extern void screen_put_icon(struct screen * screen,
@ -101,23 +97,14 @@ extern void screen_put_icon(struct screen * screen,
extern void screen_put_icon_with_offset(struct screen * display,
int x, int y, int off_x, int off_y,
enum themable_icons icon);
#endif
void icons_init(void);
#ifdef HAVE_LCD_CHARCELLS
# define CURSOR_CHAR 0xe10c
# define get_icon_width(a) 1
# define get_icon_height(a) 1 /* needs to be verified */
#else
int get_icon_width(enum screen_type screen_type);
int get_icon_height(enum screen_type screen_type);
int get_icon_format(enum screen_type screen_type);
#endif
#if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1) \
&& !defined(HAVE_LCD_CHARCELLS)
#if (LCD_DEPTH > 1) || defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1)
int get_icon_format(enum screen_type screen_type);
#else
# define get_icon_format(a) FORMAT_MONO

4
apps/gui/line.c
View file

@ -41,11 +41,7 @@
#endif
#ifdef HAVE_LCD_CHARCELLS
#define style_line(d, x, y, l)
#else
static void style_line(struct screen *display, int x, int y, struct line_desc *line);
#endif
static void put_text(struct screen *display, int x, int y, struct line_desc *line,
const char *text, bool prevent_scroll, int text_skip_pixels);

5
apps/gui/list.c
View file

@ -279,13 +279,8 @@ static void gui_list_put_selection_on_screen(struct gui_synclist * gui_list,
int bottom = MAX(0, gui_list->nb_items - nb_lines);
int new_start_item = gui_list->start_item[screen];
int difference = gui_list->selected_item - gui_list->start_item[screen];
#ifdef HAVE_LCD_CHARCELLS
const int scroll_limit_up = 0;
const int scroll_limit_down = 1;
#else
const int scroll_limit_up = (nb_lines < gui_list->selected_size+2 ? 0:1);
const int scroll_limit_down = (scroll_limit_up+gui_list->selected_size);
#endif
if (gui_list->show_selection_marker == false)
{

1
apps/gui/skin_engine/skin_display.c
View file

@ -662,7 +662,6 @@ bool skin_has_sbs(enum screen_type screen, struct wps_data *data)
*/
int skin_wait_for_action(enum skinnable_screens skin, int context, int timeout)
{
(void)skin; /* silence charcell warning */
int button = ACTION_NONE;
#ifdef HAVE_LCD_BITMAP
/* when the peak meter is enabled we want to have a

8
apps/gui/skin_engine/skin_parser.c
View file

@ -1815,14 +1815,6 @@ static void skin_data_reset(struct wps_data *wps_data)
wps_data->peak_meter_enabled = false;
wps_data->wps_sb_tag = false;
wps_data->show_sb_on_wps = false;
#else /* HAVE_LCD_CHARCELLS */
/* progress bars */
int i;
for (i = 0; i < 8; i++)
{
wps_data->wps_progress_pat[i] = 0;
}
wps_data->full_line_progressbar = false;
#endif
wps_data->wps_loaded = false;
}

12
apps/gui/skin_engine/skin_render.c
View file

@ -97,10 +97,6 @@ get_child(OFFSETTYPE(struct skin_element**) children, int child)
static bool do_non_text_tags(struct gui_wps *gwps, struct skin_draw_info *info,
struct skin_element *element, struct skin_viewport* skin_vp)
{
#ifndef HAVE_LCD_BITMAP
(void)skin_vp; /* silence warnings */
(void)info;
#endif
struct wps_token *token = (struct wps_token *)SKINOFFSETTOPTR(skin_buffer, element->data);
#ifdef HAVE_LCD_BITMAP
@ -832,14 +828,6 @@ void skin_render(struct gui_wps *gwps, unsigned refresh_mode)
int old_refresh_mode = refresh_mode;
skin_buffer = get_skin_buffer(gwps->data);
#ifdef HAVE_LCD_CHARCELLS
int i;
for (i = 0; i < 8; i++)
{
if (data->wps_progress_pat[i] == 0)
data->wps_progress_pat[i] = display->get_locked_pattern();
}
#endif
viewport = SKINOFFSETTOPTR(skin_buffer, data->tree);
skin_viewport = SKINOFFSETTOPTR(skin_buffer, viewport->data);

173
apps/gui/skin_engine/skin_tokens.c
View file

@ -37,9 +37,6 @@
#include "cuesheet.h"
#include "replaygain.h"
#include "core_alloc.h"
#ifdef HAVE_LCD_CHARCELLS
#include "hwcompat.h"
#endif
#include "abrepeat.h"
#include "lang.h"
#include "misc.h"
@ -577,148 +574,6 @@ static struct mp3entry* get_mp3entry_from_offset(int offset, char **filename)
return pid3;
}
#ifdef HAVE_LCD_CHARCELLS
static void format_player_progress(struct gui_wps *gwps)
{
struct wps_state *state = skin_get_global_state();
struct screen *display = gwps->display;
unsigned char progress_pattern[7];
int pos = 0;
int i;
int elapsed, length;
if (LIKELY(state->id3))
{
elapsed = state->id3->elapsed;
length = state->id3->length;
}
else
{
elapsed = 0;
length = 0;
}
if (length)
pos = 36 * (elapsed + state->ff_rewind_count) / length;
for (i = 0; i < 7; i++, pos -= 5)
{
if (pos <= 0)
progress_pattern[i] = 0x1fu;
else if (pos >= 5)
progress_pattern[i] = 0x00u;
else
progress_pattern[i] = 0x1fu >> pos;
}
display->define_pattern(gwps->data->wps_progress_pat[0], progress_pattern);
}
static void format_player_fullbar(struct gui_wps *gwps, char* buf, int buf_size)
{
static const unsigned char numbers[10][4] = {
{0x0e, 0x0a, 0x0a, 0x0e}, /* 0 */
{0x04, 0x0c, 0x04, 0x04}, /* 1 */
{0x0e, 0x02, 0x04, 0x0e}, /* 2 */
{0x0e, 0x02, 0x06, 0x0e}, /* 3 */
{0x08, 0x0c, 0x0e, 0x04}, /* 4 */
{0x0e, 0x0c, 0x02, 0x0c}, /* 5 */
{0x0e, 0x08, 0x0e, 0x0e}, /* 6 */
{0x0e, 0x02, 0x04, 0x08}, /* 7 */
{0x0e, 0x0e, 0x0a, 0x0e}, /* 8 */
{0x0e, 0x0e, 0x02, 0x0e} /* 9 */
};
struct wps_state *state = skin_get_global_state();
struct screen *display = gwps->display;
struct wps_data *data = gwps->data;
unsigned char progress_pattern[7];
char timestr[10];
int time;
int time_idx = 0;
int pos = 0;
int pat_idx = 1;
int digit, i, j;
bool softchar;
int elapsed, length;
if (LIKELY(state->id3))
{
elapsed = state->id3->elapsed;
length = state->id3->length;
}
else
{
elapsed = 0;
length = 0;
}
if (buf_size < 34) /* worst case: 11x UTF-8 char + \0 */
return;
time = elapsed + state->ff_rewind_count;
if (length)
pos = 55 * time / length;
memset(timestr, 0, sizeof(timestr));
format_time(timestr, sizeof(timestr)-2, time);
timestr[strlen(timestr)] = ':'; /* always safe */
for (i = 0; i < 11; i++, pos -= 5)
{
softchar = false;
memset(progress_pattern, 0, sizeof(progress_pattern));
if ((digit = timestr[time_idx]))
{
softchar = true;
digit -= '0';
if (timestr[time_idx + 1] == ':') /* ones, left aligned */
{
memcpy(progress_pattern, numbers[digit], 4);
time_idx += 2;
}
else /* tens, shifted right */
{
for (j = 0; j < 4; j++)
progress_pattern[j] = numbers[digit][j] >> 1;
if (time_idx > 0) /* not the first group, add colon in front */
{
progress_pattern[1] |= 0x10u;
progress_pattern[3] |= 0x10u;
}
time_idx++;
}
if (pos >= 5)
progress_pattern[5] = progress_pattern[6] = 0x1fu;
}
if (pos > 0 && pos < 5)
{
softchar = true;
progress_pattern[5] = progress_pattern[6] = (~0x1fu >> pos) & 0x1fu;
}
if (softchar && pat_idx < 8)
{
display->define_pattern(data->wps_progress_pat[pat_idx],
progress_pattern);
buf = utf8encode(data->wps_progress_pat[pat_idx], buf);
pat_idx++;
}
else if (pos <= 0)
buf = utf8encode(' ', buf);
else
buf = utf8encode(0xe115, buf); /* 2/7 _ */
}
*buf = '\0';
}
#endif /* HAVE_LCD_CHARCELLS */
/* Don't inline this; it was broken out of get_token_value to reduce stack
* usage.
*/
@ -1351,34 +1206,6 @@ const char *get_token_value(struct gui_wps *gwps,
return "-";
#endif
#ifdef HAVE_LCD_CHARCELLS
case SKIN_TOKEN_PROGRESSBAR:
{
char *end;
format_player_progress(gwps);
end = utf8encode(data->wps_progress_pat[0], buf);
*end = '\0';
return buf;
}
case SKIN_TOKEN_PLAYER_PROGRESSBAR:
if(is_new_player())
{
/* we need 11 characters (full line) for
progress-bar */
strlcpy(buf, " ", buf_size);
format_player_fullbar(gwps,buf,buf_size);
DEBUGF("bar='%s'\n",buf);
}
else
{
/* Tell the user if we have an OldPlayer */
strlcpy(buf, " <Old LCD> ", buf_size);
}
return buf;
#endif
#ifdef HAVE_LCD_BITMAP
/* peakmeter */
case SKIN_TOKEN_PEAKMETER_LEFT:

3
apps/gui/skin_engine/wps_internals.h
View file

@ -374,9 +374,6 @@ struct wps_data
bool peak_meter_enabled;
bool wps_sb_tag;
bool show_sb_on_wps;
#else /*HAVE_LCD_CHARCELLS */
unsigned short wps_progress_pat[8];
bool full_line_progressbar;
#endif
bool wps_loaded;
};

17
apps/gui/splash.c
View file

@ -38,12 +38,6 @@
#define RECT_SPACING 2
#define SPLASH_MEMORY_INTERVAL (HZ)
#else /* HAVE_LCD_CHARCELLS */
#define MAXLINES 2
#define MAXBUFFER 64
#define RECT_SPACING 0
#endif
@ -68,12 +62,6 @@ static void splash_internal(struct screen * screen, const char *fmt, va_list ap)
screen->set_viewport(&vp);
screen->getstringsize(" ", &space_w, &h);
#else /* HAVE_LCD_CHARCELLS */
vp.width = screen->lcdwidth;
vp.height = screen->lcdheight;
space_w = h = 1;
screen->double_height (false);
#endif
y = h;
@ -178,9 +166,6 @@ static void splash_internal(struct screen * screen, const char *fmt, va_list ap)
/* prepare putting the text */
y = RECT_SPACING;
#else /* HAVE_LCD_CHARCELLS */
y = 0; /* vertical centering on 2 lines would be silly */
screen->clear_display();
#endif
/* print the message to screen */
@ -188,8 +173,6 @@ static void splash_internal(struct screen * screen, const char *fmt, va_list ap)
{
#ifdef HAVE_LCD_BITMAP
screen->putsxy(0, y, lines[i]);
#else
screen->puts(0, y, lines[i]);
#endif
}
screen->update_viewport();

38
apps/gui/statusbar.c
View file

@ -191,12 +191,6 @@ void gui_statusbar_draw(struct gui_statusbar * bar, bool force_redraw, struct vi
if (!display)
return;
#ifdef HAVE_LCD_CHARCELLS
int val;
(void)force_redraw; /* The Player always has "redraw" */
(void)vp;
#endif /* HAVE_LCD_CHARCELLS */
bar->info.battlevel = battery_level();
#ifdef HAVE_USB_POWER
bar->info.usb_inserted = usb_inserted();
@ -359,38 +353,6 @@ void gui_statusbar_draw(struct gui_statusbar * bar, bool force_redraw, struct vi
}
#endif /* HAVE_LCD_BITMAP */
#ifdef HAVE_LCD_CHARCELLS
display->icon(ICON_BATTERY, bar->info.battery_state);
if (bar->info.batt_charge_step > -1)
val = bar->info.batt_charge_step;
else
val = (bar->info.battlevel * 3 + 50) / 100;
display->icon(ICON_BATTERY_1, val >= 1);
display->icon(ICON_BATTERY_2, val >= 2);
display->icon(ICON_BATTERY_3, val >= 3);
val = 10 * (bar->info.volume - sound_min(SOUND_VOLUME))
/ (sound_max(SOUND_VOLUME) - sound_min(SOUND_VOLUME));
display->icon(ICON_VOLUME, true);
display->icon(ICON_VOLUME_1, val >= 1);
display->icon(ICON_VOLUME_2, val >= 3);
display->icon(ICON_VOLUME_3, val >= 5);
display->icon(ICON_VOLUME_4, val >= 7);
display->icon(ICON_VOLUME_5, val >= 9);
display->icon(ICON_PLAY, current_playmode() == STATUS_PLAY);
display->icon(ICON_PAUSE, current_playmode() == STATUS_PAUSE);
display->icon(ICON_REPEAT, global_settings.repeat_mode != REPEAT_OFF);
display->icon(ICON_1, global_settings.repeat_mode == REPEAT_ONE);
display->icon(ICON_RECORD, record);
display->icon(ICON_AUDIO, audio);
display->icon(ICON_PARAM, param);
display->icon(ICON_USB, usb);
#endif /* HAVE_LCD_CHARCELLS */
}
#ifdef HAVE_LCD_BITMAP

9
apps/gui/usb_screen.c
View file

@ -269,12 +269,7 @@ void gui_usb_screen_run(bool early_usb)
* generic cleanup here */
screen->set_viewport(NULL);
screen->scroll_stop();
#ifdef HAVE_LCD_CHARCELLS
/* Quick fix. Viewports should really be enabled proper for charcell */
viewport_set_defaults(&usb_screen_vps_ar[i].parent, i);
#else
usb_screen_fix_viewports(screen, &usb_screen_vps_ar[i]);
#endif
}
/* update the UI before disabling fonts, this maximizes the propability
@ -327,10 +322,6 @@ void gui_usb_screen_run(bool early_usb)
touchscreen_set_mode(old_mode);
#endif
#ifdef HAVE_LCD_CHARCELLS
status_set_usb(false);
#endif /* HAVE_LCD_CHARCELLS */
#ifdef HAVE_LCD_BITMAP
if(!early_usb)
{

4
apps/gui/viewport.h
View file

@ -69,10 +69,6 @@ bool viewport_point_within_vp(const struct viewport *vp,
const int x, const int y);
#endif
#else /* HAVE_LCD_CHARCELL */
#define viewportmanager_theme_changed(a)
#define viewportmanager_theme_enable(...)
#define viewportmanager_theme_undo(...)
#endif
#endif /* __PCTOOL__ */

22
apps/gui/wps.c
View file

@ -232,11 +232,6 @@ static bool update_onvol_change(enum screen_type screen)
{
skin_update(WPS, screen, SKIN_REFRESH_NON_STATIC);
#ifdef HAVE_LCD_CHARCELLS
splashf(0, "Vol: %3d dB",
sound_val2phys(SOUND_VOLUME, global_settings.volume));
return true;
#endif
return false;
}
@ -401,10 +396,6 @@ bool ffwd_rew(int button)
#if (CONFIG_CODEC != SWCODEC)
if (!skin_get_global_state()->paused)
audio_resume();
#endif
#ifdef HAVE_LCD_CHARCELLS
FOR_NB_SCREENS(i)
skin_update(WPS, i, SKIN_REFRESH_ALL);
#endif
exit = true;
break;
@ -741,11 +732,6 @@ long gui_wps_show(void)
long last_left = 0, last_right = 0;
struct wps_state *state = skin_get_global_state();
#ifdef HAVE_LCD_CHARCELLS
status_set_audio(true);
status_set_param(false);
#endif
#ifdef AB_REPEAT_ENABLE
ab_repeat_init();
ab_reset_markers();
@ -833,10 +819,6 @@ long gui_wps_show(void)
break;
case ACTION_WPS_BROWSE:
#ifdef HAVE_LCD_CHARCELLS
status_set_record(false);
status_set_audio(false);
#endif
gwps_leave_wps();
return GO_TO_PREVIOUS_BROWSER;
break;
@ -1146,10 +1128,6 @@ long gui_wps_show(void)
}
if (exit) {
#ifdef HAVE_LCD_CHARCELLS
status_set_record(false);
status_set_audio(false);
#endif
#if CONFIG_CODEC != SWCODEC
if (global_settings.fade_on_stop)
fade(false, true);

5
apps/gui/yesno.c
View file

@ -160,12 +160,7 @@ enum yesno_res gui_syncyesno_run(const struct text_message * main_message,
yn[i].result_message[YESNO_NO]=no_message;
yn[i].display=&screens[i];
yn[i].vp = &vp[i];
#ifdef HAVE_LCD_CHARCELLS
/* Quick fix. Viewports should really be enabled proper for charcell */
viewport_set_defaults(yn[i].vp, i);
#else
viewportmanager_theme_enable(i, true, yn[i].vp);
#endif
screens[i].scroll_stop();
gui_yesno_draw(&(yn[i]));
}

7
apps/logfdisp.c
View file

@ -209,13 +209,6 @@ bool logfdisplay(void)
return false;
}
#else /* HAVE_LCD_BITMAP */
bool logfdisplay(void)
{
/* TODO: implement a browser for charcell bitmaps */
return false;
}
#endif /* HAVE_LCD_BITMAP */
bool logfdump(void)

28
apps/menus/main_menu.c
View file

@ -125,11 +125,7 @@ static int show_credits(void)
return 0;
}
#ifdef HAVE_LCD_CHARCELLS
#define SIZE_FMT "%s%s"
#else
#define SIZE_FMT "%s %s"
#endif
struct info_data
{
@ -500,29 +496,7 @@ MAKE_MENU(info_menu, ID2P(LANG_SYSTEM), 0, Icon_System_menu,
/***********************************/
/* MAIN MENU */
#ifdef HAVE_LCD_CHARCELLS
static int mainmenu_callback(int action,
const struct menu_item_ex *this_item,
struct gui_synclist *lists)
{
(void)this_item;
(void)lists;
switch (action)
{
case ACTION_ENTER_MENUITEM:
status_set_param(true);
break;
case ACTION_EXIT_MENUITEM:
status_set_param(false);
break;
}
return action;
}
#else
#define mainmenu_callback NULL
#endif
MAKE_MENU(main_menu_, ID2P(LANG_SETTINGS), mainmenu_callback,
MAKE_MENU(main_menu_, ID2P(LANG_SETTINGS), NULL,
Icon_Submenu_Entered,
&sound_settings,
&playback_settings,

8
apps/onplay.c
View file

@ -180,15 +180,7 @@ static int bookmark_menu_callback(int action,
else if (!bookmark_is_bookmarkable_state() && !bookmark_exists())
return ACTION_EXIT_MENUITEM;
break;
#ifdef HAVE_LCD_CHARCELLS
case ACTION_ENTER_MENUITEM:
status_set_param(true);
break;
#endif
case ACTION_EXIT_MENUITEM:
#ifdef HAVE_LCD_CHARCELLS
status_set_param(false);
#endif
settings_save();
break;
}

110
apps/player/icons.c
View file

@ -1,110 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2007 Jonathan Gordon
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "lcd.h"
#include "icon.h"
#ifdef HAVE_LCD_CHARCELLS
/* For the moment, charcell cant load custom maps... */
enum old_values{
old_Icon_Queued = 'Q',
old_Icon_Moving = 'M',
old_Icon_Unknown = 0xe100,
old_Icon_Bookmark,
old_Icon_Plugin,
old_Icon_Folder,
old_Icon_Firmware,
old_Icon_Language,
old_Icon_Audio,
old_Icon_Wps,
old_Icon_Playlist,
old_Icon_Text,
old_Icon_Config,
};
static const unsigned short icons[Icon_Last_Themeable] = {
[0 ... Icon_Last_Themeable-1] = ' ',
[Icon_Audio] = old_Icon_Audio,
[Icon_Folder] = old_Icon_Folder,
[Icon_Playlist] = old_Icon_Playlist,
[Icon_Cursor] = CURSOR_CHAR,
[Icon_Wps] = old_Icon_Wps,
[Icon_Firmware] = old_Icon_Firmware,
[Icon_Language] = old_Icon_Language,
[Icon_Config] = old_Icon_Config,
[Icon_Plugin] = old_Icon_Plugin,
[Icon_Bookmark] = old_Icon_Bookmark,
[Icon_Queued] = old_Icon_Queued,
[Icon_Moving] = old_Icon_Moving,
/*
[Icon_Keyboard] = ,
[Icon_Font] = ,
[Icon_Preset] = ,
[Icon_Reverse_Cursor] = ,
[Icon_Questionmark] = ,
[Icon_Menu_setting] = ,
[Icon_Menu_functioncall] = ,
[Icon_Submenu] = ,
[Icon_Submenu_Entered] = ,
[Icon_Recording] = ,
[Icon_Voice] = ,
[Icon_General_settings_menu] = ,
[Icon_System_menu] = ,
[Icon_Playback_menu] = ,
[Icon_Display_menu] = ,
[Icon_Remote_Display_menu] = ,
[Icon_Radio_screen] = ,
[Icon_file_view_menu] = ,
[Icon_EQ] = ,
[Icon_Rockbox] = ,
*/
};
/* as above, but x,y are letter position, NOT PIXEL */
extern void screen_put_iconxy(struct screen * screen,
int x, int y, enum themable_icons icon)
{
if (icon <= Icon_NOICON)
screen->putchar(x, y, ' ');
else if (icon >= Icon_Last_Themeable)
screen->putchar(x, y, old_Icon_Unknown);
else
screen->putchar(x, y, icons[icon]);
}
void screen_put_cursorxy(struct screen * display, int x, int y, bool on)
{
screen_put_iconxy(display, x, y, on?Icon_Cursor:-1);
}
void icons_init(void)
{
}
#endif

11
apps/plugin.c
View file

@ -195,16 +195,6 @@ static const struct plugin_api rockbox_api = {
lcd_putsf,
lcd_puts_scroll,
lcd_scroll_stop,
#ifdef HAVE_LCD_CHARCELLS
lcd_define_pattern,
lcd_get_locked_pattern,
lcd_unlock_pattern,
lcd_putc,
lcd_put_cursor,
lcd_remove_cursor,
lcd_icon,
lcd_double_height,
#else /* HAVE_LCD_BITMAP */
&lcd_static_framebuffer[0][0],
lcd_set_viewport,
lcd_set_framebuffer,
@ -270,7 +260,6 @@ static const struct plugin_api rockbox_api = {
font_get_width,
screen_clear_area,
gui_scrollbar_draw,
#endif /* HAVE_LCD_BITMAP */
get_codepage_name,
#ifdef HAVE_REMOTE_LCD

11
apps/plugin.h
View file

@ -205,16 +205,6 @@ struct plugin_api {
void (*lcd_putsf)(int x, int y, const unsigned char *fmt, ...);
bool (*lcd_puts_scroll)(int x, int y, const unsigned char* string);
void (*lcd_scroll_stop)(void);
#ifdef HAVE_LCD_CHARCELLS
void (*lcd_define_pattern)(unsigned long ucs, const char *pattern);
unsigned long (*lcd_get_locked_pattern)(void);
void (*lcd_unlock_pattern)(unsigned long ucs);
void (*lcd_putc)(int x, int y, unsigned long ucs);
void (*lcd_put_cursor)(int x, int y, unsigned long ucs);
void (*lcd_remove_cursor)(void);
void (*lcd_icon)(int icon, bool enable);
void (*lcd_double_height)(bool on);
#else /* HAVE_LCD_BITMAP */
fb_data* lcd_framebuffer;
void (*lcd_set_viewport)(struct viewport* vp);
void (*lcd_set_framebuffer)(fb_data *fb);
@ -300,7 +290,6 @@ struct plugin_api {
int width, int height, int items,
int min_shown, int max_shown,
unsigned flags);
#endif /* HAVE_LCD_BITMAP */
const char* (*get_codepage_name)(int cp);
#ifdef HAVE_REMOTE_LCD

68
apps/plugins/credits.c
View file

@ -27,69 +27,6 @@ static const char* const credits[] = {
#include "credits.raw" /* generated list of names from docs/CREDITS */
};
#ifdef HAVE_LCD_CHARCELLS
static void roll_credits(void)
{
int numnames = sizeof(credits)/sizeof(char*);
int curr_name = 0;
int curr_len = rb->utf8length(credits[0]);
int curr_index = 0;
int curr_line = 0;
int name, len, new_len, line, x;
while (1)
{
rb->lcd_clear_display();
name = curr_name;
x = -curr_index;
len = curr_len;
line = curr_line;
while (x < 11)
{
int x2;
if (x < 0)
rb->lcd_puts(0, line,
credits[name] + rb->utf8seek(credits[name], -x));
else
rb->lcd_puts(x, line, credits[name]);
if (++name >= numnames)
break;
line ^= 1;
x2 = x + len/2;
if ((unsigned)x2 < 11)
rb->lcd_putc(x2, line, '*');
new_len = rb->utf8length(credits[name]);
x += MAX(len/2 + 2, len - new_len/2 + 1);
len = new_len;
}
rb->lcd_update();
/* abort on keypress */
if(rb->action_userabort(HZ/8))
return;
if (++curr_index >= curr_len)
{
if (++curr_name >= numnames)
break;
new_len = rb->utf8length(credits[curr_name]);
curr_index -= MAX(curr_len/2 + 2, curr_len - new_len/2 + 1);
curr_len = new_len;
curr_line ^= 1;
}
}
}
#else
static bool stop_autoscroll(int action)
{
switch (action)
@ -362,8 +299,6 @@ static void roll_credits(void)
}
}
#endif
enum plugin_status plugin_start(const void* parameter)
{
(void)parameter;
@ -372,9 +307,6 @@ enum plugin_status plugin_start(const void* parameter)
backlight_ignore_timeout();
rb->show_logo();
#ifdef HAVE_LCD_CHARCELLS
rb->lcd_double_height(false);
#endif
/* Show the logo for about 3 secs allowing the user to stop */
if(!rb->action_userabort(3*HZ))

10
apps/plugins/cube.c
View file

@ -22,7 +22,6 @@
***************************************************************************/
#include "plugin.h"
#include "fixedpoint.h"
#include "lib/playergfx.h"
#include "lib/pluginlib_exit.h"
#if LCD_DEPTH > 1
#include "lib/mylcd.h" /* MYLCD_CFG_RB_XLCD or MYLCD_CFG_PGFX */
@ -746,8 +745,6 @@ static void cleanup(void)
{
#ifdef USEGSLIB
grey_release();
#elif defined HAVE_LCD_CHARCELLS
pgfx_release();
#endif
}
@ -797,13 +794,6 @@ enum plugin_status plugin_start(const void* parameter)
grey_setfont(FONT_SYSFIXED);
#endif
rb->lcd_setfont(FONT_SYSFIXED);
#else /* LCD_CHARCELLS */
if (!pgfx_init(4, 2))
{
rb->splash(HZ*2, "Old LCD :(");
return PLUGIN_OK;
}
pgfx_display(0, 0);
#endif
atexit(cleanup);

75
apps/plugins/flipit.c
View file

@ -595,75 +595,6 @@ static void draw_info_panel(void)
GRID_TOP + 4*(TK_HEIGHT+TK_SPACE) + 2, s );
}
#else /* HAVE_LCD_CHARCELLS */
static const unsigned char tk_pat[4][7] = {
{ 0x0e, 0x11, 0x0e, 0x00, 0x0e, 0x11, 0x0e }, /* white - white */
{ 0x0e, 0x11, 0x0e, 0x00, 0x0e, 0x1f, 0x0e }, /* white - black */
{ 0x0e, 0x1f, 0x0e, 0x00, 0x0e, 0x11, 0x0e }, /* black - white */
{ 0x0e, 0x1f, 0x0e, 0x00, 0x0e, 0x1f, 0x0e } /* black - black */
};
static unsigned char cur_pat[7];
static unsigned long gfx_chars[5];
static void release_gfx(void)
{
int i;
for (i = 0; i < 5; i++)
if (gfx_chars[i])
rb->lcd_unlock_pattern(gfx_chars[i]);
}
static bool init_gfx(void)
{
int i;
for (i = 0; i < 5; i++) {
if ((gfx_chars[i] = rb->lcd_get_locked_pattern()) == 0) {
release_gfx();
return false;
}
}
for (i = 0; i < 4; i++)
rb->lcd_define_pattern(gfx_chars[i], tk_pat[i]);
return true;
}
/* draw a spot at the coordinates (x,y), range of p is 0-19 */
static void draw_spot(int p)
{
if ((p/5) & 1)
p -= 5;
rb->lcd_putc (p%5, p/10, gfx_chars[2*spots[p]+spots[p+5]]);
}
/* draw the cursor at the current cursor position */
static void draw_cursor(void)
{
if ((cursor_pos/5) & 1) {
rb->memcpy( cur_pat, tk_pat[2*spots[cursor_pos-5]+spots[cursor_pos]], 7 );
cur_pat[4] ^= 0x15;
cur_pat[6] ^= 0x11;
}
else {
rb->memcpy( cur_pat, tk_pat[2*spots[cursor_pos]+spots[cursor_pos+5]], 7 );
cur_pat[0] ^= 0x15;
cur_pat[2] ^= 0x11;
}
rb->lcd_define_pattern(gfx_chars[4], cur_pat);
rb->lcd_putc( cursor_pos%5, cursor_pos/10, gfx_chars[4] );
}
/* draw the info panel ... duh */
static void draw_info_panel(void)
{
rb->lcd_puts( 6, 0, "Flips" );
rb->lcd_putsf( 6, 1, "%d", moves );
}
#endif /* LCD */
/* clear the cursor where it is */
@ -978,9 +909,6 @@ enum plugin_status plugin_start(const void* parameter)
#endif
rb->lcd_update();
#else /* HAVE_LCD_CHARCELLS */
if (!init_gfx())
return PLUGIN_ERROR;
#endif
rb->button_get_w_tmo(HZ*3);
@ -995,8 +923,5 @@ enum plugin_status plugin_start(const void* parameter)
rb->srand(*rb->current_tick);
rc = flipit_loop();
#ifdef HAVE_LCD_CHARCELLS
release_gfx();
#endif
return rc;
}

4
apps/plugins/invadrox.c
View file

@ -66,10 +66,6 @@
/* Original graphics is only 1bpp so it should be portable
* to most targets. But for now, only support the simple ones.
*/
#ifndef HAVE_LCD_BITMAP
#error INVADROX: Unsupported LCD
#endif
#if (LCD_DEPTH < 2)
#error INVADROX: Unsupported LCD
#endif

70
apps/plugins/jackpot.c
View file

@ -30,24 +30,7 @@ const struct button_mapping* plugin_contexts[]={pla_main_ctx};
#define NB_PICTURES 9
#define NB_SLOTS 3
#ifdef HAVE_LCD_CHARCELLS
#define PICTURE_ROTATION_STEPS 7
static unsigned char jackpot_slots_patterns[]={
0x00, 0x0A, 0x1F, 0x1F, 0x1F, 0x0e, 0x04, /* (+00)Heart */
0x00, 0x04, 0x0E, 0x1F, 0x1F, 0x04, 0x0E, /* (+07)Spade */
0x00, 0x04, 0x0E, 0x1F, 0x0E, 0x04, 0x00, /* (+14)Diamond */
0x00, 0x15, 0x0E, 0x1F, 0x0E, 0x15, 0x00, /* (+21)Club */
0x03, 0x04, 0x0e, 0x1F, 0x1F, 0x1F, 0x0e, /* (+28)Cherry */
0x00, 0x04, 0x04, 0x1F, 0x04, 0x0E, 0x1F, /* (+35)Cross */
0x04, 0x0E, 0x15, 0x04, 0x0A, 0x0A, 0x11, /* (+42)Man */
0x00, 0x1F, 0x1F, 0x1F, 0x1F, 0x1F, 0x00, /* (+49)Square */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* (+56)Empty */
0x00, 0x0A, 0x1F, 0x1F, 0x1F, 0x0e, 0x04 /* (+63)Heart */
};
static unsigned long char_patterns[NB_SLOTS];
#define SLEEP_TIME (HZ/24)
#else /* bitmaps LCDs */
#ifdef HAVE_LCD_BITMAP
#define PICTURE_HEIGHT (BMPHEIGHT_jackpot_slots/(NB_PICTURES+1))
#if NB_SCREENS==1
#define PICTURE_ROTATION_STEPS PICTURE_HEIGHT
@ -72,7 +55,7 @@ const struct picture jackpot_pictures[]={
};
#define SLEEP_TIME (HZ/200)
#endif /* HAVE_LCD_CHARCELLS */
#endif /* HAVE_LCD_BITMAP */
struct jackpot
{
@ -92,29 +75,9 @@ struct jackpot
int money;
};
#ifdef HAVE_LCD_CHARCELLS
static void patterns_init(struct screen* display)
{
int i;
for(i=0;i<NB_SLOTS;i++)
char_patterns[i]=display->get_locked_pattern();
}
static void patterns_deinit(struct screen* display)
{
/* Restore the old pattern */
int i;
for(i=0;i<NB_SLOTS;i++)
display->unlock_pattern(char_patterns[i]);
}
#endif /* HAVE_LCD_CHARCELLS */
/*Call when the program exit*/
static void jackpot_exit(void)
{
#ifdef HAVE_LCD_CHARCELLS
patterns_deinit(rb->screens[SCREEN_MAIN]);
#endif /* HAVE_LCD_CHARCELLS */
}
static void jackpot_init(struct jackpot* game)
@ -168,47 +131,25 @@ static void jackpot_display_slot_machine(struct jackpot* game, struct screen* di
char str[20];
int i;
bool changes=false;
#ifdef HAVE_LCD_CHARCELLS
display->putchar(0, 0, '[');
#else
const struct picture* picture= &(jackpot_pictures[display->screen_type]);
int pos_x=(display->getwidth()-NB_SLOTS*(picture->width+1))/2;
int pos_y=(display->getheight()-(picture->slide_height))/2;
#endif /* HAVE_LCD_CHARCELLS */
for(i=0;i<NB_SLOTS;i++)
{
#ifdef HAVE_LCD_CHARCELLS
/* the only charcell lcd is 7 pixel high */
int state_y=(game->slot_state[i]*7)/PICTURE_ROTATION_STEPS;
#else
int state_y=
(picture->slide_height*game->slot_state[i])/PICTURE_ROTATION_STEPS;
#endif /* HAVE_LCD_CHARCELLS */
int previous_state_y=game->state_y[display->screen_type][i];
if(state_y==previous_state_y)
continue;/*no need to update the picture
as it's the same as previous displayed one*/
changes=true;
game->state_y[display->screen_type][i]=state_y;
#ifdef HAVE_LCD_CHARCELLS
char* current_pattern=&(jackpot_slots_patterns[state_y]);
display->define_pattern(char_patterns[i],
current_pattern);
display->putchar(i+1, 0, char_patterns[i]);
#else
vertical_picture_draw_part(display, picture, state_y, pos_x, pos_y);
pos_x+=(picture->width+1);
#endif
}
if(changes){
#ifdef HAVE_LCD_CHARCELLS
rb->snprintf(str,sizeof(str),"$%d", game->money);
display->putchar(++i, 0, ']');
display->puts(++i, 0, str);
#else
rb->snprintf(str,sizeof(str),"money : $%d", game->money);
display->puts(0, 0, str);
#endif
display->update();
}
}
@ -216,9 +157,6 @@ static void jackpot_display_slot_machine(struct jackpot* game, struct screen* di
static void jackpot_info_message(struct screen* display, char* message)
{
#ifdef HAVE_LCD_CHARCELLS
display->puts_scroll(0,1,message);
#else
int xpos, ypos;
int message_height, message_width;
display->getstringsize(message, &message_width, &message_height);
@ -228,7 +166,6 @@ static void jackpot_info_message(struct screen* display, char* message)
message_height);
display->putsxy(xpos,ypos,message);
display->update();
#endif /* HAVE_LCD_CHARCELLS */
}
static void jackpot_print_turn_result(struct jackpot* game,
@ -299,9 +236,6 @@ enum plugin_status plugin_start(const void* parameter)
(void)parameter;
atexit(jackpot_exit);
rb->srand(*rb->current_tick);
#ifdef HAVE_LCD_CHARCELLS
patterns_init(rb->screens[SCREEN_MAIN]);
#endif /* HAVE_LCD_CHARCELLS */
jackpot_init(&game);
FOR_NB_SCREENS(i){

4
apps/plugins/lib/SOURCES
View file

@ -33,10 +33,6 @@ overlay.c
profile_plugin.c
#endif
#ifdef HAVE_LCD_CHARCELLS
playergfx.c
#endif
#ifdef HAVE_LCD_BITMAP
#ifdef CPU_ARM

4
apps/plugins/lib/display_text.c
View file

@ -22,11 +22,7 @@
#include "plugin.h"
#include "display_text.h"
#ifdef HAVE_LCD_CHARCELLS
#define MARGIN 0
#else
#define MARGIN 5
#endif
static bool wait_key_press(void)
{

9
apps/plugins/lib/mylcd.h
View file

@ -32,15 +32,10 @@
* targets. On color, mylcd_ub_update_XXXX refer to the proper update
* functions, otherwise they are no-ops.
*
* lib/playergfx.h or lib/grey.h should be included before including this
* lib/grey.h should be included before including this
* header. For bitmap LCD's, defaults to rb->lcd_XXXX otherwise.
*/
#if defined (HAVE_LCD_CHARCELLS) && defined(__PGFX_H__)
#define MYLCD_CFG_PGFX /* using PGFX */
#define mylcd_(fn) pgfx_##fn
#define mylcd_ub_(fn) pgfx_##fn
#elif defined (HAVE_LCD_BITMAP) && (LCD_DEPTH < 4) && defined(__GREY_H__)
#if defined (HAVE_LCD_BITMAP) && (LCD_DEPTH < 4) && defined(__GREY_H__)
#define MYLCD_CFG_GREYLIB /* using greylib */
#define mylcd_(fn) grey_##fn
#define myxlcd_(fn) grey_##fn

4
apps/plugins/lib/osd.h
View file

@ -23,10 +23,6 @@
#ifndef OSD_H
#define OSD_H
#ifndef HAVE_LCD_BITMAP
#error OSD requires bitmapped LCD
#endif
/* At this time: assumes use of the default viewport for normal drawing */
/* Callback implemented by user. Paramters are OSD vp-relative coordinates */

526
apps/plugins/lib/playergfx.c
View file

@ -1,526 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Bitmap graphics on player LCD!
*
* Copyright (C) 2005 Jens Arnold
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "plugin.h"
#include "playergfx.h"
/*** globals ***/
static int char_width;
static int char_height;
static int pixel_height;
static int pixel_width;
static unsigned long gfx_chars[8];
static unsigned char gfx_buffer[56];
static int drawmode = DRMODE_SOLID;
/*** Special functions ***/
/* library init */
bool pgfx_init(int cwidth, int cheight)
{
int i;
if (((unsigned) cwidth * (unsigned) cheight) > 8 || (unsigned) cheight > 2)
return false;
char_width = cwidth;
char_height = cheight;
pixel_height = 7 * char_height;
pixel_width = 5 * char_width;
for (i = 0; i < cwidth * cheight; i++)
{
if ((gfx_chars[i] = rb->lcd_get_locked_pattern()) == 0)
{
pgfx_release();
return false;
}
}
return true;
}
/* library deinit */
void pgfx_release(void)
{
int i;
for (i = 0; i < 8; i++)
if (gfx_chars[i])
rb->lcd_unlock_pattern(gfx_chars[i]);
}
/* place the display */
void pgfx_display(int cx, int cy)
{
int i, j;
int width = MIN(char_width, 11 - cx);
int height = MIN(char_height, 2 - cy);
for (i = 0; i < width; i++)
for (j = 0; j < height; j++)
rb->lcd_putc(cx + i, cy + j, gfx_chars[char_height * i + j]);
}
void pgfx_display_block(int cx, int cy, int x, int y)
{
rb->lcd_putc(cx, cy, gfx_chars[char_height * x + y]);
}
/*** Update functions ***/
void pgfx_update(void)
{
int i;
for (i = 0; i < char_width * char_height; i++)
rb->lcd_define_pattern(gfx_chars[i], gfx_buffer + 7 * i);
rb->lcd_update();
}
/*** Parameter handling ***/
void pgfx_set_drawmode(int mode)
{
drawmode = mode & (DRMODE_SOLID|DRMODE_INVERSEVID);
}
int pgfx_get_drawmode(void)
{
return drawmode;
}
/*** Low-level drawing functions ***/
static void setpixel(int x, int y)
{
gfx_buffer[pixel_height * (x/5) + y] |= 0x10 >> (x%5);
}
static void clearpixel(int x, int y)
{
gfx_buffer[pixel_height * (x/5) + y] &= ~(0x10 >> (x%5));
}
static void flippixel(int x, int y)
{
gfx_buffer[pixel_height * (x/5) + y] ^= 0x10 >> (x%5);
}
static void nopixel(int x, int y)
{
(void)x;
(void)y;
}
lcd_pixelfunc_type* pgfx_pixelfuncs[8] = {
flippixel, nopixel, setpixel, setpixel,
nopixel, clearpixel, nopixel, clearpixel
};
static void flipblock(unsigned char *address, unsigned mask, unsigned bits)
{
*address ^= (bits & mask);
}
static void bgblock(unsigned char *address, unsigned mask, unsigned bits)
{
*address &= (bits | ~mask);
}
static void fgblock(unsigned char *address, unsigned mask, unsigned bits)
{
*address |= (bits & mask);
}
static void solidblock(unsigned char *address, unsigned mask, unsigned bits)
{
unsigned data = *(char *)address;
bits ^= data;
*address = data ^ (bits & mask);
}
static void flipinvblock(unsigned char *address, unsigned mask, unsigned bits)
{
*address ^= (~bits & mask);
}
static void bginvblock(unsigned char *address, unsigned mask, unsigned bits)
{
*address &= ~(bits & mask);
}
static void fginvblock(unsigned char *address, unsigned mask, unsigned bits)
{
*address |= (~bits & mask);
}
static void solidinvblock(unsigned char *address, unsigned mask, unsigned bits)
{
unsigned data = *(char *)address;
bits = ~bits ^ data;
*address = data ^ (bits & mask);
}
lcd_blockfunc_type* pgfx_blockfuncs[8] = {
flipblock, bgblock, fgblock, solidblock,
flipinvblock, bginvblock, fginvblock, solidinvblock
};
/*** Drawing functions ***/
/* Clear the whole display */
void pgfx_clear_display(void)
{
unsigned bits = (drawmode & DRMODE_INVERSEVID) ? 0x1F : 0;
rb->memset(gfx_buffer, bits, char_width * pixel_height);
}
/* Set a single pixel */
void pgfx_drawpixel(int x, int y)
{
if (((unsigned)x < (unsigned)pixel_width)
&& ((unsigned)y < (unsigned)pixel_height))
pgfx_pixelfuncs[drawmode](x, y);
}
/* Draw a line */
void pgfx_drawline(int x1, int y1, int x2, int y2)
{
int numpixels;
int i;
int deltax, deltay;
int d, dinc1, dinc2;
int x, xinc1, xinc2;
int y, yinc1, yinc2;
lcd_pixelfunc_type *pfunc = pgfx_pixelfuncs[drawmode];
deltax = abs(x2 - x1);
deltay = abs(y2 - y1);
xinc2 = 1;
yinc2 = 1;
if (deltax >= deltay)
{
numpixels = deltax;
d = 2 * deltay - deltax;
dinc1 = deltay * 2;
dinc2 = (deltay - deltax) * 2;
xinc1 = 1;
yinc1 = 0;
}
else
{
numpixels = deltay;
d = 2 * deltax - deltay;
dinc1 = deltax * 2;
dinc2 = (deltax - deltay) * 2;
xinc1 = 0;
yinc1 = 1;
}
numpixels++; /* include endpoints */
if (x1 > x2)
{
xinc1 = -xinc1;
xinc2 = -xinc2;
}
if (y1 > y2)
{
yinc1 = -yinc1;
yinc2 = -yinc2;
}
x = x1;
y = y1;
for (i = 0; i < numpixels; i++)
{
if (((unsigned)x < (unsigned)pixel_width)
&& ((unsigned)y < (unsigned)pixel_height))
pfunc(x, y);
if (d < 0)
{
d += dinc1;
x += xinc1;
y += yinc1;
}
else
{
d += dinc2;
x += xinc2;
y += yinc2;
}
}
}
/* Draw a horizontal line (optimised) */
void pgfx_hline(int x1, int x2, int y)
{
int nx;
unsigned char *dst;
unsigned mask, mask_right;
lcd_blockfunc_type *bfunc;
/* direction flip */
if (x2 < x1)
{
nx = x1;
x1 = x2;
x2 = nx;
}
/* nothing to draw? */
if (((unsigned)y >= (unsigned)pixel_height) || (x1 >= pixel_width)
|| (x2 < 0))
return;
/* clipping */
if (x1 < 0)
x1 = 0;
if (x2 >= pixel_width)
x2 = pixel_width - 1;
bfunc = pgfx_blockfuncs[drawmode];
dst = &gfx_buffer[pixel_height * (x1/5) + y];
nx = x2 - (x1 - (x1 % 5));
mask = 0x1F >> (x1 % 5);
mask_right = 0x1F0 >> (nx % 5);
for (; nx >= 5; nx -= 5)
{
bfunc(dst, mask, 0xFFu);
dst += pixel_height;
mask = 0x1F;
}
mask &= mask_right;
bfunc(dst, mask, 0x1F);
}
/* Draw a vertical line (optimised) */
void pgfx_vline(int x, int y1, int y2)
{
int y;
unsigned char *dst, *dst_end;
unsigned mask;
lcd_blockfunc_type *bfunc;
/* direction flip */
if (y2 < y1)
{
y = y1;
y1 = y2;
y2 = y;
}
/* nothing to draw? */
if (((unsigned)x >= (unsigned)pixel_width) || (y1 >= pixel_height)
|| (y2 < 0))
return;
/* clipping */
if (y1 < 0)
y1 = 0;
if (y2 >= pixel_height)
y2 = pixel_height - 1;
bfunc = pgfx_blockfuncs[drawmode];
dst = &gfx_buffer[pixel_height * (x/5) + y1];
mask = 0x10 >> (x % 5);
dst_end = dst + y2 - y1;
do
bfunc(dst++, mask, 0x1F);
while (dst <= dst_end);
}
/* Draw a rectangular box */
void pgfx_drawrect(int x, int y, int width, int height)
{
if ((width <= 0) || (height <= 0))
return;
int x2 = x + width - 1;
int y2 = y + height - 1;
pgfx_vline(x, y, y2);
pgfx_vline(x2, y, y2);
pgfx_hline(x, x2, y);
pgfx_hline(x, x2, y2);
}
/* Fill a rectangular area */
void pgfx_fillrect(int x, int y, int width, int height)
{
int nx;
unsigned char *dst, *dst_end;
unsigned mask, mask_right;
lcd_blockfunc_type *bfunc;
/* nothing to draw? */
if ((width <= 0) || (height <= 0) || (x >= pixel_width)
|| (y >= pixel_height) || (x + width <= 0) || (y + height <= 0))
return;
/* clipping */
if (x < 0)
{
width += x;
x = 0;
}
if (y < 0)
{
height += y;
y = 0;
}
if (x + width > pixel_width)
width = pixel_width - x;
if (y + height > pixel_height)
height = pixel_height - y;
bfunc = pgfx_blockfuncs[drawmode];
dst = &gfx_buffer[pixel_height * (x/5) + y];
nx = width - 1 + (x % 5);
mask = 0x1F >> (x % 5);
mask_right = 0x1F0 >> (nx % 5);
for (; nx >= 5; nx -= 5)
{
unsigned char *dst_col = dst;
dst_end = dst_col + height;
do
bfunc(dst_col++, mask, 0x1F);
while (dst_col < dst_end);
dst += pixel_height;
mask = 0x1F;
}
mask &= mask_right;
dst_end = dst + height;
do
bfunc(dst++, mask, 0x1F);
while (dst < dst_end);
}
/* About PlayerGFX internal bitmap format:
*
* A bitmap contains one bit for every pixel that defines if that pixel is
* black (1) or white (0). Bits within a byte are arranged horizontally,
* MSB at the left.
* The bytes are stored in row-major order, with byte 0 being top left,
* byte 1 2nd from left etc. Each row of bytes defines one pixel row.
*
* This approximates the (even more strange) internal hardware format. */
/* Draw a partial bitmap. stride is given in pixels */
void pgfx_bitmap_part(const unsigned char *src, int src_x, int src_y,
int stride, int x, int y, int width, int height)
{
int nx, shift;
unsigned char *dst, *dst_end;
unsigned mask, mask_right;
lcd_blockfunc_type *bfunc;
/* nothing to draw? */
if ((width <= 0) || (height <= 0) || (x >= pixel_width)
|| (y >= pixel_height) || (x + width <= 0) || (y + height <= 0))
return;
/* clipping */
if (x < 0)
{
width += x;
src_x -= x;
x = 0;
}
if (y < 0)
{
height += y;
src_y -= y;
y = 0;
}
if (x + width > pixel_width)
width = pixel_width - x;
if (y + height > pixel_height)
height = pixel_height - y;
stride = (stride + 7) >> 3; /* convert to no. of bytes */
src += stride * src_y + (src_x >> 3); /* move starting point */
dst = &gfx_buffer[pixel_height * (x/5) + y];
shift = 3 + (x % 5) - (src_x & 7);
nx = width - 1 + (x % 5);
bfunc = pgfx_blockfuncs[drawmode];
mask = 0x1F >> (x % 5);
mask_right = 0x1F0 >> (nx % 5);
dst_end = dst + height;
do
{
const unsigned char *src_row = src;
unsigned char *dst_row = dst++;
unsigned mask_row = mask;
unsigned data = *src_row++;
int extrabits = shift;
for (x = nx; x >= 5; x -= 5)
{
if (extrabits < 0)
{
data = (data << 8) | *src_row++;
extrabits += 8;
}
bfunc(dst_row, mask_row, data >> extrabits);
extrabits -= 5;
dst_row += pixel_height;
mask_row = 0x1F;
}
if (extrabits < 0)
{
data = (data << 8) | *src_row;
extrabits += 8;
}
bfunc(dst_row, mask_row & mask_right, data >> extrabits);
src += stride;
}
while (dst < dst_end);
}
/* Draw a full bitmap */
void pgfx_bitmap(const unsigned char *src, int x, int y, int width, int height)
{
pgfx_bitmap_part(src, 0, 0, width, x, y, width, height);
}

55
apps/plugins/lib/playergfx.h
View file

@ -1,55 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Bitmap graphics on player LCD!
*
* Copyright (C) 2005 Jens Arnold
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#ifndef __PGFX_H__
#define __PGFX_H__
#include "plugin.h"
#ifdef HAVE_LCD_CHARCELLS /* Player only :) */
bool pgfx_init(int cwidth, int cheight);
void pgfx_release(void);
void pgfx_display(int cx, int cy);
void pgfx_display_block(int cx, int cy, int x, int y);
void pgfx_update(void);
void pgfx_set_drawmode(int mode);
int pgfx_get_drawmode(void);
void pgfx_clear_display(void);
void pgfx_drawpixel(int x, int y);
void pgfx_drawline(int x1, int y1, int x2, int y2);
void pgfx_hline(int x1, int x2, int y);
void pgfx_vline(int x, int y1, int y2);
void pgfx_drawrect(int x, int y, int width, int height);
void pgfx_fillrect(int x, int y, int width, int height);
void pgfx_bitmap_part(const unsigned char *src, int src_x, int src_y,
int stride, int x, int y, int width, int height);
void pgfx_bitmap(const unsigned char *src, int x, int y, int width, int height);
#define pgfx_mono_bitmap_part pgfx_bitmap_part
#define pgfx_mono_bitmap pgfx_bitmap
#endif /* HAVE_LCD_CHARCELLS */
#endif /* __PGFX_H__ */

5
apps/plugins/lib/simple_viewer.c
View file

@ -64,17 +64,12 @@ static const char* get_next_line(const char *text, struct view_info *info)
total = 0;
while(*ptr)
{
#ifdef HAVE_LCD_CHARCELLS
n = rb->utf8seek(ptr, 1);
w = 1;
#else
unsigned short ch;
n = ((intptr_t)rb->utf8decode(ptr, &ch) - (intptr_t)ptr);
if (rb->is_diacritic(ch, NULL))
w = 0;
else
w = rb->font_get_width(info->pf, ch);
#endif
if (isbrchr(ptr, n))
space = ptr+(isspace(*ptr) || total + w <= info->vp.width? n: 0);
if (*ptr == '\n')

17
apps/plugins/logo.c
View file

@ -19,7 +19,6 @@
*
**************************************************************************/
#include "plugin.h"
#include "lib/playergfx.h"
#include "lib/pluginlib_actions.h"
/* this set the context to use with PLA */
@ -81,19 +80,9 @@ enum plugin_status plugin_start(const void* parameter) {
int y = (DISPLAY_HEIGHT / 2) - (LOGO_HEIGHT / 2);
int dx;
int dy;
#ifdef HAVE_LCD_CHARCELLS
int cpos = -1;
int old_cpos = -1;
#endif
(void)parameter;
#ifdef HAVE_LCD_CHARCELLS
if (!pgfx_init(4, 2)) {
rb->splash(HZ*2, "Old LCD :(");
return PLUGIN_OK;
}
#endif
rb->srand(*rb->current_tick);
dx = rb->rand()%(2*RAND_SCALE+1) - RAND_SCALE;
dy = rb->rand()%(2*RAND_SCALE+1) - RAND_SCALE;
@ -159,9 +148,6 @@ enum plugin_status plugin_start(const void* parameter) {
switch (button) {
case LP_QUIT:
case LP_QUIT2:
#ifdef HAVE_LCD_CHARCELLS
pgfx_release();
#endif
return PLUGIN_OK;
case LP_DEC_X:
case LP_DEC_X_REPEAT:
@ -184,9 +170,6 @@ enum plugin_status plugin_start(const void* parameter) {
default:
if (rb->default_event_handler(button) == SYS_USB_CONNECTED) {
#ifdef HAVE_LCD_CHARCELLS
pgfx_release();
#endif
return PLUGIN_USB_CONNECTED;
}
break;

53
apps/plugins/lrcplayer.c
View file

@ -144,11 +144,7 @@ static struct viewport vp_lyrics[NB_SCREENS];
#include "lib/pluginlib_actions.h"
#define LST_SET_TIME (LST_SET_MSEC|LST_SET_SEC|LST_SET_MIN|LST_SET_HOUR)
#ifdef HAVE_LCD_CHARCELLS
#define LST_OFF_Y 0
#else /* HAVE_LCD_BITMAP */
#define LST_OFF_Y 1
#endif
static int lrc_set_time(const char *title, const char *unit, long *pval,
int step, int min, int max, int flags)
{
@ -229,17 +225,11 @@ static int lrc_set_time(const char *title, const char *unit, long *pval,
rb->lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
rb->lcd_putsxy(x, y*(1+LST_OFF_Y), &buffer[p_start]);
rb->lcd_set_drawmode(DRMODE_SOLID);
#else
rb->lcd_put_cursor(x+rb->utf8length(&buffer[p_start])-1, y, 0x7F);
#endif
}
rb->lcd_update();
int button = pluginlib_getaction(TIMEOUT_BLOCK, lst_contexts, ARRAYLEN(lst_contexts));
int mult = 1;
#ifdef HAVE_LCD_CHARCELLS
if (pos_min != pos_max)
rb->lcd_remove_cursor();
#endif
switch (button)
{
case PLA_UP_REPEAT:
@ -452,9 +442,7 @@ static struct lrc_brpos *calc_brpos(struct lrc_line *lrc_line, int i)
int word_count, word_width;
const unsigned char *str;
}
#ifndef HAVE_LCD_CHARCELLS
sp,
#endif
cr;
lrc_buffer_used = (lrc_buffer_used+3)&~3; /* 4 bytes aligned */
@ -514,19 +502,15 @@ static struct lrc_brpos *calc_brpos(struct lrc_line *lrc_line, int i)
cr.nword = lrc_line->nword;
lrc_word = lrc_line->words+cr.nword;
cr.str = (lrc_word-1)->word;
#ifndef HAVE_LCD_CHARCELLS
sp.word_count = 0;
sp.word_width = 0;
sp.nword = 0;
sp.count = 0;
sp.width = 0;
#endif
do {
cr.count = 0;
cr.width = 0;
#ifndef HAVE_LCD_CHARCELLS
sp.str = NULL;
#endif
while (1)
{
@ -541,10 +525,6 @@ static struct lrc_brpos *calc_brpos(struct lrc_line *lrc_line, int i)
break;
int c, w;
#ifdef HAVE_LCD_CHARCELLS
c = rb->utf8seek(cr.str, 1);
w = 1;
#else
c = ((intptr_t)rb->utf8decode(cr.str, &ch) - (intptr_t)cr.str);
if (rb->is_diacritic(ch, NULL))
w = 0;
@ -576,7 +556,6 @@ static struct lrc_brpos *calc_brpos(struct lrc_line *lrc_line, int i)
}
break;
}
#endif
cr.count += c;
cr.width += w;
lrc_word->count += c;
@ -1916,38 +1895,6 @@ static void display_lrcs(void)
}
if (!lrc_line && ypos < vp_lyrics[i].height)
display->putsxy(0, ypos, "[end]");
#else /* HAVE_LCD_CHARCELLS */
struct lrc_line *lrc_line = lrc_center;
struct lrc_brpos *lrc_brpos = calc_brpos(lrc_line, i);
long elapsed = 0;
const char *str = get_lrc_str(lrc_line);
int x = vp_lyrics[i].width/2, y = 0;
if (rin >= 0 && len > 0)
{
elapsed = rin * lrc_center->width / len;
while (elapsed > lrc_brpos->width)
{
elapsed -= lrc_brpos->width;
str = lrc_skip_space(str+lrc_brpos->count);
lrc_brpos++;
}
}
rb->strlcpy(temp_buf, str, lrc_brpos->count+1);
x -= elapsed;
if (x < 0)
display->puts(0, y, temp_buf + rb->utf8seek(temp_buf, -x));
else
display->puts(x, y, temp_buf);
x += rb->utf8length(temp_buf)+1;
lrc_line = lrc_line->next;
if (!lrc_line && x < vp_lyrics[i].width)
{
if (x < vp_lyrics[i].width/2)
x = vp_lyrics[i].width/2;
display->puts(x, y, "[end]");
}
#endif /* HAVE_LCD_BITMAP */
display->update_viewport();
display->set_viewport(NULL);

5
apps/plugins/metronome.c
View file

@ -1022,12 +1022,7 @@ static void play_tock(void)
static void metronome_draw(struct screen* display, int state)
{
struct part *ps;
#ifndef HAVE_LCD_BITMAP
char beat1 = ' ';
char beat2 = ' ';
#else
int textlen = display->lcdwidth / display->getcharwidth();
#endif
ps = part;
display->clear_display();
#ifdef HAVE_LCD_BITMAP

15
apps/plugins/mosaique.c
View file

@ -19,7 +19,6 @@
*
**************************************************************************/
#include "plugin.h"
#include "lib/playergfx.h"
#include "lib/mylcd.h"
#include "lib/pluginlib_actions.h"
@ -59,14 +58,6 @@ enum plugin_status plugin_start(const void* parameter)
int sy = 3;
(void)parameter;
#ifdef HAVE_LCD_CHARCELLS
if (!pgfx_init(4, 2))
{
rb->splash(HZ*2, "Old LCD :(");
return PLUGIN_OK;
}
pgfx_display(3, 0);
#endif
mylcd_clear_display();
mylcd_set_drawmode(DRMODE_COMPLEMENT);
while (1) {
@ -117,9 +108,6 @@ enum plugin_status plugin_start(const void* parameter)
case MOSAIQUE_QUIT:
case MOSAIQUE_QUIT2:
mylcd_set_drawmode(DRMODE_SOLID);
#ifdef HAVE_LCD_CHARCELLS
pgfx_release();
#endif
return PLUGIN_OK;
case MOSAIQUE_SPEED:
@ -142,9 +130,6 @@ enum plugin_status plugin_start(const void* parameter)
if (rb->default_event_handler(button) == SYS_USB_CONNECTED)
{
mylcd_set_drawmode(DRMODE_SOLID);
#ifdef HAVE_LCD_CHARCELLS
pgfx_release();
#endif
return PLUGIN_USB_CONNECTED;
}
break;

2
apps/plugins/random_folder_advance_config.c
View file

@ -229,9 +229,7 @@ static void generate(void)
rb->splashf(HZ, "Couldnt open %s", RFA_FILE);
return;
}
#ifndef HAVE_LCD_CHARCELLS
update_screen(true);
#endif
lasttick = *rb->current_tick;
if(!custom_dir())

38
apps/plugins/rockblox.c
View file

@ -25,7 +25,6 @@
#include "lib/helper.h"
#include "lib/highscore.h"
#include "lib/playback_control.h"
#include "lib/playergfx.h"
#include "lib/mylcd.h"
@ -770,17 +769,8 @@
extern const fb_data rockblox_background[];
#else /* HAVE_LCD_CHARCELLS */
#define BOARD_HEIGHT 14
#define BLOCK_WIDTH 1
#define BLOCK_HEIGHT 1
#define BOARD_X 5
#define BOARD_Y 0
#define PREVIEW_X 15
#define PREVIEW_Y 1
#else
#error "lcd screen size not defined!"
#endif
#ifndef HIGHSCORE_SPACE
@ -992,10 +982,6 @@ static void show_details (void)
rb->lcd_putsxyf (LABEL_X, SCORE_Y, "%d", rockblox_status.score);
rb->lcd_putsxyf (LEVEL_X, LEVEL_Y, "%d", rockblox_status.level);
rb->lcd_putsxyf (LINES_X, LINES_Y, "%d", rockblox_status.lines);
#else /* HAVE_LCD_CHARCELLS */
rb->lcd_putsf (5, 0, "L%d/%d", rockblox_status.level,
rockblox_status.lines);
rb->lcd_putsf (5, 1, "S%d", rockblox_status.score);
#endif
}
@ -1066,15 +1052,6 @@ static void init_rockblox (bool resume)
#ifdef HAVE_LCD_BITMAP
rb->lcd_bitmap (rockblox_background, 0, 0, LCD_WIDTH, LCD_HEIGHT);
#else /* HAVE_LCD_CHARCELLS */
pgfx_display (0, 0);
pgfx_display_block (3, 0, 3, 1);
pgfx_display_block (4, 0, 3, 0);
rb->lcd_puts(4, 1, " ");
pgfx_clear_display();
pgfx_fillrect (3, 0, 2, 14);
pgfx_fillrect (15, 7, 2, 7);
pgfx_update();
#endif
if (!resume)
{
@ -1200,8 +1177,6 @@ static void refresh_board (void)
rb->lcd_hline (BOARD_X + i * BLOCK_WIDTH + 1,
BOARD_X + (i + 1) * BLOCK_WIDTH - 1,
BOARD_Y + (j + 1) * BLOCK_HEIGHT - 1);
#else /* HAVE_LCD_CHARCELLS */
pgfx_drawpixel (BOARD_X + i, BOARD_Y + j);
#endif
}
}
@ -1246,8 +1221,6 @@ static void refresh_board (void)
rb->lcd_hline (BOARD_X + x * BLOCK_WIDTH + 1,
BOARD_X + (x + 1) * BLOCK_WIDTH - 1,
BOARD_Y + (y + 1) * BLOCK_HEIGHT - 1);
#else /* HAVE_LCD_CHARCELLS */
pgfx_drawpixel (BOARD_X + x, BOARD_Y + y);
#endif
}
@ -1285,8 +1258,6 @@ static void refresh_board (void)
rb->lcd_hline (BOARD_X + x * BLOCK_WIDTH + 1,
BOARD_X + (x + 1) * BLOCK_WIDTH - 1,
BOARD_Y + (y + 1) * BLOCK_HEIGHT - 1);
#else /* HAVE_LCD_CHARCELLS */
pgfx_drawpixel (BOARD_X + x, BOARD_Y + y);
#endif
}
@ -1355,8 +1326,6 @@ static void draw_next_block (void)
rb->lcd_hline (PREVIEW_X + rx * BLOCK_WIDTH + 1,
PREVIEW_X + (rx + 1) * BLOCK_WIDTH - 1,
PREVIEW_Y + (ry + 1) * BLOCK_HEIGHT - 1);
#else /* HAVE_LCD_CHARCELLS */
pgfx_drawpixel (PREVIEW_X + rx, PREVIEW_Y + ry);
#endif
}
@ -1787,9 +1756,6 @@ enum plugin_status plugin_start (const void *parameter)
}
}
#ifndef HAVE_LCD_BITMAP
pgfx_release();
#endif
/* Save user's HighScore */
highscore_save(SCORE_FILE, highscores, NUM_SCORES);
backlight_use_settings();

19
apps/plugins/snow.c
View file

@ -19,7 +19,6 @@
*
**************************************************************************/
#include "plugin.h"
#include "lib/playergfx.h"
#include "lib/mylcd.h"
#include "lib/pluginlib_actions.h"
@ -143,11 +142,6 @@ static void snow_init(void)
particles[i][0]=-1;
particles[i][1]=-1;
}
#ifdef HAVE_LCD_CHARCELLS
pgfx_display(0, 0); /* display three times */
pgfx_display(4, 0);
pgfx_display(8, 0);
#endif
mylcd_clear_display();
#ifdef HAVE_REMOTE_LCD
rb->lcd_remote_clear_display();
@ -159,13 +153,6 @@ enum plugin_status plugin_start(const void* parameter)
int button;
(void)(parameter);
#ifdef HAVE_LCD_CHARCELLS
if (!pgfx_init(4, 2))
{
rb->splash(HZ*2, "Old LCD :(");
return PLUGIN_OK;
}
#endif
#ifdef HAVE_LCD_COLOR
rb->lcd_clear_display();
rb->lcd_set_foreground(LCD_WHITE);
@ -186,17 +173,11 @@ enum plugin_status plugin_start(const void* parameter)
if ((button == SNOW_QUIT) || (button == SNOW_QUIT2))
{
#ifdef HAVE_LCD_CHARCELLS
pgfx_release();
#endif
return PLUGIN_OK;
}
else
if (rb->default_event_handler(button) == SYS_USB_CONNECTED)
{
#ifdef HAVE_LCD_CHARCELLS
pgfx_release();
#endif
return PLUGIN_USB_CONNECTED;
}
}

5
apps/plugins/text_viewer/tv_display.c
View file

@ -69,11 +69,6 @@
#define TV_SCROLLBAR_WIDTH rb->global_settings->scrollbar_width
#define TV_SCROLLBAR_HEIGHT 4
#ifndef HAVE_LCD_BITMAP
#define TV_BOOKMARK_ICON 0xe101
#endif
struct tv_rect {
int x;
int y;

16
apps/screen_access.c
View file

@ -237,15 +237,6 @@ struct screen screens[NB_SCREENS] =
.scroll_step=&lcd_scroll_step,
#endif /* HAVE_LCD_BITMAP */
#ifdef HAVE_LCD_CHARCELLS
.double_height=&lcd_double_height,
.putchar=&lcd_putc,
.get_locked_pattern=&lcd_get_locked_pattern,
.define_pattern=&lcd_define_pattern,
.unlock_pattern=&lcd_unlock_pattern,
.icon=&lcd_icon,
#endif /* HAVE_LCD_CHARCELLS */
.putsxy=&lcd_putsxy,
.puts=&lcd_puts,
.putsf=&lcd_putsf,
@ -333,13 +324,6 @@ struct screen screens[NB_SCREENS] =
.scroll_step=&lcd_remote_scroll_step,
#endif /* 1 */
#if 0 /* no charcell remote LCDs so far */
.double_height=&lcd_remote_double_height,
.putc=&lcd_remote_putc,
.get_locked_pattern=&lcd_remote_get_locked_pattern,
.define_pattern=&lcd_remote_define_pattern,
.icon=&lcd_remote_icon,
#endif /* 0 */
.putsxy=&lcd_remote_putsxy,
.puts=&lcd_remote_puts,
.putsf=&lcd_remote_putsf,

13
apps/screen_access.h
View file

@ -37,10 +37,6 @@ void screen_helper_setfont(int font);
#define FOR_NB_SCREENS(i) for(int i = 0; i < NB_SCREENS; i++)
#ifdef HAVE_LCD_CHARCELLS
#define MAX_LINES_ON_SCREEN 2
#endif
typedef void screen_bitmap_part_func(const void *src, int src_x, int src_y,
int stride, int x, int y, int width, int height);
typedef void screen_bitmap_func(const void *src, int x, int y, int width,
@ -110,15 +106,6 @@ struct screen
void (*hline)(int x1, int x2, int y);
#endif /* HAVE_LCD_BITMAP || HAVE_REMOTE_LCD */
#ifdef HAVE_LCD_CHARCELLS /* no charcell remote LCDs so far */
void (*double_height)(bool on);
/* name it putchar, not putc because putc is a c library function */
void (*putchar)(int x, int y, unsigned long ucs);
void (*icon)(int icon, bool enable);
unsigned long (*get_locked_pattern)(void);
void (*define_pattern)(unsigned long ucs, const char *pattern);
void (*unlock_pattern)(unsigned long ucs);
#endif
void (*putsxy)(int x, int y, const unsigned char *str);
void (*puts)(int x, int y, const unsigned char *str);
void (*putsf)(int x, int y, const unsigned char *str, ...);

4
apps/screens.c
View file

@ -763,11 +763,7 @@ int view_runtime(void)
struct gui_synclist lists;
int action;
gui_synclist_init(&lists, runtime_get_data, NULL, false, 2, NULL);
#if !defined(HAVE_LCD_CHARCELLS)
gui_synclist_set_title(&lists, str(LANG_RUNNING_TIME), NOICON);
#else
gui_synclist_set_title(&lists, NULL, NOICON);
#endif
if(global_settings.talk_menu)
gui_synclist_set_voice_callback(&lists, runtime_speak_data);
gui_synclist_set_icon_callback(&lists, NULL);

28
apps/status.c
View file

@ -79,31 +79,3 @@ int current_playmode(void)
return STATUS_STOP;
}
#if defined(HAVE_LCD_CHARCELLS)
bool record = false;
bool audio = false;
bool param = false;
bool usb = false;
void status_set_record(bool b)
{
record = b;
}
void status_set_audio(bool b)
{
audio = b;
}
void status_set_param(bool b)
{
param = b;
}
void status_set_usb(bool b)
{
usb = b;
}
#endif /* HAVE_LCD_CHARCELLS */

13
apps/status.h
View file

@ -21,13 +21,6 @@
#ifndef _STATUS_H
#define _STATUS_H
#if defined(HAVE_LCD_CHARCELLS)
extern bool record;
extern bool audio;
extern bool param;
extern bool usb;
#endif
enum playmode
{
STATUS_PLAY,
@ -48,11 +41,5 @@ int current_playmode(void);
#if (CONFIG_PLATFORM & PLATFORM_HOSTED)
#include <time.h>
#endif
#ifdef HAVE_LCD_CHARCELLS
void status_set_record(bool b);
void status_set_audio(bool b);
void status_set_param(bool b);
void status_set_usb(bool b);
#endif /* HAVE_LCD_CHARCELLS */
#endif /* _STATUS_H */

8
apps/tree.c
View file

@ -299,10 +299,6 @@ void tree_gui_init(void)
strcpy(tc.currdir, "/");
#ifdef HAVE_LCD_CHARCELLS
FOR_NB_SCREENS(i)
screens[i].double_height(false);
#endif
gui_synclist_init(&tree_lists, &tree_get_filename, &tc, false, 1, NULL);
gui_synclist_set_voice_callback(&tree_lists, tree_voice_cb);
gui_synclist_set_icon_callback(&tree_lists,
@ -710,14 +706,12 @@ static int dirbrowse(void)
if ((*tc.dirfilter == SHOW_ID3DB && tc.dirlevel == 0) ||
((*tc.dirfilter != SHOW_ID3DB && !strcmp(currdir,"/"))))
{
#ifdef HAVE_LCD_BITMAP /* charcell doesnt have ACTION_TREE_PGLEFT so this isnt needed */
if (oldbutton == ACTION_TREE_PGLEFT)
break;
else
#endif
return GO_TO_ROOT;
}
#ifdef HAVE_TAGCACHE
if (id3db)
tagtree_exit(&tc);

130
docs/PLUGIN_API
View file

@ -185,7 +185,7 @@ unsigned int battery_voltage(void)
\description
unsigned short *bidi_l2v( const unsigned char *str, int orientation )
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param str
\param orientation
\return
@ -353,7 +353,7 @@ bool button_hold(void)
\description
struct event_queue *button_queue
\conditions !defined(HAVE_LCD_CHARCELLS) )) && (defined(HAVE_LCD_ENABLE
\conditions defined(HAVE_LCD_BITMAP) )) && (defined(HAVE_LCD_ENABLE
\return
\description
@ -372,7 +372,7 @@ void cancel_cpu_boost(void)
\description Unboosts the CPU for the current thread
const unsigned char *font_get_bits( struct font *pf, unsigned short char_code )
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param pf
\param char_code
\return
@ -628,14 +628,14 @@ void flush_icache(void)
\description
struct font* font_get(int font)
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param font
\return the font structure for =font=
\description If the requested font isn't loaded/compiled-in, decrement the font number and try again.
\see [S[firmware/export/font.h]]
int font_getstringsize(const unsigned char *str, int *w, int *h, int fontnumber)
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param str
\param w
\param h
@ -644,14 +644,14 @@ int font_getstringsize(const unsigned char *str, int *w, int *h, int fontnumber)
\description
int font_get_width(struct font* pf, unsigned short char_code)
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param pf
\param char_code
\return
\description
struct font* font_load(const char *path)
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param path
\return
\description Load font =path= and returns a struct font pointer for it
@ -707,7 +707,7 @@ struct system_status *global_status
\see [S[apps/settings.h]]
void gui_scrollbar_draw(struct screen * screen, int x, int y, int width, int height, int items, int min_shown, int max_shown, unsigned flags)
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param screen
\param x
\param y
@ -837,7 +837,7 @@ int kbd_input(char* buffer, int buflen)
void lcd_bitmap(const fb_data *src, int x, int y, int width, int height)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS) && (LCD_DEPTH > 1)
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH > 1)
\param src
\param x
\param y
@ -847,7 +847,7 @@ void lcd_bitmap(const fb_data *src, int x, int y, int width, int height)
void lcd_bitmap_part(const fb_data *src, int src_x, int src_y, int stride, int x, int y, int width, int height)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS) && (LCD_DEPTH > 1)
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH > 1)
\param src
\param src_x
\param src_y
@ -860,7 +860,7 @@ void lcd_bitmap_part(const fb_data *src, int src_x, int src_y, int stride, int x
void lcd_bitmap_transparent(const fb_data *src, int x, int y, int width, int height)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS) && (LCD_DEPTH == 16)
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH == 16)
\param src
\param x
\param y
@ -870,7 +870,7 @@ void lcd_bitmap_transparent(const fb_data *src, int x, int y, int width, int hei
void lcd_bitmap_transparent_part(const fb_data *src, int src_x, int src_y, int stride, int x, int y, int width, int height)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS) && (LCD_DEPTH == 16)
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH == 16)
\param src
\param src_x
\param src_y
@ -883,7 +883,7 @@ void lcd_bitmap_transparent_part(const fb_data *src, int src_x, int src_y, int s
void lcd_blit_grey_phase(unsigned char *values, unsigned char *phases, int bx, int by, int bwidth, int bheight, int stride)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS) )) && ((LCD_DEPTH < 4) && !defined(SIMULATOR
\conditions defined(HAVE_LCD_BITMAP) )) && ((LCD_DEPTH < 4) && !defined(SIMULATOR
\param values
\param phases
\param bx
@ -895,7 +895,7 @@ void lcd_blit_grey_phase(unsigned char *values, unsigned char *phases, int bx, i
void lcd_blit_mono(const unsigned char *data, int x, int by, int width, int bheight, int stride)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS) )) && ((LCD_DEPTH < 4) && !defined(SIMULATOR
\conditions defined(HAVE_LCD_BITMAP) )) && ((LCD_DEPTH < 4) && !defined(SIMULATOR
\param data
\param x
\param by
@ -906,7 +906,7 @@ void lcd_blit_mono(const unsigned char *data, int x, int by, int width, int bhei
void lcd_blit_yuv(unsigned char * const src[3], int src_x, int src_y, int stride, int x, int y, int width, int height)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS) && (LCD_DEPTH == 16)
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH == 16)
\param src[3]
\param src_x
\param src_y
@ -921,22 +921,9 @@ void lcd_clear_display(void)
\group lcd
\description Clears the LCD and the framebuffer
void lcd_define_pattern(unsigned long ucs, const char *pattern)
\group lcd
\conditions (defined(HAVE_LCD_CHARCELLS))
\param ucs
\param pattern is a 8x8 pixelbitmap
\description Define a custom pattern for index =ucs=
void lcd_double_height(bool on)
\group lcd
\conditions (defined(HAVE_LCD_CHARCELLS))
\param on
\description
void lcd_drawline(int x1, int y1, int x2, int y2)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param x1 X top coordinate
\param y1 Y top coordinate
\param x2 X bottom coordinate
@ -945,14 +932,14 @@ void lcd_drawline(int x1, int y1, int x2, int y2)
void lcd_drawpixel(int x, int y)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param x
\param y
\description Draws a pixel at (=x=, =y=) within current drawing mode
void lcd_drawrect(int x, int y, int width, int height)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param x
\param y
\param width
@ -961,7 +948,7 @@ void lcd_drawrect(int x, int y, int width, int height)
void lcd_fillrect(int x, int y, int width, int height)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param x
\param y
\param width
@ -970,7 +957,7 @@ void lcd_fillrect(int x, int y, int width, int height)
fb_data* lcd_framebuffer
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\return
\description Pointer to the framebuffer
\see [S[firmware/export/lcd.h]]
@ -985,55 +972,40 @@ int lcd_getstringsize(const unsigned char *str, int *w, int *h)
fb_data* lcd_get_backdrop(void)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS) && (LCD_DEPTH > 1)
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH > 1)
\return Pointer to framebuffer data
\description Gets the current backdrop
\see lcd_framebuffer
unsigned lcd_get_background(void)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS) && (LCD_DEPTH > 1)
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH > 1)
\return
\description
int lcd_get_drawmode(void)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\return current LCD drawing mode
\description
unsigned lcd_get_foreground(void)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS) && (LCD_DEPTH > 1)
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH > 1)
\return
\description
unsigned long lcd_get_locked_pattern(void)
\group lcd
\conditions (defined(HAVE_LCD_CHARCELLS))
\return
\description Get a locked pattern index
\see [S[firmware/drivers/lcd-player.c]]
void lcd_hline(int x1, int x2, int y)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param x1 X start coordinate
\param x2 X end coordinate
\param y Y coordinate
\description Draws a horizontal line at (=x1=, =y=) -> (=x2=, =y=) within current drawing mode
void lcd_icon(int icon, bool enable)
\group lcd
\conditions (defined(HAVE_LCD_CHARCELLS))
\param icon
\param enable
\description
\see [S[firmware/drivers/lcd-player.c]]
void lcd_mono_bitmap(const unsigned char *src, int x, int y, int width, int height)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param src
\param x
\param y
@ -1043,7 +1015,7 @@ void lcd_mono_bitmap(const unsigned char *src, int x, int y, int width, int heig
void lcd_mono_bitmap_part(const unsigned char *src, int src_x, int src_y, int stride, int x, int y, int width, int height)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param src
\param src_x
\param src_y
@ -1054,14 +1026,6 @@ void lcd_mono_bitmap_part(const unsigned char *src, int src_x, int src_y, int st
\param height
\description
void lcd_putc(int x, int y, unsigned long ucs)
\group lcd
\conditions (defined(HAVE_LCD_CHARCELLS))
\param x
\param y
\param ucs
\description Put character =ucs= at coordinates (=x=, =y=)
void lcd_puts(int x, int y, const unsigned char *string)
\group lcd
\param x Row X
@ -1083,15 +1047,6 @@ void lcd_puts_scroll(int x, int y, const unsigned char* string)
\param string
\description Puts scrolling string on the LCD at row =x= and column =y=. The scrolling style is STYLE_DEFAULT.
void lcd_put_cursor(int x, int y, unsigned long ucs)
\group lcd
\conditions (defined(HAVE_LCD_CHARCELLS))
\param x
\param y
\param ucs
\description Put cursor at coordinates (=x=, =y=)
\see [S[firmware/export/lcd.h]]
void lcd_remote_bitmap(const fb_remote_data *src, int x, int y, int width, int height)
\conditions (defined(HAVE_REMOTE_LCD) && (LCD_REMOTE_DEPTH > 1))
\param src
@ -1302,27 +1257,22 @@ void lcd_remote_vline(int x, int y1, int y2)
\param y2
\description
void lcd_remove_cursor(void)
\group lcd
\conditions (defined(HAVE_LCD_CHARCELLS))
\description Remove the cursor from the screen
void lcd_setfont(int font)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param font
\description Set default font
void lcd_set_backdrop(fb_data* backdrop)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS) && (LCD_DEPTH > 1)
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH > 1)
\param backdrop Pointer to backdrop image
\description Set the backdrop to =backdrop=
\see lcd_framebuffer
void lcd_set_background(unsigned foreground)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS) && (LCD_DEPTH > 1)
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH > 1)
\param foreground
\description
@ -1333,19 +1283,19 @@ void lcd_set_contrast(int x)
void lcd_set_drawmode(int mode)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param mode
\description
void lcd_set_foreground(unsigned foreground)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS) && (LCD_DEPTH > 1)
\conditions defined(HAVE_LCD_BITMAP) && (LCD_DEPTH > 1)
\param foreground
\description
void lcd_set_invert_display(bool yesno)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS) )) && (defined(HAVE_LCD_INVERT
\conditions defined(HAVE_LCD_BITMAP) )) && (defined(HAVE_LCD_INVERT
\param yesno
\description
@ -1353,19 +1303,13 @@ void lcd_stop_scroll(void)
\group lcd
\description Stop all scrolling lines on the screen
void lcd_unlock_pattern(unsigned long ucs)
\group lcd
\conditions (defined(HAVE_LCD_CHARCELLS))
\param ucs
\description Unlock pattern of index =ucs=
void lcd_update(void)
\group lcd
\description Pushes LCD framebuffer changes to the LCD
void lcd_update_rect(int x, int y, int width, int height)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param x measured in pixels
\param y measured in pixels
\param width measured in pixels
@ -1374,7 +1318,7 @@ void lcd_update_rect(int x, int y, int width, int height)
void lcd_vline(int x, int y1, int y2)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param x X coordinate
\param y1 Y start coordinate
\param y2 Y end coordinate
@ -1382,7 +1326,7 @@ void lcd_vline(int x, int y1, int y2)
void lcd_yuv_set_options(unsigned options)
\group lcd
\conditions !defined(HAVE_LCD_CHARCELLS) )) && (LCD_DEPTH == 16) && (defined(TOSHIBA_GIGABEAT_F) || defined(SANSA_E200) || defined(SANSA_C200) || defined(IRIVER_H10) || defined(COWON_D2
\conditions defined(HAVE_LCD_BITMAP) )) && (LCD_DEPTH == 16) && (defined(TOSHIBA_GIGABEAT_F) || defined(SANSA_E200) || defined(SANSA_C200) || defined(IRIVER_H10) || defined(COWON_D2
\param options
\description
@ -1932,7 +1876,7 @@ struct screen* screens[NB_SCREENS]
\description
void screen_clear_area(struct screen * display, int xstart, int ystart, int width, int height)
\conditions !defined(HAVE_LCD_CHARCELLS)
\conditions defined(HAVE_LCD_BITMAP)
\param display
\param xstart
\param ystart

7
firmware/SOURCES
View file

@ -52,8 +52,6 @@ target/hosted/sdl/button-sdl.c
target/hosted/sdl/kernel-sdl.c
#ifdef HAVE_LCD_BITMAP
target/hosted/sdl/lcd-bitmap.c
#elif defined(HAVE_LCD_CHARCELLS)
target/hosted/sdl/lcd-charcells.c
#endif
#ifdef HAVE_REMOTE_LCD
target/hosted/sdl/lcd-remote-bitmap.c
@ -255,11 +253,6 @@ common/vuprintf.c
/* Display */
scroll_engine.c
#ifdef HAVE_LCD_CHARCELLS
drivers/lcd-charcell.c
drivers/lcd-charset-player.c
#endif /* HAVE_LCD_CHARCELLS */
#ifdef HAVE_LCD_BITMAP
arabjoin.c
bidi.c

599
firmware/drivers/lcd-charcell.c
View file

@ -1,599 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2007 by Jens Arnold
* Based on the work of Alan Korr, Kjell Ericson and others
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include <stdio.h>
#include "config.h"
#include "hwcompat.h"
#include "stdarg.h"
#include "lcd.h"
#include "kernel.h"
#include "thread.h"
#include "string-extra.h"
#include <stdlib.h>
#include "debug.h"
#include "file.h"
#include "system.h"
#include "lcd-charcell.h"
#include "rbunicode.h"
#include "scroll_engine.h"
/** definitions **/
#define VARIABLE_XCHARS 16 /* number of software user-definable characters */
/* There must be mappings for this many characters in the 0xe000 unicode range
* in lcd-charset-<target>.c */
#define NO_PATTERN (-1)
static int find_xchar(unsigned long ucs);
/** globals **/
unsigned char lcd_charbuffer[LCD_HEIGHT][LCD_WIDTH]; /* The "frame"buffer */
static unsigned char lcd_substbuffer[LCD_HEIGHT][LCD_WIDTH];
struct pattern_info lcd_patterns[MAX_HW_PATTERNS];
struct cursor_info lcd_cursor;
static unsigned char xfont_variable[VARIABLE_XCHARS][HW_PATTERN_SIZE];
static bool xfont_variable_locked[VARIABLE_XCHARS];
static int xspace; /* stores xhcar id of ' ' - often needed */
static struct viewport default_vp =
{
.x = 0,
.y = 0,
.width = LCD_WIDTH,
.height = LCD_HEIGHT,
};
static struct viewport* current_vp = &default_vp;
/* LCD init */
void lcd_init (void)
{
lcd_init_device();
lcd_charset_init();
memset(lcd_patterns, 0, sizeof(lcd_patterns));
xspace = find_xchar(' ');
memset(lcd_charbuffer, xchar_info[xspace].hw_char, sizeof(lcd_charbuffer));
scroll_init();
}
/* Viewports */
void lcd_set_viewport(struct viewport* vp)
{
if (vp == NULL)
current_vp = &default_vp;
else
current_vp = vp;
#if defined(SIMULATOR)
/* Force the viewport to be within bounds. If this happens it should
* be considered an error - the viewport will not draw as it might be
* expected.
*/
if((unsigned) current_vp->x > (unsigned) LCD_WIDTH
|| (unsigned) current_vp->y > (unsigned) LCD_HEIGHT
|| current_vp->x + current_vp->width > LCD_WIDTH
|| current_vp->y + current_vp->height > LCD_HEIGHT)
{
#if !defined(HAVE_VIEWPORT_CLIP)
DEBUGF("ERROR: "
#else
DEBUGF("NOTE: "
#endif
"set_viewport out of bounds: x: %d y: %d width: %d height:%d\n",
current_vp->x, current_vp->y,
current_vp->width, current_vp->height);
}
#endif
}
struct viewport *lcd_get_viewport(bool *is_default)
{
*is_default = (current_vp == &default_vp);
return current_vp;
}
void lcd_update_viewport(void)
{
lcd_update();
}
void lcd_update_viewport_rect(int x, int y, int width, int height)
{
(void) x;
(void) y;
(void) width;
(void) height;
lcd_update();
}
/** parameter handling **/
int lcd_getwidth(void)
{
return current_vp->width;
}
int lcd_getheight(void)
{
return current_vp->height;
}
int lcd_getstringsize(const unsigned char *str, int *w, int *h)
{
int width = utf8length(str);
if (w)
*w = width;
if (h)
*h = 1;
return width;
}
/** low-level functions **/
static int find_xchar(unsigned long ucs)
{
int low = 0;
int high = xchar_info_size - 1;
do
{
int probe = (low + high) >> 1;
if (xchar_info[probe].ucs < ucs)
low = probe + 1;
else if (xchar_info[probe].ucs > ucs)
high = probe - 1;
else
return probe;
}
while (low <= high);
/* Not found: return index of no-char symbol (last symbol, hardcoded). */
return xchar_info_size - 1;
}
static int glyph_to_pat(unsigned glyph)
{
int i;
for (i = 0; i < lcd_pattern_count; i++)
if (lcd_patterns[i].glyph == glyph)
return i;
return NO_PATTERN;
}
static void lcd_free_pat(int pat)
{
int x, y;
if (pat != NO_PATTERN)
{
for (x = 0; x < LCD_WIDTH; x++)
for (y = 0; y < LCD_HEIGHT; y++)
if (pat == lcd_charbuffer[y][x])
lcd_charbuffer[y][x] = lcd_substbuffer[y][x];
if (lcd_cursor.enabled && pat == lcd_cursor.hw_char)
lcd_cursor.hw_char = lcd_cursor.subst_char;
lcd_patterns[pat].count = 0;
}
}
static int lcd_get_free_pat(int xchar)
{
static int last_used_pat = 0;
int pat = last_used_pat; /* start from last used pattern */
int least_pat = pat; /* pattern with least priority */
int least_priority = lcd_patterns[pat].priority;
int i;
for (i = 0; i < lcd_pattern_count; i++)
{
if (++pat >= lcd_pattern_count) /* Keep 'pat' within limits */
pat = 0;
if (lcd_patterns[pat].count == 0)
{
last_used_pat = pat;
return pat;
}
if (lcd_patterns[pat].priority < least_priority)
{
least_priority = lcd_patterns[pat].priority;
least_pat = pat;
}
}
if (xchar_info[xchar].priority > least_priority) /* prioritized char */
{
lcd_free_pat(least_pat);
last_used_pat = least_pat;
return least_pat;
}
return NO_PATTERN;
}
static const unsigned char *glyph_to_pattern(unsigned glyph)
{
if (glyph & 0x8000)
return xfont_variable[glyph & 0x7fff];
else
return xfont_fixed[glyph];
}
static int map_xchar(int xchar, unsigned char *substitute)
{
int pat;
unsigned glyph;
if (xchar_info[xchar].priority > 0) /* soft char */
{
glyph = xchar_info[xchar].glyph;
pat = glyph_to_pat(glyph);
if (pat == NO_PATTERN) /* not yet mapped */
{
pat = lcd_get_free_pat(xchar); /* try to map */
if (pat == NO_PATTERN) /* failed: just use substitute */
return xchar_info[xchar].hw_char;
else
{ /* define pattern */
lcd_patterns[pat].priority = xchar_info[xchar].priority;
lcd_patterns[pat].glyph = glyph;
memcpy(lcd_patterns[pat].pattern, glyph_to_pattern(glyph),
HW_PATTERN_SIZE);
}
}
lcd_patterns[pat].count++; /* increase reference count */
*substitute = xchar_info[xchar].hw_char;
return pat;
}
else /* hardware char */
return xchar_info[xchar].hw_char;
}
static void lcd_putxchar(int x, int y, int xchar)
{
int lcd_char;
/* Adjust for viewport */
x += current_vp->x;
y += current_vp->y;
#if defined(HAVE_VIEWPORT_CLIP)
if((unsigned)x > (unsigned)LCD_WIDTH || (unsigned)y > (unsigned)LCD_HEIGHT)
return;
#endif
lcd_char = lcd_charbuffer[y][x];
if (lcd_char < lcd_pattern_count) /* old char was soft */
lcd_patterns[lcd_char].count--; /* decrease old reference count */
lcd_charbuffer[y][x] = map_xchar(xchar, &lcd_substbuffer[y][x]);
}
/** user-definable pattern handling **/
unsigned long lcd_get_locked_pattern(void)
{
int i = 0;
for (i = 0; i < VARIABLE_XCHARS; i++)
{
if (!xfont_variable_locked[i])
{
xfont_variable_locked[i] = true;
return 0xe000 + i; /* hard-coded */
}
}
return 0;
}
void lcd_unlock_pattern(unsigned long ucs)
{
int xchar = find_xchar(ucs);
unsigned glyph = xchar_info[xchar].glyph;
if (glyph & 0x8000) /* variable extended char */
{
lcd_free_pat(glyph_to_pat(glyph));
xfont_variable_locked[glyph & 0x7fff] = false;
}
}
void lcd_define_pattern(unsigned long ucs, const char *pattern)
{
int xchar = find_xchar(ucs);
unsigned glyph = xchar_info[xchar].glyph;
int pat;
if (glyph & 0x8000) /* variable extended char */
{
memcpy(xfont_variable[glyph & 0x7fff], pattern, HW_PATTERN_SIZE);
pat = glyph_to_pat(glyph);
if (pat != NO_PATTERN)
memcpy(lcd_patterns[pat].pattern, pattern, HW_PATTERN_SIZE);
}
}
/** output functions **/
/* Clear the whole display */
void lcd_clear_display(void)
{
int x, y;
struct viewport* old_vp = current_vp;
lcd_scroll_stop();
lcd_remove_cursor();
/* Set the default viewport - required for lcd_putxchar */
current_vp = &default_vp;
for (x = 0; x < LCD_WIDTH; x++)
for (y = 0; y < LCD_HEIGHT; y++)
lcd_putxchar(x, y, xspace);
current_vp = old_vp;
}
/* Clear the current viewport */
void lcd_clear_viewport(void)
{
int x, y;
if (current_vp == &default_vp)
{
lcd_clear_display();
}
else
{
/* Remove the cursor if it is within the current viewport */
if (lcd_cursor.enabled &&
(lcd_cursor.x >= current_vp->x) &&
(lcd_cursor.x <= current_vp->x + current_vp->width) &&
(lcd_cursor.y >= current_vp->y) &&
(lcd_cursor.y <= current_vp->y + current_vp->height))
{
lcd_remove_cursor();
}
for (x = 0; x < current_vp->width; x++)
for (y = 0; y < current_vp->height; y++)
lcd_putxchar(x, y, xspace);
lcd_scroll_stop_viewport(current_vp);
}
}
/* Put an unicode character at the given position */
void lcd_putc(int x, int y, unsigned long ucs)
{
if ((unsigned)x >= (unsigned)current_vp->width ||
(unsigned)y >= (unsigned)current_vp->height)
return;
lcd_putxchar(x, y, find_xchar(ucs));
}
/* Show cursor (alternating with existing character) at the given position */
void lcd_put_cursor(int x, int y, unsigned long cursor_ucs)
{
if ((unsigned)x >= (unsigned)current_vp->width ||
(unsigned)y >= (unsigned)current_vp->height ||
lcd_cursor.enabled)
return;
lcd_cursor.enabled = true;
lcd_cursor.visible = false;
lcd_cursor.hw_char = map_xchar(find_xchar(cursor_ucs), &lcd_cursor.subst_char);
lcd_cursor.x = current_vp->x + x;
lcd_cursor.y = current_vp->y + y;
lcd_cursor.downcount = 0;
lcd_cursor.divider = MAX((HZ/2) / lcd_scroll_info.ticks, 1);
}
/* Remove the cursor */
void lcd_remove_cursor(void)
{
if (lcd_cursor.enabled)
{
if (lcd_cursor.hw_char < lcd_pattern_count) /* soft char, unmap */
lcd_patterns[lcd_cursor.hw_char].count--;
lcd_cursor.enabled = lcd_cursor.visible = false;
}
}
/* Put a string at a given position, skipping first ofs chars */
static int lcd_putsxyofs(int x, int y, int ofs, const unsigned char *str)
{
unsigned short ucs;
const unsigned char *utf8 = str;
while (*utf8 && x < current_vp->width)
{
utf8 = utf8decode(utf8, &ucs);
if (ofs > 0)
{
ofs--;
continue;
}
lcd_putxchar(x++, y, find_xchar(ucs));
}
return x;
}
/* Put a string at a given position */
void lcd_putsxy(int x, int y, const unsigned char *str)
{
if ((unsigned)y >= (unsigned)current_vp->height)
return;
lcd_putsxyofs(x, y, 0, str);
}
/* Formatting version of lcd_putsxy */
void lcd_putsxyf(int x, int y, const unsigned char *fmt, ...)
{
va_list ap;
char buf[256];
va_start(ap, fmt);
vsnprintf(buf, sizeof (buf), fmt, ap);
va_end(ap);
lcd_putsxy(x, y, buf);
}
/*** Line oriented text output ***/
/* Put a string at a given char position, skipping first offset chars */
void lcd_putsofs(int x, int y, const unsigned char *str, int offset)
{
if ((unsigned)y >= (unsigned)current_vp->height)
return;
/* make sure scrolling is turned off on the line we are updating */
lcd_scroll_stop_viewport_rect(current_vp, x, y, current_vp->width - x, 1);
x = lcd_putsxyofs(x, y, offset, str);
while (x < current_vp->width)
lcd_putxchar(x++, y, xspace);
}
/* Put a string at a given char position */
void lcd_puts(int x, int y, const unsigned char *str)
{
lcd_putsofs(x, y, str, 0);
}
/* Formatting version of lcd_puts */
void lcd_putsf(int x, int y, const unsigned char *fmt, ...)
{
va_list ap;
char buf[256];
va_start(ap, fmt);
vsnprintf(buf, sizeof (buf), fmt, ap);
va_end(ap);
lcd_puts(x, y, buf);
}
/** scrolling **/
bool lcd_puts_scroll_worker(int x, int y, const unsigned char *string,
int offset,
void (*scroll_func)(struct scrollinfo *), void *data)
{
struct scrollinfo* s;
int len;
if ((unsigned)y >= (unsigned)current_vp->height)
return false;
/* remove any previously scrolling line at the same location */
lcd_scroll_stop_viewport_rect(current_vp, x, y, current_vp->width - x, 1);
if (lcd_scroll_info.lines >= LCD_SCROLLABLE_LINES)
return false;
s = &lcd_scroll_info.scroll[lcd_scroll_info.lines];
s->start_tick = current_tick + lcd_scroll_info.delay;
lcd_putsofs(x, y, string, offset);
len = utf8length(string);
if (current_vp->width - x >= len)
return false;
/* prepare scroll line */
strlcpy(s->linebuffer, string, sizeof s->linebuffer);
/* scroll bidirectional or forward only depending on the string width */
if (lcd_scroll_info.bidir_limit)
{
s->bidir = len < (current_vp->width) *
(100 + lcd_scroll_info.bidir_limit) / 100;
}
else
s->bidir = false;
s->scroll_func = scroll_func;
s->userdata = data;
s->vp = current_vp;
s->x = x;
s->y = y;
s->height = 1;
s->width = current_vp->width - x;
s->offset = offset;
s->backward = false;
lcd_scroll_info.lines++;
return true;
}
bool lcd_putsxy_scroll_func(int x, int y, const unsigned char *string,
void (*scroll_func)(struct scrollinfo *),
void *data, int x_offset)
{
bool retval = false;
if (!scroll_func)
lcd_putsxyofs(x, y, x_offset, string);
else
retval = lcd_puts_scroll_worker(x, y, string, x_offset, scroll_func, data);
return retval;
}
static void lcd_scroll_fn(struct scrollinfo* s)
{
/* with line == NULL when scrolling stops. This scroller
* maintains no userdata so there is nothing left to do */
if (!s->line)
return;
lcd_putsxyofs(s->x, s->y, s->offset, s->line);
if (lcd_cursor.enabled)
{
if (--lcd_cursor.downcount <= 0)
{
lcd_cursor.downcount = lcd_cursor.divider;
lcd_cursor.visible = !lcd_cursor.visible;
}
}
}
bool lcd_puts_scroll(int x, int y, const unsigned char *string)
{
return lcd_puts_scroll_worker(x, y, string, 0, lcd_scroll_fn, NULL);
}

1321
firmware/drivers/lcd-charset-player.c
View file

File diff suppressed because it is too large Load diff

17
firmware/drivers/lcd-scroll.c
View file

@ -42,10 +42,6 @@ struct scroll_screen_info LCDFN(scroll_info) =
#ifdef HAVE_LCD_BITMAP
.step = 6,
#endif
#ifdef HAVE_LCD_CHARCELLS
.jump_scroll_delay = HZ/4,
.jump_scroll = 0,
#endif
};
@ -121,17 +117,6 @@ void LCDFN(bidir_scroll)(int percent)
LCDFN(scroll_info).bidir_limit = percent;
}
#ifdef HAVE_LCD_CHARCELLS
void LCDFN(jump_scroll)(int mode) /* 0=off, 1=once, ..., JUMP_SCROLL_ALWAYS */
{
LCDFN(scroll_info).jump_scroll = mode;
}
void LCDFN(jump_scroll_delay)(int ms)
{
LCDFN(scroll_info).jump_scroll_delay = ms / (HZ / 10);
}
#endif
/* This renders the scrolling line described by s immediatly.
* This can be called to update a scrolling line if the text has changed
@ -201,7 +186,7 @@ bool LCDFN(scroll_now)(struct scrollinfo *s)
return ended;
}
#if !defined(BOOTLOADER) || defined(HAVE_REMOTE_LCD) || defined(HAVE_LCD_CHARCELLS)
#if !defined(BOOTLOADER) || defined(HAVE_REMOTE_LCD)
static void LCDFN(scroll_worker)(void)
{
int index;

68
firmware/export/lcd-charcell.h
View file

@ -1,68 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2007 by Jens Arnold
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "config.h"
/* target dependent - to be adjusted for other charcell targets */
#define HW_PATTERN_SIZE 7 /* number of bytes per pattern */
#define MAX_HW_PATTERNS 8 /* max. number of user-definable hw patterns */
struct cursor_info {
unsigned char hw_char;
unsigned char subst_char;
bool enabled;
bool visible;
int x;
int y;
int divider;
int downcount;
};
/* map unicode characters to hardware or extended lcd characters */
struct xchar_info {
unsigned short ucs;
unsigned short glyph;
/* 0x0000..0x7fff: fixed extended characters
* 0x8000..0xffff: variable extended characters
* Dontcare if priority == 0 */
unsigned char priority;
unsigned char hw_char; /* direct or substitute */
};
/* track usage of user-definable characters */
struct pattern_info {
short count;
unsigned short glyph;
unsigned char priority;
unsigned char pattern[HW_PATTERN_SIZE];
};
extern int lcd_pattern_count; /* actual number of user-definable hw patterns */
extern unsigned char lcd_charbuffer[LCD_HEIGHT][LCD_WIDTH];
extern struct pattern_info lcd_patterns[MAX_HW_PATTERNS];
extern struct cursor_info lcd_cursor;
extern const struct xchar_info *xchar_info;
extern int xchar_info_size; /* number of entries */
extern const unsigned char xfont_fixed[][HW_PATTERN_SIZE];
void lcd_charset_init(void);

40
firmware/export/lcd.h
View file

@ -144,9 +144,6 @@ typedef unsigned long fb_data;
#endif
#define FB_DATA_SZ 4
#endif /* LCD_DEPTH */
#else /* LCD_CHARCELLS */
typedef unsigned char fb_data;
#endif
#if defined(HAVE_LCD_MODES)
@ -226,43 +223,6 @@ extern void lcd_remote_update_rect(int x, int y, int width, int height);
#endif /* HAVE_REMOTE_LCD */
#endif /* HAVE_LCD_BITMAP */
#ifdef HAVE_LCD_CHARCELLS
/* Icon definitions for lcd_icon() */
enum
{
ICON_BATTERY = 0,
ICON_BATTERY_1,
ICON_BATTERY_2,
ICON_BATTERY_3,
ICON_USB,
ICON_PLAY,
ICON_RECORD,
ICON_PAUSE,
ICON_AUDIO,
ICON_REPEAT,
ICON_1,
ICON_VOLUME,
ICON_VOLUME_1,
ICON_VOLUME_2,
ICON_VOLUME_3,
ICON_VOLUME_4,
ICON_VOLUME_5,
ICON_PARAM
};
void lcd_icon(int icon, bool enable);
void lcd_double_height(bool on);
void lcd_define_pattern(unsigned long ucs, const char *pattern);
unsigned long lcd_get_locked_pattern(void);
void lcd_unlock_pattern(unsigned long ucs);
void lcd_put_cursor(int x, int y, unsigned long cursor_ucs);
void lcd_remove_cursor(void);
#define JUMP_SCROLL_ALWAYS 5
extern void lcd_jump_scroll(int mode); /* 0=off, 1=once, ..., ALWAYS */
extern void lcd_jump_scroll_delay(int ms);
#endif /* HAVE_LCD_CHARCELLS */
/* Bitmap formats */
enum
{

4
firmware/export/scroll_engine.h
View file

@ -95,10 +95,6 @@ struct scroll_screen_info
long ticks; /* # of ticks between updates*/
long delay; /* ticks delay before start */
int bidir_limit; /* percent */
#ifdef HAVE_LCD_CHARCELLS
long jump_scroll_delay; /* delay between jump scroll jumps */
int jump_scroll; /* 0=off, 1=once, ..., JUMP_SCROLL_ALWAYS */
#endif
#if defined(HAVE_LCD_BITMAP) || defined(HAVE_REMOTE_LCD)
int step; /* pixels per scroll step */
#endif

6
firmware/panic.c
View file

@ -86,11 +86,7 @@ void panicf( const char *fmt, ...)
lcd_set_viewport(NULL);
#ifdef HAVE_LCD_CHARCELLS
lcd_double_height(false);
lcd_puts(0, 0, "*PANIC*");
lcd_puts(0, 1, panic_buf);
#elif defined(HAVE_LCD_BITMAP)
#if defined(HAVE_LCD_BITMAP)
int y = 1;
#if LCD_DEPTH > 1

4
firmware/scroll_engine.c
View file

@ -185,12 +185,12 @@ static void scroll_thread(void)
while (1)
{
sleep(lcd_scroll_info.ticks);
#if !defined(BOOTLOADER) || defined(HAVE_LCD_CHARCELLS)
#if !defined(BOOTLOADER)
#if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
if (lcd_active())
#endif
lcd_scroll_worker();
#endif /*!BOOTLOADER\HAVE_LCD_CHARCELLS*/
#endif /* !BOOTLOADER */
}
}
#endif /* HAVE_REMOTE_LCD */

1
firmware/target/hosted/sdl/button-sdl.c
View file

@ -22,7 +22,6 @@
#include <math.h>
#include <stdlib.h> /* EXIT_SUCCESS */
#include "sim-ui-defines.h"
#include "lcd-charcells.h"
#ifdef HAVE_REMOTE_LCD
#include "lcd-remote.h"
#endif

206
firmware/target/hosted/sdl/lcd-charcells.c
View file

@ -1,206 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2006 Dan Everton
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include "system.h"
#include "debug.h"
#include "lcd.h"
#include "lcd-charcell.h"
#include "screendump.h"
#include "general.h"
#include "lcd-playersim.h"
#include "sim-ui-defines.h"
#include "lcd-sdl.h"
/* can't include file.h here */
#ifndef MAX_PATH
#define MAX_PATH 260
#endif
/* extern functions, needed for screendump() */
extern int sim_creat(const char *name, mode_t mode);
SDL_Surface* lcd_surface;
SDL_Color lcd_bl_color_dark = {RED_CMP(LCD_BL_DARKCOLOR),
GREEN_CMP(LCD_BL_DARKCOLOR),
BLUE_CMP(LCD_BL_DARKCOLOR), 0};
SDL_Color lcd_bl_color_bright = {RED_CMP(LCD_BL_BRIGHTCOLOR),
GREEN_CMP(LCD_BL_BRIGHTCOLOR),
BLUE_CMP(LCD_BL_BRIGHTCOLOR), 0};
SDL_Color lcd_color_dark = {RED_CMP(LCD_DARKCOLOR),
GREEN_CMP(LCD_DARKCOLOR),
BLUE_CMP(LCD_DARKCOLOR), 0};
SDL_Color lcd_color_bright = {RED_CMP(LCD_BRIGHTCOLOR),
GREEN_CMP(LCD_BRIGHTCOLOR),
BLUE_CMP(LCD_BRIGHTCOLOR), 0};
static unsigned long get_lcd_pixel(int x, int y)
{
return sim_lcd_framebuffer[y][x];
}
void sim_lcd_update_rect(int x_start, int y_start, int width, int height)
{
sdl_update_rect(lcd_surface, x_start, y_start, width, height,
SIM_LCD_WIDTH, SIM_LCD_HEIGHT, get_lcd_pixel);
sdl_gui_update(lcd_surface, x_start, y_start, width, height,
SIM_LCD_WIDTH, SIM_LCD_HEIGHT,
background ? UI_LCD_POSX : 0, background ? UI_LCD_POSY : 0);
}
void lcd_update(void)
{
int x, y;
for (y = 0; y < lcd_pattern_count; y++)
if (lcd_patterns[y].count > 0)
sim_lcd_define_pattern(y, lcd_patterns[y].pattern);
for (y = 0; y < LCD_HEIGHT; y++)
for (x = 0; x < LCD_WIDTH; x++)
lcd_print_char(x, y, lcd_charbuffer[y][x]);
if (lcd_cursor.visible)
lcd_print_char(lcd_cursor.x, lcd_cursor.y, lcd_cursor.hw_char);
sim_lcd_update_rect(0, ICON_HEIGHT, SIM_LCD_WIDTH,
LCD_HEIGHT*CHAR_HEIGHT*CHAR_PIXEL);
}
#ifdef HAVE_BACKLIGHT
void sim_backlight(int value)
{
if (value > 0) {
sdl_set_gradient(lcd_surface, &lcd_bl_color_bright,
&lcd_bl_color_dark, 0, (1<<LCD_DEPTH));
} else {
sdl_set_gradient(lcd_surface, &lcd_color_bright,
&lcd_color_dark, 0, (1<<LCD_DEPTH));
}
sim_lcd_update_rect(0, 0, SIM_LCD_WIDTH, SIM_LCD_HEIGHT);
}
#endif
/* initialise simulator lcd driver */
void lcd_init_device(void)
{
lcd_surface = SDL_CreateRGBSurface(SDL_SWSURFACE,
SIM_LCD_WIDTH * display_zoom,
SIM_LCD_HEIGHT * display_zoom,
8, 0, 0, 0, 0);
sdl_set_gradient(lcd_surface, &lcd_bl_color_bright,
&lcd_bl_color_dark, 0, (1<<LCD_DEPTH));
}
#define BMP_COMPRESSION 0 /* BI_RGB */
#define BMP_NUMCOLORS (1 << LCD_DEPTH)
#define BMP_BPP 1
#define BMP_LINESIZE (((SIM_LCD_WIDTH + 31) / 32) * 4)
#define BMP_HEADERSIZE (54 + 4 * BMP_NUMCOLORS)
#define BMP_DATASIZE (BMP_LINESIZE * SIM_LCD_HEIGHT)
#define BMP_TOTALSIZE (BMP_HEADERSIZE + BMP_DATASIZE)
#define LE16_CONST(x) (x)&0xff, ((x)>>8)&0xff
#define LE32_CONST(x) (x)&0xff, ((x)>>8)&0xff, ((x)>>16)&0xff, ((x)>>24)&0xff
static const unsigned char bmpheader[] =
{
0x42, 0x4d, /* 'BM' */
LE32_CONST(BMP_TOTALSIZE), /* Total file size */
0x00, 0x00, 0x00, 0x00, /* Reserved */
LE32_CONST(BMP_HEADERSIZE), /* Offset to start of pixel data */
0x28, 0x00, 0x00, 0x00, /* Size of (2nd) header */
LE32_CONST(SIM_LCD_WIDTH), /* Width in pixels */
LE32_CONST(SIM_LCD_HEIGHT), /* Height in pixels */
0x01, 0x00, /* Number of planes (always 1) */
LE16_CONST(BMP_BPP), /* Bits per pixel 1/4/8/16/24 */
LE32_CONST(BMP_COMPRESSION),/* Compression mode */
LE32_CONST(BMP_DATASIZE), /* Size of bitmap data */
0xc4, 0x0e, 0x00, 0x00, /* Horizontal resolution (pixels/meter) */
0xc4, 0x0e, 0x00, 0x00, /* Vertical resolution (pixels/meter) */
LE32_CONST(BMP_NUMCOLORS), /* Number of used colours */
LE32_CONST(BMP_NUMCOLORS), /* Number of important colours */
BMP_COLOR(LCD_BL_BRIGHTCOLOR),
BMP_COLOR(LCD_BL_DARKCOLOR)
};
void screen_dump(void)
{
int fd;
char filename[MAX_PATH];
int x, y;
static unsigned char line[BMP_LINESIZE];
create_numbered_filename(filename, "", "dump_", ".bmp", 4
IF_CNFN_NUM_(, NULL));
DEBUGF("screen_dump\n");
fd = sim_creat(filename, 0666);
if (fd < 0)
return;
if(write(fd, bmpheader, sizeof(bmpheader)) != sizeof(bmpheader))
{
close(fd);
return;
}
SDL_LockSurface(lcd_surface);
/* BMP image goes bottom up */
for (y = SIM_LCD_HEIGHT - 1; y >= 0; y--)
{
Uint8 *src = (Uint8 *)lcd_surface->pixels
+ y * SIM_LCD_WIDTH * (int)display_zoom * (int)display_zoom;
unsigned char *dst = line;
unsigned dst_mask = 0x80;
memset(line, 0, sizeof(line));
for (x = SIM_LCD_WIDTH; x > 0; x--)
{
if (*src)
*dst |= dst_mask;
src += (int)display_zoom;
dst_mask >>= 1;
if (dst_mask == 0)
{
dst++;
dst_mask = 0x80;
}
}
if(write(fd, line, sizeof(line)) != sizeof(line))
{
close(fd);
return;
}
}
SDL_UnlockSurface(lcd_surface);
close(fd);
}

34
firmware/target/hosted/sdl/lcd-charcells.h
View file

@ -1,34 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2006 Dan Everton
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#ifndef __LCDCHARCELL_H__
#define __LCDCHARCELL_H__
#include "lcd.h"
#include "SDL.h"
#ifdef HAVE_LCD_CHARCELLS
void sim_lcd_init(void);
void screen_dump(void);
#endif
#endif /* #ifndef __LCDCHARCELL_H__ */

2
firmware/target/hosted/sdl/system-sdl.c
View file

@ -35,8 +35,6 @@
#include "lcd-sdl.h"
#ifdef HAVE_LCD_BITMAP
#include "lcd-bitmap.h"
#elif defined(HAVE_LCD_CHARCELLS)
#include "lcd-charcells.h"
#endif
#ifdef HAVE_REMOTE_LCD
#include "lcd-remote-bitmap.h"

52
manual/advanced_topics/main.tex
View file

@ -168,32 +168,30 @@ file find the instructions on the Rockbox website:
the \fname{/.rockbox/backdrops} directory.
}%
\nopt{lcd_charcell}{
\subsection{UI Viewport}
By default, the UI is drawn on the whole screen. This can be changed so that
the UI is confined to a specific area of the screen, by use of a UI
viewport. This is done by adding the following line to the
\fname{.cfg} file for a theme:\\*
\subsection{UI Viewport}
By default, the UI is drawn on the whole screen. This can be changed so that
the UI is confined to a specific area of the screen, by use of a UI
viewport. This is done by adding the following line to the
\fname{.cfg} file for a theme:\\*
\nopt{lcd_non-mono}{\config{ui viewport: X,Y,[width],[height],[font]}}
\nopt{lcd_non-mono}{\config{ui viewport: X,Y,[width],[height],[font]}}
\nopt{lcd_color}{\opt{lcd_non-mono}{
\config{ui viewport: X,Y,[width],[height],[font],[fgshade],[bgshade]}}}
\opt{lcd_color}{
\config{ui viewport: X,Y,[width],[height],[font],[fgcolour],[bgcolour]}}
\\*
\opt{HAVE_REMOTE_LCD}{
The dimensions of the menu that is displayed on the remote control of your
\dap\ can be set in the same way. The line to be added to the theme
\fname{.cfg} is the following:\\*
\nopt{lcd_non-mono}{\config{remote ui viewport: X,Y,[width],[height],[font]}}
\nopt{lcd_color}{\opt{lcd_non-mono}{
\config{ui viewport: X,Y,[width],[height],[font],[fgshade],[bgshade]}}}
\config{remote ui viewport: X,Y,[width],[height],[font],[fgshade],[bgshade]}}}
\opt{lcd_color}{
\config{ui viewport: X,Y,[width],[height],[font],[fgcolour],[bgcolour]}}
\\*
\opt{HAVE_REMOTE_LCD}{
The dimensions of the menu that is displayed on the remote control of your
\dap\ can be set in the same way. The line to be added to the theme
\fname{.cfg} is the following:\\*
\nopt{lcd_non-mono}{\config{remote ui viewport: X,Y,[width],[height],[font]}}
\nopt{lcd_color}{\opt{lcd_non-mono}{
\config{remote ui viewport: X,Y,[width],[height],[font],[fgshade],[bgshade]}}}
\opt{lcd_color}{
\config{remote ui viewport: X,Y,[width],[height],[font],[fgcolour],[bgcolour]}}
\\*
}
\config{remote ui viewport: X,Y,[width],[height],[font],[fgcolour],[bgcolour]}}
\\*
Only the first two parameters \emph{have} to be specified, the others can
be omitted using `$-$' as a placeholder. The syntax is very similar to WPS
@ -202,7 +200,6 @@ file find the instructions on the Rockbox website:
\nopt{lcd_non-mono}{\input{advanced_topics/viewports/mono-uivp-syntax.tex}}
\nopt{lcd_color}{\opt{lcd_non-mono}{\input{advanced_topics/viewports/grayscale-uivp-syntax.tex}}}
\opt{lcd_color}{\input{advanced_topics/viewports/colour-uivp-syntax.tex}}
}
\section{\label{ref:ConfiguringtheWPS}Configuring the Theme}
@ -265,7 +262,6 @@ are discussed below.
}
}
\nopt{lcd_charcell}{
\subsubsection{\label{ref:Viewports}Viewports}
By default, a viewport filling the whole screen contains all the elements
@ -279,7 +275,7 @@ be defined. A viewport is a rectangular window on the screen%
\opt{lcd_non-mono}{ with its own foreground/background
\opt{lcd_color}{colours}\nopt{lcd_color}{shades}}.
This window also has variable dimensions. To
define a viewport a line starting \config{{\%V(\dots}} has to be
define a viewport a line starting \config{{\%V(\dots)}} has to be
present in the theme file. The full syntax will be explained later in
this section. All elements placed before the
line defining a viewport are displayed in the default viewport. Elements
@ -293,6 +289,7 @@ cannot be layered \emph{transparently} over one another. Subsequent viewports
will be drawn over any other viewports already drawn onto that
area of the screen.
\nopt{lcd_non-mono}{\input{advanced_topics/viewports/mono-vp-syntax.tex}}
\nopt{lcd_color}{\opt{lcd_non-mono}{\input{advanced_topics/viewports/grayscale-vp-syntax.tex}}}
\opt{lcd_color}{\input{advanced_topics/viewports/colour-vp-syntax.tex}}
@ -318,11 +315,10 @@ Mode can be the following:
the end colour\\}
\end{rbtabular}
}
\subsubsection{Conditional Viewports}
Any viewport can be displayed either permanently or conditionally.
Defining a viewport as \config{{\%V(\dots}}
Defining a viewport as \config{{\%V(\dots)}}
will display it permanently.
\begin{itemize}

85
manual/appendix/wps_tags.tex
View file

@ -53,61 +53,58 @@ conditionals to show alternate information in preference to assuming.
These tags, when written with a capital ``I'' (e.g. \config{\%Ia} or \config{\%Ic}),
show the information for the next song to be played.
\nopt{lcd_charcell}{
\section{Viewports}
\begin{tagmap}
\nopt{lcd_non-mono}{%
\config{\%V(x,y,[width],\tabnlindent[height],[font])}
& See section \ref{ref:Viewports}\\}
\section{Viewports}
\begin{tagmap}
\nopt{lcd_non-mono}{%
\config{\%V(x,y,[width],\tabnlindent[height],[font])}
& See section \ref{ref:Viewports}\\}
\nopt{lcd_color}{\opt{lcd_non-mono}{%
\config{\%V(x,y,[width],\tabnlindent[height],[font])}\newline
\config{\%Vf([fgshade])}\newline
\config{\%Vb([bgshade])}
& See section \ref{ref:Viewports}\\}}
\nopt{lcd_color}{\opt{lcd_non-mono}{%
\config{\%V(x,y,[width],\tabnlindent[height],[font])}\newline
\config{\%Vf([fgshade])}\newline
\config{\%Vb([bgshade])}
& See section \ref{ref:Viewports}\\}}
\opt{lcd_color}{%
\config{\%V(x,y,[width],\tabnlindent[height],[font])}\newline
\config{\%Vf([fgcolour])}\newline
\config{\%Vb([bgcolour])}\newline
\config{\%Vg(start,end \tabnlindent[,text])}
& See section \ref{ref:Viewports}\\}
\opt{lcd_color}{%
\config{\%V(x,y,[width],\tabnlindent[height],[font])}\newline
\config{\%Vf([fgcolour])}\newline
\config{\%Vb([bgcolour])}\newline
\config{\%Vg(start,end \tabnlindent[,text])}
& See section \ref{ref:Viewports}\\}
\opt{lcd_non-mono}{%
\config{\%Vs(mode[,param])}
& See section \ref{ref:Viewports}\\}
\config{\%Vl('identifier',\newline\dots)} & Preloads a viewport for later
\opt{lcd_non-mono}{%
\config{\%Vs(mode[,param])}
& See section \ref{ref:Viewports}\\}
\config{\%Vl('identifier',\newline\dots)} & Preloads a viewport for later
display. `identifier' is a single lowercase letter (a-z) and the `\dots'
parameters use the same logic as the \%V tag explained above.\\
\config{\%Vd('identifier')} & Display the `identifier' viewport. E.g.
\config{\%?C<\%Vd(a)|\%Vd(b)>}
will show viewport `a' if album art is found, and `b' if it isn't.\\
\config{\%Vd('identifier')} & Display the `identifier' viewport. E.g.
\config{\%?C<\%Vd(a)|\%Vd(b)>}
will show viewport `a' if album art is found, and `b' if it isn't.\\
\config{\%Vi('label',\dots)} &
Declare a Custom UI Viewport. The `\dots' parameters use the same logic as
the \config{\%V} tag explained above. See section \ref{ref:Viewports}.\\
\config{\%Vi('label',\dots)} &
Declare a Custom UI Viewport. The `\dots' parameters use the same logic as
the \config{\%V} tag explained above. See section \ref{ref:Viewports}.\\
\config{\%VI('label')} & Set the Info Viewport to use the viewport called
label, as declared with the previous tag.\\
\config{\%VI('label')} & Set the Info Viewport to use the viewport called
label, as declared with the previous tag.\\
\config{\%VB} & Draw this viewport on the backdrop layer.\\
\end{tagmap}
\config{\%VB} & Draw this viewport on the backdrop layer.\\
\end{tagmap}
\section{Additional Fonts}
\begin{tagmap}
\config{\%Fl('id',filename)} & See section \ref{ref:multifont}.\\
\end{tagmap}
\section{Additional Fonts}
\begin{tagmap}
\config{\%Fl('id',filename)} & See section \ref{ref:multifont}.\\
\end{tagmap}
\section{Misc Coloring Tags}
\begin{tagmap}
\config{\%dr(x,y,width,height,[color1,color2])} & Color a rectangle. \\
\end{tagmap}
width and height can be ``$-$'' to fill the viewport. If no color is
specified the viewports foreground color will be used. If two
colors are specified it will do a gradient fill.
}
\section{Misc Coloring Tags}
\begin{tagmap}
\config{\%dr(x,y,width,height,[color1,color2])} & Color a rectangle. \\
\end{tagmap}
width and height can be ``$-$'' to fill the viewport. If no color is
specified the viewports foreground color will be used. If two
colors are specified it will do a gradient fill.
\section{Power Related Information}
\begin{tagmap}

2
manual/plugins/text_viewer.tex
View file

@ -196,8 +196,6 @@ by using \emph{Open with} from the \emph{Context Menu}
\item[Viewer Options] Change settings for the current file.
\begin{description}
\item[Encoding] Set the codepage in the text viewer.
% ToDo: wrap some of the following settings into a \opt{lcd_bitmap} to exlude
% ones that don't work on charcell - as soon as the plugin itself does
Available settings:
\setting{ISO-8859-1} (Latin 1).
\setting{ISO-8859-7} (Greek),

780
tools/player_unifont.c
View file

@ -1,780 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2007 by Jens Arnold
* Based on the work of Kjell Ericson
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include "lcd-charcell.h"
#define CHAR_WIDTH 8
#define CHAR_HEIGHT 8
#define BITMAP_WIDTH (CHAR_WIDTH*(16+3))
#define SIZE 2
#define CHAR_BG_STD 0xc0c0c0
#define CHAR_BG_ALT 0x808080
#define CHAR_FG_STD 0x000000
#define CHAR_FG_ALT 0xf00000
static unsigned char font_player_newlcd[256][7] = {
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 00 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 01 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 02 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 03 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 04 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 05 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 06 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 07 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 08 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 09 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0a */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0b */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0c */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0d */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0e */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0f */
{ 0x00, 0x10, 0x1c, 0x1f, 0x1c, 0x10, 0x00 }, /* 10 */
{ 0x00, 0x01, 0x07, 0x1f, 0x07, 0x01, 0x00 }, /* 11 */
{ 0x00, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00 }, /* 12 */
{ 0x0a, 0x0a, 0x0a, 0x0a, 0x00, 0x00, 0x0a }, /* 13 */
{ 0x0f, 0x1d, 0x1d, 0x0d, 0x05, 0x05, 0x05 }, /* 14 */
{ 0x07, 0x08, 0x0e, 0x11, 0x0e, 0x02, 0x1c }, /* 15 */
{ 0x00, 0x00, 0x1f, 0x1f, 0x00, 0x00, 0x00 }, /* 16 */
{ 0x01, 0x01, 0x05, 0x09, 0x1f, 0x08, 0x04 }, /* 17 */
{ 0x04, 0x0e, 0x15, 0x04, 0x04, 0x04, 0x04 }, /* 18 */
{ 0x04, 0x04, 0x04, 0x04, 0x15, 0x0e, 0x04 }, /* 19 */
{ 0x11, 0x19, 0x1d, 0x1f, 0x1d, 0x19, 0x11 }, /* 1a */
{ 0x11, 0x13, 0x17, 0x1f, 0x17, 0x13, 0x11 }, /* 1b */
{ 0x10, 0x14, 0x12, 0x1f, 0x12, 0x14, 0x10 }, /* 1c */
{ 0x01, 0x05, 0x09, 0x1f, 0x09, 0x05, 0x01 }, /* 1d */
{ 0x00, 0x1f, 0x0e, 0x0e, 0x04, 0x04, 0x00 }, /* 1e */
{ 0x00, 0x04, 0x04, 0x0e, 0x0e, 0x1f, 0x00 }, /* 1f */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 20 */
{ 0x04, 0x04, 0x04, 0x04, 0x00, 0x00, 0x04 }, /* 21 */
{ 0x0a, 0x0a, 0x0a, 0x00, 0x00, 0x00, 0x00 }, /* 22 */
{ 0x0a, 0x0a, 0x1f, 0x0a, 0x1f, 0x0a, 0x0a }, /* 23 */
{ 0x04, 0x0f, 0x14, 0x0e, 0x05, 0x1e, 0x04 }, /* 24 */
{ 0x18, 0x19, 0x02, 0x04, 0x08, 0x13, 0x03 }, /* 25 */
{ 0x0c, 0x12, 0x14, 0x08, 0x15, 0x12, 0x0d }, /* 26 */
{ 0x0c, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00 }, /* 27 */
{ 0x02, 0x04, 0x08, 0x08, 0x08, 0x04, 0x02 }, /* 28 */
{ 0x08, 0x04, 0x02, 0x02, 0x02, 0x04, 0x08 }, /* 29 */
{ 0x00, 0x04, 0x15, 0x0e, 0x15, 0x04, 0x00 }, /* 2a */
{ 0x00, 0x04, 0x04, 0x1f, 0x04, 0x04, 0x00 }, /* 2b */
{ 0x00, 0x00, 0x00, 0x00, 0x0c, 0x04, 0x08 }, /* 2c */
{ 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00 }, /* 2d */
{ 0x00, 0x00, 0x00, 0x00, 0x0c, 0x0c, 0x00 }, /* 2e */
{ 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x00 }, /* 2f */
{ 0x0e, 0x11, 0x13, 0x15, 0x19, 0x11, 0x0e }, /* 30 */
{ 0x04, 0x0c, 0x04, 0x04, 0x04, 0x04, 0x0e }, /* 31 */
{ 0x0e, 0x11, 0x01, 0x02, 0x04, 0x08, 0x1f }, /* 32 */
{ 0x1f, 0x02, 0x04, 0x02, 0x01, 0x11, 0x0e }, /* 33 */
{ 0x02, 0x06, 0x0a, 0x12, 0x1f, 0x02, 0x02 }, /* 34 */
{ 0x1f, 0x10, 0x1e, 0x01, 0x01, 0x11, 0x0e }, /* 35 */
{ 0x06, 0x08, 0x10, 0x1e, 0x11, 0x11, 0x0e }, /* 36 */
{ 0x1f, 0x01, 0x02, 0x02, 0x04, 0x04, 0x04 }, /* 37 */
{ 0x0e, 0x11, 0x11, 0x0e, 0x11, 0x11, 0x0e }, /* 38 */
{ 0x0e, 0x11, 0x11, 0x0f, 0x01, 0x02, 0x0c }, /* 39 */
{ 0x00, 0x0c, 0x0c, 0x00, 0x0c, 0x0c, 0x00 }, /* 3a */
{ 0x0c, 0x0c, 0x00, 0x0c, 0x0c, 0x04, 0x08 }, /* 3b */
{ 0x02, 0x04, 0x08, 0x10, 0x08, 0x04, 0x02 }, /* 3c */
{ 0x00, 0x00, 0x1f, 0x00, 0x1f, 0x00, 0x00 }, /* 3d */
{ 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08 }, /* 3e */
{ 0x0e, 0x11, 0x01, 0x02, 0x04, 0x00, 0x04 }, /* 3f */
{ 0x0e, 0x11, 0x01, 0x0d, 0x15, 0x15, 0x0e }, /* 40 */
{ 0x0e, 0x11, 0x11, 0x11, 0x1f, 0x11, 0x11 }, /* 41 */
{ 0x1e, 0x11, 0x11, 0x1e, 0x11, 0x11, 0x1e }, /* 42 */
{ 0x0e, 0x11, 0x10, 0x10, 0x10, 0x11, 0x0e }, /* 43 */
{ 0x1c, 0x12, 0x11, 0x11, 0x11, 0x12, 0x1c }, /* 44 */
{ 0x1f, 0x10, 0x10, 0x1e, 0x10, 0x10, 0x1f }, /* 45 */
{ 0x1f, 0x10, 0x10, 0x1e, 0x10, 0x10, 0x10 }, /* 46 */
{ 0x0e, 0x11, 0x10, 0x17, 0x11, 0x11, 0x0f }, /* 47 */
{ 0x11, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11 }, /* 48 */
{ 0x0e, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e }, /* 49 */
{ 0x0f, 0x02, 0x02, 0x02, 0x02, 0x12, 0x0c }, /* 4a */
{ 0x11, 0x12, 0x14, 0x18, 0x14, 0x12, 0x11 }, /* 4b */
{ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1f }, /* 4c */
{ 0x11, 0x1b, 0x15, 0x15, 0x11, 0x11, 0x11 }, /* 4d */
{ 0x11, 0x11, 0x19, 0x15, 0x13, 0x11, 0x11 }, /* 4e */
{ 0x0e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 4f */
{ 0x1e, 0x11, 0x11, 0x1e, 0x10, 0x10, 0x10 }, /* 50 */
{ 0x0e, 0x11, 0x11, 0x11, 0x11, 0x12, 0x0d }, /* 51 */
{ 0x1e, 0x11, 0x11, 0x1e, 0x14, 0x12, 0x11 }, /* 52 */
{ 0x0e, 0x11, 0x10, 0x0e, 0x01, 0x11, 0x0e }, /* 53 */
{ 0x1f, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04 }, /* 54 */
{ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 55 */
{ 0x11, 0x11, 0x11, 0x11, 0x11, 0x0a, 0x04 }, /* 56 */
{ 0x11, 0x11, 0x11, 0x15, 0x15, 0x15, 0x0a }, /* 57 */
{ 0x11, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x11 }, /* 58 */
{ 0x11, 0x11, 0x0a, 0x04, 0x04, 0x04, 0x04 }, /* 59 */
{ 0x1f, 0x01, 0x02, 0x04, 0x08, 0x10, 0x1f }, /* 5a */
{ 0x0e, 0x08, 0x08, 0x08, 0x08, 0x08, 0x0e }, /* 5b */
{ 0x11, 0x0a, 0x1f, 0x04, 0x1f, 0x04, 0x04 }, /* 5c */
{ 0x0e, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0e }, /* 5d */
{ 0x04, 0x0a, 0x11, 0x00, 0x00, 0x00, 0x00 }, /* 5e */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f }, /* 5f */
{ 0x08, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00 }, /* 60 */
{ 0x00, 0x00, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 61 */
{ 0x10, 0x10, 0x16, 0x19, 0x11, 0x11, 0x1e }, /* 62 */
{ 0x00, 0x00, 0x0e, 0x10, 0x10, 0x11, 0x0e }, /* 63 */
{ 0x01, 0x01, 0x0d, 0x13, 0x11, 0x11, 0x0f }, /* 64 */
{ 0x00, 0x00, 0x0e, 0x11, 0x1f, 0x10, 0x0e }, /* 65 */
{ 0x06, 0x09, 0x08, 0x1c, 0x08, 0x08, 0x08 }, /* 66 */
{ 0x00, 0x0f, 0x11, 0x11, 0x0f, 0x01, 0x0e }, /* 67 */
{ 0x10, 0x10, 0x16, 0x19, 0x11, 0x11, 0x11 }, /* 68 */
{ 0x04, 0x00, 0x0c, 0x04, 0x04, 0x04, 0x0e }, /* 69 */
{ 0x02, 0x00, 0x06, 0x02, 0x02, 0x12, 0x0c }, /* 6a */
{ 0x10, 0x10, 0x12, 0x14, 0x18, 0x14, 0x12 }, /* 6b */
{ 0x0c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e }, /* 6c */
{ 0x00, 0x00, 0x1a, 0x15, 0x15, 0x11, 0x11 }, /* 6d */
{ 0x00, 0x00, 0x16, 0x19, 0x11, 0x11, 0x11 }, /* 6e */
{ 0x00, 0x00, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 6f */
{ 0x00, 0x00, 0x1e, 0x11, 0x1e, 0x10, 0x10 }, /* 70 */
{ 0x00, 0x00, 0x0d, 0x13, 0x0f, 0x01, 0x01 }, /* 71 */
{ 0x00, 0x00, 0x16, 0x19, 0x10, 0x10, 0x10 }, /* 72 */
{ 0x00, 0x00, 0x0e, 0x10, 0x0e, 0x01, 0x1e }, /* 73 */
{ 0x08, 0x08, 0x1c, 0x08, 0x08, 0x09, 0x06 }, /* 74 */
{ 0x00, 0x00, 0x11, 0x11, 0x11, 0x13, 0x0d }, /* 75 */
{ 0x00, 0x00, 0x11, 0x11, 0x11, 0x0a, 0x04 }, /* 76 */
{ 0x00, 0x00, 0x11, 0x11, 0x15, 0x15, 0x0a }, /* 77 */
{ 0x00, 0x00, 0x11, 0x0a, 0x04, 0x0a, 0x11 }, /* 78 */
{ 0x00, 0x00, 0x11, 0x11, 0x0f, 0x01, 0x1e }, /* 79 */
{ 0x00, 0x00, 0x1f, 0x02, 0x04, 0x08, 0x1f }, /* 7a */
{ 0x02, 0x04, 0x04, 0x08, 0x04, 0x04, 0x02 }, /* 7b */
{ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04 }, /* 7c */
{ 0x08, 0x04, 0x04, 0x02, 0x04, 0x04, 0x08 }, /* 7d */
{ 0x00, 0x04, 0x02, 0x1f, 0x02, 0x04, 0x00 }, /* 7e */
{ 0x00, 0x04, 0x08, 0x1f, 0x08, 0x04, 0x00 }, /* 7f */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f }, /* 80 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f }, /* 81 */
{ 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x1f }, /* 82 */
{ 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f }, /* 83 */
{ 0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* 84 */
{ 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* 85 */
{ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* 86 */
{ 0x00, 0x0a, 0x04, 0x1f, 0x04, 0x0a, 0x00 }, /* 87 */
{ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11 }, /* 88 */
{ 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19 }, /* 89 */
{ 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d }, /* 8a */
{ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08 }, /* 8b */
{ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c }, /* 8c */
{ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e }, /* 8d */
{ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f }, /* 8e */
{ 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x00 }, /* 8f */
{ 0x00, 0x0e, 0x1f, 0x1f, 0x1f, 0x0e, 0x00 }, /* 90 */
{ 0x1f, 0x11, 0x11, 0x11, 0x11, 0x11, 0x1f }, /* 91 */
{ 0x1f, 0x1b, 0x13, 0x1b, 0x1b, 0x11, 0x1f }, /* 92 */
{ 0x1f, 0x11, 0x1d, 0x1b, 0x17, 0x11, 0x1f }, /* 93 */
{ 0x00, 0x00, 0x07, 0x04, 0x04, 0x14, 0x08 }, /* 94 */
{ 0x04, 0x04, 0x1f, 0x04, 0x04, 0x00, 0x1f }, /* 95 */
{ 0x00, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x00 }, /* 96 */
{ 0x00, 0x04, 0x00, 0x1f, 0x00, 0x04, 0x00 }, /* 97 */
{ 0x1f, 0x00, 0x11, 0x0a, 0x04, 0x0a, 0x11 }, /* 98 */
{ 0x1c, 0x04, 0x1c, 0x10, 0x1c, 0x00, 0x00 }, /* 99 */
{ 0x1c, 0x04, 0x1c, 0x04, 0x1c, 0x00, 0x00 }, /* 9a */
{ 0x11, 0x12, 0x17, 0x09, 0x17, 0x04, 0x07 }, /* 9b */
{ 0x11, 0x12, 0x14, 0x09, 0x13, 0x07, 0x01 }, /* 9c */
{ 0x18, 0x09, 0x1a, 0x0d, 0x1b, 0x17, 0x01 }, /* 9d */
{ 0x00, 0x05, 0x0a, 0x14, 0x0a, 0x05, 0x00 }, /* 9e */
{ 0x00, 0x14, 0x0a, 0x05, 0x0a, 0x14, 0x00 }, /* 9f */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* a0 */
{ 0x00, 0x00, 0x00, 0x00, 0x1c, 0x14, 0x1c }, /* a1 */
{ 0x07, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00 }, /* a2 */
{ 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x1c }, /* a3 */
{ 0x00, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04 }, /* a4 */
{ 0x00, 0x00, 0x00, 0x0c, 0x0c, 0x00, 0x00 }, /* a5 */
{ 0x00, 0x1f, 0x01, 0x1f, 0x01, 0x02, 0x04 }, /* a6 */
{ 0x00, 0x00, 0x1f, 0x01, 0x06, 0x04, 0x08 }, /* a7 */
{ 0x00, 0x00, 0x02, 0x04, 0x0c, 0x14, 0x04 }, /* a8 */
{ 0x00, 0x00, 0x04, 0x1f, 0x11, 0x01, 0x06 }, /* a9 */
{ 0x00, 0x00, 0x00, 0x1f, 0x04, 0x04, 0x1f }, /* aa */
{ 0x00, 0x00, 0x02, 0x1f, 0x06, 0x0a, 0x12 }, /* ab */
{ 0x00, 0x00, 0x08, 0x1f, 0x09, 0x0a, 0x08 }, /* ac */
{ 0x00, 0x00, 0x00, 0x0e, 0x02, 0x02, 0x1f }, /* ad */
{ 0x00, 0x00, 0x1e, 0x02, 0x1e, 0x02, 0x1e }, /* ae */
{ 0x00, 0x00, 0x00, 0x15, 0x15, 0x01, 0x06 }, /* af */
{ 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00 }, /* b0 */
{ 0x1f, 0x01, 0x05, 0x06, 0x04, 0x04, 0x08 }, /* b1 */
{ 0x01, 0x02, 0x04, 0x0c, 0x14, 0x04, 0x04 }, /* b2 */
{ 0x04, 0x1f, 0x11, 0x11, 0x01, 0x02, 0x04 }, /* b3 */
{ 0x00, 0x1f, 0x04, 0x04, 0x04, 0x04, 0x1f }, /* b4 */
{ 0x02, 0x1f, 0x02, 0x06, 0x0a, 0x12, 0x02 }, /* b5 */
{ 0x08, 0x1f, 0x09, 0x09, 0x09, 0x09, 0x12 }, /* b6 */
{ 0x04, 0x1f, 0x04, 0x1f, 0x04, 0x04, 0x04 }, /* b7 */
{ 0x00, 0x0f, 0x09, 0x11, 0x01, 0x02, 0x0c }, /* b8 */
{ 0x08, 0x0f, 0x12, 0x02, 0x02, 0x02, 0x04 }, /* b9 */
{ 0x00, 0x1f, 0x01, 0x01, 0x01, 0x01, 0x1f }, /* ba */
{ 0x0a, 0x1f, 0x0a, 0x02, 0x02, 0x02, 0x04 }, /* bb */
{ 0x00, 0x18, 0x00, 0x18, 0x01, 0x02, 0x1c }, /* bc */
{ 0x00, 0x1f, 0x01, 0x02, 0x04, 0x0a, 0x11 }, /* bd */
{ 0x08, 0x1f, 0x09, 0x0a, 0x08, 0x08, 0x07 }, /* be */
{ 0x00, 0x11, 0x11, 0x09, 0x01, 0x02, 0x0c }, /* bf */
{ 0x00, 0x0f, 0x09, 0x15, 0x03, 0x02, 0x0c }, /* c0 */
{ 0x02, 0x1c, 0x04, 0x1f, 0x04, 0x04, 0x08 }, /* c1 */
{ 0x00, 0x15, 0x15, 0x15, 0x01, 0x02, 0x04 }, /* c2 */
{ 0x0e, 0x00, 0x1f, 0x04, 0x04, 0x04, 0x08 }, /* c3 */
{ 0x08, 0x08, 0x08, 0x0c, 0x0a, 0x08, 0x08 }, /* c4 */
{ 0x04, 0x04, 0x1f, 0x04, 0x04, 0x08, 0x10 }, /* c5 */
{ 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x1f }, /* c6 */
{ 0x00, 0x1f, 0x01, 0x0a, 0x04, 0x0a, 0x10 }, /* c7 */
{ 0x04, 0x1f, 0x02, 0x04, 0x0e, 0x15, 0x04 }, /* c8 */
{ 0x02, 0x02, 0x02, 0x02, 0x02, 0x04, 0x08 }, /* c9 */
{ 0x00, 0x04, 0x02, 0x11, 0x11, 0x11, 0x11 }, /* ca */
{ 0x10, 0x10, 0x1f, 0x10, 0x10, 0x10, 0x0f }, /* cb */
{ 0x00, 0x1f, 0x01, 0x01, 0x01, 0x02, 0x0c }, /* cc */
{ 0x00, 0x08, 0x14, 0x02, 0x01, 0x01, 0x00 }, /* cd */
{ 0x04, 0x1f, 0x04, 0x04, 0x15, 0x15, 0x04 }, /* ce */
{ 0x00, 0x1f, 0x01, 0x01, 0x0a, 0x04, 0x02 }, /* cf */
{ 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x01 }, /* d0 */
{ 0x00, 0x04, 0x08, 0x10, 0x11, 0x1f, 0x01 }, /* d1 */
{ 0x00, 0x01, 0x01, 0x0a, 0x04, 0x0a, 0x10 }, /* d2 */
{ 0x00, 0x1f, 0x08, 0x1f, 0x08, 0x08, 0x07 }, /* d3 */
{ 0x08, 0x08, 0x1f, 0x09, 0x0a, 0x08, 0x08 }, /* d4 */
{ 0x00, 0x0e, 0x02, 0x02, 0x02, 0x02, 0x1f }, /* d5 */
{ 0x00, 0x1f, 0x01, 0x1f, 0x01, 0x01, 0x1f }, /* d6 */
{ 0x0e, 0x00, 0x1f, 0x01, 0x01, 0x02, 0x04 }, /* d7 */
{ 0x12, 0x12, 0x12, 0x12, 0x12, 0x04, 0x08 }, /* d8 */
{ 0x00, 0x04, 0x14, 0x14, 0x15, 0x15, 0x16 }, /* d9 */
{ 0x00, 0x10, 0x10, 0x11, 0x12, 0x14, 0x18 }, /* da */
{ 0x1f, 0x11, 0x11, 0x11, 0x11, 0x11, 0x1f }, /* db */
{ 0x00, 0x1f, 0x11, 0x11, 0x01, 0x02, 0x04 }, /* dc */
{ 0x00, 0x18, 0x00, 0x01, 0x01, 0x02, 0x1c }, /* dd */
{ 0x04, 0x12, 0x08, 0x00, 0x00, 0x00, 0x00 }, /* de */
{ 0x1c, 0x14, 0x1c, 0x00, 0x00, 0x00, 0x00 }, /* df */
{ 0x00, 0x00, 0x09, 0x15, 0x12, 0x12, 0x0d }, /* e0 */
{ 0x00, 0x0e, 0x11, 0x1e, 0x11, 0x1e, 0x10 }, /* e1 */
{ 0x00, 0x11, 0x0a, 0x0a, 0x04, 0x04, 0x08 }, /* e2 */
{ 0x00, 0x00, 0x1f, 0x0a, 0x0a, 0x0a, 0x13 }, /* e3 */
{ 0x1f, 0x10, 0x08, 0x04, 0x08, 0x10, 0x1f }, /* e4 */
{ 0x00, 0x00, 0x0f, 0x14, 0x12, 0x11, 0x0e }, /* e5 */
{ 0x00, 0x09, 0x09, 0x09, 0x0f, 0x08, 0x10 }, /* e6 */
{ 0x00, 0x00, 0x1f, 0x04, 0x04, 0x04, 0x03 }, /* e7 */
{ 0x1f, 0x04, 0x0e, 0x15, 0x0e, 0x04, 0x1f }, /* e8 */
{ 0x00, 0x0e, 0x11, 0x1f, 0x11, 0x11, 0x0e }, /* e9 */
{ 0x00, 0x00, 0x0e, 0x11, 0x11, 0x0a, 0x1b }, /* ea */
{ 0x0f, 0x10, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* eb */
{ 0x00, 0x00, 0x00, 0x00, 0x0b, 0x15, 0x1a }, /* ec */
{ 0x02, 0x04, 0x0e, 0x15, 0x0e, 0x04, 0x08 }, /* ed */
{ 0x00, 0x0e, 0x10, 0x0e, 0x10, 0x0e, 0x00 }, /* ee */
{ 0x06, 0x09, 0x11, 0x1e, 0x10, 0x10, 0x10 }, /* ef */
{ 0x00, 0x00, 0x08, 0x15, 0x02, 0x00, 0x00 }, /* f0 */
{ 0x00, 0x08, 0x15, 0x0a, 0x15, 0x02, 0x00 }, /* f1 */
{ 0x08, 0x0f, 0x12, 0x0f, 0x0a, 0x1f, 0x02 }, /* f2 */
{ 0x0f, 0x09, 0x0f, 0x09, 0x0f, 0x09, 0x11 }, /* f3 */
{ 0x04, 0x15, 0x15, 0x04, 0x04, 0x0a, 0x11 }, /* f4 */
{ 0x04, 0x04, 0x1d, 0x06, 0x0e, 0x15, 0x04 }, /* f5 */
{ 0x04, 0x04, 0x1f, 0x04, 0x0e, 0x15, 0x04 }, /* f6 */
{ 0x04, 0x0a, 0x11, 0x0e, 0x04, 0x0e, 0x1f }, /* f7 */
{ 0x04, 0x04, 0x0e, 0x04, 0x04, 0x04, 0x1f }, /* f8 */
{ 0x1f, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x1f }, /* f9 */
{ 0x00, 0x01, 0x1e, 0x04, 0x1f, 0x04, 0x04 }, /* fa */
{ 0x00, 0x00, 0x1f, 0x08, 0x0f, 0x09, 0x11 }, /* fb */
{ 0x00, 0x00, 0x1f, 0x15, 0x1f, 0x11, 0x11 }, /* fc */
{ 0x0a, 0x15, 0x0a, 0x15, 0x0a, 0x15, 0x0a }, /* fd */
{ 0x15, 0x0a, 0x15, 0x0a, 0x15, 0x0a, 0x15 }, /* fe */
{ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* ff */
};
static unsigned char font_player_oldlcd[256][7] = {
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 00 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 01 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 02 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 03 */
{ 0x0e, 0x11, 0x17, 0x15, 0x17, 0x10, 0x0e }, /* 04 */
{ 0x06, 0x09, 0x08, 0x1e, 0x08, 0x08, 0x1f }, /* 05 */
{ 0x04, 0x0f, 0x14, 0x0e, 0x05, 0x1e, 0x04 }, /* 06 */
{ 0x11, 0x0a, 0x1f, 0x04, 0x1f, 0x04, 0x04 }, /* 07 */
{ 0x08, 0x04, 0x0e, 0x11, 0x1f, 0x10, 0x0e }, /* 08 */
{ 0x02, 0x04, 0x0e, 0x11, 0x1f, 0x10, 0x0e }, /* 09 */
{ 0x08, 0x04, 0x00, 0x11, 0x11, 0x13, 0x0d }, /* 0a */
{ 0x08, 0x04, 0x00, 0x0c, 0x04, 0x04, 0x0e }, /* 0b */
{ 0x08, 0x04, 0x00, 0x0e, 0x11, 0x11, 0x0e }, /* 0c */
{ 0x0f, 0x10, 0x10, 0x10, 0x0f, 0x02, 0x0e }, /* 0d */
{ 0x10, 0x10, 0x17, 0x14, 0x1e, 0x04, 0x04 }, /* 0e */
{ 0x01, 0x0e, 0x13, 0x15, 0x19, 0x0e, 0x10 }, /* 0f */
{ 0x00, 0x02, 0x0e, 0x15, 0x15, 0x0e, 0x08 }, /* 10 */
{ 0x1c, 0x10, 0x17, 0x1d, 0x07, 0x06, 0x05 }, /* 11 */
{ 0x04, 0x0a, 0x04, 0x0e, 0x11, 0x1f, 0x11 }, /* 12 */
{ 0x04, 0x0a, 0x04, 0x01, 0x0f, 0x11, 0x0f }, /* 13 */
{ 0x00, 0x04, 0x04, 0x0a, 0x0a, 0x11, 0x1f }, /* 14 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f }, /* 15 */
{ 0x0e, 0x04, 0x1f, 0x15, 0x1f, 0x04, 0x0e }, /* 16 */
{ 0x1f, 0x11, 0x11, 0x10, 0x10, 0x10, 0x10 }, /* 17 */
{ 0x04, 0x04, 0x0a, 0x0a, 0x11, 0x11, 0x11 }, /* 18 */
{ 0x0e, 0x11, 0x11, 0x11, 0x0a, 0x0a, 0x1b }, /* 19 */
{ 0x1f, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a }, /* 1a */
{ 0x15, 0x15, 0x15, 0x15, 0x0e, 0x04, 0x04 }, /* 1b */
{ 0x1f, 0x08, 0x04, 0x02, 0x04, 0x08, 0x1f }, /* 1c */
{ 0x0e, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x0e }, /* 1d */
{ 0x1f, 0x11, 0x00, 0x0e, 0x00, 0x11, 0x1f }, /* 1e */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 1f */
{ 0x0f, 0x14, 0x14, 0x1f, 0x14, 0x14, 0x17 }, /* 20 */
{ 0x00, 0x00, 0x1a, 0x05, 0x0f, 0x14, 0x0f }, /* 21 */
{ 0x0c, 0x12, 0x16, 0x11, 0x11, 0x16, 0x10 }, /* 22 */
{ 0x02, 0x04, 0x1f, 0x10, 0x1c, 0x10, 0x1f }, /* 23 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 24 */
{ 0x04, 0x04, 0x04, 0x04, 0x04, 0x00, 0x04 }, /* 25 */
{ 0x1b, 0x09, 0x12, 0x00, 0x00, 0x00, 0x00 }, /* 26 */
{ 0x0a, 0x0a, 0x1f, 0x0a, 0x1f, 0x0a, 0x0a }, /* 27 */
{ 0x00, 0x11, 0x0e, 0x0a, 0x0e, 0x11, 0x00 }, /* 28 */
{ 0x18, 0x19, 0x02, 0x04, 0x08, 0x13, 0x03 }, /* 29 */
{ 0x08, 0x14, 0x14, 0x09, 0x15, 0x12, 0x0d }, /* 2a */
{ 0x0c, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00 }, /* 2b */
{ 0x02, 0x04, 0x08, 0x08, 0x08, 0x04, 0x02 }, /* 2c */
{ 0x08, 0x04, 0x02, 0x02, 0x02, 0x04, 0x08 }, /* 2d */
{ 0x04, 0x15, 0x0e, 0x04, 0x0e, 0x15, 0x04 }, /* 2e */
{ 0x00, 0x04, 0x04, 0x1f, 0x04, 0x04, 0x00 }, /* 2f */
{ 0x00, 0x00, 0x00, 0x00, 0x0c, 0x04, 0x08 }, /* 30 */
{ 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00 }, /* 31 */
{ 0x00, 0x00, 0x00, 0x00, 0x0c, 0x0c, 0x00 }, /* 32 */
{ 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x00 }, /* 33 */
{ 0x0e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 34 */
{ 0x04, 0x0c, 0x04, 0x04, 0x04, 0x04, 0x0e }, /* 35 */
{ 0x0e, 0x11, 0x01, 0x02, 0x04, 0x08, 0x1f }, /* 36 */
{ 0x1f, 0x02, 0x04, 0x02, 0x01, 0x11, 0x0e }, /* 37 */
{ 0x02, 0x06, 0x0a, 0x12, 0x1f, 0x02, 0x02 }, /* 38 */
{ 0x1f, 0x10, 0x1e, 0x01, 0x01, 0x11, 0x0e }, /* 39 */
{ 0x06, 0x08, 0x10, 0x1e, 0x11, 0x11, 0x0e }, /* 3a */
{ 0x1f, 0x01, 0x02, 0x02, 0x04, 0x04, 0x04 }, /* 3b */
{ 0x0e, 0x11, 0x11, 0x0e, 0x11, 0x11, 0x0e }, /* 3c */
{ 0x0e, 0x11, 0x11, 0x0f, 0x01, 0x02, 0x0c }, /* 3d */
{ 0x00, 0x0c, 0x0c, 0x00, 0x0c, 0x0c, 0x00 }, /* 3e */
{ 0x00, 0x0c, 0x0c, 0x00, 0x0c, 0x04, 0x08 }, /* 3f */
{ 0x03, 0x06, 0x0c, 0x18, 0x0c, 0x06, 0x03 }, /* 40 */
{ 0x00, 0x00, 0x1f, 0x00, 0x1f, 0x00, 0x00 }, /* 41 */
{ 0x18, 0x0c, 0x06, 0x03, 0x06, 0x0c, 0x18 }, /* 42 */
{ 0x0e, 0x11, 0x01, 0x02, 0x04, 0x00, 0x04 }, /* 43 */
{ 0x04, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04 }, /* 44 */
{ 0x04, 0x0a, 0x11, 0x11, 0x1f, 0x11, 0x11 }, /* 45 */
{ 0x1e, 0x11, 0x11, 0x1e, 0x11, 0x11, 0x1e }, /* 46 */
{ 0x0e, 0x11, 0x10, 0x10, 0x10, 0x11, 0x0e }, /* 47 */
{ 0x1c, 0x12, 0x11, 0x11, 0x11, 0x12, 0x1c }, /* 48 */
{ 0x1f, 0x10, 0x10, 0x1e, 0x10, 0x10, 0x1f }, /* 49 */
{ 0x1f, 0x10, 0x10, 0x1e, 0x10, 0x10, 0x10 }, /* 4a */
{ 0x0e, 0x10, 0x10, 0x17, 0x11, 0x11, 0x0e }, /* 4b */
{ 0x11, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11 }, /* 4c */
{ 0x0e, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e }, /* 4d */
{ 0x0f, 0x02, 0x02, 0x02, 0x02, 0x12, 0x0c }, /* 4e */
{ 0x11, 0x12, 0x14, 0x18, 0x14, 0x12, 0x11 }, /* 4f */
{ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1f }, /* 50 */
{ 0x11, 0x1b, 0x15, 0x11, 0x11, 0x11, 0x11 }, /* 51 */
{ 0x11, 0x11, 0x19, 0x15, 0x13, 0x11, 0x11 }, /* 52 */
{ 0x0e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 53 */
{ 0x1e, 0x11, 0x11, 0x1e, 0x10, 0x10, 0x10 }, /* 54 */
{ 0x0e, 0x11, 0x11, 0x11, 0x11, 0x12, 0x0d }, /* 55 */
{ 0x1e, 0x11, 0x11, 0x1e, 0x14, 0x12, 0x11 }, /* 56 */
{ 0x0e, 0x11, 0x10, 0x0e, 0x01, 0x11, 0x0e }, /* 57 */
{ 0x1f, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04 }, /* 58 */
{ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 59 */
{ 0x11, 0x11, 0x11, 0x11, 0x11, 0x0a, 0x04 }, /* 5a */
{ 0x11, 0x11, 0x11, 0x11, 0x11, 0x15, 0x0a }, /* 5b */
{ 0x11, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x11 }, /* 5c */
{ 0x11, 0x11, 0x0a, 0x04, 0x04, 0x04, 0x04 }, /* 5d */
{ 0x1f, 0x01, 0x02, 0x04, 0x08, 0x10, 0x1f }, /* 5e */
{ 0x0a, 0x00, 0x04, 0x0a, 0x11, 0x1f, 0x11 }, /* 5f */
{ 0x0a, 0x00, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 60 */
{ 0x0d, 0x12, 0x00, 0x19, 0x15, 0x13, 0x11 }, /* 61 */
{ 0x0a, 0x00, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 62 */
{ 0x0e, 0x10, 0x0e, 0x11, 0x0e, 0x01, 0x0e }, /* 63 */
{ 0x04, 0x00, 0x04, 0x08, 0x10, 0x11, 0x0e }, /* 64 */
{ 0x00, 0x00, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 65 */
{ 0x10, 0x10, 0x1e, 0x11, 0x11, 0x11, 0x1e }, /* 66 */
{ 0x00, 0x00, 0x0f, 0x10, 0x10, 0x10, 0x0f }, /* 67 */
{ 0x01, 0x01, 0x0f, 0x11, 0x11, 0x11, 0x0f }, /* 68 */
{ 0x00, 0x00, 0x0e, 0x11, 0x1f, 0x10, 0x0f }, /* 69 */
{ 0x03, 0x04, 0x0f, 0x04, 0x04, 0x04, 0x04 }, /* 6a */
{ 0x00, 0x00, 0x0f, 0x11, 0x0f, 0x01, 0x0e }, /* 6b */
{ 0x10, 0x10, 0x16, 0x19, 0x11, 0x11, 0x11 }, /* 6c */
{ 0x04, 0x00, 0x0c, 0x04, 0x04, 0x04, 0x0e }, /* 6d */
{ 0x02, 0x00, 0x06, 0x02, 0x02, 0x12, 0x0c }, /* 6e */
{ 0x08, 0x08, 0x09, 0x0a, 0x0c, 0x0a, 0x09 }, /* 6f */
{ 0x0c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e }, /* 70 */
{ 0x00, 0x00, 0x1a, 0x15, 0x15, 0x15, 0x15 }, /* 71 */
{ 0x00, 0x00, 0x16, 0x19, 0x11, 0x11, 0x11 }, /* 72 */
{ 0x00, 0x00, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 73 */
{ 0x00, 0x00, 0x1e, 0x11, 0x1e, 0x10, 0x10 }, /* 74 */
{ 0x00, 0x00, 0x0f, 0x11, 0x0f, 0x01, 0x01 }, /* 75 */
{ 0x00, 0x00, 0x0b, 0x0c, 0x08, 0x08, 0x08 }, /* 76 */
{ 0x00, 0x00, 0x0e, 0x10, 0x0e, 0x01, 0x1e }, /* 77 */
{ 0x04, 0x04, 0x0f, 0x04, 0x04, 0x04, 0x03 }, /* 78 */
{ 0x00, 0x00, 0x11, 0x11, 0x11, 0x13, 0x0d }, /* 79 */
{ 0x00, 0x00, 0x11, 0x11, 0x11, 0x0a, 0x04 }, /* 7a */
{ 0x00, 0x00, 0x11, 0x11, 0x11, 0x15, 0x0a }, /* 7b */
{ 0x00, 0x00, 0x11, 0x0a, 0x04, 0x0a, 0x11 }, /* 7c */
{ 0x00, 0x00, 0x11, 0x11, 0x0f, 0x01, 0x1e }, /* 7d */
{ 0x00, 0x00, 0x1f, 0x02, 0x04, 0x08, 0x1f }, /* 7e */
{ 0x0a, 0x00, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 7f */
{ 0x00, 0x0a, 0x00, 0x0e, 0x11, 0x11, 0x0e }, /* 80 */
{ 0x0d, 0x12, 0x00, 0x16, 0x19, 0x11, 0x11 }, /* 81 */
{ 0x00, 0x0a, 0x00, 0x11, 0x11, 0x13, 0x0d }, /* 82 */
{ 0x08, 0x04, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 83 */
{ 0x00, 0x0f, 0x10, 0x10, 0x0f, 0x02, 0x04 }, /* 84 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x00 }, /* 85 */
{ 0x00, 0x00, 0x04, 0x0e, 0x1f, 0x00, 0x00 }, /* 86 */
{ 0x00, 0x00, 0x1f, 0x0e, 0x04, 0x00, 0x00 }, /* 87 */
{ 0x02, 0x06, 0x0e, 0x1e, 0x0e, 0x06, 0x02 }, /* 88 */
{ 0x08, 0x0c, 0x0e, 0x0f, 0x0e, 0x0c, 0x08 }, /* 89 */
{ 0x1c, 0x1f, 0x13, 0x10, 0x10, 0x10, 0x10 }, /* 8a */
{ 0x15, 0x0a, 0x15, 0x0a, 0x15, 0x0a, 0x15 }, /* 8b */
{ 0x08, 0x04, 0x0e, 0x11, 0x1f, 0x11, 0x11 }, /* 8c */
{ 0x02, 0x04, 0x0e, 0x11, 0x1f, 0x11, 0x11 }, /* 8d */
{ 0x04, 0x0a, 0x0e, 0x11, 0x1f, 0x11, 0x11 }, /* 8e */
{ 0x0d, 0x12, 0x0e, 0x11, 0x1f, 0x11, 0x11 }, /* 8f */
{ 0x08, 0x04, 0x1f, 0x10, 0x1e, 0x10, 0x1f }, /* 90 */
{ 0x04, 0x0a, 0x1f, 0x10, 0x1c, 0x10, 0x1f }, /* 91 */
{ 0x0a, 0x00, 0x1f, 0x10, 0x1c, 0x10, 0x1f }, /* 92 */
{ 0x08, 0x04, 0x0e, 0x04, 0x04, 0x04, 0x0e }, /* 93 */
{ 0x02, 0x04, 0x0e, 0x04, 0x04, 0x04, 0x0e }, /* 94 */
{ 0x0c, 0x0a, 0x09, 0x1d, 0x09, 0x0a, 0x0c }, /* 95 */
{ 0x08, 0x04, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 96 */
{ 0x02, 0x04, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 97 */
{ 0x04, 0x0a, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 98 */
{ 0x0d, 0x12, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 99 */
{ 0x08, 0x04, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 9a */
{ 0x02, 0x04, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 9b */
{ 0x02, 0x04, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 9c */
{ 0x04, 0x0a, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 9d */
{ 0x0d, 0x12, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 9e */
{ 0x04, 0x0a, 0x0e, 0x11, 0x1f, 0x10, 0x0e }, /* 9f */
{ 0x0a, 0x00, 0x0e, 0x11, 0x1f, 0x10, 0x0e }, /* a0 */
{ 0x02, 0x04, 0x00, 0x0c, 0x04, 0x04, 0x0e }, /* a1 */
{ 0x04, 0x0a, 0x00, 0x0c, 0x04, 0x04, 0x0e }, /* a2 */
{ 0x0a, 0x00, 0x00, 0x0c, 0x04, 0x04, 0x0e }, /* a3 */
{ 0x02, 0x04, 0x00, 0x0e, 0x11, 0x11, 0x0e }, /* a4 */
{ 0x04, 0x0a, 0x00, 0x0e, 0x11, 0x11, 0x0e }, /* a5 */
{ 0x0d, 0x12, 0x00, 0x0e, 0x11, 0x11, 0x0e }, /* a6 */
{ 0x02, 0x04, 0x00, 0x11, 0x11, 0x13, 0x0d }, /* a7 */
{ 0x04, 0x04, 0x0f, 0x10, 0x10, 0x0f, 0x04 }, /* a8 */
{ 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03 }, /* a9 */
{ 0x0a, 0x04, 0x0b, 0x0c, 0x08, 0x08, 0x08 }, /* aa */
{ 0x0a, 0x04, 0x0f, 0x10, 0x10, 0x10, 0x0f }, /* ab */
{ 0x0a, 0x04, 0x0e, 0x10, 0x0e, 0x01, 0x1e }, /* ac */
{ 0x0a, 0x04, 0x0e, 0x11, 0x1f, 0x10, 0x0e }, /* ad */
{ 0x04, 0x0a, 0x04, 0x11, 0x11, 0x13, 0x0d }, /* ae */
{ 0x02, 0x04, 0x11, 0x11, 0x0f, 0x01, 0x0e }, /* af */
{ 0x02, 0x0f, 0x02, 0x0e, 0x12, 0x12, 0x0e }, /* b0 */
{ 0x02, 0x04, 0x0f, 0x10, 0x10, 0x10, 0x0f }, /* b1 */
{ 0x0e, 0x11, 0x1f, 0x10, 0x0e, 0x04, 0x06 }, /* b2 */
{ 0x0e, 0x01, 0x0f, 0x11, 0x0f, 0x02, 0x03 }, /* b3 */
{ 0x04, 0x00, 0x1f, 0x02, 0x04, 0x08, 0x1f }, /* b4 */
{ 0x02, 0x04, 0x1f, 0x02, 0x04, 0x08, 0x1f }, /* b5 */
{ 0x02, 0x04, 0x0e, 0x10, 0x0e, 0x01, 0x1e }, /* b6 */
{ 0x02, 0x04, 0x16, 0x19, 0x11, 0x11, 0x11 }, /* b7 */
{ 0x0c, 0x04, 0x06, 0x0c, 0x04, 0x04, 0x0e }, /* b8 */
{ 0x04, 0x0e, 0x1f, 0x1f, 0x1b, 0x04, 0x0e }, /* b9 */
{ 0x0a, 0x04, 0x16, 0x19, 0x11, 0x11, 0x11 }, /* ba */
{ 0x09, 0x09, 0x08, 0x1e, 0x08, 0x08, 0x06 }, /* bb */
{ 0x05, 0x05, 0x0c, 0x14, 0x14, 0x14, 0x0c }, /* bc */
{ 0x0a, 0x04, 0x1f, 0x02, 0x04, 0x08, 0x1f }, /* bd */
{ 0x0f, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* be */
{ 0x0f, 0x10, 0x01, 0x01, 0x01, 0x01, 0x01 }, /* bf */
{ 0x1e, 0x01, 0x00, 0x00, 0x00, 0x00, 0x1f }, /* c0 */
{ 0x1f, 0x00, 0x0e, 0x10, 0x17, 0x11, 0x0e }, /* c1 */
{ 0x1f, 0x00, 0x0f, 0x11, 0x0f, 0x01, 0x0e }, /* c2 */
{ 0x0e, 0x10, 0x0e, 0x01, 0x0e, 0x04, 0x0c }, /* c3 */
{ 0x00, 0x0e, 0x10, 0x0e, 0x01, 0x0e, 0x04 }, /* c4 */
{ 0x04, 0x00, 0x0e, 0x04, 0x04, 0x04, 0x0e }, /* c5 */
{ 0x00, 0x00, 0x0c, 0x04, 0x04, 0x04, 0x0e }, /* c6 */
{ 0x05, 0x0a, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* c7 */
{ 0x09, 0x12, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* c8 */
{ 0x09, 0x12, 0x00, 0x11, 0x11, 0x13, 0x0d }, /* c9 */
{ 0x09, 0x12, 0x00, 0x0e, 0x11, 0x11, 0x0e }, /* ca */
{ 0x01, 0x01, 0x01, 0x01, 0x01, 0x10, 0x0f }, /* cb */
{ 0x10, 0x10, 0x10, 0x10, 0x10, 0x01, 0x1e }, /* cc */
{ 0x00, 0x1b, 0x1f, 0x1f, 0x0e, 0x04, 0x00 }, /* cd */
{ 0x18, 0x08, 0x08, 0x08, 0x08, 0x08, 0x18 }, /* ce */
{ 0x0e, 0x11, 0x04, 0x0a, 0x1b, 0x1f, 0x00 }, /* cf */
{ 0x0a, 0x15, 0x04, 0x07, 0x00, 0x11, 0x0a }, /* d0 */
{ 0x0f, 0x10, 0x00, 0x00, 0x00, 0x00, 0x1f }, /* d1 */
{ 0x01, 0x03, 0x1d, 0x11, 0x1d, 0x03, 0x01 }, /* d2 */
{ 0x0e, 0x11, 0x11, 0x1f, 0x1b, 0x1b, 0x1f }, /* d3 */
{ 0x00, 0x01, 0x02, 0x0a, 0x04, 0x04, 0x00 }, /* d4 */
{ 0x04, 0x0e, 0x1f, 0x00, 0x1f, 0x0e, 0x04 }, /* d5 */
{ 0x02, 0x02, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e }, /* d6 */
{ 0x1b, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1b }, /* d7 */
{ 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b }, /* d8 */
{ 0x04, 0x0f, 0x04, 0x04, 0x04, 0x03, 0x06 }, /* d9 */
{ 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b }, /* da */
{ 0x00, 0x04, 0x0e, 0x1f, 0x0e, 0x04, 0x00 }, /* db */
{ 0x00, 0x00, 0x1f, 0x1b, 0x15, 0x11, 0x1f }, /* dc */
{ 0x0e, 0x0e, 0x04, 0x1f, 0x0e, 0x0e, 0x0a }, /* dd */
{ 0x00, 0x00, 0x00, 0x00, 0x0a, 0x04, 0x0a }, /* de */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f }, /* df */
{ 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x1f }, /* e0 */
{ 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f }, /* e1 */
{ 0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* e2 */
{ 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* e3 */
{ 0x00, 0x00, 0x01, 0x02, 0x04, 0x04, 0x04 }, /* e4 */
{ 0x04, 0x09, 0x0a, 0x0a, 0x0a, 0x09, 0x04 }, /* e5 */
{ 0x00, 0x1f, 0x11, 0x11, 0x1f, 0x04, 0x1f }, /* e6 */
{ 0x00, 0x07, 0x03, 0x05, 0x08, 0x10, 0x00 }, /* e7 */
{ 0x00, 0x10, 0x08, 0x05, 0x03, 0x07, 0x00 }, /* e8 */
{ 0x09, 0x06, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* e9 */
{ 0x1e, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* ea */
{ 0x00, 0x00, 0x10, 0x08, 0x04, 0x04, 0x04 }, /* eb */
{ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* ec */
{ 0x1f, 0x18, 0x14, 0x12, 0x15, 0x18, 0x1f }, /* ed */
{ 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* ee */
{ 0x1f, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10 }, /* ef */
{ 0x00, 0x03, 0x07, 0x0c, 0x18, 0x1c, 0x1c }, /* f0 */
{ 0x1c, 0x10, 0x1c, 0x07, 0x1c, 0x04, 0x07 }, /* f1 */
{ 0x00, 0x1e, 0x03, 0x09, 0x19, 0x09, 0x1d }, /* f2 */
{ 0x1e, 0x01, 0x19, 0x05, 0x09, 0x1d, 0x01 }, /* f3 */
{ 0x04, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00 }, /* f4 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0f }, /* f5 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x1e }, /* f6 */
{ 0x04, 0x04, 0x04, 0x08, 0x10, 0x00, 0x00 }, /* f7 */
{ 0x07, 0x03, 0x05, 0x08, 0x10, 0x10, 0x0f }, /* f8 */
{ 0x04, 0x0e, 0x1f, 0x11, 0x11, 0x15, 0x1f }, /* f9 */
{ 0x1f, 0x03, 0x1a, 0x02, 0x1a, 0x02, 0x1e }, /* fa */
{ 0x00, 0x0e, 0x1f, 0x11, 0x1f, 0x0e, 0x00 }, /* fb */
{ 0x03, 0x05, 0x09, 0x09, 0x0b, 0x1b, 0x18 }, /* fc */
{ 0x1f, 0x03, 0x05, 0x09, 0x15, 0x03, 0x1f }, /* fd */
{ 0x10, 0x10, 0x10, 0x10, 0x10, 0x1c, 0x1c }, /* fe */
{ 0x1c, 0x1c, 0x10, 0x10, 0x10, 0x10, 0x10 }, /* ff */
};
static unsigned char (*font_player)[256][7];
static unsigned bitmap[BITMAP_WIDTH][CHAR_HEIGHT];
static bool show_subst, show_hardware;
static bool newlcd;
bool is_new_player(void)
{
return newlcd;
}
static void draw_pattern(int fg, int bg, int x, const unsigned char *pattern)
{
int x2, y2;
for (y2 = 0; y2 < 7; y2++)
{
unsigned data = pattern[y2];
for (x2 = 0; x2 < 5; x2++)
bitmap[x+x2][y2] = (data & (0x10 >> x2)) ? fg : bg;
}
}
static void draw_hexdigit(int x, int digit)
{
int x2, y2;
draw_pattern(CHAR_FG_STD, CHAR_BG_STD, x + 1,
font_player_newlcd[digit+(digit<10?'0':'A'-10)]);
for (y2 = 0; y2 < CHAR_HEIGHT; y2++)
for (x2 = 0; x2 < CHAR_WIDTH; x2++)
bitmap[x+x2][y2] ^= 0xffffff;
}
static void flush_bitmap(FILE *fp)
{
int x, y;
for (y = 0; y < CHAR_HEIGHT; y++)
{
int i, z;
for (i = 0; i < SIZE; i++)
{
for (x = 0; x < BITMAP_WIDTH; x++)
{
unsigned int col = bitmap[x][y];
for (z = 0; z < SIZE; z++)
{
fprintf(fp, "%d %d %d ", (col >> 16) & 255,
(col >> 8) & 255, (col) & 255);
}
}
fprintf(fp, "\n");
}
}
}
int main(int argc, char **argv)
{
int x, y;
int i, lines, block, oldblock;
int loop;
char *filename;
FILE *fp;
printf("This tool will generate gif-pictures that reflect the current "
"unicode charset of the Player.\n");
for (loop = 0; loop < 6; loop++)
{
switch (loop)
{
case 0:
font_player = &font_player_oldlcd;
newlcd = false;
lcd_charset_init();
filename = "lcd_old.gif";
show_subst = false;
show_hardware = false;
break;
case 1:
font_player = &font_player_newlcd;
newlcd = true;
lcd_charset_init();
filename = "lcd_new.gif";
show_subst = false;
show_hardware = false;
break;
case 2:
font_player = &font_player_oldlcd;
newlcd = false;
lcd_charset_init();
filename = "lcd_old_subst.gif";
show_subst = true;
show_hardware = false;
break;
case 3:
font_player = &font_player_newlcd;
newlcd = true;
lcd_charset_init();
filename = "lcd_new_subst.gif";
show_subst = true;
show_hardware = false;
break;
case 4:
font_player = &font_player_oldlcd;
xchar_info = NULL;
xchar_info_size = 256;
filename = "lcd_old_hw.gif";
show_subst = true;
show_hardware = true;
break;
case 5:
font_player = &font_player_newlcd;
xchar_info = NULL;
xchar_info_size = 256;
filename = "lcd_new_hw.gif";
show_subst = true;
show_hardware = true;
break;
default:
printf("Not in loop!\n");
exit(0);
}
fp = fopen("tmp.pnm", "wb");
if (!fp)
{
printf("Error opening %s!\n", filename);
exit(0);
}
if (show_hardware)
{
/* hardware mapping is always 16 lines */
lines = 16;
}
else
{
/* count lines */
for (lines = 0, oldblock = -1, i = 0; i < xchar_info_size; i++)
{
block = xchar_info[i].ucs >> 4;
if (block != oldblock)
{
lines++;
oldblock = block;
}
}
}
fprintf(fp, "P3\n#PNM showing a picture of the Player unicode charset\n");
fprintf(fp, "%d %d\n255\n", BITMAP_WIDTH*SIZE, CHAR_HEIGHT*SIZE*(lines+1));
memset(bitmap, 255, sizeof(bitmap));
for (x = 0; x < 16; x++)
{
draw_hexdigit(3*CHAR_WIDTH + x * CHAR_WIDTH, x);
}
for (oldblock = -1, i = 0; i < xchar_info_size; i++)
{
block = show_hardware ? (i >> 4) : (xchar_info[i].ucs >> 4);
if (block != oldblock)
{
flush_bitmap(fp);
memset(bitmap, 255, sizeof(bitmap));
draw_hexdigit(0, (block >> 8) & 0xf);
draw_hexdigit(CHAR_WIDTH, (block >> 4) & 0xf);
draw_hexdigit(2*CHAR_WIDTH, block & 0xf);
oldblock = block;
}
if (show_hardware)
{
draw_pattern(CHAR_FG_STD, CHAR_BG_STD,
3*CHAR_WIDTH+1 + (i & 0xf) * CHAR_WIDTH,
(*font_player)[i]);
}
else
{
if (xchar_info[i].priority == 0)
{
draw_pattern(CHAR_FG_STD, CHAR_BG_STD,
3*CHAR_WIDTH+1
+ (xchar_info[i].ucs & 0xf) * CHAR_WIDTH,
(*font_player)[xchar_info[i].hw_char]);
}
else
{
if (show_subst)
{
draw_pattern(CHAR_FG_ALT, CHAR_BG_STD,
3*CHAR_WIDTH+1
+ (xchar_info[i].ucs & 0xf) * CHAR_WIDTH,
(*font_player)[xchar_info[i].hw_char]);
}
else
{
if ((xchar_info[i].glyph & 0x8000) == 0)
draw_pattern(CHAR_FG_ALT, CHAR_BG_STD,
3*CHAR_WIDTH+1
+ (xchar_info[i].ucs & 0xf) * CHAR_WIDTH,
xfont_fixed[xchar_info[i].glyph]);
else
draw_pattern(CHAR_FG_STD, CHAR_BG_ALT,
3*CHAR_WIDTH+1
+ (xchar_info[i].ucs & 0xf) * CHAR_WIDTH,
font_player_newlcd[' ']);
}
}
}
}
flush_bitmap(fp);
fclose(fp);
{
char buffer[200];
sprintf(buffer, "convert tmp.pnm %s", filename);
system(buffer);
remove("tmp.pnm");
}
}
}

5
uisimulator/common/SOURCES
View file

@ -1,11 +1,6 @@
#ifdef SIMULATOR
lcd-common.c
#ifdef HAVE_LCD_CHARCELLS
font-player.c
lcd-playersim.c
sim_icons.c
#endif
sim_tasks.c
fmradio.c
backlight-sim.c

2
uisimulator/common/backlight-sim.c
View file

@ -27,7 +27,7 @@
#ifdef HAVE_LCD_SLEEP
extern void lcd_awake(void);
#endif
/* in uisimulator/sdl/lcd-bitmap.c and lcd-charcell.c */
/* in uisimulator/sdl/lcd-bitmap.c */
extern void sim_backlight(int value);
bool backlight_hw_init(void)

548
uisimulator/common/font-player.c
View file

@ -1,548 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "font-player.h"
#include "hwcompat.h"
static unsigned char font_player_newlcd[256][7] = {
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 00 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 01 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 02 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 03 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 04 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 05 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 06 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 07 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 08 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 09 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0a */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0b */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0c */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0d */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0e */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0f */
{ 0x00, 0x10, 0x1c, 0x1f, 0x1c, 0x10, 0x00 }, /* 10 */
{ 0x00, 0x01, 0x07, 0x1f, 0x07, 0x01, 0x00 }, /* 11 */
{ 0x00, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00 }, /* 12 */
{ 0x0a, 0x0a, 0x0a, 0x0a, 0x00, 0x00, 0x0a }, /* 13 */
{ 0x0f, 0x1d, 0x1d, 0x0d, 0x05, 0x05, 0x05 }, /* 14 */
{ 0x07, 0x08, 0x0e, 0x11, 0x0e, 0x02, 0x1c }, /* 15 */
{ 0x00, 0x00, 0x1f, 0x1f, 0x00, 0x00, 0x00 }, /* 16 */
{ 0x01, 0x01, 0x05, 0x09, 0x1f, 0x08, 0x04 }, /* 17 */
{ 0x04, 0x0e, 0x15, 0x04, 0x04, 0x04, 0x04 }, /* 18 */
{ 0x04, 0x04, 0x04, 0x04, 0x15, 0x0e, 0x04 }, /* 19 */
{ 0x11, 0x19, 0x1d, 0x1f, 0x1d, 0x19, 0x11 }, /* 1a */
{ 0x11, 0x13, 0x17, 0x1f, 0x17, 0x13, 0x11 }, /* 1b */
{ 0x10, 0x14, 0x12, 0x1f, 0x12, 0x14, 0x10 }, /* 1c */
{ 0x01, 0x05, 0x09, 0x1f, 0x09, 0x05, 0x01 }, /* 1d */
{ 0x00, 0x1f, 0x0e, 0x0e, 0x04, 0x04, 0x00 }, /* 1e */
{ 0x00, 0x04, 0x04, 0x0e, 0x0e, 0x1f, 0x00 }, /* 1f */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 20 */
{ 0x04, 0x04, 0x04, 0x04, 0x00, 0x00, 0x04 }, /* 21 */
{ 0x0a, 0x0a, 0x0a, 0x00, 0x00, 0x00, 0x00 }, /* 22 */
{ 0x0a, 0x0a, 0x1f, 0x0a, 0x1f, 0x0a, 0x0a }, /* 23 */
{ 0x04, 0x0f, 0x14, 0x0e, 0x05, 0x1e, 0x04 }, /* 24 */
{ 0x18, 0x19, 0x02, 0x04, 0x08, 0x13, 0x03 }, /* 25 */
{ 0x0c, 0x12, 0x14, 0x08, 0x15, 0x12, 0x0d }, /* 26 */
{ 0x0c, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00 }, /* 27 */
{ 0x02, 0x04, 0x08, 0x08, 0x08, 0x04, 0x02 }, /* 28 */
{ 0x08, 0x04, 0x02, 0x02, 0x02, 0x04, 0x08 }, /* 29 */
{ 0x00, 0x04, 0x15, 0x0e, 0x15, 0x04, 0x00 }, /* 2a */
{ 0x00, 0x04, 0x04, 0x1f, 0x04, 0x04, 0x00 }, /* 2b */
{ 0x00, 0x00, 0x00, 0x00, 0x0c, 0x04, 0x08 }, /* 2c */
{ 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00 }, /* 2d */
{ 0x00, 0x00, 0x00, 0x00, 0x0c, 0x0c, 0x00 }, /* 2e */
{ 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x00 }, /* 2f */
{ 0x0e, 0x11, 0x13, 0x15, 0x19, 0x11, 0x0e }, /* 30 */
{ 0x04, 0x0c, 0x04, 0x04, 0x04, 0x04, 0x0e }, /* 31 */
{ 0x0e, 0x11, 0x01, 0x02, 0x04, 0x08, 0x1f }, /* 32 */
{ 0x1f, 0x02, 0x04, 0x02, 0x01, 0x11, 0x0e }, /* 33 */
{ 0x02, 0x06, 0x0a, 0x12, 0x1f, 0x02, 0x02 }, /* 34 */
{ 0x1f, 0x10, 0x1e, 0x01, 0x01, 0x11, 0x0e }, /* 35 */
{ 0x06, 0x08, 0x10, 0x1e, 0x11, 0x11, 0x0e }, /* 36 */
{ 0x1f, 0x01, 0x02, 0x02, 0x04, 0x04, 0x04 }, /* 37 */
{ 0x0e, 0x11, 0x11, 0x0e, 0x11, 0x11, 0x0e }, /* 38 */
{ 0x0e, 0x11, 0x11, 0x0f, 0x01, 0x02, 0x0c }, /* 39 */
{ 0x00, 0x0c, 0x0c, 0x00, 0x0c, 0x0c, 0x00 }, /* 3a */
{ 0x0c, 0x0c, 0x00, 0x0c, 0x0c, 0x04, 0x08 }, /* 3b */
{ 0x02, 0x04, 0x08, 0x10, 0x08, 0x04, 0x02 }, /* 3c */
{ 0x00, 0x00, 0x1f, 0x00, 0x1f, 0x00, 0x00 }, /* 3d */
{ 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08 }, /* 3e */
{ 0x0e, 0x11, 0x01, 0x02, 0x04, 0x00, 0x04 }, /* 3f */
{ 0x0e, 0x11, 0x01, 0x0d, 0x15, 0x15, 0x0e }, /* 40 */
{ 0x0e, 0x11, 0x11, 0x11, 0x1f, 0x11, 0x11 }, /* 41 */
{ 0x1e, 0x11, 0x11, 0x1e, 0x11, 0x11, 0x1e }, /* 42 */
{ 0x0e, 0x11, 0x10, 0x10, 0x10, 0x11, 0x0e }, /* 43 */
{ 0x1c, 0x12, 0x11, 0x11, 0x11, 0x12, 0x1c }, /* 44 */
{ 0x1f, 0x10, 0x10, 0x1e, 0x10, 0x10, 0x1f }, /* 45 */
{ 0x1f, 0x10, 0x10, 0x1e, 0x10, 0x10, 0x10 }, /* 46 */
{ 0x0e, 0x11, 0x10, 0x17, 0x11, 0x11, 0x0f }, /* 47 */
{ 0x11, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11 }, /* 48 */
{ 0x0e, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e }, /* 49 */
{ 0x0f, 0x02, 0x02, 0x02, 0x02, 0x12, 0x0c }, /* 4a */
{ 0x11, 0x12, 0x14, 0x18, 0x14, 0x12, 0x11 }, /* 4b */
{ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1f }, /* 4c */
{ 0x11, 0x1b, 0x15, 0x15, 0x11, 0x11, 0x11 }, /* 4d */
{ 0x11, 0x11, 0x19, 0x15, 0x13, 0x11, 0x11 }, /* 4e */
{ 0x0e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 4f */
{ 0x1e, 0x11, 0x11, 0x1e, 0x10, 0x10, 0x10 }, /* 50 */
{ 0x0e, 0x11, 0x11, 0x11, 0x11, 0x12, 0x0d }, /* 51 */
{ 0x1e, 0x11, 0x11, 0x1e, 0x14, 0x12, 0x11 }, /* 52 */
{ 0x0e, 0x11, 0x10, 0x0e, 0x01, 0x11, 0x0e }, /* 53 */
{ 0x1f, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04 }, /* 54 */
{ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 55 */
{ 0x11, 0x11, 0x11, 0x11, 0x11, 0x0a, 0x04 }, /* 56 */
{ 0x11, 0x11, 0x11, 0x15, 0x15, 0x15, 0x0a }, /* 57 */
{ 0x11, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x11 }, /* 58 */
{ 0x11, 0x11, 0x0a, 0x04, 0x04, 0x04, 0x04 }, /* 59 */
{ 0x1f, 0x01, 0x02, 0x04, 0x08, 0x10, 0x1f }, /* 5a */
{ 0x0e, 0x08, 0x08, 0x08, 0x08, 0x08, 0x0e }, /* 5b */
{ 0x11, 0x0a, 0x1f, 0x04, 0x1f, 0x04, 0x04 }, /* 5c */
{ 0x0e, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0e }, /* 5d */
{ 0x04, 0x0a, 0x11, 0x00, 0x00, 0x00, 0x00 }, /* 5e */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f }, /* 5f */
{ 0x08, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00 }, /* 60 */
{ 0x00, 0x00, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 61 */
{ 0x10, 0x10, 0x16, 0x19, 0x11, 0x11, 0x1e }, /* 62 */
{ 0x00, 0x00, 0x0e, 0x10, 0x10, 0x11, 0x0e }, /* 63 */
{ 0x01, 0x01, 0x0d, 0x13, 0x11, 0x11, 0x0f }, /* 64 */
{ 0x00, 0x00, 0x0e, 0x11, 0x1f, 0x10, 0x0e }, /* 65 */
{ 0x06, 0x09, 0x08, 0x1c, 0x08, 0x08, 0x08 }, /* 66 */
{ 0x00, 0x0f, 0x11, 0x11, 0x0f, 0x01, 0x0e }, /* 67 */
{ 0x10, 0x10, 0x16, 0x19, 0x11, 0x11, 0x11 }, /* 68 */
{ 0x04, 0x00, 0x0c, 0x04, 0x04, 0x04, 0x0e }, /* 69 */
{ 0x02, 0x00, 0x06, 0x02, 0x02, 0x12, 0x0c }, /* 6a */
{ 0x10, 0x10, 0x12, 0x14, 0x18, 0x14, 0x12 }, /* 6b */
{ 0x0c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e }, /* 6c */
{ 0x00, 0x00, 0x1a, 0x15, 0x15, 0x11, 0x11 }, /* 6d */
{ 0x00, 0x00, 0x16, 0x19, 0x11, 0x11, 0x11 }, /* 6e */
{ 0x00, 0x00, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 6f */
{ 0x00, 0x00, 0x1e, 0x11, 0x1e, 0x10, 0x10 }, /* 70 */
{ 0x00, 0x00, 0x0d, 0x13, 0x0f, 0x01, 0x01 }, /* 71 */
{ 0x00, 0x00, 0x16, 0x19, 0x10, 0x10, 0x10 }, /* 72 */
{ 0x00, 0x00, 0x0e, 0x10, 0x0e, 0x01, 0x1e }, /* 73 */
{ 0x08, 0x08, 0x1c, 0x08, 0x08, 0x09, 0x06 }, /* 74 */
{ 0x00, 0x00, 0x11, 0x11, 0x11, 0x13, 0x0d }, /* 75 */
{ 0x00, 0x00, 0x11, 0x11, 0x11, 0x0a, 0x04 }, /* 76 */
{ 0x00, 0x00, 0x11, 0x11, 0x15, 0x15, 0x0a }, /* 77 */
{ 0x00, 0x00, 0x11, 0x0a, 0x04, 0x0a, 0x11 }, /* 78 */
{ 0x00, 0x00, 0x11, 0x11, 0x0f, 0x01, 0x1e }, /* 79 */
{ 0x00, 0x00, 0x1f, 0x02, 0x04, 0x08, 0x1f }, /* 7a */
{ 0x02, 0x04, 0x04, 0x08, 0x04, 0x04, 0x02 }, /* 7b */
{ 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04 }, /* 7c */
{ 0x08, 0x04, 0x04, 0x02, 0x04, 0x04, 0x08 }, /* 7d */
{ 0x00, 0x04, 0x02, 0x1f, 0x02, 0x04, 0x00 }, /* 7e */
{ 0x00, 0x04, 0x08, 0x1f, 0x08, 0x04, 0x00 }, /* 7f */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f }, /* 80 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f }, /* 81 */
{ 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x1f }, /* 82 */
{ 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f }, /* 83 */
{ 0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* 84 */
{ 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* 85 */
{ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* 86 */
{ 0x00, 0x0a, 0x04, 0x1f, 0x04, 0x0a, 0x00 }, /* 87 */
{ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11 }, /* 88 */
{ 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19 }, /* 89 */
{ 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d }, /* 8a */
{ 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08 }, /* 8b */
{ 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c }, /* 8c */
{ 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e }, /* 8d */
{ 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f }, /* 8e */
{ 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x00 }, /* 8f */
{ 0x00, 0x0e, 0x1f, 0x1f, 0x1f, 0x0e, 0x00 }, /* 90 */
{ 0x1f, 0x11, 0x11, 0x11, 0x11, 0x11, 0x1f }, /* 91 */
{ 0x1f, 0x1b, 0x13, 0x1b, 0x1b, 0x11, 0x1f }, /* 92 */
{ 0x1f, 0x11, 0x1d, 0x1b, 0x17, 0x11, 0x1f }, /* 93 */
{ 0x00, 0x00, 0x07, 0x04, 0x04, 0x14, 0x08 }, /* 94 */
{ 0x04, 0x04, 0x1f, 0x04, 0x04, 0x00, 0x1f }, /* 95 */
{ 0x00, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x00 }, /* 96 */
{ 0x00, 0x04, 0x00, 0x1f, 0x00, 0x04, 0x00 }, /* 97 */
{ 0x1f, 0x00, 0x11, 0x0a, 0x04, 0x0a, 0x11 }, /* 98 */
{ 0x1c, 0x04, 0x1c, 0x10, 0x1c, 0x00, 0x00 }, /* 99 */
{ 0x1c, 0x04, 0x1c, 0x04, 0x1c, 0x00, 0x00 }, /* 9a */
{ 0x11, 0x12, 0x17, 0x09, 0x17, 0x04, 0x07 }, /* 9b */
{ 0x11, 0x12, 0x14, 0x09, 0x13, 0x07, 0x01 }, /* 9c */
{ 0x18, 0x09, 0x1a, 0x0d, 0x1b, 0x17, 0x01 }, /* 9d */
{ 0x00, 0x05, 0x0a, 0x14, 0x0a, 0x05, 0x00 }, /* 9e */
{ 0x00, 0x14, 0x0a, 0x05, 0x0a, 0x14, 0x00 }, /* 9f */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* a0 */
{ 0x00, 0x00, 0x00, 0x00, 0x1c, 0x14, 0x1c }, /* a1 */
{ 0x07, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00 }, /* a2 */
{ 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x1c }, /* a3 */
{ 0x00, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04 }, /* a4 */
{ 0x00, 0x00, 0x00, 0x0c, 0x0c, 0x00, 0x00 }, /* a5 */
{ 0x00, 0x1f, 0x01, 0x1f, 0x01, 0x02, 0x04 }, /* a6 */
{ 0x00, 0x00, 0x1f, 0x01, 0x06, 0x04, 0x08 }, /* a7 */
{ 0x00, 0x00, 0x02, 0x04, 0x0c, 0x14, 0x04 }, /* a8 */
{ 0x00, 0x00, 0x04, 0x1f, 0x11, 0x01, 0x06 }, /* a9 */
{ 0x00, 0x00, 0x00, 0x1f, 0x04, 0x04, 0x1f }, /* aa */
{ 0x00, 0x00, 0x02, 0x1f, 0x06, 0x0a, 0x12 }, /* ab */
{ 0x00, 0x00, 0x08, 0x1f, 0x09, 0x0a, 0x08 }, /* ac */
{ 0x00, 0x00, 0x00, 0x0e, 0x02, 0x02, 0x1f }, /* ad */
{ 0x00, 0x00, 0x1e, 0x02, 0x1e, 0x02, 0x1e }, /* ae */
{ 0x00, 0x00, 0x00, 0x15, 0x15, 0x01, 0x06 }, /* af */
{ 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00 }, /* b0 */
{ 0x1f, 0x01, 0x05, 0x06, 0x04, 0x04, 0x08 }, /* b1 */
{ 0x01, 0x02, 0x04, 0x0c, 0x14, 0x04, 0x04 }, /* b2 */
{ 0x04, 0x1f, 0x11, 0x11, 0x01, 0x02, 0x04 }, /* b3 */
{ 0x00, 0x1f, 0x04, 0x04, 0x04, 0x04, 0x1f }, /* b4 */
{ 0x02, 0x1f, 0x02, 0x06, 0x0a, 0x12, 0x02 }, /* b5 */
{ 0x08, 0x1f, 0x09, 0x09, 0x09, 0x09, 0x12 }, /* b6 */
{ 0x04, 0x1f, 0x04, 0x1f, 0x04, 0x04, 0x04 }, /* b7 */
{ 0x00, 0x0f, 0x09, 0x11, 0x01, 0x02, 0x0c }, /* b8 */
{ 0x08, 0x0f, 0x12, 0x02, 0x02, 0x02, 0x04 }, /* b9 */
{ 0x00, 0x1f, 0x01, 0x01, 0x01, 0x01, 0x1f }, /* ba */
{ 0x0a, 0x1f, 0x0a, 0x02, 0x02, 0x02, 0x04 }, /* bb */
{ 0x00, 0x18, 0x00, 0x18, 0x01, 0x02, 0x1c }, /* bc */
{ 0x00, 0x1f, 0x01, 0x02, 0x04, 0x0a, 0x11 }, /* bd */
{ 0x08, 0x1f, 0x09, 0x0a, 0x08, 0x08, 0x07 }, /* be */
{ 0x00, 0x11, 0x11, 0x09, 0x01, 0x02, 0x0c }, /* bf */
{ 0x00, 0x0f, 0x09, 0x15, 0x03, 0x02, 0x0c }, /* c0 */
{ 0x02, 0x1c, 0x04, 0x1f, 0x04, 0x04, 0x08 }, /* c1 */
{ 0x00, 0x15, 0x15, 0x15, 0x01, 0x02, 0x04 }, /* c2 */
{ 0x0e, 0x00, 0x1f, 0x04, 0x04, 0x04, 0x08 }, /* c3 */
{ 0x08, 0x08, 0x08, 0x0c, 0x0a, 0x08, 0x08 }, /* c4 */
{ 0x04, 0x04, 0x1f, 0x04, 0x04, 0x08, 0x10 }, /* c5 */
{ 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x1f }, /* c6 */
{ 0x00, 0x1f, 0x01, 0x0a, 0x04, 0x0a, 0x10 }, /* c7 */
{ 0x04, 0x1f, 0x02, 0x04, 0x0e, 0x15, 0x04 }, /* c8 */
{ 0x02, 0x02, 0x02, 0x02, 0x02, 0x04, 0x08 }, /* c9 */
{ 0x00, 0x04, 0x02, 0x11, 0x11, 0x11, 0x11 }, /* ca */
{ 0x10, 0x10, 0x1f, 0x10, 0x10, 0x10, 0x0f }, /* cb */
{ 0x00, 0x1f, 0x01, 0x01, 0x01, 0x02, 0x0c }, /* cc */
{ 0x00, 0x08, 0x14, 0x02, 0x01, 0x01, 0x00 }, /* cd */
{ 0x04, 0x1f, 0x04, 0x04, 0x15, 0x15, 0x04 }, /* ce */
{ 0x00, 0x1f, 0x01, 0x01, 0x0a, 0x04, 0x02 }, /* cf */
{ 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x01 }, /* d0 */
{ 0x00, 0x04, 0x08, 0x10, 0x11, 0x1f, 0x01 }, /* d1 */
{ 0x00, 0x01, 0x01, 0x0a, 0x04, 0x0a, 0x10 }, /* d2 */
{ 0x00, 0x1f, 0x08, 0x1f, 0x08, 0x08, 0x07 }, /* d3 */
{ 0x08, 0x08, 0x1f, 0x09, 0x0a, 0x08, 0x08 }, /* d4 */
{ 0x00, 0x0e, 0x02, 0x02, 0x02, 0x02, 0x1f }, /* d5 */
{ 0x00, 0x1f, 0x01, 0x1f, 0x01, 0x01, 0x1f }, /* d6 */
{ 0x0e, 0x00, 0x1f, 0x01, 0x01, 0x02, 0x04 }, /* d7 */
{ 0x12, 0x12, 0x12, 0x12, 0x12, 0x04, 0x08 }, /* d8 */
{ 0x00, 0x04, 0x14, 0x14, 0x15, 0x15, 0x16 }, /* d9 */
{ 0x00, 0x10, 0x10, 0x11, 0x12, 0x14, 0x18 }, /* da */
{ 0x1f, 0x11, 0x11, 0x11, 0x11, 0x11, 0x1f }, /* db */
{ 0x00, 0x1f, 0x11, 0x11, 0x01, 0x02, 0x04 }, /* dc */
{ 0x00, 0x18, 0x00, 0x01, 0x01, 0x02, 0x1c }, /* dd */
{ 0x04, 0x12, 0x08, 0x00, 0x00, 0x00, 0x00 }, /* de */
{ 0x1c, 0x14, 0x1c, 0x00, 0x00, 0x00, 0x00 }, /* df */
{ 0x00, 0x00, 0x09, 0x15, 0x12, 0x12, 0x0d }, /* e0 */
{ 0x00, 0x0e, 0x11, 0x1e, 0x11, 0x1e, 0x10 }, /* e1 */
{ 0x00, 0x11, 0x0a, 0x0a, 0x04, 0x04, 0x08 }, /* e2 */
{ 0x00, 0x00, 0x1f, 0x0a, 0x0a, 0x0a, 0x13 }, /* e3 */
{ 0x1f, 0x10, 0x08, 0x04, 0x08, 0x10, 0x1f }, /* e4 */
{ 0x00, 0x00, 0x0f, 0x14, 0x12, 0x11, 0x0e }, /* e5 */
{ 0x00, 0x09, 0x09, 0x09, 0x0f, 0x08, 0x10 }, /* e6 */
{ 0x00, 0x00, 0x1f, 0x04, 0x04, 0x04, 0x03 }, /* e7 */
{ 0x1f, 0x04, 0x0e, 0x15, 0x0e, 0x04, 0x1f }, /* e8 */
{ 0x00, 0x0e, 0x11, 0x1f, 0x11, 0x11, 0x0e }, /* e9 */
{ 0x00, 0x00, 0x0e, 0x11, 0x11, 0x0a, 0x1b }, /* ea */
{ 0x0f, 0x10, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* eb */
{ 0x00, 0x00, 0x00, 0x00, 0x0b, 0x15, 0x1a }, /* ec */
{ 0x02, 0x04, 0x0e, 0x15, 0x0e, 0x04, 0x08 }, /* ed */
{ 0x00, 0x0e, 0x10, 0x0e, 0x10, 0x0e, 0x00 }, /* ee */
{ 0x06, 0x09, 0x11, 0x1e, 0x10, 0x10, 0x10 }, /* ef */
{ 0x00, 0x00, 0x08, 0x15, 0x02, 0x00, 0x00 }, /* f0 */
{ 0x00, 0x08, 0x15, 0x0a, 0x15, 0x02, 0x00 }, /* f1 */
{ 0x08, 0x0f, 0x12, 0x0f, 0x0a, 0x1f, 0x02 }, /* f2 */
{ 0x0f, 0x09, 0x0f, 0x09, 0x0f, 0x09, 0x11 }, /* f3 */
{ 0x04, 0x15, 0x15, 0x04, 0x04, 0x0a, 0x11 }, /* f4 */
{ 0x04, 0x04, 0x1d, 0x06, 0x0e, 0x15, 0x04 }, /* f5 */
{ 0x04, 0x04, 0x1f, 0x04, 0x0e, 0x15, 0x04 }, /* f6 */
{ 0x04, 0x0a, 0x11, 0x0e, 0x04, 0x0e, 0x1f }, /* f7 */
{ 0x04, 0x04, 0x0e, 0x04, 0x04, 0x04, 0x1f }, /* f8 */
{ 0x1f, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x1f }, /* f9 */
{ 0x00, 0x01, 0x1e, 0x04, 0x1f, 0x04, 0x04 }, /* fa */
{ 0x00, 0x00, 0x1f, 0x08, 0x0f, 0x09, 0x11 }, /* fb */
{ 0x00, 0x00, 0x1f, 0x15, 0x1f, 0x11, 0x11 }, /* fc */
{ 0x0a, 0x15, 0x0a, 0x15, 0x0a, 0x15, 0x0a }, /* fd */
{ 0x15, 0x0a, 0x15, 0x0a, 0x15, 0x0a, 0x15 }, /* fe */
{ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* ff */
};
static unsigned char font_player_oldlcd[256][7] = {
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 00 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 01 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 02 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 03 */
{ 0x0e, 0x11, 0x17, 0x15, 0x17, 0x10, 0x0e }, /* 04 */
{ 0x06, 0x09, 0x08, 0x1e, 0x08, 0x08, 0x1f }, /* 05 */
{ 0x04, 0x0f, 0x14, 0x0e, 0x05, 0x1e, 0x04 }, /* 06 */
{ 0x11, 0x0a, 0x1f, 0x04, 0x1f, 0x04, 0x04 }, /* 07 */
{ 0x08, 0x04, 0x0e, 0x11, 0x1f, 0x10, 0x0e }, /* 08 */
{ 0x02, 0x04, 0x0e, 0x11, 0x1f, 0x10, 0x0e }, /* 09 */
{ 0x08, 0x04, 0x00, 0x11, 0x11, 0x13, 0x0d }, /* 0a */
{ 0x08, 0x04, 0x00, 0x0c, 0x04, 0x04, 0x0e }, /* 0b */
{ 0x08, 0x04, 0x00, 0x0e, 0x11, 0x11, 0x0e }, /* 0c */
{ 0x0f, 0x10, 0x10, 0x10, 0x0f, 0x02, 0x0e }, /* 0d */
{ 0x10, 0x10, 0x17, 0x14, 0x1e, 0x04, 0x04 }, /* 0e */
{ 0x01, 0x0e, 0x13, 0x15, 0x19, 0x0e, 0x10 }, /* 0f */
{ 0x00, 0x02, 0x0e, 0x15, 0x15, 0x0e, 0x08 }, /* 10 */
{ 0x1c, 0x10, 0x17, 0x1d, 0x07, 0x06, 0x05 }, /* 11 */
{ 0x04, 0x0a, 0x04, 0x0e, 0x11, 0x1f, 0x11 }, /* 12 */
{ 0x04, 0x0a, 0x04, 0x01, 0x0f, 0x11, 0x0f }, /* 13 */
{ 0x00, 0x04, 0x04, 0x0a, 0x0a, 0x11, 0x1f }, /* 14 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f }, /* 15 */
{ 0x0e, 0x04, 0x1f, 0x15, 0x1f, 0x04, 0x0e }, /* 16 */
{ 0x1f, 0x11, 0x11, 0x10, 0x10, 0x10, 0x10 }, /* 17 */
{ 0x04, 0x04, 0x0a, 0x0a, 0x11, 0x11, 0x11 }, /* 18 */
{ 0x0e, 0x11, 0x11, 0x11, 0x0a, 0x0a, 0x1b }, /* 19 */
{ 0x1f, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a }, /* 1a */
{ 0x15, 0x15, 0x15, 0x15, 0x0e, 0x04, 0x04 }, /* 1b */
{ 0x1f, 0x08, 0x04, 0x02, 0x04, 0x08, 0x1f }, /* 1c */
{ 0x0e, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x0e }, /* 1d */
{ 0x1f, 0x11, 0x00, 0x0e, 0x00, 0x11, 0x1f }, /* 1e */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 1f */
{ 0x0f, 0x14, 0x14, 0x1f, 0x14, 0x14, 0x17 }, /* 20 */
{ 0x00, 0x00, 0x1a, 0x05, 0x0f, 0x14, 0x0f }, /* 21 */
{ 0x0c, 0x12, 0x16, 0x11, 0x11, 0x16, 0x10 }, /* 22 */
{ 0x02, 0x04, 0x1f, 0x10, 0x1c, 0x10, 0x1f }, /* 23 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 24 */
{ 0x04, 0x04, 0x04, 0x04, 0x04, 0x00, 0x04 }, /* 25 */
{ 0x1b, 0x09, 0x12, 0x00, 0x00, 0x00, 0x00 }, /* 26 */
{ 0x0a, 0x0a, 0x1f, 0x0a, 0x1f, 0x0a, 0x0a }, /* 27 */
{ 0x00, 0x11, 0x0e, 0x0a, 0x0e, 0x11, 0x00 }, /* 28 */
{ 0x18, 0x19, 0x02, 0x04, 0x08, 0x13, 0x03 }, /* 29 */
{ 0x08, 0x14, 0x14, 0x09, 0x15, 0x12, 0x0d }, /* 2a */
{ 0x0c, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00 }, /* 2b */
{ 0x02, 0x04, 0x08, 0x08, 0x08, 0x04, 0x02 }, /* 2c */
{ 0x08, 0x04, 0x02, 0x02, 0x02, 0x04, 0x08 }, /* 2d */
{ 0x04, 0x15, 0x0e, 0x04, 0x0e, 0x15, 0x04 }, /* 2e */
{ 0x00, 0x04, 0x04, 0x1f, 0x04, 0x04, 0x00 }, /* 2f */
{ 0x00, 0x00, 0x00, 0x00, 0x0c, 0x04, 0x08 }, /* 30 */
{ 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00 }, /* 31 */
{ 0x00, 0x00, 0x00, 0x00, 0x0c, 0x0c, 0x00 }, /* 32 */
{ 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x00 }, /* 33 */
{ 0x0e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 34 */
{ 0x04, 0x0c, 0x04, 0x04, 0x04, 0x04, 0x0e }, /* 35 */
{ 0x0e, 0x11, 0x01, 0x02, 0x04, 0x08, 0x1f }, /* 36 */
{ 0x1f, 0x02, 0x04, 0x02, 0x01, 0x11, 0x0e }, /* 37 */
{ 0x02, 0x06, 0x0a, 0x12, 0x1f, 0x02, 0x02 }, /* 38 */
{ 0x1f, 0x10, 0x1e, 0x01, 0x01, 0x11, 0x0e }, /* 39 */
{ 0x06, 0x08, 0x10, 0x1e, 0x11, 0x11, 0x0e }, /* 3a */
{ 0x1f, 0x01, 0x02, 0x02, 0x04, 0x04, 0x04 }, /* 3b */
{ 0x0e, 0x11, 0x11, 0x0e, 0x11, 0x11, 0x0e }, /* 3c */
{ 0x0e, 0x11, 0x11, 0x0f, 0x01, 0x02, 0x0c }, /* 3d */
{ 0x00, 0x0c, 0x0c, 0x00, 0x0c, 0x0c, 0x00 }, /* 3e */
{ 0x00, 0x0c, 0x0c, 0x00, 0x0c, 0x04, 0x08 }, /* 3f */
{ 0x03, 0x06, 0x0c, 0x18, 0x0c, 0x06, 0x03 }, /* 40 */
{ 0x00, 0x00, 0x1f, 0x00, 0x1f, 0x00, 0x00 }, /* 41 */
{ 0x18, 0x0c, 0x06, 0x03, 0x06, 0x0c, 0x18 }, /* 42 */
{ 0x0e, 0x11, 0x01, 0x02, 0x04, 0x00, 0x04 }, /* 43 */
{ 0x04, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04 }, /* 44 */
{ 0x04, 0x0a, 0x11, 0x11, 0x1f, 0x11, 0x11 }, /* 45 */
{ 0x1e, 0x11, 0x11, 0x1e, 0x11, 0x11, 0x1e }, /* 46 */
{ 0x0e, 0x11, 0x10, 0x10, 0x10, 0x11, 0x0e }, /* 47 */
{ 0x1c, 0x12, 0x11, 0x11, 0x11, 0x12, 0x1c }, /* 48 */
{ 0x1f, 0x10, 0x10, 0x1e, 0x10, 0x10, 0x1f }, /* 49 */
{ 0x1f, 0x10, 0x10, 0x1e, 0x10, 0x10, 0x10 }, /* 4a */
{ 0x0e, 0x10, 0x10, 0x17, 0x11, 0x11, 0x0e }, /* 4b */
{ 0x11, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11 }, /* 4c */
{ 0x0e, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e }, /* 4d */
{ 0x0f, 0x02, 0x02, 0x02, 0x02, 0x12, 0x0c }, /* 4e */
{ 0x11, 0x12, 0x14, 0x18, 0x14, 0x12, 0x11 }, /* 4f */
{ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1f }, /* 50 */
{ 0x11, 0x1b, 0x15, 0x11, 0x11, 0x11, 0x11 }, /* 51 */
{ 0x11, 0x11, 0x19, 0x15, 0x13, 0x11, 0x11 }, /* 52 */
{ 0x0e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 53 */
{ 0x1e, 0x11, 0x11, 0x1e, 0x10, 0x10, 0x10 }, /* 54 */
{ 0x0e, 0x11, 0x11, 0x11, 0x11, 0x12, 0x0d }, /* 55 */
{ 0x1e, 0x11, 0x11, 0x1e, 0x14, 0x12, 0x11 }, /* 56 */
{ 0x0e, 0x11, 0x10, 0x0e, 0x01, 0x11, 0x0e }, /* 57 */
{ 0x1f, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04 }, /* 58 */
{ 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 59 */
{ 0x11, 0x11, 0x11, 0x11, 0x11, 0x0a, 0x04 }, /* 5a */
{ 0x11, 0x11, 0x11, 0x11, 0x11, 0x15, 0x0a }, /* 5b */
{ 0x11, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x11 }, /* 5c */
{ 0x11, 0x11, 0x0a, 0x04, 0x04, 0x04, 0x04 }, /* 5d */
{ 0x1f, 0x01, 0x02, 0x04, 0x08, 0x10, 0x1f }, /* 5e */
{ 0x0a, 0x00, 0x04, 0x0a, 0x11, 0x1f, 0x11 }, /* 5f */
{ 0x0a, 0x00, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 60 */
{ 0x0d, 0x12, 0x00, 0x19, 0x15, 0x13, 0x11 }, /* 61 */
{ 0x0a, 0x00, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 62 */
{ 0x0e, 0x10, 0x0e, 0x11, 0x0e, 0x01, 0x0e }, /* 63 */
{ 0x04, 0x00, 0x04, 0x08, 0x10, 0x11, 0x0e }, /* 64 */
{ 0x00, 0x00, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 65 */
{ 0x10, 0x10, 0x1e, 0x11, 0x11, 0x11, 0x1e }, /* 66 */
{ 0x00, 0x00, 0x0f, 0x10, 0x10, 0x10, 0x0f }, /* 67 */
{ 0x01, 0x01, 0x0f, 0x11, 0x11, 0x11, 0x0f }, /* 68 */
{ 0x00, 0x00, 0x0e, 0x11, 0x1f, 0x10, 0x0f }, /* 69 */
{ 0x03, 0x04, 0x0f, 0x04, 0x04, 0x04, 0x04 }, /* 6a */
{ 0x00, 0x00, 0x0f, 0x11, 0x0f, 0x01, 0x0e }, /* 6b */
{ 0x10, 0x10, 0x16, 0x19, 0x11, 0x11, 0x11 }, /* 6c */
{ 0x04, 0x00, 0x0c, 0x04, 0x04, 0x04, 0x0e }, /* 6d */
{ 0x02, 0x00, 0x06, 0x02, 0x02, 0x12, 0x0c }, /* 6e */
{ 0x08, 0x08, 0x09, 0x0a, 0x0c, 0x0a, 0x09 }, /* 6f */
{ 0x0c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e }, /* 70 */
{ 0x00, 0x00, 0x1a, 0x15, 0x15, 0x15, 0x15 }, /* 71 */
{ 0x00, 0x00, 0x16, 0x19, 0x11, 0x11, 0x11 }, /* 72 */
{ 0x00, 0x00, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 73 */
{ 0x00, 0x00, 0x1e, 0x11, 0x1e, 0x10, 0x10 }, /* 74 */
{ 0x00, 0x00, 0x0f, 0x11, 0x0f, 0x01, 0x01 }, /* 75 */
{ 0x00, 0x00, 0x0b, 0x0c, 0x08, 0x08, 0x08 }, /* 76 */
{ 0x00, 0x00, 0x0e, 0x10, 0x0e, 0x01, 0x1e }, /* 77 */
{ 0x04, 0x04, 0x0f, 0x04, 0x04, 0x04, 0x03 }, /* 78 */
{ 0x00, 0x00, 0x11, 0x11, 0x11, 0x13, 0x0d }, /* 79 */
{ 0x00, 0x00, 0x11, 0x11, 0x11, 0x0a, 0x04 }, /* 7a */
{ 0x00, 0x00, 0x11, 0x11, 0x11, 0x15, 0x0a }, /* 7b */
{ 0x00, 0x00, 0x11, 0x0a, 0x04, 0x0a, 0x11 }, /* 7c */
{ 0x00, 0x00, 0x11, 0x11, 0x0f, 0x01, 0x1e }, /* 7d */
{ 0x00, 0x00, 0x1f, 0x02, 0x04, 0x08, 0x1f }, /* 7e */
{ 0x0a, 0x00, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 7f */
{ 0x00, 0x0a, 0x00, 0x0e, 0x11, 0x11, 0x0e }, /* 80 */
{ 0x0d, 0x12, 0x00, 0x16, 0x19, 0x11, 0x11 }, /* 81 */
{ 0x00, 0x0a, 0x00, 0x11, 0x11, 0x13, 0x0d }, /* 82 */
{ 0x08, 0x04, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 83 */
{ 0x00, 0x0f, 0x10, 0x10, 0x0f, 0x02, 0x04 }, /* 84 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x00 }, /* 85 */
{ 0x00, 0x00, 0x04, 0x0e, 0x1f, 0x00, 0x00 }, /* 86 */
{ 0x00, 0x00, 0x1f, 0x0e, 0x04, 0x00, 0x00 }, /* 87 */
{ 0x02, 0x06, 0x0e, 0x1e, 0x0e, 0x06, 0x02 }, /* 88 */
{ 0x08, 0x0c, 0x0e, 0x0f, 0x0e, 0x0c, 0x08 }, /* 89 */
{ 0x1c, 0x1f, 0x13, 0x10, 0x10, 0x10, 0x10 }, /* 8a */
{ 0x15, 0x0a, 0x15, 0x0a, 0x15, 0x0a, 0x15 }, /* 8b */
{ 0x08, 0x04, 0x0e, 0x11, 0x1f, 0x11, 0x11 }, /* 8c */
{ 0x02, 0x04, 0x0e, 0x11, 0x1f, 0x11, 0x11 }, /* 8d */
{ 0x04, 0x0a, 0x0e, 0x11, 0x1f, 0x11, 0x11 }, /* 8e */
{ 0x0d, 0x12, 0x0e, 0x11, 0x1f, 0x11, 0x11 }, /* 8f */
{ 0x08, 0x04, 0x1f, 0x10, 0x1e, 0x10, 0x1f }, /* 90 */
{ 0x04, 0x0a, 0x1f, 0x10, 0x1c, 0x10, 0x1f }, /* 91 */
{ 0x0a, 0x00, 0x1f, 0x10, 0x1c, 0x10, 0x1f }, /* 92 */
{ 0x08, 0x04, 0x0e, 0x04, 0x04, 0x04, 0x0e }, /* 93 */
{ 0x02, 0x04, 0x0e, 0x04, 0x04, 0x04, 0x0e }, /* 94 */
{ 0x0c, 0x0a, 0x09, 0x1d, 0x09, 0x0a, 0x0c }, /* 95 */
{ 0x08, 0x04, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 96 */
{ 0x02, 0x04, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 97 */
{ 0x04, 0x0a, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 98 */
{ 0x0d, 0x12, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 99 */
{ 0x08, 0x04, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 9a */
{ 0x02, 0x04, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 9b */
{ 0x02, 0x04, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 9c */
{ 0x04, 0x0a, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 9d */
{ 0x0d, 0x12, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 9e */
{ 0x04, 0x0a, 0x0e, 0x11, 0x1f, 0x10, 0x0e }, /* 9f */
{ 0x0a, 0x00, 0x0e, 0x11, 0x1f, 0x10, 0x0e }, /* a0 */
{ 0x02, 0x04, 0x00, 0x0c, 0x04, 0x04, 0x0e }, /* a1 */
{ 0x04, 0x0a, 0x00, 0x0c, 0x04, 0x04, 0x0e }, /* a2 */
{ 0x0a, 0x00, 0x00, 0x0c, 0x04, 0x04, 0x0e }, /* a3 */
{ 0x02, 0x04, 0x00, 0x0e, 0x11, 0x11, 0x0e }, /* a4 */
{ 0x04, 0x0a, 0x00, 0x0e, 0x11, 0x11, 0x0e }, /* a5 */
{ 0x0d, 0x12, 0x00, 0x0e, 0x11, 0x11, 0x0e }, /* a6 */
{ 0x02, 0x04, 0x00, 0x11, 0x11, 0x13, 0x0d }, /* a7 */
{ 0x04, 0x04, 0x0f, 0x10, 0x10, 0x0f, 0x04 }, /* a8 */
{ 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03 }, /* a9 */
{ 0x0a, 0x04, 0x0b, 0x0c, 0x08, 0x08, 0x08 }, /* aa */
{ 0x0a, 0x04, 0x0f, 0x10, 0x10, 0x10, 0x0f }, /* ab */
{ 0x0a, 0x04, 0x0e, 0x10, 0x0e, 0x01, 0x1e }, /* ac */
{ 0x0a, 0x04, 0x0e, 0x11, 0x1f, 0x10, 0x0e }, /* ad */
{ 0x04, 0x0a, 0x04, 0x11, 0x11, 0x13, 0x0d }, /* ae */
{ 0x02, 0x04, 0x11, 0x11, 0x0f, 0x01, 0x0e }, /* af */
{ 0x02, 0x0f, 0x02, 0x0e, 0x12, 0x12, 0x0e }, /* b0 */
{ 0x02, 0x04, 0x0f, 0x10, 0x10, 0x10, 0x0f }, /* b1 */
{ 0x0e, 0x11, 0x1f, 0x10, 0x0e, 0x04, 0x06 }, /* b2 */
{ 0x0e, 0x01, 0x0f, 0x11, 0x0f, 0x02, 0x03 }, /* b3 */
{ 0x04, 0x00, 0x1f, 0x02, 0x04, 0x08, 0x1f }, /* b4 */
{ 0x02, 0x04, 0x1f, 0x02, 0x04, 0x08, 0x1f }, /* b5 */
{ 0x02, 0x04, 0x0e, 0x10, 0x0e, 0x01, 0x1e }, /* b6 */
{ 0x02, 0x04, 0x16, 0x19, 0x11, 0x11, 0x11 }, /* b7 */
{ 0x0c, 0x04, 0x06, 0x0c, 0x04, 0x04, 0x0e }, /* b8 */
{ 0x04, 0x0e, 0x1f, 0x1f, 0x1b, 0x04, 0x0e }, /* b9 */
{ 0x0a, 0x04, 0x16, 0x19, 0x11, 0x11, 0x11 }, /* ba */
{ 0x09, 0x09, 0x08, 0x1e, 0x08, 0x08, 0x06 }, /* bb */
{ 0x05, 0x05, 0x0c, 0x14, 0x14, 0x14, 0x0c }, /* bc */
{ 0x0a, 0x04, 0x1f, 0x02, 0x04, 0x08, 0x1f }, /* bd */
{ 0x0f, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* be */
{ 0x0f, 0x10, 0x01, 0x01, 0x01, 0x01, 0x01 }, /* bf */
{ 0x1e, 0x01, 0x00, 0x00, 0x00, 0x00, 0x1f }, /* c0 */
{ 0x1f, 0x00, 0x0e, 0x10, 0x17, 0x11, 0x0e }, /* c1 */
{ 0x1f, 0x00, 0x0f, 0x11, 0x0f, 0x01, 0x0e }, /* c2 */
{ 0x0e, 0x10, 0x0e, 0x01, 0x0e, 0x04, 0x0c }, /* c3 */
{ 0x00, 0x0e, 0x10, 0x0e, 0x01, 0x0e, 0x04 }, /* c4 */
{ 0x04, 0x00, 0x0e, 0x04, 0x04, 0x04, 0x0e }, /* c5 */
{ 0x00, 0x00, 0x0c, 0x04, 0x04, 0x04, 0x0e }, /* c6 */
{ 0x05, 0x0a, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* c7 */
{ 0x09, 0x12, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* c8 */
{ 0x09, 0x12, 0x00, 0x11, 0x11, 0x13, 0x0d }, /* c9 */
{ 0x09, 0x12, 0x00, 0x0e, 0x11, 0x11, 0x0e }, /* ca */
{ 0x01, 0x01, 0x01, 0x01, 0x01, 0x10, 0x0f }, /* cb */
{ 0x10, 0x10, 0x10, 0x10, 0x10, 0x01, 0x1e }, /* cc */
{ 0x00, 0x1b, 0x1f, 0x1f, 0x0e, 0x04, 0x00 }, /* cd */
{ 0x18, 0x08, 0x08, 0x08, 0x08, 0x08, 0x18 }, /* ce */
{ 0x0e, 0x11, 0x04, 0x0a, 0x1b, 0x1f, 0x00 }, /* cf */
{ 0x0a, 0x15, 0x04, 0x07, 0x00, 0x11, 0x0a }, /* d0 */
{ 0x0f, 0x10, 0x00, 0x00, 0x00, 0x00, 0x1f }, /* d1 */
{ 0x01, 0x03, 0x1d, 0x11, 0x1d, 0x03, 0x01 }, /* d2 */
{ 0x0e, 0x11, 0x11, 0x1f, 0x1b, 0x1b, 0x1f }, /* d3 */
{ 0x00, 0x01, 0x02, 0x0a, 0x04, 0x04, 0x00 }, /* d4 */
{ 0x04, 0x0e, 0x1f, 0x00, 0x1f, 0x0e, 0x04 }, /* d5 */
{ 0x02, 0x02, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e }, /* d6 */
{ 0x1b, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1b }, /* d7 */
{ 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b }, /* d8 */
{ 0x04, 0x0f, 0x04, 0x04, 0x04, 0x03, 0x06 }, /* d9 */
{ 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b }, /* da */
{ 0x00, 0x04, 0x0e, 0x1f, 0x0e, 0x04, 0x00 }, /* db */
{ 0x00, 0x00, 0x1f, 0x1b, 0x15, 0x11, 0x1f }, /* dc */
{ 0x0e, 0x0e, 0x04, 0x1f, 0x0e, 0x0e, 0x0a }, /* dd */
{ 0x00, 0x00, 0x00, 0x00, 0x0a, 0x04, 0x0a }, /* de */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f }, /* df */
{ 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x1f }, /* e0 */
{ 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f }, /* e1 */
{ 0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* e2 */
{ 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* e3 */
{ 0x00, 0x00, 0x01, 0x02, 0x04, 0x04, 0x04 }, /* e4 */
{ 0x04, 0x09, 0x0a, 0x0a, 0x0a, 0x09, 0x04 }, /* e5 */
{ 0x00, 0x1f, 0x11, 0x11, 0x1f, 0x04, 0x1f }, /* e6 */
{ 0x00, 0x07, 0x03, 0x05, 0x08, 0x10, 0x00 }, /* e7 */
{ 0x00, 0x10, 0x08, 0x05, 0x03, 0x07, 0x00 }, /* e8 */
{ 0x09, 0x06, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* e9 */
{ 0x1e, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* ea */
{ 0x00, 0x00, 0x10, 0x08, 0x04, 0x04, 0x04 }, /* eb */
{ 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* ec */
{ 0x1f, 0x18, 0x14, 0x12, 0x15, 0x18, 0x1f }, /* ed */
{ 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* ee */
{ 0x1f, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10 }, /* ef */
{ 0x00, 0x03, 0x07, 0x0c, 0x18, 0x1c, 0x1c }, /* f0 */
{ 0x1c, 0x10, 0x1c, 0x07, 0x1c, 0x04, 0x07 }, /* f1 */
{ 0x00, 0x1e, 0x03, 0x09, 0x19, 0x09, 0x1d }, /* f2 */
{ 0x1e, 0x01, 0x19, 0x05, 0x09, 0x1d, 0x01 }, /* f3 */
{ 0x04, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00 }, /* f4 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0f }, /* f5 */
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x1e }, /* f6 */
{ 0x04, 0x04, 0x04, 0x08, 0x10, 0x00, 0x00 }, /* f7 */
{ 0x07, 0x03, 0x05, 0x08, 0x10, 0x10, 0x0f }, /* f8 */
{ 0x04, 0x0e, 0x1f, 0x11, 0x11, 0x15, 0x1f }, /* f9 */
{ 0x1f, 0x03, 0x1a, 0x02, 0x1a, 0x02, 0x1e }, /* fa */
{ 0x00, 0x0e, 0x1f, 0x11, 0x1f, 0x0e, 0x00 }, /* fb */
{ 0x03, 0x05, 0x09, 0x09, 0x0b, 0x1b, 0x18 }, /* fc */
{ 0x1f, 0x03, 0x05, 0x09, 0x15, 0x03, 0x1f }, /* fd */
{ 0x10, 0x10, 0x10, 0x10, 0x10, 0x1c, 0x1c }, /* fe */
{ 0x1c, 0x1c, 0x10, 0x10, 0x10, 0x10, 0x10 }, /* ff */
};
unsigned char (*font_player)[256][7] = &font_player_newlcd;
void font_init(void)
{
if (is_new_player())
font_player = &font_player_newlcd;
else
font_player = &font_player_oldlcd;
}

27
uisimulator/common/font-player.h
View file

@ -1,27 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#ifndef __FONT_PLAYER_H__
#define __FONT_PLAYER_H__
extern unsigned char (*font_player)[256][7];
void font_init(void);
#endif /* __FONT_PLAYER_H__ */

2
uisimulator/common/lcd-common.c
View file

@ -27,7 +27,7 @@
#include "system.h"
#include "lcd.h"
#if defined(HAVE_TRANSFLECTIVE_LCD) && defined(HAVE_LCD_SLEEP)
/* in uisimulator/sdl/lcd-bitmap.c and lcd-charcell.c */
/* in uisimulator/sdl/lcd-bitmap.c */
extern void sim_backlight(int value);
#endif

119
uisimulator/common/lcd-playersim.c
View file

@ -1,119 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 by Alan Korr
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include "config.h"
#include "hwcompat.h"
#include "lcd.h"
#include "lcd-charcell.h"
#include "kernel.h"
#include "thread.h"
#include <string.h>
#include <stdlib.h>
#include "debug.h"
#include "system.h"
#include "font-player.h"
#include "lcd-playersim.h"
/*** definitions ***/
bool sim_lcd_framebuffer[SIM_LCD_HEIGHT][SIM_LCD_WIDTH];
static int double_height = 1;
void lcd_print_icon(int x, int icon_line, bool enable, char **icon)
{
int row = 0, col = 0; /* shut up gcc */
int y = (ICON_HEIGHT+(CHAR_HEIGHT*2+2)*CHAR_PIXEL) * icon_line;
y += BORDER_MARGIN;
x += BORDER_MARGIN;
for (; icon[row]; row++)
{
for (col = 0; icon[row][col]; col++)
{
switch (icon[row][col])
{
case '*':
sim_lcd_framebuffer[y+row][x+col] = enable;
break;
case ' ':
sim_lcd_framebuffer[y+row][x+col] = false;
break;
}
}
}
sim_lcd_update_rect(x, y, col, row);
/* icon drawing updates immediately */
}
void lcd_print_char(int x, int y, unsigned char ch)
{
int xpos = x * CHAR_WIDTH*CHAR_PIXEL;
int ypos = y * CHAR_HEIGHT*CHAR_PIXEL + ICON_HEIGHT;
int row, col, r, c;
if (double_height > 1 && y == 1)
return; /* only one row available if text is double height */
for (row = 0; row < 7; row ++)
{
unsigned fontbitmap = (*font_player)[ch][row];
int height = (row == 3) ? 1 : double_height;
y = ypos + row * CHAR_PIXEL * double_height;
for (col = 0; col < 5; col++)
{
bool fontbit = fontbitmap & (0x10 >> col);
x = xpos + col * CHAR_PIXEL;
for (r = 0; r < height * CHAR_PIXEL; r++)
for (c = 0; c < CHAR_PIXEL; c++)
sim_lcd_framebuffer[y+r][x+c] = fontbit;
}
}
if (double_height > 1)
{
y = ypos + 15*CHAR_PIXEL;
for (r = 0; r < CHAR_PIXEL; r++)
for (c = 0; c < 5*CHAR_PIXEL; c++)
sim_lcd_framebuffer[y+r][xpos+c] = false;
}
}
void lcd_double_height(bool on)
{
int newval = (is_new_player() && on) ? 2 : 1;
if (newval != double_height)
{
double_height = newval;
lcd_update();
}
}
void sim_lcd_define_pattern(int pat, const char *pattern)
{
if (pat < lcd_pattern_count)
memcpy((*font_player)[pat], pattern, 7);
}

38
uisimulator/common/lcd-playersim.h
View file

@ -1,38 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 by Kjell Ericson
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#define ICON_HEIGHT 12
#define CHAR_HEIGHT 8
#ifdef CHAR_WIDTH
#undef CHAR_WIDTH
#endif
#define CHAR_WIDTH 6
#define CHAR_PIXEL 2
#define BORDER_MARGIN 1
extern bool sim_lcd_framebuffer[SIM_LCD_HEIGHT][SIM_LCD_WIDTH];
void lcd_print_icon(int x, int icon_line, bool enable, char **icon);
void lcd_print_char(int x, int y, unsigned char ch);
void sim_lcd_update_rect(int x, int y, int width, int height);
void sim_lcd_define_pattern(int pat, const char *pattern);

312
uisimulator/common/sim_icons.c
View file

@ -1,312 +0,0 @@
/***************************************************************************
* __________ __ ___.
* Open \______ \ ____ ____ | | _\_ |__ _______ ___
* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
* \/ \/ \/ \/ \/
* $Id$
*
* Copyright (C) 2002 Mats Lidell <matsl@contactor.se>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
* KIND, either express or implied.
*
****************************************************************************/
#include <stdio.h>
#include "config.h"
#include <lcd.h>
#include <kernel.h>
#include <string.h>
#include <debug.h>
extern void lcd_print_icon(int x, int icon_line, bool enable, char **icon);
static char* icon_battery_bit[]=
{
"-----",
" ",
"*****",
"*****",
"*****",
"*****",
"*****",
"*****",
" ",
"-----",
NULL
};
static char* icon_battery[]=
{
"********************* ",
"* * ",
"* ----- ----- ----- * ",
"* ----- ----- ----- ***",
"* ----- ----- ----- * *",
"* ----- ----- ----- * *",
"* ----- ----- ----- ***",
"* ----- ----- ----- * ",
"* * ",
"********************* ",
NULL
};
static char* icon_volume[]=
{
" ",
" ",
" ",
" ",
"* * * ",
"* * * ",
" * * *** * ",
" * * * * * ",
" * * * * ",
" * *** * ",
NULL
};
static char* icon_volume_1[]=
{
" ",
" ",
" ",
" ",
"**",
"**",
"**",
"**",
"**",
"**",
NULL
};
static char* icon_volume_2[]=
{
" ",
" ",
" ",
"**",
"**",
"**",
"**",
"**",
"**",
"**",
NULL
};
static char* icon_volume_3[]=
{
" ",
" ",
"**",
"**",
"**",
"**",
"**",
"**",
"**",
"**",
NULL
};
static char* icon_volume_4[]=
{
" ",
"**",
"**",
"**",
"**",
"**",
"**",
"**",
"**",
"**",
NULL
};
static char* icon_volume_5[]=
{
"**",
"**",
"**",
"**",
"**",
"**",
"**",
"**",
"**",
"**",
NULL
};
static char* icon_pause[]=
{
" **** **** ",
" **** **** ",
" **** **** ",
" **** **** ",
" **** **** ",
" **** **** ",
" **** **** ",
" **** **** ",
" **** **** ",
" **** **** ",
NULL
};
static char* icon_play[]=
{
"** ",
"***** ",
"******* ",
"********* ",
"*********** ",
"********* ",
"******* ",
"***** ",
"** ",
" ",
NULL
};
static char* icon_record[]=
{
" *** ",
" ***** ",
" ******* ",
" ********* ",
" ********* ",
" ********* ",
" ******* ",
" ***** ",
" *** ",
" ",
NULL
};
static char* icon_usb[]=
{
" ********* ",
" ** ** ",
" * ",
" ** * ** ",
"***********************",
" ** * ** ",
" * ",
" ** ** ",
" ******** ",
" ** ",
NULL
};
static char* icon_audio[]=
{
" *************************** ",
" ** ** ",
"* ** * * **** * *** *",
"* * * * * * * * * * *",
"* * * * * * * * * * *",
"* ****** * * * * * * * *",
"* * * * * * * * * * *",
"* * * *** **** * *** *",
" ** ** ",
" *************************** ",
NULL
};
static char* icon_param[]=
{
" ********************************* ",
" ** ** ",
"* **** ** **** ** ** ** *",
"* * * * * * * * * ** ** *",
"* * * * * * * * * * * * * *",
"* **** ****** **** ****** * * * * *",
"* * * * * * * * * * * *",
"* * * * * * * * * * * *",
" ** ** ",
" ********************************* ",
NULL
};
static char* icon_repeat[]=
{
" ",
" *************",
" * ",
" * ",
"* ",
"* ",
"* ** ",
" * **** ",
" * ****** ",
" *************",
NULL
};
static char* icon_repeat2[]=
{
" ",
" *",
" **",
"***",
" *",
" *",
" *",
" *",
" *",
" *",
NULL
};
struct icon_info
{
char** bitmap;
int xpos;
int row;
};
#define ICON_VOLUME_POS 102
#define ICON_VOLUME_SIZE 14
#define ICON_VOLUME_X_SIZE 2
static struct icon_info icons [] =
{
{icon_battery, 0, 0},
{icon_battery_bit, 2, 0},
{icon_battery_bit, 8, 0},
{icon_battery_bit, 14, 0},
{icon_usb, 0, 1},
{icon_play, 36, 0},
{icon_record, 48, 0},
{icon_pause, 60, 0},
{icon_audio, 37, 1},
{icon_repeat, 74, 0},
{icon_repeat2, 94, 0},
{icon_volume, ICON_VOLUME_POS, 0},
{icon_volume_1, ICON_VOLUME_POS+ICON_VOLUME_SIZE, 0},
{icon_volume_2, ICON_VOLUME_POS+ICON_VOLUME_SIZE+(1*ICON_VOLUME_X_SIZE)+1, 0},
{icon_volume_3, ICON_VOLUME_POS+ICON_VOLUME_SIZE+(2*ICON_VOLUME_X_SIZE)+2, 0},
{icon_volume_4, ICON_VOLUME_POS+ICON_VOLUME_SIZE+(3*ICON_VOLUME_X_SIZE)+3, 0},
{icon_volume_5, ICON_VOLUME_POS+ICON_VOLUME_SIZE+(4*ICON_VOLUME_X_SIZE)+4, 0},
{icon_param, 90, 1}
};
void
lcd_icon(int icon, bool enable)
{
lcd_print_icon(icons[icon].xpos, icons[icon].row, enable,
icons[icon].bitmap);
}

20
uisimulator/common/stubs.c
View file

@ -304,26 +304,6 @@ void mpeg_set_pitch(int pitch)
(void)pitch;
}
#ifdef HAVE_LCD_CHARCELLS
void lcd_clearrect (int x, int y, int nx, int ny)
{
/* Reprint char if you want to change anything */
(void)x;
(void)y;
(void)nx;
(void)ny;
}
void lcd_fillrect (int x, int y, int nx, int ny)
{
/* Reprint char if you want to change display anything */
(void)x;
(void)y;
(void)nx;
(void)ny;
}
#endif
void cpu_sleep(bool enabled)
{
(void)enabled;