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 * All files in this archive are subject to the GNU General Public License.
  19 * See the file COPYING in the source tree root for full license agreement.
  20 *
  21 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  22 * KIND, either express or implied.
  23 *
  24 ****************************************************************************/
  25
  26 #include "plugin.h"
  27 #include "grey.h"
  28
  29 /*** Scrolling ***/
  30
  31 /* Scroll left */
  32 void grey_scroll_left(int count)
  33 {
  34     unsigned char *data, *data_end;
  35     int length, blank;
  36
  37     if ((unsigned)count >= (unsigned)_grey_info.width)
  38         return;
  39
  40     data = _grey_info.buffer;
  41     data_end = data + _GREY_MULUQ(_grey_info.width, _grey_info.height);
  42     length = _grey_info.width - count;
  43     blank = (_grey_info.drawmode & DRMODE_INVERSEVID) ?
  44              _grey_info.fg_brightness : _grey_info.bg_brightness;
  45
  46     do
  47     {
  48         _grey_info.rb->memmove(data, data + count, length);
  49         data += length;
  50         _grey_info.rb->memset(data, blank, count);
  51         data += count;
  52     }
  53     while (data < data_end);
  54 }
  55
  56 /* Scroll right */
  57 void grey_scroll_right(int count)
  58 {
  59     unsigned char *data, *data_end;
  60     int length, blank;
  61
  62     if ((unsigned)count >= (unsigned)_grey_info.width)
  63         return;
  64
  65     data = _grey_info.buffer;
  66     data_end = data + _GREY_MULUQ(_grey_info.width, _grey_info.height);
  67     length = _grey_info.width - count;
  68     blank = (_grey_info.drawmode & DRMODE_INVERSEVID) ?
  69              _grey_info.fg_brightness : _grey_info.bg_brightness;
  70
  71     do
  72     {
  73         _grey_info.rb->memmove(data + count, data, length);
  74         _grey_info.rb->memset(data, blank, count);
  75         data += _grey_info.width;
  76     }
  77     while (data < data_end);
  78 }
  79
  80 /* Scroll up */
  81 void grey_scroll_up(int count)
  82 {
  83     long shift, length;
  84     int blank;
  85
  86     if ((unsigned)count >= (unsigned)_grey_info.height)
  87         return;
  88
  89     shift = _GREY_MULUQ(_grey_info.width, count);
  90     length = _GREY_MULUQ(_grey_info.width, _grey_info.height - count);
  91     blank = (_grey_info.drawmode & DRMODE_INVERSEVID) ?
  92              _grey_info.fg_brightness : _grey_info.bg_brightness;
  93
  94     _grey_info.rb->memmove(_grey_info.buffer, _grey_info.buffer + shift,
  95                            length);
  96     _grey_info.rb->memset(_grey_info.buffer + length, blank, shift);
  97 }
  98
  99 /* Scroll down */
 100 void grey_scroll_down(int count)
 101 {
 102     long shift, length;
 103     int blank;
 104
 105     if ((unsigned)count >= (unsigned)_grey_info.height)
 106         return;
 107
 108     shift = _GREY_MULUQ(_grey_info.width, count);
 109     length = _GREY_MULUQ(_grey_info.width, _grey_info.height - count);
 110     blank = (_grey_info.drawmode & DRMODE_INVERSEVID) ?
 111              _grey_info.fg_brightness : _grey_info.bg_brightness;
 112
 113     _grey_info.rb->memmove(_grey_info.buffer + shift, _grey_info.buffer,
 114                            length);
 115     _grey_info.rb->memset(_grey_info.buffer, blank, shift);
 116 }
 117
 118 /*** Unbuffered scrolling functions ***/
 119
 120 /* Scroll left */
 121 void grey_ub_scroll_left(int count)
 122 {
 123     unsigned char *data, *data_end;
 124     int blank, length;
 125
 126     if ((unsigned)count >= (unsigned)_grey_info.width)
 127         return;
 128
 129     data = _grey_info.values;
 130     data_end = data + _GREY_MULUQ(_grey_info.width, _grey_info.height);
 131     length = (_grey_info.width - count) << _GREY_BSHIFT;
 132     count <<= _GREY_BSHIFT;
 133     blank = _grey_info.gvalue[(_grey_info.drawmode & DRMODE_INVERSEVID) ?
 134                               _grey_info.fg_brightness :
 135                               _grey_info.bg_brightness];
 136     do
 137     {
 138         _grey_info.rb->memmove(data, data + count, length);
 139         data += length;
 140         _grey_info.rb->memset(data, blank, count);
 141         data += count;
 142     }
 143     while (data < data_end);
 144 #ifdef SIMULATOR
 145     _grey_info.rb->sim_lcd_ex_update_rect(_grey_info.x, _grey_info.y,
 146                                           _grey_info.width, _grey_info.height);
 147 #endif
 148 }
 149
 150 /* Scroll right */
 151 void grey_ub_scroll_right(int count)
 152 {
 153     unsigned char *data, *data_end;
 154     int blank, length;
 155
 156     if ((unsigned)count >= (unsigned)_grey_info.width)
 157         return;
 158
 159     data = _grey_info.values;
 160     data_end = data + _GREY_MULUQ(_grey_info.width, _grey_info.height);
 161     length = (_grey_info.width - count) << _GREY_BSHIFT;
 162     count <<= _GREY_BSHIFT;
 163     blank = _grey_info.gvalue[(_grey_info.drawmode & DRMODE_INVERSEVID) ?
 164                               _grey_info.fg_brightness :
 165                               _grey_info.bg_brightness];
 166     do
 167     {
 168         _grey_info.rb->memmove(data + count, data, length);
 169         _grey_info.rb->memset(data, blank, count);
 170         data += _grey_info.width << _GREY_BSHIFT;
 171     }
 172     while (data < data_end);
 173 #ifdef SIMULATOR
 174     _grey_info.rb->sim_lcd_ex_update_rect(_grey_info.x, _grey_info.y,
 175                                           _grey_info.width, _grey_info.height);
 176 #endif
 177 }
 178
 179 /* Scroll up */
 180 void grey_ub_scroll_up(int count)
 181 {
 182     unsigned char *dst, *end, *src;
 183     int blank;
 184
 185     if ((unsigned)count >= (unsigned)_grey_info.height)
 186         return;
 187
 188     dst   = _grey_info.values;
 189     end   = dst + _GREY_MULUQ(_grey_info.height, _grey_info.width);
 190     blank = _grey_info.gvalue[(_grey_info.drawmode & DRMODE_INVERSEVID) ?
 191                               _grey_info.fg_brightness :
 192                               _grey_info.bg_brightness];
 193
 194 #if (LCD_PIXELFORMAT == VERTICAL_PACKING) \
 195  || (LCD_PIXELFORMAT == VERTICAL_INTERLEAVED)
 196     if (count & _GREY_BMASK)
 197     {
 198         /* Scrolling by fractional blocks - move pixel wise. */
 199         unsigned char *line_end;
 200         int ys, yd;
 201
 202         for (ys = count, yd = 0; ys < _grey_info.height; ys++, yd++)
 203         {
 204             dst = _grey_info.values
 205                 + _GREY_MULUQ(_grey_info.width, yd & ~_GREY_BMASK)
 206                 + (~yd & _GREY_BMASK);
 207             src = _grey_info.values
 208                 + _GREY_MULUQ(_grey_info.width, ys & ~_GREY_BMASK)
 209                 + (~ys & _GREY_BMASK);
 210             line_end = dst + _grey_info.width * _GREY_BSIZE;
 211
 212             do
 213             {
 214                 *dst = *src;
 215                 dst += _GREY_BSIZE;
 216                 src += _GREY_BSIZE;
 217             }
 218             while (dst < line_end);
 219         }
 220         for (; yd & _GREY_BMASK; yd++)   /* Fill remainder of current block. */
 221         {
 222             dst = _grey_info.values
 223                 + _GREY_MULUQ(_grey_info.width, yd & ~_GREY_BMASK)
 224                 + (~yd & _GREY_BMASK);
 225             line_end = dst + _grey_info.width * _GREY_BSIZE;
 226
 227             do
 228             {
 229                 *dst = blank;
 230                 dst += _GREY_BSIZE;
 231             }
 232             while (dst < line_end);
 233         }
 234     }
 235     else
 236 #endif
 237     {
 238         int blen = _GREY_MULUQ(_grey_info.height - count, _grey_info.width);
 239
 240         src = dst + _GREY_MULUQ(count, _grey_info.width);
 241         _grey_info.rb->memmove(dst, src, blen);
 242         dst += blen;
 243     }
 244     _grey_info.rb->memset(dst, blank, end - dst); /* Fill remainder at once. */
 245 #ifdef SIMULATOR
 246     _grey_info.rb->sim_lcd_ex_update_rect(_grey_info.x, _grey_info.y,
 247                                           _grey_info.width, _grey_info.height);
 248 #endif
 249 }
 250
 251 /* Scroll down */
 252 void grey_ub_scroll_down(int count)
 253 {
 254     unsigned char *start, *dst;
 255     int blank;
 256
 257     if ((unsigned)count >= (unsigned)_grey_info.height)
 258         return;
 259
 260     start = _grey_info.values;
 261     dst   = start + _GREY_MULUQ(_grey_info.height, _grey_info.width);
 262     blank = _grey_info.gvalue[(_grey_info.drawmode & DRMODE_INVERSEVID) ?
 263                               _grey_info.fg_brightness :
 264                               _grey_info.bg_brightness];
 265
 266 #if (LCD_PIXELFORMAT == VERTICAL_PACKING) \
 267  || (LCD_PIXELFORMAT == VERTICAL_INTERLEAVED)
 268     if (count & _GREY_BMASK)
 269     {
 270         /* Scrolling by fractional blocks - move pixel wise. */
 271         unsigned char *src, *line_end;
 272         int ys, yd;
 273
 274         yd = _grey_info.height - 1;
 275         for (ys = yd - count; ys >= 0; ys--, yd--)
 276         {
 277             dst = _grey_info.values
 278                 + _GREY_MULUQ(_grey_info.width, yd & ~_GREY_BMASK)
 279                 + (~yd & _GREY_BMASK);
 280             src = _grey_info.values
 281                 + _GREY_MULUQ(_grey_info.width, ys & ~_GREY_BMASK)
 282                 + (~ys & _GREY_BMASK);
 283             line_end = dst + _grey_info.width * _GREY_BSIZE;
 284
 285             do
 286             {
 287                 *dst = *src;
 288                 dst += _GREY_BSIZE;
 289                 src += _GREY_BSIZE;
 290             }
 291             while (dst < line_end);
 292         }
 293         for (; ~yd & _GREY_BMASK; yd--)  /* Fill remainder of current block. */
 294         {
 295             dst = _grey_info.values
 296                 + _GREY_MULUQ(_grey_info.width, yd & ~_GREY_BMASK)
 297                 + (~yd & _GREY_BMASK);
 298             line_end = dst + _grey_info.width * _GREY_BSIZE;
 299
 300             do
 301             {
 302                 line_end -= _GREY_BSIZE;
 303                 *line_end = blank;
 304             }
 305             while (dst < line_end);
 306         }
 307         /* Top pixel in a block has the highest address, but dst must point
 308          * to the lowest address in that block for the subsequent fill. */
 309         dst -= _GREY_BMASK;
 310     }
 311     else
 312 #endif
 313     {
 314         int blen = _GREY_MULUQ(_grey_info.height - count, _grey_info.width);
 315
 316         dst -= blen;
 317         _grey_info.rb->memmove(dst, start, blen);
 318     }
 319     _grey_info.rb->memset(start, blank, dst - start);
 320     /* Fill remainder at once. */
 321 #ifdef SIMULATOR
 322     _grey_info.rb->sim_lcd_ex_update_rect(_grey_info.x, _grey_info.y,
 323                                           _grey_info.width, _grey_info.height);
 324 #endif
 325 }