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