?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rk27xx: Disable cache while invalidating it.
[maemo-rb.git] / firmware / drivers / lcd-2bit-vi.c
blob8dc746f5219517872d6eea28fa4b517a5ae1074e
1 /***************************************************************************
2 * __________ __ ___.
3 * Open \______ \ ____ ____ | | _\_ |__ _______ ___
4 * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ /
5 * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < <
6 * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \
7 * \/ \/ \/ \/ \/
8 * $Id$
9 *
10 * Copyright (C) 2006 Jens Arnold
11 *
12 * Rockbox driver for 2bit vertically interleaved 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
24 #include "config.h"
25
26 #include "lcd.h"
27 #include "kernel.h"
28 #include "thread.h"
29 #include <stdlib.h>
30 #include "string-extra.h" /* mem*() */
31 #include "file.h"
32 #include "debug.h"
33 #include "system.h"
34 #include "font.h"
35 #include "rbunicode.h"
36 #include "bidi.h"
37 #include "scroll_engine.h"
38
39 #ifndef LCDFN /* Not compiling for remote - define macros for main LCD. */
40 #define LCDFN(fn) lcd_ ## fn
41 #define FBFN(fn) fb_ ## fn
42 #define LCDM(ma) LCD_ ## ma
43 #define FBSIZE FRAMEBUFFER_SIZE
44 #define LCDNAME "lcd_"
45 #define LCDFB(x,y) FBADDR(x, y)
46 #define MAIN_LCD
47 #endif
48
49 /*** globals ***/
50
51 FBFN(data) LCDFN(static_framebuffer)[LCDM(FBHEIGHT)][LCDM(FBWIDTH)] IRAM_LCDFRAMEBUFFER;
52 FBFN(data) *LCDFN(framebuffer) = &LCDFN(static_framebuffer)[0][0];
53
54
55 static const FBFN(data) patterns[4] = {0xFFFF, 0xFF00, 0x00FF, 0x0000};
56
57 static FBFN(data) *backdrop = NULL;
58 static long backdrop_offset IDATA_ATTR = 0;
59
60 static struct viewport default_vp =
61 {
62 .x = 0,
63 .y = 0,
64 .width = LCDM(WIDTH),
65 .height = LCDM(HEIGHT),
66 .font = FONT_SYSFIXED,
67 .drawmode = DRMODE_SOLID,
68 .fg_pattern = LCDM(DEFAULT_FG),
69 .bg_pattern = LCDM(DEFAULT_BG)
70 };
71
72 static struct viewport * current_vp IBSS_ATTR;
73
74 static unsigned fg_pattern IBSS_ATTR;
75 static unsigned bg_pattern IBSS_ATTR;
76
77 /*** Viewports ***/
78
79 void LCDFN(set_viewport)(struct viewport* vp)
80 {
81 if (vp == NULL)
82 current_vp = &default_vp;
83 else
84 current_vp = vp;
85
86 fg_pattern = patterns[current_vp->fg_pattern & 3];
87 bg_pattern = patterns[current_vp->bg_pattern & 3];
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) LCDM(WIDTH)
95 || (unsigned) current_vp->y > (unsigned) LCDM(HEIGHT)
96 || current_vp->x + current_vp->width > LCDM(WIDTH)
97 || current_vp->y + current_vp->height > LCDM(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 LCDFN(update_viewport)(void)
113 {
114 LCDFN(update_rect)(current_vp->x, current_vp->y,
115 current_vp->width, current_vp->height);
116 }
117
118 void LCDFN(update_viewport_rect)(int x, int y, int width, int height)
119 {
120 LCDFN(update_rect)(current_vp->x + x, current_vp->y + y, width, height);
121 }
122
123 /* LCD init */
124 void LCDFN(init)(void)
125 {
126 LCDFN(set_viewport)(NULL);
127 LCDFN(clear_display)();
128 LCDFN(init_device)();
129 #ifdef MAIN_LCD
130 scroll_init();
131 #endif
132 }
133
134 /*** parameter handling ***/
135
136 #if !defined(MAIN_LCD) && defined(HAVE_LCD_COLOR)
137 /* When compiling for remote LCD and the main LCD is colour. */
138 unsigned lcd_remote_color_to_native(unsigned color)
139 {
140 unsigned r = (color & 0xf800) >> 10;
141 unsigned g = (color & 0x07e0) >> 5;
142 unsigned b = (color & 0x001f) << 2;
143 /*
144 * |R|
145 * |Y'| = |0.299000 0.587000 0.114000| |G|
146 * |B|
147 */
148 return (5*r + 9*g + b) >> 8;
149 }
150 #endif
151
152 void LCDFN(set_drawmode)(int mode)
153 {
154 current_vp->drawmode = mode & (DRMODE_SOLID|DRMODE_INVERSEVID);
155 }
156
157 int LCDFN(get_drawmode)(void)
158 {
159 return current_vp->drawmode;
160 }
161
162 void LCDFN(set_foreground)(unsigned brightness)
163 {
164 current_vp->fg_pattern = brightness;
165 fg_pattern = patterns[brightness & 3];
166 }
167
168 unsigned LCDFN(get_foreground)(void)
169 {
170 return current_vp->fg_pattern;
171 }
172
173 void LCDFN(set_background)(unsigned brightness)
174 {
175 current_vp->bg_pattern = brightness;
176 bg_pattern = patterns[brightness & 3];
177 }
178
179 unsigned LCDFN(get_background)(void)
180 {
181 return current_vp->bg_pattern;
182 }
183
184 void LCDFN(set_drawinfo)(int mode, unsigned fg_brightness,
185 unsigned bg_brightness)
186 {
187 LCDFN(set_drawmode)(mode);
188 LCDFN(set_foreground)(fg_brightness);
189 LCDFN(set_background)(bg_brightness);
190 }
191
192 int LCDFN(getwidth)(void)
193 {
194 return current_vp->width;
195 }
196
197 int LCDFN(getheight)(void)
198 {
199 return current_vp->height;
200 }
201 void LCDFN(setfont)(int newfont)
202 {
203 current_vp->font = newfont;
204 }
205
206 int LCDFN(getfont)(void)
207 {
208 return current_vp->font;
209 }
210
211 int LCDFN(getstringsize)(const unsigned char *str, int *w, int *h)
212 {
213 return font_getstringsize(str, w, h, current_vp->font);
214 }
215
216 /*** low-level drawing functions ***/
217
218 static void setpixel(int x, int y)
219 {
220 unsigned mask = 0x0101 << (y & 7);
221 FBFN(data) *address = LCDFB(x,y>>3);
222 unsigned data = *address;
223
224 *address = data ^ ((data ^ fg_pattern) & mask);
225 }
226
227 static void clearpixel(int x, int y)
228 {
229 unsigned mask = 0x0101 << (y & 7);
230 FBFN(data) *address = LCDFB(x,y>>3);
231 unsigned data = *address;
232
233 *address = data ^ ((data ^ bg_pattern) & mask);
234 }
235
236 static void clearimgpixel(int x, int y)
237 {
238 unsigned mask = 0x0101 << (y & 7);
239 FBFN(data) *address = LCDFB(x,y>>3);
240 unsigned data = *address;
241
242 *address = data ^ ((data ^ *(FBFN(data) *)((long)address
243 + backdrop_offset)) & mask);
244 }
245
246 static void flippixel(int x, int y)
247 {
248 unsigned mask = 0x0101 << (y & 7);
249 FBFN(data) *address = LCDFB(x,y>>3);
250
251 *address ^= mask;
252 }
253
254 static void nopixel(int x, int y)
255 {
256 (void)x;
257 (void)y;
258 }
259
260 LCDFN(pixelfunc_type)* const LCDFN(pixelfuncs_bgcolor)[8] = {
261 flippixel, nopixel, setpixel, setpixel,
262 nopixel, clearpixel, nopixel, clearpixel
263 };
264
265 LCDFN(pixelfunc_type)* const LCDFN(pixelfuncs_backdrop)[8] = {
266 flippixel, nopixel, setpixel, setpixel,
267 nopixel, clearimgpixel, nopixel, clearimgpixel
268 };
269
270 LCDFN(pixelfunc_type)* const *LCDFN(pixelfuncs) = LCDFN(pixelfuncs_bgcolor);
271
272 /* 'mask' and 'bits' contain 2 bits per pixel */
273 static void ICODE_ATTR flipblock(FBFN(data) *address, unsigned mask,
274 unsigned bits)
275 {
276 *address ^= bits & mask;
277 }
278
279 static void ICODE_ATTR bgblock(FBFN(data) *address, unsigned mask,
280 unsigned bits)
281 {
282 unsigned data = *address;
283
284 *address = data ^ ((data ^ bg_pattern) & mask & ~bits);
285 }
286
287 static void ICODE_ATTR bgimgblock(FBFN(data) *address, unsigned mask,
288 unsigned bits)
289 {
290 unsigned data = *address;
291
292 *address = data ^ ((data ^ *(FBFN(data) *)((long)address
293 + backdrop_offset)) & mask & ~bits);
294 }
295
296 static void ICODE_ATTR fgblock(FBFN(data) *address, unsigned mask,
297 unsigned bits)
298 {
299 unsigned data = *address;
300
301 *address = data ^ ((data ^ fg_pattern) & mask & bits);
302 }
303
304 static void ICODE_ATTR solidblock(FBFN(data) *address, unsigned mask,
305 unsigned bits)
306 {
307 unsigned data = *address;
308 unsigned bgp = bg_pattern;
309
310 bits = bgp ^ ((bgp ^ fg_pattern) & bits);
311 *address = data ^ ((data ^ bits) & mask);
312 }
313
314 static void ICODE_ATTR solidimgblock(FBFN(data) *address, unsigned mask,
315 unsigned bits)
316 {
317 unsigned data = *address;
318 unsigned bgp = *(FBFN(data) *)((long)address + backdrop_offset);
319
320 bits = bgp ^ ((bgp ^ fg_pattern) & bits);
321 *address = data ^ ((data ^ bits) & mask);
322 }
323
324 static void ICODE_ATTR flipinvblock(FBFN(data) *address, unsigned mask,
325 unsigned bits)
326 {
327 *address ^= ~bits & mask;
328 }
329
330 static void ICODE_ATTR bginvblock(FBFN(data) *address, unsigned mask,
331 unsigned bits)
332 {
333 unsigned data = *address;
334
335 *address = data ^ ((data ^ bg_pattern) & mask & bits);
336 }
337
338 static void ICODE_ATTR bgimginvblock(FBFN(data) *address, unsigned mask,
339 unsigned bits)
340 {
341 unsigned data = *address;
342
343 *address = data ^ ((data ^ *(FBFN(data) *)((long)address
344 + backdrop_offset)) & mask & bits);
345 }
346
347 static void ICODE_ATTR fginvblock(FBFN(data) *address, unsigned mask,
348 unsigned bits)
349 {
350 unsigned data = *address;
351
352 *address = data ^ ((data ^ fg_pattern) & mask & ~bits);
353 }
354
355 static void ICODE_ATTR solidinvblock(FBFN(data) *address, unsigned mask,
356 unsigned bits)
357 {
358 unsigned data = *address;
359 unsigned fgp = fg_pattern;
360
361 bits = fgp ^ ((fgp ^ bg_pattern) & bits);
362 *address = data ^ ((data ^ bits) & mask);
363 }
364
365 static void ICODE_ATTR solidimginvblock(FBFN(data) *address, unsigned mask,
366 unsigned bits)
367 {
368 unsigned data = *address;
369 unsigned fgp = fg_pattern;
370
371 bits = fgp ^ ((fgp ^ *(FBFN(data) *)((long)address
372 + backdrop_offset)) & bits);
373 *address = data ^ ((data ^ bits) & mask);
374 }
375
376 LCDFN(blockfunc_type)* const LCDFN(blockfuncs_bgcolor)[8] = {
377 flipblock, bgblock, fgblock, solidblock,
378 flipinvblock, bginvblock, fginvblock, solidinvblock
379 };
380
381 LCDFN(blockfunc_type)* const LCDFN(blockfuncs_backdrop)[8] = {
382 flipblock, bgimgblock, fgblock, solidimgblock,
383 flipinvblock, bgimginvblock, fginvblock, solidimginvblock
384 };
385
386 LCDFN(blockfunc_type)* const *LCDFN(blockfuncs) = LCDFN(blockfuncs_bgcolor);
387
388
389 void LCDFN(set_backdrop)(FBFN(data) *bd)
390 {
391 backdrop = bd;
392 if (bd)
393 {
394 backdrop_offset = (long)bd - (long)LCDFN(framebuffer);
395 LCDFN(pixelfuncs) = LCDFN(pixelfuncs_backdrop);
396 LCDFN(blockfuncs) = LCDFN(blockfuncs_backdrop);
397 }
398 else
399 {
400 backdrop_offset = 0;
401 LCDFN(pixelfuncs) = LCDFN(pixelfuncs_bgcolor);
402 LCDFN(blockfuncs) = LCDFN(blockfuncs_bgcolor);
403 }
404 }
405
406 FBFN(data)* LCDFN(get_backdrop)(void)
407 {
408 return backdrop;
409 }
410
411 static inline void setblock(FBFN(data) *address, unsigned mask, unsigned bits)
412 {
413 unsigned data = *address;
414
415 bits ^= data;
416 *address = data ^ (bits & mask);
417 }
418
419 /*** drawing functions ***/
420
421 /* Clear the whole display */
422 void LCDFN(clear_display)(void)
423 {
424 if (default_vp.drawmode & DRMODE_INVERSEVID)
425 {
426 memset(LCDFN(framebuffer), patterns[default_vp.fg_pattern & 3],
427 FBSIZE);
428 }
429 else
430 {
431 if (backdrop)
432 memcpy(LCDFN(framebuffer), backdrop, FBSIZE);
433 else
434 memset(LCDFN(framebuffer), patterns[default_vp.bg_pattern & 3],
435 FBSIZE);
436 }
437
438 LCDFN(scroll_info).lines = 0;
439 }
440
441 /* Clear the current viewport */
442 void LCDFN(clear_viewport)(void)
443 {
444 int lastmode;
445
446 if (current_vp == &default_vp)
447 {
448 LCDFN(clear_display)();
449 }
450 else
451 {
452 lastmode = current_vp->drawmode;
453
454 /* Invert the INVERSEVID bit and set basic mode to SOLID */
455 current_vp->drawmode = (~lastmode & DRMODE_INVERSEVID) |
456 DRMODE_SOLID;
457
458 LCDFN(fillrect)(0, 0, current_vp->width, current_vp->height);
459
460 current_vp->drawmode = lastmode;
461
462 LCDFN(scroll_stop)(current_vp);
463 }
464 }
465
466 /* Set a single pixel */
467 void LCDFN(drawpixel)(int x, int y)
468 {
469 if ( ((unsigned)x < (unsigned)current_vp->width)
470 && ((unsigned)y < (unsigned)current_vp->height)
471 #if defined(HAVE_VIEWPORT_CLIP)
472 && ((unsigned)x < (unsigned)LCDM(WIDTH))
473 && ((unsigned)y < (unsigned)LCDM(HEIGHT))
474 #endif
475 )
476 LCDFN(pixelfuncs)[current_vp->drawmode](current_vp->x+x, current_vp->y+y);
477 }
478
479 /* Draw a line */
480 void LCDFN(drawline)(int x1, int y1, int x2, int y2)
481 {
482 int numpixels;
483 int i;
484 int deltax, deltay;
485 int d, dinc1, dinc2;
486 int x, xinc1, xinc2;
487 int y, yinc1, yinc2;
488 LCDFN(pixelfunc_type) *pfunc = LCDFN(pixelfuncs)[current_vp->drawmode];
489
490 deltax = abs(x2 - x1);
491 if (deltax == 0)
492 {
493 /* DEBUGF(LCDNAME "drawline() called for vertical line - optimisation.\n"); */
494 LCDFN(vline)(x1, y1, y2);
495 return;
496 }
497 deltay = abs(y2 - y1);
498 if (deltay == 0)
499 {
500 /* DEBUGF(LCDNAME "drawline() called for horizontal line - optimisation.\n"); */
501 LCDFN(hline)(x1, x2, y1);
502 return;
503 }
504 xinc2 = 1;
505 yinc2 = 1;
506
507 if (deltax >= deltay)
508 {
509 numpixels = deltax;
510 d = 2 * deltay - deltax;
511 dinc1 = deltay * 2;
512 dinc2 = (deltay - deltax) * 2;
513 xinc1 = 1;
514 yinc1 = 0;
515 }
516 else
517 {
518 numpixels = deltay;
519 d = 2 * deltax - deltay;
520 dinc1 = deltax * 2;
521 dinc2 = (deltax - deltay) * 2;
522 xinc1 = 0;
523 yinc1 = 1;
524 }
525 numpixels++; /* include endpoints */
526
527 if (x1 > x2)
528 {
529 xinc1 = -xinc1;
530 xinc2 = -xinc2;
531 }
532
533 if (y1 > y2)
534 {
535 yinc1 = -yinc1;
536 yinc2 = -yinc2;
537 }
538
539 x = x1;
540 y = y1;
541
542 for (i = 0; i < numpixels; i++)
543 {
544 if ( ((unsigned)x < (unsigned)current_vp->width)
545 && ((unsigned)y < (unsigned)current_vp->height)
546 #if defined(HAVE_VIEWPORT_CLIP)
547 && ((unsigned)x < (unsigned)LCDM(WIDTH))
548 && ((unsigned)y < (unsigned)LCDM(HEIGHT))
549 #endif
550 )
551 pfunc(current_vp->x + x, current_vp->y + y);
552
553 if (d < 0)
554 {
555 d += dinc1;
556 x += xinc1;
557 y += yinc1;
558 }
559 else
560 {
561 d += dinc2;
562 x += xinc2;
563 y += yinc2;
564 }
565 }
566 }
567
568 /* Draw a horizontal line (optimised) */
569 void LCDFN(hline)(int x1, int x2, int y)
570 {
571 int x;
572 int width;
573 FBFN(data) *dst, *dst_end;
574 unsigned mask;
575 LCDFN(blockfunc_type) *bfunc;
576
577 /* direction flip */
578 if (x2 < x1)
579 {
580 x = x1;
581 x1 = x2;
582 x2 = x;
583 }
584
585 /******************** In viewport clipping **********************/
586 /* nothing to draw? */
587 if (((unsigned)y >= (unsigned)current_vp->height) || (x1 >= current_vp->width)
588 || (x2 < 0))
589 return;
590
591 if (x1 < 0)
592 x1 = 0;
593 if (x2 >= current_vp->width)
594 x2 = current_vp->width-1;
595
596 /* adjust x1 and y to viewport */
597 x1 += current_vp->x;
598 x2 += current_vp->x;
599 y += current_vp->y;
600
601 #if defined(HAVE_VIEWPORT_CLIP)
602 /********************* Viewport on screen clipping ********************/
603 /* nothing to draw? */
604 if (((unsigned)y >= (unsigned) LCDM(HEIGHT)) || (x1 >= LCDM(WIDTH))
605 || (x2 < 0))
606 return;
607
608 /* clipping */
609 if (x1 < 0)
610 x1 = 0;
611 if (x2 >= LCDM(WIDTH))
612 x2 = LCDM(WIDTH)-1;
613 #endif
614
615 width = x2 - x1 + 1;
616
617 bfunc = LCDFN(blockfuncs)[current_vp->drawmode];
618 dst = LCDFB(x1,y>>3);
619 mask = 0x0101 << (y & 7);
620
621 dst_end = dst + width;
622 do
623 bfunc(dst++, mask, 0xFFFFu);
624 while (dst < dst_end);
625 }
626
627 /* Draw a vertical line (optimised) */
628 void LCDFN(vline)(int x, int y1, int y2)
629 {
630 int ny;
631 FBFN(data) *dst;
632 unsigned mask, mask_bottom;
633 LCDFN(blockfunc_type) *bfunc;
634
635 /* direction flip */
636 if (y2 < y1)
637 {
638 ny = y1;
639 y1 = y2;
640 y2 = ny;
641 }
642
643 /******************** In viewport clipping **********************/
644 /* nothing to draw? */
645 if (((unsigned)x >= (unsigned)current_vp->width) || (y1 >= current_vp->height)
646 || (y2 < 0))
647 return;
648
649 if (y1 < 0)
650 y1 = 0;
651 if (y2 >= current_vp->height)
652 y2 = current_vp->height-1;
653
654 /* adjust for viewport */
655 y1 += current_vp->y;
656 y2 += current_vp->y;
657 x += current_vp->x;
658
659 #if defined(HAVE_VIEWPORT_CLIP)
660 /********************* Viewport on screen clipping ********************/
661 /* nothing to draw? */
662 if (( (unsigned) x >= (unsigned)LCDM(WIDTH)) || (y1 >= LCDM(HEIGHT))
663 || (y2 < 0))
664 return;
665
666 /* clipping */
667 if (y1 < 0)
668 y1 = 0;
669 if (y2 >= LCDM(HEIGHT))
670 y2 = LCDM(HEIGHT)-1;
671 #endif
672
673 bfunc = LCDFN(blockfuncs)[current_vp->drawmode];
674 dst = LCDFB(x,y1>>3);
675 ny = y2 - (y1 & ~7);
676 mask = (0xFFu << (y1 & 7)) & 0xFFu;
677 mask |= mask << 8;
678 mask_bottom = 0xFFu >> (~ny & 7);
679 mask_bottom |= mask_bottom << 8;
680
681 for (; ny >= 8; ny -= 8)
682 {
683 bfunc(dst, mask, 0xFFFFu);
684 dst += LCDM(WIDTH);
685 mask = 0xFFFFu;
686 }
687 mask &= mask_bottom;
688 bfunc(dst, mask, 0xFFFFu);
689 }
690
691 /* Draw a rectangular box */
692 void LCDFN(drawrect)(int x, int y, int width, int height)
693 {
694 if ((width <= 0) || (height <= 0))
695 return;
696
697 int x2 = x + width - 1;
698 int y2 = y + height - 1;
699
700 LCDFN(vline)(x, y, y2);
701 LCDFN(vline)(x2, y, y2);
702 LCDFN(hline)(x, x2, y);
703 LCDFN(hline)(x, x2, y2);
704 }
705
706 /* Fill a rectangular area */
707 void LCDFN(fillrect)(int x, int y, int width, int height)
708 {
709 int ny;
710 FBFN(data) *dst, *dst_end;
711 unsigned mask, mask_bottom;
712 unsigned bits = 0;
713 LCDFN(blockfunc_type) *bfunc;
714 bool fillopt = false;
715
716 /******************** In viewport clipping **********************/
717 /* nothing to draw? */
718 if ((width <= 0) || (height <= 0) || (x >= current_vp->width)
719 || (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
720 return;
721
722 if (x < 0)
723 {
724 width += x;
725 x = 0;
726 }
727 if (y < 0)
728 {
729 height += y;
730 y = 0;
731 }
732 if (x + width > current_vp->width)
733 width = current_vp->width - x;
734 if (y + height > current_vp->height)
735 height = current_vp->height - y;
736
737 /* adjust for viewport */
738 x += current_vp->x;
739 y += current_vp->y;
740
741 #if defined(HAVE_VIEWPORT_CLIP)
742 /********************* Viewport on screen clipping ********************/
743 /* nothing to draw? */
744 if ((x >= LCDM(WIDTH)) || (y >= LCDM(HEIGHT))
745 || (x + width <= 0) || (y + height <= 0))
746 return;
747
748 /* clip image in viewport in screen */
749 if (x < 0)
750 {
751 width += x;
752 x = 0;
753 }
754 if (y < 0)
755 {
756 height += y;
757 y = 0;
758 }
759 if (x + width > LCDM(WIDTH))
760 width = LCDM(WIDTH) - x;
761 if (y + height > LCDM(HEIGHT))
762 height = LCDM(HEIGHT) - y;
763 #endif
764
765
766 if (current_vp->drawmode & DRMODE_INVERSEVID)
767 {
768 if ((current_vp->drawmode & DRMODE_BG) && !backdrop)
769 {
770 fillopt = true;
771 bits = bg_pattern;
772 }
773 }
774 else
775 {
776 if (current_vp->drawmode & DRMODE_FG)
777 {
778 fillopt = true;
779 bits = fg_pattern;
780 }
781 }
782 bfunc = LCDFN(blockfuncs)[current_vp->drawmode];
783 dst = LCDFB(x,y>>3);
784 ny = height - 1 + (y & 7);
785 mask = (0xFFu << (y & 7)) & 0xFFu;
786 mask |= mask << 8;
787 mask_bottom = 0xFFu >> (~ny & 7);
788 mask_bottom |= mask_bottom << 8;
789
790 for (; ny >= 8; ny -= 8)
791 {
792 if (fillopt && (mask == 0xFFFFu))
793 memset16(dst, bits, width);
794 else
795 {
796 FBFN(data) *dst_row = dst;
797
798 dst_end = dst_row + width;
799 do
800 bfunc(dst_row++, mask, 0xFFFFu);
801 while (dst_row < dst_end);
802 }
803
804 dst += LCDM(WIDTH);
805 mask = 0xFFFFu;
806 }
807 mask &= mask_bottom;
808
809 if (fillopt && (mask == 0xFFFFu))
810 memset16(dst, bits, width);
811 else
812 {
813 dst_end = dst + width;
814 do
815 bfunc(dst++, mask, 0xFFFFu);
816 while (dst < dst_end);
817 }
818 }
819
820 /* About Rockbox' internal monochrome bitmap format:
821 *
822 * A bitmap contains one bit for every pixel that defines if that pixel is
823 * black (1) or white (0). Bits within a byte are arranged vertically, LSB
824 * at top.
825 * The bytes are stored in row-major order, with byte 0 being top left,
826 * byte 1 2nd from left etc. The first row of bytes defines pixel rows
827 * 0..7, the second row defines pixel row 8..15 etc.
828 *
829 * This is similar to the internal lcd hw format. */
830
831 /* Draw a partial monochrome bitmap */
832 void ICODE_ATTR LCDFN(mono_bitmap_part)(const unsigned char *src, int src_x,
833 int src_y, int stride, int x, int y,
834 int width, int height)
835 {
836 int shift, ny;
837 FBFN(data) *dst, *dst_end;
838 unsigned data, mask, mask_bottom;
839 LCDFN(blockfunc_type) *bfunc;
840
841 /******************** Image in viewport clipping **********************/
842 /* nothing to draw? */
843 if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
844 (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
845 return;
846
847 if (x < 0)
848 {
849 width += x;
850 src_x -= x;
851 x = 0;
852 }
853 if (y < 0)
854 {
855 height += y;
856 src_y -= y;
857 y = 0;
858 }
859 if (x + width > current_vp->width)
860 width = current_vp->width - x;
861 if (y + height > current_vp->height)
862 height = current_vp->height - y;
863
864 /* adjust for viewport */
865 x += current_vp->x;
866 y += current_vp->y;
867
868 #if defined(HAVE_VIEWPORT_CLIP)
869 /********************* Viewport on screen clipping ********************/
870 /* nothing to draw? */
871 if ((x >= LCDM(WIDTH)) || (y >= LCDM(HEIGHT))
872 || (x + width <= 0) || (y + height <= 0))
873 return;
874
875 /* clip image in viewport in screen */
876 if (x < 0)
877 {
878 width += x;
879 src_x -= x;
880 x = 0;
881 }
882 if (y < 0)
883 {
884 height += y;
885 src_y -= y;
886 y = 0;
887 }
888 if (x + width > LCDM(WIDTH))
889 width = LCDM(WIDTH) - x;
890 if (y + height > LCDM(HEIGHT))
891 height = LCDM(HEIGHT) - y;
892 #endif
893
894 src += stride * (src_y >> 3) + src_x; /* move starting point */
895 src_y &= 7;
896 y -= src_y;
897 dst = LCDFB(x,y>>3);
898 shift = y & 7;
899 ny = height - 1 + shift + src_y;
900
901 bfunc = LCDFN(blockfuncs)[current_vp->drawmode];
902 mask = 0xFFu << (shift + src_y);
903 /* not byte-doubled here because shift+src_y can be > 7 */
904 mask_bottom = 0xFFu >> (~ny & 7);
905 mask_bottom |= mask_bottom << 8;
906
907 if (shift == 0)
908 {
909 mask &= 0xFFu;
910 mask |= mask << 8;
911
912 for (; ny >= 8; ny -= 8)
913 {
914 const unsigned char *src_row = src;
915 FBFN(data) *dst_row = dst;
916
917 dst_end = dst_row + width;
918 do
919 {
920 data = *src_row++;
921 bfunc(dst_row++, mask, data | (data << 8));
922 }
923 while (dst_row < dst_end);
924
925 src += stride;
926 dst += LCDM(WIDTH);
927 mask = 0xFFFFu;
928 }
929 mask &= mask_bottom;
930
931 dst_end = dst + width;
932 do
933 {
934 data = *src++;
935 bfunc(dst++, mask, data | (data << 8));
936 }
937 while (dst < dst_end);
938 }
939 else
940 {
941 unsigned ddata;
942
943 dst_end = dst + width;
944 do
945 {
946 const unsigned char *src_col = src++;
947 FBFN(data) *dst_col = dst++;
948 unsigned mask_col = mask & 0xFFu;
949
950 mask_col |= mask_col << 8;
951 data = 0;
952
953 for (y = ny; y >= 8; y -= 8)
954 {
955 data |= *src_col << shift;
956
957 if (mask_col)
958 {
959 ddata = data & 0xFFu;
960 bfunc(dst_col, mask_col, ddata | (ddata << 8));
961 mask_col = 0xFFFFu;
962 }
963 else
964 {
965 mask_col = (mask >> 8) & 0xFFu;
966 mask_col |= mask_col << 8;
967 }
968
969 src_col += stride;
970 dst_col += LCDM(WIDTH);
971 data >>= 8;
972 }
973 data |= *src_col << shift;
974 mask_col &= mask_bottom;
975 ddata = data & 0xFFu;
976 bfunc(dst_col, mask_col, ddata | (ddata << 8));
977 }
978 while (dst < dst_end);
979 }
980 }
981
982 /* Draw a full monochrome bitmap */
983 void LCDFN(mono_bitmap)(const unsigned char *src, int x, int y, int width,
984 int height)
985 {
986 LCDFN(mono_bitmap_part)(src, 0, 0, width, x, y, width, height);
987 }
988
989 /* About Rockbox' internal native bitmap format:
990 *
991 * A bitmap contains one bit in each byte of a pair of bytes for every pixel.
992 * 00 = white, 01 = light grey, 10 = dark grey, 11 = black. Bits within a byte
993 * are arranged vertically, LSB at top.
994 * The pairs of bytes are stored as shorts, in row-major order, with word 0
995 * being top left, word 1 2nd from left etc. The first row of words defines
996 * pixel rows 0..7, the second row defines pixel row 8..15 etc.
997 *
998 * This is the same as the internal lcd hw format. */
999
1000 /* Draw a partial native bitmap */
1001 void ICODE_ATTR LCDFN(bitmap_part)(const FBFN(data) *src, int src_x,
1002 int src_y, int stride, int x, int y,
1003 int width, int height)
1004 {
1005 int shift, ny;
1006 FBFN(data) *dst, *dst_end;
1007 unsigned mask, mask_bottom;
1008
1009 /******************** Image in viewport clipping **********************/
1010 /* nothing to draw? */
1011 if ((width <= 0) || (height <= 0) || (x >= current_vp->width)
1012 || (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
1013 return;
1014
1015 if (x < 0)
1016 {
1017 width += x;
1018 src_x -= x;
1019 x = 0;
1020 }
1021 if (y < 0)
1022 {
1023 height += y;
1024 src_y -= y;
1025 y = 0;
1026 }
1027 if (x + width > current_vp->width)
1028 width = current_vp->width - x;
1029 if (y + height > current_vp->height)
1030 height = current_vp->height - y;
1031
1032 /* adjust for viewport */
1033 x += current_vp->x;
1034 y += current_vp->y;
1035
1036 #if defined(HAVE_VIEWPORT_CLIP)
1037 /********************* Viewport on screen clipping ********************/
1038 /* nothing to draw? */
1039 if ((x >= LCDM(WIDTH)) || (y >= LCDM(HEIGHT))
1040 || (x + width <= 0) || (y + height <= 0))
1041 return;
1042
1043 /* clip image in viewport in screen */
1044 if (x < 0)
1045 {
1046 width += x;
1047 src_x -= x;
1048 x = 0;
1049 }
1050 if (y < 0)
1051 {
1052 height += y;
1053 src_y -= y;
1054 y = 0;
1055 }
1056 if (x + width > LCDM(WIDTH))
1057 width = LCDM(WIDTH) - x;
1058 if (y + height > LCDM(HEIGHT))
1059 height = LCDM(HEIGHT) - y;
1060 #endif
1061
1062 src += stride * (src_y >> 3) + src_x; /* move starting point */
1063 src_y &= 7;
1064 y -= src_y;
1065 dst = LCDFB(x,y>>3);
1066 shift = y & 7;
1067 ny = height - 1 + shift + src_y;
1068
1069 mask = 0xFFu << (shift + src_y);
1070 /* not byte-doubled here because shift+src_y can be > 7 */
1071 mask_bottom = 0xFFu >> (~ny & 7);
1072 mask_bottom |= mask_bottom << 8;
1073
1074 if (shift == 0)
1075 {
1076 mask &= 0xFFu;
1077 mask |= mask << 8;
1078
1079 for (; ny >= 8; ny -= 8)
1080 {
1081 if (mask == 0xFFFFu)
1082 memcpy(dst, src, width * sizeof(FBFN(data)));
1083 else
1084 {
1085 const FBFN(data) *src_row = src;
1086 FBFN(data) *dst_row = dst;
1087
1088 dst_end = dst_row + width;
1089 do
1090 setblock(dst_row++, mask, *src_row++);
1091 while (dst_row < dst_end);
1092 }
1093 src += stride;
1094 dst += LCDM(WIDTH);
1095 mask = 0xFFFFu;
1096 }
1097 mask &= mask_bottom;
1098
1099 if (mask == 0xFFFFu)
1100 memcpy(dst, src, width * sizeof(FBFN(data)));
1101 else
1102 {
1103 dst_end = dst + width;
1104 do
1105 setblock(dst++, mask, *src++);
1106 while (dst < dst_end);
1107 }
1108 }
1109 else
1110 {
1111 unsigned datamask = (0xFFu << shift) & 0xFFu;
1112
1113 datamask |= datamask << 8;
1114
1115 dst_end = dst + width;
1116 do
1117 {
1118 const FBFN(data) *src_col = src++;
1119 FBFN(data) *dst_col = dst++;
1120 unsigned mask_col = mask & 0xFFu;
1121 unsigned data, olddata = 0;
1122
1123 mask_col |= mask_col << 8;
1124
1125 for (y = ny; y >= 8; y -= 8)
1126 {
1127 data = *src_col << shift;
1128
1129 if (mask_col)
1130 {
1131 setblock(dst_col, mask_col,
1132 olddata ^((olddata ^ data) & datamask));
1133 mask_col = 0xFFFFu;
1134 }
1135 else
1136 {
1137 mask_col = (mask >> 8) & 0xFFu;
1138 mask_col |= mask_col << 8;
1139 }
1140 src_col += stride;
1141 dst_col += LCDM(WIDTH);
1142 olddata = data >> 8;
1143 }
1144 data = *src_col << shift;
1145 setblock(dst_col, mask_col & mask_bottom,
1146 olddata ^((olddata ^ data) & datamask));
1147 }
1148 while (dst < dst_end);
1149 }
1150 }
1151
1152 /* Draw a full native bitmap */
1153 void LCDFN(bitmap)(const FBFN(data) *src, int x, int y, int width, int height)
1154 {
1155 LCDFN(bitmap_part)(src, 0, 0, width, x, y, width, height);
1156 }
1157
1158 #include "lcd-bitmap-common.c"
thomasjfox's rockbox modifications (mameo port)