apps/plugins/lib/playergfx.c

   1 /***************************************************************************
   2 *             __________               __   ___.
   3 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7 *                     \/            \/     \/    \/            \/
   8 * $Id$
   9 *
  10 * Bitmap graphics on player LCD!
  11 *
  12 * Copyright (C) 2005 Jens Arnold
  13 *
  14 * This program is free software; you can redistribute it and/or
  15 * modify it under the terms of the GNU General Public License
  16 * as published by the Free Software Foundation; either version 2
  17 * of the License, or (at your option) any later version.
  18 *
  19 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  20 * KIND, either express or implied.
  21 *
  22 ****************************************************************************/
  23
  24 #include "plugin.h"
  25
  26 #ifdef HAVE_LCD_CHARCELLS /* Player only :) */
  27 #include "playergfx.h"
  28
  29 /*** globals ***/
  30
  31 static int char_width;
  32 static int char_height;
  33 static int pixel_height;
  34 static int pixel_width;
  35 static unsigned long gfx_chars[8];
  36 static unsigned char gfx_buffer[56];
  37 static int drawmode = DRMODE_SOLID;
  38
  39 /*** Special functions ***/
  40
  41 /* library init */
  42 bool pgfx_init(int cwidth, int cheight)
  43 {
  44     int i;
  45
  46     if (((unsigned) cwidth * (unsigned) cheight) > 8 || (unsigned) cheight > 2)
  47         return false;
  48
  49     char_width = cwidth;
  50     char_height = cheight;
  51     pixel_height = 7 * char_height;
  52     pixel_width = 5 * char_width;
  53
  54     for (i = 0; i < cwidth * cheight; i++)
  55     {
  56         if ((gfx_chars[i] = rb->lcd_get_locked_pattern()) == 0)
  57         {
  58             pgfx_release();
  59             return false;
  60         }
  61     }
  62
  63     return true;
  64 }
  65
  66 /* library deinit */
  67 void pgfx_release(void)
  68 {
  69     int i;
  70
  71     for (i = 0; i < 8; i++)
  72         if (gfx_chars[i])
  73             rb->lcd_unlock_pattern(gfx_chars[i]);
  74 }
  75
  76 /* place the display */
  77 void pgfx_display(int cx, int cy)
  78 {
  79     int i, j;
  80     int width = MIN(char_width, 11 - cx);
  81     int height = MIN(char_height, 2 - cy);
  82
  83     for (i = 0; i < width; i++)
  84         for (j = 0; j < height; j++)
  85             rb->lcd_putc(cx + i, cy + j, gfx_chars[char_height * i + j]);
  86 }
  87
  88 void pgfx_display_block(int cx, int cy, int x, int y)
  89 {
  90     rb->lcd_putc(cx, cy, gfx_chars[char_height * x + y]);
  91 }
  92
  93
  94 /*** Update functions ***/
  95
  96 void pgfx_update(void)
  97 {
  98     int i;
  99
 100     for (i = 0; i < char_width * char_height; i++)
 101         rb->lcd_define_pattern(gfx_chars[i], gfx_buffer + 7 * i);
 102
 103     rb->lcd_update();
 104 }
 105
 106 /*** Parameter handling ***/
 107
 108 void pgfx_set_drawmode(int mode)
 109 {
 110     drawmode = mode & (DRMODE_SOLID|DRMODE_INVERSEVID);
 111 }
 112
 113 int pgfx_get_drawmode(void)
 114 {
 115     return drawmode;
 116 }
 117
 118 /*** Low-level drawing functions ***/
 119
 120 static void setpixel(int x, int y)
 121 {
 122     gfx_buffer[pixel_height * (x/5) + y] |= 0x10 >> (x%5);
 123 }
 124
 125 static void clearpixel(int x, int y)
 126 {
 127     gfx_buffer[pixel_height * (x/5) + y] &= ~(0x10 >> (x%5));
 128 }
 129
 130 static void flippixel(int x, int y)
 131 {
 132     gfx_buffer[pixel_height * (x/5) + y] ^= 0x10 >> (x%5);
 133 }
 134
 135 static void nopixel(int x, int y)
 136 {
 137     (void)x;
 138     (void)y;
 139 }
 140
 141 lcd_pixelfunc_type* pgfx_pixelfuncs[8] = {
 142     flippixel, nopixel, setpixel, setpixel,
 143     nopixel, clearpixel, nopixel, clearpixel
 144 };
 145
 146 static void flipblock(unsigned char *address, unsigned mask, unsigned bits)
 147 {
 148     *address ^= (bits & mask);
 149 }
 150
 151 static void bgblock(unsigned char *address, unsigned mask, unsigned bits)
 152 {
 153     *address &= (bits | ~mask);
 154 }
 155
 156 static void fgblock(unsigned char *address, unsigned mask, unsigned bits)
 157 {
 158     *address |= (bits & mask);
 159 }
 160
 161 static void solidblock(unsigned char *address, unsigned mask, unsigned bits)
 162 {
 163     unsigned data = *(char *)address;
 164
 165     bits    ^= data;
 166     *address = data ^ (bits & mask);
 167 }
 168
 169 static void flipinvblock(unsigned char *address, unsigned mask, unsigned bits)
 170 {
 171     *address ^= (~bits & mask);
 172 }
 173
 174 static void bginvblock(unsigned char *address, unsigned mask, unsigned bits)
 175 {
 176     *address &= ~(bits & mask);
 177 }
 178
 179 static void fginvblock(unsigned char *address, unsigned mask, unsigned bits)
 180 {
 181     *address |= (~bits & mask);
 182 }
 183
 184 static void solidinvblock(unsigned char *address, unsigned mask, unsigned bits)
 185 {
 186     unsigned data = *(char *)address;
 187
 188     bits     = ~bits ^ data;
 189     *address = data ^ (bits & mask);
 190 }
 191
 192 lcd_blockfunc_type* pgfx_blockfuncs[8] = {
 193     flipblock, bgblock, fgblock, solidblock,
 194     flipinvblock, bginvblock, fginvblock, solidinvblock
 195 };
 196
 197 /*** Drawing functions ***/
 198
 199 /* Clear the whole display */
 200 void pgfx_clear_display(void)
 201 {
 202     unsigned bits = (drawmode & DRMODE_INVERSEVID) ? 0x1F : 0;
 203
 204     rb->memset(gfx_buffer, bits, char_width * pixel_height);
 205 }
 206
 207 /* Set a single pixel */
 208 void pgfx_drawpixel(int x, int y)
 209 {
 210     if (((unsigned)x < (unsigned)pixel_width)
 211         && ((unsigned)y < (unsigned)pixel_height))
 212         pgfx_pixelfuncs[drawmode](x, y);
 213 }
 214
 215 /* Draw a line */
 216 void pgfx_drawline(int x1, int y1, int x2, int y2)
 217 {
 218     int numpixels;
 219     int i;
 220     int deltax, deltay;
 221     int d, dinc1, dinc2;
 222     int x, xinc1, xinc2;
 223     int y, yinc1, yinc2;
 224     lcd_pixelfunc_type *pfunc = pgfx_pixelfuncs[drawmode];
 225
 226     deltax = abs(x2 - x1);
 227     deltay = abs(y2 - y1);
 228     xinc2 = 1;
 229     yinc2 = 1;
 230
 231     if (deltax >= deltay)
 232     {
 233         numpixels = deltax;
 234         d = 2 * deltay - deltax;
 235         dinc1 = deltay * 2;
 236         dinc2 = (deltay - deltax) * 2;
 237         xinc1 = 1;
 238         yinc1 = 0;
 239     }
 240     else
 241     {
 242         numpixels = deltay;
 243         d = 2 * deltax - deltay;
 244         dinc1 = deltax * 2;
 245         dinc2 = (deltax - deltay) * 2;
 246         xinc1 = 0;
 247         yinc1 = 1;
 248     }
 249     numpixels++; /* include endpoints */
 250
 251     if (x1 > x2)
 252     {
 253         xinc1 = -xinc1;
 254         xinc2 = -xinc2;
 255     }
 256
 257     if (y1 > y2)
 258     {
 259         yinc1 = -yinc1;
 260         yinc2 = -yinc2;
 261     }
 262
 263     x = x1;
 264     y = y1;
 265
 266     for (i = 0; i < numpixels; i++)
 267     {
 268         if (((unsigned)x < (unsigned)pixel_width)
 269             && ((unsigned)y < (unsigned)pixel_height))
 270             pfunc(x, y);
 271
 272         if (d < 0)
 273         {
 274             d += dinc1;
 275             x += xinc1;
 276             y += yinc1;
 277         }
 278         else
 279         {
 280             d += dinc2;
 281             x += xinc2;
 282             y += yinc2;
 283         }
 284     }
 285 }
 286
 287 /* Draw a horizontal line (optimised) */
 288 void pgfx_hline(int x1, int x2, int y)
 289 {
 290     int nx;
 291     unsigned char *dst;
 292     unsigned mask, mask_right;
 293     lcd_blockfunc_type *bfunc;
 294
 295     /* direction flip */
 296     if (x2 < x1)
 297     {
 298         nx = x1;
 299         x1 = x2;
 300         x2 = nx;
 301     }
 302
 303     /* nothing to draw? */
 304     if (((unsigned)y >= (unsigned)pixel_height) || (x1 >= pixel_width)
 305         || (x2 < 0))
 306         return;
 307
 308     /* clipping */
 309     if (x1 < 0)
 310         x1 = 0;
 311     if (x2 >= pixel_width)
 312         x2 = pixel_width - 1;
 313
 314     bfunc = pgfx_blockfuncs[drawmode];
 315     dst   = &gfx_buffer[pixel_height * (x1/5) + y];
 316     nx    = x2 - (x1 - (x1 % 5));
 317     mask  = 0x1F >> (x1 % 5);
 318     mask_right = 0x1F0 >> (nx % 5);
 319
 320     for (; nx >= 5; nx -= 5)
 321     {
 322         bfunc(dst, mask, 0xFFu);
 323         dst += pixel_height;
 324         mask = 0x1F;
 325     }
 326     mask &= mask_right;
 327     bfunc(dst, mask, 0x1F);
 328 }
 329
 330 /* Draw a vertical line (optimised) */
 331 void pgfx_vline(int x, int y1, int y2)
 332 {
 333     int y;
 334     unsigned char *dst, *dst_end;
 335     unsigned mask;
 336     lcd_blockfunc_type *bfunc;
 337
 338     /* direction flip */
 339     if (y2 < y1)
 340     {
 341         y = y1;
 342         y1 = y2;
 343         y2 = y;
 344     }
 345
 346     /* nothing to draw? */
 347     if (((unsigned)x >= (unsigned)pixel_width) || (y1 >= pixel_height)
 348         || (y2 < 0))
 349         return;
 350
 351     /* clipping */
 352     if (y1 < 0)
 353         y1 = 0;
 354     if (y2 >= pixel_height)
 355         y2 = pixel_height - 1;
 356
 357     bfunc = pgfx_blockfuncs[drawmode];
 358     dst   = &gfx_buffer[pixel_height * (x/5) + y1];
 359     mask  = 0x10 >> (x % 5);
 360
 361     dst_end = dst + y2 - y1;
 362     do
 363         bfunc(dst++, mask, 0x1F);
 364     while (dst <= dst_end);
 365 }
 366
 367 /* Draw a rectangular box */
 368 void pgfx_drawrect(int x, int y, int width, int height)
 369 {
 370     if ((width <= 0) || (height <= 0))
 371         return;
 372
 373     int x2 = x + width - 1;
 374     int y2 = y + height - 1;
 375
 376     pgfx_vline(x, y, y2);
 377     pgfx_vline(x2, y, y2);
 378     pgfx_hline(x, x2, y);
 379     pgfx_hline(x, x2, y2);
 380 }
 381
 382 /* Fill a rectangular area */
 383 void pgfx_fillrect(int x, int y, int width, int height)
 384 {
 385     int nx;
 386     unsigned char *dst, *dst_end;
 387     unsigned mask, mask_right;
 388     lcd_blockfunc_type *bfunc;
 389
 390     /* nothing to draw? */
 391     if ((width <= 0) || (height <= 0) || (x >= pixel_width)
 392         || (y >= pixel_height) || (x + width <= 0) || (y + height <= 0))
 393         return;
 394
 395     /* clipping */
 396     if (x < 0)
 397     {
 398         width += x;
 399         x = 0;
 400     }
 401     if (y < 0)
 402     {
 403         height += y;
 404         y = 0;
 405     }
 406     if (x + width > pixel_width)
 407         width = pixel_width - x;
 408     if (y + height > pixel_height)
 409         height = pixel_height - y;
 410
 411     bfunc = pgfx_blockfuncs[drawmode];
 412     dst   = &gfx_buffer[pixel_height * (x/5) + y];
 413     nx    = width - 1 + (x % 5);
 414     mask  = 0x1F >> (x % 5);
 415     mask_right = 0x1F0 >> (nx % 5);
 416
 417     for (; nx >= 5; nx -= 5)
 418     {
 419         unsigned char *dst_col = dst;
 420
 421         dst_end = dst_col + height;
 422         do
 423             bfunc(dst_col++, mask, 0x1F);
 424         while (dst_col < dst_end);
 425
 426         dst += pixel_height;
 427         mask = 0x1F;
 428     }
 429     mask &= mask_right;
 430
 431     dst_end = dst + height;
 432     do
 433         bfunc(dst++, mask, 0x1F);
 434     while (dst < dst_end);
 435 }
 436
 437 /* About PlayerGFX internal bitmap format:
 438  *
 439  * A bitmap contains one bit for every pixel that defines if that pixel is
 440  * black (1) or white (0). Bits within a byte are arranged horizontally,
 441  * MSB at the left.
 442  * The bytes are stored in row-major order, with byte 0 being top left,
 443  * byte 1 2nd from left etc. Each row of bytes defines one pixel row.
 444  *
 445  * This approximates the (even more strange) internal hardware format. */
 446
 447 /* Draw a partial bitmap. stride is given in pixels */
 448 void pgfx_bitmap_part(const unsigned char *src, int src_x, int src_y,
 449                       int stride, int x, int y, int width, int height)
 450 {
 451     int nx, shift;
 452     unsigned char *dst, *dst_end;
 453     unsigned mask, mask_right;
 454     lcd_blockfunc_type *bfunc;
 455
 456     /* nothing to draw? */
 457     if ((width <= 0) || (height <= 0) || (x >= pixel_width)
 458         || (y >= pixel_height) || (x + width <= 0) || (y + height <= 0))
 459         return;
 460
 461     /* clipping */
 462     if (x < 0)
 463     {
 464         width += x;
 465         src_x -= x;
 466         x = 0;
 467     }
 468     if (y < 0)
 469     {
 470         height += y;
 471         src_y -= y;
 472         y = 0;
 473     }
 474     if (x + width > pixel_width)
 475         width = pixel_width - x;
 476     if (y + height > pixel_height)
 477         height = pixel_height - y;
 478
 479     stride = (stride + 7) >> 3; /* convert to no. of bytes */
 480
 481     src   += stride * src_y + (src_x >> 3); /* move starting point */
 482     dst   = &gfx_buffer[pixel_height * (x/5) + y];
 483     shift = 3 + (x % 5) - (src_x & 7);
 484     nx    = width - 1 + (x % 5);
 485
 486     bfunc  = pgfx_blockfuncs[drawmode];
 487     mask  = 0x1F >> (x % 5);
 488     mask_right = 0x1F0 >> (nx % 5);
 489
 490     dst_end = dst + height;
 491     do
 492     {
 493         const unsigned char *src_row = src;
 494         unsigned char *dst_row = dst++;
 495         unsigned mask_row = mask;
 496         unsigned data = *src_row++;
 497         int extrabits = shift;
 498
 499         for (x = nx; x >= 5; x -= 5)
 500         {
 501             if (extrabits < 0)
 502             {
 503                 data = (data << 8) | *src_row++;
 504                 extrabits += 8;
 505             }
 506             bfunc(dst_row, mask_row, data >> extrabits);
 507             extrabits -= 5;
 508             dst_row += pixel_height;
 509             mask_row = 0x1F;
 510         }
 511         if (extrabits < 0)
 512         {
 513             data = (data << 8) | *src_row;
 514             extrabits += 8;
 515         }
 516         bfunc(dst_row, mask_row & mask_right, data >> extrabits);
 517
 518         src += stride;
 519     }
 520     while (dst < dst_end);
 521 }
 522
 523 /* Draw a full bitmap */
 524 void pgfx_bitmap(const unsigned char *src, int x, int y, int width, int height)
 525 {
 526     pgfx_bitmap_part(src, 0, 0, width, x, y, width, height);
 527 }
 528
 529 #endif /* HAVE_LCD_CHARCELLS */