diff options
Diffstat (limited to 'converter/other/fiasco/lib/dither.c')
| -rw-r--r-- | converter/other/fiasco/lib/dither.c | 2258 |
1 files changed, 1129 insertions, 1129 deletions
diff --git a/converter/other/fiasco/lib/dither.c b/converter/other/fiasco/lib/dither.c index 669bb16c..c394f5ec 100644 --- a/converter/other/fiasco/lib/dither.c +++ b/converter/other/fiasco/lib/dither.c @@ -1,8 +1,8 @@ /* - * dither.c: Various dithering routines + * dither.c: Various dithering routines + * + * Adapted by: Ullrich Hafner * - * Adapted by: Ullrich Hafner - * * This file is part of FIASCO (Fractal Image And Sequence COdec) * Copyright (C) 1994-2000 Ullrich Hafner */ @@ -10,17 +10,17 @@ /* * Copyright (c) 1995 Erik Corry * All rights reserved. - * + * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. - * + * * IN NO EVENT SHALL ERIK CORRY BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF * THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF ERIK CORRY HAS BEEN ADVISED * OF THE POSSIBILITY OF SUCH DAMAGE. - * + * * ERIK CORRY SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" @@ -52,25 +52,25 @@ /***************************************************************************** - prototypes - + prototypes + *****************************************************************************/ -static int +static int display_16_bit (const struct fiasco_renderer *this, unsigned char *ximage, - const fiasco_image_t *fiasco_image); + const fiasco_image_t *fiasco_image); -static int +static int display_24_bit_bgr (const struct fiasco_renderer *this, unsigned char *ximage, - const fiasco_image_t *fiasco_image); + const fiasco_image_t *fiasco_image); -static int +static int display_24_bit_rgb (const struct fiasco_renderer *this, unsigned char *ximage, - const fiasco_image_t *fiasco_image); + const fiasco_image_t *fiasco_image); -static int +static int display_32_bit (const struct fiasco_renderer *this, unsigned char *ximage, - const fiasco_image_t *fiasco_image); + const fiasco_image_t *fiasco_image); static int free_bits_at_bottom (unsigned long a); @@ -80,26 +80,26 @@ number_of_bits_set (unsigned long a); /***************************************************************************** - public code - + public code + *****************************************************************************/ fiasco_renderer_t * fiasco_renderer_new (unsigned long red_mask, unsigned long green_mask, - unsigned long blue_mask, unsigned bpp, - int double_resolution) + unsigned long blue_mask, unsigned bpp, + int double_resolution) /* * FIASCO renderer constructor. * Allocate memory for the FIASCO renderer structure and * initialize values. * `red_mask', `green_mask', and `blue_mask' are the corresponding masks - * of the X11R6 XImage structure. + * of the X11R6 XImage structure. * `bpp' gives the depth of the image in bits per pixel (16, 24, or 32). * If `double_resolution' is not 0 the the image width and height is doubled. * (fast pixel doubling, no interpolation!) * * Return value: - * pointer to the new structure or NULL on error + * pointer to the new structure or NULL on error */ { if (bpp != 16 && bpp != 24 && bpp !=32) @@ -111,30 +111,30 @@ fiasco_renderer_new (unsigned long red_mask, unsigned long green_mask, { fiasco_renderer_t *render = calloc (1, sizeof (fiasco_renderer_t)); renderer_private_t *private = calloc (1, sizeof (renderer_private_t)); - bool_t twopixels = (bpp == 16 && double_resolution); - int crval, cbval, i; /* counter */ + bool_t twopixels = (bpp == 16 && double_resolution); + int crval, cbval, i; /* counter */ if (!render || !private) { - set_error (_("Out of memory.")); - return NULL; + set_error (_("Out of memory.")); + return NULL; } switch (bpp) { - case 16: - render->render = display_16_bit; - break; - case 24: - if (red_mask > green_mask) - render->render = display_24_bit_rgb; - else - render->render = display_24_bit_bgr; - break; - case 32: - render->render = display_32_bit; - break; - default: - break; /* does not happen */ + case 16: + render->render = display_16_bit; + break; + case 24: + if (red_mask > green_mask) + render->render = display_24_bit_rgb; + else + render->render = display_24_bit_bgr; + break; + case 32: + render->render = display_32_bit; + break; + default: + break; /* does not happen */ } render->private = private; render->delete = fiasco_renderer_delete; @@ -146,42 +146,42 @@ fiasco_renderer_new (unsigned long red_mask, unsigned long green_mask, private->Cb_b_tab = calloc (256 + 2 * 1024, sizeof (int)); if (!private->Cr_r_tab || !private->Cr_g_tab - || !private->Cb_b_tab || !private->Cb_g_tab) + || !private->Cb_b_tab || !private->Cb_g_tab) { - set_error (_("Out of memory.")); - return NULL; + set_error (_("Out of memory.")); + return NULL; } - + for (i = 1024; i < 1024 + 256; i++) { - cbval = crval = i - 128 - 1024; + cbval = crval = i - 128 - 1024; - private->Cr_r_tab [i] = 1.4022 * crval + 0.5; - private->Cr_g_tab [i] = -0.7145 * crval + 0.5; - private->Cb_g_tab [i] = -0.3456 * cbval + 0.5; - private->Cb_b_tab [i] = 1.7710 * cbval + 0.5; + private->Cr_r_tab [i] = 1.4022 * crval + 0.5; + private->Cr_g_tab [i] = -0.7145 * crval + 0.5; + private->Cb_g_tab [i] = -0.3456 * cbval + 0.5; + private->Cb_b_tab [i] = 1.7710 * cbval + 0.5; } for (i = 0; i < 1024; i++) { - private->Cr_r_tab [i] = private->Cr_r_tab [1024]; - private->Cr_g_tab [i] = private->Cr_g_tab [1024]; - private->Cb_g_tab [i] = private->Cb_g_tab [1024]; - private->Cb_b_tab [i] = private->Cb_b_tab [1024]; + private->Cr_r_tab [i] = private->Cr_r_tab [1024]; + private->Cr_g_tab [i] = private->Cr_g_tab [1024]; + private->Cb_g_tab [i] = private->Cb_g_tab [1024]; + private->Cb_b_tab [i] = private->Cb_b_tab [1024]; } for (i = 1024 + 256; i < 2048 + 256; i++) { - private->Cr_r_tab [i] = private->Cr_r_tab [1024 + 255]; - private->Cr_g_tab [i] = private->Cr_g_tab [1024 + 255]; - private->Cb_g_tab [i] = private->Cb_g_tab [1024 + 255]; - private->Cb_b_tab [i] = private->Cb_b_tab [1024 + 255]; + private->Cr_r_tab [i] = private->Cr_r_tab [1024 + 255]; + private->Cr_g_tab [i] = private->Cr_g_tab [1024 + 255]; + private->Cb_g_tab [i] = private->Cb_g_tab [1024 + 255]; + private->Cb_b_tab [i] = private->Cb_b_tab [1024 + 255]; } private->Cr_r_tab += 1024 + 128; private->Cr_g_tab += 1024 + 128; private->Cb_g_tab += 1024 + 128; private->Cb_b_tab += 1024 + 128; - - /* + + /* * Set up entries 0-255 in rgb-to-pixel value tables. */ private->r_table = calloc (256 + 2 * 1024, sizeof (unsigned int)); @@ -190,38 +190,38 @@ fiasco_renderer_new (unsigned long red_mask, unsigned long green_mask, private->y_table = calloc (256 + 2 * 1024, sizeof (unsigned int)); if (!private->r_table || !private->g_table - || !private->b_table || !private->y_table) + || !private->b_table || !private->y_table) { - set_error (_("Out of memory.")); - return NULL; + set_error (_("Out of memory.")); + return NULL; } - + for (i = 0; i < 256; i++) { - private->r_table [i + 1024] - = i >> (8 - number_of_bits_set(red_mask)); - private->r_table [i + 1024] - <<= free_bits_at_bottom (red_mask); - private->g_table [i + 1024] - = i >> (8 - number_of_bits_set (green_mask)); - private->g_table [i + 1024] - <<= free_bits_at_bottom (green_mask); - private->b_table [i + 1024] - <<= free_bits_at_bottom (blue_mask); - private->b_table [i + 1024] - = i >> (8 - number_of_bits_set (blue_mask)); - if (twopixels) - { - private->r_table [i + 1024] = ((private->r_table [i + 1024] << 16) - | private->r_table [i + 1024]); - private->g_table [i + 1024] = ((private->g_table [i + 1024] << 16) - | private->g_table [i + 1024]); - private->b_table [i + 1024] = ((private->b_table [i + 1024] << 16) - | private->b_table [i + 1024]); - } - private->y_table [i + 1024] = (private->r_table [i + 1024] - | private->g_table [i + 1024] - | private->b_table [i + 1024]); + private->r_table [i + 1024] + = i >> (8 - number_of_bits_set(red_mask)); + private->r_table [i + 1024] + <<= free_bits_at_bottom (red_mask); + private->g_table [i + 1024] + = i >> (8 - number_of_bits_set (green_mask)); + private->g_table [i + 1024] + <<= free_bits_at_bottom (green_mask); + private->b_table [i + 1024] + <<= free_bits_at_bottom (blue_mask); + private->b_table [i + 1024] + = i >> (8 - number_of_bits_set (blue_mask)); + if (twopixels) + { + private->r_table [i + 1024] = ((private->r_table [i + 1024] << 16) + | private->r_table [i + 1024]); + private->g_table [i + 1024] = ((private->g_table [i + 1024] << 16) + | private->g_table [i + 1024]); + private->b_table [i + 1024] = ((private->b_table [i + 1024] << 16) + | private->b_table [i + 1024]); + } + private->y_table [i + 1024] = (private->r_table [i + 1024] + | private->g_table [i + 1024] + | private->b_table [i + 1024]); } /* @@ -230,14 +230,14 @@ fiasco_renderer_new (unsigned long red_mask, unsigned long green_mask, */ for (i = 0; i < 1024; i++) { - private->r_table [i] = private->r_table [1024]; - private->r_table [i + 1024 + 256] = private->r_table [1024 + 255]; - private->g_table [i] = private->g_table [1024]; - private->g_table [i + 1024 + 256] = private->g_table [1024 + 255]; - private->b_table [i] = private->b_table [1024]; - private->b_table [i + 1024 + 256] = private->b_table [1024 + 255]; - private->y_table [i] = private->y_table [1024]; - private->y_table [i + 1024 + 256] = private->y_table [1024 + 255]; + private->r_table [i] = private->r_table [1024]; + private->r_table [i + 1024 + 256] = private->r_table [1024 + 255]; + private->g_table [i] = private->g_table [1024]; + private->g_table [i + 1024 + 256] = private->g_table [1024 + 255]; + private->b_table [i] = private->b_table [1024]; + private->b_table [i + 1024 + 256] = private->b_table [1024 + 255]; + private->y_table [i] = private->y_table [1024]; + private->y_table [i + 1024 + 256] = private->y_table [1024 + 255]; } private->r_table += 1024; @@ -247,7 +247,7 @@ fiasco_renderer_new (unsigned long red_mask, unsigned long green_mask, return render; } - + } void @@ -259,7 +259,7 @@ fiasco_renderer_delete (fiasco_renderer_t *renderer) * No return value. * * Side effects: - * structure 'renderer' is discarded. + * structure 'renderer' is discarded. */ { if (!renderer) @@ -284,8 +284,8 @@ fiasco_renderer_delete (fiasco_renderer_t *renderer) int fiasco_renderer_render (const fiasco_renderer_t *renderer, - unsigned char *ximage, - const fiasco_image_t *fiasco_image) + unsigned char *ximage, + const fiasco_image_t *fiasco_image) { if (!renderer) { @@ -298,8 +298,8 @@ fiasco_renderer_render (const fiasco_renderer_t *renderer, /***************************************************************************** - private code - + private code + *****************************************************************************/ /* @@ -313,7 +313,7 @@ fiasco_renderer_render (const fiasco_renderer_t *renderer, * mode, since this involves getting down to byte level again. It is * assumed that the bits for each color are contiguous in the * longword. - * + * * Writing to memory is done in shorts or ints. (Unfortunately, short * is not very fast on Alpha, so there is room for improvement * here). There is no dither time check for overflow - instead the @@ -357,9 +357,9 @@ free_bits_at_bottom (unsigned long a) return 1 + free_bits_at_bottom ( a >> 1); } -static int +static int display_16_bit (const struct fiasco_renderer *this, unsigned char *ximage, - const fiasco_image_t *fiasco_image) + const fiasco_image_t *fiasco_image) /* * Convert 'image' to 16 bit color bitmap. * If 'double_resolution' is true then double image size in both directions. @@ -367,13 +367,13 @@ display_16_bit (const struct fiasco_renderer *this, unsigned char *ximage, * No return value. * * Side effects: - * 'out[]' is filled with dithered image + * 'out[]' is filled with dithered image */ { const image_t *image; renderer_private_t *private; - byte_t *out; - + byte_t *out; + if (!this) { set_error (_("Parameter `%s' not defined (NULL)."), "this"); @@ -390,21 +390,21 @@ display_16_bit (const struct fiasco_renderer *this, unsigned char *ximage, return 0; } - out = (byte_t *) ximage; + out = (byte_t *) ximage; image = cast_image ((fiasco_image_t *) fiasco_image); if (!image) return 0; private = (renderer_private_t *) this->private; - + if (image->color) { - word_t *cbptr, *crptr; /* pointer to chroma bands */ - word_t *yptr; /* pointers to lumincance band */ - int yval, crval, cbval; /* pixel value in YCbCr color space */ - int R, G, B; /* pixel value in RGB color space */ - int n; /* pixel counter */ - int x, y; /* pixel coordinates */ - int *Cr_r_tab, *Cr_g_tab, *Cb_g_tab, *Cb_b_tab; + word_t *cbptr, *crptr; /* pointer to chroma bands */ + word_t *yptr; /* pointers to lumincance band */ + int yval, crval, cbval; /* pixel value in YCbCr color space */ + int R, G, B; /* pixel value in RGB color space */ + int n; /* pixel counter */ + int x, y; /* pixel coordinates */ + int *Cr_r_tab, *Cr_g_tab, *Cb_g_tab, *Cb_b_tab; unsigned int *r_table, *g_table, *b_table; Cr_g_tab = private->Cr_g_tab; @@ -420,245 +420,245 @@ display_16_bit (const struct fiasco_renderer *this, unsigned char *ximage, if (image->format == FORMAT_4_2_0) { - u_word_t *dst, *dst2; /* pointers to dithered pixels */ - word_t *yptr2; /* pointers to lumincance band */ - - if (private->double_resolution) - { - yptr2 = yptr + image->width; - dst = (u_word_t *) out; - dst2 = dst + 4 * image->width; - for (y = image->height / 2; y; y--) - { - for (x = image->width / 2; x; x--) - { + u_word_t *dst, *dst2; /* pointers to dithered pixels */ + word_t *yptr2; /* pointers to lumincance band */ + + if (private->double_resolution) + { + yptr2 = yptr + image->width; + dst = (u_word_t *) out; + dst2 = dst + 4 * image->width; + for (y = image->height / 2; y; y--) + { + for (x = image->width / 2; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - crval = *crptr++ >> 4; - cbval = *cbptr++ >> 4; - yval = (*yptr++ >> 4) + 128; + crval = *crptr++ >> 4; + cbval = *cbptr++ >> 4; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - crval = *crptr++ / 16; - cbval = *cbptr++ / 16; - yval = *yptr++ / 16 + 128; + crval = *crptr++ / 16; + cbval = *cbptr++ / 16; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; + #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr++ >> 4) + 128; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr++ / 16 + 128; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr2++ >> 4) + 128; + yval = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr2++ / 16 + 128; + yval = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr2++ >> 4) + 128; + yval = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr2++ / 16 + 128; + yval = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; - } - memcpy (dst, dst - 2 * image->width, - 2 * image->width * sizeof (u_word_t)); - memcpy (dst2, dst2 - 2 * image->width, - 2 * image->width * sizeof (u_word_t)); - yptr += image->width; - yptr2 += image->width; - dst += 3 * image->width * 2; - dst2 += 3 * image->width * 2; - } - } - else - { - yptr2 = yptr + image->width; - dst = (u_word_t *) out; - dst2 = dst + image->width; - - for (y = image->height / 2; y; y--) - { - for (x = image->width / 2; x; x--) - { + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; + } + memcpy (dst, dst - 2 * image->width, + 2 * image->width * sizeof (u_word_t)); + memcpy (dst2, dst2 - 2 * image->width, + 2 * image->width * sizeof (u_word_t)); + yptr += image->width; + yptr2 += image->width; + dst += 3 * image->width * 2; + dst2 += 3 * image->width * 2; + } + } + else + { + yptr2 = yptr + image->width; + dst = (u_word_t *) out; + dst2 = dst + image->width; + + for (y = image->height / 2; y; y--) + { + for (x = image->width / 2; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - crval = *crptr++ >> 4; - cbval = *cbptr++ >> 4; - yval = (*yptr++ >> 4) + 128; + crval = *crptr++ >> 4; + cbval = *cbptr++ >> 4; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - crval = *crptr++ / 16; - cbval = *cbptr++ / 16; - yval = *yptr++ / 16 + 128; + crval = *crptr++ / 16; + cbval = *cbptr++ / 16; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; + #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr++ >> 4) + 128; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr++ / 16 + 128; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr2++ >> 4) + 128; + yval = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr2++ / 16 + 128; + yval = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr2++ >> 4) + 128; + yval = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr2++ / 16 + 128; + yval = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; - } - yptr += image->width; - yptr2 += image->width; - dst += image->width; - dst2 += image->width; - } - } + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; + } + yptr += image->width; + yptr2 += image->width; + dst += image->width; + dst2 += image->width; + } + } } - else /* 4:4:4 format */ + else /* 4:4:4 format */ { - if (private->double_resolution) - { - unsigned int *dst; /* pointer to dithered pixels */ - - dst = (unsigned int *) out; - - for (y = image->height; y; y--) - { - for (x = image->width; x; x--) - { + if (private->double_resolution) + { + unsigned int *dst; /* pointer to dithered pixels */ + + dst = (unsigned int *) out; + + for (y = image->height; y; y--) + { + for (x = image->width; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - crval = *crptr++ >> 4; - cbval = *cbptr++ >> 4; - yval = (*yptr++ >> 4) + 128; + crval = *crptr++ >> 4; + cbval = *cbptr++ >> 4; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - crval = *crptr++ / 16; - cbval = *cbptr++ / 16; - yval = *yptr++ / 16 + 128; + crval = *crptr++ / 16; + cbval = *cbptr++ / 16; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - - *dst++ = r_table [R] | g_table [G] | b_table [B]; - } - memcpy (dst, dst - image->width, - image->width * sizeof (unsigned int)); - dst += image->width; - } - } - else - { - u_word_t *dst; /* pointer to dithered pixels */ - - dst = (u_word_t *) out; - - for (n = image->width * image->height; n; n--) - { + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + + *dst++ = r_table [R] | g_table [G] | b_table [B]; + } + memcpy (dst, dst - image->width, + image->width * sizeof (unsigned int)); + dst += image->width; + } + } + else + { + u_word_t *dst; /* pointer to dithered pixels */ + + dst = (u_word_t *) out; + + for (n = image->width * image->height; n; n--) + { #ifdef HAVE_SIGNED_SHIFT - crval = *crptr++ >> 4; - cbval = *cbptr++ >> 4; - yval = (*yptr++ >> 4) + 128; + crval = *crptr++ >> 4; + cbval = *cbptr++ >> 4; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - crval = *crptr++ / 16; - cbval = *cbptr++ / 16; - yval = *yptr++ / 16 + 128; + crval = *crptr++ / 16; + cbval = *cbptr++ / 16; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - } - } + *dst++ = r_table [R] | g_table [G] | b_table [B]; + } + } } } else { - unsigned int *dst; /* pointer to dithered pixels */ - word_t *src; /* current pixel of frame */ + unsigned int *dst; /* pointer to dithered pixels */ + word_t *src; /* current pixel of frame */ unsigned int *y_table; y_table = private->y_table; dst = (unsigned int *) out; src = image->pixels [GRAY]; - + if (private->double_resolution) { - int x, y; /* pixel coordinates */ - - for (y = image->height; y; y--) - { - for (x = image->width; x; x--) - { - int value; - + int x, y; /* pixel coordinates */ + + for (y = image->height; y; y--) + { + for (x = image->width; x; x--) + { + int value; + #ifdef HAVE_SIGNED_SHIFT - value = y_table [*src++ >> 4]; + value = y_table [*src++ >> 4]; #else /* not HAVE_SIGNED_SHIFT */ - value = y_table [*src++ / 16]; + value = y_table [*src++ / 16]; #endif /* not HAVE_SIGNED_SHIFT */ - *dst++ = (value << 16) | value; - } - - memcpy (dst, dst - image->width, - image->width * sizeof (unsigned int)); - dst += image->width; - } + *dst++ = (value << 16) | value; + } + + memcpy (dst, dst - image->width, + image->width * sizeof (unsigned int)); + dst += image->width; + } } else { - int n; /* pixel counter */ - - for (n = image->width * image->height / 2; n; n--, src += 2) + int n; /* pixel counter */ + + for (n = image->width * image->height / 2; n; n--, src += 2) #ifdef HAVE_SIGNED_SHIFT -# if BYTE_ORDER == LITTLE_ENDIAN - *dst++ = (y_table [src [1] >> 4] << 16) | y_table [src [0] >> 4]; -# else - *dst++ = (y_table [src [0] >> 4] << 16) | y_table [src [1] >> 4]; -# endif +# if BYTE_ORDER == LITTLE_ENDIAN + *dst++ = (y_table [src [1] >> 4] << 16) | y_table [src [0] >> 4]; +# else + *dst++ = (y_table [src [0] >> 4] << 16) | y_table [src [1] >> 4]; +# endif #else /* not HAVE_SIGNED_SHIFT */ -# if BYTE_ORDER == LITTLE_ENDIAN - *dst++ = (y_table [src [1] / 16] << 16) | y_table [src [0] / 16]; -# else - *dst++ = (y_table [src [0] / 16] << 16) | y_table [src [1] / 16]; -# endif +# if BYTE_ORDER == LITTLE_ENDIAN + *dst++ = (y_table [src [1] / 16] << 16) | y_table [src [0] / 16]; +# else + *dst++ = (y_table [src [0] / 16] << 16) | y_table [src [1] / 16]; +# endif #endif /* not HAVE_SIGNED_SHIFT */ } } @@ -666,9 +666,9 @@ display_16_bit (const struct fiasco_renderer *this, unsigned char *ximage, return 1; } -static int +static int display_24_bit_bgr (const struct fiasco_renderer *this, unsigned char *ximage, - const fiasco_image_t *fiasco_image) + const fiasco_image_t *fiasco_image) /* * Convert 'image' to 16 bit color bitmap. * If 'double_resolution' is true then double image size in both directions. @@ -676,13 +676,13 @@ display_24_bit_bgr (const struct fiasco_renderer *this, unsigned char *ximage, * No return value. * * Side effects: - * 'out[]' is filled with dithered image + * 'out[]' is filled with dithered image */ { - unsigned *gray_clip = init_clipping (); + unsigned *gray_clip = init_clipping (); const image_t *image; renderer_private_t *private; - byte_t *out; + byte_t *out; if (!gray_clip) return 0; @@ -702,17 +702,17 @@ display_24_bit_bgr (const struct fiasco_renderer *this, unsigned char *ximage, return 0; } - out = (byte_t *) ximage; + out = (byte_t *) ximage; image = cast_image ((fiasco_image_t *) fiasco_image); if (!image) return 0; private = (renderer_private_t *) this->private; - + if (image->color) { - word_t *cbptr, *crptr; /* pointer to chroma bands */ - word_t *yptr; /* pointers to lumincance band */ - int *Cr_r_tab, *Cr_g_tab, *Cb_g_tab, *Cb_b_tab; + word_t *cbptr, *crptr; /* pointer to chroma bands */ + word_t *yptr; /* pointers to lumincance band */ + int *Cr_r_tab, *Cr_g_tab, *Cb_g_tab, *Cb_b_tab; Cr_g_tab = private->Cr_g_tab; Cr_r_tab = private->Cr_r_tab; @@ -724,396 +724,396 @@ display_24_bit_bgr (const struct fiasco_renderer *this, unsigned char *ximage, if (image->format == FORMAT_4_2_0) { - if (private->double_resolution) - { - int yval1; /* lumincance pixel */ - int crval1, cbval1; /* chroma pixels */ - int yval2; /* pixel in YCbCr color space */ - unsigned int R1, G1, B1; /* pixel in RGB color space */ - unsigned int R2, G2, B2; /* pixel in RGB color space */ - int x, y; /* pixel counter */ - unsigned int *dst; /* pointer to dithered pixels */ - unsigned int *dst2; /* pointers to dithered pixels */ - word_t *yptr2; /* pointers to lumincance band */ - - dst = (unsigned int *) out; - dst2 = dst + (image->width >> 1) * 3 * 2; - yptr2 = yptr + image->width; - - for (y = image->height >> 1; y; y--) - { - for (x = image->width >> 1; x; x--) - { + if (private->double_resolution) + { + int yval1; /* lumincance pixel */ + int crval1, cbval1; /* chroma pixels */ + int yval2; /* pixel in YCbCr color space */ + unsigned int R1, G1, B1; /* pixel in RGB color space */ + unsigned int R2, G2, B2; /* pixel in RGB color space */ + int x, y; /* pixel counter */ + unsigned int *dst; /* pointer to dithered pixels */ + unsigned int *dst2; /* pointers to dithered pixels */ + word_t *yptr2; /* pointers to lumincance band */ + + dst = (unsigned int *) out; + dst2 = dst + (image->width >> 1) * 3 * 2; + yptr2 = yptr + image->width; + + for (y = image->height >> 1; y; y--) + { + for (x = image->width >> 1; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - *dst++ = B1 | (G1 << 8) | (R1 << 16) | (B1 << 24); - *dst++ = G1 | (R1 << 8) | (B2 << 16) | (G2 << 24); - *dst++ = R2 | (B2 << 8) | (G2 << 16) | (R2 << 24); + *dst++ = B1 | (G1 << 8) | (R1 << 16) | (B1 << 24); + *dst++ = G1 | (R1 << 8) | (B2 << 16) | (G2 << 24); + *dst++ = R2 | (B2 << 8) | (G2 << 16) | (R2 << 24); #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr2++ >> 4) + 128; - yval2 = (*yptr2++ >> 4) + 128; + yval1 = (*yptr2++ >> 4) + 128; + yval2 = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr2++ / 16 + 128; - yval2 = *yptr2++ / 16 + 128; + yval1 = *yptr2++ / 16 + 128; + yval2 = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - - *dst2++ = B1 | (G1 << 8) | (R1 << 16) | (B1 << 24); - *dst2++ = G1 | (R1 << 8) | (B2 << 16) | (G2 << 24); - *dst2++ = R2 | (B2 << 8) | (G2 << 16) | (R2 << 24); - } - memcpy (dst, dst - (image->width >> 1) * 3, - (image->width >> 1) * 3 * sizeof (unsigned int)); - memcpy (dst2, dst2 - (image->width >> 1) * 3, - (image->width >> 1) * 3 * sizeof (unsigned int)); - dst += (image->width >> 1) * 3 * 3; - dst2 += (image->width >> 1) * 3 * 3; - yptr += image->width; - yptr2 += image->width; - } - } - else - { - int yval1; /* lumincance pixel */ - int crval1, cbval1; /* chroma pixels */ - int yval2; /* pixel in YCbCr color space */ - unsigned int R1, G1, B1; /* pixel in RGB color space */ - unsigned int R2, G2, B2; /* pixel in RGB color space */ - int x, y; /* pixel counter */ - unsigned int *dst; /* pointer to dithered pixels */ - unsigned int *dst2; /* pointers to dithered pixels */ - word_t *yptr2; /* pointers to lumincance band */ - - dst = (unsigned int *) out; - dst2 = dst + (image->width >> 2) * 3; - yptr2 = yptr + image->width; - - for (y = image->height >> 1; y; y--) - { - for (x = image->width >> 2; x; x--) - { + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + + *dst2++ = B1 | (G1 << 8) | (R1 << 16) | (B1 << 24); + *dst2++ = G1 | (R1 << 8) | (B2 << 16) | (G2 << 24); + *dst2++ = R2 | (B2 << 8) | (G2 << 16) | (R2 << 24); + } + memcpy (dst, dst - (image->width >> 1) * 3, + (image->width >> 1) * 3 * sizeof (unsigned int)); + memcpy (dst2, dst2 - (image->width >> 1) * 3, + (image->width >> 1) * 3 * sizeof (unsigned int)); + dst += (image->width >> 1) * 3 * 3; + dst2 += (image->width >> 1) * 3 * 3; + yptr += image->width; + yptr2 += image->width; + } + } + else + { + int yval1; /* lumincance pixel */ + int crval1, cbval1; /* chroma pixels */ + int yval2; /* pixel in YCbCr color space */ + unsigned int R1, G1, B1; /* pixel in RGB color space */ + unsigned int R2, G2, B2; /* pixel in RGB color space */ + int x, y; /* pixel counter */ + unsigned int *dst; /* pointer to dithered pixels */ + unsigned int *dst2; /* pointers to dithered pixels */ + word_t *yptr2; /* pointers to lumincance band */ + + dst = (unsigned int *) out; + dst2 = dst + (image->width >> 2) * 3; + yptr2 = yptr + image->width; + + for (y = image->height >> 1; y; y--) + { + for (x = image->width >> 2; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - *dst++ = B1 | (G1 << 8) | (R1 << 16) | (B2 << 24); - *dst = G2 | (R2 << 8); + *dst++ = B1 | (G1 << 8) | (R1 << 16) | (B2 << 24); + *dst = G2 | (R2 << 8); #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr2++ >> 4) + 128; - yval2 = (*yptr2++ >> 4) + 128; + yval1 = (*yptr2++ >> 4) + 128; + yval2 = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr2++ / 16 + 128; - yval2 = *yptr2++ / 16 + 128; + yval1 = *yptr2++ / 16 + 128; + yval2 = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - - *dst2++ = B1 | (G1 << 8) | (R1 << 16) | (B2 << 24); - *dst2 = G2 | (R2 << 8); - + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + + *dst2++ = B1 | (G1 << 8) | (R1 << 16) | (B2 << 24); + *dst2 = G2 | (R2 << 8); + #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - crval2 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; - cbval2 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + crval2 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; + cbval2 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - *dst++ |= (B1 << 16) | (G1 << 24); - *dst++ = R1 | (B2 << 8) | (G2 << 16) | (R2 << 24); + *dst++ |= (B1 << 16) | (G1 << 24); + *dst++ = R1 | (B2 << 8) | (G2 << 16) | (R2 << 24); #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr2++ >> 4) + 128; - yval2 = (*yptr2++ >> 4) + 128; + yval1 = (*yptr2++ >> 4) + 128; + yval2 = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr2++ / 16 + 128; - yval2 = *yptr2++ / 16 + 128; + yval1 = *yptr2++ / 16 + 128; + yval2 = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - - *dst2++ |= (B1 << 16) | (G1 << 24); - *dst2++ = R1 | (B2 << 8) | (G2 << 16) | (R2 << 24); - } - dst += (image->width >> 2) * 3; - dst2 += (image->width >> 2) * 3; - yptr += image->width; - yptr2 += image->width; - } - } + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + + *dst2++ |= (B1 << 16) | (G1 << 24); + *dst2++ = R1 | (B2 << 8) | (G2 << 16) | (R2 << 24); + } + dst += (image->width >> 2) * 3; + dst2 += (image->width >> 2) * 3; + yptr += image->width; + yptr2 += image->width; + } + } } - else /* 4:4:4 format */ + else /* 4:4:4 format */ { - if (private->double_resolution) - { - unsigned int R1, G1, B1; /* pixel1 in RGB color space */ - unsigned int R2, G2, B2; /* pixel2 in RGB color space */ - int yval1, crval1, cbval1; /* pixel1 in YCbCr space */ - int yval2, crval2, cbval2; /* pixel2 in YCbCr space */ - int x, y; /* pixel counter */ - unsigned int *dst; /* dithered pixel pointer */ - - dst = (unsigned int *) out; - - for (y = image->height; y; y--) - { - for (x = image->width >> 1; x; x--) - { + if (private->double_resolution) + { + unsigned int R1, G1, B1; /* pixel1 in RGB color space */ + unsigned int R2, G2, B2; /* pixel2 in RGB color space */ + int yval1, crval1, cbval1; /* pixel1 in YCbCr space */ + int yval2, crval2, cbval2; /* pixel2 in YCbCr space */ + int x, y; /* pixel counter */ + unsigned int *dst; /* dithered pixel pointer */ + + dst = (unsigned int *) out; + + for (y = image->height; y; y--) + { + for (x = image->width >> 1; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - crval2 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; - cbval2 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + crval2 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; + cbval2 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - crval2 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; - cbval2 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + crval2 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; + cbval2 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval2] - + Cb_g_tab [cbval2]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; - - *dst++ = B1 | (G1 << 8) | (R1 << 16) | (B1 << 24); - *dst++ = G1 | (R1 << 8) | (B2 << 16) | (G2 << 24); - *dst++ = R2 | (B2 << 8) | (G2 << 16) | (R2 << 24); - } - memcpy (dst, dst - 3 * (image->width >> 1), - 3 * (image->width >> 1) * sizeof (unsigned int)); - dst += 3 * (image->width >> 1); - } - } - else - { - unsigned int R1, G1, B1; /* pixel in RGB color space */ - unsigned int R2, G2, B2; /* pixel in RGB color space */ - int yval1, crval1, cbval1; /* pixel1 in YCbCr space */ - int yval2, crval2, cbval2; /* pixel2 in YCbCr space */ - int n; /* pixel counter */ - unsigned int *dst; /* dithered pixel pointer */ - - dst = (unsigned int *) out; - - for (n = (image->width * image->height) >> 2; n; n--) - { + + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval2] + + Cb_g_tab [cbval2]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; + + *dst++ = B1 | (G1 << 8) | (R1 << 16) | (B1 << 24); + *dst++ = G1 | (R1 << 8) | (B2 << 16) | (G2 << 24); + *dst++ = R2 | (B2 << 8) | (G2 << 16) | (R2 << 24); + } + memcpy (dst, dst - 3 * (image->width >> 1), + 3 * (image->width >> 1) * sizeof (unsigned int)); + dst += 3 * (image->width >> 1); + } + } + else + { + unsigned int R1, G1, B1; /* pixel in RGB color space */ + unsigned int R2, G2, B2; /* pixel in RGB color space */ + int yval1, crval1, cbval1; /* pixel1 in YCbCr space */ + int yval2, crval2, cbval2; /* pixel2 in YCbCr space */ + int n; /* pixel counter */ + unsigned int *dst; /* dithered pixel pointer */ + + dst = (unsigned int *) out; + + for (n = (image->width * image->height) >> 2; n; n--) + { #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - crval2 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; - cbval2 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + crval2 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; + cbval2 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - crval2 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; - cbval2 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + crval2 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; + cbval2 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval2] + Cb_g_tab [cbval2]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval2] + Cb_g_tab [cbval2]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; - *dst++ = B1 | (G1 << 8) | (R1 << 16) | (B2 << 24); - *dst = G2 | (R2 << 8); + *dst++ = B1 | (G1 << 8) | (R1 << 16) | (B2 << 24); + *dst = G2 | (R2 << 8); #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - crval2 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; - cbval2 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + crval2 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; + cbval2 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - crval2 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; - cbval2 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + crval2 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; + cbval2 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval2] + Cb_g_tab [cbval2]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; - - *dst++ |= (B1 << 16) | (G1 << 24); - *dst++ = R1 | (B2 << 8) | (G2 << 16) | (R2 << 24); - } - } + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval2] + Cb_g_tab [cbval2]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; + + *dst++ |= (B1 << 16) | (G1 << 24); + *dst++ = R1 | (B2 << 8) | (G2 << 16) | (R2 << 24); + } + } } } else { - unsigned int *dst; /* pointer to dithered pixels */ - word_t *src; /* current pixel of frame */ + unsigned int *dst; /* pointer to dithered pixels */ + word_t *src; /* current pixel of frame */ dst = (unsigned int *) out; src = image->pixels [GRAY]; if (private->double_resolution) { - int x, y; /* pixel counter */ - unsigned *shift_clipping = gray_clip + 128; - - for (y = image->height; y; y--) - { - for (x = image->width >> 1; x; x--) - { - unsigned int val1, val2; + int x, y; /* pixel counter */ + unsigned *shift_clipping = gray_clip + 128; + + for (y = image->height; y; y--) + { + for (x = image->width >> 1; x; x--) + { + unsigned int val1, val2; #ifdef HAVE_SIGNED_SHIFT - val1 = shift_clipping [*src++ >> 4]; - val2 = shift_clipping [*src++ >> 4]; + val1 = shift_clipping [*src++ >> 4]; + val2 = shift_clipping [*src++ >> 4]; #else /* not HAVE_SIGNED_SHIFT */ - val1 = shift_clipping [*src++ / 16]; - val2 = shift_clipping [*src++ / 16]; + val1 = shift_clipping [*src++ / 16]; + val2 = shift_clipping [*src++ / 16]; #endif /* not HAVE_SIGNED_SHIFT */ - *dst++ = val1 | (val1 << 8) | (val1 << 16) | (val1 << 24); - *dst++ = val1 | (val1 << 8) | (val2 << 16) | (val2 << 24); - *dst++ = val2 | (val2 << 8) | (val2 << 16) | (val2 << 24); - } + *dst++ = val1 | (val1 << 8) | (val1 << 16) | (val1 << 24); + *dst++ = val1 | (val1 << 8) | (val2 << 16) | (val2 << 24); + *dst++ = val2 | (val2 << 8) | (val2 << 16) | (val2 << 24); + } - memcpy (dst, dst - 3 * (image->width >> 1), - 3 * (image->width >> 1) * sizeof (unsigned int)); - dst += 3 * (image->width >> 1); - } + memcpy (dst, dst - 3 * (image->width >> 1), + 3 * (image->width >> 1) * sizeof (unsigned int)); + dst += 3 * (image->width >> 1); + } } else { - int n; /* pixel counter */ - unsigned *shift_clipping = gray_clip + 128; + int n; /* pixel counter */ + unsigned *shift_clipping = gray_clip + 128; - for (n = (image->width * image->height) >> 2; n; n--) - { - unsigned int val1, val2; + for (n = (image->width * image->height) >> 2; n; n--) + { + unsigned int val1, val2; #ifdef HAVE_SIGNED_SHIFT - val1 = shift_clipping [*src++ >> 4]; - val2 = shift_clipping [*src++ >> 4]; + val1 = shift_clipping [*src++ >> 4]; + val2 = shift_clipping [*src++ >> 4]; #else /* not HAVE_SIGNED_SHIFT */ - val1 = shift_clipping [*src++ / 16]; - val2 = shift_clipping [*src++ / 16]; + val1 = shift_clipping [*src++ / 16]; + val2 = shift_clipping [*src++ / 16]; #endif /* not HAVE_SIGNED_SHIFT */ - *dst++ = val1 | (val1 << 8) - | (val1 << 16) | (val2 << 24); /* RGBR */ - *dst = val2 | (val2 << 8); /* GB-- */ + *dst++ = val1 | (val1 << 8) + | (val1 << 16) | (val2 << 24); /* RGBR */ + *dst = val2 | (val2 << 8); /* GB-- */ #ifdef HAVE_SIGNED_SHIFT - val1 = shift_clipping [*src++ >> 4]; - val2 = shift_clipping [*src++ >> 4]; + val1 = shift_clipping [*src++ >> 4]; + val2 = shift_clipping [*src++ >> 4]; #else /* not HAVE_SIGNED_SHIFT */ - val1 = shift_clipping [*src++ / 16]; - val2 = shift_clipping [*src++ / 16]; + val1 = shift_clipping [*src++ / 16]; + val2 = shift_clipping [*src++ / 16]; #endif /* not HAVE_SIGNED_SHIFT */ - - *dst++ |= (val1 << 16) | (val1 << 24); /* --RG */ - *dst++ = val1 | (val2 << 8) - | (val2 << 16) | (val2 << 24); /* BRGB */ - } + + *dst++ |= (val1 << 16) | (val1 << 24); /* --RG */ + *dst++ = val1 | (val2 << 8) + | (val2 << 16) | (val2 << 24); /* BRGB */ + } } } - + return 1; } -static int +static int display_24_bit_rgb (const struct fiasco_renderer *this, unsigned char *ximage, - const fiasco_image_t *fiasco_image) + const fiasco_image_t *fiasco_image) /* * Convert 'image' to 16 bit color bitmap. * If 'double_resolution' is true then double image size in both directions. @@ -1121,13 +1121,13 @@ display_24_bit_rgb (const struct fiasco_renderer *this, unsigned char *ximage, * No return value. * * Side effects: - * 'out[]' is filled with dithered image + * 'out[]' is filled with dithered image */ { - unsigned *gray_clip = init_clipping (); + unsigned *gray_clip = init_clipping (); const image_t *image; renderer_private_t *private; - byte_t *out; + byte_t *out; if (!gray_clip) return 0; @@ -1147,17 +1147,17 @@ display_24_bit_rgb (const struct fiasco_renderer *this, unsigned char *ximage, return 0; } - out = (byte_t *) ximage; + out = (byte_t *) ximage; image = cast_image ((fiasco_image_t *) fiasco_image); if (!image) return 0; private = (renderer_private_t *) this->private; - + if (image->color) { - word_t *cbptr, *crptr; /* pointer to chroma bands */ - word_t *yptr; /* pointers to lumincance band */ - int *Cr_r_tab, *Cr_g_tab, *Cb_g_tab, *Cb_b_tab; + word_t *cbptr, *crptr; /* pointer to chroma bands */ + word_t *yptr; /* pointers to lumincance band */ + int *Cr_r_tab, *Cr_g_tab, *Cb_g_tab, *Cb_b_tab; Cr_g_tab = private->Cr_g_tab; Cr_r_tab = private->Cr_r_tab; @@ -1169,396 +1169,396 @@ display_24_bit_rgb (const struct fiasco_renderer *this, unsigned char *ximage, if (image->format == FORMAT_4_2_0) { - if (private->double_resolution) - { - int yval1; /* lumincance pixel */ - int crval1, cbval1; /* chroma pixels */ - int yval2; /* pixel in YCbCr color space */ - unsigned int R1, G1, B1; /* pixel in RGB color space */ - unsigned int R2, G2, B2; /* pixel in RGB color space */ - int x, y; /* pixel counter */ - unsigned int *dst; /* pointer to dithered pixels */ - unsigned int *dst2; /* pointers to dithered pixels */ - word_t *yptr2; /* pointers to lumincance band */ - - dst = (unsigned int *) out; - dst2 = dst + (image->width >> 1) * 3 * 2; - yptr2 = yptr + image->width; - - for (y = image->height >> 1; y; y--) - { - for (x = image->width >> 1; x; x--) - { + if (private->double_resolution) + { + int yval1; /* lumincance pixel */ + int crval1, cbval1; /* chroma pixels */ + int yval2; /* pixel in YCbCr color space */ + unsigned int R1, G1, B1; /* pixel in RGB color space */ + unsigned int R2, G2, B2; /* pixel in RGB color space */ + int x, y; /* pixel counter */ + unsigned int *dst; /* pointer to dithered pixels */ + unsigned int *dst2; /* pointers to dithered pixels */ + word_t *yptr2; /* pointers to lumincance band */ + + dst = (unsigned int *) out; + dst2 = dst + (image->width >> 1) * 3 * 2; + yptr2 = yptr + image->width; + + for (y = image->height >> 1; y; y--) + { + for (x = image->width >> 1; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - *dst++ = R1 | (G1 << 8) | (B1 << 16) | (R1 << 24); - *dst++ = G1 | (B1 << 8) | (R2 << 16) | (G2 << 24); - *dst++ = B2 | (R2 << 8) | (G2 << 16) | (B2 << 24); + *dst++ = R1 | (G1 << 8) | (B1 << 16) | (R1 << 24); + *dst++ = G1 | (B1 << 8) | (R2 << 16) | (G2 << 24); + *dst++ = B2 | (R2 << 8) | (G2 << 16) | (B2 << 24); #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr2++ >> 4) + 128; - yval2 = (*yptr2++ >> 4) + 128; + yval1 = (*yptr2++ >> 4) + 128; + yval2 = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr2++ / 16 + 128; - yval2 = *yptr2++ / 16 + 128; + yval1 = *yptr2++ / 16 + 128; + yval2 = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - - *dst2++ = R1 | (G1 << 8) | (B1 << 16) | (R1 << 24); - *dst2++ = G1 | (B1 << 8) | (R2 << 16) | (G2 << 24); - *dst2++ = B2 | (R2 << 8) | (G2 << 16) | (B2 << 24); - } - memcpy (dst, dst - (image->width >> 1) * 3, - (image->width >> 1) * 3 * sizeof (unsigned int)); - memcpy (dst2, dst2 - (image->width >> 1) * 3, - (image->width >> 1) * 3 * sizeof (unsigned int)); - dst += (image->width >> 1) * 3 * 3; - dst2 += (image->width >> 1) * 3 * 3; - yptr += image->width; - yptr2 += image->width; - } - } - else - { - int yval1; /* lumincance pixel */ - int crval1, cbval1; /* chroma pixels */ - int yval2; /* pixel in YCbCr color space */ - unsigned int R1, G1, B1; /* pixel in RGB color space */ - unsigned int R2, G2, B2; /* pixel in RGB color space */ - int x, y; /* pixel counter */ - unsigned int *dst; /* pointer to dithered pixels */ - unsigned int *dst2; /* pointers to dithered pixels */ - word_t *yptr2; /* pointers to lumincance band */ - - dst = (unsigned int *) out; - dst2 = dst + (image->width >> 2) * 3; - yptr2 = yptr + image->width; - - for (y = image->height >> 1; y; y--) - { - for (x = image->width >> 2; x; x--) - { + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + + *dst2++ = R1 | (G1 << 8) | (B1 << 16) | (R1 << 24); + *dst2++ = G1 | (B1 << 8) | (R2 << 16) | (G2 << 24); + *dst2++ = B2 | (R2 << 8) | (G2 << 16) | (B2 << 24); + } + memcpy (dst, dst - (image->width >> 1) * 3, + (image->width >> 1) * 3 * sizeof (unsigned int)); + memcpy (dst2, dst2 - (image->width >> 1) * 3, + (image->width >> 1) * 3 * sizeof (unsigned int)); + dst += (image->width >> 1) * 3 * 3; + dst2 += (image->width >> 1) * 3 * 3; + yptr += image->width; + yptr2 += image->width; + } + } + else + { + int yval1; /* lumincance pixel */ + int crval1, cbval1; /* chroma pixels */ + int yval2; /* pixel in YCbCr color space */ + unsigned int R1, G1, B1; /* pixel in RGB color space */ + unsigned int R2, G2, B2; /* pixel in RGB color space */ + int x, y; /* pixel counter */ + unsigned int *dst; /* pointer to dithered pixels */ + unsigned int *dst2; /* pointers to dithered pixels */ + word_t *yptr2; /* pointers to lumincance band */ + + dst = (unsigned int *) out; + dst2 = dst + (image->width >> 2) * 3; + yptr2 = yptr + image->width; + + for (y = image->height >> 1; y; y--) + { + for (x = image->width >> 2; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - *dst++ = R1 | (G1 << 8) | (B1 << 16) | (R2 << 24); - *dst = G2 | (B2 << 8); + *dst++ = R1 | (G1 << 8) | (B1 << 16) | (R2 << 24); + *dst = G2 | (B2 << 8); #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr2++ >> 4) + 128; - yval2 = (*yptr2++ >> 4) + 128; + yval1 = (*yptr2++ >> 4) + 128; + yval2 = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr2++ / 16 + 128; - yval2 = *yptr2++ / 16 + 128; + yval1 = *yptr2++ / 16 + 128; + yval2 = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - - *dst2++ = R1 | (G1 << 8) | (B1 << 16) | (R2 << 24); - *dst2 = G2 | (B2 << 8); - + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + + *dst2++ = R1 | (G1 << 8) | (B1 << 16) | (R2 << 24); + *dst2 = G2 | (B2 << 8); + #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - crval2 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; - cbval2 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + crval2 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; + cbval2 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - *dst++ |= (R1 << 16) | (G1 << 24); - *dst++ = B1 | (R2 << 8) | (G2 << 16) | (B2 << 24); + *dst++ |= (R1 << 16) | (G1 << 24); + *dst++ = B1 | (R2 << 8) | (G2 << 16) | (B2 << 24); #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr2++ >> 4) + 128; - yval2 = (*yptr2++ >> 4) + 128; + yval1 = (*yptr2++ >> 4) + 128; + yval2 = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr2++ / 16 + 128; - yval2 = *yptr2++ / 16 + 128; + yval1 = *yptr2++ / 16 + 128; + yval2 = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; - - *dst2++ |= (R1 << 16) | (G1 << 24); - *dst2++ = B1 | (R2 << 8) | (G2 << 16) | (B2 << 24); - } - dst += (image->width >> 2) * 3; - dst2 += (image->width >> 2) * 3; - yptr += image->width; - yptr2 += image->width; - } - } + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval1]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval1]]; + + *dst2++ |= (R1 << 16) | (G1 << 24); + *dst2++ = B1 | (R2 << 8) | (G2 << 16) | (B2 << 24); + } + dst += (image->width >> 2) * 3; + dst2 += (image->width >> 2) * 3; + yptr += image->width; + yptr2 += image->width; + } + } } - else /* 4:4:4 format */ + else /* 4:4:4 format */ { - if (private->double_resolution) - { - unsigned int R1, G1, B1; /* pixel1 in RGB color space */ - unsigned int R2, G2, B2; /* pixel2 in RGB color space */ - int yval1, crval1, cbval1; /* pixel1 in YCbCr space */ - int yval2, crval2, cbval2; /* pixel2 in YCbCr space */ - int x, y; /* pixel counter */ - unsigned int *dst; /* dithered pixel pointer */ - - dst = (unsigned int *) out; - - for (y = image->height; y; y--) - { - for (x = image->width >> 1; x; x--) - { + if (private->double_resolution) + { + unsigned int R1, G1, B1; /* pixel1 in RGB color space */ + unsigned int R2, G2, B2; /* pixel2 in RGB color space */ + int yval1, crval1, cbval1; /* pixel1 in YCbCr space */ + int yval2, crval2, cbval2; /* pixel2 in YCbCr space */ + int x, y; /* pixel counter */ + unsigned int *dst; /* dithered pixel pointer */ + + dst = (unsigned int *) out; + + for (y = image->height; y; y--) + { + for (x = image->width >> 1; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - crval2 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; - cbval2 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + crval2 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; + cbval2 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - crval2 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; - cbval2 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + crval2 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; + cbval2 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] - + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval2] - + Cb_g_tab [cbval2]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; - - *dst++ = R1 | (G1 << 8) | (B1 << 16) | (R1 << 24); - *dst++ = G1 | (B1 << 8) | (R2 << 16) | (G2 << 24); - *dst++ = B2 | (R2 << 8) | (G2 << 16) | (B2 << 24); - } - memcpy (dst, dst - 3 * (image->width >> 1), - 3 * (image->width >> 1) * sizeof (unsigned int)); - dst += 3 * (image->width >> 1); - } - } - else - { - unsigned int R1, G1, B1; /* pixel in RGB color space */ - unsigned int R2, G2, B2; /* pixel in RGB color space */ - int yval1, crval1, cbval1; /* pixel1 in YCbCr space */ - int yval2, crval2, cbval2; /* pixel2 in YCbCr space */ - int n; /* pixel counter */ - unsigned int *dst; /* dithered pixel pointer */ - - dst = (unsigned int *) out; - - for (n = (image->width * image->height) >> 2; n; n--) - { + + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval2] + + Cb_g_tab [cbval2]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; + + *dst++ = R1 | (G1 << 8) | (B1 << 16) | (R1 << 24); + *dst++ = G1 | (B1 << 8) | (R2 << 16) | (G2 << 24); + *dst++ = B2 | (R2 << 8) | (G2 << 16) | (B2 << 24); + } + memcpy (dst, dst - 3 * (image->width >> 1), + 3 * (image->width >> 1) * sizeof (unsigned int)); + dst += 3 * (image->width >> 1); + } + } + else + { + unsigned int R1, G1, B1; /* pixel in RGB color space */ + unsigned int R2, G2, B2; /* pixel in RGB color space */ + int yval1, crval1, cbval1; /* pixel1 in YCbCr space */ + int yval2, crval2, cbval2; /* pixel2 in YCbCr space */ + int n; /* pixel counter */ + unsigned int *dst; /* dithered pixel pointer */ + + dst = (unsigned int *) out; + + for (n = (image->width * image->height) >> 2; n; n--) + { #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - crval2 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; - cbval2 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + crval2 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; + cbval2 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - crval2 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; - cbval2 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + crval2 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; + cbval2 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval2] + Cb_g_tab [cbval2]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval2] + Cb_g_tab [cbval2]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; - *dst++ = R1 | (G1 << 8) | (B1 << 16) | (R2 << 24); - *dst = G2 | (B2 << 8); + *dst++ = R1 | (G1 << 8) | (B1 << 16) | (R2 << 24); + *dst = G2 | (B2 << 8); #ifdef HAVE_SIGNED_SHIFT - yval1 = (*yptr++ >> 4) + 128; - yval2 = (*yptr++ >> 4) + 128; - crval1 = *crptr++ >> 4; - crval2 = *crptr++ >> 4; - cbval1 = *cbptr++ >> 4; - cbval2 = *cbptr++ >> 4; + yval1 = (*yptr++ >> 4) + 128; + yval2 = (*yptr++ >> 4) + 128; + crval1 = *crptr++ >> 4; + crval2 = *crptr++ >> 4; + cbval1 = *cbptr++ >> 4; + cbval2 = *cbptr++ >> 4; #else /* not HAVE_SIGNED_SHIFT */ - yval1 = *yptr++ / 16 + 128; - yval2 = *yptr++ / 16 + 128; - crval1 = *crptr++ / 16; - crval2 = *crptr++ / 16; - cbval1 = *cbptr++ / 16; - cbval2 = *cbptr++ / 16; + yval1 = *yptr++ / 16 + 128; + yval2 = *yptr++ / 16 + 128; + crval1 = *crptr++ / 16; + crval2 = *crptr++ / 16; + cbval1 = *cbptr++ / 16; + cbval2 = *cbptr++ / 16; #endif /* not HAVE_SIGNED_SHIFT */ - R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; - G1 = gray_clip [yval1 + Cr_g_tab [crval1] + Cb_g_tab [cbval1]]; - B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; - R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; - G2 = gray_clip [yval2 + Cr_g_tab [crval2] + Cb_g_tab [cbval2]]; - B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; - - *dst++ |= (R1 << 16) | (G1 << 24); - *dst++ = B1 | (R2 << 8) | (G2 << 16) | (B2 << 24); - } - } + R1 = gray_clip [yval1 + Cr_r_tab [crval1]]; + G1 = gray_clip [yval1 + Cr_g_tab [crval1] + Cb_g_tab [cbval1]]; + B1 = gray_clip [yval1 + Cb_b_tab [cbval1]]; + R2 = gray_clip [yval2 + Cr_r_tab [crval2]]; + G2 = gray_clip [yval2 + Cr_g_tab [crval2] + Cb_g_tab [cbval2]]; + B2 = gray_clip [yval2 + Cb_b_tab [cbval2]]; + + *dst++ |= (R1 << 16) | (G1 << 24); + *dst++ = B1 | (R2 << 8) | (G2 << 16) | (B2 << 24); + } + } } } else { - unsigned int *dst; /* pointer to dithered pixels */ - word_t *src; /* current pixel of frame */ + unsigned int *dst; /* pointer to dithered pixels */ + word_t *src; /* current pixel of frame */ dst = (unsigned int *) out; src = image->pixels [GRAY]; if (private->double_resolution) { - int x, y; /* pixel counter */ - unsigned *shift_clipping = gray_clip + 128; - - for (y = image->height; y; y--) - { - for (x = image->width >> 1; x; x--) - { - unsigned int val1, val2; + int x, y; /* pixel counter */ + unsigned *shift_clipping = gray_clip + 128; + + for (y = image->height; y; y--) + { + for (x = image->width >> 1; x; x--) + { + unsigned int val1, val2; #ifdef HAVE_SIGNED_SHIFT - val1 = shift_clipping [*src++ >> 4]; - val2 = shift_clipping [*src++ >> 4]; + val1 = shift_clipping [*src++ >> 4]; + val2 = shift_clipping [*src++ >> 4]; #else /* not HAVE_SIGNED_SHIFT */ - val1 = shift_clipping [*src++ / 16]; - val2 = shift_clipping [*src++ / 16]; + val1 = shift_clipping [*src++ / 16]; + val2 = shift_clipping [*src++ / 16]; #endif /* not HAVE_SIGNED_SHIFT */ - *dst++ = val1 | (val1 << 8) | (val1 << 16) | (val1 << 24); - *dst++ = val1 | (val1 << 8) | (val2 << 16) | (val2 << 24); - *dst++ = val2 | (val2 << 8) | (val2 << 16) | (val2 << 24); - } + *dst++ = val1 | (val1 << 8) | (val1 << 16) | (val1 << 24); + *dst++ = val1 | (val1 << 8) | (val2 << 16) | (val2 << 24); + *dst++ = val2 | (val2 << 8) | (val2 << 16) | (val2 << 24); + } - memcpy (dst, dst - 3 * (image->width >> 1), - 3 * (image->width >> 1) * sizeof (unsigned int)); - dst += 3 * (image->width >> 1); - } + memcpy (dst, dst - 3 * (image->width >> 1), + 3 * (image->width >> 1) * sizeof (unsigned int)); + dst += 3 * (image->width >> 1); + } } else { - int n; /* pixel counter */ - unsigned *shift_clipping = gray_clip + 128; + int n; /* pixel counter */ + unsigned *shift_clipping = gray_clip + 128; - for (n = (image->width * image->height) >> 2; n; n--) - { - unsigned int val1, val2; + for (n = (image->width * image->height) >> 2; n; n--) + { + unsigned int val1, val2; #ifdef HAVE_SIGNED_SHIFT - val1 = shift_clipping [*src++ >> 4]; - val2 = shift_clipping [*src++ >> 4]; + val1 = shift_clipping [*src++ >> 4]; + val2 = shift_clipping [*src++ >> 4]; #else /* not HAVE_SIGNED_SHIFT */ - val1 = shift_clipping [*src++ / 16]; - val2 = shift_clipping [*src++ / 16]; + val1 = shift_clipping [*src++ / 16]; + val2 = shift_clipping [*src++ / 16]; #endif /* not HAVE_SIGNED_SHIFT */ - *dst++ = val1 | (val1 << 8) - | (val1 << 16) | (val2 << 24); /* RGBR */ - *dst = val2 | (val2 << 8); /* GB-- */ + *dst++ = val1 | (val1 << 8) + | (val1 << 16) | (val2 << 24); /* RGBR */ + *dst = val2 | (val2 << 8); /* GB-- */ #ifdef HAVE_SIGNED_SHIFT - val1 = shift_clipping [*src++ >> 4]; - val2 = shift_clipping [*src++ >> 4]; + val1 = shift_clipping [*src++ >> 4]; + val2 = shift_clipping [*src++ >> 4]; #else /* not HAVE_SIGNED_SHIFT */ - val1 = shift_clipping [*src++ / 16]; - val2 = shift_clipping [*src++ / 16]; + val1 = shift_clipping [*src++ / 16]; + val2 = shift_clipping [*src++ / 16]; #endif /* not HAVE_SIGNED_SHIFT */ - - *dst++ |= (val1 << 16) | (val1 << 24); /* --RG */ - *dst++ = val1 | (val2 << 8) - | (val2 << 16) | (val2 << 24); /* BRGB */ - } + + *dst++ |= (val1 << 16) | (val1 << 24); /* --RG */ + *dst++ = val1 | (val2 << 8) + | (val2 << 16) | (val2 << 24); /* BRGB */ + } } } - + return 1; } -static int +static int display_32_bit (const struct fiasco_renderer *this, unsigned char *ximage, - const fiasco_image_t *fiasco_image) + const fiasco_image_t *fiasco_image) /* * Convert 'image' to 16 bit color bitmap. * If 'double_resolution' is true then double image size in both directions. @@ -1566,13 +1566,13 @@ display_32_bit (const struct fiasco_renderer *this, unsigned char *ximage, * No return value. * * Side effects: - * 'out[]' is filled with dithered image + * 'out[]' is filled with dithered image */ { const image_t *image; renderer_private_t *private; - byte_t *out; - + byte_t *out; + if (!this) { set_error (_("Parameter `%s' not defined (NULL)."), "this"); @@ -1589,21 +1589,21 @@ display_32_bit (const struct fiasco_renderer *this, unsigned char *ximage, return 0; } - out = (byte_t *) ximage; + out = (byte_t *) ximage; private = (renderer_private_t *) this->private; image = cast_image ((fiasco_image_t *) fiasco_image); if (!image) return 0; - + if (image->color) { - word_t *cbptr, *crptr; /* pointer to chroma bands */ - word_t *yptr; /* pointers to lumincance band */ - int yval, crval, cbval; /* pixel value in YCbCr color space */ - int R, G, B; /* pixel value in RGB color space */ - int n; /* pixel counter */ - int x, y; /* pixel coordinates */ - int *Cr_r_tab, *Cr_g_tab, *Cb_g_tab, *Cb_b_tab; + word_t *cbptr, *crptr; /* pointer to chroma bands */ + word_t *yptr; /* pointers to lumincance band */ + int yval, crval, cbval; /* pixel value in YCbCr color space */ + int R, G, B; /* pixel value in RGB color space */ + int n; /* pixel counter */ + int x, y; /* pixel coordinates */ + int *Cr_r_tab, *Cr_g_tab, *Cb_g_tab, *Cb_b_tab; unsigned int *r_table, *g_table, *b_table; Cr_g_tab = private->Cr_g_tab; @@ -1619,245 +1619,245 @@ display_32_bit (const struct fiasco_renderer *this, unsigned char *ximage, if (image->format == FORMAT_4_2_0) { - unsigned int *dst, *dst2; /* pointers to dithered pixels */ - word_t *yptr2; /* pointers to lumincance band */ - - if (private->double_resolution) - { - yptr2 = yptr + image->width; - dst = (unsigned int *) out; - dst2 = dst + 4 * image->width; - for (y = image->height / 2; y; y--) - { - for (x = image->width / 2; x; x--) - { + unsigned int *dst, *dst2; /* pointers to dithered pixels */ + word_t *yptr2; /* pointers to lumincance band */ + + if (private->double_resolution) + { + yptr2 = yptr + image->width; + dst = (unsigned int *) out; + dst2 = dst + 4 * image->width; + for (y = image->height / 2; y; y--) + { + for (x = image->width / 2; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - crval = *crptr++ >> 4; - cbval = *cbptr++ >> 4; - yval = (*yptr++ >> 4) + 128; + crval = *crptr++ >> 4; + cbval = *cbptr++ >> 4; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - crval = *crptr++ / 16; - cbval = *cbptr++ / 16; - yval = *yptr++ / 16 + 128; + crval = *crptr++ / 16; + cbval = *cbptr++ / 16; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; + #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr++ >> 4) + 128; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr++ / 16 + 128; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr2++ >> 4) + 128; + yval = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr2++ / 16 + 128; + yval = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr2++ >> 4) + 128; + yval = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr2++ / 16 + 128; + yval = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; - } - memcpy (dst, dst - 2 * image->width, - 2 * image->width * sizeof (unsigned int)); - memcpy (dst2, dst2 - 2 * image->width, - 2 * image->width * sizeof (unsigned int)); - yptr += image->width; - yptr2 += image->width; - dst += 3 * image->width * 2; - dst2 += 3 * image->width * 2; - } - } - else - { - yptr2 = yptr + image->width; - dst = (unsigned int *) out; - dst2 = dst + image->width; - - for (y = image->height / 2; y; y--) - { - for (x = image->width / 2; x; x--) - { + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; + } + memcpy (dst, dst - 2 * image->width, + 2 * image->width * sizeof (unsigned int)); + memcpy (dst2, dst2 - 2 * image->width, + 2 * image->width * sizeof (unsigned int)); + yptr += image->width; + yptr2 += image->width; + dst += 3 * image->width * 2; + dst2 += 3 * image->width * 2; + } + } + else + { + yptr2 = yptr + image->width; + dst = (unsigned int *) out; + dst2 = dst + image->width; + + for (y = image->height / 2; y; y--) + { + for (x = image->width / 2; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - crval = *crptr++ >> 4; - cbval = *cbptr++ >> 4; - yval = (*yptr++ >> 4) + 128; + crval = *crptr++ >> 4; + cbval = *cbptr++ >> 4; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - crval = *crptr++ / 16; - cbval = *cbptr++ / 16; - yval = *yptr++ / 16 + 128; + crval = *crptr++ / 16; + cbval = *cbptr++ / 16; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; + #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr++ >> 4) + 128; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr++ / 16 + 128; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr2++ >> 4) + 128; + yval = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr2++ / 16 + 128; + yval = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; #ifdef HAVE_SIGNED_SHIFT - yval = (*yptr2++ >> 4) + 128; + yval = (*yptr2++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - yval = *yptr2++ / 16 + 128; + yval = *yptr2++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - *dst2++ = r_table [R] | g_table [G] | b_table [B]; - } - yptr += image->width; - yptr2 += image->width; - dst += image->width; - dst2 += image->width; - } - } + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + *dst2++ = r_table [R] | g_table [G] | b_table [B]; + } + yptr += image->width; + yptr2 += image->width; + dst += image->width; + dst2 += image->width; + } + } } - else /* 4:4:4 format */ + else /* 4:4:4 format */ { - if (private->double_resolution) - { - unsigned int *dst; /* pointer to dithered pixels */ - - dst = (unsigned int *) out; - - for (y = image->height; y; y--) - { - for (x = image->width; x; x--) - { + if (private->double_resolution) + { + unsigned int *dst; /* pointer to dithered pixels */ + + dst = (unsigned int *) out; + + for (y = image->height; y; y--) + { + for (x = image->width; x; x--) + { #ifdef HAVE_SIGNED_SHIFT - crval = *crptr++ >> 4; - cbval = *cbptr++ >> 4; - yval = (*yptr++ >> 4) + 128; + crval = *crptr++ >> 4; + cbval = *cbptr++ >> 4; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - crval = *crptr++ / 16; - cbval = *cbptr++ / 16; - yval = *yptr++ / 16 + 128; + crval = *crptr++ / 16; + cbval = *cbptr++ / 16; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; - - *dst++ = r_table [R] | g_table [G] | b_table [B]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - } - memcpy (dst, dst - 2 * image->width, - 2 * image->width * sizeof (unsigned int)); - dst += image->width * 2; - } - } - else - { - unsigned int *dst; /* pointer to dithered pixels */ - - dst = (unsigned int *) out; - - for (n = image->width * image->height; n; n--) - { + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; + + *dst++ = r_table [R] | g_table [G] | b_table [B]; + *dst++ = r_table [R] | g_table [G] | b_table [B]; + } + memcpy (dst, dst - 2 * image->width, + 2 * image->width * sizeof (unsigned int)); + dst += image->width * 2; + } + } + else + { + unsigned int *dst; /* pointer to dithered pixels */ + + dst = (unsigned int *) out; + + for (n = image->width * image->height; n; n--) + { #ifdef HAVE_SIGNED_SHIFT - crval = *crptr++ >> 4; - cbval = *cbptr++ >> 4; - yval = (*yptr++ >> 4) + 128; + crval = *crptr++ >> 4; + cbval = *cbptr++ >> 4; + yval = (*yptr++ >> 4) + 128; #else /* not HAVE_SIGNED_SHIFT */ - crval = *crptr++ / 16; - cbval = *cbptr++ / 16; - yval = *yptr++ / 16 + 128; + crval = *crptr++ / 16; + cbval = *cbptr++ / 16; + yval = *yptr++ / 16 + 128; #endif /* not HAVE_SIGNED_SHIFT */ - R = yval + Cr_r_tab [crval]; - G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; - B = yval + Cb_b_tab [cbval]; + R = yval + Cr_r_tab [crval]; + G = yval + Cr_g_tab [crval] + Cb_g_tab [cbval]; + B = yval + Cb_b_tab [cbval]; - *dst++ = r_table [R] | g_table [G] | b_table [B]; - } - } + *dst++ = r_table [R] | g_table [G] | b_table [B]; + } + } } } else { - unsigned int *dst; /* pointer to dithered pixels */ - word_t *src; /* current pixel of frame */ + unsigned int *dst; /* pointer to dithered pixels */ + word_t *src; /* current pixel of frame */ unsigned int *y_table; y_table = private->y_table; dst = (unsigned int *) out; src = image->pixels [GRAY]; - + if (private->double_resolution) { - int x, y; /* pixel coordinates */ - - for (y = image->height; y; y--) - { - for (x = image->width; x; x--) - { - int value; + int x, y; /* pixel coordinates */ + + for (y = image->height; y; y--) + { + for (x = image->width; x; x--) + { + int value; #ifdef HAVE_SIGNED_SHIFT - value = y_table [*src++ >> 4]; + value = y_table [*src++ >> 4]; #else /* not HAVE_SIGNED_SHIFT */ - value = y_table [*src++ / 16]; + value = y_table [*src++ / 16]; #endif /* not HAVE_SIGNED_SHIFT */ - *dst++ = value; - *dst++ = value; - } - - memcpy (dst, dst - 2 * image->width, - 2 * image->width * sizeof (unsigned int)); - dst += 2 * image->width; - } + *dst++ = value; + *dst++ = value; + } + + memcpy (dst, dst - 2 * image->width, + 2 * image->width * sizeof (unsigned int)); + dst += 2 * image->width; + } } else { - int n; /* pixel counter */ - - for (n = image->width * image->height; n; n--) + int n; /* pixel counter */ + + for (n = image->width * image->height; n; n--) #ifdef HAVE_SIGNED_SHIFT - *dst++ = y_table [*src++ >> 4]; + *dst++ = y_table [*src++ >> 4]; #else /* not HAVE_SIGNED_SHIFT */ - *dst++ = y_table [*src++ / 16]; + *dst++ = y_table [*src++ / 16]; #endif /* not HAVE_SIGNED_SHIFT */ } } - + return 1; } - + |