From 71c83b9b6b091e2adacbcf651a2c41e4d4c03b59 Mon Sep 17 00:00:00 2001 From: Jens Arnold Date: Wed, 19 May 2004 17:05:17 +0000 Subject: Removed duplicate grayscale framework git-svn-id: svn://svn.rockbox.org/rockbox/trunk@4651 a1c6a512-1295-4272-9138-f99709370657 --- apps/plugins/lib/grayscale.c | 1757 ------------------------------------------ 1 file changed, 1757 deletions(-) delete mode 100644 apps/plugins/lib/grayscale.c (limited to 'apps/plugins/lib/grayscale.c') diff --git a/apps/plugins/lib/grayscale.c b/apps/plugins/lib/grayscale.c deleted file mode 100644 index 3b33b6e19c..0000000000 --- a/apps/plugins/lib/grayscale.c +++ /dev/null @@ -1,1757 +0,0 @@ -/*************************************************************************** -* __________ __ ___. -* Open \______ \ ____ ____ | | _\_ |__ _______ ___ -* Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / -* Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < -* Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ -* \/ \/ \/ \/ \/ -* $Id$ -* -* Grayscale framework & demo plugin -* -* Copyright (C) 2004 Jens Arnold -* -* All files in this archive are subject to the GNU General Public License. -* See the file COPYING in the source tree root for full license agreement. -* -* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY -* KIND, either express or implied. -* -****************************************************************************/ - -#ifndef SIMULATOR /* not for simulator by now */ -#include "plugin.h" - -#ifdef HAVE_LCD_BITMAP /* and also not for the Player */ -#include "grayscale.h" - -/******************************* Globals ***********************************/ - -static struct plugin_api* rb; /* global api struct pointer */ - -/*********************** Begin grayscale framework *************************/ - -/* This is a generic framework to use grayscale display within rockbox - * plugins. It obviously does not work for the player. - * - * If you want to use grayscale display within a plugin, copy this section - * (up to "End grayscale framework") into your source and you are able to use - * it. For detailed documentation look at the head of each public function. - * - * It requires a global Rockbox api pointer in "rb" and uses the rockbox - * timer api so you cannot use that timer for other purposes while - * displaying grayscale. - * - * The framework consists of 3 sections: - * - * - internal core functions and definitions - * - public core functions - * - public optional functions - * - * Usually you will use functions from the latter two sections in your code. - * You can cut out functions from the third section that you do not need in - * order to not waste space. Don't forget to cut the prototype as well. - */ - -/** implementation **/ - -/* timer interrupt handler: display next bitplane */ -void gray_timer_isr(void) -{ - rb->lcd_blit(graybuf->data + MULU16(graybuf->plane_size, graybuf->cur_plane), - graybuf->x, graybuf->by, graybuf->width, graybuf->bheight, - graybuf->width); - - if (++graybuf->cur_plane >= graybuf->depth) - graybuf->cur_plane = 0; - - if (graybuf->flags & GRAY_DEFERRED_UPDATE) /* lcd_update() requested? */ - { - int x1 = MAX(graybuf->x, 0); - int x2 = MIN(graybuf->x + graybuf->width, LCD_WIDTH); - int y1 = MAX(graybuf->by << 3, 0); - int y2 = MIN((graybuf->by + graybuf->bheight) << 3, LCD_HEIGHT); - - if (y1 > 0) /* refresh part above overlay, full width */ - rb->lcd_update_rect(0, 0, LCD_WIDTH, y1); - - if (y2 < LCD_HEIGHT) /* refresh part below overlay, full width */ - rb->lcd_update_rect(0, y2, LCD_WIDTH, LCD_HEIGHT - y2); - - if (x1 > 0) /* refresh part to the left of overlay */ - rb->lcd_update_rect(0, y1, x1, y2 - y1); - - if (x2 < LCD_WIDTH) /* refresh part to the right of overlay */ - rb->lcd_update_rect(x2, y1, LCD_WIDTH - x2, y2 - y1); - - graybuf->flags &= ~GRAY_DEFERRED_UPDATE; /* clear request */ - } -} - -/* Set a pixel to a specific bit pattern - * This is the fundamental graphics primitive, asm optimized */ -void graypixel(int x, int y, unsigned long pattern) -{ - register long address, mask, random; - - /* Some (pseudo-)random function must be used here to shift the bit - * pattern randomly, otherwise you would get flicker and/or moire. - * Since rand() is relatively slow, I've implemented a simple, but very - * fast pseudo-random generator based on linear congruency in assembler. - * It delivers 16 pseudo-random bits in each iteration. */ - - /* simple but fast pseudo-random generator */ - asm( - "mov.w @%1,%0 \n" /* load last value */ - "mov #75,r1 \n" - "mulu %0,r1 \n" /* multiply by 75 */ - "sts macl,%0 \n" /* get result */ - "add #74,%0 \n" /* add another 74 */ - "mov.w %0,@%1 \n" /* store new value */ - /* Since the lower bits are not very random: */ - "shlr8 %0 \n" /* get bits 8..15 (need max. 5) */ - "and %2,%0 \n" /* mask out unneeded bits */ - : /* outputs */ - /* %0 */ "=&r"(random) - : /* inputs */ - /* %1 */ "r"(&gray_random_buffer), - /* %2 */ "r"(graybuf->randmask) - : /* clobbers */ - "r1","macl" - ); - - /* precalculate mask and byte address in first bitplane */ - asm( - "mov %3,%0 \n" /* take y as base for address offset */ - "shlr2 %0 \n" /* shift right by 3 (= divide by 8) */ - "shlr %0 \n" - "mulu %0,%2 \n" /* multiply with width */ - "and #7,%3 \n" /* get lower 3 bits of y */ - "sts macl,%0 \n" /* get mulu result */ - "add %4,%0 \n" /* add base + x to get final address */ - - "mov %3,%1 \n" /* move lower 3 bits of y out of r0 */ - "mova .pp_table,%3 \n" /* get address of mask table in r0 */ - "bra .pp_end \n" /* skip the table */ - "mov.b @(%3,%1),%1 \n" /* get entry from mask table */ - - ".align 2 \n" - ".pp_table: \n" /* mask table */ - ".byte 0x01 \n" - ".byte 0x02 \n" - ".byte 0x04 \n" - ".byte 0x08 \n" - ".byte 0x10 \n" - ".byte 0x20 \n" - ".byte 0x40 \n" - ".byte 0x80 \n" - - ".pp_end: \n" - : /* outputs */ - /* %0 */ "=&r"(address), - /* %1 */ "=&r"(mask) - : /* inputs */ - /* %2 */ "r"(graybuf->width), - /* %3 = r0 */ "z"(y), - /* %4 */ "r"(graybuf->data + x) - : /* clobbers */ - "macl" - ); - - /* the hard part: set bits in all bitplanes according to pattern */ - asm( - "cmp/hs %1,%5 \n" /* random >= depth ? */ - "bf .p_ntrim \n" - "sub %1,%5 \n" /* yes: random -= depth */ - /* it's sufficient to do this once, since the mask guarantees - * random < 2 * depth */ - ".p_ntrim: \n" - - /* calculate some addresses */ - "mulu %4,%1 \n" /* end address offset */ - "not %3,r1 \n" /* get inverse mask (for "and") */ - "sts macl,%1 \n" /* result of mulu */ - "mulu %4,%5 \n" /* address offset of 'th plane */ - "add %2,%1 \n" /* end offset -> end address */ - "sts macl,%5 \n" /* result of mulu */ - "add %2,%5 \n" /* address of 'th plane */ - "bra .p_start1 \n" - "mov %5,r2 \n" /* copy address */ - - /* first loop: set bits from 'th bitplane to last */ - ".p_loop1: \n" - "mov.b @r2,r3 \n" /* get data byte */ - "shlr %0 \n" /* shift bit mask, sets t bit */ - "and r1,r3 \n" /* reset bit (-> "white") */ - "bf .p_white1 \n" /* t=0? -> "white" bit */ - "or %3,r3 \n" /* set bit ("black" bit) */ - ".p_white1: \n" - "mov.b r3,@r2 \n" /* store data byte */ - "add %4,r2 \n" /* advance address to next bitplane */ - ".p_start1: \n" - "cmp/hi r2,%1 \n" /* address < end address ? */ - "bt .p_loop1 \n" - - "bra .p_start2 \n" - "nop \n" - - /* second loop: set bits from first to 'th bitplane - * Bit setting works the other way round here to equalize average - * execution times for bright and dark pixels */ - ".p_loop2: \n" - "mov.b @%2,r3 \n" /* get data byte */ - "shlr %0 \n" /* shift bit mask, sets t bit */ - "or %3,r3 \n" /* set bit (-> "black") */ - "bt .p_black2 \n" /* t=1? -> "black" bit */ - "and r1,r3 \n" /* reset bit ("white" bit) */ - ".p_black2: \n" - "mov.b r3,@%2 \n" /* store data byte */ - "add %4,%2 \n" /* advance address to next bitplane */ - ".p_start2: \n" - "cmp/hi %2,%5 \n" /* address < 'th address ? */ - "bt .p_loop2 \n" - : /* outputs */ - : /* inputs */ - /* %0 */ "r"(pattern), - /* %1 */ "r"(graybuf->depth), - /* %2 */ "r"(address), - /* %3 */ "r"(mask), - /* %4 */ "r"(graybuf->plane_size), - /* %5 */ "r"(random) - : /* clobbers */ - "r1", "r2", "r3", "macl" - ); -} - -/* Set 8 pixels to specific gray values at once, asm optimized - * This greatly enhances performance of gray_fillrect() and gray_drawgraymap() - * for larger rectangles and graymaps */ -void grayblock(int x, int by, unsigned char* src, int stride) -{ - /* precalculate the bit patterns with random shifts (same RNG as graypixel, - * see there for an explanation) for all 8 pixels and put them on the - * stack (!) */ - asm( - "mova .gb_reload,r0 \n" /* set default loopback address */ - "tst %1,%1 \n" /* stride == 0 ? */ - "bf .gb_needreload \n" /* no: keep that address */ - "mova .gb_reuse,r0 \n" /* yes: set shortcut (no reload) */ - ".gb_needreload: \n" - "mov r0,r2 \n" /* loopback address to r2 */ - "mov #7,r3 \n" /* loop count in r3: 8 pixels */ - - ".align 2 \n" /** load pattern for pixel **/ - ".gb_reload: \n" - "mov.b @%0,r0 \n" /* load src byte */ - "extu.b r0,r0 \n" /* extend unsigned */ - "mulu %2,r0 \n" /* macl = byte * depth; */ - "add %1,%0 \n" /* src += stride; */ - "sts macl,r4 \n" /* r4 = macl; */ - "add r4,r0 \n" /* byte += r4; */ - "shlr8 r0 \n" /* byte >>= 8; */ - "shll2 r0 \n" - "mov.l @(r0,%3),r4 \n" /* r4 = bitpattern[byte]; */ - - ".align 2 \n" /** RNG **/ - ".gb_reuse: \n" - "mov.w @%4,r1 \n" /* load last value */ - "mov #75,r0 \n" - "mulu r0,r1 \n" /* multiply by 75 */ - "sts macl,r1 \n" - "add #74,r1 \n" /* add another 74 */ - "mov.w r1,@%4 \n" /* store new value */ - /* Since the lower bits are not very random: */ - "shlr8 r1 \n" /* get bits 8..15 (need max. 5) */ - "and %5,r1 \n" /* mask out unneeded bits */ - - "cmp/hs %2,r1 \n" /* random >= depth ? */ - "bf .gb_ntrim \n" - "sub %2,r1 \n" /* yes: random -= depth; */ - ".gb_ntrim: \n" - - "mov.l .ashlsi3,r0 \n" /** rotate pattern **/ - "jsr @r0 \n" /* shift r4 left by r1 */ - "mov r1,r5 \n" - - "mov %2,r5 \n" - "sub r1,r5 \n" /* r5 = depth - r1 */ - "mov.l .lshrsi3,r1 \n" - "jsr @r1 \n" /* shift r4 right by r5 */ - "mov r0,r1 \n" /* last result stored in r1 */ - - "or r1,r0 \n" /* rotated_pattern = r0 | r1 */ - "mov.l r0,@-r15 \n" /* push pattern */ - - "cmp/pl r3 \n" /* loop count > 0? */ - "bf .gb_patdone \n" /* no: done */ - - "jmp @r2 \n" /* yes: loop */ - "add #-1,r3 \n" /* decrease loop count */ - - ".align 2 \n" - ".ashlsi3: \n" /* C library routine: */ - ".long ___ashlsi3 \n" /* shift r4 left by r5, return in r0 */ - ".lshrsi3: \n" /* C library routine: */ - ".long ___lshrsi3 \n" /* shift r4 right by r5, return in r0 */ - /* both routines preserve r4, destroy r5 and take ~16 cycles */ - - ".gb_patdone: \n" - : /* outputs */ - : /* inputs */ - /* %0 */ "r"(src), - /* %1 */ "r"(stride), - /* %2 */ "r"(graybuf->depth), - /* %3 */ "r"(graybuf->bitpattern), - /* %4 */ "r"(&gray_random_buffer), - /* %5 */ "r"(graybuf->randmask) - : /* clobbers */ - "r0", "r1", "r2", "r3", "r4", "r5", "macl" - ); - - /* calculate start address in first bitplane and end address */ - register unsigned char *address = graybuf->data + x - + MULU16(graybuf->width, by); - register unsigned char *end_addr = address - + MULU16(graybuf->depth, graybuf->plane_size); - - /* set the bits for all 8 pixels in all bytes according to the - * precalculated patterns on the stack */ - asm ( - "mov.l @r15+,r1 \n" /* pop all 8 patterns */ - "mov.l @r15+,r2 \n" - "mov.l @r15+,r3 \n" - "mov.l @r15+,r4 \n" - "mov.l @r15+,r5 \n" - "mov.l @r15+,r6 \n" - "mov.l @r15+,r7 \n" - "mov.l @r15+,r8 \n" - - ".gb_loop: \n" /* loop for all bitplanes */ - "shlr r1 \n" /* rotate lsb of pattern 1 to t bit */ - "rotcl r0 \n" /* rotate t bit into r0 */ - "shlr r2 \n" - "rotcl r0 \n" - "shlr r3 \n" - "rotcl r0 \n" - "shlr r4 \n" - "rotcl r0 \n" - "shlr r5 \n" - "rotcl r0 \n" - "shlr r6 \n" - "rotcl r0 \n" - "shlr r7 \n" - "rotcl r0 \n" - "shlr r8 \n" - "rotcl r0 \n" - "mov.b r0,@%0 \n" /* store byte to bitplane */ - "add %2,%0 \n" /* advance to next bitplane */ - "cmp/hi %0,%1 \n" /* last bitplane done? */ - "bt .gb_loop \n" /* no: loop */ - : /* outputs */ - : /* inputs */ - /* %0 */ "r"(address), - /* %1 */ "r"(end_addr), - /* %2 */ "r"(graybuf->plane_size) - : /* clobbers */ - "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8" - ); -} - -/* Invert the bits for 1-8 pixels within the buffer */ -void grayinvertmasked(int x, int by, unsigned char mask) -{ - asm( - "mulu %4,%5 \n" /* width * by (offset of row) */ - "mov #0,r1 \n" /* current_plane = 0 */ - "sts macl,r2 \n" /* get mulu result */ - "add r2,%1 \n" /* -> address in 1st bitplane */ - - ".i_loop: \n" - "mov.b @%1,r2 \n" /* get data byte */ - "add #1,r1 \n" /* current_plane++; */ - "xor %2,r2 \n" /* invert bits */ - "mov.b r2,@%1 \n" /* store data byte */ - "add %3,%1 \n" /* advance address to next bitplane */ - "cmp/hi r1,%0 \n" /* current_plane < depth ? */ - "bt .i_loop \n" - : /* outputs */ - : /* inputs */ - /* %0 */ "r"(graybuf->depth), - /* %1 */ "r"(graybuf->data + x), - /* %2 */ "r"(mask), - /* %3 */ "r"(graybuf->plane_size), - /* %4 */ "r"(graybuf->width), - /* %5 */ "r"(by) - : /* clobbers */ - "r1", "r2", "macl" - ); -} - -/** implementation **/ - -/* Prepare the grayscale display buffer - * - * arguments: - * gbuf = pointer to the memory area to use (e.g. plugin buffer) - * gbuf_size = max usable size of the buffer - * width = width in pixels (1..112) - * bheight = height in 8-pixel units (1..8) - * depth = desired number of shades - 1 (1..32) - * - * result: - * = depth if there was enough memory - * < depth if there wasn't enough memory. The number of displayable - * shades is smaller than desired, but it still works - * = 0 if there wasn't even enough memory for 1 bitplane (black & white) - * - * You can request any depth from 1 to 32, not just powers of 2. The routine - * performs "graceful degradation" if the memory is not sufficient for the - * desired depth. As long as there is at least enough memory for 1 bitplane, - * it creates as many bitplanes as fit into memory, although 1 bitplane will - * only deliver black & white display. - * - * The total memory needed can be calculated as follows: - * total_mem = - * sizeof(tGraymap) (= 48 bytes currently) - * + sizeof(long) (= 4 bytes) - * + (width * bheight + sizeof(long)) * depth - * + 0..3 (longword alignment of grayscale display buffer) - */ -int gray_init_buffer(unsigned char *gbuf, int gbuf_size, int width, - int bheight, int depth) -{ - int possible_depth, plane_size; - int i, j; - - if ((unsigned) width > LCD_WIDTH - || (unsigned) bheight > (LCD_HEIGHT >> 3) - || depth < 1) - return 0; - - while ((unsigned long)gbuf & 3) /* the buffer has to be long aligned */ - { - gbuf++; - gbuf_size--; - } - - plane_size = width * bheight; - possible_depth = (gbuf_size - sizeof(tGraybuf) - sizeof(unsigned long)) - / (plane_size + sizeof(unsigned long)); - - if (possible_depth < 1) - return 0; - - depth = MIN(depth, 32); - depth = MIN(depth, possible_depth); - - graybuf = (tGraybuf *) gbuf; /* global pointer to buffer structure */ - - graybuf->x = 0; - graybuf->by = 0; - graybuf->width = width; - graybuf->height = bheight << 3; - graybuf->bheight = bheight; - graybuf->plane_size = plane_size; - graybuf->depth = depth; - graybuf->cur_plane = 0; - graybuf->flags = 0; - graybuf->data = gbuf + sizeof(tGraybuf); - graybuf->bitpattern = (unsigned long *) (graybuf->data - + depth * plane_size); - - i = depth; - j = 8; - while (i != 0) - { - i >>= 1; - j--; - } - graybuf->randmask = 0xFF >> j; - - /* initial state is all white */ - rb->memset(graybuf->data, 0, depth * plane_size); - - /* Precalculate the bit patterns for all possible pixel values */ - for (i = 0; i <= depth; i++) - { - unsigned long pattern = 0; - int value = 0; - - for (j = 0; j < depth; j++) - { - pattern <<= 1; - value += i; - - if (value >= depth) - value -= depth; /* "white" bit */ - else - pattern |= 1; /* "black" bit */ - } - /* now the lower bits contain the pattern */ - - graybuf->bitpattern[i] = pattern; - } - - return depth; -} - -/* Release the grayscale display buffer - * - * Switches the grayscale overlay off at first if it is still running, - * then sets the pointer to NULL. - * DO CALL either this function or at least gray_show_display(false) - * before you exit, otherwise nasty things may happen. - */ -void gray_release_buffer(void) -{ - gray_show_display(false); - graybuf = NULL; -} - -/* Set position of the top left corner of the grayscale overlay - * - * arguments: - * x = left margin in pixels - * by = top margin in 8-pixel units - * - * You may set this in a way that the overlay spills across the right or - * bottom display border. In this case it will simply be clipped by the - * LCD controller. You can even set negative values, this will clip at the - * left or top border. I did not test it, but the limits may be +127 / -128 - * - * If you use this while the grayscale overlay is running, the now-freed area - * will be restored. - */ -void gray_position_display(int x, int by) -{ - if (graybuf == NULL) - return; - - graybuf->x = x; - graybuf->by = by; - - if (graybuf->flags & GRAY_RUNNING) - graybuf->flags |= GRAY_DEFERRED_UPDATE; -} - -/* Switch the grayscale overlay on or off - * - * arguments: - * enable = true: the grayscale overlay is switched on if initialized - * = false: the grayscale overlay is switched off and the regular lcd - * content is restored - * - * DO NOT call lcd_update() or any other api function that directly accesses - * the lcd while the grayscale overlay is running! If you need to do - * lcd_update() to update something outside the grayscale overlay area, use - * gray_deferred_update() instead. - * - * Other functions to avoid are: - * lcd_blit() (obviously), lcd_update_rect(), lcd_set_contrast(), - * lcd_set_invert_display(), lcd_set_flip(), lcd_roll() - * - * The grayscale display consumes ~50 % CPU power (for a full screen overlay, - * less if the overlay is smaller) when switched on. You can switch the overlay - * on and off as many times as you want. - */ -void gray_show_display(bool enable) -{ - if (graybuf == NULL) - return; - - if (enable) - { - graybuf->flags |= GRAY_RUNNING; - rb->plugin_register_timer(FREQ / 67, 1, gray_timer_isr); - } - else - { - rb->plugin_unregister_timer(); - graybuf->flags &= ~GRAY_RUNNING; - rb->lcd_update(); /* restore whatever there was before */ - } -} - -/*** public optional functions ***/ - -/* Here are the various graphics primitives. Cut out functions you do not - * need in order to keep plugin code size down. - */ - -/** prototypes **/ - -/** implementation **/ - -/* Clear the grayscale display (sets all pixels to white) - */ -void gray_clear_display(void) -{ - if (graybuf == NULL) - return; - - rb->memset(graybuf->data, 0, MULU16(graybuf->depth, graybuf->plane_size)); -} - -/* Set the grayscale display to all black - */ -void gray_black_display(void) -{ - if (graybuf == NULL) - return; - - rb->memset(graybuf->data, 0xFF, MULU16(graybuf->depth, graybuf->plane_size)); -} - -/* Do an lcd_update() to show changes done by rb->lcd_xxx() functions (in areas - * of the screen not covered by the grayscale overlay). If the grayscale - * overlay is running, the update will be done in the next call of the - * interrupt routine, otherwise it will be performed right away. See also - * comment for the gray_show_display() function. - */ -void gray_deferred_update(void) -{ - if (graybuf != NULL && (graybuf->flags & GRAY_RUNNING)) - graybuf->flags |= GRAY_DEFERRED_UPDATE; - else - rb->lcd_update(); -} - -/* Scroll the whole grayscale buffer left by pixels - * - * black_border determines if the pixels scrolled in at the right are black - * or white - * - * Scrolling left/right by an even pixel count is almost twice as fast as - * scrolling by an odd pixel count. - */ -void gray_scroll_left(int count, bool black_border) -{ - int by, d; - unsigned char *ptr; - unsigned char filler; - - if (graybuf == NULL || (unsigned) count >= (unsigned) graybuf->width) - return; - - if (black_border) - filler = 0xFF; - else - filler = 0; - - /* Scroll row by row to minimize flicker (byte rows = 8 pixels each) */ - for (by = 0; by < graybuf->bheight; by++) - { - ptr = graybuf->data + MULU16(graybuf->width, by); - for (d = 0; d < graybuf->depth; d++) - { - if (count & 1) /* odd count: scroll byte-wise */ - asm volatile ( - ".sl_loop1: \n" - "mov.b @%0+,r1 \n" - "mov.b r1,@(%2,%0) \n" - "cmp/hi %0,%1 \n" - "bt .sl_loop1 \n" - : /* outputs */ - : /* inputs */ - /* %0 */ "r"(ptr + count), - /* %1 */ "r"(ptr + graybuf->width), - /* %2 */ "z"(-count - 1) - : /* clobbers */ - "r1" - ); - else /* even count: scroll word-wise */ - asm volatile ( - ".sl_loop2: \n" - "mov.w @%0+,r1 \n" - "mov.w r1,@(%2,%0) \n" - "cmp/hi %0,%1 \n" - "bt .sl_loop2 \n" - : /* outputs */ - : /* inputs */ - /* %0 */ "r"(ptr + count), - /* %1 */ "r"(ptr + graybuf->width), - /* %2 */ "z"(-count - 2) - : /* clobbers */ - "r1" - ); - - rb->memset(ptr + graybuf->width - count, filler, count); - ptr += graybuf->plane_size; - } - } -} - -/* Scroll the whole grayscale buffer right by pixels - * - * black_border determines if the pixels scrolled in at the left are black - * or white - * - * Scrolling left/right by an even pixel count is almost twice as fast as - * scrolling by an odd pixel count. - */ -void gray_scroll_right(int count, bool black_border) -{ - int by, d; - unsigned char *ptr; - unsigned char filler; - - if (graybuf == NULL || (unsigned) count >= (unsigned) graybuf->width) - return; - - if (black_border) - filler = 0xFF; - else - filler = 0; - - /* Scroll row by row to minimize flicker (byte rows = 8 pixels each) */ - for (by = 0; by < graybuf->bheight; by++) - { - ptr = graybuf->data + MULU16(graybuf->width, by); - for (d = 0; d < graybuf->depth; d++) - { - if (count & 1) /* odd count: scroll byte-wise */ - asm volatile ( - ".sr_loop1: \n" - "mov.b @(%2,%0),r1 \n" - "mov.b r1,@-%0 \n" - "cmp/hi %1,%0 \n" - "bt .sr_loop1 \n" - : /* outputs */ - : /* inputs */ - /* %0 */ "r"(ptr + graybuf->width), - /* %1 */ "r"(ptr + count), - /* %2 */ "z"(-count - 1) - : /* clobbers */ - "r1" - ); - else /* even count: scroll word-wise */ - asm volatile ( - ".sr_loop2: \n" - "mov.w @(%2,%0),r1 \n" - "mov.w r1,@-%0 \n" - "cmp/hi %1,%0 \n" - "bt .sr_loop2 \n" - : /* outputs */ - : /* inputs */ - /* %0 */ "r"(ptr + graybuf->width), - /* %1 */ "r"(ptr + count), - /* %2 */ "z"(-count - 2) - : /* clobbers */ - "r1" - ); - - rb->memset(ptr, filler, count); - ptr += graybuf->plane_size; - } - } -} - -/* Scroll the whole grayscale buffer up by 8 pixels - * - * black_border determines if the pixels scrolled in at the bottom are black - * or white - * - * Scrolling up/down by 8 pixels is very fast. - */ -void gray_scroll_up8(bool black_border) -{ - int by, d; - unsigned char *ptr; - unsigned char filler; - - if (graybuf == NULL) - return; - - if (black_border) - filler = 0xFF; - else - filler = 0; - - /* Scroll row by row to minimize flicker (byte rows = 8 pixels each) */ - for (by = 1; by < graybuf->bheight; by++) - { - ptr = graybuf->data + MULU16(graybuf->width, by); - for (d = 0; d < graybuf->depth; d++) - { - rb->memcpy(ptr - graybuf->width, ptr, graybuf->width); - ptr += graybuf->plane_size; - } - } - /* fill last row */ - ptr = graybuf->data + graybuf->plane_size - graybuf->width; - for (d = 0; d < graybuf->depth; d++) - { - rb->memset(ptr, filler, graybuf->width); - ptr += graybuf->plane_size; - } -} - -/* Scroll the whole grayscale buffer down by 8 pixels - * - * black_border determines if the pixels scrolled in at the top are black - * or white - * - * Scrolling up/down by 8 pixels is very fast. - */ -void gray_scroll_down8(bool black_border) -{ - int by, d; - unsigned char *ptr; - unsigned char filler; - - if (graybuf == NULL) - return; - - if (black_border) - filler = 0xFF; - else - filler = 0; - - /* Scroll row by row to minimize flicker (byte rows = 8 pixels each) */ - for (by = graybuf->bheight - 1; by > 0; by--) - { - ptr = graybuf->data + MULU16(graybuf->width, by); - for (d = 0; d < graybuf->depth; d++) - { - rb->memcpy(ptr, ptr - graybuf->width, graybuf->width); - ptr += graybuf->plane_size; - } - } - /* fill first row */ - ptr = graybuf->data; - for (d = 0; d < graybuf->depth; d++) - { - rb->memset(ptr, filler, graybuf->width); - ptr += graybuf->plane_size; - } -} - -/* Scroll the whole grayscale buffer up by pixels (<= 7) - * - * black_border determines if the pixels scrolled in at the bottom are black - * or white - * - * Scrolling up/down pixel-wise is significantly slower than scrolling - * left/right or scrolling up/down byte-wise because it involves bit - * shifting. That's why it is asm optimized. - */ -void gray_scroll_up(int count, bool black_border) -{ - unsigned long filler; - - if (graybuf == NULL || (unsigned) count > 7) - return; - - if (black_border) - filler = 0xFF; - else - filler = 0; - - /* scroll column by column to minimize flicker */ - asm( - "mov #0,r6 \n" /* x = 0 */ - "mova .su_shifttbl,r0 \n" /* calculate jump destination for */ - "mov.b @(r0,%6),%6 \n" /* shift amount from table */ - "bra .su_cloop \n" /* skip table */ - "add r0,%6 \n" - - ".align 2 \n" - ".su_shifttbl: \n" /* shift jump offset table */ - ".byte .su_shift0 - .su_shifttbl \n" - ".byte .su_shift1 - .su_shifttbl \n" - ".byte .su_shift2 - .su_shifttbl \n" - ".byte .su_shift3 - .su_shifttbl \n" - ".byte .su_shift4 - .su_shifttbl \n" - ".byte .su_shift5 - .su_shifttbl \n" - ".byte .su_shift6 - .su_shifttbl \n" - ".byte .su_shift7 - .su_shifttbl \n" - - ".su_cloop: \n" /* repeat for every column */ - "mov %1,r2 \n" /* get start address */ - "mov #0,r3 \n" /* current_plane = 0 */ - - ".su_oloop: \n" /* repeat for every bitplane */ - "mov r2,r4 \n" /* get start address */ - "mov #0,r5 \n" /* current_row = 0 */ - "mov %5,r1 \n" /* get filler bits */ - - ".su_iloop: \n" /* repeat for all rows */ - "sub %2,r4 \n" /* address -= width */ - "mov.b @r4,r0 \n" /* get data byte */ - "shll8 r1 \n" /* old data to 2nd byte */ - "extu.b r0,r0 \n" /* extend unsigned */ - "or r1,r0 \n" /* combine old data */ - "jmp @%6 \n" /* jump into shift "path" */ - "extu.b r0,r1 \n" /* store data for next round */ - - ".su_shift6: \n" /* shift right by 0..7 bits */ - "shlr2 r0 \n" - ".su_shift4: \n" - "shlr2 r0 \n" - ".su_shift2: \n" - "bra .su_shift0 \n" - "shlr2 r0 \n" - ".su_shift7: \n" - "shlr2 r0 \n" - ".su_shift5: \n" - "shlr2 r0 \n" - ".su_shift3: \n" - "shlr2 r0 \n" - ".su_shift1: \n" - "shlr r0 \n" - ".su_shift0: \n" - - "mov.b r0,@r4 \n" /* store data */ - "add #1,r5 \n" /* current_row++ */ - "cmp/hi r5,%3 \n" /* current_row < bheight ? */ - "bt .su_iloop \n" - - "add %4,r2 \n" /* start_address += plane_size */ - "add #1,r3 \n" /* current_plane++ */ - "cmp/hi r3,%0 \n" /* current_plane < depth ? */ - "bt .su_oloop \n" - - "add #1,%1 \n" /* start_address++ */ - "add #1,r6 \n" /* x++ */ - "cmp/hi r6,%2 \n" /* x < width ? */ - "bt .su_cloop \n" - : /* outputs */ - : /* inputs */ - /* %0 */ "r"(graybuf->depth), - /* %1 */ "r"(graybuf->data + graybuf->plane_size), - /* %2 */ "r"(graybuf->width), - /* %3 */ "r"(graybuf->bheight), - /* %4 */ "r"(graybuf->plane_size), - /* %5 */ "r"(filler), - /* %6 */ "r"(count) - : /* clobbers */ - "r0", "r1", "r2", "r3", "r4", "r5", "r6" - ); -} - -/* Scroll the whole grayscale buffer down by pixels (<= 7) - * - * black_border determines if the pixels scrolled in at the top are black - * or white - * - * Scrolling up/down pixel-wise is significantly slower than scrolling - * left/right or scrolling up/down byte-wise because it involves bit - * shifting. That's why it is asm optimized. - */ -void gray_scroll_down(int count, bool black_border) -{ - unsigned long filler; - - if (graybuf == NULL || (unsigned) count > 7) - return; - - if (black_border) - filler = 0xFF << count; /* calculate filler bits */ - else - filler = 0; - - /* scroll column by column to minimize flicker */ - asm( - "mov #0,r6 \n" /* x = 0 */ - "mova .sd_shifttbl,r0 \n" /* calculate jump destination for */ - "mov.b @(r0,%6),%6 \n" /* shift amount from table */ - "bra .sd_cloop \n" /* skip table */ - "add r0,%6 \n" - - ".align 2 \n" - ".sd_shifttbl: \n" /* shift jump offset table */ - ".byte .sd_shift0 - .sd_shifttbl \n" - ".byte .sd_shift1 - .sd_shifttbl \n" - ".byte .sd_shift2 - .sd_shifttbl \n" - ".byte .sd_shift3 - .sd_shifttbl \n" - ".byte .sd_shift4 - .sd_shifttbl \n" - ".byte .sd_shift5 - .sd_shifttbl \n" - ".byte .sd_shift6 - .sd_shifttbl \n" - ".byte .sd_shift7 - .sd_shifttbl \n" - - ".sd_cloop: \n" /* repeat for every column */ - "mov %1,r2 \n" /* get start address */ - "mov #0,r3 \n" /* current_plane = 0 */ - - ".sd_oloop: \n" /* repeat for every bitplane */ - "mov r2,r4 \n" /* get start address */ - "mov #0,r5 \n" /* current_row = 0 */ - "mov %5,r1 \n" /* get filler bits */ - - ".sd_iloop: \n" /* repeat for all rows */ - "shlr8 r1 \n" /* shift right to get residue */ - "mov.b @r4,r0 \n" /* get data byte */ - "jmp @%6 \n" /* jump into shift "path" */ - "extu.b r0,r0 \n" /* extend unsigned */ - - ".sd_shift6: \n" /* shift left by 0..7 bits */ - "shll2 r0 \n" - ".sd_shift4: \n" - "shll2 r0 \n" - ".sd_shift2: \n" - "bra .sd_shift0 \n" - "shll2 r0 \n" - ".sd_shift7: \n" - "shll2 r0 \n" - ".sd_shift5: \n" - "shll2 r0 \n" - ".sd_shift3: \n" - "shll2 r0 \n" - ".sd_shift1: \n" - "shll r0 \n" - ".sd_shift0: \n" - - "or r0,r1 \n" /* combine with last residue */ - "mov.b r1,@r4 \n" /* store data */ - "add %2,r4 \n" /* address += width */ - "add #1,r5 \n" /* current_row++ */ - "cmp/hi r5,%3 \n" /* current_row < bheight ? */ - "bt .sd_iloop \n" - - "add %4,r2 \n" /* start_address += plane_size */ - "add #1,r3 \n" /* current_plane++ */ - "cmp/hi r3,%0 \n" /* current_plane < depth ? */ - "bt .sd_oloop \n" - - "add #1,%1 \n" /* start_address++ */ - "add #1,r6 \n" /* x++ */ - "cmp/hi r6,%2 \n" /* x < width ? */ - "bt .sd_cloop \n" - : /* outputs */ - : /* inputs */ - /* %0 */ "r"(graybuf->depth), - /* %1 */ "r"(graybuf->data), - /* %2 */ "r"(graybuf->width), - /* %3 */ "r"(graybuf->bheight), - /* %4 */ "r"(graybuf->plane_size), - /* %5 */ "r"(filler), - /* %6 */ "r"(count) - : /* clobbers */ - "r0", "r1", "r2", "r3", "r4", "r5", "r6" - ); -} - -/* Set a pixel to a specific gray value - * - * brightness is 0..255 (black to white) regardless of real bit depth - */ -void gray_drawpixel(int x, int y, int brightness) -{ - if (graybuf == NULL - || (unsigned) x >= (unsigned) graybuf->width - || (unsigned) y >= (unsigned) graybuf->height - || (unsigned) brightness > 255) - return; - - graypixel(x, y, graybuf->bitpattern[MULU16(brightness, - graybuf->depth + 1) >> 8]); -} - -/* Invert a pixel - * - * The bit pattern for that pixel in the buffer is inverted, so white becomes - * black, light gray becomes dark gray etc. - */ -void gray_invertpixel(int x, int y) -{ - if (graybuf == NULL - || (unsigned) x >= (unsigned) graybuf->width - || (unsigned) y >= (unsigned) graybuf->height) - return; - - grayinvertmasked(x, (y >> 3), 1 << (y & 7)); -} - -/* Draw a line from (x1, y1) to (x2, y2) with a specific gray value - * - * brightness is 0..255 (black to white) regardless of real bit depth - */ -void gray_drawline(int x1, int y1, int x2, int y2, int brightness) -{ - int numpixels; - int i; - int deltax, deltay; - int d, dinc1, dinc2; - int x, xinc1, xinc2; - int y, yinc1, yinc2; - unsigned long pattern; - - if (graybuf == NULL - || (unsigned) x1 >= (unsigned) graybuf->width - || (unsigned) y1 >= (unsigned) graybuf->height - || (unsigned) x2 >= (unsigned) graybuf->width - || (unsigned) y2 >= (unsigned) graybuf->height - || (unsigned) brightness > 255) - return; - - pattern = graybuf->bitpattern[MULU16(brightness, graybuf->depth + 1) >> 8]; - - deltax = abs(x2 - x1); - deltay = abs(y2 - y1); - xinc2 = 1; - yinc2 = 1; - - if (deltax >= deltay) - { - numpixels = deltax; - d = 2 * deltay - deltax; - dinc1 = deltay * 2; - dinc2 = (deltay - deltax) * 2; - xinc1 = 1; - yinc1 = 0; - } - else - { - numpixels = deltay; - d = 2 * deltax - deltay; - dinc1 = deltax * 2; - dinc2 = (deltax - deltay) * 2; - xinc1 = 0; - yinc1 = 1; - } - numpixels++; /* include endpoints */ - - if (x1 > x2) - { - xinc1 = -xinc1; - xinc2 = -xinc2; - } - - if (y1 > y2) - { - yinc1 = -yinc1; - yinc2 = -yinc2; - } - - x = x1; - y = y1; - - for (i=0; i= (unsigned) graybuf->width - || (unsigned) y1 >= (unsigned) graybuf->height - || (unsigned) x2 >= (unsigned) graybuf->width - || (unsigned) y2 >= (unsigned) graybuf->height) - return; - - deltax = abs(x2 - x1); - deltay = abs(y2 - y1); - xinc2 = 1; - yinc2 = 1; - - if (deltax >= deltay) - { - numpixels = deltax; - d = 2 * deltay - deltax; - dinc1 = deltay * 2; - dinc2 = (deltay - deltax) * 2; - xinc1 = 1; - yinc1 = 0; - } - else - { - numpixels = deltay; - d = 2 * deltax - deltay; - dinc1 = deltax * 2; - dinc2 = (deltax - deltay) * 2; - xinc1 = 0; - yinc1 = 1; - } - numpixels++; /* include endpoints */ - - if (x1 > x2) - { - xinc1 = -xinc1; - xinc2 = -xinc2; - } - - if (y1 > y2) - { - yinc1 = -yinc1; - yinc2 = -yinc2; - } - - x = x1; - y = y1; - - for (i=0; i> 3), 1 << (y & 7)); - - if (d < 0) - { - d += dinc1; - x += xinc1; - y += yinc1; - } - else - { - d += dinc2; - x += xinc2; - y += yinc2; - } - } -} - -/* Draw a (hollow) rectangle with a specific gray value, - * corners are (x1, y1) and (x2, y2) - * - * brightness is 0..255 (black to white) regardless of real bit depth - */ -void gray_drawrect(int x1, int y1, int x2, int y2, int brightness) -{ - int x, y; - unsigned long pattern; - unsigned char srcpixel; - - if (graybuf == NULL - || (unsigned) x1 >= (unsigned) graybuf->width - || (unsigned) y1 >= (unsigned) graybuf->height - || (unsigned) x2 >= (unsigned) graybuf->width - || (unsigned) y2 >= (unsigned) graybuf->height - || (unsigned) brightness > 255) - return; - - if (y1 > y2) - { - y = y1; - y1 = y2; - y2 = y; - } - if (x1 > x2) - { - x = x1; - x1 = x2; - x2 = x; - } - - pattern = graybuf->bitpattern[MULU16(brightness, graybuf->depth + 1) >> 8]; - srcpixel = brightness; - - for (x = x1 + 1; x < x2; x++) - { - graypixel(x, y1, pattern); - graypixel(x, y2, pattern); - } - for (y = y1; y <= y2; ) - { - if (!(y & 7) && (y2 - y >= 7)) - /* current row byte aligned in fb & at least 8 rows left */ - { - /* shortcut: draw all 8 rows at once: 2..3 times faster */ - grayblock(x1, y >> 3, &srcpixel, 0); - grayblock(x2, y >> 3, &srcpixel, 0); - y += 8; - } - else - { - graypixel(x1, y, pattern); - graypixel(x2, y, pattern); - y++; - } - } -} - -/* Fill a rectangle with a specific gray value - * corners are (x1, y1) and (x2, y2) - * - * brightness is 0..255 (black to white) regardless of real bit depth - */ -void gray_fillrect(int x1, int y1, int x2, int y2, int brightness) -{ - int x, y; - unsigned long pattern; - unsigned char srcpixel; - - if (graybuf == NULL - || (unsigned) x1 >= (unsigned) graybuf->width - || (unsigned) y1 >= (unsigned) graybuf->height - || (unsigned) x2 >= (unsigned) graybuf->width - || (unsigned) y2 >= (unsigned) graybuf->height - || (unsigned) brightness > 255) - return; - - if (y1 > y2) - { - y = y1; - y1 = y2; - y2 = y; - } - if (x1 > x2) - { - x = x1; - x1 = x2; - x2 = x; - } - - pattern = graybuf->bitpattern[MULU16(brightness, graybuf->depth + 1) >> 8]; - srcpixel = brightness; - - for (y = y1; y <= y2; ) - { - if (!(y & 7) && (y2 - y >= 7)) - /* current row byte aligned in fb & at least 8 rows left */ - { - for (x = x1; x <= x2; x++) - { - /* shortcut: draw all 8 rows at once: 2..3 times faster */ - grayblock(x, y >> 3, &srcpixel, 0); - } - y += 8; - } - else - { - for (x = x1; x <= x2; x++) - { - graypixel(x, y, pattern); - } - y++; - } - } -} - -/* Invert a (solid) rectangle, corners are (x1, y1) and (x2, y2) - * - * The bit patterns for all pixels of the rectangle are inverted, so white - * becomes black, light gray becomes dark gray etc. This is the fastest of - * all gray_xxxrect() functions! Perfectly suited for cursors. - */ -void gray_invertrect(int x1, int y1, int x2, int y2) -{ - int x, yb, yb1, yb2; - unsigned char mask; - - if (graybuf == NULL - || (unsigned) x1 >= (unsigned) graybuf->width - || (unsigned) y1 >= (unsigned) graybuf->height - || (unsigned) x2 >= (unsigned) graybuf->width - || (unsigned) y2 >= (unsigned) graybuf->height) - return; - - if (y1 > y2) - { - yb = y1; - y1 = y2; - y2 = yb; - } - if (x1 > x2) - { - x = x1; - x1 = x2; - x2 = x; - } - - yb1 = y1 >> 3; - yb2 = y2 >> 3; - - if (yb1 == yb2) - { - mask = 0xFF << (y1 & 7); - mask &= 0xFF >> (7 - (y2 & 7)); - - for (x = x1; x <= x2; x++) - grayinvertmasked(x, yb1, mask); - } - else - { - mask = 0xFF << (y1 & 7); - - for (x = x1; x <= x2; x++) - grayinvertmasked(x, yb1, mask); - - for (yb = yb1 + 1; yb < yb2; yb++) - { - for (x = x1; x <= x2; x++) - grayinvertmasked(x, yb, 0xFF); - } - - mask = 0xFF >> (7 - (y2 & 7)); - - for (x = x1; x <= x2; x++) - grayinvertmasked(x, yb2, mask); - } -} - -/* Copy a grayscale bitmap into the display - * - * A grayscale bitmap contains one byte for every pixel that defines the - * brightness of the pixel (0..255). Bytes are read in row-major order. - * The parameter is useful if you want to show only a part of a - * bitmap. It should always be set to the "row length" of the bitmap, so - * for displaying the whole bitmap, nx == stride. - */ -void gray_drawgraymap(unsigned char *src, int x, int y, int nx, int ny, - int stride) -{ - int xi, yi; - unsigned char *row; - - if (graybuf == NULL - || (unsigned) x >= (unsigned) graybuf->width - || (unsigned) y >= (unsigned) graybuf->height) - return; - - if ((y + ny) >= graybuf->height) /* clip bottom */ - ny = graybuf->height - y; - - if ((x + nx) >= graybuf->width) /* clip right */ - nx = graybuf->width - x; - - for (yi = y; yi < y + ny; ) - { - row = src; - - if (!(yi & 7) && (y + ny - yi > 7)) - /* current row byte aligned in fb & at least 8 rows left */ - { - for (xi = x; xi < x + nx; xi++) - { - /* shortcut: draw all 8 rows at once: 2..3 times faster */ - grayblock(xi, yi >> 3, row++, stride); - } - yi += 8; - src += stride << 3; - } - else - { - for (xi = x; xi < x + nx; xi++) - { - graypixel(xi, yi, graybuf->bitpattern[MULU16(*row++, - graybuf->depth + 1) >> 8]); - } - yi++; - src += stride; - } - } -} - -/* Display a bitmap with specific foreground and background gray values - * - * This (now) uses the same bitmap format as the core b&w graphics routines, - * so you can use bmp2rb to generate bitmaps for use with this function as - * well. - * - * A bitmap contains one bit for every pixel that defines if that pixel is - * foreground (1) or background (0). Bits within a byte are arranged - * vertically, LSB at top. - * The bytes are stored in row-major order, with byte 0 being top left, - * byte 1 2nd from left etc. The first row of bytes defines pixel rows - * 0..7, the second row defines pixel row 8..15 etc. - * - * The parameter is useful if you want to show only a part of a - * bitmap. It should always be set to the "row length" of the bitmap. - * - * If draw_bg is false, only foreground pixels are drawn, so the background - * is transparent. In this case bg_brightness is ignored. - */ -void gray_drawbitmap(unsigned char *src, int x, int y, int nx, int ny, - int stride, bool draw_bg, int fg_brightness, - int bg_brightness) -{ - int xi, dy; - int bits = 0; /* Have to initialize to prevent warning */ - unsigned long fg_pattern, bg_pattern; - unsigned char *col; - - if (graybuf == NULL - || (unsigned) x >= (unsigned) graybuf->width - || (unsigned) y >= (unsigned) graybuf->height - || (unsigned) fg_brightness > 255 - || (unsigned) bg_brightness > 255) - return; - - if ((y + ny) >= graybuf->height) /* clip bottom */ - ny = graybuf->height - y; - - if ((x + nx) >= graybuf->width) /* clip right */ - nx = graybuf->width - x; - - fg_pattern = graybuf->bitpattern[MULU16(fg_brightness, - graybuf->depth + 1) >> 8]; - - bg_pattern = graybuf->bitpattern[MULU16(bg_brightness, - graybuf->depth + 1) >> 8]; - - for (xi = x; xi < x + nx; xi++) - { - col = src++; - for (dy = 0; dy < ny; dy++) - { - if (!(dy & 7)) /* get next 8 bits */ - { - bits = (int)(*col); - col += stride; - } - - if (bits & 0x01) - graypixel(xi, y + dy, fg_pattern); - else - if (draw_bg) - graypixel(xi, y + dy, bg_pattern); - - bits >>= 1; - } - } -} - -/*********************** end grayscale framework ***************************/ - -#ifdef GRAYSCALE_PLUGIN -static char pbuf[32]; /* global printf buffer */ -static unsigned char *gbuf; -static unsigned int gbuf_size = 0; - -/**************************** main function ********************************/ - -/* this is only a demo of what the framework can do */ -int main(void) -{ - int shades, time; - int x, y, i; - int button, scroll_amount; - bool black_border; - - static unsigned char rockbox[] = { - /* ........................................... - * .####...###...###..#...#.####...###..#...#. - * .#...#.#...#.#...#.#..#..#...#.#...#..#.#.. - * .####..#...#.#.....###...####..#...#...#... - * .#..#..#...#.#...#.#..#..#...#.#...#..#.#.. - * .#...#..###...###..#...#.####...###..#...#. - * ........................................... - * 43 x 7 pixel, 1 bpp - */ - 0x00, 0x3E, 0x0A, 0x0A, 0x1A, 0x24, 0x00, 0x1C, 0x22, 0x22, - 0x22, 0x1C, 0x00, 0x1C, 0x22, 0x22, 0x22, 0x14, 0x00, 0x3E, - 0x08, 0x08, 0x14, 0x22, 0x00, 0x3E, 0x2A, 0x2A, 0x2A, 0x14, - 0x00, 0x1C, 0x22, 0x22, 0x22, 0x1C, 0x00, 0x22, 0x14, 0x08, - 0x14, 0x22, 0x00 - }; - - static unsigned char showing[] = { - /* ....................................... - * ..####.#...#..###..#...#.#.#...#..####. - * .#.....#...#.#...#.#...#.#.##..#.#..... - * ..###..#####.#...#.#.#.#.#.#.#.#.#..##. - * .....#.#...#.#...#.#.#.#.#.#..##.#...#. - * .####..#...#..###...#.#..#.#...#..####. - * ....................................... - * 39 x 7 pixel, 1 bpp - */ - 0x00, 0x24, 0x2A, 0x2A, 0x2A, 0x12, 0x00, 0x3E, 0x08, 0x08, - 0x08, 0x3E, 0x00, 0x1C, 0x22, 0x22, 0x22, 0x1C, 0x00, 0x1E, - 0x20, 0x18, 0x20, 0x1E, 0x00, 0x3E, 0x00, 0x3E, 0x04, 0x08, - 0x10, 0x3E, 0x00, 0x1C, 0x22, 0x22, 0x2A, 0x3A, 0x00 - }; - - static unsigned char grayscale_gray[] = { - /* ....................................................... - * ..####.####...###..#...#..####..###...###..#.....#####. - * .#.....#...#.#...#.#...#.#.....#...#.#...#.#.....#..... - * .#..##.####..#####..#.#...###..#.....#####.#.....####.. - * .#...#.#..#..#...#...#.......#.#...#.#...#.#.....#..... - * ..####.#...#.#...#...#...####...###..#...#.#####.#####. - * ....................................................... - * 55 x 7 pixel, 8 bpp - */ - 110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110, - 110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110, - 110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110, - 110,110,110,110,110,110,110, - 120,120, 20, 20, 20, 20,120,222,222,222,222,120,120,120, 24, 24, - 24,120,120,226,120,120,120,226,120,120, 28, 28, 28, 28,120,120, - 230,230,230,120,120,120, 32, 32, 32,120,120,234,120,120,120,120, - 120, 36, 36, 36, 36, 36,120, - 130, 20,130,130,130,130,130,222,130,130,130,222,130, 24,130,130, - 130, 24,130,226,130,130,130,226,130, 28,130,130,130,130,130,230, - 130,130,130,230,130, 32,130,130,130, 32,130,234,130,130,130,130, - 130, 36,130,130,130,130,130, - 140, 20,140,140, 20, 20,140,222,222,222,222,140,140, 24, 24, 24, - 24, 24,140,140,226,140,226,140,140,140, 28, 28, 28,140,140,230, - 140,140,140,140,140, 32, 32, 32, 32, 32,140,234,140,140,140,140, - 140, 36, 36, 36, 36,140,140, - 130, 20,130,130,130, 20,130,222,130,130,222,130,130, 24,130,130, - 130, 24,130,130,130,226,130,130,130,130,130,130,130, 28,130,230, - 130,130,130,230,130, 32,130,130,130, 32,130,234,130,130,130,130, - 130, 36,130,130,130,130,130, - 120,120, 20, 20, 20, 20,120,222,120,120,120,222,120, 24,120,120, - 120, 24,120,120,120,226,120,120,120, 28, 28, 28, 28,120,120,120, - 230,230,230,120,120, 32,120,120,120, 32,120,234,234,234,234,234, - 120, 36, 36, 36, 36, 36,120, - 110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110, - 110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110, - 110,110,110,110,110,110,110,110,110,110,110,110,110,110,110,110, - 110,110,110,110,110,110,110 - }; - - if (rb->global_settings->backlight_timeout > 0) - rb->backlight_set_timeout(1); /* keep the light on */ - - rb->lcd_setfont(FONT_SYSFIXED); /* select default font */ - - /* get the remainder of the plugin buffer */ - gbuf = (unsigned char *) rb->plugin_get_buffer(&gbuf_size); - - /* initialize the grayscale buffer: - * 112 pixels wide, 7 rows (56 pixels) high, (try to) reserve - * 32 bitplanes for 33 shades of gray. (uses 25268 bytes)*/ - shades = gray_init_buffer(gbuf, gbuf_size, 112, 7, 32) + 1; - - /* place grayscale overlay 1 row down */ - gray_position_display(0, 1); - - rb->snprintf(pbuf, sizeof(pbuf), "Shades: %d", shades); - rb->lcd_puts(0, 0, pbuf); - rb->lcd_update(); - - gray_show_display(true); /* switch on grayscale overlay */ - - time = *rb->current_tick; /* start time measurement */ - - gray_fillrect(0, 0, 111, 55, 150); /* fill everything with gray 150 */ - - /* draw a dark gray line star background */ - for (y = 0; y < 56; y += 8) /* horizontal part */ - { - gray_drawline(0, y, 111, 55 - y, 80); /* gray lines */ - } - for (x = 10; x < 112; x += 10) /* vertical part */ - { - gray_drawline(x, 0, 111 - x, 55, 80); /* gray lines */ - } - - gray_drawrect(0, 0, 111, 55, 0); /* black border */ - - /* draw gray tones */ - for (i = 0; i < 86; i++) - { - x = 13 + i; - gray_fillrect(x, 6, x, 49, 3 * i); /* gray rectangles */ - } - - gray_invertrect(13, 29, 98, 49); /* invert rectangle (lower half) */ - gray_invertline(13, 27, 98, 27); /* invert a line */ - - /* show bitmaps (1 bit and 8 bit) */ - gray_drawbitmap(rockbox, 14, 13, 43, 7, 43, true, 255, 100); /* opaque */ - gray_drawbitmap(showing, 58, 13, 39, 7, 39, false, 0, 0); /* transparent */ - gray_drawgraymap(grayscale_gray, 28, 35, 55, 7, 55); - - time = *rb->current_tick - time; /* end time measurement */ - - rb->snprintf(pbuf, sizeof(pbuf), "Shades: %d, %d.%02ds", shades, - time / 100, time % 100); - rb->lcd_puts(0, 0, pbuf); - gray_deferred_update(); /* schedule an lcd_update() */ - - /* drawing is now finished, play around with scrolling - * until you press OFF or connect USB - */ - while (true) - { - scroll_amount = 1; - black_border = false; - - button = rb->button_get(true); - - if (button == SYS_USB_CONNECTED) - { - gray_release_buffer(); /* switch off overlay and deinitialize */ - /* restore normal backlight setting */ - rb->backlight_set_timeout(rb->global_settings->backlight_timeout); - return PLUGIN_USB_CONNECTED; - } - - if (button & BUTTON_ON) - black_border = true; - - if (button & BUTTON_REPEAT) - scroll_amount = 4; - - switch(button & ~(BUTTON_ON | BUTTON_REPEAT)) - { - case BUTTON_LEFT: - - gray_scroll_left(scroll_amount, black_border); /* scroll left */ - break; - - case BUTTON_RIGHT: - - gray_scroll_right(scroll_amount, black_border); /* scroll right */ - break; - - case BUTTON_UP: - - gray_scroll_up(scroll_amount, black_border); /* scroll up */ - break; - - case BUTTON_DOWN: - - gray_scroll_down(scroll_amount, black_border); /* scroll down */ - break; - - case BUTTON_OFF: - - gray_release_buffer(); /* switch off overlay and deinitialize */ - /* restore normal backlight setting */ - rb->backlight_set_timeout(rb->global_settings->backlight_timeout); - return PLUGIN_OK; - } - } -} - -/*************************** Plugin entry point ****************************/ -enum plugin_status plugin_start(struct plugin_api* api, void* parameter) -{ - int ret; - /* this macro should be called as the first thing you do in the plugin. - it test that the api version and model the plugin was compiled for - matches the machine it is running on */ - TEST_PLUGIN_API(api); - - rb = api; // copy to global api pointer - (void)parameter; - - ret = main(); - - if (ret == PLUGIN_USB_CONNECTED) - rb->usb_screen(); - return ret; -} -#endif /* GRAYSCALE_PLUGIN */ - -#endif // #ifdef HAVE_LCD_BITMAP -#endif // #ifndef SIMULATOR - -- cgit v1.2.3