apps/plugins/lib/grey_scroll.c

   1 /***************************************************************************
   2 *             __________               __   ___.
   3 *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4 *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5 *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6 *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7 *                     \/            \/     \/    \/            \/
   8 * $Id$
   9 *
  10 * New greyscale framework
  11 * Scrolling routines
  12 *
  13 * This is a generic framework to display 129 shades of grey on low-depth
  14 * bitmap LCDs (Archos b&w, Iriver & Ipod 4-grey) within plugins.
  15 *
  16 * Copyright (C) 2008 Jens Arnold
  17 *
  18 * This program is free software; you can redistribute it and/or
  19 * modify it under the terms of the GNU General Public License
  20 * as published by the Free Software Foundation; either version 2
  21 * of the License, or (at your option) any later version.
  22 *
  23 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  24 * KIND, either express or implied.
  25 *
  26 ****************************************************************************/
  27
  28 #include "plugin.h"
  29 #include "grey.h"
  30
  31 /*** Scrolling ***/
  32
  33 /* Scroll left */
  34 void grey_scroll_left(int count)
  35 {
  36     unsigned char *data, *data_end;
  37     int length, blank;
  38
  39     if ((unsigned)count >= (unsigned)_grey_info.width)
  40     {
  41         grey_clear_display();
  42         return;
  43     }
  44
  45     data = _grey_info.buffer;
  46     data_end = data + _GREY_MULUQ(_grey_info.width, _grey_info.height);
  47     length = _grey_info.width - count;
  48     blank = (_grey_info.drawmode & DRMODE_INVERSEVID) ?
  49              _grey_info.fg_brightness : _grey_info.bg_brightness;
  50
  51     do
  52     {
  53         rb->memmove(data, data + count, length);
  54         data += length;
  55         rb->memset(data, blank, count);
  56         data += count;
  57     }
  58     while (data < data_end);
  59 }
  60
  61 /* Scroll right */
  62 void grey_scroll_right(int count)
  63 {
  64     unsigned char *data, *data_end;
  65     int length, blank;
  66
  67     if ((unsigned)count >= (unsigned)_grey_info.width)
  68     {
  69         grey_clear_display();
  70         return;
  71     }
  72
  73     data = _grey_info.buffer;
  74     data_end = data + _GREY_MULUQ(_grey_info.width, _grey_info.height);
  75     length = _grey_info.width - count;
  76     blank = (_grey_info.drawmode & DRMODE_INVERSEVID) ?
  77              _grey_info.fg_brightness : _grey_info.bg_brightness;
  78
  79     do
  80     {
  81         rb->memmove(data + count, data, length);
  82         rb->memset(data, blank, count);
  83         data += _grey_info.width;
  84     }
  85     while (data < data_end);
  86 }
  87
  88 /* Scroll up */
  89 void grey_scroll_up(int count)
  90 {
  91     long shift, length;
  92     int blank;
  93
  94     if ((unsigned)count >= (unsigned)_grey_info.height)
  95     {
  96         grey_clear_display();
  97         return;
  98     }
  99
 100     shift = _GREY_MULUQ(_grey_info.width, count);
 101     length = _GREY_MULUQ(_grey_info.width, _grey_info.height - count);
 102     blank = (_grey_info.drawmode & DRMODE_INVERSEVID) ?
 103              _grey_info.fg_brightness : _grey_info.bg_brightness;
 104
 105     rb->memmove(_grey_info.buffer, _grey_info.buffer + shift,
 106                            length);
 107     rb->memset(_grey_info.buffer + length, blank, shift);
 108 }
 109
 110 /* Scroll down */
 111 void grey_scroll_down(int count)
 112 {
 113     long shift, length;
 114     int blank;
 115
 116     if ((unsigned)count >= (unsigned)_grey_info.height)
 117     {
 118         grey_clear_display();
 119         return;
 120     }
 121
 122     shift = _GREY_MULUQ(_grey_info.width, count);
 123     length = _GREY_MULUQ(_grey_info.width, _grey_info.height - count);
 124     blank = (_grey_info.drawmode & DRMODE_INVERSEVID) ?
 125              _grey_info.fg_brightness : _grey_info.bg_brightness;
 126
 127     rb->memmove(_grey_info.buffer + shift, _grey_info.buffer,
 128                            length);
 129     rb->memset(_grey_info.buffer, blank, shift);
 130 }
 131
 132 /*** Unbuffered scrolling functions ***/
 133
 134 /* Scroll left */
 135 void grey_ub_scroll_left(int count)
 136 {
 137     unsigned char *data, *data_end;
 138     int blank, length;
 139
 140     if ((unsigned)count >= (unsigned)_grey_info.width)
 141     {
 142         grey_ub_clear_display();
 143         return;
 144     }
 145
 146     data = _grey_info.values;
 147     data_end = data + _GREY_MULUQ(_grey_info.width, _grey_info.height);
 148     length = (_grey_info.width - count) << _GREY_BSHIFT;
 149     count <<= _GREY_BSHIFT;
 150     blank = _grey_info.gvalue[(_grey_info.drawmode & DRMODE_INVERSEVID) ?
 151                               _grey_info.fg_brightness :
 152                               _grey_info.bg_brightness];
 153     do
 154     {
 155         rb->memmove(data, data + count, length);
 156         data += length;
 157         rb->memset(data, blank, count);
 158         data += count;
 159     }
 160     while (data < data_end);
 161 #ifdef SIMULATOR
 162     rb->sim_lcd_ex_update_rect(_grey_info.x, _grey_info.y,
 163                                           _grey_info.width, _grey_info.height);
 164 #endif
 165 }
 166
 167 /* Scroll right */
 168 void grey_ub_scroll_right(int count)
 169 {
 170     unsigned char *data, *data_end;
 171     int blank, length;
 172
 173     if ((unsigned)count >= (unsigned)_grey_info.width)
 174     {
 175         grey_ub_clear_display();
 176         return;
 177     }
 178
 179     data = _grey_info.values;
 180     data_end = data + _GREY_MULUQ(_grey_info.width, _grey_info.height);
 181     length = (_grey_info.width - count) << _GREY_BSHIFT;
 182     count <<= _GREY_BSHIFT;
 183     blank = _grey_info.gvalue[(_grey_info.drawmode & DRMODE_INVERSEVID) ?
 184                               _grey_info.fg_brightness :
 185                               _grey_info.bg_brightness];
 186     do
 187     {
 188         rb->memmove(data + count, data, length);
 189         rb->memset(data, blank, count);
 190         data += _grey_info.width << _GREY_BSHIFT;
 191     }
 192     while (data < data_end);
 193 #ifdef SIMULATOR
 194     rb->sim_lcd_ex_update_rect(_grey_info.x, _grey_info.y,
 195                                           _grey_info.width, _grey_info.height);
 196 #endif
 197 }
 198
 199 /* Scroll up */
 200 void grey_ub_scroll_up(int count)
 201 {
 202     unsigned char *dst, *end, *src;
 203     int blank;
 204
 205     if ((unsigned)count >= (unsigned)_grey_info.height)
 206     {
 207         grey_ub_clear_display();
 208         return;
 209     }
 210
 211     dst   = _grey_info.values;
 212     end   = dst + _GREY_MULUQ(_grey_info.height, _grey_info.width);
 213     blank = _grey_info.gvalue[(_grey_info.drawmode & DRMODE_INVERSEVID) ?
 214                               _grey_info.fg_brightness :
 215                               _grey_info.bg_brightness];
 216
 217 #if (LCD_PIXELFORMAT == VERTICAL_PACKING) \
 218  || (LCD_PIXELFORMAT == VERTICAL_INTERLEAVED)
 219     if (count & _GREY_BMASK)
 220     {
 221         /* Scrolling by fractional blocks - move pixel wise. */
 222         unsigned char *line_end;
 223         int ys, yd;
 224
 225         for (ys = count, yd = 0; ys < _grey_info.height; ys++, yd++)
 226         {
 227             dst = _grey_info.values
 228                 + _GREY_MULUQ(_grey_info.width, yd & ~_GREY_BMASK)
 229                 + (~yd & _GREY_BMASK);
 230             src = _grey_info.values
 231                 + _GREY_MULUQ(_grey_info.width, ys & ~_GREY_BMASK)
 232                 + (~ys & _GREY_BMASK);
 233             line_end = dst + _grey_info.width * _GREY_BSIZE;
 234
 235             do
 236             {
 237                 *dst = *src;
 238                 dst += _GREY_BSIZE;
 239                 src += _GREY_BSIZE;
 240             }
 241             while (dst < line_end);
 242         }
 243         for (; yd & _GREY_BMASK; yd++)   /* Fill remainder of current block. */
 244         {
 245             dst = _grey_info.values
 246                 + _GREY_MULUQ(_grey_info.width, yd & ~_GREY_BMASK)
 247                 + (~yd & _GREY_BMASK);
 248             line_end = dst + _grey_info.width * _GREY_BSIZE;
 249
 250             do
 251             {
 252                 *dst = blank;
 253                 dst += _GREY_BSIZE;
 254             }
 255             while (dst < line_end);
 256         }
 257     }
 258     else
 259 #endif
 260     {
 261         int blen = _GREY_MULUQ(_grey_info.height - count, _grey_info.width);
 262
 263         src = dst + _GREY_MULUQ(count, _grey_info.width);
 264         rb->memmove(dst, src, blen);
 265         dst += blen;
 266     }
 267     rb->memset(dst, blank, end - dst); /* Fill remainder at once. */
 268 #ifdef SIMULATOR
 269     rb->sim_lcd_ex_update_rect(_grey_info.x, _grey_info.y,
 270                                           _grey_info.width, _grey_info.height);
 271 #endif
 272 }
 273
 274 /* Scroll down */
 275 void grey_ub_scroll_down(int count)
 276 {
 277     unsigned char *start, *dst;
 278     int blank;
 279
 280     if ((unsigned)count >= (unsigned)_grey_info.height)
 281     {
 282         grey_ub_clear_display();
 283         return;
 284     }
 285
 286     start = _grey_info.values;
 287     dst   = start + _GREY_MULUQ(_grey_info.height, _grey_info.width);
 288     blank = _grey_info.gvalue[(_grey_info.drawmode & DRMODE_INVERSEVID) ?
 289                               _grey_info.fg_brightness :
 290                               _grey_info.bg_brightness];
 291
 292 #if (LCD_PIXELFORMAT == VERTICAL_PACKING) \
 293  || (LCD_PIXELFORMAT == VERTICAL_INTERLEAVED)
 294     if (count & _GREY_BMASK)
 295     {
 296         /* Scrolling by fractional blocks - move pixel wise. */
 297         unsigned char *src, *line_end;
 298         int ys, yd;
 299
 300         yd = _grey_info.height - 1;
 301         for (ys = yd - count; ys >= 0; ys--, yd--)
 302         {
 303             dst = _grey_info.values
 304                 + _GREY_MULUQ(_grey_info.width, yd & ~_GREY_BMASK)
 305                 + (~yd & _GREY_BMASK);
 306             src = _grey_info.values
 307                 + _GREY_MULUQ(_grey_info.width, ys & ~_GREY_BMASK)
 308                 + (~ys & _GREY_BMASK);
 309             line_end = dst + _grey_info.width * _GREY_BSIZE;
 310
 311             do
 312             {
 313                 *dst = *src;
 314                 dst += _GREY_BSIZE;
 315                 src += _GREY_BSIZE;
 316             }
 317             while (dst < line_end);
 318         }
 319         for (; ~yd & _GREY_BMASK; yd--)  /* Fill remainder of current block. */
 320         {
 321             dst = _grey_info.values
 322                 + _GREY_MULUQ(_grey_info.width, yd & ~_GREY_BMASK)
 323                 + (~yd & _GREY_BMASK);
 324             line_end = dst + _grey_info.width * _GREY_BSIZE;
 325
 326             do
 327             {
 328                 line_end -= _GREY_BSIZE;
 329                 *line_end = blank;
 330             }
 331             while (dst < line_end);
 332         }
 333         /* Top pixel in a block has the highest address, but dst must point
 334          * to the lowest address in that block for the subsequent fill. */
 335         dst -= _GREY_BMASK;
 336     }
 337     else
 338 #endif
 339     {
 340         int blen = _GREY_MULUQ(_grey_info.height - count, _grey_info.width);
 341
 342         dst -= blen;
 343         rb->memmove(dst, start, blen);
 344     }
 345     rb->memset(start, blank, dst - start);
 346     /* Fill remainder at once. */
 347 #ifdef SIMULATOR
 348     rb->sim_lcd_ex_update_rect(_grey_info.x, _grey_info.y,
 349                                           _grey_info.width, _grey_info.height);
 350 #endif
 351 }