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     if (count & _GREY_BMASK)
 196     {
 197         /* Scrolling by fractional blocks - move pixel wise. */
 198         unsigned char *line_end;
 199         int ys, yd;
 200
 201         for (ys = count, yd = 0; ys < _grey_info.height; ys++, yd++)
 202         {
 203             dst = _grey_info.values
 204                 + _GREY_MULUQ(_grey_info.width, yd & ~_GREY_BMASK)
 205                 + (~yd & _GREY_BMASK);
 206             src = _grey_info.values
 207                 + _GREY_MULUQ(_grey_info.width, ys & ~_GREY_BMASK)
 208                 + (~ys & _GREY_BMASK);
 209             line_end = dst + _grey_info.width * _GREY_BSIZE;
 210
 211             do
 212             {
 213                 *dst = *src;
 214                 dst += _GREY_BSIZE;
 215                 src += _GREY_BSIZE;
 216             }
 217             while (dst < line_end);
 218         }
 219         for (; yd & _GREY_BMASK; yd++)   /* Fill remainder of current block. */
 220         {
 221             dst = _grey_info.values
 222                 + _GREY_MULUQ(_grey_info.width, yd & ~_GREY_BMASK)
 223                 + (~yd & _GREY_BMASK);
 224             line_end = dst + _grey_info.width * _GREY_BSIZE;
 225
 226             do
 227             {
 228                 *dst = blank;
 229                 dst += _GREY_BSIZE;
 230             }
 231             while (dst < line_end);
 232         }
 233     }
 234     else
 235 #endif
 236     {
 237         int blen = _GREY_MULUQ(_grey_info.height - count, _grey_info.width);
 238
 239         src = dst + _GREY_MULUQ(count, _grey_info.width);
 240         _grey_info.rb->memmove(dst, src, blen);
 241         dst += blen;
 242     }
 243     _grey_info.rb->memset(dst, blank, end - dst); /* Fill remainder at once. */
 244 #ifdef SIMULATOR
 245     _grey_info.rb->sim_lcd_ex_update_rect(_grey_info.x, _grey_info.y,
 246                                           _grey_info.width, _grey_info.height);
 247 #endif
 248 }
 249
 250 /* Scroll down */
 251 void grey_ub_scroll_down(int count)
 252 {
 253     unsigned char *start, *dst;
 254     int blank;
 255
 256     if ((unsigned)count >= (unsigned)_grey_info.height)
 257         return;
 258
 259     start = _grey_info.values;
 260     dst   = start + _GREY_MULUQ(_grey_info.height, _grey_info.width);
 261     blank = _grey_info.gvalue[(_grey_info.drawmode & DRMODE_INVERSEVID) ?
 262                               _grey_info.fg_brightness :
 263                               _grey_info.bg_brightness];
 264
 265 #if LCD_PIXELFORMAT == VERTICAL_PACKING
 266     if (count & _GREY_BMASK)
 267     {
 268         /* Scrolling by fractional blocks - move pixel wise. */
 269         unsigned char *src, *line_end;
 270         int ys, yd;
 271
 272         yd = _grey_info.height - 1;
 273         for (ys = yd - count; ys >= 0; ys--, yd--)
 274         {
 275             dst = _grey_info.values
 276                 + _GREY_MULUQ(_grey_info.width, yd & ~_GREY_BMASK)
 277                 + (~yd & _GREY_BMASK);
 278             src = _grey_info.values
 279                 + _GREY_MULUQ(_grey_info.width, ys & ~_GREY_BMASK)
 280                 + (~ys & _GREY_BMASK);
 281             line_end = dst + _grey_info.width * _GREY_BSIZE;
 282
 283             do
 284             {
 285                 *dst = *src;
 286                 dst += _GREY_BSIZE;
 287                 src += _GREY_BSIZE;
 288             }
 289             while (dst < line_end);
 290         }
 291         for (; ~yd & _GREY_BMASK; yd--)  /* Fill remainder of current block. */
 292         {
 293             dst = _grey_info.values
 294                 + _GREY_MULUQ(_grey_info.width, yd & ~_GREY_BMASK)
 295                 + (~yd & _GREY_BMASK);
 296             line_end = dst + _grey_info.width * _GREY_BSIZE;
 297
 298             do
 299             {
 300                 line_end -= _GREY_BSIZE;
 301                 *line_end = blank;
 302             }
 303             while (dst < line_end);
 304         }
 305     }
 306     else
 307 #endif
 308     {
 309         int blen = _GREY_MULUQ(_grey_info.height - count, _grey_info.width);
 310
 311         dst -= blen;
 312         _grey_info.rb->memmove(dst, start, blen);
 313     }
 314     _grey_info.rb->memset(start, blank, dst - start);
 315     /* Fill remainder at once. */
 316 #ifdef SIMULATOR
 317     _grey_info.rb->sim_lcd_ex_update_rect(_grey_info.x, _grey_info.y,
 318                                           _grey_info.width, _grey_info.height);
 319 #endif
 320 }