firmware/drivers/lcd-16bit.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 by Dave Chapman
  11  *
  12  * Rockbox driver for 16-bit colour LCDs
  13  *
  14  * This program is free software; you can redistribute it and/or
  15  * modify it under the terms of the GNU General Public License
  16  * as published by the Free Software Foundation; either version 2
  17  * of the License, or (at your option) any later version.
  18  *
  19  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  20  * KIND, either express or implied.
  21  *
  22  ****************************************************************************/
  23 #include "config.h"
  24
  25 #include "cpu.h"
  26 #include "lcd.h"
  27 #include "kernel.h"
  28 #include "thread.h"
  29 #include <string.h>
  30 #include <stdlib.h>
  31 #include "memory.h"
  32 #include "file.h"
  33 #include "debug.h"
  34 #include "system.h"
  35 #include "font.h"
  36 #include "rbunicode.h"
  37 #include "bidi.h"
  38 #include "scroll_engine.h"
  39
  40 enum fill_opt {
  41     OPT_NONE = 0,
  42     OPT_SET,
  43     OPT_COPY
  44 };
  45
  46 /*** globals ***/
  47 fb_data lcd_framebuffer[LCD_FBHEIGHT][LCD_FBWIDTH]
  48     IRAM_LCDFRAMEBUFFER CACHEALIGN_AT_LEAST_ATTR(16);
  49
  50
  51 static fb_data* lcd_backdrop = NULL;
  52 static long lcd_backdrop_offset IDATA_ATTR = 0;
  53
  54 static struct viewport default_vp =
  55 {
  56     .x        = 0,
  57     .y        = 0,
  58     .width    = LCD_WIDTH,
  59     .height   = LCD_HEIGHT,
  60     .font     = FONT_SYSFIXED,
  61     .drawmode = DRMODE_SOLID,
  62     .fg_pattern = LCD_DEFAULT_FG,
  63     .bg_pattern = LCD_DEFAULT_BG,
  64     .lss_pattern = LCD_DEFAULT_BG,
  65     .lse_pattern = LCD_DEFAULT_BG,
  66     .lst_pattern = LCD_DEFAULT_BG,
  67 };
  68
  69 /* The Gigabeat target build requires access to the current fg_pattern
  70    in lcd-meg-fx.c */
  71 #if (!defined(TOSHIBA_GIGABEAT_F)&& !defined(TOSHIBA_GIGABEAT_S)) || defined(SIMULATOR)
  72 static struct viewport* current_vp IDATA_ATTR = &default_vp;
  73 #else
  74 struct viewport* current_vp IDATA_ATTR = &default_vp;
  75 #endif
  76
  77
  78 /*** Helpers - consolidate optional code ***/
  79 #if defined(HAVE_LCD_ENABLE) || defined(HAVE_LCD_SLEEP)
  80 static void (*lcd_activation_hook)(void) = NULL;
  81
  82 void lcd_activation_set_hook(void (*func)(void))
  83 {
  84     lcd_activation_hook = func;
  85 }
  86
  87 /* To be called by target driver after enabling display and refreshing it */
  88 void lcd_activation_call_hook(void)
  89 {
  90     void (*func)(void) = lcd_activation_hook;
  91
  92     if (func != NULL)
  93         func();
  94 }
  95
  96 #endif
  97
  98 /* LCD init */
  99 void lcd_init(void)
 100 {
 101     lcd_clear_display();
 102
 103     /* Call device specific init */
 104     lcd_init_device();
 105     scroll_init();
 106 }
 107 /*** Viewports ***/
 108
 109 void lcd_set_viewport(struct viewport* vp)
 110 {
 111     if (vp == NULL)
 112         current_vp = &default_vp;
 113     else
 114         current_vp = vp;
 115 }
 116
 117 void lcd_update_viewport(void)
 118 {
 119     lcd_update_rect(current_vp->x, current_vp->y,
 120                     current_vp->width, current_vp->height);
 121 }
 122
 123 void lcd_update_viewport_rect(int x, int y, int width, int height)
 124 {
 125     lcd_update_rect(current_vp->x + x, current_vp->y + y, width, height);
 126 }
 127
 128 /*** parameter handling ***/
 129
 130 void lcd_set_drawmode(int mode)
 131 {
 132     current_vp->drawmode = mode & (DRMODE_SOLID|DRMODE_INVERSEVID);
 133 }
 134
 135 int lcd_get_drawmode(void)
 136 {
 137     return current_vp->drawmode;
 138 }
 139
 140 void lcd_set_foreground(unsigned color)
 141 {
 142     current_vp->fg_pattern = color;
 143 }
 144
 145 unsigned lcd_get_foreground(void)
 146 {
 147     return current_vp->fg_pattern;
 148 }
 149
 150 void lcd_set_background(unsigned color)
 151 {
 152     current_vp->bg_pattern = color;
 153 }
 154
 155 unsigned lcd_get_background(void)
 156 {
 157     return current_vp->bg_pattern;
 158 }
 159
 160 void lcd_set_selector_start(unsigned color)
 161 {
 162     current_vp->lss_pattern = color;
 163 }
 164
 165 void lcd_set_selector_end(unsigned color)
 166 {
 167     current_vp->lse_pattern = color;
 168 }
 169
 170 void lcd_set_selector_text(unsigned color)
 171 {
 172     current_vp->lst_pattern = color;
 173 }
 174
 175 void lcd_set_drawinfo(int mode, unsigned fg_color, unsigned bg_color)
 176 {
 177     lcd_set_drawmode(mode);
 178     current_vp->fg_pattern = fg_color;
 179     current_vp->bg_pattern = bg_color;
 180 }
 181
 182 int lcd_getwidth(void)
 183 {
 184     return current_vp->width;
 185 }
 186
 187 int lcd_getheight(void)
 188 {
 189     return current_vp->height;
 190 }
 191
 192 void lcd_setfont(int newfont)
 193 {
 194     current_vp->font = newfont;
 195 }
 196
 197 int lcd_getfont(void)
 198 {
 199     return current_vp->font;
 200 }
 201
 202 int lcd_getstringsize(const unsigned char *str, int *w, int *h)
 203 {
 204     return font_getstringsize(str, w, h, current_vp->font);
 205 }
 206
 207 /*** low-level drawing functions ***/
 208
 209 #define LCDADDR(x, y) (&lcd_framebuffer[(y)][(x)])
 210
 211 static void ICODE_ATTR setpixel(fb_data *address)
 212 {
 213     *address = current_vp->fg_pattern;
 214 }
 215
 216 static void ICODE_ATTR clearpixel(fb_data *address)
 217 {
 218     *address = current_vp->bg_pattern;
 219 }
 220
 221 static void ICODE_ATTR clearimgpixel(fb_data *address)
 222 {
 223     *address = *(fb_data *)((long)address + lcd_backdrop_offset);
 224 }
 225
 226 static void ICODE_ATTR flippixel(fb_data *address)
 227 {
 228     *address = ~(*address);
 229 }
 230
 231 static void ICODE_ATTR nopixel(fb_data *address)
 232 {
 233     (void)address;
 234 }
 235
 236 lcd_fastpixelfunc_type* const lcd_fastpixelfuncs_bgcolor[8] = {
 237     flippixel, nopixel, setpixel, setpixel,
 238     nopixel, clearpixel, nopixel, clearpixel
 239 };
 240
 241 lcd_fastpixelfunc_type* const lcd_fastpixelfuncs_backdrop[8] = {
 242     flippixel, nopixel, setpixel, setpixel,
 243     nopixel, clearimgpixel, nopixel, clearimgpixel
 244 };
 245
 246 lcd_fastpixelfunc_type* const * lcd_fastpixelfuncs = lcd_fastpixelfuncs_bgcolor;
 247
 248 void lcd_set_backdrop(fb_data* backdrop)
 249 {
 250     lcd_backdrop = backdrop;
 251     if (backdrop)
 252     {
 253         lcd_backdrop_offset = (long)backdrop - (long)&lcd_framebuffer[0][0];
 254         lcd_fastpixelfuncs = lcd_fastpixelfuncs_backdrop;
 255     }
 256     else
 257     {
 258         lcd_backdrop_offset = 0;
 259         lcd_fastpixelfuncs = lcd_fastpixelfuncs_bgcolor;
 260     }
 261 }
 262
 263 fb_data* lcd_get_backdrop(void)
 264 {
 265     return lcd_backdrop;
 266 }
 267
 268 /*** drawing functions ***/
 269
 270 /* Clear the current viewport */
 271 void lcd_clear_viewport(void)
 272 {
 273     fb_data *dst, *dst_end;
 274
 275     dst = LCDADDR(current_vp->x, current_vp->y);
 276     dst_end = dst + current_vp->height * LCD_WIDTH;
 277
 278     if (current_vp->drawmode & DRMODE_INVERSEVID)
 279     {
 280         do
 281         {
 282             memset16(dst, current_vp->fg_pattern, current_vp->width);
 283             dst += LCD_WIDTH;
 284         }
 285         while (dst < dst_end);
 286     }
 287     else
 288     {
 289         if (!lcd_backdrop)
 290         {
 291             do
 292             {
 293                 memset16(dst, current_vp->bg_pattern, current_vp->width);
 294                 dst += LCD_WIDTH;
 295             }
 296             while (dst < dst_end);
 297         }
 298         else
 299         {
 300             do
 301             {
 302                 memcpy(dst, (void *)((long)dst + lcd_backdrop_offset),
 303                        current_vp->width * sizeof(fb_data));
 304                 dst += LCD_WIDTH;
 305             }
 306             while (dst < dst_end);
 307         }
 308     }
 309
 310     if (current_vp == &default_vp)
 311     {
 312         lcd_scroll_info.lines = 0;
 313     }
 314     else
 315     {
 316         lcd_scroll_stop(current_vp);
 317     }
 318 }
 319
 320 /* Clear the whole display */
 321 void lcd_clear_display(void)
 322 {
 323     struct viewport* old_vp = current_vp;
 324
 325     current_vp = &default_vp;
 326
 327     lcd_clear_viewport();
 328
 329     current_vp = old_vp;
 330 }
 331
 332 /* Set a single pixel */
 333 void lcd_drawpixel(int x, int y)
 334 {
 335     if (((unsigned)x < (unsigned)current_vp->width) &&
 336         ((unsigned)y < (unsigned)current_vp->height))
 337         lcd_fastpixelfuncs[current_vp->drawmode](LCDADDR(current_vp->x+x, current_vp->y+y));
 338 }
 339
 340 /* Draw a line */
 341 void lcd_drawline(int x1, int y1, int x2, int y2)
 342 {
 343     int numpixels;
 344     int i;
 345     int deltax, deltay;
 346     int d, dinc1, dinc2;
 347     int x, xinc1, xinc2;
 348     int y, yinc1, yinc2;
 349     lcd_fastpixelfunc_type *pfunc = lcd_fastpixelfuncs[current_vp->drawmode];
 350
 351     deltay = abs(y2 - y1);
 352     if (deltay == 0)
 353     {
 354         DEBUGF("lcd_drawline() called for horizontal line - optimisation.\n");
 355         lcd_hline(x1, x2, y1);
 356         return;
 357     }
 358     deltax = abs(x2 - x1);
 359     if (deltax == 0)
 360     {
 361         DEBUGF("lcd_drawline() called for vertical line - optimisation.\n");
 362         lcd_vline(x1, y1, y2);
 363         return;
 364     }
 365     xinc2 = 1;
 366     yinc2 = 1;
 367
 368     if (deltax >= deltay)
 369     {
 370         numpixels = deltax;
 371         d = 2 * deltay - deltax;
 372         dinc1 = deltay * 2;
 373         dinc2 = (deltay - deltax) * 2;
 374         xinc1 = 1;
 375         yinc1 = 0;
 376     }
 377     else
 378     {
 379         numpixels = deltay;
 380         d = 2 * deltax - deltay;
 381         dinc1 = deltax * 2;
 382         dinc2 = (deltax - deltay) * 2;
 383         xinc1 = 0;
 384         yinc1 = 1;
 385     }
 386     numpixels++; /* include endpoints */
 387
 388     if (x1 > x2)
 389     {
 390         xinc1 = -xinc1;
 391         xinc2 = -xinc2;
 392     }
 393
 394     if (y1 > y2)
 395     {
 396         yinc1 = -yinc1;
 397         yinc2 = -yinc2;
 398     }
 399
 400     x = x1;
 401     y = y1;
 402
 403     for (i = 0; i < numpixels; i++)
 404     {
 405         if (((unsigned)x < (unsigned)current_vp->width) && ((unsigned)y < (unsigned)current_vp->height))
 406             pfunc(LCDADDR(x + current_vp->x, y + current_vp->y));
 407
 408         if (d < 0)
 409         {
 410             d += dinc1;
 411             x += xinc1;
 412             y += yinc1;
 413         }
 414         else
 415         {
 416             d += dinc2;
 417             x += xinc2;
 418             y += yinc2;
 419         }
 420     }
 421 }
 422
 423 /* Draw a horizontal line (optimised) */
 424 void lcd_hline(int x1, int x2, int y)
 425 {
 426     int x, width;
 427     unsigned bits = 0;
 428     enum fill_opt fillopt = OPT_NONE;
 429     fb_data *dst, *dst_end;
 430
 431     /* direction flip */
 432     if (x2 < x1)
 433     {
 434         x = x1;
 435         x1 = x2;
 436         x2 = x;
 437     }
 438
 439     /* nothing to draw? */
 440     if (((unsigned)y >= (unsigned)current_vp->height) ||
 441         (x1 >= current_vp->width) ||
 442         (x2 < 0))
 443         return;
 444
 445     /* drawmode and optimisation */
 446     if (current_vp->drawmode & DRMODE_INVERSEVID)
 447     {
 448         if (current_vp->drawmode & DRMODE_BG)
 449         {
 450             if (!lcd_backdrop)
 451             {
 452                 fillopt = OPT_SET;
 453                 bits = current_vp->bg_pattern;
 454             }
 455             else
 456                 fillopt = OPT_COPY;
 457         }
 458     }
 459     else
 460     {
 461         if (current_vp->drawmode & DRMODE_FG)
 462         {
 463             fillopt = OPT_SET;
 464             bits = current_vp->fg_pattern;
 465         }
 466     }
 467     if (fillopt == OPT_NONE && current_vp->drawmode != DRMODE_COMPLEMENT)
 468         return;
 469
 470     /* clipping */
 471     if (x1 < 0)
 472         x1 = 0;
 473     if (x2 >= current_vp->width)
 474         x2 = current_vp->width-1;
 475
 476     width = x2 - x1 + 1;
 477
 478     /* Adjust x1 and y to viewport */
 479     x1 += current_vp->x;
 480     y += current_vp->y;
 481
 482     dst = LCDADDR(x1, y);
 483
 484     switch (fillopt)
 485     {
 486       case OPT_SET:
 487         memset16(dst, bits, width);
 488         break;
 489
 490       case OPT_COPY:
 491         memcpy(dst, (void *)((long)dst + lcd_backdrop_offset),
 492                width * sizeof(fb_data));
 493         break;
 494
 495       case OPT_NONE:  /* DRMODE_COMPLEMENT */
 496         dst_end = dst + width;
 497         do
 498             *dst = ~(*dst);
 499         while (++dst < dst_end);
 500         break;
 501     }
 502 }
 503
 504 /* Draw a vertical line (optimised) */
 505 void lcd_vline(int x, int y1, int y2)
 506 {
 507     int y;
 508     fb_data *dst, *dst_end;
 509     lcd_fastpixelfunc_type *pfunc = lcd_fastpixelfuncs[current_vp->drawmode];
 510
 511     /* direction flip */
 512     if (y2 < y1)
 513     {
 514         y = y1;
 515         y1 = y2;
 516         y2 = y;
 517     }
 518
 519     /* nothing to draw? */
 520     if (((unsigned)x >= (unsigned)current_vp->width) ||
 521         (y1 >= current_vp->height) ||
 522         (y2 < 0))
 523         return;
 524
 525     /* clipping */
 526     if (y1 < 0)
 527         y1 = 0;
 528     if (y2 >= current_vp->height)
 529         y2 = current_vp->height-1;
 530
 531     dst = LCDADDR(x + current_vp->x, y1 + current_vp->y);
 532     dst_end = dst + (y2 - y1) * LCD_WIDTH;
 533
 534     do
 535     {
 536         pfunc(dst);
 537         dst += LCD_WIDTH;
 538     }
 539     while (dst <= dst_end);
 540 }
 541
 542 /* Draw a rectangular box */
 543 void lcd_drawrect(int x, int y, int width, int height)
 544 {
 545     if ((width <= 0) || (height <= 0))
 546         return;
 547
 548     int x2 = x + width - 1;
 549     int y2 = y + height - 1;
 550
 551     lcd_vline(x, y, y2);
 552     lcd_vline(x2, y, y2);
 553     lcd_hline(x, x2, y);
 554     lcd_hline(x, x2, y2);
 555 }
 556
 557 /* Fill a rectangular area */
 558 void lcd_fillrect(int x, int y, int width, int height)
 559 {
 560     unsigned bits = 0;
 561     enum fill_opt fillopt = OPT_NONE;
 562     fb_data *dst, *dst_end;
 563
 564     /* nothing to draw? */
 565     if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
 566         (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
 567         return;
 568
 569     /* drawmode and optimisation */
 570     if (current_vp->drawmode & DRMODE_INVERSEVID)
 571     {
 572         if (current_vp->drawmode & DRMODE_BG)
 573         {
 574             if (!lcd_backdrop)
 575             {
 576                 fillopt = OPT_SET;
 577                 bits = current_vp->bg_pattern;
 578             }
 579             else
 580                 fillopt = OPT_COPY;
 581         }
 582     }
 583     else
 584     {
 585         if (current_vp->drawmode & DRMODE_FG)
 586         {
 587             fillopt = OPT_SET;
 588             bits = current_vp->fg_pattern;
 589         }
 590     }
 591     if (fillopt == OPT_NONE && current_vp->drawmode != DRMODE_COMPLEMENT)
 592         return;
 593
 594     /* clipping */
 595     if (x < 0)
 596     {
 597         width += x;
 598         x = 0;
 599     }
 600     if (y < 0)
 601     {
 602         height += y;
 603         y = 0;
 604     }
 605     if (x + width > current_vp->width)
 606         width = current_vp->width - x;
 607     if (y + height > current_vp->height)
 608         height = current_vp->height - y;
 609
 610     dst = LCDADDR(current_vp->x + x, current_vp->y + y);
 611     dst_end = dst + height * LCD_WIDTH;
 612
 613     do
 614     {
 615         fb_data *dst_row, *row_end;
 616
 617         switch (fillopt)
 618         {
 619           case OPT_SET:
 620             memset16(dst, bits, width);
 621             break;
 622
 623           case OPT_COPY:
 624             memcpy(dst, (void *)((long)dst + lcd_backdrop_offset),
 625                    width * sizeof(fb_data));
 626             break;
 627
 628           case OPT_NONE:  /* DRMODE_COMPLEMENT */
 629             dst_row = dst;
 630             row_end = dst_row + width;
 631             do
 632                 *dst_row = ~(*dst_row);
 633             while (++dst_row < row_end);
 634             break;
 635         }
 636         dst += LCD_WIDTH;
 637     }
 638     while (dst < dst_end);
 639 }
 640
 641 /* Fill a rectangle with a gradient */
 642 static void lcd_gradient_rect(int x1, int x2, int y, int h)
 643 {
 644     int old_pattern = current_vp->fg_pattern;
 645
 646     if (h == 0) return;
 647
 648     int h_r = RGB_UNPACK_RED(current_vp->lss_pattern) << 16;
 649     int h_b = RGB_UNPACK_BLUE(current_vp->lss_pattern) << 16;
 650     int h_g = RGB_UNPACK_GREEN(current_vp->lss_pattern) << 16;
 651     int rstep = (h_r - ((signed)RGB_UNPACK_RED(current_vp->lse_pattern) << 16)) / h;
 652     int gstep = (h_g - ((signed)RGB_UNPACK_GREEN(current_vp->lse_pattern) << 16)) / h;
 653     int bstep = (h_b - ((signed)RGB_UNPACK_BLUE(current_vp->lse_pattern) << 16)) / h;
 654     int count;
 655
 656     current_vp->fg_pattern = current_vp->lss_pattern;
 657     for(count = 0; count < h; count++) {
 658         lcd_hline(x1, x2, y + count);
 659         h_r -= rstep;
 660         h_g -= gstep;
 661         h_b -= bstep;
 662         current_vp->fg_pattern = LCD_RGBPACK(h_r >> 16, h_g >> 16, h_b >> 16);
 663     }
 664
 665     current_vp->fg_pattern = old_pattern;
 666 }
 667
 668 #define H_COLOR(lss, lse, cur_line, max_line) \
 669         (((lse) - (lss)) * (cur_line) / (max_line) + (lss))
 670
 671 /* Fill a rectangle with a gradient for scrolling line. To draw a gradient that
 672    covers several lines, we need to know how many lines will be covered
 673    (the num_lines arg), and which one is the current line within the selection
 674    (the cur_line arg). */
 675 static void lcd_gradient_rect_scroll(int x1, int x2, int y, int h,
 676                                      unsigned char num_lines, unsigned char cur_line)
 677 {
 678     if (h == 0 || num_lines == 0) return;
 679
 680     unsigned tmp_lss = current_vp->lss_pattern;
 681     unsigned tmp_lse = current_vp->lse_pattern;
 682     int lss_r = (signed)RGB_UNPACK_RED(current_vp->lss_pattern);
 683     int lss_b = (signed)RGB_UNPACK_BLUE(current_vp->lss_pattern);
 684     int lss_g = (signed)RGB_UNPACK_GREEN(current_vp->lss_pattern);
 685     int lse_r = (signed)RGB_UNPACK_RED(current_vp->lse_pattern);
 686     int lse_b = (signed)RGB_UNPACK_BLUE(current_vp->lse_pattern);
 687     int lse_g = (signed)RGB_UNPACK_GREEN(current_vp->lse_pattern);
 688
 689     int h_r = H_COLOR(lss_r, lse_r, cur_line, num_lines);
 690     int h_g = H_COLOR(lss_g, lse_g, cur_line, num_lines);
 691     int h_b = H_COLOR(lss_b, lse_b, cur_line, num_lines);
 692     lcd_set_selector_start(LCD_RGBPACK(h_r, h_g, h_b));
 693
 694     int l_r = H_COLOR(lss_r, lse_r, cur_line+1, num_lines);
 695     int l_g = H_COLOR(lss_g, lse_g, cur_line+1, num_lines);
 696     int l_b = H_COLOR(lss_b, lse_b, cur_line+1, num_lines);
 697     lcd_set_selector_end(LCD_RGBPACK(l_r, l_g, l_b));
 698
 699     lcd_gradient_rect(x1, x2, y, h);
 700
 701     current_vp->lss_pattern = tmp_lss;
 702     current_vp->lse_pattern = tmp_lse;
 703 }
 704
 705 /* About Rockbox' internal monochrome bitmap format:
 706  *
 707  * A bitmap contains one bit for every pixel that defines if that pixel is
 708  * black (1) or white (0). Bits within a byte are arranged vertically, LSB
 709  * at top.
 710  * The bytes are stored in row-major order, with byte 0 being top left,
 711  * byte 1 2nd from left etc. The first row of bytes defines pixel rows
 712  * 0..7, the second row defines pixel row 8..15 etc.
 713  *
 714  * This is the mono bitmap format used on all other targets so far; the
 715  * pixel packing doesn't really matter on a 8bit+ target. */
 716
 717 /* Draw a partial monochrome bitmap */
 718
 719 void ICODE_ATTR lcd_mono_bitmap_part(const unsigned char *src, int src_x,
 720                                      int src_y, int stride, int x, int y,
 721                                      int width, int height)
 722 {
 723     const unsigned char *src_end;
 724     fb_data *dst, *dst_end;
 725     unsigned dmask = 0x100; /* bit 8 == sentinel */
 726     int drmode = current_vp->drawmode;
 727
 728     /* nothing to draw? */
 729     if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
 730         (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
 731         return;
 732
 733     /* clipping */
 734     if (x < 0)
 735     {
 736         width += x;
 737         src_x -= x;
 738         x = 0;
 739     }
 740     if (y < 0)
 741     {
 742         height += y;
 743         src_y -= y;
 744         y = 0;
 745     }
 746     if (x + width > current_vp->width)
 747         width = current_vp->width - x;
 748     if (y + height > current_vp->height)
 749         height = current_vp->height - y;
 750
 751     src += stride * (src_y >> 3) + src_x; /* move starting point */
 752     src_y  &= 7;
 753     src_end = src + width;
 754     dst = LCDADDR(current_vp->x + x, current_vp->y + y);
 755
 756     if (drmode & DRMODE_INVERSEVID)
 757     {
 758         dmask = 0x1ff;          /* bit 8 == sentinel */
 759         drmode &= DRMODE_SOLID; /* mask out inversevid */
 760     }
 761
 762     do
 763     {
 764         const unsigned char *src_col = src++;
 765         unsigned data = (*src_col ^ dmask) >> src_y;
 766         fb_data *dst_col = dst++;
 767         int fg, bg;
 768         long bo;
 769
 770         dst_end = dst_col + height * LCD_WIDTH;
 771
 772 #define UPDATE_SRC  do {                  \
 773             data >>= 1;                   \
 774             if (data == 0x001) {          \
 775                 src_col += stride;        \
 776                 data = *src_col ^ dmask;  \
 777             }                             \
 778         } while (0)
 779
 780         switch (drmode)
 781         {
 782           case DRMODE_COMPLEMENT:
 783             do
 784             {
 785                 if (data & 0x01)
 786                     *dst_col = ~(*dst_col);
 787
 788                 dst_col += LCD_WIDTH;
 789                 UPDATE_SRC;
 790             }
 791             while (dst_col < dst_end);
 792             break;
 793
 794           case DRMODE_BG:
 795             if (lcd_backdrop)
 796             {
 797                 bo = lcd_backdrop_offset;
 798                 do
 799                 {
 800                     if (!(data & 0x01))
 801                         *dst_col = *(fb_data *)((long)dst_col + bo);
 802
 803                     dst_col += LCD_WIDTH;
 804                     UPDATE_SRC;
 805                 }
 806                 while (dst_col < dst_end);
 807             }
 808             else
 809             {
 810                 bg = current_vp->bg_pattern;
 811                 do
 812                 {
 813                     if (!(data & 0x01))
 814                         *dst_col = bg;
 815
 816                     dst_col += LCD_WIDTH;
 817                     UPDATE_SRC;
 818                 }
 819                 while (dst_col < dst_end);
 820             }
 821             break;
 822
 823           case DRMODE_FG:
 824             fg = current_vp->fg_pattern;
 825             do
 826             {
 827                 if (data & 0x01)
 828                     *dst_col = fg;
 829
 830                 dst_col += LCD_WIDTH;
 831                 UPDATE_SRC;
 832             }
 833             while (dst_col < dst_end);
 834             break;
 835
 836           case DRMODE_SOLID:
 837             fg = current_vp->fg_pattern;
 838             if (lcd_backdrop)
 839             {
 840                 bo = lcd_backdrop_offset;
 841                 do
 842                 {
 843                     *dst_col = (data & 0x01) ? fg
 844                                : *(fb_data *)((long)dst_col + bo);
 845                     dst_col += LCD_WIDTH;
 846                     UPDATE_SRC;
 847                 }
 848                 while (dst_col < dst_end);
 849             }
 850             else
 851             {
 852                 bg = current_vp->bg_pattern;
 853                 do
 854                 {
 855                     *dst_col = (data & 0x01) ? fg : bg;
 856                     dst_col += LCD_WIDTH;
 857                     UPDATE_SRC;
 858                 }
 859                 while (dst_col < dst_end);
 860             }
 861             break;
 862         }
 863     }
 864     while (src < src_end);
 865 }
 866 /* Draw a full monochrome bitmap */
 867 void lcd_mono_bitmap(const unsigned char *src, int x, int y, int width, int height)
 868 {
 869     lcd_mono_bitmap_part(src, 0, 0, width, x, y, width, height);
 870 }
 871
 872 /* Draw a partial native bitmap */
 873 void ICODE_ATTR lcd_bitmap_part(const fb_data *src, int src_x, int src_y,
 874                                 int stride, int x, int y, int width,
 875                                 int height)
 876 {
 877     fb_data *dst, *dst_end;
 878
 879     /* nothing to draw? */
 880     if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
 881         (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
 882         return;
 883
 884     /* clipping */
 885     if (x < 0)
 886     {
 887         width += x;
 888         src_x -= x;
 889         x = 0;
 890     }
 891     if (y < 0)
 892     {
 893         height += y;
 894         src_y -= y;
 895         y = 0;
 896     }
 897     if (x + width > current_vp->width)
 898         width = current_vp->width - x;
 899     if (y + height > current_vp->height)
 900         height = current_vp->height - y;
 901
 902     src += stride * src_y + src_x; /* move starting point */
 903     dst = LCDADDR(current_vp->x + x, current_vp->y + y);
 904     dst_end = dst + height * LCD_WIDTH;
 905
 906     do
 907     {
 908         memcpy(dst, src, width * sizeof(fb_data));
 909         src += stride;
 910         dst += LCD_WIDTH;
 911     }
 912     while (dst < dst_end);
 913 }
 914
 915 /* Draw a full native bitmap */
 916 void lcd_bitmap(const fb_data *src, int x, int y, int width, int height)
 917 {
 918     lcd_bitmap_part(src, 0, 0, width, x, y, width, height);
 919 }
 920
 921 #if !defined(TOSHIBA_GIGABEAT_F) && !defined(TOSHIBA_GIGABEAT_S) \
 922     || defined(SIMULATOR)
 923 /* Draw a partial native bitmap */
 924 void ICODE_ATTR lcd_bitmap_transparent_part(const fb_data *src, int src_x,
 925                                             int src_y, int stride, int x,
 926                                             int y, int width, int height)
 927 {
 928     fb_data *dst, *dst_end;
 929
 930     /* nothing to draw? */
 931     if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
 932         (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
 933         return;
 934
 935     /* clipping */
 936     if (x < 0)
 937     {
 938         width += x;
 939         src_x -= x;
 940         x = 0;
 941     }
 942     if (y < 0)
 943     {
 944         height += y;
 945         src_y -= y;
 946         y = 0;
 947     }
 948     if (x + width > current_vp->width)
 949         width = current_vp->width - x;
 950     if (y + height > current_vp->height)
 951         height = current_vp->height - y;
 952
 953     src += stride * src_y + src_x; /* move starting point */
 954     dst = LCDADDR(current_vp->x + x, current_vp->y + y);
 955     dst_end = dst + height * LCD_WIDTH;
 956
 957     do
 958     {
 959         int i;
 960         for(i = 0;i < width;i++)
 961         {
 962             if (src[i] == REPLACEWITHFG_COLOR)
 963                 dst[i] = current_vp->fg_pattern;
 964             else if(src[i] != TRANSPARENT_COLOR)
 965                 dst[i] = src[i];
 966         }
 967         src += stride;
 968         dst += LCD_WIDTH;
 969     }
 970     while (dst < dst_end);
 971 }
 972 #endif /* !defined(TOSHIBA_GIGABEAT_F) || defined(SIMULATOR) */
 973
 974 /* Draw a full native bitmap with a transparent color */
 975 void lcd_bitmap_transparent(const fb_data *src, int x, int y,
 976                             int width, int height)
 977 {
 978     lcd_bitmap_transparent_part(src, 0, 0, width, x, y, width, height);
 979 }
 980
 981 /* put a string at a given pixel position, skipping first ofs pixel columns */
 982 static void lcd_putsxyofs(int x, int y, int ofs, const unsigned char *str)
 983 {
 984     unsigned short ch;
 985     unsigned short *ucs;
 986     struct font* pf = font_get(current_vp->font);
 987
 988     ucs = bidi_l2v(str, 1);
 989
 990     while ((ch = *ucs++) != 0 && x < current_vp->width)
 991     {
 992         int width;
 993         const unsigned char *bits;
 994
 995         /* get proportional width and glyph bits */
 996         width = font_get_width(pf,ch);
 997
 998         if (ofs > width)
 999         {
1000             ofs -= width;
1001             continue;
1002         }
1003
1004         bits = font_get_bits(pf, ch);
1005
1006         lcd_mono_bitmap_part(bits, ofs, 0, width, x, y, width - ofs, pf->height);
1007
1008         x += width - ofs;
1009         ofs = 0;
1010     }
1011 }
1012
1013 /* put a string at a given pixel position */
1014 void lcd_putsxy(int x, int y, const unsigned char *str)
1015 {
1016     lcd_putsxyofs(x, y, 0, str);
1017 }
1018
1019 /*** line oriented text output ***/
1020
1021 /* put a string at a given char position */
1022 void lcd_puts(int x, int y, const unsigned char *str)
1023 {
1024     lcd_puts_style_offset(x, y, str, STYLE_DEFAULT, 0);
1025 }
1026
1027 void lcd_puts_style(int x, int y, const unsigned char *str, int style)
1028 {
1029     lcd_puts_style_offset(x, y, str, style, 0);
1030 }
1031
1032 void lcd_puts_offset(int x, int y, const unsigned char *str, int offset)
1033 {
1034     lcd_puts_style_offset(x, y, str, STYLE_DEFAULT, offset);
1035 }
1036
1037 /* put a string at a given char position, style, and pixel position,
1038  * skipping first offset pixel columns */
1039 void lcd_puts_style_offset(int x, int y, const unsigned char *str, int style,
1040                            int offset)
1041 {
1042     int xpos,ypos,w,h,xrect;
1043     int lastmode = current_vp->drawmode;
1044     int oldfgcolor = current_vp->fg_pattern;
1045     int oldbgcolor = current_vp->bg_pattern;
1046
1047     /* make sure scrolling is turned off on the line we are updating */
1048     lcd_scroll_stop_line(current_vp, y);
1049
1050     if(!str || !str[0])
1051         return;
1052
1053     lcd_getstringsize(str, &w, &h);
1054     xpos = x*w / utf8length(str);
1055     ypos = y*h;
1056     current_vp->drawmode = (style & STYLE_INVERT) ?
1057                (DRMODE_SOLID|DRMODE_INVERSEVID) : DRMODE_SOLID;
1058     if (style & STYLE_COLORED) {
1059         if (current_vp->drawmode == DRMODE_SOLID)
1060             current_vp->fg_pattern = style & STYLE_COLOR_MASK;
1061         else
1062             current_vp->bg_pattern = style & STYLE_COLOR_MASK;
1063     }
1064     current_vp->drawmode ^= DRMODE_INVERSEVID;
1065     xrect = xpos + MAX(w - offset, 0);
1066
1067     if (style & STYLE_GRADIENT) {
1068         current_vp->drawmode = DRMODE_FG;
1069         if (CURLN_UNPACK(style) == 0)
1070             lcd_gradient_rect(xpos, current_vp->width, ypos, h*NUMLN_UNPACK(style));
1071         current_vp->fg_pattern = current_vp->lst_pattern;
1072     }
1073     else if (style & STYLE_COLORBAR) {
1074         current_vp->drawmode = DRMODE_FG;
1075         current_vp->fg_pattern = current_vp->lss_pattern;
1076         lcd_fillrect(xpos, ypos, current_vp->width - xpos, h);
1077         current_vp->fg_pattern = current_vp->lst_pattern;
1078     }
1079     else {
1080         lcd_fillrect(xrect, ypos, current_vp->width - xrect, h);
1081         current_vp->drawmode = (style & STYLE_INVERT) ?
1082         (DRMODE_SOLID|DRMODE_INVERSEVID) : DRMODE_SOLID;
1083     }
1084     lcd_putsxyofs(xpos, ypos, offset, str);
1085     current_vp->drawmode = lastmode;
1086     current_vp->fg_pattern = oldfgcolor;
1087     current_vp->bg_pattern = oldbgcolor;
1088 }
1089
1090 /*** scrolling ***/
1091 void lcd_puts_scroll(int x, int y, const unsigned char *string)
1092 {
1093     lcd_puts_scroll_style(x, y, string, STYLE_DEFAULT);
1094 }
1095
1096 void lcd_puts_scroll_style(int x, int y, const unsigned char *string, int style)
1097 {
1098      lcd_puts_scroll_style_offset(x, y, string, style, 0);
1099 }
1100
1101 void lcd_puts_scroll_offset(int x, int y, const unsigned char *string, int offset)
1102 {
1103      lcd_puts_scroll_style_offset(x, y, string, STYLE_DEFAULT, offset);
1104 }
1105
1106 /* Initialise a scrolling line at (x,y) in current viewport */
1107
1108 void lcd_puts_scroll_style_offset(int x, int y, const unsigned char *string,
1109                                          int style, int offset)
1110 {
1111     struct scrollinfo* s;
1112     int w, h;
1113
1114     if ((unsigned)y >= (unsigned)current_vp->height)
1115         return;
1116
1117     /* remove any previously scrolling line at the same location */
1118     lcd_scroll_stop_line(current_vp, y);
1119
1120     if (lcd_scroll_info.lines >= LCD_SCROLLABLE_LINES) return;
1121
1122     s = &lcd_scroll_info.scroll[lcd_scroll_info.lines];
1123
1124     s->start_tick = current_tick + lcd_scroll_info.delay;
1125     s->style = style;
1126     lcd_puts_style_offset(x,y,string,style,offset);
1127
1128     lcd_getstringsize(string, &w, &h);
1129
1130     if (current_vp->width - x * 8 < w) {
1131         /* prepare scroll line */
1132         char *end;
1133
1134         memset(s->line, 0, sizeof s->line);
1135         strcpy(s->line, string);
1136
1137         /* get width */
1138         s->width = lcd_getstringsize(s->line, &w, &h);
1139
1140         /* scroll bidirectional or forward only depending on the string
1141            width */
1142         if ( lcd_scroll_info.bidir_limit ) {
1143             s->bidir = s->width < (current_vp->width) *
1144                 (100 + lcd_scroll_info.bidir_limit) / 100;
1145         }
1146         else
1147             s->bidir = false;
1148
1149         if (!s->bidir) { /* add spaces if scrolling in the round */
1150             strcat(s->line, "   ");
1151             /* get new width incl. spaces */
1152             s->width = lcd_getstringsize(s->line, &w, &h);
1153         }
1154
1155         end = strchr(s->line, '\0');
1156         strncpy(end, string, current_vp->width/2);
1157
1158         s->vp = current_vp;
1159         s->y = y;
1160         s->len = utf8length(string);
1161         s->offset = offset;
1162         s->startx = x * s->width / s->len;
1163         s->backward = false;
1164         lcd_scroll_info.lines++;
1165     }
1166 }
1167
1168 void lcd_scroll_fn(void)
1169 {
1170     struct font* pf;
1171     struct scrollinfo* s;
1172     int index;
1173     int xpos, ypos;
1174     int lastmode;
1175     unsigned old_fgcolor;
1176     unsigned old_bgcolor;
1177     struct viewport* old_vp = current_vp;
1178
1179     for ( index = 0; index < lcd_scroll_info.lines; index++ ) {
1180         s = &lcd_scroll_info.scroll[index];
1181
1182         /* check pause */
1183         if (TIME_BEFORE(current_tick, s->start_tick))
1184             continue;
1185
1186         lcd_set_viewport(s->vp);
1187         old_fgcolor = current_vp->fg_pattern;
1188         old_bgcolor = current_vp->bg_pattern;
1189
1190         if (s->style&STYLE_COLORED) {
1191             if (s->style&STYLE_MODE_MASK) {
1192                 current_vp->fg_pattern = old_fgcolor;
1193                 current_vp->bg_pattern = s->style&STYLE_COLOR_MASK;
1194             }
1195             else {
1196                 current_vp->fg_pattern = s->style&STYLE_COLOR_MASK;
1197                 current_vp->bg_pattern = old_bgcolor;
1198             }
1199         }
1200
1201         if (s->backward)
1202             s->offset -= lcd_scroll_info.step;
1203         else
1204             s->offset += lcd_scroll_info.step;
1205
1206         pf = font_get(current_vp->font);
1207         xpos = s->startx;
1208         ypos = s->y * pf->height;
1209
1210         if (s->bidir) { /* scroll bidirectional */
1211             if (s->offset <= 0) {
1212                 /* at beginning of line */
1213                 s->offset = 0;
1214                 s->backward = false;
1215                 s->start_tick = current_tick + lcd_scroll_info.delay * 2;
1216             }
1217             if (s->offset >= s->width - (current_vp->width - xpos)) {
1218                 /* at end of line */
1219                 s->offset = s->width - (current_vp->width - xpos);
1220                 s->backward = true;
1221                 s->start_tick = current_tick + lcd_scroll_info.delay * 2;
1222             }
1223         }
1224         else {
1225             /* scroll forward the whole time */
1226             if (s->offset >= s->width)
1227                 s->offset %= s->width;
1228         }
1229
1230         lastmode = current_vp->drawmode;
1231         switch (s->style&STYLE_MODE_MASK) {
1232             case STYLE_INVERT:
1233                 current_vp->drawmode = DRMODE_SOLID|DRMODE_INVERSEVID;
1234                 break;
1235             case STYLE_COLORBAR:
1236                 /* Solid colour line selector */
1237                 current_vp->drawmode = DRMODE_FG;
1238                 current_vp->fg_pattern = current_vp->lss_pattern;
1239                 lcd_fillrect(xpos, ypos, current_vp->width - xpos, pf->height);
1240                 current_vp->fg_pattern = current_vp->lst_pattern;
1241                 break;
1242             case STYLE_GRADIENT:
1243                 /* Gradient line selector */
1244                 current_vp->drawmode = DRMODE_FG;
1245                 lcd_gradient_rect_scroll(xpos, current_vp->width, ypos, (signed)pf->height,
1246                                          NUMLN_UNPACK(s->style),
1247                                          CURLN_UNPACK(s->style));
1248                 current_vp->fg_pattern = current_vp->lst_pattern;
1249                 break;
1250             default:
1251                 current_vp->drawmode = DRMODE_SOLID;
1252                 break;
1253         }
1254         lcd_putsxyofs(xpos, ypos, s->offset, s->line);
1255         current_vp->drawmode = lastmode;
1256         current_vp->fg_pattern = old_fgcolor;
1257         current_vp->bg_pattern = old_bgcolor;
1258         lcd_update_viewport_rect(xpos, ypos, current_vp->width - xpos, pf->height);
1259     }
1260
1261     lcd_set_viewport(old_vp);
1262 }