From 6920aed85872fa878670a89fe7ace1ef1ecbf49a Mon Sep 17 00:00:00 2001 From: Jens Arnold Date: Wed, 19 May 2004 17:19:11 +0000 Subject: Removed the grayscale framework, gets linked in from the plugin lib instead git-svn-id: svn://svn.rockbox.org/rockbox/trunk@4652 a1c6a512-1295-4272-9138-f99709370657 --- apps/plugins/mandelbrot.c | 559 ++-------------------------------------------- 1 file changed, 21 insertions(+), 538 deletions(-) (limited to 'apps') diff --git a/apps/plugins/mandelbrot.c b/apps/plugins/mandelbrot.c index 3d6774a882..106d4b69f7 100644 --- a/apps/plugins/mandelbrot.c +++ b/apps/plugins/mandelbrot.c @@ -21,6 +21,7 @@ #include "plugin.h" #ifdef HAVE_LCD_BITMAP // this is not fun on the player +# include "gray.h" static struct plugin_api* rb; static char buff[32]; @@ -34,527 +35,6 @@ 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 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. - */ - -/**** internal core functions and definitions ****/ - -/* You do not want to touch these if you don't know exactly what you're - * doing. */ - -#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_isr(void); -void graypixel(int x, int y, unsigned long pattern); -void grayinvertmasked(int x, int yb, unsigned char mask); - -/** implementation **/ - -/* timer interrupt handler: display next bitplane */ -void timer_isr(void) -{ - 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 '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" - ); -} - -/* 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" - ); -} - -/*** 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 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 (width > LCD_WIDTH || 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, 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 **/ - -/* 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, -// int stride); -//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); - -/** 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 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]); -} - - -/*********************** end grayscale framework ***************************/ - - void init_mandelbrot_set(void){ x_min = -5<<25; // -2.0<<26 @@ -603,17 +83,17 @@ void calc_mandelbrot_set(void){ y = 2 * x * y + b; x = x2 - y2 + a; } - + // "coloring" - brightness = 0; + brightness = 0; if (n_iter > max_iter){ - brightness = 0; // black - } else { - brightness = 255 - (31 * (n_iter & 7)); - } - - gray_drawpixel( x_pixel, y_pixel, brightness); - } + brightness = 0; // black + } else { + brightness = 255 - (31 * (n_iter & 7)); + } + + gray_drawpixel( x_pixel, y_pixel, brightness); + } } } @@ -627,19 +107,22 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter) rb = api; (void)parameter; + /* This plugin uses the grayscale framework, so initialize */ + gray_init(api); + /* 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; + grayscales = gray_init_buffer(gbuf, gbuf_size, 112, 8, 16, NULL) + 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); + 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 */ @@ -667,7 +150,7 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter) delta = (x_max - x_min) >> 3; redraw = true; break; - + case BUTTON_PLAY: x_min += ((delta>>13)*(lcd_aspect_ratio>>13)); @@ -677,7 +160,7 @@ enum plugin_status plugin_start(struct plugin_api* api, void* parameter) delta = (x_max - x_min) >> 3; redraw = true; break; - + case BUTTON_UP: y_min -= delta; y_max -= delta; -- cgit v1.2.3