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

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 by Alan Korr
  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
  22 #include "config.h"
  23
  24 #include "lcd.h"
  25 #include "kernel.h"
  26 #include "thread.h"
  27 #include <string.h>
  28 #include <stdlib.h>
  29 #include "file.h"
  30 #include "debug.h"
  31 #include "system.h"
  32 #include "font.h"
  33 #include "rbunicode.h"
  34 #include "bidi.h"
  35 #include "scroll_engine.h"
  36
  37 #ifndef LCDFN /* Not compiling for remote - define macros for main LCD. */
  38 #define LCDFN(fn) lcd_ ## fn
  39 #define FBFN(fn)  fb_ ## fn
  40 #define LCDM(ma) LCD_ ## ma
  41 #define LCDNAME "lcd_"
  42 #define MAIN_LCD
  43 #endif
  44
  45 /*** globals ***/
  46
  47 FBFN(data) LCDFN(framebuffer)[LCDM(FBHEIGHT)][LCDM(FBWIDTH)] IRAM_LCDFRAMEBUFFER;
  48
  49 static struct viewport default_vp =
  50 {
  51     .x        = 0,
  52     .y        = 0,
  53     .width    = LCDM(WIDTH),
  54     .height   = LCDM(HEIGHT),
  55     .font     = FONT_SYSFIXED,
  56     .drawmode = DRMODE_SOLID,
  57 };
  58
  59 static struct viewport* current_vp = &default_vp;
  60
  61 /*** Viewports ***/
  62
  63 void LCDFN(set_viewport)(struct viewport* vp)
  64 {
  65     if (vp == NULL)
  66         current_vp = &default_vp;
  67     else
  68         current_vp = vp;
  69 }
  70
  71 void LCDFN(update_viewport)(void)
  72 {
  73     LCDFN(update_rect)(current_vp->x, current_vp->y,
  74                        current_vp->width, current_vp->height);
  75 }
  76
  77 void LCDFN(update_viewport_rect)(int x, int y, int width, int height)
  78 {
  79     LCDFN(update_rect)(current_vp->x + x, current_vp->y + y, width, height);
  80 }
  81
  82 /* LCD init */
  83 void LCDFN(init)(void)
  84 {
  85     LCDFN(clear_display)();
  86 #ifndef SIMULATOR
  87     LCDFN(init_device)();
  88 #endif
  89 #ifdef MAIN_LCD
  90     scroll_init();
  91 #endif
  92 }
  93
  94 /*** parameter handling ***/
  95
  96 void LCDFN(set_drawmode)(int mode)
  97 {
  98     current_vp->drawmode = mode & (DRMODE_SOLID|DRMODE_INVERSEVID);
  99 }
 100
 101 int LCDFN(get_drawmode)(void)
 102 {
 103     return current_vp->drawmode;
 104 }
 105
 106 int LCDFN(getwidth)(void)
 107 {
 108     return current_vp->width;
 109 }
 110
 111 int LCDFN(getheight)(void)
 112 {
 113     return current_vp->height;
 114 }
 115
 116 void LCDFN(setfont)(int newfont)
 117 {
 118     current_vp->font = newfont;
 119 }
 120
 121 int LCDFN(getfont)(void)
 122 {
 123     return current_vp->font;
 124 }
 125
 126 int LCDFN(getstringsize)(const unsigned char *str, int *w, int *h)
 127 {
 128     return font_getstringsize(str, w, h, current_vp->font);
 129 }
 130
 131 /*** low-level drawing functions ***/
 132
 133 static void setpixel(int x, int y)
 134 {
 135     LCDFN(framebuffer)[y>>3][x] |= BIT_N(y & 7);
 136 }
 137
 138 static void clearpixel(int x, int y)
 139 {
 140     LCDFN(framebuffer)[y>>3][x] &= ~BIT_N(y & 7);
 141 }
 142
 143 static void flippixel(int x, int y)
 144 {
 145     LCDFN(framebuffer)[y>>3][x] ^= BIT_N(y & 7);
 146 }
 147
 148 static void nopixel(int x, int y)
 149 {
 150     (void)x;
 151     (void)y;
 152 }
 153
 154 LCDFN(pixelfunc_type)* const LCDFN(pixelfuncs)[8] = {
 155     flippixel, nopixel, setpixel, setpixel,
 156     nopixel, clearpixel, nopixel, clearpixel
 157 };
 158
 159 static void ICODE_ATTR flipblock(FBFN(data) *address, unsigned mask,
 160                                  unsigned bits)
 161 {
 162     *address ^= bits & mask;
 163 }
 164
 165 static void ICODE_ATTR bgblock(FBFN(data) *address, unsigned mask,
 166                                unsigned bits)
 167 {
 168     *address &= bits | ~mask;
 169 }
 170
 171 static void ICODE_ATTR fgblock(FBFN(data) *address, unsigned mask,
 172                                unsigned bits)
 173 {
 174     *address |= bits & mask;
 175 }
 176
 177 static void ICODE_ATTR solidblock(FBFN(data) *address, unsigned mask,
 178                                   unsigned bits)
 179 {
 180     unsigned data = *(char*)address;
 181
 182     bits    ^= data;
 183     *address = data ^ (bits & mask);
 184 }
 185
 186 static void ICODE_ATTR flipinvblock(FBFN(data) *address, unsigned mask,
 187                                     unsigned bits)
 188 {
 189     *address ^= ~bits & mask;
 190 }
 191
 192 static void ICODE_ATTR bginvblock(FBFN(data) *address, unsigned mask,
 193                                   unsigned bits)
 194 {
 195     *address &= ~(bits & mask);
 196 }
 197
 198 static void ICODE_ATTR fginvblock(FBFN(data) *address, unsigned mask,
 199                                   unsigned bits)
 200 {
 201     *address |= ~bits & mask;
 202 }
 203
 204 static void ICODE_ATTR solidinvblock(FBFN(data) *address, unsigned mask,
 205                                      unsigned bits)
 206 {
 207     unsigned data = *(char *)address;
 208
 209     bits     = ~bits ^ data;
 210     *address = data ^ (bits & mask);
 211 }
 212
 213 LCDFN(blockfunc_type)* const LCDFN(blockfuncs)[8] = {
 214     flipblock, bgblock, fgblock, solidblock,
 215     flipinvblock, bginvblock, fginvblock, solidinvblock
 216 };
 217
 218 /*** drawing functions ***/
 219
 220 /* Clear the whole display */
 221 void LCDFN(clear_display)(void)
 222 {
 223     unsigned bits = (current_vp->drawmode & DRMODE_INVERSEVID) ? 0xFFu : 0;
 224
 225     memset(LCDFN(framebuffer), bits, sizeof LCDFN(framebuffer));
 226     LCDFN(scroll_info).lines = 0;
 227 }
 228
 229 /* Clear the current viewport */
 230 void LCDFN(clear_viewport)(void)
 231 {
 232     int oldmode;
 233
 234     if (current_vp == &default_vp)
 235     {
 236         LCDFN(clear_display)();
 237     }
 238     else
 239     {
 240         oldmode = current_vp->drawmode;
 241
 242         /* Invert the INVERSEVID bit and set basic mode to SOLID */
 243         current_vp->drawmode = (~current_vp->drawmode & DRMODE_INVERSEVID) |
 244                                DRMODE_SOLID;
 245
 246         LCDFN(fillrect)(0, 0, current_vp->width, current_vp->height);
 247
 248         current_vp->drawmode = oldmode;
 249
 250         LCDFN(scroll_stop)(current_vp);
 251     }
 252 }
 253
 254 /* Set a single pixel */
 255 void LCDFN(drawpixel)(int x, int y)
 256 {
 257     if (((unsigned)x < (unsigned)current_vp->width) &&
 258         ((unsigned)y < (unsigned)current_vp->height))
 259         LCDFN(pixelfuncs)[current_vp->drawmode](current_vp->x + x, current_vp->y + y);
 260 }
 261
 262 /* Draw a line */
 263 void LCDFN(drawline)(int x1, int y1, int x2, int y2)
 264 {
 265     int numpixels;
 266     int i;
 267     int deltax, deltay;
 268     int d, dinc1, dinc2;
 269     int x, xinc1, xinc2;
 270     int y, yinc1, yinc2;
 271     LCDFN(pixelfunc_type) *pfunc = LCDFN(pixelfuncs)[current_vp->drawmode];
 272
 273     deltax = abs(x2 - x1);
 274     if (deltax == 0)
 275     {
 276         DEBUGF(LCDNAME "drawline() called for vertical line - optimisation.\n");
 277         LCDFN(vline)(x1, y1, y2);
 278         return;
 279     }
 280     deltay = abs(y2 - y1);
 281     if (deltay == 0)
 282     {
 283         DEBUGF(LCDNAME "drawline() called for horizontal line - optimisation.\n");
 284         LCDFN(hline)(x1, x2, y1);
 285         return;
 286     }
 287     xinc2 = 1;
 288     yinc2 = 1;
 289
 290     if (deltax >= deltay)
 291     {
 292         numpixels = deltax;
 293         d = 2 * deltay - deltax;
 294         dinc1 = deltay * 2;
 295         dinc2 = (deltay - deltax) * 2;
 296         xinc1 = 1;
 297         yinc1 = 0;
 298     }
 299     else
 300     {
 301         numpixels = deltay;
 302         d = 2 * deltax - deltay;
 303         dinc1 = deltax * 2;
 304         dinc2 = (deltax - deltay) * 2;
 305         xinc1 = 0;
 306         yinc1 = 1;
 307     }
 308     numpixels++; /* include endpoints */
 309
 310     if (x1 > x2)
 311     {
 312         xinc1 = -xinc1;
 313         xinc2 = -xinc2;
 314     }
 315
 316     if (y1 > y2)
 317     {
 318         yinc1 = -yinc1;
 319         yinc2 = -yinc2;
 320     }
 321
 322     x = x1;
 323     y = y1;
 324
 325     for (i = 0; i < numpixels; i++)
 326     {
 327         if (((unsigned)x < (unsigned)current_vp->width)
 328             && ((unsigned)y < (unsigned)current_vp->height))
 329             pfunc(current_vp->x + x, current_vp->y + y);
 330
 331         if (d < 0)
 332         {
 333             d += dinc1;
 334             x += xinc1;
 335             y += yinc1;
 336         }
 337         else
 338         {
 339             d += dinc2;
 340             x += xinc2;
 341             y += yinc2;
 342         }
 343     }
 344 }
 345
 346 /* Draw a horizontal line (optimised) */
 347 void LCDFN(hline)(int x1, int x2, int y)
 348 {
 349     int x, width;
 350     unsigned char *dst, *dst_end;
 351     unsigned mask;
 352     LCDFN(blockfunc_type) *bfunc;
 353
 354     /* direction flip */
 355     if (x2 < x1)
 356     {
 357         x = x1;
 358         x1 = x2;
 359         x2 = x;
 360     }
 361
 362     /* nothing to draw? */
 363     if (((unsigned)y >= (unsigned)current_vp->height) || (x1 >= current_vp->width)
 364         || (x2 < 0))
 365         return;
 366
 367     /* clipping */
 368     if (x1 < 0)
 369         x1 = 0;
 370     if (x2 >= current_vp->width)
 371         x2 = current_vp->width-1;
 372
 373     width = x2 - x1 + 1;
 374
 375     /* adjust to viewport */
 376     x1 += current_vp->x;
 377     y += current_vp->y;
 378
 379     bfunc = LCDFN(blockfuncs)[current_vp->drawmode];
 380     dst   = &LCDFN(framebuffer)[y>>3][x1];
 381     mask  = BIT_N(y & 7);
 382
 383     dst_end = dst + width;
 384     do
 385         bfunc(dst++, mask, 0xFFu);
 386     while (dst < dst_end);
 387 }
 388
 389 /* Draw a vertical line (optimised) */
 390 void LCDFN(vline)(int x, int y1, int y2)
 391 {
 392     int ny;
 393     FBFN(data) *dst;
 394     unsigned mask, mask_bottom;
 395     LCDFN(blockfunc_type) *bfunc;
 396
 397     /* direction flip */
 398     if (y2 < y1)
 399     {
 400         ny = y1;
 401         y1 = y2;
 402         y2 = ny;
 403     }
 404
 405     /* nothing to draw? */
 406     if (((unsigned)x >= (unsigned)current_vp->width) || (y1 >= current_vp->height)
 407         || (y2 < 0))
 408         return;
 409
 410     /* clipping */
 411     if (y1 < 0)
 412         y1 = 0;
 413     if (y2 >= current_vp->height)
 414         y2 = current_vp->height-1;
 415
 416     /* adjust for viewport */
 417     y1 += current_vp->y;
 418     y2 += current_vp->y;
 419     x += current_vp->x;
 420
 421     bfunc = LCDFN(blockfuncs)[current_vp->drawmode];
 422     dst   = &LCDFN(framebuffer)[y1>>3][x];
 423     ny    = y2 - (y1 & ~7);
 424     mask  = 0xFFu << (y1 & 7);
 425     mask_bottom = 0xFFu >> (~ny & 7);
 426
 427     for (; ny >= 8; ny -= 8)
 428     {
 429         bfunc(dst, mask, 0xFFu);
 430         dst += LCDM(WIDTH);
 431         mask = 0xFFu;
 432     }
 433     mask &= mask_bottom;
 434     bfunc(dst, mask, 0xFFu);
 435 }
 436
 437 /* Draw a rectangular box */
 438 void LCDFN(drawrect)(int x, int y, int width, int height)
 439 {
 440     if ((width <= 0) || (height <= 0))
 441         return;
 442
 443     int x2 = x + width - 1;
 444     int y2 = y + height - 1;
 445
 446     LCDFN(vline)(x, y, y2);
 447     LCDFN(vline)(x2, y, y2);
 448     LCDFN(hline)(x, x2, y);
 449     LCDFN(hline)(x, x2, y2);
 450 }
 451
 452 /* Fill a rectangular area */
 453 void LCDFN(fillrect)(int x, int y, int width, int height)
 454 {
 455     int ny;
 456     FBFN(data) *dst, *dst_end;
 457     unsigned mask, mask_bottom;
 458     unsigned bits = 0;
 459     LCDFN(blockfunc_type) *bfunc;
 460     bool fillopt = false;
 461
 462     /* nothing to draw? */
 463     if ((width <= 0) || (height <= 0) || (x >= current_vp->width)
 464         || (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
 465         return;
 466
 467     /* clipping */
 468     if (x < 0)
 469     {
 470         width += x;
 471         x = 0;
 472     }
 473     if (y < 0)
 474     {
 475         height += y;
 476         y = 0;
 477     }
 478     if (x + width > current_vp->width)
 479         width = current_vp->width - x;
 480     if (y + height > current_vp->height)
 481         height = current_vp->height - y;
 482
 483     /* adjust for viewport */
 484     x += current_vp->x;
 485     y += current_vp->y;
 486
 487     if (current_vp->drawmode & DRMODE_INVERSEVID)
 488     {
 489         if (current_vp->drawmode & DRMODE_BG)
 490         {
 491             fillopt = true;
 492         }
 493     }
 494     else
 495     {
 496         if (current_vp->drawmode & DRMODE_FG)
 497         {
 498             fillopt = true;
 499             bits = 0xFFu;
 500         }
 501     }
 502     bfunc = LCDFN(blockfuncs)[current_vp->drawmode];
 503     dst   = &LCDFN(framebuffer)[y>>3][x];
 504     ny    = height - 1 + (y & 7);
 505     mask  = 0xFFu << (y & 7);
 506     mask_bottom = 0xFFu >> (~ny & 7);
 507
 508     for (; ny >= 8; ny -= 8)
 509     {
 510         if (fillopt && (mask == 0xFFu))
 511             memset(dst, bits, width);
 512         else
 513         {
 514             FBFN(data) *dst_row = dst;
 515
 516             dst_end = dst_row + width;
 517             do
 518                 bfunc(dst_row++, mask, 0xFFu);
 519             while (dst_row < dst_end);
 520         }
 521
 522         dst += LCDM(WIDTH);
 523         mask = 0xFFu;
 524     }
 525     mask &= mask_bottom;
 526
 527     if (fillopt && (mask == 0xFFu))
 528         memset(dst, bits, width);
 529     else
 530     {
 531         dst_end = dst + width;
 532         do
 533             bfunc(dst++, mask, 0xFFu);
 534         while (dst < dst_end);
 535     }
 536 }
 537
 538 /* About Rockbox' internal bitmap format:
 539  *
 540  * A bitmap contains one bit for every pixel that defines if that pixel is
 541  * black (1) or white (0). Bits within a byte are arranged vertically, LSB
 542  * at top.
 543  * The bytes are stored in row-major order, with byte 0 being top left,
 544  * byte 1 2nd from left etc. The first row of bytes defines pixel rows
 545  * 0..7, the second row defines pixel row 8..15 etc.
 546  *
 547  * This is the same as the internal lcd hw format. */
 548
 549 /* Draw a partial bitmap */
 550 void ICODE_ATTR LCDFN(bitmap_part)(const unsigned char *src, int src_x,
 551                                    int src_y, int stride, int x, int y,
 552                                    int width, int height)
 553 {
 554     int shift, ny;
 555     FBFN(data) *dst, *dst_end;
 556     unsigned mask, mask_bottom;
 557     LCDFN(blockfunc_type) *bfunc;
 558
 559     /* nothing to draw? */
 560     if ((width <= 0) || (height <= 0) || (x >= current_vp->width)
 561         || (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
 562         return;
 563
 564     /* clipping */
 565     if (x < 0)
 566     {
 567         width += x;
 568         src_x -= x;
 569         x = 0;
 570     }
 571     if (y < 0)
 572     {
 573         height += y;
 574         src_y -= y;
 575         y = 0;
 576     }
 577     if (x + width > current_vp->width)
 578         width = current_vp->width - x;
 579     if (y + height > current_vp->height)
 580         height = current_vp->height - y;
 581
 582     /* adjust for viewport */
 583     x += current_vp->x;
 584     y += current_vp->y;
 585
 586     src    += stride * (src_y >> 3) + src_x; /* move starting point */
 587     src_y  &= 7;
 588     y      -= src_y;
 589     dst    = &LCDFN(framebuffer)[y>>3][x];
 590     shift  = y & 7;
 591     ny     = height - 1 + shift + src_y;
 592
 593     bfunc  = LCDFN(blockfuncs)[current_vp->drawmode];
 594     mask   = 0xFFu << (shift + src_y);
 595     mask_bottom = 0xFFu >> (~ny & 7);
 596
 597     if (shift == 0)
 598     {
 599         bool copyopt = (current_vp->drawmode == DRMODE_SOLID);
 600
 601         for (; ny >= 8; ny -= 8)
 602         {
 603             if (copyopt && (mask == 0xFFu))
 604                 memcpy(dst, src, width);
 605             else
 606             {
 607                 const unsigned char *src_row = src;
 608                 FBFN(data) *dst_row = dst;
 609
 610                 dst_end = dst_row + width;
 611                 do
 612                     bfunc(dst_row++, mask, *src_row++);
 613                 while (dst_row < dst_end);
 614             }
 615
 616             src += stride;
 617             dst += LCDM(WIDTH);
 618             mask = 0xFFu;
 619         }
 620         mask &= mask_bottom;
 621
 622         if (copyopt && (mask == 0xFFu))
 623             memcpy(dst, src, width);
 624         else
 625         {
 626             dst_end = dst + width;
 627             do
 628                 bfunc(dst++, mask, *src++);
 629             while (dst < dst_end);
 630         }
 631     }
 632     else
 633     {
 634         dst_end = dst + width;
 635         do
 636         {
 637             const unsigned char *src_col = src++;
 638             FBFN(data) *dst_col = dst++;
 639             unsigned mask_col = mask;
 640             unsigned data = 0;
 641
 642             for (y = ny; y >= 8; y -= 8)
 643             {
 644                 data |= *src_col << shift;
 645
 646                 if (mask_col & 0xFFu)
 647                 {
 648                     bfunc(dst_col, mask_col, data);
 649                     mask_col = 0xFFu;
 650                 }
 651                 else
 652                     mask_col >>= 8;
 653
 654                 src_col += stride;
 655                 dst_col += LCDM(WIDTH);
 656                 data >>= 8;
 657             }
 658             data |= *src_col << shift;
 659             bfunc(dst_col, mask_col & mask_bottom, data);
 660         }
 661         while (dst < dst_end);
 662     }
 663 }
 664
 665 /* Draw a full bitmap */
 666 void LCDFN(bitmap)(const unsigned char *src, int x, int y, int width,
 667                    int height)
 668 {
 669     LCDFN(bitmap_part)(src, 0, 0, width, x, y, width, height);
 670 }
 671
 672 #include "lcd-bitmap-common.c"