firmware/drivers/lcd-2bit-vert.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2004 by Linus Nielsen Feltzing
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include "config.h"
  22
  23 #include "system.h"
  24 #include "cpu.h"
  25 #include "kernel.h"
  26 #include "lcd.h"
  27 #include "thread.h"
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include "file.h"
  31 #include "debug.h"
  32 #include "font.h"
  33 #include "rbunicode.h"
  34 #include "bidi.h"
  35 #include "scroll_engine.h"
  36
  37 /*** globals ***/
  38
  39 fb_data lcd_framebuffer[LCD_FBHEIGHT][LCD_FBWIDTH] IRAM_LCDFRAMEBUFFER;
  40
  41 const unsigned char lcd_dibits[16] ICONST_ATTR = {
  42     0x00, 0x03, 0x0C, 0x0F, 0x30, 0x33, 0x3C, 0x3F,
  43     0xC0, 0xC3, 0xCC, 0xCF, 0xF0, 0xF3, 0xFC, 0xFF
  44 };
  45
  46 static const unsigned char pixmask[4] ICONST_ATTR = {
  47     0x03, 0x0C, 0x30, 0xC0
  48 };
  49
  50 static fb_data* lcd_backdrop = NULL;
  51 static long lcd_backdrop_offset IDATA_ATTR = 0;
  52
  53 static struct viewport default_vp =
  54 {
  55     .x        = 0,
  56     .y        = 0,
  57     .width    = LCD_WIDTH,
  58     .height   = LCD_HEIGHT,
  59     .font     = FONT_SYSFIXED,
  60     .drawmode = DRMODE_SOLID,
  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 int lcd_getwidth(void)
 148 {
 149     return current_vp->width;
 150 }
 151
 152 int lcd_getheight(void)
 153 {
 154     return current_vp->height;
 155 }
 156
 157 void lcd_setfont(int newfont)
 158 {
 159     current_vp->font = newfont;
 160 }
 161
 162 int lcd_getfont(void)
 163 {
 164     return current_vp->font;
 165 }
 166
 167 int lcd_getstringsize(const unsigned char *str, int *w, int *h)
 168 {
 169     return font_getstringsize(str, w, h, current_vp->font);
 170 }
 171
 172 /*** low-level drawing functions ***/
 173
 174 static void setpixel(int x, int y)
 175 {
 176     unsigned mask = pixmask[y & 3];
 177     fb_data *address = &lcd_framebuffer[y>>2][x];
 178     unsigned data = *address;
 179
 180     *address = data ^ ((data ^ fg_pattern) & mask);
 181 }
 182
 183 static void clearpixel(int x, int y)
 184 {
 185     unsigned mask = pixmask[y & 3];
 186     fb_data *address = &lcd_framebuffer[y>>2][x];
 187     unsigned data = *address;
 188
 189     *address = data ^ ((data ^ bg_pattern) & mask);
 190 }
 191
 192 static void clearimgpixel(int x, int y)
 193 {
 194     unsigned mask = pixmask[y & 3];
 195     fb_data *address = &lcd_framebuffer[y>>2][x];
 196     unsigned data = *address;
 197
 198     *address = data ^ ((data ^ *(address + lcd_backdrop_offset)) & mask);
 199 }
 200
 201 static void flippixel(int x, int y)
 202 {
 203     unsigned mask = pixmask[y & 3];
 204     fb_data *address = &lcd_framebuffer[y>>2][x];
 205
 206     *address ^= mask;
 207 }
 208
 209 static void nopixel(int x, int y)
 210 {
 211     (void)x;
 212     (void)y;
 213 }
 214
 215 lcd_pixelfunc_type* const lcd_pixelfuncs_bgcolor[8] = {
 216     flippixel, nopixel, setpixel, setpixel,
 217     nopixel, clearpixel, nopixel, clearpixel
 218 };
 219
 220 lcd_pixelfunc_type* const lcd_pixelfuncs_backdrop[8] = {
 221     flippixel, nopixel, setpixel, setpixel,
 222     nopixel, clearimgpixel, nopixel, clearimgpixel
 223 };
 224
 225
 226 lcd_pixelfunc_type* const * lcd_pixelfuncs = lcd_pixelfuncs_bgcolor;
 227
 228 /* 'mask' and 'bits' contain 2 bits per pixel */
 229 static void ICODE_ATTR flipblock(fb_data *address, unsigned mask,
 230                                  unsigned bits)
 231 {
 232     *address ^= bits & mask;
 233 }
 234
 235 static void ICODE_ATTR bgblock(fb_data *address, unsigned mask,
 236                                unsigned bits)
 237 {
 238     unsigned data = *address;
 239
 240     *address = data ^ ((data ^ bg_pattern) & mask & ~bits);
 241 }
 242
 243 static void ICODE_ATTR bgimgblock(fb_data *address, unsigned mask,
 244                                   unsigned bits)
 245 {
 246     unsigned data = *address;
 247
 248     *address = data ^ ((data ^ *(address + lcd_backdrop_offset)) & mask & ~bits);
 249 }
 250
 251 static void ICODE_ATTR fgblock(fb_data *address, unsigned mask,
 252                                unsigned bits)
 253 {
 254     unsigned data = *address;
 255
 256     *address = data ^ ((data ^ fg_pattern) & mask & bits);
 257 }
 258
 259 static void ICODE_ATTR solidblock(fb_data *address, unsigned mask,
 260                                   unsigned bits)
 261 {
 262     unsigned data = *address;
 263     unsigned bgp  = bg_pattern;
 264
 265     bits     = bgp  ^ ((bgp ^ fg_pattern) & bits);
 266     *address = data ^ ((data ^ bits) & mask);
 267 }
 268
 269 static void ICODE_ATTR solidimgblock(fb_data *address, unsigned mask,
 270                                      unsigned bits)
 271 {
 272     unsigned data = *address;
 273     unsigned bgp  = *(address + lcd_backdrop_offset);
 274
 275     bits     = bgp  ^ ((bgp ^ fg_pattern) & bits);
 276     *address = data ^ ((data ^ bits) & mask);
 277 }
 278
 279 static void ICODE_ATTR flipinvblock(fb_data *address, unsigned mask,
 280                                     unsigned bits)
 281 {
 282     *address ^= ~bits & mask;
 283 }
 284
 285 static void ICODE_ATTR bginvblock(fb_data *address, unsigned mask,
 286                                   unsigned bits)
 287 {
 288     unsigned data = *address;
 289
 290     *address = data ^ ((data ^ bg_pattern) & mask & bits);
 291 }
 292
 293 static void ICODE_ATTR bgimginvblock(fb_data *address, unsigned mask,
 294                                      unsigned bits)
 295 {
 296     unsigned data = *address;
 297
 298     *address = data ^ ((data ^ *(address + lcd_backdrop_offset)) & mask & bits);
 299 }
 300
 301 static void ICODE_ATTR fginvblock(fb_data *address, unsigned mask,
 302                                   unsigned bits)
 303 {
 304     unsigned data = *address;
 305
 306     *address = data ^ ((data ^ fg_pattern) & mask & ~bits);
 307 }
 308
 309 static void ICODE_ATTR solidinvblock(fb_data *address, unsigned mask,
 310                                      unsigned bits)
 311 {
 312     unsigned data = *address;
 313     unsigned fgp  = fg_pattern;
 314
 315     bits     = fgp  ^ ((fgp ^ bg_pattern) & bits);
 316     *address = data ^ ((data ^ bits) & mask);
 317 }
 318
 319 static void ICODE_ATTR solidimginvblock(fb_data *address, unsigned mask,
 320                                         unsigned bits)
 321 {
 322     unsigned data = *address;
 323     unsigned fgp  = fg_pattern;
 324
 325     bits     = fgp  ^ ((fgp ^ *(address + lcd_backdrop_offset)) & bits);
 326     *address = data ^ ((data ^ bits) & mask);
 327 }
 328
 329 lcd_blockfunc_type* const lcd_blockfuncs_bgcolor[8] = {
 330     flipblock, bgblock, fgblock, solidblock,
 331     flipinvblock, bginvblock, fginvblock, solidinvblock
 332 };
 333
 334 lcd_blockfunc_type* const lcd_blockfuncs_backdrop[8] = {
 335     flipblock, bgimgblock, fgblock, solidimgblock,
 336     flipinvblock, bgimginvblock, fginvblock, solidimginvblock
 337 };
 338
 339 lcd_blockfunc_type* const * lcd_blockfuncs = lcd_blockfuncs_bgcolor;
 340
 341
 342 void lcd_set_backdrop(fb_data* backdrop)
 343 {
 344     lcd_backdrop = backdrop;
 345     if (backdrop)
 346     {
 347         lcd_backdrop_offset = (long)backdrop - (long)lcd_framebuffer;
 348         lcd_pixelfuncs = lcd_pixelfuncs_backdrop;
 349         lcd_blockfuncs = lcd_blockfuncs_backdrop;
 350     }
 351     else
 352     {
 353         lcd_backdrop_offset = 0;
 354         lcd_pixelfuncs = lcd_pixelfuncs_bgcolor;
 355         lcd_blockfuncs = lcd_blockfuncs_bgcolor;
 356     }
 357 }
 358
 359 fb_data* lcd_get_backdrop(void)
 360 {
 361     return lcd_backdrop;
 362 }
 363
 364
 365 static inline void setblock(fb_data *address, unsigned mask, unsigned bits)
 366 {
 367     unsigned data = *address;
 368
 369     bits    ^= data;
 370     *address = data ^ (bits & mask);
 371 }
 372
 373 /*** drawing functions ***/
 374
 375 /* Clear the whole display */
 376 void lcd_clear_display(void)
 377 {
 378     if (current_vp->drawmode & DRMODE_INVERSEVID)
 379     {
 380         memset(lcd_framebuffer, fg_pattern, sizeof lcd_framebuffer);
 381     }
 382     else
 383     {
 384         if (lcd_backdrop)
 385             memcpy(lcd_framebuffer, lcd_backdrop, sizeof lcd_framebuffer);
 386         else
 387             memset(lcd_framebuffer, bg_pattern, sizeof lcd_framebuffer);
 388     }
 389
 390     lcd_scroll_info.lines = 0;
 391 }
 392
 393 /* Clear the current viewport */
 394 void lcd_clear_viewport(void)
 395 {
 396     int lastmode;
 397
 398     if (current_vp == &default_vp)
 399     {
 400         lcd_clear_display();
 401     }
 402     else
 403     {
 404         lastmode = current_vp->drawmode;
 405
 406         /* Invert the INVERSEVID bit and set basic mode to SOLID */
 407         current_vp->drawmode = (~lastmode & DRMODE_INVERSEVID) |
 408                                DRMODE_SOLID;
 409
 410         lcd_fillrect(0, 0, current_vp->width, current_vp->height);
 411
 412         current_vp->drawmode = lastmode;
 413
 414         lcd_scroll_stop(current_vp);
 415     }
 416 }
 417
 418 /* Set a single pixel */
 419 void lcd_drawpixel(int x, int y)
 420 {
 421     if (((unsigned)x < (unsigned)current_vp->width) &&
 422         ((unsigned)y < (unsigned)current_vp->height))
 423         lcd_pixelfuncs[current_vp->drawmode](current_vp->x + x, current_vp->y + y);
 424 }
 425
 426 /* Draw a line */
 427 void lcd_drawline(int x1, int y1, int x2, int y2)
 428 {
 429     int numpixels;
 430     int i;
 431     int deltax, deltay;
 432     int d, dinc1, dinc2;
 433     int x, xinc1, xinc2;
 434     int y, yinc1, yinc2;
 435     lcd_pixelfunc_type *pfunc = lcd_pixelfuncs[current_vp->drawmode];
 436
 437     deltax = abs(x2 - x1);
 438     if (deltax == 0)
 439     {
 440         DEBUGF("lcd_drawline() called for vertical line - optimisation.\n");
 441         lcd_vline(x1, y1, y2);
 442         return;
 443     }
 444     deltay = abs(y2 - y1);
 445     if (deltay == 0)
 446     {
 447         DEBUGF("lcd_drawline() called for horizontal line - optimisation.\n");
 448         lcd_hline(x1, x2, y1);
 449         return;
 450     }
 451     xinc2 = 1;
 452     yinc2 = 1;
 453
 454     if (deltax >= deltay)
 455     {
 456         numpixels = deltax;
 457         d = 2 * deltay - deltax;
 458         dinc1 = deltay * 2;
 459         dinc2 = (deltay - deltax) * 2;
 460         xinc1 = 1;
 461         yinc1 = 0;
 462     }
 463     else
 464     {
 465         numpixels = deltay;
 466         d = 2 * deltax - deltay;
 467         dinc1 = deltax * 2;
 468         dinc2 = (deltax - deltay) * 2;
 469         xinc1 = 0;
 470         yinc1 = 1;
 471     }
 472     numpixels++; /* include endpoints */
 473
 474     if (x1 > x2)
 475     {
 476         xinc1 = -xinc1;
 477         xinc2 = -xinc2;
 478     }
 479
 480     if (y1 > y2)
 481     {
 482         yinc1 = -yinc1;
 483         yinc2 = -yinc2;
 484     }
 485
 486     x = x1;
 487     y = y1;
 488
 489     for (i = 0; i < numpixels; i++)
 490     {
 491         if (((unsigned)x < (unsigned)current_vp->width) &&
 492             ((unsigned)y < (unsigned)current_vp->height))
 493             pfunc(current_vp->x + x, current_vp->y + y);
 494
 495         if (d < 0)
 496         {
 497             d += dinc1;
 498             x += xinc1;
 499             y += yinc1;
 500         }
 501         else
 502         {
 503             d += dinc2;
 504             x += xinc2;
 505             y += yinc2;
 506         }
 507     }
 508 }
 509
 510 /* Draw a horizontal line (optimised) */
 511 void lcd_hline(int x1, int x2, int y)
 512 {
 513     int x;
 514     int width;
 515     fb_data *dst, *dst_end;
 516     unsigned mask;
 517     lcd_blockfunc_type *bfunc;
 518
 519     /* direction flip */
 520     if (x2 < x1)
 521     {
 522         x = x1;
 523         x1 = x2;
 524         x2 = x;
 525     }
 526
 527     /* nothing to draw? */
 528     if (((unsigned)y >= (unsigned)current_vp->height) || (x1 >= current_vp->width)
 529         || (x2 < 0))
 530         return;
 531
 532     /* clipping */
 533     if (x1 < 0)
 534         x1 = 0;
 535     if (x2 >= current_vp->width)
 536         x2 = current_vp->width-1;
 537
 538     width = x2 - x1 + 1;
 539
 540     /* adjust x1 and y to viewport */
 541     x1 += current_vp->x;
 542     y += current_vp->y;
 543
 544     bfunc = lcd_blockfuncs[current_vp->drawmode];
 545     dst   = &lcd_framebuffer[y>>2][x1];
 546     mask  = pixmask[y & 3];
 547
 548     dst_end = dst + width;
 549     do
 550         bfunc(dst++, mask, 0xFFu);
 551     while (dst < dst_end);
 552 }
 553
 554 /* Draw a vertical line (optimised) */
 555 void lcd_vline(int x, int y1, int y2)
 556 {
 557     int ny;
 558     fb_data *dst;
 559     unsigned mask, mask_bottom;
 560     lcd_blockfunc_type *bfunc;
 561
 562     /* direction flip */
 563     if (y2 < y1)
 564     {
 565         ny = y1;
 566         y1 = y2;
 567         y2 = ny;
 568     }
 569
 570     /* nothing to draw? */
 571     if (((unsigned)x >= (unsigned)current_vp->width) || (y1 >= current_vp->height)
 572         || (y2 < 0))
 573         return;
 574
 575     /* clipping */
 576     if (y1 < 0)
 577         y1 = 0;
 578     if (y2 >= current_vp->height)
 579         y2 = current_vp->height-1;
 580
 581     /* adjust for viewport */
 582     y1 += current_vp->y;
 583     y2 += current_vp->y;
 584     x += current_vp->x;
 585
 586     bfunc = lcd_blockfuncs[current_vp->drawmode];
 587     dst   = &lcd_framebuffer[y1>>2][x];
 588     ny    = y2 - (y1 & ~3);
 589     mask  = 0xFFu << (2 * (y1 & 3));
 590     mask_bottom = 0xFFu >> (2 * (~ny & 3));
 591
 592     for (; ny >= 4; ny -= 4)
 593     {
 594         bfunc(dst, mask, 0xFFu);
 595         dst += LCD_WIDTH;
 596         mask = 0xFFu;
 597     }
 598     mask &= mask_bottom;
 599     bfunc(dst, mask, 0xFFu);
 600 }
 601
 602 /* Draw a rectangular box */
 603 void lcd_drawrect(int x, int y, int width, int height)
 604 {
 605     if ((width <= 0) || (height <= 0))
 606         return;
 607
 608     int x2 = x + width - 1;
 609     int y2 = y + height - 1;
 610
 611     lcd_vline(x, y, y2);
 612     lcd_vline(x2, y, y2);
 613     lcd_hline(x, x2, y);
 614     lcd_hline(x, x2, y2);
 615 }
 616
 617 /* Fill a rectangular area */
 618 void lcd_fillrect(int x, int y, int width, int height)
 619 {
 620     int ny;
 621     fb_data *dst, *dst_end;
 622     unsigned mask, mask_bottom;
 623     unsigned bits = 0;
 624     lcd_blockfunc_type *bfunc;
 625     bool fillopt = false;
 626
 627     /* nothing to draw? */
 628     if ((width <= 0) || (height <= 0) || (x >= current_vp->width)
 629         || (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
 630         return;
 631
 632     /* clipping */
 633     if (x < 0)
 634     {
 635         width += x;
 636         x = 0;
 637     }
 638     if (y < 0)
 639     {
 640         height += y;
 641         y = 0;
 642     }
 643     if (x + width > current_vp->width)
 644         width = current_vp->width - x;
 645     if (y + height > current_vp->height)
 646         height = current_vp->height - y;
 647
 648     /* adjust for viewport */
 649     x += current_vp->x;
 650     y += current_vp->y;
 651
 652     if (current_vp->drawmode & DRMODE_INVERSEVID)
 653     {
 654         if ((current_vp->drawmode & DRMODE_BG) && !lcd_backdrop)
 655         {
 656             fillopt = true;
 657             bits = bg_pattern;
 658         }
 659     }
 660     else
 661     {
 662         if (current_vp->drawmode & DRMODE_FG)
 663         {
 664             fillopt = true;
 665             bits = fg_pattern;
 666         }
 667     }
 668     bfunc = lcd_blockfuncs[current_vp->drawmode];
 669     dst   = &lcd_framebuffer[y>>2][x];
 670     ny    = height - 1 + (y & 3);
 671     mask  = 0xFFu << (2 * (y & 3));
 672     mask_bottom = 0xFFu >> (2 * (~ny & 3));
 673
 674     for (; ny >= 4; ny -= 4)
 675     {
 676         if (fillopt && (mask == 0xFFu))
 677             memset(dst, bits, width);
 678         else
 679         {
 680             fb_data *dst_row = dst;
 681
 682             dst_end = dst_row + width;
 683             do
 684                 bfunc(dst_row++, mask, 0xFFu);
 685             while (dst_row < dst_end);
 686         }
 687
 688         dst += LCD_WIDTH;
 689         mask = 0xFFu;
 690     }
 691     mask &= mask_bottom;
 692
 693     if (fillopt && (mask == 0xFFu))
 694         memset(dst, bits, width);
 695     else
 696     {
 697         dst_end = dst + width;
 698         do
 699             bfunc(dst++, mask, 0xFFu);
 700         while (dst < dst_end);
 701     }
 702 }
 703
 704 /* About Rockbox' internal monochrome bitmap format:
 705  *
 706  * A bitmap contains one bit for every pixel that defines if that pixel is
 707  * black (1) or white (0). Bits within a byte are arranged vertically, LSB
 708  * at top.
 709  * The bytes are stored in row-major order, with byte 0 being top left,
 710  * byte 1 2nd from left etc. The first row of bytes defines pixel rows
 711  * 0..7, the second row defines pixel row 8..15 etc.
 712  *
 713  * This is similar to the internal lcd hw format. */
 714
 715 /* Draw a partial monochrome bitmap */
 716 void ICODE_ATTR lcd_mono_bitmap_part(const unsigned char *src, int src_x,
 717                                      int src_y, int stride, int x, int y,
 718                                      int width, int height)
 719 {
 720     int shift, ny;
 721     fb_data *dst, *dst_end;
 722     unsigned mask, mask_bottom;
 723     lcd_blockfunc_type *bfunc;
 724
 725     /* nothing to draw? */
 726     if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
 727         (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
 728         return;
 729
 730     /* clipping */
 731     if (x < 0)
 732     {
 733         width += x;
 734         src_x -= x;
 735         x = 0;
 736     }
 737     if (y < 0)
 738     {
 739         height += y;
 740         src_y -= y;
 741         y = 0;
 742     }
 743     if (x + width > current_vp->width)
 744         width = current_vp->width - x;
 745     if (y + height > current_vp->height)
 746         height = current_vp->height - y;
 747
 748     /* adjust for viewport */
 749     x += current_vp->x;
 750     y += current_vp->y;
 751
 752     src    += stride * (src_y >> 3) + src_x; /* move starting point */
 753     src_y  &= 7;
 754     y      -= src_y;
 755     dst    = &lcd_framebuffer[y>>2][x];
 756     shift  = y & 3;
 757     ny     = height - 1 + shift + src_y;
 758     mask   = 0xFFFFu << (2 * (shift + src_y));
 759              /* Overflowing bits aren't important. */
 760     mask_bottom  = 0xFFFFu >> (2 * (~ny & 7));
 761
 762     bfunc  = lcd_blockfuncs[current_vp->drawmode];
 763
 764     if (shift == 0)
 765     {
 766         unsigned dmask1, dmask2, data;
 767
 768         dmask1 = mask & 0xFFu;
 769         dmask2 = mask >> 8;
 770
 771         for (; ny >= 8; ny -= 8)
 772         {
 773             const unsigned char *src_row = src;
 774             fb_data *dst_row = dst + LCD_WIDTH;
 775
 776             dst_end = dst_row + width;
 777
 778             if (dmask1 != 0)
 779             {
 780                 do
 781                 {
 782                     data = *src_row++;
 783                     bfunc(dst_row - LCD_WIDTH, dmask1, lcd_dibits[data&0x0F]);
 784                     bfunc(dst_row++, dmask2, lcd_dibits[(data>>4)&0x0F]);
 785                 }
 786                 while (dst_row < dst_end);
 787             }
 788             else
 789             {
 790                 do
 791                     bfunc(dst_row++, dmask2, lcd_dibits[((*src_row++)>>4)&0x0F]);
 792                 while (dst_row < dst_end);
 793             }
 794             src += stride;
 795             dst += 2*LCD_WIDTH;
 796             dmask1 = dmask2 = 0xFFu;
 797         }
 798         dmask1 &= mask_bottom;
 799                   /* & 0xFFu is unnecessary here - dmask1 can't exceed that*/
 800         dmask2 &= (mask_bottom >> 8);
 801         dst_end = dst + width;
 802
 803         if (dmask1 != 0)
 804         {
 805             if (dmask2 != 0)
 806             {
 807                 do
 808                 {
 809                     data = *src++;
 810                     bfunc(dst, dmask1, lcd_dibits[data&0x0F]);
 811                     bfunc((dst++) + LCD_WIDTH, dmask2, lcd_dibits[(data>>4)&0x0F]);
 812                 }
 813                 while (dst < dst_end);
 814             }
 815             else
 816             {
 817                 do
 818                     bfunc(dst++, dmask1, lcd_dibits[(*src++)&0x0F]);
 819                 while (dst < dst_end);
 820             }
 821         }
 822         else
 823         {
 824             do
 825                 bfunc((dst++) + LCD_WIDTH, dmask2, lcd_dibits[((*src++)>>4)&0x0F]);
 826             while (dst < dst_end);
 827         }
 828     }
 829     else
 830     {
 831         dst_end = dst + width;
 832         do
 833         {
 834             const unsigned char *src_col = src++;
 835             fb_data *dst_col = dst++;
 836             unsigned mask_col = mask;
 837             unsigned data = 0;
 838
 839             for (y = ny; y >= 8; y -= 8)
 840             {
 841                 data |= *src_col << shift;
 842
 843                 if (mask_col & 0xFFFFu)
 844                 {
 845                     if (mask_col & 0xFFu)
 846                         bfunc(dst_col, mask_col, lcd_dibits[data&0x0F]);
 847                     bfunc(dst_col + LCD_WIDTH, mask_col >> 8,
 848                           lcd_dibits[(data>>4)&0x0F]);
 849                     mask_col = 0xFFFFu;
 850                 }
 851                 else
 852                     mask_col >>= 16;
 853
 854                 src_col += stride;
 855                 dst_col += 2*LCD_WIDTH;
 856                 data >>= 8;
 857             }
 858             data |= *src_col << shift;
 859             mask_col &= mask_bottom ;
 860             if (mask_col & 0xFFu)
 861                 bfunc(dst_col, mask_col, lcd_dibits[data&0x0F]);
 862             if (mask_col & 0xFF00u)
 863                 bfunc(dst_col + LCD_WIDTH, mask_col >> 8,
 864                       lcd_dibits[(data>>4)&0x0F]);
 865         }
 866         while (dst < dst_end);
 867     }
 868 }
 869
 870 /* Draw a full monochrome bitmap */
 871 void lcd_mono_bitmap(const unsigned char *src, int x, int y, int width, int height)
 872 {
 873     lcd_mono_bitmap_part(src, 0, 0, width, x, y, width, height);
 874 }
 875
 876 /* About Rockbox' internal native bitmap format:
 877  *
 878  * A bitmap contains two bits for every pixel. 00 = white, 01 = light grey,
 879  * 10 = dark grey, 11 = black. Bits within a byte are arranged vertically, LSB
 880  * at top.
 881  * The bytes are stored in row-major order, with byte 0 being top left,
 882  * byte 1 2nd from left etc. The first row of bytes defines pixel rows
 883  * 0..3, the second row defines pixel row 4..7 etc.
 884  *
 885  * This is the same as the internal lcd hw format. */
 886
 887 /* Draw a partial native bitmap */
 888 void ICODE_ATTR lcd_bitmap_part(const fb_data *src, int src_x, int src_y,
 889                                 int stride, int x, int y, int width,
 890                                 int height)
 891 {
 892     int shift, ny;
 893     fb_data *dst, *dst_end;
 894     unsigned mask, mask_bottom;
 895
 896     /* nothing to draw? */
 897     if ((width <= 0) || (height <= 0) || (x >= current_vp->width)
 898         || (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
 899         return;
 900
 901     /* clipping */
 902     if (x < 0)
 903     {
 904         width += x;
 905         src_x -= x;
 906         x = 0;
 907     }
 908     if (y < 0)
 909     {
 910         height += y;
 911         src_y -= y;
 912         y = 0;
 913     }
 914     if (x + width > current_vp->width)
 915         width = current_vp->width - x;
 916     if (y + height > current_vp->height)
 917         height = current_vp->height - y;
 918
 919     /* adjust for viewport */
 920     x += current_vp->x;
 921     y += current_vp->y;
 922
 923     src   += stride * (src_y >> 2) + src_x; /* move starting point */
 924     src_y &= 3;
 925     y     -= src_y;
 926     dst    = &lcd_framebuffer[y>>2][x];
 927     shift  = y & 3;
 928     ny     = height - 1 + shift + src_y;
 929
 930     mask   = 0xFFu << (2 * (shift + src_y));
 931     mask_bottom = 0xFFu >> (2 * (~ny & 3));
 932
 933     if (shift == 0)
 934     {
 935         for (; ny >= 4; ny -= 4)
 936         {
 937             if (mask == 0xFFu)
 938                 memcpy(dst, src, width);
 939             else
 940             {
 941                 const fb_data *src_row = src;
 942                 fb_data *dst_row = dst;
 943
 944                 dst_end = dst_row + width;
 945                 do
 946                     setblock(dst_row++, mask, *src_row++);
 947                 while (dst_row < dst_end);
 948             }
 949             src += stride;
 950             dst += LCD_WIDTH;
 951             mask = 0xFFu;
 952         }
 953         mask &= mask_bottom;
 954
 955         if (mask == 0xFFu)
 956             memcpy(dst, src, width);
 957         else
 958         {
 959             dst_end = dst + width;
 960             do
 961                 setblock(dst++, mask, *src++);
 962             while (dst < dst_end);
 963         }
 964     }
 965     else
 966     {
 967         shift *= 2;
 968         dst_end = dst + width;
 969         do
 970         {
 971             const fb_data *src_col = src++;
 972             fb_data *dst_col = dst++;
 973             unsigned mask_col = mask;
 974             unsigned data = 0;
 975
 976             for (y = ny; y >= 4; y -= 4)
 977             {
 978                 data |= *src_col << shift;
 979
 980                 if (mask_col & 0xFFu)
 981                 {
 982                     setblock(dst_col, mask_col, data);
 983                     mask_col = 0xFFu;
 984                 }
 985                 else
 986                     mask_col >>= 8;
 987
 988                 src_col += stride;
 989                 dst_col += LCD_WIDTH;
 990                 data >>= 8;
 991             }
 992             data |= *src_col << shift;
 993             setblock(dst_col, mask_col & mask_bottom, data);
 994         }
 995         while (dst < dst_end);
 996     }
 997 }
 998
 999 /* Draw a full native bitmap */
1000 void lcd_bitmap(const fb_data *src, int x, int y, int width, int height)
1001 {
1002     lcd_bitmap_part(src, 0, 0, width, x, y, width, height);
1003 }
1004
1005 #include "lcd-bitmap-common.c"