?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
a bit of code cleanup.. use a single function to get the statusbar height (or lack...
[Rockbox.git] / firmware / drivers / lcd-2bit-vert.c
blobd43bf6cc81f2df13f46b350dbd60471b8e4f087d
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (C) 2004 by Linus Nielsen Feltzing
11 *
12 * All files in this archive are subject to the GNU General Public License.
13 * See the file COPYING in the source tree root for full license agreement.
14 *
15 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
16 * KIND, either express or implied.
17 *
18 ****************************************************************************/
19 #include "config.h"
20
21 #include "system.h"
22 #include "cpu.h"
23 #include "kernel.h"
24 #include "lcd.h"
25 #include "thread.h"
26 #include <string.h>
27 #include <stdlib.h>
28 #include "file.h"
29 #include "debug.h"
30 #include "font.h"
31 #include "rbunicode.h"
32 #include "bidi.h"
33 #include "scroll_engine.h"
34
35 /*** globals ***/
36
37 fb_data lcd_framebuffer[LCD_FBHEIGHT][LCD_FBWIDTH] IBSS_ATTR;
38
39 const unsigned char lcd_dibits[16] ICONST_ATTR = {
40 0x00, 0x03, 0x0C, 0x0F, 0x30, 0x33, 0x3C, 0x3F,
41 0xC0, 0xC3, 0xCC, 0xCF, 0xF0, 0xF3, 0xFC, 0xFF
42 };
43
44 static const unsigned char pixmask[4] ICONST_ATTR = {
45 0x03, 0x0C, 0x30, 0xC0
46 };
47
48 static fb_data* lcd_backdrop = NULL;
49 static long lcd_backdrop_offset IDATA_ATTR = 0;
50
51 static struct viewport default_vp =
52 {
53 .x = 0,
54 .y = 0,
55 .width = LCD_WIDTH,
56 .height = LCD_HEIGHT,
57 .font = FONT_SYSFIXED,
58 .drawmode = DRMODE_SOLID,
59 .xmargin = 0,
60 .ymargin = 0,
61 .fg_pattern = LCD_DEFAULT_FG,
62 .bg_pattern = LCD_DEFAULT_BG
63 };
64
65 static struct viewport* current_vp IBSS_ATTR;
66 static unsigned fg_pattern IBSS_ATTR;
67 static unsigned bg_pattern IBSS_ATTR;
68
69 /* LCD init */
70 void lcd_init(void)
71 {
72 /* Initialise the viewport */
73 lcd_set_viewport(NULL);
74
75 lcd_clear_display();
76 /* Call device specific init */
77 lcd_init_device();
78 scroll_init();
79 }
80
81 /*** Viewports ***/
82
83 void lcd_set_viewport(struct viewport* vp)
84 {
85 if (vp == NULL)
86 current_vp = &default_vp;
87 else
88 current_vp = vp;
89
90 fg_pattern = 0x55 * (~current_vp->fg_pattern & 3);
91 bg_pattern = 0x55 * (~current_vp->bg_pattern & 3);
92 }
93
94 void lcd_update_viewport(void)
95 {
96 lcd_update_rect(current_vp->x, current_vp->y,
97 current_vp->width, current_vp->height);
98 }
99
100 void lcd_update_viewport_rect(int x, int y, int width, int height)
101 {
102 lcd_update_rect(current_vp->x + x, current_vp->y + y, width, height);
103 }
104
105
106 /*** parameter handling ***/
107
108 void lcd_set_drawmode(int mode)
109 {
110 current_vp->drawmode = mode & (DRMODE_SOLID|DRMODE_INVERSEVID);
111 }
112
113 int lcd_get_drawmode(void)
114 {
115 return current_vp->drawmode;
116 }
117
118 void lcd_set_foreground(unsigned brightness)
119 {
120 current_vp->fg_pattern = brightness;
121 fg_pattern = 0x55 * (~brightness & 3);
122 }
123
124 unsigned lcd_get_foreground(void)
125 {
126 return current_vp->fg_pattern;
127 }
128
129 void lcd_set_background(unsigned brightness)
130 {
131 current_vp->bg_pattern = brightness;
132 bg_pattern = 0x55 * (~brightness & 3);
133 }
134
135 unsigned lcd_get_background(void)
136 {
137 return current_vp->bg_pattern;
138 }
139
140 void lcd_set_drawinfo(int mode, unsigned fg_brightness, unsigned bg_brightness)
141 {
142 lcd_set_drawmode(mode);
143 lcd_set_foreground(fg_brightness);
144 lcd_set_background(bg_brightness);
145 }
146
147 void lcd_setmargins(int x, int y)
148 {
149 current_vp->xmargin = x;
150 current_vp->ymargin = y;
151 }
152
153 int lcd_getxmargin(void)
154 {
155 return current_vp->xmargin;
156 }
157
158 int lcd_getymargin(void)
159 {
160 return current_vp->ymargin;
161 }
162
163 int lcd_getwidth(void)
164 {
165 return current_vp->width;
166 }
167
168 int lcd_getheight(void)
169 {
170 return current_vp->height;
171 }
172
173 void lcd_setfont(int newfont)
174 {
175 current_vp->font = newfont;
176 }
177
178 int lcd_getfont(void)
179 {
180 return current_vp->font;
181 }
182
183 int lcd_getstringsize(const unsigned char *str, int *w, int *h)
184 {
185 return font_getstringsize(str, w, h, current_vp->font);
186 }
187
188 /*** low-level drawing functions ***/
189
190 static void setpixel(int x, int y)
191 {
192 unsigned mask = pixmask[y & 3];
193 fb_data *address = &lcd_framebuffer[y>>2][x];
194 unsigned data = *address;
195
196 *address = data ^ ((data ^ fg_pattern) & mask);
197 }
198
199 static void clearpixel(int x, int y)
200 {
201 unsigned mask = pixmask[y & 3];
202 fb_data *address = &lcd_framebuffer[y>>2][x];
203 unsigned data = *address;
204
205 *address = data ^ ((data ^ bg_pattern) & mask);
206 }
207
208 static void clearimgpixel(int x, int y)
209 {
210 unsigned mask = pixmask[y & 3];
211 fb_data *address = &lcd_framebuffer[y>>2][x];
212 unsigned data = *address;
213
214 *address = data ^ ((data ^ *(address + lcd_backdrop_offset)) & mask);
215 }
216
217 static void flippixel(int x, int y)
218 {
219 unsigned mask = pixmask[y & 3];
220 fb_data *address = &lcd_framebuffer[y>>2][x];
221
222 *address ^= mask;
223 }
224
225 static void nopixel(int x, int y)
226 {
227 (void)x;
228 (void)y;
229 }
230
231 lcd_pixelfunc_type* const lcd_pixelfuncs_bgcolor[8] = {
232 flippixel, nopixel, setpixel, setpixel,
233 nopixel, clearpixel, nopixel, clearpixel
234 };
235
236 lcd_pixelfunc_type* const lcd_pixelfuncs_backdrop[8] = {
237 flippixel, nopixel, setpixel, setpixel,
238 nopixel, clearimgpixel, nopixel, clearimgpixel
239 };
240
241
242 lcd_pixelfunc_type* const * lcd_pixelfuncs = lcd_pixelfuncs_bgcolor;
243
244 /* 'mask' and 'bits' contain 2 bits per pixel */
245 static void ICODE_ATTR flipblock(fb_data *address, unsigned mask,
246 unsigned bits)
247 {
248 *address ^= bits & mask;
249 }
250
251 static void ICODE_ATTR bgblock(fb_data *address, unsigned mask,
252 unsigned bits)
253 {
254 unsigned data = *address;
255
256 *address = data ^ ((data ^ bg_pattern) & mask & ~bits);
257 }
258
259 static void ICODE_ATTR bgimgblock(fb_data *address, unsigned mask,
260 unsigned bits)
261 {
262 unsigned data = *address;
263
264 *address = data ^ ((data ^ *(address + lcd_backdrop_offset)) & mask & ~bits);
265 }
266
267 static void ICODE_ATTR fgblock(fb_data *address, unsigned mask,
268 unsigned bits)
269 {
270 unsigned data = *address;
271
272 *address = data ^ ((data ^ fg_pattern) & mask & bits);
273 }
274
275 static void ICODE_ATTR solidblock(fb_data *address, unsigned mask,
276 unsigned bits)
277 {
278 unsigned data = *address;
279 unsigned bgp = bg_pattern;
280
281 bits = bgp ^ ((bgp ^ fg_pattern) & bits);
282 *address = data ^ ((data ^ bits) & mask);
283 }
284
285 static void ICODE_ATTR solidimgblock(fb_data *address, unsigned mask,
286 unsigned bits)
287 {
288 unsigned data = *address;
289 unsigned bgp = *(address + lcd_backdrop_offset);
290
291 bits = bgp ^ ((bgp ^ fg_pattern) & bits);
292 *address = data ^ ((data ^ bits) & mask);
293 }
294
295 static void ICODE_ATTR flipinvblock(fb_data *address, unsigned mask,
296 unsigned bits)
297 {
298 *address ^= ~bits & mask;
299 }
300
301 static void ICODE_ATTR bginvblock(fb_data *address, unsigned mask,
302 unsigned bits)
303 {
304 unsigned data = *address;
305
306 *address = data ^ ((data ^ bg_pattern) & mask & bits);
307 }
308
309 static void ICODE_ATTR bgimginvblock(fb_data *address, unsigned mask,
310 unsigned bits)
311 {
312 unsigned data = *address;
313
314 *address = data ^ ((data ^ *(address + lcd_backdrop_offset)) & mask & bits);
315 }
316
317 static void ICODE_ATTR fginvblock(fb_data *address, unsigned mask,
318 unsigned bits)
319 {
320 unsigned data = *address;
321
322 *address = data ^ ((data ^ fg_pattern) & mask & ~bits);
323 }
324
325 static void ICODE_ATTR solidinvblock(fb_data *address, unsigned mask,
326 unsigned bits)
327 {
328 unsigned data = *address;
329 unsigned fgp = fg_pattern;
330
331 bits = fgp ^ ((fgp ^ bg_pattern) & bits);
332 *address = data ^ ((data ^ bits) & mask);
333 }
334
335 static void ICODE_ATTR solidimginvblock(fb_data *address, unsigned mask,
336 unsigned bits)
337 {
338 unsigned data = *address;
339 unsigned fgp = fg_pattern;
340
341 bits = fgp ^ ((fgp ^ *(address + lcd_backdrop_offset)) & bits);
342 *address = data ^ ((data ^ bits) & mask);
343 }
344
345 lcd_blockfunc_type* const lcd_blockfuncs_bgcolor[8] = {
346 flipblock, bgblock, fgblock, solidblock,
347 flipinvblock, bginvblock, fginvblock, solidinvblock
348 };
349
350 lcd_blockfunc_type* const lcd_blockfuncs_backdrop[8] = {
351 flipblock, bgimgblock, fgblock, solidimgblock,
352 flipinvblock, bgimginvblock, fginvblock, solidimginvblock
353 };
354
355 lcd_blockfunc_type* const * lcd_blockfuncs = lcd_blockfuncs_bgcolor;
356
357
358 void lcd_set_backdrop(fb_data* backdrop)
359 {
360 lcd_backdrop = backdrop;
361 if (backdrop)
362 {
363 lcd_backdrop_offset = (long)backdrop - (long)lcd_framebuffer;
364 lcd_pixelfuncs = lcd_pixelfuncs_backdrop;
365 lcd_blockfuncs = lcd_blockfuncs_backdrop;
366 }
367 else
368 {
369 lcd_backdrop_offset = 0;
370 lcd_pixelfuncs = lcd_pixelfuncs_bgcolor;
371 lcd_blockfuncs = lcd_blockfuncs_bgcolor;
372 }
373 }
374
375 fb_data* lcd_get_backdrop(void)
376 {
377 return lcd_backdrop;
378 }
379
380
381 static inline void setblock(fb_data *address, unsigned mask, unsigned bits)
382 {
383 unsigned data = *address;
384
385 bits ^= data;
386 *address = data ^ (bits & mask);
387 }
388
389 /*** drawing functions ***/
390
391 /* Clear the whole display */
392 void lcd_clear_display(void)
393 {
394 if (current_vp->drawmode & DRMODE_INVERSEVID)
395 {
396 memset(lcd_framebuffer, fg_pattern, sizeof lcd_framebuffer);
397 }
398 else
399 {
400 if (lcd_backdrop)
401 memcpy(lcd_framebuffer, lcd_backdrop, sizeof lcd_framebuffer);
402 else
403 memset(lcd_framebuffer, bg_pattern, sizeof lcd_framebuffer);
404 }
405
406 lcd_scroll_info.lines = 0;
407 }
408
409 /* Clear the current viewport */
410 void lcd_clear_viewport(void)
411 {
412 int lastmode;
413
414 if (current_vp == &default_vp)
415 {
416 lcd_clear_display();
417 }
418 else
419 {
420 lastmode = current_vp->drawmode;
421
422 /* Invert the INVERSEVID bit and set basic mode to SOLID */
423 current_vp->drawmode = (~lastmode & DRMODE_INVERSEVID) |
424 DRMODE_SOLID;
425
426 lcd_fillrect(0, 0, current_vp->width, current_vp->height);
427
428 current_vp->drawmode = lastmode;
429
430 lcd_scroll_stop(current_vp);
431 }
432 }
433
434 /* Set a single pixel */
435 void lcd_drawpixel(int x, int y)
436 {
437 if (((unsigned)x < (unsigned)current_vp->width) &&
438 ((unsigned)y < (unsigned)current_vp->height))
439 lcd_pixelfuncs[current_vp->drawmode](current_vp->x + x, current_vp->y + y);
440 }
441
442 /* Draw a line */
443 void lcd_drawline(int x1, int y1, int x2, int y2)
444 {
445 int numpixels;
446 int i;
447 int deltax, deltay;
448 int d, dinc1, dinc2;
449 int x, xinc1, xinc2;
450 int y, yinc1, yinc2;
451 lcd_pixelfunc_type *pfunc = lcd_pixelfuncs[current_vp->drawmode];
452
453 deltax = abs(x2 - x1);
454 if (deltax == 0)
455 {
456 DEBUGF("lcd_drawline() called for vertical line - optimisation.\n");
457 lcd_vline(x1, y1, y2);
458 return;
459 }
460 deltay = abs(y2 - y1);
461 if (deltay == 0)
462 {
463 DEBUGF("lcd_drawline() called for horizontal line - optimisation.\n");
464 lcd_hline(x1, x2, y1);
465 return;
466 }
467 xinc2 = 1;
468 yinc2 = 1;
469
470 if (deltax >= deltay)
471 {
472 numpixels = deltax;
473 d = 2 * deltay - deltax;
474 dinc1 = deltay * 2;
475 dinc2 = (deltay - deltax) * 2;
476 xinc1 = 1;
477 yinc1 = 0;
478 }
479 else
480 {
481 numpixels = deltay;
482 d = 2 * deltax - deltay;
483 dinc1 = deltax * 2;
484 dinc2 = (deltax - deltay) * 2;
485 xinc1 = 0;
486 yinc1 = 1;
487 }
488 numpixels++; /* include endpoints */
489
490 if (x1 > x2)
491 {
492 xinc1 = -xinc1;
493 xinc2 = -xinc2;
494 }
495
496 if (y1 > y2)
497 {
498 yinc1 = -yinc1;
499 yinc2 = -yinc2;
500 }
501
502 x = x1;
503 y = y1;
504
505 for (i = 0; i < numpixels; i++)
506 {
507 if (((unsigned)x < (unsigned)current_vp->width) &&
508 ((unsigned)y < (unsigned)current_vp->height))
509 pfunc(current_vp->x + x, current_vp->y + y);
510
511 if (d < 0)
512 {
513 d += dinc1;
514 x += xinc1;
515 y += yinc1;
516 }
517 else
518 {
519 d += dinc2;
520 x += xinc2;
521 y += yinc2;
522 }
523 }
524 }
525
526 /* Draw a horizontal line (optimised) */
527 void lcd_hline(int x1, int x2, int y)
528 {
529 int x;
530 int width;
531 fb_data *dst, *dst_end;
532 unsigned mask;
533 lcd_blockfunc_type *bfunc;
534
535 /* direction flip */
536 if (x2 < x1)
537 {
538 x = x1;
539 x1 = x2;
540 x2 = x;
541 }
542
543 /* nothing to draw? */
544 if (((unsigned)y >= (unsigned)current_vp->height) || (x1 >= current_vp->width)
545 || (x2 < 0))
546 return;
547
548 /* clipping */
549 if (x1 < 0)
550 x1 = 0;
551 if (x2 >= current_vp->width)
552 x2 = current_vp->width-1;
553
554 width = x2 - x1 + 1;
555
556 /* adjust x1 and y to viewport */
557 x1 += current_vp->x;
558 y += current_vp->y;
559
560 bfunc = lcd_blockfuncs[current_vp->drawmode];
561 dst = &lcd_framebuffer[y>>2][x1];
562 mask = pixmask[y & 3];
563
564 dst_end = dst + width;
565 do
566 bfunc(dst++, mask, 0xFFu);
567 while (dst < dst_end);
568 }
569
570 /* Draw a vertical line (optimised) */
571 void lcd_vline(int x, int y1, int y2)
572 {
573 int ny;
574 fb_data *dst;
575 unsigned mask, mask_bottom;
576 lcd_blockfunc_type *bfunc;
577
578 /* direction flip */
579 if (y2 < y1)
580 {
581 ny = y1;
582 y1 = y2;
583 y2 = ny;
584 }
585
586 /* nothing to draw? */
587 if (((unsigned)x >= (unsigned)current_vp->width) || (y1 >= current_vp->height)
588 || (y2 < 0))
589 return;
590
591 /* clipping */
592 if (y1 < 0)
593 y1 = 0;
594 if (y2 >= current_vp->height)
595 y2 = current_vp->height-1;
596
597 /* adjust for viewport */
598 y1 += current_vp->y;
599 y2 += current_vp->y;
600 x += current_vp->x;
601
602 bfunc = lcd_blockfuncs[current_vp->drawmode];
603 dst = &lcd_framebuffer[y1>>2][x];
604 ny = y2 - (y1 & ~3);
605 mask = 0xFFu << (2 * (y1 & 3));
606 mask_bottom = 0xFFu >> (2 * (~ny & 3));
607
608 for (; ny >= 4; ny -= 4)
609 {
610 bfunc(dst, mask, 0xFFu);
611 dst += LCD_WIDTH;
612 mask = 0xFFu;
613 }
614 mask &= mask_bottom;
615 bfunc(dst, mask, 0xFFu);
616 }
617
618 /* Draw a rectangular box */
619 void lcd_drawrect(int x, int y, int width, int height)
620 {
621 if ((width <= 0) || (height <= 0))
622 return;
623
624 int x2 = x + width - 1;
625 int y2 = y + height - 1;
626
627 lcd_vline(x, y, y2);
628 lcd_vline(x2, y, y2);
629 lcd_hline(x, x2, y);
630 lcd_hline(x, x2, y2);
631 }
632
633 /* Fill a rectangular area */
634 void lcd_fillrect(int x, int y, int width, int height)
635 {
636 int ny;
637 fb_data *dst, *dst_end;
638 unsigned mask, mask_bottom;
639 unsigned bits = 0;
640 lcd_blockfunc_type *bfunc;
641 bool fillopt = false;
642
643 /* nothing to draw? */
644 if ((width <= 0) || (height <= 0) || (x >= current_vp->width)
645 || (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
646 return;
647
648 /* clipping */
649 if (x < 0)
650 {
651 width += x;
652 x = 0;
653 }
654 if (y < 0)
655 {
656 height += y;
657 y = 0;
658 }
659 if (x + width > current_vp->width)
660 width = current_vp->width - x;
661 if (y + height > current_vp->height)
662 height = current_vp->height - y;
663
664 /* adjust for viewport */
665 x += current_vp->x;
666 y += current_vp->y;
667
668 if (current_vp->drawmode & DRMODE_INVERSEVID)
669 {
670 if ((current_vp->drawmode & DRMODE_BG) && !lcd_backdrop)
671 {
672 fillopt = true;
673 bits = bg_pattern;
674 }
675 }
676 else
677 {
678 if (current_vp->drawmode & DRMODE_FG)
679 {
680 fillopt = true;
681 bits = fg_pattern;
682 }
683 }
684 bfunc = lcd_blockfuncs[current_vp->drawmode];
685 dst = &lcd_framebuffer[y>>2][x];
686 ny = height - 1 + (y & 3);
687 mask = 0xFFu << (2 * (y & 3));
688 mask_bottom = 0xFFu >> (2 * (~ny & 3));
689
690 for (; ny >= 4; ny -= 4)
691 {
692 if (fillopt && (mask == 0xFFu))
693 memset(dst, bits, width);
694 else
695 {
696 fb_data *dst_row = dst;
697
698 dst_end = dst_row + width;
699 do
700 bfunc(dst_row++, mask, 0xFFu);
701 while (dst_row < dst_end);
702 }
703
704 dst += LCD_WIDTH;
705 mask = 0xFFu;
706 }
707 mask &= mask_bottom;
708
709 if (fillopt && (mask == 0xFFu))
710 memset(dst, bits, width);
711 else
712 {
713 dst_end = dst + width;
714 do
715 bfunc(dst++, mask, 0xFFu);
716 while (dst < dst_end);
717 }
718 }
719
720 /* About Rockbox' internal monochrome bitmap format:
721 *
722 * A bitmap contains one bit for every pixel that defines if that pixel is
723 * black (1) or white (0). Bits within a byte are arranged vertically, LSB
724 * at top.
725 * The bytes are stored in row-major order, with byte 0 being top left,
726 * byte 1 2nd from left etc. The first row of bytes defines pixel rows
727 * 0..7, the second row defines pixel row 8..15 etc.
728 *
729 * This is similar to the internal lcd hw format. */
730
731 /* Draw a partial monochrome bitmap */
732 void ICODE_ATTR lcd_mono_bitmap_part(const unsigned char *src, int src_x,
733 int src_y, int stride, int x, int y,
734 int width, int height)
735 {
736 int shift, ny;
737 fb_data *dst, *dst_end;
738 unsigned mask, mask_bottom;
739 lcd_blockfunc_type *bfunc;
740
741 /* nothing to draw? */
742 if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
743 (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
744 return;
745
746 /* clipping */
747 if (x < 0)
748 {
749 width += x;
750 src_x -= x;
751 x = 0;
752 }
753 if (y < 0)
754 {
755 height += y;
756 src_y -= y;
757 y = 0;
758 }
759 if (x + width > current_vp->width)
760 width = current_vp->width - x;
761 if (y + height > current_vp->height)
762 height = current_vp->height - y;
763
764 /* adjust for viewport */
765 x += current_vp->x;
766 y += current_vp->y;
767
768 src += stride * (src_y >> 3) + src_x; /* move starting point */
769 src_y &= 7;
770 y -= src_y;
771 dst = &lcd_framebuffer[y>>2][x];
772 shift = y & 3;
773 ny = height - 1 + shift + src_y;
774
775 bfunc = lcd_blockfuncs[current_vp->drawmode];
776 mask = 0xFFu << (shift + src_y);
777 mask_bottom = 0xFFu >> (~ny & 7);
778
779 if (shift == 0)
780 {
781 unsigned dmask1, dmask2, data;
782
783 for (; ny >= 8; ny -= 8)
784 {
785 const unsigned char *src_row = src;
786 fb_data *dst_row = dst + LCD_WIDTH;
787
788 dmask1 = lcd_dibits[mask&0x0F];
789 dmask2 = lcd_dibits[(mask>>4)&0x0F];
790 dst_end = dst_row + width;
791
792 if (dmask1 != 0)
793 {
794 do
795 {
796 data = *src_row++;
797 bfunc(dst_row - LCD_WIDTH, dmask1, lcd_dibits[data&0x0F]);
798 bfunc(dst_row++, dmask2, lcd_dibits[(data>>4)&0x0F]);
799 }
800 while (dst_row < dst_end);
801 }
802 else
803 {
804 do
805 bfunc(dst_row++, dmask2, lcd_dibits[((*src_row++)>>4)&0x0F]);
806 while (dst_row < dst_end);
807 }
808 src += stride;
809 dst += 2*LCD_WIDTH;
810 mask = 0xFFu;
811 }
812 mask &= mask_bottom;
813 dmask1 = lcd_dibits[mask&0x0F];
814 dmask2 = lcd_dibits[(mask>>4)&0x0F];
815 dst_end = dst + width;
816
817 if (dmask1 != 0)
818 {
819 if (dmask2 != 0)
820 {
821 do
822 {
823 data = *src++;
824 bfunc(dst, dmask1, lcd_dibits[data&0x0F]);
825 bfunc((dst++) + LCD_WIDTH, dmask2, lcd_dibits[(data>>4)&0x0F]);
826 }
827 while (dst < dst_end);
828 }
829 else
830 {
831 do
832 bfunc(dst++, dmask1, lcd_dibits[(*src++)&0x0F]);
833 while (dst < dst_end);
834 }
835 }
836 else
837 {
838 do
839 bfunc((dst++) + LCD_WIDTH, dmask2, lcd_dibits[((*src++)>>4)&0x0F]);
840 while (dst < dst_end);
841 }
842 }
843 else
844 {
845 dst_end = dst + width;
846 do
847 {
848 const unsigned char *src_col = src++;
849 fb_data *dst_col = dst++;
850 unsigned mask_col = mask;
851 unsigned data = 0;
852
853 for (y = ny; y >= 8; y -= 8)
854 {
855 data |= *src_col << shift;
856
857 if (mask_col & 0xFFu)
858 {
859 if (mask_col & 0x0F)
860 bfunc(dst_col, lcd_dibits[mask_col&0x0F], lcd_dibits[data&0x0F]);
861 bfunc(dst_col + LCD_WIDTH, lcd_dibits[(mask_col>>4)&0x0F],
862 lcd_dibits[(data>>4)&0x0F]);
863 mask_col = 0xFFu;
864 }
865 else
866 mask_col >>= 8;
867
868 src_col += stride;
869 dst_col += 2*LCD_WIDTH;
870 data >>= 8;
871 }
872 data |= *src_col << shift;
873 mask_bottom &= mask_col;
874 if (mask_bottom & 0x0F)
875 bfunc(dst_col, lcd_dibits[mask_bottom&0x0F], lcd_dibits[data&0x0F]);
876 if (mask_bottom & 0xF0)
877 bfunc(dst_col + LCD_WIDTH, lcd_dibits[(mask_bottom&0xF0)>>4],
878 lcd_dibits[(data>>4)&0x0F]);
879 }
880 while (dst < dst_end);
881 }
882 }
883
884 /* Draw a full monochrome bitmap */
885 void lcd_mono_bitmap(const unsigned char *src, int x, int y, int width, int height)
886 {
887 lcd_mono_bitmap_part(src, 0, 0, width, x, y, width, height);
888 }
889
890 /* About Rockbox' internal native bitmap format:
891 *
892 * A bitmap contains two bits for every pixel. 00 = white, 01 = light grey,
893 * 10 = dark grey, 11 = black. Bits within a byte are arranged vertically, LSB
894 * at top.
895 * The bytes are stored in row-major order, with byte 0 being top left,
896 * byte 1 2nd from left etc. The first row of bytes defines pixel rows
897 * 0..3, the second row defines pixel row 4..7 etc.
898 *
899 * This is the same as the internal lcd hw format. */
900
901 /* Draw a partial native bitmap */
902 void ICODE_ATTR lcd_bitmap_part(const fb_data *src, int src_x, int src_y,
903 int stride, int x, int y, int width,
904 int height)
905 {
906 int shift, ny;
907 fb_data *dst, *dst_end;
908 unsigned mask, mask_bottom;
909
910 /* nothing to draw? */
911 if ((width <= 0) || (height <= 0) || (x >= current_vp->width)
912 || (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
913 return;
914
915 /* clipping */
916 if (x < 0)
917 {
918 width += x;
919 src_x -= x;
920 x = 0;
921 }
922 if (y < 0)
923 {
924 height += y;
925 src_y -= y;
926 y = 0;
927 }
928 if (x + width > current_vp->width)
929 width = current_vp->width - x;
930 if (y + height > current_vp->height)
931 height = current_vp->height - y;
932
933 /* adjust for viewport */
934 x += current_vp->x;
935 y += current_vp->y;
936
937 src += stride * (src_y >> 2) + src_x; /* move starting point */
938 src_y &= 3;
939 y -= src_y;
940 dst = &lcd_framebuffer[y>>2][x];
941 shift = y & 3;
942 ny = height - 1 + shift + src_y;
943
944 mask = 0xFFu << (2 * (shift + src_y));
945 mask_bottom = 0xFFu >> (2 * (~ny & 3));
946
947 if (shift == 0)
948 {
949 for (; ny >= 4; ny -= 4)
950 {
951 if (mask == 0xFFu)
952 memcpy(dst, src, width);
953 else
954 {
955 const fb_data *src_row = src;
956 fb_data *dst_row = dst;
957
958 dst_end = dst_row + width;
959 do
960 setblock(dst_row++, mask, *src_row++);
961 while (dst_row < dst_end);
962 }
963 src += stride;
964 dst += LCD_WIDTH;
965 mask = 0xFFu;
966 }
967 mask &= mask_bottom;
968
969 if (mask == 0xFFu)
970 memcpy(dst, src, width);
971 else
972 {
973 dst_end = dst + width;
974 do
975 setblock(dst++, mask, *src++);
976 while (dst < dst_end);
977 }
978 }
979 else
980 {
981 shift *= 2;
982 dst_end = dst + width;
983 do
984 {
985 const fb_data *src_col = src++;
986 fb_data *dst_col = dst++;
987 unsigned mask_col = mask;
988 unsigned data = 0;
989
990 for (y = ny; y >= 4; y -= 4)
991 {
992 data |= *src_col << shift;
993
994 if (mask_col & 0xFFu)
995 {
996 setblock(dst_col, mask_col, data);
997 mask_col = 0xFFu;
998 }
999 else
1000 mask_col >>= 8;
1001
1002 src_col += stride;
1003 dst_col += LCD_WIDTH;
1004 data >>= 8;
1005 }
1006 data |= *src_col << shift;
1007 setblock(dst_col, mask_col & mask_bottom, data);
1008 }
1009 while (dst < dst_end);
1010 }
1011 }
1012
1013 /* Draw a full native bitmap */
1014 void lcd_bitmap(const fb_data *src, int x, int y, int width, int height)
1015 {
1016 lcd_bitmap_part(src, 0, 0, width, x, y, width, height);
1017 }
1018
1019 /* put a string at a given pixel position, skipping first ofs pixel columns */
1020 static void lcd_putsxyofs(int x, int y, int ofs, const unsigned char *str)
1021 {
1022 unsigned short ch;
1023 unsigned short *ucs;
1024 struct font* pf = font_get(current_vp->font);
1025
1026 ucs = bidi_l2v(str, 1);
1027
1028 while ((ch = *ucs++) != 0 && x < current_vp->width)
1029 {
1030 int width;
1031 const unsigned char *bits;
1032
1033 /* get proportional width and glyph bits */
1034 width = font_get_width(pf,ch);
1035
1036 if (ofs > width)
1037 {
1038 ofs -= width;
1039 continue;
1040 }
1041
1042 bits = font_get_bits(pf, ch);
1043
1044 lcd_mono_bitmap_part(bits, ofs, 0, width, x, y, width - ofs,
1045 pf->height);
1046
1047 x += width - ofs;
1048 ofs = 0;
1049 }
1050 }
1051
1052 /* put a string at a given pixel position */
1053 void lcd_putsxy(int x, int y, const unsigned char *str)
1054 {
1055 lcd_putsxyofs(x, y, 0, str);
1056 }
1057
1058 /*** line oriented text output ***/
1059
1060 /* put a string at a given char position */
1061 void lcd_puts(int x, int y, const unsigned char *str)
1062 {
1063 lcd_puts_style_offset(x, y, str, STYLE_DEFAULT, 0);
1064 }
1065
1066 void lcd_puts_style(int x, int y, const unsigned char *str, int style)
1067 {
1068 lcd_puts_style_offset(x, y, str, style, 0);
1069 }
1070
1071 void lcd_puts_offset(int x, int y, const unsigned char *str, int offset)
1072 {
1073 lcd_puts_style_offset(x, y, str, STYLE_DEFAULT, offset);
1074 }
1075
1076 /* put a string at a given char position, style, and pixel position,
1077 * skipping first offset pixel columns */
1078 void lcd_puts_style_offset(int x, int y, const unsigned char *str,
1079 int style, int offset)
1080 {
1081 int xpos,ypos,w,h,xrect;
1082 int lastmode = current_vp->drawmode;
1083
1084 /* make sure scrolling is turned off on the line we are updating */
1085 lcd_scroll_stop_line(current_vp, y);
1086
1087 if(!str || !str[0])
1088 return;
1089
1090 lcd_getstringsize(str, &w, &h);
1091 xpos = current_vp->xmargin + x*w / utf8length((char *)str);
1092 ypos = current_vp->ymargin + y*h;
1093 current_vp->drawmode = (style & STYLE_INVERT) ?
1094 (DRMODE_SOLID|DRMODE_INVERSEVID) : DRMODE_SOLID;
1095 lcd_putsxyofs(xpos, ypos, offset, str);
1096 current_vp->drawmode ^= DRMODE_INVERSEVID;
1097 xrect = xpos + MAX(w - offset, 0);
1098 lcd_fillrect(xrect, ypos, current_vp->width - xrect, h);
1099 current_vp->drawmode = lastmode;
1100 }
1101
1102 /*** scrolling ***/
1103
1104 void lcd_puts_scroll(int x, int y, const unsigned char *string)
1105 {
1106 lcd_puts_scroll_style(x, y, string, STYLE_DEFAULT);
1107 }
1108
1109 void lcd_puts_scroll_style(int x, int y, const unsigned char *string, int style)
1110 {
1111 lcd_puts_scroll_style_offset(x, y, string, style, 0);
1112 }
1113
1114 void lcd_puts_scroll_offset(int x, int y, const unsigned char *string, int offset)
1115 {
1116 lcd_puts_scroll_style_offset(x, y, string, STYLE_DEFAULT, offset);
1117 }
1118
1119 void lcd_puts_scroll_style_offset(int x, int y, const unsigned char *string,
1120 int style, int offset)
1121 {
1122 struct scrollinfo* s;
1123 int w, h;
1124
1125 if ((unsigned)y >= (unsigned)current_vp->height)
1126 return;
1127
1128 /* remove any previously scrolling line at the same location */
1129 lcd_scroll_stop_line(current_vp, y);
1130
1131 if (lcd_scroll_info.lines >= LCD_SCROLLABLE_LINES) return;
1132
1133 s = &lcd_scroll_info.scroll[lcd_scroll_info.lines];
1134
1135 s->start_tick = current_tick + lcd_scroll_info.delay;
1136 s->style = style;
1137 if (style & STYLE_INVERT) {
1138 lcd_puts_style_offset(x,y,string,STYLE_INVERT,offset);
1139 }
1140 else
1141 lcd_puts_offset(x,y,string,offset);
1142
1143 lcd_getstringsize(string, &w, &h);
1144
1145 if (current_vp->width - x * 8 - current_vp->xmargin < w) {
1146 /* prepare scroll line */
1147 char *end;
1148
1149 memset(s->line, 0, sizeof s->line);
1150 strcpy(s->line, (char *)string);
1151
1152 /* get width */
1153 s->width = lcd_getstringsize((unsigned char *)s->line, &w, &h);
1154
1155 /* scroll bidirectional or forward only depending on the string
1156 width */
1157 if ( lcd_scroll_info.bidir_limit ) {
1158 s->bidir = s->width < (current_vp->width - current_vp->xmargin) *
1159 (100 + lcd_scroll_info.bidir_limit) / 100;
1160 }
1161 else
1162 s->bidir = false;
1163
1164 if (!s->bidir) { /* add spaces if scrolling in the round */
1165 strcat(s->line, " ");
1166 /* get new width incl. spaces */
1167 s->width = lcd_getstringsize((unsigned char *)s->line, &w, &h);
1168 }
1169
1170 end = strchr(s->line, '\0');
1171 strncpy(end, (char *)string, current_vp->width/2);
1172
1173 s->vp = current_vp;
1174 s->y = y;
1175 s->len = utf8length((char *)string);
1176 s->offset = offset;
1177 s->startx = current_vp->xmargin + x * s->width / s->len;
1178 s->backward = false;
1179
1180 lcd_scroll_info.lines++;
1181 }
1182 }
1183
1184 void lcd_scroll_fn(void)
1185 {
1186 struct font* pf;
1187 struct scrollinfo* s;
1188 int index;
1189 int xpos, ypos;
1190 int lastmode;
1191 struct viewport* old_vp = current_vp;
1192
1193 for ( index = 0; index < lcd_scroll_info.lines; index++ ) {
1194 s = &lcd_scroll_info.scroll[index];
1195
1196 /* check pause */
1197 if (TIME_BEFORE(current_tick, s->start_tick))
1198 continue;
1199
1200 lcd_set_viewport(s->vp);
1201
1202 if (s->backward)
1203 s->offset -= lcd_scroll_info.step;
1204 else
1205 s->offset += lcd_scroll_info.step;
1206
1207 pf = font_get(current_vp->font);
1208 xpos = s->startx;
1209 ypos = current_vp->ymargin + s->y * pf->height;
1210
1211 if (s->bidir) { /* scroll bidirectional */
1212 if (s->offset <= 0) {
1213 /* at beginning of line */
1214 s->offset = 0;
1215 s->backward = false;
1216 s->start_tick = current_tick + lcd_scroll_info.delay * 2;
1217 }
1218 if (s->offset >= s->width - (current_vp->width - xpos)) {
1219 /* at end of line */
1220 s->offset = s->width - (current_vp->width - xpos);
1221 s->backward = true;
1222 s->start_tick = current_tick + lcd_scroll_info.delay * 2;
1223 }
1224 }
1225 else {
1226 /* scroll forward the whole time */
1227 if (s->offset >= s->width)
1228 s->offset %= s->width;
1229 }
1230
1231 lastmode = current_vp->drawmode;
1232 current_vp->drawmode = (s->style&STYLE_INVERT) ?
1233 (DRMODE_SOLID|DRMODE_INVERSEVID) : DRMODE_SOLID;
1234 lcd_putsxyofs(xpos, ypos, s->offset, s->line);
1235 current_vp->drawmode = lastmode;
1236 lcd_update_viewport_rect(xpos, ypos,
1237 current_vp->width - xpos, pf->height);
1238 }
1239
1240 lcd_set_viewport(old_vp);
1241 }
Open Source Jukebox Firmware