forked from len0rd/rockbox
Now uses grayscalescvs diff -u apps/plugins/mandelbrot.c! Plus some internal changes, like removing TAB chars, and preventing unnecessary redraws etc.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@4535 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Linus Nielsen Feltzing
parent
1de3dd570d
commit
75b575a750
1 changed files with 699 additions and 90 deletions
|
|
@ -9,8 +9,6 @@
|
||||||
*
|
*
|
||||||
* Copyright (C) 2004 Matthias Wientapper
|
* Copyright (C) 2004 Matthias Wientapper
|
||||||
*
|
*
|
||||||
* Thanks to Jens Arnold and Joerg Hohensohn for the speed tips.
|
|
||||||
* Boy, that was a hell of a code review ;-)
|
|
||||||
*
|
*
|
||||||
* All files in this archive are subject to the GNU General Public License.
|
* 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.
|
* See the file COPYING in the source tree root for full license agreement.
|
||||||
|
|
@ -18,11 +16,8 @@
|
||||||
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
||||||
* KIND, either express or implied.
|
* KIND, either express or implied.
|
||||||
*
|
*
|
||||||
*
|
|
||||||
* further optimization ideas:
|
|
||||||
* - incremental recalculation when moving
|
|
||||||
*
|
|
||||||
****************************************************************************/
|
****************************************************************************/
|
||||||
|
#ifndef SIMULATOR
|
||||||
#include "plugin.h"
|
#include "plugin.h"
|
||||||
|
|
||||||
#ifdef HAVE_LCD_BITMAP // this is not fun on the player
|
#ifdef HAVE_LCD_BITMAP // this is not fun on the player
|
||||||
|
|
@ -36,9 +31,603 @@ static int y_min;
|
||||||
static int y_max;
|
static int y_max;
|
||||||
static int delta;
|
static int delta;
|
||||||
static int max_iter;
|
static int max_iter;
|
||||||
|
static unsigned char *gbuf;
|
||||||
|
static unsigned int gbuf_size = 0;
|
||||||
|
|
||||||
|
/**************** 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
|
||||||
|
* timer 4 so you cannot use timer 4 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.
|
||||||
|
*/
|
||||||
|
|
||||||
|
/**** internal core functions and definitions ****/
|
||||||
|
|
||||||
|
/* You do not want to touch these if you don't know exactly what
|
||||||
|
* you're doing.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#define IMIA4 (*((volatile unsigned long*)0x09000180)) /* timer 4 */
|
||||||
|
|
||||||
|
#define GRAY_RUNNING 0x0001 /* grayscale overlay is running */
|
||||||
|
#define GRAY_DEFERRED_UPDATE 0x0002 /* lcd_update() requested */
|
||||||
|
|
||||||
|
typedef struct
|
||||||
|
{
|
||||||
|
int x;
|
||||||
|
int by; /* 8-pixel units */
|
||||||
|
int width;
|
||||||
|
int height;
|
||||||
|
int bheight; /* 8-pixel units */
|
||||||
|
int plane_size;
|
||||||
|
int depth; /* number_of_bitplanes = (number_of_grayscales - 1) */
|
||||||
|
int cur_plane; /* for the timer isr */
|
||||||
|
unsigned long randmask; /* mask for random value in graypixel() */
|
||||||
|
unsigned long flags; /* various flags, see #defines */
|
||||||
|
unsigned char *data; /* pointer to start of bitplane data */
|
||||||
|
unsigned long *bitpattern; /* pointer to start of pattern table */
|
||||||
|
} tGraybuf;
|
||||||
|
|
||||||
|
static tGraybuf *graybuf = NULL;
|
||||||
|
|
||||||
|
/** prototypes **/
|
||||||
|
|
||||||
|
void timer_set(unsigned period);
|
||||||
|
void timer4_isr(void) __attribute__((interrupt_handler));
|
||||||
|
void graypixel(int x, int y, unsigned long pattern);
|
||||||
|
void grayinvertmasked(int x, int yb, unsigned char mask);
|
||||||
|
|
||||||
|
/** implementation **/
|
||||||
|
|
||||||
|
/* setup ISR and timer registers */
|
||||||
|
void timer_set(unsigned period)
|
||||||
|
{
|
||||||
|
if (period)
|
||||||
|
{
|
||||||
|
and_b(~0x10, &TSTR); /* Stop the timer 4 */
|
||||||
|
and_b(~0x10, &TSNC); /* No synchronization */
|
||||||
|
and_b(~0x10, &TMDR); /* Operate normally */
|
||||||
|
|
||||||
|
IMIA4 = (unsigned long) timer4_isr; /* install ISR */
|
||||||
|
|
||||||
|
and_b(~0x01, &TSR4);
|
||||||
|
TIER4 = 0xF9; /* Enable GRA match interrupt */
|
||||||
|
|
||||||
|
GRA4 = (unsigned short)(period/4 - 1);
|
||||||
|
TCR4 = 0x22; /* clear at GRA match, sysclock/4 */
|
||||||
|
IPRD = (IPRD & 0xFF0F) | 0x0010; /* interrupt priority 1 (lowest) */
|
||||||
|
or_b(0x10, &TSTR); /* start timer 4 */
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
and_b(~0x10, &TSTR); /* stop the timer 4 */
|
||||||
|
IPRD = (IPRD & 0xFF0F); /* disable interrupt */
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/* timer interrupt handler: display next bitplane */
|
||||||
|
void timer4_isr(void) /* IMIA4 */
|
||||||
|
{
|
||||||
|
and_b(~0x01, &TSR4); /* clear the interrupt */
|
||||||
|
|
||||||
|
rb->lcd_blit(graybuf->data + (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)
|
||||||
|
{
|
||||||
|
static short random_buffer;
|
||||||
|
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"(&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 <random>'th plane */
|
||||||
|
"add %2,%1 \n" /* end offset -> end address */
|
||||||
|
"sts macl,%5 \n" /* result of mulu */
|
||||||
|
"add %2,%5 \n" /* address of <random>'th plane */
|
||||||
|
"bra .p_start1 \n"
|
||||||
|
"mov %5,r2 \n" /* copy address */
|
||||||
|
|
||||||
|
/* first loop: set bits from <random>'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 <random-1>'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 < <random>'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"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Invert the bits for 1-8 pixels within the buffer */
|
||||||
|
void grayinvertmasked(int x, int yb, 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"(yb)
|
||||||
|
: /* clobbers */
|
||||||
|
"r1", "r2", "macl"
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*** public core functions ***/
|
||||||
|
|
||||||
|
/** prototypes **/
|
||||||
|
|
||||||
|
int gray_init_buffer(unsigned char *gbuf, int gbuf_size, int width,
|
||||||
|
int bheight, int depth);
|
||||||
|
void gray_release_buffer(void);
|
||||||
|
void gray_position_display(int x, int by);
|
||||||
|
void gray_show_display(bool enable);
|
||||||
|
|
||||||
|
/** 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 grayscales - 1 (1..32)
|
||||||
|
*
|
||||||
|
* result:
|
||||||
|
* = depth if there was enough memory
|
||||||
|
* < depth if there wasn't enough memory. The number of displayable
|
||||||
|
* grayscales 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
|
||||||
|
*/
|
||||||
|
int gray_init_buffer(unsigned char *gbuf, int gbuf_size, int width,
|
||||||
|
int bheight, int depth)
|
||||||
|
{
|
||||||
|
int plane_size;
|
||||||
|
int possible_depth;
|
||||||
|
int i, j;
|
||||||
|
|
||||||
|
if (width > LCD_WIDTH || bheight > (LCD_HEIGHT >> 3) || depth < 1)
|
||||||
|
return 0;
|
||||||
|
|
||||||
|
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 <depth> 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;
|
||||||
|
timer_set(FREQ / 67);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
timer_set(0);
|
||||||
|
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 **/
|
||||||
|
|
||||||
|
/* functions affecting the whole display */
|
||||||
|
void gray_clear_display(void);
|
||||||
|
//void gray_black_display(void);
|
||||||
|
//void gray_deferred_update(void);
|
||||||
|
|
||||||
|
/* scrolling functions */
|
||||||
|
//void gray_scroll_left(int count, bool black_border);
|
||||||
|
//void gray_scroll_right(int count, bool black_border);
|
||||||
|
//void gray_scroll_up8(bool black_border);
|
||||||
|
//void gray_scroll_down8(bool black_border);
|
||||||
|
//void gray_scroll_up1(bool black_border);
|
||||||
|
//void gray_scroll_down1(bool black_border);
|
||||||
|
//
|
||||||
|
/* pixel functions */
|
||||||
|
void gray_drawpixel(int x, int y, int brightness);
|
||||||
|
//void gray_invertpixel(int x, int y);
|
||||||
|
|
||||||
|
/* line functions */
|
||||||
|
//void gray_drawline(int x1, int y1, int x2, int y2, int brightness);
|
||||||
|
//void gray_invertline(int x1, int y1, int x2, int y2);
|
||||||
|
|
||||||
|
/* rectangle functions */
|
||||||
|
//void gray_drawrect(int x1, int y1, int x2, int y2, int brightness);
|
||||||
|
//void gray_fillrect(int x1, int y1, int x2, int y2, int brightness);
|
||||||
|
//void gray_invertrect(int x1, int y1, int x2, int y2);
|
||||||
|
|
||||||
|
/* bitmap functions */
|
||||||
|
//void gray_drawgraymap(unsigned char *src, int x, int y, int nx, int ny);
|
||||||
|
//void gray_drawbitmap(unsigned char *src, int x, int y, int nx, int ny,
|
||||||
|
// bool draw_bg, int fg_brightness, int bg_brightness);
|
||||||
|
|
||||||
|
/** implementation **/
|
||||||
|
|
||||||
|
/* Clear the grayscale display (sets all pixels to white)
|
||||||
|
*/
|
||||||
|
void gray_clear_display(void)
|
||||||
|
{
|
||||||
|
if (graybuf == NULL)
|
||||||
|
return;
|
||||||
|
|
||||||
|
rb->memset(graybuf->data, 0, 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, graybuf->depth * graybuf->plane_size);
|
||||||
|
}
|
||||||
|
|
||||||
|
/* Do a 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();
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
/* 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 || x >= graybuf->width || y >= graybuf->height
|
||||||
|
|| brightness > 255)
|
||||||
|
return;
|
||||||
|
|
||||||
|
graypixel(x, y, graybuf->bitpattern[(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 || x >= graybuf->width || y >= graybuf->height)
|
||||||
|
return;
|
||||||
|
|
||||||
|
grayinvertmasked(x, (y >> 3), 1 << (y & 7));
|
||||||
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
/**************** end grayscale framework ********************/
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
void init_mandelbrot_set(void){
|
void init_mandelbrot_set(void){
|
||||||
x_min = -5<<25; // -2.5<<26
|
x_min = -5<<25; // -2.0<<26
|
||||||
x_max = 1<<26; // 1.0<<26
|
x_max = 1<<26; // 1.0<<26
|
||||||
y_min = -1<<26; // -1.0<<26
|
y_min = -1<<26; // -1.0<<26
|
||||||
y_max = 1<<26; // 1.0<<26
|
y_max = 1<<26; // 1.0<<26
|
||||||
|
|
@ -53,11 +642,14 @@ void calc_mandelbrot_set(void){
|
||||||
int x_pixel, y_pixel;
|
int x_pixel, y_pixel;
|
||||||
int x, x2, y, y2, a, b;
|
int x, x2, y, y2, a, b;
|
||||||
int x_fact, y_fact;
|
int x_fact, y_fact;
|
||||||
|
int brightness;
|
||||||
|
|
||||||
start_tick = *rb->current_tick;
|
start_tick = *rb->current_tick;
|
||||||
|
|
||||||
rb->lcd_clear_display();
|
// rb->lcd_clear_display();
|
||||||
rb->lcd_update();
|
// rb->lcd_update();
|
||||||
|
|
||||||
|
gray_clear_display();
|
||||||
|
|
||||||
x_fact = (x_max - x_min) / LCD_WIDTH;
|
x_fact = (x_max - x_min) / LCD_WIDTH;
|
||||||
y_fact = (y_max - y_min) / LCD_HEIGHT;
|
y_fact = (y_max - y_min) / LCD_HEIGHT;
|
||||||
|
|
@ -83,52 +675,58 @@ void calc_mandelbrot_set(void){
|
||||||
}
|
}
|
||||||
|
|
||||||
// "coloring"
|
// "coloring"
|
||||||
if ( (n_iter > max_iter) ||
|
brightness = 0;
|
||||||
(n_iter == (max_iter >> 1)) ||
|
if (n_iter > max_iter){
|
||||||
(n_iter == (max_iter >> 2)) ||
|
brightness = 0; // black
|
||||||
(n_iter == (max_iter >> 3))
|
} else {
|
||||||
){
|
brightness = 255 - (31 * (n_iter & 7));
|
||||||
rb->lcd_drawpixel(x_pixel,y_pixel);
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/* update block of 8 lines */
|
gray_drawpixel( x_pixel, y_pixel, brightness);
|
||||||
if ((y_pixel & 0x7) == 0)
|
}
|
||||||
rb->lcd_update_rect(0, y_pixel, LCD_WIDTH, 8);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
/* we want to know how long we had to wait */
|
|
||||||
rb->lcd_setfont(FONT_SYSFIXED);
|
|
||||||
rb->snprintf(buff, sizeof(buff), "%d", (*rb->current_tick - start_tick));
|
|
||||||
rb->lcd_puts(0,0,buff);
|
|
||||||
rb->snprintf(buff, sizeof(buff), "%d", max_iter);
|
|
||||||
rb->lcd_puts(0,1,buff);
|
|
||||||
rb->lcd_update_rect(0,0,24,16);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
|
enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
|
||||||
{
|
{
|
||||||
|
int grayscales;
|
||||||
|
bool redraw = true;
|
||||||
|
|
||||||
TEST_PLUGIN_API(api);
|
TEST_PLUGIN_API(api);
|
||||||
(void)parameter;
|
|
||||||
rb = api;
|
rb = api;
|
||||||
|
(void)parameter;
|
||||||
|
|
||||||
|
/* get the remainder of the plugin buffer */
|
||||||
|
gbuf = (unsigned char *) rb->plugin_get_buffer(&gbuf_size);
|
||||||
|
|
||||||
|
/* initialize the grayscale buffer:
|
||||||
|
* 112 pixels wide, 8 rows (64 pixels) high, (try to) reserve
|
||||||
|
* 16 bitplanes for 17 shades of gray.*/
|
||||||
|
grayscales = gray_init_buffer(gbuf, gbuf_size, 112, 8, 16) + 1;
|
||||||
|
if (grayscales != 17){
|
||||||
|
rb->snprintf(buff, sizeof(buff), "%d", grayscales);
|
||||||
|
rb->lcd_puts(0, 1, buff);
|
||||||
|
rb->lcd_update();
|
||||||
|
rb->sleep(HZ*2);
|
||||||
|
return(0);
|
||||||
|
}
|
||||||
|
|
||||||
|
gray_show_display(true); /* switch on grayscale overlay */
|
||||||
|
|
||||||
init_mandelbrot_set();
|
init_mandelbrot_set();
|
||||||
lcd_aspect_ratio = ((LCD_WIDTH<<13) / LCD_HEIGHT)<<13;
|
lcd_aspect_ratio = ((LCD_WIDTH<<13) / LCD_HEIGHT)<<13;
|
||||||
|
|
||||||
/* main loop */
|
/* main loop */
|
||||||
while (true){
|
while (true){
|
||||||
|
if(redraw)
|
||||||
calc_mandelbrot_set();
|
calc_mandelbrot_set();
|
||||||
|
|
||||||
/* FIXME: is this the right way to empty the key-queue?
|
redraw = false;
|
||||||
(Otherwise we have to process things twice :-/ ?! */
|
|
||||||
|
|
||||||
rb->button_get(true);
|
|
||||||
|
|
||||||
|
|
||||||
switch (rb->button_get(true)) {
|
switch (rb->button_get(true)) {
|
||||||
case BUTTON_OFF:
|
case BUTTON_OFF:
|
||||||
|
gray_release_buffer();
|
||||||
return PLUGIN_OK;
|
return PLUGIN_OK;
|
||||||
|
|
||||||
case BUTTON_ON:
|
case BUTTON_ON:
|
||||||
|
|
@ -137,6 +735,7 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
|
||||||
y_min -= delta;
|
y_min -= delta;
|
||||||
y_max += delta;
|
y_max += delta;
|
||||||
delta = (x_max - x_min) >> 3;
|
delta = (x_max - x_min) >> 3;
|
||||||
|
redraw = true;
|
||||||
break;
|
break;
|
||||||
|
|
||||||
|
|
||||||
|
|
@ -146,50 +745,60 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter)
|
||||||
y_min += delta;
|
y_min += delta;
|
||||||
y_max -= delta;
|
y_max -= delta;
|
||||||
delta = (x_max - x_min) >> 3;
|
delta = (x_max - x_min) >> 3;
|
||||||
|
redraw = true;
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case BUTTON_UP:
|
case BUTTON_UP:
|
||||||
y_min -= delta;
|
y_min -= delta;
|
||||||
y_max -= delta;
|
y_max -= delta;
|
||||||
|
redraw = true;
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case BUTTON_DOWN:
|
case BUTTON_DOWN:
|
||||||
y_min += delta;
|
y_min += delta;
|
||||||
y_max += delta;
|
y_max += delta;
|
||||||
|
redraw = true;
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case BUTTON_LEFT:
|
case BUTTON_LEFT:
|
||||||
x_min -= delta;
|
x_min -= delta;
|
||||||
x_max -= delta;
|
x_max -= delta;
|
||||||
|
redraw = true;
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case BUTTON_RIGHT:
|
case BUTTON_RIGHT:
|
||||||
x_min += delta;
|
x_min += delta;
|
||||||
x_max += delta;
|
x_max += delta;
|
||||||
|
redraw = true;
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case BUTTON_F1:
|
case BUTTON_F1:
|
||||||
if (max_iter>5){
|
if (max_iter>5){
|
||||||
max_iter -= 5;
|
max_iter -= 5;
|
||||||
|
redraw = true;
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case BUTTON_F2:
|
case BUTTON_F2:
|
||||||
if (max_iter < 195){
|
if (max_iter < 195){
|
||||||
max_iter += 5;
|
max_iter += 5;
|
||||||
|
redraw = true;
|
||||||
}
|
}
|
||||||
break;
|
break;
|
||||||
|
|
||||||
case BUTTON_F3:
|
case BUTTON_F3:
|
||||||
init_mandelbrot_set();
|
init_mandelbrot_set();
|
||||||
|
redraw = true;
|
||||||
break;
|
break;
|
||||||
|
|
||||||
|
|
||||||
case SYS_USB_CONNECTED:
|
case SYS_USB_CONNECTED:
|
||||||
|
gray_release_buffer();
|
||||||
rb->usb_screen();
|
rb->usb_screen();
|
||||||
return PLUGIN_USB_CONNECTED;
|
return PLUGIN_USB_CONNECTED;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
gray_release_buffer();
|
||||||
return false;
|
return false;
|
||||||
}
|
}
|
||||||
#endif
|
#endif
|
||||||
|
#endif
|
||||||
|
|
|
||||||
Loading…
Add table
Add a link
Reference in a new issue