?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Trim down peak calculation a bit.
[kugel-rb.git] / firmware / drivers / lcd-16bit.c
blobf8b4272f7c17e7669e83db589cbfe898fbdd1573
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (C) 2005 by Dave Chapman
11 *
12 * Rockbox driver for 16-bit colour LCDs
13 *
14 * This program is free software; you can redistribute it and/or
15 * modify it under the terms of the GNU General Public License
16 * as published by the Free Software Foundation; either version 2
17 * of the License, or (at your option) any later version.
18 *
19 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
20 * KIND, either express or implied.
21 *
22 ****************************************************************************/
23 #include "config.h"
24
25 #include "cpu.h"
26 #include "lcd.h"
27 #include "kernel.h"
28 #include "thread.h"
29 #include <string.h>
30 #include <stdlib.h>
31 #include "memory.h"
32 #include "file.h"
33 #include "debug.h"
34 #include "system.h"
35 #include "font.h"
36 #include "rbunicode.h"
37 #include "bidi.h"
38 #include "scroll_engine.h"
39
40 enum fill_opt {
41 OPT_NONE = 0,
42 OPT_SET,
43 OPT_COPY
44 };
45
46 /*** globals ***/
47 fb_data lcd_framebuffer[LCD_FBHEIGHT][LCD_FBWIDTH]
48 IRAM_LCDFRAMEBUFFER CACHEALIGN_AT_LEAST_ATTR(16);
49
50
51 static fb_data* lcd_backdrop = NULL;
52 static long lcd_backdrop_offset IDATA_ATTR = 0;
53
54 static struct viewport default_vp =
55 {
56 .x = 0,
57 .y = 0,
58 .width = LCD_WIDTH,
59 .height = LCD_HEIGHT,
60 .font = FONT_SYSFIXED,
61 .drawmode = DRMODE_SOLID,
62 .fg_pattern = LCD_DEFAULT_FG,
63 .bg_pattern = LCD_DEFAULT_BG,
64 .lss_pattern = LCD_DEFAULT_BG,
65 .lse_pattern = LCD_DEFAULT_BG,
66 .lst_pattern = LCD_DEFAULT_BG,
67 };
68
69 static struct viewport* current_vp IDATA_ATTR = &default_vp;
70
71 /* LCD init */
72 void lcd_init(void)
73 {
74 lcd_clear_display();
75
76 /* Call device specific init */
77 lcd_init_device();
78 scroll_init();
79 }
80 /*** Viewports ***/
81
82 void lcd_set_viewport(struct viewport* vp)
83 {
84 if (vp == NULL)
85 current_vp = &default_vp;
86 else
87 current_vp = vp;
88
89 #if defined(SIMULATOR)
90 /* Force the viewport to be within bounds. If this happens it should
91 * be considered an error - the viewport will not draw as it might be
92 * expected.
93 */
94 if((unsigned) current_vp->x > (unsigned) LCD_WIDTH
95 || (unsigned) current_vp->y > (unsigned) LCD_HEIGHT
96 || current_vp->x + current_vp->width > LCD_WIDTH
97 || current_vp->y + current_vp->height > LCD_HEIGHT)
98 {
99 #if !defined(HAVE_VIEWPORT_CLIP)
100 DEBUGF("ERROR: "
101 #else
102 DEBUGF("NOTE: "
103 #endif
104 "set_viewport out of bounds: x: %d y: %d width: %d height:%d\n",
105 current_vp->x, current_vp->y,
106 current_vp->width, current_vp->height);
107 }
108
109 #endif
110 }
111
112 void lcd_update_viewport(void)
113 {
114 lcd_update_rect(current_vp->x, current_vp->y,
115 current_vp->width, current_vp->height);
116 }
117
118 void lcd_update_viewport_rect(int x, int y, int width, int height)
119 {
120 lcd_update_rect(current_vp->x + x, current_vp->y + y, width, height);
121 }
122
123 /*** parameter handling ***/
124
125 void lcd_set_drawmode(int mode)
126 {
127 current_vp->drawmode = mode & (DRMODE_SOLID|DRMODE_INVERSEVID);
128 }
129
130 int lcd_get_drawmode(void)
131 {
132 return current_vp->drawmode;
133 }
134
135 void lcd_set_foreground(unsigned color)
136 {
137 current_vp->fg_pattern = color;
138 }
139
140 unsigned lcd_get_foreground(void)
141 {
142 return current_vp->fg_pattern;
143 }
144
145 void lcd_set_background(unsigned color)
146 {
147 current_vp->bg_pattern = color;
148 }
149
150 unsigned lcd_get_background(void)
151 {
152 return current_vp->bg_pattern;
153 }
154
155 void lcd_set_selector_start(unsigned color)
156 {
157 current_vp->lss_pattern = color;
158 }
159
160 void lcd_set_selector_end(unsigned color)
161 {
162 current_vp->lse_pattern = color;
163 }
164
165 void lcd_set_selector_text(unsigned color)
166 {
167 current_vp->lst_pattern = color;
168 }
169
170 void lcd_set_drawinfo(int mode, unsigned fg_color, unsigned bg_color)
171 {
172 lcd_set_drawmode(mode);
173 current_vp->fg_pattern = fg_color;
174 current_vp->bg_pattern = bg_color;
175 }
176
177 int lcd_getwidth(void)
178 {
179 return current_vp->width;
180 }
181
182 int lcd_getheight(void)
183 {
184 return current_vp->height;
185 }
186
187 void lcd_setfont(int newfont)
188 {
189 current_vp->font = newfont;
190 }
191
192 int lcd_getfont(void)
193 {
194 return current_vp->font;
195 }
196
197 int lcd_getstringsize(const unsigned char *str, int *w, int *h)
198 {
199 return font_getstringsize(str, w, h, current_vp->font);
200 }
201
202 /*** low-level drawing functions ***/
203
204 #define LCDADDR(x, y) (&lcd_framebuffer[(y)][(x)])
205
206 static void ICODE_ATTR setpixel(fb_data *address)
207 {
208 *address = current_vp->fg_pattern;
209 }
210
211 static void ICODE_ATTR clearpixel(fb_data *address)
212 {
213 *address = current_vp->bg_pattern;
214 }
215
216 static void ICODE_ATTR clearimgpixel(fb_data *address)
217 {
218 *address = *(fb_data *)((long)address + lcd_backdrop_offset);
219 }
220
221 static void ICODE_ATTR flippixel(fb_data *address)
222 {
223 *address = ~(*address);
224 }
225
226 static void ICODE_ATTR nopixel(fb_data *address)
227 {
228 (void)address;
229 }
230
231 lcd_fastpixelfunc_type* const lcd_fastpixelfuncs_bgcolor[8] = {
232 flippixel, nopixel, setpixel, setpixel,
233 nopixel, clearpixel, nopixel, clearpixel
234 };
235
236 lcd_fastpixelfunc_type* const lcd_fastpixelfuncs_backdrop[8] = {
237 flippixel, nopixel, setpixel, setpixel,
238 nopixel, clearimgpixel, nopixel, clearimgpixel
239 };
240
241 lcd_fastpixelfunc_type* const * lcd_fastpixelfuncs = lcd_fastpixelfuncs_bgcolor;
242
243 void lcd_set_backdrop(fb_data* backdrop)
244 {
245 lcd_backdrop = backdrop;
246 if (backdrop)
247 {
248 lcd_backdrop_offset = (long)backdrop - (long)&lcd_framebuffer[0][0];
249 lcd_fastpixelfuncs = lcd_fastpixelfuncs_backdrop;
250 }
251 else
252 {
253 lcd_backdrop_offset = 0;
254 lcd_fastpixelfuncs = lcd_fastpixelfuncs_bgcolor;
255 }
256 }
257
258 fb_data* lcd_get_backdrop(void)
259 {
260 return lcd_backdrop;
261 }
262
263 /*** drawing functions ***/
264
265 /* Clear the current viewport */
266 void lcd_clear_viewport(void)
267 {
268 fb_data *dst, *dst_end;
269
270 dst = LCDADDR(current_vp->x, current_vp->y);
271 dst_end = dst + current_vp->height * LCD_WIDTH;
272
273 if (current_vp->drawmode & DRMODE_INVERSEVID)
274 {
275 do
276 {
277 memset16(dst, current_vp->fg_pattern, current_vp->width);
278 dst += LCD_WIDTH;
279 }
280 while (dst < dst_end);
281 }
282 else
283 {
284 if (!lcd_backdrop)
285 {
286 do
287 {
288 memset16(dst, current_vp->bg_pattern, current_vp->width);
289 dst += LCD_WIDTH;
290 }
291 while (dst < dst_end);
292 }
293 else
294 {
295 do
296 {
297 memcpy(dst, (void *)((long)dst + lcd_backdrop_offset),
298 current_vp->width * sizeof(fb_data));
299 dst += LCD_WIDTH;
300 }
301 while (dst < dst_end);
302 }
303 }
304
305 if (current_vp == &default_vp)
306 {
307 lcd_scroll_info.lines = 0;
308 }
309 else
310 {
311 lcd_scroll_stop(current_vp);
312 }
313 }
314
315 /* Clear the whole display */
316 void lcd_clear_display(void)
317 {
318 struct viewport* old_vp = current_vp;
319
320 current_vp = &default_vp;
321
322 lcd_clear_viewport();
323
324 current_vp = old_vp;
325 }
326
327 /* Set a single pixel */
328 void lcd_drawpixel(int x, int y)
329 {
330 if ( ((unsigned)x < (unsigned)current_vp->width)
331 && ((unsigned)y < (unsigned)current_vp->height)
332 #if defined(HAVE_VIEWPORT_CLIP)
333 && ((unsigned)x < (unsigned)LCD_WIDTH)
334 && ((unsigned)y < (unsigned)LCD_HEIGHT)
335 #endif
336 )
337 lcd_fastpixelfuncs[current_vp->drawmode](LCDADDR(current_vp->x+x, current_vp->y+y));
338 }
339
340 /* Draw a line */
341 void lcd_drawline(int x1, int y1, int x2, int y2)
342 {
343 int numpixels;
344 int i;
345 int deltax, deltay;
346 int d, dinc1, dinc2;
347 int x, xinc1, xinc2;
348 int y, yinc1, yinc2;
349 lcd_fastpixelfunc_type *pfunc = lcd_fastpixelfuncs[current_vp->drawmode];
350
351 deltay = abs(y2 - y1);
352 if (deltay == 0)
353 {
354 /* DEBUGF("lcd_drawline() called for horizontal line - optimisation.\n"); */
355 lcd_hline(x1, x2, y1);
356 return;
357 }
358 deltax = abs(x2 - x1);
359 if (deltax == 0)
360 {
361 /* DEBUGF("lcd_drawline() called for vertical line - optimisation.\n"); */
362 lcd_vline(x1, y1, y2);
363 return;
364 }
365 xinc2 = 1;
366 yinc2 = 1;
367
368 if (deltax >= deltay)
369 {
370 numpixels = deltax;
371 d = 2 * deltay - deltax;
372 dinc1 = deltay * 2;
373 dinc2 = (deltay - deltax) * 2;
374 xinc1 = 1;
375 yinc1 = 0;
376 }
377 else
378 {
379 numpixels = deltay;
380 d = 2 * deltax - deltay;
381 dinc1 = deltax * 2;
382 dinc2 = (deltax - deltay) * 2;
383 xinc1 = 0;
384 yinc1 = 1;
385 }
386 numpixels++; /* include endpoints */
387
388 if (x1 > x2)
389 {
390 xinc1 = -xinc1;
391 xinc2 = -xinc2;
392 }
393
394 if (y1 > y2)
395 {
396 yinc1 = -yinc1;
397 yinc2 = -yinc2;
398 }
399
400 x = x1;
401 y = y1;
402
403 for (i = 0; i < numpixels; i++)
404 {
405 if ( ((unsigned)x < (unsigned)current_vp->width)
406 && ((unsigned)y < (unsigned)current_vp->height)
407 #if defined(HAVE_VIEWPORT_CLIP)
408 && ((unsigned)x < (unsigned)LCD_WIDTH)
409 && ((unsigned)y < (unsigned)LCD_HEIGHT)
410 #endif
411 )
412 pfunc(LCDADDR(x + current_vp->x, y + current_vp->y));
413
414 if (d < 0)
415 {
416 d += dinc1;
417 x += xinc1;
418 y += yinc1;
419 }
420 else
421 {
422 d += dinc2;
423 x += xinc2;
424 y += yinc2;
425 }
426 }
427 }
428
429 /* Draw a horizontal line (optimised) */
430 void lcd_hline(int x1, int x2, int y)
431 {
432 int x, width;
433 unsigned bits = 0;
434 enum fill_opt fillopt = OPT_NONE;
435 fb_data *dst, *dst_end;
436
437 /* direction flip */
438 if (x2 < x1)
439 {
440 x = x1;
441 x1 = x2;
442 x2 = x;
443 }
444
445 /******************** In viewport clipping **********************/
446 /* nothing to draw? */
447 if (((unsigned)y >= (unsigned)current_vp->height) ||
448 (x1 >= current_vp->width) ||
449 (x2 < 0))
450 return;
451
452 if (x1 < 0)
453 x1 = 0;
454 if (x2 >= current_vp->width)
455 x2 = current_vp->width-1;
456
457 /* Adjust x1 and y to viewport */
458 x1 += current_vp->x;
459 x2 += current_vp->x;
460 y += current_vp->y;
461
462 #if defined(HAVE_VIEWPORT_CLIP)
463 /********************* Viewport on screen clipping ********************/
464 /* nothing to draw? */
465 if (((unsigned)y >= (unsigned) LCD_HEIGHT) || (x1 >= LCD_WIDTH)
466 || (x2 < 0))
467 return;
468
469 /* clipping */
470 if (x1 < 0)
471 x1 = 0;
472 if (x2 >= LCD_WIDTH)
473 x2 = LCD_WIDTH-1;
474 #endif
475
476 width = x2 - x1 + 1;
477
478 /* drawmode and optimisation */
479 if (current_vp->drawmode & DRMODE_INVERSEVID)
480 {
481 if (current_vp->drawmode & DRMODE_BG)
482 {
483 if (!lcd_backdrop)
484 {
485 fillopt = OPT_SET;
486 bits = current_vp->bg_pattern;
487 }
488 else
489 fillopt = OPT_COPY;
490 }
491 }
492 else
493 {
494 if (current_vp->drawmode & DRMODE_FG)
495 {
496 fillopt = OPT_SET;
497 bits = current_vp->fg_pattern;
498 }
499 }
500 if (fillopt == OPT_NONE && current_vp->drawmode != DRMODE_COMPLEMENT)
501 return;
502
503 dst = LCDADDR(x1, y);
504
505 switch (fillopt)
506 {
507 case OPT_SET:
508 memset16(dst, bits, width);
509 break;
510
511 case OPT_COPY:
512 memcpy(dst, (void *)((long)dst + lcd_backdrop_offset),
513 width * sizeof(fb_data));
514 break;
515
516 case OPT_NONE: /* DRMODE_COMPLEMENT */
517 dst_end = dst + width;
518 do
519 *dst = ~(*dst);
520 while (++dst < dst_end);
521 break;
522 }
523 }
524
525 /* Draw a vertical line (optimised) */
526 void lcd_vline(int x, int y1, int y2)
527 {
528 int y;
529 fb_data *dst, *dst_end;
530 lcd_fastpixelfunc_type *pfunc = lcd_fastpixelfuncs[current_vp->drawmode];
531
532 /* direction flip */
533 if (y2 < y1)
534 {
535 y = y1;
536 y1 = y2;
537 y2 = y;
538 }
539
540 /******************** In viewport clipping **********************/
541 /* nothing to draw? */
542 if (((unsigned)x >= (unsigned)current_vp->width) ||
543 (y1 >= current_vp->height) ||
544 (y2 < 0))
545 return;
546
547 if (y1 < 0)
548 y1 = 0;
549 if (y2 >= current_vp->height)
550 y2 = current_vp->height-1;
551
552 /* adjust for viewport */
553 x += current_vp->x;
554 y1 += current_vp->y;
555 y2 += current_vp->y;
556
557 #if defined(HAVE_VIEWPORT_CLIP)
558 /********************* Viewport on screen clipping ********************/
559 /* nothing to draw? */
560 if (( (unsigned) x >= (unsigned)LCD_WIDTH) || (y1 >= LCD_HEIGHT)
561 || (y2 < 0))
562 return;
563
564 /* clipping */
565 if (y1 < 0)
566 y1 = 0;
567 if (y2 >= LCD_HEIGHT)
568 y2 = LCD_HEIGHT-1;
569 #endif
570
571 dst = LCDADDR(x , y1);
572 dst_end = dst + (y2 - y1) * LCD_WIDTH;
573
574 do
575 {
576 pfunc(dst);
577 dst += LCD_WIDTH;
578 }
579 while (dst <= dst_end);
580 }
581
582 /* Draw a rectangular box */
583 void lcd_drawrect(int x, int y, int width, int height)
584 {
585 if ((width <= 0) || (height <= 0))
586 return;
587
588 int x2 = x + width - 1;
589 int y2 = y + height - 1;
590
591 lcd_vline(x, y, y2);
592 lcd_vline(x2, y, y2);
593 lcd_hline(x, x2, y);
594 lcd_hline(x, x2, y2);
595 }
596
597 /* Fill a rectangular area */
598 void lcd_fillrect(int x, int y, int width, int height)
599 {
600 unsigned bits = 0;
601 enum fill_opt fillopt = OPT_NONE;
602 fb_data *dst, *dst_end;
603
604 /******************** In viewport clipping **********************/
605 /* nothing to draw? */
606 if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
607 (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
608 return;
609
610 if (x < 0)
611 {
612 width += x;
613 x = 0;
614 }
615 if (y < 0)
616 {
617 height += y;
618 y = 0;
619 }
620 if (x + width > current_vp->width)
621 width = current_vp->width - x;
622 if (y + height > current_vp->height)
623 height = current_vp->height - y;
624
625 /* adjust for viewport */
626 x += current_vp->x;
627 y += current_vp->y;
628
629 #if defined(HAVE_VIEWPORT_CLIP)
630 /********************* Viewport on screen clipping ********************/
631 /* nothing to draw? */
632 if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT)
633 || (x + width <= 0) || (y + height <= 0))
634 return;
635
636 /* clip image in viewport in screen */
637 if (x < 0)
638 {
639 width += x;
640 x = 0;
641 }
642 if (y < 0)
643 {
644 height += y;
645 y = 0;
646 }
647 if (x + width > LCD_WIDTH)
648 width = LCD_WIDTH - x;
649 if (y + height > LCD_HEIGHT)
650 height = LCD_HEIGHT - y;
651 #endif
652
653 /* drawmode and optimisation */
654 if (current_vp->drawmode & DRMODE_INVERSEVID)
655 {
656 if (current_vp->drawmode & DRMODE_BG)
657 {
658 if (!lcd_backdrop)
659 {
660 fillopt = OPT_SET;
661 bits = current_vp->bg_pattern;
662 }
663 else
664 fillopt = OPT_COPY;
665 }
666 }
667 else
668 {
669 if (current_vp->drawmode & DRMODE_FG)
670 {
671 fillopt = OPT_SET;
672 bits = current_vp->fg_pattern;
673 }
674 }
675 if (fillopt == OPT_NONE && current_vp->drawmode != DRMODE_COMPLEMENT)
676 return;
677
678 dst = LCDADDR(x, y);
679 dst_end = dst + height * LCD_WIDTH;
680
681 do
682 {
683 fb_data *dst_row, *row_end;
684
685 switch (fillopt)
686 {
687 case OPT_SET:
688 memset16(dst, bits, width);
689 break;
690
691 case OPT_COPY:
692 memcpy(dst, (void *)((long)dst + lcd_backdrop_offset),
693 width * sizeof(fb_data));
694 break;
695
696 case OPT_NONE: /* DRMODE_COMPLEMENT */
697 dst_row = dst;
698 row_end = dst_row + width;
699 do
700 *dst_row = ~(*dst_row);
701 while (++dst_row < row_end);
702 break;
703 }
704 dst += LCD_WIDTH;
705 }
706 while (dst < dst_end);
707 }
708
709 /* About Rockbox' internal monochrome bitmap format:
710 *
711 * A bitmap contains one bit for every pixel that defines if that pixel is
712 * black (1) or white (0). Bits within a byte are arranged vertically, LSB
713 * at top.
714 * The bytes are stored in row-major order, with byte 0 being top left,
715 * byte 1 2nd from left etc. The first row of bytes defines pixel rows
716 * 0..7, the second row defines pixel row 8..15 etc.
717 *
718 * This is the mono bitmap format used on all other targets so far; the
719 * pixel packing doesn't really matter on a 8bit+ target. */
720
721 /* Draw a partial monochrome bitmap */
722
723 void ICODE_ATTR lcd_mono_bitmap_part(const unsigned char *src, int src_x,
724 int src_y, int stride, int x, int y,
725 int width, int height)
726 {
727 const unsigned char *src_end;
728 fb_data *dst, *dst_end;
729 unsigned dmask = 0x100; /* bit 8 == sentinel */
730 int drmode = current_vp->drawmode;
731
732 /******************** Image in viewport clipping **********************/
733 /* nothing to draw? */
734 if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
735 (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
736 return;
737
738 if (x < 0)
739 {
740 width += x;
741 src_x -= x;
742 x = 0;
743 }
744 if (y < 0)
745 {
746 height += y;
747 src_y -= y;
748 y = 0;
749 }
750 if (x + width > current_vp->width)
751 width = current_vp->width - x;
752 if (y + height > current_vp->height)
753 height = current_vp->height - y;
754
755 /* adjust for viewport */
756 x += current_vp->x;
757 y += current_vp->y;
758
759 #if defined(HAVE_VIEWPORT_CLIP)
760 /********************* Viewport on screen clipping ********************/
761 /* nothing to draw? */
762 if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT)
763 || (x + width <= 0) || (y + height <= 0))
764 return;
765
766 /* clip image in viewport in screen */
767 if (x < 0)
768 {
769 width += x;
770 src_x -= x;
771 x = 0;
772 }
773 if (y < 0)
774 {
775 height += y;
776 src_y -= y;
777 y = 0;
778 }
779 if (x + width > LCD_WIDTH)
780 width = LCD_WIDTH - x;
781 if (y + height > LCD_HEIGHT)
782 height = LCD_HEIGHT - y;
783 #endif
784
785 src += stride * (src_y >> 3) + src_x; /* move starting point */
786 src_y &= 7;
787 src_end = src + width;
788 dst = LCDADDR(x, y);
789 dst_end = dst + height * LCD_WIDTH;
790
791 if (drmode & DRMODE_INVERSEVID)
792 {
793 dmask = 0x1ff; /* bit 8 == sentinel */
794 drmode &= DRMODE_SOLID; /* mask out inversevid */
795 }
796
797 do
798 {
799 const unsigned char *src_col = src++;
800 unsigned data = (*src_col ^ dmask) >> src_y;
801 fb_data *dst_col = dst++;
802 int fg, bg;
803 long bo;
804
805 #define UPDATE_SRC do { \
806 data >>= 1; \
807 if (data == 0x001) { \
808 src_col += stride; \
809 data = *src_col ^ dmask; \
810 } \
811 } while (0)
812
813 switch (drmode)
814 {
815 case DRMODE_COMPLEMENT:
816 do
817 {
818 if (data & 0x01)
819 *dst_col = ~(*dst_col);
820
821 dst_col += LCD_WIDTH;
822 UPDATE_SRC;
823 }
824 while (dst_col < dst_end);
825 break;
826
827 case DRMODE_BG:
828 if (lcd_backdrop)
829 {
830 bo = lcd_backdrop_offset;
831 do
832 {
833 if (!(data & 0x01))
834 *dst_col = *(fb_data *)((long)dst_col + bo);
835
836 dst_col += LCD_WIDTH;
837 UPDATE_SRC;
838 }
839 while (dst_col < dst_end);
840 }
841 else
842 {
843 bg = current_vp->bg_pattern;
844 do
845 {
846 if (!(data & 0x01))
847 *dst_col = bg;
848
849 dst_col += LCD_WIDTH;
850 UPDATE_SRC;
851 }
852 while (dst_col < dst_end);
853 }
854 break;
855
856 case DRMODE_FG:
857 fg = current_vp->fg_pattern;
858 do
859 {
860 if (data & 0x01)
861 *dst_col = fg;
862
863 dst_col += LCD_WIDTH;
864 UPDATE_SRC;
865 }
866 while (dst_col < dst_end);
867 break;
868
869 case DRMODE_SOLID:
870 fg = current_vp->fg_pattern;
871 if (lcd_backdrop)
872 {
873 bo = lcd_backdrop_offset;
874 do
875 {
876 *dst_col = (data & 0x01) ? fg
877 : *(fb_data *)((long)dst_col + bo);
878 dst_col += LCD_WIDTH;
879 UPDATE_SRC;
880 }
881 while (dst_col < dst_end);
882 }
883 else
884 {
885 bg = current_vp->bg_pattern;
886 do
887 {
888 *dst_col = (data & 0x01) ? fg : bg;
889 dst_col += LCD_WIDTH;
890 UPDATE_SRC;
891 }
892 while (dst_col < dst_end);
893 }
894 break;
895 }
896 }
897 while (src < src_end);
898 }
899 /* Draw a full monochrome bitmap */
900 void lcd_mono_bitmap(const unsigned char *src, int x, int y, int width, int height)
901 {
902 lcd_mono_bitmap_part(src, 0, 0, width, x, y, width, height);
903 }
904
905 /* Draw a partial native bitmap */
906 void ICODE_ATTR lcd_bitmap_part(const fb_data *src, int src_x, int src_y,
907 int stride, int x, int y, int width,
908 int height)
909 {
910 fb_data *dst;
911
912 /******************** Image in viewport clipping **********************/
913 /* nothing to draw? */
914 if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
915 (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
916 return;
917
918 if (x < 0)
919 {
920 width += x;
921 src_x -= x;
922 x = 0;
923 }
924 if (y < 0)
925 {
926 height += y;
927 src_y -= y;
928 y = 0;
929 }
930
931 if (x + width > current_vp->width)
932 width = current_vp->width - x;
933 if (y + height > current_vp->height)
934 height = current_vp->height - y;
935
936 /* adjust for viewport */
937 x += current_vp->x;
938 y += current_vp->y;
939
940 #if defined(HAVE_VIEWPORT_CLIP)
941 /********************* Viewport on screen clipping ********************/
942 /* nothing to draw? */
943 if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT)
944 || (x + width <= 0) || (y + height <= 0))
945 return;
946
947 /* clip image in viewport in screen */
948 if (x < 0)
949 {
950 width += x;
951 src_x -= x;
952 x = 0;
953 }
954 if (y < 0)
955 {
956 height += y;
957 src_y -= y;
958 y = 0;
959 }
960 if (x + width > LCD_WIDTH)
961 width = LCD_WIDTH - x;
962 if (y + height > LCD_HEIGHT)
963 height = LCD_HEIGHT - y;
964 #endif
965
966 src += stride * src_y + src_x; /* move starting point */
967 dst = LCDADDR(x, y);
968
969 do
970 {
971 memcpy(dst, src, width * sizeof(fb_data));
972 src += stride;
973 dst += LCD_WIDTH;
974 }
975 while (--height > 0);
976 }
977
978 /* Draw a full native bitmap */
979 void lcd_bitmap(const fb_data *src, int x, int y, int width, int height)
980 {
981 lcd_bitmap_part(src, 0, 0, width, x, y, width, height);
982 }
983
984 /* Draw a partial native bitmap with transparency and foreground colors */
985 void ICODE_ATTR lcd_bitmap_transparent_part(const fb_data *src, int src_x,
986 int src_y, int stride, int x,
987 int y, int width, int height)
988 {
989 fb_data *dst;
990 unsigned fg = current_vp->fg_pattern;
991
992 /******************** Image in viewport clipping **********************/
993 /* nothing to draw? */
994 if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
995 (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
996 return;
997
998 if (x < 0)
999 {
1000 width += x;
1001 src_x -= x;
1002 x = 0;
1003 }
1004 if (y < 0)
1005 {
1006 height += y;
1007 src_y -= y;
1008 y = 0;
1009 }
1010
1011 if (x + width > current_vp->width)
1012 width = current_vp->width - x;
1013 if (y + height > current_vp->height)
1014 height = current_vp->height - y;
1015
1016 /* adjust for viewport */
1017 x += current_vp->x;
1018 y += current_vp->y;
1019
1020 #if defined(HAVE_VIEWPORT_CLIP)
1021 /********************* Viewport on screen clipping ********************/
1022 /* nothing to draw? */
1023 if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT)
1024 || (x + width <= 0) || (y + height <= 0))
1025 return;
1026
1027 /* clip image in viewport in screen */
1028 if (x < 0)
1029 {
1030 width += x;
1031 src_x -= x;
1032 x = 0;
1033 }
1034 if (y < 0)
1035 {
1036 height += y;
1037 src_y -= y;
1038 y = 0;
1039 }
1040 if (x + width > LCD_WIDTH)
1041 width = LCD_WIDTH - x;
1042 if (y + height > LCD_HEIGHT)
1043 height = LCD_HEIGHT - y;
1044 #endif
1045
1046 src += stride * src_y + src_x; /* move starting point */
1047 dst = LCDADDR(x, y);
1048
1049 #ifdef CPU_ARM
1050 {
1051 int w, px;
1052 asm volatile (
1053 ".rowstart: \n"
1054 "mov %[w], %[width] \n" /* Load width for inner loop */
1055 ".nextpixel: \n"
1056 "ldrh %[px], [%[s]], #2 \n" /* Load src pixel */
1057 "add %[d], %[d], #2 \n" /* Uncoditionally increment dst */
1058 /* done here for better pipelining */
1059 "cmp %[px], %[fgcolor] \n" /* Compare to foreground color */
1060 "streqh %[fgpat], [%[d], #-2] \n" /* Store foregroud if match */
1061 "cmpne %[px], %[transcolor] \n" /* Compare to transparent color */
1062 "strneh %[px], [%[d], #-2] \n" /* Store dst if not transparent */
1063 "subs %[w], %[w], #1 \n" /* Width counter has run down? */
1064 "bgt .nextpixel \n" /* More in this row? */
1065 "add %[s], %[s], %[sstp], lsl #1 \n" /* Skip over to start of next line */
1066 "add %[d], %[d], %[dstp], lsl #1 \n"
1067 "subs %[h], %[h], #1 \n" /* Height counter has run down? */
1068 "bgt .rowstart \n" /* More rows? */
1069 : [w]"=&r"(w), [h]"+&r"(height), [px]"=&r"(px),
1070 [s]"+&r"(src), [d]"+&r"(dst)
1071 : [width]"r"(width),
1072 [sstp]"r"(stride - width),
1073 [dstp]"r"(LCD_WIDTH - width),
1074 [transcolor]"r"(TRANSPARENT_COLOR),
1075 [fgcolor]"r"(REPLACEWITHFG_COLOR),
1076 [fgpat]"r"(fg)
1077 );
1078 }
1079 #else /* optimized C version */
1080 do
1081 {
1082 const fb_data *src_row = src;
1083 fb_data *dst_row = dst;
1084 fb_data *row_end = dst_row + width;
1085 do
1086 {
1087 unsigned data = *src_row++;
1088 if (data != TRANSPARENT_COLOR)
1089 {
1090 if (data == REPLACEWITHFG_COLOR)
1091 data = fg;
1092 *dst_row = data;
1093 }
1094 }
1095 while (++dst_row < row_end);
1096 src += stride;
1097 dst += LCD_WIDTH;
1098 }
1099 while (--height > 0);
1100 #endif
1101 }
1102
1103 /* Draw a full native bitmap with transparent and foreground colors */
1104 void lcd_bitmap_transparent(const fb_data *src, int x, int y,
1105 int width, int height)
1106 {
1107 lcd_bitmap_transparent_part(src, 0, 0, width, x, y, width, height);
1108 }
1109
1110 #include "lcd-bitmap-common.c"
My public Rockbox git repo