diff options
author | Jens Arnold <amiconn@rockbox.org> | 2007-03-31 09:58:49 +0000 |
---|---|---|
committer | Jens Arnold <amiconn@rockbox.org> | 2007-03-31 09:58:49 +0000 |
commit | 54ea2e435e1a5688de4e4dcf551a1fc9c1db323f (patch) | |
tree | e8ee4e55a20c872a6c0deff554734038c35dc661 | |
parent | 6186b556bdbe97bc3c50dd8feb970590bec2053c (diff) | |
download | rockbox-54ea2e435e1a5688de4e4dcf551a1fc9c1db323f.tar.gz rockbox-54ea2e435e1a5688de4e4dcf551a1fc9c1db323f.zip |
Charcell lcd driver: Preparations for switching to non-immediate LCD updates, using lcd_update() like on bitmap targets. * Added proper clipping. * Simplified simulator code.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@12979 a1c6a512-1295-4272-9138-f99709370657
-rw-r--r-- | apps/plugin.c | 2 | ||||
-rw-r--r-- | apps/plugin.h | 6 | ||||
-rw-r--r-- | firmware/drivers/lcd-charcell.c | 194 | ||||
-rw-r--r-- | firmware/drivers/lcd-charset-player.c | 6 | ||||
-rw-r--r-- | firmware/export/lcd-charcell.h | 30 | ||||
-rw-r--r-- | firmware/export/lcd.h | 12 | ||||
-rw-r--r-- | firmware/target/sh/archos/player/lcd-player.c | 38 | ||||
-rw-r--r-- | uisimulator/common/font-player.c | 1042 | ||||
-rw-r--r-- | uisimulator/common/font-player.h | 2 | ||||
-rw-r--r-- | uisimulator/common/lcd-playersim.c | 253 | ||||
-rw-r--r-- | uisimulator/common/lcd-playersim.h | 28 | ||||
-rw-r--r-- | uisimulator/sdl/SOURCES | 2 | ||||
-rw-r--r-- | uisimulator/sdl/button.c | 2 | ||||
-rw-r--r-- | uisimulator/sdl/lcd-charcells.c (renamed from uisimulator/sdl/lcd-charcell.c) | 91 | ||||
-rw-r--r-- | uisimulator/sdl/lcd-charcells.h (renamed from uisimulator/sdl/lcd-charcell.h) | 0 | ||||
-rw-r--r-- | uisimulator/sdl/uisdl.c | 2 |
16 files changed, 763 insertions, 947 deletions
diff --git a/apps/plugin.c b/apps/plugin.c index de04269a89..52d43123b7 100644 --- a/apps/plugin.c +++ b/apps/plugin.c | |||
@@ -66,6 +66,7 @@ static const struct plugin_api rockbox_api = { | |||
66 | 66 | ||
67 | /* lcd */ | 67 | /* lcd */ |
68 | lcd_set_contrast, | 68 | lcd_set_contrast, |
69 | lcd_update, | ||
69 | lcd_clear_display, | 70 | lcd_clear_display, |
70 | lcd_setmargins, | 71 | lcd_setmargins, |
71 | lcd_getstringsize, | 72 | lcd_getstringsize, |
@@ -114,7 +115,6 @@ static const struct plugin_api rockbox_api = { | |||
114 | lcd_puts_scroll_style, | 115 | lcd_puts_scroll_style, |
115 | &lcd_framebuffer[0][0], | 116 | &lcd_framebuffer[0][0], |
116 | lcd_blit, | 117 | lcd_blit, |
117 | lcd_update, | ||
118 | lcd_update_rect, | 118 | lcd_update_rect, |
119 | gui_scrollbar_draw, | 119 | gui_scrollbar_draw, |
120 | font_get, | 120 | font_get, |
diff --git a/apps/plugin.h b/apps/plugin.h index 7688057d86..cb076f5b85 100644 --- a/apps/plugin.h +++ b/apps/plugin.h | |||
@@ -110,12 +110,12 @@ | |||
110 | #define PLUGIN_MAGIC 0x526F634B /* RocK */ | 110 | #define PLUGIN_MAGIC 0x526F634B /* RocK */ |
111 | 111 | ||
112 | /* increase this every time the api struct changes */ | 112 | /* increase this every time the api struct changes */ |
113 | #define PLUGIN_API_VERSION 50 | 113 | #define PLUGIN_API_VERSION 51 |
114 | 114 | ||
115 | /* update this to latest version if a change to the api struct breaks | 115 | /* update this to latest version if a change to the api struct breaks |
116 | backwards compatibility (and please take the opportunity to sort in any | 116 | backwards compatibility (and please take the opportunity to sort in any |
117 | new function which are "waiting" at the end of the function table) */ | 117 | new function which are "waiting" at the end of the function table) */ |
118 | #define PLUGIN_MIN_API_VERSION 50 | 118 | #define PLUGIN_MIN_API_VERSION 51 |
119 | 119 | ||
120 | /* plugin return codes */ | 120 | /* plugin return codes */ |
121 | enum plugin_status { | 121 | enum plugin_status { |
@@ -134,6 +134,7 @@ struct plugin_api { | |||
134 | 134 | ||
135 | /* lcd */ | 135 | /* lcd */ |
136 | void (*lcd_set_contrast)(int x); | 136 | void (*lcd_set_contrast)(int x); |
137 | void (*lcd_update)(void); | ||
137 | void (*lcd_clear_display)(void); | 138 | void (*lcd_clear_display)(void); |
138 | void (*lcd_setmargins)(int x, int y); | 139 | void (*lcd_setmargins)(int x, int y); |
139 | int (*lcd_getstringsize)(const unsigned char *str, int *w, int *h); | 140 | int (*lcd_getstringsize)(const unsigned char *str, int *w, int *h); |
@@ -191,7 +192,6 @@ struct plugin_api { | |||
191 | fb_data* lcd_framebuffer; | 192 | fb_data* lcd_framebuffer; |
192 | void (*lcd_blit) (const fb_data* data, int x, int by, int width, | 193 | void (*lcd_blit) (const fb_data* data, int x, int by, int width, |
193 | int bheight, int stride); | 194 | int bheight, int stride); |
194 | void (*lcd_update)(void); | ||
195 | void (*lcd_update_rect)(int x, int y, int width, int height); | 195 | void (*lcd_update_rect)(int x, int y, int width, int height); |
196 | void (*gui_scrollbar_draw)(struct screen * screen, int x, int y, | 196 | void (*gui_scrollbar_draw)(struct screen * screen, int x, int y, |
197 | int width, int height, int items, | 197 | int width, int height, int items, |
diff --git a/firmware/drivers/lcd-charcell.c b/firmware/drivers/lcd-charcell.c index 76f7cf1b1e..5ddef99655 100644 --- a/firmware/drivers/lcd-charcell.c +++ b/firmware/drivers/lcd-charcell.c | |||
@@ -38,42 +38,21 @@ | |||
38 | 38 | ||
39 | #define NO_PATTERN (-1) | 39 | #define NO_PATTERN (-1) |
40 | 40 | ||
41 | #define SCROLL_MODE_OFF 0 | ||
42 | #define SCROLL_MODE_RUN 1 | ||
43 | |||
44 | /* track usage of user-definable characters */ | ||
45 | struct pattern_info { | ||
46 | short count; | ||
47 | unsigned short xchar; | ||
48 | }; | ||
49 | |||
50 | struct cursor_info { | ||
51 | unsigned char hw_char; | ||
52 | bool enabled; | ||
53 | bool visible; | ||
54 | int x; | ||
55 | int y; | ||
56 | int divider; | ||
57 | int downcount; | ||
58 | }; | ||
59 | |||
60 | static int find_xchar(unsigned long ucs); | 41 | static int find_xchar(unsigned long ucs); |
61 | 42 | ||
62 | /** globals **/ | 43 | /** globals **/ |
63 | 44 | ||
64 | /* The "frame"buffer */ | 45 | /* The "frame"buffer */ |
65 | static unsigned char lcd_buffer[LCD_WIDTH][LCD_HEIGHT]; | 46 | unsigned char lcd_charbuffer[LCD_HEIGHT][LCD_WIDTH]; |
66 | #ifdef SIMULATOR | 47 | struct pattern_info lcd_patterns[MAX_HW_PATTERNS]; |
67 | unsigned char hardware_buffer_lcd[LCD_WIDTH][LCD_HEIGHT]; | 48 | struct cursor_info lcd_cursor; |
68 | #endif | ||
69 | |||
70 | static int xmargin = 0; | ||
71 | static int ymargin = 0; | ||
72 | 49 | ||
73 | static unsigned char xfont_variable[VARIABLE_XCHARS][HW_PATTERN_SIZE]; | 50 | static unsigned char xfont_variable[VARIABLE_XCHARS][HW_PATTERN_SIZE]; |
74 | static bool xfont_variable_locked[VARIABLE_XCHARS]; | 51 | static bool xfont_variable_locked[VARIABLE_XCHARS]; |
75 | static struct pattern_info hw_pattern[MAX_HW_PATTERNS]; | 52 | static int xspace; /* stores xhcar id of ' ' - often needed */ |
76 | static struct cursor_info cursor; | 53 | |
54 | static int xmargin = 0; | ||
55 | static int ymargin = 0; | ||
77 | 56 | ||
78 | /* scrolling */ | 57 | /* scrolling */ |
79 | static volatile int scrolling_lines=0; /* Bitpattern of which lines are scrolling */ | 58 | static volatile int scrolling_lines=0; /* Bitpattern of which lines are scrolling */ |
@@ -98,8 +77,9 @@ void lcd_init (void) | |||
98 | { | 77 | { |
99 | lcd_init_device(); | 78 | lcd_init_device(); |
100 | lcd_charset_init(); | 79 | lcd_charset_init(); |
101 | memset(hw_pattern, 0, sizeof(hw_pattern)); | 80 | memset(lcd_patterns, 0, sizeof(lcd_patterns)); |
102 | memset(lcd_buffer, xchar_info[find_xchar(' ')].hw_char, sizeof(lcd_buffer)); | 81 | xspace = find_xchar(' '); |
82 | memset(lcd_charbuffer, xchar_info[xspace].hw_char, sizeof(lcd_charbuffer)); | ||
103 | 83 | ||
104 | create_thread(scroll_thread, scroll_stack, | 84 | create_thread(scroll_thread, scroll_stack, |
105 | sizeof(scroll_stack), scroll_name | 85 | sizeof(scroll_stack), scroll_name |
@@ -165,8 +145,8 @@ static int xchar_to_pat(int xchar) | |||
165 | { | 145 | { |
166 | int i; | 146 | int i; |
167 | 147 | ||
168 | for (i = 0; i < hw_pattern_count; i++) | 148 | for (i = 0; i < lcd_pattern_count; i++) |
169 | if (hw_pattern[i].xchar == xchar) | 149 | if (lcd_patterns[i].xchar == xchar) |
170 | return i; | 150 | return i; |
171 | 151 | ||
172 | return NO_PATTERN; | 152 | return NO_PATTERN; |
@@ -193,27 +173,14 @@ static void lcd_free_pat(int xchar) | |||
193 | substitute = xchar_info[xchar].hw_char; | 173 | substitute = xchar_info[xchar].hw_char; |
194 | 174 | ||
195 | for (x = 0; x < LCD_WIDTH; x++) | 175 | for (x = 0; x < LCD_WIDTH; x++) |
196 | { | ||
197 | for (y = 0; y < LCD_HEIGHT; y++) | 176 | for (y = 0; y < LCD_HEIGHT; y++) |
198 | { | 177 | if (pat == lcd_charbuffer[y][x]) |
199 | if (pat == lcd_buffer[x][y]) | 178 | lcd_charbuffer[y][x] = substitute; |
200 | { | ||
201 | lcd_buffer[x][y] = substitute; | ||
202 | #ifdef SIMULATOR | ||
203 | hardware_buffer_lcd[x][y] = substitute; | ||
204 | #else | ||
205 | lcd_put_hw_char(x, y, substitute); | ||
206 | #endif | ||
207 | } | ||
208 | } | ||
209 | } | ||
210 | if (cursor.enabled && pat == cursor.hw_char) | ||
211 | cursor.hw_char = substitute; | ||
212 | 179 | ||
213 | hw_pattern[pat].count = 0; | 180 | if (lcd_cursor.enabled && pat == lcd_cursor.hw_char) |
214 | #ifdef SIMULATOR | 181 | lcd_cursor.hw_char = substitute; |
215 | lcd_update(); | 182 | |
216 | #endif | 183 | lcd_patterns[pat].count = 0; |
217 | } | 184 | } |
218 | } | 185 | } |
219 | 186 | ||
@@ -223,30 +190,30 @@ static int lcd_get_free_pat(int xchar) | |||
223 | 190 | ||
224 | int pat = last_used_pat; /* start from last used pattern */ | 191 | int pat = last_used_pat; /* start from last used pattern */ |
225 | int least_pat = pat; /* pattern with least priority */ | 192 | int least_pat = pat; /* pattern with least priority */ |
226 | int least_priority = xchar_info[hw_pattern[pat].xchar].priority; | 193 | int least_priority = xchar_info[lcd_patterns[pat].xchar].priority; |
227 | int i; | 194 | int i; |
228 | 195 | ||
229 | for (i = 0; i < hw_pattern_count; i++) | 196 | for (i = 0; i < lcd_pattern_count; i++) |
230 | { | 197 | { |
231 | if (++pat >= hw_pattern_count) /* Keep 'pat' within limits */ | 198 | if (++pat >= lcd_pattern_count) /* Keep 'pat' within limits */ |
232 | pat = 0; | 199 | pat = 0; |
233 | 200 | ||
234 | if (hw_pattern[pat].count == 0) | 201 | if (lcd_patterns[pat].count == 0) |
235 | { | 202 | { |
236 | hw_pattern[pat].xchar = xchar; | 203 | lcd_patterns[pat].xchar = xchar; |
237 | last_used_pat = pat; | 204 | last_used_pat = pat; |
238 | return pat; | 205 | return pat; |
239 | } | 206 | } |
240 | if (xchar_info[hw_pattern[pat].xchar].priority < least_priority) | 207 | if (xchar_info[lcd_patterns[pat].xchar].priority < least_priority) |
241 | { | 208 | { |
242 | least_priority = xchar_info[hw_pattern[pat].xchar].priority; | 209 | least_priority = xchar_info[lcd_patterns[pat].xchar].priority; |
243 | least_pat = pat; | 210 | least_pat = pat; |
244 | } | 211 | } |
245 | } | 212 | } |
246 | if (xchar_info[xchar].priority > least_priority) /* prioritized char */ | 213 | if (xchar_info[xchar].priority > least_priority) /* prioritized char */ |
247 | { | 214 | { |
248 | lcd_free_pat(hw_pattern[least_pat].xchar); | 215 | lcd_free_pat(lcd_patterns[least_pat].xchar); |
249 | hw_pattern[least_pat].xchar = xchar; | 216 | lcd_patterns[least_pat].xchar = xchar; |
250 | last_used_pat = least_pat; | 217 | last_used_pat = least_pat; |
251 | return least_pat; | 218 | return least_pat; |
252 | } | 219 | } |
@@ -267,9 +234,10 @@ static int map_xchar(int xchar) | |||
267 | if (pat == NO_PATTERN) /* failed: just use substitute */ | 234 | if (pat == NO_PATTERN) /* failed: just use substitute */ |
268 | return xchar_info[xchar].hw_char; | 235 | return xchar_info[xchar].hw_char; |
269 | else /* define pattern */ | 236 | else /* define pattern */ |
270 | lcd_define_hw_pattern(pat, xchar_to_glyph(xchar)); | 237 | memcpy(lcd_patterns[pat].pattern, xchar_to_glyph(xchar), |
238 | HW_PATTERN_SIZE); | ||
271 | } | 239 | } |
272 | hw_pattern[pat].count++; /* increase reference count */ | 240 | lcd_patterns[pat].count++; /* increase reference count */ |
273 | return pat; | 241 | return pat; |
274 | } | 242 | } |
275 | else /* hardware char */ | 243 | else /* hardware char */ |
@@ -278,18 +246,12 @@ static int map_xchar(int xchar) | |||
278 | 246 | ||
279 | static void lcd_putxchar(int x, int y, int xchar) | 247 | static void lcd_putxchar(int x, int y, int xchar) |
280 | { | 248 | { |
281 | int lcd_char = lcd_buffer[x][y]; | 249 | int lcd_char = lcd_charbuffer[y][x]; |
282 | 250 | ||
283 | if (lcd_char < hw_pattern_count) /* old char was soft */ | 251 | if (lcd_char < lcd_pattern_count) /* old char was soft */ |
284 | hw_pattern[lcd_char].count--; /* decrease old reference count */ | 252 | lcd_patterns[lcd_char].count--; /* decrease old reference count */ |
285 | 253 | ||
286 | lcd_buffer[x][y] = lcd_char = map_xchar(xchar); | 254 | lcd_charbuffer[y][x] = map_xchar(xchar); |
287 | #ifdef SIMULATOR | ||
288 | hardware_buffer_lcd[x][y] = lcd_char; | ||
289 | lcd_update(); | ||
290 | #else | ||
291 | lcd_put_hw_char(x, y, lcd_char); | ||
292 | #endif | ||
293 | } | 255 | } |
294 | 256 | ||
295 | /** user-definable pattern handling **/ | 257 | /** user-definable pattern handling **/ |
@@ -332,7 +294,10 @@ void lcd_define_pattern(unsigned long ucs, const char *pattern) | |||
332 | memcpy(xfont_variable[index & 0x7fff], pattern, HW_PATTERN_SIZE); | 294 | memcpy(xfont_variable[index & 0x7fff], pattern, HW_PATTERN_SIZE); |
333 | pat = xchar_to_pat(xchar); | 295 | pat = xchar_to_pat(xchar); |
334 | if (pat != NO_PATTERN) | 296 | if (pat != NO_PATTERN) |
335 | lcd_define_hw_pattern(pat, pattern); | 297 | { |
298 | memcpy(lcd_patterns[pat].pattern, pattern, HW_PATTERN_SIZE); | ||
299 | lcd_update(); //FIXME: remove when lcd_update() calls are checked all over | ||
300 | } | ||
336 | } | 301 | } |
337 | } | 302 | } |
338 | 303 | ||
@@ -342,14 +307,15 @@ void lcd_define_pattern(unsigned long ucs, const char *pattern) | |||
342 | void lcd_clear_display(void) | 307 | void lcd_clear_display(void) |
343 | { | 308 | { |
344 | int x, y; | 309 | int x, y; |
345 | int xchar = find_xchar(' '); | ||
346 | 310 | ||
347 | lcd_stop_scroll(); | 311 | lcd_stop_scroll(); |
348 | lcd_remove_cursor(); | 312 | lcd_remove_cursor(); |
349 | 313 | ||
350 | for (x = 0; x < LCD_WIDTH; x++) | 314 | for (x = 0; x < LCD_WIDTH; x++) |
351 | for (y = 0; y < LCD_HEIGHT; y++) | 315 | for (y = 0; y < LCD_HEIGHT; y++) |
352 | lcd_putxchar(x, y, xchar); | 316 | lcd_putxchar(x, y, xspace); |
317 | |||
318 | lcd_update(); //FIXME: remove when lcd_update() calls are checked all over | ||
353 | } | 319 | } |
354 | 320 | ||
355 | /* Put an unicode character at the given position */ | 321 | /* Put an unicode character at the given position */ |
@@ -359,38 +325,34 @@ void lcd_putc(int x, int y, unsigned long ucs) | |||
359 | return; | 325 | return; |
360 | 326 | ||
361 | lcd_putxchar(x, y, find_xchar(ucs)); | 327 | lcd_putxchar(x, y, find_xchar(ucs)); |
328 | lcd_update(); //FIXME: remove when lcd_update() calls are checked all over | ||
362 | } | 329 | } |
363 | 330 | ||
364 | /* Show cursor (alternating with existing character) at the given position */ | 331 | /* Show cursor (alternating with existing character) at the given position */ |
365 | void lcd_put_cursor(int x, int y, unsigned long cursor_ucs) | 332 | void lcd_put_cursor(int x, int y, unsigned long cursor_ucs) |
366 | { | 333 | { |
367 | if ((unsigned)x >= LCD_WIDTH || (unsigned)y >= LCD_HEIGHT | 334 | if ((unsigned)x >= LCD_WIDTH || (unsigned)y >= LCD_HEIGHT |
368 | || cursor.enabled) | 335 | || lcd_cursor.enabled) |
369 | return; | 336 | return; |
370 | 337 | ||
371 | cursor.enabled = true; | 338 | lcd_cursor.enabled = true; |
372 | cursor.visible = false; | 339 | lcd_cursor.visible = false; |
373 | cursor.hw_char = map_xchar(find_xchar(cursor_ucs)); | 340 | lcd_cursor.hw_char = map_xchar(find_xchar(cursor_ucs)); |
374 | cursor.x = x; | 341 | lcd_cursor.x = x; |
375 | cursor.y = y; | 342 | lcd_cursor.y = y; |
376 | cursor.downcount = 0; | 343 | lcd_cursor.downcount = 0; |
377 | cursor.divider = 4; | 344 | lcd_cursor.divider = 4; |
378 | } | 345 | } |
379 | 346 | ||
380 | /* Remove the cursor */ | 347 | /* Remove the cursor */ |
381 | void lcd_remove_cursor(void) | 348 | void lcd_remove_cursor(void) |
382 | { | 349 | { |
383 | if (cursor.enabled) | 350 | if (lcd_cursor.enabled) |
384 | { | 351 | { |
385 | if (cursor.hw_char < hw_pattern_count) /* soft char, unmap */ | 352 | if (lcd_cursor.hw_char < lcd_pattern_count) /* soft char, unmap */ |
386 | hw_pattern[cursor.hw_char].count--; | 353 | lcd_patterns[lcd_cursor.hw_char].count--; |
387 | 354 | ||
388 | cursor.enabled = false; | 355 | lcd_cursor.enabled = lcd_cursor.visible = false; |
389 | #ifdef SIMULATOR | ||
390 | hardware_buffer_lcd[cursor.x][cursor.y] = lcd_buffer[cursor.x][cursor.y]; | ||
391 | #else | ||
392 | lcd_put_hw_char(cursor.x, cursor.y, lcd_buffer[cursor.x][cursor.y]); | ||
393 | #endif | ||
394 | } | 356 | } |
395 | } | 357 | } |
396 | 358 | ||
@@ -409,7 +371,7 @@ static int lcd_putsxyofs(int x, int y, int ofs, const unsigned char *str) | |||
409 | ofs--; | 371 | ofs--; |
410 | continue; | 372 | continue; |
411 | } | 373 | } |
412 | lcd_putc(x++, y, ucs); | 374 | lcd_putxchar(x++, y, find_xchar(ucs)); |
413 | } | 375 | } |
414 | return x; | 376 | return x; |
415 | } | 377 | } |
@@ -417,7 +379,11 @@ static int lcd_putsxyofs(int x, int y, int ofs, const unsigned char *str) | |||
417 | /* Put a string at a given position */ | 379 | /* Put a string at a given position */ |
418 | void lcd_putsxy(int x, int y, const unsigned char *str) | 380 | void lcd_putsxy(int x, int y, const unsigned char *str) |
419 | { | 381 | { |
382 | if ((unsigned)y >= LCD_HEIGHT) | ||
383 | return; | ||
384 | |||
420 | lcd_putsxyofs(x, y, 0, str); | 385 | lcd_putsxyofs(x, y, 0, str); |
386 | lcd_update(); //FIXME: remove when lcd_update() calls are checked all over | ||
421 | } | 387 | } |
422 | 388 | ||
423 | /*** Line oriented text output ***/ | 389 | /*** Line oriented text output ***/ |
@@ -431,15 +397,20 @@ void lcd_puts(int x, int y, const unsigned char *str) | |||
431 | /* Put a string at a given char position, skipping first offset chars */ | 397 | /* Put a string at a given char position, skipping first offset chars */ |
432 | void lcd_puts_offset(int x, int y, const unsigned char *str, int offset) | 398 | void lcd_puts_offset(int x, int y, const unsigned char *str, int offset) |
433 | { | 399 | { |
434 | /* make sure scrolling is turned off on the line we are updating */ | ||
435 | scrolling_lines &= ~(1 << y); | ||
436 | |||
437 | x += xmargin; | 400 | x += xmargin; |
438 | y += ymargin; | 401 | y += ymargin; |
439 | 402 | ||
403 | if ((unsigned)y >= LCD_HEIGHT) | ||
404 | return; | ||
405 | |||
406 | /* make sure scrolling is turned off on the line we are updating */ | ||
407 | scrolling_lines &= ~(1 << y); | ||
408 | |||
440 | x = lcd_putsxyofs(x, y, offset, str); | 409 | x = lcd_putsxyofs(x, y, offset, str); |
441 | while (x < LCD_WIDTH) | 410 | while (x < LCD_WIDTH) |
442 | lcd_putc(x++, y, ' '); | 411 | lcd_putxchar(x++, y, xspace); |
412 | |||
413 | lcd_update(); //FIXME: remove when lcd_update() calls are checked all over | ||
443 | } | 414 | } |
444 | 415 | ||
445 | /** scrolling **/ | 416 | /** scrolling **/ |
@@ -536,12 +507,14 @@ static void scroll_thread(void) | |||
536 | struct scrollinfo* s; | 507 | struct scrollinfo* s; |
537 | int index; | 508 | int index; |
538 | int xpos, ypos; | 509 | int xpos, ypos; |
510 | bool update; | ||
539 | 511 | ||
540 | /* initialize scroll struct array */ | 512 | /* initialize scroll struct array */ |
541 | scrolling_lines = 0; | 513 | scrolling_lines = 0; |
542 | 514 | ||
543 | while (1) | 515 | while (1) |
544 | { | 516 | { |
517 | update = false; | ||
545 | for (index = 0; index < SCROLLABLE_LINES; index++) | 518 | for (index = 0; index < SCROLLABLE_LINES; index++) |
546 | { | 519 | { |
547 | /* really scroll? */ | 520 | /* really scroll? */ |
@@ -585,27 +558,20 @@ static void scroll_thread(void) | |||
585 | s->offset -= s->len; | 558 | s->offset -= s->len; |
586 | } | 559 | } |
587 | lcd_putsxyofs(xpos, ypos, s->offset, s->line); | 560 | lcd_putsxyofs(xpos, ypos, s->offset, s->line); |
561 | update = true; | ||
588 | } | 562 | } |
589 | if (cursor.enabled) | 563 | if (lcd_cursor.enabled) |
590 | { | 564 | { |
591 | if (--cursor.downcount < 0) | 565 | if (--lcd_cursor.downcount < 0) |
592 | { | 566 | { |
593 | int lcd_char; | 567 | lcd_cursor.downcount = lcd_cursor.divider; |
594 | 568 | lcd_cursor.visible = !lcd_cursor.visible; | |
595 | cursor.downcount = cursor.divider; | 569 | update = true; |
596 | cursor.visible = !cursor.visible; | ||
597 | lcd_char = cursor.visible ? cursor.hw_char | ||
598 | : lcd_buffer[cursor.x][cursor.y]; | ||
599 | #ifdef SIMULATOR | ||
600 | hardware_buffer_lcd[cursor.x][cursor.y] = lcd_char; | ||
601 | #else | ||
602 | lcd_put_hw_char(cursor.x, cursor.y, lcd_char); | ||
603 | #endif | ||
604 | } | 570 | } |
605 | } | 571 | } |
606 | #ifdef SIMULATOR | 572 | if (update) |
607 | lcd_update(); | 573 | lcd_update(); |
608 | #endif | 574 | |
609 | sleep(scroll_ticks); | 575 | sleep(scroll_ticks); |
610 | } | 576 | } |
611 | } | 577 | } |
diff --git a/firmware/drivers/lcd-charset-player.c b/firmware/drivers/lcd-charset-player.c index 24c0f65ee0..8218535ac2 100644 --- a/firmware/drivers/lcd-charset-player.c +++ b/firmware/drivers/lcd-charset-player.c | |||
@@ -22,7 +22,7 @@ | |||
22 | 22 | ||
23 | #include "lcd-charcell.h" | 23 | #include "lcd-charcell.h" |
24 | 24 | ||
25 | int hw_pattern_count; /* actual number of user-definable hw patterns */ | 25 | int lcd_pattern_count; /* actual number of user-definable hw patterns */ |
26 | 26 | ||
27 | const struct xchar_info *xchar_info; | 27 | const struct xchar_info *xchar_info; |
28 | int xchar_info_size; /* number of entries */ | 28 | int xchar_info_size; /* number of entries */ |
@@ -1237,13 +1237,13 @@ void lcd_charset_init(void) | |||
1237 | { | 1237 | { |
1238 | if (is_new_player()) | 1238 | if (is_new_player()) |
1239 | { | 1239 | { |
1240 | hw_pattern_count = 8; | 1240 | lcd_pattern_count = 8; |
1241 | xchar_info = xchar_info_newlcd; | 1241 | xchar_info = xchar_info_newlcd; |
1242 | xchar_info_size = sizeof(xchar_info_newlcd)/sizeof(struct xchar_info); | 1242 | xchar_info_size = sizeof(xchar_info_newlcd)/sizeof(struct xchar_info); |
1243 | } | 1243 | } |
1244 | else /* old lcd */ | 1244 | else /* old lcd */ |
1245 | { | 1245 | { |
1246 | hw_pattern_count = 4; | 1246 | lcd_pattern_count = 4; |
1247 | xchar_info = xchar_info_oldlcd; | 1247 | xchar_info = xchar_info_oldlcd; |
1248 | xchar_info_size = sizeof(xchar_info_oldlcd)/sizeof(struct xchar_info); | 1248 | xchar_info_size = sizeof(xchar_info_oldlcd)/sizeof(struct xchar_info); |
1249 | } | 1249 | } |
diff --git a/firmware/export/lcd-charcell.h b/firmware/export/lcd-charcell.h index 9a93cf19de..0684f9cd7b 100644 --- a/firmware/export/lcd-charcell.h +++ b/firmware/export/lcd-charcell.h | |||
@@ -17,6 +17,20 @@ | |||
17 | * | 17 | * |
18 | ****************************************************************************/ | 18 | ****************************************************************************/ |
19 | 19 | ||
20 | /* target dependent - to be adjusted for other charcell targets */ | ||
21 | #define HW_PATTERN_SIZE 7 /* number of bytes per pattern */ | ||
22 | #define MAX_HW_PATTERNS 8 /* max. number of user-definable hw patterns */ | ||
23 | |||
24 | struct cursor_info { | ||
25 | unsigned char hw_char; | ||
26 | bool enabled; | ||
27 | bool visible; | ||
28 | int x; | ||
29 | int y; | ||
30 | int divider; | ||
31 | int downcount; | ||
32 | }; | ||
33 | |||
20 | /* map unicode characters to hardware or extended lcd characters */ | 34 | /* map unicode characters to hardware or extended lcd characters */ |
21 | struct xchar_info { | 35 | struct xchar_info { |
22 | unsigned short ucs; | 36 | unsigned short ucs; |
@@ -28,10 +42,18 @@ struct xchar_info { | |||
28 | unsigned char hw_char; /* direct or substitute */ | 42 | unsigned char hw_char; /* direct or substitute */ |
29 | }; | 43 | }; |
30 | 44 | ||
31 | /* target dependent - to be adjusted for other charcell targets */ | 45 | /* track usage of user-definable characters */ |
32 | #define HW_PATTERN_SIZE 7 /* number of bytes per pattern */ | 46 | struct pattern_info { |
33 | #define MAX_HW_PATTERNS 8 /* max. number of user-definable hw patterns */ | 47 | short count; |
34 | extern int hw_pattern_count; /* actual number of user-definable hw patterns */ | 48 | unsigned short xchar; |
49 | unsigned char pattern[HW_PATTERN_SIZE]; | ||
50 | }; | ||
51 | |||
52 | extern int lcd_pattern_count; /* actual number of user-definable hw patterns */ | ||
53 | |||
54 | extern unsigned char lcd_charbuffer[LCD_HEIGHT][LCD_WIDTH]; | ||
55 | extern struct pattern_info lcd_patterns[MAX_HW_PATTERNS]; | ||
56 | extern struct cursor_info lcd_cursor; | ||
35 | 57 | ||
36 | extern const struct xchar_info *xchar_info; | 58 | extern const struct xchar_info *xchar_info; |
37 | extern int xchar_info_size; /* number of entries */ | 59 | extern int xchar_info_size; /* number of entries */ |
diff --git a/firmware/export/lcd.h b/firmware/export/lcd.h index 48de53ada3..68f0961a5c 100644 --- a/firmware/export/lcd.h +++ b/firmware/export/lcd.h | |||
@@ -64,6 +64,7 @@ extern int lcd_getxmargin(void); | |||
64 | extern int lcd_getymargin(void); | 64 | extern int lcd_getymargin(void); |
65 | extern int lcd_getstringsize(const unsigned char *str, int *w, int *h); | 65 | extern int lcd_getstringsize(const unsigned char *str, int *w, int *h); |
66 | 66 | ||
67 | extern void lcd_update(void); | ||
67 | extern void lcd_clear_display(void); | 68 | extern void lcd_clear_display(void); |
68 | extern void lcd_putsxy(int x, int y, const unsigned char *string); | 69 | extern void lcd_putsxy(int x, int y, const unsigned char *string); |
69 | extern void lcd_puts(int x, int y, const unsigned char *string); | 70 | extern void lcd_puts(int x, int y, const unsigned char *string); |
@@ -79,7 +80,6 @@ extern void lcd_scroll_delay(int ms); | |||
79 | extern void lcd_puts_scroll(int x, int y, const unsigned char* string); | 80 | extern void lcd_puts_scroll(int x, int y, const unsigned char* string); |
80 | extern void lcd_puts_scroll_style(int x, int y, const unsigned char* string, | 81 | extern void lcd_puts_scroll_style(int x, int y, const unsigned char* string, |
81 | int style); | 82 | int style); |
82 | extern void lcd_icon(int icon, bool enable); | ||
83 | 83 | ||
84 | #if defined(HAVE_LCD_COLOR) && !defined(SIMULATOR) | 84 | #if defined(HAVE_LCD_COLOR) && !defined(SIMULATOR) |
85 | extern void lcd_yuv_blit(unsigned char * const src[3], | 85 | extern void lcd_yuv_blit(unsigned char * const src[3], |
@@ -87,12 +87,11 @@ extern void lcd_yuv_blit(unsigned char * const src[3], | |||
87 | int x, int y, int width, int height); | 87 | int x, int y, int width, int height); |
88 | #endif | 88 | #endif |
89 | 89 | ||
90 | #if defined(SIMULATOR) || defined(HAVE_LCD_BITMAP) | 90 | #ifdef HAVE_LCD_BITMAP |
91 | /* performance function */ | 91 | /* performance function */ |
92 | extern void lcd_blit(const fb_data* data, int x, int by, int width, | 92 | extern void lcd_blit(const fb_data* data, int x, int by, int width, |
93 | int bheight, int stride); | 93 | int bheight, int stride); |
94 | 94 | ||
95 | extern void lcd_update(void); | ||
96 | /* update a fraction of the screen */ | 95 | /* update a fraction of the screen */ |
97 | extern void lcd_update_rect(int x, int y, int width, int height); | 96 | extern void lcd_update_rect(int x, int y, int width, int height); |
98 | 97 | ||
@@ -101,10 +100,6 @@ extern void lcd_remote_update(void); | |||
101 | /* update a fraction of the screen */ | 100 | /* update a fraction of the screen */ |
102 | extern void lcd_remote_update_rect(int x, int y, int width, int height); | 101 | extern void lcd_remote_update_rect(int x, int y, int width, int height); |
103 | #endif | 102 | #endif |
104 | |||
105 | #else | ||
106 | #define lcd_update() | ||
107 | #define lcd_update_rect(x,y,w,h) | ||
108 | #endif | 103 | #endif |
109 | 104 | ||
110 | #ifdef HAVE_LCD_CHARCELLS | 105 | #ifdef HAVE_LCD_CHARCELLS |
@@ -132,9 +127,8 @@ enum | |||
132 | ICON_PARAM | 127 | ICON_PARAM |
133 | }; | 128 | }; |
134 | 129 | ||
130 | void lcd_icon(int icon, bool enable); | ||
135 | void lcd_double_height(bool on); | 131 | void lcd_double_height(bool on); |
136 | void lcd_put_hw_char(int x, int y, unsigned char hw_char); | ||
137 | void lcd_define_hw_pattern(int which, const char *pattern); | ||
138 | void lcd_define_pattern(unsigned long ucs, const char *pattern); | 132 | void lcd_define_pattern(unsigned long ucs, const char *pattern); |
139 | unsigned long lcd_get_locked_pattern(void); | 133 | unsigned long lcd_get_locked_pattern(void); |
140 | void lcd_unlock_pattern(unsigned long ucs); | 134 | void lcd_unlock_pattern(unsigned long ucs); |
diff --git a/firmware/target/sh/archos/player/lcd-player.c b/firmware/target/sh/archos/player/lcd-player.c index 7018b2277a..8f59901116 100644 --- a/firmware/target/sh/archos/player/lcd-player.c +++ b/firmware/target/sh/archos/player/lcd-player.c | |||
@@ -23,6 +23,7 @@ | |||
23 | #include "hwcompat.h" | 23 | #include "hwcompat.h" |
24 | #include "system.h" | 24 | #include "system.h" |
25 | #include "lcd.h" | 25 | #include "lcd.h" |
26 | #include "lcd-charcell.h" | ||
26 | 27 | ||
27 | #define OLD_LCD_CRAM ((char)0xB0) /* Characters */ | 28 | #define OLD_LCD_CRAM ((char)0xB0) /* Characters */ |
28 | #define OLD_LCD_PRAM ((char)0x80) /* Patterns */ | 29 | #define OLD_LCD_PRAM ((char)0x80) /* Patterns */ |
@@ -69,17 +70,6 @@ void lcd_double_height(bool on) | |||
69 | : NEW_LCD_SET_DOUBLE_HEIGHT); | 70 | : NEW_LCD_SET_DOUBLE_HEIGHT); |
70 | } | 71 | } |
71 | 72 | ||
72 | void lcd_put_hw_char(int x, int y, unsigned char hw_char) | ||
73 | { | ||
74 | lcd_write_command_e(LCD_CURSOR(x, y), hw_char); | ||
75 | } | ||
76 | |||
77 | void lcd_define_hw_pattern (int which, const char *pattern) | ||
78 | { | ||
79 | lcd_write_command(lcd_pram | (which << 3)); | ||
80 | lcd_write_data(pattern, 7); | ||
81 | } | ||
82 | |||
83 | void lcd_icon(int icon, bool enable) | 73 | void lcd_icon(int icon, bool enable) |
84 | { | 74 | { |
85 | static const struct { | 75 | static const struct { |
@@ -233,3 +223,29 @@ void lcd_init_device(void) | |||
233 | } | 223 | } |
234 | lcd_set_contrast(lcd_default_contrast()); | 224 | lcd_set_contrast(lcd_default_contrast()); |
235 | } | 225 | } |
226 | |||
227 | /*** Update functions ***/ | ||
228 | |||
229 | void lcd_update(void) | ||
230 | { | ||
231 | int y; | ||
232 | |||
233 | for (y = 0; y < lcd_pattern_count; y++) | ||
234 | { | ||
235 | if (lcd_patterns[y].count > 0) | ||
236 | { | ||
237 | lcd_write_command(lcd_pram | (y << 3)); | ||
238 | lcd_write_data(lcd_patterns[y].pattern, 7); | ||
239 | } | ||
240 | } | ||
241 | for (y = 0; y < LCD_HEIGHT; y++) | ||
242 | { | ||
243 | lcd_write_command(LCD_CURSOR(0, y)); | ||
244 | lcd_write_data(lcd_charbuffer[y], LCD_WIDTH); | ||
245 | } | ||
246 | if (lcd_cursor.visible) | ||
247 | { | ||
248 | lcd_write_command_e(LCD_CURSOR(lcd_cursor.x, lcd_cursor.y), | ||
249 | lcd_cursor.hw_char); | ||
250 | } | ||
251 | } | ||
diff --git a/uisimulator/common/font-player.c b/uisimulator/common/font-player.c index e85304dcdc..03bb9dd0fd 100644 --- a/uisimulator/common/font-player.c +++ b/uisimulator/common/font-player.c | |||
@@ -16,533 +16,531 @@ | |||
16 | ****************************************************************************/ | 16 | ****************************************************************************/ |
17 | 17 | ||
18 | #include "font-player.h" | 18 | #include "font-player.h" |
19 | |||
20 | #include "hwcompat.h" | 19 | #include "hwcompat.h" |
21 | 20 | ||
22 | 21 | static unsigned char font_player_newlcd[256][7] = { | |
23 | unsigned char font_new_player[256][5] = { | 22 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 00 */ |
24 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 00 */ | 23 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 01 */ |
25 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 01 */ | 24 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 02 */ |
26 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 02 */ | 25 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 03 */ |
27 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 03 */ | 26 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 04 */ |
28 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 04 */ | 27 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 05 */ |
29 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 05 */ | 28 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 06 */ |
30 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 06 */ | 29 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 07 */ |
31 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 07 */ | 30 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 08 */ |
32 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 08 */ | 31 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 09 */ |
33 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 09 */ | 32 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0a */ |
34 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0a */ | 33 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0b */ |
35 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0b */ | 34 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0c */ |
36 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0c */ | 35 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0d */ |
37 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0d */ | 36 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0e */ |
38 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0e */ | 37 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0f */ |
39 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 0f */ | 38 | { 0x00, 0x10, 0x1c, 0x1f, 0x1c, 0x10, 0x00 }, /* 10 */ |
40 | { 0x3e, 0x1c, 0x1c, 0x08, 0x08 }, /* 10 */ | 39 | { 0x00, 0x01, 0x07, 0x1f, 0x07, 0x01, 0x00 }, /* 11 */ |
41 | { 0x08, 0x08, 0x1c, 0x1c, 0x3e }, /* 11 */ | 40 | { 0x00, 0x10, 0x08, 0x04, 0x02, 0x01, 0x00 }, /* 12 */ |
42 | { 0x02, 0x04, 0x08, 0x10, 0x20 }, /* 12 */ | 41 | { 0x0a, 0x0a, 0x0a, 0x0a, 0x00, 0x00, 0x0a }, /* 13 */ |
43 | { 0x00, 0x4f, 0x00, 0x4f, 0x00 }, /* 13 */ | 42 | { 0x0f, 0x1d, 0x1d, 0x0d, 0x05, 0x05, 0x05 }, /* 14 */ |
44 | { 0x06, 0x0f, 0x7f, 0x01, 0x7f }, /* 14 */ | 43 | { 0x07, 0x08, 0x0e, 0x11, 0x0e, 0x02, 0x1c }, /* 15 */ |
45 | { 0x48, 0x56, 0x55, 0x35, 0x09 }, /* 15 */ | 44 | { 0x00, 0x00, 0x1f, 0x1f, 0x00, 0x00, 0x00 }, /* 16 */ |
46 | { 0x0c, 0x0c, 0x0c, 0x0c, 0x0c }, /* 16 */ | 45 | { 0x01, 0x01, 0x05, 0x09, 0x1f, 0x08, 0x04 }, /* 17 */ |
47 | { 0x10, 0x38, 0x54, 0x10, 0x1f }, /* 17 */ | 46 | { 0x04, 0x0e, 0x15, 0x04, 0x04, 0x04, 0x04 }, /* 18 */ |
48 | { 0x04, 0x02, 0x7f, 0x02, 0x04 }, /* 18 */ | 47 | { 0x04, 0x04, 0x04, 0x04, 0x15, 0x0e, 0x04 }, /* 19 */ |
49 | { 0x10, 0x20, 0x7f, 0x20, 0x10 }, /* 19 */ | 48 | { 0x11, 0x19, 0x1d, 0x1f, 0x1d, 0x19, 0x11 }, /* 1a */ |
50 | { 0x7f, 0x3e, 0x1c, 0x08, 0x7f }, /* 1a */ | 49 | { 0x11, 0x13, 0x17, 0x1f, 0x17, 0x13, 0x11 }, /* 1b */ |
51 | { 0x7f, 0x08, 0x1c, 0x3e, 0x7f }, /* 1b */ | 50 | { 0x10, 0x14, 0x12, 0x1f, 0x12, 0x14, 0x10 }, /* 1c */ |
52 | { 0x7f, 0x08, 0x2a, 0x1c, 0x08 }, /* 1c */ | 51 | { 0x01, 0x05, 0x09, 0x1f, 0x09, 0x05, 0x01 }, /* 1d */ |
53 | { 0x08, 0x1c, 0x2a, 0x08, 0x7f }, /* 1d */ | 52 | { 0x00, 0x1f, 0x0e, 0x0e, 0x04, 0x04, 0x00 }, /* 1e */ |
54 | { 0x02, 0x0e, 0x3e, 0x0e, 0x02 }, /* 1e */ | 53 | { 0x00, 0x04, 0x04, 0x0e, 0x0e, 0x1f, 0x00 }, /* 1f */ |
55 | { 0x20, 0x38, 0x3e, 0x38, 0x20 }, /* 1f */ | 54 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 20 */ |
56 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 20 */ | 55 | { 0x04, 0x04, 0x04, 0x04, 0x00, 0x00, 0x04 }, /* 21 */ |
57 | { 0x00, 0x00, 0x4f, 0x00, 0x00 }, /* 21 */ | 56 | { 0x0a, 0x0a, 0x0a, 0x00, 0x00, 0x00, 0x00 }, /* 22 */ |
58 | { 0x00, 0x07, 0x00, 0x07, 0x00 }, /* 22 */ | 57 | { 0x0a, 0x0a, 0x1f, 0x0a, 0x1f, 0x0a, 0x0a }, /* 23 */ |
59 | { 0x14, 0x7f, 0x14, 0x7f, 0x14 }, /* 23 */ | 58 | { 0x04, 0x0f, 0x14, 0x0e, 0x05, 0x1e, 0x04 }, /* 24 */ |
60 | { 0x24, 0x2a, 0x7f, 0x2a, 0x12 }, /* 24 */ | 59 | { 0x18, 0x19, 0x02, 0x04, 0x08, 0x13, 0x03 }, /* 25 */ |
61 | { 0x23, 0x13, 0x08, 0x64, 0x62 }, /* 25 */ | 60 | { 0x0c, 0x12, 0x14, 0x08, 0x15, 0x12, 0x0d }, /* 26 */ |
62 | { 0x36, 0x49, 0x55, 0x22, 0x50 }, /* 26 */ | 61 | { 0x0c, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00 }, /* 27 */ |
63 | { 0x00, 0x05, 0x03, 0x00, 0x00 }, /* 27 */ | 62 | { 0x02, 0x04, 0x08, 0x08, 0x08, 0x04, 0x02 }, /* 28 */ |
64 | { 0x00, 0x1c, 0x22, 0x41, 0x00 }, /* 28 */ | 63 | { 0x08, 0x04, 0x02, 0x02, 0x02, 0x04, 0x08 }, /* 29 */ |
65 | { 0x00, 0x41, 0x22, 0x1c, 0x00 }, /* 29 */ | 64 | { 0x00, 0x04, 0x15, 0x0e, 0x15, 0x04, 0x00 }, /* 2a */ |
66 | { 0x14, 0x08, 0x3e, 0x08, 0x14 }, /* 2a */ | 65 | { 0x00, 0x04, 0x04, 0x1f, 0x04, 0x04, 0x00 }, /* 2b */ |
67 | { 0x08, 0x08, 0x3e, 0x08, 0x08 }, /* 2b */ | 66 | { 0x00, 0x00, 0x00, 0x00, 0x0c, 0x04, 0x08 }, /* 2c */ |
68 | { 0x00, 0x50, 0x30, 0x00, 0x00 }, /* 2c */ | 67 | { 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00 }, /* 2d */ |
69 | { 0x08, 0x08, 0x08, 0x08, 0x08 }, /* 2d */ | 68 | { 0x00, 0x00, 0x00, 0x00, 0x0c, 0x0c, 0x00 }, /* 2e */ |
70 | { 0x00, 0x30, 0x30, 0x00, 0x00 }, /* 2e */ | 69 | { 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x00 }, /* 2f */ |
71 | { 0x20, 0x10, 0x08, 0x04, 0x02 }, /* 2f */ | 70 | { 0x0e, 0x11, 0x13, 0x15, 0x19, 0x11, 0x0e }, /* 30 */ |
72 | { 0x3e, 0x51, 0x49, 0x45, 0x3e }, /* 30 */ | 71 | { 0x04, 0x0c, 0x04, 0x04, 0x04, 0x04, 0x0e }, /* 31 */ |
73 | { 0x00, 0x42, 0x7f, 0x40, 0x00 }, /* 31 */ | 72 | { 0x0e, 0x11, 0x01, 0x02, 0x04, 0x08, 0x1f }, /* 32 */ |
74 | { 0x42, 0x61, 0x51, 0x49, 0x46 }, /* 32 */ | 73 | { 0x1f, 0x02, 0x04, 0x02, 0x01, 0x11, 0x0e }, /* 33 */ |
75 | { 0x21, 0x41, 0x45, 0x4b, 0x31 }, /* 33 */ | 74 | { 0x02, 0x06, 0x0a, 0x12, 0x1f, 0x02, 0x02 }, /* 34 */ |
76 | { 0x18, 0x14, 0x12, 0x7f, 0x10 }, /* 34 */ | 75 | { 0x1f, 0x10, 0x1e, 0x01, 0x01, 0x11, 0x0e }, /* 35 */ |
77 | { 0x27, 0x45, 0x45, 0x45, 0x39 }, /* 35 */ | 76 | { 0x06, 0x08, 0x10, 0x1e, 0x11, 0x11, 0x0e }, /* 36 */ |
78 | { 0x3c, 0x4a, 0x49, 0x49, 0x30 }, /* 36 */ | 77 | { 0x1f, 0x01, 0x02, 0x02, 0x04, 0x04, 0x04 }, /* 37 */ |
79 | { 0x01, 0x01, 0x71, 0x0d, 0x03 }, /* 37 */ | 78 | { 0x0e, 0x11, 0x11, 0x0e, 0x11, 0x11, 0x0e }, /* 38 */ |
80 | { 0x36, 0x49, 0x49, 0x49, 0x36 }, /* 38 */ | 79 | { 0x0e, 0x11, 0x11, 0x0f, 0x01, 0x02, 0x0c }, /* 39 */ |
81 | { 0x06, 0x49, 0x49, 0x29, 0x1e }, /* 39 */ | 80 | { 0x00, 0x0c, 0x0c, 0x00, 0x0c, 0x0c, 0x00 }, /* 3a */ |
82 | { 0x00, 0x36, 0x36, 0x00, 0x00 }, /* 3a */ | 81 | { 0x0c, 0x0c, 0x00, 0x0c, 0x0c, 0x04, 0x08 }, /* 3b */ |
83 | { 0x00, 0x5b, 0x3b, 0x00, 0x00 }, /* 3b */ | 82 | { 0x02, 0x04, 0x08, 0x10, 0x08, 0x04, 0x02 }, /* 3c */ |
84 | { 0x08, 0x14, 0x22, 0x41, 0x00 }, /* 3c */ | 83 | { 0x00, 0x00, 0x1f, 0x00, 0x1f, 0x00, 0x00 }, /* 3d */ |
85 | { 0x14, 0x14, 0x14, 0x14, 0x14 }, /* 3d */ | 84 | { 0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08 }, /* 3e */ |
86 | { 0x00, 0x41, 0x22, 0x14, 0x08 }, /* 3e */ | 85 | { 0x0e, 0x11, 0x01, 0x02, 0x04, 0x00, 0x04 }, /* 3f */ |
87 | { 0x02, 0x01, 0x51, 0x09, 0x06 }, /* 3f */ | 86 | { 0x0e, 0x11, 0x01, 0x0d, 0x15, 0x15, 0x0e }, /* 40 */ |
88 | { 0x32, 0x49, 0x79, 0x41, 0x3e }, /* 40 */ | 87 | { 0x0e, 0x11, 0x11, 0x11, 0x1f, 0x11, 0x11 }, /* 41 */ |
89 | { 0x7e, 0x11, 0x11, 0x11, 0x7e }, /* 41 */ | 88 | { 0x1e, 0x11, 0x11, 0x1e, 0x11, 0x11, 0x1e }, /* 42 */ |
90 | { 0x7f, 0x49, 0x49, 0x49, 0x36 }, /* 42 */ | 89 | { 0x0e, 0x11, 0x10, 0x10, 0x10, 0x11, 0x0e }, /* 43 */ |
91 | { 0x3e, 0x41, 0x41, 0x41, 0x22 }, /* 43 */ | 90 | { 0x1c, 0x12, 0x11, 0x11, 0x11, 0x12, 0x1c }, /* 44 */ |
92 | { 0x7f, 0x41, 0x41, 0x22, 0x1c }, /* 44 */ | 91 | { 0x1f, 0x10, 0x10, 0x1e, 0x10, 0x10, 0x1f }, /* 45 */ |
93 | { 0x7f, 0x49, 0x49, 0x49, 0x41 }, /* 45 */ | 92 | { 0x1f, 0x10, 0x10, 0x1e, 0x10, 0x10, 0x10 }, /* 46 */ |
94 | { 0x7f, 0x09, 0x09, 0x09, 0x01 }, /* 46 */ | 93 | { 0x0e, 0x11, 0x10, 0x17, 0x11, 0x11, 0x0f }, /* 47 */ |
95 | { 0x3e, 0x41, 0x49, 0x49, 0x7a }, /* 47 */ | 94 | { 0x11, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11 }, /* 48 */ |
96 | { 0x7f, 0x08, 0x08, 0x08, 0x7f }, /* 48 */ | 95 | { 0x0e, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e }, /* 49 */ |
97 | { 0x00, 0x41, 0x7f, 0x41, 0x00 }, /* 49 */ | 96 | { 0x0f, 0x02, 0x02, 0x02, 0x02, 0x12, 0x0c }, /* 4a */ |
98 | { 0x20, 0x41, 0x41, 0x3f, 0x01 }, /* 4a */ | 97 | { 0x11, 0x12, 0x14, 0x18, 0x14, 0x12, 0x11 }, /* 4b */ |
99 | { 0x7f, 0x08, 0x14, 0x22, 0x41 }, /* 4b */ | 98 | { 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1f }, /* 4c */ |
100 | { 0x7f, 0x40, 0x40, 0x40, 0x40 }, /* 4c */ | 99 | { 0x11, 0x1b, 0x15, 0x15, 0x11, 0x11, 0x11 }, /* 4d */ |
101 | { 0x7f, 0x02, 0x0c, 0x02, 0x7f }, /* 4d */ | 100 | { 0x11, 0x11, 0x19, 0x15, 0x13, 0x11, 0x11 }, /* 4e */ |
102 | { 0x7f, 0x04, 0x08, 0x10, 0x7f }, /* 4e */ | 101 | { 0x0e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 4f */ |
103 | { 0x3e, 0x41, 0x41, 0x41, 0x3e }, /* 4f */ | 102 | { 0x1e, 0x11, 0x11, 0x1e, 0x10, 0x10, 0x10 }, /* 50 */ |
104 | { 0x7f, 0x09, 0x09, 0x09, 0x06 }, /* 50 */ | 103 | { 0x0e, 0x11, 0x11, 0x11, 0x11, 0x12, 0x0d }, /* 51 */ |
105 | { 0x3e, 0x41, 0x41, 0x21, 0x5e }, /* 51 */ | 104 | { 0x1e, 0x11, 0x11, 0x1e, 0x14, 0x12, 0x11 }, /* 52 */ |
106 | { 0x7f, 0x09, 0x19, 0x29, 0x46 }, /* 52 */ | 105 | { 0x0e, 0x11, 0x10, 0x0e, 0x01, 0x11, 0x0e }, /* 53 */ |
107 | { 0x26, 0x49, 0x49, 0x49, 0x32 }, /* 53 */ | 106 | { 0x1f, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04 }, /* 54 */ |
108 | { 0x01, 0x01, 0x7f, 0x01, 0x01 }, /* 54 */ | 107 | { 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 55 */ |
109 | { 0x3f, 0x40, 0x40, 0x40, 0x3f }, /* 55 */ | 108 | { 0x11, 0x11, 0x11, 0x11, 0x11, 0x0a, 0x04 }, /* 56 */ |
110 | { 0x1f, 0x20, 0x40, 0x20, 0x1f }, /* 56 */ | 109 | { 0x11, 0x11, 0x11, 0x15, 0x15, 0x15, 0x0a }, /* 57 */ |
111 | { 0x3f, 0x40, 0x38, 0x40, 0x3f }, /* 57 */ | 110 | { 0x11, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x11 }, /* 58 */ |
112 | { 0x63, 0x14, 0x08, 0x14, 0x63 }, /* 58 */ | 111 | { 0x11, 0x11, 0x0a, 0x04, 0x04, 0x04, 0x04 }, /* 59 */ |
113 | { 0x03, 0x04, 0x78, 0x04, 0x03 }, /* 59 */ | 112 | { 0x1f, 0x01, 0x02, 0x04, 0x08, 0x10, 0x1f }, /* 5a */ |
114 | { 0x61, 0x51, 0x49, 0x45, 0x43 }, /* 5a */ | 113 | { 0x0e, 0x08, 0x08, 0x08, 0x08, 0x08, 0x0e }, /* 5b */ |
115 | { 0x00, 0x7f, 0x41, 0x41, 0x00 }, /* 5b */ | 114 | { 0x11, 0x0a, 0x1f, 0x04, 0x1f, 0x04, 0x04 }, /* 5c */ |
116 | { 0x15, 0x16, 0x7c, 0x16, 0x15 }, /* 5c */ | 115 | { 0x0e, 0x02, 0x02, 0x02, 0x02, 0x02, 0x0e }, /* 5d */ |
117 | { 0x00, 0x41, 0x41, 0x7f, 0x00 }, /* 5d */ | 116 | { 0x04, 0x0a, 0x11, 0x00, 0x00, 0x00, 0x00 }, /* 5e */ |
118 | { 0x04, 0x02, 0x01, 0x02, 0x04 }, /* 5e */ | 117 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f }, /* 5f */ |
119 | { 0x40, 0x40, 0x40, 0x40, 0x40 }, /* 5f */ | 118 | { 0x08, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00 }, /* 60 */ |
120 | { 0x00, 0x01, 0x02, 0x04, 0x00 }, /* 60 */ | 119 | { 0x00, 0x00, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 61 */ |
121 | { 0x20, 0x54, 0x54, 0x54, 0x78 }, /* 61 */ | 120 | { 0x10, 0x10, 0x16, 0x19, 0x11, 0x11, 0x1e }, /* 62 */ |
122 | { 0x7f, 0x48, 0x44, 0x44, 0x38 }, /* 62 */ | 121 | { 0x00, 0x00, 0x0e, 0x10, 0x10, 0x11, 0x0e }, /* 63 */ |
123 | { 0x38, 0x44, 0x44, 0x44, 0x20 }, /* 63 */ | 122 | { 0x01, 0x01, 0x0d, 0x13, 0x11, 0x11, 0x0f }, /* 64 */ |
124 | { 0x38, 0x44, 0x44, 0x48, 0x7f }, /* 64 */ | 123 | { 0x00, 0x00, 0x0e, 0x11, 0x1f, 0x10, 0x0e }, /* 65 */ |
125 | { 0x38, 0x54, 0x54, 0x54, 0x18 }, /* 65 */ | 124 | { 0x06, 0x09, 0x08, 0x1c, 0x08, 0x08, 0x08 }, /* 66 */ |
126 | { 0x08, 0x7e, 0x09, 0x01, 0x02 }, /* 66 */ | 125 | { 0x00, 0x0f, 0x11, 0x11, 0x0f, 0x01, 0x0e }, /* 67 */ |
127 | { 0x0c, 0x52, 0x52, 0x52, 0x3e }, /* 67 */ | 126 | { 0x10, 0x10, 0x16, 0x19, 0x11, 0x11, 0x11 }, /* 68 */ |
128 | { 0x7f, 0x08, 0x04, 0x04, 0x78 }, /* 68 */ | 127 | { 0x04, 0x00, 0x0c, 0x04, 0x04, 0x04, 0x0e }, /* 69 */ |
129 | { 0x00, 0x44, 0x7d, 0x40, 0x00 }, /* 69 */ | 128 | { 0x02, 0x00, 0x06, 0x02, 0x02, 0x12, 0x0c }, /* 6a */ |
130 | { 0x20, 0x40, 0x44, 0x3d, 0x00 }, /* 6a */ | 129 | { 0x10, 0x10, 0x12, 0x14, 0x18, 0x14, 0x12 }, /* 6b */ |
131 | { 0x7f, 0x10, 0x28, 0x44, 0x00 }, /* 6b */ | 130 | { 0x0c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e }, /* 6c */ |
132 | { 0x00, 0x41, 0x7f, 0x40, 0x00 }, /* 6c */ | 131 | { 0x00, 0x00, 0x1a, 0x15, 0x15, 0x11, 0x11 }, /* 6d */ |
133 | { 0x7c, 0x04, 0x18, 0x04, 0x78 }, /* 6d */ | 132 | { 0x00, 0x00, 0x16, 0x19, 0x11, 0x11, 0x11 }, /* 6e */ |
134 | { 0x7c, 0x08, 0x04, 0x04, 0x78 }, /* 6e */ | 133 | { 0x00, 0x00, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 6f */ |
135 | { 0x38, 0x44, 0x44, 0x44, 0x38 }, /* 6f */ | 134 | { 0x00, 0x00, 0x1e, 0x11, 0x1e, 0x10, 0x10 }, /* 70 */ |
136 | { 0x7c, 0x14, 0x14, 0x14, 0x08 }, /* 70 */ | 135 | { 0x00, 0x00, 0x0d, 0x13, 0x0f, 0x01, 0x01 }, /* 71 */ |
137 | { 0x08, 0x14, 0x14, 0x18, 0x7c }, /* 71 */ | 136 | { 0x00, 0x00, 0x16, 0x19, 0x10, 0x10, 0x10 }, /* 72 */ |
138 | { 0x7c, 0x08, 0x04, 0x04, 0x08 }, /* 72 */ | 137 | { 0x00, 0x00, 0x0e, 0x10, 0x0e, 0x01, 0x1e }, /* 73 */ |
139 | { 0x48, 0x54, 0x54, 0x54, 0x20 }, /* 73 */ | 138 | { 0x08, 0x08, 0x1c, 0x08, 0x08, 0x09, 0x06 }, /* 74 */ |
140 | { 0x04, 0x3f, 0x44, 0x40, 0x20 }, /* 74 */ | 139 | { 0x00, 0x00, 0x11, 0x11, 0x11, 0x13, 0x0d }, /* 75 */ |
141 | { 0x3c, 0x40, 0x40, 0x20, 0x7c }, /* 75 */ | 140 | { 0x00, 0x00, 0x11, 0x11, 0x11, 0x0a, 0x04 }, /* 76 */ |
142 | { 0x1c, 0x20, 0x40, 0x20, 0x1c }, /* 76 */ | 141 | { 0x00, 0x00, 0x11, 0x11, 0x15, 0x15, 0x0a }, /* 77 */ |
143 | { 0x3c, 0x40, 0x30, 0x40, 0x3c }, /* 77 */ | 142 | { 0x00, 0x00, 0x11, 0x0a, 0x04, 0x0a, 0x11 }, /* 78 */ |
144 | { 0x44, 0x28, 0x10, 0x28, 0x44 }, /* 78 */ | 143 | { 0x00, 0x00, 0x11, 0x11, 0x0f, 0x01, 0x1e }, /* 79 */ |
145 | { 0x4c, 0x50, 0x50, 0x50, 0x3c }, /* 79 */ | 144 | { 0x00, 0x00, 0x1f, 0x02, 0x04, 0x08, 0x1f }, /* 7a */ |
146 | { 0x44, 0x64, 0x54, 0x4c, 0x44 }, /* 7a */ | 145 | { 0x02, 0x04, 0x04, 0x08, 0x04, 0x04, 0x02 }, /* 7b */ |
147 | { 0x00, 0x08, 0x36, 0x41, 0x00 }, /* 7b */ | 146 | { 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04 }, /* 7c */ |
148 | { 0x00, 0x00, 0x7f, 0x00, 0x00 }, /* 7c */ | 147 | { 0x08, 0x04, 0x04, 0x02, 0x04, 0x04, 0x08 }, /* 7d */ |
149 | { 0x00, 0x41, 0x36, 0x08, 0x00 }, /* 7d */ | 148 | { 0x00, 0x04, 0x02, 0x1f, 0x02, 0x04, 0x00 }, /* 7e */ |
150 | { 0x08, 0x08, 0x2a, 0x1c, 0x08 }, /* 7e */ | 149 | { 0x00, 0x04, 0x08, 0x1f, 0x08, 0x04, 0x00 }, /* 7f */ |
151 | { 0x08, 0x1c, 0x2a, 0x08, 0x08 }, /* 7f */ | 150 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f }, /* 80 */ |
152 | { 0x40, 0x40, 0x40, 0x40, 0x40 }, /* 80 */ | 151 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f }, /* 81 */ |
153 | { 0x60, 0x60, 0x60, 0x60, 0x60 }, /* 81 */ | 152 | { 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x1f }, /* 82 */ |
154 | { 0x70, 0x70, 0x70, 0x70, 0x70 }, /* 82 */ | 153 | { 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f }, /* 83 */ |
155 | { 0x78, 0x78, 0x78, 0x78, 0x78 }, /* 83 */ | 154 | { 0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* 84 */ |
156 | { 0x7c, 0x7c, 0x7c, 0x7c, 0x7c }, /* 84 */ | 155 | { 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* 85 */ |
157 | { 0x7e, 0x7e, 0x7e, 0x7e, 0x7e }, /* 85 */ | 156 | { 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* 86 */ |
158 | { 0x7f, 0x7f, 0x7f, 0x7f, 0x7f }, /* 86 */ | 157 | { 0x00, 0x0a, 0x04, 0x1f, 0x04, 0x0a, 0x00 }, /* 87 */ |
159 | { 0x08, 0x2a, 0x1c, 0x2a, 0x08 }, /* 87 */ | 158 | { 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11 }, /* 88 */ |
160 | { 0x7f, 0x00, 0x00, 0x00, 0x7f }, /* 88 */ | 159 | { 0x19, 0x19, 0x19, 0x19, 0x19, 0x19, 0x19 }, /* 89 */ |
161 | { 0x7f, 0x7f, 0x00, 0x00, 0x7f }, /* 89 */ | 160 | { 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d, 0x1d }, /* 8a */ |
162 | { 0x7f, 0x7f, 0x7f, 0x00, 0x7f }, /* 8a */ | 161 | { 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08 }, /* 8b */ |
163 | { 0x00, 0x7f, 0x00, 0x00, 0x00 }, /* 8b */ | 162 | { 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c }, /* 8c */ |
164 | { 0x00, 0x7f, 0x7f, 0x00, 0x00 }, /* 8c */ | 163 | { 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e }, /* 8d */ |
165 | { 0x00, 0x7f, 0x7f, 0x7f, 0x00 }, /* 8d */ | 164 | { 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f }, /* 8e */ |
166 | { 0x00, 0x7f, 0x7f, 0x7f, 0x7f }, /* 8e */ | 165 | { 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x00 }, /* 8f */ |
167 | { 0x3e, 0x3e, 0x3e, 0x3e, 0x3e }, /* 8f */ | 166 | { 0x00, 0x0e, 0x1f, 0x1f, 0x1f, 0x0e, 0x00 }, /* 90 */ |
168 | { 0x1c, 0x3e, 0x3e, 0x3e, 0x1c }, /* 90 */ | 167 | { 0x1f, 0x11, 0x11, 0x11, 0x11, 0x11, 0x1f }, /* 91 */ |
169 | { 0x7f, 0x41, 0x41, 0x41, 0x7f }, /* 91 */ | 168 | { 0x1f, 0x1b, 0x13, 0x1b, 0x1b, 0x11, 0x1f }, /* 92 */ |
170 | { 0x7f, 0x5b, 0x41, 0x5f, 0x7f }, /* 92 */ | 169 | { 0x1f, 0x11, 0x1d, 0x1b, 0x17, 0x11, 0x1f }, /* 93 */ |
171 | { 0x7f, 0x4d, 0x55, 0x59, 0x7f }, /* 93 */ | 170 | { 0x00, 0x00, 0x07, 0x04, 0x04, 0x14, 0x08 }, /* 94 */ |
172 | { 0x20, 0x40, 0x3c, 0x04, 0x04 }, /* 94 */ | 171 | { 0x04, 0x04, 0x1f, 0x04, 0x04, 0x00, 0x1f }, /* 95 */ |
173 | { 0x44, 0x44, 0x5f, 0x44, 0x44 }, /* 95 */ | 172 | { 0x00, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x00 }, /* 96 */ |
174 | { 0x22, 0x14, 0x08, 0x14, 0x22 }, /* 96 */ | 173 | { 0x00, 0x04, 0x00, 0x1f, 0x00, 0x04, 0x00 }, /* 97 */ |
175 | { 0x08, 0x08, 0x2a, 0x08, 0x08 }, /* 97 */ | 174 | { 0x1f, 0x00, 0x11, 0x0a, 0x04, 0x0a, 0x11 }, /* 98 */ |
176 | { 0x45, 0x29, 0x11, 0x29, 0x45 }, /* 98 */ | 175 | { 0x1c, 0x04, 0x1c, 0x10, 0x1c, 0x00, 0x00 }, /* 99 */ |
177 | { 0x1d, 0x15, 0x17, 0x00, 0x00 }, /* 99 */ | 176 | { 0x1c, 0x04, 0x1c, 0x04, 0x1c, 0x00, 0x00 }, /* 9a */ |
178 | { 0x15, 0x15, 0x1f, 0x00, 0x00 }, /* 9a */ | 177 | { 0x11, 0x12, 0x17, 0x09, 0x17, 0x04, 0x07 }, /* 9b */ |
179 | { 0x17, 0x08, 0x74, 0x56, 0x5d }, /* 9b */ | 178 | { 0x11, 0x12, 0x14, 0x09, 0x13, 0x07, 0x01 }, /* 9c */ |
180 | { 0x17, 0x08, 0x24, 0x32, 0x79 }, /* 9c */ | 179 | { 0x18, 0x09, 0x1a, 0x0d, 0x1b, 0x17, 0x01 }, /* 9d */ |
181 | { 0x35, 0x1f, 0x28, 0x34, 0x7a }, /* 9d */ | 180 | { 0x00, 0x05, 0x0a, 0x14, 0x0a, 0x05, 0x00 }, /* 9e */ |
182 | { 0x08, 0x14, 0x2a, 0x14, 0x22 }, /* 9e */ | 181 | { 0x00, 0x14, 0x0a, 0x05, 0x0a, 0x14, 0x00 }, /* 9f */ |
183 | { 0x22, 0x14, 0x2a, 0x14, 0x08 }, /* 9f */ | 182 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* a0 */ |
184 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* a0 */ | 183 | { 0x00, 0x00, 0x00, 0x00, 0x1c, 0x14, 0x1c }, /* a1 */ |
185 | { 0x70, 0x50, 0x70, 0x00, 0x00 }, /* a1 */ | 184 | { 0x07, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00 }, /* a2 */ |
186 | { 0x00, 0x00, 0x0f, 0x01, 0x01 }, /* a2 */ | 185 | { 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x1c }, /* a3 */ |
187 | { 0x40, 0x40, 0x78, 0x00, 0x00 }, /* a3 */ | 186 | { 0x00, 0x00, 0x00, 0x00, 0x10, 0x08, 0x04 }, /* a4 */ |
188 | { 0x10, 0x20, 0x40, 0x00, 0x00 }, /* a4 */ | 187 | { 0x00, 0x00, 0x00, 0x0c, 0x0c, 0x00, 0x00 }, /* a5 */ |
189 | { 0x00, 0x18, 0x18, 0x00, 0x00 }, /* a5 */ | 188 | { 0x00, 0x1f, 0x01, 0x1f, 0x01, 0x02, 0x04 }, /* a6 */ |
190 | { 0x0a, 0x0a, 0x4a, 0x2a, 0x1e }, /* a6 */ | 189 | { 0x00, 0x00, 0x1f, 0x01, 0x06, 0x04, 0x08 }, /* a7 */ |
191 | { 0x04, 0x44, 0x34, 0x14, 0x0c }, /* a7 */ | 190 | { 0x00, 0x00, 0x02, 0x04, 0x0c, 0x14, 0x04 }, /* a8 */ |
192 | { 0x20, 0x10, 0x78, 0x04, 0x00 }, /* a8 */ | 191 | { 0x00, 0x00, 0x04, 0x1f, 0x11, 0x01, 0x06 }, /* a9 */ |
193 | { 0x18, 0x08, 0x4c, 0x48, 0x38 }, /* a9 */ | 192 | { 0x00, 0x00, 0x00, 0x1f, 0x04, 0x04, 0x1f }, /* aa */ |
194 | { 0x48, 0x48, 0x78, 0x48, 0x48 }, /* aa */ | 193 | { 0x00, 0x00, 0x02, 0x1f, 0x06, 0x0a, 0x12 }, /* ab */ |
195 | { 0x48, 0x28, 0x18, 0x7c, 0x08 }, /* ab */ | 194 | { 0x00, 0x00, 0x08, 0x1f, 0x09, 0x0a, 0x08 }, /* ac */ |
196 | { 0x08, 0x7c, 0x08, 0x28, 0x18 }, /* ac */ | 195 | { 0x00, 0x00, 0x00, 0x0e, 0x02, 0x02, 0x1f }, /* ad */ |
197 | { 0x40, 0x48, 0x48, 0x78, 0x40 }, /* ad */ | 196 | { 0x00, 0x00, 0x1e, 0x02, 0x1e, 0x02, 0x1e }, /* ae */ |
198 | { 0x54, 0x54, 0x54, 0x7c, 0x00 }, /* ae */ | 197 | { 0x00, 0x00, 0x00, 0x15, 0x15, 0x01, 0x06 }, /* af */ |
199 | { 0x18, 0x00, 0x58, 0x40, 0x38 }, /* af */ | 198 | { 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00 }, /* b0 */ |
200 | { 0x08, 0x08, 0x08, 0x08, 0x08 }, /* b0 */ | 199 | { 0x1f, 0x01, 0x05, 0x06, 0x04, 0x04, 0x08 }, /* b1 */ |
201 | { 0x01, 0x41, 0x3d, 0x09, 0x07 }, /* b1 */ | 200 | { 0x01, 0x02, 0x04, 0x0c, 0x14, 0x04, 0x04 }, /* b2 */ |
202 | { 0x10, 0x08, 0x7c, 0x02, 0x01 }, /* b2 */ | 201 | { 0x04, 0x1f, 0x11, 0x11, 0x01, 0x02, 0x04 }, /* b3 */ |
203 | { 0x0e, 0x02, 0x43, 0x22, 0x1e }, /* b3 */ | 202 | { 0x00, 0x1f, 0x04, 0x04, 0x04, 0x04, 0x1f }, /* b4 */ |
204 | { 0x42, 0x42, 0x7e, 0x42, 0x42 }, /* b4 */ | 203 | { 0x02, 0x1f, 0x02, 0x06, 0x0a, 0x12, 0x02 }, /* b5 */ |
205 | { 0x22, 0x12, 0x0a, 0x7f, 0x02 }, /* b5 */ | 204 | { 0x08, 0x1f, 0x09, 0x09, 0x09, 0x09, 0x12 }, /* b6 */ |
206 | { 0x42, 0x3f, 0x02, 0x42, 0x3e }, /* b6 */ | 205 | { 0x04, 0x1f, 0x04, 0x1f, 0x04, 0x04, 0x04 }, /* b7 */ |
207 | { 0x0a, 0x0a, 0x7f, 0x0a, 0x0a }, /* b7 */ | 206 | { 0x00, 0x0f, 0x09, 0x11, 0x01, 0x02, 0x0c }, /* b8 */ |
208 | { 0x08, 0x46, 0x42, 0x22, 0x1e }, /* b8 */ | 207 | { 0x08, 0x0f, 0x12, 0x02, 0x02, 0x02, 0x04 }, /* b9 */ |
209 | { 0x04, 0x03, 0x42, 0x3e, 0x02 }, /* b9 */ | 208 | { 0x00, 0x1f, 0x01, 0x01, 0x01, 0x01, 0x1f }, /* ba */ |
210 | { 0x42, 0x42, 0x42, 0x42, 0x7e }, /* ba */ | 209 | { 0x0a, 0x1f, 0x0a, 0x02, 0x02, 0x02, 0x04 }, /* bb */ |
211 | { 0x02, 0x07, 0x42, 0x3f, 0x02 }, /* bb */ | 210 | { 0x00, 0x18, 0x00, 0x18, 0x01, 0x02, 0x1c }, /* bc */ |
212 | { 0x4a, 0x4a, 0x40, 0x20, 0x10 }, /* bc */ | 211 | { 0x00, 0x1f, 0x01, 0x02, 0x04, 0x0a, 0x11 }, /* bd */ |
213 | { 0x42, 0x22, 0x12, 0x2a, 0x46 }, /* bd */ | 212 | { 0x08, 0x1f, 0x09, 0x0a, 0x08, 0x08, 0x07 }, /* be */ |
214 | { 0x02, 0x3f, 0x42, 0x4a, 0x46 }, /* be */ | 213 | { 0x00, 0x11, 0x11, 0x09, 0x01, 0x02, 0x0c }, /* bf */ |
215 | { 0x06, 0x48, 0x40, 0x20, 0x1e }, /* bf */ | 214 | { 0x00, 0x0f, 0x09, 0x15, 0x03, 0x02, 0x0c }, /* c0 */ |
216 | { 0x08, 0x46, 0x4a, 0x32, 0x1e }, /* c0 */ | 215 | { 0x02, 0x1c, 0x04, 0x1f, 0x04, 0x04, 0x08 }, /* c1 */ |
217 | { 0x0a, 0x4a, 0x3e, 0x09, 0x08 }, /* c1 */ | 216 | { 0x00, 0x15, 0x15, 0x15, 0x01, 0x02, 0x04 }, /* c2 */ |
218 | { 0x0e, 0x00, 0x4e, 0x20, 0x1e }, /* c2 */ | 217 | { 0x0e, 0x00, 0x1f, 0x04, 0x04, 0x04, 0x08 }, /* c3 */ |
219 | { 0x04, 0x45, 0x3d, 0x05, 0x04 }, /* c3 */ | 218 | { 0x08, 0x08, 0x08, 0x0c, 0x0a, 0x08, 0x08 }, /* c4 */ |
220 | { 0x00, 0x7f, 0x08, 0x10, 0x00 }, /* c4 */ | 219 | { 0x04, 0x04, 0x1f, 0x04, 0x04, 0x08, 0x10 }, /* c5 */ |
221 | { 0x44, 0x24, 0x1f, 0x04, 0x04 }, /* c5 */ | 220 | { 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x1f }, /* c6 */ |
222 | { 0x40, 0x42, 0x42, 0x42, 0x40 }, /* c6 */ | 221 | { 0x00, 0x1f, 0x01, 0x0a, 0x04, 0x0a, 0x10 }, /* c7 */ |
223 | { 0x42, 0x2a, 0x12, 0x2a, 0x06 }, /* c7 */ | 222 | { 0x04, 0x1f, 0x02, 0x04, 0x0e, 0x15, 0x04 }, /* c8 */ |
224 | { 0x22, 0x12, 0x7b, 0x16, 0x22 }, /* c8 */ | 223 | { 0x02, 0x02, 0x02, 0x02, 0x02, 0x04, 0x08 }, /* c9 */ |
225 | { 0x00, 0x40, 0x20, 0x1f, 0x00 }, /* c9 */ | 224 | { 0x00, 0x04, 0x02, 0x11, 0x11, 0x11, 0x11 }, /* ca */ |
226 | { 0x78, 0x00, 0x02, 0x04, 0x78 }, /* ca */ | 225 | { 0x10, 0x10, 0x1f, 0x10, 0x10, 0x10, 0x0f }, /* cb */ |
227 | { 0x3f, 0x44, 0x44, 0x44, 0x44 }, /* cb */ | 226 | { 0x00, 0x1f, 0x01, 0x01, 0x01, 0x02, 0x0c }, /* cc */ |
228 | { 0x02, 0x42, 0x42, 0x22, 0x1e }, /* cc */ | 227 | { 0x00, 0x08, 0x14, 0x02, 0x01, 0x01, 0x00 }, /* cd */ |
229 | { 0x04, 0x02, 0x04, 0x08, 0x30 }, /* cd */ | 228 | { 0x04, 0x1f, 0x04, 0x04, 0x15, 0x15, 0x04 }, /* ce */ |
230 | { 0x32, 0x02, 0x7f, 0x02, 0x32 }, /* ce */ | 229 | { 0x00, 0x1f, 0x01, 0x01, 0x0a, 0x04, 0x02 }, /* cf */ |
231 | { 0x02, 0x12, 0x22, 0x52, 0x0e }, /* cf */ | 230 | { 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x01 }, /* d0 */ |
232 | { 0x00, 0x2a, 0x2a, 0x2a, 0x40 }, /* d0 */ | 231 | { 0x00, 0x04, 0x08, 0x10, 0x11, 0x1f, 0x01 }, /* d1 */ |
233 | { 0x38, 0x24, 0x22, 0x20, 0x70 }, /* d1 */ | 232 | { 0x00, 0x01, 0x01, 0x0a, 0x04, 0x0a, 0x10 }, /* d2 */ |
234 | { 0x40, 0x28, 0x10, 0x28, 0x06 }, /* d2 */ | 233 | { 0x00, 0x1f, 0x08, 0x1f, 0x08, 0x08, 0x07 }, /* d3 */ |
235 | { 0x0a, 0x3e, 0x4a, 0x4a, 0x4a }, /* d3 */ | 234 | { 0x08, 0x08, 0x1f, 0x09, 0x0a, 0x08, 0x08 }, /* d4 */ |
236 | { 0x04, 0x7f, 0x04, 0x14, 0x0c }, /* d4 */ | 235 | { 0x00, 0x0e, 0x02, 0x02, 0x02, 0x02, 0x1f }, /* d5 */ |
237 | { 0x40, 0x42, 0x42, 0x7e, 0x40 }, /* d5 */ | 236 | { 0x00, 0x1f, 0x01, 0x1f, 0x01, 0x01, 0x1f }, /* d6 */ |
238 | { 0x4a, 0x4a, 0x4a, 0x4a, 0x7e }, /* d6 */ | 237 | { 0x0e, 0x00, 0x1f, 0x01, 0x01, 0x02, 0x04 }, /* d7 */ |
239 | { 0x04, 0x05, 0x45, 0x25, 0x1c }, /* d7 */ | 238 | { 0x12, 0x12, 0x12, 0x12, 0x12, 0x04, 0x08 }, /* d8 */ |
240 | { 0x1f, 0x40, 0x20, 0x1f, 0x00 }, /* d8 */ | 239 | { 0x00, 0x04, 0x14, 0x14, 0x15, 0x15, 0x16 }, /* d9 */ |
241 | { 0x7c, 0x00, 0x7e, 0x40, 0x30 }, /* d9 */ | 240 | { 0x00, 0x10, 0x10, 0x11, 0x12, 0x14, 0x18 }, /* da */ |
242 | { 0x7e, 0x40, 0x20, 0x10, 0x08 }, /* da */ | 241 | { 0x1f, 0x11, 0x11, 0x11, 0x11, 0x11, 0x1f }, /* db */ |
243 | { 0x7f, 0x41, 0x41, 0x41, 0x7f }, /* db */ | 242 | { 0x00, 0x1f, 0x11, 0x11, 0x01, 0x02, 0x04 }, /* dc */ |
244 | { 0x0e, 0x02, 0x42, 0x22, 0x1e }, /* dc */ | 243 | { 0x00, 0x18, 0x00, 0x01, 0x01, 0x02, 0x1c }, /* dd */ |
245 | { 0x42, 0x42, 0x40, 0x20, 0x18 }, /* dd */ | 244 | { 0x04, 0x12, 0x08, 0x00, 0x00, 0x00, 0x00 }, /* de */ |
246 | { 0x02, 0x04, 0x01, 0x02, 0x00 }, /* de */ | 245 | { 0x1c, 0x14, 0x1c, 0x00, 0x00, 0x00, 0x00 }, /* df */ |
247 | { 0x07, 0x05, 0x07, 0x00, 0x00 }, /* df */ | 246 | { 0x00, 0x00, 0x09, 0x15, 0x12, 0x12, 0x0d }, /* e0 */ |
248 | { 0x38, 0x44, 0x48, 0x30, 0x4c }, /* e0 */ | 247 | { 0x00, 0x0e, 0x11, 0x1e, 0x11, 0x1e, 0x10 }, /* e1 */ |
249 | { 0x7c, 0x2a, 0x2a, 0x2a, 0x14 }, /* e1 */ | 248 | { 0x00, 0x11, 0x0a, 0x0a, 0x04, 0x04, 0x08 }, /* e2 */ |
250 | { 0x02, 0x4c, 0x30, 0x0c, 0x02 }, /* e2 */ | 249 | { 0x00, 0x00, 0x1f, 0x0a, 0x0a, 0x0a, 0x13 }, /* e3 */ |
251 | { 0x44, 0x3c, 0x04, 0x7c, 0x44 }, /* e3 */ | 250 | { 0x1f, 0x10, 0x08, 0x04, 0x08, 0x10, 0x1f }, /* e4 */ |
252 | { 0x63, 0x55, 0x49, 0x41, 0x41 }, /* e4 */ | 251 | { 0x00, 0x00, 0x0f, 0x14, 0x12, 0x11, 0x0e }, /* e5 */ |
253 | { 0x38, 0x44, 0x4c, 0x54, 0x24 }, /* e5 */ | 252 | { 0x00, 0x09, 0x09, 0x09, 0x0f, 0x08, 0x10 }, /* e6 */ |
254 | { 0x40, 0x3e, 0x10, 0x10, 0x1e }, /* e6 */ | 253 | { 0x00, 0x00, 0x1f, 0x04, 0x04, 0x04, 0x03 }, /* e7 */ |
255 | { 0x04, 0x04, 0x3c, 0x44, 0x44 }, /* e7 */ | 254 | { 0x1f, 0x04, 0x0e, 0x15, 0x0e, 0x04, 0x1f }, /* e8 */ |
256 | { 0x49, 0x55, 0x7f, 0x55, 0x49 }, /* e8 */ | 255 | { 0x00, 0x0e, 0x11, 0x1f, 0x11, 0x11, 0x0e }, /* e9 */ |
257 | { 0x3c, 0x4a, 0x4a, 0x4a, 0x3c }, /* e9 */ | 256 | { 0x00, 0x00, 0x0e, 0x11, 0x11, 0x0a, 0x1b }, /* ea */ |
258 | { 0x58, 0x64, 0x04, 0x64, 0x58 }, /* ea */ | 257 | { 0x0f, 0x10, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* eb */ |
259 | { 0x3a, 0x45, 0x45, 0x45, 0x39 }, /* eb */ | 258 | { 0x00, 0x00, 0x00, 0x00, 0x0b, 0x15, 0x1a }, /* ec */ |
260 | { 0x60, 0x50, 0x20, 0x50, 0x30 }, /* ec */ | 259 | { 0x02, 0x04, 0x0e, 0x15, 0x0e, 0x04, 0x08 }, /* ed */ |
261 | { 0x08, 0x54, 0x3e, 0x15, 0x08 }, /* ed */ | 260 | { 0x00, 0x0e, 0x10, 0x0e, 0x10, 0x0e, 0x00 }, /* ee */ |
262 | { 0x14, 0x2a, 0x2a, 0x2a, 0x00 }, /* ee */ | 261 | { 0x06, 0x09, 0x11, 0x1e, 0x10, 0x10, 0x10 }, /* ef */ |
263 | { 0x7c, 0x0a, 0x09, 0x09, 0x06 }, /* ef */ | 262 | { 0x00, 0x00, 0x08, 0x15, 0x02, 0x00, 0x00 }, /* f0 */ |
264 | { 0x08, 0x04, 0x08, 0x10, 0x08 }, /* f0 */ | 263 | { 0x00, 0x08, 0x15, 0x0a, 0x15, 0x02, 0x00 }, /* f1 */ |
265 | { 0x14, 0x0a, 0x14, 0x28, 0x14 }, /* f1 */ | 264 | { 0x08, 0x0f, 0x12, 0x0f, 0x0a, 0x1f, 0x02 }, /* f2 */ |
266 | { 0x24, 0x3b, 0x2a, 0x7e, 0x2a }, /* f2 */ | 265 | { 0x0f, 0x09, 0x0f, 0x09, 0x0f, 0x09, 0x11 }, /* f3 */ |
267 | { 0x40, 0x3f, 0x15, 0x15, 0x7f }, /* f3 */ | 266 | { 0x04, 0x15, 0x15, 0x04, 0x04, 0x0a, 0x11 }, /* f4 */ |
268 | { 0x46, 0x20, 0x1f, 0x20, 0x46 }, /* f4 */ | 267 | { 0x04, 0x04, 0x1d, 0x06, 0x0e, 0x15, 0x04 }, /* f5 */ |
269 | { 0x24, 0x14, 0x7f, 0x18, 0x24 }, /* f5 */ | 268 | { 0x04, 0x04, 0x1f, 0x04, 0x0e, 0x15, 0x04 }, /* f6 */ |
270 | { 0x24, 0x14, 0x7f, 0x14, 0x24 }, /* f6 */ | 269 | { 0x04, 0x0a, 0x11, 0x0e, 0x04, 0x0e, 0x1f }, /* f7 */ |
271 | { 0x44, 0x6a, 0x79, 0x6a, 0x44 }, /* f7 */ | 270 | { 0x04, 0x04, 0x0e, 0x04, 0x04, 0x04, 0x1f }, /* f8 */ |
272 | { 0x40, 0x44, 0x7f, 0x44, 0x40 }, /* f8 */ | 271 | { 0x1f, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x1f }, /* f9 */ |
273 | { 0x7f, 0x49, 0x49, 0x49, 0x7f }, /* f9 */ | 272 | { 0x00, 0x01, 0x1e, 0x04, 0x1f, 0x04, 0x04 }, /* fa */ |
274 | { 0x14, 0x14, 0x7c, 0x14, 0x12 }, /* fa */ | 273 | { 0x00, 0x00, 0x1f, 0x08, 0x0f, 0x09, 0x11 }, /* fb */ |
275 | { 0x44, 0x3c, 0x14, 0x14, 0x74 }, /* fb */ | 274 | { 0x00, 0x00, 0x1f, 0x15, 0x1f, 0x11, 0x11 }, /* fc */ |
276 | { 0x7c, 0x14, 0x1c, 0x14, 0x7c }, /* fc */ | 275 | { 0x0a, 0x15, 0x0a, 0x15, 0x0a, 0x15, 0x0a }, /* fd */ |
277 | { 0x2a, 0x55, 0x2a, 0x55, 0x2a }, /* fd */ | 276 | { 0x15, 0x0a, 0x15, 0x0a, 0x15, 0x0a, 0x15 }, /* fe */ |
278 | { 0x55, 0x2a, 0x55, 0x2a, 0x55 }, /* fe */ | 277 | { 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* ff */ |
279 | { 0x7f, 0x7f, 0x7f, 0x7f, 0x7f } /* ff */ | ||
280 | }; | 278 | }; |
281 | 279 | static unsigned char font_player_oldlcd[256][7] = { | |
282 | unsigned char font_old_player[256][5] = { | 280 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 00 */ |
283 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 00 */ | 281 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 01 */ |
284 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 01 */ | 282 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 02 */ |
285 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 02 */ | 283 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 03 */ |
286 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 03 */ | 284 | { 0x0e, 0x11, 0x17, 0x15, 0x17, 0x10, 0x0e }, /* 04 */ |
287 | { 0x3e, 0x41, 0x5d, 0x55, 0x1e }, /* 04 */ | 285 | { 0x06, 0x09, 0x08, 0x1e, 0x08, 0x08, 0x1f }, /* 05 */ |
288 | { 0x48, 0x7e, 0x49, 0x49, 0x42 }, /* 05 */ | 286 | { 0x04, 0x0f, 0x14, 0x0e, 0x05, 0x1e, 0x04 }, /* 06 */ |
289 | { 0x24, 0x2a, 0x7f, 0x2a, 0x12 }, /* 06 */ | 287 | { 0x11, 0x0a, 0x1f, 0x04, 0x1f, 0x04, 0x04 }, /* 07 */ |
290 | { 0x15, 0x16, 0x7c, 0x16, 0x15 }, /* 07 */ | 288 | { 0x08, 0x04, 0x0e, 0x11, 0x1f, 0x10, 0x0e }, /* 08 */ |
291 | { 0x38, 0x55, 0x56, 0x54, 0x18 }, /* 08 */ | 289 | { 0x02, 0x04, 0x0e, 0x11, 0x1f, 0x10, 0x0e }, /* 09 */ |
292 | { 0x38, 0x54, 0x56, 0x55, 0x18 }, /* 09 */ | 290 | { 0x08, 0x04, 0x00, 0x11, 0x11, 0x13, 0x0d }, /* 0a */ |
293 | { 0x38, 0x41, 0x42, 0x20, 0x78 }, /* 0a */ | 291 | { 0x08, 0x04, 0x00, 0x0c, 0x04, 0x04, 0x0e }, /* 0b */ |
294 | { 0x00, 0x49, 0x7a, 0x40, 0x00 }, /* 0b */ | 292 | { 0x08, 0x04, 0x00, 0x0e, 0x11, 0x11, 0x0e }, /* 0c */ |
295 | { 0x30, 0x49, 0x4a, 0x48, 0x30 }, /* 0c */ | 293 | { 0x0f, 0x10, 0x10, 0x10, 0x0f, 0x02, 0x0e }, /* 0d */ |
296 | { 0x0e, 0x51, 0x51, 0x71, 0x11 }, /* 0d */ | 294 | { 0x10, 0x10, 0x17, 0x14, 0x1e, 0x04, 0x04 }, /* 0e */ |
297 | { 0x1f, 0x10, 0x7c, 0x14, 0x04 }, /* 0e */ | 295 | { 0x01, 0x0e, 0x13, 0x15, 0x19, 0x0e, 0x10 }, /* 0f */ |
298 | { 0x5c, 0x32, 0x2a, 0x26, 0x1d }, /* 0f */ | 296 | { 0x00, 0x02, 0x0e, 0x15, 0x15, 0x0e, 0x08 }, /* 10 */ |
299 | { 0x18, 0x64, 0x3c, 0x26, 0x18 }, /* 10 */ | 297 | { 0x1c, 0x10, 0x17, 0x1d, 0x07, 0x06, 0x05 }, /* 11 */ |
300 | { 0x0f, 0x09, 0x7d, 0x34, 0x5c }, /* 11 */ | 298 | { 0x04, 0x0a, 0x04, 0x0e, 0x11, 0x1f, 0x11 }, /* 12 */ |
301 | { 0x70, 0x2a, 0x2d, 0x2a, 0x70 }, /* 12 */ | 299 | { 0x04, 0x0a, 0x04, 0x01, 0x0f, 0x11, 0x0f }, /* 13 */ |
302 | { 0x20, 0x52, 0x55, 0x52, 0x78 }, /* 13 */ | 300 | { 0x00, 0x04, 0x04, 0x0a, 0x0a, 0x11, 0x1f }, /* 14 */ |
303 | { 0x60, 0x58, 0x46, 0x58, 0x60 }, /* 14 */ | 301 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f }, /* 15 */ |
304 | { 0x40, 0x40, 0x40, 0x40, 0x40 }, /* 15 */ | 302 | { 0x0e, 0x04, 0x1f, 0x15, 0x1f, 0x04, 0x0e }, /* 16 */ |
305 | { 0x1c, 0x55, 0x7f, 0x55, 0x1c }, /* 16 */ | 303 | { 0x1f, 0x11, 0x11, 0x10, 0x10, 0x10, 0x10 }, /* 17 */ |
306 | { 0x7f, 0x01, 0x01, 0x01, 0x07 }, /* 17 */ | 304 | { 0x04, 0x04, 0x0a, 0x0a, 0x11, 0x11, 0x11 }, /* 18 */ |
307 | { 0x70, 0x0c, 0x03, 0x0c, 0x70 }, /* 18 */ | 305 | { 0x0e, 0x11, 0x11, 0x11, 0x0a, 0x0a, 0x1b }, /* 19 */ |
308 | { 0x4e, 0x71, 0x01, 0x71, 0x4e }, /* 19 */ | 306 | { 0x1f, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a }, /* 1a */ |
309 | { 0x01, 0x7f, 0x01, 0x7f, 0x01 }, /* 1a */ | 307 | { 0x15, 0x15, 0x15, 0x15, 0x0e, 0x04, 0x04 }, /* 1b */ |
310 | { 0x0f, 0x10, 0x7f, 0x10, 0x0f }, /* 1b */ | 308 | { 0x1f, 0x08, 0x04, 0x02, 0x04, 0x08, 0x1f }, /* 1c */ |
311 | { 0x41, 0x63, 0x55, 0x49, 0x41 }, /* 1c */ | 309 | { 0x0e, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x0e }, /* 1d */ |
312 | { 0x3e, 0x49, 0x49, 0x49, 0x3e }, /* 1d */ | 310 | { 0x1f, 0x11, 0x00, 0x0e, 0x00, 0x11, 0x1f }, /* 1e */ |
313 | { 0x63, 0x49, 0x49, 0x49, 0x63 }, /* 1e */ | 311 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 1f */ |
314 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 1f */ | 312 | { 0x0f, 0x14, 0x14, 0x1f, 0x14, 0x14, 0x17 }, /* 20 */ |
315 | { 0x7e, 0x09, 0x7f, 0x49, 0x49 }, /* 20 */ | 313 | { 0x00, 0x00, 0x1a, 0x05, 0x0f, 0x14, 0x0f }, /* 21 */ |
316 | { 0x24, 0x54, 0x78, 0x54, 0x58 }, /* 21 */ | 314 | { 0x0c, 0x12, 0x16, 0x11, 0x11, 0x16, 0x10 }, /* 22 */ |
317 | { 0x7e, 0x01, 0x25, 0x26, 0x18 }, /* 22 */ | 315 | { 0x02, 0x04, 0x1f, 0x10, 0x1c, 0x10, 0x1f }, /* 23 */ |
318 | { 0x7c, 0x54, 0x56, 0x45, 0x44 }, /* 23 */ | 316 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 24 */ |
319 | { 0x00, 0x00, 0x00, 0x00, 0x00 }, /* 24 */ | 317 | { 0x04, 0x04, 0x04, 0x04, 0x04, 0x00, 0x04 }, /* 25 */ |
320 | { 0x00, 0x00, 0x5f, 0x00, 0x00 }, /* 25 */ | 318 | { 0x1b, 0x09, 0x12, 0x00, 0x00, 0x00, 0x00 }, /* 26 */ |
321 | { 0x05, 0x03, 0x00, 0x05, 0x03 }, /* 26 */ | 319 | { 0x0a, 0x0a, 0x1f, 0x0a, 0x1f, 0x0a, 0x0a }, /* 27 */ |
322 | { 0x14, 0x7f, 0x14, 0x7f, 0x14 }, /* 27 */ | 320 | { 0x00, 0x11, 0x0e, 0x0a, 0x0e, 0x11, 0x00 }, /* 28 */ |
323 | { 0x22, 0x1c, 0x14, 0x1c, 0x22 }, /* 28 */ | 321 | { 0x18, 0x19, 0x02, 0x04, 0x08, 0x13, 0x03 }, /* 29 */ |
324 | { 0x23, 0x13, 0x08, 0x64, 0x62 }, /* 29 */ | 322 | { 0x08, 0x14, 0x14, 0x09, 0x15, 0x12, 0x0d }, /* 2a */ |
325 | { 0x36, 0x49, 0x56, 0x20, 0x58 }, /* 2a */ | 323 | { 0x0c, 0x04, 0x08, 0x00, 0x00, 0x00, 0x00 }, /* 2b */ |
326 | { 0x00, 0x05, 0x03, 0x00, 0x00 }, /* 2b */ | 324 | { 0x02, 0x04, 0x08, 0x08, 0x08, 0x04, 0x02 }, /* 2c */ |
327 | { 0x00, 0x1c, 0x22, 0x41, 0x00 }, /* 2c */ | 325 | { 0x08, 0x04, 0x02, 0x02, 0x02, 0x04, 0x08 }, /* 2d */ |
328 | { 0x00, 0x41, 0x22, 0x1c, 0x00 }, /* 2d */ | 326 | { 0x04, 0x15, 0x0e, 0x04, 0x0e, 0x15, 0x04 }, /* 2e */ |
329 | { 0x22, 0x14, 0x7f, 0x14, 0x22 }, /* 2e */ | 327 | { 0x00, 0x04, 0x04, 0x1f, 0x04, 0x04, 0x00 }, /* 2f */ |
330 | { 0x08, 0x08, 0x3e, 0x08, 0x08 }, /* 2f */ | 328 | { 0x00, 0x00, 0x00, 0x00, 0x0c, 0x04, 0x08 }, /* 30 */ |
331 | { 0x00, 0x50, 0x30, 0x00, 0x00 }, /* 30 */ | 329 | { 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00 }, /* 31 */ |
332 | { 0x08, 0x08, 0x08, 0x08, 0x08 }, /* 31 */ | 330 | { 0x00, 0x00, 0x00, 0x00, 0x0c, 0x0c, 0x00 }, /* 32 */ |
333 | { 0x00, 0x30, 0x30, 0x00, 0x00 }, /* 32 */ | 331 | { 0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x00 }, /* 33 */ |
334 | { 0x20, 0x10, 0x08, 0x04, 0x02 }, /* 33 */ | 332 | { 0x0e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 34 */ |
335 | { 0x3e, 0x41, 0x41, 0x41, 0x3e }, /* 34 */ | 333 | { 0x04, 0x0c, 0x04, 0x04, 0x04, 0x04, 0x0e }, /* 35 */ |
336 | { 0x00, 0x42, 0x7f, 0x40, 0x00 }, /* 35 */ | 334 | { 0x0e, 0x11, 0x01, 0x02, 0x04, 0x08, 0x1f }, /* 36 */ |
337 | { 0x42, 0x61, 0x51, 0x49, 0x46 }, /* 36 */ | 335 | { 0x1f, 0x02, 0x04, 0x02, 0x01, 0x11, 0x0e }, /* 37 */ |
338 | { 0x21, 0x41, 0x45, 0x4b, 0x31 }, /* 37 */ | 336 | { 0x02, 0x06, 0x0a, 0x12, 0x1f, 0x02, 0x02 }, /* 38 */ |
339 | { 0x18, 0x14, 0x12, 0x7f, 0x10 }, /* 38 */ | 337 | { 0x1f, 0x10, 0x1e, 0x01, 0x01, 0x11, 0x0e }, /* 39 */ |
340 | { 0x27, 0x45, 0x45, 0x45, 0x39 }, /* 39 */ | 338 | { 0x06, 0x08, 0x10, 0x1e, 0x11, 0x11, 0x0e }, /* 3a */ |
341 | { 0x3c, 0x4a, 0x49, 0x49, 0x30 }, /* 3a */ | 339 | { 0x1f, 0x01, 0x02, 0x02, 0x04, 0x04, 0x04 }, /* 3b */ |
342 | { 0x01, 0x01, 0x71, 0x0d, 0x03 }, /* 3b */ | 340 | { 0x0e, 0x11, 0x11, 0x0e, 0x11, 0x11, 0x0e }, /* 3c */ |
343 | { 0x36, 0x49, 0x49, 0x49, 0x36 }, /* 3c */ | 341 | { 0x0e, 0x11, 0x11, 0x0f, 0x01, 0x02, 0x0c }, /* 3d */ |
344 | { 0x06, 0x49, 0x49, 0x29, 0x1e }, /* 3d */ | 342 | { 0x00, 0x0c, 0x0c, 0x00, 0x0c, 0x0c, 0x00 }, /* 3e */ |
345 | { 0x00, 0x36, 0x36, 0x00, 0x00 }, /* 3e */ | 343 | { 0x00, 0x0c, 0x0c, 0x00, 0x0c, 0x04, 0x08 }, /* 3f */ |
346 | { 0x00, 0x56, 0x36, 0x00, 0x00 }, /* 3f */ | 344 | { 0x03, 0x06, 0x0c, 0x18, 0x0c, 0x06, 0x03 }, /* 40 */ |
347 | { 0x08, 0x1c, 0x36, 0x63, 0x41 }, /* 40 */ | 345 | { 0x00, 0x00, 0x1f, 0x00, 0x1f, 0x00, 0x00 }, /* 41 */ |
348 | { 0x14, 0x14, 0x14, 0x14, 0x14 }, /* 41 */ | 346 | { 0x18, 0x0c, 0x06, 0x03, 0x06, 0x0c, 0x18 }, /* 42 */ |
349 | { 0x41, 0x63, 0x36, 0x1c, 0x08 }, /* 42 */ | 347 | { 0x0e, 0x11, 0x01, 0x02, 0x04, 0x00, 0x04 }, /* 43 */ |
350 | { 0x02, 0x01, 0x51, 0x09, 0x06 }, /* 43 */ | 348 | { 0x04, 0x00, 0x04, 0x04, 0x04, 0x04, 0x04 }, /* 44 */ |
351 | { 0x00, 0x00, 0x7d, 0x00, 0x00 }, /* 44 */ | 349 | { 0x04, 0x0a, 0x11, 0x11, 0x1f, 0x11, 0x11 }, /* 45 */ |
352 | { 0x7c, 0x12, 0x11, 0x12, 0x7c }, /* 45 */ | 350 | { 0x1e, 0x11, 0x11, 0x1e, 0x11, 0x11, 0x1e }, /* 46 */ |
353 | { 0x7f, 0x49, 0x49, 0x49, 0x36 }, /* 46 */ | 351 | { 0x0e, 0x11, 0x10, 0x10, 0x10, 0x11, 0x0e }, /* 47 */ |
354 | { 0x3e, 0x41, 0x41, 0x41, 0x22 }, /* 47 */ | 352 | { 0x1c, 0x12, 0x11, 0x11, 0x11, 0x12, 0x1c }, /* 48 */ |
355 | { 0x7f, 0x41, 0x41, 0x22, 0x1c }, /* 48 */ | 353 | { 0x1f, 0x10, 0x10, 0x1e, 0x10, 0x10, 0x1f }, /* 49 */ |
356 | { 0x7f, 0x49, 0x49, 0x49, 0x41 }, /* 49 */ | 354 | { 0x1f, 0x10, 0x10, 0x1e, 0x10, 0x10, 0x10 }, /* 4a */ |
357 | { 0x7f, 0x09, 0x09, 0x09, 0x01 }, /* 4a */ | 355 | { 0x0e, 0x10, 0x10, 0x17, 0x11, 0x11, 0x0e }, /* 4b */ |
358 | { 0x3e, 0x41, 0x49, 0x49, 0x38 }, /* 4b */ | 356 | { 0x11, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11 }, /* 4c */ |
359 | { 0x7f, 0x08, 0x08, 0x08, 0x7f }, /* 4c */ | 357 | { 0x0e, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e }, /* 4d */ |
360 | { 0x00, 0x41, 0x7f, 0x41, 0x00 }, /* 4d */ | 358 | { 0x0f, 0x02, 0x02, 0x02, 0x02, 0x12, 0x0c }, /* 4e */ |
361 | { 0x20, 0x41, 0x41, 0x3f, 0x01 }, /* 4e */ | 359 | { 0x11, 0x12, 0x14, 0x18, 0x14, 0x12, 0x11 }, /* 4f */ |
362 | { 0x7f, 0x08, 0x14, 0x22, 0x41 }, /* 4f */ | 360 | { 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1f }, /* 50 */ |
363 | { 0x7f, 0x40, 0x40, 0x40, 0x40 }, /* 50 */ | 361 | { 0x11, 0x1b, 0x15, 0x11, 0x11, 0x11, 0x11 }, /* 51 */ |
364 | { 0x7f, 0x02, 0x04, 0x02, 0x7f }, /* 51 */ | 362 | { 0x11, 0x11, 0x19, 0x15, 0x13, 0x11, 0x11 }, /* 52 */ |
365 | { 0x7f, 0x04, 0x08, 0x10, 0x7f }, /* 52 */ | 363 | { 0x0e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 53 */ |
366 | { 0x3e, 0x41, 0x41, 0x41, 0x3e }, /* 53 */ | 364 | { 0x1e, 0x11, 0x11, 0x1e, 0x10, 0x10, 0x10 }, /* 54 */ |
367 | { 0x7f, 0x09, 0x09, 0x09, 0x06 }, /* 54 */ | 365 | { 0x0e, 0x11, 0x11, 0x11, 0x11, 0x12, 0x0d }, /* 55 */ |
368 | { 0x3e, 0x41, 0x41, 0x21, 0x5e }, /* 55 */ | 366 | { 0x1e, 0x11, 0x11, 0x1e, 0x14, 0x12, 0x11 }, /* 56 */ |
369 | { 0x7f, 0x09, 0x19, 0x29, 0x46 }, /* 56 */ | 367 | { 0x0e, 0x11, 0x10, 0x0e, 0x01, 0x11, 0x0e }, /* 57 */ |
370 | { 0x26, 0x49, 0x49, 0x49, 0x32 }, /* 57 */ | 368 | { 0x1f, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04 }, /* 58 */ |
371 | { 0x01, 0x01, 0x7f, 0x01, 0x01 }, /* 58 */ | 369 | { 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 59 */ |
372 | { 0x3f, 0x40, 0x40, 0x40, 0x3f }, /* 59 */ | 370 | { 0x11, 0x11, 0x11, 0x11, 0x11, 0x0a, 0x04 }, /* 5a */ |
373 | { 0x1f, 0x20, 0x40, 0x20, 0x1f }, /* 5a */ | 371 | { 0x11, 0x11, 0x11, 0x11, 0x11, 0x15, 0x0a }, /* 5b */ |
374 | { 0x3f, 0x40, 0x20, 0x40, 0x3f }, /* 5b */ | 372 | { 0x11, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x11 }, /* 5c */ |
375 | { 0x63, 0x14, 0x08, 0x14, 0x63 }, /* 5c */ | 373 | { 0x11, 0x11, 0x0a, 0x04, 0x04, 0x04, 0x04 }, /* 5d */ |
376 | { 0x03, 0x04, 0x78, 0x04, 0x03 }, /* 5d */ | 374 | { 0x1f, 0x01, 0x02, 0x04, 0x08, 0x10, 0x1f }, /* 5e */ |
377 | { 0x61, 0x51, 0x49, 0x45, 0x43 }, /* 5e */ | 375 | { 0x0a, 0x00, 0x04, 0x0a, 0x11, 0x1f, 0x11 }, /* 5f */ |
378 | { 0x70, 0x29, 0x24, 0x29, 0x70 }, /* 5f */ | 376 | { 0x0a, 0x00, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 60 */ |
379 | { 0x38, 0x45, 0x44, 0x45, 0x38 }, /* 60 */ | 377 | { 0x0d, 0x12, 0x00, 0x19, 0x15, 0x13, 0x11 }, /* 61 */ |
380 | { 0x7a, 0x09, 0x11, 0x22, 0x79 }, /* 61 */ | 378 | { 0x0a, 0x00, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 62 */ |
381 | { 0x3c, 0x41, 0x40, 0x41, 0x3c }, /* 62 */ | 379 | { 0x0e, 0x10, 0x0e, 0x11, 0x0e, 0x01, 0x0e }, /* 63 */ |
382 | { 0x0a, 0x55, 0x55, 0x55, 0x28 }, /* 63 */ | 380 | { 0x04, 0x00, 0x04, 0x08, 0x10, 0x11, 0x0e }, /* 64 */ |
383 | { 0x30, 0x48, 0x45, 0x40, 0x20 }, /* 64 */ | 381 | { 0x00, 0x00, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 65 */ |
384 | { 0x20, 0x54, 0x54, 0x54, 0x78 }, /* 65 */ | 382 | { 0x10, 0x10, 0x1e, 0x11, 0x11, 0x11, 0x1e }, /* 66 */ |
385 | { 0x7f, 0x44, 0x44, 0x44, 0x38 }, /* 66 */ | 383 | { 0x00, 0x00, 0x0f, 0x10, 0x10, 0x10, 0x0f }, /* 67 */ |
386 | { 0x38, 0x44, 0x44, 0x44, 0x44 }, /* 67 */ | 384 | { 0x01, 0x01, 0x0f, 0x11, 0x11, 0x11, 0x0f }, /* 68 */ |
387 | { 0x38, 0x44, 0x44, 0x44, 0x7f }, /* 68 */ | 385 | { 0x00, 0x00, 0x0e, 0x11, 0x1f, 0x10, 0x0f }, /* 69 */ |
388 | { 0x38, 0x54, 0x54, 0x54, 0x58 }, /* 69 */ | 386 | { 0x03, 0x04, 0x0f, 0x04, 0x04, 0x04, 0x04 }, /* 6a */ |
389 | { 0x00, 0x04, 0x7e, 0x05, 0x05 }, /* 6a */ | 387 | { 0x00, 0x00, 0x0f, 0x11, 0x0f, 0x01, 0x0e }, /* 6b */ |
390 | { 0x08, 0x54, 0x54, 0x54, 0x3c }, /* 6b */ | 388 | { 0x10, 0x10, 0x16, 0x19, 0x11, 0x11, 0x11 }, /* 6c */ |
391 | { 0x7f, 0x08, 0x04, 0x04, 0x78 }, /* 6c */ | 389 | { 0x04, 0x00, 0x0c, 0x04, 0x04, 0x04, 0x0e }, /* 6d */ |
392 | { 0x00, 0x44, 0x7d, 0x40, 0x00 }, /* 6d */ | 390 | { 0x02, 0x00, 0x06, 0x02, 0x02, 0x12, 0x0c }, /* 6e */ |
393 | { 0x20, 0x40, 0x44, 0x3d, 0x00 }, /* 6e */ | 391 | { 0x08, 0x08, 0x09, 0x0a, 0x0c, 0x0a, 0x09 }, /* 6f */ |
394 | { 0x00, 0x7f, 0x10, 0x28, 0x44 }, /* 6f */ | 392 | { 0x0c, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e }, /* 70 */ |
395 | { 0x00, 0x41, 0x7f, 0x40, 0x00 }, /* 70 */ | 393 | { 0x00, 0x00, 0x1a, 0x15, 0x15, 0x15, 0x15 }, /* 71 */ |
396 | { 0x7c, 0x04, 0x78, 0x04, 0x78 }, /* 71 */ | 394 | { 0x00, 0x00, 0x16, 0x19, 0x11, 0x11, 0x11 }, /* 72 */ |
397 | { 0x7c, 0x08, 0x04, 0x04, 0x78 }, /* 72 */ | 395 | { 0x00, 0x00, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 73 */ |
398 | { 0x38, 0x44, 0x44, 0x44, 0x38 }, /* 73 */ | 396 | { 0x00, 0x00, 0x1e, 0x11, 0x1e, 0x10, 0x10 }, /* 74 */ |
399 | { 0x7c, 0x14, 0x14, 0x14, 0x08 }, /* 74 */ | 397 | { 0x00, 0x00, 0x0f, 0x11, 0x0f, 0x01, 0x01 }, /* 75 */ |
400 | { 0x08, 0x14, 0x14, 0x14, 0x7c }, /* 75 */ | 398 | { 0x00, 0x00, 0x0b, 0x0c, 0x08, 0x08, 0x08 }, /* 76 */ |
401 | { 0x00, 0x7c, 0x08, 0x04, 0x04 }, /* 76 */ | 399 | { 0x00, 0x00, 0x0e, 0x10, 0x0e, 0x01, 0x1e }, /* 77 */ |
402 | { 0x48, 0x54, 0x54, 0x54, 0x20 }, /* 77 */ | 400 | { 0x04, 0x04, 0x0f, 0x04, 0x04, 0x04, 0x03 }, /* 78 */ |
403 | { 0x00, 0x04, 0x3f, 0x44, 0x44 }, /* 78 */ | 401 | { 0x00, 0x00, 0x11, 0x11, 0x11, 0x13, 0x0d }, /* 79 */ |
404 | { 0x3c, 0x40, 0x40, 0x20, 0x7c }, /* 79 */ | 402 | { 0x00, 0x00, 0x11, 0x11, 0x11, 0x0a, 0x04 }, /* 7a */ |
405 | { 0x1c, 0x20, 0x40, 0x20, 0x1c }, /* 7a */ | 403 | { 0x00, 0x00, 0x11, 0x11, 0x11, 0x15, 0x0a }, /* 7b */ |
406 | { 0x3c, 0x40, 0x20, 0x40, 0x3c }, /* 7b */ | 404 | { 0x00, 0x00, 0x11, 0x0a, 0x04, 0x0a, 0x11 }, /* 7c */ |
407 | { 0x44, 0x28, 0x10, 0x28, 0x44 }, /* 7c */ | 405 | { 0x00, 0x00, 0x11, 0x11, 0x0f, 0x01, 0x1e }, /* 7d */ |
408 | { 0x4c, 0x50, 0x50, 0x50, 0x3c }, /* 7d */ | 406 | { 0x00, 0x00, 0x1f, 0x02, 0x04, 0x08, 0x1f }, /* 7e */ |
409 | { 0x44, 0x64, 0x54, 0x4c, 0x44 }, /* 7e */ | 407 | { 0x0a, 0x00, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 7f */ |
410 | { 0x20, 0x55, 0x54, 0x55, 0x78 }, /* 7f */ | 408 | { 0x00, 0x0a, 0x00, 0x0e, 0x11, 0x11, 0x0e }, /* 80 */ |
411 | { 0x30, 0x4a, 0x48, 0x4a, 0x30 }, /* 80 */ | 409 | { 0x0d, 0x12, 0x00, 0x16, 0x19, 0x11, 0x11 }, /* 81 */ |
412 | { 0x7a, 0x11, 0x09, 0x0a, 0x71 }, /* 81 */ | 410 | { 0x00, 0x0a, 0x00, 0x11, 0x11, 0x13, 0x0d }, /* 82 */ |
413 | { 0x38, 0x42, 0x40, 0x22, 0x78 }, /* 82 */ | 411 | { 0x08, 0x04, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 83 */ |
414 | { 0x20, 0x55, 0x56, 0x54, 0x78 }, /* 83 */ | 412 | { 0x00, 0x0f, 0x10, 0x10, 0x0f, 0x02, 0x04 }, /* 84 */ |
415 | { 0x0c, 0x12, 0x52, 0x32, 0x12 }, /* 84 */ | 413 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x00 }, /* 85 */ |
416 | { 0x20, 0x00, 0x20, 0x00, 0x20 }, /* 85 */ | 414 | { 0x00, 0x00, 0x04, 0x0e, 0x1f, 0x00, 0x00 }, /* 86 */ |
417 | { 0x10, 0x18, 0x1c, 0x18, 0x10 }, /* 86 */ | 415 | { 0x00, 0x00, 0x1f, 0x0e, 0x04, 0x00, 0x00 }, /* 87 */ |
418 | { 0x04, 0x0c, 0x1c, 0x0c, 0x04 }, /* 87 */ | 416 | { 0x02, 0x06, 0x0e, 0x1e, 0x0e, 0x06, 0x02 }, /* 88 */ |
419 | { 0x08, 0x1c, 0x3e, 0x7f, 0x00 }, /* 88 */ | 417 | { 0x08, 0x0c, 0x0e, 0x0f, 0x0e, 0x0c, 0x08 }, /* 89 */ |
420 | { 0x00, 0x7f, 0x3e, 0x1c, 0x08 }, /* 89 */ | 418 | { 0x1c, 0x1f, 0x13, 0x10, 0x10, 0x10, 0x10 }, /* 8a */ |
421 | { 0x7f, 0x03, 0x03, 0x06, 0x06 }, /* 8a */ | 419 | { 0x15, 0x0a, 0x15, 0x0a, 0x15, 0x0a, 0x15 }, /* 8b */ |
422 | { 0x55, 0x2a, 0x55, 0x2a, 0x55 }, /* 8b */ | 420 | { 0x08, 0x04, 0x0e, 0x11, 0x1f, 0x11, 0x11 }, /* 8c */ |
423 | { 0x78, 0x15, 0x16, 0x14, 0x78 }, /* 8c */ | 421 | { 0x02, 0x04, 0x0e, 0x11, 0x1f, 0x11, 0x11 }, /* 8d */ |
424 | { 0x78, 0x14, 0x16, 0x15, 0x78 }, /* 8d */ | 422 | { 0x04, 0x0a, 0x0e, 0x11, 0x1f, 0x11, 0x11 }, /* 8e */ |
425 | { 0x78, 0x16, 0x15, 0x16, 0x78 }, /* 8e */ | 423 | { 0x0d, 0x12, 0x0e, 0x11, 0x1f, 0x11, 0x11 }, /* 8f */ |
426 | { 0x7a, 0x15, 0x15, 0x16, 0x79 }, /* 8f */ | 424 | { 0x08, 0x04, 0x1f, 0x10, 0x1e, 0x10, 0x1f }, /* 90 */ |
427 | { 0x7c, 0x55, 0x56, 0x54, 0x44 }, /* 90 */ | 425 | { 0x04, 0x0a, 0x1f, 0x10, 0x1c, 0x10, 0x1f }, /* 91 */ |
428 | { 0x7c, 0x56, 0x55, 0x46, 0x44 }, /* 91 */ | 426 | { 0x0a, 0x00, 0x1f, 0x10, 0x1c, 0x10, 0x1f }, /* 92 */ |
429 | { 0x7c, 0x55, 0x54, 0x45, 0x44 }, /* 92 */ | 427 | { 0x08, 0x04, 0x0e, 0x04, 0x04, 0x04, 0x0e }, /* 93 */ |
430 | { 0x00, 0x45, 0x7e, 0x44, 0x00 }, /* 93 */ | 428 | { 0x02, 0x04, 0x0e, 0x04, 0x04, 0x04, 0x0e }, /* 94 */ |
431 | { 0x00, 0x44, 0x7e, 0x45, 0x00 }, /* 94 */ | 429 | { 0x0c, 0x0a, 0x09, 0x1d, 0x09, 0x0a, 0x0c }, /* 95 */ |
432 | { 0x08, 0x7f, 0x49, 0x22, 0x1c }, /* 95 */ | 430 | { 0x08, 0x04, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 96 */ |
433 | { 0x38, 0x45, 0x46, 0x44, 0x38 }, /* 96 */ | 431 | { 0x02, 0x04, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 97 */ |
434 | { 0x38, 0x44, 0x46, 0x45, 0x38 }, /* 97 */ | 432 | { 0x04, 0x0a, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 98 */ |
435 | { 0x38, 0x46, 0x45, 0x46, 0x38 }, /* 98 */ | 433 | { 0x0d, 0x12, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* 99 */ |
436 | { 0x3a, 0x45, 0x45, 0x46, 0x39 }, /* 99 */ | 434 | { 0x08, 0x04, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 9a */ |
437 | { 0x3c, 0x41, 0x42, 0x40, 0x3c }, /* 9a */ | 435 | { 0x02, 0x04, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* 9b */ |
438 | { 0x3c, 0x40, 0x42, 0x41, 0x3c }, /* 9b */ | 436 | { 0x02, 0x04, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 9c */ |
439 | { 0x20, 0x54, 0x56, 0x55, 0x78 }, /* 9c */ | 437 | { 0x04, 0x0a, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 9d */ |
440 | { 0x20, 0x56, 0x55, 0x56, 0x78 }, /* 9d */ | 438 | { 0x0d, 0x12, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* 9e */ |
441 | { 0x22, 0x55, 0x55, 0x56, 0x79 }, /* 9e */ | 439 | { 0x04, 0x0a, 0x0e, 0x11, 0x1f, 0x10, 0x0e }, /* 9f */ |
442 | { 0x38, 0x56, 0x55, 0x56, 0x18 }, /* 9f */ | 440 | { 0x0a, 0x00, 0x0e, 0x11, 0x1f, 0x10, 0x0e }, /* a0 */ |
443 | { 0x38, 0x55, 0x54, 0x55, 0x18 }, /* a0 */ | 441 | { 0x02, 0x04, 0x00, 0x0c, 0x04, 0x04, 0x0e }, /* a1 */ |
444 | { 0x00, 0x48, 0x7a, 0x41, 0x00 }, /* a1 */ | 442 | { 0x04, 0x0a, 0x00, 0x0c, 0x04, 0x04, 0x0e }, /* a2 */ |
445 | { 0x00, 0x4a, 0x79, 0x42, 0x00 }, /* a2 */ | 443 | { 0x0a, 0x00, 0x00, 0x0c, 0x04, 0x04, 0x0e }, /* a3 */ |
446 | { 0x00, 0x49, 0x78, 0x41, 0x00 }, /* a3 */ | 444 | { 0x02, 0x04, 0x00, 0x0e, 0x11, 0x11, 0x0e }, /* a4 */ |
447 | { 0x30, 0x48, 0x4a, 0x49, 0x30 }, /* a4 */ | 445 | { 0x04, 0x0a, 0x00, 0x0e, 0x11, 0x11, 0x0e }, /* a5 */ |
448 | { 0x30, 0x4a, 0x49, 0x4a, 0x30 }, /* a5 */ | 446 | { 0x0d, 0x12, 0x00, 0x0e, 0x11, 0x11, 0x0e }, /* a6 */ |
449 | { 0x32, 0x49, 0x49, 0x4a, 0x31 }, /* a6 */ | 447 | { 0x02, 0x04, 0x00, 0x11, 0x11, 0x13, 0x0d }, /* a7 */ |
450 | { 0x38, 0x40, 0x42, 0x21, 0x78 }, /* a7 */ | 448 | { 0x04, 0x04, 0x0f, 0x10, 0x10, 0x0f, 0x04 }, /* a8 */ |
451 | { 0x18, 0x24, 0x67, 0x24, 0x24 }, /* a8 */ | 449 | { 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x03 }, /* a9 */ |
452 | { 0x00, 0x00, 0x00, 0x7f, 0x41 }, /* a9 */ | 450 | { 0x0a, 0x04, 0x0b, 0x0c, 0x08, 0x08, 0x08 }, /* aa */ |
453 | { 0x00, 0x7d, 0x0a, 0x05, 0x04 }, /* aa */ | 451 | { 0x0a, 0x04, 0x0f, 0x10, 0x10, 0x10, 0x0f }, /* ab */ |
454 | { 0x38, 0x45, 0x46, 0x45, 0x44 }, /* ab */ | 452 | { 0x0a, 0x04, 0x0e, 0x10, 0x0e, 0x01, 0x1e }, /* ac */ |
455 | { 0x48, 0x55, 0x56, 0x55, 0x20 }, /* ac */ | 453 | { 0x0a, 0x04, 0x0e, 0x11, 0x1f, 0x10, 0x0e }, /* ad */ |
456 | { 0x38, 0x55, 0x56, 0x55, 0x18 }, /* ad */ | 454 | { 0x04, 0x0a, 0x04, 0x11, 0x11, 0x13, 0x0d }, /* ae */ |
457 | { 0x38, 0x42, 0x45, 0x22, 0x78 }, /* ae */ | 455 | { 0x02, 0x04, 0x11, 0x11, 0x0f, 0x01, 0x0e }, /* af */ |
458 | { 0x0c, 0x50, 0x52, 0x51, 0x3c }, /* af */ | 456 | { 0x02, 0x0f, 0x02, 0x0e, 0x12, 0x12, 0x0e }, /* b0 */ |
459 | { 0x30, 0x4a, 0x4a, 0x7f, 0x02 }, /* b0 */ | 457 | { 0x02, 0x04, 0x0f, 0x10, 0x10, 0x10, 0x0f }, /* b1 */ |
460 | { 0x38, 0x44, 0x46, 0x45, 0x44 }, /* b1 */ | 458 | { 0x0e, 0x11, 0x1f, 0x10, 0x0e, 0x04, 0x06 }, /* b2 */ |
461 | { 0x0e, 0x15, 0x75, 0x55, 0x06 }, /* b2 */ | 459 | { 0x0e, 0x01, 0x0f, 0x11, 0x0f, 0x02, 0x03 }, /* b3 */ |
462 | { 0x08, 0x15, 0x15, 0x75, 0x5e }, /* b3 */ | 460 | { 0x04, 0x00, 0x1f, 0x02, 0x04, 0x08, 0x1f }, /* b4 */ |
463 | { 0x44, 0x64, 0x55, 0x4c, 0x44 }, /* b4 */ | 461 | { 0x02, 0x04, 0x1f, 0x02, 0x04, 0x08, 0x1f }, /* b5 */ |
464 | { 0x44, 0x64, 0x56, 0x4d, 0x44 }, /* b5 */ | 462 | { 0x02, 0x04, 0x0e, 0x10, 0x0e, 0x01, 0x1e }, /* b6 */ |
465 | { 0x48, 0x54, 0x56, 0x55, 0x20 }, /* b6 */ | 463 | { 0x02, 0x04, 0x16, 0x19, 0x11, 0x11, 0x11 }, /* b7 */ |
466 | { 0x7c, 0x08, 0x06, 0x05, 0x78 }, /* b7 */ | 464 | { 0x0c, 0x04, 0x06, 0x0c, 0x04, 0x04, 0x0e }, /* b8 */ |
467 | { 0x00, 0x49, 0x7f, 0x44, 0x00 }, /* b8 */ | 465 | { 0x04, 0x0e, 0x1f, 0x1f, 0x1b, 0x04, 0x0e }, /* b9 */ |
468 | { 0x1c, 0x5e, 0x6f, 0x5e, 0x1c }, /* b9 */ | 466 | { 0x0a, 0x04, 0x16, 0x19, 0x11, 0x11, 0x11 }, /* ba */ |
469 | { 0x7c, 0x09, 0x06, 0x05, 0x78 }, /* ba */ | 467 | { 0x09, 0x09, 0x08, 0x1e, 0x08, 0x08, 0x06 }, /* bb */ |
470 | { 0x08, 0x3f, 0x48, 0x48, 0x03 }, /* bb */ | 468 | { 0x05, 0x05, 0x0c, 0x14, 0x14, 0x14, 0x0c }, /* bc */ |
471 | { 0x38, 0x44, 0x7f, 0x00, 0x03 }, /* bc */ | 469 | { 0x0a, 0x04, 0x1f, 0x02, 0x04, 0x08, 0x1f }, /* bd */ |
472 | { 0x44, 0x65, 0x56, 0x4d, 0x44 }, /* bd */ | 470 | { 0x0f, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* be */ |
473 | { 0x02, 0x01, 0x01, 0x01, 0x01 }, /* be */ | 471 | { 0x0f, 0x10, 0x01, 0x01, 0x01, 0x01, 0x01 }, /* bf */ |
474 | { 0x02, 0x01, 0x01, 0x01, 0x7d }, /* bf */ | 472 | { 0x1e, 0x01, 0x00, 0x00, 0x00, 0x00, 0x1f }, /* c0 */ |
475 | { 0x41, 0x41, 0x41, 0x41, 0x42 }, /* c0 */ | 473 | { 0x1f, 0x00, 0x0e, 0x10, 0x17, 0x11, 0x0e }, /* c1 */ |
476 | { 0x39, 0x45, 0x55, 0x55, 0x31 }, /* c1 */ | 474 | { 0x1f, 0x00, 0x0f, 0x11, 0x0f, 0x01, 0x0e }, /* c2 */ |
477 | { 0x09, 0x55, 0x55, 0x55, 0x3d }, /* c2 */ | 475 | { 0x0e, 0x10, 0x0e, 0x01, 0x0e, 0x04, 0x0c }, /* c3 */ |
478 | { 0x02, 0x55, 0x75, 0x15, 0x08 }, /* c3 */ | 476 | { 0x00, 0x0e, 0x10, 0x0e, 0x01, 0x0e, 0x04 }, /* c4 */ |
479 | { 0x04, 0x2a, 0x6a, 0x2a, 0x10 }, /* c4 */ | 477 | { 0x04, 0x00, 0x0e, 0x04, 0x04, 0x04, 0x0e }, /* c5 */ |
480 | { 0x00, 0x44, 0x7d, 0x44, 0x00 }, /* c5 */ | 478 | { 0x00, 0x00, 0x0c, 0x04, 0x04, 0x04, 0x0e }, /* c6 */ |
481 | { 0x00, 0x44, 0x7c, 0x40, 0x00 }, /* c6 */ | 479 | { 0x05, 0x0a, 0x11, 0x11, 0x11, 0x11, 0x0e }, /* c7 */ |
482 | { 0x3c, 0x42, 0x41, 0x42, 0x3d }, /* c7 */ | 480 | { 0x09, 0x12, 0x0e, 0x11, 0x11, 0x11, 0x0e }, /* c8 */ |
483 | { 0x3a, 0x45, 0x44, 0x46, 0x39 }, /* c8 */ | 481 | { 0x09, 0x12, 0x00, 0x11, 0x11, 0x13, 0x0d }, /* c9 */ |
484 | { 0x3a, 0x41, 0x40, 0x22, 0x79 }, /* c9 */ | 482 | { 0x09, 0x12, 0x00, 0x0e, 0x11, 0x11, 0x0e }, /* ca */ |
485 | { 0x32, 0x49, 0x48, 0x4a, 0x31 }, /* ca */ | 483 | { 0x01, 0x01, 0x01, 0x01, 0x01, 0x10, 0x0f }, /* cb */ |
486 | { 0x20, 0x40, 0x40, 0x40, 0x5f }, /* cb */ | 484 | { 0x10, 0x10, 0x10, 0x10, 0x10, 0x01, 0x1e }, /* cc */ |
487 | { 0x5f, 0x40, 0x40, 0x40, 0x20 }, /* cc */ | 485 | { 0x00, 0x1b, 0x1f, 0x1f, 0x0e, 0x04, 0x00 }, /* cd */ |
488 | { 0x0e, 0x1e, 0x3c, 0x1e, 0x0e }, /* cd */ | 486 | { 0x18, 0x08, 0x08, 0x08, 0x08, 0x08, 0x18 }, /* ce */ |
489 | { 0x41, 0x7f, 0x00, 0x00, 0x00 }, /* ce */ | 487 | { 0x0e, 0x11, 0x04, 0x0a, 0x1b, 0x1f, 0x00 }, /* cf */ |
490 | { 0x32, 0x39, 0x25, 0x39, 0x32 }, /* cf */ | 488 | { 0x0a, 0x15, 0x04, 0x07, 0x00, 0x11, 0x0a }, /* d0 */ |
491 | { 0x22, 0x41, 0x0e, 0x49, 0x2a }, /* d0 */ | 489 | { 0x0f, 0x10, 0x00, 0x00, 0x00, 0x00, 0x1f }, /* d1 */ |
492 | { 0x42, 0x41, 0x41, 0x41, 0x41 }, /* d1 */ | 490 | { 0x01, 0x03, 0x1d, 0x11, 0x1d, 0x03, 0x01 }, /* d2 */ |
493 | { 0x1c, 0x14, 0x14, 0x22, 0x7f }, /* d2 */ | 491 | { 0x0e, 0x11, 0x11, 0x1f, 0x1b, 0x1b, 0x1f }, /* d3 */ |
494 | { 0x7e, 0x79, 0x49, 0x79, 0x7e }, /* d3 */ | 492 | { 0x00, 0x01, 0x02, 0x0a, 0x04, 0x04, 0x00 }, /* d4 */ |
495 | { 0x00, 0x08, 0x30, 0x0c, 0x02 }, /* d4 */ | 493 | { 0x04, 0x0e, 0x1f, 0x00, 0x1f, 0x0e, 0x04 }, /* d5 */ |
496 | { 0x14, 0x36, 0x77, 0x36, 0x14 }, /* d5 */ | 494 | { 0x02, 0x02, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e }, /* d6 */ |
497 | { 0x00, 0x7c, 0x7c, 0x7f, 0x00 }, /* d6 */ | 495 | { 0x1b, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1b }, /* d7 */ |
498 | { 0x7f, 0x7f, 0x00, 0x41, 0x41 }, /* d7 */ | 496 | { 0x1b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1b }, /* d8 */ |
499 | { 0x41, 0x41, 0x00, 0x41, 0x41 }, /* d8 */ | 497 | { 0x04, 0x0f, 0x04, 0x04, 0x04, 0x03, 0x06 }, /* d9 */ |
500 | { 0x00, 0x02, 0x5f, 0x62, 0x22 }, /* d9 */ | 498 | { 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b }, /* da */ |
501 | { 0x7f, 0x7f, 0x00, 0x7f, 0x7f }, /* da */ | 499 | { 0x00, 0x04, 0x0e, 0x1f, 0x0e, 0x04, 0x00 }, /* db */ |
502 | { 0x08, 0x1c, 0x3e, 0x1c, 0x08 }, /* db */ | 500 | { 0x00, 0x00, 0x1f, 0x1b, 0x15, 0x11, 0x1f }, /* dc */ |
503 | { 0x7c, 0x4c, 0x54, 0x4c, 0x7c }, /* dc */ | 501 | { 0x0e, 0x0e, 0x04, 0x1f, 0x0e, 0x0e, 0x0a }, /* dd */ |
504 | { 0x08, 0x7b, 0x3f, 0x7b, 0x08 }, /* dd */ | 502 | { 0x00, 0x00, 0x00, 0x00, 0x0a, 0x04, 0x0a }, /* de */ |
505 | { 0x00, 0x50, 0x20, 0x50, 0x00 }, /* de */ | 503 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f }, /* df */ |
506 | { 0x60, 0x60, 0x60, 0x60, 0x60 }, /* df */ | 504 | { 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x1f }, /* e0 */ |
507 | { 0x70, 0x70, 0x70, 0x70, 0x70 }, /* e0 */ | 505 | { 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f }, /* e1 */ |
508 | { 0x78, 0x78, 0x78, 0x78, 0x78 }, /* e1 */ | 506 | { 0x00, 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* e2 */ |
509 | { 0x7c, 0x7c, 0x7c, 0x7c, 0x7c }, /* e2 */ | 507 | { 0x00, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* e3 */ |
510 | { 0x7e, 0x7e, 0x7e, 0x7e, 0x7e }, /* e3 */ | 508 | { 0x00, 0x00, 0x01, 0x02, 0x04, 0x04, 0x04 }, /* e4 */ |
511 | { 0x00, 0x00, 0x70, 0x08, 0x04 }, /* e4 */ | 509 | { 0x04, 0x09, 0x0a, 0x0a, 0x0a, 0x09, 0x04 }, /* e5 */ |
512 | { 0x00, 0x3e, 0x41, 0x1c, 0x22 }, /* e5 */ | 510 | { 0x00, 0x1f, 0x11, 0x11, 0x1f, 0x04, 0x1f }, /* e6 */ |
513 | { 0x5e, 0x52, 0x72, 0x52, 0x5e }, /* e6 */ | 511 | { 0x00, 0x07, 0x03, 0x05, 0x08, 0x10, 0x00 }, /* e7 */ |
514 | { 0x20, 0x10, 0x0a, 0x06, 0x0e }, /* e7 */ | 512 | { 0x00, 0x10, 0x08, 0x05, 0x03, 0x07, 0x00 }, /* e8 */ |
515 | { 0x02, 0x04, 0x28, 0x30, 0x38 }, /* e8 */ | 513 | { 0x09, 0x06, 0x0e, 0x01, 0x0f, 0x11, 0x0f }, /* e9 */ |
516 | { 0x20, 0x55, 0x56, 0x56, 0x79 }, /* e9 */ | 514 | { 0x1e, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* ea */ |
517 | { 0x01, 0x01, 0x01, 0x01, 0x02 }, /* ea */ | 515 | { 0x00, 0x00, 0x10, 0x08, 0x04, 0x04, 0x04 }, /* eb */ |
518 | { 0x04, 0x08, 0x70, 0x00, 0x00 }, /* eb */ | 516 | { 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f }, /* ec */ |
519 | { 0x7f, 0x7f, 0x7f, 0x7f, 0x7f }, /* ec */ | 517 | { 0x1f, 0x18, 0x14, 0x12, 0x15, 0x18, 0x1f }, /* ed */ |
520 | { 0x7f, 0x63, 0x55, 0x49, 0x51 }, /* ed */ | 518 | { 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, /* ee */ |
521 | { 0x01, 0x01, 0x01, 0x01, 0x01 }, /* ee */ | 519 | { 0x1f, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10 }, /* ef */ |
522 | { 0x7f, 0x01, 0x01, 0x01, 0x01 }, /* ef */ | 520 | { 0x00, 0x03, 0x07, 0x0c, 0x18, 0x1c, 0x1c }, /* f0 */ |
523 | { 0x70, 0x78, 0x6c, 0x06, 0x06 }, /* f0 */ | 521 | { 0x1c, 0x10, 0x1c, 0x07, 0x1c, 0x04, 0x07 }, /* f1 */ |
524 | { 0x17, 0x15, 0x7d, 0x48, 0x48 }, /* f1 */ | 522 | { 0x00, 0x1e, 0x03, 0x09, 0x19, 0x09, 0x1d }, /* f2 */ |
525 | { 0x52, 0x7a, 0x42, 0x06, 0x7c }, /* f2 */ | 523 | { 0x1e, 0x01, 0x19, 0x05, 0x09, 0x1d, 0x01 }, /* f3 */ |
526 | { 0x25, 0x35, 0x29, 0x01, 0x7e }, /* f3 */ | 524 | { 0x04, 0x04, 0x04, 0x02, 0x01, 0x00, 0x00 }, /* f4 */ |
527 | { 0x00, 0x00, 0x07, 0x08, 0x10 }, /* f4 */ | 525 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0f }, /* f5 */ |
528 | { 0x20, 0x40, 0x40, 0x40, 0x40 }, /* f5 */ | 526 | { 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x1e }, /* f6 */ |
529 | { 0x40, 0x40, 0x40, 0x40, 0x20 }, /* f6 */ | 527 | { 0x04, 0x04, 0x04, 0x08, 0x10, 0x00, 0x00 }, /* f7 */ |
530 | { 0x10, 0x08, 0x07, 0x00, 0x00 }, /* f7 */ | 528 | { 0x07, 0x03, 0x05, 0x08, 0x10, 0x10, 0x0f }, /* f8 */ |
531 | { 0x30, 0x48, 0x45, 0x43, 0x47 }, /* f8 */ | 529 | { 0x04, 0x0e, 0x1f, 0x11, 0x11, 0x15, 0x1f }, /* f9 */ |
532 | { 0x7c, 0x46, 0x67, 0x46, 0x7c }, /* f9 */ | 530 | { 0x1f, 0x03, 0x1a, 0x02, 0x1a, 0x02, 0x1e }, /* fa */ |
533 | { 0x55, 0x55, 0x41, 0x7f, 0x03 }, /* fa */ | 531 | { 0x00, 0x0e, 0x1f, 0x11, 0x1f, 0x0e, 0x00 }, /* fb */ |
534 | { 0x1c, 0x36, 0x36, 0x36, 0x1c }, /* fb */ | 532 | { 0x03, 0x05, 0x09, 0x09, 0x0b, 0x1b, 0x18 }, /* fc */ |
535 | { 0x60, 0x7c, 0x02, 0x31, 0x3f }, /* fc */ | 533 | { 0x1f, 0x03, 0x05, 0x09, 0x15, 0x03, 0x1f }, /* fd */ |
536 | { 0x51, 0x49, 0x55, 0x63, 0x7f }, /* fd */ | 534 | { 0x10, 0x10, 0x10, 0x10, 0x10, 0x1c, 0x1c }, /* fe */ |
537 | { 0x7f, 0x60, 0x60, 0x00, 0x00 }, /* fe */ | 535 | { 0x1c, 0x1c, 0x10, 0x10, 0x10, 0x10, 0x10 }, /* ff */ |
538 | { 0x7f, 0x03, 0x03, 0x00, 0x00 } /* ff */ | ||
539 | }; | 536 | }; |
540 | unsigned char (*font_player)[256][5]=&font_new_player; | 537 | |
538 | unsigned char (*font_player)[256][7] = &font_player_newlcd; | ||
541 | 539 | ||
542 | void font_init() | 540 | void font_init() |
543 | { | 541 | { |
544 | if (is_new_player()) | 542 | if (is_new_player()) |
545 | font_player = &font_new_player; | 543 | font_player = &font_player_newlcd; |
546 | else | 544 | else |
547 | font_player = &font_old_player; | 545 | font_player = &font_player_oldlcd; |
548 | } | 546 | } |
diff --git a/uisimulator/common/font-player.h b/uisimulator/common/font-player.h index 99c45da030..efa86e92c6 100644 --- a/uisimulator/common/font-player.h +++ b/uisimulator/common/font-player.h | |||
@@ -15,7 +15,7 @@ | |||
15 | * | 15 | * |
16 | ****************************************************************************/ | 16 | ****************************************************************************/ |
17 | 17 | ||
18 | extern unsigned char (*font_player)[256][5]; | 18 | extern unsigned char (*font_player)[256][7]; |
19 | 19 | ||
20 | void font_init(); | 20 | void font_init(); |
21 | 21 | ||
diff --git a/uisimulator/common/lcd-playersim.c b/uisimulator/common/lcd-playersim.c index 4c658438d6..1c877d4409 100644 --- a/uisimulator/common/lcd-playersim.c +++ b/uisimulator/common/lcd-playersim.c | |||
@@ -20,6 +20,7 @@ | |||
20 | #include "hwcompat.h" | 20 | #include "hwcompat.h" |
21 | 21 | ||
22 | #include "lcd.h" | 22 | #include "lcd.h" |
23 | #include "lcd-charcell.h" | ||
23 | #include "kernel.h" | 24 | #include "kernel.h" |
24 | #include "thread.h" | 25 | #include "thread.h" |
25 | #include <string.h> | 26 | #include <string.h> |
@@ -32,215 +33,85 @@ | |||
32 | 33 | ||
33 | /*** definitions ***/ | 34 | /*** definitions ***/ |
34 | 35 | ||
35 | #define CHAR_WIDTH 6 | 36 | bool sim_lcd_framebuffer[SIM_LCD_HEIGHT][SIM_LCD_WIDTH]; |
36 | #define CHAR_HEIGHT 8 | ||
37 | #define ICON_HEIGHT 12 | ||
38 | #define CHAR_PIXEL 2 | ||
39 | #define BORDER_MARGIN 1 | ||
40 | |||
41 | static int double_height=1; | ||
42 | extern bool lcd_display_redraw; | ||
43 | extern const unsigned short *lcd_ascii; | ||
44 | extern unsigned char hardware_buffer_lcd[11][2]; | ||
45 | 37 | ||
38 | static int double_height = 1; | ||
46 | 39 | ||
47 | void lcd_print_icon(int x, int icon_line, bool enable, char **icon) | 40 | void lcd_print_icon(int x, int icon_line, bool enable, char **icon) |
48 | { | 41 | { |
49 | int xpos = x; | 42 | int row, col; |
50 | int ypos = icon_line*(ICON_HEIGHT+(CHAR_HEIGHT*2+2)*CHAR_PIXEL); | 43 | int y = (ICON_HEIGHT+(CHAR_HEIGHT*2+2)*CHAR_PIXEL) * icon_line; |
51 | int row=0, col; | ||
52 | 44 | ||
53 | int p=0, cp=0; | 45 | y += BORDER_MARGIN; |
54 | struct coordinate points[SIM_LCD_WIDTH * SIM_LCD_HEIGHT]; | 46 | x += BORDER_MARGIN; |
55 | struct coordinate clearpoints[SIM_LCD_WIDTH * SIM_LCD_HEIGHT]; | ||
56 | 47 | ||
57 | while (icon[row]) { | 48 | for (row = 0; icon[row]; row++) |
58 | col=0; | 49 | { |
59 | while (icon[row][col]) { | 50 | for (col = 0; icon[row][col]; col++) |
60 | switch(icon[row][col]) { | 51 | { |
61 | case '*': | 52 | switch (icon[row][col]) |
62 | if (enable) { | 53 | { |
63 | /* set a dot */ | 54 | case '*': |
64 | points[p].x = xpos + col +BORDER_MARGIN; | 55 | sim_lcd_framebuffer[y+row][x+col] = enable; |
65 | points[p].y = ypos+row +BORDER_MARGIN; | 56 | break; |
66 | p++; /* increase the point counter */ | 57 | |
67 | } else { | 58 | case ' ': |
68 | /* clear a dot */ | 59 | sim_lcd_framebuffer[y+row][x+col] = false; |
69 | clearpoints[cp].x = xpos + col +BORDER_MARGIN; | 60 | break; |
70 | clearpoints[cp].y = ypos+row +BORDER_MARGIN; | 61 | } |
71 | cp++; /* increase the point counter */ | ||
72 | } | 62 | } |
73 | break; | ||
74 | case ' ': /* Clear bit */ | ||
75 | /* clear a dot */ | ||
76 | clearpoints[cp].x = xpos + col+BORDER_MARGIN; | ||
77 | clearpoints[cp].y = ypos+row+BORDER_MARGIN; | ||
78 | cp++; /* increase the point counter */ | ||
79 | break; | ||
80 | } | ||
81 | col++; | ||
82 | } | 63 | } |
83 | row++; | 64 | sim_lcd_update_rect(x, y, col, row); |
84 | } | 65 | /* icon drawing updates immediately */ |
85 | /* DEBUGF("icon draw %d/%d\n", p, cp);*/ | ||
86 | if (cp) | ||
87 | drawdots(0, &clearpoints[0], cp); | ||
88 | if (p) | ||
89 | drawdots(1, &points[0], p); | ||
90 | } | 66 | } |
91 | 67 | ||
92 | void lcd_print_char(int x, int y) | 68 | void lcd_print_char(int x, int y, unsigned char ch) |
93 | { | 69 | { |
94 | int xpos = x * CHAR_WIDTH * CHAR_PIXEL; | 70 | int xpos = x * CHAR_WIDTH*CHAR_PIXEL; |
95 | int ypos = y * CHAR_HEIGHT * CHAR_PIXEL + ICON_HEIGHT; | 71 | int ypos = y * CHAR_HEIGHT*CHAR_PIXEL + ICON_HEIGHT; |
96 | int col, row; | 72 | int row, col, r, c; |
97 | int p=0, cp=0; | 73 | |
98 | struct rectangle points[CHAR_HEIGHT*CHAR_WIDTH]; | 74 | if (double_height > 1 && y == 1) |
99 | struct rectangle clearpoints[CHAR_HEIGHT*CHAR_WIDTH]; | 75 | return; /* only one row available if text is double height */ |
100 | unsigned char ch=hardware_buffer_lcd[x][y]; | 76 | |
101 | static char bitmap_content[11*8][2*8]; | 77 | for (row = 0; row < 7; row ++) |
102 | 78 | { | |
103 | if (double_height == 2 && y == 1) | 79 | unsigned fontbitmap = (*font_player)[ch][row]; |
104 | return; /* only one row available if text is double height */ | 80 | int height = (row == 3) ? 1 : double_height; |
105 | 81 | ||
106 | for (col=0; col<5; col++) { | 82 | y = ypos + row * CHAR_PIXEL * double_height; |
107 | unsigned char fontbitmap=(*font_player)[ch][col]; | 83 | for (col = 0; col < 5; col++) |
108 | for (row=0; row<7; row++) { | 84 | { |
109 | char fontbit=fontbitmap&(1<<row); | 85 | bool fontbit = fontbitmap & (0x10 >> col); |
110 | int height=CHAR_PIXEL*double_height; | 86 | |
111 | int ypixel; | 87 | x = xpos + col * CHAR_PIXEL; |
112 | if (bitmap_content[x*8+col][y*8+row*double_height]!=fontbit || | 88 | for (r = 0; r < height * CHAR_PIXEL; r++) |
113 | bitmap_content[x*8+col][y*8+row*double_height+double_height-1]!= | 89 | for (c = 0; c < CHAR_PIXEL; c++) |
114 | fontbit) { | 90 | sim_lcd_framebuffer[y+r][x+c] = fontbit; |
115 | bitmap_content[x*8+col][y*8+row*double_height]=fontbit; | ||
116 | bitmap_content[x*8+col][y*8+row*double_height+double_height-1]=fontbit; | ||
117 | |||
118 | ypixel=CHAR_PIXEL*(double_height*row)+ypos; | ||
119 | if (double_height==2) { | ||
120 | if (row == 3) /* Adjust for blank row in the middle */ | ||
121 | height=CHAR_PIXEL; | ||
122 | } | ||
123 | |||
124 | if (fontbit) { | ||
125 | /* set a dot */ | ||
126 | points[p].x = xpos + col*CHAR_PIXEL +BORDER_MARGIN; | ||
127 | points[p].y = ypixel +BORDER_MARGIN; | ||
128 | points[p].width=CHAR_PIXEL; | ||
129 | points[p].height=height; | ||
130 | p++; /* increase the point counter */ | ||
131 | } else { | ||
132 | clearpoints[cp].x = xpos + col*CHAR_PIXEL +BORDER_MARGIN; | ||
133 | clearpoints[cp].y = ypixel +BORDER_MARGIN; | ||
134 | clearpoints[cp].width=CHAR_PIXEL; | ||
135 | clearpoints[cp].height=height; | ||
136 | cp++; | ||
137 | } | 91 | } |
138 | } | ||
139 | } | 92 | } |
140 | } | 93 | if (double_height > 1) |
141 | /* DEBUGF("print_char %d/%d\n", p, cp);*/ | 94 | { |
142 | if (cp) | 95 | y = ypos + 15*CHAR_PIXEL; |
143 | drawrectangles(0, &clearpoints[0], cp); | 96 | for (r = 0; r < CHAR_PIXEL; r++) |
144 | if (p) | 97 | for (c = 0; c < 5*CHAR_PIXEL; c++) |
145 | drawrectangles(1, &points[0], p); | 98 | sim_lcd_framebuffer[y+r][xpos+c] = false; |
146 | } | 99 | } |
147 | |||
148 | |||
149 | /* | ||
150 | * Draw a rectangle with upper left corner at (x, y) | ||
151 | * and size (nx, ny) | ||
152 | */ | ||
153 | void lcd_drawrect (int x, int y, int nx, int ny) | ||
154 | { | ||
155 | (void)x; | ||
156 | (void)y; | ||
157 | (void)nx; | ||
158 | (void)ny; | ||
159 | } | ||
160 | |||
161 | /* Invert a rectangular area at (x, y), size (nx, ny) */ | ||
162 | void lcd_invertrect (int x, int y, int nx, int ny) | ||
163 | { | ||
164 | (void)x; | ||
165 | (void)y; | ||
166 | (void)nx; | ||
167 | (void)ny; | ||
168 | } | ||
169 | |||
170 | void lcd_drawline( int x1, int y1, int x2, int y2 ) | ||
171 | { | ||
172 | (void)x1; | ||
173 | (void)x2; | ||
174 | (void)y1; | ||
175 | (void)y2; | ||
176 | } | ||
177 | |||
178 | void lcd_clearline( int x1, int y1, int x2, int y2 ) | ||
179 | { | ||
180 | (void)x1; | ||
181 | (void)x2; | ||
182 | (void)y1; | ||
183 | (void)y2; | ||
184 | } | ||
185 | |||
186 | /* | ||
187 | * Set a single pixel | ||
188 | */ | ||
189 | void lcd_drawpixel(int x, int y) | ||
190 | { | ||
191 | (void)x; | ||
192 | (void)y; | ||
193 | } | ||
194 | |||
195 | /* | ||
196 | * Clear a single pixel | ||
197 | */ | ||
198 | void lcd_clearpixel(int x, int y) | ||
199 | { | ||
200 | (void)x; | ||
201 | (void)y; | ||
202 | } | ||
203 | |||
204 | /* | ||
205 | * Invert a single pixel | ||
206 | */ | ||
207 | void lcd_invertpixel(int x, int y) | ||
208 | { | ||
209 | (void)x; | ||
210 | (void)y; | ||
211 | } | 100 | } |
212 | 101 | ||
213 | |||
214 | |||
215 | void lcd_double_height(bool on) | 102 | void lcd_double_height(bool on) |
216 | { | 103 | { |
217 | double_height = 1; | 104 | int newval = (is_new_player() && on) ? 2 : 1; |
218 | if (on) | 105 | |
219 | double_height = 2; | 106 | if (newval != double_height) |
220 | lcd_display_redraw=true; | ||
221 | lcd_update(); | ||
222 | } | ||
223 | |||
224 | void lcd_define_hw_pattern(int pat, const char *pattern) | ||
225 | { | ||
226 | int i, j; | ||
227 | unsigned char icon[8]; | ||
228 | memset(icon, 0, sizeof icon); | ||
229 | |||
230 | DEBUGF("Defining pattern %d:", pat); | ||
231 | for (j = 0; j <= 5; j++) { | ||
232 | for (i = 0; i < 7; i++) { | ||
233 | if ((pattern[i])&(1<<(j))) | ||
234 | icon[5-j] |= (1<<(i)); | ||
235 | } | ||
236 | } | ||
237 | for (i = 1; i <= 5; i++) | ||
238 | { | 107 | { |
239 | DEBUGF(" 0x%02x", icon[i]); | 108 | double_height = newval; |
240 | (*font_player)[pat][i-1] = icon[i]; | 109 | lcd_update(); |
241 | } | 110 | } |
242 | DEBUGF("\n"); | ||
243 | lcd_display_redraw=true; | ||
244 | lcd_update(); | ||
245 | } | 111 | } |
246 | 112 | ||
113 | void sim_lcd_define_pattern(int pat, const char *pattern) | ||
114 | { | ||
115 | if (pat < lcd_pattern_count) | ||
116 | memcpy((*font_player)[pat], pattern, 7); | ||
117 | } | ||
diff --git a/uisimulator/common/lcd-playersim.h b/uisimulator/common/lcd-playersim.h index 10267de1f1..763e4159e9 100644 --- a/uisimulator/common/lcd-playersim.h +++ b/uisimulator/common/lcd-playersim.h | |||
@@ -17,23 +17,15 @@ | |||
17 | * | 17 | * |
18 | ****************************************************************************/ | 18 | ****************************************************************************/ |
19 | 19 | ||
20 | struct coordinate { | 20 | #define ICON_HEIGHT 12 |
21 | int x; | 21 | #define CHAR_HEIGHT 8 |
22 | int y; | 22 | #define CHAR_WIDTH 6 |
23 | }; | 23 | #define CHAR_PIXEL 2 |
24 | struct rectangle { | 24 | #define BORDER_MARGIN 1 |
25 | int x; | ||
26 | int y; | ||
27 | int width; | ||
28 | int height; | ||
29 | }; | ||
30 | |||
31 | void drawdots(int color, struct coordinate *coord, int count); | ||
32 | void drawdot(int color, int x, int y); | ||
33 | void drawrect(int color, int x1, int y1, int x2, int y2); | ||
34 | void drawrectangles(int color, struct rectangle *rects, int count); | ||
35 | |||
36 | |||
37 | void dots(int *colors, struct coordinate *points, int count); | ||
38 | 25 | ||
26 | extern bool sim_lcd_framebuffer[SIM_LCD_HEIGHT][SIM_LCD_WIDTH]; | ||
39 | 27 | ||
28 | void lcd_print_icon(int x, int icon_line, bool enable, char **icon); | ||
29 | void lcd_print_char(int x, int y, unsigned char ch); | ||
30 | void sim_lcd_update_rect(int x, int y, int width, int height); | ||
31 | void sim_lcd_define_pattern(int pat, const char *pattern); | ||
diff --git a/uisimulator/sdl/SOURCES b/uisimulator/sdl/SOURCES index 8f1f3e2fd7..e563cb984d 100644 --- a/uisimulator/sdl/SOURCES +++ b/uisimulator/sdl/SOURCES | |||
@@ -3,7 +3,7 @@ kernel.c | |||
3 | #ifdef HAVE_LCD_BITMAP | 3 | #ifdef HAVE_LCD_BITMAP |
4 | lcd-bitmap.c | 4 | lcd-bitmap.c |
5 | #elif defined(HAVE_LCD_CHARCELLS) | 5 | #elif defined(HAVE_LCD_CHARCELLS) |
6 | lcd-charcell.c | 6 | lcd-charcells.c |
7 | #endif | 7 | #endif |
8 | #ifdef HAVE_REMOTE_LCD | 8 | #ifdef HAVE_REMOTE_LCD |
9 | lcd-remote-bitmap.c | 9 | lcd-remote-bitmap.c |
diff --git a/uisimulator/sdl/button.c b/uisimulator/sdl/button.c index 76a41f2230..4b03008497 100644 --- a/uisimulator/sdl/button.c +++ b/uisimulator/sdl/button.c | |||
@@ -18,7 +18,7 @@ | |||
18 | ****************************************************************************/ | 18 | ****************************************************************************/ |
19 | 19 | ||
20 | #include "uisdl.h" | 20 | #include "uisdl.h" |
21 | #include "lcd-charcell.h" | 21 | #include "lcd-charcells.h" |
22 | #include "lcd-remote.h" | 22 | #include "lcd-remote.h" |
23 | #include "config.h" | 23 | #include "config.h" |
24 | #include "button.h" | 24 | #include "button.h" |
diff --git a/uisimulator/sdl/lcd-charcell.c b/uisimulator/sdl/lcd-charcells.c index 8849efc7cd..5a08179232 100644 --- a/uisimulator/sdl/lcd-charcell.c +++ b/uisimulator/sdl/lcd-charcells.c | |||
@@ -19,6 +19,7 @@ | |||
19 | 19 | ||
20 | #include "debug.h" | 20 | #include "debug.h" |
21 | #include "lcd.h" | 21 | #include "lcd.h" |
22 | #include "lcd-charcell.h" | ||
22 | #include "misc.h" | 23 | #include "misc.h" |
23 | #include <string.h> | 24 | #include <string.h> |
24 | #include <unistd.h> | 25 | #include <unistd.h> |
@@ -36,82 +37,38 @@ SDL_Color lcd_color_zero = {UI_LCD_BGCOLOR, 0}; | |||
36 | SDL_Color lcd_backlight_color_zero = {UI_LCD_BGCOLORLIGHT, 0}; | 37 | SDL_Color lcd_backlight_color_zero = {UI_LCD_BGCOLORLIGHT, 0}; |
37 | SDL_Color lcd_color_max = {0, 0, 0, 0}; | 38 | SDL_Color lcd_color_max = {0, 0, 0, 0}; |
38 | 39 | ||
39 | /* Defined in lcd-playersim.c */ | ||
40 | extern void lcd_print_char(int x, int y); | ||
41 | 40 | ||
42 | void lcd_update(void) | 41 | static unsigned long get_lcd_pixel(int x, int y) |
43 | { | 42 | { |
44 | int x, y; | 43 | return sim_lcd_framebuffer[y][x]; |
45 | SDL_Rect dest = {UI_LCD_POSX, UI_LCD_POSY, UI_LCD_WIDTH, UI_LCD_HEIGHT}; | ||
46 | |||
47 | SDL_LockSurface(lcd_surface); | ||
48 | |||
49 | for (y=0; y<2; y++) { | ||
50 | for (x=0; x<11; x++) { | ||
51 | lcd_print_char(x, y); | ||
52 | } | ||
53 | } | ||
54 | |||
55 | SDL_UnlockSurface(lcd_surface); | ||
56 | |||
57 | if (!background) { | ||
58 | dest.x -= UI_LCD_POSX; | ||
59 | dest.y -= UI_LCD_POSY; | ||
60 | } | ||
61 | |||
62 | SDL_BlitSurface(lcd_surface, NULL, gui_surface, &dest); | ||
63 | SDL_UpdateRect(gui_surface, dest.x, dest.y, dest.w, dest.h); | ||
64 | SDL_Flip(gui_surface); | ||
65 | } | 44 | } |
66 | 45 | ||
67 | void drawdots(int color, struct coordinate *points, int count) | 46 | void sim_lcd_update_rect(int x_start, int y_start, int width, int height) |
68 | { | 47 | { |
69 | SDL_Rect dest; | 48 | sdl_update_rect(lcd_surface, x_start, y_start, width, height, |
70 | Uint32 sdlcolor; | 49 | SIM_LCD_WIDTH, SIM_LCD_HEIGHT, get_lcd_pixel); |
71 | 50 | sdl_gui_update(lcd_surface, x_start, y_start, width, height, | |
72 | SDL_LockSurface(lcd_surface); | 51 | SIM_LCD_WIDTH, SIM_LCD_HEIGHT, |
73 | 52 | background ? UI_LCD_POSX : 0, background ? UI_LCD_POSY : 0); | |
74 | if (color == 1) { | ||
75 | sdlcolor = SDL_MapRGB(lcd_surface->format, lcd_color_max.r, lcd_color_max.g, lcd_color_max.b); | ||
76 | } else { | ||
77 | sdlcolor = SDL_MapRGB(lcd_surface->format, lcd_color_zero.r, lcd_color_zero.g, lcd_color_zero.b); | ||
78 | } | ||
79 | |||
80 | while (count--) { | ||
81 | dest.x = points[count].x * display_zoom; | ||
82 | dest.y = points[count].y * display_zoom; | ||
83 | dest.w = 1 * display_zoom; | ||
84 | dest.h = 1 * display_zoom; | ||
85 | |||
86 | SDL_FillRect(lcd_surface, &dest, sdlcolor); | ||
87 | } | ||
88 | |||
89 | SDL_UnlockSurface(lcd_surface); | ||
90 | } | 53 | } |
91 | 54 | ||
92 | void drawrectangles(int color, struct rectangle *points, int count) | 55 | void lcd_update(void) |
93 | { | 56 | { |
94 | SDL_Rect dest; | 57 | int x, y; |
95 | Uint32 sdlcolor; | ||
96 | |||
97 | SDL_LockSurface(lcd_surface); | ||
98 | |||
99 | if (color == 1) { | ||
100 | sdlcolor = SDL_MapRGB(lcd_surface->format, lcd_color_max.r, lcd_color_max.g, lcd_color_max.b); | ||
101 | } else { | ||
102 | sdlcolor = SDL_MapRGB(lcd_surface->format, lcd_color_zero.r, lcd_color_zero.g, lcd_color_zero.b); | ||
103 | } | ||
104 | 58 | ||
105 | while (count--) { | 59 | for (y = 0; y < lcd_pattern_count; y++) |
106 | dest.x = points[count].x * display_zoom; | 60 | if (lcd_patterns[y].count > 0) |
107 | dest.y = points[count].y * display_zoom; | 61 | sim_lcd_define_pattern(y, lcd_patterns[y].pattern); |
108 | dest.w = points[count].width * display_zoom; | ||
109 | dest.h = points[count].height * display_zoom; | ||
110 | 62 | ||
111 | SDL_FillRect(lcd_surface, &dest, sdlcolor); | 63 | for (y = 0; y < LCD_HEIGHT; y++) |
112 | } | 64 | for (x = 0; x < LCD_WIDTH; x++) |
65 | lcd_print_char(x, y, lcd_charbuffer[y][x]); | ||
113 | 66 | ||
114 | SDL_UnlockSurface(lcd_surface); | 67 | if (lcd_cursor.visible) |
68 | lcd_print_char(lcd_cursor.x, lcd_cursor.y, lcd_cursor.hw_char); | ||
69 | |||
70 | sim_lcd_update_rect(0, ICON_HEIGHT, SIM_LCD_WIDTH, | ||
71 | LCD_HEIGHT*CHAR_HEIGHT*CHAR_PIXEL); | ||
115 | } | 72 | } |
116 | 73 | ||
117 | #if CONFIG_BACKLIGHT | 74 | #if CONFIG_BACKLIGHT |
@@ -124,8 +81,8 @@ void sim_backlight(int value) | |||
124 | sdl_set_gradient(lcd_surface, &lcd_color_zero, &lcd_color_max, | 81 | sdl_set_gradient(lcd_surface, &lcd_color_zero, &lcd_color_max, |
125 | 0, (1<<LCD_DEPTH)); | 82 | 0, (1<<LCD_DEPTH)); |
126 | } | 83 | } |
127 | 84 | ||
128 | lcd_update(); | 85 | sim_lcd_update_rect(0, 0, SIM_LCD_WIDTH, SIM_LCD_HEIGHT); |
129 | } | 86 | } |
130 | #endif | 87 | #endif |
131 | 88 | ||
diff --git a/uisimulator/sdl/lcd-charcell.h b/uisimulator/sdl/lcd-charcells.h index 6b1e85e549..6b1e85e549 100644 --- a/uisimulator/sdl/lcd-charcell.h +++ b/uisimulator/sdl/lcd-charcells.h | |||
diff --git a/uisimulator/sdl/uisdl.c b/uisimulator/sdl/uisdl.c index 037c54a9bf..54175ce727 100644 --- a/uisimulator/sdl/uisdl.c +++ b/uisimulator/sdl/uisdl.c | |||
@@ -28,7 +28,7 @@ | |||
28 | #ifdef HAVE_LCD_BITMAP | 28 | #ifdef HAVE_LCD_BITMAP |
29 | #include "lcd-bitmap.h" | 29 | #include "lcd-bitmap.h" |
30 | #elif defined(HAVE_LCD_CHARCELLS) | 30 | #elif defined(HAVE_LCD_CHARCELLS) |
31 | #include "lcd-charcell.h" | 31 | #include "lcd-charcells.h" |
32 | #endif | 32 | #endif |
33 | #ifdef HAVE_REMOTE_LCD | 33 | #ifdef HAVE_REMOTE_LCD |
34 | #include "lcd-remote-bitmap.h" | 34 | #include "lcd-remote-bitmap.h" |