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  * Copyright (C) 2009 by Karl Kurbjun
  12  *
  13  * Rockbox driver for 16-bit colour LCDs
  14  *
  15  * This program is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU General Public License
  17  * as published by the Free Software Foundation; either version 2
  18  * of the License, or (at your option) any later version.
  19  *
  20  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  21  * KIND, either express or implied.
  22  *
  23  ****************************************************************************/
  24
  25 #include "config.h"
  26
  27 #include "cpu.h"
  28 #include "lcd.h"
  29 #include "kernel.h"
  30 #include "thread.h"
  31 #include <stdlib.h>
  32 #include "string-extra.h" /* mem*() */
  33 #include "file.h"
  34 #include "debug.h"
  35 #include "system.h"
  36 #include "font.h"
  37 #include "rbunicode.h"
  38 #include "bidi.h"
  39 #include "scroll_engine.h"
  40
  41 #define ROW_INC LCD_WIDTH
  42 #define COL_INC 1
  43
  44 #include "lcd-16bit-common.c"
  45 #include "lcd-bitmap-common.c"
  46
  47 /*** drawing functions ***/
  48
  49 /* Clear the current viewport */
  50 void lcd_clear_viewport(void)
  51 {
  52     fb_data *dst, *dst_end;
  53
  54     dst = FBADDR(current_vp->x, current_vp->y);
  55     dst_end = dst + current_vp->height * LCD_WIDTH;
  56
  57     if (current_vp->drawmode & DRMODE_INVERSEVID)
  58     {
  59         do
  60         {
  61             memset16(dst, current_vp->fg_pattern, current_vp->width);
  62             dst += LCD_WIDTH;
  63         }
  64         while (dst < dst_end);
  65     }
  66     else
  67     {
  68         if (!lcd_backdrop)
  69         {
  70             do
  71             {
  72                 memset16(dst, current_vp->bg_pattern, current_vp->width);
  73                 dst += LCD_WIDTH;
  74             }
  75             while (dst < dst_end);
  76         }
  77         else
  78         {
  79             do
  80             {
  81                 memcpy(dst, (void *)((long)dst + lcd_backdrop_offset),
  82                        current_vp->width * sizeof(fb_data));
  83                 dst += LCD_WIDTH;
  84             }
  85             while (dst < dst_end);
  86         }
  87     }
  88
  89     if (current_vp == &default_vp)
  90     {
  91         lcd_scroll_info.lines = 0;
  92     }
  93     else
  94     {
  95         lcd_scroll_stop(current_vp);
  96     }
  97 }
  98
  99 /* Draw a horizontal line (optimised) */
 100 void lcd_hline(int x1, int x2, int y)
 101 {
 102     int x, width;
 103     unsigned bits = 0;
 104     enum fill_opt fillopt = OPT_NONE;
 105     fb_data *dst, *dst_end;
 106
 107     /* direction flip */
 108     if (x2 < x1)
 109     {
 110         x = x1;
 111         x1 = x2;
 112         x2 = x;
 113     }
 114
 115     /******************** In viewport clipping **********************/
 116     /* nothing to draw? */
 117     if (((unsigned)y >= (unsigned)current_vp->height) ||
 118         (x1 >= current_vp->width) ||
 119         (x2 < 0))
 120         return;
 121
 122     if (x1 < 0)
 123         x1 = 0;
 124     if (x2 >= current_vp->width)
 125         x2 = current_vp->width-1;
 126
 127     /* Adjust x1 and y to viewport */
 128     x1 += current_vp->x;
 129     x2 += current_vp->x;
 130     y += current_vp->y;
 131
 132 #if defined(HAVE_VIEWPORT_CLIP)
 133     /********************* Viewport on screen clipping ********************/
 134     /* nothing to draw? */
 135     if (((unsigned)y >= (unsigned) LCD_HEIGHT) || (x1 >= LCD_WIDTH)
 136         || (x2 < 0))
 137         return;
 138
 139     /* clipping */
 140     if (x1 < 0)
 141         x1 = 0;
 142     if (x2 >= LCD_WIDTH)
 143         x2 = LCD_WIDTH-1;
 144 #endif
 145
 146     width = x2 - x1 + 1;
 147
 148     /* drawmode and optimisation */
 149     if (current_vp->drawmode & DRMODE_INVERSEVID)
 150     {
 151         if (current_vp->drawmode & DRMODE_BG)
 152         {
 153             if (!lcd_backdrop)
 154             {
 155                 fillopt = OPT_SET;
 156                 bits = current_vp->bg_pattern;
 157             }
 158             else
 159                 fillopt = OPT_COPY;
 160         }
 161     }
 162     else
 163     {
 164         if (current_vp->drawmode & DRMODE_FG)
 165         {
 166             fillopt = OPT_SET;
 167             bits = current_vp->fg_pattern;
 168         }
 169     }
 170     if (fillopt == OPT_NONE && current_vp->drawmode != DRMODE_COMPLEMENT)
 171         return;
 172
 173     dst = FBADDR(x1, y);
 174
 175     switch (fillopt)
 176     {
 177       case OPT_SET:
 178         memset16(dst, bits, width);
 179         break;
 180
 181       case OPT_COPY:
 182         memcpy(dst, (void *)((long)dst + lcd_backdrop_offset),
 183                width * sizeof(fb_data));
 184         break;
 185
 186       case OPT_NONE:  /* DRMODE_COMPLEMENT */
 187         dst_end = dst + width;
 188         do
 189             *dst = ~(*dst);
 190         while (++dst < dst_end);
 191         break;
 192     }
 193 }
 194
 195 /* Draw a vertical line (optimised) */
 196 void lcd_vline(int x, int y1, int y2)
 197 {
 198     int y;
 199     fb_data *dst, *dst_end;
 200     lcd_fastpixelfunc_type *pfunc = lcd_fastpixelfuncs[current_vp->drawmode];
 201
 202     /* direction flip */
 203     if (y2 < y1)
 204     {
 205         y = y1;
 206         y1 = y2;
 207         y2 = y;
 208     }
 209
 210     /******************** In viewport clipping **********************/
 211     /* nothing to draw? */
 212     if (((unsigned)x >= (unsigned)current_vp->width) ||
 213         (y1 >= current_vp->height) ||
 214         (y2 < 0))
 215         return;
 216
 217     if (y1 < 0)
 218         y1 = 0;
 219     if (y2 >= current_vp->height)
 220         y2 = current_vp->height-1;
 221
 222     /* adjust for viewport */
 223     x += current_vp->x;
 224     y1 += current_vp->y;
 225     y2 += current_vp->y;
 226
 227 #if defined(HAVE_VIEWPORT_CLIP)
 228     /********************* Viewport on screen clipping ********************/
 229     /* nothing to draw? */
 230     if (( (unsigned) x >= (unsigned)LCD_WIDTH) || (y1 >= LCD_HEIGHT)
 231         || (y2 < 0))
 232         return;
 233
 234     /* clipping */
 235     if (y1 < 0)
 236         y1 = 0;
 237     if (y2 >= LCD_HEIGHT)
 238         y2 = LCD_HEIGHT-1;
 239 #endif
 240
 241     dst = FBADDR(x , y1);
 242     dst_end = dst + (y2 - y1) * LCD_WIDTH;
 243
 244     do
 245     {
 246         pfunc(dst);
 247         dst += LCD_WIDTH;
 248     }
 249     while (dst <= dst_end);
 250 }
 251
 252 /* Fill a rectangular area */
 253 void lcd_fillrect(int x, int y, int width, int height)
 254 {
 255     unsigned bits = 0;
 256     enum fill_opt fillopt = OPT_NONE;
 257     fb_data *dst, *dst_end;
 258
 259     /******************** In viewport clipping **********************/
 260     /* nothing to draw? */
 261     if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
 262         (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
 263         return;
 264
 265     if (x < 0)
 266     {
 267         width += x;
 268         x = 0;
 269     }
 270     if (y < 0)
 271     {
 272         height += y;
 273         y = 0;
 274     }
 275     if (x + width > current_vp->width)
 276         width = current_vp->width - x;
 277     if (y + height > current_vp->height)
 278         height = current_vp->height - y;
 279
 280     /* adjust for viewport */
 281     x += current_vp->x;
 282     y += current_vp->y;
 283
 284 #if defined(HAVE_VIEWPORT_CLIP)
 285     /********************* Viewport on screen clipping ********************/
 286     /* nothing to draw? */
 287     if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT)
 288         || (x + width <= 0) || (y + height <= 0))
 289         return;
 290
 291     /* clip image in viewport in screen */
 292     if (x < 0)
 293     {
 294         width += x;
 295         x = 0;
 296     }
 297     if (y < 0)
 298     {
 299         height += y;
 300         y = 0;
 301     }
 302     if (x + width > LCD_WIDTH)
 303         width = LCD_WIDTH - x;
 304     if (y + height > LCD_HEIGHT)
 305         height = LCD_HEIGHT - y;
 306 #endif
 307
 308     /* drawmode and optimisation */
 309     if (current_vp->drawmode & DRMODE_INVERSEVID)
 310     {
 311         if (current_vp->drawmode & DRMODE_BG)
 312         {
 313             if (!lcd_backdrop)
 314             {
 315                 fillopt = OPT_SET;
 316                 bits = current_vp->bg_pattern;
 317             }
 318             else
 319                 fillopt = OPT_COPY;
 320         }
 321     }
 322     else
 323     {
 324         if (current_vp->drawmode & DRMODE_FG)
 325         {
 326             fillopt = OPT_SET;
 327             bits = current_vp->fg_pattern;
 328         }
 329     }
 330     if (fillopt == OPT_NONE && current_vp->drawmode != DRMODE_COMPLEMENT)
 331         return;
 332
 333     dst = FBADDR(x, y);
 334     dst_end = dst + height * LCD_WIDTH;
 335
 336     do
 337     {
 338         fb_data *dst_row, *row_end;
 339
 340         switch (fillopt)
 341         {
 342           case OPT_SET:
 343             memset16(dst, bits, width);
 344             break;
 345
 346           case OPT_COPY:
 347             memcpy(dst, (void *)((long)dst + lcd_backdrop_offset),
 348                    width * sizeof(fb_data));
 349             break;
 350
 351           case OPT_NONE:  /* DRMODE_COMPLEMENT */
 352             dst_row = dst;
 353             row_end = dst_row + width;
 354             do
 355                 *dst_row = ~(*dst_row);
 356             while (++dst_row < row_end);
 357             break;
 358         }
 359         dst += LCD_WIDTH;
 360     }
 361     while (dst < dst_end);
 362 }
 363
 364 /* Draw a partial native bitmap */
 365 void ICODE_ATTR lcd_bitmap_part(const fb_data *src, int src_x, int src_y,
 366                                 int stride, int x, int y, int width,
 367                                 int height)
 368 {
 369     fb_data *dst;
 370
 371     /******************** Image in viewport clipping **********************/
 372     /* nothing to draw? */
 373     if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
 374         (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
 375         return;
 376
 377     if (x < 0)
 378     {
 379         width += x;
 380         src_x -= x;
 381         x = 0;
 382     }
 383     if (y < 0)
 384     {
 385         height += y;
 386         src_y -= y;
 387         y = 0;
 388     }
 389
 390     if (x + width > current_vp->width)
 391         width = current_vp->width - x;
 392     if (y + height > current_vp->height)
 393         height = current_vp->height - y;
 394
 395     /* adjust for viewport */
 396     x += current_vp->x;
 397     y += current_vp->y;
 398
 399 #if defined(HAVE_VIEWPORT_CLIP)
 400     /********************* Viewport on screen clipping ********************/
 401     /* nothing to draw? */
 402     if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT)
 403         || (x + width <= 0) || (y + height <= 0))
 404         return;
 405
 406     /* clip image in viewport in screen */
 407     if (x < 0)
 408     {
 409         width += x;
 410         src_x -= x;
 411         x = 0;
 412     }
 413     if (y < 0)
 414     {
 415         height += y;
 416         src_y -= y;
 417         y = 0;
 418     }
 419     if (x + width > LCD_WIDTH)
 420         width = LCD_WIDTH - x;
 421     if (y + height > LCD_HEIGHT)
 422         height = LCD_HEIGHT - y;
 423 #endif
 424
 425     src += stride * src_y + src_x; /* move starting point */
 426     dst = FBADDR(x, y);
 427
 428     do
 429     {
 430         memcpy(dst, src, width * sizeof(fb_data));
 431         src += stride;
 432         dst += LCD_WIDTH;
 433     }
 434     while (--height > 0);
 435 }
 436
 437 /* Draw a partial native bitmap with transparency and foreground colors */
 438 void ICODE_ATTR lcd_bitmap_transparent_part(const fb_data *src, int src_x,
 439                                             int src_y, int stride, int x,
 440                                             int y, int width, int height)
 441 {
 442     fb_data *dst;
 443     unsigned fg = current_vp->fg_pattern;
 444
 445     /******************** Image in viewport clipping **********************/
 446     /* nothing to draw? */
 447     if ((width <= 0) || (height <= 0) || (x >= current_vp->width) ||
 448         (y >= current_vp->height) || (x + width <= 0) || (y + height <= 0))
 449         return;
 450
 451     if (x < 0)
 452     {
 453         width += x;
 454         src_x -= x;
 455         x = 0;
 456     }
 457     if (y < 0)
 458     {
 459         height += y;
 460         src_y -= y;
 461         y = 0;
 462     }
 463
 464     if (x + width > current_vp->width)
 465         width = current_vp->width - x;
 466     if (y + height > current_vp->height)
 467         height = current_vp->height - y;
 468
 469     /* adjust for viewport */
 470     x += current_vp->x;
 471     y += current_vp->y;
 472
 473 #if defined(HAVE_VIEWPORT_CLIP)
 474     /********************* Viewport on screen clipping ********************/
 475     /* nothing to draw? */
 476     if ((x >= LCD_WIDTH) || (y >= LCD_HEIGHT)
 477         || (x + width <= 0) || (y + height <= 0))
 478         return;
 479
 480     /* clip image in viewport in screen */
 481     if (x < 0)
 482     {
 483         width += x;
 484         src_x -= x;
 485         x = 0;
 486     }
 487     if (y < 0)
 488     {
 489         height += y;
 490         src_y -= y;
 491         y = 0;
 492     }
 493     if (x + width > LCD_WIDTH)
 494         width = LCD_WIDTH - x;
 495     if (y + height > LCD_HEIGHT)
 496         height = LCD_HEIGHT - y;
 497 #endif
 498
 499     src += stride * src_y + src_x; /* move starting point */
 500     dst = FBADDR(x, y);
 501
 502 #ifdef CPU_ARM
 503     {
 504         int w, px;
 505         asm volatile (
 506         ".rowstart:                              \n"
 507             "mov     %[w], %[width]              \n" /* Load width for inner loop */
 508         ".nextpixel:                             \n"
 509             "ldrh    %[px], [%[s]], #2           \n" /* Load src pixel */
 510             "add     %[d], %[d], #2              \n" /* Uncoditionally increment dst */
 511                                                  /* done here for better pipelining */
 512             "cmp     %[px], %[fgcolor]           \n" /* Compare to foreground color */
 513             "streqh  %[fgpat], [%[d], #-2]       \n" /* Store foregroud if match */
 514             "cmpne   %[px], %[transcolor]        \n" /* Compare to transparent color */
 515             "strneh  %[px], [%[d], #-2]          \n" /* Store dst if not transparent */
 516             "subs    %[w], %[w], #1              \n" /* Width counter has run down? */
 517             "bgt     .nextpixel                  \n" /* More in this row? */
 518             "add     %[s], %[s], %[sstp], lsl #1 \n" /* Skip over to start of next line */
 519             "add     %[d], %[d], %[dstp], lsl #1 \n"
 520             "subs    %[h], %[h], #1              \n" /* Height counter has run down? */
 521             "bgt     .rowstart                   \n" /* More rows? */
 522             : [w]"=&r"(w), [h]"+&r"(height), [px]"=&r"(px),
 523               [s]"+&r"(src), [d]"+&r"(dst)
 524             : [width]"r"(width),
 525               [sstp]"r"(stride - width),
 526               [dstp]"r"(LCD_WIDTH - width),
 527               [transcolor]"r"(TRANSPARENT_COLOR),
 528               [fgcolor]"r"(REPLACEWITHFG_COLOR),
 529               [fgpat]"r"(fg)
 530         );
 531     }
 532 #else  /* optimized C version */
 533     do
 534     {
 535         const fb_data *src_row = src;
 536         fb_data *dst_row = dst;
 537         fb_data *row_end = dst_row + width;
 538         do
 539         {
 540             unsigned data = *src_row++;
 541             if (data != TRANSPARENT_COLOR)
 542             {
 543                 if (data == REPLACEWITHFG_COLOR)
 544                     data = fg;
 545                 *dst_row = data;
 546             }
 547         }
 548         while (++dst_row < row_end);
 549         src += stride;
 550         dst += LCD_WIDTH;
 551     }
 552     while (--height > 0);
 553 #endif
 554 }