/* The GIMP -- an image manipulation program * Copyright (C) 1995 Spencer Kimball and Peter Mattis * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include #include #include "appenv.h" #include "gimprc.h" #include "paint_funcs.h" #include "boundary.h" #define STD_BUF_SIZE 1021 #define MAXDIFF 195076 #define HASH_TABLE_SIZE 1021 #define RANDOM_TABLE_SIZE 4096 #define RANDOM_SEED 314159265 #define EPSILON 0.0001 #define INT_MULT(a,b,t) ((t) = (a) * (b) + 0x80, ((((t) >> 8) + (t)) >> 8)) typedef enum { MinifyX_MinifyY, MinifyX_MagnifyY, MagnifyX_MinifyY, MagnifyX_MagnifyY } ScaleType; /* Layer modes information */ typedef struct _LayerMode LayerMode; struct _LayerMode { int affect_alpha; /* does the layer mode affect the alpha channel */ char *name; /* layer mode specification */ }; LayerMode layer_modes[] = { { 1, "Normal" }, { 1, "Dissolve" }, { 1, "Behind" }, { 0, "Multiply (Burn)" }, { 0, "Screen" }, { 0, "Overlay" }, { 0, "Difference" }, { 0, "Addition" }, { 0, "Subtraction" }, { 0, "Darken Only" }, { 0, "Lighten Only" }, { 0, "Hue" }, { 0, "Saturation" }, { 0, "Color" }, { 0, "Value" }, { 0, "Divide (Dodge)" }, { 1, "Erase" }, { 1, "Replace" } }; /* ColorHash structure */ typedef struct _ColorHash ColorHash; struct _ColorHash { int pixel; /* R << 16 | G << 8 | B */ int index; /* colormap index */ int colormap_ID; /* colormap ID */ }; static ColorHash color_hash_table [HASH_TABLE_SIZE]; static int random_table [RANDOM_TABLE_SIZE]; static int color_hash_misses; static int color_hash_hits; static unsigned char * tmp_buffer; /* temporary buffer available upon request */ static int tmp_buffer_size; static unsigned char no_mask = OPAQUE_OPACITY; /*******************************/ /* Local function prototypes */ static int * make_curve (double, int *); static void run_length_encode (unsigned char *, int *, int, int); static void draw_segments (PixelRegion *, BoundSeg *, int, int, int, int); static double cubic (double, int, int, int, int); static void apply_layer_mode_replace (unsigned char *, unsigned char *, unsigned char *, unsigned char *, int, int, int, int, int, int, int *); static unsigned char * paint_funcs_get_buffer (int size) { if (size > tmp_buffer_size) { tmp_buffer_size = size; tmp_buffer = (unsigned char *) g_realloc (tmp_buffer, size); } return tmp_buffer; } /* * The equations: g(r) = exp (- r^2 / (2 * sigma^2)) * r = sqrt (x^2 + y ^2) */ static int * make_curve (double sigma, int *length) { int *curve; double sigma2; double l; int temp; int i, n; sigma2 = 2 * sigma * sigma; l = sqrt (-sigma2 * log (1.0 / 255.0)); n = ceil (l) * 2; if ((n % 2) == 0) n += 1; curve = g_malloc (sizeof (int) * n); *length = n / 2; curve += *length; curve[0] = 255; for (i = 1; i <= *length; i++) { temp = (int) (exp (- (i * i) / sigma2) * 255); curve[-i] = temp; curve[i] = temp; } return curve; } static void run_length_encode (unsigned char *src, int *dest, int w, int bytes) { int start; int i; int j; unsigned char last; last = *src; src += bytes; start = 0; for (i = 1; i < w; i++) { if (*src != last) { for (j = start; j < i; j++) { *dest++ = (i - j); *dest++ = last; } start = i; last = *src; } src += bytes; } for (j = start; j < i; j++) { *dest++ = (i - j); *dest++ = last; } } static void draw_segments (PixelRegion *destPR, BoundSeg *bs, int num_segs, int off_x, int off_y, int opacity) { int x1, y1, x2, y2; int tmp, i, length; unsigned char *line; length = MAXIMUM (destPR->w, destPR->h); line = paint_funcs_get_buffer (length); memset (line, opacity, length); for (i = 0; i < num_segs; i++) { x1 = bs[i].x1 + off_x; y1 = bs[i].y1 + off_y; x2 = bs[i].x2 + off_x; y2 = bs[i].y2 + off_y; if (bs[i].open == 0) { /* If it is vertical */ if (x1 == x2) { x1 -= 1; x2 -= 1; } else { y1 -= 1; y2 -= 1; } } /* render segment */ x1 = BOUNDS (x1, 0, destPR->w - 1); y1 = BOUNDS (y1, 0, destPR->h - 1); x2 = BOUNDS (x2, 0, destPR->w - 1); y2 = BOUNDS (y2, 0, destPR->h - 1); if (x1 == x2) { if (y2 < y1) { tmp = y1; y1 = y2; y2 = tmp; } pixel_region_set_col (destPR, x1, y1, (y2 - y1), line); } else { if (x2 < x1) { tmp = x1; x1 = x2; x2 = tmp; } pixel_region_set_row (destPR, x1, y1, (x2 - x1), line); } } } static double cubic (double dx, int jm1, int j, int jp1, int jp2) { double dx1, dx2, dx3; double h1, h2, h3, h4; double result; /* constraint parameter = -1 */ dx1 = fabs (dx); dx2 = dx1 * dx1; dx3 = dx2 * dx1; h1 = dx3 - 2 * dx2 + 1; result = h1 * j; dx1 = fabs (dx - 1.0); dx2 = dx1 * dx1; dx3 = dx2 * dx1; h2 = dx3 - 2 * dx2 + 1; result += h2 * jp1; dx1 = fabs (dx - 2.0); dx2 = dx1 * dx1; dx3 = dx2 * dx1; h3 = -dx3 + 5 * dx2 - 8 * dx1 + 4; result += h3 * jp2; dx1 = fabs (dx + 1.0); dx2 = dx1 * dx1; dx3 = dx2 * dx1; h4 = -dx3 + 5 * dx2 - 8 * dx1 + 4; result += h4 * jm1; if (result < 0.0) result = 0.0; if (result > 255.0) result = 255.0; return result; } /*********************/ /* FUNCTIONS */ /*********************/ void paint_funcs_setup () { int i; /* allocate the temporary buffer */ tmp_buffer = (unsigned char *) g_malloc (STD_BUF_SIZE); tmp_buffer_size = STD_BUF_SIZE; /* initialize the color hash table--invalidate all entries */ for (i = 0; i < HASH_TABLE_SIZE; i++) color_hash_table[i].colormap_ID = -1; color_hash_misses = 0; color_hash_hits = 0; /* generate a table of random seeds */ srand (RANDOM_SEED); for (i = 0; i < RANDOM_TABLE_SIZE; i++) random_table[i] = rand (); for (i = 0; i < RANDOM_TABLE_SIZE; i++) { int tmp; int swap = i + rand () % (RANDOM_TABLE_SIZE - i); tmp = random_table[i]; random_table[i] = random_table[swap]; random_table[swap] = tmp; } } void paint_funcs_free () { /* free the temporary buffer */ g_free (tmp_buffer); /* print out the hash table statistics printf ("RGB->indexed hash table lookups: %d\n", color_hash_hits + color_hash_misses); printf ("RGB->indexed hash table hits: %d\n", color_hash_hits); printf ("RGB->indexed hash table misses: %d\n", color_hash_misses); printf ("RGB->indexed hash table hit rate: %f\n", 100.0 * color_hash_hits / (color_hash_hits + color_hash_misses)); */ } void color_pixels (unsigned char *dest, unsigned char *color, int w, int bytes) { int b; while (w--) { for (b = 0; b < bytes; b++) dest[b] = color[b]; dest += bytes; } } void blend_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, int blend, int w, int bytes, int has_alpha) { int alpha, b; unsigned char blend2 = (255 - blend); alpha = (has_alpha) ? bytes - 1 : bytes; while (w --) { for (b = 0; b < alpha; b++) dest[b] = (src1[b] * blend2 + src2[b] * blend) / 255; if (has_alpha) dest[alpha] = src1[alpha]; /* alpha channel--assume src2 has none */ src1 += bytes; src2 += bytes; dest += bytes; } } void shade_pixels (unsigned char *src, unsigned char *dest, unsigned char *col, int blend, int w, int bytes, int has_alpha) { int alpha, b; unsigned char blend2 = (255 - blend); alpha = (has_alpha) ? bytes - 1 : bytes; while (w --) { for (b = 0; b < alpha; b++) dest[b] = (src[b] * blend2 + col[b] * blend) / 255; if (has_alpha) dest[alpha] = src[alpha]; /* alpha channel */ src += bytes; dest += bytes; } } void extract_alpha_pixels (unsigned char *src, unsigned char *mask, unsigned char *dest, int w, int bytes) { int alpha; unsigned char * m; if (mask) m = mask; else m = &no_mask; alpha = bytes - 1; while (w --) { *dest++ = (src[alpha] * *m) / 255; if (mask) m++; src += bytes; } } void darken_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, int length, int b1, int b2, int ha1, int ha2) { int b, alpha; unsigned char s1, s2; alpha = (ha1 || ha2) ? MAXIMUM (b1, b2) - 1 : b1; while (length--) { for (b = 0; b < alpha; b++) { s1 = src1[b]; s2 = src2[b]; dest[b] = (s1 < s2) ? s1 : s2; } if (ha1 && ha2) dest[alpha] = MIN (src1[alpha], src2[alpha]); else if (ha2) dest[alpha] = src2[alpha]; src1 += b1; src2 += b2; dest += b2; } } void lighten_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, int length, int b1, int b2, int ha1, int ha2) { int b, alpha; unsigned char s1, s2; alpha = (ha1 || ha2) ? MAXIMUM (b1, b2) - 1 : b1; while (length--) { for (b = 0; b < alpha; b++) { s1 = src1[b]; s2 = src2[b]; dest[b] = (s1 < s2) ? s2 : s1; } if (ha1 && ha2) dest[alpha] = MIN (src1[alpha], src2[alpha]); else if (ha2) dest[alpha] = src2[alpha]; src1 += b1; src2 += b2; dest += b2; } } void hsv_only_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, int mode, int length, int bytes1, int bytes2, int ha1, int ha2) { int r1, g1, b1; int r2, g2, b2; /* assumes inputs are only 4 byte RGBA pixels */ while (length--) { r1 = src1[0]; g1 = src1[1]; b1 = src1[2]; r2 = src2[0]; g2 = src2[1]; b2 = src2[2]; rgb_to_hsv (&r1, &g1, &b1); rgb_to_hsv (&r2, &g2, &b2); switch (mode) { case HUE_MODE: r1 = r2; break; case SATURATION_MODE: g1 = g2; break; case VALUE_MODE: b1 = b2; break; } /* set the destination */ hsv_to_rgb (&r1, &g1, &b1); dest[0] = r1; dest[1] = g1; dest[2] = b1; if (ha1 && ha2) dest[3] = MIN (src1[3], src2[3]); else if (ha2) dest[3] = src2[3]; src1 += bytes1; src2 += bytes2; dest += bytes2; } } void color_only_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, int mode, int length, int bytes1, int bytes2, int ha1, int ha2) { int r1, g1, b1; int r2, g2, b2; /* assumes inputs are only 4 byte RGBA pixels */ while (length--) { r1 = src1[0]; g1 = src1[1]; b1 = src1[2]; r2 = src2[0]; g2 = src2[1]; b2 = src2[2]; rgb_to_hls (&r1, &g1, &b1); rgb_to_hls (&r2, &g2, &b2); /* transfer hue and saturation to the source pixel */ r1 = r2; b1 = b2; /* set the destination */ hls_to_rgb (&r1, &g1, &b1); dest[0] = r1; dest[1] = g1; dest[2] = b1; if (ha1 && ha2) dest[3] = MIN (src1[3], src2[3]); else if (ha2) dest[3] = src2[3]; src1 += bytes1; src2 += bytes2; dest += bytes2; } } void multiply_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, int length, int b1, int b2, int ha1, int ha2) { int alpha, b; alpha = (ha1 || ha2) ? MAXIMUM (b1, b2) - 1 : b1; while (length --) { for (b = 0; b < alpha; b++) dest[b] = (src1[b] * src2[b]) / 255; if (ha1 && ha2) dest[alpha] = MIN (src1[alpha], src2[alpha]); else if (ha2) dest[alpha] = src2[alpha]; src1 += b1; src2 += b2; dest += b2; } } void divide_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, int length, int b1, int b2, int ha1, int ha2) { int alpha, b, result; alpha = (ha1 || ha2) ? MAXIMUM (b1, b2) - 1 : b1; while (length --) { for (b = 0; b < alpha; b++) { result = ((src1[b] * 256) / (1+src2[b])); dest[b] = (result > 255) ? 255 : result; } if (ha1 && ha2) dest[alpha] = MIN (src1[alpha], src2[alpha]); else if (ha2) dest[alpha] = src2[alpha]; src1 += b1; src2 += b2; dest += b2; } } void screen_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, int length, int b1, int b2, int ha1, int ha2) { int alpha, b; alpha = (ha1 || ha2) ? MAXIMUM (b1, b2) - 1 : b1; while (length --) { for (b = 0; b < alpha; b++) dest[b] = 255 - ((255 - src1[b]) * (255 - src2[b])) / 255; if (ha1 && ha2) dest[alpha] = MIN (src1[alpha], src2[alpha]); else if (ha2) dest[alpha] = src2[alpha]; src1 += b1; src2 += b2; dest += b2; } } void overlay_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, int length, int b1, int b2, int ha1, int ha2) { int alpha, b; int screen, mult; alpha = (ha1 || ha2) ? MAXIMUM (b1, b2) - 1 : b1; while (length --) { for (b = 0; b < alpha; b++) { screen = 255 - ((255 - src1[b]) * (255 - src2[b])) / 255; mult = (src1[b] * src2[b]) / 255; dest[b] = (screen * src1[b] + mult * (255 - src1[b])) / 255; } if (ha1 && ha2) dest[alpha] = MIN (src1[alpha], src2[alpha]); else if (ha2) dest[alpha] = src2[alpha]; src1 += b1; src2 += b2; dest += b2; } } void add_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, int length, int b1, int b2, int ha1, int ha2) { int alpha, b; int sum; alpha = (ha1 || ha2) ? MAXIMUM (b1, b2) - 1 : b1; while (length --) { for (b = 0; b < alpha; b++) { sum = src1[b] + src2[b]; dest[b] = (sum > 255) ? 255 : sum; } if (ha1 && ha2) dest[alpha] = MIN (src1[alpha], src2[alpha]); else if (ha2) dest[alpha] = src2[alpha]; src1 += b1; src2 += b2; dest += b2; } } void subtract_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, int length, int b1, int b2, int ha1, int ha2) { int alpha, b; int diff; alpha = (ha1 || ha2) ? MAXIMUM (b1, b2) - 1 : b1; while (length --) { for (b = 0; b < alpha; b++) { diff = src1[b] - src2[b]; dest[b] = (diff < 0) ? 0 : diff; } if (ha1 && ha2) dest[alpha] = MIN (src1[alpha], src2[alpha]); else if (ha2) dest[alpha] = src2[alpha]; src1 += b1; src2 += b2; dest += b2; } } void difference_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, int length, int b1, int b2, int ha1, int ha2) { int alpha, b; int diff; alpha = (ha1 || ha2) ? MAXIMUM (b1, b2) - 1 : b1; while (length --) { for (b = 0; b < alpha; b++) { diff = src1[b] - src2[b]; dest[b] = (diff < 0) ? -diff : diff; } if (ha1 && ha2) dest[alpha] = MIN (src1[alpha], src2[alpha]); else if (ha2) dest[alpha] = src2[alpha]; src1 += b1; src2 += b2; dest += b2; } } void dissolve_pixels (unsigned char *src, unsigned char *dest, int x, int y, int opacity, int length, int sb, int db, int has_alpha) { int alpha, b; int rand_val; /* Set up the random number generator */ srand (random_table [y % RANDOM_TABLE_SIZE]); for (b = 0; b < x; b++) rand (); alpha = db - 1; while (length --) { /* preserve the intensity values */ for (b = 0; b < alpha; b++) dest[b] = src[b]; /* dissolve if random value is > opacity */ rand_val = (rand() & 0xFF); if (has_alpha) dest[alpha] = (rand_val > opacity) ? 0 : src[alpha]; else dest[alpha] = (rand_val > opacity) ? 0 : OPAQUE_OPACITY; dest += db; src += sb; } } void replace_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, unsigned char *mask, int length, int opacity, int *affect, int b1, int b2) { int alpha; int b; double a_val, a_recip, mask_val; double norm_opacity; int s1_a, s2_a; int new_val; if (b1 != b2) { g_message ("replace_pixels only works on commensurate pixel regions"); return; } alpha = b1 - 1; norm_opacity = opacity * (1.0 / 65025.0); while (length --) { mask_val = mask[0] * norm_opacity; /* calculate new alpha first. */ s1_a = src1[alpha]; s2_a = src2[alpha]; a_val = s1_a + mask_val * (s2_a - s1_a); if (a_val == 0) a_recip = 0; else a_recip = 1.0 / a_val; /* possible optimization: fold a_recip into s1_a and s2_a */ for (b = 0; b < alpha; b++) { new_val = 0.5 + a_recip * (src1[b] * s1_a + mask_val * (src2[b] * s2_a - src1[b] * s1_a)); dest[b] = affect[b] ? MIN (new_val, 255) : src1[b]; } dest[alpha] = affect[alpha] ? a_val + 0.5: s1_a; src1 += b1; src2 += b2; dest += b2; mask++; } } void swap_pixels (unsigned char *src, unsigned char *dest, int length) { while (length--) { *src = *src ^ *dest; *dest = *dest ^ *src; *src = *src ^ *dest; src++; dest++; } } void scale_pixels (unsigned char *src, unsigned char *dest, int length, int scale) { while (length --) *dest++ = (unsigned char) ((*src++ * scale) / 255); } void add_alpha_pixels (unsigned char *src, unsigned char *dest, int length, int bytes) { int alpha, b; alpha = bytes + 1; while (length --) { for (b = 0; b < bytes; b++) dest[b] = src[b]; dest[b] = OPAQUE_OPACITY; src += bytes; dest += alpha; } } void flatten_pixels (unsigned char *src, unsigned char *dest, unsigned char *bg, int length, int bytes) { int alpha, b; int t1, t2; alpha = bytes - 1; while (length --) { for (b = 0; b < alpha; b++) dest[b] = INT_MULT (src[b], src[alpha], t1) + INT_MULT (bg[b], (255 - src[alpha]), t2); src += bytes; dest += alpha; } } void gray_to_rgb_pixels (unsigned char *src, unsigned char *dest, int length, int bytes) { int b; int dest_bytes; int has_alpha; has_alpha = (bytes == 2) ? 1 : 0; dest_bytes = (has_alpha) ? 4 : 3; while (length --) { for (b = 0; b < bytes; b++) dest[b] = src[0]; if (has_alpha) dest[3] = src[1]; src += bytes; dest += dest_bytes; } } void apply_mask_to_alpha_channel (unsigned char *src, unsigned char *mask, int opacity, int length, int bytes) { int alpha; alpha = bytes - 1; while (length --) { src[alpha] = (src[alpha] * *mask++ * opacity) / 65025; src += bytes; } } void combine_mask_and_alpha_channel (unsigned char *src, unsigned char *mask, int opacity, int length, int bytes) { unsigned char mask_val; int alpha; alpha = bytes - 1; while (length --) { mask_val = (*mask++ * opacity) / 255; src[alpha] = src[alpha] + ((255 - src[alpha]) * mask_val) / 255; src += bytes; } } void copy_gray_to_inten_a_pixels (unsigned char *src, unsigned char *dest, int length, int bytes) { int b; int alpha; alpha = bytes - 1; while (length --) { for (b = 0; b < alpha; b++) dest[b] = *src; dest[b] = OPAQUE_OPACITY; src ++; dest += bytes; } } void initial_channel_pixels (unsigned char *src, unsigned char *dest, int length, int bytes) { int alpha, b; alpha = bytes - 1; while (length --) { for (b = 0; b < alpha; b++) dest[b] = src[0]; dest[alpha] = OPAQUE_OPACITY; dest += bytes; src ++; } } void initial_indexed_pixels (unsigned char *src, unsigned char *dest, unsigned char *cmap, int length) { int col_index; /* This function assumes always that we're mapping from * an RGB colormap to an RGBA image... */ while (length--) { col_index = *src++ * 3; *dest++ = cmap[col_index++]; *dest++ = cmap[col_index++]; *dest++ = cmap[col_index++]; *dest++ = OPAQUE_OPACITY; } } void initial_indexed_a_pixels (unsigned char *src, unsigned char *dest, unsigned char *mask, unsigned char *cmap, int opacity, int length) { int col_index; unsigned char new_alpha; unsigned char * m; if (mask) m = mask; else m = &no_mask; while (length --) { col_index = *src++ * 3; new_alpha = (*src++ * *m * opacity) / 65025; *dest++ = cmap[col_index++]; *dest++ = cmap[col_index++]; *dest++ = cmap[col_index++]; /* Set the alpha channel */ *dest++ = (new_alpha > 127) ? OPAQUE_OPACITY : TRANSPARENT_OPACITY; if (mask) m++; } } void initial_inten_pixels (unsigned char *src, unsigned char *dest, unsigned char *mask, int opacity, int *affect, int length, int bytes) { int b, dest_bytes; unsigned char * m; if (mask) m = mask; else m = &no_mask; /* This function assumes the source has no alpha channel and * the destination has an alpha channel. So dest_bytes = bytes + 1 */ dest_bytes = bytes + 1; if (mask) { while (length --) { for (b = 0; b < bytes; b++) dest [b] = affect [b] ? src [b] : 0; /* Set the alpha channel */ dest[b] = affect [b] ? (opacity * *m) / 255 : 0; m++; dest += dest_bytes; src += bytes; } } else { while (length --) { for (b = 0; b < bytes; b++) dest [b] = affect [b] ? src [b] : 0; /* Set the alpha channel */ dest[b] = affect [b] ? opacity : 0; dest += dest_bytes; src += bytes; } } } void initial_inten_a_pixels (unsigned char *src, unsigned char *dest, unsigned char *mask, int opacity, int *affect, int length, int bytes) { int alpha, b; unsigned char * m; alpha = bytes - 1; if (mask) { m = mask; while (length --) { for (b = 0; b < alpha; b++) dest[b] = src[b] * affect[b]; /* Set the alpha channel */ dest[alpha] = affect [alpha] ? (opacity * src[alpha] * *m) / 65025 : 0; m++; dest += bytes; src += bytes; } } else { while (length --) { for (b = 0; b < alpha; b++) dest[b] = src[b] * affect[b]; /* Set the alpha channel */ dest[alpha] = affect [alpha] ? (opacity * src[alpha]) / 255 : 0; dest += bytes; src += bytes; } } } void combine_indexed_and_indexed_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, unsigned char *mask, int opacity, int *affect, int length, int bytes) { int b; unsigned char new_alpha; unsigned char * m; if (mask) { m = mask; while (length --) { new_alpha = (*m * opacity) / 255; for (b = 0; b < bytes; b++) dest[b] = (affect[b] && new_alpha > 127) ? src2[b] : src1[b]; m++; src1 += bytes; src2 += bytes; dest += bytes; } } else { while (length --) { new_alpha = opacity; for (b = 0; b < bytes; b++) dest[b] = (affect[b] && new_alpha > 127) ? src2[b] : src1[b]; src1 += bytes; src2 += bytes; dest += bytes; } } } void combine_indexed_and_indexed_a_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, unsigned char *mask, int opacity, int *affect, int length, int bytes) { int b, alpha; unsigned char new_alpha; unsigned char * m; int src2_bytes; alpha = 1; src2_bytes = 2; if (mask) { m = mask; while (length --) { new_alpha = (src2[alpha] * *m * opacity) / 65025; for (b = 0; b < bytes; b++) dest[b] = (affect[b] && new_alpha > 127) ? src2[b] : src1[b]; m++; src1 += bytes; src2 += src2_bytes; dest += bytes; } } else { while (length --) { new_alpha = (src2[alpha] * opacity) / 255; for (b = 0; b < bytes; b++) dest[b] = (affect[b] && new_alpha > 127) ? src2[b] : src1[b]; src1 += bytes; src2 += src2_bytes; dest += bytes; } } } void combine_indexed_a_and_indexed_a_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, unsigned char *mask, int opacity, int *affect, int length, int bytes) { int b, alpha; unsigned char new_alpha; unsigned char * m; alpha = 1; if (mask) { m = mask; while (length --) { new_alpha = (src2[alpha] * *m * opacity) / 65025; for (b = 0; b < alpha; b++) dest[b] = (affect[b] && new_alpha > 127) ? src2[b] : src1[b]; dest[alpha] = (affect[alpha] && new_alpha > 127) ? OPAQUE_OPACITY : src1[alpha]; m++; src1 += bytes; src2 += bytes; dest += bytes; } } else { while (length --) { new_alpha = (src2[alpha] * opacity) / 255; for (b = 0; b < alpha; b++) dest[b] = (affect[b] && new_alpha > 127) ? src2[b] : src1[b]; dest[alpha] = (affect[alpha] && new_alpha > 127) ? OPAQUE_OPACITY : src1[alpha]; src1 += bytes; src2 += bytes; dest += bytes; } } } void combine_inten_a_and_indexed_a_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, unsigned char *mask, unsigned char *cmap, int opacity, int length, int bytes) { int b, alpha; unsigned char new_alpha; int src2_bytes; int index; alpha = 1; src2_bytes = 2; if (mask) { unsigned char *m = mask; while (length --) { new_alpha = (src2[alpha] * *m * opacity) / 65025; index = src2[0] * 3; for (b = 0; b < bytes-1; b++) dest[b] = (new_alpha > 127) ? cmap[index + b] : src1[b]; dest[b] = (new_alpha > 127) ? OPAQUE_OPACITY : src1[b]; /* alpha channel is opaque */ m++; src1 += bytes; src2 += src2_bytes; dest += bytes; } } else { while (length --) { new_alpha = (src2[alpha] * opacity) / 255; index = src2[0] * 3; for (b = 0; b < bytes-1; b++) dest[b] = (new_alpha > 127) ? cmap[index + b] : src1[b]; dest[b] = (new_alpha > 127) ? OPAQUE_OPACITY : src1[b]; /* alpha channel is opaque */ /* m++; /Per */ src1 += bytes; src2 += src2_bytes; dest += bytes; } } } void combine_inten_and_inten_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, unsigned char *mask, int opacity, int *affect, int length, int bytes) { int b; unsigned char new_alpha; unsigned char * m; if (mask) { m = mask; while (length --) { new_alpha = (*m * opacity) / 255; for (b = 0; b < bytes; b++) dest[b] = (affect[b]) ? (src2[b] * new_alpha + src1[b] * (255 - new_alpha)) / 255 : src1[b]; m++; src1 += bytes; src2 += bytes; dest += bytes; } } else { while (length --) { new_alpha = opacity; for (b = 0; b < bytes; b++) dest[b] = (affect[b]) ? (src2[b] * new_alpha + src1[b] * (255 - new_alpha)) / 255 : src1[b]; src1 += bytes; src2 += bytes; dest += bytes; } } } void combine_inten_and_inten_a_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, unsigned char *mask, int opacity, int *affect, int length, int bytes) { int alpha, b; int src2_bytes; unsigned char new_alpha; unsigned char * m; alpha = bytes; src2_bytes = bytes + 1; if (mask) { m = mask; while (length --) { new_alpha = (src2[alpha] * *m * opacity) / 65025; for (b = 0; b < bytes; b++) dest[b] = (affect[b]) ? (src2[b] * new_alpha + src1[b] * (255 - new_alpha)) / 255 : src1[b]; m++; src1 += bytes; src2 += src2_bytes; dest += bytes; } } else { while (length --) { new_alpha = (src2[alpha] * opacity) / 255; for (b = 0; b < bytes; b++) dest[b] = (affect[b]) ? (src2[b] * new_alpha + src1[b] * (255 - new_alpha)) / 255 : src1[b]; src1 += bytes; src2 += src2_bytes; dest += bytes; } } } #define alphify(src2_alpha,new_alpha) \ if (new_alpha == 0 || src2_alpha == 0) \ { \ for (b = 0; b < alpha; b++) \ dest[b] = src1 [b]; \ } \ else if (src2_alpha == new_alpha){ \ for (b = 0; b < alpha; b++) \ dest [b] = affect [b] ? src2 [b] : src1 [b]; \ } else { \ ratio = (float) src2_alpha / new_alpha; \ compl_ratio = 1.0 - ratio; \ \ for (b = 0; b < alpha; b++) \ dest[b] = affect[b] ? \ (unsigned char) (src2[b] * ratio + src1[b] * compl_ratio + EPSILON) : src1[b]; \ } void combine_inten_a_and_inten_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, unsigned char *mask, int opacity, int *affect, int mode_affect, /* how does the combination mode affect alpha? */ int length, int bytes) /* 4 or 2 depending on RGBA or GRAYA */ { int alpha, b; int src2_bytes; unsigned char src2_alpha; unsigned char new_alpha; unsigned char * m; float ratio, compl_ratio; src2_bytes = bytes - 1; alpha = bytes - 1; if (mask) { m = mask; while (length --) { src2_alpha = (*m * opacity) / 255; new_alpha = src1[alpha] + ((255 - src1[alpha]) * src2_alpha) / 255; alphify (src2_alpha, new_alpha); if (mode_affect) dest[alpha] = (affect[alpha]) ? new_alpha : src1[alpha]; else dest[alpha] = (src1[alpha]) ? src1[alpha] : (affect[alpha] ? new_alpha : src1[alpha]); m++; src1 += bytes; src2 += src2_bytes; dest += bytes; } } else { while (length --) { src2_alpha = opacity; new_alpha = src1[alpha] + ((255 - src1[alpha]) * src2_alpha) / 255; alphify (src2_alpha, new_alpha); if (mode_affect) dest[alpha] = (affect[alpha]) ? new_alpha : src1[alpha]; else dest[alpha] = (src1[alpha]) ? src1[alpha] : (affect[alpha] ? new_alpha : src1[alpha]); src1 += bytes; src2 += src2_bytes; dest += bytes; } } } void combine_inten_a_and_inten_a_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, unsigned char *mask, int opacity, int *affect, int mode_affect, /* how does the combination mode affect alpha? */ int length, int bytes) /* 4 or 2 depending on RGBA or GRAYA */ { int alpha, b; unsigned char src2_alpha; unsigned char new_alpha; unsigned char * m; float ratio, compl_ratio; alpha = bytes - 1; if (mask){ m = mask; while (length --) { src2_alpha = (src2[alpha] * *m * opacity) / 65025; new_alpha = src1[alpha] + ((255 - src1[alpha]) * src2_alpha) / 255; alphify (src2_alpha, new_alpha); if (mode_affect) dest[alpha] = (affect[alpha]) ? new_alpha : src1[alpha]; else dest[alpha] = (src1[alpha]) ? src1[alpha] : (affect[alpha] ? new_alpha : src1[alpha]); m++; src1 += bytes; src2 += bytes; dest += bytes; } } else { while (length --) { src2_alpha = (src2[alpha] * opacity) / 255; new_alpha = src1[alpha] + ((255 - src1[alpha]) * src2_alpha) / 255; alphify (src2_alpha, new_alpha); if (mode_affect) dest[alpha] = (affect[alpha]) ? new_alpha : src1[alpha]; else dest[alpha] = (src1[alpha]) ? src1[alpha] : (affect[alpha] ? new_alpha : src1[alpha]); src1 += bytes; src2 += bytes; dest += bytes; } } } #undef alphify void combine_inten_a_and_channel_mask_pixels (unsigned char *src, unsigned char *channel, unsigned char *dest, unsigned char *col, int opacity, int length, int bytes) { int alpha, b; unsigned char channel_alpha; unsigned char new_alpha; unsigned char compl_alpha; int t, s; alpha = bytes - 1; while (length --) { channel_alpha = INT_MULT (255 - *channel, opacity, t); if (channel_alpha) { new_alpha = src[alpha] + INT_MULT ((255 - src[alpha]), channel_alpha, t); if (new_alpha != 255) channel_alpha = (channel_alpha * 255) / new_alpha; compl_alpha = 255 - channel_alpha; for (b = 0; b < alpha; b++) dest[b] = INT_MULT (col[b], channel_alpha, t) + INT_MULT (src[b], compl_alpha, s); dest[b] = new_alpha; } else memcpy(dest, src, bytes); /* advance pointers */ src+=bytes; dest+=bytes; channel++; } } void combine_inten_a_and_channel_selection_pixels (unsigned char *src, unsigned char *channel, unsigned char *dest, unsigned char *col, int opacity, int length, int bytes) { int alpha, b; unsigned char channel_alpha; unsigned char new_alpha; unsigned char compl_alpha; int t, s; alpha = bytes - 1; while (length --) { channel_alpha = INT_MULT (*channel, opacity, t); if (channel_alpha) { new_alpha = src[alpha] + INT_MULT ((255 - src[alpha]), channel_alpha, t); if (new_alpha != 255) channel_alpha = (channel_alpha * 255) / new_alpha; compl_alpha = 255 - channel_alpha; for (b = 0; b < alpha; b++) dest[b] = INT_MULT (col[b], channel_alpha, t) + INT_MULT (src[b], compl_alpha, s); dest[b] = new_alpha; } else memcpy(dest, src, bytes); /* advance pointers */ src+=bytes; dest+=bytes; channel++; } } void behind_inten_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, unsigned char *mask, int opacity, int *affect, int length, int b1, int b2, int ha1, int ha2) { int alpha, b; unsigned char src1_alpha; unsigned char src2_alpha; unsigned char new_alpha; unsigned char * m; float ratio, compl_ratio; if (mask) m = mask; else m = &no_mask; /* the alpha channel */ alpha = b1 - 1; while (length --) { src1_alpha = src1[alpha]; src2_alpha = (src2[alpha] * *m * opacity) / 65025; new_alpha = src2_alpha + ((255 - src2_alpha) * src1_alpha) / 255; if (new_alpha) ratio = (float) src1_alpha / new_alpha; else ratio = 0.0; compl_ratio = 1.0 - ratio; for (b = 0; b < alpha; b++) dest[b] = (affect[b]) ? (unsigned char) (src1[b] * ratio + src2[b] * compl_ratio + EPSILON) : src1[b]; dest[alpha] = (affect[alpha]) ? new_alpha : src1[alpha]; if (mask) m++; src1 += b1; src2 += b2; dest += b1; } } void behind_indexed_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, unsigned char *mask, int opacity, int *affect, int length, int b1, int b2, int ha1, int ha2) { int alpha, b; unsigned char src1_alpha; unsigned char src2_alpha; unsigned char new_alpha; unsigned char * m; if (mask) m = mask; else m = &no_mask; /* the alpha channel */ alpha = b1 - 1; while (length --) { src1_alpha = src1[alpha]; src2_alpha = (src2[alpha] * *m * opacity) / 65025; new_alpha = (src2_alpha > 127) ? OPAQUE_OPACITY : TRANSPARENT_OPACITY; for (b = 0; b < b1; b++) dest[b] = (affect[b] && new_alpha == OPAQUE_OPACITY && (src1_alpha > 127)) ? src2[b] : src1[b]; if (mask) m++; src1 += b1; src2 += b2; dest += b1; } } void replace_inten_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, unsigned char *mask, int opacity, int *affect, int length, int b1, int b2, int ha1, int ha2) { int bytes, b; unsigned char mask_alpha; unsigned char * m; if (mask) m = mask; else m = &no_mask; bytes = MINIMUM (b1, b2); while (length --) { mask_alpha = (*m * opacity) / 255; for (b = 0; b < bytes; b++) dest[b] = (affect[b]) ? (src2[b] * mask_alpha + src1[b] * (255 - mask_alpha)) / 255 : src1[b]; if (ha1 && !ha2) dest[b] = src1[b]; if (mask) m++; src1 += b1; src2 += b2; dest += b1; } } void replace_indexed_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, unsigned char *mask, int opacity, int *affect, int length, int b1, int b2, int ha1, int ha2) { int bytes, b; unsigned char mask_alpha; unsigned char * m; if (mask) m = mask; else m = &no_mask; bytes = MINIMUM (b1, b2); while (length --) { mask_alpha = (*m * opacity) / 255; for (b = 0; b < bytes; b++) dest[b] = (affect[b] && mask_alpha) ? src2[b] : src1[b]; if (ha1 && !ha2) dest[b] = src1[b]; if (mask) m++; src1 += b1; src2 += b2; dest += b1; } } void erase_inten_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, unsigned char *mask, int opacity, int *affect, int length, int bytes) { int alpha, b; unsigned char src2_alpha; unsigned char * m; if (mask) m = mask; else m = &no_mask; alpha = bytes - 1; while (length --) { for (b = 0; b < alpha; b++) dest[b] = src1[b]; src2_alpha = (src2[alpha] * *m * opacity) / 65025; dest[alpha] = src1[alpha] - (src1[alpha] * src2_alpha) / 255; if (mask) m++; src1 += bytes; src2 += bytes; dest += bytes; } } void erase_indexed_pixels (unsigned char *src1, unsigned char *src2, unsigned char *dest, unsigned char *mask, int opacity, int *affect, int length, int bytes) { int alpha, b; unsigned char src2_alpha; unsigned char * m; if (mask) m = mask; else m = &no_mask; alpha = bytes - 1; while (length --) { for (b = 0; b < alpha; b++) dest[b] = src1[b]; src2_alpha = (src2[alpha] * *m * opacity) / 65025; dest[alpha] = (src2_alpha > 127) ? TRANSPARENT_OPACITY : src1[alpha]; if (mask) m++; src1 += bytes; src2 += bytes; dest += bytes; } } void extract_from_inten_pixels (unsigned char *src, unsigned char *dest, unsigned char *mask, unsigned char *bg, int cut, int length, int bytes, int has_alpha) { int b, alpha; int dest_bytes; unsigned char * m; if (mask) m = mask; else m = &no_mask; alpha = (has_alpha) ? bytes - 1 : bytes; dest_bytes = (has_alpha) ? bytes : bytes + 1; while (length --) { for (b = 0; b < alpha; b++) dest[b] = src[b]; if (has_alpha) { dest[alpha] = (*m * src[alpha]) / 255; if (cut) src[alpha] = ((255 - *m) * src[alpha]) / 255; } else { dest[alpha] = *m; if (cut) for (b = 0; b < bytes; b++) src[b] = (*m * bg[b] + (255 - *m) * src[b]) / 255; } if (mask) m++; src += bytes; dest += dest_bytes; } } void extract_from_indexed_pixels (unsigned char *src, unsigned char *dest, unsigned char *mask, unsigned char *cmap, unsigned char *bg, int cut, int length, int bytes, int has_alpha) { int b; int index; unsigned char * m; int t; if (mask) m = mask; else m = &no_mask; while (length --) { index = src[0] * 3; for (b = 0; b < 3; b++) dest[b] = cmap[index + b]; if (has_alpha) { dest[3] = INT_MULT (*m, src[1], t); if (cut) src[1] = INT_MULT ((255 - *m), src[1], t); } else { dest[3] = *m; if (cut) src[0] = (*m > 127) ? bg[0] : src[0]; } if (mask) m++; src += bytes; dest += 4; } } void map_to_color (int src_type, unsigned char *cmap, unsigned char *src, unsigned char *rgb) { switch (src_type) { case 0: /* RGB */ /* Straight copy */ *rgb++ = *src++; *rgb++ = *src++; *rgb = *src; break; case 1: /* GRAY */ *rgb++ = *src; *rgb++ = *src; *rgb = *src; break; case 2: /* INDEXED */ { int index = *src * 3; *rgb++ = cmap [index++]; *rgb++ = cmap [index++]; *rgb = cmap [index++]; } break; } } int map_rgb_to_indexed (unsigned char *cmap, int num_cols, int ID, int r, int g, int b) { unsigned int pixel; int hash_index; int cmap_index; pixel = (r << 16) | (g << 8) | b; hash_index = pixel % HASH_TABLE_SIZE; /* Hash table lookup hit */ if (color_hash_table[hash_index].colormap_ID == ID && color_hash_table[hash_index].pixel == pixel) { cmap_index = color_hash_table[hash_index].index; color_hash_hits++; } /* Hash table lookup miss */ else { unsigned char *col; int diff, sum, max; int i; max = MAXDIFF; cmap_index = 0; col = cmap; for (i = 0; i < num_cols; i++) { diff = r - *col++; sum = diff * diff; diff = g - *col++; sum += diff * diff; diff = b - *col++; sum += diff * diff; if (sum < max) { cmap_index = i; max = sum; } } /* update the hash table */ color_hash_table[hash_index].pixel = pixel; color_hash_table[hash_index].index = cmap_index; color_hash_table[hash_index].colormap_ID = ID; color_hash_misses++; } return cmap_index; } /**************************************************/ /* REGION FUNCTIONS */ /**************************************************/ void color_region (PixelRegion *src, unsigned char *col) { int h; unsigned char * s; void * pr; for (pr = pixel_regions_register (1, src); pr != NULL; pr = pixel_regions_process (pr)) { h = src->h; s = src->data; while (h--) { color_pixels (s, col, src->w, src->bytes); s += src->rowstride; } } } void blend_region (PixelRegion *src1, PixelRegion *src2, PixelRegion *dest, int blend) { int h; unsigned char * s1, * s2, * d; s1 = src1->data; s2 = src2->data; d = dest->data; h = src1->h; while (h --) { /* blend_pixels (s1, s2, d, blend, src1->w, src1->bytes);*/ s1 += src1->rowstride; s2 += src2->rowstride; d += dest->rowstride; } } void shade_region (PixelRegion *src, PixelRegion *dest, unsigned char *col, int blend) { int h; unsigned char * s, * d; s = src->data; d = dest->data; h = src->h; while (h --) { /* blend_pixels (s, d, col, blend, src->w, src->bytes);*/ s += src->rowstride; d += dest->rowstride; } } void copy_region (PixelRegion *src, PixelRegion *dest) { int h; int pixelwidth; unsigned char * s, * d; void * pr; for (pr = pixel_regions_register (2, src, dest); pr != NULL; pr = pixel_regions_process (pr)) { pixelwidth = src->w * src->bytes; s = src->data; d = dest->data; h = src->h; while (h --) { memcpy (d, s, pixelwidth); s += src->rowstride; d += dest->rowstride; } } } void add_alpha_region (PixelRegion *src, PixelRegion *dest) { int h; unsigned char * s, * d; void * pr; for (pr = pixel_regions_register (2, src, dest); pr != NULL; pr = pixel_regions_process (pr)) { s = src->data; d = dest->data; h = src->h; while (h --) { add_alpha_pixels (s, d, src->w, src->bytes); s += src->rowstride; d += dest->rowstride; } } } void flatten_region (PixelRegion *src, PixelRegion *dest, unsigned char *bg) { int h; unsigned char * s, * d; s = src->data; d = dest->data; h = src->h; while (h --) { flatten_pixels (s, d, bg, src->w, src->bytes); s += src->rowstride; d += dest->rowstride; } } void extract_alpha_region (PixelRegion *src, PixelRegion *mask, PixelRegion *dest) { int h; unsigned char * s, * m, * d; void * pr; for (pr = pixel_regions_register (3, src, mask, dest); pr != NULL; pr = pixel_regions_process (pr)) { s = src->data; d = dest->data; if (mask) m = mask->data; else m = NULL; h = src->h; while (h --) { extract_alpha_pixels (s, m, d, src->w, src->bytes); s += src->rowstride; d += dest->rowstride; if (mask) m += mask->rowstride; } } } void extract_from_region (PixelRegion *src, PixelRegion *dest, PixelRegion *mask, unsigned char *cmap, unsigned char *bg, int type, int has_alpha, int cut) { int h; unsigned char * s, * d, * m; void * pr; for (pr = pixel_regions_register (3, src, dest, mask); pr != NULL; pr = pixel_regions_process (pr)) { s = src->data; d = dest->data; m = (mask) ? mask->data : NULL; h = src->h; while (h --) { switch (type) { case 0: /* RGB */ case 1: /* GRAY */ extract_from_inten_pixels (s, d, m, bg, cut, src->w, src->bytes, has_alpha); break; case 2: /* INDEXED */ extract_from_indexed_pixels (s, d, m, cmap, bg, cut, src->w, src->bytes, has_alpha); break; } s += src->rowstride; d += dest->rowstride; if (mask) m += mask->rowstride; } } } void convolve_region (PixelRegion *srcR, PixelRegion *destR, int *matrix, int size, int divisor, int mode) { /* Convolve the src image using the convolution matrix, writing to dest */ /* Convolve is not tile-enabled--use accordingly */ unsigned char *src, *s_row, * s; unsigned char *dest, * d; int * m; int total [4]; int b, bytes; int length; int wraparound; int margin; /* margin imposed by size of conv. matrix */ int i, j; int x, y; int offset; /* If the mode is NEGATIVE, the offset should be 128 */ if (mode == NEGATIVE) { offset = 128; mode = 0; } else offset = 0; /* check for the boundary cases */ if (srcR->w < (size - 1) || srcR->h < (size - 1)) return; /* Initialize some values */ bytes = srcR->bytes; length = bytes * srcR->w; margin = size / 2; src = srcR->data; dest = destR->data; /* calculate the source wraparound value */ wraparound = srcR->rowstride - size * bytes; /* copy the first (size / 2) scanlines of the src image... */ for (i = 0; i < margin; i++) { memcpy (dest, src, length); src += srcR->rowstride; dest += destR->rowstride; } src = srcR->data; for (y = margin; y < srcR->h - margin; y++) { s_row = src; s = s_row + srcR->rowstride*margin; d = dest; /* handle the first margin pixels... */ b = bytes * margin; while (b --) *d++ = *s++; /* now, handle the center pixels */ x = srcR->w - margin*2; while (x--) { s = s_row; m = matrix; total [0] = total [1] = total [2] = total [3] = 0; i = size; while (i --) { j = size; while (j --) { for (b = 0; b < bytes; b++) total [b] += *m * *s++; m ++; } s += wraparound; } for (b = 0; b < bytes; b++) { total [b] = total [b] / divisor + offset; /* only if mode was ABSOLUTE will mode by non-zero here */ if (total [b] < 0 && mode) total [b] = - total [b]; if (total [b] < 0) *d++ = 0; else *d++ = (total [b] > 255) ? 255 : (unsigned char) total [b]; } s_row += bytes; } /* handle the last pixel... */ s = s_row + (srcR->rowstride + bytes) * margin; b = bytes * margin; while (b --) *d++ = *s++; /* set the memory pointers */ src += srcR->rowstride; dest += destR->rowstride; } src += srcR->rowstride*margin; /* copy the last (margin) scanlines of the src image... */ for (i = 0; i < margin; i++) { memcpy (dest, src, length); src += srcR->rowstride; dest += destR->rowstride; } } /* Convert from separated alpha to premultiplied alpha. Only works on non-tiled regions! */ void multiply_alpha_region (PixelRegion *srcR) { unsigned char *src, *s; int x, y; int width, height; int b, bytes; double alpha_val; width = srcR->w; height = srcR->h; bytes = srcR->bytes; src = srcR->data; for (y = 0; y < height; y++) { s = src; for (x = 0; x < width; x++) { alpha_val = s[bytes - 1] * (1.0 / 255.0); for (b = 0; b < bytes - 1; b++) s[b] = 0.5 + s[b] * alpha_val; s += bytes; } src += srcR->rowstride; } } /* Convert from premultiplied alpha to separated alpha. Only works on non-tiled regions! */ void separate_alpha_region (PixelRegion *srcR) { unsigned char *src, *s; int x, y; int width, height; int b, bytes; double alpha_recip; int new_val; width = srcR->w; height = srcR->h; bytes = srcR->bytes; src = srcR->data; for (y = 0; y < height; y++) { s = src; for (x = 0; x < width; x++) { /* predicate is equivalent to: (((s[bytes - 1] - 1) & 255) + 2) & 256 */ if (s[bytes - 1] != 0 && s[bytes - 1] != 255) { alpha_recip = 255.0 / s[bytes - 1]; for (b = 0; b < bytes - 1; b++) { new_val = 0.5 + s[b] * alpha_recip; new_val = MIN (new_val, 255); s[b] = new_val; } } s += bytes; } src += srcR->rowstride; } } void gaussian_blur_region (PixelRegion *srcR, double radius) { double std_dev; long width, height; int bytes; unsigned char *src, *sp; unsigned char *dest, *dp; unsigned char *data; int *buf, *b; int pixels; int total; int i, row, col; int start, end; int *curve; int *sum; int val; int length; int alpha; int initial_p, initial_m; if (radius == 0.0) return; /* zero blur is a no-op */ /* allocate the result buffer */ length = MAXIMUM (srcR->w, srcR->h) * srcR->bytes; data = paint_funcs_get_buffer (length * 2); src = data; dest = data + length; std_dev = sqrt (-(radius * radius) / (2 * log (1.0 / 255.0))); curve = make_curve (std_dev, &length); sum = g_malloc (sizeof (int) * (2 * length + 1)); sum[0] = 0; for (i = 1; i <= length*2; i++) sum[i] = curve[i-length-1] + sum[i-1]; sum += length; width = srcR->w; height = srcR->h; bytes = srcR->bytes; alpha = bytes - 1; buf = g_malloc (sizeof (int) * MAXIMUM (width, height) * 2); total = sum[length] - sum[-length]; for (col = 0; col < width; col++) { pixel_region_get_col (srcR, col + srcR->x, srcR->y, height, src, 1); sp = src + alpha; initial_p = sp[0]; initial_m = sp[(height-1) * bytes]; /* Determine a run-length encoded version of the column */ run_length_encode (sp, buf, height, bytes); for (row = 0; row < height; row++) { start = (row < length) ? -row : -length; end = (height <= (row + length)) ? (height - row - 1) : length; val = 0; i = start; b = buf + (row + i) * 2; if (start != -length) val += initial_p * (sum[start] - sum[-length]); while (i < end) { pixels = b[0]; i += pixels; if (i > end) i = end; val += b[1] * (sum[i] - sum[start]); b += (pixels * 2); start = i; } if (end != length) val += initial_m * (sum[length] - sum[end]); sp[row * bytes] = val / total; } pixel_region_set_col (srcR, col + srcR->x, srcR->y, height, src); } for (row = 0; row < height; row++) { pixel_region_get_row (srcR, srcR->x, row + srcR->y, width, src, 1); sp = src + alpha; dp = dest + alpha; initial_p = sp[0]; initial_m = sp[(width-1) * bytes]; /* Determine a run-length encoded version of the row */ run_length_encode (sp, buf, width, bytes); for (col = 0; col < width; col++) { start = (col < length) ? -col : -length; end = (width <= (col + length)) ? (width - col - 1) : length; val = 0; i = start; b = buf + (col + i) * 2; if (start != -length) val += initial_p * (sum[start] - sum[-length]); while (i < end) { pixels = b[0]; i += pixels; if (i > end) i = end; val += b[1] * (sum[i] - sum[start]); b += (pixels * 2); start = i; } if (end != length) val += initial_m * (sum[length] - sum[end]); val = val / total; dp[col * bytes] = val; } pixel_region_set_row (srcR, srcR->x, row + srcR->y, width, dest); } g_free (buf); g_free (sum - length); g_free (curve - length); } /* non-interpolating scale_region. [adam] */ void scale_region_no_resample (PixelRegion *srcPR, PixelRegion *destPR) { int * x_src_offsets; int * y_src_offsets; unsigned char * src; unsigned char * dest; int width, height, orig_width, orig_height; int last_src_y; int row_bytes; int x,y,b; char bytes; orig_width = srcPR->w; orig_height = srcPR->h; width = destPR->w; height = destPR->h; bytes = srcPR->bytes; /* the data pointers... */ x_src_offsets = (int *) g_malloc (width * bytes * sizeof(int)); y_src_offsets = (int *) g_malloc (height * sizeof(int)); src = (unsigned char *) g_malloc (orig_width * bytes); dest = (unsigned char *) g_malloc (width * bytes); /* pre-calc the scale tables */ for (b = 0; b < bytes; b++) { for (x = 0; x < width; x++) { x_src_offsets [b + x * bytes] = b + bytes * ((x * orig_width + orig_width / 2) / width); } } for (y = 0; y < height; y++) { y_src_offsets [y] = (y * orig_height + orig_height / 2) / height; } /* do the scaling */ row_bytes = width * bytes; last_src_y = -1; for (y = 0; y < height; y++) { /* if the source of this line was the same as the source * of the last line, there's no point in re-rescaling. */ if (y_src_offsets[y] != last_src_y) { pixel_region_get_row (srcPR, 0, y_src_offsets[y], orig_width, src, 1); for (x = 0; x < row_bytes ; x++) { dest[x] = src[x_src_offsets[x]]; } last_src_y = y_src_offsets[y]; } pixel_region_set_row (destPR, 0, y, width, dest); } g_free (x_src_offsets); g_free (y_src_offsets); g_free (src); g_free (dest); } void scale_region (PixelRegion *srcPR, PixelRegion *destPR) { unsigned char * src_m1, * src, * src_p1, * src_p2; unsigned char * s_m1, * s, * s_p1, * s_p2; unsigned char * dest, * d; double * row, * r; int src_row, src_col; int bytes, b; int width, height; int orig_width, orig_height; double x_rat, y_rat; double x_cum, y_cum; double x_last, y_last; double * x_frac, y_frac, tot_frac; float dx, dy; int i, j; int frac; int advance_dest_x, advance_dest_y; int minus_x, plus_x, plus2_x; ScaleType scale_type; orig_width = srcPR->w; orig_height = srcPR->h; width = destPR->w; height = destPR->h; /* Some calculations... */ bytes = destPR->bytes; /* the data pointers... */ src_m1 = (unsigned char *) g_malloc (orig_width * bytes); src = (unsigned char *) g_malloc (orig_width * bytes); src_p1 = (unsigned char *) g_malloc (orig_width * bytes); src_p2 = (unsigned char *) g_malloc (orig_width * bytes); dest = (unsigned char *) g_malloc (width * bytes); /* find the ratios of old x to new x and old y to new y */ x_rat = (double) orig_width / (double) width; y_rat = (double) orig_height / (double) height; /* determine the scale type */ if (x_rat < 1.0 && y_rat < 1.0) scale_type = MagnifyX_MagnifyY; else if (x_rat < 1.0 && y_rat >= 1.0) scale_type = MagnifyX_MinifyY; else if (x_rat >= 1.0 && y_rat < 1.0) scale_type = MinifyX_MagnifyY; else scale_type = MinifyX_MinifyY; /* allocate an array to help with the calculations */ row = (double *) g_malloc (sizeof (double) * width * bytes); x_frac = (double *) g_malloc (sizeof (double) * (width + orig_width)); /* initialize the pre-calculated pixel fraction array */ src_col = 0; x_cum = (double) src_col; x_last = x_cum; for (i = 0; i < width + orig_width; i++) { if (x_cum + x_rat <= (src_col + 1 + EPSILON)) { x_cum += x_rat; x_frac[i] = x_cum - x_last; } else { src_col ++; x_frac[i] = src_col - x_last; } x_last += x_frac[i]; } /* clear the "row" array */ memset (row, 0, sizeof (double) * width * bytes); /* counters... */ src_row = 0; y_cum = (double) src_row; y_last = y_cum; /* Get the first src row */ pixel_region_get_row (srcPR, 0, src_row, orig_width, src, 1); /* Get the next two if possible */ if (src_row < (orig_height - 1)) pixel_region_get_row (srcPR, 0, (src_row + 1), orig_width, src_p1, 1); if ((src_row + 1) < (orig_height - 1)) pixel_region_get_row (srcPR, 0, (src_row + 2), orig_width, src_p2, 1); /* Scale the selected region */ i = height; while (i) { src_col = 0; x_cum = (double) src_col; /* determine the fraction of the src pixel we are using for y */ if (y_cum + y_rat <= (src_row + 1 + EPSILON)) { y_cum += y_rat; dy = y_cum - src_row; y_frac = y_cum - y_last; advance_dest_y = TRUE; } else { y_frac = (src_row + 1) - y_last; dy = 1.0; advance_dest_y = FALSE; } y_last += y_frac; s = src; s_m1 = (src_row > 0) ? src_m1 : src; s_p1 = (src_row < (orig_height - 1)) ? src_p1 : src; s_p2 = ((src_row + 1) < (orig_height - 1)) ? src_p2 : s_p1; r = row; frac = 0; j = width; while (j) { if (x_cum + x_rat <= (src_col + 1 + EPSILON)) { x_cum += x_rat; dx = x_cum - src_col; advance_dest_x = TRUE; } else { dx = 1.0; advance_dest_x = FALSE; } tot_frac = x_frac[frac++] * y_frac; minus_x = (src_col > 0) ? -bytes : 0; plus_x = (src_col < (orig_width - 1)) ? bytes : 0; plus2_x = ((src_col + 1) < (orig_width - 1)) ? bytes * 2 : plus_x; if (cubic_interpolation) switch (scale_type) { case MagnifyX_MagnifyY: for (b = 0; b < bytes; b++) r[b] += cubic (dy, cubic (dx, s_m1[b+minus_x], s_m1[b], s_m1[b+plus_x], s_m1[b+plus2_x]), cubic (dx, s[b+minus_x], s[b], s[b+plus_x], s[b+plus2_x]), cubic (dx, s_p1[b+minus_x], s_p1[b], s_p1[b+plus_x], s_p1[b+plus2_x]), cubic (dx, s_p2[b+minus_x], s_p2[b], s_p2[b+plus_x], s_p2[b+plus2_x])) * tot_frac; break; case MagnifyX_MinifyY: for (b = 0; b < bytes; b++) r[b] += cubic (dx, s[b+minus_x], s[b], s[b+plus_x], s[b+plus2_x]) * tot_frac; break; case MinifyX_MagnifyY: for (b = 0; b < bytes; b++) r[b] += cubic (dy, s_m1[b], s[b], s_p1[b], s_p2[b]) * tot_frac; break; case MinifyX_MinifyY: for (b = 0; b < bytes; b++) r[b] += s[b] * tot_frac; break; } else switch (scale_type) { case MagnifyX_MagnifyY: for (b = 0; b < bytes; b++) r[b] += ((1 - dy) * ((1 - dx) * s[b] + dx * s[b+plus_x]) + dy * ((1 - dx) * s_p1[b] + dx * s_p1[b+plus_x])) * tot_frac; break; case MagnifyX_MinifyY: for (b = 0; b < bytes; b++) r[b] += (s[b] * (1 - dx) + s[b+plus_x] * dx) * tot_frac; break; case MinifyX_MagnifyY: for (b = 0; b < bytes; b++) r[b] += (s[b] * (1 - dy) + s_p1[b] * dy) * tot_frac; break; case MinifyX_MinifyY: for (b = 0; b < bytes; b++) r[b] += s[b] * tot_frac; break; } if (advance_dest_x) { r += bytes; j--; } else { s_m1 += bytes; s += bytes; s_p1 += bytes; s_p2 += bytes; src_col++; } } if (advance_dest_y) { tot_frac = 1.0 / (x_rat * y_rat); /* copy "row" to "dest" */ d = dest; r = row; j = width; while (j--) { b = bytes; while (b--) *d++ = (unsigned char) (*r++ * tot_frac); } /* set the pixel region span */ pixel_region_set_row (destPR, 0, (height - i), width, dest); /* clear the "row" array */ memset (row, 0, sizeof (double) * width * bytes); i--; } else { /* Shuffle pointers */ s = src_m1; src_m1 = src; src = src_p1; src_p1 = src_p2; src_p2 = s; src_row++; if ((src_row + 1) < (orig_height - 1)) pixel_region_get_row (srcPR, 0, (src_row + 2), orig_width, src_p2, 1); } } /* free up temporary arrays */ g_free (row); g_free (x_frac); g_free (src_m1); g_free (src); g_free (src_p1); g_free (src_p2); g_free (dest); } void subsample_region (PixelRegion *srcPR, PixelRegion *destPR, int subsample) { unsigned char * src, * s; unsigned char * dest, * d; double * row, * r; int destwidth; int src_row, src_col; int bytes, b; int width, height; int orig_width, orig_height; double x_rat, y_rat; double x_cum, y_cum; double x_last, y_last; double * x_frac, y_frac, tot_frac; int i, j; int frac; int advance_dest; orig_width = srcPR->w / subsample; orig_height = srcPR->h / subsample; width = destPR->w; height = destPR->h; /* Some calculations... */ bytes = destPR->bytes; destwidth = destPR->rowstride; /* the data pointers... */ src = (unsigned char *) g_malloc (orig_width * bytes); dest = destPR->data; /* find the ratios of old x to new x and old y to new y */ x_rat = (double) orig_width / (double) width; y_rat = (double) orig_height / (double) height; /* allocate an array to help with the calculations */ row = (double *) g_malloc (sizeof (double) * width * bytes); x_frac = (double *) g_malloc (sizeof (double) * (width + orig_width)); /* initialize the pre-calculated pixel fraction array */ src_col = 0; x_cum = (double) src_col; x_last = x_cum; for (i = 0; i < width + orig_width; i++) { if (x_cum + x_rat <= (src_col + 1 + EPSILON)) { x_cum += x_rat; x_frac[i] = x_cum - x_last; } else { src_col ++; x_frac[i] = src_col - x_last; } x_last += x_frac[i]; } /* clear the "row" array */ memset (row, 0, sizeof (double) * width * bytes); /* counters... */ src_row = 0; y_cum = (double) src_row; y_last = y_cum; pixel_region_get_row (srcPR, 0, src_row * subsample, orig_width * subsample, src, subsample); /* Scale the selected region */ for (i = 0; i < height; ) { src_col = 0; x_cum = (double) src_col; /* determine the fraction of the src pixel we are using for y */ if (y_cum + y_rat <= (src_row + 1 + EPSILON)) { y_cum += y_rat; y_frac = y_cum - y_last; advance_dest = TRUE; } else { src_row ++; y_frac = src_row - y_last; advance_dest = FALSE; } y_last += y_frac; s = src; r = row; frac = 0; j = width; while (j) { tot_frac = x_frac[frac++] * y_frac; for (b = 0; b < bytes; b++) r[b] += s[b] * tot_frac; /* increment the destination */ if (x_cum + x_rat <= (src_col + 1 + EPSILON)) { r += bytes; x_cum += x_rat; j--; } /* increment the source */ else { s += bytes; src_col++; } } if (advance_dest) { tot_frac = 1.0 / (x_rat * y_rat); /* copy "row" to "dest" */ d = dest; r = row; j = width; while (j--) { b = bytes; while (b--) *d++ = (unsigned char) (*r++ * tot_frac); } dest += destwidth; /* clear the "row" array */ memset (row, 0, sizeof (double) * destwidth); i++; } else pixel_region_get_row (srcPR, 0, src_row * subsample, orig_width * subsample, src, subsample); } /* free up temporary arrays */ g_free (row); g_free (x_frac); g_free (src); } float shapeburst_region (PixelRegion *srcPR, PixelRegion *distPR) { Tile *tile; unsigned char *tile_data; float max_iterations; float *distp_cur; float *distp_prev; float *tmp; float min_prev; float float_tmp; int min; int min_left; int length; int i, j, k; int src; int fraction; int prev_frac; int x, y; int end; int boundary; int inc; src = 0; max_iterations = 0.0; length = distPR->w + 1; distp_prev = (float *) paint_funcs_get_buffer (sizeof (float) * length * 2); for (i = 0; i < length; i++) distp_prev[i] = 0.0; distp_prev += 1; distp_cur = distp_prev + length; for (i = 0; i < srcPR->h; i++) { /* set the current dist row to 0's */ memset(distp_cur - 1, 0, sizeof(float) * (length - 1)); for (j = 0; j < srcPR->w; j++) { min_prev = MINIMUM (distp_cur[j-1], distp_prev[j]); min_left = MINIMUM ((srcPR->w - j - 1), (srcPR->h - i - 1)); min = (int) MINIMUM (min_left, min_prev); fraction = 255; /* This might need to be changed to 0 instead of k = (min) ? (min - 1) : 0 */ for (k = (min) ? (min - 1) : 0; k <= min; k++) { x = j; y = i + k; end = y - k; while (y >= end) { tile = tile_manager_get_tile (srcPR->tiles, x, y, 0); tile_ref (tile); tile_data = tile->data + (tile->ewidth * (y % TILE_HEIGHT) + (x % TILE_WIDTH)); boundary = MINIMUM ((y % TILE_HEIGHT), (tile->ewidth - (x % TILE_WIDTH) - 1)); boundary = MINIMUM (boundary, (y - end)) + 1; inc = 1 - tile->ewidth; while (boundary--) { src = *tile_data; if (src == 0) { min = k; y = -1; break; } if (src < fraction) fraction = src; x++; y--; tile_data += inc; } tile_unref (tile, FALSE); } } if (src != 0) { /* If min_left != min_prev use the previous fraction * if it is less than the one found */ if (min_left != min) { prev_frac = (int) (255 * (min_prev - min)); if (prev_frac == 255) prev_frac = 0; fraction = MINIMUM (fraction, prev_frac); } min++; } float_tmp = distp_cur[j] = min + fraction / 256.0; if (float_tmp > max_iterations) max_iterations = float_tmp; } /* set the dist row */ pixel_region_set_row (distPR, distPR->x, distPR->y + i, distPR->w, (unsigned char *) distp_cur); /* swap pointers around */ tmp = distp_prev; distp_prev = distp_cur; distp_cur = tmp; } return max_iterations; } static void rotate_pointers(void **p, guint32 n) { guint32 i; void *tmp; tmp = p[0]; for (i = 0; i < n-1; i++) { p[i] = p[i+1]; } p[i] = tmp; } static void compute_border(gint16 *circ, guint16 radius) { gint32 i; gint32 diameter = radius*2 +1; gdouble tmp; for (i = 0; i < diameter; i++) { if (i > radius) tmp = (i - radius) - .5; else if (i < radius) tmp = (radius - i) - .5; else tmp = 0.0; circ[i] = rint(sqrt((radius)*(radius) - (tmp)*(tmp))); } } void fatten_region(PixelRegion *src, gint16 radius) { /* Any bugs in this fuction are probably also in thin_region Blame all bugs in this function on jaycox@earthlink.net */ register gint32 i, j, x, y; guchar **buf, *out; guchar **max; gint16 *circ; gint16 last_max, last_index; guchar *buffer; guint16 diameter = radius*2+1; if (radius <= 0) return; max = (guchar **)g_malloc ((src->w + 2*radius) * sizeof(void *)); buf = (guchar **)g_malloc((radius + 1) * sizeof(void *)); for (i = 0; i < radius+1; i++) { buf[i] = (guchar *)g_malloc(src->w * sizeof(guchar)); } buffer = g_malloc((src->w + 2*radius)*(radius + 1) * sizeof(guchar)); for (i = 0; i < src->w + 2*radius; i++) { if (i < radius) max[i] = buffer; else if (i < src->w + radius) max[i] = &buffer[(radius+1)*(i - radius)]; else max[i] = &buffer[(radius+1)*(src->w + radius - 1)]; for (j = 0 ; j < radius + 1; j++) max[i][j] = 0; } max += radius; out = (guchar *)g_malloc (src->w * sizeof(guchar)); circ = (short *)g_malloc (diameter * sizeof(gint16)); compute_border (circ, radius); circ += radius; memset (buf[0], 0, src->w); for (i = 0; i < radius && i < src->h; i++) /* load top of image */ pixel_region_get_row (src, src->x, src->y + i, src->w, buf[i+1], 1); for (x = 0; x < src->w; x++) /* set up max for top of image */ { max[x][0] = buf[0][x]; for (j = 1; j < radius+1; j++) if (max[x][j] < buf[j][x]) max[x][j] = buf[j][x]; else max[x][j] = max[x][j-1]; } for (y = 0; y < src->h; y++) { rotate_pointers((void **)buf, radius+1); if (y < src->h - (radius)) pixel_region_get_row (src, src->x, src->y + y + radius, src->w, buf[radius], 1); else memset (buf[radius], 0, src->w); for (x = 0 ; x < src->w; x++) /* update max array */ { for (i = radius; i > 0; i--) { max[x][i] = (MAX (MAX (max[x][i - 1], buf[i-1][x]), buf[i][x])); } max[x][0] = buf[0][x]; } last_max = max[0][circ[-1]]; last_index = 1; for (x = 0 ; x < src->w; x++) /* render scan line */ { last_index--; if (last_index >= 0) { if (last_max == 255) out[x] = 255; else { last_max = 0; for (i = radius; i >= 0; i--) if (last_max < max[x+i][circ[i]]) { last_max = max[x+i][circ[i]]; last_index = i; } out[x] = last_max; } } else { last_index = radius; last_max = max[x+radius][circ[radius]]; for (i = radius-1; i >= -radius; i--) if (last_max < max[x+i][circ[i]]) { last_max = max[x+i][circ[i]]; last_index = i; } out[x] = last_max; } } pixel_region_set_row (src, src->x, src->y + y, src->w, out); } circ -= radius; max -= radius; g_free (circ); g_free (buffer); g_free (max); for (i = 0; i < radius; i++) g_free (buf[i]); g_free (buf); g_free (out); } void thin_region(PixelRegion *src, gint16 radius) { /* pretty much the same as fatten_region only different blame all bugs in this function on jaycox@earthlink.net */ register gint32 i, j, x, y; guchar **buf, *out; guchar **max; gint16 *circ; gint16 last_max, last_index; guchar *buffer; guint16 diameter = radius*2+1; if (radius <= 0) return; max = (guchar **)g_malloc ((src->w+2*radius) * sizeof(void *)); buf = (guchar **)g_malloc ((radius+1) * sizeof(void *)); for (i = 0; i < radius+1; i++) { buf[i] = (guchar *)g_malloc (src->w * sizeof(guchar)); } buffer = g_malloc ((src->w+2*radius)*(radius+1)); for (i = 0; i < src->w+2*radius; i++) { if (i < radius) max[i] = buffer; else if (i < src->w + radius) max[i] = &buffer[(radius+1)*(i - radius)]; else max[i] = &buffer[(radius+1)*(src->w + radius - 1)]; for (j = 0 ; j < radius+1; j++) max[i][j] = 255; } max += radius; out = (char *)g_malloc(src->w); circ = (short *)g_malloc((diameter)*sizeof(gint16)); compute_border(circ, radius); circ += radius; for (i = 0; i < radius && i < src->h; i++) /* load top of image */ pixel_region_get_row (src, src->x, src->y + i, src->w, buf[i+1], 1); memcpy (buf[0], buf[1], src->w); for (x = 0; x < src->w; x++) /* set up max for top of image */ { max[x][0] = buf[0][x]; for (j = 1; j < radius+1; j++) if (max[x][j] > buf[j][x]) max[x][j] = buf[j][x]; else max[x][j] = max[x][j-1]; } for (y = 0; y < src->h; y++) { rotate_pointers ((void **)buf, radius+1); if (y < src->h - (radius)) pixel_region_get_row (src, src->x, src->y + y + radius, src->w, buf[radius], 1); else memcpy (buf[radius], buf[radius -1], src->w); for (x = 0 ; x < src->w; x++) /* update max array */ { for (i = radius; i > 0; i--) { max[x][i] = (MIN (MIN (max[x][i - 1], buf[i-1][x]), buf[i][x])); } max[x][0] = buf[0][x]; } last_max = max[0][circ[-1]]; last_index = 1; for (x = 0 ; x < src->w; x++) /* render scan line */ { last_index--; if (last_index >= 0) { if (last_max == 0) out[x] = 0; else { last_max = 255; for (i = radius; i >= 0; i--) if (last_max > max[x+i][circ[i]]) { last_max = max[x+i][circ[i]]; last_index = i; } out[x] = last_max; } } else { last_index = radius; last_max = max[x+radius][circ[radius]]; for (i = radius-1; i >= -radius; i--) if (last_max > max[x+i][circ[i]]) { last_max = max[x+i][circ[i]]; last_index = i; } out[x] = last_max; } } pixel_region_set_row (src, src->x, src->y + y, src->w, out); } circ -= radius; max -= radius; g_free (circ); g_free (buffer); g_free (max); for (i = 0; i < radius; i++) g_free (buf[i]); g_free (buf); g_free (out); } static void compute_transition(guchar *transition, guchar **buf, gint32 width) { register gint32 x = 0; if (width == 1) { if (buf[1][x] > 127 && (buf[0][x] < 128 || buf[2][x] < 128)) transition[x] = 255; else transition[x] = 0; return; } if (buf[1][x] > 127) { if ( buf[0][x] < 128 || buf[0][x+1] < 128 || buf[1][x+1] < 128 || buf[2][x] < 128 || buf[2][x+1] < 128 ) transition[x] = 255; else transition[x] = 0; } else transition[x] = 0; for (x = 1; x < width - 1; x++) { if (buf[1][x] >= 128) { if (buf[0][x-1] < 128 || buf[0][x] < 128 || buf[0][x+1] < 128 || buf[1][x-1] < 128 || buf[1][x+1] < 128 || buf[2][x-1] < 128 || buf[2][x] < 128 || buf[2][x+1] < 128) transition[x] = 255; else transition[x] = 0; } else transition[x] = 0; } if (buf[1][x] >= 128) { if ( buf[0][x-1] < 128 || buf[0][x] < 128 || buf[1][x-1] < 128 || buf[2][x-1] < 128 || buf[2][x] < 128) transition[x] = 255; else transition[x] = 0; } else transition[x] = 0; } void border_region(PixelRegion *src, gint16 radius) { /* blame all bugs in this function on jaycox@earthlink.net */ register gint32 i, j, x, y; guchar **buf, *out; gint16 *max; guchar **density; guchar **transition; guint16 diameter = radius*2+1; guchar last_max; gint16 last_index; if (radius < 0) { g_warning ("border_region: negative radius specified."); return; } if (radius == 0) { char color[] = "\0\0\0"; color_region(src, color); return; } if (radius == 1) /* optomize this case specificaly */ { guchar *transition; guchar *source[3]; for (i = 0; i < 3; i++) source[i] = (guchar *)g_malloc ((src->w)*sizeof(guchar)); transition = (guchar *)g_malloc ((src->w)*sizeof(guchar)); pixel_region_get_row (src, src->x, src->y + 0, src->w, source[0], 1); memcpy (source[1], source[0], src->w); if (src->h > 1) pixel_region_get_row (src, src->x, src->y + 1, src->w, source[2], 1); else memcpy (source[2], source[1], src->w); compute_transition (transition, source, src->w); pixel_region_set_row (src, src->x, src->y , src->w, transition); for (y = 1; y < src->h; y++) { rotate_pointers ((void **)source, 3); if (y +1 < src->h) pixel_region_get_row (src, src->x, src->y +y +1, src->w, source[2], 1); else memcpy(source[2], source[1], src->w); compute_transition (transition, source, src->w); pixel_region_set_row (src, src->x, src->y + y, src->w, transition); } for (i = 0; i < 3; i++) g_free(source[i]); g_free(transition); return; } /* end of if (radius == 1) */ max = (gint16 *)g_malloc ((src->w+2*radius)*sizeof(gint16 *)); for (i = 0; i < (src->w+2*radius); i++) max[i] = radius+2; max += radius; buf = (guchar **)g_malloc ((3)*sizeof(void *)); for (i = 0; i < 3; i++) { buf[i] = (guchar *)g_malloc ((src->w)*sizeof(guchar)); } transition = (guchar **)g_malloc ((radius+1)*sizeof(void*)); for (i = 0; i < radius +1; i++) { transition[i] = (guchar *)g_malloc (src->w+2*radius); bzero(transition[i], src->w+2*radius); transition[i] += radius; } out = (guchar *)g_malloc ((src->w)*sizeof(guchar)); density = (guchar **)g_malloc (diameter*sizeof(void *)); density += radius; for (x = -(radius); x < (radius+1); x++) /* compute density[][] */ { register double tmpx, tmpy; density[x] = (guchar *)g_malloc (diameter); density[x] += radius; for (y = -radius; y < (radius+1); y++) { if (x > 0) tmpx = x - 0.5; else if (x < 0) tmpx = x + 0.5; else tmpx = 0.0; if (y > 0) tmpy = y - 0.5; else if (y < 0) tmpy = y + 0.5; else tmpy = 0.0; if (tmpy*tmpy + tmpx*tmpx < (radius)*(radius)) density[x][y] = 255*(1.0 - sqrt ((tmpx*tmpx+tmpy*tmpy))/radius); else density[x][y] = 0; } } pixel_region_get_row (src, src->x, src->y + 0, src->w, buf[0], 1); memcpy (buf[1], buf[0], src->w); if (src->h > 1) pixel_region_get_row (src, src->x, src->y + 1, src->w, buf[2], 1); else memcpy (buf[2], buf[1], src->w); compute_transition (transition[1], buf, src->w); for (y = 1; y < radius && y + 1< src->h; y++) /* set up top of image */ { rotate_pointers ((void **)buf, 3); pixel_region_get_row (src, src->x, src->y + y + 1, src->w, buf[2], 1); compute_transition (transition[y + 1], buf, src->w); } for (x = 0; x < src->w; x++) /* set up max[] for top of image */ { max[x] = -(radius+7); for (j = 1; j < radius+1; j++) if (transition[j][x]) { max[x] = j; break; } } for (y = 0; y < src->h; y++) /* main calculation loop */ { rotate_pointers ((void **)buf, 3); rotate_pointers ((void **)transition, radius + 1); if (y < src->h - (radius+1)) { pixel_region_get_row (src, src->x, src->y + y + radius + 1, src->w, buf[2], 1); compute_transition (transition[radius], buf, src->w); } else memcpy (transition[radius], transition[radius - 1], src->w); for (x = 0; x < src->w; x++) /* update max array */ { if (max[x] < 1) { if (max[x] <= -radius) { if (transition[radius][x]) max[x] = radius; else max[x]--; } else if (transition[-max[x]][x]) max[x] = -max[x]; else if (transition[-max[x]+1][x]) max[x] = -max[x]+1; else max[x]--; } else max[x]--; if (max[x] < -radius - 1) max[x] = -radius -1; } last_max = max[0][density[-1]]; last_index = 1; for (x = 0 ; x < src->w; x++) /* render scan line */ { last_index--; if (last_index >= 0) { last_max = 0; for (i = radius; i >= 0; i--) if (max[x+i] <= radius && max[x+i] >= -radius && density[i][max[x+i]] > last_max) { last_max = density[i][max[x+i]]; last_index = i; } out[x] = last_max; } else { last_max = 0; for (i = radius; i >= -radius; i--) if (max[x+i] <= radius && max[x+i] >= -radius && density[i][max[x+i]] > last_max) { last_max = density[i][max[x+i]]; last_index = i; } out[x] = last_max; } if (last_max == 0) { for (i = x+1; i < src->w; i++) { if (max[i] >= -radius) break; } if (i - x > radius) { for (; x < i - radius; x++) out[x] = 0; x--; } last_index = radius; } } pixel_region_set_row (src, src->x, src->y + y, src->w, out); } g_free(out); for (i = 0; i < 3; i++) g_free(buf[i]); g_free (buf); max -= radius; g_free (max); for (i = 0; i < radius +1; i++) { transition[i] -= radius; g_free (transition[i]); } g_free (transition); for (i = -radius; i < radius +1 ; i++) { density[i]-= radius; g_free(density[i]); } density -= radius; g_free(density); } void swap_region (PixelRegion *src, PixelRegion *dest) { int h; int length; unsigned char * s, * d; void * pr; for (pr = pixel_regions_register (2, src, dest); pr != NULL; pr = pixel_regions_process (pr)) { s = src->data; h = src->h; d = dest->data; length = src->w * src->bytes; while (h --) { swap_pixels (s, d, length); s += src->rowstride; d += dest->rowstride; } } } void apply_mask_to_region (PixelRegion *src, PixelRegion *mask, int opacity) { int h; unsigned char * s, * m; void * pr; for (pr = pixel_regions_register (2, src, mask); pr != NULL; pr = pixel_regions_process (pr)) { s = src->data; m = mask->data; h = src->h; while (h --) { apply_mask_to_alpha_channel (s, m, opacity, src->w, src->bytes); s += src->rowstride; m += mask->rowstride; } } } void combine_mask_and_region (PixelRegion *src, PixelRegion *mask, int opacity) { int h; unsigned char * s, * m; void * pr; for (pr = pixel_regions_register (2, src, mask); pr != NULL; pr = pixel_regions_process (pr)) { s = src->data; s = src->data; m = mask->data; h = src->h; while (h --) { combine_mask_and_alpha_channel (s, m, opacity, src->w, src->bytes); s += src->rowstride; m += mask->rowstride; } } } void copy_gray_to_region (PixelRegion *src, PixelRegion *dest) { int h; unsigned char * s, * d; void * pr; for (pr = pixel_regions_register (2, src, dest); pr != NULL; pr = pixel_regions_process (pr)) { s = src->data; d = dest->data; h = src->h; while (h --) { copy_gray_to_inten_a_pixels (s, d, src->w, dest->bytes); s += src->rowstride; d += dest->rowstride; } } } void initial_region (PixelRegion *src, PixelRegion *dest, PixelRegion *mask, unsigned char *data, int opacity, int mode, int *affect, int type) { int h; unsigned char * s, * d, * m; unsigned char * buf; void * pr; buf = paint_funcs_get_buffer (src->w * (src->bytes + 1)); for (pr = pixel_regions_register (3, src, dest, mask); pr != NULL; pr = pixel_regions_process (pr)) { s = src->data; d = dest->data; m = (mask) ? mask->data : NULL; for (h = 0; h < src->h; h++) { /* based on the type of the initial image... */ switch (type) { case INITIAL_CHANNEL_MASK: case INITIAL_CHANNEL_SELECTION: initial_channel_pixels (s, d, src->w, dest->bytes); break; case INITIAL_INDEXED: initial_indexed_pixels (s, d, data, src->w); break; case INITIAL_INDEXED_ALPHA: initial_indexed_a_pixels (s, d, m, data, opacity, src->w); break; case INITIAL_INTENSITY: if (mode == DISSOLVE_MODE) { dissolve_pixels (s, buf, src->x, src->y + h, opacity, src->w, src->bytes, src->bytes + 1, 0); initial_inten_pixels (buf, d, m, opacity, affect, src->w, src->bytes); } else initial_inten_pixels (s, d, m, opacity, affect, src->w, src->bytes); break; case INITIAL_INTENSITY_ALPHA: if (mode == DISSOLVE_MODE) { dissolve_pixels (s, buf, src->x, src->y + h, opacity, src->w, src->bytes, src->bytes, 1); initial_inten_a_pixels (buf, d, m, opacity, affect, src->w, src->bytes); } else initial_inten_a_pixels (s, d, m, opacity, affect, src->w, src->bytes); break; } s += src->rowstride; d += dest->rowstride; if (mask) m += mask->rowstride; } } } void combine_regions (PixelRegion *src1, PixelRegion *src2, PixelRegion *dest, PixelRegion *mask, unsigned char *data, int opacity, int mode, int *affect, int type) { int h; int ha1, ha2; int combine; int mode_affect; unsigned char * s, * s1, * s2; unsigned char * d, * m; unsigned char * buf; void * pr; combine = 0; /* Determine which sources have alpha channels */ switch (type) { case COMBINE_INTEN_INTEN: case COMBINE_INDEXED_INDEXED: ha1 = ha2 = 0; break; case COMBINE_INTEN_A_INTEN: ha1 = 1; ha2 = 0; break; case COMBINE_INTEN_INTEN_A: case COMBINE_INDEXED_INDEXED_A: ha1 = 0; ha2 = 1; break; case COMBINE_INTEN_A_INTEN_A: case COMBINE_INDEXED_A_INDEXED_A: ha1 = ha2 = 1; break; default: ha1 = ha2 = 0; } buf = paint_funcs_get_buffer (src1->w * (src1->bytes + 1)); for (pr = pixel_regions_register (4, src1, src2, dest, mask); pr != NULL; pr = pixel_regions_process (pr)) { s1 = src1->data; s2 = src2->data; d = dest->data; m = (mask) ? mask->data : NULL; for (h = 0; h < src1->h; h++) { s = buf; /* apply the paint mode based on the combination type & mode */ switch (type) { case COMBINE_INTEN_A_INDEXED_A: case COMBINE_INTEN_A_CHANNEL_MASK: case COMBINE_INTEN_A_CHANNEL_SELECTION: combine = type; break; case COMBINE_INDEXED_INDEXED: case COMBINE_INDEXED_INDEXED_A: case COMBINE_INDEXED_A_INDEXED_A: /* Now, apply the paint mode--for indexed images */ combine = apply_indexed_layer_mode (s1, s2, &s, mode, ha1, ha2); break; case COMBINE_INTEN_INTEN_A: case COMBINE_INTEN_A_INTEN: case COMBINE_INTEN_INTEN: case COMBINE_INTEN_A_INTEN_A: /* Now, apply the paint mode */ combine = apply_layer_mode (s1, s2, &s, src1->x, src1->y + h, opacity, src1->w, mode, src1->bytes, src2->bytes, ha1, ha2, &mode_affect); break; default: break; } /* based on the type of the initial image... */ switch (combine) { case COMBINE_INDEXED_INDEXED: combine_indexed_and_indexed_pixels (s1, s2, d, m, opacity, affect, src1->w, src1->bytes); break; case COMBINE_INDEXED_INDEXED_A: combine_indexed_and_indexed_a_pixels (s1, s2, d, m, opacity, affect, src1->w, src1->bytes); break; case COMBINE_INDEXED_A_INDEXED_A: combine_indexed_a_and_indexed_a_pixels (s1, s2, d, m, opacity, affect, src1->w, src1->bytes); break; case COMBINE_INTEN_A_INDEXED_A: /* assume the data passed to this procedure is the * indexed layer's colormap */ combine_inten_a_and_indexed_a_pixels (s1, s2, d, m, data, opacity, src1->w, dest->bytes); break; case COMBINE_INTEN_A_CHANNEL_MASK: /* assume the data passed to this procedure is the * indexed layer's colormap */ combine_inten_a_and_channel_mask_pixels (s1, s2, d, data, opacity, src1->w, dest->bytes); break; case COMBINE_INTEN_A_CHANNEL_SELECTION: combine_inten_a_and_channel_selection_pixels (s1, s2, d, data, opacity, src1->w, src1->bytes); break; case COMBINE_INTEN_INTEN: combine_inten_and_inten_pixels (s1, s, d, m, opacity, affect, src1->w, src1->bytes); break; case COMBINE_INTEN_INTEN_A: combine_inten_and_inten_a_pixels (s1, s, d, m, opacity, affect, src1->w, src1->bytes); break; case COMBINE_INTEN_A_INTEN: combine_inten_a_and_inten_pixels (s1, s, d, m, opacity, affect, mode_affect, src1->w, src1->bytes); break; case COMBINE_INTEN_A_INTEN_A: combine_inten_a_and_inten_a_pixels (s1, s, d, m, opacity, affect, mode_affect, src1->w, src1->bytes); break; case BEHIND_INTEN: behind_inten_pixels (s1, s, d, m, opacity, affect, src1->w, src1->bytes, src2->bytes, ha1, ha2); break; case BEHIND_INDEXED: behind_indexed_pixels (s1, s, d, m, opacity, affect, src1->w, src1->bytes, src2->bytes, ha1, ha2); break; case REPLACE_INTEN: replace_inten_pixels (s1, s, d, m, opacity, affect, src1->w, src1->bytes, src2->bytes, ha1, ha2); break; case REPLACE_INDEXED: replace_indexed_pixels (s1, s, d, m, opacity, affect, src1->w, src1->bytes, src2->bytes, ha1, ha2); break; case ERASE_INTEN: erase_inten_pixels (s1, s, d, m, opacity, affect, src1->w, src1->bytes); break; case ERASE_INDEXED: erase_indexed_pixels (s1, s, d, m, opacity, affect, src1->w, src1->bytes); break; case NO_COMBINATION: break; default: break; } s1 += src1->rowstride; s2 += src2->rowstride; d += dest->rowstride; if (mask) m += mask->rowstride; } } } void combine_regions_replace (PixelRegion *src1, PixelRegion *src2, PixelRegion *dest, PixelRegion *mask, unsigned char *data, int opacity, int *affect, int type) { int h; unsigned char * s1, * s2; unsigned char * d, * m; void * pr; for (pr = pixel_regions_register (4, src1, src2, dest, mask); pr != NULL; pr = pixel_regions_process (pr)) { s1 = src1->data; s2 = src2->data; d = dest->data; m = mask->data; for (h = 0; h < src1->h; h++) { /* Now, apply the paint mode */ apply_layer_mode_replace (s1, s2, d, m, src1->x, src1->y + h, opacity, src1->w, src1->bytes, src2->bytes, affect); s1 += src1->rowstride; s2 += src2->rowstride; d += dest->rowstride; m += mask->rowstride; } } } /********************************* * color conversion routines * *********************************/ void rgb_to_hsv (int *r, int *g, int *b) { int red, green, blue; float h, s, v; int min, max; int delta; h = 0.0; red = *r; green = *g; blue = *b; if (red > green) { if (red > blue) max = red; else max = blue; if (green < blue) min = green; else min = blue; } else { if (green > blue) max = green; else max = blue; if (red < blue) min = red; else min = blue; } v = max; if (max != 0) s = ((max - min) * 255) / (float) max; else s = 0; if (s == 0) h = 0; else { delta = max - min; if (red == max) h = (green - blue) / (float) delta; else if (green == max) h = 2 + (blue - red) / (float) delta; else if (blue == max) h = 4 + (red - green) / (float) delta; h *= 42.5; if (h < 0) h += 255; if (h > 255) h -= 255; } *r = h; *g = s; *b = v; } void hsv_to_rgb (int *h, int *s, int *v) { float hue, saturation, value; float f, p, q, t; if (*s == 0) { *h = *v; *s = *v; *v = *v; } else { hue = *h * 6.0 / 255.0; saturation = *s / 255.0; value = *v / 255.0; f = hue - (int) hue; p = value * (1.0 - saturation); q = value * (1.0 - (saturation * f)); t = value * (1.0 - (saturation * (1.0 - f))); switch ((int) hue) { case 0: *h = value * 255; *s = t * 255; *v = p * 255; break; case 1: *h = q * 255; *s = value * 255; *v = p * 255; break; case 2: *h = p * 255; *s = value * 255; *v = t * 255; break; case 3: *h = p * 255; *s = q * 255; *v = value * 255; break; case 4: *h = t * 255; *s = p * 255; *v = value * 255; break; case 5: *h = value * 255; *s = p * 255; *v = q * 255; break; } } } void rgb_to_hls (int *r, int *g, int *b) { int red, green, blue; float h, l, s; int min, max; int delta; red = *r; green = *g; blue = *b; if (red > green) { if (red > blue) max = red; else max = blue; if (green < blue) min = green; else min = blue; } else { if (green > blue) max = green; else max = blue; if (red < blue) min = red; else min = blue; } l = (max + min) / 2.0; if (max == min) { s = 0.0; h = 0.0; } else { delta = (max - min); if (l < 128) s = 255 * (float) delta / (float) (max + min); else s = 255 * (float) delta / (float) (511 - max - min); if (red == max) h = (green - blue) / (float) delta; else if (green == max) h = 2 + (blue - red) / (float) delta; else h = 4 + (red - green) / (float) delta; h = h * 42.5; if (h < 0) h += 255; if (h > 255) h -= 255; } *r = h; *g = l; *b = s; } static int hls_value (float n1, float n2, float hue) { float value; if (hue > 255) hue -= 255; else if (hue < 0) hue += 255; if (hue < 42.5) value = n1 + (n2 - n1) * (hue / 42.5); else if (hue < 127.5) value = n2; else if (hue < 170) value = n1 + (n2 - n1) * ((170 - hue) / 42.5); else value = n1; return (int) (value * 255); } void hls_to_rgb (int *h, int *l, int *s) { float hue, lightness, saturation; float m1, m2; hue = *h; lightness = *l; saturation = *s; if (saturation == 0) { /* achromatic case */ *h = lightness; *l = lightness; *s = lightness; } else { if (lightness < 128) m2 = (lightness * (255 + saturation)) / 65025.0; else m2 = (lightness + saturation - (lightness * saturation)/255.0) / 255.0; m1 = (lightness / 127.5) - m2; /* chromatic case */ *h = hls_value (m1, m2, hue + 85); *l = hls_value (m1, m2, hue); *s = hls_value (m1, m2, hue - 85); } } /************************************/ /* apply layer modes */ /************************************/ int apply_layer_mode (unsigned char *src1, unsigned char *src2, unsigned char **dest, int x, int y, int opacity, int length, int mode, int b1, /* bytes */ int b2, /* bytes */ int ha1, /* has alpha */ int ha2, /* has alpha */ int *mode_affect) { int combine; if (!ha1 && !ha2) combine = COMBINE_INTEN_INTEN; else if (!ha1 && ha2) combine = COMBINE_INTEN_INTEN_A; else if (ha1 && !ha2) combine = COMBINE_INTEN_A_INTEN; else combine = COMBINE_INTEN_A_INTEN_A; /* assumes we're applying src2 TO src1 */ switch (mode) { case NORMAL_MODE: *dest = src2; break; case DISSOLVE_MODE: /* Since dissolve requires an alpha channels... */ if (! ha2) add_alpha_pixels (src2, *dest, length, b2); dissolve_pixels (src2, *dest, x, y, opacity, length, b2, ((ha2) ? b2 : b2 + 1), ha2); combine = (ha1) ? COMBINE_INTEN_A_INTEN_A : COMBINE_INTEN_INTEN_A; break; case MULTIPLY_MODE: multiply_pixels (src1, src2, *dest, length, b1, b2, ha1, ha2); break; case DIVIDE_MODE: divide_pixels (src1, src2, *dest, length, b1, b2, ha1, ha2); break; case SCREEN_MODE: screen_pixels (src1, src2, *dest, length, b1, b2, ha1, ha2); break; case OVERLAY_MODE: overlay_pixels (src1, src2, *dest, length, b1, b2, ha1, ha2); break; case DIFFERENCE_MODE: difference_pixels (src1, src2, *dest, length, b1, b2, ha1, ha2); break; case ADDITION_MODE: add_pixels (src1, src2, *dest, length, b1, b2, ha1, ha2); break; case SUBTRACT_MODE: subtract_pixels (src1, src2, *dest, length, b1, b2, ha1, ha2); break; case DARKEN_ONLY_MODE: darken_pixels (src1, src2, *dest, length, b1, b2, ha1, ha2); break; case LIGHTEN_ONLY_MODE: lighten_pixels (src1, src2, *dest, length, b1, b2, ha1, ha2); break; case HUE_MODE: case SATURATION_MODE: case VALUE_MODE: /* only works on RGB color images */ if (b1 > 2) hsv_only_pixels (src1, src2, *dest, mode, length, b1, b2, ha1, ha2); else *dest = src2; break; case COLOR_MODE: /* only works on RGB color images */ if (b1 > 2) color_only_pixels (src1, src2, *dest, mode, length, b1, b2, ha1, ha2); else *dest = src2; break; case BEHIND_MODE: *dest = src2; if (ha1) combine = BEHIND_INTEN; else combine = NO_COMBINATION; break; case REPLACE_MODE: *dest = src2; combine = REPLACE_INTEN; break; case ERASE_MODE: *dest = src2; /* If both sources have alpha channels, call erase function. * Otherwise, just combine in the normal manner */ combine = (ha1 && ha2) ? ERASE_INTEN : combine; break; default : break; } /* Determine whether the alpha channel of the destination can be affected * by the specified mode--This keeps consistency with varying opacities */ *mode_affect = layer_modes[mode].affect_alpha; return combine; } int apply_indexed_layer_mode (unsigned char *src1, unsigned char *src2, unsigned char **dest, int mode, int ha1, /* has alpha */ int ha2) /* has alpha */ { int combine; if (!ha1 && !ha2) combine = COMBINE_INDEXED_INDEXED; else if (!ha1 && ha2) combine = COMBINE_INDEXED_INDEXED_A; else if (ha1 && ha2) combine = COMBINE_INDEXED_A_INDEXED_A; else combine = NO_COMBINATION; /* assumes we're applying src2 TO src1 */ switch (mode) { case REPLACE_MODE: *dest = src2; combine = REPLACE_INDEXED; break; case BEHIND_MODE: *dest = src2; if (ha1) combine = BEHIND_INDEXED; else combine = NO_COMBINATION; break; case ERASE_MODE: *dest = src2; /* If both sources have alpha channels, call erase function. * Otherwise, just combine in the normal manner */ combine = (ha1 && ha2) ? ERASE_INDEXED : combine; break; default: break; } return combine; } static void apply_layer_mode_replace (unsigned char *src1, unsigned char *src2, unsigned char *dest, unsigned char *mask, int x, int y, int opacity, int length, int b1, /* bytes */ int b2, /* bytes */ int *affect) { replace_pixels (src1, src2, dest, mask, length, opacity, affect, b1, b2); }