From 9ecfacc475041a640d02b5220043fbf3bf4d5bcb Mon Sep 17 00:00:00 2001 From: Jens Arnold Date: Mon, 10 May 2004 22:00:51 +0000 Subject: Updated with the latest grayscale framework git-svn-id: svn://svn.rockbox.org/rockbox/trunk@4604 a1c6a512-1295-4272-9138-f99709370657 --- apps/plugins/mandelbrot.c | 163 ++++++++++++++++++---------------------------- 1 file changed, 62 insertions(+), 101 deletions(-) diff --git a/apps/plugins/mandelbrot.c b/apps/plugins/mandelbrot.c index 2f5bc53ab0..3d6774a882 100644 --- a/apps/plugins/mandelbrot.c +++ b/apps/plugins/mandelbrot.c @@ -34,18 +34,17 @@ static int max_iter; static unsigned char *gbuf; static unsigned int gbuf_size = 0; -/**************** Begin grayscale framework ******************/ +/*********************** Begin grayscale framework *************************/ -/* This is a generic framework to use grayscale display within - * rockbox plugins. It obviously does not work for the player. +/* 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. + * 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 + * 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: @@ -54,17 +53,15 @@ static unsigned int gbuf_size = 0; * - 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. + * 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. - */ +/* 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 */ @@ -89,14 +86,14 @@ static tGraybuf *graybuf = NULL; /** prototypes **/ -void timer4_isr(void); +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 timer4_isr(void) /* IMIA4 */ +void timer_isr(void) { rb->lcd_blit(graybuf->data + (graybuf->plane_size * graybuf->cur_plane), graybuf->x, graybuf->by, graybuf->width, graybuf->bheight, @@ -107,24 +104,24 @@ void timer4_isr(void) /* IMIA4 */ 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); + 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 (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 (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 (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); + 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 */ + graybuf->flags &= ~GRAY_DEFERRED_UPDATE; /* clear request */ } } @@ -135,14 +132,11 @@ 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. - */ + /* 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( @@ -192,7 +186,7 @@ void graypixel(int x, int y, unsigned long pattern) ".pp_end: \n" : /* outputs */ - /* %0 */ "=&r"(address), + /* %0 */ "=&r"(address), /* %1 */ "=&r"(mask) : /* inputs */ /* %2 */ "r"(graybuf->width), @@ -268,7 +262,7 @@ void graypixel(int x, int y, unsigned long pattern) } /* Invert the bits for 1-8 pixels within the buffer */ -void grayinvertmasked(int x, int yb, unsigned char mask) +void grayinvertmasked(int x, int by, unsigned char mask) { asm( "mulu %4,%5 \n" /* width * by (offset of row) */ @@ -291,7 +285,7 @@ void grayinvertmasked(int x, int yb, unsigned char mask) /* %2 */ "r"(mask), /* %3 */ "r"(graybuf->plane_size), /* %4 */ "r"(graybuf->width), - /* %5 */ "r"(yb) + /* %5 */ "r"(by) : /* clobbers */ "r1", "r2", "macl" ); @@ -316,12 +310,12 @@ void gray_show_display(bool enable); * 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) + * 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 - * grayscales is smaller than desired, but it still works + * 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 @@ -335,17 +329,23 @@ void gray_show_display(bool enable); * 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 plane_size; - int possible_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)); @@ -375,8 +375,8 @@ int gray_init_buffer(unsigned char *gbuf, int gbuf_size, int width, j = 8; while (i != 0) { - i >>= 1; - j--; + i >>= 1; + j--; } graybuf->randmask = 0xFF >> j; @@ -386,11 +386,11 @@ int gray_init_buffer(unsigned char *gbuf, int gbuf_size, int width, /* Precalculate the bit patterns for all possible pixel values */ for (i = 0; i <= depth; i++) { - unsigned long pattern = 0; - int value = 0; + unsigned long pattern = 0; + int value = 0; - for (j = 0; j < depth; j++) - { + for (j = 0; j < depth; j++) + { pattern <<= 1; value += i; @@ -398,10 +398,10 @@ int gray_init_buffer(unsigned char *gbuf, int gbuf_size, int width, value -= depth; /* "white" bit */ else pattern |= 1; /* "black" bit */ - } + } /* now the lower bits contain the pattern */ - graybuf->bitpattern[i] = pattern; + graybuf->bitpattern[i] = pattern; } return depth; @@ -474,7 +474,7 @@ void gray_show_display(bool enable) if (enable) { graybuf->flags |= GRAY_RUNNING; - rb->plugin_register_timer(FREQ / 67, 1, timer4_isr); + rb->plugin_register_timer(FREQ / 67, 1, timer_isr); } else { @@ -504,7 +504,7 @@ void gray_clear_display(void); //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); @@ -519,9 +519,11 @@ void gray_drawpixel(int x, int y, 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_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, -// bool draw_bg, int fg_brightness, int bg_brightness); +// int stride, bool draw_bg, int fg_brightness, +// int bg_brightness); /** implementation **/ @@ -535,31 +537,6 @@ void gray_clear_display(void) 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 @@ -574,24 +551,8 @@ void gray_drawpixel(int x, int y, int 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 ********************/ +/*********************** end grayscale framework ***************************/ @@ -630,7 +591,7 @@ void calc_mandelbrot_set(void){ x = 0; y = 0; n_iter = 0; - + while (++n_iter<=max_iter) { x >>= 13; y >>= 13; -- cgit v1.2.3